Ozzadar - Game Development

In this lesson, we're going to create our vertex and index Vulkan buffers in order to easily create objects on the GPU for future rendering. By the end of this video, you'll have the ability to upload arbitrary mesh data to the GPU and render it on screen. We're going to be removing the triangle from our Vulkan renderer, abstract our file system layer a little bit, and by the end have two differently colored triangles. Github repository: https://github.com/mauville-technologies/youtube-engine/commit/7d1494b9c2bb89cb182e4a175f420add59287b15 Appreciate the content? Show your appreciation here: https://paypal.me/ozzadar Chapters: 00:00:00 Intro 00:00:50 Adding Vulkan Memory Allocator dependency 00:04:27 Describing the desired interface 00:15:04 Creating Vertex/Index Buffer abstract classes 00:19:51 Creating Vertex data type 00:22:00 Filling Vertex data from shaders 00:24:40 Renderer Implementation for Vulkan 00:26:21 Vertex/Index Buffers Vulkan implementation 01 00:42:15 Creating Vulkan Memory Allocator 00:49:17 Vertex/Index Buffers Vulkan implementation 02 01:15:26 Updating vertex shader source 01:18:41 Silencing VMA clang warnings 01:20:04 Creating Vulkan Vertex Bindings and Attributes 01:33:27 BONUS: updating vk-bootstrap dependency

In this lesson, we're going to create our Vulkan Shader abstraction which will allow us to instantiate and use multiple shaders at a time within our application. We're going to be removing the shader code from our vulkan renderer, abstract our file system layer a little bit, and by the end have two differently colored triangles. Github repository: https://github.com/mauville-technologies/youtube-engine/commit/4b5eed2cf8a6c422ea88c87649688185808647f9 Appreciate the content? Show your appreication here: https://paypal.me/ozzadar

In this lesson, we're going to make a few adjustments to the codebase in order to compile and run our Vulkan renderer on Mac OSX using MoltenVK. This will complete the process for ensuring that the engine runs on all three desktop platforms: Windows, OS X and Linux. Join me next time when we create our shader abstraction and start doing a lot more interesting things! Github repository: https://github.com/mauville-technologies/youtube-engine/commit/aa403f2a9858329747d490d880665f19fbc3995d Appreciate the content? Show your appreication here: https://paypal.me/ozzadar

Recently we outsourced the building of our corporate website. While overall I think it did fairly well, there are some things that I want to change over time which requires me to figure out how Django works. I would also like to dockerize the entire thing and build a deployment pipeline around it.

Last stream it was pointed out to me that quality settings weren't set up correctly. I went through and changed some settings and am giving this a shot now. Will be playing Super Mario World and answering random programming related questions if there are any. Channel Discord can be found here if you need to reach me directly: https://discord.gg/QnyRAtGQrf

In preparation for a Game Jam we're throwing on the SNHU CS Hangout Discord, I'll be showing some basic game development concepts, flows and answering questions. Our SNHU CS Hangout Discord channel can be found here: https://discord.gg/YymQ4SpkRA Channel Discord can be found here if you need to reach me directly: https://discord.gg/QnyRAtGQrf

I have received many questions and requests around my previous Google Play Services and Android Exports lessons. Specifically in implementing them in Godot 3.3. Due to the volume of requests, I thought it was time to put out an updated guide for the newer version. In this lesson, we create a new Godot 3.3 project, configure Android Exports and follup by enabling and configuring the Google Play Services plugin. Godot: https://godotengine.org OpenJDK: https://adoptopenjdk.net Plugin: https://github.com/mauville-technologies/PGSGP Chapters: 00:00 Intro 01:30 Acquiring the Engine and export templates 02:30 Creating the Project 04:12 Creating debug keystore 08:00 Configuring Android Exports 11:38 Adding basic project files 13:45 Installing Google Play Service Plugin 20:30 Configuring App on Google Play Console 33:00 Writing Scripts for Signing into Google Play 43:30 TIPS FOR ERROR 4 44:45 Creating builds for Google Play Store

In this lesson, we build upon the knowledge we gathered last time to create a more full-featured c++ chat application by abstracting the forward compatible networking TS stuff from the Boost library into our own networking stack. Next time, we'll look at transmitting data objects in order to give ourselves the ability to parse user data and have proper MUD game interactions. Chapters 00:00 Introduction 00:56 Repository 01:15 Recap + Minor refactor 03:00 Fleshing out the TCP Server 13:45 Telnet for testing 15:00 TCP Connections on the server 33:15 Broadcasting messages 37:34 Writing the chat server with our library 49:55 Adding a TCP Client class to the library 01:07:41 Writing our chat client

