i love your series cherno!

0:55 Better call Saul! mentioned.

Hi, has there been more livestreams of the hazel 2d? Or is this one the last one?

Btw, setting "double emSize = 40.0" seems to be a requirement, because otherwise the texture gets rotated as if applied a rotation matrix. Not sure what is happening here to cause this. If someone wants to debug, pls mess with the emSize value

anyone having problems with blending making sure to enable depth testing then enable blending. opengl is a state machine essentially and it matter on the order these are called This works for me: void OpenGLRendererAPI::Init() { glEnable(GL_DEPTH_TEST); glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } ps also for more complex blending you should sort the entities by the distance from the camera (furthest first) for proper blending from what learnopengl says of course there are more complex ways but this is the easier approach

it's weird that I can not install the HazelToolVS to my VS2022. But fortunately the Unity debug extension can work just like it

Following along, 26:40, "Don't do this at home" 🤣🤣

the view count indicates that people watch this video could do some big & high scale projects and following the schedule until the end no matter how hard it is. Also thanks for your work Yan!

13:10, Cherno please consider making that livestream for Vulkan in 1 day/stream

its so funny… you have been raving about pre-make and ranting about cmake for as long as I remember you… .. cmake is truly awesome … when u learn it 😉 …. not to mention your “but of course thats impossible with cmake” … what u really mean is “darn i still have no clue and dont want to make the effort to learn the new things that are so much easier to bitch about” … 🤣😂 … 😀 but i see u r now adopting more modern c++ features than a couple years ago.. way to go 👍

thank you for uploading the stream :D

CHEROOOOOOO YESSSS YOU'VE EMBRACED THE JETBRAIN WAYS. It truly is MILES ahead of visual studio in my opinion. Visual studio is years of bloat, I like jetbrains because they provide a very solid base then have plugins to add what is needed.

Music is a bit loud. Also stream would be much better without it

Anyone know what's he using for screen magnification/painting? Doesn't seem like it's the default windows magnifier.

Skill issues :)

*Remaking My First Game in C++ (Part 1)* * *0:00** Introduction and Project Goals:* The streamer introduces the project, which involves remaking his first game from 2012 in C++ using the Raylib framework and the CLion IDE sponsored by JetBrains. The goal is to create a faithful replica of the original game's functionality and visual style, including its software rasterization rendering technique. The original game, titled "Genesis," is a population simulation where the player controls a male character who must reproduce with as many female characters as possible within a 5-minute time limit. * *19:36** Original Game Overview:* The original game is presented, showcasing its pixelated graphics, day/night cycle, and core gameplay mechanics. The game was originally made for the Ludum Dare 48-hour game jam using Java and has a fixed resolution of 300x188 pixels, scaled up 3 times. * *26:18** Software Rasterization Explained:* The streamer explains the decision to recreate the game's software rasterization rendering technique. This means rendering graphics using CPU calculations on a pixel buffer, rather than using GPU-accelerated rendering, replicating the original game's retro visual aesthetic. * *32:22** Setting Up CLion:* The stream transitions to setting up the CLion IDE. The streamer walks through basic configurations like themes, font settings, keyboard shortcuts, and the activation of the experimental "Nova" C++ language engine. * *39:58** Configuring Raylib with CMake:* The integration of Raylib using CMake is demonstrated, leveraging a CMake script that automatically downloads and sets up Raylib if it's not found on the system. The project is initialized with a basic window displaying a magenta rectangle. * *1:00:42** Designing an Application Structure:* The streamer discusses approaches to structuring the game's code, favoring an approach with a global `Application` class and a `Renderer` class to handle graphics, while considering future optimizations and potential refactoring. * *1:38:09** Implementing a Renderer with Random Pixels:* A `Renderer` class is implemented with a function to generate and display an image filled with random colors. The streamer verifies Raylib's default scaling using nearest-neighbor filtering, which maintains the desired pixelated look. * *2:11:24** Introducing the Game Class and Level:* A `Game` class is created to house game logic and data, including a `Level` class to manage level data. The original game's level design is shown, based on PNG images where each pixel represents a tile type. * *2:58:56** Loading the Sprite Sheet:* The process of loading the game's sprite sheet is tackled. The streamer encounters a bug related to the deletion of the sprite sheet data and spends a considerable time debugging, ultimately tracing it back to a missing move constructor implementation in the `SpriteSheet` class. * *3:33:53** Setting Up Entities, Mobs, and the Player:* An entity hierarchy is established with `Entity`, `Mob`, and `Player` classes, mirroring the structure of the original game. The streamer highlights the original code's design decisions and plans for improvements in the C++ version. * *4:23:57** Handling Player Input and Camera Movement:* Player input is implemented using Raylib's input functions, enabling movement via WASD or arrow keys. The camera is then set up to follow the player's position, centering the player on the screen. * *4:56:46** Rendering and Animating Tiles:* Tile rendering is refined to include tile types and animation, specifically focusing on animating water tiles. The streamer decides against a complex entity hierarchy for tiles, opting for a simpler tile type enumeration and static functions for tile-specific behavior. * *6:06:28** Optimizing Tile Rendering:* Further optimizations for tile rendering are discussed, replacing the original game's multiple subclass approach with a more efficient system based on a `Tile` struct and function maps for type-specific updates and rendering. * *6:58:47** Implementing Randomly Scattered Grass:* The original game's randomly scattered grass tiles are re-implemented, modifying the level loading process to replace specific grass tiles with a different variant based on a random chance. * *7:06:59** Reflecting on CLion:* In the final segment, the streamer shares his positive impressions of CLion, highlighting its performance, responsiveness, and useful features like generators and code navigation shortcuts. * *7:15:24** Conclusion and Next Steps:* The stream concludes with the current progress committed to a public GitHub repository and the announcement of the next stream scheduled for the following Wednesday. The entire stream will be available on the "Cherno Unplugged" KZbin channel, and a condensed, edited version will be released later on the main "Cherno" channel. I used gemini-1.5-pro-exp-0827 on rocketrecap dot com to summarize the transcript. Cost (if I didn't use the free tier): $0.17 Input tokens: 127879 Output tokens: 1053

