Advertisement Jump to content
  • Advertisement


  • Content Count

  • Joined

  • Last visited

Community Reputation

601 Good

About johnchapman

  • Rank

Personal Information

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1.   He's written his name into history with that silly voice!
  2.   Ah, thanks for clearing that up. I was thinking that you were skipping the sort in this case.
  3. This is interesting, although I'm a little confused about how the scheme outlined by L Spiro works, specifically:   Is it not possible that the total could be the same between two frames, but that items in the render queue (after culling) are different? In this case the indices won't necessarily point to the same items as in the previous frame, and the queue would need to be re-sorted.
  4. Here's a tech demo I "completed" (i.e. stopped working on) a couple of years back, which has a couple of nice features although it's quite dated now:     Same software, with a more organic-looking scene:    
  5.   Writing your own wrapper can be quite a good way to explore the API, but be warned that it's easy to get bogged down trying to 'redesign' OpenGL. Personally I just use some simple object-oriented wrappers that handle things like creating textures/framebuffers/shaders, plus some logging/debugging stuff.
  6. johnchapman

    Do you extend GLSL?

    Like Promit, I have a somewhat hacky preprocessor which manages #includes but not much else. For experimental and small scale projects you don't really need anything more. A serious renderer would probably require a more complete system for things like generating shader permutations. External #defines are a good mechanism for that sort of thing. 
  7. There's an adaptive supersampling approach outlined here which may also be of interest.
  8. #pragma optimize isn't in the spec, so probably isn't supported on your implementation.   I think the best solution will be to make your application code more robust, e.g. check to see if glGetAttribLocation() returns -1 to avoid enabling attributes that have been optimized out, etc.
  9. There are a number of different approaches to motion blur and a number of variables that can be tweaked which will change the overall 'look'; for smoother camera motion you can use a simple camera-only motion blur post process and adjust the blur kernel size to balance smooth motion against a blurry image (tutorial here). I find that at around 60Hz the effect isn't noticeable beyond making the camera motion look more fluid. Depending on the implementation it's really not very computationally expensive.
  10. johnchapman

    Deferred shading - light accumulation issue

    Typically when accumulating lights you'll need to enable blending, so that the result of the fragment shader gets combined with what's already in the buffer (i.e. the result from previous lights): glClear(GL_COLOR_BUFFER_BIT); // clear light accumulation buffer to black here glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); // additive blending // render lights glDisable(GL_BLEND);
  11. johnchapman

    [D3D11]Raindrop effect

    I seem to recall reading about this in one of the GPU Pro series, using sun shadows to determine where raindrops can/can't fall. It's a nice idea! Could also be used to apply 'wetting' to the scene in screen space.
  12. johnchapman

    SSAO artifacts

    It looks to me as though your sample kernel's radius is quite small, such that it's causing some erroneous occlusion on the floor where the triangles intersect. Try increasing the sample kernel radius to see if that alleviates the problem.
  13. There's a short overview here:
  14. johnchapman

    Assembly Programming

    If you're aiming at OS dev, here's a pretty good resource: This tutorial in particular: http://www.osdever.n...opment-tutorial There's a free book, "Art of Assembly Language Programming". I've never really looked at it but it seems quite comprehensive: There are Intel system programmer manuals and things like that on the Intel website which is a good source once you get going with the x86.
  15. There should be a difference if you've implemented it correctly. Remember to renormalize the incoming interpolated normals in the fragment shader.
  • Advertisement

Important Information

By using, you agree to our community Guidelines, Terms of Use, and Privacy Policy. is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!