I ACCIDENTALLY Created Hazel's Greatest Feature
Vložit
- čas přidán 17. 03. 2024
- To try everything Brilliant has to offer-free-for a full 30 days, visit brilliant.org/TheCherno . You’ll also get 20% off an annual premium subscription.
Hazel ► get.hazelengine.com
Patreon ► / thecherno
Instagram ► / thecherno
Twitter ► / thecherno
Discord ► / discord
Hazel ► hazelengine.com
🕹️ Play our latest game FREE (made in Hazel!) ► studiocherno.itch.io/dichotomy
🌏 Need web hosting? ► hostinger.com/cherno
💰 Links to stuff I use:
⌨ Keyboard ► geni.us/T2J7
🐭 Mouse ► geni.us/BuY7
💻 Monitors ► geni.us/wZFSwSK
This video is sponsored by Brilliant.
What did you guys think of this video style? I’ve been trying to make my dev streams into entertaining videos in an effort to show more of the real work that goes into Hazel, and by doing so actually spend more time working on it.
Don’t forget you can try everything Brilliant has to offer-free-for a full 30 days, visit brilliant.org/TheCherno . You’ll also get 20% off an annual premium subscription.
Those cuts are a bit too fast, other than that - I love it!
This video is significantly more engaging than previous dev logs. If this is the result of you now having an editor, keep using an editor. Great work!
Its very good!!!
Damm, this is so much better!
Already loved you videos, but this even better :)
Love this style!!!! Do this with your normal Dev Vlogs
Take a shot everytime he says "yeah?"
I'm so drunk
Gonna send someone to the ER for sure.
Yeah, right?
😂
That's probably his coffee speaking
Vídeo was good until I read this comment XD
My idea why Epic does it the way with Unreal Engine (and perhaps others with their engines as well) is that they want to give off a "What you see is what you get." feel. So like, by already fully importing your asset into the final format, the Editor can basically show you a very accurate final representation of the final game. While when you do it like you described, there could potentially be a discrepancy later down the line where the editor view looks different / inaccurate to the final packaged game.
Not saying your method is wrong or anything, but that could be a reason for why Epic opted that way.
Not only that but I can see this result in poor editing experience if the data isn't optimized for rendering in the engine. Game engines usually knows what the most optimal representation of a format is, and so can do the best-effort optimizations and store them in formats that fits the engine's pipeline without destroying the original source file.
An example would be importing images as textures; there's no need for the editor to render textures at full resolution of the original source. It would result in terrible performance if you imported high resolution textures for a large scene.
In Hazel, as it currently stands, it would require a custom import pipeline _just_ for optimizing the editing experience, and they would have to know what the optimal formats are for the engine, rather than the engine doing the work for them.
@@dealloc Or just an intermediate step on resource loading that optimizes the data structures in memory lazily after it is loaded, so the next time it loads faster.
Because really what game engines do is 2 step import, they import gltf to udata or whatever, then load it into a memory data structure, but before that it has to be converted again to the end format that the hardware wants. Ideally the data stored on disk would be in the same format that the GPU wants, but we know there's compression, so there's another intermediate conversion/import step.
You end up having to process the data structures when the game loads, or the editor loads anyway because you have actually 3 representation formats to the same data (disk, memory/engine, gpu/final).
I think what game engines tried to do is to cut the number of formats and ideally store data on disk in the same format it is needed to be sent to the GPU, maybe maintaining all that conversion code is a problem.
"rather than the engine doing the work for them" , The engine is still required to do the loading of the file from disk, its at that point that it can decide to create an optimized version and store it in a cache directory, but of course that can create invalidation problems.
For ex, I'm using a heavily modified Irrlicht engine as the engine of one of my 3D visualizer applications, and I have "duplicated" code to support GLTF, FBX, OBJ, etc, the engine directly loads from that file format on disk and then convert to data structures in memory, and then converts to EGL triangle strips for the GPU, ideally I would store EGL data directly on the disk and not do any conversion, except maybe decompression on loading, I think that's why game engines usually have their own format, it this "duplication" of code, its less code creating the internal data structures of the engine. Developers hate to duplicate code, but the real problem isn't even being solved, which is duplicating data structures (you have 3 representation of the same data). Data structures are more important than duplicating code, because they affect performance, having to create code to optimize for every format, so it can load in the optimized final data structure format for the GPU isn't that big of a deal for performance, it just requires more code to be maintained, which isn't that big of a deal, excess abstraction is.
So basically, you could basically import GLTF and double convert it to the final data-structures the hardware wants, and it would be exactly the same amount of work done by any engine, except at different times, the data optimization can be done in background as the editor runs. And it would be what you see is what you get and also have the cool benefits Cherno says of direct editing the source data (at the cost of more code and having to deal with cache invalidation of the editor).
Imo also optimization is one bigger reason this does not always work on bigger projects as lot of assets can be in a weird and compressed format and quite big. Working live with for example longer audio formats or image sequence data that is compressed in time domain, the working pipeline gets messy and memory hungry as in many cases you constantly need to decode the full asset. When working with internal representation then it can be optimized to load only bytes what's needed. I can see edge cases with multiple orders of magnitude perf difference.
Other thing might be code maintainability, it might be better to encapsulate all import logic (there is always a lot of edge cases and fixes and settings) in import library so all asset processing logic is completely isolated from data formats. Imagine 20 different audio format importers and only one asset parsing/rendering functionality based on for example converted wav format or opposite - 20 audio format files directly linked in asset metadata so asset parser needs to handle all the import weirdness for every format every time.
Maybe I got something wrong and it is already meant to be converted and cached into this intermediate for example wav format but still not convinced.
It sure can be done but the bigger the file formats support the messier it likely gets.
You all made really good points actually!
And yeah i think further down the line and depending on project scope, this hot reload and just loading the source asset could potentially become a big issue. While for Indie Projects it's probably not a big deal, but for AAA or even AA....
If you have like huge source files for like e.g. 3D scanned models, motion capture data etc. then keeping a "hot reload" on these would become quite the issue. As you guys said, loading such huge assets into memory would very quickly fill up all available memory. Also dev machines don't have insane amounts of RAM. So it would make much more sense to already convert your 3D scanned model into a much more efficient format the engine can deal a lot better with. Not only probably reducing memory load, but also performance cost in the editor. Potentially you can already do some optimizations during the import.
Also my initial thought could become even more an issue, since for packaging, models then get converted properly, you just don't know what data gets perhaps changed / optimized and how compressed. Essentially, thinking of a AAA project, packaging the game which takes hours and then finding out that some of your meshes just look "off" or "wrong" in the final package is just... shit. And you have to do the whole process every single time just to check, if it now looks like what you want.
I guess in the end the manual reload becomes a much less nuisance since it does give you more stability and you directly see in the editor if it looks like you want. Perhaps the better trade off, clicking a button and waiting a moment for a re-import vs. wasting potentially hours every time to just check if it NOW looks correct.
Not saying that it will happen, and that meshes will look off. But you never know... seeing how insanely large some source assets can be in large productions...
@@Speed74LP You don't have to give up hot reload per-se. Hot reload just means not having to manually refresh the assets; it can still work by re-importing; the meta data in Hazel already contains the original location and ID (hash?) of the original source asset.
My guess is that Cherno wanted to have more immediate feedback, without having to waiting for re-imports each time, which would be the result; especially if multiple assets were changed between revisions. But that is, IMO, a tiny cost compared to loading source files as-is in the editor for larger projects.
I manage my render queue with git
deferred rendering
Quality comment
Imo the UI could better reflect the fact that all those static meshes do not have the mesh data in them.
So having the UI components be the same size and equal with the mesh components in the UI gives an impression that they are completely separate entities with the copied data. It would make more sense for the metadata to be visually attached to the original mesh somehow either by being in a separate list inside the same container as the other information about the mesh or by somehow given as options when dragging in the normal mesh itself in a form of "Hey you got all these metadata versions of your mesh, which one do you want to drag in?"
Some of my best features were created by accident, I say run with it!
My initial impulse would be to fix this. User, as a base rule, expects consistency. Most people are ok with manually refreshing assets in scene but would welcome automatic and near instantaneous reloading, but not based on whether the assets' thumbnail is visible or not.
The way I understood it the idea is to make this into a feature independent of the thumbnails. The thumbnails just kinda triggered this as a side effect, but they're not necessary for this to happen.
I get so excited when cherno gets excited about something he made.
man these new stream highlights are sooo good. Please keep uploading them
Dude! This is so exiting!!!! Im so hyped for the insta uodate thingie. MOREEEE
Funny that modders dream of having this in the game release build too. Someone will do it. Accidentally...
The "Accidentally..." at the end *_got_* me! 😂
"Yeah?"
I did this very thing with my raycaster engine, I setup a class that acted off the asset manager but paid attention to specific absolute file paths of things currently loaded (to minimize the number of files I’m iterating through as possible) and would essentially do a quick exact date string check, and if there’s any difference it’ll invoke that assets load() routine. This allowed me to play my wolf3d like game while realtime modifying the map in my text editor, editing level textures in real time, placing entities in real time, updating entity data like textures / health / even animation sequences, audio too. It really wasn’t that difficult to do, but some of my friends who are used to bigger bulkier general purpose engines were flabbergasted how easy and instant my project could handle real time updates.
Thinking about that project makes me want to work on it again.. now that I think about it
I love how passionate he is about this
Aren't we all passionate about our game engines?
@@Brahvim true
Wow, so cool, eventual thing that happens to you when you a have very excellent project design, organization and implementation approaches🙌🏻💫
I guess you need to make it check all assets in scene for updates while working in the editor then you’re golden!
This is how my engine at home works too except that the directory tree is just monitored for changes.
When a change is detected (new, delete, modified) the file monitor just tells the resource manager and it goes "okay I'll hot-reload that if it's currently loaded".
... then you get the same thing, but without having to view a thumbnail 😉
On a separate note, there is one benefit to imported assets that you're perhaps glossing over a little (although I take your point re "it's the editor"), which is that imported assets should already be in their runtime format. You can combine that with the above, where you say "if the source asset changes, automatically re-import, and then hot-reload the imported asset" and that works just fine. You get live editing, you can sync source or imported assets while running, and if your import step isn't slow then it's effectively instant too.
Just food for thought if you're going down this path anyway 👍
this sounds nice
Now I love TDD .
I wondered if this approach will be effective for generating a mesh procedurally and potentially modifying it using sliders
an icon in the top left corner of the thumbnail would be cool. I don't wanna be looking at the same image and thinking "why do I have another avocado"?
Still think that a engine runtime mesh storage format is useful when you have larger and larger levels and projects. Even a 20-50% difference in size can change a lot in performance.
I think both make sense, but both have trade-offs. For me, I'm used to the import process workflow and don't mind it, since it's usually pretty fast, even with importing giant single files in Unreal.
Still look forward in seeing how Hazel goes :)
Just as usual I'm motivated again ❤
I'm actually really enjoying these new videos... :D
Dude, I've been a software engineer for a bit over 20 years and still game almost every night.
LOVE your channel. Really enjoy seeing how the how the sausage is made.
Tonight has been my most favorite vid of all.
“Right” count: 29
“Yeah” count: 33
Yeah wins! Right?
It's mostly mostly “Right” at the begining and the flip to “Yeah” is about 8:20
btw. This IS a cool feature.
Nice to see more tech CZcamsrs in Melbourne!
I've done this with Lisp; I can update meshes and materials as the game is running. But not only that, I can change the logic as the game is running and if something is wrong, the game pauses and I can inspect the state; change the state and the logic and continue the game. It's a very nice approach to coding games.
Man, instant autoupdating is some serious devex. Love it.
Every day we get closer to runtime asset streaming game engines
This is so cool!
Love watching these Hazel update videos. I wish I could use it, but I’m on Linux. 😢
Very interesting topic. This essentially removes the step of having to update the engine material instance related to that "data" file whenever it updates. How do you handle scene objects having that material when for example you remove that material file?
YEAH!
Reminds me of the Gadot asset stream
Happy to see you smile in thumbnail 😊
Real engineers not allowed to do that however
Did you used to edit out the extra "yeah"s before had editors? Because I definitely do not remember your YPM (yeahs per minute) being as high as it was in the video.
I was wondering the same. But maybe he's just really excited about thumbnail driven development
Nah, I'm just super fired up in this video/stream so I let the yeah's outta the bag a little too much... I'll try and keep them under control next time 🤞
The asset manager is so cool, I love it, you should however make it very clear that the sourcemesh is a sourcefile and not a directly applicable asset. Visually that is.
The problem is not the updating of the textures and assets. The problem is the checking for changes in all the files.
This might be fine for a some thousand files but as the szenes get bigger it gets worse because you have to check all assets periodicly.
You could resolve this by checking only the assets currently visible in the scene. (Obviously not every frame)
Alternativly you could introduce groups. -> Fixed ammount of assets in one group -> always check only the assets of one group for updates.
This makes the load predictable which is always nice to have
You don't have to check for changes at all. You just subscribe to the event "file change" inte file system. And the OS will handle that and send event when a file has been changed in the folder(s) you specify. (FileSystemWatcher)
I'm following your 6years old cpp video :) and it's insanely good
Technically, you don't even need to read the files from disk on every frame. I've done this kind of thing before in java and you just attach a listener to the directory or file path. Then the file system will tell you when the file has changed.
What is the program that you zoom in and draw lines? Thanks in advance
cool as heck. I love it. My one concern is, should there be a popup to prevent unwanted reloading of assets? It could have a "don't ask again" checkbox or something similar. That way, people could decide whether they want this always-loading behavior. I could also understand if you would want the system to be opinionated about this, though - maybe having an option to turn it off in the settings would allow people the freedom to choose without bugging them with popups.
You got to love happy accidents
would it be still fast on big project?
weeel, in Unreal u have the whole Nanite/Lumeb pipeline in the back that definitely NEEDS to import and work its magic on the mesh. Otherwise you just could not use that stuff. Highly recommend to read their papers on that topic. Its heavy stuff, but explains why importing is needed, at least in UE5
But why are the thumbnails checking if the file has been modified on every tick, but the folder doesn't get updated when new file gets added (you need to press refresh)?
Wouldn't it be weird if only assets of current folder are always live-updated while playing in editor, but not all assets of other folders.
It doesn't seem to scale, if it needs to check file modified for every file in the project on every tick.
bro realized he has to make it a polished feature
I'm sold on this engine. Been hearing about it from you for maybe a year or two, maybe even longer. Initially, I thought, 'Okay, another engine among many, what's the big deal?' Especially since I thought it was just one guy working on it (I've since learned it's an entire team). Over time, as I've struggled to find an engine that suits my needs, yours keeps popping up. Unreal, Unity, Godot-they're great, but they miss a certain something. Hazel, though, feels different. It feels like every line of code is carefully thought out and managed. It doesn't just pile new systems on top of old ones to meet standards while introducing new features. It feels like Hazel is designed for significant internal shifts, maximizing effectiveness.
Yeah, that's how I instinctively did it in my engine. I was considering unreal approach but when i thought about it, it just didn't make that much sense for me to use. I'm sure unreal has a reason to do it their way and i see the advantages, but having meta and data separated is quite nice to work with.
You can do the DirectStorage stuff using nvidia's RTX I/O with Vulkan. Not sure if you'll ever see this but I hope it's helpful!
amazing! i wish something like this will be also in unreal engine :D
Greatest inventions are always accidents - good accidents
Well technically you can create an instance in unreal of the original asset and that works faster rhan Hazel for what it allows you to change in the editor. It's fully real time.
So, it's more like "Date-Time-Driven development". It's cool to have that live update behavior.
"ooOOoooooh! That's a nice name, too! I really like it.."
_...yeah, I do sound cringe. I am _*_very_*_ sorry._
thumbnail driven development XDDD
Now the viewport just has to update even when the thumbnail isn't visible
Sounds like the date should be on the asset manager not the thumbnail
What is your system or workstation hardware requirements ?
that's great but how is the file watching actually done? since you have to manually reload after copying an asset, I'm assuming it's not going through all directories and checking for new files. So does the engine just use the asset registry and check every update loop if the date of the source assets match the loaded assets? Does that even scale well? what if you have thousands of assets?
There are OS-specific functions that one can use to receive events when a watched file is modified/deleted/etc. And there are cross-platform libraries, opensource ones on Github, for example, that wrap this stuff nicely.
File watching can (and should) be handled by the OS, which can notify the process whenever the watched files have changed-typically based on a mask of the changes you are interested in, i.e. specific file attributes. On Windows this can be done with the "FindFirstChangeNotification" API, macOS with fsevents and Linux with inotify.
@@deallocexactly!
@@dealloc that makes sense, I've only ever worked with file watching in my past life using libraries that highly abstract those details away and I didn't realize they're probably subscribed to OS events under the hood as opposed to looking for file changes manually every x seconds
@@phee3D Yes, there's a lot of abstractions that you work with which can hide the nitty gritty details.
Even things like threads and async I/O often relies on libraries that abstracts away the underlying calls to OS APIs (and in some cases syscalls). Eventually the OS is the closest thing to the hardware you need to communicate with, and the most effecient way-but not necessary the best way since working directly with OS APIs and syscalls can be tedious, especially with cross-platform support.
Why is the second avocado "static mesh" asset, which only contains metadata, needed? Looks like bloat if the asset is just a pointer to the original mesh but it duplicated the number of items in searches. It's strange.
If you were to implement this, would you make the asset manager responsible for keeping assets current? I'm thinking that would be the easiest. Lets say every 100ms check all in use assets for an update? If there are some to be updated add them to a queue? This might simplify the thumbnail system a little bit because it would no longer have to check if a asset is up to date or not.
I use Unity and Unreal a lot, and I think about this issue a lot, as unity is very similar to this method, where I have the fbx, then I have the meta file associated to it. Unreal is how he described, ideally I would love something in the middle. I've thought about how I would implement it, although I've never made an engine. And I don't see why you cant have both pieces.
In my mind, you drag the file into the content browser, fbx or whatever, you keep that there as a file, then, you generate the optimized version as hzfbx or whatever with the metadata at the top. I don't see why you couldn't still use the same asset database, to load up all the meta files, those in-turn load their original files to see for changes, if they are changed reimport, if not whatever. those are then used in-game as he mentions. It's basically the same, just with the optimized import that you then WYSIWYG in builds too. I would personally require in play mode to hit a refresh button, but in-edit mode I would refresh maybe 10% of the assets every frame or something.
I can't tell if he's joking about "inventing" WYSIWYG or if he really thinks he's the first
16:30 what’s wrong is that
You will be in hell while linux programmers and terry davis are in heaven.
hmm I think Unreal does the import process as a check to make sure the intermediate doesn't change to an invalid asset for the metadata. Data validation at reimport time. Plus, on larger teams, the person using the static mesh could be a level designer who does not understand what the correct metadata to select might be. The author of the static mesh does. I'm not saying it's better, but I suspect that is the advantage gained in this particular tradeoff.
But yeah, that hot reloading is sexy
That's cool! Doesn't Godot do something similar to that? If I remember correctly it just reads directly from the directory, the original asset.
I think your right. Been using godot recently and noticed that I can drag files into folders in file explorer and the editor would update to show them.
yup! just tested it, Godot actually just uses the original file in the editor and generates a ".import" metadata file when you drag it to the project folder. It generates the "metadata file" when you drag to the folder, which is a step earlier that what you've described, but seems like it's a similar idea.
@@VitorGuerreiroVideos Godot converts files like meshes or textures in an internal format in the imported directory, but also optionally inside the actual scene file (make local). Updating changes can sometime break, or not do anything if the file is local already. But there are usecases for those approaches.
I don't know if it does, but I'll tell you that half the time I reimport an image or something, the thumbnail in the editor does not update at all. It's been like that for some time.
Time to write a book about Thumbnail Driven Development
Neat. So you save time and disk space by not copying files into your local directories as well as minimize RAM usage because assets can be unloaded when you're not looking at them.
_Now_ - even I'm proud that Hazel exists. This comment is not memey. Just me expressing the excitement of making game engines and the fact that Hazel _actually_ feels like it DOES have "all of it" with the asset hot reload feature!
*_Thank you for sharing your journey with Hazel, Yan!_*
Oh, and _for my learning purposes,_ do get me wrong on the following statements! (I mean, help me refine my understanding, please!):
The way Hazel stores metadata instead of a mesh's data - that's some data-oriented design, right? Like, "handles", in say, a low-level API, like an operating system's. I call it DOD _("data-oriented design")_ because of the fact that there are features that treat this as an advantage - for example, like Yan describes!: The packaging of assets into the executable that Hazel builds (which uses this 'dependency tracking' approach to produce results that are like the results of something like, say, tree-shaking!), as well as the instancing-like feature, where Hazel uses 'mesh-sources' to produce many kinds of meshes for you to use, without duplication of data or anything. Ahahah! Awesome stuff [to me given that I'm a beginner]!
Thank you, reader!
so basically git is now a part of the engine :D
So Im guessing that you DO have an intermediary format of all assets that gets constructed and saved in ram once they are put into the scene tree or something? In the example at 10:00 you explain it as if your header points to the raw GLTF data. A larger point of having an intermediary file is to have a unified and standardized structure for the data which can be easily read by the engine at runtime to put on the GPU, no? You have to process the mesh file data at SOME point to extract the actual index arrays and vertex arrays, for example.
You explained it all very concisely but I'm very confused how this actually works in practicality. I have not worked on any industry-grade game engine but have read academic papers and books about the common ways in which this is done (as well as WHY it was done) and have also implemented game engine asset managers in C++ in different larger projects myself, and I'm still confused.
I love your channel and the information that you give out so I'm just super curious how it actually manages to work on the lower end of implementation.
He basically just swapped offline processing for online processing. And until Hazel is used in an actual larger production, all the possible annoyances will not be visible. Also import options cant just be asked for when dragging thing into the scene. That must be fixed metadata for any file. There are tons of things that need setting (texture compression, flipping Y channel for normal maps, adjusting bone import mapping, assigning material overrides etc)
Love your vids.
I forgot she told me yeah yeah
One case against hot-loading is committing the changes, or "undo". Let's say I want to do some irreversible transformation, but then I decide I dislike it, and I want to go to my previous version. Since the transformation is irreversible, then the engine would have to store 2 versions of the assets, one way or another.
great content
Very cool
I really don't know enough about the topic. But yeah... This would work when simply changing colors and such. But what if your existing mesh is already part of more complex meshes, and you changed the actual mesh, not just its color? Couldn't that potentially screw up everything?
this guy reached enlightenment out of nowhere, yeah!? 🤣
Does hazel have 2D features and how do they compare to unity and godot?
"Yeah" count: 36. Nice vid yeah !
Won't it be inneficient in case you use large files, like high quality textures?
Aaaaaand @6:04 this is what a developer frustrated with bloated corporate decisions sounds like, folks 😆
It's weird to me that the metadata associated with a mesh is stored in a different "mesh" file. This feels like it will get really confusing (is this the raw mesh? or the static mesh? or the dynamic mesh? or the banana mesh?). It seems to me that this metadata is not a "mesh", but a property of the scene in which the mesh is being used. I might want one scene where the avocado is static, and another where it's dynamic, or where some other metadata property is different. What would make sense to me is that you have mesh files, then you have a scene with objects, and each object has a mesh, plus metadata. You wouldn't see this metadata in an asset explorer, because the only "asset" is the underlying mesh. Signed: some rando on the internet.
Agree, this should be the default. However would like to be able to turn this off on project-by-project basis
I only create bugs ACCIDENTALLY :D
What happens if we delete the mesh source that was being referenced by the meta data ?
Obviously it will break the asset in-game but that is expected and IMO should be the desired behavior.
It may sound reasonable to have the asset still work, while it's main source file is dead or missing, but you really don't want that during development, this is because final in-game assets, are very optimized and many information necessary for editing, is removed from the final asset, making baked final models, very hard (or even impossible for most developers) to edit after export. And I don't think is good to use assets during development that you can't edit.
Unless you are the developer of the asset format and know how to revert it back...
@@Argoon1981 I get that point but I was confused at 10:40 , when we compare .UAsset vs .hsmesh , .UAsset is self sufficient but for .hsmesh we only store metadata in it and it references the Mesh Data and is not self contained so what would happen if we delete that Mesh Data , all the .hsmesh files which were referencing it would break right? Would that be ideal or am I Missing something ?
Are you saying hazel’s content browser is blazingly fast?
i want hazel, but i can't pay...
Yeah that good. I think Unreal Engine and all the other engines are hindered from their old baggage. Tech has changed but they still need to accommodate the old code.
i understand the reason why you would do it your way, by just dumping and letting engine do the rest but having import options is still nice.
yeah?
The downside maybe is when your assets are stored on a network drive, or any remote drive that can get disconnected unintentionally. In a studio environment you very often rely on your NAS storage.
Also, as I discovered myself, Windows has a pretty crappy way of handling offline network drives. Too many apps become slower (including powershell running a simple command) because they're trying to check if something exists on a storage resource that's offline. 🤦♂🤦♂🤦♂
A few too many yeah's
yeah
That's so funny 🤣
Great video!
You say "yeah?" way too much, but other than that, I like the format.
Damn I wanna work in that game engine. The poor syncing of assets with got is what put me off most engines.
I'm sorry @TheCherno 17:50 tabletop wargamers have been saying WYSIWG for at least the last 20 years and I think some Xerox exec's wife said it in the 70's or something.
Pretty cool, yeah?
so it's like unity .meta file ?
Was gonna say this! What he's describing sounds almost exactly like Unity.
Except I guess, Unity generates "Shipping" versions behind the scenes for use in the editor Libraries folder. Using the editor you never see that though. Unity is kind of the best of both worlds. Split out meta files and optimized assets in the editor.
That is very cool ! One thing id consider tho (if its not already in there) is that i might not want to keep my assets in the Hazel asset registery/directory. You might want to allow (a bit like windows path) to specify multiple places/path the user can specify for his assets. A good example use for this is. Imagine a dev teams that has their assets loaded into a NAS where team artist dump the models. Imagine how cool that would be. An artist just finished his mesh and dumps it into the NAS, all the devs just hit refresh and boom they all instantly have it. Woudnt that be wonderfull !
This is the only type of TDD I'll waste my time with!