Jump to content
  • Advertisement


  • Content Count

  • Joined

  • Last visited

Community Reputation

266 Neutral

About MAnd

  • Rank

Personal Information

  • Interests
  1. MAnd

    OpenGL API Overhead

    This is the second pretty promising article this author publishes here in a row. Nice. However, it's also the second time that he publishes it focusing in profiling comparisons but... without showing the code used for profilling. I really do think that the author - actually all authors, of all articles here and elsewhere - should be required to show how the performance measurement used. Without that, performance comparison are just words in the wind.
  2. MAnd

    Frustum Culling

    This is a great post in many aspects. First, it's rare to find real discussions on the implementation of VF algorithms that use both SSE and multi-threading. Second, it's even harder to find code samples of those things. Although I didn't check the code, I am sure that it might be pretty usefull for people who never tried such techniques. It is a very generous offer by the author and if code is good it will be a gold mine for beginners. Third, I always appreciate when authors take the time to actually compare algorithms. It is of little no value to come here and advocate for an algorithm without performance analyses. This article does not commit such sin.   On the nitpicking side, I think the article misses details about how the performance was measured. Every article that makes performance comparisons should give details about that part since they can completely alter everything. Additionally, I would say that the text is often too rushed. Many parts will leave interested readers at a loss. In particular, rushing over details about SSE, threading and GPU is dangerous. Also, the text really needs to be reviewed. I am not talking about the written English, but about things like: it does not make sense to include "Not all algorithms could be easily rewrited in SSE" in the list of SSE drawbacks that make SSE less performant. Those kind of minor things are all over the article.   However, don't get me wrong. The article is very welcome and pretty useful. Again, I am very happy to see someone actually share actual implementation of actual multi-threaded+SSE VF code. Not to mention a GPU implementation. I would only stress to whoever read this, that the author chose (understandably, given the purposes of this article) to not deal with spatial partitioning. But in my experience, in many cases even a basic implementation of an Octree or KD-tree outperform even SSE+multithreaded non-spatialized solutions (although I never compared against GPU non-spatialized solutions, but if the performance metrics here are correct, these would be outperformed as well). Of course, it dependes heavily on the chracteristics of each game or engine. But anyone needing high performance should also try at least an Octree and then decide in case by case basis.   Anyways, thanks for the article!
  • 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!