• Advertisement


  • Content count

  • Joined

  • Last visited

Community Reputation

321 Neutral

About NickW

  • Rank
  1. how do I create a small multiplayer game?

    Have you considered doing local multiplayer first to get the mechanics down?
  2. Just take each of the identity basis vectors (1, 0, 0), (0, 1, 0) and (0, 0, 1) and rotate them with the quaternion.  This will give you a new set of basis vectors that should correspond to the columns in a rotation matrix.
  3. Not sure if this is relevant or would answer your question at all, but there was a talk at GDC a few years ago about using dealing with SH ringing by using something called needlets   http://gdcvault.com/play/1015310/Frames-Sparsity-and-Global-Illumination
  4. You seem to be overthinking things.   It is possible to do OOP in C withtout using classes.  You have a struct contains all the data, and you have functions which operate on that struct.  There is a tight binding between the functions and the data even though they're separate elements in the code.  C++ classes are just shorthand for this.  Every time you call a C++ function, you're sending a pointer to a struct as the first parameter.  I'm assuming this is basically what you're doing when you call into lua - passing a block of data for the lua script to operate on.   Keep in mind the defining characteristic of a singleton is that it only operates on a single set of data, or in other words, there can only be one instance of the data.
  5. How to mipmap procedural shaders?

    What you want is actually anti-aliasing since what you're making is closer to rasterizing than texture mapping.  You can use any of the anti-aliasing techniques that people have been using for years, such as multisampling. You'll just have to implement them in your fragment shader, and depending on how it's written, could be very tricky.   Think of each pixel as a tiny little frustum instead of a ray.
  6. Just seemed counter-intuitive to me is all since I figured the convention would be to follow the trajectory of the photons as them came from the light source.
  7. The only weird thing about that paper is the fact that the light vector L is pointing toward the light source instead of away from it.  Otherwise, it pretty much makes sense.   In your example, the light is coming directly down the plane, but it's still perpendicular to the thread vector.  Think of each thread as a cylindrical mirror.  Since the threads themselves are infinitely small, the only reflected light you get from them is being reflected off the normal that is most aligned with the camera vector.  If you're looking straight on to one of the threads, the normal should be pointing directly back at you.
  8. Here's some things you can try   1. make the render targets smaller 2. use compressed render targets 3. re-use render targets have disposable data 4. pre-bake the graphics offline instead of at run-time
  9. voxel to mesh

    I saw a GDC talk that used marching cubes to generate geometry for signed distance fields, which is somewhat similar to your voxel problem.  However, the author didn't do any backface/frustum culling and it was done using compute shaders.  So you could definitely make it work on CPU, but it wouldn't scale as well as doing it on GPU.   Here are the slides if you're interested http://directtovideo.wordpress.com/2012/03/15/get-my-slides-from-gdc2012/
  10. Extreme Framerates

    Increasing bandwidth can lead to a decrease in latency due to the exact effect you're talking about.  Decreasing latency will almost always make your game feel better and more responsive no matter how it's done.  Another way you can go about is, for example, sampling the player input as closest to the end of the frame as possible, or just making sure that nothing in your game is causing input processing to get delayed.   Using a separate rendering thread doesn't usually decrease latency because the rendering thread usually has to run a frame behind.  You can't render and update the same frame at the same time, otherwise you end up with temporal inconsistencies between frames (i.e. jitter).  Rendering on a separate thread is mainly a performance benefit to take advantage of multiple cores.
  11. How and what do I do now?

    Sounds like you have a pretty good idea of what to do next.   Locking the camera to the player is just a matter of offsetting everything as you draw it by your camera position   camera_x = player_x - screenwidth / 2 camera_y = player_y - screenheight / 2   then whenever you draw, subtract out the camera position   Draw(x - camera_x, y - camera_y);
  12. Where next?

    Stick with it!  Find things that inspire you.  Get involved in game dev communities like ludum dare or one game a month. Talk to people.  If you're get stuck and are struggling with something specific, ask questions.  Never stop learning.   If you want to do some stuff with physics, trying playing around with jbox2d.   If you like procedural generation, check out this site: http://pcg.wikidot.com/
  13. Mirror bone in local space

    If both parent and child bone are mirrored, then the bone relative to its parent will be the same as the mirrored version.   If not, just use the inverse transform of the parent joint multiplied by the child joint position to get the local space transform.
  14. Bending of track in a racing game

    The surface normal vector of the track should be roughly opposite of whatever forces are acting on the player's car   f = mass * gravity + centripetal force surface normal =  -f / | f |   centripetal force = bspline 2nd derivative * speed of the player * mass   You'll probably need to do some smoothing so that the twists in the 2nd derivative don't make the track look chopped up.
  15. 1 source/header per window type is a good start, but you should really be thinking about how to organize the data so that everything that needs to read or change the data is able to do so appropriately.  After that, good project/file organization should reveal itself intuitively.   For example, I recently made a 2D map editor and I organized it like this:  Each panel/window gets it's own file, but there's a central data structure that all the panels/windows have access to which provides all the functions to manipulate the map.  The data structure itself is split up into multiple files logically based on the type of data being modified (for example there's one file for all the tile manipulation functions, another file for all the entity manipulation functions).
  • Advertisement