What's up guys? In this lesson, I add an SDL Windowing class to the engine in order to prepare for Android and Web exports in future videos. I show off an example project with Desktop, Android, and Web support using SDL that you can use immediately. In a future video, we will properly implement the Android and Web exports as well as add OpenGL support! SDL: https://github.com/libsdl-org/SDL Github Repository: https://github.com/mauville-technologies/youtube-engine Chapters: 0:00 Intro 01:10 Cite your sources! 02:25 Android, SDL and Desktop toy engine showcase 07:43 Adding SDL window class to Youtube Game Engine 24:56 Future plans

Support the stream: https://ozzadar.live Adding music, fixing bugs, and polishing my Godot Android game with Google Play integration.

Support the stream: https://streamlabs.com/ozzadar0 Knocking off some random development tasks I've been meaning to tackle for awhile now. - New Godot Dragonbones binaries - Play Services plugin bugfix -

Support the stream: https://streamlabs.com/ozzadar0 Knocking off some random development tasks I've been meaning to tackle for awhile now. - New Godot Dragonbones binaries - Play Services plugin bugfix -

In this lesson, we go over the basics of network communication by creating a simple TCP Client and TCP Server using the Boost ASIO C++ libraries. Due to the libraries being incompatible with C++ 20 modules, I walk you through the process of creating a new CMake project, downloading and including the libraries and then building out a basic "Hello, Network" application that sends a message to a client that connects to the server. In future lessons, we'll expand on these applications as we delve into the various C++ topics with the end goal being to create a MUD (Multi-User Dungeon) application. Chapters 00:00:00 So our story begins... 00:01:24 Setting up the CMake project 00:10:30 Adding the Boost library to our project 00:16:17 Creating a simple tcp server 00:24:00 Creating a simple tcp client 00:32:58 TCPServer class 01 | Building our Networking Library 00:46:15 TCPConnection class | Building our Networking Library 00:55:15 TCPServer class 02 | Building our Networking Library 00:58:49 Double checking and housekeeping (shared_from_this) 01:01:49 Using our library to create our tcp server 01:03:38 Testing client + server 01:05:05 Persistent Connections 01:09:47 Detecting dropped TCP connections 01:13:17 Potential Enhancements (Future videos) 01:19:26 Thanks for watching ( plz dont skip =] )

In this lesson, we implement a fully-featured input manager with controller, keyboard, and mouse support in GLFW into our C++ cross-platform YouTube game engine. This system provides support for mapping inputs to actions similar to the input systems in Unreal Engine, Unity, and Godot. I'll explain the theory behind the system, design an interface and then we'll jump in and implement the solution to completion. Next time, we'll continue working on our Vulkan renderer in order to see these inputs in action on screen. Chapters: 00:00:00 Intro 00:02:15 Feature Explanation (Software Engineering 01) 00:07:00 Interface Design (Software Engineering 02) 00:19:30 Offline Changes 00:21:00 Action Mapping System 00:39:50 Extending the Service Locator 00:49:27 Storing Input Device State 00:55:40 Main Input Loop (Generating Action Events) 01:17:30 Registering Input Devices with Input Manager 01:21:30 GLFW integration 01 (Keyboard + Mouse) 01:42:15 Debugging Session 01 (Bug fixes) 01:46:35 GLFW integration 02 (Keyboard + Mouse) 01:56:50 Verifying Implementation ( validating the flow + tweaks) 02:00:50 Using the Input Manager from our Game 02:20:35 Detecting Gamepads and Controller Input in GLFW 02:33:00 Debugging Session 02 (Some idiosyncracies with GLFW) 02:46:55 Collecting Gamepad State (buttons and axes) 03:05:24 Using Controllers in our Game! (IT WORKS!) 03:11:45 Conclusion, Next Steps, Homework ( plz don't skip thanks =] )

