Autoplay
Autocomplete
Previous Lesson
Complete and Continue
The Unreal Engine Developer Course - Learn C++ & Make Games
First Section
00. Promo Video (1:46)
02. Welcome to the Course (5:27)
03. A Note On Unreal Versions (1:50)
04. Setup Visual Studio or XCode (4:07)
05. Unreal Development Environment (7:25)
06. Intro to Visual Studio 2015 on PC (7:34)
07. Intro to Xcode on MacOS (5:12)
08. How to Ask Good Questions (10:58)
09. A Quick Tour of Unreal Editor (9:46)
10. Section 1 Wrap-Up (2:43)
11. Instructor Hangout (5:19)
Section 2
01. Intro, Notes & Section 2 Assets (3:03)
02. Bull Cow Game Overview (5:33)
03. S02 Game Design Document (GDD) (6:56)
04. How Solutions & Projects Relate (11:09)
05. C++ Function Syntax (7:53)
06. Using, #include and Namespaces (11:34)
07. Magic Numbers and Constants (7:21)
08. Variables and cin for Input (10:00)
09. Using getline() (5:03)
10. Simplifying With Functions (11:42)
11. Iterating With For & While Loops (8:08)
12. Mid Section Quiz (4:52)
13. Clarity is Worth Fighting For (10:19)
14. Booleans and comparisons (11:33)
15. Using do and while in C++ (6:44)
16. Introducing Classes (2:59)
17. Using Header Files as Contracts (11:35)
18. Including Our Own Header File (9:37)
19. Instantiating Your Class (7:00)
20. Writing & Using Getter Methods (9:00)
21. Introducing the Const Keyword (6:20)
22. Constructors For Initialisation (7:50)
23. Pseudocode Programming (9:07)
24. Using using for Type Aliases (9:41)
25. Using struct for Simple Types (10:01)
26. Using if Statements in C++ (13:49)
27. Debugging 101 (7:39)
28. A Place for Everything (7:06)
29. Introducing enumerations (9:55)
30. Writing Error Checking Code (9:17)
31. Using switch Statements (11:57)
32. Warm Fuzzy Feelings (6:31)
33. Handling Game Win Condition - Part 1 (7:58)
34. Win or Lose "Screen" (6:07)
35. Introducing Big O Notation (11:49)
36. TMap and map Data Structures (11:09)
37. Range-Based for Loop (8:58)
38. Design a Helper Function (8:47)
39. Playtesting Your Game (7:59)
40. Difficulty & Play Tuning (9:35)
41. Polishing & Packaging (8:35)
42. Section 2 Wrap-Up (1:17)
Section 3
01. Intro, Notes & Section 3 Assets (2:12)
02. S03 Game Design Document (GDD) (2:50)
03. Building Escape Overview (4:35)
04. Version Control 101 (6:42)
05. Ignoring Unreal Derived Files (8:45)
06. Your First .gitignore for Unreal (11:27)
07. Getting to Know Unreal’s Editor (8:23)
08. A Pointers Primer (5:40)
09. Unreal’s Class System (13:04)
10. Cloning and Building Our Code (17:25)
11. Runtime Messages for Feedback (7:18)
12. Accessing Object Names (10:45)
13. Include What You Use For 4.17+ (16:37)
14. Getting Transforms in C++ (12:59)
15. Moving Objects With C++ (12:00)
16. Laying Out Geometry (14:27)
17. Applying Materials (8:38)
18. Macros Starting with UPROPERTY (9:53)
19. Using Trigger Volumes (10:14)
20. Unreal’s PlayerController (10:27)
21. Using Collision Volumes (9:41)
22. Using GetTimeSeconds() (11:27)
23. Grabbing System Overview (5:32)
24. Modifying the Default Pawn Actor (7:28)
25. Inherit Game Mode Blueprint (7:05)
26. Getting Player Viewpoint (12:42)
27. Using DrawDebugLine (12:10)
28. Line Tracing AKA Ray-Casting (10:15)
29. LineTraceSingleByObjectType() (12:03)
30. REFERENCES & POINTERS (14:34)
31. Resetting Your Unreal Project (6:40)
32. Using FindComponentByClass() (8:59)
33. Introducing Input Binding (12:08)
34. Accessors & Memory Layout (9:25)
35. Reducing Code in “Hot Loops” (13:50)
36. Using Physics Handles (12:30)
37. Refactoring Rules (12:25)
38. Introducing Unreal’s TArray (12:07)
39. Iterating over TArray with for (8:27)
40. Debugging Game Issues (7:58)
41. Managing Texture Tiling (8:49)
42. Pointer Protection Process (11:34)
43. Exposing Events to Blueprint (11:36)
44. Using Blueprint Timeline (10:27)
45. Everything in its Place (11:25)
46. Using Variables in Blueprint (8:35)
47. SFX & Audio Clips (6:30)
48. Section 3 Wrap-Up (2:01)
Section 4
01. Intro, Notes & Section 4 Assets (1:05)
02. Battle Tank Overview (3:42)
03. Game Design Document (GDD) (6:09)
04. Setting Up a GitHub “Repo” (10:40)
05. Creating & Deleting Landscapes (10:03)
06. Landscape Setup & Scaling (12:15)
07. A Landscaping Process (10:16)
08. Upgrading Engine Version (5:48)
09. Using Landscape Layers (12:11)
10. Flat Shading Low Poly Landscapes (12:38)
11. More Landscaping Tools (12:10)
12. Tank Control System (7:32)
13. Actors from Multiple Meshes (13:42)
14. Configuring a Tank (9:13)
15. 3rd Person Camera Control (14:16)
16. Fixing 3rd Person Camera Rotation (8:06)
17. User Interface (UI) in Unreal (9:18)
18. Main Menu Screens (9:02)
19. UI Scale Box, Buttons & Mouse (11:13)
20. Controller Ready Navigation (8:25)
21. Trial Packaging Your Game (7:08)
22. Delegating to Components (11:20)
23. Using Virtual And Override (14:04)
24. Overloading and Polymorphism (14:27)
25. Virtual Functions and Vtables (11:20)
26. Creating an AI Controller Class (10:56)
27. Get the Player Controller with C++ (9:35)
28. Add Tick() to PlayerController (11:50)
29. Creating an Out Parameter Method (12:09)
30. Finding Screen Pixel Coordinates (13:48)
31. Using DeprojectScreenToWorld (12:49)
32. Using LineTraceSingleByChannel() (15:24)
33. Unify Player & AI Aiming (10:36)
34. Create Default Sub Objects in C++ (12:07)
35. BlueprintCallable() (13:04)
36. SuggestProjectileVelocity() (11:53)
37. Predict Projectile Landing Point (12:16)
38. Using FRotators in Unreal (10:58)
39. The C++ Compilation Process (7:26)
40. Using Forward Declarations (12:37)
41. BlueprintSpawnableComponent() (10:56)
42. Review Our Execution Flow (13:35)
43. How to Report Bugs (10:47)
44. Using Clamp() to Limit Values (14:18)
45. CHALLENGE - Turret Rotation (12:44)
46. CHALLENGE - Turret Rotation Pt.2
47. Setting Up Projectiles (10:34)
48. Upgrading to Unreal 4.12 (11:04)
49. Working Round Awkward Bugs (13:56)
50. Using SpawnActor() to Spawn (11:36)
51. Projectile Movement Components (11:10)
52. Making AI Tanks Fire (10:30)
53. EditAnywhere vs EditDefaultsOnly (8:37)
54. Adding a Quit Button (11:05)
55. Setup Track Throttles (12:31)
56. ApplyForceAtLocation() in Action (12:03)
57. Physics Materials & Friction (14:16)
58. Fly-by-Wire Control System (8:50)
59. Using BlueprintReadOnly (12:46)
60. A Better Component Architecture (12:04)
61. Completing Manual Tank Movement (11:09)
62. Introducing AI Pathfinding (12:03)
63. Dissecting RequestDirectMove() (12:29)
64. DotProduct() Vector Operator (12:30)
65. CrossProduct() Vector Operator (13:42)
66. Finalising Your Class Code (9:28)
67. How to Use Blueprint Variables (10:10)
68. Using Enum(erations) in UE4 (12:06)
69. Refactoring our Aiming Component (14:52)
70. Attaching a Debugger to Unreal (7:22)
71. Constructor & Begin Play Timing (11:58)
72. Decoupling Your Architecture (9:01)
73. BlueprintImplementableEvent (11:57)
74. Using the ensure Assertion (9:32)
75. Dependency Mapping (9:53)
76. Talking Head - Real World Skills (2:29)
77. Starting From Green (11:10)
78. Aiming Without the Tank (13:57)
79. Finishing our Refactoring (14:04)
80. Adding TickComponent() Back (13:06)
81. Are Two Floats Equal? (11:39)
82. Programmatic Sideways Friction (15:18)
83. OnComponentHit Event in 4.12 (8:36)
84. Avoiding Boolean Flags (13:18)
85. Improving Tank Aiming (11:23)
86. Tweaking Tank AI (12:14)
87. Making an Ammo Display (14:23)
88. Making an AutoMortar (14:10)
89. Using the Reference Viewer (14:10)
90. Preparing for Particles (13:22)
91. Introducing Particle Systems (15:54)
92. Particle Bounding Boxes (6:37)
93. Using FAttachmentTransformRules (16:26)
94. Radial Forces & Caching (14:20)
95. Using GetTimerManager() (10:15)
96. Using TakeDamage() on Actors (15:47)
97. BlueprintPure & Health Bars (14:09)
98. The Observer Pattern (14:19)
99. Finishing Off - Part 1 (14:35)
100. Finishing Off - Part 2 (15:47)
101. Section 4 Wrap-Up (3:14)
102. Bonus - Switching Cameras (6:35)
103. Fixing The Tank Suspension (2:21)
104. Upgrade to 4.19 And Bug Fixes (13:07)
105. Real-world Vehicle Physics (8:51)
106. Creating Physics Constraints (15:45)
107. Making Springs (15:32)
108. Converting The Spring To C++ (11:55)
109. Attachment, Actors and Components (13:31)
110. SpawnActorDeferred and BeginPlay (7:14)
111. Attaching Constraints In C++ (13:09)
112. Chaining Physics Constraints (15:42)
113. Applying Wheel Driving Force (11:29)
114. Solution: Implement GetWheels() (10:26)
115. Tick Groups And Physics (18:20)
116. Tweaking Linear & Angular Damping (11:56)
117. BONUS: Fixing Collider Issues (3:21)
New Lecture
Section 5
01. Testing Grounds Introduction (2:21)
02. Testing Grounds GDD (5:24)
03. Using Git LFS (Large File Support) (15:46)
04. Marketing & Markdown (13:39)
05. Use git clean to Revert Project (11:27)
06. The First Person Character Overview (7:33)
07. The Third Person Character (9:35)
08. Introducing AI Behaviour Trees (8:54)
09. Introducing AI Blackboard Data (10:14)
10. Target Points and Patrol Routes (9:14)
11. Using Any Actor for Waypoints (12:42)
12. Options for Grouping Actors (8:57)
13. Blueprint Behaviour Tree Tasks (14:31)
14. Modular Arithmetic & Cycles (12:45)
15. Performance Profiling 101 (9:22)
16. C++ AI Behaviour Tree Tasks (12:19)
17. Reading Blackboard Data in C++ (9:35)
18. The Consequences of Inheritance (8:36)
19. Converting Blueprint to C++ (12:52)
20. Composition over Inheritance (13:41)
21. Talking Head: What We've Covered So Far (1:34)
22. How to Delete a C++ Class (5:06)
23. Instanced Materials (10:52)
24. Introducing AI Perception (10:50)
25. OnTargetPerceptionUpdated Event (9:47)
26. AI Hearing Perception in Unreal (8:38)
27. The Animation Starter Pack (12:06)
28. Changing a Character’s Animation (11:16)
29. Customising a Character Blueprint (8:27)
30. Sub Behaviour Trees (8:47)
31. Talking Head - Introducing Sam (0:35)
32. Talking Head - Refactoring Superpowers (1:43)
33. Simplifying Our Project (17:34)
34. Renaming & Moving CPP (13:37)
35. Solution: Renaming & Moving CPP (9:44)
36. Holding a Gun with Skeletal Sockets (14:25)
37. Understanding Animation Blueprints (11:03)
38. Creating Animation State Machines (14:04)
39. Movement Blend Spaces (16:11)
40. Offset Animations (18:04)
41. Aiming Blend Spaces Offsets (6:19)
42. Rotating with SetFocalPoint() (9:47)
43. Character Movement vs Rotation (16:19)
44. Control Rotation for Aim (11:59)
45. Behaviour Tree Decorators (11:32)
46. Behaviour Tree Services (12:56)
47. Tweaking AI Behaviour (5:21)
48. Debugging AI Behaviour (14:39)
49. Refactoring to a Gun Actor (15:29)
50. Attaching Actors to Components (13:03)
51. Configuring the Gun (9:48)
52. Moving Files from LFS to Git (13:50)
53. To LFS or Not to LFS? (13:42)
54. Child Actor Components (8:18)
55. IIntroduction to Inverse Kinematics (6:50)
56. Inverse Kinematics with Animations (10:21)
57. Comparing Blueprints with Diffs (10:50)
58. Boolean Blending for Aim States (10:47)
59. Adding Firing Animations (7:57)
60. Animation Notify Events (10:24)
61. Taking Damage in Blueprint (6:44)
62. Death Animations and Refactors (9:55)
63. Switching 1st and 3rd Person (8:13)
64. Owner Invisible Meshes (9:18)
65. Separating Firing from Gun Meshes (9:42)
66. Aiming Our 1st Person Camera (5:44)
67. Architecture of Infinite Runners (11:09)
68. Spawning Terrain in the GameMode (10:09)
69. Level Gating for Testing Grounds (13:13)
70. Swapping Materials in Blueprint (9:31)
71. Garbage Collecting Previous Tiles (8:10)
72. Merging Our TP and FP Files (17:30)
73. Hit vs Overlap Events (11:12)
74. Dynamically Calculating NavMesh (12:56)
75. Keep It Simple Stupid (10:59)
76. Parallel Behaviour Tree Tasks (17:47)
77. Custom BT Tasks and Decorators (16:40)
78. External Build Data in 4.14+ (9:43)
79. Physical Gun Architecture (18:43)
80. Converting a Character BP to C++ (17:36)
81. Who’s Pulled the Trigger? (17:18)
82. Cooldown Nodes & Gameplay Tags (16:25)
83. Animation Montages and Slots (18:06)
84. Reattaching the Gun (20:01)
85. Procedural Level Generation (20:33)
86. Generating Random Numbers (19:00)
87. Spawning Actors in the Tile (15:47)
88. Sphere Casting in C++ (15:51)
89. Configure Custom Trace Channels (11:32)
90. Spawning into Free Space (16:35)
91. Randomising Rotation & Scale (17:21)
92. Flyweight Pattern for Foliage (18:03)
93. Choosing Waypoint with EQS (14:17)
94. Find Actors of Type from C++ (19:33)
95. Plumbing an Actor Pool Setup (19:13)
96. Using the Pool API (19:00)
97. Using TArray for Pools (10:53)
98. Rebuilding Navigation Meshes (15:30)
99. Structs to Simplify Function Args (18:20)
100. Spawning AI from C++ (14:10)
101. Understanding Function Templates (10:39)
102. Template Specialization (9:55)
103. Fixing Double Spawning (17:18)
104. Keeping Score (12:40)
105. Using the HUD Class (12:39)
106. Post Processing For tunnel Vision (10:39)
107. Recruiting Play Testers (14:41)
108. Smooth Blending the Camera (11:25)
109. Processing and The View Target (10:36)
110. The Calm Before The Storm (17:52)
111. Testing Grounds Wrap-up (1:46)
97. Using TArray for Pools
Lesson content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock