BASIC 3D GAME ENGINE based on Hazel! // Code Review

hey what's up guys my name is luciano back at it again with one of these sweet code review videos this is just a little series on my channel where you guys send me some code and i take a look at it now last time was the first episode of this series i'll have it linked up there and since then there have been quite a lot of submissions from you guys as well some questions as to what kind of code i'll be looking at so i'll try and answer that today but the short answer is if you want me to review your code check out the uh email address in the description below it's what is it like china review gmail.com you can send your code there as well as a little description of what the code actually is and if there's a specific area that you want me to review in particular now the first thing i want to mention is there have been like a lot of submissions and it's a little bit difficult for me to obviously pick one and and review it my area of expertise is of course game engines so i do like looking at game engines but that is not the only thing i want to look at we are going to be looking at another game engine last time we covered like a 2d game engine made by a 13 year old this person is 17. um we'll dive into this email in a minute uh and this is as far as i'm concerned a 3d game engine kind of based on hazel so this should be a little bit of familiar code maybe this uh my hope is that this kind of code review will hopefully help guide some of the people who are following my game engine series but also trying to write some of their own code because for those of you don't know of course i do have a game engine series here on youtube but if you have a project that is in another language if you have a project that is just a game or a game engine or an implementation of some algorithm and like a visualizer to go with it feel free to send that as well it doesn't have to be game engine it doesn't have to be cfos plus but anyway i don't want to spend half an hour talking about this series in general if you have some code that you want me to review check the email address in the description of the video let's dive in and take a look at dmitri vasiliev so dimitri is from ukraine which is pretty cool and he's 17. so a little bit of a uh age difference between 13 year old but still still not like professional code right i'm kind of building towards that maybe we'll get into like someone who is like some engineer at a company and they have a hobby project and they want me to code review that that would be interesting as well but you know this should be a step up from the 13 year old code that we looked at last time by the way a little bit of a precursor i'm assuming that they're more experienced because they're older that's not necessarily the case so actually i could be wrong i'm currently working on my own game engine because it's a great practice project i want to be an engine developer maybe there's a chance for me to write something new and amazing for the industry it now can render a rotating cube and much more maybe put a test engine sound like threshing cube okay cube implies 3d so this should be in fact a 3d engine i want to improve every aspect of engine so i'd be very grateful if you can point out my mistakes and explain how to fix them link to github repository is here let me look at that and you'll find all the instructions inside thank you also thank you a lot for your content and this review sorry for my english working on it people who don't speak english as the first language always say this and their english is usually very good so yeah well done okay so here we have the code looks like cmake is in use here and we can clone it recursively and there are actually build instructions which is pretty good i think that's more than hazel has cma 3.17 clone uh you know standard cmake stuff here and if you build a sandbox project we need to add this option okay so good thing i read this um or you can use c line all right and then we can generate this okay so we're going to dive in and generate a visual studio solution file with the sandbox project i guess and we'll try and compile and run it first i might just skip past that part um and then we'll actually dive in and look at the code but first first this video is sponsored by skillshare those of you who still don't know what skillshare is skillshare is an amazing online learning community where millions of creative and curious people from all around the world can come together and learn some new skills because learning new skills is both fun and incredibly helpful in life now whilst i'm from melbourne australia and we're finally coming out of our lockdown i know that europe's kind of going into a bit of a lockdown at the moment and one of the things that i actually did to help me get through lockdown was i tried to be productive right if you are stuck at home and you can't go outside and you can't hang out with your friends as much then instead of just watching netflix just binge watching it the whole the whole way through and then feeling bad about yourself you can actually use some of that time to do something productive and learn a new skill i know that makes me feel a lot better and i stay a lot healthier mentally and that of course is where skillshare comes in they have thousands of amazing classes on pretty much any topic you could think of whether you're interested in art or illustration or like logo design or business and marketing or productivity or photography or editing photos or anything like that they have a bunch of amazing classes for me one of my personal favorites is this art and illustration course by jazza jazza has a youtube channel i'm sure a lot of people have heard of him but he also has this amazing like really well put together skillshare course which can function as a really good introduction to illustration and just drawing in general which is something that i love to do for fun just to chill out after a long day and i love the fact that the classes are so bite-sized a lot of the videos in the classes are like between five and ten minutes so even if you just have a few minutes at the end of the day it's so easy to sit down and actually do something productive for a limited time skillshare is offering you guys a free trial so definitely jump on that link in the description below check it out see what kind of courses skillshare has in general and go ahead and learn some new skills huge thank you to skillshare as always for sponsoring this video now the first thing i want to do with this is obviously try and build it according to these settings i just want to start off by saying that even though we're not into the code this kind of documentation is great right when i look at a repository like this the first thing that i want to see is what the project is which it clearly states and a getting started guide that actually has instructions on how to obtain it and how to build it these instructions aren't that long so he could have left them here but i mean it doesn't matter at all the point is that they're here it's really easy to actually build this project the instructions are all here there's even a plan and a little cute little mention to my hazel video so thank you for that but my point is it's really nicely organized and i don't have to think twice about what on earth this even is now once the project matures a little bit more it's really nice to see a screenshot of what it's capable of rendering now i don't do this in hazel if we look at hazel it's just kind of got like the the logo here and then that's kind of it i mean it's got instructions on getting started as you can see and the plan as well and all of that stuff but it doesn't have a screenshot we're not really rendering anything exciting yet i don't think he is either but that's just something to keep in mind for the future if you're actually working on something visual then it's good to include some screenshots okay so i'm gonna grab the link i've got a little uh let's call this well we'll just clone it over here so i'll just make a um i'll go open a command prompt here get clone recursive we'll dump that in here and then we will once this clones we'll compile it with cmake this was actually quite fast so i'll probably just not even have to skip through this okay so let's let's take a look at this in the meantime so we've got glad we've got glfw got glm we've got i'm going we've got spd log speed lock this is basically the same setup as hazel it does say that it's inspired by hazel so um we'll see uh what kind of modifications he's made for the record a lot of people tend to ask me if it's okay for them to kind of copy hazel um like of course it is right this is a tutorial series for you guys my hope is that you would take what you like from it and then maybe change some things that you don't like and then add a whole bunch of your own stuff to it um you know it's it's there's no there's no reason to ask me if it's okay to copy the code now if you just copy the whole repository and then just change the name from hazel to walnut engine or something like that i don't know then that's kind of like that's a bit lame you know it's not not very cool but if you're obviously learning from it and then molding it into your own work that's kind of the idea so let's make a directory called build we'll go into build and then we'll just run cmake like that subdirectory uh okay i just completely failed there let's actually go into um what was it called real engine and then we'll make our build directory and then we'll go into the build directory and then we'll see make there we go okay so pretty oh whoa okay let's stop i remembered so this is why it's so good to read the the instructions you need to add this let's go ahead and add that so c make dot dot paste again so this should also i guess include the build examples which is going to be good or other it's going to include the examples okay and of course it hasn't worked now even though cma seems to have failed it it does seem to have generated like a solution file i might just open that i don't really like debugging cmake i don't think anyone does it looks like it's saying that cmake may not be built correctly but i'm pretty sure i've been using it for a while on this computer so a little bit weird on a side note this is why i love pre-make so much i have had pretty much zero issues with pre-make and all the issues with cmake okay so real engine engine uh i guess we'll look at the cube example hopefully this will just build i'm not sure if it will because of the cma issues i described earlier but let's take a look at this okay so there's a bunch of custom build rules for all of these different uh projects because i imagine they also support cmake which is nice one of the downsides obviously with using something like pre-make because you have to write scripts for anything that doesn't include it where a cmake is pretty much standard so uh that's definitely helping out in this example and if we hit f5 hopefully this will run there we go it runs now i can't open shader's bass glsl um so it looks like we can't load a shader file interestingly enough though it didn't crash or anything like that which is nice it's just running with a black screen let's see if i can quickly diagnose this and have it actually open the file so it's supposed to be in shaders let's see uh what the working directory is set to it's directly properties debugging working directory is set to the bin folder this might actually be the issue um because perhaps oh here it is so in the bin folder there's debug shaders and then shaders in here is empty so this should probably be the working directory so it's just missing a debug yeah a little bit weird again this might have been a cmake thing i'll just set it manually because this is a code review and i just want to see it running properly there we go okay so a bit of a white cube here uh i guess the shaders is just just setting a flat color and everything else looks pretty good obviously similar to hazel here with like the logging and different coloring and all that stuff but we have a point to get started so the next step for me here is going to be just to dive in and take a look at the general structure of things now i already imagine that this is going to be fairly fairly similar to hazel which is kind of making me think that maybe this was almost a mistake picking this one because it's it's probably going to have a very similar uh kind of layout but maybe i'm wrong maybe there's been some stuff that's been added let's take a look at this obviously the big thing that i'm looking for is the fact that the hazel hazel in the game engine series on youtube is not 3d yet whereas this seems to be 3d so i'm interested to see how this person has actually kind of integrated 3d rendering even though it is just a flatly lit kind of or a flat shaded white cube and we'll see if we can review that code specifically okay so this is the main example of the real example cube now obviously i'm seeing a lot of kind of engine code inside this even though it is an example so that's kind of the first thing i'll point out um you know there's there's like setting up the actual cube here application init these are all things that i don't like to do inside the actual client app so to speak now the reason is that application init from within this real engine this is something that i have no doubt has to happen for every single application so this is just like part of the engine startup why is it the application's responsibility to call that you know there's no there's no way around calling application init right i imagine that this hap absolutely has to be called i mean this is actually this is it initializes the render of the window all of that stuff so why have it here why not have it as part of the engine startup now i don't know maybe i should bring up hazel and kind of talk about the architecture with that but we'll see if you guys if you guys have any ideas for how i can maybe be more effective in these code reviews and and what stuff you're interested in then definitely leave a comment below but i'll just kind of take this as it is for now okay share the live reload okay my first question is immediately where does the shader library come from right because this is a variable we're in the init function this is a variable right so it's a pointer in this case it's a real reference which is just a shared pointer so we do a similar thing of course within hazel um but you can see that just kind of in this private section of this class we're just creating this right over here now that might be okay because shader library is just a uh like it's a very kind of um straightforward kind of simple to initialize class right simple to instantiate class it's not like it does any kind of opengl code or anything that's dependent on anything else it just creates an empty unordered map and that's it so it's totally fine to initialize it here but then my second question is why is it a reference why is it a shared pointer i don't imagine this would get passed anywhere and you can see it doesn't so my first kind of advice would be probably just get rid of this you know just have a stack allocated shader library like that um and then you don't have to uh don't have to allocate it on the heap and it's a lot simpler i mean it doesn't change like the actual kind of api that much right but it it just it's something that you just don't need to do and that you shouldn't make a habit out of same with all of these like um you know these might be passed into an api that expects like a shared pointer or a reference cannon object and that's fine in which case i would create them on the heap but you know for the most part these are probably not going to suffer if you don't create them on the heap especially for this example yeah so you can see kind of in this in this um case right um ad index buffer takes a reference in so you know unless you want to write your api twice it's just best to just stick with the references and i get that that's totally fine um also i won't jump ahead uh let's let's continue going over here okay so we load this shader sure fine um now this is a shader library so i wonder how this person is going to reference this next so obviously we're taking a file name here does it automatically get the name from the file like how do we a library obviously uh implies to me that we have a library filled with shaders and we want to be able to retrieve shaders later so how do we retrieve them shader name seems to be a function um potentially i can't really go to it unfortunately shader name here it is um and then name gets set here and i imagine that maybe it's just the the file name yep so i think we do a similar thing in hazel or at least in hiddle dev um so in other words this would probably treat it as bass and if i want to get in the future i can just retrieve the bass shader so that's fine okay setting up rendering here so we have a bunch of vertices for our cube and we have a bunch of well it's called positions but these are indices so i would definitely rename them to indices because um whilst i guess technically speaking these are vertex positions and there's no colors or whatever in here um it's probably not not great to have them like this also um keep in mind this cube isn't really going to work so what what what you've done is you've got a total of eight vertices here describing the cube um i mean for a cube this may be lit like with a flat color or in your shader you're just setting it to white that's totally fine you can physically get it to render but when you start to do any kind of lighting calculations you'll need to have normals and normals you can't have one normal per each kind of vertex in this case here let me just illustrate this this is something that a lot of people get wrong so if we have a cube pretend that this is a cube and we've decided to have a total of eight kind of vertices here so if you kind of draw the cube you wind up with a cube technically because you really only need eight of them right so it looks something like this and you obviously have your cube and it looks like a cube the problem is that when you want to start doing lighting you'll need to actually know which direction all of these faces are facing in so that you can see how much how much they're facing the light right so to do that you'll need normals and normals point in the direction of the face now if you've only got one vertex you can only have one vertex normal it doesn't really make sense because even though it has physically one position if you think about it it's part of this face which is pointing this way it's part of this face which is pointing this way and then it's also part of that kind of back face that's pointing that way right so in in actual fact you need three vertices in this one place they have the same position but they have different normals now there are no normals here which is why it's working fine and and consequently you can see that you're not doing any kind of lighting in that flat white cube that we looked at earlier but for the future this is something that you'll need so in other words even though you might think that you can get away with eight vertices for a cube in reality you'll need 24 of them because you need to there are still some that you can duplicate so in other words if we have kind of a triangle if we have this face which is made up of two triangles we only really need four vertices to represent this because even though we have two vertices here that are the same one belonging to this triangle one belonging to this triangle they still are facing the same direction so we can get away with them having the same normals but you know when you're talking about all of these different faces facing different ways you'll need more than that so that's just a little bit of information regarding cubes because because i remember back in the day i used to struggle with this as well i thought why on earth would i need more than eight vertices to represent a cube there's just eight points in 3d space and that's correct but again a vertex is not just a position it can have other other data attached to it such as a normal and if you want to have different data per vertex then you might have to duplicate the position because it's not just all about the position okay back to the code positions um yeah so these are all the indices now just a little quick note i would probably recommend just uh once you have like the ability to load 3d models it'd be very useful to actually just load a 3d model that contains all of this in it the reason is that writing stuff out like this is kind of useful and a lot of engines have something called a mesh factory that can generate this but it is also a little bit of a headache i don't know i'm kind of torn on this because on one hand it's good to learn about this and it's good to learn about how you can manually like position a cube but it's also not it's also like very tedious i think for a beginner to do i'm not sure leave a comment below with whether or not you think a beginner will say i'm not sure i'm not calling this person a beginner but for the sake of this example we'll pretend that they're a beginner is it a good idea for a beginner to be kind of manually you know building meshes up like this or should i just try and load a 3d model what's better because i can't really decide one thing i do want to note that i was i could probably keep talking about this cube for like the whole video but um one thing i'm also noticing here is it's not like a one by one meter cube so generally when we have like basic primitive types basic meshes we want them to be uh some kind of consistent size usually about one meter in either like you know the diameter or the radius you can decide which one you want usually radius sorry usually the whole diameter would be one meter and then also like for this you probably want the cube to be one by one meter right or one by one centimeter depending on what units you're using this is obviously two by two right because we go from positive one to negative one the problem with this is that it kind of throw it can throw off the scale of the rest of your 3d rendering scale is something that's really important scale is something that people don't really think about that often either but just know that when you're making stuff like this you should just make it kind of you know be i guess one by one unit and then you can obviously scale it to whatever size you want uh okay positions sure we've gone through that okay vo reset um see this is like another kind of consequence of using these shared pointers i don't personally don't not a huge fan of calling a reset um you can probably just set it equal to something like this right um and you might have to do like a make shared and then i guess that's probably why you've done it this way but i think i just think dot reset looks a little bit messy um because you're basically substituting like an assignment like an equal sign for a function called reset bind um not sure why you're binding here so see this is just another example of a of like an api that's doing too much in the client right um what you probably should do is like if you really do want to construct your own vertex array and then your own kind of vertex buffer and index buffer then what you should do instead is um and we can get into this stuff in a minute but what you can do instead is just maybe add them correctly like that without having to like bind them then this does any kind of binding it needs to if you actually want to like for example link the index buffer to a vertex array because the like one of the ways that you you do that is by actually just binding the vertex three and then binding the index buff and then it magically links open gel is annoying um but anyway uh that's a lot better without having to kind of uh i guess put that responsibility onto the client because if you look at this you know this becomes a little bit complicated already right like if i want to render a cube this data is kind of necessary because for the sake of this we'll pretend that instead of being like this is how my engine renders the cube because that's a bit ridiculous you don't want to have to write out all this code to render a cube let's pretend that the kind of for the sake of this that this is how our engine renders the custom shape in which we provide the vertices and the indices right so if if this is our custom data that we're providing that obviously needs to be there but then this i think could be a lot more simplified so you could for example make a vertex array don't worry about binding it you can set the layout because that needs to be done into the vertex buffer this code needs to be here obviously and then this code needs to be here obviously right and then i guess you need to add it somehow but like all the kind of binding and the you know that stuff doesn't need to be here you want to keep it as simple as possible you could even write a kind of constructor for a vertex array that actually takes in a vertex buffer and an index buffer and like a layout or something like that so that it's really easy to just be like hey i have this information right i have this data and this is my layout that's my vertex array please like save this so that i can use it to render later now these code reviews are getting difficult if you guys let let me know with if you guys are okay with like a one hour code review every time i do this then please let me know because i kind of consciously want to keep this on 20 minutes but this is it's impossible to review a 3d engine um or even like something of this size which isn't that big in this amount of time maybe i'm just going through this way too finely but it's kind of it's kind of fun and i'm seeing a lot of things here okay i want to mention that uh using the standard math library not the biggest defense but you've got glm use glm right you've got a math library that presumably supports like intrinsics and ssc and all that stuff i don't think i don't know if the standard library supports that stuff to be honest so maybe i'm wrong but i would use glm instead of all of this stuff just to be consistent with your math library as well not to mention that you know this if you use the standard math library you're kind of leaving that up to the compiler so you might see different speeds across different platforms with different compilers whereas uh you know glm is presumably going to be stable um okay camera position camera lookout so what this yeah okay so we're looking at a point this is probably just going to do a lookout matrix yeah all right cool update view projection and then we create a uh projection times view okay sure pretty sounding camera class here render okay so this is interesting right so we start a scene we get our transform so this is going to be oh we actually have a transform so transform is a uh matrix here with a little notice card attribute that's cute um i don't usually use them that often but they're not bad obviously to use probably a good thing uh then we're taking the transform here um i would probably try and avoid copying this by the way so taking this in by const reference is probably a good idea so that we don't um necessarily copy it either that or you could take it as like an r value reference if you want um if you've got some kind of local kind of variable that you want to just move into there the the point being that it is 64 bytes um so it's probably worth saving the copy there uh initializing to identity by default so this is again something that i would reconsider the reason being that you've only got a single constructor that is taking in a transform right so this actually does nothing at the moment it might as well not be here because you're setting the transform to be whatever you take in the constructor so this is just kind of just empty code that um kind of uh you know is misleading because when you look at this you're like oh by default is that empty but actually it's not it's whatever you specify here i'm not even sure if i would necessarily have this class because literally it's a matrix um it's just a wrapper over mat four and i definitely like to not um clutter my code with things like this okay submit so we submit a vertex array we get that base shader there we go that's what i was talking about and then we submit a transform so pretty simple right we have a vertex array which contains the buffer the vertex buffer and the index buffer so we have all the information we need there to render the object we specify the we'll say material that we want to render it with which is the shader in this case and then transform is the the transform of the object where do we want to render it in our 3d scene and then of course we start the scene with a camera so fairly fairly kind of um standard i'll say straightforward render design here where we start like a rendering context with like our camera and our environment scene setup and then we obviously proceed to actually submitting entities for rendering by specifying uh both their actual physical like vertex buffer information as well as things like materials and transforms okay and then we end scene i'm interested to see what this does um yep okay so we're just literally taking the view projection of the camera and i guess copying it into the data and scene does nothing i had a feeling it would do nothing um and then we obviously of course set up our uniform matrices from this shader obviously assuming that they're there and then calling and running command draw index again very similar to hazel uh and then that will actually okay set um polygon mode to fill so that we get filled uh rasterized triangles here not wireframe or anything like that and then draw elements um in a pretty standard way um yeah i mean look uh pretty simple pretty effective i think obviously there's a lot of things that you would want to change in the future but you probably understand that and this is obviously a work in progress um you know things like assuming the uh primitive type as well as assuming the fact that it doesn't unsign into not like an unsigned short so because obviously we can have uh you know like 16-bit indices 32-bit indices stuff like that um and then obviously the fact that we might not want to render the entire vertex array at once in one draw course and we might have like a mesh with multiple different materials in it for example um but other than that you know it's it's pretty simple i would say this almost does too much for a uh draw indexed command because in hazel usually i like to keep these as separate commands but it's i think it's okay for this not a big deal um default clear bits enum val enum val okay just returns gl all right that's the enum value of this api um i notice your code convention's a bit interesting as well uh usually we like to like capitalize classes um you know the fact that you're using like snake case for this is totally fine a lot of people do that uh but i definitely have to say i don't like classes not being capitalized i would definitely capitalize them because otherwise you can't you literally can't tell the difference between a class and a variable name or a type um or a type name or like a you know function um and it just gets a little bit confusing uh but other than that yeah it looks pretty solid to be honest if we look at real api um and just see what it kind of maps to here so we're doing dll export so i guess we're compiling real as a dll which is fine and uh i think i've covered pretty much everything and then of course we have like an event uh kind of person again things like you know ev like um i would just write the word event you know like this to make it really quite simple um to understand because in general like i mean i personally believe that writing code you know you don't want to write overly verbose code but in my experience it's better to just write code that might be a little bit longer but make a lot more sense than code that is short and only makes sense to you and also you might forget about it in the future i mean obviously on event we're taking an event i guessed that this is an event it's not particularly difficult to read but still like i mean you know try and avoid um classes called ev because i think that that's uh just you know unnecessarily uh difficult to read okay then we've got a bunch of um and this is kind of part of the event class looks similar to hazel's event class um there's a few differences here i guess is events yep so that we can just kind of process different types and make sure that we are in fact dealing with something that is a derived class from our base event class okay cool um yeah pretty standard i think pretty simple windows window so i guess this is the window data for the window okay so we have a client window and we derive from the kind of game engine window okay that's interesting window dimension t i would also say avoid so many custom types right so key code t mouse button t mouse position t window dimension t window position t like this is all very unnecessary just have a just use uint 32t or in 32t or just int even i mean if it's not a big deal and you don't really care about like the uh exact number of bits i think that in general like i remember when i was a little bit younger and i was learning about cbs plus and i'm like oh my goodness you can make any type you want i probably also went crazy and made a billion types don't do that it's really annoying um and it doesn't help at all so just you know change this to just be either an m32t or even just an int or i mean like a window width can't really be negative so i'd probably write something like um32t like that really easy to understand and you don't have to have uh long names you know here you use a long name but event gets shortened to ev so yeah okay oh we've got some move moves going on here so that's kind of nice i was going to say that in general strings like i like taking strings in by const reference most most of the time this is a good uh opportunity or a good place to not do that right so if you take it in by value it's a lot easier to kind of move it in here presuming that we move it into title into this constructor in the first place which might not happen but there are some optimizations you can do with move semantics if you take strings by value so i don't want to say that it's like a hard rule that strings have to be const reference because they they don't and in a lot of cases you can get away with um well rather it will be preferable to take them in by either value or like has a string view or something like that um i don't want to really get into too much of that but the point my point is this is interesting this is nice to see as well um and then yeah i don't know things like moving callbacks like i'm not sure that i would do that um uh but um i guess it's not it's definitely not harmful okay um blah blah blah okay so it i mean in general i'm just saying and i'm just saying an extraordinarily large window class like why is this stuff not in the base window like this is you know this almost feels like windows when oh it is windows window okay right this is windows window it's just that it's inside the example or at least uh is it inside the example maybe it's just like linked somehow yeah it doesn't look like it is cmags just included this okay never mind so this isn't actually in this if we look at where the file resides in it's actually inside the real engine inside the engine i thought that it was inside the example project because that's what maybe cmake has included it because i guess it's used inside main um in some way or another anyway it's a bit weird thing in here but i guess that that makes sense that's very similar again to hazel um and then we've got input again with the positions um with the type of the custom type so i'll get rid of those uh and also i wouldn't use um i don't know if i noticed this before actually but i wouldn't use header guards like this anymore it's not like the 90s i would just write pragma once because i know that it's technically not part of the standard or whatever but it's it's supported by every compiler and pretty much everyone uses it so i would just use bracket once okay cool um i think that pretty much covers it so in general uh i mean i guess good work i i definitely question some of your naming conventions and some of your kind of uh different types that you've made um as well as just some of the api design obviously this is all work in progress and you did mention that you're 17 and you're just kind of inspired by hazel and following along so for that obviously you've done a really good job i'm clearly very heavily inspired by hazel there's a lot of architecture that's very similar to that which is obviously nice to see because that's the point of making the game engine series in the future uh for those of you watching let me know if there's something in the code that that um that i've missed maybe and that you noticed that i should point out or that you wanted to point out i want this to be more of a community thing i mentioned this before but i'm not like some kind of um you know c plus was god that just corrects people people's codes in absolute perfect kind of fashion this is all my opinion if you disagree with it leave a comment below share your thoughts instead um and then we can kind of even though it's me looking at this is kind of i guess us doing it together and i was even thinking about adapting this to be more like a live stream format maybe right even here on this youtube channel so that it can just get you know proceed to be like a uh uh like a youtube video once it's done but you know with kind of like chat or something like that we'll we'll think about the format in the future but in general uh let me know what you thought of this code review if you did enjoy it please don't forget to hit the like button if you have some code that you want me to check out submit it below i'll try not not to do a game engine next time i would love to like look at a little game maybe um or just some other kind of cool project that you've made so if you've got something interesting then definitely submit it and also one thing that i've kind of realized throughout this episode is that maybe it's it's a good idea for me to kind of pick a pick a subject just while i'm going through code in like one of these code review episodes just like pick a subject like in this in this case it was almost like the cube right and just hone in on that and talk about that kind of in more depth rather than trying to quickly read through all of the engine code and i don't know with this project i felt like it was a little bit more i guess overwhelming to try and get through it in a timely fashion than like the other project and i think that maybe maybe it would be more useful to people if i just kind of use the code as an example and maybe just give a brief overview of the coding style and just the the different kind of way that it's architected but then also you know focus in on something specific let me know what you think in the comment section below don't forget that you can get a free trial for skillshare by using my link in description below and i will see you guys next time [Music] goodbye [Music] foreign

Channel: The Cherno

Views: 47,172

Rating: 4.942955 out of 5

Keywords: thecherno, thechernoproject, cherno, c++, programming, gamedev, game development, learn c++, c++ tutorial, game engine, how to make a game engine, game engine series, code review, hazel, 3d game engine

Id: sIAXLH7ZqCw

Length: 35min 15sec (2115 seconds)

Published: Fri Nov 06 2020