Learn Unity'S Entity Component System To Optimise Your Games

What you'll learn
Take existing Unity projects created without the use of DOTs and convert them to employ parallel processing and the entity component system.
The advantages and disadvantages of using DOTs.
Requirements
Students should have a strong working understanding of the Unity game engine.
Students should be proficient in C#
Description
Unity's new Data-Oriented Technology Stack (DOTS) and Entity Component System (ECS) programming paradigm have been developed to optimize game development and open up new ways of accessing memory and parallel processing for developing high-performance C# code that takes advantage of contemporary multicore computers. Through the use of the Burst Compiler, your game programs become native code, able to run faster on multiple threads thus pushing the boundaries of the size of your virtual environments and the simultaneous processing of tens of thousands of game objects.In this course, Penny demystifies Unity's new DOTS architecture and introduces intermediate Unity users to ECS by upgrading classic Unity projects and developing a multitude of examples of the use of DOTS concentrating on the most popular game mechanics. Using her internationally acclaimed teaching style and knowledge from over 25 years working with games, graphics and having written two award-winning books on games AI, Penny will take you from familiar object-oriented programming and upgrade your skill to the more memory efficient and optimized entity component architecture. Throughout, you will follow along with hands-on workshops designed to take you through every step of becoming familiar with ECS. You will build on numerous scenarios that examine the basics of ECS programming through the new DOTS-specific math and physics libraries.While DOTS is still in preview, this course aims to assist you in understanding how it works and how games are constructed with it. The knowledge you obtain will further your ability to decipher future released Unity ECS tech demos and handle API updates.This course requires Unity 2019.3.0f6. and the Hybrid Renderer Package 0.3.3.Learn how to program and work with:Entities and ComponentsThe C# Job SystemsCollision SystemsTrigger SystemsUser Input to Control EntitiesInterfacing with classic Unity and game objects to entity-based systems.Contents and OverviewThe course begins with a section that compares the old way of working with game objects in Unity, through to the creation of a complete ECS system using the exact same scenario in each instance to give you time to compare the programming methods and optimizations gained through implementing DOTS.Following this, you will dive deeper into the creation and debugging of entities while learning how to tag, identify and add data to them with custom components. You will also learn how to find entities once they are injected into the game environment and to access and manipulate them at runtime.After you've become comfortable with the nature of entities, you will discover how the new math library can be used to replicate many of the functions you've become familiar with in the Unity Mathf API. The content will cover transformation, rotations, slerps, pivoting, following waypoints and pursuing and fleeing from targets. A space-based scenario will be created with several planets and thousands of spacecraft programmed to attack, by generating even more thousands of bullets and finally explosions.Next, you'll build a blocky Minecraft inspired landscape from cubes that can be infinitely generated in any direction by implementing Perlin Noise and examining how parallel processing (achieved through the C# Jobs system) dramatically speeds up processing that has in the past been limited to the main thread.On completion of this exercise, a thorough examination of the new DOTS physics capabilities will take place. All the classic Unity elements you've become used to will be replicated via the new physics API and ECS job systems. You will learn about collisions, triggers, camera tracking, bullet physics and the basics of recreating Newtonian physics for moving dynamic and kinematic entities.The course ends with a challenge and project to recreate a third person shooter in which a single player takes on a swarm of zombies.At the completion of this course, you will be familiar with DOTS and the ECS and be able to further your skills by interpreting and making sense of the Unity tech demos as they are released, presenting updated API and introducing more and more functionality into DOTS.What students are saying about Penny's courses:Excellent course!! I am already in game development industry and there is one quote here that "Whenever you are not able to solve complex problem, its the right time to get back to the BASICS"She is the best teacher ever in this platformMost instructors are very smart people. Some are good at teaching and some are not. Penny is great at describing complex concepts without going down a dark cerebral rabbit hole that so many instructors feel obligated to do. It's like they need to demonstrate their knowledge by explaining every tiny aspect. Penny does not go there. She explains things clearly but does not overwhelm the student with more than they need to know.
Overview
Section 1: Introduction
Lecture 1 Welcome
Lecture 2 What Version of Unity Should I Use?
Lecture 3 What Version of Unity Should I Use 2.0.
Lecture 4 Information Relevant to this Course
Lecture 5 Join the H3D Student Community
Lecture 6 Contacting H3D
Lecture 7 FAQs
Section 2: DOTS in a Nutshell
Lecture 8 Understanding DOTS
Lecture 9 Comparing the Old & the New Part 1
Lecture 10 Comparing the Old & the New Part 2
Lecture 11 Comparing the Old & the New Part 3
Lecture 12 Comparing the Old & the New Part 4
Lecture 13 Comparing the Old & the New Part 5
Lecture 14 Your First ECS Challenge
Lecture 15 Parallel Computing
Lecture 16 Structures, Classes and Blittable Types
Section 3: Working with Entities
Lecture 17 Creating and Debugging Entities
Lecture 18 Accessing and Modifying Entity Data
Lecture 19 Adding IComponentData Challenge
Lecture 20 Performing Entity Queries
Lecture 21 Entity Query Interface Challenge
Lecture 22 Adding an Entity from Monobehaviour at Runtime
Lecture 23 Constructing an Entity from Scratch
Lecture 24 Constructing Sheep Entities from a Mesh Challenge
Section 4: Transformation Mathematics in DOTS
Lecture 25 Performing Translations
Lecture 26 Performing Rotations
Lecture 27 Performing a Slerp to Face a Target
Lecture 28 Rotating Around a Pivot Point
Lecture 29 Pivoting Challenge
Section 5: Working with Custom Components
Lecture 30 Getting Player Transformations into Entities
Lecture 31 Adding and Setting Data Values in a Custom Components
Lecture 32 Updating Custom Component Values
Lecture 33 Waypoint Follow Challenge
Section 6: Project: Space Wars Simulation
Lecture 34 Finding Closest Planet
Lecture 35 Attacking and Retreat Movement
Lecture 36 Spawning an Entity from an Entity Part 1
Lecture 37 Spawning an Entity from an Entity Part 2
Lecture 38 Spawning Entities from Another Location Part 1
Lecture 39 Spawning Entities from Another Location Part 2
Lecture 40 Restricting the Lifetime of an Entity
Lecture 41 Restricting the Lifetime of an Entity Update
Lecture 42 Implementing Line of Sight in an Entity
Lecture 43 Faking Collisions
Lecture 44 Instantiating Explosions
Lecture 45 A System for Scaling Particles
Section 7: Project: Infinite Cube World
Lecture 46 Creating a Landscape with Cubes
Lecture 47 Using Perlin Noise for Height
Lecture 48 Enhanced Perlin Heights
Lecture 49 Changing Materials on an Entity
Lecture 50 Identifying Bottlenecks and Solutions to FPS Drop
Lecture 51 Scrolling the Landscape with the Player
Section 8: DOTS Physics
Lecture 52 The Physics Components
Lecture 53 An ECS Physics-Based Character Controller
Lecture 54 Spawning Multiple Physics Entities
Lecture 55 Shooting Physics Bullets Challenge
Lecture 56 Moving a Bullet with Physics
Lecture 57 Upgrading a Package
Lecture 58 Detecting Collisions
Lecture 59 Using Custom Values in a Collision Event
Lecture 60 Destroying an Entity on Collision
Lecture 61 Entity Tracking with the Camera
Lecture 62 Detecting Physics Triggers
Lecture 63 Converting to a Dynamic Character
Lecture 64 Using Custom Values in a Trigger Event
Section 9: Raycasting
Lecture 65 Starting with a Tower Defence Setup
Lecture 66 Performing a Raycast Hit Part 1
Lecture 67 Performing a Raycast Hit Part 2
Lecture 68 Destroying an Entity Hit by a Raycast
Lecture 69 Performing Raycast Distance Hits P1
Lecture 70 Performing Raycast Distance Hits P2
Lecture 71 Locating and Following The Closest Physics Entity
Lecture 72 Destroying Tracked Physics Entity
Lecture 73 Destroying Zombie Challenge P1
Lecture 74 Destroying Zombie Challenge P2
Section 10: Final Words
Lecture 75 Some Final Words from Penny
Lecture 76 Where to now?
Professionals and students who are comfortable using Unity but would like to upgrade their skills to implement the new Unity DOTS system.

Homepage

https://www.udemy.com/course/unitydots/