• Announcements

    • khawk

      Download the Game Design and Indie Game Marketing Freebook   07/19/17

      GameDev.net and CRC Press have teamed up to bring a free ebook of content curated from top titles published by CRC Press. The freebook, Practices of Game Design & Indie Game Marketing, includes chapters from The Art of Game Design: A Book of Lenses, A Practical Guide to Indie Game Marketing, and An Architectural Approach to Level Design. The GameDev.net FreeBook is relevant to game designers, developers, and those interested in learning more about the challenges in game development. We know game development can be a tough discipline and business, so we picked several chapters from CRC Press titles that we thought would be of interest to you, the GameDev.net audience, in your journey to design, develop, and market your next game. The free ebook is available through CRC Press by clicking here. The Curated Books The Art of Game Design: A Book of Lenses, Second Edition, by Jesse Schell Presents 100+ sets of questions, or different lenses, for viewing a game’s design, encompassing diverse fields such as psychology, architecture, music, film, software engineering, theme park design, mathematics, anthropology, and more. Written by one of the world's top game designers, this book describes the deepest and most fundamental principles of game design, demonstrating how tactics used in board, card, and athletic games also work in video games. It provides practical instruction on creating world-class games that will be played again and again. View it here. A Practical Guide to Indie Game Marketing, by Joel Dreskin Marketing is an essential but too frequently overlooked or minimized component of the release plan for indie games. A Practical Guide to Indie Game Marketing provides you with the tools needed to build visibility and sell your indie games. With special focus on those developers with small budgets and limited staff and resources, this book is packed with tangible recommendations and techniques that you can put to use immediately. As a seasoned professional of the indie game arena, author Joel Dreskin gives you insight into practical, real-world experiences of marketing numerous successful games and also provides stories of the failures. View it here. An Architectural Approach to Level Design This is one of the first books to integrate architectural and spatial design theory with the field of level design. The book presents architectural techniques and theories for level designers to use in their own work. It connects architecture and level design in different ways that address the practical elements of how designers construct space and the experiential elements of how and why humans interact with this space. Throughout the text, readers learn skills for spatial layout, evoking emotion through gamespaces, and creating better levels through architectural theory. View it here. Learn more and download the ebook by clicking here. Did you know? GameDev.net and CRC Press also recently teamed up to bring GDNet+ Members up to a 20% discount on all CRC Press books. Learn more about this and other benefits here.

BFG

Members
  • Content count

    55
  • Joined

  • Last visited

Community Reputation

1301 Excellent

