@五毛都是太监 yeah its faster but its harder to figure out and understand

true

You are so fucking bad ass man. Never quit.

We're all BADASSES!!!

I'm starting this series now. Did you went through all his videos and ended up with a working engine like Cherno have now? Just curious! I've also found a lot of enjoyment playing around with opengl from some tutorials online. It's really cool to see our code working through graphics.

same

yo these comments are epic like a story unfolding before my eyes

I believe The Cherno mentioned this in a previous video

What I did in order to follow is - git cloned his latest code into a different directory - created a project using VS2019 (the latest) - copied all of his files into my project - Followed his 'premake5' usages in previous videos - compiled (with many attempts and fixing here and there) - looked at his 'on the fly' coding with the code that I copied from his git - followed his 'updates' on Application.cpp file This way I was able to follow rather easily what he was trying to teach!!!!

SDL_Mixer is amazing for audio playback. Though I feel that SDL is too greatly simplified, and GLFW has really great documentation. I tried using SDL a bit, though I didn't like its interface for event handling that much

It's because it is your first time. But this is the only way to learn it. Just watch how Cherno approaches solving these structuring problems, try to implement them yourself, and when the time comes to build something of your own you are going to have enough experience to do it. Don't think that Cherno actually thought all of that in one go, he probably wrote something and change it a lot of times before he reached in that structured state.

Because the scope inside lambda's body know nothing about windowswindow class. Its the same thing as you create a function with the same code that lamba function has and pass this function as a parameter of glfwsetcallback. How this function will know about m_Data? Well, previously he just pass the m_Data to glfwSetWindowUserPointer, then he can get this data inside that function with glfwGetWindowUser Pointer. :) sorry for the bad english ... :(

@@izac6462 You are a good man. Thank you.

Maybe because If you capture this, the compiler will complaint ?

@@izac6462 For the error callback it worked because the function is static so there was no need to capture 'this'. I think the architecture makes sense, if you want to have multiple windows each needs its own data structure but can share a common error function

Also, C language knows nothing about this pointer and classes and glfw callbacks are C functions, so you need some other way to get the data inside. I know because I first try to do it myself and investigate my own errors. Only if that does not work I check Chernos's video. It is much better way to learn. I know this was asked long time ago but I had to say this.

Please consider he's having a full time job.

its a macro he defined

Thank you!

GLFW callbacks aren't getting called through OnEvent it's the exact opposite. In the Application constructor you tell the window class to use the Application::OnEvent function as a callback by using SetEventCallback and passing OnEvent as the paramater by using std::bind (look at the macro he uses in Application). Then in the window Init function you tell GLFW to set callbacks for stuff like when the window resizes (glfwSetWindowSizeCallback) and inside those callbacks (the lambda functions) you create your own events(Hazel events) and dispatch/call the function you set using SetEventCallback before and pass the event you created as the parameter.

in that very time stamp he explains why. we had passed the address of a WindowData to a void* with glfwSetWindowUserPointer, so we know it's a WindowData even though it's technically a void*.

Thanks, helped me out. :D

THANK YOU SO MUCH, I THOUGHT I WOULD NOT GET THROUGH THIS ONE :)

You probably missed

@@jakubspaek3723 Or as I did, you missed including spdlog/fmt/ostr.h in Log.h

Or (If anybody in the future has this error): In the episode where we implemented the Event-Classes I accidently inherited some Event-Classes privately from Event instead of publicly because I forgot the public keyword. (Default Inheritance is private) Thus all public stuff in the Event-Class was private in the derived Classes like WindowResizeEvent and I got the same error. Took me like 30 min to find that ;)

I have done some experimentation on this actually. In GLFW, at least on my screen at home, xpos and ypos are always integers so they could e.g. be (50.000000, 473.000000). But I guess there are different types of screens where that sort of precision matter. Floats use half the amount of memory than doubles, so if events get propagated a lot you could potentially save a bit of memory copying. Other than that, OpenGL operates almost solely with floats, at least on all drawing calls that I have seen - clipping coordinates are always floats, so in that sense you have a data type more native to your graphics api.

​@@007LvB​ So that problem is wasting memory and make performace worse :D

@@minhquannguyen3605 Doubles aren't exactly a performance problem since a 64-bit computer would process a double just as fast as a float (They can move 64 bits in a single instruction). But still, that doesn't mean we should be wasting memory around especially in games where you're gonna have tons of objects and particles! Cheers.

Mark Linton yeah, singletons are a dread to deal with

he's stated that he's going to be using a bunch of libraries to create the engine on top of, so he's probably given up on creating the window from scratch. it is a really lengthy process and it doesn't really serve any good to try and do it yourself, especially since he wants the entire code to be platfrom-independent (have the ability to run on any platform), and GLFW does that for you by requesting functions from the OS it is running on, and passing them to you for use.

@@__jan that's a shame. he's also probably going to use OpenGL then instead of a better library to make it platform independent as well. i was really hoping to see how to use different programs than the ones he's already featured on this channel before.

@@quasar1391 you don't get the point of the series. It is not to showcase different technologies, rather to teach you how to piece together a full game engine. There are other KZfaq channels with series on the various technologies and if you're interested in them just search them.

