Jump to content
  • Advertisement

Leaderboard


Popular Content

Showing content with the highest reputation since 10/17/19 in all areas

  1. 8 points
    Nice write up of some classic tricks! I would strongly advise against using these today, though. These are all undefined behavior in C++. Type punning through a union is allowed in C but not allowed in C++. (For a historical note, SGI's/Carmack's original implementation didn't use a union and was also UB even in C.) The only way to safely do type punning in C++ today is to use std::memcpy. In the upcoming C++20 you'll also be able to use std::bit_cast, which is basically just a wrapper around memcpy, though hypothetically compilers will use intrinsics to optimize bit_cast more reliably than their existing memcpy substitution optimizations. Using a `static` makes these thread unsafe. If two threads both try to call these functions at the same time then bad things will happen. These are all slower and less accurate on all modern CPUs than just using the 20-year-old Intel rsqrtss instruction or the ARM NEON equivalent. This is both because a dedicated instruction is faster than a series of data-dependent instructions, and also because moving values between an SSE scalar register and a GPR integer register has unnecessary overhead. Keep your floats in SSE registers and use scalar SSE intrinsics, which the compiler will do for you for the most part. Unfortunately there is no rsqrt in either C or C++ to portably expose the behavior of the rsqrtss instruction or equivalents on non-Intel architectures, but writing one that selectively uses the correct intrinsics is easy enough.
  2. 7 points
    A particle (in this case a leaf) falling in a straight line is boring. To make it more interesting: Rotate the particle Offset the texture to create a more interesting movement pattern with the rotation If you enjoyed this simple tutorial, check out Ruben's Twitter account, and free games on Itch.io.
  3. 5 points
    Progress Image(191031 Working on door handling makes me remember UDK. Today I push my project to be a little more visible. https://github.com/MarkKughler/NubDevice [dev.azure : NubDevice] project development board Over time, I've glued together more than a handful of starter frameworks. This time I've changed it up a bit and tried for a bit of consistency from the start so new objects feel natural to use. This is working well for shaders, textures, input and the display. I'm actually happy with it as a start. High-lights that may be interesting: start of custom gui (inspired by fpl::flatui) updated stack based state management (menu[n]/play/pause) push in pop out (or maybe old school, first in, last out) .dae loader (geometry and skinning info) (todo: keyframe) currently broken TBN path Hope to finally do some interesting shader work this time around and feel better prepared for the next game challenge. I'm a fan of openAL. That parallel to openGL way is a good thing in my book. Start the device, fill a buffer, attach to a source. Bounce a listener around. It's good. As my interface, that's all I need. A buffer load and a source to play. Fairly clean solution for home brew. Since I don't see a need for the buffer because we don't alter it, I'm thinking of making that init a one liner, except form maybe a reload need. Play from id is great. buffer_click = sound.add("buttonClick"); source_click = sound.attach(buffer_click); // and anywhere alSourcePlay(source_click); // sure why not :) The main character := reveal. nope...still not telling. I'll let you know when I do. heavy current inspiration is an first person arm mesh on the table. Still dreaming up what could go with it proper third person. Choices are fun.
  4. 4 points
    Check the latencies on the link. This is for vectorized code, but I guess, the results are quite similar for serial instructions. `_mm_sqrt_ps` is the standard square root while `_mm_rsqrt_ps` calculates the reciprocal square root using an approximation formula as described by the TO. It is 3.25 times faster (on a skylake processor) but less accurate. If you perform a lot of square root calculations, this might be beneficial. However, there are many situations where you can simply avoid calculating the square root. For example, when you want to know which vectors length is bigger, you can simply compare the squared lengths instead of calculating the length using the square root. No square root is faster than a fast square root 😛 You should generally avoid fast square roots if the result is used in complex subsequent calculations (physics simulations, linear solvers like LLT or QR). The error can lead to unwanted numerical instabilities, especially if you are only using 32bit floats. However, if accuracy is not an issue, you might get a performance boost. I am not sure if it really matters since the relative number of square root calculations per frame shouldn't be too high, but that depends on your game/program. Greetings
  5. 4 points
    You've not shown the buffer creation code, or the code for the buffer binding and draw call, which in this case are quite important. However, there's a standard way to create variable quantities of dynamic geometry using D3D. The basic process is: Create a large (e.g. 1MB) dynamic vertex buffer, once during initialization. The first time in a frame that you want to add vertices to it, Map() it with D3D11_MAP_WRITE_DISCARD. For all subsequent Map()s during the frame use D3D11_MAP_WRITE_NO_OVERWRITE. When it's locked, you can append an arbitrary quantity of vertex data (up to the 1MB limit) to the buffer. When you call IASetVertexBuffers() you can set up the appropriate offset within that large buffer, and the stride for the vertex data that you've just added. In the Draw() call you can pass in the vertex count for the data you just added. A very similar process applies if you want to create index buffer data too.
  6. 4 points
    And here it is, the gameplay, rendering and many other features are pretty much almost ready. I believe that at this point the game actually satisfies everything the challenge requests. Including, somewhat dark but still complete main menu: Fig. 01 - Main menu with fonts and some effects And the rendering was finally changed to something better than colored preview ... so naturally the game is fully path traced (it is noisy, it is slow, but it is ... AWESOME). I will probably provide also non path traced build as playing it in fullHD is pretty much not possible (doing few samples per pixel is a bit of overkill, even for such small scene). Fig. 02 - DOOM has brought us ray casting and some interesting new effects, GROOM follows the spirit of DOOM and implements fully path traced rendering And yes, I've actually named it GROOM (no idea why - it just sounded well to me). So, there will be few more updates improving the playable area slightly, but generally this is it - I know it is small, but pulling off GPU ray tracer for dynamic scenes, that isn't too slow, isn't as easy as it sounds. It was a nice ride - and once release (which will happen within next 24 hours), you can try it yourself to see, how path tracing really is slow.
  7. 3 points
    Hi, this is my first forum and I want to do it: quick way to calculate the square root in c ++ with floating data types. These types of functions are very useful to gain some CPU time, especially when used continuously. I will show you 3 similar functions and indicate the advantages and disadvantages of each of them. The last of these three functions was written by me. If you notice that the writing is a bit out of grammar, it is because I do not speak English and I am using a support tool. My native language is Spanish. Well, let's start: The First method is very famous was used in the video game quake III arena and you can find a reference in Wikipedia as: :https://en.wikipedia.org/wiki/Fast_inverse_square_root. The Function was optimized for improvements in computing times. float sqrt1(const float &n) { static union{int i; float f;} u; u.i = 0x5F375A86 - (*(int*)&n >> 1); return (int(3) - n * u.f * u.f) * n * u.f * 0.5f; } -Advantages: * When Root of 0 is calculated the function returns 0. * The convergence of the function is acceptable enough for games. * It generates very good times. * The Reciprocal of the root can be calculated by removing the second “n” from the third line. According to the property of: 1 / sqrt (n) * n = sqrt (n). -Disadvantages: * Convergence decreases when the root to be calculated is very large. The second method is not as famous as the first. But it does the same function calculate the root. float sqrt2(const float& n) { union {int i; float f;} u; u.i = 0x1FB5AD00 + (*(int*)&n >> 1); u.f = n / u.f + u.f; return n / u.f + u.f * 0.25f; } -Advantages: * The convergence of the function is high enough to be used in applications other than games. -Disadvantages: * Computing times are much larger. * The square root of “0” is a number very close to “0” but never “0”. * The division operation is the bottleneck in this function. because the division operation is more expensive than the other arithmetic operations of Arithmetic Logic Units (ALU). The third method takes certain characteristics of the two previous methods. float sqrt3(const float& n) { static union {int i; float f;} u; u.i = 0x2035AD0C + (*(int*)&n >> 1); return n / u.f + u.f * 0.25f; } Advantages: * The convergence of the function is greater than that of the first method. * Generates times equal to or greater than the first method. Disadvantages: * The square root of “0” is a number very close to “0” but never “0”. The 3 previous methods have something in common. They are based on the definition of the Newton-Raphson Method. according to the function of the square root > f (x) = x ^ 2 - s. well thanks to you for reading my forum. well thanks to you for reading my forum.
  8. 3 points
    Let’s say you have made a game. It’s working quite fine and in your opinion, it is extremely interesting to play. Will it be enough for becoming a new hit? What level of sales can you expect to get? This article is my attempts to analyze some general and insider information, gathered throughout years of working on different games and communicating with colleagues. Unfortunately, a possibility of finding a simple answer to this question is slim to none (which is not really different from trying to find some solution to other issues like “How to become successful” of “How to win one’s heart”). What is worse – it’s a lack of some proper statistics or at least, some trustworthy information on sales levels and promo feedback. Out of publicly available information, we can rely only on the number of reviews and players on steam, postmortems, positive twits and marketing presentations of developers. Half of this information is worthless but could be enough for some approximate estimation. Confidential information usually pops up in terms of a crisis, when this or that company goes bankrupt or a new post like “Our game has failed” turns up. In these cases people don’t care about conversions or organic anymore and tell the truth. Gearstorm. Procedural sci-fi sandbox Well, enough of the initial data, so what about the goal? How to determine the level of your product’s success? I consider gamedev to be a part of the art world and making games is more of a calling than a job. But bare enthusiasm is not enough for living, so I have come to this idea – if you are doing what you like without any need of working extra hours in Walmart - you are doing fine. It means your games bring you and your family enough money for living and if any of these games one day becomes a hit – it will be only a pleasant but sufficient enough bonus. To keep it simple – let’s estimate the costs, based on the average industry salary and the time spent on making a game (in case if you are not hiring anyone). Gamedev is a poor industry when it comes to wages of average employees, so don’t count on more than $30 per hour. Let’s add more sad facts: It’s rumored that only 16% of games get any money at all If it is so, two reasons might have led to such an outcome, in my opinion. Numerous advisors tell you to release as many small games as possible, counting on the possibility of one of them to breakthrough. It’s a bad idea. This amazing model of behavior makes the market full of trash. In order to save up money and accelerate the release, these developers come up with raw and dull games. So, everybody is suffering from it. A good idea would be to start many projects, work on them up to some sufficient demo level and go public. If nobody wants a prototype with a well-determined unique main feature – give it up and start working on a new one. That’s how you can save lots of time and the general quality of the ready-to-play indie-games will increase. But don’t call your tech demos as “early access” and don’t waste time examining the market for years. The second is a problem of any creative person. I like to compare gamedev with music. Imagine, one day you decided to give up on everything and become a solo developer, sounds like an ordinary story, right? And now let’s imagine being in exactly the same situation, with the same zero knowledge of the subject, but this time you have chosen music. “Yeah, everybody is listening to music every day. What is difficult about playing something myself? Give me some advice on what instrument is the best, folks!” Doesn’t sound very optimistic, right? For some reason, forthcoming musicians study a lot, get together in groups and never expect that their yesterday-made track in their dad’s garage will become a hit. I have never seen an amateur guitarist, who would have such confident and overoptimistic outlooks of life as a typical developer from /r/Gamedev or UE4 forum. The higher you fly, the more painful it is to fall. Shining eyes of the latest go dim every time he/she faces the reality: bugs, procrastination, and, most importantly – misunderstanding. No one hears you and if they do – they mostly criticize you. A popular decision in this case is to give up halfway and release what you have. Last Joy. cRPG about death in a world of immortal people How many beginner musicians have become famous? Or at least, paid off their educational costs. I think everybody will agree it’s less than 1%. Your game, probably, has even fewer chances of success. But even the most basic game requires at least 100 hours of work, meaning you have to sell more than 600 copies ($5 each). Sounds realistic but the level of difficulty in this current situation can be seen in the following example. It is like approaching a stranger on the street and trying to sell a book. And even in this case you have an advantage of some real-time contact and lack of competition at that particular moment. It is obvious that on the internet hundreds of people fight for attention of a potential buyer simultaneously. Don’t rely on ordinary ads. I spent more than $240 in Google Ads during one night for my first game and received only 2 installations. On Facebook it turned out to be impossible to even figure out the budget in order to start showing the ad. It was already $50 for an estimated installation (more probable that it would be $500). Don’t think that once you create a page in a store you will start selling. No channel nowadays brings any organic installations (even though there are some individuals who manage to get 90% of the traffic from the “More Like This” section on Steam). But if you decided to give it a shot anyways, try to search for some growing portals which are obtaining content and money artificially. I have lost $235 advertising my first game. Good news – if your game is good, after the first hundred of players you will face a problem of sales less and less regularly and the word-of-mouth will be in action. What unites good games? Reasonable price. There is a golden rule that says – a casual player should pay $1 for one hour of gameplay. If it’s less – it is fine as well, if it’s more – you have higher chances of getting negative reviews, being called greedy and being nit-picked. Eye for detail. The game should create a feeling of being worked on hard. Marketplace assets along with tutorial framework will never breakthrough. Polishing up the game will take 20% of the time but give 80% of the result. The point is to know when to stop because the process might last forever. Right choice of the target audience. So much has been written about it – it’s the basic rule of business. The above is obvious but in order to be estimated by anyone you have to attract attention of potential players first. And as a result, the determining factors of success are: Community support. Even if you are making crappy games but people already play them you can simply keep releasing series after series and make good money out of them. Even in case if your community is not made of gamers but a bunch of SJW paladins instead, they will be forming hype around everything you do anyways. The core of the game is so unique and fresh that one can’t help noticing it. I guess it’s the easiest way. I am personally trying to follow this strategy in my projects. Connections. A journalist of a well-known portal can find some space for your announcement. A famous media person can have a word with investors. An employee of a distinguished company can assist you with a grant for some commission. Yes, corruption as it is, unfair competition and everything else typical of our world. I have been personally advised to write a guy, helping with receiving EpicMegaGrants. It was like: “Text him on Linkedin as we did and that’s it, you will get your 30 thousand…” Abuse of rating systems in digital stores. It seems like the programmers themselves don’t know their ranging algorithms (Steam, for instance, can’t even configure their account server). I am not even speaking of the Google Play ads, there are so many theories of how you can be promoted there once you sign up. The worse the system is working, the easier it is to break it. And who knows, maybe you are the one who knows the secrets of promotion. Simple luck. Game announcement is similar to a longread on Reddit. Imagine you are tossing a 1d20 dice with each post. The post gets in “hot” only if you have a crit, 19 posts out of 20 will be lost amongst hundreds of announcements. A famous reviewer can accidentally pick up your game among numerous options and make a living for you, dooming others to stay poor. The chances depend directly on the length of the list. By the way, not all influencers are equally useful. I was lucky to have a few discussions with the authors of the games which were streamed with 30k+ audience. Guess, how much it increased their sales? Zero. Literally, zero increase. A vivid example – Balancelot, which was streamed by Lirik and Forsen. The guys who made the game, not to fall apart, had to start making a new one right away, using the same assets but in a different genre, less casual. Here is a checklist. Take a pencil and tick the points that really characterize your project. If you have ticked all the points from the first list and at least one from the second – keep going! Chances are you will get in that golden percent. Your success is just around the corner, finish up what you have started. Otherwise… Alien Seasons. Mindless platformer for kids. As I have already said, if you are happy, you have some funds to keep living, your wife is not nagging you for wasting youth in front of PC, why not? You can consider you game to be already successful. You have found your calling – something most people dream of having throughout their entire lives and some of them give up on searching too early.
  9. 3 points
    Slides and transcript for "Ray Tracing a Procedural Planet", with links to all of the code. An easy and inspirational introduction to procedural landscape generation by Morgan McGuire. Slides: http://casual-effects.com/research/McGuire2019ProcGen/McGuire2019ProcGen.pdf Originally posted on Twitter:
  10. 3 points
    Huh, that's 'kinda neat moments... When you start over from scratch, design aspects become more important. I can't help what I have yet to discover but for the first of I suspect to be many, a happy moment. Mouse input ponder. The usual choice is to constantly redirect the mouse cursor to the center and act from the deltas. I'm starting to hate that. Something about it. So I changed it up a bit where I'm still clipping to the window but wrapping on the left and right edge. This feels better at least to not have to hide the cursor and still not allow to click focus lost. This is what my front end input handling looks like. Now I don't care about mouse sensitivity or delta timing on the camera yaw movement and perhaps puts a skill modifier back on the user. In a sense. #define imp_bool(x) if(input.pAction_map->GetBool(x)) #define imp_float(x) if(input.pAction_map->GetFloatDelta(x) != 0.0f) void Game::update(float deltaTime) { // user input pump imp_bool(cancel) { action_this_frame = quit; } // camera imp_bool(forward) { camera.move(FORWARD, deltaTime); } imp_bool(backward) { camera.move(BACKWARD, deltaTime); } imp_bool(left) { camera.move(LEFT, deltaTime); } imp_bool(right) { camera.move(RIGHT, deltaTime); } imp_bool(up) { camera.move(UP, deltaTime); } imp_bool(down) { camera.move(DOWN, deltaTime); } imp_bool(jump) { } float x = input.pAction_map->GetFloat(mouseX); // 0.0--->1.0 (l--r) float y = input.pAction_map->GetFloatDelta(mouseY); // upper ndc space also camera.ProcessMouseMovement(x * 360.0f, y, true); // yaw rotation based on horz screen position // pitch is accumulated and clamped process side // // todo: take into account the physical velocity of the mouse movement // high velocity user movement skips a beat at edge transition // solution: track previous movement and apply // priority: barely notice-able // POINT pt; ::GetCursorPos(&pt); // keep y component if(x<0) { // left and right screen edge cursor wrapping POINT pt_desired = { display.dims.width, 0 }; ::ClientToScreen(display.hwnd, &pt_desired); ::SetCursorPos(pt_desired.x-2, pt.y); // todo: refactor out the magic number } if(x>0.9985f) { // partial cause of refactor above (but it's decent smooth at 800 x_res) POINT pt_desired = { 0, 0 }; ::ClientToScreen(display.hwnd, &pt_desired); ::SetCursorPos(pt_desired.x, pt.y); } } we'll see how it goes.... Next up... [ Fix your timestep ] yup, I'm a believer. I've heard said, 'If you're going to do multiplayer, do it early'. Hard to argue, set up you system to play nice with something hard. I've always partially ignored the previous state - this state tween concept when it came to timing, but this really, really makes sense to me now. Oh yeah, we're keeping that... And the closer.. I'll be spending the week cleaning up and minor miscellaneous tweaks. I understand the importance of tidying up and now is the point to decide how I branch out from here cleanly. I feel now is a good time to give the [ RIP Method ] a serious follow through. I agree, repetition is key (at least for me) Thanks @DavinCreed, that's helping. I've only started to browse. Have to go to work for now though.
  11. 3 points
    The DOOM: GameDev Challenge ended last week. Congratulations to all who managed to complete the challenge! It's always cool to see members in the community complete projects like this, and some of these entries turned out more "complete" than we might have expected for 2 months of development. Here's the list of completed projects, in no particular order: Owl Shooter (Manager Killer) Member: @Homeship Unity-based Doom-like gameplay with Steam release plans. Project page: https://www.gamedev.net/projects/1872-owl-shooter-manager-killer/ Blog: https://www.gamedev.net/blogs/blog/3973-owl-shooter-manager-killer/ GDDoom Member: @Endurion Unpolished, programmer art based on a custom Doom-like engine. Blog comment: https://www.gamedev.net/blogs/entry/2267685-doom-the-gamedev-challenge/?do=findComment&amp;comment=2269236 GROOM Member: @Vilem Otte Custom path tracing renderer DOOM experience with custom art. Project page: https://www.gamedev.net/projects/835-doom/ Blog postmortem: https://www.gamedev.net/blogs/entry/2268070-doom-post-mortem/ PulseHazard Member: @emanubit Godot engine based Project page: https://www.gamedev.net/projects/1870-pulsehazard/ Blog postmortem: https://www.gamedev.net/blogs/entry/2268071-pulsehazard-postmorten/ Gloom Member: @dimi309 small3d framework based Doom-style game with 3D models created in Blender. Project page: https://www.gamedev.net/projects/1863-gloom/ Blog postmortem: https://www.gamedev.net/blogs/entry/2268060-doom-fall-2019-challenge-participation/ Doomish Member: @DavinCreed Very Doom-like experience clone. Project page: https://www.gamedev.net/projects/1758-doomish/ Blog postmortem: https://www.gamedev.net/blogs/entry/2268019-doomish-done/
  12. 3 points
    The answer really depends on the operating system you're using, if any. If you're not using an operating system, it depends on the hardware you're using. At a basic level, input is handled by reading from a memory location, device file, or message events from an input server. You might have to poll the input, or receive input asynchronously. Output is, as you say, rendering 2-D colours to a memory region and taking the appropriate action to have that memory region displayed on an output device (you might be writing directly to screen memory, or you might have to submit the particulars of your memory area, like address and size, to another memory area, device file, or buffer stream going to a display server. You may have to instruct the output to swap buffers. You will need to handle timesteps to synchronize input, output, and in-game processing. If you want to know how SDL doe these jobs, read the SDL code. It's all open source. If you want to do your own input and output, read the SDL code to learn how they do it to get an understanding of how input and output work on a number of operating systems. It turns out there isn't a small simple answer to your question. No one can point to a function in the C standard library for getting input and rending in the DOM. C is not JavaScript or a full-stack web development kit.
  13. 3 points
    All of the videos from the first DVD have now been released. The videos from the second DVD - which focuses on lighting and lighting models started coming out this week. You can watch them here: https://www.youtube.com/playlist?list=PL78XDi0TS4lE772rZflLkFe-WdhYEV4WE A new one will be released each weekday.
  14. 2 points
    Hello everyone! I'm a high school senior trying to gain as much insight on the game music industry as I can. I've taken up the task to teach myself a ton of music theory and production to better myself as a composer and as a musician overall. Most of what I listen to is from a wide variety of anime and games, and although I'd like to say I'm heavily influenced by Japanese composers, my music is hopelessly all over the place in terms of genre and style. I originally wrote this post to ask for feedback for all of what I've written so far, but it felt like such an open ended question for such a wide variety of music that I've divided my music into sets. I'm here to ask for any feedback on what I have written in this playlist. With that being said, here is a link to the first set of music. Thank you for your time:
  15. 2 points
    First weapon of choice: The sword Making this weapon of choice took some thinking for sure. For one, the design significantly changed over time (see the image below, or on my twitter for its dedicated thread), and took several iterations to get to this point, but I'm fairly happy with the results. Of course, I could work on it endlessly, but the project has to go forward; might come back to it at a later point, if needed. Old design (HP): New design (LP): I think many of you fine folks out there will notice that there's something different is going on with the blade. You see, I wanted to make this sword a bit more special than your average butter knife, and thought to add some meaning to its purpose. After all, there is more to it what meets the eye. It was crafted by the finest blacksmith that any soldier could afford; and was forged to honor the gods! The one who wields this fine blade shall carry the gift of its words.
  16. 2 points
    1/2. People being able to monopolize something for a week means they are on a timer and have to do affordable pricing. People being able to monopolize for months or years means they can ask any price. 3. Even if you don't need the items they will still allow each for x% faster game progress. 4. Not no grinding but no excessive grinding (for example incited through monopolization).
  17. 2 points
    What is the question? Don't keep us in suspense.
  18. 2 points
    A (very simple and short) DOOM shooter like experience (Named GROOM), that isn't using ray casting, but real time path tracing. Post mortem and gameplay video will be added shortly. I hope that anyone playing it will be able to run it (very good GPU is required!), and hopefully it will be at least a bit fun for him. And yes, programmer's art included! EDIT: I'm not sure if post mortem should be posted here or not, anyways here it is -
  19. 2 points
    I have estimated that I will not be able to finish this challenge in time. I have started it too late and without a clear direction from the beginning. I managed to finish the necromancer character, the AI and most of the map. But I had some problems with projectiles going through walls and sometimes going in weird directions without any kind of apparent reason why. I have decided not to release the game as it is because it has some broken gameplay mechanics and I'd rather not release the game like this. I might continue working on it when I have more time and not be busy with other things as well. Well, it was fun anyway and congrats to the community members who succeeded in this challenge! Cheers.
  20. 2 points
    Okay,thanks! Then i will continue here if necessary. @Zakwayda Thanks man! Second time you helped me out succesfully! Couldnt have done it alone. Also thanks to @alvaro. Great postprocessing algorithm! Still amazed how it does its job with crappy data out of thin air! Thanks for your effort and time!
  21. 2 points
    My unsolicited advice if you would be so kind as to allow it: 1. Do not write if if if if if if. Use for loops. 2. Create two classes called Plane and Bullet then create instances of both of those objects. Store all planes into an array called planes, and all bullets into an array called bullets. This is called object-oriented programming.
  22. 2 points
    Wow! I wish my first sprites looked like this! Very good job. Some things to note: 1. When you're doing an idle stance look for parts that seem "glued" or stuck. It looks as if the sprite is doing shrugs. You should try to incorporate more motion if possible. Adding in some "sway" could breath more life into the animation. 2. The same thing with the running animation, the shoulders and upper body appear motionless in terms of vertical movement. I don't have too much time to find resources but look at the end of this video. Notice the full body movement?
  23. 2 points
    My irony sense is tingling.
  24. 2 points
    Welcome ! Tips always, but my shares stay in the depot 👹 Just kidding, i don't hold any shares
  25. 2 points
    Hopefully you won't be given thousands of lines of FORTRAN IV to port and debug like I was 😭
  • Advertisement
  • Advertisement
  • Popular Contributors

  • Member Statistics

    • Total Members
      261323
    • Most Online
      6110

    Newest Member
    SuX_X1
    Joined
  • 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!