Jump to content
  • Advertisement

Maik Xhani

Member
  • Content Count

    6
  • Joined

  • Last visited

Community Reputation

127 Neutral

About Maik Xhani

  • Rank
    Newbie
  1. I also tried this: i put a glFinish() at the end so that all the commands in the queue would be executed at that point. This is what shows up in the debugger   1 void glFinish() 0x00010000 1772914 0 2 void glClear(GLbitfield mask = GL_DEPTH_BUFFER_BIT) 0x00010000 7749507 0   glClear is taking 7 ms of CPU time?   If i run other stuff before it it takes even 12ms. Also I have 2 more glClear and they both take this long. Is this normal?
  2. sorry, that was my typo, I had an extra query before. Still the results are the same I posted
  3. Actually I turned off vsync so that I get the actual FPS. So these are the actual results (voxelization is the expensive shader)   voxelization alone: 94 FPS   normal+depth and color pass alone: 240 FPS (I could improve this by using a g-buffer instead of 2 textures)   shadowmap alone: 135 FPS   normal+depth+color & shadowmap: 160 FPS (those 2 passes use the same shader)   second pass + shadowmap + voxelisation (in this order) : 67 FPS   The weird thing is that if I run the shadowmap pass alone it's slower than if i run it after th other pass, so it means that I am probabily wasting something.  I will go on and try to optimize the voxelisation part. It's the cyril crassin method of rendering everything while using the geometry shader to project to the dominant axis and use the fragment shader to write to a 3d texture. Right now I am writing to the 3d Tex by using imageStore even though that doesn't seem the bottleneck of the shader.   If I use gl_ext_timer_query i get those results   normal+depth & color : 10,336,416 ns shadowmap: 5,412,064 ns voxelise: 55,344,416 ns which should run at 14 fps...   all I did was glBeginQuery(GL_TIME_ELAPSED_EXT, queries[0]); firstPass(); glEndQuery(GL_TIME_ELAPSED_EXT); glBeginQuery(GL_TIME_ELAPSED_EXT, queries[1]); ShadowMapPass(); glEndQuery(GL_TIME_ELAPSED_EXT); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glBeginQuery(GL_TIME_ELAPSED_EXT, queries[2]); Voxelize(false); glEndQuery(GL_TIME_ELAPSED_EXT); while (!available) { glGetQueryObjectiv(queries[4 - 1], GL_QUERY_RESULT_AVAILABLE, &available); } for (int i = 0; i < 3; i++) { // See how much time the rendering of object i took in nanoseconds. glGetQueryObjectui64vEXT(queries[i], GL_QUERY_RESULT, &timeElapsed); } I assure that the fps count above is correct because it is the same one that is displayed by NSight
  4. So I started doing some debugging with Nsight and I took a look at the events. This is what I saw:   I have numerous calls like this  void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 15) 0x00010000 1539 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 1188, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 000354FC, GLint basevertex = 38051) 0x00010000 21038 22504 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003678C, GLint basevertex = 38847) 0x00010000 17446 15872 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 000373D4, GLint basevertex = 39373) 0x00010000 16933 15292 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003801C, GLint basevertex = 39899) 0x00010000 21552 14868 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 00038C64, GLint basevertex = 40425) 0x00010000 17960 14080 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 1188, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 000398AC, GLint basevertex = 40951) 0x00010000 16933 21740 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 1188, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003AB3C, GLint basevertex = 41747) 0x00010000 16420 21856 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003BDCC, GLint basevertex = 42543) 0x00010000 16933 15432 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003CA14, GLint basevertex = 43069) 0x00010000 16933 15448 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003D65C, GLint basevertex = 43595) 0x00010000 16420 14704 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 786, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003E2A4, GLint basevertex = 44121) 0x00010000 16933 13788 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 1188, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0003EEEC, GLint basevertex = 44647) 0x00010000 16420 21668 and I guess I could turn those draw calls into a single call. I then noticed this other thing: void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 10) 0x00010000 1539 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 612, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0004017C, GLint basevertex = 45443) 0x00010000 21038 30748 void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 12) 0x00010000 1026 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 612, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 00040B0C, GLint basevertex = 45959) 0x00010000 20525 28388 void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 10) 0x00010000 1026 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 444, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0004149C, GLint basevertex = 46475) 0x00010000 20525 55416 void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 11) 0x00010000 1026 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 480, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 00041B8C, GLint basevertex = 46797) 0x00010000 20525 13716 void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 12) 0x00010000 1026 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 336, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0004230C, GLint basevertex = 47117) 0x00010000 20525 10060 void glBindTexture(GLenum target = GL_TEXTURE_2D, GLuint texture = 11) 0x00010000 1026 0 void glDrawElementsBaseVertex(GLenum mode = GL_TRIANGLES, GLsizei count = 480, GLenum type = GL_UNSIGNED_INT, GLvoid* indices = 0004284C, GLint basevertex = 47349) 0x00010000 20525 11676 Now in this one as you can notice I keep binding to the same 3 textures back and forth. Would it make sense to sort my elements based on texture object when I load the model, so that I can bind one texture and make all the draw calls and then go to the next?
  5. I have Nsights installed in VS 13, would it work as a profiler for glsl? Btw the big shader is fine cause everything runs fast when i run it alone. The other one is slowing things down, Also, I have 5 FBOs with a total of 6 targets, maybe this is one of the things that is slowing down everything
  6. Hello everybody I am working on an application that needs to render the scene from multiple points of view. I notice that if I render once, even if the frag shader is long and complicated (writing to multiple 3D textures) it runs at 65 FPS. As soon as I add another rendering pass before that (simply rendering to 2 targets, colour and normals+depth) the framerate drops to 40. If I add a shadowmap pass it drops even further to 25-30 FPS. What is the best way to cope with multiple renderings and still retain a high framerate?   This is what I have right now: 1 - a shader that computes the normal+depth and colors, 2 targets on the same FBO 2 - the same shader gets called again for the shadowmap (different uniform parameters) but renders to a different FBO target 3 - a shader that writes values on a 3D texture using imageStore, new FBO 4 - a last shader that performs ray marching through the 3D texture and, at the same time, reads from the 2 maps created before if i just run step 3 and 4 i get 65 FPS, if i add the 2 steps above the performance drops and the only explanation I have is that I am doing something useless in the middle cause the shaders in 3 and 4 are way more complicated (1000+ lines) Thank you 
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net 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!