Hello everyone! This video will give you an abbreviated version of how I became a software engineer and professional game developer with no cs degree. Thank you for 1000 subscribers! I have hesitated to share my background through YouTube but had decided a while ago that I would start some talking-head pieces when I reach 1000 subscribers. My schedule moving forward will focus on a rotating, 4 series schedule. 1) Godot Android Game Development 2) Cross-Platform Game Development (Vulkan) 3) C++ in 2021 4) A more personal, less instructional series. The exact format hasn't been decided but will address more of the soft skills involved in software engineering and game development. What this means for you, is that each series should get a new entry roughly once a month considering my currently weekly upload schedule. Links to various things: DreamDesk VR (don't buy it): https://store.steampowered.com/app/520210/DreamDesk_VR/ Multiplayer 3D Platformer Course: https://www.youtube.com/watch?v=1kdPpG1PPns Chapters 00:00 Intro 00:40 Personal Background 01:32 Moving to Vietnam 04:00 First Technologies and "Real" Development Experience 06:35 Freelancing 08:20 Desktop VR Developmnet 09:39 Getting Married 10:20 Creating Unreal Engine Courses 11:05 Getting My First "Real Job" as a Software Engineer 12:29 Losing My First "Real Job" =D 13:40 Cisco baby! 14:45 Professional Game Developer! (wut wut) 15:25 Advice For Making a Career Change

In this lesson, we finally add AdMob monetization into our Godot Android application! Follow along to learn how to implement AdMob banner ads, interstitials, and even rewarded ads! Admob plugin: https://github.com/Shin-NiL/Godot-Android-Admob-Plugin Admob Dashboard: https://admob.com/ In the next lesson of the series, we'll go through the process of releasing our little game to the Google Play Store. Due to the review processes involved, this may mean a slight delay before the next lesson in this series. Thanks for understanding :) Chapters 00:00 Introduction 00:35 Admob Application Setup (Account) 07:45 Godot Admob Plugin Setup 19:00 Interstitial and Banner Ads 28:17 Rewarded Ads

In this lesson, I introduce the C++ standard thread library by showing you how you can build a concurrent queue system. We'll build upon this queue system in future lessons to achieve a multiple thread queue with thread pools and data sharing. C++ in 2021 Github: https://github.com/mauville-technologies/cppin2021/releases/tag/tutorial-05 Reference Material: C++ Concurrency in Action: https://amzn.to/3iuSGLd Chapters: 0:00 Intro 1:10 Github Repo 1:50 TaskManager Module Interface 4:50 Main Command Loop 11:35 std::thread basics 18:05 Implementing the Command Queue 31:00 Closing a thread / RAII 34:10 Joining threads ( Learning as we go ) 39:50 Demonstrating the Queue concurrency 42:00 Detaching Threads + Daemon Threads ( + live experimentation)

In this lesson, we create our first Vulkan GLSL Shaders, set up CMake to automatically compile them with the build, and render our first triangle! In the next lesson, we will build out our basic input manager to demonstrate swapping out Vulkan Pipelines and set us up for camera controls in the future! Screenshots extracted from Real Time Rendering 4th Edition: https://amzn.to/3r5vk2I Heavily referenced VkGuide.dev: https://vkguide.dev/docs/chapter_2 Source code for this lesson: https://github.com/mauville-technologies/youtube-engine/releases/tag/tutorial-04 Chapters: 0:00 Intro 1:13 Vertex and Fragment shaders 8:30 Compiling Shaders (environment variables) 10:45 Compiling Shaders (CMake) 15:00 Load Shaders into Engine 26:50 Pipeline Builder (part 01) 30:40 Struct Initializers 48:00 Pipeline Builder (part 02) 55:05 Pipeline Layout 1:00:00 Create Triangle Pipeline 1:08:15 Draw MonoColor Triangle 1:09:30 Object Cleanup 1:11:35 Set Up Rainbow Triangle 1:16:30 RAINBOW TRIANGLE!!

In this lesson, I show you how to implement android achievements in Godot!. We go over hidden achievements, incremented achievements, and everything else you'll need for your own implementation in Godot. We take a more live-coding approach to development this week due to time constraints for this one. Hope you understand! Feel free to ask any questions if I accidentally edited out something important while trimming out debugging times! Chapters: 0:00 Intro 0:50 Google Play Console 5:09 Show Achievement List 11:35 Unlock First Achievement 15:23 Hidden + Step Achievements 20:55 Incremental Achievement 24:15 Complete API Summary Descriptions

