• Advertisement


  • Content count

  • Joined

  • Last visited

Community Reputation

379 Neutral

About ferreiradaselva

  • Rank

Personal Information

  • Interests


  • Twitter
  • Github

Recent Profile Visitors

2654 profile views
  1. uastar - Simple A* path finder in C

    There are a bunch of path finding implementations online. But, to be honest, I wasn't much satisfied with most of them, for one of these reasons: Dynamic memory allocation in the middle of the algorithm Algorithm that does too much (more than what is needed) Too many files for just a single task So I made this two-files (`uastar.c` and `uastar.h`) library: https://github.com/ferreiradaselva/uastar No memory dynamic allocation. Straight to the point (the README.md explains how to use). It's nothing biggie, but certainly useful. Path finder at work: I'm leaving this in announcements, because I probably won't add more features (it's pretty much done).
  2. OpenGL My first experience in starting OpenGL

    You don't have an excess of code, the issue is that your your code isn't fragmented in systems (yet). As a learner, what you are doing (writing everything in a single function) is OK, that way you learn what does what in OpenGL. When you want to use what you learned to build a framework/engine, then you need to separate things into systems/modules. Then you won't have to repeat that kind of code everywhere.
  3. We are moving out of LibGDX. What should be our next engine?

    I would say MonoGame, too, as it's "close" (note the quotation marks). I'm not even a C# programmer, but I've taken a look into the code of MonoGame, since I'm working on my own engine, and I liked it.
  4. MathC - a C math library for 2D and 3D programming

    I started using semantic versioning (currently version 0.2.0) and the library almost suffice any needs for 2D and 3D programming. These are some examples that are in my other project (CGDFW): Switching from projection and orthographic matrices for 3D | Using rotation matrices Using orthographic matrices and rotation matrices for 2D Using bezier functions
  5. Discord Launches Rich Presence

    WAIT WAIT WAIT WAIT https://discordapp.com/developers/docs/rich-presence/how-to Search for "match." There are callbacks that configure party size and id, and callbacks to join. DOES IT MEAN IT HAS MATCH MAKING? FREE? There's a video, it seems you can join in Discord itself:
  6. Reinventing the wheel

    Hecking great response. Put in words what I never could I agree with this. In my post, I was more towards to the developer that works for themselves (or the hobbyist). I would never ever, reinvent the wheel if I was working for someone else, unless specified. First, the project manager certainly have a plan and your wheel reinvention isn't in it. Second, it's not your project. Reinventing the wheel is something original, and you would be giving away something original to someone else with no reason. Unless your reason is to show yourself for the boss and up the chances of a promotion (which to be honest, there are better ways to do so, instead of giving away your original creation).
  7. How to learn from Quake source code

    Debatable and that's why inline functions exists. Even when OK, not the kind of approach to be passed to a learner, as @Alberth said: In addition to what @Oberon_Command, we have good version control software for that task. And, tbh, I doubt "not rewriting it again" or "reminds yourself of what have been issues or alternatives" are the only reasons here. Corporate code is different from the code that one can take the time to write, with all patience as a hobbyist. Ideally, learn as a hobbyist is better, write the code with all the time you have, no deadlines to worry about. Corporate programming must worry about delivery and deadlines, and it does affect code quality. It's not that people working on companies are bad programmers (not saying that), it's that they know when to prioritize time over good practices. A learner should prioritize good practices until they are secure enough to break their rules under certain circumstances (shipping delay). Yes, I use global variables, too, and the goto, too. But, by having global variables in the middle of the code: will make difficult to make something multithreaded (you will have a harder time locating where are the globals affected my a threaded function) will cause needless differences in the versioning when you have to move those variables from one point to another (which happens when a new function needs to use that variable, too, and could be avoided if they were on top) To let it be clear: I'm not shitting on Carmack (or his team) work, but I can't help to feel bothered when I see the DOOM/Quake code being pushed as holy to beginners. And it's not.
  8. How to learn from Quake source code

    It's not just because it's legacy C or legacy C++. Quake and Doom source code aren't that perfect beauty that should be aimed to. Some sources have a bunch of global variables spread everywhere, and I mean everywhere, not at the top of the source file, but in between functions definitions. Some functions are huge monoliths, which is a bad practice, too. Some piece of the content are just commented out piece of code, not even removed from the source, but just unused. Just because the game is good, doesn't mean the source code behind it is.
  9. Reinventing the wheel

    Reinventing the wheel is great when (and when you have the time): Your wheel has less dependencies than the current wheels Your wheel is faster than the current wheels Your wheel is simpler than the current wheels The current wheels are obsolete or lack development in the recent years It fits your needs better than the current wheels (specialization) The current wheels have a license that doesn't fit your needs Experience Edit: when you just want to have fun
  10. Is Phil Fish a Jerk?

    Just, lock this thread, already. It's beyond ridiculous a thread dedicated to debate whether someone is a jerk because of their actions under stress.
  11. Welcome to the GameDev Challenges Forum

    I had a lot of surprise work this month, that fortunately are finished, so I will focus on finish my first challenge :'D, this means, somebody else, please make a challenge.
  12. Horizontal and Vertical Lines

    I don't know where to post this, but here it goes. I don't know if this is serious or not (maybe it's an uncanny valley of seriousness).
  13. October 2017 GameDev Challenge: Arcade Battle Arena!

    You can totally submit after. You can interpret it like "make this game in 4 weeks". The most important thing here is learning. Any user can submit a challenge (under a mod approval), and it's not necessarily a monthly thing: https://www.gamedev.net/forums/forum/81-gamedev-challenges/
  14. Advice Leaning how to make a game engine in OpenGL SDL/GLFW

    https://learnopengl.com/ is great. And the examples are in C++, since it is what you are going to work with.
  15. Advice Leaning how to make a game engine in OpenGL SDL/GLFW

    I'm actually making a C framework with OpenGL and GLFW. So, here are my cents. SDL is a larger library compared with GLFW. It isn't big to the point that will make you "overwhelmed", though. If your game engine will be exclusively 2D, it's a doable option. But, if you want something for 3D, too, then SDL is in my opinion a "waste", since some of its features are dedicated for 2D. It wouldn't impede you from making a 3D engine, but there would be that "waste" of unused features. That said, GLFW is cleaner for doing a single job. Is you engine going to manage all assets? Textures, scenes, camera, meshes, animation, shaders/material? You can go with two options, let the engine manage these assets and be responsible for creating and destroying them, or give more power to the user and let the user decide the life time of assets. There's a trade-off here, which is the more power the user have, the more they have to write their own implementations. How much of OpenGL you two know? If not much, start with "modern" OpenGL (a.k.a. OpenGL with shaders). Don't go with fixed function pipeline (old style OpenGL). OpenGL version 3.3 is a good candidate as I mentioned in other thread: Also, how much of OpenGL you will wrap? You certainly will wrap to a degree, since functions to create/delete textures/framebuffers/shaders/VBOs/VAOs will have to use OpenGL. For each type off asset, have a header (.h/.hpp) and a source (.c/.cpp). Then having a central header (myengine.h/pp) that include the header of the types. If this is a possibility, it helps for who uses your engine to include only a single header. Use git for version control. There are several workflows to work with git (for example: http://nvie.com/posts/a-successful-git-branching-model/). Some might be too complex for a team of 2 people. Check what works better for you. You will probably make mistakes with your workflow, so just start using it and learn the best approach for you early. He can use clang or gcc with some editor (Atom is a nice one with good integrations). I don't use Visual Studio (Linux), but it seems like it has support for CMake since 2016. Couldn't you use the CMake instead and make the work with the two platforms easier?
  • Advertisement