diff --git a/Engine/Engine/Shaders/Definitions/2D/billboard.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/2D/billboard.vtsdef.vtmeta index 57b8074e5..c167cab59 100644 --- a/Engine/Engine/Shaders/Definitions/2D/billboard.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/2D/billboard.vtsdef.vtmeta @@ -1,10 +1,10 @@ Metadata: - assetHandle: 15136988847370015351 + assetHandle: 585492020858108193 filePath: Engine/Shaders/Definitions/2D/billboard.vtsdef type: 7 Dependencies: - - 15049971953168935482 - - 14596888969656169387 - - 16412945933612528755 + - 1746948195225081534 + - 17114040380507038797 + - 7790196234502764883 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/2D/line.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/2D/line.vtsdef.vtmeta index adcba43b3..2842e4326 100644 --- a/Engine/Engine/Shaders/Definitions/2D/line.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/2D/line.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 9553159252088009564 + assetHandle: 5961308220321977209 filePath: Engine/Shaders/Definitions/2D/line.vtsdef type: 7 Dependencies: - - 16244739428916651028 - - 8652728642948850320 + - 4130123315620204099 + - 15330101710155819216 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/2D/particle.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/2D/particle.vtsdef.vtmeta index 3bb2f4e37..62bd95210 100644 --- a/Engine/Engine/Shaders/Definitions/2D/particle.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/2D/particle.vtsdef.vtmeta @@ -1,10 +1,10 @@ Metadata: - assetHandle: 14191556180656021201 + assetHandle: 13783186330635476140 filePath: Engine/Shaders/Definitions/2D/particle.vtsdef type: 7 Dependencies: - - 16312622993519494368 - - 13060053700122240821 - - 13968960746862725779 + - 17303629067289062319 + - 7333808985412559288 + - 12894686563302475048 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/2D/quad.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/2D/quad.vtsdef.vtmeta index 0d3d334c4..fa67aae5d 100644 --- a/Engine/Engine/Shaders/Definitions/2D/quad.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/2D/quad.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 2457044044311143512 + assetHandle: 12407222213850309022 filePath: Engine/Shaders/Definitions/2D/quad.vtsdef type: 7 Dependencies: - - 10798280601690009728 - - 3512387666108709840 + - 14307076154255412709 + - 11465030724416367464 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/2D/text.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/2D/text.vtsdef.vtmeta index 4a9592b83..48d81d042 100644 --- a/Engine/Engine/Shaders/Definitions/2D/text.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/2D/text.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 14517565385528167745 + assetHandle: 6784887531298128888 filePath: Engine/Shaders/Definitions/2D/text.vtsdef type: 7 Dependencies: - - 927757418871849614 - - 6812817055861832887 + - 16326240539526189605 + - 4759303392739937285 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Compute/depthReduction.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Compute/depthReduction.vtsdef.vtmeta index 03a43240c..d5a0e5e85 100644 --- a/Engine/Engine/Shaders/Definitions/Compute/depthReduction.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Compute/depthReduction.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 12580255423346362675 + assetHandle: 10100503024771641464 filePath: Engine/Shaders/Definitions/Compute/depthReduction.vtsdef type: 7 Dependencies: - - 3979947650794548229 + - 17154850799399108920 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Compute/generateMotionVectors.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Compute/generateMotionVectors.vtsdef.vtmeta index ac0b4adee..f9f5597f9 100644 --- a/Engine/Engine/Shaders/Definitions/Compute/generateMotionVectors.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Compute/generateMotionVectors.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 11617270491698955271 + assetHandle: 11652032054238079956 filePath: Engine/Shaders/Definitions/Compute/generateMotionVectors.vtsdef type: 7 Dependencies: - - 17850854312759922289 + - 7165052867735898511 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Compute/lightCull.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Compute/lightCull.vtsdef.vtmeta index b4742f210..994f82a24 100644 --- a/Engine/Engine/Shaders/Definitions/Compute/lightCull.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Compute/lightCull.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 9390687463083118559 + assetHandle: 16030116979251359974 filePath: Engine/Shaders/Definitions/Compute/lightCull.vtsdef type: 7 Dependencies: - - 5956773354011343704 + - 2228964935288828824 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Compute/sssBlur.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Compute/sssBlur.vtsdef.vtmeta index 644f64461..7a9c76a6e 100644 --- a/Engine/Engine/Shaders/Definitions/Compute/sssBlur.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Compute/sssBlur.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 9246287954784993296 + assetHandle: 14443470579464330243 filePath: Engine/Shaders/Definitions/Compute/sssBlur.vtsdef type: 7 Dependencies: - - 4125849356268107829 + - 6835451459480640531 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Compute/sssComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Compute/sssComposite.vtsdef.vtmeta index db9ec252f..3aae9eeea 100644 --- a/Engine/Engine/Shaders/Definitions/Compute/sssComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Compute/sssComposite.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 6784638589642478868 + assetHandle: 17288527058691534305 filePath: Engine/Shaders/Definitions/Compute/sssComposite.vtsdef type: 7 Dependencies: - - 6135401567621209146 + - 2892278115364692890 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Deferred/decal.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Deferred/decal.vtsdef.vtmeta index dee680112..140892362 100644 --- a/Engine/Engine/Shaders/Definitions/Deferred/decal.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Deferred/decal.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 1051185456672539728 + assetHandle: 16823523339031218928 filePath: Engine/Shaders/Definitions/Deferred/decal.vtsdef type: 7 Dependencies: - - 13277876072457634846 - - 15364409864408163782 + - 2844431812623975525 + - 8894298428766099984 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Deferred/deferred.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Deferred/deferred.vtsdef.vtmeta index 00a2e46a2..502aa29bd 100644 --- a/Engine/Engine/Shaders/Definitions/Deferred/deferred.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Deferred/deferred.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 2476914073847913243 + assetHandle: 15332723922649589144 filePath: Engine/Shaders/Definitions/Deferred/deferred.vtsdef type: 7 Dependencies: - - 17633572153581414977 - - 11930847771017622628 + - 11138145988443942200 + - 8347663285989942360 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Deferred/deferredShading.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Deferred/deferredShading.vtsdef.vtmeta index 3bc7256f3..be89892c3 100644 --- a/Engine/Engine/Shaders/Definitions/Deferred/deferredShading.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Deferred/deferredShading.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 12824071054137530994 + assetHandle: 17976384317247551253 filePath: Engine/Shaders/Definitions/Deferred/deferredShading.vtsdef type: 7 Dependencies: - - 3960943964559254294 + - 3578397422449156617 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Editor/colliderDebug.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Editor/colliderDebug.vtsdef.vtmeta index 86a599188..8e16c269d 100644 --- a/Engine/Engine/Shaders/Definitions/Editor/colliderDebug.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Editor/colliderDebug.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 10350968135567944220 + assetHandle: 6530562566454829558 filePath: Engine/Shaders/Definitions/Editor/colliderDebug.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 3630795769804761510 + - 3601805211560947120 + - 17449542838329971233 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Editor/grid.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Editor/grid.vtsdef.vtmeta index 31f69cf98..1e5c15400 100644 --- a/Engine/Engine/Shaders/Definitions/Editor/grid.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Editor/grid.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 11685137258237284022 + assetHandle: 11318972731203596950 filePath: Engine/Shaders/Definitions/Editor/grid.vtsdef type: 7 Dependencies: - - 10333585351520757801 - - 6212267489373485534 + - 8828133760640228354 + - 503750040999919829 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Editor/navMeshDebug.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Editor/navMeshDebug.vtsdef.vtmeta index 5d175c5fb..68ad56ecf 100644 --- a/Engine/Engine/Shaders/Definitions/Editor/navMeshDebug.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Editor/navMeshDebug.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 2820475171386238705 + assetHandle: 4414389567644252281 filePath: Engine/Shaders/Definitions/Editor/navmeshDebug.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 7359963059665638003 + - 3601805211560947120 + - 9398311829184947408 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Editor/vertexColorVisualization.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Editor/vertexColorVisualization.vtsdef.vtmeta index 56e060be1..920bbb42b 100644 --- a/Engine/Engine/Shaders/Definitions/Editor/vertexColorVisualization.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Editor/vertexColorVisualization.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 7904364345790401573 + assetHandle: 11435955340030689368 filePath: Engine/Shaders/Definitions/Editor/vertexColorVisualization.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 15543690279891023692 + - 3601805211560947120 + - 13394621642338625548 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricFogInjectLight.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricFogInjectLight.vtsdef.vtmeta index 62395f5f3..cad1e0bde 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricFogInjectLight.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricFogInjectLight.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 2026137956591543497 + assetHandle: 4568994918066159140 filePath: Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricFogInjectLight.vtsdef type: 7 Dependencies: - - 5810568471916359425 + - 16839111756646803688 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricRayMarch.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricRayMarch.vtsdef.vtmeta index d397dd698..ac8052094 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricRayMarch.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricRayMarch.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 2299757592212547030 + assetHandle: 2461225861046004795 filePath: Engine/Shaders/Definitions/Environment/VolumetricFog/volumetricRayMarch.vtsdef type: 7 Dependencies: - - 914479535148210632 + - 16737677636808457441 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/environmentIrradiance.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/environmentIrradiance.vtsdef.vtmeta index d1000f83b..9f76dff15 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/environmentIrradiance.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/environmentIrradiance.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 1617039910843096862 + assetHandle: 9619188529545786396 filePath: Engine/Shaders/Definitions/Environment/environmentIrradiance.vtsdef type: 7 Dependencies: - - 10428837376462372131 + - 14590711002682899869 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/environmentMipFilter.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/environmentMipFilter.vtsdef.vtmeta index c3593636d..ccfb524b3 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/environmentMipFilter.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/environmentMipFilter.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 18288694320153380234 + assetHandle: 8223907025343505676 filePath: Engine/Shaders/Definitions/Environment/environmentMipFilter.vtsdef type: 7 Dependencies: - - 8221344861703282776 + - 8049198954314922344 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/equirectangularToCubemap.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/equirectangularToCubemap.vtsdef.vtmeta index 025f65182..b185656e2 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/equirectangularToCubemap.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/equirectangularToCubemap.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 8160978070378900156 + assetHandle: 17557695888895458033 filePath: Engine/Shaders/Definitions/Environment/equirectangularToCubemap.vtsdef type: 7 Dependencies: - - 1046117990186118766 + - 5244557820175129514 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/preethamSky.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/preethamSky.vtsdef.vtmeta index a5dad4ce1..e04896697 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/preethamSky.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/preethamSky.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 14011107847426585934 + assetHandle: 7262692570430410866 filePath: Engine/Shaders/Definitions/Environment/preethamSky.vtsdef type: 7 Dependencies: - - 6536228802478257894 + - 12272748295093346455 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Environment/skybox.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Environment/skybox.vtsdef.vtmeta index 00a02e28e..f44a28460 100644 --- a/Engine/Engine/Shaders/Definitions/Environment/skybox.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Environment/skybox.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 2790837096507933923 + assetHandle: 3181615129780372952 filePath: Engine/Shaders/Definitions/Environment/skybox.vtsdef type: 7 Dependencies: - - 15505709367574573075 - - 14436737968341369911 + - 8131475673020517095 + - 7107809791463772697 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Forward/foliage.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Forward/foliage.vtsdef.vtmeta index ed854d308..ca9896815 100644 --- a/Engine/Engine/Shaders/Definitions/Forward/foliage.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Forward/foliage.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 7785405407838344559 + assetHandle: 4892647611999441649 filePath: Engine/Shaders/Definitions/Forward/foliage.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 2363339451227361009 + - 3601805211560947120 + - 15086908939535742121 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Forward/forward.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Forward/forward.vtsdef.vtmeta index 21e543b39..70b8b3a6c 100644 --- a/Engine/Engine/Shaders/Definitions/Forward/forward.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Forward/forward.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 2101643264270249514 + assetHandle: 2623990934271536198 filePath: Engine/Shaders/Definitions/Forward/forward.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 12368517809918622172 + - 3601805211560947120 + - 13521408894763143955 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Forward/forwardSSS.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Forward/forwardSSS.vtsdef.vtmeta index 5f807412e..e376b5395 100644 --- a/Engine/Engine/Shaders/Definitions/Forward/forwardSSS.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Forward/forwardSSS.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 12003476195331023459 + assetHandle: 10052439329315348002 filePath: Engine/Shaders/Definitions/Forward/forwardSSS.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 11107184385068211448 + - 3601805211560947120 + - 1733430113960929821 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Forward/forwardTransparent.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Forward/forwardTransparent.vtsdef.vtmeta index 88f572004..fc5218294 100644 --- a/Engine/Engine/Shaders/Definitions/Forward/forwardTransparent.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Forward/forwardTransparent.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 1252517811570416588 + assetHandle: 18306077472242931842 filePath: Engine/Shaders/Definitions/Forward/forwardTransparent.vtsdef type: 7 Dependencies: - - 6321163614473994367 - - 10167309096478049105 + - 3601805211560947120 + - 2466697835349803929 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Forward/transparentComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Forward/transparentComposite.vtsdef.vtmeta index 63dc5f54e..a30d3f4ca 100644 --- a/Engine/Engine/Shaders/Definitions/Forward/transparentComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Forward/transparentComposite.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 1611253702979965074 + assetHandle: 15419602749726191012 filePath: Engine/Shaders/Definitions/Forward/transparentComposite.vtsdef type: 7 Dependencies: - - 1421142594836268293 - - 15577269964020924019 + - 13811339343625986972 + - 1537890340690121028 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Indirect/clearCountBuffer.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Indirect/clearCountBuffer.vtsdef.vtmeta index 0262f1ca1..7981dd55c 100644 --- a/Engine/Engine/Shaders/Definitions/Indirect/clearCountBuffer.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Indirect/clearCountBuffer.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 7692098614928392254 + assetHandle: 16211559002788243770 filePath: Engine/Shaders/Definitions/Indirect/clearCountBuffer.vtsdef type: 7 Dependencies: - - 5186308870278711452 + - 3401659400447313785 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Indirect/indirectCull.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Indirect/indirectCull.vtsdef.vtmeta index 927a4ecc9..f836d4d9d 100644 --- a/Engine/Engine/Shaders/Definitions/Indirect/indirectCull.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Indirect/indirectCull.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 12239241819470492541 + assetHandle: 1333608582570411322 filePath: Engine/Shaders/Definitions/Indirect/indirectCull.vtsdef type: 7 Dependencies: - - 13303399783846472238 + - 14336012692834025828 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Indirect/lodSelection.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Indirect/lodSelection.vtsdef.vtmeta index 61420900c..5b074f04d 100644 --- a/Engine/Engine/Shaders/Definitions/Indirect/lodSelection.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Indirect/lodSelection.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 1151105214214712621 + assetHandle: 15602301864654121835 filePath: Engine/Shaders/Definitions/Indirect/lodSelection.vtsdef type: 7 Dependencies: - - 482649990060757559 + - 7579689898188310832 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Outline/jumpFloodInit.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Outline/jumpFloodInit.vtsdef.vtmeta index 9d8b2a7d6..4cd6a1174 100644 --- a/Engine/Engine/Shaders/Definitions/Outline/jumpFloodInit.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Outline/jumpFloodInit.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 18421887292546724905 + assetHandle: 9811275491310152904 filePath: Engine/Shaders/Definitions/Outline/jumpFloodInit.vtsdef type: 7 Dependencies: - - 1421142594836268293 - - 9760723259950797587 + - 13811339343625986972 + - 915217769471678931 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Outline/jumpFloodPass.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Outline/jumpFloodPass.vtsdef.vtmeta index c46e6b774..348724356 100644 --- a/Engine/Engine/Shaders/Definitions/Outline/jumpFloodPass.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Outline/jumpFloodPass.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 15093176245341726615 + assetHandle: 16384764305504184776 filePath: Engine/Shaders/Definitions/Outline/jumpFloodPass.vtsdef type: 7 Dependencies: - - 16165746696296269245 - - 8776008193119797911 + - 2966116593059028554 + - 4716162580267918986 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Outline/outlineComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Outline/outlineComposite.vtsdef.vtmeta index d16ebcc5c..7cd6b0dda 100644 --- a/Engine/Engine/Shaders/Definitions/Outline/outlineComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Outline/outlineComposite.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 10912109429973415851 + assetHandle: 8063245575727628523 filePath: Engine/Shaders/Definitions/Outline/outlineComposite.vtsdef type: 7 Dependencies: - - 3896226660567456510 + - 757712097860892410 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Outline/outlineGeometry.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Outline/outlineGeometry.vtsdef.vtmeta index 01df34798..5e36754aa 100644 --- a/Engine/Engine/Shaders/Definitions/Outline/outlineGeometry.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Outline/outlineGeometry.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 4294362833710653702 + assetHandle: 4610309978415966039 filePath: Engine/Shaders/Definitions/Outline/outlineGeometry.vtsdef type: 7 Dependencies: - - 2289556126288207401 - - 5398517952915921890 + - 10167137101529002518 + - 887860446677193370 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/AA/aaComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/AA/aaComposite.vtsdef.vtmeta index ff354016c..982d3caf8 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/AA/aaComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/AA/aaComposite.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 17390035386456892785 + assetHandle: 6975907782735325665 filePath: Engine/Shaders/Definitions/PostProcessing/AA/aaComposite.vtsdef type: 7 Dependencies: - - 17591370596927486423 + - 15105257189616714041 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/AA/fxaa.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/AA/fxaa.vtsdef.vtmeta index 35b8e4d51..514310b29 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/AA/fxaa.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/AA/fxaa.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 7784010669829461599 + assetHandle: 7313926656693230231 filePath: Engine/Shaders/Definitions/PostProcessing/AA/fxaa.vtsdef type: 7 Dependencies: - - 4154449763657603183 + - 603419948025402599 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/AA/taa.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/AA/taa.vtsdef.vtmeta index b51ce39b8..073527beb 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/AA/taa.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/AA/taa.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 5336457945952689272 + assetHandle: 3612100628127470572 filePath: Engine/Shaders/Definitions/PostProcessing/AA/taa.vtsdef type: 7 Dependencies: - - 5425951086488874302 + - 1937471627419906563 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomComposite.vtsdef.vtmeta index c401a6bf4..be501db68 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomComposite.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 8561230336178322463 + assetHandle: 266027453412511178 filePath: Engine/Shaders/Definitions/PostProcessing/Bloom/bloomComposite.vtsdef type: 7 Dependencies: - - 12885707061725190140 + - 7428795430801917266 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomDownsample.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomDownsample.vtsdef.vtmeta index 8628d5355..9c08abed5 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomDownsample.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomDownsample.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 2487543033777469779 + assetHandle: 1806748239731417395 filePath: Engine/Shaders/Definitions/PostProcessing/Bloom/bloomDownsample.vtsdef type: 7 Dependencies: - - 16624762277392342326 + - 3431436573797459303 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomUpsample.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomUpsample.vtsdef.vtmeta index 33aaf1a0d..d60e2db1e 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomUpsample.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/Bloom/bloomUpsample.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 16319043175348845236 + assetHandle: 11052985556358384214 filePath: Engine/Shaders/Definitions/PostProcessing/Bloom/bloomUpsample.vtsdef type: 7 Dependencies: - - 3500807235121010197 + - 4248933374495153383 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDenoise.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDenoise.vtsdef.vtmeta index bed6ff0d6..92caf34f4 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDenoise.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDenoise.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 13431780035930367231 + assetHandle: 12587926778704494106 filePath: Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDenoise.vtsdef type: 7 Dependencies: - - 16045574824786007394 + - 13445968943959903829 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDepthPrefilter.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDepthPrefilter.vtsdef.vtmeta index 64c94f559..8784eefe6 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDepthPrefilter.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDepthPrefilter.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 3135367254474799551 + assetHandle: 3018453772997222660 filePath: Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoDepthPrefilter.vtsdef type: 7 Dependencies: - - 4870608170725517826 + - 10611632505612667329 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoMainPass.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoMainPass.vtsdef.vtmeta index bb16924d6..8226c03c1 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoMainPass.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoMainPass.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 15237990180629279158 + assetHandle: 14995890432789178259 filePath: Engine/Shaders/Definitions/PostProcessing/GTAO/gtaoMainPass.vtsdef type: 7 Dependencies: - - 4756761712322692605 + - 13166265678075234921 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssr.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssr.vtsdef.vtmeta index f884016af..8bb898408 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssr.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssr.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 5218011216011485012 + assetHandle: 9702223394949338577 filePath: Engine/Shaders/Definitions/PostProcessing/SSR/ssr.vtsdef type: 7 Dependencies: - - 4999629954248835168 - - 1421142594836268293 + - 5513805365316638066 + - 13811339343625986972 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssrComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssrComposite.vtsdef.vtmeta index 0ca9036cd..9869e2e97 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssrComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/SSR/ssrComposite.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 4505907894927844733 + assetHandle: 10645006631006988795 filePath: Engine/Shaders/Definitions/PostProcessing/SSR/ssrComposite.vtsdef type: 7 Dependencies: - - 8843034905201491889 - - 1421142594836268293 + - 6856540910608758541 + - 13811339343625986972 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/aces.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/aces.vtsdef.vtmeta index f7aa9839c..a140584ba 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/aces.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/aces.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 3053926224595714920 + assetHandle: 12886999447041920349 filePath: Engine/Shaders/Definitions/PostProcessing/aces.vtsdef type: 7 Dependencies: - - 3269495155555447905 + - 16831301972904337312 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/aoComposite.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/aoComposite.vtsdef.vtmeta index 525ca35ce..3e2cb714d 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/aoComposite.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/aoComposite.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 11467567915339584903 + assetHandle: 14806327704924216509 filePath: Engine/Shaders/Definitions/PostProcessing/aoComposite.vtsdef type: 7 Dependencies: - - 12838837060596027054 - - 1421142594836268293 + - 13516047568433567417 + - 13811339343625986972 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/PostProcessing/gammaCorrection.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/PostProcessing/gammaCorrection.vtsdef.vtmeta index 25eff3679..8a50602e1 100644 --- a/Engine/Engine/Shaders/Definitions/PostProcessing/gammaCorrection.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/PostProcessing/gammaCorrection.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 18413508417498122082 + assetHandle: 15234732111292706428 filePath: Engine/Shaders/Definitions/PostProcessing/gammaCorrection.vtsdef type: 7 Dependencies: - - 11399337496996532325 + - 568449036929530454 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Shadows/directionalShadow.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Shadows/directionalShadow.vtsdef.vtmeta index 2cef3aa0a..eca352d99 100644 --- a/Engine/Engine/Shaders/Definitions/Shadows/directionalShadow.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Shadows/directionalShadow.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 11754033106093276420 + assetHandle: 14472602492546404240 filePath: Engine/Shaders/Definitions/Shadows/directionalShadow.vtsdef type: 7 Dependencies: - - 1491125166448784660 - - 17231576757744671609 + - 4948080663175736811 + - 17410215861176089342 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadow.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadow.vtsdef.vtmeta index e7f4735f6..070a00bae 100644 --- a/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadow.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadow.vtsdef.vtmeta @@ -1,10 +1,10 @@ Metadata: - assetHandle: 5298046333331650473 + assetHandle: 7617093585610972836 filePath: Engine/Shaders/Definitions/Shadows/pointLightShadow.vtsdef type: 7 Dependencies: - - 12089087132953055945 - - 6264200697815171063 - - 11975935530074849119 + - 958466612296659324 + - 11321470963536788218 + - 4360583749447524551 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadowParaboloid.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadowParaboloid.vtsdef.vtmeta index 4644edfc1..34450817f 100644 --- a/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadowParaboloid.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Shadows/pointLightShadowParaboloid.vtsdef.vtmeta @@ -1,10 +1,10 @@ Metadata: - assetHandle: 1901096243448572738 + assetHandle: 415798122680917160 filePath: Engine/Shaders/Definitions/Shadows/pointLightShadowParaboloid.vtsdef type: 7 Dependencies: - - 17466296530272892716 - - 703446259123602191 - - 8898576306088752264 + - 5516314935974899350 + - 2040336750658859989 + - 15488574881513730290 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Shadows/spotlightShadow.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Shadows/spotlightShadow.vtsdef.vtmeta index f9de64ddd..ebbd954fd 100644 --- a/Engine/Engine/Shaders/Definitions/Shadows/spotlightShadow.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Shadows/spotlightShadow.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 15802505154510469482 + assetHandle: 4465798584754229468 filePath: Engine/Shaders/Definitions/Shadows/spotlightShadow.vtsdef type: 7 Dependencies: - - 17702392570058882665 + - 17488314473290848483 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Utility/PreDepth.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Utility/PreDepth.vtsdef.vtmeta index 8814a560b..5506abe1b 100644 --- a/Engine/Engine/Shaders/Definitions/Utility/PreDepth.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Utility/PreDepth.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 10497566329041014742 + assetHandle: 6985633029494188026 filePath: Engine/Shaders/Definitions/Utility/PreDepth.vtsdef type: 7 Dependencies: - - 11711108724042085187 - - 14806869465067222885 + - 3441348774587194015 + - 10206046193485733211 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Utility/brdfGeneration.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Utility/brdfGeneration.vtsdef.vtmeta index 912120846..dad8b97c2 100644 --- a/Engine/Engine/Shaders/Definitions/Utility/brdfGeneration.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Utility/brdfGeneration.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 1113443741560778378 + assetHandle: 17225688300846063316 filePath: Engine/Shaders/Definitions/Utility/brdfGeneration.vtsdef type: 7 Dependencies: - - 1128127446153439271 + - 6925787805327676937 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Utility/calculateLuminosity.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Utility/calculateLuminosity.vtsdef.vtmeta index a29195402..f9345a759 100644 --- a/Engine/Engine/Shaders/Definitions/Utility/calculateLuminosity.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Utility/calculateLuminosity.vtsdef.vtmeta @@ -1,8 +1,8 @@ Metadata: - assetHandle: 13992196398054844281 + assetHandle: 402477387252706525 filePath: Engine/Shaders/Definitions/Utility/calculateLuminosity.vtsdef type: 7 Dependencies: - - 14950691606684469773 + - 3851214989686430313 Properties: {} \ No newline at end of file diff --git a/Engine/Engine/Shaders/Definitions/Utility/id.vtsdef.vtmeta b/Engine/Engine/Shaders/Definitions/Utility/id.vtsdef.vtmeta index 791dc746d..4bee44369 100644 --- a/Engine/Engine/Shaders/Definitions/Utility/id.vtsdef.vtmeta +++ b/Engine/Engine/Shaders/Definitions/Utility/id.vtsdef.vtmeta @@ -1,9 +1,9 @@ Metadata: - assetHandle: 7835198559971345711 + assetHandle: 9499113291806634356 filePath: Engine/Shaders/Definitions/Utility/id.vtsdef type: 7 Dependencies: - - 16407646991808430817 - - 12029051531208947971 + - 14039424650318418426 + - 3691422679832161666 Properties: {} \ No newline at end of file diff --git a/Volt/Sandbox/src/ProjectUpgrade/ProjectUpgradeLayer.cpp b/Volt/Sandbox/src/ProjectUpgrade/ProjectUpgradeLayer.cpp new file mode 100644 index 000000000..75de3ca1c --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/ProjectUpgradeLayer.cpp @@ -0,0 +1,117 @@ +#include "sbpch.h" +#include "ProjectUpgradeLayer.h" + +#include "Sandbox/Utility/Theme.h" +#include "ProjectUpgrade/V011/V011Convert.h" +#include "ProjectUpgrade/V012/V012Convert.h" +#include "ProjectUpgrade/V013/V013Convert.h" +#include "ProjectUpgrade/V015/V015Convert.h" + +#include +#include +#include + +#include + +ProjectUpgradeLayer::ProjectUpgradeLayer() +{ +} + +ProjectUpgradeLayer::~ProjectUpgradeLayer() +{ +} + +void ProjectUpgradeLayer::OnAttach() +{ +} + +void ProjectUpgradeLayer::OnDetach() +{ +} + +void ProjectUpgradeLayer::OnEvent(Volt::Event& e) +{ + Volt::EventDispatcher dispatcher{ e }; + dispatcher.Dispatch(VT_BIND_EVENT_FN(ProjectUpgradeLayer::OnImGuiUpdateEvent)); +} + +void ProjectUpgradeLayer::DrawUpgradeUI() +{ + ImGui::Text("The current project is not the same version as the engine!"); + ImGui::Text("Would you like to upgrade?"); + + const Volt::Version engineVersion = Volt::Application::Get().GetInfo().version; + const Volt::Version projectVersion = Volt::ProjectManager::GetProject().engineVersion; + + if (ImGui::Button("Yes")) + { + if (projectVersion.GetMinor() < 1 && projectVersion.GetMajor() == 0) + { + V011::Convert(); + } + + if (projectVersion.GetPatch() < 2 && projectVersion.GetMinor() < 2 && projectVersion.GetMajor() == 0) + { + V012::Convert(); + } + + if (projectVersion.GetPatch() < 3 && projectVersion.GetMinor() < 2 && projectVersion.GetMajor() == 0) + { + V013::Convert(); + } + + if (projectVersion.GetPatch() < 5 && projectVersion.GetMinor() < 2 && projectVersion.GetMajor() == 0) + { + V015::Convert(); + } + + Volt::ProjectManager::OnProjectUpgraded(); + Volt::ProjectManager::SerializeProject(); + + Volt::WindowCloseEvent loadEvent{}; + Volt::Application::Get().OnEvent(loadEvent); + } + + ImGui::SameLine(); + + if (ImGui::Button("No")) + { + Volt::WindowCloseEvent loadEvent{}; + Volt::Application::Get().OnEvent(loadEvent); + } +} + +bool ProjectUpgradeLayer::OnImGuiUpdateEvent(Volt::AppImGuiUpdateEvent& e) +{ + ImGuiIO& io = ImGui::GetIO(); + io.ConfigWindowsResizeFromEdges = io.BackendFlags & ImGuiBackendFlags_HasMouseCursors; + + // We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into, + // because it would be confusing to have two docking targets within each others. + ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoDocking; + + ImGuiViewport* viewport = ImGui::GetMainViewport(); + ImGui::SetNextWindowPos(viewport->Pos); + ImGui::SetNextWindowSize(viewport->Size); + ImGui::SetNextWindowViewport(viewport->ID); + ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f); + ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f); + window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove; + window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus; + + const bool isMaximized = Volt::Application::Get().GetWindow().IsMaximized(); + + ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, isMaximized ? ImVec2(6.0f, 6.0f) : ImVec2(1.0f, 1.0f)); + ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 3.0f); + ImGui::PushStyleColor(ImGuiCol_MenuBarBg, ImVec4{ 0.0f, 0.0f, 0.0f, 0.0f }); + ImGui::Begin("MainDockspace", nullptr, window_flags); + ImGui::PopStyleColor(); // MenuBarBg + ImGui::PopStyleVar(2); + ImGui::PopStyleVar(2); + + DrawUpgradeUI(); + + ImGui::End(); + + return false; +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/ProjectUpgradeLayer.h b/Volt/Sandbox/src/ProjectUpgrade/ProjectUpgradeLayer.h new file mode 100644 index 000000000..556cfbf5e --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/ProjectUpgradeLayer.h @@ -0,0 +1,24 @@ +#pragma once + +#include + +namespace Volt +{ + class AppImGuiUpdateEvent; +} + +class ProjectUpgradeLayer : public Volt::Layer +{ +public: + ProjectUpgradeLayer(); + ~ProjectUpgradeLayer() override; + + void OnAttach() override; + void OnDetach() override; + + void OnEvent(Volt::Event& e) override; + +private: + void DrawUpgradeUI(); + bool OnImGuiUpdateEvent(Volt::AppImGuiUpdateEvent& e); +}; diff --git a/Volt/Sandbox/src/ProjectUpgrade/V011/V011Convert.cpp b/Volt/Sandbox/src/ProjectUpgrade/V011/V011Convert.cpp new file mode 100644 index 000000000..5aa0c1546 --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V011/V011Convert.cpp @@ -0,0 +1,89 @@ +#include "sbpch.h" +#include "V011Convert.h" + +#include +#include +#include +#include + +namespace V011 +{ + inline std::pair DeserializeV0MetaFile(const std::filesystem::path& metaPath) + { + Volt::YAMLFileStreamReader streamReader{}; + + if (!streamReader.OpenFile(metaPath)) + { + return {}; + } + + std::filesystem::path resultAssetFilePath; + Volt::AssetHandle resultAssetHandle = 0; + + // Is new + if (streamReader.HasKey("Metadata")) + { + streamReader.EnterScope("Metadata"); + + resultAssetFilePath = streamReader.ReadKey("filePath", std::string("")); + resultAssetHandle = streamReader.ReadKey("assetHandle", uint64_t(0u)); + + streamReader.ExitScope(); + } + else if (streamReader.HasKey("Handle")) + { + resultAssetHandle = streamReader.ReadKey("Handle", uint64_t(0)); + resultAssetFilePath = streamReader.ReadKey("Path", std::string("")); + } + + return { resultAssetFilePath, resultAssetHandle }; + } + + inline void ConvertMetaFilesToV011() + { + auto& project = Volt::ProjectManager::GetProject(); + + const std::filesystem::path assetsPath = project.projectDirectory / project.assetsDirectory; + + std::vector metaFilesToConvert; + + for (const auto& entry : std::filesystem::recursive_directory_iterator(assetsPath)) + { + if (entry.path().extension().string() != ".vtmeta") + { + continue; + } + + metaFilesToConvert.emplace_back(entry.path()); + } + + struct AssetDescriptor + { + Volt::AssetHandle handle; + std::filesystem::path assetFilePath; + }; + + std::vector assetDescriptors; + + for (const auto& metaPath : metaFilesToConvert) + { + auto [assetPath, handle] = DeserializeV0MetaFile(metaPath); + assetDescriptors.emplace_back(handle, assetPath); + + if (std::filesystem::exists(metaPath)) + { + std::filesystem::remove(metaPath); + } + } + + for (const auto& descriptor : assetDescriptors) + { + Volt::AssetManager::Get().AddAssetToRegistry(descriptor.assetFilePath, descriptor.handle); + } + } + + void Convert() + { + ConvertMetaFilesToV011(); + } +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V011/V011Convert.h b/Volt/Sandbox/src/ProjectUpgrade/V011/V011Convert.h new file mode 100644 index 000000000..439fb42ad --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V011/V011Convert.h @@ -0,0 +1,6 @@ +#pragma once + +namespace V011 +{ + extern void Convert(); +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V012/V012Convert.cpp b/Volt/Sandbox/src/ProjectUpgrade/V012/V012Convert.cpp new file mode 100644 index 000000000..45ff00e6d --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V012/V012Convert.cpp @@ -0,0 +1,386 @@ +#include "sbpch.h" +#include "V012Convert.h" + +#include +#include +#include + +namespace V012 +{ + inline void ConvertAnimationGraphsToV012() + { + auto& project = Volt::ProjectManager::GetProject(); + + const std::filesystem::path assetsPath = project.projectDirectory / project.assetsDirectory; + + std::vector animGraphsToConvert; + std::vector characterAssets; + std::vector layerAssets; + std::vector prefabAssets; + for (const auto& entry : std::filesystem::recursive_directory_iterator(assetsPath)) + { + if (entry.path().extension().string() == ".vtanimgraph") + { + animGraphsToConvert.emplace_back(entry.path()); + } + + if (entry.path().extension().string() == ".vtchr") + { + characterAssets.emplace_back(entry.path()); + } + + if (entry.path().extension().string() == ".vtlayer") + { + layerAssets.emplace_back(entry.path()); + } + + if (entry.path().extension().string() == ".vtprefab") + { + prefabAssets.emplace_back(entry.path()); + } + } + + auto parseCharacterWithHandle = [characterAssets](Volt::AssetHandle handle, Volt::AssetHandle& outSkinHandle, Volt::AssetHandle& outSkeletonHandle) + { + for (const auto& characterPath : characterAssets) + { + Volt::YAMLFileStreamReader metaStreamReader{}; + + if (!metaStreamReader.OpenFile(characterPath.string() + ".vtmeta")) + { + return false; + } + + Volt::AssetHandle characterAssetHandle = 0; + + metaStreamReader.EnterScope("Metadata"); + + characterAssetHandle = metaStreamReader.ReadKey("assetHandle", uint64_t(0)); + + if (characterAssetHandle == handle) + { + Volt::YAMLFileStreamReader charStreamReader{}; + + if (!charStreamReader.OpenFile(characterPath)) + { + return false; + } + + charStreamReader.EnterScope("AnimatedCharacter"); + outSkeletonHandle = charStreamReader.ReadKey("skeleton", uint64_t(0)); + outSkinHandle = charStreamReader.ReadKey("skin", uint64_t(0)); + return true; + } + } + return false; + }; + + struct AnimGraphDescriptor + { + Volt::AssetHandle handle = 0; + Volt::AssetHandle skeletonHandle = 0; + Volt::AssetHandle skinHandle = 0; + }; + + std::vector animGraphDescriptors; + animGraphDescriptors.resize(animGraphsToConvert.size()); + + for (const auto& animGraphPath : animGraphsToConvert) + { + AnimGraphDescriptor& descriptor = animGraphDescriptors.emplace_back(); + { // convert the animgraph + {// parse meta + Volt::YAMLFileStreamReader metaStreamReader{}; + + if (!metaStreamReader.OpenFile(animGraphPath.string() + ".vtmeta")) + { + VT_CORE_ASSERT(false); + } + + Volt::AssetHandle characterAssetHandle = 0; + + metaStreamReader.EnterScope("Metadata"); + + descriptor.handle = metaStreamReader.ReadKey("assetHandle", uint64_t(0)); + } + + std::ifstream input(animGraphPath); + if (!input.is_open()) + { + VT_CORE_ERROR("Failed to convert: File {0} not found!", animGraphPath); + continue; + } + + std::stringstream sstream; + sstream << input.rdbuf(); + input.close(); + + YAML::Node root; + + root = YAML::Load(sstream.str()); + + YAML::Node rootNode = root["AnimationGraph"]; + Volt::AssetHandle characterHandle = rootNode["character"].as(); + rootNode.remove("character"); + + parseCharacterWithHandle(characterHandle, descriptor.skinHandle, descriptor.skeletonHandle); + + uint64_t apa2 = descriptor.skinHandle; + apa2; + + uint64_t skeletonHandleInt = static_cast(descriptor.skeletonHandle); + rootNode.force_insert("skeleton", skeletonHandleInt); + + + YAML::Node graphNode = rootNode["Graph"]; + + for (int nodeIndex = 0; graphNode["Nodes"][nodeIndex]; nodeIndex++) + { + auto node = graphNode["Nodes"][nodeIndex]; + if (node["type"].as() == "StateMachineNode") + { + auto nodeSpecific = node["nodeSpecific"]; + auto stateMachineNode = nodeSpecific["StateMachine"]; + stateMachineNode.remove("characterHandle"); + stateMachineNode.force_insert("skeletonHandle", skeletonHandleInt); + + //loop through all states + for (int i = 0; stateMachineNode["States"][i]; i++) + { + auto state = stateMachineNode["States"][i]; + + if (state["characterHandle"]) + { + state.remove("characterHandle"); + state.force_insert("skeletonHandle", skeletonHandleInt); + } + state.force_insert("topPinId", state["pinId"].as()); + state.force_insert("bottomPinId", state["pinId2"].as()); + state.remove("pinId"); + state.remove("pinId2"); + + bool isAny = state["isAny"].as(); + bool isEntry = state["isEntry"].as(); + state.force_insert("stateType", isAny ? "AliasState" : isEntry ? "EntryState" : "AnimationState"); + + if (isAny) + { + YAML::Node arrayNode(YAML::NodeType::Sequence); // Create a new Node of Sequence type. + for (auto stateLoopTwo : stateMachineNode["States"]) + { + if (!(stateLoopTwo["isAny"].as()) && !(stateLoopTwo["isEntry"].as())) + { + arrayNode.push_back(stateLoopTwo["id"].as()); // Add elements to the Sequence Node. + } + } + + state.force_insert("TransitionFromStates", arrayNode); + } + } + //loop through them again and remove the bools + for (int i = 0; stateMachineNode["States"][i]; i++) + { + auto state = stateMachineNode["States"][i]; + state.remove("isAny"); + state.remove("isEntry"); + } + } + } + + std::ofstream output(animGraphPath); + if (!output.is_open()) + { + VT_CORE_ERROR("Failed to convert: File {0} not found!", animGraphPath); + continue; + } + + output << root; + output.close(); + } + } + + auto createMeshComponentNode = [](Volt::AssetHandle skinHandle) + { + YAML::Node meshComponentNode; + + YAML::Node guidNode(YAML::NodeType::Sequence); + guidNode.push_back(5579790378469427390); + guidNode.push_back(5138106327942809248); + meshComponentNode.force_insert("guid", guidNode); // guid for mesh component + + YAML::Node propertiesNode(YAML::NodeType::Sequence); + + YAML::Node propertyNodeMesh; + propertyNodeMesh["type"] = 16; + propertyNodeMesh["vectorType"] = 13; + propertyNodeMesh["name"] = "Mesh"; + propertyNodeMesh["data"] = static_cast(skinHandle); + propertiesNode.push_back(propertyNodeMesh); + + YAML::Node propertyNodeMaterial; + propertyNodeMaterial["type"] = 16; + propertyNodeMaterial["vectorType"] = 13; + propertyNodeMaterial["name"] = "Material"; + propertyNodeMaterial["data"] = 0; + propertiesNode.push_back(propertyNodeMaterial); + + meshComponentNode.force_insert("properties", propertiesNode); + return meshComponentNode; + }; + + for (auto& layer : layerAssets) + { + bool modified = false; + std::ifstream input(layer); + if (!input.is_open()) + { + VT_CORE_ERROR("Failed to convert: File {0} not found!", layer); + continue; + } + + std::stringstream sstream; + sstream << input.rdbuf(); + input.close(); + + YAML::Node root; + + root = YAML::Load(sstream.str()); + + YAML::Node rootNode = root["Layer"]; + + if (rootNode["Entities"]) + { + for (int entityIndex = 0; rootNode["Entities"][entityIndex]; entityIndex++) + { + auto entity = rootNode["Entities"][entityIndex]["Entity"]; + if (entity["components"]) + { + + for (int componentIndex = 0; entity["components"][componentIndex]; componentIndex++) + { + auto compNode = entity["components"][componentIndex]; + std::pair componentGUID; + componentGUID.first = compNode["guid"][0].as(); + componentGUID.second = compNode["guid"][1].as(); + if (componentGUID.first != 0 && componentGUID.second != 0) + { + continue; + } + + // check if the component is an animation controller + if (componentGUID.first == 4626977537440075682 && componentGUID.second == 8666096866538760379) + { + if (compNode["properties"].size() > 0) + { + uint64_t compGraphAssetId = compNode["properties"][0]["data"].as(); + + for (auto& descriptor : animGraphDescriptors) + { + if (descriptor.handle == compGraphAssetId) + { + entity["components"].push_back(createMeshComponentNode(descriptor.skinHandle)); + modified = true; + break; + } + } + } + } + } + } + } + } + + if (modified) + { + std::ofstream output(layer); + if (!output.is_open()) + { + VT_CORE_ERROR("Failed to convert: File {0} not found!", layer); + continue; + } + + output << root; + output.close(); + } + } + + for (auto& prefab : prefabAssets) + { + bool modified = false; + std::ifstream input(prefab); + if (!input.is_open()) + { + VT_CORE_ERROR("Failed to convert: File {0} not found!", prefab); + continue; + } + + std::stringstream sstream; + sstream << input.rdbuf(); + input.close(); + + YAML::Node root; + + root = YAML::Load(sstream.str()); + + YAML::Node rootNode = root["Prefab"]; + + if (rootNode["entities"]) + { + for (int entityIndex = 0; rootNode["entities"][entityIndex]; entityIndex++) + { + auto entity = rootNode["entities"][entityIndex]; + if (entity["components"]) + { + + for (int componentIndex = 0; entity["components"][componentIndex]; componentIndex++) + { + auto compNode = entity["components"][componentIndex]; + std::pair componentGUID; + componentGUID.first = compNode["guid"][0].as(); + componentGUID.second = compNode["guid"][1].as(); + if (componentGUID.first != 0 && componentGUID.second != 0) + { + continue; + } + + // check if the component is an animation controller + if (componentGUID.first == 4626977537440075682 && componentGUID.second == 8666096866538760379) + { + if (compNode["properties"].size() > 0) + { + uint64_t compGraphAssetId = compNode["properties"][0]["data"].as(); + for (auto& descriptor : animGraphDescriptors) + { + if (descriptor.handle == compGraphAssetId) + { + modified = true; + entity["components"].push_back(createMeshComponentNode(descriptor.skinHandle)); + break; + } + } + } + } + } + } + } + } + if (modified) + { + std::ofstream output(prefab); + if (!output.is_open()) + { + VT_CORE_ERROR("Failed to convert: File {0} not found!", prefab); + continue; + } + + output << root; + output.close(); + } + } + } + + void Convert() + { + ConvertAnimationGraphsToV012(); + } +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V012/V012Convert.h b/Volt/Sandbox/src/ProjectUpgrade/V012/V012Convert.h new file mode 100644 index 000000000..e59857f0f --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V012/V012Convert.h @@ -0,0 +1,6 @@ +#pragma once + +namespace V012 +{ + extern void Convert(); +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V013/V013Convert.cpp b/Volt/Sandbox/src/ProjectUpgrade/V013/V013Convert.cpp new file mode 100644 index 000000000..a5466a5bb --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V013/V013Convert.cpp @@ -0,0 +1,874 @@ +#include "sbpch.h" +#include "V013Convert.h" +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace V013 +{ + enum class PreV013PropertyType : uint32_t + { + Bool = 0, + Int = 1, + UInt = 2, + Short = 3, + UShort = 4, + Char = 5, + UChar = 6, + Float = 7, + Double = 8, + Vector2 = 9, + Vector3 = 10, + Vector4 = 11, + String = 12, + Unknown = 13, + + Int64 = 14, + UInt64 = 15, + AssetHandle = 16, + Color3 = 17, + Color4 = 18, + Directory = 19, + Path = 20, + Vector = 21, + EntityId = 22, + GUID = 23, + Enum = 24, + Quaternion = 25 + }; + + struct TypeIndexContainer + { + std::type_index typeIndex = typeid(void); + }; + + static std::unordered_map s_preV113PropTypeToTypeIndexMap; + static std::unordered_map> s_arrayDeserializers; + static std::unordered_map> s_componentMemberRemap; + + inline const bool IsPreV013EntityNull(Volt::EntityID entityId) + { + return entityId == Volt::Entity::NullID(); + } + + inline void ValidateEntityValidity(Volt::EntityID* entityId) + { + if (*entityId == (Volt::EntityID)0) + { + *entityId = Volt::Entity::NullID(); + } + } + + inline const Volt::ComponentMember* TryGetComponentMemberFromName(const std::string& memberName, const Volt::IComponentTypeDesc* componentDesc) + { + std::string demangledName = Utility::ToLower(memberName); + demangledName.erase(std::remove_if(demangledName.begin(), demangledName.end(), ::isspace)); + + for (uint32_t idx = 0; const auto & member : componentDesc->GetMembers()) + { + const std::string memberNameLower = Utility::ToLower(std::string(member.name)); + + if (demangledName.find(memberNameLower) != std::string::npos) + { + return &componentDesc->GetMembers().at(idx); + } + + idx++; + } + + if (s_componentMemberRemap.contains(componentDesc->GetGUID())) + { + for (const auto& [oldMemberName, newMemberName] : s_componentMemberRemap.at(componentDesc->GetGUID())) + { + if (memberName == oldMemberName) + { + return componentDesc->FindMemberByName(newMemberName); + } + } + } + + return nullptr; + } + + inline void DeserializePreV113Component(uint8_t* componentData, const Volt::IComponentTypeDesc* componentDesc, Volt::YAMLFileStreamReader& streamReader) + { + const auto& typeDeserializers = Volt::SceneImporter::GetTypeDeserializers(); + + streamReader.ForEach("properties", [&]() + { + const std::string memberName = streamReader.ReadKey("name", std::string("")); + + if (memberName.empty()) + { + return; + } + + const Volt::ComponentMember* componentMember = TryGetComponentMemberFromName(memberName, componentDesc); + if (!componentMember) + { + return; + } + + const PreV013PropertyType oldType = static_cast(streamReader.ReadKey("type", 0u)); + + if (oldType == PreV013PropertyType::Vector && componentMember->typeDesc != nullptr) + { + const Volt::IArrayTypeDesc* arrayTypeDesc = reinterpret_cast(componentMember->typeDesc); + const PreV013PropertyType vectorType = static_cast(streamReader.ReadKey("vectorType", 0u)); + const std::type_index vectorValueType = s_preV113PropTypeToTypeIndexMap.at(vectorType).typeIndex; + void* arrayPtr = &componentData[componentMember->offset]; + + if (arrayTypeDesc->GetElementTypeIndex() != vectorValueType) + { + VT_CORE_WARN("[Upgrade Project]: Component member vector type does not match file specified type!"); + return; + } + + streamReader.ForEach("data", [&]() + { + void* tempDataStorage = nullptr; + arrayTypeDesc->DefaultConstructElement(tempDataStorage); + + uint8_t* tempBytePtr = reinterpret_cast(tempDataStorage); + + if (s_arrayDeserializers.contains(vectorValueType)) + { + s_arrayDeserializers.at(vectorValueType)(streamReader, tempBytePtr, 0); + } + + if (arrayTypeDesc->GetElementTypeIndex() == std::type_index{ typeid(Volt::EntityID) }) + { + ValidateEntityValidity(reinterpret_cast(tempDataStorage)); + } + + arrayTypeDesc->PushBack(arrayPtr, tempDataStorage); + arrayTypeDesc->DestroyElement(tempDataStorage); + }); + + return; + } + else if (oldType == PreV013PropertyType::Enum) + { + typeDeserializers.at(typeid(int32_t))(streamReader, componentData, componentMember->offset); + return; + } + + const std::type_index memberType = s_preV113PropTypeToTypeIndexMap.at(oldType).typeIndex; + if (memberType != componentMember->typeIndex) + { + VT_CORE_WARN("[Upgrade Project]: Component member type does not match file specified type!"); + return; + } + + if (typeDeserializers.contains(memberType)) + { + typeDeserializers.at(memberType)(streamReader, componentData, componentMember->offset); + if (memberType == std::type_index{ typeid(Volt::EntityID) }) + { + Volt::EntityID* entDataPtr = reinterpret_cast(&componentData[componentMember->offset]); + ValidateEntityValidity(entDataPtr); + } + } + }); + } + + void DeserializePreV113MonoScripts(Ref scene, const Volt::EntityID entityId, Volt::YAMLFileStreamReader& streamReader) + { + Volt::Entity entity = scene->GetEntityFromUUID(entityId); + const auto& typeDeserializers = Volt::SceneImporter::GetTypeDeserializers(); + + streamReader.ForEach("MonoScripts", [&]() + { + streamReader.EnterScope("ScriptEntry"); + + if (!entity.HasComponent()) + { + entity.AddComponent(); + } + + const std::string scriptName = streamReader.ReadKey("name", std::string("")); + Volt::UUID scriptId = streamReader.ReadKey("id", Volt::UUID(0)); + + auto scriptClass = Volt::MonoScriptEngine::GetScriptClass(scriptName); + if (!scriptClass) + { + streamReader.ExitScope(); + return; + } + + auto& scriptComp = entity.GetComponent(); + + if (auto it = std::find(scriptComp.scriptNames.begin(), scriptComp.scriptNames.end(), scriptName); it != scriptComp.scriptNames.end()) + { + const size_t index = std::distance(scriptComp.scriptNames.begin(), it); + scriptId = scriptComp.scriptIds.at(index); + } + else + { + scriptComp.scriptIds.emplace_back(scriptId); + scriptComp.scriptNames.emplace_back(scriptName); + } + + const auto& classFields = scriptClass->GetFields(); + auto& fieldCache = scene->GetScriptFieldCache().GetCache()[scriptId]; + + streamReader.ForEach("properties", [&]() + { + const std::string memberName = streamReader.ReadKey("name", std::string("")); + if (!classFields.contains(memberName)) + { + return; + } + + Ref fieldInstance = CreateRef(); + fieldCache[memberName] = fieldInstance; + + fieldInstance->field = classFields.at(memberName); + if (fieldInstance->field.type.IsString()) + { + const std::string str = streamReader.ReadKey("data", std::string("")); + fieldInstance->SetValue(str, str.size()); + } + else if (typeDeserializers.contains(fieldInstance->field.type.typeIndex)) + { + fieldInstance->data.Allocate(fieldInstance->field.type.typeSize); + typeDeserializers.at(fieldInstance->field.type.typeIndex)(streamReader, fieldInstance->data.As(), 0); + } + }); + + streamReader.ExitScope(); + }); + } + + inline void DeserializePreV013Entity(Ref scene, Volt::YAMLFileStreamReader& streamReader, std::map& entityRemapping, bool isPrefabEntity) + { + if (!isPrefabEntity) + { + streamReader.EnterScope("Entity"); + } + + Volt::EntityID originalEntityId = streamReader.ReadKey("id", Volt::Entity::NullID()); + + if (IsPreV013EntityNull(originalEntityId)) + { + return; + } + + Volt::Entity newEntity = scene->CreateEntityWithUUID(originalEntityId); + const Volt::EntityID entityId = newEntity.GetID(); + + const auto handle = scene->GetHandleFromUUID(entityId); + + if (entityId != originalEntityId) + { + entityRemapping[originalEntityId] = entityId; + } + + bool skipTransformComp = false; + bool skipPrefabComp = false; + bool skipRelComp = false; + bool skipCommonComp = false; + + streamReader.ForEach("components", [&]() + { + const VoltGUID compGuid = streamReader.ReadKey("guid", VoltGUID::Null()); + if (compGuid == VoltGUID::Null()) + { + return; + } + + const Volt::ICommonTypeDesc* typeDesc = Volt::ComponentRegistry::GetTypeDescFromGUID(compGuid); + if (!typeDesc) + { + return; + } + + switch (typeDesc->GetValueType()) + { + case Volt::ValueType::Component: + { + if (!Volt::ComponentRegistry::Helpers::HasComponentWithGUID(compGuid, scene->GetRegistry(), handle)) + { + Volt::ComponentRegistry::Helpers::AddComponentWithGUID(compGuid, scene->GetRegistry(), handle); + } + void* voidCompPtr = Volt::ComponentRegistry::Helpers::GetComponentWithGUID(compGuid, scene->GetRegistry(), handle); + uint8_t* componentData = reinterpret_cast(voidCompPtr); + + const Volt::IComponentTypeDesc* componentDesc = reinterpret_cast(typeDesc); + + if (componentDesc->GetGUID() == Volt::GetTypeGUID()) + { + if (!streamReader.IsSequenceEmpty("properties")) + { + skipTransformComp = true; + } + } + else if (componentDesc->GetGUID() == Volt::GetTypeGUID()) + { + if (!streamReader.IsSequenceEmpty("properties")) + { + skipPrefabComp = true; + } + } + else if (componentDesc->GetGUID() == Volt::GetTypeGUID()) + { + if (!streamReader.IsSequenceEmpty("properties")) + { + skipRelComp = true; + } + } + else if (componentDesc->GetGUID() == Volt::GetTypeGUID()) + { + if (!streamReader.IsSequenceEmpty("properties")) + { + skipCommonComp = true; + } + } + + DeserializePreV113Component(componentData, componentDesc, streamReader); + break; + } + } + }); + + if (scene->GetRegistry().any_of(handle) && !isPrefabEntity) + { + auto& prefabComp = scene->GetRegistry().get(handle); + Ref prefabAsset = Volt::AssetManager::GetAsset(prefabComp.prefabAsset); + + if (prefabAsset && prefabAsset->IsValid()) + { + Volt::EntityCopyFlags copyFlags = Volt::EntityCopyFlags::None; + if (skipTransformComp) + { + copyFlags = copyFlags | Volt::EntityCopyFlags::SkipTransform; + } + if (skipPrefabComp) + { + copyFlags = copyFlags | Volt::EntityCopyFlags::SkipPrefab; + } + if (skipRelComp) + { + copyFlags = copyFlags | Volt::EntityCopyFlags::SkipRelationships; + } + if (skipCommonComp) + { + copyFlags = copyFlags | Volt::EntityCopyFlags::SkipCommonData; + } + + prefabAsset->CopyPrefabEntity(newEntity, prefabComp.prefabEntity, copyFlags); + } + } + + if (scene->GetRegistry().any_of(handle)) + { + DeserializePreV113MonoScripts(scene, entityId, streamReader); + } + + // Make sure entity has relationship component + if (!scene->GetRegistry().any_of(handle)) + { + scene->GetRegistry().emplace(handle); + } + + if (!isPrefabEntity) + { + streamReader.ExitScope(); + } + } + + inline void ValidateSceneConversionArray(Ref scene, const Volt::ComponentMember& componentMember, uint8_t* componentData) + { + const Volt::IArrayTypeDesc* memberArrayTypeDesc = reinterpret_cast(componentMember.typeDesc); + void* arrayPtr = reinterpret_cast(&componentData[componentMember.offset]); + + std::vector indicesToRemove{}; + + for (size_t i = 0; i < memberArrayTypeDesc->Size(arrayPtr); i++) + { + Volt::EntityID* value = reinterpret_cast(memberArrayTypeDesc->At(arrayPtr, i)); + if (!scene->GetRegistry().valid(scene->GetHandleFromUUID(*value))) + { + indicesToRemove.emplace_back(i); + *value = Volt::Entity::NullID(); + } + } + + for (const auto& i : indicesToRemove) + { + memberArrayTypeDesc->Erase(arrayPtr, i); + } + } + + inline void ValidateSceneConversion(Ref scene) + { + for (auto&& curr : scene->GetRegistry().storage()) + { + auto& storage = curr.second; + std::string_view typeName = storage.type().name(); + + const Volt::ICommonTypeDesc* typeDesc = Volt::ComponentRegistry::GetTypeDescFromName(typeName); + if (!typeDesc) + { + continue; + } + + if (typeDesc->GetGUID() == Volt::GetTypeGUID()) + { + continue; + } + + if (typeDesc->GetValueType() != Volt::ValueType::Component) + { + continue; + } + + const Volt::IComponentTypeDesc* componentTypeDesc = reinterpret_cast(typeDesc); + + for (const auto& member : componentTypeDesc->GetMembers()) + { + if (member.typeDesc) + { + if (member.typeDesc->GetValueType() != Volt::ValueType::Array) + { + continue; + } + + const Volt::IArrayTypeDesc* memberArrayTypeDesc = reinterpret_cast(member.typeDesc); + if (memberArrayTypeDesc->GetElementTypeIndex() != std::type_index{ typeid(Volt::EntityID) }) + { + continue; + } + + for (const auto& id : storage) + { + uint8_t* componentDataPtr = reinterpret_cast(storage.get(id)); + ValidateSceneConversionArray(scene, member, componentDataPtr); + } + } + else if (member.typeIndex == std::type_index{ typeid(Volt::EntityID) }) + { + for (const auto& id : storage) + { + uint8_t* componentDataPtr = reinterpret_cast(storage.get(id)); + Volt::EntityID& value = *reinterpret_cast(&componentDataPtr[member.offset]); + + if (!scene->GetRegistry().valid(scene->GetHandleFromUUID(value))) + { + value = Volt::Entity::NullID(); + } + } + } + } + } + } + + inline void HandleEntityArrayRemapping(Ref scene, const std::map& entityRemapping, const Volt::ComponentMember& componentMember, uint8_t* componentData) + { + const Volt::IArrayTypeDesc* memberArrayTypeDesc = reinterpret_cast(componentMember.typeDesc); + void* arrayPtr = reinterpret_cast(&componentData[componentMember.offset]); + + for (size_t i = 0; i < memberArrayTypeDesc->Size(arrayPtr); i++) + { + Volt::EntityID* value = reinterpret_cast(memberArrayTypeDesc->At(arrayPtr, i)); + for (const auto& [originalEntityId, newEntityId] : entityRemapping) + { + if (*value == originalEntityId) + { + *value = newEntityId; + } + } + } + } + + inline void HandleEntityRemapping(Ref scene, const std::map& entityRemapping) + { + for (auto&& curr : scene->GetRegistry().storage()) + { + auto& storage = curr.second; + std::string_view typeName = storage.type().name(); + + const Volt::ICommonTypeDesc* typeDesc = Volt::ComponentRegistry::GetTypeDescFromName(typeName); + if (!typeDesc) + { + continue; + } + + if (typeDesc->GetValueType() != Volt::ValueType::Component) + { + continue; + } + + const Volt::IComponentTypeDesc* componentTypeDesc = reinterpret_cast(typeDesc); + + for (const auto& member : componentTypeDesc->GetMembers()) + { + if (member.typeDesc) + { + if (member.typeDesc->GetValueType() != Volt::ValueType::Array) + { + continue; + } + + const Volt::IArrayTypeDesc* memberArrayTypeDesc = reinterpret_cast(member.typeDesc); + if (memberArrayTypeDesc->GetElementTypeIndex() != std::type_index{ typeid(Volt::EntityID) }) + { + continue; + } + + for (const auto& id : storage) + { + uint8_t* componentDataPtr = reinterpret_cast(storage.get(id)); + HandleEntityArrayRemapping(scene, entityRemapping, member, componentDataPtr); + } + } + else if (member.typeIndex == std::type_index{ typeid(Volt::EntityID) }) + { + for (const auto& id : storage) + { + uint8_t* componentDataPtr = reinterpret_cast(storage.get(id)); + + for (const auto& [originalEntityId, newEntityId] : entityRemapping) + { + Volt::EntityID& value = *reinterpret_cast(&componentDataPtr[member.offset]); + if (value == originalEntityId) + { + value = newEntityId; + } + } + } + } + } + } + } + + inline void ConvertPreV013Prefab(const std::filesystem::path& filePath) + { + Volt::YAMLFileStreamReader streamReader{}; + if (!streamReader.OpenFile(filePath)) + { + return; + } + + uint32_t version = 0; + Volt::EntityID rootEntityId = Volt::Entity::NullID(); + Ref prefabScene = CreateRef(); + + std::map entityRemapping; + + streamReader.EnterScope("Prefab"); + { + version = streamReader.ReadKey("version", 0u); + + streamReader.ForEach("entities", [&]() + { + Volt::EntityID entityId = streamReader.ReadKey("id", Volt::Entity::NullID()); + if (IsPreV013EntityNull(entityId)) + { + return; + } + + DeserializePreV013Entity(prefabScene, streamReader, entityRemapping, true); + }); + } + streamReader.ExitScope(); + + HandleEntityRemapping(prefabScene, entityRemapping); + ValidateSceneConversion(prefabScene); + + // In old prefabs, the root is the only entity with no parent + prefabScene->ForEachWithComponents([&](const entt::entity id, const Volt::RelationshipComponent& comp, const Volt::IDComponent& idComponent) + { + if (comp.parent == Volt::Entity::NullID()) + { + rootEntityId = idComponent.id; + } + }); + + Ref newPrefab = CreateRef(prefabScene, rootEntityId, version); + + Volt::AssetMetadata imposterMeta{}; + imposterMeta.filePath = filePath; + + Volt::PrefabImporter::Get().Save(imposterMeta, newPrefab); + } + + inline void ConvertPrefabsToV013() + { + auto& project = Volt::ProjectManager::GetProject(); + const std::filesystem::path assetsPath = project.projectDirectory / project.assetsDirectory; + + std::vector prefabFilePaths; + for (const auto& entry : std::filesystem::recursive_directory_iterator(assetsPath)) + { + if (entry.path().extension().string() == ".vtprefab") + { + prefabFilePaths.emplace_back(entry.path()); + } + } + + for (const auto& prefabFilePath : prefabFilePaths) + { + ConvertPreV013Prefab(prefabFilePath); + } + } + + inline void DeserializePreV113SceneLayer(Ref scene, Volt::SceneLayer& sceneLayer, const std::filesystem::path& layerPath, std::map& entityRemapping) + { + Volt::YAMLFileStreamReader streamReader{}; + + if (!streamReader.OpenFile(layerPath)) + { + return; + } + + streamReader.EnterScope("Layer"); + { + sceneLayer.name = streamReader.ReadKey("name", std::string("Null")); + sceneLayer.id = streamReader.ReadKey("id", 0u); + sceneLayer.visible = streamReader.ReadKey("visible", true); + sceneLayer.locked = streamReader.ReadKey("locked", false); + + streamReader.ForEach("Entities", [&]() + { + DeserializePreV013Entity(scene, streamReader, entityRemapping, false); + }); + } + streamReader.ExitScope(); + } + + inline void ConvertScenesToV013() + { + // We only need to convert the layer files, and not the scene files + + // Find all scene directories + auto& project = Volt::ProjectManager::GetProject(); + const std::filesystem::path assetsPath = project.projectDirectory / project.assetsDirectory; + + std::vector sceneFilePaths; + for (const auto& entry : std::filesystem::recursive_directory_iterator(assetsPath)) + { + if (entry.path().extension().string() == ".vtscene") + { + sceneFilePaths.emplace_back(entry.path()); + } + } + + // Convert all found scenes + for (const auto& sceneFilePath : sceneFilePaths) + { + const auto sceneDir = sceneFilePath.parent_path(); + + if (!std::filesystem::exists(sceneDir / "Layers")) + { + continue; + } + + std::string sceneName; + + // Load scene name + { + Volt::YAMLFileStreamReader streamReader{}; + if (!streamReader.OpenFile(sceneFilePath)) + { + VT_CORE_ERROR("[Project Upgrade]: Unable to open scene file! Skipping!"); + continue; + } + + streamReader.EnterScope("Scene"); + sceneName = streamReader.ReadKey("name", std::string("New Scene")); + streamReader.ExitScope(); + } + + Ref scene = CreateRef(sceneName); + std::vector sceneLayers; + + std::map entityRemapping; + + for (const auto& entry : std::filesystem::directory_iterator(sceneDir / "Layers")) + { + if (entry.path().extension().string() != ".vtlayer") + { + continue; + } + + DeserializePreV113SceneLayer(scene, sceneLayers.emplace_back(), entry.path(), entityRemapping); + } + + scene->SetLayers(sceneLayers); + + HandleEntityRemapping(scene, entityRemapping); + //ValidateSceneConversion(scene); + + Volt::AssetMetadata imposterMeta; + imposterMeta.filePath = Volt::AssetManager::GetRelativePath(sceneFilePath); + Volt::SceneImporter::Get().Save(imposterMeta, scene); + } + } + + template + inline void RegisterArrayDeserializationFunction() + { + s_arrayDeserializers[std::type_index{ typeid(T) }] = [](Volt::YAMLFileStreamReader& streamReader, uint8_t* data, const size_t offset) + { + *reinterpret_cast(&data[offset]) = streamReader.ReadKey("value", T()); + }; + } + + template + inline void AddComponentMemberRemap(const std::string& oldName, const std::string& newName) + { + s_componentMemberRemap[Volt::GetTypeGUID()][oldName] = newName; + } + + inline void Initialize() + { + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Bool].typeIndex = std::type_index{ typeid(bool) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Int].typeIndex = std::type_index{ typeid(int32_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::UInt].typeIndex = std::type_index{ typeid(uint32_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Short].typeIndex = std::type_index{ typeid(int16_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::UShort].typeIndex = std::type_index{ typeid(uint16_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Char].typeIndex = std::type_index{ typeid(int8_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::UChar].typeIndex = std::type_index{ typeid(uint8_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Float].typeIndex = std::type_index{ typeid(float) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Double].typeIndex = std::type_index{ typeid(double) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Vector2].typeIndex = std::type_index{ typeid(glm::vec2) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Vector3].typeIndex = std::type_index{ typeid(glm::vec3) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Vector4].typeIndex = std::type_index{ typeid(glm::vec4) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::String].typeIndex = std::type_index{ typeid(std::string) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Int64].typeIndex = std::type_index{ typeid(int64_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::UInt64].typeIndex = std::type_index{ typeid(uint64_t) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::AssetHandle].typeIndex = std::type_index{ typeid(Volt::AssetHandle) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Color3].typeIndex = std::type_index{ typeid(glm::vec3) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Color4].typeIndex = std::type_index{ typeid(glm::vec4) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Directory].typeIndex = std::type_index{ typeid(std::filesystem::path) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Path].typeIndex = std::type_index{ typeid(std::filesystem::path) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::EntityId].typeIndex = std::type_index{ typeid(Volt::EntityID) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::GUID].typeIndex = std::type_index{ typeid(VoltGUID) }; + s_preV113PropTypeToTypeIndexMap[PreV013PropertyType::Quaternion].typeIndex = std::type_index{ typeid(glm::quat) }; + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + RegisterArrayDeserializationFunction(); + RegisterArrayDeserializationFunction(); + + // Member remapping + { + AddComponentMemberRemap("Mesh", "handle"); + AddComponentMemberRemap("Character", "animatedCharacter"); + AddComponentMemberRemap("Material", "materialHandle"); + AddComponentMemberRemap("Override Skin", "skin"); + AddComponentMemberRemap("Material", "decalMaterial"); + + // Vision components + { + AddComponentMemberRemap("Camera", "triggerCam"); + AddComponentMemberRemap("Force Camera", "forceActiveCam"); + + AddComponentMemberRemap("Blend Time", "blendTime"); + AddComponentMemberRemap("Field Of View", "fieldOfView"); + AddComponentMemberRemap("Ignored Layers", "layerMasks"); + AddComponentMemberRemap("Camera Type", "cameraType"); + AddComponentMemberRemap("Blend Type", "blendType"); + AddComponentMemberRemap("Damping", "damping"); + AddComponentMemberRemap("Offset", "offset"); + AddComponentMemberRemap("Follow", "followId"); + AddComponentMemberRemap("LookAt", "lookAtId"); + AddComponentMemberRemap("Collision Focus Point", "collisionRayPoint"); + AddComponentMemberRemap("Focal Distance", "focalDistance"); + AddComponentMemberRemap("Mouse Sensitivity", "mouseSensitivity"); + AddComponentMemberRemap("Collision Sphere Radius", "collisionRadius"); + AddComponentMemberRemap("Collision", "isColliding"); + AddComponentMemberRemap("Is Default", "isDefault"); + AddComponentMemberRemap("X FollowLock", "xFollowLock"); + AddComponentMemberRemap("Y FollowLock", "yFollowLock"); + AddComponentMemberRemap("Z FollowLock", "zFollowLock"); + AddComponentMemberRemap("X ShouldDamp", "xShouldDamp"); + AddComponentMemberRemap("Y ShouldDamp", "yShouldDamp"); + AddComponentMemberRemap("Z ShouldDamp", "zShouldDamp"); + AddComponentMemberRemap("Additive Blend", "additiveBlend"); + } + + // NetActorComponent + { + AddComponentMemberRemap("Condition", "condition"); + AddComponentMemberRemap("Update Position", "updateTransformPos"); + AddComponentMemberRemap("Update Rotation", "updateTransformRot"); + AddComponentMemberRemap("Update Scale", "updateTransformScale"); + AddComponentMemberRemap("RepId", "repId"); + AddComponentMemberRemap("cID", "clientId"); + } + + // GameModeComponent + { + AddComponentMemberRemap("PlayerPrefab", "prefabHandle"); + AddComponentMemberRemap("EnemyPrefab", "enemy"); + } + + // AudioListenerComponent + { + AddComponentMemberRemap("Default", "default"); + } + } + } + + inline void Shutdown() + { + s_preV113PropTypeToTypeIndexMap.clear(); + s_arrayDeserializers.clear(); + s_componentMemberRemap.clear(); + } + + void Convert() + { + Initialize(); + + ConvertPrefabsToV013(); + ConvertScenesToV013(); + + Shutdown(); + } +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V013/V013Convert.h b/Volt/Sandbox/src/ProjectUpgrade/V013/V013Convert.h new file mode 100644 index 000000000..39167d1b0 --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V013/V013Convert.h @@ -0,0 +1,6 @@ +#pragma once + +namespace V013 +{ + extern void Convert(); +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V015/V015Convert.cpp b/Volt/Sandbox/src/ProjectUpgrade/V015/V015Convert.cpp new file mode 100644 index 000000000..9c86a815a --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V015/V015Convert.cpp @@ -0,0 +1,270 @@ +#include "sbpch.h" +#include "V015Convert.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +namespace V015 +{ + inline static std::unordered_map s_oldMetadata; + + inline std::vector GetEngineMetaFiles() + { + std::vector files; + const std::string ext(".vtmeta"); + + // Engine Directory + for (auto& p : std::filesystem::recursive_directory_iterator(Volt::ProjectManager::GetEngineDirectory() / "Engine")) + { + if (p.path().extension() == ext) + { + files.emplace_back(p.path()); + } + } + + const auto editorFolder = Volt::ProjectManager::GetEngineDirectory() / "Editor"; + if (FileSystem::Exists(editorFolder)) + { + for (auto& p : std::filesystem::recursive_directory_iterator(editorFolder)) + { + if (p.path().extension() == ext) + { + files.emplace_back(p.path()); + } + } + } + + return files; + } + + inline std::vector GetProjectMetaFiles() + { + std::vector files; + std::string ext(".vtmeta"); + + // Project Directory + const auto assetsDir = Volt::ProjectManager::GetProject().projectDirectory / Volt::ProjectManager::GetProject().assetsDirectory; + + if (FileSystem::Exists(assetsDir)) + { + for (auto& p : std::filesystem::recursive_directory_iterator(assetsDir)) + { + if (p.path().extension() == ext) + { + files.emplace_back(p.path()); + } + } + } + + return files; + } + + inline Volt::AssetType GetAssetTypeFromExtension(const std::string& extension) + { + std::string ext = ::Utility::ToLower(extension); + if (!Volt::s_assetExtensionsMap.contains(ext)) + { + return Volt::AssetType::None; + } + + return Volt::s_assetExtensionsMap.at(ext); + } + + inline void DeserializeAssetMetafile(std::filesystem::path metaFilePath) + { + if (!std::filesystem::exists(metaFilePath)) + { + return; + } + + std::ifstream file(metaFilePath); + if (!file.is_open()) + { + VT_CORE_CRITICAL("[AssetManager] Failed to open asset registry file: {0}!", metaFilePath.string().c_str()); + return; + } + + std::stringstream strStream; + strStream << file.rdbuf(); + file.close(); + + YAML::Node root; + try + { + root = YAML::Load(strStream.str()); + } + catch (std::exception& e) + { + VT_CORE_CRITICAL("[AssetManager] Meta file {0} contains invalid YAML! Please correct it! Error: {1}", metaFilePath, e.what()); + return; + } + + YAML::Node metaRoot = root["Metadata"]; + + if (!metaRoot["assetHandle"]) + { + VT_CORE_CRITICAL("[AssetManager] Meta file {0} is missing an asset handle! Please correct it!", metaFilePath); + return; + } + + Volt::AssetHandle assetHandle = metaRoot["assetHandle"].as(); + + if (!metaRoot["filePath"]) + { + VT_CORE_CRITICAL("[AssetManager] Meta file {0} is missing a file path! Please correct it!", metaFilePath); + return; + } + + std::filesystem::path filePath = metaRoot["filePath"].as(); + + std::vector dependencies; + if (metaRoot["Dependencies"]) + { + for (const auto& d : metaRoot["Dependencies"]) + { + dependencies.emplace_back(d.as()); + } + } + + std::unordered_map assetProperties; + + if (metaRoot["Properties"]) + { + for (const auto& node : metaRoot["Properties"]) + { + const auto key = node.first.as(); + const auto value = node.as(); + + assetProperties[key] = value; + } + } + + const auto type = GetAssetTypeFromExtension(filePath.extension().string()); + + std::filesystem::path oldFilePath = filePath; + + if (!Volt::AssetManager::IsSourceAsset(type)) + { + filePath.replace_extension(".vtasset"); + } + + // If an asset with that filePath already exists, we append the asset type to the name + auto metadata = Volt::AssetManager::GetMetadataFromFilePath(filePath); + if (metadata.IsValid()) + { + std::string newFileName = filePath.stem().string(); + newFileName += "_" + Utility::ReplaceCharacter(Volt::GetAssetTypeName(type), ' ', '_'); + newFileName += filePath.extension().string(); + + filePath = filePath.parent_path() / newFileName; + } + + Volt::AssetMetadata& oldMetadata = s_oldMetadata[assetHandle]; + oldMetadata.handle = assetHandle; + oldMetadata.filePath = oldFilePath; + oldMetadata.type = type; + + Volt::AssetManager::Get().AddAssetToRegistry(filePath, assetHandle, type); + } + + void LoadAssetMetadata() + { + const auto projectMetaFiles = GetProjectMetaFiles(); + const auto engineMetaFiles = GetEngineMetaFiles(); + + for (auto file : engineMetaFiles) + { + DeserializeAssetMetafile(file); + } + + for (auto file : projectMetaFiles) + { + DeserializeAssetMetafile(file); + } + } + + void Convert() + { + LoadAssetMetadata(); + + std::unordered_map> importers; + { + importers.emplace(Volt::AssetType::Shader, CreateScope()); + importers.emplace(Volt::AssetType::TextureSource, CreateScope()); + importers.emplace(Volt::AssetType::Material, CreateScope()); + importers.emplace(Volt::AssetType::Mesh, CreateScope()); + importers.emplace(Volt::AssetType::NavMesh, CreateScope()); + importers.emplace(Volt::AssetType::Scene, CreateScope()); + importers.emplace(Volt::AssetType::Skeleton, CreateScope()); + importers.emplace(Volt::AssetType::AnimationGraph, CreateScope()); + importers.emplace(Volt::AssetType::Animation, CreateScope()); + importers.emplace(Volt::AssetType::AnimatedCharacter, CreateScope()); + importers.emplace(Volt::AssetType::ParticlePreset, CreateScope()); + importers.emplace(Volt::AssetType::Prefab, CreateScope()); + importers.emplace(Volt::AssetType::PhysicsMaterial, CreateScope()); + importers.emplace(Volt::AssetType::BehaviorGraph, CreateScope()); + importers.emplace(Volt::AssetType::BlendSpace, CreateScope()); + importers.emplace(Volt::AssetType::PostProcessingStack, CreateScope()); + importers.emplace(Volt::AssetType::PostProcessingMaterial, CreateScope()); + importers.emplace(Volt::AssetType::NetContract, CreateScope()); + } + + // We start by converting all texture source files to texture files + for (auto& [handle, metadata] : Volt::AssetManager::GetAssetRegistryMutable()) + { + if (metadata.type != Volt::AssetType::TextureSource) + { + continue; + } + + Ref asset = Volt::AssetManager::Get().GetFactory().CreateAssetOfType(Volt::AssetType::Texture); + asset->handle = metadata.handle; + importers[metadata.type]->Load(s_oldMetadata[metadata.handle], asset); + asset->handle = metadata.handle; + + metadata.filePath.replace_extension(".vtasset"); + metadata.type = Volt::AssetType::Texture; + Volt::AssetManager::SaveAsset(asset); + } + + // Then we resave all other assets into it's new format + for (const auto& [handle, metadata] : Volt::AssetManager::GetAssetRegistry()) + { + if (!importers.contains(metadata.type) || metadata.type == Volt::AssetType::Shader || metadata.type == Volt::AssetType::TextureSource) + { + continue; + } + + Ref asset = Volt::AssetManager::Get().GetFactory().CreateAssetOfType(metadata.type); + asset->handle = metadata.handle; + importers[metadata.type]->Load(s_oldMetadata[metadata.handle], asset); + asset->handle = metadata.handle; + + Volt::AssetManager::SaveAsset(asset); + } + + s_oldMetadata.clear(); + } +} diff --git a/Volt/Sandbox/src/ProjectUpgrade/V015/V015Convert.h b/Volt/Sandbox/src/ProjectUpgrade/V015/V015Convert.h new file mode 100644 index 000000000..d9ae1bdd8 --- /dev/null +++ b/Volt/Sandbox/src/ProjectUpgrade/V015/V015Convert.h @@ -0,0 +1,6 @@ +#pragma once + +namespace V015 +{ + extern void Convert(); +} diff --git a/Volt/Sandbox/src/Sandbox/DebugRendering.cpp b/Volt/Sandbox/src/Sandbox/DebugRendering.cpp index 241dd6d3c..2eef55338 100644 --- a/Volt/Sandbox/src/Sandbox/DebugRendering.cpp +++ b/Volt/Sandbox/src/Sandbox/DebugRendering.cpp @@ -293,7 +293,7 @@ void Sandbox::RenderGizmos(Ref scene, Ref camera) { Volt::Entity entity{ id, myRuntimeScene.get() }; - auto cubeMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube.vtmesh"); + auto cubeMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); const glm::mat4 colliderTransform = glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), collider.halfSize * 2.f * 0.01f); Volt::DebugRenderer::DrawMesh(cubeMesh, collisionMaterial, entity.GetTransform() * colliderTransform, entity.GetID()); @@ -303,7 +303,7 @@ void Sandbox::RenderGizmos(Ref scene, Ref camera) { Volt::Entity entity{ id, myRuntimeScene.get() }; - auto sphereMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtmesh"); + auto sphereMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtasset"); const glm::mat4 colliderTransform = glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), { collider.radius * 2.f * 0.01f }); Volt::DebugRenderer::DrawMesh(sphereMesh, collisionMaterial, entity.GetTransform() * colliderTransform, entity.GetID()); @@ -314,7 +314,7 @@ void Sandbox::RenderGizmos(Ref scene, Ref camera) Volt::Entity entity{ id, myRuntimeScene.get() }; const glm::mat4 colliderTransform = glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), { collider.radius * 2.f * 0.01f, collider.height * 0.01f, collider.radius * 2.f * 0.01f }); - auto capsuleMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Capsule.vtmesh"); + auto capsuleMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Capsule.vtasset"); Volt::DebugRenderer::DrawMesh(capsuleMesh, collisionMaterial, entity.GetTransform() * colliderTransform, entity.GetID()); }); @@ -349,7 +349,7 @@ void Sandbox::RenderGizmos(Ref scene, Ref camera) if (entity.HasComponent()) { const auto& collider = entity.GetComponent(); - auto cubeMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube.vtmesh"); + auto cubeMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); const glm::mat4 colliderTransform = glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), collider.halfSize * 2.f * 0.01f); Volt::DebugRenderer::DrawMesh(cubeMesh, collisionMaterial, entity.GetTransform() * colliderTransform, entity.GetID()); @@ -358,7 +358,7 @@ void Sandbox::RenderGizmos(Ref scene, Ref camera) if (entity.HasComponent()) { const auto& collider = entity.GetComponent(); - auto sphereMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtmesh"); + auto sphereMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtasset"); const glm::mat4 colliderTransform = glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), { collider.radius * 2.f * 0.01f }); Volt::DebugRenderer::DrawMesh(sphereMesh, collisionMaterial, entity.GetTransform() * colliderTransform, entity.GetID()); @@ -369,7 +369,7 @@ void Sandbox::RenderGizmos(Ref scene, Ref camera) const auto& collider = entity.GetComponent(); const glm::mat4 colliderTransform = glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), { collider.radius * 2.f * 0.01f, collider.height * 0.01f, collider.radius * 2.f * 0.01f }); - auto capsuleMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Capsule.vtmesh"); + auto capsuleMesh = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Capsule.vtasset"); Volt::DebugRenderer::DrawMesh(capsuleMesh, collisionMaterial, entity.GetTransform() * colliderTransform, entity.GetID()); } diff --git a/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgradeModal.cpp b/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.cpp similarity index 99% rename from Volt/Sandbox/src/Sandbox/Modals/ProjectUpgradeModal.cpp rename to Volt/Sandbox/src/Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.cpp index 99b1a226a..44fcd0534 100644 --- a/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgradeModal.cpp +++ b/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.cpp @@ -267,6 +267,10 @@ void ProjectUpgradeModal::UpgradeCurrentProject() ConvertScenesToV013(); } + if (projectVersion.GetPatch() < 4 && projectVersion.GetMinor() < 2 && projectVersion.GetMajor() == 0) + { + } + Volt::ProjectManager::OnProjectUpgraded(); Volt::ProjectManager::SerializeProject(); } @@ -826,6 +830,11 @@ void ProjectUpgradeModal::ConvertPreV013Prefab(const std::filesystem::path& file Volt::PrefabImporter::Get().Save(imposterMeta, newPrefab); } +void ProjectUpgradeModal::ConvertAssetsToV015() +{ + +} + void ProjectUpgradeModal::DeserializePreV113SceneLayer(Ref scene, Volt::SceneLayer& sceneLayer, const std::filesystem::path& layerPath, std::map& entityRemapping) { Volt::YAMLFileStreamReader streamReader{}; diff --git a/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgradeModal.h b/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.h similarity index 98% rename from Volt/Sandbox/src/Sandbox/Modals/ProjectUpgradeModal.h rename to Volt/Sandbox/src/Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.h index 1eb2b4c9b..8139b95d2 100644 --- a/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgradeModal.h +++ b/Volt/Sandbox/src/Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.h @@ -30,15 +30,16 @@ class ProjectUpgradeModal : public Modal private: void UpgradeCurrentProject(); - void ConvertMetaFilesFromV0(); - void ConvertAnimationGraphsToV0_1_2(); void ConvertMetaFilesToV011(); + void ConvertAnimationGraphsToV0_1_2(); + void ConvertPrefabsToV013(); void ConvertScenesToV013(); - void ConvertPreV013Prefab(const std::filesystem::path& filePath); - + + void ConvertAssetsToV015(); + void DeserializePreV113SceneLayer(Ref scene, Volt::SceneLayer& sceneLayer, const std::filesystem::path& layerPath, std::map& entityRemapping); void DeserializePreV013Entity(Ref scene, Volt::YAMLFileStreamReader& streamReader, std::map& entityRemapping, bool isPrefabEntity); void DeserializePreV113Component(uint8_t* componentData, const Volt::IComponentTypeDesc* componentDesc, Volt::YAMLFileStreamReader& streamReader); diff --git a/Volt/Sandbox/src/Sandbox/Sandbox.cpp b/Volt/Sandbox/src/Sandbox/Sandbox.cpp index a2e1b06d2..81becde74 100644 --- a/Volt/Sandbox/src/Sandbox/Sandbox.cpp +++ b/Volt/Sandbox/src/Sandbox/Sandbox.cpp @@ -5,7 +5,7 @@ #include "Sandbox/UISystems/ModalSystem.h" -#include "Sandbox/Modals/ProjectUpgradeModal.h" +#include "Sandbox/Modals/ProjectUpgrade/ProjectUpgradeModal.h" #include "Sandbox/Window/PropertiesPanel.h" #include "Sandbox/Window/ViewportPanel.h" @@ -91,8 +91,8 @@ #include -#include "Volt/Asset/ImportersNew/SourceTextureSerializer.h" -#include "Volt/Asset/ImportersNew/TextureSerializer.h" +#include "Volt/Asset/Serializers/SourceTextureSerializer.h" +#include "Volt/Asset/Serializers/TextureSerializer.h" Sandbox::Sandbox() { @@ -109,7 +109,11 @@ void Sandbox::OnAttach() { SelectionManager::Init(); - EditorResources::Initialize(); + if (!Volt::ProjectManager::GetProject().isDeprecated) + { + EditorResources::Initialize(); + } + VersionControl::Initialize(VersionControlSystem::Perforce); NodeEditorHelpers::Initialize(); IONodeGraphEditorHelpers::Initialize(); diff --git a/Volt/Sandbox/src/Sandbox/Utility/AssetBrowserPopup.cpp b/Volt/Sandbox/src/Sandbox/Utility/AssetBrowserPopup.cpp index 3341f355a..ebd46f5d1 100644 --- a/Volt/Sandbox/src/Sandbox/Utility/AssetBrowserPopup.cpp +++ b/Volt/Sandbox/src/Sandbox/Utility/AssetBrowserPopup.cpp @@ -72,7 +72,7 @@ AssetBrowserPopup::State AssetBrowserPopup::RenderView(const std::vector #include +#include #include @@ -93,13 +94,13 @@ void EditorResources::Initialize() // Meshes { - myEditorMeshes[EditorMesh::Cube] = TryLoadMesh("Engine/Meshes/Primitives/SM_Cube.vtmesh"); - myEditorMeshes[EditorMesh::Capsule] = TryLoadMesh("Engine/Meshes/Primitives/SM_Capsule.vtmesh"); - myEditorMeshes[EditorMesh::Cone] = TryLoadMesh("Engine/Meshes/Primitives/SM_Cone.vtmesh"); - myEditorMeshes[EditorMesh::Cylinder] = TryLoadMesh("Engine/Meshes/Primitives/SM_Cylinder.vtmesh"); - myEditorMeshes[EditorMesh::Plane] = TryLoadMesh("Engine/Meshes/Primitives/SM_Plane.vtmesh"); - myEditorMeshes[EditorMesh::Sphere] = TryLoadMesh("Engine/Meshes/Primitives/SM_Sphere.vtmesh"); - myEditorMeshes[EditorMesh::Arrow] = TryLoadMesh("Editor/Meshes/Arrow/3dpil.vtmesh"); + myEditorMeshes[EditorMesh::Cube] = TryLoadMesh("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); + myEditorMeshes[EditorMesh::Capsule] = TryLoadMesh("Engine/Meshes/Primitives/SM_Capsule.vtasset"); + myEditorMeshes[EditorMesh::Cone] = TryLoadMesh("Engine/Meshes/Primitives/SM_Cone.vtasset"); + myEditorMeshes[EditorMesh::Cylinder] = TryLoadMesh("Engine/Meshes/Primitives/SM_Cylinder.vtasset"); + myEditorMeshes[EditorMesh::Plane] = TryLoadMesh("Engine/Meshes/Primitives/SM_Plane.vtasset"); + myEditorMeshes[EditorMesh::Sphere] = TryLoadMesh("Engine/Meshes/Primitives/SM_Sphere.vtasset"); + //myEditorMeshes[EditorMesh::Arrow] = TryLoadMesh("Editor/Meshes/Arrow/3dpil.vtasset"); } } @@ -127,8 +128,8 @@ Ref EditorResources::GetEditorIcon(EditorIcon icon) return Volt::Renderer::GetDefaultData().whiteTexture; } - return myEditorIcons.at(icon); -} + return myEditorIcons.at(icon); + } Ref EditorResources::GetEditorMesh(EditorMesh mesh) { @@ -155,8 +156,8 @@ Ref EditorResources::TryLoadIcon(const std::filesystem::path& p Ref EditorResources::TryLoadMesh(const std::filesystem::path& path) { - Ref mesh = CreateRef(); - if (!Volt::MeshTypeImporter::ImportMesh(path, *mesh)) + Ref mesh = Volt::AssetManager::GetAsset(path); + if (!mesh->IsValid()) { mesh = Volt::Shape::CreateUnitCube(); } diff --git a/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/PreviewRenderer.cpp b/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/PreviewRenderer.cpp index 2ba0a88a5..bef28ffec 100644 --- a/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/PreviewRenderer.cpp +++ b/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/PreviewRenderer.cpp @@ -134,7 +134,7 @@ bool PreviewRenderer::RenderMaterialPreview(Weak assetI return false; } - auto meshAsset = Volt::AssetManager::QueueAsset(Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Sphere.vtmesh")); + auto meshAsset = Volt::AssetManager::QueueAsset(Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Sphere.vtasset")); if (!meshAsset || !meshAsset->IsValid()) { return false; diff --git a/Volt/Sandbox/src/Sandbox/Window/CharacterEditorPanel.cpp b/Volt/Sandbox/src/Sandbox/Window/CharacterEditorPanel.cpp index 279909e9a..08da26622 100644 --- a/Volt/Sandbox/src/Sandbox/Window/CharacterEditorPanel.cpp +++ b/Volt/Sandbox/src/Sandbox/Window/CharacterEditorPanel.cpp @@ -152,7 +152,7 @@ void CharacterEditorPanel::OpenAsset(Ref asset) for (const auto& attachment : myCurrentCharacter->GetJointAttachments()) { auto newEntity = myScene->CreateEntity(); - newEntity.AddComponent().handle = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtmesh")->handle; + newEntity.AddComponent().handle = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtasset")->handle; newEntity.SetScale(0.2f); myCharacterEntity.GetComponent().attachedEntities[attachment.id].emplace_back(newEntity); @@ -898,7 +898,7 @@ void CharacterEditorPanel::AddJointAttachmentPopup() newAttachment.jointIndex = myCurrentCharacter->GetSkeleton()->GetJointIndexFromName(name); auto newEntity = myScene->CreateEntity(); - newEntity.AddComponent().handle = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtmesh")->handle; + newEntity.AddComponent().handle = Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtasset")->handle; newEntity.SetScale(0.2f); myCharacterEntity.GetComponent().attachedEntities[newAttachment.id].emplace_back(newEntity); diff --git a/Volt/Sandbox/src/Sandbox/Window/MaterialEditorPanel.cpp b/Volt/Sandbox/src/Sandbox/Window/MaterialEditorPanel.cpp index c23f81eeb..51972f721 100644 --- a/Volt/Sandbox/src/Sandbox/Window/MaterialEditorPanel.cpp +++ b/Volt/Sandbox/src/Sandbox/Window/MaterialEditorPanel.cpp @@ -40,7 +40,7 @@ MaterialEditorPanel::MaterialEditorPanel(Ref& aScene) { auto entity = myPreviewScene->CreateEntity(); Volt::MeshComponent& comp = entity.AddComponent(); - comp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Sphere.vtmesh"); + comp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Sphere.vtasset"); myPreviewEntity = entity; } diff --git a/Volt/Sandbox/src/Sandbox/Window/MeshPreviewPanel.cpp b/Volt/Sandbox/src/Sandbox/Window/MeshPreviewPanel.cpp index 3aff09daf..075cacbdb 100644 --- a/Volt/Sandbox/src/Sandbox/Window/MeshPreviewPanel.cpp +++ b/Volt/Sandbox/src/Sandbox/Window/MeshPreviewPanel.cpp @@ -30,7 +30,7 @@ MeshPreviewPanel::MeshPreviewPanel() { auto entity = myScene->CreateEntity(); Volt::MeshComponent& comp = entity.AddComponent(); - comp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cube.vtmesh"); + comp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); myPreviewEntity = entity; } } diff --git a/Volt/Sandbox/src/Sandbox/Window/NavigationPanel.cpp b/Volt/Sandbox/src/Sandbox/Window/NavigationPanel.cpp index 84bdc911a..09dc46087 100644 --- a/Volt/Sandbox/src/Sandbox/Window/NavigationPanel.cpp +++ b/Volt/Sandbox/src/Sandbox/Window/NavigationPanel.cpp @@ -118,7 +118,7 @@ Ref NavigationPanel::CompileWorldMeshes() // Volt::Entity entity = { id, myScene }; // auto transform = entity.GetTransform(); - // srcMeshes.emplace_back(Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube.vtmesh")); + // srcMeshes.emplace_back(Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset")); // srcTransforms.emplace_back(transform * glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), collider.halfSize * 2.f * 0.01f)); //}); @@ -127,7 +127,7 @@ Ref NavigationPanel::CompileWorldMeshes() // Volt::Entity entity = { id, myScene }; // auto transform = entity.GetTransform(); - // srcMeshes.emplace_back(Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Capsule.vtmesh")); + // srcMeshes.emplace_back(Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Capsule.vtasset")); // srcTransforms.emplace_back(transform * glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), { collider.radius * 2.f * 0.01f, collider.height * 0.01f, collider.radius * 2.f * 0.01f })); //}); @@ -136,7 +136,7 @@ Ref NavigationPanel::CompileWorldMeshes() // Volt::Entity entity = { id, myScene }; // auto transform = entity.GetTransform(); // - // srcMeshes.emplace_back(Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtmesh")); + // srcMeshes.emplace_back(Volt::AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Sphere.vtasset")); // srcTransforms.emplace_back(transform * glm::translate(glm::mat4(1.f), collider.offset) * glm::scale(glm::mat4(1.f), { collider.radius * 2.f * 0.01f })); //}); diff --git a/Volt/Sandbox/src/Sandbox/Window/SceneViewPanel.cpp b/Volt/Sandbox/src/Sandbox/Window/SceneViewPanel.cpp index 7bec6354c..84e531484 100644 --- a/Volt/Sandbox/src/Sandbox/Window/SceneViewPanel.cpp +++ b/Volt/Sandbox/src/Sandbox/Window/SceneViewPanel.cpp @@ -1314,7 +1314,7 @@ void SceneViewPanel::DrawMainRightClickPopup() { auto ent = m_scene->CreateEntity(); auto& meshComp = ent.AddComponent(); - meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cube.vtmesh"); + meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); ent.SetTag("New Cube"); SelectionManager::DeselectAll(); @@ -1325,7 +1325,7 @@ void SceneViewPanel::DrawMainRightClickPopup() { auto ent = m_scene->CreateEntity(); auto& meshComp = ent.AddComponent(); - meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Capsule.vtmesh"); + meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Capsule.vtasset"); ent.SetTag("New Capsule"); SelectionManager::DeselectAll(); @@ -1336,7 +1336,7 @@ void SceneViewPanel::DrawMainRightClickPopup() { auto ent = m_scene->CreateEntity(); auto& meshComp = ent.AddComponent(); - meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cone.vtmesh"); + meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cone.vtasset"); ent.SetTag("New Cone"); SelectionManager::DeselectAll(); @@ -1347,7 +1347,7 @@ void SceneViewPanel::DrawMainRightClickPopup() { auto ent = m_scene->CreateEntity(); auto& meshComp = ent.AddComponent(); - meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cylinder.vtmesh"); + meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cylinder.vtasset"); ent.SetTag("New Cylinder"); SelectionManager::DeselectAll(); @@ -1358,7 +1358,7 @@ void SceneViewPanel::DrawMainRightClickPopup() { auto ent = m_scene->CreateEntity(); auto& meshComp = ent.AddComponent(); - meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Sphere.vtmesh"); + meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Sphere.vtasset"); ent.SetTag("New Sphere"); SelectionManager::DeselectAll(); @@ -1369,7 +1369,7 @@ void SceneViewPanel::DrawMainRightClickPopup() { auto ent = m_scene->CreateEntity(); auto& meshComp = ent.AddComponent(); - meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Plane.vtmesh"); + meshComp.handle = Volt::AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Plane.vtasset"); ent.SetTag("New Plane"); SelectionManager::DeselectAll(); diff --git a/Volt/Sandbox/src/SandboxApp.cpp b/Volt/Sandbox/src/SandboxApp.cpp index 9a2378b02..7f8ec1c41 100644 --- a/Volt/Sandbox/src/SandboxApp.cpp +++ b/Volt/Sandbox/src/SandboxApp.cpp @@ -1,11 +1,13 @@ #include "sbpch.h" #include "Sandbox/Sandbox.h" +#include "ProjectUpgrade/ProjectUpgradeLayer.h" #include #include #include +#include class SandboxApp : public Volt::Application { @@ -13,8 +15,16 @@ class SandboxApp : public Volt::Application SandboxApp(const Volt::ApplicationInfo& appInfo) : Volt::Application(appInfo) { - Sandbox* sandbox = new Sandbox(); - PushLayer(sandbox); + if (Volt::ProjectManager::GetProject().isDeprecated) + { + ProjectUpgradeLayer* layer = new ProjectUpgradeLayer(); + PushLayer(layer); + } + else + { + Sandbox* sandbox = new Sandbox(); + PushLayer(sandbox); + } } }; diff --git a/Volt/Volt/src/Volt/Asset/Asset.h b/Volt/Volt/src/Volt/Asset/Asset.h index b498fdb90..70c0d3a0d 100644 --- a/Volt/Volt/src/Volt/Asset/Asset.h +++ b/Volt/Volt/src/Volt/Asset/Asset.h @@ -86,13 +86,13 @@ namespace Volt { ".vtchr", AssetType::AnimatedCharacter }, { ".vtanimgraph", AssetType::AnimationGraph }, - { ".png", AssetType::Texture }, - { ".jpg", AssetType::Texture }, - { ".jpeg", AssetType::Texture }, - { ".tga", AssetType::Texture }, - { ".ktx", AssetType::Texture }, - { ".dds", AssetType::Texture }, - { ".hdr", AssetType::Texture }, + { ".png", AssetType::TextureSource }, + { ".jpg", AssetType::TextureSource }, + { ".jpeg", AssetType::TextureSource }, + { ".tga", AssetType::TextureSource }, + { ".ktx", AssetType::TextureSource }, + { ".dds", AssetType::TextureSource }, + { ".hdr", AssetType::TextureSource }, { ".vtsdef", AssetType::Shader }, { ".hlsl", AssetType::ShaderSource }, @@ -131,6 +131,7 @@ namespace Volt { "Animated Character", AssetType::AnimatedCharacter }, { "Animation Graph", AssetType::AnimationGraph }, + { "TextureSource", AssetType::TextureSource }, { "Texture", AssetType::Texture }, { "Shader", AssetType::Shader }, @@ -170,6 +171,19 @@ namespace Volt return "Unknown"; } + inline static std::string GetAssetTypeExtension(AssetType type) + { + for (const auto& [ext, assetType] : s_assetExtensionsMap) + { + if (assetType == type) + { + return ext; + } + } + + return "Unknown"; + } + struct AssetMetadata { inline void SetValue(const std::string& key, const std::string& data) diff --git a/Volt/Volt/src/Volt/Asset/AssetFactory.cpp b/Volt/Volt/src/Volt/Asset/AssetFactory.cpp index 0664d9683..d8f684fb3 100644 --- a/Volt/Volt/src/Volt/Asset/AssetFactory.cpp +++ b/Volt/Volt/src/Volt/Asset/AssetFactory.cpp @@ -77,7 +77,7 @@ namespace Volt m_assetFactoryFunctions.clear(); } - Ref AssetFactory::CreateAssetOfType(AssetType type) + Ref AssetFactory::CreateAssetOfType(AssetType type) const { return m_assetFactoryFunctions.at(type)(); } diff --git a/Volt/Volt/src/Volt/Asset/AssetFactory.h b/Volt/Volt/src/Volt/Asset/AssetFactory.h index aa09b0699..dbf83ae65 100644 --- a/Volt/Volt/src/Volt/Asset/AssetFactory.h +++ b/Volt/Volt/src/Volt/Asset/AssetFactory.h @@ -17,7 +17,7 @@ namespace Volt void Initialize(); void Shutdown(); - Ref CreateAssetOfType(AssetType type); + Ref CreateAssetOfType(AssetType type) const; private: std::unordered_map m_assetFactoryFunctions; diff --git a/Volt/Volt/src/Volt/Asset/AssetManager.cpp b/Volt/Volt/src/Volt/Asset/AssetManager.cpp index 17c744518..c10fe1ccc 100644 --- a/Volt/Volt/src/Volt/Asset/AssetManager.cpp +++ b/Volt/Volt/src/Volt/Asset/AssetManager.cpp @@ -4,28 +4,42 @@ #include "Volt/Core/Base.h" #include "Volt/Core/Application.h" -#include "Volt/Asset/Importers/AssetImporter.h" - #include "Volt/Asset/Importers/MeshTypeImporter.h" #include "Volt/Asset/Importers/TextureImporter.h" -#include "Volt/Asset/Importers/MeshSourceImporter.h" -#include "Volt/Asset/Importers/VTNavMeshImporter.h" -#include "Volt/Asset/Importers/SkeletonImporter.h" -#include "Volt/Asset/Importers/AnimationImporter.h" -#include "Volt/Asset/Importers/SceneImporter.h" -#include "Volt/Asset/Importers/AnimatedCharacterImporter.h" -#include "Volt/Asset/Importers/AnimationGraphImporter.h" -#include "Volt/Asset/Importers/PrefabImporter.h" -#include "Volt/Asset/Importers/BehaviorTreeImporter.h" -#include "Volt/Asset/Importers/NetContractImporter.h" -#include "Volt/Asset/Importers/ParticlePresetImporter.h" + +#include "Volt/Asset/Serializers/AnimatedCharacterSerializer.h" +#include "Volt/Asset/Serializers/AnimationGraphSerializer.h" +#include "Volt/Asset/Serializers/AnimationSerializer.h" +#include "Volt/Asset/Serializers/BehaviourTreeSerializer.h" +#include "Volt/Asset/Serializers/BlendSpaceSerializer.h" +#include "Volt/Asset/Serializers/FontSerializer.h" +#include "Volt/Asset/Serializers/MaterialSerializer.h" +#include "Volt/Asset/Serializers/MeshSerializer.h" +#include "Volt/Asset/Serializers/NavigationMeshSerializer.h" +#include "Volt/Asset/Serializers/NetContractSerializer.h" +#include "Volt/Asset/Serializers/ParticlePresetSerializer.h" +#include "Volt/Asset/Serializers/PhysicsMaterialSerializer.h" +#include "Volt/Asset/Serializers/PostProcessingMaterialSerializer.h" +#include "Volt/Asset/Serializers/PostProcessingStackSerializer.h" +#include "Volt/Asset/Serializers/PrefabSerializer.h" +#include "Volt/Asset/Serializers/SceneSerializer.h" +#include "Volt/Asset/Serializers/ShaderSerializer.h" +#include "Volt/Asset/Serializers/SkeletonSerializer.h" +#include "Volt/Asset/Serializers/SourceMeshSerializer.h" +#include "Volt/Asset/Serializers/SourceTextureSerializer.h" +#include "Volt/Asset/Serializers/TextureSerializer.h" +#include "Volt/Asset/Serializers/VideoSerializer.h" + #include "Volt/Asset/AssetFactory.h" #include "Volt/Platform/ThreadUtility.h" +#include "Volt/Net/SceneInteraction/NetContract.h" + #include "Volt/Utility/FileSystem.h" #include "Volt/Utility/YAMLSerializationHelpers.h" #include "Volt/Utility/SerializationMacros.h" +#include "Volt/Core/ScopedTimer.h" namespace Volt { @@ -51,8 +65,13 @@ namespace Volt m_assetFactory = CreateScope(); m_assetFactory->Initialize(); + if (!ProjectManager::AreCurrentProjectMetaFilesDeprecated()) + { + NetContractContainer::Load(); + } + RegisterAssetSerializers(); - LoadAssetMetafiles(); + LoadAllAssetMetadata(); } void AssetManager::Shutdown() @@ -97,7 +116,6 @@ namespace Volt } metadata.dependencies.emplace_back(dependencyMetaData.handle); - SerializeAssetMetaFile(metadata.handle); } const std::vector AssetManager::GetAllAssetsOfType(AssetType wantedAssetType) @@ -149,27 +167,28 @@ namespace Volt void AssetManager::RegisterAssetSerializers() { - m_assetImporters.emplace(AssetType::MeshSource, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Texture, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Shader, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Material, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Mesh, CreateScope()); // Done - m_assetImporters.emplace(AssetType::NavMesh, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Scene, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Skeleton, CreateScope()); // Done - m_assetImporters.emplace(AssetType::AnimationGraph, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Animation, CreateScope()); // Done - m_assetImporters.emplace(AssetType::AnimatedCharacter, CreateScope()); // Done - m_assetImporters.emplace(AssetType::ParticlePreset, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Prefab, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Font, CreateScope()); // Done - m_assetImporters.emplace(AssetType::PhysicsMaterial, CreateScope()); // Done - m_assetImporters.emplace(AssetType::Video, CreateScope()); // Done - m_assetImporters.emplace(AssetType::BehaviorGraph, CreateScope()); // Done - m_assetImporters.emplace(AssetType::BlendSpace, CreateScope()); // Done - m_assetImporters.emplace(AssetType::PostProcessingStack, CreateScope()); // Done - m_assetImporters.emplace(AssetType::PostProcessingMaterial, CreateScope()); // Done - m_assetImporters.emplace(AssetType::NetContract, CreateScope()); // Done + m_assetSerializers.emplace(AssetType::MeshSource, CreateScope()); + m_assetSerializers.emplace(AssetType::TextureSource, CreateScope()); + m_assetSerializers.emplace(AssetType::Texture, CreateScope()); + m_assetSerializers.emplace(AssetType::Shader, CreateScope()); + m_assetSerializers.emplace(AssetType::Material, CreateScope()); + m_assetSerializers.emplace(AssetType::Mesh, CreateScope()); + m_assetSerializers.emplace(AssetType::NavMesh, CreateScope()); + m_assetSerializers.emplace(AssetType::Scene, CreateScope()); + m_assetSerializers.emplace(AssetType::Skeleton, CreateScope()); + m_assetSerializers.emplace(AssetType::AnimationGraph, CreateScope()); + m_assetSerializers.emplace(AssetType::Animation, CreateScope()); + m_assetSerializers.emplace(AssetType::AnimatedCharacter, CreateScope()); + m_assetSerializers.emplace(AssetType::ParticlePreset, CreateScope()); + m_assetSerializers.emplace(AssetType::Prefab, CreateScope()); + m_assetSerializers.emplace(AssetType::Font, CreateScope()); + m_assetSerializers.emplace(AssetType::PhysicsMaterial, CreateScope()); + m_assetSerializers.emplace(AssetType::Video, CreateScope()); + m_assetSerializers.emplace(AssetType::BehaviorGraph, CreateScope()); + m_assetSerializers.emplace(AssetType::BlendSpace, CreateScope()); + m_assetSerializers.emplace(AssetType::PostProcessingStack, CreateScope()); + m_assetSerializers.emplace(AssetType::PostProcessingMaterial, CreateScope()); + m_assetSerializers.emplace(AssetType::NetContract, CreateScope()); } void AssetManager::LoadAsset(AssetHandle assetHandle, Ref& asset) @@ -191,8 +210,8 @@ namespace Volt { ReadLock lock{ m_assetRegistryMutex }; - AssetMetadata& metadata = GetMetadataFromHandleMutable(assetHandle); + if (!metadata.IsValid()) { VT_CORE_ERROR("[AssetManager] Trying to load asset which has invalid metadata!"); @@ -200,14 +219,14 @@ namespace Volt return; } - if (!m_assetImporters.contains(metadata.type)) + if (!m_assetSerializers.contains(metadata.type)) { VT_CORE_WARN("[AssetManager] No importer for asset found!"); asset->SetFlag(AssetFlag::Invalid, true); return; } - m_assetImporters.at(metadata.type)->Load(metadata, asset); + m_assetSerializers.at(metadata.type)->Deserialize(metadata, asset); #ifdef VT_DEBUG VT_CORE_TRACE("[AssetManager] Loaded asset {0} with handle {1}!", metadata.filePath, assetHandle); @@ -225,19 +244,49 @@ namespace Volt } } - void AssetManager::LoadAssetMetafiles() + void AssetManager::LoadAllAssetMetadata() + { + VT_CORE_INFO("[AssetManager] Fetching asset meta data..."); + ScopedTimer timer{}; + + const auto projectAssetFiles = GetProjectAssetFiles(); + const auto engineAssetFiles = GetEngineAssetFiles(); + + for (auto file : engineAssetFiles) + { + DeserializeAssetMetadata(file); + } + + for (auto file : projectAssetFiles) + { + DeserializeAssetMetadata(file); + } + + VT_CORE_INFO("[AssetManager] Finished fetching meta data in {} seconds!", timer.GetTime()); + } + + void AssetManager::DeserializeAssetMetadata(std::filesystem::path assetPath) { - const auto projectMetaFiles = GetProjectMetaFiles(); - const auto engineMetaFiles = GetEngineMetaFiles(); + BinaryStreamReader streamReader{ assetPath }; + if (!streamReader.IsStreamValid()) + { + VT_CORE_ERROR("Failed to open file: {0}!", assetPath); + return; + } - for (auto file : engineMetaFiles) + SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader); + if (serializedMetadata.magic != SerializedAssetMetadata::AssetMagic) { - DeserializeAssetMetafile(file); + return; } - for (auto file : projectMetaFiles) { - DeserializeAssetMetafile(file); + WriteLock lock{ m_assetRegistryMutex }; + AssetMetadata& metadata = m_assetRegistry[serializedMetadata.handle]; + metadata.handle = serializedMetadata.handle; + metadata.filePath = assetPath; + metadata.properties = {}; + metadata.type = serializedMetadata.type; } } @@ -280,7 +329,7 @@ namespace Volt { auto& instance = Get(); - if (instance.m_assetImporters.find(asset->GetType()) == instance.m_assetImporters.end()) + if (instance.m_assetSerializers.find(asset->GetType()) == instance.m_assetSerializers.end()) { VT_CORE_ERROR("[AssetManager] No exporter for asset {0} found!", asset->handle); return; @@ -310,7 +359,7 @@ namespace Volt metadata = GetMetadataFromHandle(asset->handle); } - instance.m_assetImporters[metadata.type]->Save(metadata, asset); + instance.m_assetSerializers[metadata.type]->Serialize(metadata, asset); { WriteLock lock{ instance.m_assetCacheMutex }; @@ -319,15 +368,13 @@ namespace Volt instance.m_assetCache.emplace(asset->handle, asset); } } - - instance.SerializeAssetMetaFile(asset->handle); } void AssetManager::SaveAsset(const Ref asset) { auto& instance = Get(); - if (instance.m_assetImporters.find(asset->GetType()) == instance.m_assetImporters.end()) + if (instance.m_assetSerializers.find(asset->GetType()) == instance.m_assetSerializers.end()) { VT_CORE_ERROR("[AssetManager] No exporter for asset {0} found!", asset->handle); return; @@ -346,7 +393,7 @@ namespace Volt metadata = GetMetadataFromHandle(asset->handle); } - instance.m_assetImporters[metadata.type]->Save(metadata, asset); + instance.m_assetSerializers[metadata.type]->Serialize(metadata, asset); { WriteLock lock{ instance.m_assetCacheMutex }; @@ -384,9 +431,6 @@ namespace Volt WriteLock lock{ m_assetRegistryMutex }; m_assetRegistry[asset->handle].filePath = newPath; } - - RemoveMetaFile(assetFilePath); - SerializeAssetMetaFile(asset->handle); } void AssetManager::MoveAsset(AssetHandle assetHandle, const std::filesystem::path& targetDir) @@ -415,9 +459,6 @@ namespace Volt WriteLock lock{ m_assetRegistryMutex }; m_assetRegistry[assetHandle].filePath = newPath; } - - RemoveMetaFile(assetFilePath); - SerializeAssetMetaFile(assetHandle); } void AssetManager::MoveAssetInRegistry(const std::filesystem::path& sourcePath, const std::filesystem::path& targetPath) @@ -433,9 +474,6 @@ namespace Volt metadata.filePath = GetCleanAssetFilePath(targetPath); assetHandle = metadata.handle; } - - RemoveMetaFile(sourcePath); - SerializeAssetMetaFile(assetHandle); } void AssetManager::MoveFullFolder(const std::filesystem::path& sourceDir, const std::filesystem::path& targetDir) @@ -484,11 +522,7 @@ namespace Volt newPath.erase(directoryStringLoc, sourceDir.string().length()); newPath.insert(directoryStringLoc, targetDir.string()); - - RemoveMetaFile(metadata.filePath); metadata.filePath = GetCleanAssetFilePath(newPath); - - SerializeAssetMetaFile(metadata.handle); } } } @@ -511,9 +545,6 @@ namespace Volt } FileSystem::Rename(projDir / oldPath, newName); - - RemoveMetaFile(oldPath); - SerializeAssetMetaFile(assetHandle); } void AssetManager::RenameAssetFolder(AssetHandle assetHandle, const std::filesystem::path& targetFilePath) @@ -527,9 +558,7 @@ namespace Volt return; } - RemoveMetaFile(metadata.filePath); metadata.filePath = GetCleanAssetFilePath(targetFilePath); - SerializeAssetMetaFile(metadata.handle); } void AssetManager::RemoveAsset(AssetHandle assetHandle) @@ -554,7 +583,6 @@ namespace Volt } FileSystem::MoveToRecycleBin(projDir / filePath); - RemoveMetaFile(filePath); #ifdef VT_DEBUG VT_CORE_INFO("[AssetManager] Removed asset {0} with handle {1}!", assetHandle, filePath.string()); @@ -583,21 +611,26 @@ namespace Volt } FileSystem::MoveToRecycleBin(projDir / filePath); - RemoveMetaFile(filePath); #ifdef VT_DEBUG VT_CORE_INFO("[AssetManager] Removed asset {0} with handle {1}!", metadata.handle, filePath.string()); #endif } - void AssetManager::RemoveMetaFile(const std::filesystem::path& filePath) + bool AssetManager::ValidateAssetType(AssetHandle handle, Ref asset) { - auto metafile = GetContextPath(filePath) / filePath; - metafile.replace_filename(metafile.filename().string() + ".vtmeta"); - if (std::filesystem::exists(metafile)) + ReadLock lock{ Get().m_assetRegistryMutex }; + const auto& metadata = GetMetadataFromHandle(handle); + + // If the metadata is not valid we allow the asset to be valid + if (!metadata.IsValid()) { - std::filesystem::remove(metafile); + return true; } + + VT_CORE_ASSERT(metadata.type == asset->GetType() , "Asset type does not match meta type!"); + + return metadata.type == asset->GetType(); } void AssetManager::RemoveFromRegistry(AssetHandle assetHandle) @@ -638,10 +671,8 @@ namespace Volt m_assetCache.erase(assetHandle); } - const auto cleanFilePath = GetCleanAssetFilePath(metadata.filePath); - RemoveMetaFile(cleanFilePath); - #ifdef VT_DEBUG + const auto cleanFilePath = GetCleanAssetFilePath(metadata.filePath); VT_CORE_INFO("[AssetManager] Removed asset {0} with handle {1} from registry!", assetHandle, cleanFilePath); #endif } @@ -671,10 +702,8 @@ namespace Volt m_assetCache.erase(metadata.handle); } - const auto cleanFilePath = GetCleanAssetFilePath(metadata.filePath); - RemoveMetaFile(cleanFilePath); - #ifdef VT_DEBUG + const auto cleanFilePath = GetCleanAssetFilePath(metadata.filePath); VT_CORE_INFO("[AssetManager] Removed asset {0} with handle {1} from registry!", metadata.handle, cleanFilePath); #endif } @@ -721,8 +750,6 @@ namespace Volt m_assetRegistry.erase(handle); } - RemoveMetaFile(metadata.filePath); - #ifdef VT_DEBUG VT_CORE_INFO("[AssetManager] Removed asset with handle {0} from registry!", handle); #endif @@ -754,12 +781,32 @@ namespace Volt metadata.type = GetAssetTypeFromPath(filePath); } - if (!HasAssetMetaFile(newHandle)) + return newHandle; + } + + void AssetManager::AddAssetToRegistry(const std::filesystem::path& filePath, AssetHandle handle, AssetType type) + { { - SerializeAssetMetaFile(newHandle); + ReadLock lock{ m_assetRegistryMutex }; + const std::filesystem::path cleanPath = GetCleanAssetFilePath(filePath); + const auto& metadata = GetMetadataFromFilePath(filePath); + + if (metadata.IsValid()) + { + return; + } } - return newHandle; + const auto newHandle = handle; + const auto cleanFilePath = GetCleanAssetFilePath(filePath); + + { + WriteLock lock{ m_assetRegistryMutex }; + AssetMetadata& metadata = m_assetRegistry[newHandle]; + metadata.handle = newHandle; + metadata.filePath = cleanFilePath; + metadata.type = type; + } } bool AssetManager::IsLoaded(AssetHandle handle) @@ -879,9 +926,11 @@ namespace Volt { auto& instance = Get(); + std::filesystem::path cleanPath = GetRelativePath(filePath); + for (const auto& [handle, metaData] : instance.m_assetRegistry) { - if (metaData.filePath == filePath) + if (metaData.filePath == cleanPath) { return metaData; } @@ -895,6 +944,11 @@ namespace Volt return Get().m_assetRegistry; } + std::unordered_map& AssetManager::GetAssetRegistryMutable() + { + return Get().m_assetRegistry; + } + const std::filesystem::path AssetManager::GetFilePathFromAssetHandle(AssetHandle handle) { const auto& metadata = GetMetadataFromHandle(handle); @@ -947,18 +1001,25 @@ namespace Volt return {}; } - bool AssetManager::IsSourceFile(AssetHandle handle) + bool AssetManager::IsSourceAsset(AssetHandle handle) { auto& instance = Get(); ReadLock lock{ instance.m_assetRegistryMutex }; const AssetType type = GetAssetTypeFromHandle(handle); + return IsSourceAsset(type); + } + + bool AssetManager::IsSourceAsset(AssetType type) + { switch (type) { case AssetType::MeshSource: case AssetType::ShaderSource: + case AssetType::TextureSource: return true; } + return false; } @@ -996,13 +1057,18 @@ namespace Volt if (temp.find(ProjectManager::GetDirectory().string()) != std::string::npos) { relativePath = std::filesystem::relative(path, ProjectManager::GetDirectory()); - if (relativePath.empty()) - { - relativePath = path.lexically_normal(); - } + } + else if (temp.find(ProjectManager::GetEngineDirectory().string()) != std::string::npos) + { + relativePath = std::filesystem::relative(path, ProjectManager::GetEngineDirectory()); + } + + if (relativePath.empty()) + { + relativePath = path.lexically_normal(); } - return relativePath; + return GetCleanAssetFilePath(relativePath); } void AssetManager::QueueAssetInternal(AssetHandle assetHandle, Ref& asset) @@ -1049,14 +1115,14 @@ namespace Volt asset = m_assetCache.at(handle); } - if (!m_assetImporters.contains(metadata.type)) + if (!m_assetSerializers.contains(metadata.type)) { VT_CORE_ERROR("No importer for asset found!"); asset->SetFlag(AssetFlag::Invalid, true); return; } - m_assetImporters.at(metadata.type)->Load(metadata, asset); + m_assetSerializers.at(metadata.type)->Deserialize(metadata, asset); if (handle != Asset::Null()) { asset->handle = handle; @@ -1131,7 +1197,7 @@ namespace Volt return; } - if (!m_assetImporters.contains(metadata.type)) + if (!m_assetSerializers.contains(metadata.type)) { VT_CORE_ERROR("No importer for asset found!"); return; @@ -1143,7 +1209,7 @@ namespace Volt asset = m_assetCache.at(handle); } - m_assetImporters.at(metadata.type)->Load(metadata, asset); + m_assetSerializers.at(metadata.type)->Deserialize(metadata, asset); if (handle != Asset::Null()) { asset->handle = handle; @@ -1206,17 +1272,17 @@ namespace Volt return pathClean; } - std::vector AssetManager::GetEngineMetaFiles() + std::vector AssetManager::GetEngineAssetFiles() { std::vector files; - const std::string ext(".vtmeta"); + const std::string ext(".vtasset"); // Engine Directory for (auto& p : std::filesystem::recursive_directory_iterator(ProjectManager::GetEngineDirectory() / "Engine")) { if (p.path().extension() == ext) { - files.emplace_back(p.path()); + files.emplace_back(GetRelativePath(p.path())); } } @@ -1227,7 +1293,7 @@ namespace Volt { if (p.path().extension() == ext) { - files.emplace_back(p.path()); + files.emplace_back(GetRelativePath(p.path())); } } } @@ -1235,16 +1301,10 @@ namespace Volt return files; } - std::vector AssetManager::GetProjectMetaFiles() + std::vector AssetManager::GetProjectAssetFiles() { - if (ProjectManager::AreCurrentProjectMetaFilesDeprecated()) - { - VT_CORE_ERROR("[AssetManager]: Unable to load metafiles as the loaded project is deprecated!"); - return {}; - } - std::vector files; - std::string ext(".vtmeta"); + std::string ext(".vtasset"); // Project Directory const auto assetsDir = ProjectManager::GetProject().projectDirectory / ProjectManager::GetProject().assetsDirectory; @@ -1255,139 +1315,11 @@ namespace Volt { if (p.path().extension() == ext) { - files.emplace_back(p.path()); + files.emplace_back(GetRelativePath(p.path())); } } } return files; } - - void AssetManager::SerializeAssetMetaFile(AssetHandle assetHandle) - { - const auto& metadata = GetMetadataFromHandle(assetHandle); - if (!metadata.IsValid()) - { - VT_CORE_WARN("[AssetManager] Unable to save meta file for invalid asset {0}!", metadata.filePath); - return; - } - - YAML::Emitter out; - out << YAML::BeginMap; - out << YAML::Key << "Metadata" << YAML::Value; - { - out << YAML::BeginMap; - VT_SERIALIZE_PROPERTY(assetHandle, metadata.handle, out); - VT_SERIALIZE_PROPERTY(filePath, metadata.filePath, out); - VT_SERIALIZE_PROPERTY(type, (uint32_t)metadata.type, out); - - out << YAML::Key << "Dependencies" << YAML::Value << metadata.dependencies; - - out << YAML::Key << "Properties" << YAML::Value; - out << YAML::BeginMap; - for (const auto& [name, data] : metadata.properties) - { - out << YAML::Key << name << YAML::Value << data; - } - out << YAML::EndMap; - out << YAML::EndMap; - } - out << YAML::EndMap; - out << YAML::EndMap; - - auto metaPath = GetFilesystemPath(assetHandle); - metaPath.replace_filename(metaPath.filename().string() + ".vtmeta"); - - std::ofstream fout(metaPath); - fout << out.c_str(); - fout.close(); - } - - bool AssetManager::HasAssetMetaFile(AssetHandle assetHandle) - { - auto metaPath = GetFilesystemPath(assetHandle); - metaPath.replace_filename(metaPath.filename().string() + ".vtmeta"); - - return FileSystem::Exists(metaPath); - } - - void AssetManager::DeserializeAssetMetafile(std::filesystem::path metaFilePath) - { - if (!std::filesystem::exists(metaFilePath)) - { - return; - } - - std::ifstream file(metaFilePath); - if (!file.is_open()) - { - VT_CORE_CRITICAL("[AssetManager] Failed to open asset registry file: {0}!", metaFilePath.string().c_str()); - return; - } - - std::stringstream strStream; - strStream << file.rdbuf(); - file.close(); - - YAML::Node root; - try - { - root = YAML::Load(strStream.str()); - } - catch (std::exception& e) - { - VT_CORE_CRITICAL("[AssetManager] Meta file {0} contains invalid YAML! Please correct it! Error: {1}", metaFilePath, e.what()); - return; - } - - YAML::Node metaRoot = root["Metadata"]; - - if (!metaRoot["assetHandle"]) - { - VT_CORE_CRITICAL("[AssetManager] Meta file {0} is missing an asset handle! Please correct it!", metaFilePath); - return; - } - - AssetHandle assetHandle = metaRoot["assetHandle"].as(); - - if (!metaRoot["filePath"]) - { - VT_CORE_CRITICAL("[AssetManager] Meta file {0} is missing a file path! Please correct it!", metaFilePath); - return; - } - - std::filesystem::path filePath = metaRoot["filePath"].as(); - - std::vector dependencies; - if (metaRoot["Dependencies"]) - { - for (const auto& d : metaRoot["Dependencies"]) - { - dependencies.emplace_back(d.as()); - } - } - - std::unordered_map assetProperties; - - if (metaRoot["Properties"]) - { - for (const auto& node : metaRoot["Properties"]) - { - const auto key = node.first.as(); - const auto value = node.as(); - - assetProperties[key] = value; - } - } - - { - WriteLock lock{ m_assetRegistryMutex }; - AssetMetadata& metadata = m_assetRegistry[assetHandle]; - metadata.handle = assetHandle; - metadata.filePath = filePath; - metadata.dependencies = dependencies; - metadata.properties = assetProperties; - metadata.type = GetAssetTypeFromExtension(filePath.extension().string()); - } - } } diff --git a/Volt/Volt/src/Volt/Asset/AssetManager.h b/Volt/Volt/src/Volt/Asset/AssetManager.h index 831ae168c..5b3defa31 100644 --- a/Volt/Volt/src/Volt/Asset/AssetManager.h +++ b/Volt/Volt/src/Volt/Asset/AssetManager.h @@ -21,7 +21,7 @@ namespace Volt { class AssetFactory; - class AssetImporter; + class AssetSerializer; class AssetManager { public: @@ -38,8 +38,6 @@ namespace Volt void AddDependency(AssetHandle asset, const std::filesystem::path& dependency); void AddDependency(AssetHandle asset, AssetHandle dependency); - bool HasAssetMetaFile(AssetHandle assetHandle); - void Unload(AssetHandle assetHandle); void MoveAsset(Ref asset, const std::filesystem::path& targetDir); @@ -56,12 +54,17 @@ namespace Volt void RemoveFromRegistry(AssetHandle asset); void RemoveFromRegistry(const std::filesystem::path& path); void RemoveFullFolderFromRegistry(const std::filesystem::path& path); + const AssetHandle AddAssetToRegistry(const std::filesystem::path& path, AssetHandle handle = 0); + void AddAssetToRegistry(const std::filesystem::path& path, AssetHandle handle, AssetType type); void ReloadAsset(AssetHandle handle); void ReloadAsset(const std::filesystem::path& path); - static bool IsSourceFile(AssetHandle handle); + inline const AssetFactory& GetFactory() const { return *m_assetFactory; } + + static bool IsSourceAsset(AssetType type); + static bool IsSourceAsset(AssetHandle handle); static bool IsLoaded(AssetHandle handle); static bool IsEngineAsset(const std::filesystem::path& path); @@ -89,6 +92,7 @@ namespace Volt static const AssetMetadata& GetMetadataFromFilePath(const std::filesystem::path filePath); static const std::unordered_map& GetAssetRegistry(); + static std::unordered_map& GetAssetRegistryMutable(); static std::string GetExtensionFromAssetType(AssetType type); @@ -140,24 +144,23 @@ namespace Volt void RegisterAssetSerializers(); void LoadAsset(AssetHandle assetHandle, Ref& asset); - void DeserializeAssetMetafile(std::filesystem::path metaPath); - void LoadAssetMetafiles(); - void SerializeAssetMetaFile(AssetHandle assetHandle); - void RemoveMetaFile(const std::filesystem::path& filePath); + void LoadAllAssetMetadata(); + void DeserializeAssetMetadata(std::filesystem::path assetPath); void QueueAssetInternal(AssetHandle assetHandle, Ref& asset); void QueueAssetInternal(AssetHandle assetHandle, Ref& asset, const std::function& loadedCallback); + static bool ValidateAssetType(AssetHandle handle, Ref asset); static AssetMetadata& GetMetadataFromHandleMutable(AssetHandle handle); static AssetMetadata& GetMetadataFromFilePathMutable(const std::filesystem::path filePath); static const std::filesystem::path GetCleanAssetFilePath(const std::filesystem::path& path); - std::vector GetEngineMetaFiles(); - std::vector GetProjectMetaFiles(); + std::vector GetEngineAssetFiles(); + std::vector GetProjectAssetFiles(); - std::unordered_map> m_assetImporters; + std::unordered_map> m_assetSerializers; std::unordered_map m_assetCreateFunctions; std::unordered_map> m_assetCache; @@ -178,16 +181,24 @@ namespace Volt return nullptr; } - Ref asset = CreateRef(); - Get().LoadAsset(assetHandle, asset); - - if (asset) { - if (asset->GetType() != T::GetStaticType()) + ReadLock lock{ Get().m_assetRegistryMutex }; + const auto& metadata = GetMetadataFromHandle(assetHandle); + if (!metadata.IsValid()) { - VT_CORE_CRITICAL("Type Mismatch!"); + VT_CORE_ERROR("[AssetManager] Trying to load asset which has invalid metadata!"); + return nullptr; } } + + Ref asset = CreateRef(); + if (!ValidateAssetType(assetHandle, asset)) + { + VT_CORE_CRITICAL("[AssetManager] Asset type does not match!"); + return nullptr; + } + + Get().LoadAsset(assetHandle, asset); return std::reinterpret_pointer_cast(asset); } @@ -205,7 +216,18 @@ namespace Volt return nullptr; } + { + ReadLock lock{ Get().m_assetRegistryMutex }; + const auto& metadata = GetMetadataFromHandle(assetHandle); + if (!metadata.IsValid()) + { + VT_CORE_ERROR("[AssetManager] Trying to load asset which has invalid metadata!"); + return nullptr; + } + } + Ref asset = QueueAsset(assetHandle); + if (!asset) { return nullptr; @@ -213,12 +235,6 @@ namespace Volt while (!asset->IsValid()) {} - - if (asset->GetType() != T::GetStaticType()) - { - VT_CORE_CRITICAL("Type Mismatch!"); - } - return std::reinterpret_pointer_cast(asset); } @@ -236,6 +252,16 @@ namespace Volt return nullptr; } + { + ReadLock lock{ Get().m_assetRegistryMutex }; + const auto& metadata = GetMetadataFromHandle(handle); + if (!metadata.IsValid()) + { + VT_CORE_ERROR("[AssetManager] Trying to load asset which has invalid metadata!"); + return nullptr; + } + } + // If it's a memory asset, return it if (Get().m_memoryAssets.contains(handle)) { @@ -251,13 +277,15 @@ namespace Volt } Ref asset = CreateRef(); + if (!ValidateAssetType(handle, asset)) + { + VT_CORE_CRITICAL("[AssetManager] Asset type does not match!"); + return nullptr; + } + asset->SetFlag(AssetFlag::Queued, true); Get().QueueAssetInternal(handle, asset); - if (asset->GetType() != T::GetStaticType()) - { - VT_CORE_CRITICAL("Type Mismatch!"); - } return std::reinterpret_pointer_cast(asset); } @@ -268,6 +296,16 @@ namespace Volt { return nullptr; } + + { + ReadLock lock{ Get().m_assetRegistryMutex }; + const auto& metadata = GetMetadataFromHandle(handle); + if (!metadata.IsValid()) + { + VT_CORE_ERROR("[AssetManager] Trying to load asset which has invalid metadata!"); + return nullptr; + } + } // If it's a memory asset, return it if (Get().m_memoryAssets.contains(handle)) @@ -284,13 +322,15 @@ namespace Volt } Ref asset = CreateRef(); + if (!ValidateAssetType(handle, asset)) + { + VT_CORE_CRITICAL("[AssetManager] Asset type does not match!"); + return nullptr; + } + asset->SetFlag(AssetFlag::Queued, true); Get().QueueAssetInternal(handle, asset, assetLoadedCallback); - if (asset->GetType() != T::GetStaticType()) - { - VT_CORE_CRITICAL("Type Mismatch!"); - } return std::reinterpret_pointer_cast(asset); } @@ -314,8 +354,6 @@ namespace Volt AssetManager::Get().m_assetRegistry.emplace(asset->handle, metadata); AssetManager::Get().m_assetCache.emplace(asset->handle, asset); - Get().SerializeAssetMetaFile(metadata.handle); - return asset; } @@ -343,12 +381,12 @@ namespace Volt inline const ImporterType& AssetManager::GetImporterForType() { const auto type = Type::GetStaticType(); - if (!Get().m_assetImporters.contains(type)) + if (!Get().m_assetSerializers.contains(type)) { VT_CORE_ASSERT(false, "Importer for type does not exist!"); } - return (ImporterType&)*Get().m_assetImporters.at(type); + return (ImporterType&)*Get().m_assetSerializers.at(type); } template inline const std::vector> AssetManager::GetAllCachedAssetsOfType() diff --git a/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.cpp b/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.cpp index 9476071b5..b5de5c0a1 100644 --- a/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.cpp +++ b/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.cpp @@ -8,17 +8,17 @@ namespace Volt { void SerializedAssetMetadata::Serialize(BinaryStreamWriter& streamWriter, const SerializedAssetMetadata& data) { + streamWriter.Write(data.magic); streamWriter.Write(data.handle); streamWriter.Write(data.type); streamWriter.Write(data.version); - streamWriter.Write(data.dependencies); } void SerializedAssetMetadata::Deserialize(BinaryStreamReader& streamReader, SerializedAssetMetadata& outData) { + streamReader.Read(outData.magic); streamReader.Read(outData.handle); streamReader.Read(outData.type); streamReader.Read(outData.version); - streamReader.Read(outData.dependencies); } } diff --git a/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.h b/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.h index 52b1c2d1b..076a71753 100644 --- a/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.h +++ b/Volt/Volt/src/Volt/Asset/Serialization/AssetSerializationCommon.h @@ -9,11 +9,12 @@ namespace Volt struct SerializedAssetMetadata { - AssetHandle handle; + inline static constexpr uint32_t AssetMagic = 9999; + + uint32_t magic; AssetType type; uint32_t version; - - std::vector dependencies; + AssetHandle handle; static void Serialize(BinaryStreamWriter& streamWriter, const SerializedAssetMetadata& data); static void Deserialize(BinaryStreamReader& streamReader, SerializedAssetMetadata& outData); diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/AnimatedCharacterSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/AnimatedCharacterSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/AnimatedCharacterSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/AnimatedCharacterSerializer.h index c275464b0..18bf14906 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/AnimatedCharacterSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/AnimationGraphSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/AnimationGraphSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/AnimationGraphSerializer.h similarity index 83% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/AnimationGraphSerializer.h index 585fbaaa4..5a3632fe8 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/AnimationGraphSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AnimationSerializer.h" +#include namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/AnimationSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/AnimationSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/AnimationSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/AnimationSerializer.h index 1285f2e77..58acd9395 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/AnimationSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AssetSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/AssetSerializer.cpp similarity index 90% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AssetSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/AssetSerializer.cpp index 2432b5720..e9d7de150 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/AssetSerializer.cpp +++ b/Volt/Volt/src/Volt/Asset/Serializers/AssetSerializer.cpp @@ -9,7 +9,7 @@ namespace Volt serializedMetadata.handle = metadata.handle; serializedMetadata.type = metadata.type; serializedMetadata.version = version; - serializedMetadata.dependencies = metadata.dependencies; + serializedMetadata.magic = SerializedAssetMetadata::AssetMagic; return streamWriter.Write(serializedMetadata); } diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AssetSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/AssetSerializer.h similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/AssetSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/AssetSerializer.h diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/BehaviourTreeSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/BehaviourTreeSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/BehaviourTreeSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/BehaviourTreeSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/BehaviourTreeSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/BehaviourTreeSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/BehaviourTreeSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/BehaviourTreeSerializer.h index 983a10f8e..85ade583a 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/BehaviourTreeSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/BehaviourTreeSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/BlendSpaceSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/BlendSpaceSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/BlendSpaceSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/BlendSpaceSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/BlendSpaceSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/BlendSpaceSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/BlendSpaceSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/BlendSpaceSerializer.h index 112a7a831..37383ccbd 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/BlendSpaceSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/BlendSpaceSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/FontSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/FontSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/FontSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/FontSerializer.h index e3ddbfa03..a677e01e9 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/FontSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/MaterialSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/MaterialSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/MaterialSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/MaterialSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/MaterialSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/MaterialSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/MaterialSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/MaterialSerializer.h index 103faff8c..269b06162 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/MaterialSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/MaterialSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/MeshSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/MeshSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/MeshSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/MeshSerializer.h index 3f109147b..f96ba5e2b 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/MeshSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/NavigationMeshSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/NavigationMeshSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/NavigationMeshSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/NavigationMeshSerializer.h index 9d3931655..db5555330 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/NavigationMeshSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/NetContractSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/NetContractSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/NetContractSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/NetContractSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/NetContractSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/NetContractSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/NetContractSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/NetContractSerializer.h index 5f9631abb..698e3fd21 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/NetContractSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/NetContractSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/ParticlePresetSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/ParticlePresetSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/ParticlePresetSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/ParticlePresetSerializer.h index b0e04f84a..d0608dd46 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/ParticlePresetSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/PhysicsMaterialSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/PhysicsMaterialSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/PhysicsMaterialSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/PhysicsMaterialSerializer.h index fe9f36ccc..276c06aa0 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/PhysicsMaterialSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingMaterialSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/PostProcessingMaterialSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingMaterialSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/PostProcessingMaterialSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingMaterialSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/PostProcessingMaterialSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingMaterialSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/PostProcessingMaterialSerializer.h index 7b19d51c1..765fd9d50 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingMaterialSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/PostProcessingMaterialSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingStackSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/PostProcessingStackSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingStackSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/PostProcessingStackSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingStackSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/PostProcessingStackSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingStackSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/PostProcessingStackSerializer.h index 67c1d28cd..0aca3bb01 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/PostProcessingStackSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/PostProcessingStackSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/PrefabSerializer.cpp similarity index 98% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/PrefabSerializer.cpp index d3cdf80ba..5a3c54c27 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.cpp +++ b/Volt/Volt/src/Volt/Asset/Serializers/PrefabSerializer.cpp @@ -4,7 +4,7 @@ #include "Volt/Asset/AssetManager.h" #include "Volt/Asset/Prefab.h" -#include "Volt/Asset/ImportersNew/SceneSerializer.h" +#include "Volt/Asset/Serializers/SceneSerializer.h" #include "Volt/Utility/FileIO/YAMLMemoryStreamWriter.h" #include "Volt/Utility/FileIO/YAMLMemoryStreamReader.h" diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/PrefabSerializer.h similarity index 88% rename from Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/PrefabSerializer.h index b9aadd646..40004bc4f 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/PrefabSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/SceneSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/SceneSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/SceneSerializer.h similarity index 97% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/SceneSerializer.h index 13d4dd8ff..803ae83a2 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/SceneSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" #include "Volt/Scene/Entity.h" diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/ShaderSerializer.cpp similarity index 76% rename from Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/ShaderSerializer.cpp index 3870141b7..29cb18607 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.cpp +++ b/Volt/Volt/src/Volt/Asset/Serializers/ShaderSerializer.cpp @@ -5,8 +5,8 @@ #include "Volt/Rendering/Shader/Shader.h" -#include "Volt/Utility/FileIO/YAMLMemoryStreamWriter.h" -#include "Volt/Utility/FileIO/YAMLMemoryStreamReader.h" +#include "Volt/Utility/FileIO/YAMLFileStreamWriter.h" +#include "Volt/Utility/FileIO/YAMLFileStreamReader.h" namespace Volt { @@ -14,8 +14,16 @@ namespace Volt { Ref shader = std::reinterpret_pointer_cast(asset); - YAMLMemoryStreamWriter yamlStreamWriter{}; + const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath); + YAMLFileStreamWriter yamlStreamWriter{ filePath }; yamlStreamWriter.BeginMap(); + + // Serialize AssetMetadata + yamlStreamWriter.SetKey("assetHandle", metadata.handle); + yamlStreamWriter.SetKey("type", (uint32_t)metadata.type); + yamlStreamWriter.SetKey("version", shader->GetVersion()); + // + yamlStreamWriter.SetKey("name", shader->GetName()); yamlStreamWriter.SetKey("internal", shader->IsInternal()); @@ -37,15 +45,7 @@ namespace Volt yamlStreamWriter.EndSequence(); yamlStreamWriter.EndMap(); - BinaryStreamWriter streamWriter{}; - const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, asset->GetVersion(), streamWriter); - - Buffer buffer = yamlStreamWriter.WriteAndGetBuffer(); - streamWriter.Write(buffer); - buffer.Release(); - - const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath); - streamWriter.WriteToDisk(filePath, true, compressedDataOffset); + yamlStreamWriter.WriteToDisk(); } bool ShaderSerializer::Deserialize(const AssetMetadata& metadata, Ref destinationAsset) const @@ -59,27 +59,21 @@ namespace Volt return false; } - BinaryStreamReader streamReader{ filePath }; + YAMLFileStreamReader yamlStreamReader{}; - if (!streamReader.IsStreamValid()) + if (!yamlStreamReader.OpenFile(filePath)) { VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath); destinationAsset->SetFlag(AssetFlag::Invalid, true); return false; } - SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader); - VT_CORE_ASSERT(serializedMetadata.version == destinationAsset->GetVersion(), "Incompatible version!"); + SerializedAssetMetadata serializedMetadata{}; + serializedMetadata.handle = yamlStreamReader.ReadKey("assetHandle", AssetHandle(0)); + serializedMetadata.type = (AssetType)yamlStreamReader.ReadKey("type", 0u); + serializedMetadata.version = yamlStreamReader.ReadKey("version", 1u); - Buffer buffer{}; - streamReader.Read(buffer); - - YAMLMemoryStreamReader yamlStreamReader{}; - if (!yamlStreamReader.ConsumeBuffer(buffer)) - { - destinationAsset->SetFlag(AssetFlag::Invalid, true); - return false; - } + VT_CORE_ASSERT(serializedMetadata.version == destinationAsset->GetVersion(), "Incompatible version!"); const std::string name = yamlStreamReader.ReadKey("name", std::string("Unnamed")); const bool isInternal = yamlStreamReader.ReadKey("internal", false); diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/ShaderSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/ShaderSerializer.h index a22599e2a..ab393874d 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/ShaderSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/SkeletonSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/SkeletonSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/SkeletonSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/SkeletonSerializer.h index 0d90133d8..3738de2e3 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/SkeletonSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SourceMeshSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/SourceMeshSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SourceMeshSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/SourceMeshSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SourceMeshSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/SourceMeshSerializer.h similarity index 85% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SourceMeshSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/SourceMeshSerializer.h index 45448eedc..713fe2344 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/SourceMeshSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/SourceMeshSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SourceTextureSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/SourceTextureSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SourceTextureSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/SourceTextureSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SourceTextureSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/SourceTextureSerializer.h similarity index 85% rename from Volt/Volt/src/Volt/Asset/ImportersNew/SourceTextureSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/SourceTextureSerializer.h index 05ca8a4a9..c3e5b0c3e 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/SourceTextureSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/SourceTextureSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/TextureSerializer.cpp similarity index 89% rename from Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/TextureSerializer.cpp index 9ef4c5bf9..7d4f64306 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp +++ b/Volt/Volt/src/Volt/Asset/Serializers/TextureSerializer.cpp @@ -10,30 +10,6 @@ namespace Volt { - namespace Utility - { - inline static bool IsEncodedFormat(ImageFormat format) - { - switch (format) - { - case ImageFormat::BC1: - case ImageFormat::BC1SRGB: - case ImageFormat::BC2: - case ImageFormat::BC2SRGB: - case ImageFormat::BC3: - case ImageFormat::BC3SRGB: - case ImageFormat::BC4: - case ImageFormat::BC5: - case ImageFormat::BC7: - case ImageFormat::BC7SRGB: - case ImageFormat::BC6H_SF16: - case ImageFormat::BC6H_UF16: - return true; - } - return false; - } - } - struct TextureMip { uint32_t width; @@ -97,17 +73,17 @@ namespace Volt Buffer dataBuffer{}; - if (!Utility::IsEncodedFormat(texture->GetImage()->GetFormat())) - { - // do encoding - } - else + //if (!Utility::IsEncodedFormat(texture->GetImage()->GetFormat())) + //{ + // // do encoding + //} + //else { for (uint32_t i = 0; i < image->GetSpecification().mips; i++) { auto& newMip = header.mips.emplace_back(); - newMip.width = image->GetWidth() >> i; - newMip.height = image->GetHeight() >> i; + newMip.width = std::max(image->GetWidth() >> i, 1u); + newMip.height = std::max(image->GetHeight() >> i, 1u); newMip.dataOffset = dataBuffer.GetSize(); newMip.dataSize = image->CopyToBuffer(dataBuffer, i, dataBuffer.GetSize()); diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/TextureSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/TextureSerializer.h index 756cea92f..78decff9d 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/TextureSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.cpp b/Volt/Volt/src/Volt/Asset/Serializers/VideoSerializer.cpp similarity index 100% rename from Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.cpp rename to Volt/Volt/src/Volt/Asset/Serializers/VideoSerializer.cpp diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.h b/Volt/Volt/src/Volt/Asset/Serializers/VideoSerializer.h similarity index 84% rename from Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.h rename to Volt/Volt/src/Volt/Asset/Serializers/VideoSerializer.h index 87c17e622..745848c75 100644 --- a/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.h +++ b/Volt/Volt/src/Volt/Asset/Serializers/VideoSerializer.h @@ -1,6 +1,6 @@ #pragma once -#include "Volt/Asset/ImportersNew/AssetSerializer.h" +#include "Volt/Asset/Serializers/AssetSerializer.h" namespace Volt { diff --git a/Volt/Volt/src/Volt/Core/Application.cpp b/Volt/Volt/src/Volt/Core/Application.cpp index b49f3ce6b..2bc682983 100644 --- a/Volt/Volt/src/Volt/Core/Application.cpp +++ b/Volt/Volt/src/Volt/Core/Application.cpp @@ -79,6 +79,11 @@ namespace Volt windowProperties.iconPath = ProjectManager::GetProject().iconPath; } + if (ProjectManager::GetProject().isDeprecated) + { + windowProperties.useTitlebar = true; + } + m_window = Window::Create(windowProperties); m_window->SetEventCallback(VT_BIND_EVENT_FN(Application::OnEvent)); diff --git a/Volt/Volt/src/Volt/Core/Base.h b/Volt/Volt/src/Volt/Core/Base.h index f6dcf46f7..45308b123 100644 --- a/Volt/Volt/src/Volt/Core/Base.h +++ b/Volt/Volt/src/Volt/Core/Base.h @@ -6,7 +6,7 @@ #include #include -#define VT_VERSION Version::Create(0, 1, 4) +#define VT_VERSION Version::Create(0, 1, 5) #define BIT(X) (1 << (X)) #define TO_NORMALIZEDRGB(r, g, b) glm::vec4{ r / 255.f, g / 255.f, b / 255.f, 1.f } diff --git a/Volt/Volt/src/Volt/Core/ScopedTimer.h b/Volt/Volt/src/Volt/Core/ScopedTimer.h index 155887f10..8b3bae0d6 100644 --- a/Volt/Volt/src/Volt/Core/ScopedTimer.h +++ b/Volt/Volt/src/Volt/Core/ScopedTimer.h @@ -3,9 +3,14 @@ #include "Volt/Log/Log.h" #include - #include -#include + +namespace Time +{ + typedef std::chrono::milliseconds::period Milliseconds; + typedef std::chrono::seconds::period Seconds; + typedef std::chrono::nanoseconds Nanoseconds; +} class ScopedTimer { @@ -30,12 +35,13 @@ class ScopedTimer } } + template inline float GetTime() { - return std::chrono::duration(std::chrono::high_resolution_clock::now() - m_startTime).count(); - }; + return std::chrono::duration(std::chrono::high_resolution_clock::now() - m_startTime).count(); + } private: std::string m_name; std::chrono::high_resolution_clock::time_point m_startTime; -}; \ No newline at end of file +}; diff --git a/Volt/Volt/src/Volt/Core/Window.cpp b/Volt/Volt/src/Volt/Core/Window.cpp index 0d1157a6a..a2a864a1e 100644 --- a/Volt/Volt/src/Volt/Core/Window.cpp +++ b/Volt/Volt/src/Volt/Core/Window.cpp @@ -85,7 +85,7 @@ namespace Volt glfwSetErrorCallback(GLFWErrorCallback); glfwWindowHint(GLFW_SAMPLES, 0); glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); - glfwWindowHint(GLFW_TITLEBAR, Application::Get().GetInfo().isRuntime ? GLFW_TRUE : GLFW_FALSE); + glfwWindowHint(GLFW_TITLEBAR, Application::Get().GetInfo().isRuntime || myProperties.useTitlebar ? GLFW_TRUE : GLFW_FALSE); glfwWindowHint(GLFW_AUTO_ICONIFY, false); GLFWmonitor* primaryMonitor = nullptr; diff --git a/Volt/Volt/src/Volt/Core/Window.h b/Volt/Volt/src/Volt/Core/Window.h index 913f57134..3cfada21d 100644 --- a/Volt/Volt/src/Volt/Core/Window.h +++ b/Volt/Volt/src/Volt/Core/Window.h @@ -23,7 +23,7 @@ namespace Volt struct WindowProperties { WindowProperties(const std::string& aTitle = "Volt", uint32_t aWidth = 1280, uint32_t aHeight = 720, bool aVSync = true, WindowMode aWindowMode = WindowMode::Windowed) - : title(aTitle), width(aWidth), height(aHeight), vsync(aVSync), windowMode(aWindowMode) + : title(aTitle), width(aWidth), height(aHeight), vsync(aVSync), windowMode(aWindowMode), useTitlebar(false) { } @@ -31,6 +31,7 @@ namespace Volt uint32_t width; uint32_t height; bool vsync; + bool useTitlebar; WindowMode windowMode; std::filesystem::path iconPath; std::filesystem::path cursorPath; diff --git a/Volt/Volt/src/Volt/Net/NetHandler.cpp b/Volt/Volt/src/Volt/Net/NetHandler.cpp index a9dd750f5..c461bff32 100644 --- a/Volt/Volt/src/Volt/Net/NetHandler.cpp +++ b/Volt/Volt/src/Volt/Net/NetHandler.cpp @@ -18,7 +18,6 @@ namespace Volt NetHandler::NetHandler() { m_lastUnhandledNetError = new eNetErrorCode(); - NetContractContainer::Load(); } void NetHandler::StartSinglePlayer() diff --git a/Volt/Volt/src/Volt/Net/SceneInteraction/NetContract.cpp b/Volt/Volt/src/Volt/Net/SceneInteraction/NetContract.cpp index 51e5f7011..37494e95c 100644 --- a/Volt/Volt/src/Volt/Net/SceneInteraction/NetContract.cpp +++ b/Volt/Volt/src/Volt/Net/SceneInteraction/NetContract.cpp @@ -124,7 +124,7 @@ namespace Volt if (type == AssetType::NetContract) { - if (!AssetManager::Get().ExistsInRegistry(relPath)) + if (!AssetManager::ExistsInRegistry(relPath)) { AssetManager::Get().AddAssetToRegistry(relPath); } diff --git a/Volt/Volt/src/Volt/Project/ProjectManager.cpp b/Volt/Volt/src/Volt/Project/ProjectManager.cpp index 840c6360d..16162cc67 100644 --- a/Volt/Volt/src/Volt/Project/ProjectManager.cpp +++ b/Volt/Volt/src/Volt/Project/ProjectManager.cpp @@ -23,7 +23,7 @@ namespace Volt } else { - m_currentProject->projectDirectory = "./"; + m_currentProject->projectDirectory = std::filesystem::current_path(); for (const auto& dir : std::filesystem::directory_iterator("./")) { diff --git a/Volt/Volt/src/Volt/Rendering/RenderPipeline/ShaderRegistry.cpp b/Volt/Volt/src/Volt/Rendering/RenderPipeline/ShaderRegistry.cpp index 1411f6cdb..18c52d801 100644 --- a/Volt/Volt/src/Volt/Rendering/RenderPipeline/ShaderRegistry.cpp +++ b/Volt/Volt/src/Volt/Rendering/RenderPipeline/ShaderRegistry.cpp @@ -77,6 +77,8 @@ namespace Volt return myShaderRegistry.at(lowName); } + + void ShaderRegistry::LoadAllShaders() { const std::vector searchPaths = @@ -104,8 +106,8 @@ namespace Volt AssetManager::Get().AddAssetToRegistry(relPath); } - Ref pipelineAsset = AssetManager::GetAsset(relPath); - Register(pipelineAsset->GetName(), pipelineAsset); + Ref shaderAsset = AssetManager::GetAsset(relPath); + Register(shaderAsset->GetName(), shaderAsset); } } } diff --git a/Volt/Volt/src/Volt/Rendering/SceneRenderer.cpp b/Volt/Volt/src/Volt/Rendering/SceneRenderer.cpp index 213e341e7..df33f8781 100644 --- a/Volt/Volt/src/Volt/Rendering/SceneRenderer.cpp +++ b/Volt/Volt/src/Volt/Rendering/SceneRenderer.cpp @@ -607,7 +607,7 @@ namespace Volt // Decal { - myDecalMesh = AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube.vtmesh"); + myDecalMesh = AssetManager::GetAsset("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); RenderPipelineSpecification spec{}; spec.shader = ShaderRegistry::GetShader("Decal"); diff --git a/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp b/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp index bd727ab3d..a72a8fe86 100644 --- a/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp +++ b/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp @@ -486,7 +486,19 @@ namespace Volt size_t Image2D::CopyToBuffer(Buffer& buffer, uint32_t mip, size_t bufferOffset) const { - const size_t mipSize = glm::max((mySpecification.width >> mip) * (mySpecification.height >> mip) * Utility::PerPixelSizeFromFormat(mySpecification.format), Utility::GetFormatMinimumSize(mySpecification.format)); + uint32_t width = mySpecification.width; + uint32_t height = mySpecification.height; + + if (Utility::IsEncodedFormat(mySpecification.format)) + { + width = Utility::NextPow2(width); + height = Utility::NextPow2(height); + } + + width = std::max(width >> mip, 1u); + height = std::max(height >> mip, 1u); + + const size_t mipSize = glm::max(width * height * Utility::PerPixelSizeFromFormat(mySpecification.format), Utility::GetFormatMinimumSize(mySpecification.format)); VkBuffer hostBuffer{}; VmaAllocation hostAllocation{}; @@ -504,7 +516,7 @@ namespace Volt } Utility::TransitionImageLayout(myImage, myImageData.layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); - Utility::CopyImageToBuffer(hostBuffer, 0, myImage, mySpecification.width >> mip, mySpecification.height >> mip, mip); + Utility::CopyImageToBuffer(hostBuffer, 0, myImage, std::max(mySpecification.width >> mip, 1u), std::max(mySpecification.height >> mip, 1u), mip); Utility::TransitionImageLayout(myImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, myImageData.layout); auto* imageData = allocator.MapMemory(hostAllocation); diff --git a/Volt/Volt/src/Volt/Scene/Scene.cpp b/Volt/Volt/src/Volt/Scene/Scene.cpp index 0fe41221c..438df930f 100644 --- a/Volt/Volt/src/Volt/Scene/Scene.cpp +++ b/Volt/Volt/src/Volt/Scene/Scene.cpp @@ -712,7 +712,7 @@ namespace Volt auto id = ent.GetComponent(); auto& meshComp = ent.AddComponent(); - meshComp.handle = AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cube.vtmesh"); + meshComp.handle = AssetManager::GetAssetHandleFromFilePath("Engine/Meshes/Primitives/SM_Cube_Mesh.vtasset"); ent.AddComponent(); } diff --git a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp index 81ffa0b9e..9b9e096b3 100644 --- a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp +++ b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp @@ -7,7 +7,8 @@ namespace Volt { BinaryStreamReader::BinaryStreamReader(const std::filesystem::path& filePath) { - constexpr size_t compressionEncodingHeaderSize = sizeof(uint8_t) + sizeof(size_t); + constexpr size_t compressionEncodingHeaderSize = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(size_t); + constexpr uint32_t MAGIC = 5121; std::ifstream stream(filePath, std::ios::in | std::ios::binary); if (stream) @@ -25,8 +26,15 @@ namespace Volt } // Read compression encoding - const uint8_t isCompressed = m_data[0]; - const size_t compressedDataOffset = *reinterpret_cast(&m_data[1]) + compressionEncodingHeaderSize; + const uint32_t magic = *(uint32_t*)m_data.data(); + if (magic != MAGIC) + { + m_streamValid = false; + return; + } + + const uint8_t isCompressed = m_data[sizeof(uint32_t)]; + const size_t compressedDataOffset = *reinterpret_cast(&m_data[sizeof(uint32_t) + sizeof(uint8_t)]) + compressionEncodingHeaderSize; if (isCompressed) { @@ -52,7 +60,7 @@ namespace Volt bool BinaryStreamReader::Decompress(size_t compressedDataOffset) { constexpr uint32_t CHUNK_SIZE = 16384; - constexpr size_t compressionEncodingHeaderSize = sizeof(uint8_t) + sizeof(size_t); + constexpr size_t compressionEncodingHeaderSize = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(size_t); z_stream stream; stream.zalloc = Z_NULL; diff --git a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp index c95ec6fd3..8b9e91c54 100644 --- a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp +++ b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp @@ -7,7 +7,8 @@ namespace Volt { void BinaryStreamWriter::WriteToDisk(const std::filesystem::path& targetFilepath, bool compress, size_t compressedDataOffset) { - constexpr size_t compressionEncodingHeaderSize = sizeof(uint8_t) + sizeof(size_t); + constexpr size_t compressionEncodingHeaderSize = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(size_t); + constexpr uint32_t MAGIC = 5121; std::ofstream stream(targetFilepath, std::ios::out | std::ios::binary); @@ -18,10 +19,12 @@ namespace Volt if (compress) { compressedData.resize(compressionEncodingHeaderSize); - compressedData[0] = 1; // First byte tells if file is compressed + + *(uint32_t*)(compressedData.data()) = MAGIC; // First we set a magic value + compressedData[sizeof(uint32_t)] = 1; // First byte tells if file is compressed // Next 8 bytes tells the offset to where the compressed data starts - memcpy_s(&compressedData[1], sizeof(size_t), &compressedDataOffset, sizeof(size_t)); + memcpy_s(&compressedData[sizeof(uint32_t) + sizeof(uint8_t)], sizeof(size_t), &compressedDataOffset, sizeof(size_t)); compressedDataOffset += compressionEncodingHeaderSize; @@ -37,10 +40,13 @@ namespace Volt if (writePtr == m_data.data()) { - // Insert 0 at beginning to flag that file is uncompressed; + // Insert 0 at beginning to flag that file is uncompressed + // We also insert the magic value std::array emptyEncodingHeader; emptyEncodingHeader.fill(0); + *(uint32_t*)(emptyEncodingHeader.data()) = MAGIC; + m_data.insert(m_data.begin(), emptyEncodingHeader.begin(), emptyEncodingHeader.end()); writePtr = m_data.data(); size = m_data.size(); @@ -53,7 +59,7 @@ namespace Volt bool BinaryStreamWriter::GetCompressed(std::vector& result, size_t compressedDataOffset) { constexpr uint32_t CHUNK_SIZE = 16384; - constexpr size_t compressionEncodingHeaderSize = sizeof(uint8_t) + sizeof(size_t); + constexpr size_t compressionEncodingHeaderSize = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(size_t); z_stream stream; stream.zalloc = Z_NULL; @@ -113,6 +119,8 @@ namespace Volt void BinaryStreamWriter::WriteData(const void* data, const size_t size) { + VT_CORE_ASSERT(size > 0, "Write size must be greater than zero!"); + const size_t writeSize = size; const size_t currentOffset = m_data.size(); m_data.resize(currentOffset + writeSize); diff --git a/Volt/Volt/src/Volt/Utility/ImageUtility.h b/Volt/Volt/src/Volt/Utility/ImageUtility.h index 8d63f5b7f..8ff0eefb1 100644 --- a/Volt/Volt/src/Volt/Utility/ImageUtility.h +++ b/Volt/Volt/src/Volt/Utility/ImageUtility.h @@ -740,6 +740,39 @@ namespace Volt return VK_ATTACHMENT_LOAD_OP_LOAD; } + inline static bool IsEncodedFormat(ImageFormat format) + { + switch (format) + { + case ImageFormat::BC1: + case ImageFormat::BC1SRGB: + case ImageFormat::BC2: + case ImageFormat::BC2SRGB: + case ImageFormat::BC3: + case ImageFormat::BC3SRGB: + case ImageFormat::BC4: + case ImageFormat::BC5: + case ImageFormat::BC7: + case ImageFormat::BC7SRGB: + case ImageFormat::BC6H_SF16: + case ImageFormat::BC6H_UF16: + return true; + } + return false; + } + + inline uint32_t NextPow2(uint32_t v) + { + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; + } + inline uint32_t PerPixelSizeFromFormat(ImageFormat format) { switch (format)