In this lesson, I guide you through using c ++ function pointer and lambdas to store and invoke callbacks from anywhere in your applications. This is demonstrated through a mock Input Manager that you might find in a game engine implementation. We start off by mocking out the manager, support accepting c ++ function pointers and then enhancing the class to accept a wider set of functions using std::function and lambdas. Professional C++ by Marc Gregoire: https://amzn.to/3h4HGmW Chapters: 0:00 Intro 1:10 Designing the implementation 3:25 Creating the InputManager class 6:10 C Function Pointer 7:54 Continuing InputManager Implementation 11:15 Demonstrating Callbacks (Function Pointer) 15:20 std::function 16:50 std::bind - Binding object member function 23:45 C++ Lambdas (introduction, templates, auto) 31:45 Bound Lambdas (capturing `this`) 34:01 BONUS -- Blocking Input layers ___ Godot Dragonbones is a custom Godot engine build with the godot_dragonbones module that I am maintaining and distributing. It provides full-featured, 2D Skeletal animation support for the DragonBones API; a free, open source alternative to Spine: 2D Skeletal Animation. PLEASE SUBSCRIBE! https://cutt.ly/zdCef9v JOIN OUR DISCORD: https://discord.gg/bXMkFsg DONATE HERE: https://cutt.ly/zdCnvmj GET GODOT DRAGONBONES HERE (Windows, Linux, Mac): http://godotdragonbones.com Godot-Dragonbones module included with this build of engine: https://github.com/mauville-technologies/godot-dragonbones If you're interested in using this in your projects but would like more guidance, leave a comment letting me know what you'd like me to explain next.

Finally, we reach one of our bigger lessons: Intro to Vulkan. This time, I provide a fairly in-depth intro to the Vulkan API and go through the process of adding a Vulkan renderer to our game engine. I thought about splitting this beast into multiple videos, but figured Youtube's Chapter system does a good enough job of allowing you to jump around to what you're looking for. Application Repository: https://github.com/mauville-technologies/youtube_project/releases/tag/tutorial-03 Engine Repository: https://github.com/mauville-technologies/youtube-engine/releases/tag/tutorial-03 Heavily referenced: https://vkguide.dev Check out these books! Professional C++: https://amzn.to/3gz2mo5 Game Engine Architecture: https://amzn.to/3vwT9Rh Realtime Rendering: https://amzn.to/3cJMAo7 Chapters: 0:00 Intro 2:59 Getting Libraries 9:15 Vulkan Window 14:03 Detour: Namespacing 16:55 Renderer Interface 19:03 Provide Renderer Service 24:03 Vulkan Renderer Class 26:50 Setting up Render loop 30:45 Vulkan Helper files 37:08 Initialize Vulkan Core 1:02:11 Summary: Vulkan Core 1:02:40 Create Swapchain 1:12:24 Live Debugging =D 1:16:56 Summary: Errors we just fixed 1:17:51 Clean up on shut down 1:22:31 Command Queue, Pool, and Buffer 1:37:00 Setup Render Pass 1:47:00 Summary: Render Pass 1:49:31 Create Framebuffers 1:58:43 Render Frames (Clear Colour!) 2:24:38 It Renders! ___ Godot Dragonbones is a custom Godot engine build with the godot_dragonbones module that I am maintaining and distributing. It provides full-featured, 2D Skeletal animation support for the DragonBones API; a free, open source alternative to Spine: 2D Skeletal Animation. PLEASE SUBSCRIBE! https://cutt.ly/zdCef9v JOIN OUR DISCORD: https://discord.gg/bXMkFsg DONATE HERE: https://cutt.ly/zdCnvmj GET GODOT DRAGONBONES HERE (Windows, Linux, Mac): http://godotdragonbones.com Godot-Dragonbones module included with this build of engine: https://github.com/mauville-technologies/godot-dragonbones If you're interested in using this in your projects but would like more guidance, leave a comment letting me know what you'd like me to explain next.

In this tutorial, I'll show you how to quickly and easily add Google Play Leaderboards to your Godot projects. Google Play Godot Plugin: https://github.com/mauville-technologies/PGSGP Included: - Submit score to Google Play - Display built-in leaderboards screen - Query player's rank and hiscore to display in game This lesson builds on what was covered in Godot Google Play Services on Android in 30 Minutes! https://youtu.be/Y3Bj7qww0Y0 Join me next time where we add achievements to our Android project. Chapters: 0:00 Introduction 1:00 Repository 2:50 Project Structure (Overview) 4:12 Google Play Console Setup (Leaderboard creation) 6:00 Open Builtin Leaderboard View 9:10 Submit High Scores to Leaderboard 11:35 Retrieve Existing High score and Rank on Startup 17:43 Retrieve New Rank + High Score after score submission