*Remaking Genesis: A 12-Year Journey from Java to C++* * *0:06** Game Overview:* The streamer is remaking his first game, Genesis, originally created in Java 12 years ago, using C++ and the Raylib framework. * *5:55** Animation and Collision:* The C++ remake already features basic animation and collision detection, implemented using a simplified tile system compared to the original Java version. * *26:40** Collision Implementation:* Collision is implemented by checking the "solid" property of tiles in the game world. * *27:59** Introducing Females:* The "female" mob type is introduced, inheriting from the "mob" class and featuring random movement patterns. * *46:51** Breeding Mechanics:* Breeding mechanics are implemented, changing the color of a female mob's tag to indicate breeding availability and spawning new "forest mob" entities upon collision with the player. * *51:56** Population Growth:* A "population" class tracks the game's population, increasing it over time and spawning additional females and forest mobs. * *1:56:26** Implementing a Timer:* A timer is implemented using Raylib's time functions, triggering events every second and displaying the remaining time to the player. * *2:06:56** Day-Night Cycle:* A day-night cycle is implemented by manipulating brightness levels. The original game's complex logic is simplified using a brightness delta variable. * *2:28:59** Implementing Torches:* Torches are introduced, using the "render light" function to brighten nearby tiles and mobs. A bug where the player remains lit even when away from torches is identified and fixed. * *3:08:41** Refining Lighting:* The lighting system is further refined, ensuring that the closest light source is used for calculating mob brightness and adjusting the falloff curve for smoother transitions. * *3:10:41** Menu System:* A menu system is created, using classes derived from a base "menu" class to represent different screens like the main menu, help menu, about menu, and game over menu. * *4:51:49** Publishing VODs:* The streamer addresses an issue with Twitch VODs being unpublished due to potential copyright claims and resolves it by manually publishing them. * *5:10:58** Implementing Sound:* Sound effects and music are added using Raylib's audio functions. Music is streamed and requires manual buffer updates each frame, while sound effects are loaded into memory. * *6:07:15** Adding an Icon:* An icon is created in Photoshop and set for the game executable using resource files and a tutorial found online. * *6:24:14** Building a Release Version:* The game is built in release mode using Cmake options to enable optimization and statically link libraries, resulting in a smaller executable file. * *7:06:29** Postmortem:* The streamer concludes the project with a postmortem, highlighting the positive experience with Raylib and Clion, along with some minor challenges and areas for improvement. I used gemini-1.5-pro-exp-0827 on rocketrecap dot com to summarize the transcript. Cost (if I didn't use the free tier): $0.14 Input tokens: 109111 Output tokens: 666