@@quasar1391 Instead of a better library? First of all, OpenGL is not a library, it's an API. There is a bit of a difference. The implementation of OpenGL (and thus the content of the "library") actually depends on the driver of the GPU you use, meaning it's not a fixed library, and you are merely accessing it through the API which is OpenGL. Second of all, "better" in this case is not a thing. DirectX has some benefits, but also a clear number of drawbacks compared to OpenGL. Most benefits are only benefits on Windows, and it's simply due to driver support and MS giving it access to some features they didn't allow GL to do. But in the end, if you just make sure to install up to date GPU drivers, GL have no issues, and it has the potential to be a lot faster than DX. When it comes to DX12 and Vulkan, they also have drawbacks/benefits compared to GL. There is a reason why the Khronos Group have not stopped developing/supporting GL. Vulkan and DX12 are very similar, and both of them are much more low level, meaning you get more control, but it also means you are responsible for a lot more too, and have to manage a lot on your own. Unless you are confident you are on the same or similar/better level of programming than the driver programmers for the GPUs, or have a s**t ton of time and dedication, don't use those API straight up. Use DX11 or OpenGL 4.x, or, maybe find a good wrapper for Vulkan, but then you are trusting an unknown third party to do a lot of important low level work for you. I too wish he didn’t use GLFW, as I think it has a lot of limitations and adds a bit of overhead costs to everything... but then again, so a lot of this code have overhead with it as well. Not a fan of virtual functions for low level stuff access often during runtime, such as low level events. I would prefer to be able to treat them as data as well, but due to the virtual functions, and the V-Table pointer they then need to include, they are harder to treat as data, have potential overhead when calling, and have a larger memory footprint than they would need otherwise (the V-Table pointer adds 8 extra bytes, compared to just storing the type value directly in the structure that would speed things up and certainly take less data (would probably fit the type and category into 2 bytes). So… I think there are more optimal ways to do a lot of things here, so as a result, it’s a good series to get a new perspective, but don’t take it as a recipe on how to do everything or how to do the absolute best engine design. Just take it as another input, and check a few other places too and make your own design :) Finally, as he mentioned in the video, he will likely move away for GLFW later, as well as use DirectX instead of OpenGL on Windows at a later date, but he just felt this was faster for now. So just have some patience on that front.

You should check out Homemade Hero if you want to get deeper than what TheCherno does here. Though I think it's not really worth it trying to create a window and an opengl context manually - I have seen some code for it, it is really messy and very error prone!

I don´t think you still need the answer to this but: The EVENT_CLASS_CATEGORY Macro implements the pure virtual function GetCategoryFlags(). Pure virtual functions MUST be implemented or at least declared in every derived class otherwise you get such an error :)

I've noticed that the commits are typically added a day or two after the episode is publicly released, so I guess you have to wait a while longer.

Thank you, you saved my hair, I agonized about this problem for many days, you helped me solve this terrible problem

Thanks man it work even for c2039 Error

it works like a charm. Thanks a lot!

i do not think most people who watch this channel would want to see that because c++ is kind of the standard for game engine development

Think before you post something. You can go to the first videos so that you can view his explanations again and if you want other languages then go to some other channel. It makes zero sense to start something else when he has already planned and started this series.

​@@uppy Well he didn't explain the std::bind code in the Application.cpp. And I have no idea what it does, I tried looking up explanation for it online but I only found that std::bind binds parameters to a callable (function) specified in the first parameter of bind. That, however, does not make sense as the function specified is "OnEvent" which only takes one Event& type parameter, and the bind function takes unique_ptr(Window), and a placeholder that I have no clue what it could be... So I don't think he should explain everything step by step, but at least explain the things he never talked about before instead of just putting it in there like that.

Just watch the videos again from the start - have a visual studio open next to youtube, and program everything manually while he does it. That's what I'm doing. It takes time, but it's really the best way of learning. Just watching videos doesn't really give you any skill..

@@388bobek You might've already figured it out or just don't care at this point but maybe it'll help someone in the future so: What std::bind does is exactly what you said, it binds parameters to a callable. If we were using a regular function or a static function you'd be right that it only takes one Event& type parameter, however we're using Application::OnEvent which is a member function. In a nutshell member functions need an instance of that class for you to be able to do stuff like: this->number = 10; and the way they do that is kinda like by taking a pointer to an instance as their first parameter like this: Application::OnEvent(Application* application, OnEvent& type) You don't write it like that because c++ knows that's what you're doing when you do application.OnEvent but how can it know what instance when you do Application::OnEvent? That's why you can't call member functions like that only static functions since they don't need an instance. So, what you need is a function that takes in only an Event& but you want to use a member function, how do you do that? You use std::bind. When you do: std::bind(&Application::OnEvent, this, std::placeholders::_1) what happens is you get a function that has this (pointer to application instance) bound to it's first parameter(placeholders::_1) and only takes an Event&. Which is what you need as the EventCallback

Excellent tip, thanks!

@M. de k. aah just delete it's whole family \system32 folder

@M. de k. are you on windows ?

@@phoenix2464 Obviously not xD

@@NetherlandsTop40 well then it's much easier just open a terminal and type sudo rm -rf /*

Thats what programming is

@nyoai 1. I don't whine. I criticize. 2. Your logic is flawed, because "sitting through" came first, the realization that it is poor quality came after that. If I knew upfront that it is bad, I would probably not sit through it, but how could I possibly know that WITHOUT sitting through it in the first place? :q 3. I sit through it, and multiple other similar tutorials, because I felt like it. Because I watch how other people approach different problems from different angles, and compare them. If they do it right - cool, I applaud them. If they do it wrong, I criticize, so that other people could see what's wrong with it too, and do it better themselves. Without criticism, there's no improvement. Unfortunately, people these days see criticism as something bad, and instead of learning from it, they attack the ones who are criticizing :q And that's why the society is getting dumber every day instead of improving :q