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

DonDickieD

Members
  • Content count

    989
  • Joined

  • Last visited

Community Reputation

2751 Excellent

About DonDickieD

  • Rank
    Advanced Member

Personal Information

  • Location
    United States
  1. C++

    This is a long shot, but one thing I noticed with XNAMath/DirectXMath is that the quaternion multiplication is reversed. Say you two rotations q1 and q2. In usual quaternion notation q = q2 * q1 would apply q1 first followed by q2. If you are using XNAMath they changed that order to match the matrix multiplication So q = q1 * q2 is how you need to concatenate. E.g. see here for an explanation: https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.quaternion.xmquaternionmultiply(v=vs.85).aspx So if you use the operator overload you might be in trouble. I am sure you know this already. Still I point this out since I have seen this issue before. IIRC the Maya SDK does similar things. Personally I hate this, but I can see what they are trying to do.
  2. C++

    Hi, I post my code here which should be relatively simple and have another look later if you want. Basically I collect all skeleton nodes (bones) and then I read the animation from these nodes. The animation is stored as an array of poses (as opposed to an array of tracks). Another good reference is the Ozz Animation Library. In particular if you need to transform the coordinate system or units. The FBX library can mess things up since it only applies some transformation in the root.
  3. FBX doesn't support collision shapes out of the box. One common approach would be to flag collision primitives using a special mesh name. E.g. a collision sphere starts with CLSP_*, a capsule CLCA, etc. Unreal uses something like this and you can read about it here: https://docs.unrealengine.com/latest/INT/Engine/Content/FBX/index.html Alternatively you can write a small import dialog and the user needs to select whether a mesh is a collision mesh or render mesh or both. You basically assign the content of the model FBX file into different sets like render mesh, collision mesh, animation, etc. I think you can also write your custom FBX node attribute types, but I haven't done this so I cannot really comment on this. It is very easy to write some custom node types in Maya and export this e.g. into a simple JSON file. You would then reference the associated nodes/bones by name and save the physics/collision file along with the model. You can even have a dedicated model JSON which references the model FBX and animation FBX and also custom data like hitboxes, physics, etc. This can then be compiled into a more optimal runtime format if needed. To answer your last question I usually compute the best fit OBB and then fit a capsule or sphere into this. This is very easy. There are many approaches to compute the best fit OBB, but for tool side computations a simple brute force approach usually works very well in practice. HTH, -Dirk
  4. When you do the overlap tests you need to check if you already created a contact for that pair. A hashtable is a good choice for this. Usually the arbiters also store a list of contacts (contact graph) so you can also search that list. You can search either arbiter since the contact would be referenced on both arbiters. Make sure to search the shorter list since e.g. the world arbiter can have potentially a large number of contacts. The other issue is how to detect when a pair is *not* overlapping anymore. The solution to this problem depends quite a bit on your acceleration structure in your broadphase. E.g. SAP has a natural begin and end overlap event where you can handle the pair management. A dynamic tree doesn't have these events and things become a bit more tricky. So my broadphase only *adds* pairs. Then when I iterate the current contacts to send them to the solver a contact needs to be confirmed (a quick AABB overlap test for the involved shapes). If a contact is not confirmed it is skipped and removed from the list. HTH, -Dirk
  5. All true, but I am surprised how someone with these traits would not know about affine transformations when applying for a role as game developer. I did practice with people from DigiPen at the whiteboard here at the office and also did go for many lunches to answer their questions. One of the guys just landed a senior position at Amazon essentially after a couple of months out of college. This is what I compare this junior candidate against and this is a guy with dedication and good social skills. There is competition there and there are excellent people out there at all kind of levels. The point I want to make is not to only see this from the perspective of a candidate, but also from the position of the interviewer. As the interviewer you need to get the best person out of the pool of people applying for the role.
  6. I never heard of any legal issues, but I do ask if the candidate wants feedback before I provide it. In my personal opinion this is only fair and the least you can do. I strongly believe that mistakes and failure are a good thing if we can learn and grow from them!
  7. I think the question whether this is fair or not is misleading. If you are interviewing a candidate the job is to hire the best person for the position you can find. A candidate which cannot answer a simple question about affine transformation is definitely not the strongest candidate. I run into the same issue with white board coding interviews all the time. People claim it is unfair and doesn't bring out their strengths. I agree with all of this, but in my opinion a false positive is more expansive for a company than a false negative and as I know for sure that there are people exceeding at white board interviews and I am pretty sure that there are junior candidates that will be able to answer simple questions about affine transformation. These are the people you are looking for and the job of the interviewer is to find the best candidate. Personal drama has no room here. So, in my opinion this was the right decision as there a potentially better candidates which are a better fit for that role and it is very legit to aim for this. Also, failing in an interview is not the end of the world. It happened to me as well! The important thing for the candidate is that he receives feedback and can take something out of the interview. So the next time he is asked about affine transformation he will be able to give good answers.
  8. I also found Intel's Threading Building Blocks library very useful. It has nice parallel_for and other useful concepts which are very handy quite often. https://www.threadingbuildingblocks.org/
  9. This looks a bit like Wahba's problem: https://en.wikipedia.org/wiki/Wahba%27s_problem   And you can e.g. use Davenport's method to solve it. https://math.stackexchange.com/questions/1634113/davenports-q-method-finding-an-orientation-matching-a-set-of-point-samples
  10. Kylotan, I think this is a good summary. I recently took a step back and in my opinion this all comes down to the problem of reusable software. From my experience smaller systems are easier to reuse than larger ones. Working in a large codebase on a daily basis I also found that it is usually very easy to work on the low end system (e.g. a material system, collision, or physics) and all the way on the other end when implementing some behavior for some entity. The real complexity is in the glue part in the middle that brings both of these ends together and this is usually what is called the engine. In order to make the engine reusable we now come up with meaningless abstractions like entity, component and system. We choose a component decomposition without any context and end up with a small granularity to potentially meet them all. I am wondering if it all boils down to ditching engines all together and write games instead. For reusability we now have nice game specific modules (e.g. material and rendering, collision and physics and pathfinding, etc) and potentially discover more along the way. On the downside for new projects you will need programmers to setup a minimal tool framework for artists to start. If you only have content people that will definitely not work.  
  11. In Source we use something similar to what you describe. An entity can register thinker functions. They actually are only called once. So if you want another call you need to re-register. The other nice feature is that you can pass a time stamp. So instead of being called per frame, you can be called maybe every 5 ms (which might be an appropriate interval to update your sepcific entity). I really like that approach. https://developer.valvesoftware.com/wiki/Dota_2_Workshop_Tools/Scripting/ThinkerFunctions
  12. I use this: https://blog.molecular-matters.com/2011/09/19/generic-type-safe-delegates-and-events-in-c/ There is a more extensive coverage in the latest Game Engine Gems.
  13. I think I would first show that the naive approach fails (e.g. either sphere or box under shear transform). The reason it doesn't work is that you are essentially transforming a vector which is a non-linear function of the underlying mesh surface. E.g. n = f( v1, v2, ...) and obviously R * n = R * f( v1, v2, ...) !=  f( R * v1, R * v2, ... ) The discussion if normals are vectors is not useful in this context. Eric gave a presentation about Grassman algebra here: http://www.terathon.com/gdc12_lengyel.pdf which covers this problem properly.
  14. Not exactly your question, but pretty much in context I hope. This is a very nice book on general problem solving. It seems to be a classic here in the US while not so popular in Europe. Very cheap so you might want to give it a look: https://www.amazon.com/How-Solve-Mathematical-Princeton-Science/dp/069116407X/ref=sr_1_1?ie=UTF8&qid=1489273247&sr=8-1&keywords=how+to+solve+it
  15. You need to define "FBXSDK_SHARED"  if you are using the DLLs.