• 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.


  • Content count

  • Joined

  • Last visited

Community Reputation

5002 Excellent

About NightCreature83

  • Rank

Personal Information

  • Location
  • Interests

Recent Profile Visitors

24563 profile views
  1. C++

    Underscores are evil and should never be used in anything, camelCase for the win. That being said do what you like in your own projects and stick to your own conventions. When working in another project were you are collaborating with other people conform to the convention of that code base or agree on a common convention and stick to that. I have worked in a few code bases that use C and S for classes and structures in the naming but dont use this in the filenames and just use the logical name of the class. Personally I have the C, S I and other sort of Hungarian but not really prefixes, I much rather see sensible names for variables and classes so I can at a glance see what they are supposed to do, or at least give me a clear idea of what they should do. Making code readable and understandable is far more important than sticking to a particular way of casing or pre/post-fixing names or Hungarian coding. Besides a good IDE will actually show you what type something is when you hover over it when you need to know it.
  2. I have used D3D11 for a while now I still use these tools to figure out what goes wrong if something isnt showing up as I expect them to show up. Using tools only makes it easier to find the location where your problem is and thus much easier to solve your issue.
  3. You could try using CodeXL to see if your OpenGL commands are actually handles by the gpu. This should also show you the GPU state and such so that you can see what is actually wrong. Renderdoc is another tool for this but the openGL support for that is not optimal had it been d3d or vullkan you could have used that tool which is really good at debugging graphics and is used in the industry by AAA game companies.
  4. There are also free tools out there written by gamedevs like https://mtuner.net/
  5. I would spawn a SpawnBullet/SpawnResource message and have whatever needs to deal with that message pick it up. This way you can stick the control handling in player or player input handling but not have the responsibility of creating a bullet inside the player. Also this message should carry all needed information to spawn that resource in the world.
  6. If you are in a bad situation job wise and its not you but the fit is just so off that stay will do more harm to you personally than going, my advice is leave. I have been in that situation and stuck around worst option ever, my last year at the job was hell to be honest (bad fit, reason I was on the project was kicked off the project all kinds of things that just killed my motivation to go to work), the only option in that case is leave. Verbally accepting an offer is not the same as actually signing the contract you can back out of these things, its not great to do this but you haven't signed anything yet so there is no real legal obligation yet. Also never ever accept an offer if anything feels off, even if its the littlest thing you (the reason why my last job was such a bad fit). The hardest thing to learn when entering the games industry I found is that it's a job at the end of the day. What this means is that you have to make sure for yourself that the job you accept fits with you, you are more important than the company when it gets down to the line for yourself.   In the first year on my first game(DiRT2) I learnt more about writing software and implementing things than I ever did on my own to be honest so keep that in mind too, as mentioned in previous messages
  7. I used pygments to do some parsing with, its fairly straight forward and will tell you what token each word in a script is. Pygments supports a lot of languages, I for example used it to figure out what the arguments and names of public function were in a actionscript 3 class. This took me about 3 hours to write most of that time was not spent on integrating pygments to the script. Pygments is mostly used for langauges highlighters in text editors, it allows you to define the grammar it matches the string against too. You might want to look at abstract syntaxes to understand the meaning of the concepts mentioned in parsing.
  8. IMHO Deferred shading solves this problem.   You can go much further with tiled deferred and forward+ and clustered forward or deferred shading, these techniques allow 1000s of lights in a scene whilst maintaining shading performance. These techniques create light lists that only shade the geometry that is in the view frustum subdivision the light affects. http://www.humus.name/Articles/PracticalClusteredShading.pdf The choice for forward or deferred matters more on the scenes you are making and whats in it than on how many lights you can have with the above techniques. If you have lots of transparent surfaces that are affected by light forward shading is much simpler to use.
  9. In your particular case however your access in that loop is not cache friendly because the arrays are stored after each other if declared and created at the same time. Had you looped over all x's then y's and then z's you would have had a cache friendly access. The trick is to layout your data in such a way that when you need to access that data you access all/most of it in the same loop.   Herb has done a talk about the benefit of looping in order through your data and has some slides that show what happens an why. ( https://channel9.msdn.com/Events/Build/2014/2-661 there is more in this talk than just that.) https://view.officeapps.live.com/op/view.aspx?src=http%3a%2f%2fvideo.ch9.ms%2fsessions%2fbuild%2f2014%2f2-661.pptx   Ps: on most PC hardware the cache line size is 64-bytes.
  10. Unity

    Seeing Xamarin is now a part of visual studio (https://www.xamarin.com/compare-visual-studio) why not use Visual Studio Community edition to begin with.
  11. The difference between the two operations is that post will return the previous value of the variable you increment when assigning to a variable. In the case of user types, like iterators, this can come with a copy cost and as such the rule started to exist that you should prefer per-increment for a loop variable. When user types are involved the compiler cannot see the optimisations anymore that it can do for POD types, most likely a ++i and i++ will both result in to a inc eax assembly instruction in the case of a for loop. But when its implemented as an overloaded operator the compiler has to insert that code there. As a simple example this code with a release compile on VS2015: int i = 0; int y = ++i; int x = i++; //can be a fair amount of code in between here std::cout << i << x << y; Will generate this assembly: 00007FF6718C9C43  mov         edx,2   00007FF6718C9C48  mov         rcx,qword ptr [__imp_std::cout (07FF6718CD1C0h)]   00007FF6718C9C4F  call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF6718CD198h)]  00007FF6718C9C55  mov         rcx,rax   00007FF6718C9C58  mov         edx,1   00007FF6718C9C5D  call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF6718CD198h)]   00007FF6718C9C63  mov         rcx,rax   00007FF6718C9C66  mov         edx,1   00007FF6718C9C6B  call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF6718CD198h)] Which shows that for integers the compiler can compile the increment away completely. When you wrap that code in a for loop you get a sub asm call followed by a jne on the counter value to jump back to the beginning of the loop.
  12. It sounds to me that you are deriving from a base class, why not cast to that instead of the void*. Added benefit is that you can just call the handle function on these classes, assuming its part of the interface.   class EventHandler { public:     void HandleEvent() = 0; };   template<class T> class EventHandlerT : public EventHandler { };   THis would work fine and you can now store pointers to EventHandler instead of void* in a container. std::function and std::bind are options you should avoid in favour of lambdas if you can, lambdas are more efficient.
  13.   As I said, the original idea was to enforce a certain semantic for a certain type. IE:   - int, float, bool are passed as value - std::string, std::vector<>, user-defined structs are passed via const reference - user-defined objects are passed via pointer   so the idea was, that if I called such a function, it would enforce the correct semantic automatically in the function signature: int x = 1; dummyFunction(x); // works dummyFunction(&x); // doesn't compile, int is only passed by value Object* pObject = new Object(); dummyFunction(pObject); // works dummyFunction(*pObject); // doesn't compile, objects are only passed by pointer So if I just put auto&&, it would take whatever I pass to it (like int***** as an extreme case), and I didn't want that. Apparently this isn't possible with the type-trait template that I made. So what I'm now going to do is akin to this: template<typename Type> void function(Type type) { // clearType-trait removes const, reference, pointer static_assert(std::is_same<Type, typename semantic<typename clearType<Type>::type>::type>::value, "Type is passed with an invalid signature."); } This should make sure that the signature fits the expected value for the underlying type, and since all calls of those type eventually come down to my variant-class, I can just put it there and be fine with it, I assume.   Auto&& allowes that its a universal reference so it even maintains const correctness and accepts both pointer, reference and pass by value semantics.
  14. Why not stick an "auto&&" in your function instead of the specific type, if you use a modern (C++14 compiler) that would work, and would also be easier to read.
  15. This happens in AAA games too, if you dont make a plan at the beginning you will never get your time schedule in order. The worst thing to happen in a game is start the production phase without having a design in AAA because you are running behind already things cant move forward without a design.