About BFG

  • Rank
    Member
  1. zlib (specifically contrib/minizip) can create zip files. Use a zero compression level if you really want the files in the zip file to be uncompressed. PAK files are usually just zip files.
  2. I remember facing this problem. If I recall correctly it boils down to finding the inverse of a function of the form f(x) = a*x + b*cos(c*x) for which I believe there is no analytic solution. If you find one though let me know! Without an analytic solution you have a couple of options. Probably the best option is to formulate some approximation. A simple option though is to just displace a mesh on the CPU around where you need to sample heights and use that (e.g., if you need the heights for a boat, create a "collision mesh" around the boat extending beyond the boat boundary by the maximum horizontal wave displacement).
  3. Looks like a gamma problem, e.g., your algorithm expects linear pixel data and you are using non-linear sRGB pixel data.
  4. cell.x = layeroffset % numcells.x; In HLSL the modulus operator gives different results for floats and integers.  Try casting numcells.x in the above line to a uint. See: https://msdn.microsoft.com/en-us/library/windows/desktop/bb509631(v=vs.85).aspx#Additive_and_Multiplicative_Operators
  5. You might have better luck using the VS solutions in the curl-XXX/projects/Windows/ directory and compiling for the static LIB configurations.  The last time I did this was a few years ago so maybe things have changed.  Anyway I compiled with Windows Secure Channel for SSL (see https://curl.haxx.se/docs/ssl-compared.html) and add the following to Preprocessor Definitions: USE_SCHANNEL USE_WINDOWS_SSPI HTTP_ONLY   This worked and added only 100K or so to the executable size.  Using OpenSSL also worked but add a megabyte.   Good luck!   
  6.   That's certainly a bug but I wouldn't say it's the main problem.  It wouldn't cause the discontinuities OP was getting.   Check out what happens when you do (1) floorf, (2) the "improved" second FAST_FLOOR macro above, and (3) the "original" first FAST_FLOOR macro above on the following arguments respectively: #define FAST_FLOOR_ORIGINAL(x) ((x>0) ? (int)x : ((int)x-1)) #define FAST_FLOOR_IMPROVED(x) (((x)>0) ? ((int)(x)) : (((int)(x))-1)) // but still incorrect for floating point values that are exactly nonpositive integers for (float x = -1.5f; x < 2.f; x += 0.1f) { const int a = floorf(x + 1.2f); const int b = FAST_FLOOR_IMPROVED(x + 1.2f); const int c = FAST_FLOOR_ORIGINAL(x + 1.2f); fprintf(fp, "(%f + 1.2f): %d %d %d\n", x, a, b, c); } (-1.500000 + 1.2f):  -1 -1 0 (-1.400000 + 1.2f):  -1 -1 0 (-1.300000 + 1.2f):  -1 -1 0 (-1.200000 + 1.2f):  0 0 0 (-1.100000 + 1.2f):  0 0 0 (-1.000000 + 1.2f):  0 0 1 (-0.900000 + 1.2f):  0 0 1 (-0.800000 + 1.2f):  0 0 1 (-0.700000 + 1.2f):  0 0 1 (-0.600000 + 1.2f):  0 0 1 (-0.500000 + 1.2f):  0 0 1 (-0.400000 + 1.2f):  0 0 1 (-0.300000 + 1.2f):  0 0 1 (-0.200000 + 1.2f):  1 1 1 (-0.100000 + 1.2f):  1 1 1 (0.000000 + 1.2f):  1 1 1 (0.100000 + 1.2f):  1 1 1 (0.200000 + 1.2f):  1 1 1 (0.300000 + 1.2f):  1 1 1 (0.400000 + 1.2f):  1 1 1 (0.500000 + 1.2f):  1 1 1 (0.600000 + 1.2f):  1 1 1 (0.700000 + 1.2f):  1 1 1 (0.800000 + 1.2f):  2 2 1 (0.900000 + 1.2f):  2 2 1 (1.000000 + 1.2f):  2 2 2 (1.100000 + 1.2f):  2 2 2 (1.200000 + 1.2f):  2 2 2 (1.300000 + 1.2f):  2 2 2 (1.400000 + 1.2f):  2 2 2 (1.500000 + 1.2f):  2 2 2 (1.600000 + 1.2f):  2 2 2 (1.700000 + 1.2f):  2 2 2 (1.800000 + 1.2f):  3 3 2 (1.900000 + 1.2f):  3 3 2  
  7. If your macro looks like this... #define FAST_FLOOR(x) ((x>0) ? (int)x : ((int)x-1)) ...then trying changing it to: #define FAST_FLOOR(x) (((x)>0) ? ((int)(x)) : (((int)(x))-1))
  8. I did it.  It's not hard but can take a lot more time than you might think. Consider all the changes and how they might impact your project: https://msdn.microsoft.com/en-us/library/windows/desktop/bb205073(v=vs.85).aspx.  I would never do it near the end of a project...because then I would no longer be near the end of the project.
  9. You will probably create more problems than you solve by making a heightmap be an actor.  It's likely to be a special case in every scenario (collision, rendering, etc.).
  10. Note that "nointerpolation" uses the value from the first vertex of a primitive.  If that doesn't work for you, then the "normal" approach is to duplicate vertices.
  11. Sounds like you're mapping straight to noise.  Noise by itself is boring and repetitive especially at low frequencies.  The trick is to build a sufficiently complex (and interesting) function using various transformations and combinations of noise, e.g., http://http.developer.nvidia.com/GPUGems3/gpugems3_ch01.html.
  12. You can "seed" Perlin/Simplex noise by shuffling the permutation table using a PRNG with a given seed.  It's immutable after that.  For speed look at SIMD implementations.    Not sure I understood your input requirements.  Sounds like the appropriate hash of your input would do what you want.
  13.   [attachment=33705:ocean.png]
  14. From the album Random

  15.   You have simple.  Moving to XML buys you what exactly?  Bloated and less readable data files?  Slower parsing?  Dependencies on third party XML parsers?