In this lesson, we create an implementation of our own Vector class! We do so in the context of learning operator overloading including: Vector Addition Vector Subtraction Vector * Scalar Vector / Scalar Comparison Operators Conversion Operators OStream operator Type wrapping builtin functions In the end, we'll have a class implementation that will be usable in your own game projects! Professional C++ by Marc Gregoire: https://amzn.to/3eVMlaU Chapters: 0:00 Intro 0:35 Follow ups from last lesson 2:50 Code Cleanup 3:55 Create Vector3 class 5:18 THEORY - Operator Overloading 16:50 +(addition) Operator 19:00 - (substraction) Operator 19:50 ostream operator 22:37 First usage / test 25:08 Vector * Scalar (Multiplication) operator (RHS) 26:05 Vector / Scalar (Division) operator (RHS) 27:37 Changing your Left Hand Operand (Multiplication) 29:50 Comparison Operator Overloads 35:00 (BONUS) Type wrapping for overloading builtin types

In this lesson, we bootstrap some game engine systems and provide an entry point to our client applications. By the end we have a fully functional window system and a functional basic game loop in our game engine. Next lesson, we'll be adding Vulkan to our project and clearing the window to a colour! (Exciting stuff!) Repositories: https://github.com/mauville-technologies/youtube_project/releases/tag/tutorial-02 - client application https://github.com/mauville-technologies/youtube-engine/tree/tutorial-02 - Engine Interested in further learning? Checkout these sources! Game Engine Architecture: https://amzn.to/3yP6A1Z (affiliate) Game Programming Patterns: https://amzn.to/3c0trxR (affiliate) The Cherno - Entry Point: https://www.youtube.com/watch?v=meARMOmTLgE Chapters: 0:00 Intro 1:10 Entry Point 4:00 Main Game Class 9:25 Window System 19:05 Main Game Loop 24:00 Extensible Update Functions 27:10 Customizing the Window ___ Godot Dragonbones is a custom Godot engine build with the godot_dragonbones module that I am maintaining and distributing. It provides full-featured, 2D Skeletal animation support for the DragonBones API; a free, open source alternative to Spine: 2D Skeletal Animation. PLEASE SUBSCRIBE! https://cutt.ly/zdCef9v JOIN OUR DISCORD: https://discord.gg/bXMkFsg DONATE HERE: https://cutt.ly/zdCnvmj GET GODOT DRAGONBONES HERE (Windows, Linux, Mac): http://godotdragonbones.com Godot-Dragonbones module included with this build of engine: https://github.com/mauville-technologies/godot-dragonbones If you're interested in using this in your projects but would like more guidance, leave a comment letting me know what you'd like me to explain next.

In order to show you how to integrate the various features of Google Play, we first needed an Android Game in Godot. In this video, I show you how I made a game in 4 hours using Godot 3.3 with basic Google Play integration as described in my previous video. As of June 8th 2021, I'm maintaining a fork so I can always have a working version. In addition, I've added a little functionality into the plugin: https://github.com/mauville-technologies/PGSGP/releases 3.3 compatible Google Play Services plugin (original): https://github.com/oneseedfruit/PGSGP/releases/tag/3.1.1 Be sure to subscribe as in the next video, I'll show you how to add Leaderboards to your own project. 0:00 - Intro 0:45 - Series Plan 2:13 - Creating Art 3:27 - Setting Up the Godot Project 3:40 - Adding Physics (RigidBody) 4:30 - Gameplay loop 5:00 - Player Input 6:17 - Google Play Services (all aboard the struggle bus!) 7:29 - Gameplay Demo ___ Godot Dragonbones is a custom Godot engine build with the godot_dragonbones module that I am maintaining and distributing. It provides full-featured, 2D Skeletal animation support for the DragonBones API; a free, open source alternative to Spine: 2D Skeletal Animation. PLEASE SUBSCRIBE! https://cutt.ly/zdCef9v JOIN OUR DISCORD: https://discord.gg/bXMkFsg DONATE HERE: https://cutt.ly/zdCnvmj GET GODOT DRAGONBONES HERE (Windows, Linux, Mac): http://godotdragonbones.com Godot-Dragonbones module included with this build of engine: https://github.com/mauville-technologies/godot-dragonbones If you're interested in using this in your projects but would like more guidance, leave a comment letting me know what you'd like me to explain next.