AI Car - Unity Hybrid ECS/DOTS Forging Station 2020-07-11 | In this video, we will explore and build a simple AI-controlled system for our vehicle / Car.This is built upon our previously developed code. If you have not seen my previous video, please watch it now!!! as it is essential to understand what we will be doing. Here is the link - Unity Hybrid-ECS Car Controller -youtube.com/watch?v=f0viJi8vi5I&t=71sWe will use Unity's new Navigation system, and follow a NavMesh agent around the terrain, however, our code and physics will control the vehicle.We are also going to explore and calculate the commonly used Inverse Transform Point using Unity Mathematics - essential to steer our car in the right direction.I have tried to keep the explanation around the inverse transform point, Local To World Matrix & Matrix transformation as simple as possible. (In fact very simple when I say its a Matrix. There is a lot going on in the background and explaining that falls out of the scope of this video)This is an excellent use case demonstrating how classic Game Objects can be mixed with Unity ECS/DOTS in a hybrid fashion to achieve desired behaviour.Source code (only) can be found here - github.com/ForgingStation/AI-Car---Unity-Hybrid-ECS*************************************************Terrain textures - textures.comProcedural Terrain - Map Magic 2 - assetstore.unity.com/packages/tools/terrain/mapmagic-2-165180Introduction to Unity Mathematics - youtube.com/watch?v=u9DzbBHNwtc*************************************************
Dynamic Obstacle Avoidance with Nav Mesh Query - DOTS 1.0 Forging Station 2023-05-18 | Hey everyone. Coming back after a while now! In this video, I have upgraded the most requested, Navmesh query-based pathfinding to the DOTS 1.0 version. That's not all! The new system is more modular, with a spawner that can be reused and dynamic obstacle avoidance. To top it all, with a proper GIT repo :PIt's not perfect and robust as it really depends on the level and enhancement specific to the level where such dynamic behavior is needed. At the least, this should help one understand how to utilize the navmesh query-based ray cast to determine path validityNote that this is still highly experimental and must not be used in productive environments!PS - The audio is not great :( I have been trying a new setup and used AI noise cancellation. I guess I got it all wrong.Hope you guys enjoy the video!SourceCode - github.com/ForgingStation/Dynamic-Obstacle--Avoidance-with-Nav-Mesh-Query---DOTS-1.0Music -"Half Mystery" Kevin MacLeod (incompetech.com)Licensed under Creative Commons: By Attribution 4.0 Licensehttp://creativecommons.org/licenses/by/4.0
Shield/Forcefield with Unity DOTS & Shader Graph Forging Station 2022-06-18 | In this video, we are going to look at an example where we will have projectiles firing at our ally that needs to be protected. So we have a shield around our ally to absorb the incoming projectile impacts.We will do this using Shader graph, with exposed variables addressed via the Unity DOTS-based system.This can be much simpler but I just wanted to explore things that may have to be done when having a parent-child hierarchy in our entities - that is mostly the case.I will still fine-tune and have more controls exposed to be controlled for the script so stay tuned!Source code -github.com/ForgingStation/Shield-Forcefield-with-Unity-DOTS---Shader-GraphAn amazing tutorial on Shadergraph & Shield that I followed to make the shield prefab - @GabrielAguiarProd youtube.com/watch?v=IZAzckJaSO8
#Shorts Unity DOTS & Shader Graph - Flocking Simulation - https://youtu.be/wmeXusKiCK4 Forging Station 2022-05-07 | #Shorts A nice way to address shader graph exposed material properties via a DOTS-based system!youtu.be/wmeXusKiCK4
Shader Graph & Unity DOTS - Flocking Simulation Forging Station 2022-05-07 | In this video, we will go over one of many ways to use shader graphs with DOTS based system. This is a regular boids simulation but with quads flapping their wings. The frequency of the flapping is proportional to the boids current velocity and the glow is more intense if they are concentrated.Both of these behaviors are controlled by a DOTS-based system that is continuously modifying the exposed shader graph properties.GitHub - github.com/ForgingStation/ShaderGraphs---Unity-DOTS
Collision Avoidance using Boids behaviour Forging Station 2022-04-09 | In the last video, we spoke about adding navigation capability to arbitrary entities. Those entities still did not know each other's position, and hence did not exhibit collision avoidance, and this is what we are going to do in this short video.The very same GIT repo has been updated - github.com/ForgingStation/New-DOTS-Nav-Mesh-Query-Implementation
Easily add navigation capability to any entity - Unity DOTS navigation with nav mesh query Forging Station 2022-03-12 | This was long due, but I had to try out new ways to achieve a more efficient and maintainable DOTS-based navigation system that can be easily added to any entity to provide navigation capability.I am open to feedback on the way this has now been implemented, but I have verified it to be efficient and serves the purpose of processing a set number of entities per frame without too much of an overhead.I also have a working IJobEntity Batch version of the core navigation system that is available on GIT for you guys to have a look at.GIT - github.com/ForgingStation/New-DOTS-Nav-Mesh-Query-Implementation
Unity DOTS Navigation - Click To Move - New Input System Forging Station 2022-02-12 | In this short video, we are going to make an AI car move to the mouse position.The more I see this the more I think that this is a kind of spaghetti code or system. I will be simplifying & modularizing the navigation code so it can simply be attached to an entity and we have had the path calculated. One more thing that I have to take away from the existing solution is the logic to used the cached path. I will keep the current code that has this feature as is but will be removing it from this version forward as I don't see myself reusing the cached path in my scenarios. I will also try and take advantage of a newer DOTS-based job system that makes the code more readable and clean.I will be refactoring the code and then adding them to the repo so it is easy to understand and reusable as well. I am thinking of making some kind of a recipe repo where you can pick the systems you need and use them as you wish!
Procedurally Generated Park! Wave Function Collapse - Basic & Simplified version - Unity Forging Station 2022-01-08 | Hey guys! This is an updated & simplified version of my last attempt on the Wave Function Collapse algorithm. The last one had a few issues and was poorly optimized.GitHub has been updated with the old version of the code marked as deprecated.I even tried out modeling in blender this time to make it look a bit interesting. I basically wanted a nice-looking level for the DOTS-based AI car project. Though this would not be the environment, at least it is a step in the right direction.I will be enhancing this project to incorporate some kind of error correction, layering, usage of nonuniform tiles, and of course going 3D, etc so stay tuned.GitHub - github.com/ForgingStation/Wave-Function-CollapseGood Reads - boristhebrave.com/2020/04/13/wave-function-collapse-explained
New Input System With Unity DOTS-ECS Forging Station 2021-12-11 | With unity's new & elegant input system, we do not have to worry about the input devices used to generate the necessary input. This is a wonderful way to separate input from actions. |In this video, I talk about the easier and straight forward way of using the new input system in the DOTS context, and also a not so clever way of using the input system in a struct-based system.I am still not sure why one would try to capture long-lived inputs via events in a struct-based system, but it has its use cases. But for the most part, it would be easier to read the inputs and pass them on to high-performance multithreaded jobs.SourceCode - github.com/ForgingStation/New-Input-System-With-Unity-DOTS
Getting Started With Procedural Content Generation with Wave Function Collapse - Unity Forging Station 2021-11-13 | Barely getting started with the basics of procedural content generation using wave function collapse. I am excited about this project and will keep adding small enhancements in-between other projects so stay tuned!It took a while to even understand how unity deals with vertex positions and how it could be used. I am not sure if a generic WFC algorithm can be made but if one understands the algorithm, I think it can be used in a pipeline to procedurally generate content, at least some content for a game.Took me a while this one. This is extremely inefficient at this point. Share your feedback/suggestions on optimization and ways to improve the approach I am taking here!!GitHub - github.com/ForgingStation/Wave-Function-CollapseMuch better explanation of the Wave Function Collapse Algorithm - youtube.com/watch?v=2SuvO4Gi7uYProcedurally generated city - Marianhttps://marian42.de/article/wfc/
Structs Only! Proper Way To Burst Compile & Change Material Properties While Using - Unity Dots Forging Station 2021-10-16 | Hey everyone ! Today we will talk about changing material properties while using DOTS and how to properly burst your code. Two entirely different topics because I encountered an error while coding this.Turns out for some reason we cannot use IjobEntityBatch in ISystemBase struct though it works. We have to only use IjobChunk.Its worth all the code because the main thread is bursted! where we are scheduling the other jobs!Turbo Makes Games - Generate RANDOM VALUES in ECS - Unity DOTS Tutorial - youtube.com/watch?v=s-nr9EMmhfoGitHub-github.com/ForgingStation/Spawn---Operate-On-Entites-Using-Structs-Only--DOTS
Spawn and operate on entities using only structs - Unity DOTS Forging Station 2021-09-18 | Imagine burst compiling the update method and using only structs in your game logic.Not sure if its possible but here is a start.We spawn and control the entity with out using classes!
Boids - IjobEntitiyBatch Vs Entities.Foreach Is it worth the extra lines of code? Forging Station 2021-08-28 | Today we are messing around with the usage of IJobEntityBatch instead of Entities.Foreach() to see if we gain or lose performance in Boids/flocking simulation.We are also using Hybrid Renderer V2 - Ran into an unexpected issue where materials in entities were just rendered black.Note that extra lines of code need to be written if you ever choose to use IJobEntityBatch over Entities.Foreach().Make an informed decision if you going this route by going through the documentation and use cases where it would shine. Know more here-docs.unity3d.com/Packages/com.unity.entities@0.17/manual/ecs_ijobentitybatch.htmlSource code on GitHubgithub.com/ForgingStation/Boids-Using-IJobEntityBatch
My RayTraced Computer Room. Not what I expected! Forging Station 2021-08-07 | This time I tried to raytrace my computer room and the results were bit surprising. I spent a lot of time tuning the SSGI, SSR and AO parameters.It was overall a very rewarding experience. It took me over a week to figure how to make 'modular models' snap properly!Do lookup for Nvidia RTXGI & less known RTXDI (with more to explore)Probe based RTXGI is sometimes called DDGI as well.Here is something if you want to know more - DDGI in Unity-youtube.com/watch?v=F3hIculYFwMRTXGI: SCALABLE RAY TRACED GLOBAL ILLUMINATION IN REAL TIME -developer.download.nvidia.com/rtx/rtxgi/NVIDIA-RTXGI-03-23-2020-v2.pdf?lDUDwH8Te7f4be7fCQiojIjhoq-3a4B3fkVGd4aBhOFbLMvDrE1wnHfEvI4RQYtjLMko4HsSAnOYY2cyN7u_JqfMrWYCc1B1F1keBbDCHtKYKV-aNAyFZh_g1E_Kp5l2WDgeW7Kt9AI wan this in Unity-gdcvault.com/play/1026182
COMPLETLY failed - Nothing went as planned with crowd simulation! Forging Station 2021-07-11 | My failed attempt to realize crowd simulation using gradient descent algorithm.The idea here was to associate a cost to movement and obstacle avoidance in a way, that movement cost increases if the agent is not directly heading towards the goal, and obstacle cost increases if there is a higher chance of impending collision.We can then use gradient descent to descend upon these const functions to reduce them. Given that these cost functions are expressed in terms of speed and direction, as we descend we can obtain the speed and direction values that produce the least change in the cost function.It did not go as planned but here it is anyway.For this wondering - Va - Velocity of agent a - or agent under considerationVaz, Vax - x & z components of velocity VaPba - Position of other agent/obstacle WRT agent aThe rest of the parameters are explained in detail in my previous crowd simulation videos.
Crowd Simulation Part 2 - The Movement Cost - Not sure why I do this!! Forging Station 2021-06-19 | Hey everyone!In this video, we associate and calculate the cost of the movement of an agent heading towards a designated target.The ultimate idea here is to calculate collision cost and the movement cost so we minimize both to find the most optimal route.We are given to understand that the movement cost which is expressed as a function of speed and direction of the agent, is a Gaussian function.We compute the partial derivatives and code them to see how the agents behave.The agents sort of turn wildly during the start of the simulation - which is done to exaggerate the system's ability to correct itself. I am pretty convinced, that the deviation in an actual scenario that needs to be corrected by this system won't be so much that the agents exhibit these wild turns - this remains to be seen :)Derivation of Gaussian function - youtube.com/watch?v=cTyPuZ9-JZ0Gradient-based steering for vision-based crowd simulation algorithms, Eurographics 2017 youtube.com/watch?v=aqOfqdm9Hcc
Crowd Simulation Part - 1. Closest Approach Calculation Forging Station 2021-05-22 | Hello!In this video series we are going to try and produce an intelligent crowd simulation. We already have perceptrons which can be tagged to every bot, so all we have to do is to deduce a parameter to portray the bots current situation along with governing variables.In this particular video we only calculate the distance & time to closest approach. We will see how to derive this and compute a temporary cost value.This is still work in progress. Refactoring, fine tuning of grid system and of course the introduction of perceptron behavior will happen in the next video, which would be the only deviation from the paper. Gradient-based steering for vision-based crowd simulation algorithms, Eurographics 2017youtube.com/watch?v=aqOfqdm9Hcchttp://people.rennes.inria.fr/Julien.Pettre/pdf/EG2017Dutra.pdf
Perceptron Based Decision Making Unity DOTS Forging Station 2021-04-04 | In this video, I try and explore the possibilities of having a single perceptron make sensible intelligent decisions. We have a system where a bot wanders around to consume food of type bread or venom to stay alive as long as possible. Consuming bread will add health whereas consuming venom removes some health but provides a speed boost. It is up to the perceptron to figure the right bias values to switch at the right time to maximize the survivability of the bots!There is a facility to limit the number of generations to omit those bots which show no evolution. This can happen if other bots have matured too fast which usually leads to scarcity of available resources.Availability of consumables/resources greatly influences the overall system. In my case, I had to spawn bread every 0.5 seconds and venom every 1 second for 10 bots to evolve.About Perceptron -youtube.com/watch?v=ntKn5TPHHAkGitHub -github.com/ForgingStation/Perceptron-Based-Decision-Making
Apply Force Upon Impact - Unity DOTS Physics Forging Station 2021-03-06 | Hello! In this video we will explore one possible way to add force upon impact, using DOTS Physics.The cannon video did not have any force added to incoming enemies, rather simply destroyed it. I plan to implement a similar solution there but this is a barebone implementation of how to add force upon impact.The float variable in WallComponentData is optional if we let the force deplete naturally. I tried doing this but for some reason, it did not work for me and the cubes kept experiencing force. I had no choice but to add a tag to stop applying force.This is something I will look into, and update the code if I figure it out.This implementation with the actual cannon is going to look different as there is one more thing that needs to be done before applying force there, need to change the identified enemies from kinematic to dynamic to let the physics simulation take effect.Overview of physics in DOTS - Unite Copenhagen - youtube.com/watch?v=tI9QfqQ9ATAGitHub -github.com/ForgingStation/Add-Force-Upon-Impact---Unity-DOTS-Physics
Cannon System - Unity Dots - Parabolic Projectile Forging Station 2021-02-06 | I have used the term-base when I actually refer to the parent object housing all the cannon mesh parts.The barrel rotation is still sloppy and needs a bit of work.Not to mention the cannonball hitting the ground. Ideally, a hit should be registered against the ground and make the surrounding enemies dynamic before applying outward force to all the enemies. And I dont think its called an 'annotation' :)Lots of things still need finetuning and the API also needs to evolve for a better and cleaner implementation Source code can be found here -github.com/ForgingStation/Battle-Simulation-Basic-Setup---Unity-ECS-DOTS
Battle Simulation Basic Setup - Unity ECS/DOTS Forging Station 2021-01-09 | In this video we are going to setup an DOTS-ECS based basic battle simulation system.I was very impressed by the Nordius demo from Unity showcasing the brand new C# job system. I decided to build a battle system from scratch but the very thought of how many things need to work in harmony is scary.The shooter entity is going to stay still while trying to take out a bunch of oncoming enemy capsules. We are going to use a collider cast to sense for enemies and a converted physics collider to register a hit on the enemies.we will rely on a collision event to fire which we can handle to define what must happen. To keep it simple let's just destroy the projectile and the enemy.We do this by writing a collision event job that will be invoked every time there is a collision. It's our job to filter on it and identify if the 2 entities involved in collision say entity A and entity B are the projectile and enemy. If so we are going to destroy both irrespective of the order the collision occurs.GitHub - github.com/ForgingStation/Battle-Simulation-Basic-Setup---Unity-ECS-DOTS
Sense the Surrounding environment - Parallel Job - Collider Distance Query Unity DOTS Physics Forging Station 2020-12-19 | Hi there!! Today we are going to try to use DOTS physics-based collider distance query to sense the surrounding environment for BOIDS.The idea here is to have a mesh - a sphere collider cast near/around every boid and have this collider register a hit when it hits other entities, so we can read the hit position and do whatever we want with it.I have not spoken about filters that can be set while creating colliders, and it is still working because it is the same collider that we are referring everywhere. Naturally, it cannot register a hit with itself, and can only interact with other entities. Currently, the collider hits all other entities/colliders but we can control that with the help of layers - by specifying bit masks while specifying filters.Spatial Queries And Filtering - docs.unity3d.com/Packages/com.unity.physics@0.0/manual/collision_queries.htmlGitHub - github.com/ForgingStation/DOTS-Physics---Collider-Distance-Query---Parallel-Job
No Ray Casting/Overlap Queries!! Reverse using Ackermann Steering Geometry - Unity DOTS/ECS Forging Station 2020-12-05 | Hello!!Today we are going to use an approximate version of Ackermann steering geometry to try and reverse a car.The idea here is simple. if a waypoint is within a circle defined by this turning radius then our car cannot reach that waypoint by making a turn.All we have to do is turn the steering wheels in the opposite direction, reverse until the waypoint is outside the circle. We can then resume moving towards the waypoint.We already have a car and Dots based Navmesh query system to calculate a path for us and dump waypoints into a buffer element, from which we are reading to navigate. You might want to watch some of my previous videos to know more about the hybrid ECS car / the Dots NavMesh query system and how they are communicating with each other.The car should never get stuck in the maze - provided, it naturally gets into a position. If we place it in unnatural positions manually then it will not be able to get itself out of the situation. This is another area where casts / overlap queries will be needed to make a right move. Ackermann steering geometry-en.wikipedia.org/wiki/Ackermann_steering_geometryThe Science of Off-Roading: Uncharted 4's 4x4youtube.com/watch?v=SKXqWcaoTGEHybrid ECS - AI Car -github.com/ForgingStation/AI-Car---Unity-Hybrid-ECSDOTS - NavMeshQuery-Implementationgithub.com/ForgingStation/NavMeshQuery-Implementation
Basic Flocking Optimization - Android Build - 20000 Boids - Unity ECS/DOTS Forging Station 2020-11-21 | Hi there!In this video, we are going to look at ways to optimize flocking behaviour and run it on my Android smartphone to see how far our performance tuning can take us.We will focus on the following areas - Usage of BLOB asset store to store parameters that stay constant during the gameplay - this will make sure all the boids are referring to the same memory block where these parameters are not duplicated in every boid.Limiting the iteration - When the boids are close to one another / when they are clumped together, the code will have to iterate on a lot more boids than necessary - every frame - which results in rapid frame drops. We will incorporate a simple logic to limit these iterations.Field of view - If we are choosing a limited number of boids around a given boid then we will make sure we pick the most relevant boid by defining a field of view - in a way only boids in front of a given boid swept along the field of view are considered.I am sure this can be pushed further and the system can be better optimized by introducing algorithms like particle swarm optimization / genetic algorithms and also by writing even more optimized code.Though these methods might - in some cases - provide marginal performance improvement, at the least we know where the bottleneck is - Iterating and pushing boids into a cell. It would be ideal to register only boids that matter in a cell and implement a quadtree for quicker convergence.Scalar projection - youtube.com/watch?v=_ENEsV_kNx8BLOB Asset Store - youtube.com/watch?v=7_rZhp6V8dsSource code - github.com/ForgingStation/Flocking-Optimization---20000-Boids-on-Android-Smartphone
Simple Flocking Simulation - Boids - Unity ECS/DOTS Forging Station 2020-11-07 | Today we are going to code & play around with some boids!! You might have already come across this term as this is what Craig Reynolds called these entities in his flocking simulation proposed way back in 1986.I have been messing around with collision avoidance recently, and I simply could not resist realizing boids.******IMPORTANT BUG FIX - Boid_Movement - Line #73 should be : alignment = alignment / totalThe same result / massive flocking behavior can be obtained by playing around with exposed variables.GITHUB has been updated.******Craig Reynolds - Boidshttp://www.red3d.com/cwr/boidsThe system is not fully optimized - not yet - because, if a given cell has more boids at any one point / cell, the frame rate drops which makes sense as alignment, separation, and cohesion have to be calculated for all the boids in the same cell - this can be reduced by having a smaller cell size but we may not get a nice flocking behaviour.We can implement quad tree to improve performance but we also have to rearrange the data before processing (IJobParallelFor / shared key indices)Source Code - github.com/ForgingStation/Simple-Flocking-Simulation---Boids---Unity-ECS-DOTSAn amazing flocking simulation - youtube.com/watch?v=mhjuuHl6qHM&vl=en
Separation Based Collison Avoidance - AI Cars - Unity ECS/DOTS Forging Station 2020-10-24 | In this short video, I try and implement Craig Reynolds - Separation behaviour to get a more natural-looking collision avoidance between AI cars.It is possible to have 100% collision avoidance but it might look less natural - at least in my case, of all possible values I tried for distance threshold and force multipliers, having 100% avoidance was definitely unnatural. Creag Raynolds already has the steering behaviour figured out in his elaborate - Steering Behaviours For Autonomous Characters - paper, which emphasizes several ways to steer an agent which can be mixed to get really interesting behaviours.Here is one of many links to the same paper/materialred3d.com/cwr/steerI have not implemented cohesion and alignment, but, still, it exists in some manner, because cars are navigating through calculated waypoints on Navmesh - so they are aligned as all cars have a similar path as a destination is the same.This is a very basic implementation and hence does not consider level geometry especially with sharp corners, hence it completely relies on navmesh which may not provide enough information to make precise adjustments to agent trajectory. Ray casts may have to be used in such circumstances or if possible register the level geometry in the grid and go for nonuniform grid subdivision using - say an R tree for example.And one last thing - its Night :)
Dynamic Collision Avoidance System with Spatial Partitioning - Unity ECS/DOTS Forging Station 2020-10-10 | In this video two of the most commonly used collision avoidance methods - placing an agent at an average location to avoid collision Vs avoiding the nearest agent - are compared.Simple yet optimized spatial partitioning methods can be used to achieve highly parallel collision avoidance behaviour for a large number of agents.I tried and failed while using unrestricted Ray Casting to find nearby agents though - as usually Ray Casting much be hidden behind a condition.Source Code - github.com/ForgingStation/Unity-DOTS_Collision_Avoidance_SystemUnitV2_Component - The componentData struct which holds the necessary data for every unit.Unit_Spawner_Base - A Monobehaviour class spawning entity with necessary components. Any code block with a comment - Debug - can be commented to increase performance.Unit_Movement_System - A system base operating on UnitV2_Component, responsible for movement and collision avoidance. Two methods demonstrated in this video exist as separate foreach loops on entities.Unit_Buffer - A dynamic buffer holding two locations between which units traverse.This system ac be clubbed with DOTS- NavMesh Query system to achieve collision avoidance while navigating. Bullet Points used while recording - Cloning the DOTS Navmesh Query Code - verify there is no difference in behaviour.RayCast problemHashKey calculationSpatial separationHash bucket visualization with cell size 8 & 20Persisting Map data throughout the frame and rebuilding the map - NativeMultiHashMapCollision Avoidance walkthrough, result & comparisonOther papers on Collision Avoidance.Check out the following links to know more about spatial partitioning.en.wikipedia.org/wiki/Space_partitioningQuadrant System in Unity ECS -youtube.com/watch?v=hP4Vu6JbzSoQuad Tree - youtube.com/watch?v=OJxEcs0w_kE*** Music - Please - Wayne Jones***
Number Sequences On Spirograph Pattern - Unity DOTS Forging Station 2020-09-26 | I got side-tracked!!While I was working on the collision avoidance system I experienced crashes at regular intervals no matter how I tweaked my settings. The basic system itself was working but it somehow failed to scale.I had no idea what was going on and I started researching but ended up doing this. But it was quite fun though - visualizing number sequences on a spirographic equations.There are 15000 spheres here all successively positioned at exact coordinates to form deterministic patterns. Strange as it may sound, it was near impossible to get these kinds of shapes and change them with random numbers. Only with number sequences and some initial conditions gave me these amazing results.I will revisit these and fractal patterns at a later point. For now, have fun watching these beautiful mathematical shapes!!***************************************************************Source code - github.com/ForgingStation/Number-Sequences-On-Spirograph-Pattern---Unity-DOTSSpirograph demo -desmos.com/calculator/kyzhoelm2tInteger sequence WIKIen.wikipedia.org/wiki/Integer_sequence****************************************************************
AI Car Navigation using DOTS based Nav-Mesh Query - Unity ECS/DOTS Forging Station 2020-09-12 | In this video, we will talk about how we can integrate the newly built Unity-DOTS based pathfinding into our existing hybrid ECS AI car. The NavMesh Query can be integrated to nay AI car if you wish to replace the classic navigation system We can spawn the entitles necessary for pathfinding, attach it to the AI car and we are good to go!! All we have to do is iterate through Dynamic Buffer containing path stored as waypoints and steer towards subsequent targets. This gives us a lot of control over how we can tune and achieve interesting behaviours as the entire path is accessible without making any method calls.*************************************************Terrain textures - textures.comProcedural Terrain - Map Magic 2- assetstore.unity.com/packages/tools/terrain/mapmagic-2-165180*************************************************
DOTS Pathfinding with NavMeshQuery - Implementation - Unity ECS Forging Station 2020-08-29 | In this video, we will explore one of many ways to implement a multithreaded burst-compiled pathfinding solution using Unity's experimental but highly performant NavmeshQuery API. DOTS based pathfinding using NavmeshQuery is highly performant. There is an in-detail comparison of classic and DOTS based navigation here - youtu.be/1YtkeGDWuC8 We will be building upon the already existing entity spawner system - youtu.be/2IYa1jDGTFs There is plenty of room for optimization especially if you cannot reuse cached path as frequently as this / if you want to squeeze out as much performance as you can. To highlight these areas, I would alter unit system class to use entity-command buffer instead of entity manager so caching and retrieving can happen in a parallel job. You might have to reconsider while using the Unit buffer, more so if you are ever going to implement DOTS navigation on handheld devices as you need to keep a lower memory footprint. Here the same path is copied over to multiple entities which is a huge red flag on devices with low memory. We can retrieve the path from our dictionary and iterate over waypoints for many entities. This might require NativeHashMap as we are moving entities in a parallel job.Another aspect that is missing here is exceptional handling, which has to be implemented so we can know if a path calculation failed and for what reason, so we can retry pathfinding.Last but not least - NavmeshQuery is still experimental. API calls / the API itself might change in the future. I will try and update it when it happens.******************Source Code - github.com/ForgingStation/NavMeshQuery-ImplementationPath Utils class - github.com/Unity-Technologies/UniteAustinTechnicalPresentation/blob/master/StressTesting/Assets/Scripts/Utils/PathUtils.csGeometry Utils class - github.com/Unity-Technologies/UniteAustinTechnicalPresentation/blob/master/StressTesting/Assets/Scripts/Utils/GeometryUtils.cs******************Again, Do not forget to have a look at this - github.com/zulfajuniadi/unity-ecs-navmesh which helped me a lot in understanding how NavMeshQuery needs to be used!!!
Spawn Grid Of Entities In Jobs Context - Fast!! - Unity ECS/DOTS Forging Station 2020-08-22 | In this short video, we will look at one of the simplest ways to spawn entities from within (parallel) Jobs context - in a grid patternWe will be using Entity Command Buffer to record all the structural changes and playback all the events in the predefined sync point. We will build upon this when we develop the DOTS Navigation (NavMeshQUery) system. I have kept the explanation as simple as possible with regards to Burst compiler and Entity Command Buffer. Please go through the Unity Documentation if you need to know more - especially about command buffers as they are extremely helpful and also a very good practice to follow. Performing structural changes using Command buffers enables us to use burst compiler even on the main thread if need be. Synchronous compilation attribute not only works before frame-0 but in general it is used to make sure the burst compilation happens before the job is scheduled. If not, normally it would happen asynchronously - loosely speaking during the gameplay.
Unity DOTS Vs Classic Navigation - Pathfinding With New NavMeshQuery Forging Station 2020-08-15 | In this video, we will be comparing Unity's robust classic navigation with experimental but highly performant DOTS based navigation using the NavMeshQuery API for pathfinding.The DOTS based pathfinding calculations here is burst complied and multithreaded, which means it will execute on all threads if there is a need and whenever possible. Jobs are not completed one after the other, instead, they are all completed, and then the result is processed. This means, "Complete" is called only once per-frame making this bit more efficient. This aspect differs from other online repositories one might find.We will dive deeper into the implementation in the subsequent video.I was able to route 100000 units without caching which means path calculation was done for every unit spawned before the framerate dropped below 30fps.DOTS and Navmesh query is still in the preview & experimental phase at this stage respectively. I will update this in the future if things change significantly.************************************************************************This link helped a lot in understanding how to use NavMeshQuery - github.com/zulfajuniadi/unity-ecs-navmesh.************************************************************************
Can a car carry water?!! Playing with - nvidia - Flex - Fluid Simulation - Unity Forging Station 2020-08-01 | In this video, we will play with Nvidia Flex - Plugin in Unity. This can be freely downloaded from the Unity asset store. I was fascinated by the flexibility and performance of the fluid simulation system in Nvidia - Flex and tried to carry water across the humps using a towing water tank configuration. The water tank is towed across using a Hinge joint. I don't think fluids exert force on classic Rigidbody nor do they weight unless we somehow add Rigidbody component to them. Please do let me know if we can somehow add mas to these particles as it would make this even more interesting.
How to flip an AI car right side up? Unity Hybrid-ECS/DOTS Forging Station 2020-07-25 | In this short video, we will implement a very basic vehicle reset/flipping system which can flip our car back upright after it topples. We are going to deduce the orientation of our vehicle using the dot product. We are already passing the local to world Matrix from which we could have figured the necessary local transform direction - upward pointing direction. Fortunately, this time Unity has a struct that can do this job for us. Now that we have a hook to figure if our vehicle has toppled, we will simply reset the rotation to that of initial rotation. we can make it aesthetically more pleasing and accurate if necessary, by lerping the rotation values & orienting vehicle to current forward direction etc., but we won't make this too complicated herePlease watch my previous videos to get a better understanding of the system we have implemented so far.This is an excellent use case demonstrating how classic Game Objects can be mixed with Unity ECS/DOTS in a hybrid fashion to achieve desired behaviour.Unity Hybrid-ECS/DOTS Car Controller - youtu.be/f0viJi8vi5IAI Car - Unity Hybrid ECS/DOTS - youtu.be/qjfjdYVKQu0AI Car Testing on a Massive terrain - youtu.be/L7Uhk9zhEjo*************************************************Terrain textures - textures.comProcedural Terrain - Map Magic 2- assetstore.unity.com/packages/tools/terrain/mapmagic-2-165180Wheels - assetstore.unity.com/packages/3d/vehicles/land/tire-pack-147202*************************************************
Can AI cars finish the race? Unity Hybrid-ECS/DOTS - Testing Forging Station 2020-07-18 | How far can AI cars go? Is there a bug on our logic? How many cars can our code handle?Well, there is only one way to find out!!In this video, we will be testing the development we did so far, on a massive scale. We will have 50 of our Unity - Hybrid-ECS AI cars, all racing towards a common destination which is on the other side of this massive 100 sqkm (~ 62 sqmi) terrain. The purpose here is to identify loopholes, performance issues, and areas we can enhance. Although the speed is not physically accurate as we are not using time.deltatime - not yet - to calculate our achievable speed, this setup should test our development pretty well.We will also review our upgraded vehicle/car with a brand new set of wheels and a wider body, which will place our wheel colliders further apart and slightly increasing the overall stability.We will explore how Unity's inbuilt Navigation agent works on large terrain/landscape and talk about other issues we get while running the game.We will also shortlist all the issues we find in our gameplayHere are the links to previous videos which will help you understand how we came to this point -AI Car - Unity Hybrid ECS - youtu.be/qjfjdYVKQu0Unity Hybrid-ECS Car Controller - youtu.be/f0viJi8vi5IThink of it as a gameplay - walkthrough and review of the game we developed. Hope you have fun watching AI cars driving around!!*************************************************Terrain textures - textures.comProcedural Terrain - Map Magic 2- assetstore.unity.com/packages/tools/terrain/mapmagic-2-165180Wheels - assetstore.unity.com/packages/3d/high-detail-1970-s-supercar-wheel-92408*************************************************
Unity Hybrid-ECS/DOTS Car Controller Forging Station 2020-07-04 | In this video, we will explore one of many ways to build a player car controller/vehicle controller in Unity using the Hybrid DOTS-ECS approach. We will also have our vehicle pull a trailer with a heavy payload over a set of obstacles. We will be using classic Rigid Body and Wheel Colliders, and ECS to accept player input and process them to derive necessary drive parameters.We will also see how to move data in and out of ECS world from classic Game Object Monobehaviour world. (Interaction with ECS world).At the point of this recording, DOTS is still in preview, hence, for now, we will prioritize on carrying out the essential mathematical operation in Unity-ECS.This is an excellent use case demonstrating how classic Game Objects can be mixed with Unity ECS/DOTS in a hybrid fashion to achieve desired behaviour.**Source Code & Project files can be found here **github.com/ForgingStation/Unity-Hybrid-ECS-Car-Controller