I find it interesting how you write the API of the classes before its data members. Usually when I look at a class the first thing that I look for is its memory layout.

1 hour for editor configuration, editting every piece of shortcuts, line placement etc. He's a true programmer, Comfort is the most important thing for every programmer.

do you think the clion comments requests might be paid biased. just saying. usually the market works like that. yes paid comments requests. some other similar stuff going on that just want more sales and market share etc. what market does is not what is actually useful. also popular is not what is truly useful and beneficial. neverheard of clion. someone usually makes a law that some stuff needs to bought, in some way, like community pressure or actual law. no care of usefulness, gov. try actual freedom instead. if your tools become the problem. make new better tools. rant mode off. too much fluff on current stuff. stuff. do you need that much stuff to make the thing happen, drowning in the tools complexity. yes if you spend most time in the tools and not in the product then whats the use. set new bars for productivity. this is not fine. God is good perfect, so have God.

23:52 every time we F-... we reproduce 💀

40:00 talks about quads and bounds

Mono ia dead.... How to do it with dotnet?

Your thoughts on FreeType? I'm implementing it as I speak.

ty, learning

Hey.. When are you going to post the VOD that you are refactoring your old game written in JAVA ? Amazing videos!

Its nice to see a new video on this series, I would love to see the runtime eventually too!

Hi Mr cherno. Can I ask a question about the asset manager in big hazel? Why we need to distinguish memory asset from loaded asset? In AssimpMeshImporter, the textures imported are always create as the memory asset instead of the loaded asset. I'm too curious about the reason.

Since the World Transform can be expressed as a single combined transformation of all matricies combined, wouldn't it speed-up calculating if you cache not th result, but the transform if the hierarchy doesn't change?

What happed to this guy? He was a dynamic handsome sharp fellow! Look at him now, just a fat guy who knows almost everything about C++, lol

❗ *promo sm*

Mate, you will never finish Hazel for a public release.

14:40, I guess first it's better to have some kind of logs visible to the user just so that he knows what the heck is going on 😅, apart from that you could try to reference an asset by id and by path if the id is not found

Okay so... I'm just learning Python since a few months and I have no clue what I was watching but this it still was amazing. x_X

I think this series was so ambitious it should have always should have been in this format. It's kind of unfortunate that it ran the course it did. At this point the series is so long and complicated that it's impossible to onboard new people.

Are there some episodes missing? I watched all videos on this channel and I can't remember starting an AssetManager and deciding on a zombie game…

Maybe it's just me, but I really don't think that Godot-like RefCounted system is better then just using std::shared_ptr. The only reason why they don't use it is probably because Godot doesn't use STL at all, for reasons explained in their FAQ.

It too long!

Why are we rewriting the asset manager? I remember this being completed ages ago

I know this was recorded a while ago, cause I could actually afford a Twitch Sub

is it close to release yet?

Finallyyyy

did you quit this series?

1 hour of game engine series per month

what makes you think that this is watchable?

Great stream. Thanks for continuing this series.

C# is shit, better remove it

If you need an caching system for models anyway, I think it would make sense to first implement that for images before doing this Async. This will save disk reading time and therefore alsspeed up showing the images a lot once they are cached. And personally I'm quite curious how much you could save from the 15 seconds after it is cached

Caching and async would each be interesting topics - hopefully they both end up on a stream at some point. Looks like you're settling into the new studio/office. Hopefully it gives you more time with the family. Thanks for the videos.

55:53 You can keep the original aspect ratio in the thumbnail if you divide newHeight with the aspect ratio of the original texture and use that as the new height in glBlitFrameBuffer call. Then it works just like in windows explorer.