- 33
- 1 943 557
Brendan Galea
Canada
Registrace 19. 11. 2020
ChatGPT controls NPCs in game - Coding Experiment
This is very much just in the proof of concept stage. Basically the game would be like pokemon but all the Non-player characters would be controlled through a combination of built-in ai systems + chatGPT.
Links
github: github.com/blurrypiano/monster-chat
artwork and tileset: cypor.itch.io/12x12-rpg-tileset
tutorial for html pokemon like game: czcams.com/video/yP5DKzriqXA/video.html
background music
------------------------------
Track: After Rain - Zackross [Audio Library Release]
Music provided by Audio Library Plus
Watch: • After Rain - Zack...
Free Download / Stream: alplus.io/after-rain
------------------------------
Links
github: github.com/blurrypiano/monster-chat
artwork and tileset: cypor.itch.io/12x12-rpg-tileset
tutorial for html pokemon like game: czcams.com/video/yP5DKzriqXA/video.html
background music
------------------------------
Track: After Rain - Zackross [Audio Library Release]
Music provided by Audio Library Plus
Watch: • After Rain - Zack...
Free Download / Stream: alplus.io/after-rain
------------------------------
zhlédnutí: 19 783
Video
Alpha Blending and Transparency - Vulkan Game Engine Tutorial 27
zhlédnutí 27KPřed 2 lety
By setting a fragment's alpha to a value in between 0 and 1 we can render semi-transparent objects. Unfortunately things aren’t that simple. When working with semi-transparent objects, the order in which we render them actually matters! In this tutorial we add a limited blending capability to our point light system, allowing them to be rendered with a nicer appearance. Discard vs Alpha Blending...
Specular Lighting - Vulkan Game Engine Tutorial 26
zhlédnutí 10KPřed 2 lety
Specular lighting represents shiny materials by modelling the reflection of light sources on the object. Shiny materials reflect light more strongly in the direction opposite the angle of incidence. This means that unlike diffuse lighting, the position of the camera/viewer now plays a role in the lighting calculation. Inverse View Matrix Paste Bin Link pastebin.com/wBAEhNjz Timestamps 00:00 - I...
Multiple Lights - Vulkan Game Engine Tutorial 25
zhlédnutí 13KPřed 2 lety
In this tutorial we add support for multiple point light objects in the scene. Lights will still be stored in the GlobalUbo, however for rendering the light objects we will use push constants. With the simple implementation shown in the video, each light in the scene contributes to every fragment's lighting calculation. For this reason, I set a limit on the total number of lights possible. With...
Billboards - Vulkan Game Engine Tutorial 24
zhlédnutí 15KPřed 2 lety
A billboard is a flat 2D object embedded in the 3D world, but has the additional property that it is always facing the camera. No matter how the camera moves or rotates, the billboard will always face the camera to some extent. In this tutorial we implement a second rendering system that uses this billboard technique to render a spherical point light. Offsets Paste Bin Link pastebin.com/ENRQLRR...
Project restructure and cmake - Vulkan Game Engine Tutorial 23
zhlédnutí 16KPřed 2 lety
In this tutorial I change the projectto use cmake rather than a simple makefile to make building on multiple platforms simpler and more straightforward. Paste Bin Links Cmakelists.txt: pastebin.com/jzk262hg Env windows example: pastebin.com/mrPVsS1r Env Unix example: pastebin.com/j23jKX7U Timestamps 00:00 - Git repository restructure 02:35 - Tutorial start (CMakeLists) 07:12 - Updating relative...
Vertex vs Fragment Lighting - Vulkan Game Engine Tutorial 22
zhlédnutí 11KPřed 2 lety
Currently all lighting calculations are being performed within a vertex shader, meaning that light intensity is only calculated for each vertex, and the computed color is then blended across the fragments of each triangle. Rather than interpolating the final color value, we can instead interpolate the surface normal at each vertex. Then within the fragment shader we use the interpolated normal ...
Intro to Point Lights - Vulkan Game Engine Tutorial 21
zhlédnutí 13KPřed 2 lety
Point lights are infinitesimally small sources of light. They differ from directional lighting in two major ways: the direction to the light source will be different for each vertex and the intensity of light is attenuated based on the distance between the vertex and the light’s position. In this tutorial we add a point light object to the global UBO and update the vertex shader to make use of ...
Descriptor Sets - Vulkan Game Engine Tutorial 20
zhlédnutí 19KPřed 2 lety
Vulkan uses descriptors as a way to provide resources to our shader programs. Descriptors cannot be bound to a pipeline individually, and must be grouped into a set. Additionally, before pipeline creation, a descriptor set layout must be provided. A descriptor set layout acts as a blueprint, telling the pipeline how many descriptors will be bound, and what types of resources each descriptor use...
NonCoherentAtomSize Bug Fix (Tutorial 19)
zhlédnutí 7KPřed 2 lety
In this video we fix an error from tutorial 19 where we weren't taking the nonCoherentAtomSize property into account when flushing the memory range of the uniform's buffer. To flush/invalidate any memory range of a buffer object, unless the ranges size = VK_WHOLE_SIZE (the entire size of the buffer), the range's size and offset must be a multiple of the VkPhysicalDeviceLimits::nonCoherentAtomSi...
Uniform Buffers - Vulkan Game Engine Tutorial 19
zhlédnutí 14KPřed 2 lety
In this tutorial we create a buffer abstraction to make working with buffers a bit more convenient. We replace existing usages (vertex and index buffers) with this new abstraction, and then create a uniform buffer object which will store read-only data that can be updated dynamically between frames, to pass additional data to our shaders. Uniform buffer data can be used within shaders, similarl...
Realtime 2D Gravity Simulation
zhlédnutí 402KPřed 2 lety
This has been a fun side project I've wanted to work on for a while. I had originally just planned on doing a GPU based particle fluid, but I got sidetracked by the nice looking results of the gravity simulation. (Sorry about all the compression artifacts, kind of impossible to avoid when uploading something like this to youtube) It is still very much a work in progress. This uses a grid based ...
Diffuse Shading - Vulkan Game Engine Tutorial 18
zhlédnutí 18KPřed 2 lety
In this tutorial we implement a diffuse lighting model with a constant ambient light term in the vertex shader. This colors the vase object by calculating the intensity of light for each vertex based on how directly the surface at the point faces the incoming light. We use a directional light source, which means the same direction is used for every vertex. This simulates a light source that is ...
Loading 3D Models - Vulkan Game Engine Tutorial 17
zhlédnutí 20KPřed 2 lety
In this tutorial we make use of tinyobjloader, a tiny but powerful single file wavefront obj loader, to load 3D models into the engine. This video is primarily based off of Vulkan tutorial : vulkan-tutorial.com/Loading_models Join the discord: discord.gg/CUQkuKsszr TinyObjLoader Header github.com/tinyobjloader/tinyobjloader/blob/master/tiny_obj_loader.h Models Sharedrive drive.google.com/dri...
Index and Staging Buffers - Vulkan Game Engine Tutorial 16
zhlédnutí 15KPřed 2 lety
Index buffers are a way to reduce the amount of gpu memory required to store a model’s attribute data by allowing duplicate vertex data to be removed from the Vertex Buffer. An Index Buffer acts like an array of pointers into the Vertex Buffer, allowing vertex data to be reused by multiple triangles during rendering. A staging buffer is used in the process of transferring data from the host (cp...
Game loops & User input - Vulkan Game Engine Tutorial 15
zhlédnutí 16KPřed 2 lety
Game loops & User input - Vulkan Game Engine Tutorial 15
Camera (View) Transform - Vulkan Game Engine Tutorial 14
zhlédnutí 22KPřed 2 lety
Camera (View) Transform - Vulkan Game Engine Tutorial 14
Projection Matrices - Vulkan Game Engine Tutorial 13
zhlédnutí 35KPřed 2 lety
Projection Matrices - Vulkan Game Engine Tutorial 13
The Math behind (most) 3D games - Perspective Projection
zhlédnutí 365KPřed 2 lety
The Math behind (most) 3D games - Perspective Projection
Euler Angles & Homogeneous Coordinates - Vulkan Game Engine Tutorial 12
zhlédnutí 19KPřed 3 lety
Euler Angles & Homogeneous Coordinates - Vulkan Game Engine Tutorial 12
Renderer & Systems - Vulkan Game Engine Tutorial 11
zhlédnutí 27KPřed 3 lety
Renderer & Systems - Vulkan Game Engine Tutorial 11
2D Transformations - Vulkan Game Engine Tutorial 10
zhlédnutí 21KPřed 3 lety
2D Transformations - Vulkan Game Engine Tutorial 10
Push Constants - Vulkan Game Engine Tutorial 09
zhlédnutí 21KPřed 3 lety
Push Constants - Vulkan Game Engine Tutorial 09
Swap Chain Recreation & Dynamic Viewports - Vulkan Game Engine Tutorial 08
zhlédnutí 23KPřed 3 lety
Swap Chain Recreation & Dynamic Viewports - Vulkan Game Engine Tutorial 08
Fragment Interpolation - Vulkan Game Engine Tutorial 07
zhlédnutí 23KPřed 3 lety
Fragment Interpolation - Vulkan Game Engine Tutorial 07
Vertex Buffers - Vulkan Game Engine Tutorial 06
zhlédnutí 35KPřed 3 lety
Vertex Buffers - Vulkan Game Engine Tutorial 06
Command Buffers Overview - Vulkan Game Engine Tutorial 05 part 2
zhlédnutí 34KPřed 3 lety
Command Buffers Overview - Vulkan Game Engine Tutorial 05 part 2
Swap Chain Overview - Vulkan Game Engine Tutorial 05 part 1
zhlédnutí 47KPřed 3 lety
Swap Chain Overview - Vulkan Game Engine Tutorial 05 part 1
Fixed Function Pipeline Stages - Vulkan Game Engine Tutorial 04
zhlédnutí 46KPřed 3 lety
Fixed Function Pipeline Stages - Vulkan Game Engine Tutorial 04
Device Setup & Pipeline cont. - Vulkan Game Engine Tutorial 03
zhlédnutí 72KPřed 3 lety
Device Setup & Pipeline cont. - Vulkan Game Engine Tutorial 03
4:32 because you changed the path, cmake doesnt recognize the source files before regeneration, and reopening vscode automatically generates cmake files. You can just regenerate from command palette
I'm using Visual Studio 2019 and I can't figure out how to add a custom build step. Anyone have any luck with that?
I managed to get it working by adding the following to VulkanTest.vcxproj in the section <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> It's doesn't look for all *.frag and *.vert files currently. Just the specific ones. I'd appreciate any help on making it generic like in the tutorial make file. <CustomBuildStep> <Command>C:\VulkanSDK\1.3.280.0\Bin\glslc.exe $(ProjectDir)simple_shader.vert -o $(ProjectDir)simple_shader.vert.spv</Command> <Outputs>$(ProjectDir)simple_shader.vert.spv</Outputs> <Inputs>$(ProjectDir)simple_shader.vert</Inputs> </CustomBuildStep> <CustomBuildStep> <Command>C:\VulkanSDK\1.3.280.0\Bin\glslc.exe $(ProjectDir)simple_shader.frag -o $(ProjectDir)simple_shader.frag.spv</Command> <Outputs>$(ProjectDir)simple_shader.frag.spv</Outputs> <Inputs>$(ProjectDir)simple_shader.frag</Inputs> </CustomBuildStep>
I found a way that works for each file you add. It doesn't check for every frag or vert file and then loop however. Select the file in the Solution Explorer. Click the wrench icon in the lower Properties window to open Property Pages. Under Item Type select Custom Build Tool and Hit OK Open Property Pages again There will now be a Custom Build Tool tree, select that. Set Command Line to: C:\VulkanSDK\1.3.280.0\Bin\glslc.exe $(ProjectDir)%(Identity) -o $(ProjectDir)\%(Identity).spv Set Outputs to: $(ProjectDir)\%(Identity).spv And set Link Objects to No (Not sure what this does?) Repeat for both FRAG and VERT files.
I have tried to implement the projection and view matrix in my vulkan application but my screen still blank even after using this method.
hey was there ever a "device setup" video made about the classes you created?
3 years after, this is still a Masterpiece, following the tuts rn. I can already tell you play a small part in changing my life. And for that, I want to thank you.
The 3 billion body problem.
if i stretch the window to be 0 pixels tall then it stops accepting input
So in the end the frustum matrix is simplified to a ‘pyramid’ matrix so that angles from the center are displayed with respect to their tangential value. Right? 😅
great tutorial but how come its B8G8R8A8 not R8G8B8A8?
Imagine if you could do this with games like Sims 3 or Sims 4!!!
Tutorial 1 had 150k views, this, the second to last tutorial only has (almost) 10k views, only 7% of people actually finish (I didn't do last tutorial, because people probably skipped ahead and just watched to see what they were making, as its got a lot more views than this.
you... are.. the shit bro, str8 up. This is simply amazing, ty for making these videos. You should follow it up with a part two of an engine creation but instead of vulkan using glfw for 3d graphics in a window, you should do it for OpenXR technologies, focusing on either PCVR or better, the Android / C++ native implementation of OpenXR for the meta quest 3. I am learning a lot from you, as opposed to the numerous books I could not quite grasp fully until I found your videos.. not even in the university I attend have I learned as much as I have in the past 20 summin videos of yours I binged in 4 days.. so far thanks
Could ChatGTP help you to continue with Vulkan tutotials?
How to make the makefile? What’s .env?
Wow, these drawings are so cool, they have a 2000's vibe. Nice.
I’m working on my NEA project but I am super confused, can I get any contact details to ask for help? Or can you suggest any tutorials that could help me understand this?
where have discord ink
in what coding language?
The way you say homogeneous is strange, I know its the proper way, but its not fluid, hum odge unis
how does the non linear z buffering effects the light calculations? or are they too small to care about?
When doing light calculations you want to use the world space x,y,z values so the non linear z value (screen space) in the depth buffer does not play a role in the calculation. The z depth buffering value is only really used for determining which fragment is closest so only the ordering matters. However for some more advanced techniques such as screen space ambient occulsion or when using shadow maps the non linear z buffering does start to matter and is something that should be kept in mind. It’s a bit beyond the scope of a CZcams comment to be able to go into. But any good tutorial that depends on depth dependent information should cover how it is relevant in the context of the tutorials topic.
If anyone is wondering "Why is he doing most of the legwork for us - HOW WILL I EVER LEARN MYSELF?!!!!" .... Let me tell you ... I had that same thought. So I stopped watching this series and put it to one side. I then proceeded to go through the Vulkan-Tutorial chapter by chapter, reading everything and typing it all out...line....by....line. It was a freaking painful SLOG. 1000+ lines of code later, most of which I barely understood what I was copying out (and I'm an experienced C++ programmer just new to graphics) and you've JUST ABOUT rendered a simple triangle on the screen. It's a real motivation killer and I think that is EXACTLY what Brendan's example code aims to solve. Tuck away the excruciating detail in a few classes and let the learner understand the core concepts rather getting bogged down in why the VkImageViewCreateInfo::subresourceRange.baseMipLevel must be '0' in this particular example. I'm still working through some of the final chapters / more advanced topics, and I have a 'better' understanding on things but the reason I've now gone back to re-watch/continue this video series is to actually learn what the heck I was just typing for many hours :D
The problem with this tutorial is that this is a Vulkan tutorial. Although this series is most likely completed, I wanted to point out that what makes copying code so bad is that it's defeating the entire purpose of Vulkan, by copying code which is integral to Vulkan and what actually makes Vulkan it's own. The main goal of Vulkan is not to render a cube, this could be done with OpenGL or any other API, but what makes Vulkan different from an OpenGL tutorial is it's verbose low level design like setting up a logical device, etc. You can't learn a language like Spanish by using google translate. Of course this is just my opinion but again the viewers should not be dependent on downloaded code that they don't understand as beginners, which should have been the main talking points of this tutorial. Anyways that's my only issue with it, I do really like the quality of this series and how beginner friendly it is (excluding the copying).
Thanks for the honest critical feedback. I agree with what you’re saying. However if I was to do this again I would do it in the same way. I want to build up more of the surrounding context around renderpasses, framebuffers, etc where the tutorials covering each of these topics can really go into the proper depth, before going back and then going over the swap chain and device code. When I was first writing the tutorials for the device and swap chain code it was just information overload so I scrapped them and went the other direction. So hopefully in about 4ish months when I have a chance to start making videos again there will be just a few more topics covered before we finally go back to rewrite the swap chain and device code
What is advantage of uniform buffers over storage buffer? If it has so big limitation in size, which big loose over storages, there should be something bad side of storage buffer over uniforms. What's that?
Not positive and haven’t benchmarked it myself but I believe it comes down mostly to performance. The hard thing is it’s definitely device dependent what it actually going on behind the scenes. Uniform buffers are read only in shader code and also have a more limited size. Also it’s typically recommended to avoid frequently updating uniform buffer data. Because of this it’s feasible that some gpu devices may be using a different type of memory with faster read performance to optimize speed for reading uniform data in shaders. Sorry for the lackluster answer. I guess a good rule of thumb is that if you’re not targeting any specific device then use uniform buffers when you require only read only access in shaders and when the size limitations aren’t an issue. If targeting a specific device and performance is critical, best to do benchmarking to determine the differences.
4:00 "Since we've not using Vulkan" I assume you meant to say OpenGL?
Yup! Lol
Wooot!! Red triangle!! I gotta call home for this. Hey Mom! check this out😅
Making a vulkan game engine by myself just wanted to see how to link it lol
I'd like to use something like this for my game, you have to find a ring in a haunted house but the townsfolk are terrified of the ghosts. the ghost is not all that scary but he IS mean however, so you could defeat it by using a magic stone. Once you defeat the ghost another quest could show up to defeat a demon that is in a building
I love your tutorials! I am following the official Vulakn Tutorials but I think it is hard for me to understand how it works. Your explanation is very clear!
Great explanation!
Your videos are some of the best on 3D programming!
Bruh made a whole universe
This is almost the perfect derivation of perspective projection (especially since it includes both the off-axis and FOV versions!). However, I wish you would have talked more about why applying the first perspective transform gets us into a space that allows for trivially transforming with the orthographic projection matrix. It doesn't seem intuitive to me. Firstly, I think it would have helped to emphasize that multiplying by n and dividing by z actually turns the slanted edge of the frustum into the right-angled straight edge of the desired rectangular prism because everything on that will end up landing at the exact same x value (or y, for the top, respectively). Secondly, however, we should note that what we get after multiplying with our perspective matrix is *not* a 3D rectangular prism, since its components haven't been divided by the w component (i.e. z value) yet. It's a seemingly somewhat arbitrary 4-dimensional entity, and so it's unclear from my limited linear algebra skills why doing the perspective divide and then applying the orthographic projection is equivalent to doing the orthographic projection and then the perspective divide. There seems to be a deeper "truth" to homogeneous coordinate equivalence that is more than just a notational convenience. If you had touched a little on that, this would have been the de-facto, perfect explanation.
Hmm, trying to figure it out more, it seems like the "divide-by-w" can really just be considered to be multiplying the matrix-vector multiplication by the scalar 1/w. And if you have a scalar a and a matrix-vector multiplication M times v, M[av] = a[Mv] (as well as [aM]v). I think that's the last piece of the puzzle.
Are you the same person as Joseph Anderson? The guy who makes game critique videos? You sound so similar...
No not sure who that is!
6:55 why isn't that possible exactly?
Because matrices only allow for the resulting values to be linear combinations of the form Ax + By + Cz + Dw, where A,B,C, and D are just regular old numbers. In other words, matrix-vector multiplication takes a set of raw numbers, multiplies them component-wise with the vector's components, and then adds them together. There's no way to represent dividing one of the vector's components by a different one of its components. Now obviously you could make, for instance, A = 1/z before-hand and bake that into the matrix, but then *every single vertex* would need a special matrix because every vertex has a unique 3D position and thus a unique z value. So instead, we can use homogeneous coordinates to allow us to use a single matrix for all vertices of a given object, and then do the z division as a separate, final step.
Brilliant video.
This is beautiful! What happens when its in 3D though?
This method probably wouldn’t work well in 3D. In 3d most of space is empty so doing a dense grid representation would be a lot slower.
@@BrendanGalea ah, makes sense.
This represents our world peace! Galaxy collisions!!!🐼🐾
Bro got me good with the code to download, unfortunatelly for me, im implementing the tutorial with other names so i'll take my time translating everything. Still think that i`ll end up learnng a lot, so thanks!!! I`m really enjoying thinks so far! Edit, it was actually very fast, nice.
opengl looks down the positive z-axis? it is the y-axis that are swapped?
6:30 seems that there is mistake ys/n = y/(n+z) Or ys/n = (y-ys)/z But NOT ys/n = y/z as in video
Ya bad diagram on my part. I meant z as the total distance but the diagram as it is implies that z is just the shorter distance. Sorry about that
bro u need to link a download
Love the tutorials so far!
I started work on a space exploration game and this is almost exactly what I have been looking for, thanks for making this
Oh cool! Best of luck. Will it be 2D or 3D?
Even though I thought I had already understood this before I watched, I still learn something from it. Thanks for making this video, I think it's the clearest one about how to get the Perspective Projection
On linux, I kept getting errors opening the shader files - adding std::ios::in to the flags fixed this.
fking idt you dont explain a shit here
The best explanation of perspective projection. Thank you
IMO too fast explained/too many intermediate stuff leaved out. I just needed a revision and I am pretty sure nobody will understand the whole video without A LOT OF additional information. Like just to truely understand homogenous coords we should spent 1 hour. So this kind of video is neither helpful for beginners nor for people who knew it all already.
This is a masterpiece. Thx!