diff --git a/Assets/Application.SHConfig b/Assets/Application.SHConfig new file mode 100644 index 00000000..3f7a4ac0 --- /dev/null +++ b/Assets/Application.SHConfig @@ -0,0 +1,4 @@ +Start in Fullscreen: false +Starting Scene ID: 94283040 +Window Size: {x: 1920, y: 1080} +Window Title: SHADE Engine \ No newline at end of file diff --git a/Assets/Cube.003.shmesh b/Assets/Cube.003.shmesh deleted file mode 100644 index 54cfb867..00000000 Binary files a/Assets/Cube.003.shmesh and /dev/null differ diff --git a/Assets/Cube.003.shmesh.shmeta b/Assets/Cube.003.shmesh.shmeta deleted file mode 100644 index 628ecd00..00000000 --- a/Assets/Cube.003.shmesh.shmeta +++ /dev/null @@ -1,3 +0,0 @@ -Name: Cube.003 -ID: 71245919 -Type: 4 diff --git a/Assets/Cube.012.shmesh.shmeta b/Assets/Cube.012.shmesh.shmeta deleted file mode 100644 index 56d2d0f5..00000000 --- a/Assets/Cube.012.shmesh.shmeta +++ /dev/null @@ -1,3 +0,0 @@ -Name: Cube.012 -ID: 80365422 -Type: 4 diff --git a/Assets/Editor/Layouts/Default.ini b/Assets/Editor/Layouts/Default.ini index d7a7bf69..1099b5ac 100644 --- a/Assets/Editor/Layouts/Default.ini +++ b/Assets/Editor/Layouts/Default.ini @@ -1,16 +1,16 @@ [Window][MainStatusBar] -Pos=0,1060 +Pos=0,1007 Size=1920,20 Collapsed=0 [Window][SHEditorMenuBar] Pos=0,48 -Size=1920,1012 +Size=1920,959 Collapsed=0 [Window][Hierarchy Panel] -Pos=0,197 -Size=308,863 +Pos=0,189 +Size=308,818 Collapsed=0 DockId=0x00000004,0 @@ -21,13 +21,13 @@ Collapsed=0 [Window][Inspector] Pos=1528,48 -Size=392,1012 +Size=392,959 Collapsed=0 DockId=0x00000006,0 [Window][Profiler] Pos=0,48 -Size=308,147 +Size=308,139 Collapsed=0 DockId=0x00000003,0 @@ -76,7 +76,7 @@ DockId=0x0000000B,0 [Window][ Viewport] Pos=310,48 -Size=1216,715 +Size=1216,662 Collapsed=0 DockId=0x0000000B,0 @@ -93,13 +93,19 @@ Collapsed=0 DockId=0x0000000A,0 [Window][ Asset Browser] -Pos=310,765 +Pos=310,712 Size=1216,295 Collapsed=0 DockId=0x0000000C,0 +[Window][Material Inspector] +Pos=1528,48 +Size=392,959 +Collapsed=0 +DockId=0x00000006,1 + [Docking][Data] -DockSpace ID=0xC5C9B8AB Window=0xBE4044E9 Pos=8,79 Size=1920,1012 Split=X +DockSpace ID=0xC5C9B8AB Window=0xBE4044E9 Pos=0,71 Size=1920,959 Split=X DockNode ID=0x00000005 Parent=0xC5C9B8AB SizeRef=1526,1036 Split=X DockNode ID=0x00000001 Parent=0x00000005 SizeRef=308,1036 Split=Y Selected=0x1E6EB881 DockNode ID=0x00000003 Parent=0x00000001 SizeRef=225,147 Selected=0x1E6EB881 @@ -111,5 +117,5 @@ DockSpace ID=0xC5C9B8AB Window=0xBE4044E9 Pos=8,79 Size=1920,1012 Spli DockNode ID=0x0000000C Parent=0x00000009 SizeRef=1501,295 Selected=0xB128252A DockNode ID=0x0000000A Parent=0x00000007 SizeRef=1501,310 Selected=0xD446F7B6 DockNode ID=0x00000008 Parent=0x00000002 SizeRef=1501,338 Selected=0xD9F31532 - DockNode ID=0x00000006 Parent=0xC5C9B8AB SizeRef=392,1036 Selected=0xE7039252 + DockNode ID=0x00000006 Parent=0xC5C9B8AB SizeRef=392,1036 Selected=0xD3697FB6 diff --git a/Assets/Materials/BagMaterial.shmat b/Assets/Materials/BagMaterial.shmat new file mode 100644 index 00000000..e538b834 --- /dev/null +++ b/Assets/Materials/BagMaterial.shmat @@ -0,0 +1,8 @@ +- VertexShader: 39210065 + FragmentShader: 46377769 + SubPass: G-Buffer Write + Properties: + data.color: {x: 1, y: 1, z: 1, w: 1} + data.textureIndex: 58303057 + data.alpha: 0 + data.beta: {x: 1, y: 1, z: 1} \ No newline at end of file diff --git a/Assets/Materials/BagMaterial.shmat.shmeta b/Assets/Materials/BagMaterial.shmat.shmeta new file mode 100644 index 00000000..b903a854 --- /dev/null +++ b/Assets/Materials/BagMaterial.shmat.shmeta @@ -0,0 +1,3 @@ +Name: BagMaterial +ID: 123745521 +Type: 7 diff --git a/Assets/Materials/TestMat.shmat b/Assets/Materials/TestMat.shmat new file mode 100644 index 00000000..c1bb43c5 --- /dev/null +++ b/Assets/Materials/TestMat.shmat @@ -0,0 +1,8 @@ +- VertexShader: 39210065 + FragmentShader: 46377769 + SubPass: G-Buffer Write + Properties: + data.color: {x: 1, y: 1, z: 1, w: 1} + data.textureIndex: 64651793 + data.alpha: 0 + data.beta: {x: 1, y: 1, z: 1} \ No newline at end of file diff --git a/Assets/Materials/TestMat.shmat.shmeta b/Assets/Materials/TestMat.shmat.shmeta new file mode 100644 index 00000000..1612ef22 --- /dev/null +++ b/Assets/Materials/TestMat.shmat.shmeta @@ -0,0 +1,3 @@ +Name: TestMat +ID: 126974645 +Type: 7 diff --git a/Assets/Materials/WhiteMat.shmat b/Assets/Materials/WhiteMat.shmat new file mode 100644 index 00000000..5a1cb199 --- /dev/null +++ b/Assets/Materials/WhiteMat.shmat @@ -0,0 +1,8 @@ +- VertexShader: 39210065 + FragmentShader: 46377769 + SubPass: G-Buffer Write + Properties: + data.color: {x: 1, y: 1, z: 1, w: 1} + data.textureIndex: 0 + data.alpha: 0 + data.beta: {x: 1, y: 1, z: 1} \ No newline at end of file diff --git a/Assets/Materials/WhiteMat.shmat.shmeta b/Assets/Materials/WhiteMat.shmat.shmeta new file mode 100644 index 00000000..588afba4 --- /dev/null +++ b/Assets/Materials/WhiteMat.shmat.shmeta @@ -0,0 +1,3 @@ +Name: WhiteMat +ID: 124370424 +Type: 7 diff --git a/Assets/Models/racoon.fbx b/Assets/Models/racoon.fbx new file mode 100644 index 00000000..4d823d9d Binary files /dev/null and b/Assets/Models/racoon.fbx differ diff --git a/Assets/Models/racoon.gltf b/Assets/Models/racoon.gltf new file mode 100644 index 00000000..459a542d --- /dev/null +++ b/Assets/Models/racoon.gltf @@ -0,0 +1,4993 @@ +{ + "asset" : { + "generator" : "Khronos glTF Blender I/O v3.3.27", + "version" : "2.0" + }, + "extensionsUsed" : [ + "KHR_materials_specular", + "KHR_materials_ior" + ], + "scene" : 0, + "scenes" : [ + { + "name" : "Scene", + "nodes" : [ + 55 + ] + } + ], + "nodes" : [ + { + "name" : "L_Toe_end", + "rotation" : [ + -1.304514398725587e-07, + -4.8278069232242024e-14, + -3.113858042524953e-07, + 1 + ], + "translation" : [ + 2.9270432744255004e-09, + 0.02392714098095894, + 1.3476908478082805e-10 + ] + }, + { + "children" : [ + 0 + ], + "name" : "L_Toe", + "rotation" : [ + 0.32702386379241943, + 1.1310142156162328e-07, + 1.641405731334089e-07, + 0.945016086101532 + ], + "scale" : [ + 1, + 0.9999999403953552, + 0.9999999403953552 + ], + "translation" : [ + -8.650776095464607e-09, + 0.03380582109093666, + -2.448857117087755e-09 + ] + }, + { + "children" : [ + 1 + ], + "name" : "L_Feet", + "rotation" : [ + 0.516292929649353, + -0.020581310614943504, + -0.05452270060777664, + 0.854426920413971 + ], + "translation" : [ + 1.2865877252465907e-09, + 0.06353945285081863, + 2.6193447411060333e-10 + ] + }, + { + "children" : [ + 2 + ], + "name" : "L_Shin", + "rotation" : [ + -0.054226718842983246, + 0.00034972387948073447, + -0.0027083493769168854, + 0.9985249042510986 + ], + "scale" : [ + 0.9999998807907104, + 0.9999999403953552, + 0.9999998807907104 + ], + "translation" : [ + -8.217813984856548e-09, + 0.012935775332152843, + -1.1059455573558807e-09 + ] + }, + { + "children" : [ + 3 + ], + "name" : "L_Knee", + "rotation" : [ + -0.117364302277565, + -0.00023353073629550636, + -0.005353146698325872, + 0.9930744767189026 + ], + "scale" : [ + 1, + 1.0000001192092896, + 1 + ], + "translation" : [ + -7.161837345392996e-09, + 0.08009886741638184, + -3.725290298461914e-09 + ] + }, + { + "children" : [ + 4 + ], + "name" : "L_Thigh", + "rotation" : [ + 0.005340703763067722, + -0.08032803982496262, + -0.9945576786994934, + 0.06613556295633316 + ], + "scale" : [ + 1.0000009536743164, + 1.0000001192092896, + 1.0000014305114746 + ], + "translation" : [ + 0.06634333729743958, + 0.021777987480163574, + -0.000205356627702713 + ] + }, + { + "name" : "Head_end", + "rotation" : [ + 0, + 3.552713678800501e-15, + 0, + 1 + ], + "translation" : [ + -8.470329472543003e-22, + 0.11583378911018372, + 0 + ] + }, + { + "children" : [ + 6 + ], + "name" : "Head", + "rotation" : [ + 0, + 5.960462701182223e-08, + 0, + 1 + ], + "scale" : [ + 1, + 0.9999999403953552, + 1 + ], + "translation" : [ + 0, + 0.022377878427505493, + 0 + ] + }, + { + "children" : [ + 7 + ], + "name" : "Neck", + "translation" : [ + 0, + 0.10304805636405945, + 0 + ] + }, + { + "name" : "L_Hand_end", + "rotation" : [ + 1.3239958462918366e-08, + -2.4324227076988336e-09, + 1.4901161193847656e-08, + 1 + ], + "translation" : [ + 2.2351740014414645e-08, + 0.016836093738675117, + -5.329070518200751e-15 + ] + }, + { + "children" : [ + 9 + ], + "name" : "L_Hand", + "rotation" : [ + -0.10859407484531403, + -0.0013414795976132154, + -0.012280543334782124, + 0.9940094351768494 + ], + "scale" : [ + 1, + 1, + 0.9999999403953552 + ], + "translation" : [ + -5.215407838932151e-08, + 0.030574528500437737, + 4.579678858362968e-09 + ] + }, + { + "children" : [ + 10 + ], + "name" : "L_Forearm", + "rotation" : [ + 0.03182216361165047, + -0.010124370455741882, + -0.05386859551072121, + 0.9979895353317261 + ], + "scale" : [ + 1, + 0.9999999403953552, + 0.9999999403953552 + ], + "translation" : [ + -1.4001724224499412e-08, + 0.011892830953001976, + -4.656612873077393e-10 + ] + }, + { + "children" : [ + 11 + ], + "name" : "L_Elbow", + "rotation" : [ + 0.13403145968914032, + 0.0004466302052605897, + 0.0229647234082222, + 0.9907108545303345 + ], + "translation" : [ + 9.490547014934236e-09, + 0.07338026165962219, + 1.862645149230957e-09 + ] + }, + { + "children" : [ + 12 + ], + "name" : "L_Shoulder", + "rotation" : [ + -0.05528340861201286, + 0.01580565795302391, + -0.27442947030067444, + 0.9598866701126099 + ], + "translation" : [ + 1.1175854908174188e-08, + 0.034574370831251144, + -3.3306690738754696e-15 + ] + }, + { + "children" : [ + 13 + ], + "name" : "L_Clavicle", + "rotation" : [ + -4.527326780134899e-08, + -2.4482876170850432e-08, + -0.6586140990257263, + 0.7524808645248413 + ], + "scale" : [ + 0.9999998807907104, + 0.9999998807907104, + 1 + ], + "translation" : [ + 0.03500552102923393, + 0.07119831442832947, + -6.646381223163189e-10 + ] + }, + { + "name" : "R_Hand_end", + "rotation" : [ + 1.3239958462918366e-08, + 2.4324227076988336e-09, + -1.4901161193847656e-08, + 1 + ], + "translation" : [ + -2.2351740014414645e-08, + 0.016836093738675117, + -5.329070518200751e-15 + ] + }, + { + "children" : [ + 15 + ], + "name" : "R_Hand", + "rotation" : [ + -0.10859407484531403, + 0.0013414795976132154, + 0.012280543334782124, + 0.9940094351768494 + ], + "scale" : [ + 1, + 1, + 0.9999999403953552 + ], + "translation" : [ + 5.215407838932151e-08, + 0.030574528500437737, + 4.579678858362968e-09 + ] + }, + { + "children" : [ + 16 + ], + "name" : "R_Forearm", + "rotation" : [ + 0.03182216361165047, + 0.010124370455741882, + 0.05386859551072121, + 0.9979895353317261 + ], + "scale" : [ + 1, + 0.9999999403953552, + 0.9999999403953552 + ], + "translation" : [ + 1.4001724224499412e-08, + 0.011892830953001976, + -4.656612873077393e-10 + ] + }, + { + "children" : [ + 17 + ], + "name" : "R_Elbow", + "rotation" : [ + 0.13403145968914032, + -0.0004466302052605897, + -0.0229647234082222, + 0.9907108545303345 + ], + "translation" : [ + -9.490547014934236e-09, + 0.07338026165962219, + 1.862645149230957e-09 + ] + }, + { + "children" : [ + 18 + ], + "name" : "R_Shoulder", + "rotation" : [ + -0.05528340861201286, + -0.01580565795302391, + 0.27442947030067444, + 0.9598866701126099 + ], + "translation" : [ + -1.1175854908174188e-08, + 0.034574370831251144, + -3.3306690738754696e-15 + ] + }, + { + "children" : [ + 19 + ], + "name" : "R_Clavicle", + "rotation" : [ + -4.527326780134899e-08, + 2.4482876170850432e-08, + 0.6586140990257263, + 0.7524808645248413 + ], + "scale" : [ + 0.9999998807907104, + 0.9999998807907104, + 1 + ], + "translation" : [ + -0.03500552102923393, + 0.07119831442832947, + -6.646381223163189e-10 + ] + }, + { + "name" : "L_IK_Arm_Pole_end", + "rotation" : [ + -8.14913803104389e-10, + -2.8273916541365907e-08, + 3.597233089180918e-08, + 1 + ], + "translation" : [ + 1.3742706528319104e-08, + 0.04507105425000191, + 1.6264998237147665e-08 + ] + }, + { + "children" : [ + 21 + ], + "name" : "L_IK_Arm_Pole", + "rotation" : [ + -0.3575689494609833, + -0.6109033823013306, + 0.6082502007484436, + 0.3591284155845642 + ], + "scale" : [ + 0.9999999403953552, + 0.9999998807907104, + 0.9999999403953552 + ], + "translation" : [ + 0.0021197572350502014, + -0.04126967862248421, + -0.053202081471681595 + ] + }, + { + "children" : [ + 22 + ], + "name" : "L_IK_Arm_Target", + "rotation" : [ + -0.0011026781285181642, + 0.0018760154489427805, + -0.8620717525482178, + 0.5067814588546753 + ], + "scale" : [ + 0.9999999403953552, + 1, + 1 + ], + "translation" : [ + 0.17300567030906677, + 0.02745041251182556, + 3.304734264020226e-10 + ] + }, + { + "name" : "R_IK_Arm_Pole_end", + "rotation" : [ + -8.14913803104389e-10, + 2.8273916541365907e-08, + -3.597233089180918e-08, + 1 + ], + "translation" : [ + -1.3742706528319104e-08, + 0.04507105425000191, + 1.6264998237147665e-08 + ] + }, + { + "children" : [ + 24 + ], + "name" : "R_IK_Arm_Pole", + "rotation" : [ + -0.3575689494609833, + 0.6109033823013306, + -0.6082502007484436, + 0.3591284155845642 + ], + "scale" : [ + 0.9999999403953552, + 0.9999998807907104, + 0.9999999403953552 + ], + "translation" : [ + -0.0021197572350502014, + -0.04126967862248421, + -0.053202081471681595 + ] + }, + { + "children" : [ + 25 + ], + "name" : "R_IK_Arm_Target", + "rotation" : [ + -0.0011026781285181642, + -0.0018760154489427805, + 0.8620717525482178, + 0.5067814588546753 + ], + "scale" : [ + 0.9999999403953552, + 1, + 1 + ], + "translation" : [ + -0.17300567030906677, + 0.02745041251182556, + 3.304734264020226e-10 + ] + }, + { + "children" : [ + 8, + 14, + 20, + 23, + 26 + ], + "name" : "Upper_Spine", + "translation" : [ + 0, + 0.06622835993766785, + 0 + ] + }, + { + "children" : [ + 27 + ], + "name" : "Lower_Spine", + "translation" : [ + 0, + 0.06622838973999023, + 0 + ] + }, + { + "name" : "Tail_end", + "translation" : [ + 0, + 0.07595176249742508, + -1.3838050705317073e-09 + ] + }, + { + "children" : [ + 29 + ], + "name" : "Tail", + "rotation" : [ + -0.7071068286895752, + 0, + 0, + 0.7071068286895752 + ], + "translation" : [ + -5.8597615213960615e-18, + 0.03983837366104126, + -0.09847982972860336 + ] + }, + { + "name" : "L_Hip_end", + "translation" : [ + 0, + 0.032987553626298904, + -1.5967565047958487e-09 + ] + }, + { + "children" : [ + 31 + ], + "name" : "L_Hip", + "translation" : [ + 0.06953180581331253, + 0.04957667365670204, + 0.061330340802669525 + ] + }, + { + "name" : "L_Butt_end", + "translation" : [ + 0, + 0.03298754245042801, + 1.3750955929481279e-09 + ] + }, + { + "children" : [ + 33 + ], + "name" : "L_Butt", + "translation" : [ + 0.06953180581331253, + -0.0007792188553139567, + -0.04653617739677429 + ] + }, + { + "name" : "R_Toe_end", + "rotation" : [ + -1.304514398725587e-07, + 4.8278069232242024e-14, + 3.113858042524953e-07, + 1 + ], + "translation" : [ + -2.9270432744255004e-09, + 0.02392714098095894, + 1.3476908478082805e-10 + ] + }, + { + "children" : [ + 35 + ], + "name" : "R_Toe", + "rotation" : [ + 0.32702386379241943, + -1.1310142156162328e-07, + -1.641405731334089e-07, + 0.945016086101532 + ], + "scale" : [ + 1, + 0.9999999403953552, + 0.9999999403953552 + ], + "translation" : [ + 8.650776095464607e-09, + 0.03380582109093666, + -2.448857117087755e-09 + ] + }, + { + "children" : [ + 36 + ], + "name" : "R_Feet", + "rotation" : [ + 0.516292929649353, + 0.020581310614943504, + 0.05452270060777664, + 0.854426920413971 + ], + "translation" : [ + -1.2865877252465907e-09, + 0.06353945285081863, + 2.6193447411060333e-10 + ] + }, + { + "children" : [ + 37 + ], + "name" : "R_Shin", + "rotation" : [ + -0.054226718842983246, + -0.00034972387948073447, + 0.0027083493769168854, + 0.9985249042510986 + ], + "scale" : [ + 0.9999998807907104, + 0.9999999403953552, + 0.9999998807907104 + ], + "translation" : [ + 8.217813984856548e-09, + 0.012935775332152843, + -1.1059455573558807e-09 + ] + }, + { + "children" : [ + 38 + ], + "name" : "R_Knee", + "rotation" : [ + -0.117364302277565, + 0.00023353073629550636, + 0.005353146698325872, + 0.9930744767189026 + ], + "scale" : [ + 1, + 1.0000001192092896, + 1 + ], + "translation" : [ + 7.161837345392996e-09, + 0.08009886741638184, + -3.725290298461914e-09 + ] + }, + { + "children" : [ + 39 + ], + "name" : "R_Thigh", + "rotation" : [ + 0.005340703763067722, + 0.08032803982496262, + 0.9945576786994934, + 0.06613556295633316 + ], + "scale" : [ + 1.0000009536743164, + 1.0000001192092896, + 1.0000014305114746 + ], + "translation" : [ + -0.06634333729743958, + 0.021777987480163574, + -0.000205356627702713 + ] + }, + { + "name" : "R_Hip_end", + "translation" : [ + 0, + 0.032987553626298904, + -1.5967565047958487e-09 + ] + }, + { + "children" : [ + 41 + ], + "name" : "R_Hip", + "translation" : [ + -0.06953180581331253, + 0.04957667365670204, + 0.061330340802669525 + ] + }, + { + "name" : "R_Butt_end", + "translation" : [ + 0, + 0.03298754245042801, + 1.3750955929481279e-09 + ] + }, + { + "children" : [ + 43 + ], + "name" : "R_Butt", + "translation" : [ + -0.06953180581331253, + -0.0007792188553139567, + -0.04653617739677429 + ] + }, + { + "children" : [ + 5, + 28, + 30, + 32, + 34, + 40, + 42, + 44 + ], + "name" : "Pelvis", + "translation" : [ + 0, + 0.15915730595588684, + 0 + ] + }, + { + "name" : "L_IK_Leg_Pole_end", + "translation" : [ + 0, + 0.04320859909057617, + 2.2203057170600005e-09 + ] + }, + { + "children" : [ + 46 + ], + "name" : "L_IK_Leg_Pole", + "rotation" : [ + 0, + 0, + -1, + 0 + ], + "translation" : [ + -0.008841380476951599, + -0.08020301908254623, + 0.0748630166053772 + ] + }, + { + "children" : [ + 47 + ], + "name" : "L_IK_Leg_Target", + "rotation" : [ + -0.7071068286895752, + 0, + 0, + 0.7071068286895752 + ], + "translation" : [ + 0.08565311133861542, + 0.027707800269126892, + 0.00015427125617861748 + ] + }, + { + "name" : "R_IK_Leg_Pole_end", + "translation" : [ + 0, + 0.04320859909057617, + 2.2203057170600005e-09 + ] + }, + { + "children" : [ + 49 + ], + "name" : "R_IK_Leg_Pole", + "rotation" : [ + 0, + 0, + -1, + 0 + ], + "translation" : [ + 0.008841380476951599, + -0.08020301908254623, + 0.0748630166053772 + ] + }, + { + "children" : [ + 50 + ], + "name" : "R_IK_Leg_Target", + "rotation" : [ + -0.7071068286895752, + 0, + 0, + 0.7071068286895752 + ], + "translation" : [ + -0.08565311133861542, + 0.027707800269126892, + 0.00015427125617861748 + ] + }, + { + "children" : [ + 45, + 48, + 51 + ], + "name" : "Root" + }, + { + "mesh" : 0, + "name" : "Bag", + "skin" : 0 + }, + { + "mesh" : 1, + "name" : "Raccoon", + "skin" : 0 + }, + { + "children" : [ + 53, + 54, + 52 + ], + "name" : "Armature" + } + ], + "animations" : [ + { + "channels" : [ + { + "sampler" : 0, + "target" : { + "node" : 52, + "path" : "translation" + } + }, + { + "sampler" : 1, + "target" : { + "node" : 52, + "path" : "rotation" + } + }, + { + "sampler" : 2, + "target" : { + "node" : 52, + "path" : "scale" + } + }, + { + "sampler" : 3, + "target" : { + "node" : 45, + "path" : "translation" + } + }, + { + "sampler" : 4, + "target" : { + "node" : 45, + "path" : "rotation" + } + }, + { + "sampler" : 5, + "target" : { + "node" : 45, + "path" : "scale" + } + }, + { + "sampler" : 6, + "target" : { + "node" : 5, + "path" : "translation" + } + }, + { + "sampler" : 7, + "target" : { + "node" : 5, + "path" : "rotation" + } + }, + { + "sampler" : 8, + "target" : { + "node" : 5, + "path" : "scale" + } + }, + { + "sampler" : 9, + "target" : { + "node" : 4, + "path" : "translation" + } + }, + { + "sampler" : 10, + "target" : { + "node" : 4, + "path" : "rotation" + } + }, + { + "sampler" : 11, + "target" : { + "node" : 4, + "path" : "scale" + } + }, + { + "sampler" : 12, + "target" : { + "node" : 3, + "path" : "translation" + } + }, + { + "sampler" : 13, + "target" : { + "node" : 3, + "path" : "rotation" + } + }, + { + "sampler" : 14, + "target" : { + "node" : 3, + "path" : "scale" + } + }, + { + "sampler" : 15, + "target" : { + "node" : 2, + "path" : "translation" + } + }, + { + "sampler" : 16, + "target" : { + "node" : 2, + "path" : "rotation" + } + }, + { + "sampler" : 17, + "target" : { + "node" : 2, + "path" : "scale" + } + }, + { + "sampler" : 18, + "target" : { + "node" : 1, + "path" : "translation" + } + }, + { + "sampler" : 19, + "target" : { + "node" : 1, + "path" : "rotation" + } + }, + { + "sampler" : 20, + "target" : { + "node" : 1, + "path" : "scale" + } + }, + { + "sampler" : 21, + "target" : { + "node" : 0, + "path" : "translation" + } + }, + { + "sampler" : 22, + "target" : { + "node" : 0, + "path" : "rotation" + } + }, + { + "sampler" : 23, + "target" : { + "node" : 0, + "path" : "scale" + } + }, + { + "sampler" : 24, + "target" : { + "node" : 28, + "path" : "translation" + } + }, + { + "sampler" : 25, + "target" : { + "node" : 28, + "path" : "rotation" + } + }, + { + "sampler" : 26, + "target" : { + "node" : 28, + "path" : "scale" + } + }, + { + "sampler" : 27, + "target" : { + "node" : 27, + "path" : "translation" + } + }, + { + "sampler" : 28, + "target" : { + "node" : 27, + "path" : "rotation" + } + }, + { + "sampler" : 29, + "target" : { + "node" : 27, + "path" : "scale" + } + }, + { + "sampler" : 30, + "target" : { + "node" : 8, + "path" : "translation" + } + }, + { + "sampler" : 31, + "target" : { + "node" : 8, + "path" : "rotation" + } + }, + { + "sampler" : 32, + "target" : { + "node" : 8, + "path" : "scale" + } + }, + { + "sampler" : 33, + "target" : { + "node" : 7, + "path" : "translation" + } + }, + { + "sampler" : 34, + "target" : { + "node" : 7, + "path" : "rotation" + } + }, + { + "sampler" : 35, + "target" : { + "node" : 7, + "path" : "scale" + } + }, + { + "sampler" : 36, + "target" : { + "node" : 6, + "path" : "translation" + } + }, + { + "sampler" : 37, + "target" : { + "node" : 6, + "path" : "rotation" + } + }, + { + "sampler" : 38, + "target" : { + "node" : 6, + "path" : "scale" + } + }, + { + "sampler" : 39, + "target" : { + "node" : 14, + "path" : "translation" + } + }, + { + "sampler" : 40, + "target" : { + "node" : 14, + "path" : "rotation" + } + }, + { + "sampler" : 41, + "target" : { + "node" : 14, + "path" : "scale" + } + }, + { + "sampler" : 42, + "target" : { + "node" : 13, + "path" : "translation" + } + }, + { + "sampler" : 43, + "target" : { + "node" : 13, + "path" : "rotation" + } + }, + { + "sampler" : 44, + "target" : { + "node" : 13, + "path" : "scale" + } + }, + { + "sampler" : 45, + "target" : { + "node" : 12, + "path" : "translation" + } + }, + { + "sampler" : 46, + "target" : { + "node" : 12, + "path" : "rotation" + } + }, + { + "sampler" : 47, + "target" : { + "node" : 12, + "path" : "scale" + } + }, + { + "sampler" : 48, + "target" : { + "node" : 11, + "path" : "translation" + } + }, + { + "sampler" : 49, + "target" : { + "node" : 11, + "path" : "rotation" + } + }, + { + "sampler" : 50, + "target" : { + "node" : 11, + "path" : "scale" + } + }, + { + "sampler" : 51, + "target" : { + "node" : 10, + "path" : "translation" + } + }, + { + "sampler" : 52, + "target" : { + "node" : 10, + "path" : "rotation" + } + }, + { + "sampler" : 53, + "target" : { + "node" : 10, + "path" : "scale" + } + }, + { + "sampler" : 54, + "target" : { + "node" : 9, + "path" : "translation" + } + }, + { + "sampler" : 55, + "target" : { + "node" : 9, + "path" : "rotation" + } + }, + { + "sampler" : 56, + "target" : { + "node" : 9, + "path" : "scale" + } + }, + { + "sampler" : 57, + "target" : { + "node" : 20, + "path" : "translation" + } + }, + { + "sampler" : 58, + "target" : { + "node" : 20, + "path" : "rotation" + } + }, + { + "sampler" : 59, + "target" : { + "node" : 20, + "path" : "scale" + } + }, + { + "sampler" : 60, + "target" : { + "node" : 19, + "path" : "translation" + } + }, + { + "sampler" : 61, + "target" : { + "node" : 19, + "path" : "rotation" + } + }, + { + "sampler" : 62, + "target" : { + "node" : 19, + "path" : "scale" + } + }, + { + "sampler" : 63, + "target" : { + "node" : 18, + "path" : "translation" + } + }, + { + "sampler" : 64, + "target" : { + "node" : 18, + "path" : "rotation" + } + }, + { + "sampler" : 65, + "target" : { + "node" : 18, + "path" : "scale" + } + }, + { + "sampler" : 66, + "target" : { + "node" : 17, + "path" : "translation" + } + }, + { + "sampler" : 67, + "target" : { + "node" : 17, + "path" : "rotation" + } + }, + { + "sampler" : 68, + "target" : { + "node" : 17, + "path" : "scale" + } + }, + { + "sampler" : 69, + "target" : { + "node" : 16, + "path" : "translation" + } + }, + { + "sampler" : 70, + "target" : { + "node" : 16, + "path" : "rotation" + } + }, + { + "sampler" : 71, + "target" : { + "node" : 16, + "path" : "scale" + } + }, + { + "sampler" : 72, + "target" : { + "node" : 15, + "path" : "translation" + } + }, + { + "sampler" : 73, + "target" : { + "node" : 15, + "path" : "rotation" + } + }, + { + "sampler" : 74, + "target" : { + "node" : 15, + "path" : "scale" + } + }, + { + "sampler" : 75, + "target" : { + "node" : 23, + "path" : "translation" + } + }, + { + "sampler" : 76, + "target" : { + "node" : 23, + "path" : "rotation" + } + }, + { + "sampler" : 77, + "target" : { + "node" : 23, + "path" : "scale" + } + }, + { + "sampler" : 78, + "target" : { + "node" : 22, + "path" : "translation" + } + }, + { + "sampler" : 79, + "target" : { + "node" : 22, + "path" : "rotation" + } + }, + { + "sampler" : 80, + "target" : { + "node" : 22, + "path" : "scale" + } + }, + { + "sampler" : 81, + "target" : { + "node" : 21, + "path" : "translation" + } + }, + { + "sampler" : 82, + "target" : { + "node" : 21, + "path" : "rotation" + } + }, + { + "sampler" : 83, + "target" : { + "node" : 21, + "path" : "scale" + } + }, + { + "sampler" : 84, + "target" : { + "node" : 26, + "path" : "translation" + } + }, + { + "sampler" : 85, + "target" : { + "node" : 26, + "path" : "rotation" + } + }, + { + "sampler" : 86, + "target" : { + "node" : 26, + "path" : "scale" + } + }, + { + "sampler" : 87, + "target" : { + "node" : 25, + "path" : "translation" + } + }, + { + "sampler" : 88, + "target" : { + "node" : 25, + "path" : "rotation" + } + }, + { + "sampler" : 89, + "target" : { + "node" : 25, + "path" : "scale" + } + }, + { + "sampler" : 90, + "target" : { + "node" : 24, + "path" : "translation" + } + }, + { + "sampler" : 91, + "target" : { + "node" : 24, + "path" : "rotation" + } + }, + { + "sampler" : 92, + "target" : { + "node" : 24, + "path" : "scale" + } + }, + { + "sampler" : 93, + "target" : { + "node" : 30, + "path" : "translation" + } + }, + { + "sampler" : 94, + "target" : { + "node" : 30, + "path" : "rotation" + } + }, + { + "sampler" : 95, + "target" : { + "node" : 30, + "path" : "scale" + } + }, + { + "sampler" : 96, + "target" : { + "node" : 29, + "path" : "translation" + } + }, + { + "sampler" : 97, + "target" : { + "node" : 29, + "path" : "rotation" + } + }, + { + "sampler" : 98, + "target" : { + "node" : 29, + "path" : "scale" + } + }, + { + "sampler" : 99, + "target" : { + "node" : 32, + "path" : "translation" + } + }, + { + "sampler" : 100, + "target" : { + "node" : 32, + "path" : "rotation" + } + }, + { + "sampler" : 101, + "target" : { + "node" : 32, + "path" : "scale" + } + }, + { + "sampler" : 102, + "target" : { + "node" : 31, + "path" : "translation" + } + }, + { + "sampler" : 103, + "target" : { + "node" : 31, + "path" : "rotation" + } + }, + { + "sampler" : 104, + "target" : { + "node" : 31, + "path" : "scale" + } + }, + { + "sampler" : 105, + "target" : { + "node" : 34, + "path" : "translation" + } + }, + { + "sampler" : 106, + "target" : { + "node" : 34, + "path" : "rotation" + } + }, + { + "sampler" : 107, + "target" : { + "node" : 34, + "path" : "scale" + } + }, + { + "sampler" : 108, + "target" : { + "node" : 33, + "path" : "translation" + } + }, + { + "sampler" : 109, + "target" : { + "node" : 33, + "path" : "rotation" + } + }, + { + "sampler" : 110, + "target" : { + "node" : 33, + "path" : "scale" + } + }, + { + "sampler" : 111, + "target" : { + "node" : 40, + "path" : "translation" + } + }, + { + "sampler" : 112, + "target" : { + "node" : 40, + "path" : "rotation" + } + }, + { + "sampler" : 113, + "target" : { + "node" : 40, + "path" : "scale" + } + }, + { + "sampler" : 114, + "target" : { + "node" : 39, + "path" : "translation" + } + }, + { + "sampler" : 115, + "target" : { + "node" : 39, + "path" : "rotation" + } + }, + { + "sampler" : 116, + "target" : { + "node" : 39, + "path" : "scale" + } + }, + { + "sampler" : 117, + "target" : { + "node" : 38, + "path" : "translation" + } + }, + { + "sampler" : 118, + "target" : { + "node" : 38, + "path" : "rotation" + } + }, + { + "sampler" : 119, + "target" : { + "node" : 38, + "path" : "scale" + } + }, + { + "sampler" : 120, + "target" : { + "node" : 37, + "path" : "translation" + } + }, + { + "sampler" : 121, + "target" : { + "node" : 37, + "path" : "rotation" + } + }, + { + "sampler" : 122, + "target" : { + "node" : 37, + "path" : "scale" + } + }, + { + "sampler" : 123, + "target" : { + "node" : 36, + "path" : "translation" + } + }, + { + "sampler" : 124, + "target" : { + "node" : 36, + "path" : "rotation" + } + }, + { + "sampler" : 125, + "target" : { + "node" : 36, + "path" : "scale" + } + }, + { + "sampler" : 126, + "target" : { + "node" : 35, + "path" : "translation" + } + }, + { + "sampler" : 127, + "target" : { + "node" : 35, + "path" : "rotation" + } + }, + { + "sampler" : 128, + "target" : { + "node" : 35, + "path" : "scale" + } + }, + { + "sampler" : 129, + "target" : { + "node" : 42, + "path" : "translation" + } + }, + { + "sampler" : 130, + "target" : { + "node" : 42, + "path" : "rotation" + } + }, + { + "sampler" : 131, + "target" : { + "node" : 42, + "path" : "scale" + } + }, + { + "sampler" : 132, + "target" : { + "node" : 41, + "path" : "translation" + } + }, + { + "sampler" : 133, + "target" : { + "node" : 41, + "path" : "rotation" + } + }, + { + "sampler" : 134, + "target" : { + "node" : 41, + "path" : "scale" + } + }, + { + "sampler" : 135, + "target" : { + "node" : 44, + "path" : "translation" + } + }, + { + "sampler" : 136, + "target" : { + "node" : 44, + "path" : "rotation" + } + }, + { + "sampler" : 137, + "target" : { + "node" : 44, + "path" : "scale" + } + }, + { + "sampler" : 138, + "target" : { + "node" : 43, + "path" : "translation" + } + }, + { + "sampler" : 139, + "target" : { + "node" : 43, + "path" : "rotation" + } + }, + { + "sampler" : 140, + "target" : { + "node" : 43, + "path" : "scale" + } + }, + { + "sampler" : 141, + "target" : { + "node" : 48, + "path" : "translation" + } + }, + { + "sampler" : 142, + "target" : { + "node" : 48, + "path" : "rotation" + } + }, + { + "sampler" : 143, + "target" : { + "node" : 48, + "path" : "scale" + } + }, + { + "sampler" : 144, + "target" : { + "node" : 47, + "path" : "translation" + } + }, + { + "sampler" : 145, + "target" : { + "node" : 47, + "path" : "rotation" + } + }, + { + "sampler" : 146, + "target" : { + "node" : 47, + "path" : "scale" + } + }, + { + "sampler" : 147, + "target" : { + "node" : 46, + "path" : "translation" + } + }, + { + "sampler" : 148, + "target" : { + "node" : 46, + "path" : "rotation" + } + }, + { + "sampler" : 149, + "target" : { + "node" : 46, + "path" : "scale" + } + }, + { + "sampler" : 150, + "target" : { + "node" : 51, + "path" : "translation" + } + }, + { + "sampler" : 151, + "target" : { + "node" : 51, + "path" : "rotation" + } + }, + { + "sampler" : 152, + "target" : { + "node" : 51, + "path" : "scale" + } + }, + { + "sampler" : 153, + "target" : { + "node" : 50, + "path" : "translation" + } + }, + { + "sampler" : 154, + "target" : { + "node" : 50, + "path" : "rotation" + } + }, + { + "sampler" : 155, + "target" : { + "node" : 50, + "path" : "scale" + } + }, + { + "sampler" : 156, + "target" : { + "node" : 49, + "path" : "translation" + } + }, + { + "sampler" : 157, + "target" : { + "node" : 49, + "path" : "rotation" + } + }, + { + "sampler" : 158, + "target" : { + "node" : 49, + "path" : "scale" + } + }, + { + "sampler" : 159, + "target" : { + "node" : 55, + "path" : "translation" + } + }, + { + "sampler" : 160, + "target" : { + "node" : 55, + "path" : "rotation" + } + }, + { + "sampler" : 161, + "target" : { + "node" : 55, + "path" : "scale" + } + } + ], + "name" : "Armature|Armature|ArmatureAction", + "samplers" : [ + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 15 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 16 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 17 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 18 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 19 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 20 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 21 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 22 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 23 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 24 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 25 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 26 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 27 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 28 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 29 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 30 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 31 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 32 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 33 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 34 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 35 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 36 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 37 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 38 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 39 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 40 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 41 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 42 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 43 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 44 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 45 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 46 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 47 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 48 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 49 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 50 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 51 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 52 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 53 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 54 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 55 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 56 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 57 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 58 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 59 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 60 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 61 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 62 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 63 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 64 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 65 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 66 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 67 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 68 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 69 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 70 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 71 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 72 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 73 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 74 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 75 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 76 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 77 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 78 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 79 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 80 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 81 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 82 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 83 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 84 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 85 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 86 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 87 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 88 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 89 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 90 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 91 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 92 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 93 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 94 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 95 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 96 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 97 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 98 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 99 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 100 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 101 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 102 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 103 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 104 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 105 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 106 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 107 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 108 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 109 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 110 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 111 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 112 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 113 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 114 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 115 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 116 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 117 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 118 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 119 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 120 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 121 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 122 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 123 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 124 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 125 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 126 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 127 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 128 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 129 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 130 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 131 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 132 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 133 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 134 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 135 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 136 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 137 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 138 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 139 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 140 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 141 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 142 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 143 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 144 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 145 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 146 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 147 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 148 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 149 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 150 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 151 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 152 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 153 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 154 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 155 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 156 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 157 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 158 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 159 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 160 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 161 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 162 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 163 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 164 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 165 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 166 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 167 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 168 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 169 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 170 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 171 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 172 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 173 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 174 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 175 + }, + { + "input" : 14, + "interpolation" : "LINEAR", + "output" : 176 + } + ] + } + ], + "materials" : [ + { + "doubleSided" : true, + "name" : "BagMaterial", + "pbrMetallicRoughness" : { + "baseColorFactor" : [ + 0.800000011920929, + 0.800000011920929, + 0.800000011920929, + 1 + ], + "metallicFactor" : 0, + "roughnessFactor" : 0.5 + } + }, + { + "alphaMode" : "BLEND", + "doubleSided" : true, + "extensions" : { + "KHR_materials_specular" : { + "specularColorFactor" : [ + 0, + 0, + 0 + ] + }, + "KHR_materials_ior" : { + "ior" : 1.4500000476837158 + } + }, + "name" : "BodyMaterial", + "pbrMetallicRoughness" : { + "baseColorFactor" : [ + 0.800000011920929, + 0.800000011920929, + 0.800000011920929, + 1 + ], + "metallicFactor" : 0 + } + } + ], + "meshes" : [ + { + "name" : "Cube.003", + "primitives" : [ + { + "attributes" : { + "POSITION" : 0, + "NORMAL" : 1, + "TEXCOORD_0" : 2, + "JOINTS_0" : 3, + "WEIGHTS_0" : 4 + }, + "indices" : 5, + "material" : 0 + } + ] + }, + { + "name" : "Cube.012", + "primitives" : [ + { + "attributes" : { + "POSITION" : 7, + "NORMAL" : 8, + "TEXCOORD_0" : 9, + "COLOR_0" : 10, + "JOINTS_0" : 11, + "WEIGHTS_0" : 12 + }, + "indices" : 13, + "material" : 1 + } + ] + } + ], + "skins" : [ + { + "inverseBindMatrices" : 6, + "joints" : [ + 52, + 45, + 5, + 4, + 3, + 2, + 1, + 0, + 28, + 27, + 8, + 7, + 6, + 14, + 13, + 12, + 11, + 10, + 9, + 20, + 19, + 18, + 17, + 16, + 15, + 23, + 22, + 21, + 26, + 25, + 24, + 30, + 29, + 32, + 31, + 34, + 33, + 40, + 39, + 38, + 37, + 36, + 35, + 42, + 41, + 44, + 43, + 48, + 47, + 46, + 51, + 50, + 49 + ], + "name" : "Armature" + } + ], + "accessors" : [ + { + "bufferView" : 0, + "componentType" : 5126, + "count" : 506, + "max" : [ + 0.1090814545750618, + 0.40452075004577637, + 0.0857388824224472 + ], + "min" : [ + -0.09462108463048935, + 0.2630254030227661, + -0.11617939174175262 + ], + "type" : "VEC3" + }, + { + "bufferView" : 1, + "componentType" : 5126, + "count" : 506, + "type" : "VEC3" + }, + { + "bufferView" : 2, + "componentType" : 5126, + "count" : 506, + "type" : "VEC2" + }, + { + "bufferView" : 3, + "componentType" : 5121, + "count" : 506, + "type" : "VEC4" + }, + { + "bufferView" : 4, + "componentType" : 5126, + "count" : 506, + "type" : "VEC4" + }, + { + "bufferView" : 5, + "componentType" : 5123, + "count" : 2346, + "type" : "SCALAR" + }, + { + "bufferView" : 6, + "componentType" : 5126, + "count" : 53, + "type" : "MAT4" + }, + { + "bufferView" : 7, + "componentType" : 5126, + "count" : 3484, + "max" : [ + 0.2035536766052246, + 0.5987313389778137, + 0.09013944119215012 + ], + "min" : [ + -0.19493983685970306, + -0.0017474208725616336, + -0.19020147621631622 + ], + "type" : "VEC3" + }, + { + "bufferView" : 8, + "componentType" : 5126, + "count" : 3484, + "type" : "VEC3" + }, + { + "bufferView" : 9, + "componentType" : 5126, + "count" : 3484, + "type" : "VEC2" + }, + { + "bufferView" : 10, + "componentType" : 5123, + "count" : 3484, + "normalized" : true, + "type" : "VEC4" + }, + { + "bufferView" : 11, + "componentType" : 5121, + "count" : 3484, + "type" : "VEC4" + }, + { + "bufferView" : 12, + "componentType" : 5126, + "count" : 3484, + "type" : "VEC4" + }, + { + "bufferView" : 13, + "componentType" : 5123, + "count" : 17472, + "type" : "SCALAR" + }, + { + "bufferView" : 14, + "componentType" : 5126, + "count" : 51, + "max" : [ + 2.125 + ], + "min" : [ + 0.041666666666666664 + ], + "type" : "SCALAR" + }, + { + "bufferView" : 15, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 16, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 17, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 18, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 19, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 20, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 21, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 22, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 23, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 24, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 25, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 26, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 27, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 28, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 29, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 30, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 31, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 32, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 33, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 34, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 35, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 36, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 37, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 38, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 39, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 40, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 41, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 42, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 43, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 44, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 45, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 46, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 47, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 48, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 49, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 50, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 51, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 52, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 53, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 54, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 55, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 56, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 57, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 58, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 59, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 60, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 61, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 62, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 63, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 64, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 65, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 66, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 67, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 68, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 69, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 70, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 71, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 72, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 73, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 74, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 75, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 76, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 77, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 78, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 79, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 80, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 81, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 82, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 83, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 84, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 85, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 86, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 87, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 88, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 89, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 90, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 91, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 92, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 93, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 94, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 95, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 96, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 97, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 98, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 99, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 100, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 101, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 102, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 103, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 104, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 105, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 106, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 107, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 108, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 109, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 110, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 111, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 112, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 113, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 114, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 115, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 116, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 117, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 118, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 119, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 120, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 121, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 122, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 123, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 124, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 125, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 126, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 127, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 128, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 129, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 130, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 131, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 132, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 133, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 134, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 135, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 136, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 137, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 138, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 139, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 140, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 141, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 142, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 143, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 144, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 145, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 146, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 147, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 148, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 149, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 150, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 151, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 152, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 153, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 154, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 155, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 156, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 157, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 158, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 159, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 160, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 161, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 162, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 163, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 164, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 165, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 166, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 167, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 168, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 169, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 170, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 171, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 172, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 173, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 174, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + }, + { + "bufferView" : 175, + "componentType" : 5126, + "count" : 51, + "type" : "VEC4" + }, + { + "bufferView" : 176, + "componentType" : 5126, + "count" : 51, + "type" : "VEC3" + } + ], + "bufferViews" : [ + { + "buffer" : 0, + "byteLength" : 6072, + "byteOffset" : 0, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 6072, + "byteOffset" : 6072, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 4048, + "byteOffset" : 12144, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 2024, + "byteOffset" : 16192, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 8096, + "byteOffset" : 18216, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 4692, + "byteOffset" : 26312, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 3392, + "byteOffset" : 31004 + }, + { + "buffer" : 0, + "byteLength" : 41808, + "byteOffset" : 34396, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 41808, + "byteOffset" : 76204, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 27872, + "byteOffset" : 118012, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 27872, + "byteOffset" : 145884, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 13936, + "byteOffset" : 173756, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 55744, + "byteOffset" : 187692, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 34944, + "byteOffset" : 243436, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 204, + "byteOffset" : 278380 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 278584 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 279196 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 280012 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 280624 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 281236 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 282052 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 282664 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 283276 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 284092 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 284704 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 285316 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 286132 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 286744 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 287356 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 288172 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 288784 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 289396 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 290212 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 290824 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 291436 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 292252 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 292864 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 293476 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 294292 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 294904 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 295516 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 296332 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 296944 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 297556 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 298372 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 298984 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 299596 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 300412 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 301024 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 301636 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 302452 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 303064 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 303676 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 304492 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 305104 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 305716 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 306532 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 307144 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 307756 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 308572 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 309184 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 309796 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 310612 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 311224 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 311836 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 312652 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 313264 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 313876 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 314692 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 315304 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 315916 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 316732 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 317344 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 317956 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 318772 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 319384 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 319996 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 320812 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 321424 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 322036 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 322852 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 323464 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 324076 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 324892 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 325504 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 326116 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 326932 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 327544 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 328156 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 328972 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 329584 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 330196 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 331012 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 331624 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 332236 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 333052 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 333664 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 334276 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 335092 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 335704 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 336316 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 337132 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 337744 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 338356 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 339172 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 339784 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 340396 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 341212 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 341824 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 342436 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 343252 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 343864 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 344476 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 345292 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 345904 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 346516 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 347332 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 347944 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 348556 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 349372 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 349984 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 350596 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 351412 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 352024 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 352636 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 353452 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 354064 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 354676 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 355492 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 356104 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 356716 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 357532 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 358144 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 358756 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 359572 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 360184 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 360796 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 361612 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 362224 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 362836 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 363652 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 364264 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 364876 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 365692 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 366304 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 366916 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 367732 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 368344 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 368956 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 369772 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 370384 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 370996 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 371812 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 372424 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 373036 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 373852 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 374464 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 375076 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 375892 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 376504 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 377116 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 377932 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 378544 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 379156 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 379972 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 380584 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 381196 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 382012 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 382624 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 383236 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 384052 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 384664 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 385276 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 386092 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 386704 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 387316 + }, + { + "buffer" : 0, + "byteLength" : 612, + "byteOffset" : 388132 + } + ], + "buffers" : [ + { + "byteLength" : 388744, + "uri" : "data:application/octet-stream;base64,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" + } + ] +} diff --git a/Assets/Cube.012.shmesh b/Assets/Models/racoon.shmodel similarity index 87% rename from Assets/Cube.012.shmesh rename to Assets/Models/racoon.shmodel index bc26a4e8..9c5d866a 100644 Binary files a/Assets/Cube.012.shmesh and b/Assets/Models/racoon.shmodel differ diff --git a/Assets/Models/racoon.shmodel.shmeta b/Assets/Models/racoon.shmodel.shmeta new file mode 100644 index 00000000..96d1291c --- /dev/null +++ b/Assets/Models/racoon.shmodel.shmeta @@ -0,0 +1,10 @@ +Name: racoon +ID: 77816045 +Type: 4 +Sub Assets: +Name: Bag +ID: 144838771 +Type: 8 +Name: Raccoon +ID: 149697411 +Type: 8 diff --git a/Assets/Scenes/M2Scene.shade b/Assets/Scenes/M2Scene.shade new file mode 100644 index 00000000..b2a5683f --- /dev/null +++ b/Assets/Scenes/M2Scene.shade @@ -0,0 +1,229 @@ +- EID: 0 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Camera Component: + Position: {x: 0, y: 0, z: 0} + Pitch: 0 + Yaw: 0 + Roll: 0 + Width: 1920 + Height: 1080 + Near: 0.00999999978 + Far: 10000 + Perspective: true + Light Component: + Position: {x: 0, y: 0, z: 0} + Type: Directional + Direction: {x: 1.79999995, y: 0, z: 1} + Color: {x: 0.951541841, y: 0.921719015, z: 0.553319454, w: 1} + Layer: 4294967295 + Strength: 0 + Scripts: ~ +- EID: 1 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: -1.440328, y: -4.41369677, z: -5} + Rotate: {x: -0, y: 0, z: -0} + Scale: {x: 49.4798889, y: 0.5, z: 17.5} + Renderable Component: + Mesh: 149697411 + Material: 126974645 + RigidBody Component: + Type: Static + Mass: 1 + Drag: 0 + Angular Drag: 0 + Use Gravity: true + Interpolate: true + Freeze Position X: false + Freeze Position Y: false + Freeze Position Z: false + Freeze Rotation X: false + Freeze Rotation Y: false + Freeze Rotation Z: false + Collider Component: + Colliders: + - Is Trigger: false + Type: Box + Half Extents: {x: 1, y: 1, z: 1} + Friction: 0.400000006 + Bounciness: 0 + Density: 1 + Position Offset: {x: 0, y: 0, z: 0} + Scripts: ~ +- EID: 2 + Name: Player + IsActive: true + NumberOfChildren: 3 + Components: + Transform Component: + Translate: {x: -3.06177855, y: -2, z: -5} + Rotate: {x: -0, y: 0, z: -0} + Scale: {x: 2, y: 2, z: 2} + Renderable Component: + Mesh: 149697411 + Material: 126974645 + RigidBody Component: + Type: Dynamic + Mass: 1 + Drag: 0 + Angular Drag: 0 + Use Gravity: true + Interpolate: true + Freeze Position X: false + Freeze Position Y: false + Freeze Position Z: false + Freeze Rotation X: false + Freeze Rotation Y: false + Freeze Rotation Z: false + Collider Component: + Colliders: + - Is Trigger: false + Type: Box + Half Extents: {x: 1, y: 1, z: 1} + Friction: 0.400000006 + Bounciness: 0 + Density: 1 + Position Offset: {x: 0, y: 0.5, z: 0} + Scripts: ~ +- EID: 3 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: -0.0094268322, y: 0, z: 0} + Rotate: {x: -0, y: 0, z: -0} + Scale: {x: 1, y: 1, z: 1} + Scripts: ~ +- EID: 4 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: 0, y: 0, z: 0} + Rotate: {x: 0, y: 0, z: 0} + Scale: {x: 1, y: 1, z: 1} + Scripts: ~ +- EID: 9 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: 0, y: 0, z: 0} + Rotate: {x: 0, y: 0, z: 0} + Scale: {x: 1, y: 1, z: 1} + Renderable Component: + Mesh: 144838771 + Material: 123745521 + Scripts: ~ +- EID: 6 + Name: AI + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: -8, y: -2, z: 2.5} + Rotate: {x: 0, y: 0, z: 0} + Scale: {x: 1, y: 1, z: 1} + Renderable Component: + Mesh: 149697411 + Material: 126974645 + RigidBody Component: + Type: Dynamic + Mass: 1 + Drag: 0 + Angular Drag: 0 + Use Gravity: true + Interpolate: false + Freeze Position X: false + Freeze Position Y: false + Freeze Position Z: false + Freeze Rotation X: true + Freeze Rotation Y: true + Freeze Rotation Z: true + Collider Component: + Colliders: + - Is Trigger: false + Type: Box + Half Extents: {x: 0.5, y: 0.5, z: 0.5} + Friction: 0.400000006 + Bounciness: 0 + Density: 1 + Position Offset: {x: 0, y: 0.5, z: 0} + Scripts: ~ +- EID: 7 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: 0, y: -16.8647861, z: -14.039052} + Rotate: {x: -0, y: 0, z: -0} + Scale: {x: 28.1434975, y: 28.1434975, z: 28.1434975} + Renderable Component: + Mesh: 149697411 + Material: 126974645 + Scripts: ~ +- EID: 8 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Light Component: + Position: {x: 0, y: 0, z: 0} + Type: Ambient + Direction: {x: 0, y: 0, z: 1} + Color: {x: 1, y: 1, z: 1, w: 1} + Layer: 4294967295 + Strength: 0.25 + Scripts: ~ +- EID: 5 + Name: item + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: 0, y: -2, z: -5} + Rotate: {x: 0, y: 0, z: 0} + Scale: {x: 2, y: 2, z: 2} + Renderable Component: + Mesh: 144838771 + Material: 123745521 + RigidBody Component: + Type: Dynamic + Mass: 1 + Drag: 0 + Angular Drag: 0 + Use Gravity: true + Interpolate: false + Freeze Position X: false + Freeze Position Y: false + Freeze Position Z: false + Freeze Rotation X: true + Freeze Rotation Y: true + Freeze Rotation Z: true + Collider Component: + Colliders: + - Is Trigger: false + Type: Box + Half Extents: {x: 1, y: 1, z: 1} + Friction: 0.400000006 + Bounciness: 0 + Density: 1 + Position Offset: {x: 0, y: 0.5, z: 0} + - Is Trigger: true + Type: Box + Half Extents: {x: 2, y: 2, z: 2} + Friction: 0.400000006 + Bounciness: 0 + Density: 1 + Position Offset: {x: 0, y: 0.5, z: 0} + Scripts: ~ \ No newline at end of file diff --git a/Assets/Scenes/M2Scene.shade.shmeta b/Assets/Scenes/M2Scene.shade.shmeta new file mode 100644 index 00000000..9289949c --- /dev/null +++ b/Assets/Scenes/M2Scene.shade.shmeta @@ -0,0 +1,3 @@ +Name: M2Scene +ID: 94283040 +Type: 5 diff --git a/Assets/Scenes/Scene2.shade b/Assets/Scenes/Scene2.shade new file mode 100644 index 00000000..2f38a933 --- /dev/null +++ b/Assets/Scenes/Scene2.shade @@ -0,0 +1,72 @@ +- EID: 0 + Name: Default + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: 0, y: 0.304069757, z: 1.73034382} + Rotate: {x: 0, y: 0, z: 0} + Scale: {x: 1, y: 1, z: 1} + Camera Component: + Position: {x: 0, y: 0.304069757, z: 1.73034382} + Pitch: 0 + Yaw: 0 + Roll: 0 + Width: 1200 + Height: 1080 + Near: 0.00999999978 + Far: 10000 + Perspective: true + Scripts: ~ +- EID: 1 + Name: Raccoon + IsActive: true + NumberOfChildren: 1 + Components: + Transform Component: + Translate: {x: 0, y: 0, z: 0} + Rotate: {x: 0, y: 0, z: 0} + Scale: {x: 1, y: 1, z: 1} + Renderable Component: + Mesh: 149697411 + Material: 126974645 + Scripts: ~ +- EID: 3 + Name: Bag + IsActive: true + NumberOfChildren: 0 + Components: + Transform Component: + Translate: {x: 0.006237939, y: -0.000393368304, z: 0} + Rotate: {x: -0, y: 2.79945588, z: 0} + Scale: {x: 1.0000881, y: 1, z: 1.0000881} + Renderable Component: + Mesh: 144838771 + Material: 123745521 + Scripts: ~ +- EID: 2 + Name: DirectionalLight + IsActive: true + NumberOfChildren: 0 + Components: + Light Component: + Position: {x: 0, y: 0, z: 0} + Type: Directional + Direction: {x: 0, y: 0, z: 1} + Color: {x: 1, y: 1, z: 1, w: 1} + Layer: 4294967295 + Strength: 0 + Scripts: ~ +- EID: 4 + Name: AmbientLight + IsActive: true + NumberOfChildren: 0 + Components: + Light Component: + Position: {x: 0, y: 0, z: 0} + Type: Ambient + Direction: {x: 0, y: 0, z: 1} + Color: {x: 1, y: 1, z: 1, w: 1} + Layer: 4294967295 + Strength: 0.600000024 + Scripts: ~ \ No newline at end of file diff --git a/Assets/Scenes/Scene2.shade.shmeta b/Assets/Scenes/Scene2.shade.shmeta new file mode 100644 index 00000000..bbcbc66c --- /dev/null +++ b/Assets/Scenes/Scene2.shade.shmeta @@ -0,0 +1,3 @@ +Name: Scene2 +ID: 87285316 +Type: 5 diff --git a/Assets/Scripts/AIPrototype.cs b/Assets/Scripts/AIPrototype.cs new file mode 100644 index 00000000..d678de78 --- /dev/null +++ b/Assets/Scripts/AIPrototype.cs @@ -0,0 +1,184 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Security.Cryptography.X509Certificates; +using System.Text; +using System.Threading.Tasks; +using SHADE; + +public class AIPrototype : Script +{ + //This object's relevant components + private Transform transform; + private RigidBody rb; + + /*[SerializeField] + [Tooltip("The list of waypoints that the object will move around on")] + private Vector3[] waypoints;*/ + + private Vector3[] waypoints = { new Vector3(-8.0f, -2.0f, 3.5f), new Vector3(-8.0f, -2.0f, -13.0f), new Vector3(8.0f, -2.0f, -13.0f), new Vector3(8.0f, -2.0f, 3.5f) }; + + [SerializeField] + [Tooltip("How much force is applied in movement")] + private float movementForceMultiplier = 100.0f; + + [SerializeField] + [Tooltip("How fast the object moves about waypoints")] + private float patrolSpeed = 0.4f; + + [SerializeField] + [Tooltip("How fast the object moves while chasing")] + private float chaseSpeed = 0.8f; + + [SerializeField] + [Tooltip("How near the player must be to the AI for capture")] + private float distanceToCapture = 1.2f; + + [SerializeField] + [Tooltip("How near the player must be for the chase to begin. Should be less than distanceToEndChase")] + private float distanceToStartChase = 2.0f; + + [SerializeField] + [Tooltip("How far the player must be for the chase to end. Should be greater than distanceToStartChase")] + private float distanceToEndChase = 2.5f; + + //Whether the AI is chasing or not + private bool chaseMode; + + //To cycle depending on the length of waypoints + private int currentTargetWaypointIndex; + + private GameObject? player; + + public AIPrototype(GameObject gameObj) : base(gameObj) { } + + protected override void awake() + { + transform = GetComponent(); + if (transform == null) + { + Debug.LogError("Transform is NULL!"); + } + + rb = GetComponent(); + if (rb == null) + { + Debug.LogError("Rigidbody is NULL!"); + } + + currentTargetWaypointIndex = 0; + + player = GameObject.Find("Player"); + if (player == null) + { + Debug.LogError("Player is NULL!"); + } + + chaseMode = false; + } + + protected override void fixedUpdate() + { + //Patrolling + if (!chaseMode) + { + //Head towards the next target + Vector3 normalisedDifference = waypoints[currentTargetWaypointIndex] - transform.GlobalPosition; + normalisedDifference /= normalisedDifference.GetMagnitude(); + + //transform.GlobalPosition += normalisedDifference * moveSpeed * (float)Time.DeltaTime; + //rb.LinearVelocity = normalisedDifference * patrolSpeed; + + //ORIGINAL INTENDED CODE + /*rb.AddForce(new Vector3(normalisedDifference.x, 0.0f, normalisedDifference.z) * movementForceMultiplier); + float currentSpeed = MathF.Sqrt(rb.LinearVelocity.x * rb.LinearVelocity.x + rb.LinearVelocity.z * rb.LinearVelocity.z); + if (currentSpeed > patrolSpeed) + { + float adjustmentFactor = patrolSpeed / currentSpeed; + Vector3 adjustedVelocity = rb.LinearVelocity; + //adjustedVelocity *= adjustmentFactor; + adjustedVelocity.x = patrolSpeed; + adjustedVelocity.z = patrolSpeed; + rb.LinearVelocity = adjustedVelocity; + }*/ + + //TODO delete this when original intended code above works with velocity being limited correctly + rb.LinearVelocity = normalisedDifference * patrolSpeed; + + //transform.GlobalRotation.SetLookRotation(waypoints[currentTargetWaypointIndex], Vector3.Up); + + //Cycle to next waypoint if near enough current waypoint + if ((waypoints[currentTargetWaypointIndex] - transform.GlobalPosition).GetSqrMagnitude() <= 0.5f) + { + ++currentTargetWaypointIndex; + if (currentTargetWaypointIndex >= waypoints.Length) + { + currentTargetWaypointIndex = 0; //Recycle + } + } + + //Go chase if near enough to player + if (player != null) + { + Transform pTransform = player.GetValueOrDefault().GetComponent(); + if ((pTransform.GlobalPosition - transform.GlobalPosition).GetMagnitude() <= distanceToStartChase) + { + //Start the chase + chaseMode = true; + } + } + } + else //Chasing + { + if (player != null) + { + Transform pTransform = player.GetValueOrDefault().GetComponent(); + + //Chase the player + Vector3 normalisedDifference = pTransform.GlobalPosition - transform.GlobalPosition; + normalisedDifference /= normalisedDifference.GetMagnitude(); + + //transform.GlobalPosition += normalisedDifference * moveSpeed * (float)Time.DeltaTime; + + //ORIGINAL INTENDED CODE + /*rb.AddForce(new Vector3(normalisedDifference.x, 0.0f, normalisedDifference.z) * movementForceMultiplier); + float currentSpeed = MathF.Sqrt(rb.LinearVelocity.x * rb.LinearVelocity.x + rb.LinearVelocity.z * rb.LinearVelocity.z); + if (currentSpeed > chaseSpeed) + { + float adjustmentFactor = chaseSpeed / currentSpeed; + Vector3 adjustedVelocity = rb.LinearVelocity; + adjustedVelocity *= adjustmentFactor; + rb.LinearVelocity = adjustedVelocity; + }*/ + + //TODO delete this when original intended code above works with velocity being limited correctly + rb.LinearVelocity = normalisedDifference * chaseSpeed; + + //Capture player if near enough + if ((pTransform.GlobalPosition - transform.GlobalPosition).GetMagnitude() <= distanceToCapture) + { + player.GetValueOrDefault().GetScript().currentState = PlayerController.RaccoonStates.CAUGHT; + } + + //End chase if too far + if ((pTransform.GlobalPosition - transform.GlobalPosition).GetMagnitude() >= distanceToEndChase) + { + //Stop the chase + chaseMode = false; + + //Find the nearest waypoint to go instead + float nearestWaypointDistance = 99999999999999.9f; + for (int i = 0; i < waypoints.Length; ++i) + { + if ((waypoints[i] - transform.GlobalPosition).GetSqrMagnitude() < nearestWaypointDistance) + { + nearestWaypointDistance = waypoints[i].GetSqrMagnitude(); + currentTargetWaypointIndex = i; + } + } + } + } + } + } +} \ No newline at end of file diff --git a/TempScriptsFolder/CameraControl.cs b/Assets/Scripts/CameraControl.cs similarity index 100% rename from TempScriptsFolder/CameraControl.cs rename to Assets/Scripts/CameraControl.cs diff --git a/Assets/Scripts/CameraFix.cs b/Assets/Scripts/CameraFix.cs new file mode 100644 index 00000000..5347a72f --- /dev/null +++ b/Assets/Scripts/CameraFix.cs @@ -0,0 +1,24 @@ +using SHADE; +using System; + +public class CameraFix : Script +{ + public CameraFix(GameObject gameObj) : base(gameObj) { } + + private Transform tranform; + public Vector3 pos = Vector3.Zero; + public Vector3 rot = Vector3.Zero; + protected override void awake() + { + tranform = GetComponent(); + if (tranform == null) + Debug.LogError("tranform is NULL!"); + else + { + tranform.LocalPosition = pos; + tranform.LocalEulerAngles = rot; + } + + + } +} diff --git a/Assets/Scripts/Item.cs b/Assets/Scripts/Item.cs new file mode 100644 index 00000000..96ec092d --- /dev/null +++ b/Assets/Scripts/Item.cs @@ -0,0 +1,18 @@ +using SHADE; +using System; +public class Item : Script +{ + public enum ItemCategory + { + LIGHT, + MEDIUM, + HEAVY + } + + public ItemCategory currCategory; + public Item(GameObject gameObj) : base(gameObj) { } + + protected override void awake() + { + } +} \ No newline at end of file diff --git a/TempScriptsFolder/PhysicsTest.cs b/Assets/Scripts/PhysicsTest.cs similarity index 100% rename from TempScriptsFolder/PhysicsTest.cs rename to Assets/Scripts/PhysicsTest.cs diff --git a/Assets/Scripts/PickAndThrow.cs b/Assets/Scripts/PickAndThrow.cs new file mode 100644 index 00000000..ea814b36 --- /dev/null +++ b/Assets/Scripts/PickAndThrow.cs @@ -0,0 +1,99 @@ +using SHADE; +using System; +using static PlayerController; + +public class PickAndThrow : Script +{ + public Vector3 throwForce = new Vector3(100.0f, 200.0f, 100.0f); + public GameObject item; + private PlayerController pc; + private Camera cam; + private Transform itemTransform; + private RigidBody itemRidibody; + private Transform raccoonHoldLocation; + private float lastXDir; + private float lastZDir; + private bool inRange = false; + public PickAndThrow(GameObject gameObj) : base(gameObj) { } + + protected override void awake() + { + pc = GetScript(); + raccoonHoldLocation = GetComponentInChildren(); + if (raccoonHoldLocation == null) + Debug.Log("CHILD EMPTY"); + else + raccoonHoldLocation.LocalPosition = new Vector3(0.0f, 1.0f, 0.0f); + } + protected override void update() + { + if (cam == null) + cam = GetComponentInChildren(); + else if (cam != null) + { + Vector3 camerAixs = cam.GetForward(); + camerAixs.y = 0; + camerAixs.Normalise(); + lastXDir = camerAixs.x; + lastZDir = camerAixs.z; + } + + if (item.GetScript() != null && itemTransform == null && itemRidibody == null) + { + itemTransform = item.GetComponent(); + if (itemTransform == null) + Debug.Log("Item transform EMPTY"); + + itemRidibody = item.GetComponent(); + if (itemRidibody == null) + Debug.Log("Item rb EMPTY"); + } + + if (pc != null && inRange && !pc.holdItem && Input.GetKey(Input.KeyCode.E)) + pc.holdItem = true; + + if (pc != null && itemRidibody != null && itemTransform != null && pc.holdItem) + { + itemTransform.LocalPosition = raccoonHoldLocation.GlobalPosition; + itemRidibody.IsGravityEnabled = false; + itemRidibody.LinearVelocity = Vector3.Zero; + itemRidibody.AngularVelocity = Vector3.Zero; + + if (Input.GetMouseButtonDown(Input.MouseCode.LeftButton)) + { + pc.holdItem = false; + inRange = false; + itemRidibody.IsGravityEnabled = true; + itemRidibody.AddForce(new Vector3(throwForce.x * lastXDir, throwForce.y, throwForce.z * lastZDir)); + itemRidibody.LinearVelocity += pc.rb.LinearVelocity; + } + } + else if(!pc.holdItem && itemRidibody != null) + itemRidibody.IsGravityEnabled = true; + } + protected override void onCollisionEnter(CollisionInfo info) + { + } + protected override void onTriggerEnter(CollisionInfo info) + { + //Debug.Log("ENTER"); + if (info.GameObject.GetScript() != null && !pc.holdItem) + { + item = info.GameObject; + inRange = true; + } + } + protected override void onTriggerStay(CollisionInfo info) + { + //Debug.Log("STAY"); + } + protected override void onTriggerExit(CollisionInfo info) + { + //Debug.Log("EXIT"); + if (info.GameObject.GetScript() != null && !pc.holdItem) + { + inRange = false; + } + } + +} \ No newline at end of file diff --git a/Assets/Scripts/PlayerController.cs b/Assets/Scripts/PlayerController.cs new file mode 100644 index 00000000..86ba7c98 --- /dev/null +++ b/Assets/Scripts/PlayerController.cs @@ -0,0 +1,360 @@ +using SHADE; +using System; +using static Item; + +public class PlayerController : Script +{ + public enum RaccoonStates + { + IDILE, + WALKING, + RUNNING, + JUMP, + FALLING, + CAUGHT, + TOTAL + } + + public RigidBody rb { get; set; } + private Transform tranform; + private Camera cam; + private PickAndThrow pat; + + //to be remove + public float drag = 2.0f; + public bool holdItem { get; set; } + [SerializeField] + [Tooltip("The current state fo the raccoon")] + public RaccoonStates currentState = RaccoonStates.IDILE; + + //Movement variables============================================================ + [SerializeField] + [Tooltip("Max vel for walking")] + public float maxMoveVel = 2.0f; + [SerializeField] + [Tooltip("how much force is apply for walking")] + public float moveForce = 50.0f; + [SerializeField] + [Tooltip("increase the moveForce and maxMoveVel by its amt")] + public float sprintMultiplier = 2.0f; + + private float oldForce; + private float maxOldVel; + private bool sprintIncreaseOnce = false; + + public float xAxisMove { get; set; } + public float zAxisMove { get; set; } + + public Vector2 axisMove { get; set; } + + public bool isMoveKeyPress { get; set; } + + [SerializeField] + [Tooltip("curr not working")] + public float rotationFactorPerFrame = 1.0f; + + //Jumping vars================================================================== + [SerializeField] + [Tooltip("max height of the jump")] + public float maxJumpHeight = 4.0f; + [SerializeField] + [Tooltip("max amt of time it will take for the jump")] + public float maxJumpTime = 0.75f; + [SerializeField] + [Tooltip("increase gravity when falling")] + public float fallMultipler = 2.0f; + private float initialJumpVel; + private bool isGrounded = true; + private float gravity = -9.8f; + private float groundGravity = -0.5f; + + //ItemMultipler================================================================== + public float lightMultiper = 0.75f; + public float mediumMultiper = 0.5f; + public float heavyMultiper = 0.25f; + + public PlayerController(GameObject gameObj) : base(gameObj) { } + + protected override void awake() + { + //default setup + isMoveKeyPress = false; + holdItem = false; + + //Jump setup + float timeToApex = maxJumpTime / 2; + gravity = (-2 * maxJumpHeight) / MathF.Pow(timeToApex, 2); + initialJumpVel = (2 * maxJumpHeight) / timeToApex; + + //rigidbody check + rb = GetComponent(); + if (rb == null) + Debug.LogError("RigidBody is NULL!"); + else + { + rb.IsGravityEnabled = false; + rb.FreezeRotationX = true; + rb.FreezeRotationY = true; + rb.FreezeRotationZ = true; + rb.Drag = drag; + rb.Interpolating = false; + } + + //Transform check + tranform = GetComponent(); + if(tranform == null) + Debug.LogError("tranform is NULL!"); + + //PickAndThrow checl + pat = GetScript(); + if (pat == null) + Debug.LogError("PickAndThrow is NULL!"); + + //toRemove + tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f); + tranform.LocalRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f); + } + + protected override void update() + { + if (cam == null) + cam = GetComponentInChildren(); + + //toRemove + if (Input.GetKey(Input.KeyCode.G)) + { + tranform.LocalRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f); + tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f); + } + + GotCaught(); + MoveKey(); + + + + //Debug.Log(currentState.ToString() + " x:" + rb.LinearVelocity.x.ToString() + " y:" + rb.LinearVelocity.y.ToString() + " z:" + rb.LinearVelocity.z.ToString()); + } + + protected override void fixedUpdate() + { + //Rotation(); + Move(); + Sprint(); + Jump(); + Gravity(); + } + + + private void MoveKey() + { + /* if (Input.GetKey(Input.KeyCode.A)) + xAxisMove = -1; + else if (Input.GetKey(Input.KeyCode.D)) + xAxisMove = 1; + else + xAxisMove = 0; + + if (Input.GetKey(Input.KeyCode.W)) + zAxisMove = -1; + else if (Input.GetKey(Input.KeyCode.S)) + zAxisMove = 1; + else + zAxisMove = 0;*/ + + + xAxisMove = 0; + zAxisMove = 0; + axisMove = Vector2.Zero; + if (Input.GetKey(Input.KeyCode.W)) + { + Vector3 camerAixs = cam.GetForward(); + camerAixs.y = 0; + camerAixs.Normalise(); + xAxisMove = camerAixs.x; + zAxisMove = camerAixs.z; + axisMove += new Vector2(camerAixs.x, camerAixs.z); + } + if (Input.GetKey(Input.KeyCode.S)) + { + Vector3 camerAixs = cam.GetForward(); + camerAixs.y = 0; + camerAixs.Normalise(); + xAxisMove = -camerAixs.x; + zAxisMove = -camerAixs.z; + axisMove -= new Vector2(camerAixs.x, camerAixs.z); + } + if (Input.GetKey(Input.KeyCode.A)) + { + Vector3 camerAixs = cam.GetRight(); + camerAixs.y = 0; + camerAixs.Normalise(); + xAxisMove = -camerAixs.x; + zAxisMove = -camerAixs.z; + axisMove -= new Vector2(camerAixs.x, camerAixs.z); + } + if (Input.GetKey(Input.KeyCode.D)) + { + Vector3 camerAixs = cam.GetRight(); + camerAixs.y = 0; + camerAixs.Normalise(); + xAxisMove = camerAixs.x; + zAxisMove = camerAixs.z; + axisMove += new Vector2(camerAixs.x, camerAixs.z); + } + axisMove.Normalise(); + isMoveKeyPress = xAxisMove != 0 || zAxisMove != 0; + + if(isMoveKeyPress && currentState != RaccoonStates.RUNNING && isGrounded) + currentState = RaccoonStates.WALKING; + + if (!isMoveKeyPress && isGrounded) + currentState = RaccoonStates.IDILE; + } + + private void Move() + { + if (rb != null) + { + rb.AddForce(new Vector3(axisMove.x, 0.0f,axisMove.y) * moveForce); + + if (isMoveKeyPress) + { + if (rb.LinearVelocity.x > maxMoveVel || rb.LinearVelocity.x < -maxMoveVel) + { + Vector3 v = rb.LinearVelocity; + v.x = System.Math.Clamp(v.x, -maxMoveVel, maxMoveVel); + rb.LinearVelocity = v; + } + if (rb.LinearVelocity.z > maxMoveVel || rb.LinearVelocity.z < -maxMoveVel) + { + Vector3 v = rb.LinearVelocity; + v.z = System.Math.Clamp(v.z, -maxMoveVel, maxMoveVel); + rb.LinearVelocity = v; + } + } + } + } + + private void Sprint() + { + if (Input.GetKey(Input.KeyCode.LeftShift) && isMoveKeyPress && isGrounded) + { + currentState = RaccoonStates.RUNNING; + holdItem = false; + if (!sprintIncreaseOnce) + { + sprintIncreaseOnce = true; + oldForce = moveForce; + moveForce *= sprintMultiplier; + + maxOldVel = maxMoveVel; + maxMoveVel *= sprintMultiplier; + } + } + + if (Input.GetKeyUp(Input.KeyCode.LeftShift)) + { + if(isMoveKeyPress) + currentState = RaccoonStates.WALKING; + sprintIncreaseOnce = false; + moveForce = oldForce; + maxMoveVel = maxOldVel; + } + } + + //press and hold jump + private void Jump() + { + if (currentState == RaccoonStates.WALKING || currentState == RaccoonStates.RUNNING || currentState == RaccoonStates.IDILE) + { + if (Input.GetKeyDown(Input.KeyCode.Space) && isGrounded && rb != null) + { + currentState = RaccoonStates.JUMP; + Vector3 v = rb.LinearVelocity; + v.y = initialJumpVel * 0.5f; + if (pat != null && pat.item.GetScript() != null && holdItem) + { + Item item = pat.item.GetScript(); + if (item.currCategory == ItemCategory.LIGHT) + v.y *= lightMultiper; + if (item.currCategory == ItemCategory.MEDIUM) + v.y *= mediumMultiper; + if (item.currCategory == ItemCategory.HEAVY) + v.y *= heavyMultiper; + } + rb.LinearVelocity = v; + } + } + + if(rb != null && !isGrounded && (rb.LinearVelocity.y < 0.0f || Input.GetKeyUp(Input.KeyCode.Space))) + currentState = RaccoonStates.FALLING; + } + + private void Rotation() + { + Vector3 poitionToLookAt; + poitionToLookAt.x = xAxisMove; + poitionToLookAt.y = 0.0f; + poitionToLookAt.z = zAxisMove; + + if (tranform != null) + { + Quaternion currentRotation = tranform.LocalRotation; + if (currentState == RaccoonStates.WALKING || currentState == RaccoonStates.RUNNING) + { + Quaternion targetRotation = Quaternion.LookRotation(poitionToLookAt, new Vector3(0.0f, 1.0f, 0.0f)); + tranform.LocalRotation = Quaternion.Slerp(currentRotation, targetRotation, rotationFactorPerFrame * (float)Time.DeltaTime); + } + } + } + + private void Gravity() + { + if (rb != null) + { + //check player vel.y if its close to zero its on the ground + if (SHADE.Math.CompareFloat(rb.LinearVelocity.y, 0.0f)) + isGrounded = true; + else + isGrounded = false; + + Vector3 v = rb.LinearVelocity; + + if (isGrounded) + v.y = groundGravity; + else if (currentState == RaccoonStates.FALLING) + { + float prevYVel = v.y; + float newYVel = v.y + (gravity * fallMultipler * (float)Time.DeltaTime); + float nextYVel = (prevYVel + newYVel) * 0.5f; + v.y = nextYVel; + } + else + { + float prevYVel = v.y; + float newYVel = v.y + (gravity * (float)Time.DeltaTime); + float nextYVel = (prevYVel + newYVel) * 0.5f; + v.y = nextYVel; + } + + rb.LinearVelocity = v; + + } + } + + private void GotCaught() + { + if (currentState == RaccoonStates.CAUGHT && tranform != null) + { + currentState = RaccoonStates.IDILE; + tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f); + } + } + + protected override void onCollisionEnter(CollisionInfo info) + { + } + + +} + diff --git a/TempScriptsFolder/PrintWhenActive.cs b/Assets/Scripts/PrintWhenActive.cs similarity index 100% rename from TempScriptsFolder/PrintWhenActive.cs rename to Assets/Scripts/PrintWhenActive.cs diff --git a/TempScriptsFolder/RaccoonShowcase.cs b/Assets/Scripts/RaccoonShowcase.cs similarity index 84% rename from TempScriptsFolder/RaccoonShowcase.cs rename to Assets/Scripts/RaccoonShowcase.cs index da0b89d2..4583a699 100644 --- a/TempScriptsFolder/RaccoonShowcase.cs +++ b/Assets/Scripts/RaccoonShowcase.cs @@ -36,4 +36,10 @@ public class RaccoonShowcase : Script //Transform.LocalRotation = new Vector3(0.0f, rotation, 0.0f); //Transform.LocalScale = new Vector3(System.Math.Abs(System.Math.Sin(scale.x)) * originalScale, System.Math.Abs(System.Math.Cos(scale.y)) * originalScale, System.Math.Abs(System.Math.Sin(scale.z)) * originalScale); } + + protected override void onDrawGizmos() + { + Gizmos.DrawLine(new Vector3(-1.0f, 0.0f, 0.0f), new Vector3(1.0f, 0.0f, 0.0f)); + Gizmos.DrawLine(new Vector3(-1.0f, 1.0f, 0.0f), new Vector3(1.0f, 1.0f, 0.0f), Color.Red); + } } \ No newline at end of file diff --git a/TempScriptsFolder/RaccoonSpin.cs b/Assets/Scripts/RaccoonSpin.cs similarity index 68% rename from TempScriptsFolder/RaccoonSpin.cs rename to Assets/Scripts/RaccoonSpin.cs index c5420ffb..efdfadeb 100644 --- a/TempScriptsFolder/RaccoonSpin.cs +++ b/Assets/Scripts/RaccoonSpin.cs @@ -8,14 +8,23 @@ public class RaccoonSpin : Script private float RotateSpeed = 1.0f; private float rotation = 0.0f; [SerializeField] + private CallbackEvent emptyEvent; + [SerializeField] private CallbackEvent testEvent; [SerializeField] private CallbackEvent testEvent3 = new CallbackEvent(); private Transform Transform; public RaccoonSpin(GameObject gameObj) : base(gameObj) { } + protected override void awake() { + emptyEvent = new CallbackEvent(); + emptyEvent.RegisterAction(() => Debug.Log("Empty event action!")); + testEvent = new CallbackEvent(); + Action action = (x) => Debug.Log($"{x}"); + testEvent.RegisterAction(action); + Transform = GetComponent(); if (Transform == null) { diff --git a/TempScriptsFolder/ThirdPersonCamera.cs b/Assets/Scripts/ThirdPersonCamera.cs similarity index 53% rename from TempScriptsFolder/ThirdPersonCamera.cs rename to Assets/Scripts/ThirdPersonCamera.cs index e3b043bd..141865e8 100644 --- a/TempScriptsFolder/ThirdPersonCamera.cs +++ b/Assets/Scripts/ThirdPersonCamera.cs @@ -11,7 +11,7 @@ namespace SHADE_Scripting public class ThirdPersonCamera: Script { - public float armLength = 4.0f; + public float armLength = 2.0f; public float turnSpeedPitch = 0.3f; public float turnSpeedYaw = 0.5f; public float pitchClamp = 45.0f; @@ -19,10 +19,13 @@ namespace SHADE_Scripting protected override void awake() { + AddComponent(); + if(!GetComponent()) { AddComponent(); } + GetComponent().SetMainCamera(); if (!GetComponent()) { AddComponent(); @@ -30,26 +33,29 @@ namespace SHADE_Scripting GetComponent().ArmLength = armLength; } - protected override void update() - { - CameraArm arm = GetComponent(); - if(arm) + protected override void update() + { + if (Input.GetMouseButton(Input.MouseCode.RightButton)) + { + CameraArm arm = GetComponent(); + if (arm) + { + Vector2 vel = Input.GetMouseVelocity(); + arm.Pitch -= vel.y * turnSpeedPitch * Time.DeltaTimeF; + arm.Yaw += vel.x * turnSpeedYaw * Time.DeltaTimeF; + + if (arm.Pitch > pitchClamp) { - Vector2 vel = Input.GetMouseVelocity(); - arm.Pitch -= vel.y * turnSpeedPitch * Time.DeltaTimeF; - arm.Yaw += vel.x * turnSpeedYaw * Time.DeltaTimeF; - - if(arm.Pitch > pitchClamp) - { - arm.Pitch = pitchClamp; - } - else if(arm.Pitch < -pitchClamp) - { - arm.Pitch = -pitchClamp; - } - + arm.Pitch = pitchClamp; } + else if (arm.Pitch < 0) + { + arm.Pitch = 0; + } + + } } + } } } diff --git a/Assets/Shaders/DebugDraw_FS.glsl b/Assets/Shaders/DebugDraw_FS.glsl new file mode 100644 index 00000000..266f8ad4 --- /dev/null +++ b/Assets/Shaders/DebugDraw_FS.glsl @@ -0,0 +1,17 @@ +#version 450 +#extension GL_ARB_separate_shader_objects : enable +#extension GL_ARB_shading_language_420pack : enable +#extension GL_EXT_nonuniform_qualifier : require + +layout(location = 0) in struct +{ + vec4 vertColor; +} In; + + +layout(location = 0) out vec4 outColor; + +void main() +{ + outColor = In.vertColor; +} \ No newline at end of file diff --git a/Assets/Shaders/DebugDraw_FS.shshaderb b/Assets/Shaders/DebugDraw_FS.shshaderb new file mode 100644 index 00000000..7b596885 Binary files /dev/null and b/Assets/Shaders/DebugDraw_FS.shshaderb differ diff --git a/Assets/Shaders/DebugDraw_FS.shshaderb.shmeta b/Assets/Shaders/DebugDraw_FS.shshaderb.shmeta new file mode 100644 index 00000000..58f62b44 --- /dev/null +++ b/Assets/Shaders/DebugDraw_FS.shshaderb.shmeta @@ -0,0 +1,3 @@ +Name: DebugDraw_FS +ID: 36671027 +Type: 2 diff --git a/Assets/Shaders/DebugDraw_VS.glsl b/Assets/Shaders/DebugDraw_VS.glsl new file mode 100644 index 00000000..cb0886d1 --- /dev/null +++ b/Assets/Shaders/DebugDraw_VS.glsl @@ -0,0 +1,24 @@ +#version 450 +#extension GL_KHR_vulkan_glsl : enable + +layout(location = 0) in vec4 aVertexPos; +layout(location = 1) in vec4 aVertColor; + + +layout(location = 0) out struct +{ + vec4 vertColor; // location 0 + +} Out; + +layout(set = 2, binding = 0) uniform CameraData +{ + vec4 position; + mat4 vpMat; +} cameraData; + +void main() +{ + gl_Position = cameraData.vpMat * vec4 (aVertexPos.xyz, 1.0f); + Out.vertColor = aVertColor; +} \ No newline at end of file diff --git a/Assets/Shaders/DebugDraw_VS.shshaderb b/Assets/Shaders/DebugDraw_VS.shshaderb new file mode 100644 index 00000000..2d8cd0ed Binary files /dev/null and b/Assets/Shaders/DebugDraw_VS.shshaderb differ diff --git a/Assets/Shaders/DebugDraw_VS.shshaderb.shmeta b/Assets/Shaders/DebugDraw_VS.shshaderb.shmeta new file mode 100644 index 00000000..ab840f4c --- /dev/null +++ b/Assets/Shaders/DebugDraw_VS.shshaderb.shmeta @@ -0,0 +1,3 @@ +Name: DebugDraw_VS +ID: 48002439 +Type: 2 diff --git a/Assets/Shaders/DeferredComposite_CS.glsl b/Assets/Shaders/DeferredComposite_CS.glsl index c1caf0aa..5af585ba 100644 --- a/Assets/Shaders/DeferredComposite_CS.glsl +++ b/Assets/Shaders/DeferredComposite_CS.glsl @@ -21,7 +21,8 @@ layout(set = 4, binding = 0, rgba32f) uniform image2D positions; layout(set = 4, binding = 1, rgba32f) uniform image2D normals; layout(set = 4, binding = 2, rgba8) uniform image2D albedo; layout(set = 4, binding = 3, r32ui) uniform uimage2D lightLayerData; -layout(set = 4, binding = 4, rgba8) uniform image2D targetImage; +layout(set = 4, binding = 4, r8) uniform image2D ssaoBlurredImage; +layout(set = 4, binding = 5, rgba8) uniform image2D targetImage; layout(set = 1, binding = 0) uniform LightCounts { @@ -51,33 +52,46 @@ void main() vec3 pixelDiffuse = imageLoad (albedo, globalThread).rgb; // Get position of fragment in world space - vec3 positionWorld = imageLoad (positions, globalThread).rgb; + vec3 positionView = imageLoad (positions, globalThread).rgb; // normal of fragment - vec3 normalWorld = imageLoad(normals, globalThread).rgb; + vec3 normalView = imageLoad(normals, globalThread).rgb; + + // light layer index + uint lightLayer = imageLoad (lightLayerData, globalThread).r; vec3 fragColor = vec3 (0.0f); for (int i = 0; i < lightCounts.directionalLights; ++i) { - // get normalized direction of light - vec3 dLightNormalized = normalize (DirLightData.dLightData[i].direction); + if ((lightLayer & DirLightData.dLightData[i].cullingMask) != 0) + { + // get normalized direction of light + vec3 dLightNormalized = normalize (DirLightData.dLightData[i].direction); - // Get diffuse strength - float diffuseStrength = max (0, dot (dLightNormalized, normalWorld)); + // Get diffuse strength + float diffuseStrength = max (0, dot (dLightNormalized, normalView)); - // Calculate the fragment color - fragColor += DirLightData.dLightData[i].diffuseColor.rgb * diffuseStrength.rrr * pixelDiffuse; + // Calculate the fragment color + fragColor += DirLightData.dLightData[i].diffuseColor.rgb * diffuseStrength.rrr * pixelDiffuse; + } } for (int i = 0; i < lightCounts.ambientLights; ++i) { - // Just do some add - //fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (0.5f); - fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (AmbLightData.aLightData[i].strength); + if ((lightLayer & AmbLightData.aLightData[i].cullingMask) != 0) + { + // Just do some add + //fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (0.5f); + fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (AmbLightData.aLightData[i].strength); + } } + float ssaoVal = imageLoad (ssaoBlurredImage, globalThread).r; + fragColor *= ssaoVal; + // store result into result image - imageStore(targetImage, ivec2(gl_GlobalInvocationID.xy), vec4(fragColor, 1.0f)); + imageStore(targetImage, ivec2(gl_GlobalInvocationID.xy), vec4(fragColor.rgb, 1.0f)); + //imageStore(targetImage, ivec2(gl_GlobalInvocationID.xy), vec4(ssaoVal.rrr, 1.0f)); } \ No newline at end of file diff --git a/Assets/Shaders/DeferredComposite_CS.shshaderb b/Assets/Shaders/DeferredComposite_CS.shshaderb index 4326daf1..172a6a32 100644 Binary files a/Assets/Shaders/DeferredComposite_CS.shshaderb and b/Assets/Shaders/DeferredComposite_CS.shshaderb differ diff --git a/Assets/Shaders/SSAOBlur_CS.glsl b/Assets/Shaders/SSAOBlur_CS.glsl new file mode 100644 index 00000000..64066525 --- /dev/null +++ b/Assets/Shaders/SSAOBlur_CS.glsl @@ -0,0 +1,58 @@ +#version 450 + +#define BLUR_WIDTH 5 +#define BLUR_HALF_WIDTH BLUR_WIDTH / 2 +#define SHM_WIDTH BLUR_WIDTH + 16 - 1 + +layout(local_size_x = 16, local_size_y = 16) in; +layout(set = 4, binding = 0, r8) uniform image2D ssaoImage; +layout(set = 4, binding = 1, r8) uniform image2D ssaoBlurImage; + + +float GetSSAOValue(ivec2 uv, ivec2 imageSize) +{ + if (uv.x >= 0 && uv.y >= 0 && uv.x < imageSize.x && uv.y < imageSize.y) + { + return imageLoad (ssaoImage, uv).r; + } + + return 0.0f; +} + +shared float sharedPixels[16 + BLUR_WIDTH - 1][16 + BLUR_WIDTH - 1]; + +void main() +{ + ivec2 globalThread = ivec2 (gl_GlobalInvocationID.xy); + ivec2 localThread = ivec2 (gl_LocalInvocationID.xy); + ivec2 inputImageSize = imageSize(ssaoImage); + + // Load color into shared memory + ivec2 start = ivec2 (gl_WorkGroupID) * ivec2 (gl_WorkGroupSize) - (BLUR_HALF_WIDTH); + for (int i = localThread.x; i < SHM_WIDTH; i += int (gl_WorkGroupSize.x)) + { + for (int j = localThread.y; j < SHM_WIDTH; j += int (gl_WorkGroupSize.y)) + { + float value = GetSSAOValue (start + ivec2 (i, j), inputImageSize); + sharedPixels[i][j] = value; + } + } + + // wait for all shared memory to load + barrier(); + + ivec2 shmStart = ivec2 (localThread + (BLUR_HALF_WIDTH)); + + float sum = 0; + for (int i = -BLUR_HALF_WIDTH; i <= BLUR_HALF_WIDTH; ++i) + { + for (int j = -BLUR_HALF_WIDTH; j <= BLUR_HALF_WIDTH; ++j) + { + float sharedVal = sharedPixels[shmStart.x + i][shmStart.y + j]; + sum += sharedVal; + } + } + + sum /= (BLUR_WIDTH * BLUR_WIDTH); + imageStore(ssaoBlurImage, globalThread, vec4(sum.rrr, 1.0f)); +} \ No newline at end of file diff --git a/Assets/Shaders/SSAOBlur_CS.shshaderb b/Assets/Shaders/SSAOBlur_CS.shshaderb new file mode 100644 index 00000000..e25b57ba Binary files /dev/null and b/Assets/Shaders/SSAOBlur_CS.shshaderb differ diff --git a/Assets/Shaders/SSAOBlur_CS.shshaderb.shmeta b/Assets/Shaders/SSAOBlur_CS.shshaderb.shmeta new file mode 100644 index 00000000..57bdb72b --- /dev/null +++ b/Assets/Shaders/SSAOBlur_CS.shshaderb.shmeta @@ -0,0 +1,3 @@ +Name: SSAOBlur_CS +ID: 39760835 +Type: 2 diff --git a/Assets/Shaders/SSAO_CS.glsl b/Assets/Shaders/SSAO_CS.glsl new file mode 100644 index 00000000..1a572521 --- /dev/null +++ b/Assets/Shaders/SSAO_CS.glsl @@ -0,0 +1,104 @@ +#version 450 + +const uint NUM_SAMPLES = 64; +const uint NUM_ROTATIONS = 16; +const int ROTATION_KERNEL_W = 4; +const int ROTATION_KERNEL_H = 4; + +// can perhaps pass in as push constant. +const float RADIUS = 0.5f; +const float BIAS = 0.025f; + +layout(local_size_x = 16, local_size_y = 16) in; +layout(set = 4, binding = 0, rgba32f) uniform image2D positions; +layout(set = 4, binding = 1, rgba32f) uniform image2D normals; +layout(set = 4, binding = 2, rgba32f) uniform image2D outputImage; + + +// SSAO data +layout(std430, set = 5, binding = 0) buffer SSAOData +{ + vec4 samples[NUM_SAMPLES]; + +} ssaoData; + +layout (set = 5, binding = 1) uniform sampler2D noiseTexture; + +layout(set = 2, binding = 0) uniform CameraData +{ + vec4 position; + mat4 vpMat; + mat4 viewMat; + mat4 projMat; + +} cameraData; + + +void main() +{ + // image size of the SSAO image + ivec2 ssaoSize = imageSize (outputImage); + + // global thread + ivec2 globalThread = ivec2 (gl_GlobalInvocationID.xy); + + // load all the necessary variables + vec3 viewSpacePos = imageLoad (positions, globalThread).rgb; + vec3 viewSpaceNormal = normalize (imageLoad (normals, globalThread).rgb); + + // Get the noise dimension. This should be 4x4 + vec2 noiseDim = vec2 (textureSize(noiseTexture, 0)); + + // Get normlized thread UV coordinates + vec2 threadUV = (vec2(globalThread)) / vec2(ssaoSize); + vec2 noiseUVMult = vec2 (vec2(ssaoSize) / noiseDim); + noiseUVMult *= threadUV; + + // sample from the noise + vec3 randomVec = texture(noiseTexture, noiseUVMult).rgb; + + // Gram schmidt + vec3 tangent = normalize (randomVec - (viewSpaceNormal * dot(viewSpaceNormal, randomVec))); + vec3 bitangent = normalize (cross (tangent, viewSpaceNormal)); + + // matrix for tangent space to view space + mat3 TBN = mat3(tangent, bitangent, viewSpaceNormal); + + float occlusion = 0.0f; + for (int i = 0; i < NUM_SAMPLES; ++i) + { + // We want to get a position at an offset from the view space position. Offset scaled by radius. + vec3 displacementVector = TBN * ssaoData.samples[i].rgb; + + // Why are we adding positions? + displacementVector = viewSpacePos + displacementVector * RADIUS; + + // Now we take that offset position and bring it to clip space + vec4 offsetPos = vec4 (displacementVector, 1.0f); + offsetPos = cameraData.projMat * offsetPos; + + // then we do perspective division + offsetPos.xyz /= offsetPos.w; + + // and bring it from [-1, 1] to screen coordinates + offsetPos.xyz = ((offsetPos.xyz * 0.5f) + 0.5f); + offsetPos.xy *= vec2(ssaoSize.xy); + + // Now we attempt to get a position at that point. + float sampleDepth = imageLoad (positions, ivec2 (offsetPos.xy)).z; + + // skip checks + if (sampleDepth == 0.0f) + continue; + + // if sampled fragment is in front of current fragment, just occlude + float rangeCheck = smoothstep (0.0f, 1.0f, RADIUS / abs (viewSpacePos.z - sampleDepth)); + occlusion += (sampleDepth <= displacementVector.z - BIAS ? 1.0f : 0.0f) * rangeCheck; + } + + occlusion = 1.0f - (occlusion / float(NUM_SAMPLES)); + + // store result into result image + imageStore(outputImage, globalThread, occlusion.rrrr); + +} \ No newline at end of file diff --git a/Assets/Shaders/SSAO_CS.shshaderb b/Assets/Shaders/SSAO_CS.shshaderb new file mode 100644 index 00000000..69f7a44f Binary files /dev/null and b/Assets/Shaders/SSAO_CS.shshaderb differ diff --git a/Assets/Shaders/SSAO_CS.shshaderb.shmeta b/Assets/Shaders/SSAO_CS.shshaderb.shmeta new file mode 100644 index 00000000..9a477b24 --- /dev/null +++ b/Assets/Shaders/SSAO_CS.shshaderb.shmeta @@ -0,0 +1,3 @@ +Name: SSAO_CS +ID: 38430899 +Type: 2 diff --git a/Assets/Shaders/TestCube_FS.glsl b/Assets/Shaders/TestCube_FS.glsl index c60da6ce..d6f88687 100644 --- a/Assets/Shaders/TestCube_FS.glsl +++ b/Assets/Shaders/TestCube_FS.glsl @@ -43,7 +43,7 @@ void main() { position = In.vertPos; normals = In.normal; - albedo = texture(textures[nonuniformEXT(MatProp.data[In2.materialIndex].textureIndex)], In.uv) + MatProp.data[In2.materialIndex].color / MatProp.data[In2.materialIndex].alpha; + albedo = texture(textures[nonuniformEXT(MatProp.data[In2.materialIndex].textureIndex)], In.uv) * MatProp.data[In2.materialIndex].color; outEntityID = In2.eid; lightLayerIndices = In2.lightLayerIndex; diff --git a/Assets/Shaders/TestCube_FS.shshaderb b/Assets/Shaders/TestCube_FS.shshaderb index 95b4f62a..bcf5bf5e 100644 Binary files a/Assets/Shaders/TestCube_FS.shshaderb and b/Assets/Shaders/TestCube_FS.shshaderb differ diff --git a/Assets/Shaders/TestCube_VS.glsl b/Assets/Shaders/TestCube_VS.glsl index 49f107dd..0e055395 100644 --- a/Assets/Shaders/TestCube_VS.glsl +++ b/Assets/Shaders/TestCube_VS.glsl @@ -33,18 +33,31 @@ layout(set = 2, binding = 0) uniform CameraData { vec4 position; mat4 vpMat; + mat4 viewMat; + mat4 projMat; } cameraData; void main() { - Out2.materialIndex = gl_InstanceIndex; Out2.eid = integerData[0]; Out2.lightLayerIndex = integerData[1]; - Out.vertPos = worldTransform * vec4(aVertexPos, 1.0f); + // for transforming gBuffer position and normal data + mat4 modelViewMat = cameraData.viewMat * worldTransform; + + // gBuffer position will be in view space + Out.vertPos = modelViewMat * vec4(aVertexPos, 1.0f); + + // uvs for texturing in fragment shader Out.uv = aUV; - Out.normal.rgb = mat3(transpose(inverse(worldTransform))) * aNormal.rgb; + + mat3 transposeInv = mat3 (transpose(inverse(modelViewMat))); + + // normals are also in view space + Out.normal.rgb = transposeInv * aNormal.rgb; Out.normal.rgb = normalize (Out.normal.rgb); + + // clip space for rendering gl_Position = cameraData.vpMat * worldTransform * vec4 (aVertexPos, 1.0f); } \ No newline at end of file diff --git a/Assets/Shaders/TestCube_VS.shshaderb b/Assets/Shaders/TestCube_VS.shshaderb index 7a7b047a..fb282b4d 100644 Binary files a/Assets/Shaders/TestCube_VS.shshaderb and b/Assets/Shaders/TestCube_VS.shshaderb differ diff --git a/Dependencies.bat b/Dependencies.bat index 1d4a3473..44185ff8 100644 --- a/Dependencies.bat +++ b/Dependencies.bat @@ -7,7 +7,7 @@ echo "SHADE DEPENDENCIES (Default - All in 10 Seconds)" echo "A - All" echo "B - VMA" echo "C - msdf" -echo "D - assimp" +echo "D - ModelCompiler" echo "E - spdlog" echo "F - reactphysics3d" echo "G - imgui" @@ -29,7 +29,7 @@ set _e=%ERRORLEVEL% if %_e%==1 goto VMA if %_e%==2 goto VMA if %_e%==3 goto MSDF -if %_e%==4 goto assimp +if %_e%==4 goto ModelCompiler if %_e%==5 goto spdlog if %_e%==6 goto reactphysics3d if %_e%==7 goto imgui @@ -53,12 +53,13 @@ if %_e%==2 (goto :done) else (goto :MSDF) echo -----------------------MSDF---------------------------- rmdir "Dependencies/msdf" /S /Q git clone --recurse-submodules https://github.com/SHADE-DP/msdf-atlas-gen.git "Dependencies/msdf" -if %_e%==3 (goto :done) else (goto :assimp) +if %_e%==3 (goto :done) else (goto :ModelCompiler) -:assimp -echo -----------------------assimp---------------------------- -rmdir "Dependencies/assimp" /S /Q -git clone https://github.com/SHADE-DP/assimp.git "Dependencies/assimp" +:ModelCompiler +echo -----------------------ModelCompiler---------------------------- +rmdir "Dependencies/ModelCompiler" /S /Q +git clone https://github.com/SHADE-DP/ModelCompiler.git "Dependencies/ModelCompiler" +git clone https://github.com/SHADE-DP/assimp.git "Dependencies/ModelCompiler/Dependencies/assimp" if %_e%==4 (goto :done) else (goto :spdlog) @REM :ktx diff --git a/Dependencies.lua b/Dependencies.lua index 6dd7a711..2e24222b 100644 --- a/Dependencies.lua +++ b/Dependencies.lua @@ -1,5 +1,5 @@ IncludeDir = {} -IncludeDir["assimp"] = "%{wks.location}\\Dependencies\\assimp" +IncludeDir["ModelCompiler"] = "%{wks.location}\\Dependencies\\ModelCompiler" IncludeDir["imgui"] = "%{wks.location}\\Dependencies\\imgui" IncludeDir["imguizmo"] = "%{wks.location}\\Dependencies\\imguizmo" IncludeDir["imnodes"] = "%{wks.location}\\Dependencies\\imnodes" diff --git a/SHADE_Application/src/Application/SBApplication.cpp b/SHADE_Application/src/Application/SBApplication.cpp index a4fef1fa..6b67dbce 100644 --- a/SHADE_Application/src/Application/SBApplication.cpp +++ b/SHADE_Application/src/Application/SBApplication.cpp @@ -31,6 +31,7 @@ #include "FRC/SHFramerateController.h" #include "AudioSystem/SHAudioSystem.h" #include "Camera/SHCameraSystem.h" +#include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" // Components #include "Graphics/MiddleEnd/Interface/SHRenderable.h" @@ -40,8 +41,11 @@ #include "Assets/SHAssetManager.h" +#include "Scenes/SBMainScene.h" +#include "Serialization/Configurations/SHConfigurationManager.h" #include "Tools/SHLogger.h" +#include "Tools/SHDebugDraw.h" using namespace SHADE; @@ -58,8 +62,9 @@ namespace Sandbox { // Set working directory SHFileUtilities::SetWorkDirToExecDir(); - - window.Create(hInstance, hPrevInstance, lpCmdLine, nCmdShow); + WindowData wndData{}; + auto& appConfig = SHConfigurationManager::LoadApplicationConfig(&wndData); + window.Create(hInstance, hPrevInstance, lpCmdLine, nCmdShow, wndData); // Create Systems SHSystemManager::CreateSystem(); @@ -69,12 +74,20 @@ namespace Sandbox SHGraphicsSystem* graphicsSystem = static_cast(SHSystemManager::GetSystem()); SHSystemManager::CreateSystem(); SHSystemManager::CreateSystem(); + SHSystemManager::CreateSystem(); + + // Link up SHDebugDraw + SHDebugDraw::Init(SHSystemManager::GetSystem()); #ifdef SHEDITOR SDL_Init(SDL_INIT_VIDEO); sdlWindow = SDL_CreateWindowFrom(window.GetHWND()); SHSystemManager::CreateSystem(); - SHSystemManager::GetSystem()->SetSDLWindow(sdlWindow); + if(auto editor = SHSystemManager::GetSystem()) + { + editor->SetSDLWindow(sdlWindow); + editor->SetSHWindow(&window); + } #endif // Create Routines @@ -88,9 +101,12 @@ namespace Sandbox SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); + SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); + SHSystemManager::RegisterRoutine(); + SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); @@ -120,9 +136,12 @@ namespace Sandbox SHSystemManager::Init(); - SHSceneManager::InitSceneManager("TestScene"); + SHSceneManager::InitSceneManager(appConfig.startingSceneID); SHFrameRateController::UpdateFRC(); + + // Link up SHDebugDraw + SHDebugDraw::Init(SHSystemManager::GetSystem()); } void SBApplication::Update(void) @@ -141,6 +160,13 @@ namespace Sandbox #endif SHSystemManager::RunRoutines(editor->editorState != SHEditor::State::PLAY, 0.016f); editor->PollPicking(); + + static bool drawColliders = false; + if (SHInputManager::GetKeyDown(SHInputManager::SH_KEYCODE::F10)) + { + drawColliders = !drawColliders; + SHSystemManager::GetSystem()->SetDrawColliders(drawColliders); + } } // Finish all graphics jobs first graphicsSystem->AwaitGraphicsExecution(); diff --git a/SHADE_Application/src/Scenes/SBMainScene.cpp b/SHADE_Application/src/Scenes/SBMainScene.cpp new file mode 100644 index 00000000..34190915 --- /dev/null +++ b/SHADE_Application/src/Scenes/SBMainScene.cpp @@ -0,0 +1,62 @@ + #include "SBpch.h" +#include "SBMainScene.h" + +#include "ECS_Base/Managers/SHSystemManager.h" +#include "Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h" +#include "ECS_Base/Managers/SHEntityManager.h" +#include "Graphics/MiddleEnd/Interface/SHRenderable.h" +#include "Scene/SHSceneManager.h" +#include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h" +#include "Scripting/SHScriptEngine.h" +#include "Math/Transform/SHTransformComponent.h" +#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" +#include "Physics/Components/SHRigidBodyComponent.h" +#include "Physics/Components/SHColliderComponent.h" +#include "Graphics/MiddleEnd/Lights/SHLightComponent.h" + +#include "Assets/SHAssetManager.h" +#include "Camera/SHCameraComponent.h" +#include "Resource/SHResourceManager.h" +#include "Serialization/SHSerialization.h" + + using namespace SHADE; + +namespace Sandbox +{ + + void SBMainScene::WindowFocusFunc([[maybe_unused]] void* window, int focused) + { + if (focused) + { + } + else + { + } + } + + void SBMainScene::Load() + { + } + + void SBMainScene::Init() + { + sceneName = SHSerialization::DeserializeSceneFromFile(sceneAssetID); + } + + void SBMainScene::Update(float dt) + { + } + + void SBMainScene::Render() + { + } + + void SBMainScene::Unload() + { + } + + void SBMainScene::Free() + { + //SHSerialization::SerializeScene("resources/scenes/Scene01.SHADE"); + } +} diff --git a/SHADE_Application/src/Scenes/SBMainScene.h b/SHADE_Application/src/Scenes/SBMainScene.h new file mode 100644 index 00000000..7bd10118 --- /dev/null +++ b/SHADE_Application/src/Scenes/SBMainScene.h @@ -0,0 +1,30 @@ +#pragma once + +#include "Scene/SHScene.h" +#include "Scene/SHSceneManager.h" + +namespace Sandbox +{ + class SBMainScene : public SHADE::SHScene + { + private: + EntityID camera; + EntityID testObj; + std::vector stressTestObjects; + + public: + virtual void Load(); + virtual void Init(); + virtual void Update(float dt); + virtual void Render(); + virtual void Free(); + virtual void Unload(); + + //TODO: Change to new window DO IT IN CPP TOO + void WindowFocusFunc(void* window, int focused); + + SBMainScene(void) = default; + }; + +} + diff --git a/SHADE_Application/src/Scenes/SBTestScene.cpp b/SHADE_Application/src/Scenes/SBTestScene.cpp index db58c21e..8281f114 100644 --- a/SHADE_Application/src/Scenes/SBTestScene.cpp +++ b/SHADE_Application/src/Scenes/SBTestScene.cpp @@ -18,6 +18,8 @@ #include "Camera/SHCameraComponent.h" #include "Math/SHColour.h" #include "Resource/SHResourceManager.h" +#include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" +#include "Tools/SHDebugDraw.h" using namespace SHADE; @@ -51,7 +53,7 @@ namespace Sandbox switch (asset.type) { case AssetType::MESH: - if (asset.name == "Cube.012") + if (asset.name == "Raccoon") handles.emplace_back(SHResourceManager::LoadOrGet(asset.id)); break; case AssetType::TEXTURE: @@ -63,58 +65,20 @@ namespace Sandbox SHResourceManager::FinaliseChanges(); // Create Materials - auto matInst = graphicsSystem->AddOrGetBaseMaterialInstance(); - auto customMat = graphicsSystem->AddMaterialInstanceCopy(matInst); - customMat->SetProperty("data.color", SHVec4(0.0f, 1.0f, 1.0f, 1.0f)); - customMat->SetProperty("data.textureIndex", 0); - customMat->SetProperty("data.alpha", 0.1f); + auto baseRaccoonMat = graphicsSystem->AddOrGetBaseMaterialInstance(); + auto baseRaccoonMatInstant = graphicsSystem->AddMaterialInstanceCopy(baseRaccoonMat); + baseRaccoonMatInstant->SetProperty("data.color", SHVec4(1.0f, 1.0f, 1.0f, 1.0f)); + baseRaccoonMatInstant->SetProperty("data.textureIndex", 0); + baseRaccoonMatInstant->SetProperty("data.alpha", 0.1f); - // Create Stress Test Objects - static const SHVec3 TEST_OBJ_SCALE = SHVec3::One; - constexpr int NUM_ROWS = 3; - constexpr int NUM_COLS = 1; - static const SHVec3 TEST_OBJ_SPACING = { 0.1f, 0.1f, 0.1f }; - static const SHVec3 TEST_OBJ_START_POS = { -(NUM_COLS / 2 * TEST_OBJ_SPACING.x) + 1.0f, -2.0f, -1.0f }; + auto baseFloorMatInstant = graphicsSystem->AddMaterialInstanceCopy(baseRaccoonMat); + baseFloorMatInstant->SetProperty("data.color", SHVec4(1.0f, 1.0f, 1.0f, 1.0f)); + baseFloorMatInstant->SetProperty("data.textureIndex", 0); + baseFloorMatInstant->SetProperty("data.alpha", 0.1f); - for (int y = 0; y < NUM_ROWS; ++y) - for (int x = 0; x < NUM_COLS; ++x) - { - auto entity = SHEntityManager::CreateEntity(); - auto& renderable = *SHComponentManager::GetComponent_s(entity); - auto& transform = *SHComponentManager::GetComponent_s(entity); - auto& collider = *SHComponentManager::GetComponent_s(entity); + auto dummy = SHEntityManager::CreateEntity<>(); - //renderable.Mesh = handles.front(); - renderable.SetMesh(CUBE_MESH); - renderable.SetMaterial(customMat); - - if (y == 50) - renderable.GetModifiableMaterial()->SetProperty("data.color", SHVec4(1.0f, 0.0f, 0.0f, 1.0f)); - - //Set initial positions - transform.SetWorldPosition(TEST_OBJ_START_POS + SHVec3{ x * TEST_OBJ_SPACING.x, y * TEST_OBJ_SPACING.y, SHMath::GenerateRandomNumber(-3.5f, -5.0f) }); - //transform.SetWorldPosition({-1.0f, -1.0f, -1.0f}); - transform.SetWorldRotation(SHMath::GenerateRandomNumber(0.0f, 360.0f), SHMath::GenerateRandomNumber(0.0f, 360.0f), SHMath::GenerateRandomNumber(0.0f, 360.0f)); - transform.SetWorldScale(TEST_OBJ_SCALE); - - collider.AddBoundingBox(SHVec3::One, SHVec3::Zero); - stressTestObjects.emplace_back(entity); - } - - auto raccoonSpin = SHEntityManager::CreateEntity(); - auto& renderable = *SHComponentManager::GetComponent_s(raccoonSpin); - auto& transform = *SHComponentManager::GetComponent_s(raccoonSpin); - - renderable.SetMesh(handles.front()); - renderable.SetMaterial(customMat); - renderable.GetModifiableMaterial()->SetProperty("data.color", SHVec4(0.0f, 0.0f, 0.0f, 0.0f)); - renderable.GetModifiableMaterial()->SetProperty("data.alpha", 1.0f); - renderable.GetModifiableMaterial()->SetProperty("data.textureIndex", 0); - - transform.SetWorldPosition({ -3.0f, -1.0f, -1.0f }); - transform.SetLocalScale({ 5.0f, 5.0f, 5.0f }); - - auto floor = SHEntityManager::CreateEntity(); + auto floor = SHEntityManager::CreateEntity(); auto& floorRenderable = *SHComponentManager::GetComponent_s(floor); auto& floorTransform = *SHComponentManager::GetComponent_s(floor); auto& floorRigidBody = *SHComponentManager::GetComponent_s(floor); @@ -123,12 +87,12 @@ namespace Sandbox floorRenderable.SetMesh(CUBE_MESH); floorRenderable.SetMaterial(graphicsSystem->GetDefaultMaterialInstance()); - floorTransform.SetWorldScale({ 7.5f, 0.5f, 7.5 }); + floorTransform.SetWorldScale({ 17.5f, 0.5f, 17.5f }); floorTransform.SetWorldPosition({ 0.0f, -3.0f, -5.0f }); floorRigidBody.SetType(SHRigidBodyComponent::Type::STATIC); - auto* floorBox = floorCollider.AddBoundingBox(); + floorCollider.AddBoundingBox(); // Create blank entity with a script //testObj = SHADE::SHEntityManager::CreateEntity(); @@ -136,17 +100,97 @@ namespace Sandbox //testObjRenderable.Mesh = CUBE_MESH; //testObjRenderable.SetMaterial(matInst); + //raccoon ======================================================================================================================= + auto racoon = SHEntityManager::CreateEntity(MAX_EID, "Player"); + auto& racoonRenderable = *SHComponentManager::GetComponent_s(racoon); + auto& racoonTransform = *SHComponentManager::GetComponent_s(racoon); + auto& racoonRigidBody = *SHComponentManager::GetComponent_s(racoon); + auto& racoonCollider = *SHComponentManager::GetComponent_s(racoon); + + racoonRenderable.SetMesh(handles.front()); + racoonRenderable.SetMaterial(baseRaccoonMatInstant); + + racoonTransform.SetWorldScale({ 2.0f, 2.0f, 2.0f }); + racoonTransform.SetWorldPosition({ -3.0f, -2.0f, -5.0f }); + + racoonCollider.AddBoundingBox(); + racoonCollider.GetCollisionShape(0).SetPositionOffset(SHVec3(0.0f,0.5f,0.0f)); + racoonCollider.GetCollisionShape(0).SetBoundingBox(SHVec3(0.5f, 0.5f, 0.5f)); + + auto racoonItemLocation = SHEntityManager::CreateEntity(); + auto& racoonItemLocationTransform = *SHComponentManager::GetComponent_s(racoonItemLocation); + SHSceneManager::GetCurrentSceneGraph().SetParent(racoonItemLocation, racoon); + + auto racoonCamera = SHEntityManager::CreateEntity(); + SHSceneManager::GetCurrentSceneGraph().SetParent(racoonCamera, racoon); + //================================================================================================================================ + + //item =========================================================================================================================== + auto item = SHEntityManager::CreateEntity(MAX_EID, "item"); + auto& itemRenderable = *SHComponentManager::GetComponent_s(item); + auto& itemTransform = *SHComponentManager::GetComponent_s(item); + auto& itemRigidBody = *SHComponentManager::GetComponent_s(item); + auto& itemCollider = *SHComponentManager::GetComponent_s(item); + + itemRenderable.SetMesh(handles.front()); + itemRenderable.SetMaterial(baseRaccoonMatInstant); + + itemTransform.SetWorldScale({ 2.0f, 2.0f, 2.0f }); + itemTransform.SetWorldPosition({ 0.0f, -2.0f, -5.0f }); + + itemCollider.AddBoundingBox(); + itemCollider.AddBoundingBox(SHVec3(2.0f,2.0f,2.0f)); + itemCollider.GetCollisionShape(1).SetIsTrigger(true); + + itemCollider.GetCollisionShape(0).SetPositionOffset(SHVec3(0.0f, 0.5f, 0.0f)); + itemCollider.GetCollisionShape(0).SetBoundingBox(SHVec3(0.5f, 0.5f, 0.5f)); + + itemCollider.GetCollisionShape(1).SetPositionOffset(SHVec3(0.0f, 0.5f, 0.0f)); + itemCollider.GetCollisionShape(1).SetBoundingBox(SHVec3(1.0f, 1.0f, 1.0f)); + + itemRigidBody.SetInterpolate(false); + itemRigidBody.SetFreezeRotationX(true); + itemRigidBody.SetFreezeRotationY(true); + itemRigidBody.SetFreezeRotationZ(true); + //================================================================================================================================ + + //AI ============================================================================================================================= + auto AI = SHEntityManager::CreateEntity(MAX_EID, "AI"); + auto& AIRenderable = *SHComponentManager::GetComponent_s(AI); + auto& AITransform = *SHComponentManager::GetComponent_s(AI); + auto& AIRigidBody = *SHComponentManager::GetComponent_s(AI); + auto& AICollider = *SHComponentManager::GetComponent_s(AI); + + AIRenderable.SetMesh(handles.front()); + AIRenderable.SetMaterial(baseRaccoonMatInstant); + + AITransform.SetWorldScale({ 2.0f, 2.0f, 2.0f }); + AITransform.SetWorldPosition({ -8.0f, -2.0f, 2.5f }); + + AICollider.AddBoundingBox(); + AICollider.GetCollisionShape(0).SetPositionOffset(SHVec3(0.0f, 0.5f, 0.0f)); + AICollider.GetCollisionShape(0).SetBoundingBox(SHVec3(0.5f, 0.5f, 0.5f)); + + AIRigidBody.SetInterpolate(false); + AIRigidBody.SetFreezeRotationX(true); + AIRigidBody.SetFreezeRotationY(true); + AIRigidBody.SetFreezeRotationZ(true); + //================================================================================================================================ SHADE::SHScriptEngine* scriptEngine = static_cast(SHADE::SHSystemManager::GetSystem()); - scriptEngine->AddScript(raccoonSpin, "RaccoonSpin"); + scriptEngine->AddScript(racoon, "PlayerController"); + scriptEngine->AddScript(racoon, "PickAndThrow"); + scriptEngine->AddScript(racoonCamera, "ThirdPersonCamera"); + scriptEngine->AddScript(AI, "AIPrototype"); + scriptEngine->AddScript(item, "Item"); auto raccoonShowcase = SHEntityManager::CreateEntity(); auto& renderableShowcase = *SHComponentManager::GetComponent_s(raccoonShowcase); auto& transformShowcase = *SHComponentManager::GetComponent_s(raccoonShowcase); renderableShowcase.SetMesh(handles.front()); - renderableShowcase.SetMaterial(customMat); - renderableShowcase.GetModifiableMaterial()->SetProperty("data.color", SHVec4(0.0f, 0.0f, 0.0f, 0.0f)); + renderableShowcase.SetMaterial(baseRaccoonMatInstant); + renderableShowcase.GetModifiableMaterial()->SetProperty("data.color", SHVec4(1.0f, 1.0f, 1.0f, 1.0f)); renderableShowcase.GetModifiableMaterial()->SetProperty("data.alpha", 1.0f); renderableShowcase.GetModifiableMaterial()->SetProperty("data.textureIndex", 0); @@ -187,6 +231,8 @@ namespace Sandbox SHADE::SHScriptEngine* scriptEngine = static_cast(SHADE::SHSystemManager::GetSystem()); scriptEngine->RemoveAllScripts(testObj); } + + SHDebugDraw::Cube(SHColour::CRIMSON, SHVec3(1.0f, 0.0f, 0.0f), SHVec3(1.0f, 1.0f, 1.0f)); } void SBTestScene::Render() diff --git a/SHADE_CSharp/src/Events/CallbackAction.cs b/SHADE_CSharp/src/Events/CallbackAction.cs index 623e4f59..b6082c0c 100644 --- a/SHADE_CSharp/src/Events/CallbackAction.cs +++ b/SHADE_CSharp/src/Events/CallbackAction.cs @@ -34,6 +34,99 @@ namespace SHADE Object TargetObject { get; } } + /// + /// Represents a function call that can be serialised and put togetheer with scripts. + /// This variant accepts functions with 0 parameter. + /// + public class CallbackAction : ICallbackAction + { + #region Properties ------------------------------------------------------------ + /// + public Object TargetObject { get; private set; } + /// + public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name; + /// + public bool IsRuntimeAction => targetAction != null; + #endregion + + #region Fields ------------------------------------------------------------------ + private MethodInfo targetMethod; + private Action targetAction; + private Object[] parameters; + #endregion + + #region Constructors ------------------------------------------------------------ + /// + /// Constructs an empty Callback action. + /// + public CallbackAction() {} + /// + /// Constructs a CallbackAction that represents a call to the specified static + /// method. + /// + /// Method to call. + /// + /// Thrown if a method that is not compatible with the target is specified. The method's + /// source type must match the target's type. + /// + public CallbackAction(MethodInfo method) + { + // No errors, assign + targetMethod = method; + + // Create storage for parameters for calling + parameters = new Object[0]; + } + /// + /// Constructs a CallbackAction that represents a call to a specified member + /// method on the specified target. + /// + /// Object to call the method on. + /// Method to call. + /// + /// Thrown if a method that is not compatible with the target is specified. The method's + /// source type must match the target's type. + /// + public CallbackAction(Object target, MethodInfo method) + { + // Error Checks + if (method.DeclaringType != target.GetType()) + throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method."); + + // No errors, assign + TargetObject = target; + targetMethod = method; + + // Create storage for parameters for calling + parameters = new Object[0]; + } + /// + /// Constructs a Callback action based on an action. + /// + /// Action that wraps a function to be called. + public CallbackAction(Action action) + { + targetAction = action; + } + #endregion + + #region Usage Functions --------------------------------------------------------- + /// + /// Invokes the CallbackAction's stored method/action with the specified parameters. + /// + public void Invoke() + { + if (targetAction != null) + { + targetAction.Invoke(); + } + else if (targetMethod != null) + { + _ = targetMethod.Invoke(TargetObject, parameters); + } + } + #endregion + } /// /// Represents a function call that can be serialised and put togetheer with scripts. /// This variant accepts functions with 1 parameter. diff --git a/SHADE_CSharp/src/Events/CallbackAction.tt b/SHADE_CSharp/src/Events/CallbackAction.tt index 34789b67..3fbb7617 100644 --- a/SHADE_CSharp/src/Events/CallbackAction.tt +++ b/SHADE_CSharp/src/Events/CallbackAction.tt @@ -50,12 +50,12 @@ namespace SHADE Object TargetObject { get; } } -<# for (int i = 1; i <= max; ++i) { #> +<# for (int i = 0; i <= max; ++i) { #> /// /// Represents a function call that can be serialised and put togetheer with scripts. /// This variant accepts functions with <#=i#> parameter<# if (i > 1) {#>s<#} #>. /// - public class CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> : ICallbackAction + public class CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> : ICallbackAction { #region Properties ------------------------------------------------------------ /// @@ -68,7 +68,7 @@ namespace SHADE #region Fields ------------------------------------------------------------------ private MethodInfo targetMethod; - private Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> targetAction; + private Action<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> targetAction; private Object[] parameters; #endregion @@ -121,7 +121,7 @@ namespace SHADE /// Constructs a Callback action based on an action. /// /// Action that wraps a function to be called. - public CallbackAction(Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action) + public CallbackAction(Action<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> action) { targetAction = action; } diff --git a/SHADE_CSharp/src/Events/CallbackEvent.cs b/SHADE_CSharp/src/Events/CallbackEvent.cs index ec464ba9..2c3cc388 100644 --- a/SHADE_CSharp/src/Events/CallbackEvent.cs +++ b/SHADE_CSharp/src/Events/CallbackEvent.cs @@ -45,6 +45,92 @@ namespace SHADE IEnumerable Actions { get; } } + /// + /// A container of CallbackActions that is correlated to a specific scenario as + /// specified by the user of this class. + /// This variant accepts CallbackEvents with 1 generic parameter. + /// + public class CallbackEvent : ICallbackEvent + { + #region Properties -------------------------------------------------------------- + /// + public IEnumerable Actions => actions; + #endregion + + #region Fields ------------------------------------------------------------------ + private List actions = new List(); + #endregion + + #region Usage Functions --------------------------------------------------------- + /// + public void RegisterAction() + { + actions.Add(new CallbackAction()); + } + /// + public void RegisterAction(ICallbackAction action) + { + // Check if valid action + if (action.GetType() != typeof(CallbackAction)) + { + Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this); + return; + } + + actions.Add(action); + } + /// + /// Adds a CallbackAction into the event. + /// + /// CallbackAction to add. + public void RegisterAction(CallbackAction action) + { + actions.Add(action); + } + /// + /// Constructs and adds a CallbackAction into the event. + /// + /// System.Action to add as a CallbackAction. + public void RegisterAction(Action action) + { + actions.Add(new CallbackAction(action)); + } + /// + /// Constructs and adds a CallbackAction into the event. + /// + /// Object to call the method on. + /// Method to call. + public void RegisterAction(Object target, MethodInfo method) + { + actions.Add(new CallbackAction(target, method)); + } + /// + public void DeregisterAction(ICallbackAction action) + { + if (!actions.Remove(action)) + { + Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this); + } + } + /// + /// Invokes all stored CallbackActions with the specified parameters. + /// + public void Invoke() + { + foreach (CallbackAction action in actions) + { + try + { + action.Invoke(); + } + catch (Exception e) + { + Debug.LogException(e, this); + } + } + } + #endregion + } /// /// A container of CallbackActions that is correlated to a specific scenario as /// specified by the user of this class. @@ -88,7 +174,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -96,7 +182,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -174,7 +260,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -182,7 +268,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -260,7 +346,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -268,7 +354,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -346,7 +432,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -354,7 +440,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -432,7 +518,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -440,7 +526,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -518,7 +604,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -526,7 +612,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -604,7 +690,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -612,7 +698,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -690,7 +776,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -698,7 +784,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -776,7 +862,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -784,7 +870,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. @@ -862,7 +948,7 @@ namespace SHADE actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. public void RegisterAction(Action action) @@ -870,7 +956,7 @@ namespace SHADE actions.Add(new CallbackAction(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. diff --git a/SHADE_CSharp/src/Events/CallbackEvent.tt b/SHADE_CSharp/src/Events/CallbackEvent.tt index 6a545601..66a8b6d9 100644 --- a/SHADE_CSharp/src/Events/CallbackEvent.tt +++ b/SHADE_CSharp/src/Events/CallbackEvent.tt @@ -61,13 +61,13 @@ namespace SHADE IEnumerable Actions { get; } } -<# for (int i = 1; i <= max; ++i) { #> +<# for (int i = 0; i <= max; ++i) { #> /// /// A container of CallbackActions that is correlated to a specific scenario as /// specified by the user of this class. /// This variant accepts CallbackEvents with 1 generic parameter. /// - public class CallbackEvent<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> : ICallbackEvent + public class CallbackEvent<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> : ICallbackEvent { #region Properties -------------------------------------------------------------- /// @@ -82,13 +82,13 @@ namespace SHADE /// public void RegisterAction() { - actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>()); + actions.Add(new CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #>()); } /// public void RegisterAction(ICallbackAction action) { // Check if valid action - if (action.GetType() != typeof(CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>)) + if (action.GetType() != typeof(CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #>)) { Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this); return; @@ -100,26 +100,26 @@ namespace SHADE /// Adds a CallbackAction into the event. /// /// CallbackAction to add. - public void RegisterAction(CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action) + public void RegisterAction(CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> action) { actions.Add(action); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// System.Action to add as a CallbackAction. - public void RegisterAction(Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action) + public void RegisterAction(Action<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> action) { - actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>(action)); + actions.Add(new CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #>(action)); } /// - /// Constructs and adds a CallbackACtion into the event. + /// Constructs and adds a CallbackAction into the event. /// /// Object to call the method on. /// Method to call. public void RegisterAction(Object target, MethodInfo method) { - actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>(target, method)); + actions.Add(new CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #>(target, method)); } /// public void DeregisterAction(ICallbackAction action) @@ -132,9 +132,9 @@ namespace SHADE /// /// Invokes all stored CallbackActions with the specified parameters. /// - public void Invoke(<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#> t<#=t#><# if (t != i) { #>, <# } #><# } #>) + public void Invoke(<# if (i != 0) { for (int t = 1; t < i + 1; ++t) { #>T<#=t#> t<#=t#><# if (t != i) { #>, <# } #><# } } #>) { - foreach (CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action in actions) + foreach (CallbackAction<# if (i != 0) { #><<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>><# } #> action in actions) { try { diff --git a/SHADE_Engine/premake5.lua b/SHADE_Engine/premake5.lua index bc1f6a03..42f95520 100644 --- a/SHADE_Engine/premake5.lua +++ b/SHADE_Engine/premake5.lua @@ -26,7 +26,6 @@ project "SHADE_Engine" externalincludedirs { - "%{IncludeDir.assimp}\\include", "%{IncludeDir.imgui}", "%{IncludeDir.imguizmo}", "%{IncludeDir.imnodes}", @@ -52,8 +51,6 @@ project "SHADE_Engine" { "%{prj.location}/libs", "%{IncludeDir.VULKAN}/Lib", - "%{IncludeDir.assimp}/lib/Debug", - "%{IncludeDir.assimp}/lib/Release", "%{IncludeDir.RTTR}/lib", "%{IncludeDir.SDL}/lib", "%{IncludeDir.spdlog}/lib", @@ -119,7 +116,8 @@ project "SHADE_Engine" filter "configurations:Debug" postbuildcommands { - "xcopy /r /y /q \"%{IncludeDir.assimp}\\bin\\Debug\\assimp-vc142-mtd.dll\" \"$(OutDir)\"", + "xcopy /r /y /q \"%{IncludeDir.ModelCompiler}\\bin\\Debug\\assimp-vc142-mtd.dll\" \"$(OutDir)\"", + "xcopy /r /y /q \"%{IncludeDir.ModelCompiler}\\bin\\Debug\\ModelCompiler.exe\" \"$(OutDir)\"", "xcopy /r /y /q \"%{IncludeDir.fmod}\\lib\\fmodL.dll\" \"$(OutDir)\"", "xcopy /r /y /q \"%{IncludeDir.fmod}\\lib\\fmodstudioL.dll\" \"$(OutDir)\"" } @@ -127,7 +125,8 @@ project "SHADE_Engine" filter "configurations:Release" postbuildcommands { - "xcopy /r /y /q \"%{IncludeDir.assimp}\\bin\\Release\\assimp-vc142-mt.dll\" \"$(OutDir)\"", + "xcopy /r /y /q \"%{IncludeDir.ModelCompiler}\\bin\\Release\\assimp-vc142-mt.dll\" \"$(OutDir)\"", + "xcopy /r /y /q \"%{IncludeDir.ModelCompiler}\\bin\\Release\\ModelCompiler.exe\" \"$(OutDir)\"", "xcopy /r /y /q \"%{IncludeDir.fmod}\\lib\\fmod.dll\" \"$(OutDir)\"", "xcopy /r /y /q \"%{IncludeDir.fmod}\\lib\\fmodstudio.dll\" \"$(OutDir)\"" } @@ -135,32 +134,35 @@ project "SHADE_Engine" filter "configurations:Publish" postbuildcommands { - "xcopy /r /y /q \"%{IncludeDir.assimp}\\bin\\Release\\assimp-vc142-mt.dll\" \"$(OutDir)\"", + --"xcopy /r /y /q \"%{IncludeDir.assimp}\\bin\\Release\\assimp-vc142-mt.dll\" \"$(OutDir)\"", "xcopy /r /y /q \"%{IncludeDir.fmod}\\lib\\fmod.dll\" \"$(OutDir)\"", "xcopy /r /y /q \"%{IncludeDir.fmod}\\lib\\fmodstudio.dll\" \"$(OutDir)\"" } filter "configurations:Publish" - postbuildcommands {"xcopy /r /y /q \"%{IncludeDir.assimp}\\bin\\Release\\assimp-vc142-mt.dll\" \"$(OutDir)\""} + postbuildcommands + { + --"xcopy /r /y /q \"%{IncludeDir.assimp}\\bin\\Release\\assimp-vc142-mt.dll\" \"$(OutDir)\"" + } warnings 'Extra' filter "configurations:Debug" symbols "On" defines {"_DEBUG", "SHEDITOR"} - links{"assimp-vc142-mtd.lib", "librttr_core_d.lib", "spdlogd.lib"} + links{"librttr_core_d.lib", "spdlogd.lib"} links{"fmodstudioL_vc.lib", "fmodL_vc.lib"} filter "configurations:Release" optimize "On" defines{"_RELEASE", "SHEDITOR"} - links{"assimp-vc142-mt.lib", "librttr_core.lib", "spdlog.lib"} + links{"librttr_core.lib", "spdlog.lib"} links{"fmodstudio_vc.lib", "fmod_vc.lib"} filter "configurations:Publish" optimize "On" defines{"_RELEASE", "_PUBLISH"} - links{"assimp-vc142-mt.lib", "librttr_core.lib", "spdlog.lib"} + links{"librttr_core.lib", "spdlog.lib"} excludes { -- "%{prj.location}/src/Editor/**.cpp", diff --git a/SHADE_Engine/src/Assets/Asset Types/SHAssetIncludes.h b/SHADE_Engine/src/Assets/Asset Types/SHAssetIncludes.h index 1c1ed44a..f4fb49f0 100644 --- a/SHADE_Engine/src/Assets/Asset Types/SHAssetIncludes.h +++ b/SHADE_Engine/src/Assets/Asset Types/SHAssetIncludes.h @@ -1,4 +1,4 @@ #pragma once -#include "SHMeshAsset.h" +#include "SHModelAsset.h" #include "SHTextureAsset.h" \ No newline at end of file diff --git a/SHADE_Engine/src/Assets/Asset Types/SHMeshAsset.h b/SHADE_Engine/src/Assets/Asset Types/SHModelAsset.h similarity index 53% rename from SHADE_Engine/src/Assets/Asset Types/SHMeshAsset.h rename to SHADE_Engine/src/Assets/Asset Types/SHModelAsset.h index 20b442ba..c057678b 100644 --- a/SHADE_Engine/src/Assets/Asset Types/SHMeshAsset.h +++ b/SHADE_Engine/src/Assets/Asset Types/SHModelAsset.h @@ -18,24 +18,31 @@ namespace SHADE { - struct SH_API SHMeshAssetHeader - { - uint32_t vertexCount; - uint32_t indexCount; - std::string name; - }; + struct SHMeshAssetHeader + { + uint32_t vertexCount; + uint32_t indexCount; + std::string name; + }; - struct SH_API SHMeshAsset : SHAssetData - { - bool compiled; - bool changed; + struct SHModelAssetHeader + { + size_t meshCount; + }; - SHMeshAssetHeader header; + struct SH_API SHMeshData : SHAssetData + { + SHMeshAssetHeader header; + std::vector VertexPositions; + std::vector VertexTangents; + std::vector VertexNormals; + std::vector VertexTexCoords; + std::vector Indices; + }; - std::vector vertexPosition; - std::vector vertexTangent; - std::vector vertexNormal; - std::vector texCoords; - std::vector indices; - }; + struct SH_API SHModelAsset : SHAssetData + { + SHModelAssetHeader header; + std::vector subMeshes; + }; } \ No newline at end of file diff --git a/SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.cpp b/SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.cpp deleted file mode 100644 index 046ba767..00000000 --- a/SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.cpp +++ /dev/null @@ -1,201 +0,0 @@ -/*************************************************************************//** - * \file SHMeshCompiler.cpp - * \author Loh Xiao Qi - * \date 30 September 2022 - * \brief Library to write data in SHMeshAsset into binary file for faster - * loading in the future - * - * - * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. - *****************************************************************************/ -#include "SHpch.h" -#include "SHMeshCompiler.h" -#include "Graphics/MiddleEnd/Meshes/SHMeshData.h" -#include - -#include - -namespace SHADE -{ - - Assimp::Importer SHMeshCompiler::aiImporter; - - void SHMeshCompiler::ProcessNode(aiNode const& node, aiScene const& scene, MeshVectorRef meshes) noexcept - { - for (size_t i{ 0 }; i < node.mNumMeshes; ++i) - { - aiMesh* mesh = scene.mMeshes[node.mMeshes[i]]; - meshes.push_back(ProcessMesh(*mesh)); - } - - for (size_t i{ 0 }; i < node.mNumChildren; ++i) - { - ProcessNode(*node.mChildren[i], scene, meshes); - } - } - - void SHMeshCompiler::ExtractAnimations(aiScene const& scene, AnimVectorRef anims) noexcept - { - if (scene.HasAnimations()) - { - std::vector anims(scene.mNumAnimations); - for (auto i{ 0 }; i < scene.mNumAnimations; ++i) - { - auto const& anim{ *scene.mAnimations[i] }; - - anims[i].name = anim.mName.C_Str(); - - anims[i].duration = anim.mDuration; - anims[i].ticksPerSecond = anim.mTicksPerSecond; - - std::copy_n(anim.mChannels, anim.mNumChannels, anims[i].nodeChannels.data()); - std::copy_n(anim.mMeshChannels, anim.mNumMeshChannels, anims[i].meshChannels.data()); - std::copy_n(anim.mMorphMeshChannels, anim.mNumMorphMeshChannels, anims[i].morphMeshChannels.data()); - } - } - } - - SHMeshAsset* SHMeshCompiler::ProcessMesh(aiMesh const& mesh) noexcept - { - SHMeshAsset* result = new SHMeshAsset(); - result->compiled = false; - result->changed = false; - - for (size_t i{ 0 }; i < mesh.mNumVertices; ++i) - { - // Vertex position - SHVec3 vertex; - vertex.x = mesh.mVertices[i].x; - vertex.y = mesh.mVertices[i].y; - vertex.z = mesh.mVertices[i].z; - result->vertexPosition.push_back(vertex); - - // Tex coords - SHVec2 texCoord{ 0.f, 0.f }; - if (mesh.mTextureCoords[0]) - { - texCoord.x = mesh.mTextureCoords[0][i].x; - texCoord.y = mesh.mTextureCoords[0][i].y; - } - result->texCoords.push_back(texCoord); - - // Normals - SHVec3 normal{ 0.f, 0.f, 0.f }; - if (mesh.mNormals) - { - normal.x = mesh.mNormals[i].x; - normal.y = mesh.mNormals[i].y; - normal.z = mesh.mNormals[i].z; - } - result->vertexNormal.push_back(normal); - - // Tangent - SHVec3 tangent{ 0.f, 0.f, 0.f }; - if (mesh.mTangents) - { - tangent.x = mesh.mTangents[i].x; - tangent.y = mesh.mTangents[i].y; - tangent.z = mesh.mTangents[i].z; - } - result->vertexTangent.push_back(tangent); - } - - for (size_t i{ 0 }; i < mesh.mNumFaces; ++i) - { - aiFace face = mesh.mFaces[i]; - for (size_t j{ 0 }; j < face.mNumIndices; ++j) - { - result->indices.push_back(face.mIndices[j]); - } - } - - result->header.vertexCount = static_cast(result->vertexPosition.size()); - result->header.indexCount = static_cast(result->indices.size()); - result->header.name = mesh.mName.C_Str(); - - return result; - } - - void SHMeshCompiler::LoadFromFile(AssetPath path, MeshVectorRef meshes, AnimVectorRef anims) noexcept - { - const aiScene* scene = aiImporter.ReadFile(path.string().c_str(), - aiProcess_Triangulate // Make sure we get triangles rather than nvert polygons - | aiProcess_GenUVCoords // Convert any type of mapping to uv mapping - | aiProcess_TransformUVCoords // preprocess UV transformations (scaling, translation ...) - | aiProcess_FindInstances // search for instanced meshes and remove them by references to one master - | aiProcess_CalcTangentSpace // calculate tangents and bitangents if possible - | aiProcess_JoinIdenticalVertices // join identical vertices/ optimize indexing - | aiProcess_RemoveRedundantMaterials // remove redundant materials - | aiProcess_FindInvalidData // detect invalid model data, such as invalid normal vectors - | aiProcess_FlipUVs // flip the V to match the Vulkans way of doing UVs - ); - - if (!scene || !scene->HasMeshes()) - { - SHLOG_ERROR("ERROR in GLTF::ASSIMP: {}\nFile: {}", aiImporter.GetErrorString(), path.string()); - return; - } - - //ExtractAnimations(*scene, anims); - - ProcessNode(*scene->mRootNode, *scene, meshes); - - aiImporter.FreeScene(); - } - - std::optional SHMeshCompiler::CompileMeshBinary(SHMeshAsset const& asset, AssetPath path) noexcept - { - std::string newPath{ path.parent_path().string() + '/' }; - newPath += asset.header.name + MESH_EXTENSION.data(); - - std::ofstream file{ newPath, std::ios::out | std::ios::binary | std::ios::trunc }; - if (!file.is_open()) - { - SHLOG_ERROR("Unable to open file for writing mesh file: {}", path.string()); - } - - file.write( - reinterpret_cast(&(asset.header.vertexCount)), - sizeof(uint32_t) - ); - - file.write( - reinterpret_cast(&(asset.header.indexCount)), - sizeof(uint32_t) - ); - - auto const vertexVec3Byte{ sizeof(SHVec3) * asset.header.vertexCount }; - auto const vertexVec2Byte{ sizeof(SHVec2) * asset.header.vertexCount }; - - file.write( - reinterpret_cast(asset.vertexPosition.data()), - vertexVec3Byte - ); - - file.write( - reinterpret_cast(asset.vertexTangent.data()), - vertexVec3Byte - ); - - file.write( - reinterpret_cast(asset.vertexNormal.data()), - vertexVec3Byte - ); - - file.write( - reinterpret_cast(asset.texCoords.data()), - vertexVec2Byte - ); - - file.write( - reinterpret_cast(asset.indices.data()), - sizeof(uint32_t) * asset.header.indexCount - ); - - file.close(); - - return newPath; - } -} diff --git a/SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.h b/SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.h deleted file mode 100644 index 1af1298b..00000000 --- a/SHADE_Engine/src/Assets/Libraries/Compilers/SHMeshCompiler.h +++ /dev/null @@ -1,40 +0,0 @@ -/*************************************************************************//** - * \file SHMeshCompiler.h - * \author Loh Xiao Qi - * \date 30 September 2022 - * \brief Library to write data in SHMeshAsset into binary file for faster - * loading in the future - * - * - * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. - *****************************************************************************/ -#pragma once - -#include -#include -#include - -#include "Assets/Asset Types/SHAnimationAsset.h" -#include "Assets/Asset Types/SHMeshAsset.h" -#include "Assets/SHAssetMacros.h" - -namespace SHADE -{ - class SHMeshCompiler - { - - using MeshVectorRef = std::vector&; - using AnimVectorRef = std::vector&; - - static Assimp::Importer aiImporter; - static void ProcessNode(aiNode const& node, aiScene const& scene, MeshVectorRef meshes) noexcept; - static void ExtractAnimations(aiScene const& scene, AnimVectorRef anims) noexcept; - static SHMeshAsset* ProcessMesh(aiMesh const& mesh) noexcept; - - public: - static void LoadFromFile(AssetPath path, MeshVectorRef meshes, AnimVectorRef anims) noexcept; - static std::optional CompileMeshBinary(SHMeshAsset const& asset, AssetPath path) noexcept; - }; -} \ No newline at end of file diff --git a/SHADE_Engine/src/Assets/Libraries/Loaders/SHMeshLoader.cpp b/SHADE_Engine/src/Assets/Libraries/Loaders/SHMeshLoader.cpp deleted file mode 100644 index 52134440..00000000 --- a/SHADE_Engine/src/Assets/Libraries/Loaders/SHMeshLoader.cpp +++ /dev/null @@ -1,130 +0,0 @@ -/*************************************************************************//** - * \file SHMeshLoader.cpp - * \author Loh Xiao Qi - * \date 30 September 2022 - * \brief Implementation for Mesh loader. Accounts for custom binary format - * as well as GLTF file format. - * - * - * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. - *****************************************************************************/ -#include "SHpch.h" -#include "SHMeshLoader.h" -#include - -namespace SHADE -{ - void SHMeshLoader::LoadSHMesh(AssetPath path, SHMeshAsset& mesh) noexcept - { - std::ifstream file{ path.string(), std::ios::in | std::ios::binary }; - if (!file.is_open()) - { - SHLOG_ERROR("Unable to open SHMesh File: {}", path.string()); - return; - } - - const std::string name{ path.stem().string() }; - - file.seekg(0); - - uint32_t vertCount, indexCount; - std::vector vertPos, vertTan, vertNorm; - std::vector texCoord; - std::vector indices; - - file.read(reinterpret_cast(&vertCount), sizeof(uint32_t)); - file.read(reinterpret_cast(&indexCount), sizeof(uint32_t)); - - auto const vertexVec3Byte{ sizeof(SHVec3) * vertCount }; - auto const vertexVec2Byte{ sizeof(SHVec2) * vertCount }; - - vertPos.resize(vertCount); - vertTan.resize(vertCount); - vertNorm.resize(vertCount); - texCoord.resize(vertCount); - indices.resize(indexCount); - - file.read(reinterpret_cast(vertPos.data()), vertexVec3Byte); - file.read(reinterpret_cast(vertTan.data()), vertexVec3Byte); - file.read(reinterpret_cast(vertNorm.data()), vertexVec3Byte); - file.read(reinterpret_cast(texCoord.data()), vertexVec2Byte); - file.read(reinterpret_cast(indices.data()), sizeof(uint32_t) * indexCount); - - mesh.compiled = true; - mesh.changed = false; - - mesh.header.indexCount = indexCount; - mesh.header.vertexCount = vertCount; - mesh.header.name = name; - - mesh.vertexPosition = std::move(vertPos); - mesh.vertexTangent = std::move(vertTan); - mesh.vertexNormal = std::move(vertNorm); - mesh.texCoords = std::move(texCoord); - mesh.indices = std::move(indices); - - file.close(); - } - - SHAssetData* SHMeshLoader::Load(AssetPath path) - { - auto result = new SHMeshAsset(); - - LoadSHMesh(path, *result); - - return result; - } - - void SHMeshLoader::Write(SHAssetData const* data, AssetPath path) - { - std::ofstream file{ path, std::ios::out | std::ios::binary | std::ios::trunc }; - if (!file.is_open()) - { - SHLOG_ERROR("Unable to open file for writing mesh file: {}", path.string()); - } - - auto asset = *dynamic_cast(data); - - file.write( - reinterpret_cast(&(asset.header.vertexCount)), - sizeof(uint32_t) - ); - - file.write( - reinterpret_cast(&(asset.header.indexCount)), - sizeof(uint32_t) - ); - - auto const vertexVec3Byte{ sizeof(SHVec3) * asset.header.vertexCount }; - auto const vertexVec2Byte{ sizeof(SHVec2) * asset.header.vertexCount }; - - file.write( - reinterpret_cast(asset.vertexPosition.data()), - vertexVec3Byte - ); - - file.write( - reinterpret_cast(asset.vertexTangent.data()), - vertexVec3Byte - ); - - file.write( - reinterpret_cast(asset.vertexNormal.data()), - vertexVec3Byte - ); - - file.write( - reinterpret_cast(asset.texCoords.data()), - vertexVec2Byte - ); - - file.write( - reinterpret_cast(asset.indices.data()), - sizeof(uint32_t) * asset.header.indexCount - ); - - file.close(); - } -} diff --git a/SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.cpp b/SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.cpp new file mode 100644 index 00000000..74aa5350 --- /dev/null +++ b/SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.cpp @@ -0,0 +1,91 @@ +/*************************************************************************//** + * \file SHModelLoader.cpp + * \author Loh Xiao Qi + * \date 30 September 2022 + * \brief Implementation for Mesh loader. Accounts for custom binary format + * as well as GLTF file format. + * + * + * Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. + *****************************************************************************/ +#include "SHpch.h" +#include "SHModelLoader.h" +#include + +namespace SHADE +{ + void SHModelLoader::ReadHeader(std::ifstream& file, SHMeshLoaderHeader& header) noexcept + { + file.read( + reinterpret_cast(&header), + sizeof(SHMeshLoaderHeader) + ); + } + + void SHModelLoader::ReadData(std::ifstream& file, SHMeshLoaderHeader const& header, SHMeshData& data) noexcept + { + auto const vertexVec3Byte{ sizeof(SHVec3) * header.vertexCount }; + auto const vertexVec2Byte{ sizeof(SHVec2) * header.vertexCount }; + + data.VertexPositions.resize(header.vertexCount); + data.VertexTangents.resize(header.vertexCount); + data.VertexNormals.resize(header.vertexCount); + data.VertexTexCoords.resize(header.vertexCount); + data.Indices.resize(header.indexCount); + data.header.name.resize(header.charCount); + + file.read(data.header.name.data(), header.charCount); + file.read(reinterpret_cast(data.VertexPositions.data()), vertexVec3Byte); + file.read(reinterpret_cast(data.VertexTangents.data()), vertexVec3Byte); + file.read(reinterpret_cast(data.VertexNormals.data()), vertexVec3Byte); + file.read(reinterpret_cast(data.VertexTexCoords.data()), vertexVec2Byte); + file.read(reinterpret_cast(data.Indices.data()), sizeof(uint32_t) * header.indexCount); + + data.header.vertexCount = header.vertexCount; + data.header.indexCount = header.indexCount; + } + + void SHModelLoader::LoadSHMesh(AssetPath path, SHModelAsset& model) noexcept + { + std::ifstream file{ path.string(), std::ios::in | std::ios::binary }; + if (!file.is_open()) + { + SHLOG_ERROR("Unable to open SHMesh File: {}", path.string()); + return; + } + + file.seekg(0); + + file.read( + reinterpret_cast(&model.header), + sizeof(SHModelAssetHeader) + ); + + std::vector headers(model.header.meshCount); + model.subMeshes.resize(model.header.meshCount); + + for (auto i{ 0 }; i < model.header.meshCount; ++i) + { + model.subMeshes[i] = new SHMeshData(); + ReadHeader(file, headers[i]); + ReadData(file, headers[i], *model.subMeshes[i]); + } + file.close(); + } + + SHAssetData* SHModelLoader::Load(AssetPath path) + { + auto result = new SHModelAsset(); + + LoadSHMesh(path, *result); + + return result; + } + + void SHModelLoader::Write(SHAssetData const* data, AssetPath path) + { + + } +} diff --git a/SHADE_Engine/src/Assets/Libraries/Loaders/SHMeshLoader.h b/SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.h similarity index 56% rename from SHADE_Engine/src/Assets/Libraries/Loaders/SHMeshLoader.h rename to SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.h index 03a111ce..35dc4514 100644 --- a/SHADE_Engine/src/Assets/Libraries/Loaders/SHMeshLoader.h +++ b/SHADE_Engine/src/Assets/Libraries/Loaders/SHModelLoader.h @@ -1,5 +1,5 @@ /*************************************************************************//** - * \file SHMeshLoader.h + * \file SHModelLoader.h * \author Loh Xiao Qi * \date 30 September 2022 * \brief Library to load gltf mesh files and custom binary format @@ -10,14 +10,27 @@ * of DigiPen Institute of Technology is prohibited. *****************************************************************************/ #pragma once -#include "Assets/Asset Types/SHMeshAsset.h" +#include "Assets/Asset Types/SHModelAsset.h" #include "SHAssetLoader.h" +#include namespace SHADE { - struct SHMeshLoader : SHAssetLoader + class SHModelLoader : public SHAssetLoader { - void LoadSHMesh(AssetPath path, SHMeshAsset& meshes) noexcept; + struct SHMeshLoaderHeader + { + uint32_t vertexCount; + uint32_t indexCount; + uint32_t charCount; + }; + + + void ReadHeader(std::ifstream& file, SHMeshLoaderHeader& header) noexcept; + void ReadData(std::ifstream& file, SHMeshLoaderHeader const& header, SHMeshData& data) noexcept; + + public: + void LoadSHMesh(AssetPath path, SHModelAsset& model) noexcept; SHAssetData* Load(AssetPath path) override; void Write(SHAssetData const* data, AssetPath path) override; }; diff --git a/SHADE_Engine/src/Assets/SHAsset.h b/SHADE_Engine/src/Assets/SHAsset.h index a4e9847c..29f43e0c 100644 --- a/SHADE_Engine/src/Assets/SHAsset.h +++ b/SHADE_Engine/src/Assets/SHAsset.h @@ -21,6 +21,11 @@ namespace SHADE AssetName name; AssetID id; AssetType type; - AssetPath path; + AssetPath path; + bool isSubAsset; + + std::vector subAssets; + + AssetID parent; }; } \ No newline at end of file diff --git a/SHADE_Engine/src/Assets/SHAssetMacros.h b/SHADE_Engine/src/Assets/SHAssetMacros.h index 3376a2d5..92c4b69e 100644 --- a/SHADE_Engine/src/Assets/SHAssetMacros.h +++ b/SHADE_Engine/src/Assets/SHAssetMacros.h @@ -47,10 +47,11 @@ enum class AssetType : AssetTypeMeta SHADER, SHADER_BUILT_IN, TEXTURE, - MESH, + MODEL, SCENE, PREFAB, MATERIAL, + MESH, MAX_COUNT }; constexpr size_t TYPE_COUNT{ static_cast(AssetType::MAX_COUNT) }; @@ -64,6 +65,9 @@ constexpr std::string_view ASSET_ROOT {"../../Assets"}; constexpr std::string_view BUILT_IN_ASSET_ROOT{ "../../Built_In" }; #endif +// COMPILER PATHS +constexpr std::string_view MODEL_COMPILER_EXE{ "ModelCompiler.exe" }; + // INTERNAL ASSET PATHS constexpr std::string_view SCENE_FOLDER{ "/Scenes/" }; constexpr std::string_view PREFAB_FOLDER{ "/Prefabs/" }; @@ -81,7 +85,7 @@ constexpr std::string_view SCENE_EXTENSION {".shade"}; constexpr std::string_view PREFAB_EXTENSION {".shprefab"}; constexpr std::string_view MATERIAL_EXTENSION {".shmat"}; constexpr std::string_view TEXTURE_EXTENSION {".shtex"}; -constexpr std::string_view MESH_EXTENSION {".shmesh"}; +constexpr std::string_view MODEL_EXTENSION {".shmodel"}; constexpr std::string_view EXTENSIONS[] = { AUDIO_EXTENSION, @@ -89,7 +93,7 @@ constexpr std::string_view EXTENSIONS[] = { SHADER_BUILT_IN_EXTENSION, MATERIAL_EXTENSION, TEXTURE_EXTENSION, - MESH_EXTENSION, + MODEL_EXTENSION, SCRIPT_EXTENSION, SCENE_EXTENSION, PREFAB_EXTENSION, diff --git a/SHADE_Engine/src/Assets/SHAssetManager.cpp b/SHADE_Engine/src/Assets/SHAssetManager.cpp index 4897fc42..3fd71a8e 100644 --- a/SHADE_Engine/src/Assets/SHAssetManager.cpp +++ b/SHADE_Engine/src/Assets/SHAssetManager.cpp @@ -11,15 +11,17 @@ #include #include #include +#include + #include "SHAssetManager.h" #include "SHAssetMetaHandler.h" -#include "Libraries/Loaders/SHMeshLoader.h" +#include "Libraries/Loaders/SHModelLoader.h" #include "Libraries/Loaders/SHTextureLoader.h" #include "Libraries/Loaders/SHShaderSourceLoader.h" #include "Libraries/Loaders/SHTextBasedLoader.h" -#include "Libraries/Compilers/SHMeshCompiler.h" +//#include "Libraries/Compilers/SHMeshCompiler.h" #include "Libraries/Compilers/SHTextureCompiler.h" #include "Libraries/Compilers/SHShaderSourceCompiler.h" @@ -157,16 +159,22 @@ namespace SHADE { case AssetType::PREFAB: newPath += PREFAB_FOLDER; + newPath += name; + newPath += PREFAB_EXTENSION; data = new SHPrefabAsset(); break; case AssetType::SCENE: newPath += SCENE_FOLDER; + newPath += name; + newPath += SCENE_EXTENSION; data = new SHSceneAsset(); break; case AssetType::MATERIAL: newPath += MATERIAL_FOLDER; + newPath += name; + newPath += MATERIAL_EXTENSION; data = new SHMaterialAsset(); break; @@ -180,7 +188,8 @@ namespace SHADE name, id, type, - newPath + newPath, + false }; assetCollection.insert({ @@ -189,7 +198,8 @@ namespace SHADE name, id, type, - newPath + newPath, + false ) }); @@ -328,25 +338,32 @@ namespace SHADE return result; } - AssetID SHAssetManager::CompileAsset(AssetPath const& path) noexcept + void SHAssetManager::CompileAsset(AssetPath const& path) noexcept { - SHAsset newAsset - { - .name = path.stem().string() - }; - + if (!std::filesystem::exists(path)) + { + SHLOG_ERROR("Path provided does not point to a file: {}", path.string()); + return; + } + AssetPath newPath; auto const ext{ path.extension().string() }; if (ext == GLSL_EXTENSION.data()) { - newAsset.path = SHShaderSourceCompiler::LoadAndCompileShader(path).value(); - newAsset.id = GenerateAssetID(AssetType::SHADER_BUILT_IN); - newAsset.type = AssetType::SHADER_BUILT_IN; + newPath = SHShaderSourceCompiler::LoadAndCompileShader(path).value(); } + else if (ext == GLTF_EXTENSION.data() || ext == FBX_EXTENSION.data()) + { + std::string command = MODEL_COMPILER_EXE.data(); + command += " " + path.string(); + std::system(command.c_str()); - assetCollection.insert({ newAsset.id, newAsset }); - SHAssetMetaHandler::WriteMetaData(newAsset); + std::string modelPath = path.string().substr(0, path.string().find_last_of('.')); + modelPath += MODEL_EXTENSION; + newPath = modelPath; + + GenerateNewMeta(newPath); + } - return newAsset.id; } FolderPointer SHAssetManager::GetRootFolder() noexcept @@ -399,46 +416,28 @@ namespace SHADE for (auto const& path : paths) { - SHAsset newAsset - { - .name = path.stem().string() - }; - + AssetPath newPath; auto const ext{ path.extension().string() }; if (ext == GLSL_EXTENSION.data()) { - newAsset.path = SHShaderSourceCompiler::LoadAndCompileShader(path).value(); - newAsset.id = GenerateAssetID(AssetType::SHADER_BUILT_IN); - newAsset.type = AssetType::SHADER_BUILT_IN; + newPath = SHShaderSourceCompiler::LoadAndCompileShader(path).value(); } else if (ext == DDS_EXTENSION.data()) { - newAsset.path = SHTextureCompiler::CompileTextureAsset(path).value(); - newAsset.id = GenerateAssetID(AssetType::TEXTURE); - newAsset.type = AssetType::TEXTURE; + newPath = SHTextureCompiler::CompileTextureAsset(path).value(); } else if (ext == GLTF_EXTENSION.data() || ext == FBX_EXTENSION.data()) { - std::vector meshes; - std::vector anims; - SHMeshCompiler::LoadFromFile(path, meshes, anims); + std::string command = MODEL_COMPILER_EXE.data(); + command += " " + path.string(); + std::system(command.c_str()); - for (auto const& mesh : meshes) - { - SHAsset meshAsset{ - .name = mesh->header.name - }; - meshAsset.path = SHMeshCompiler::CompileMeshBinary(*mesh, path).value(); - meshAsset.id = GenerateAssetID(AssetType::MESH); - meshAsset.type = AssetType::MESH; - assetCollection.insert({ meshAsset.id, meshAsset }); - SHAssetMetaHandler::WriteMetaData(meshAsset); - } - continue; + std::string modelPath = path.string().substr(0, path.string().find_last_of('.')); + modelPath += MODEL_EXTENSION; + newPath = modelPath; } - assetCollection.insert({ newAsset.id, newAsset }); - SHAssetMetaHandler::WriteMetaData(newAsset); + GenerateNewMeta(newPath); } } @@ -453,10 +452,11 @@ namespace SHADE loaders[static_cast(AssetType::SHADER)] = dynamic_cast(new SHShaderSourceLoader()); loaders[static_cast(AssetType::SHADER_BUILT_IN)] = loaders[static_cast(AssetType::SHADER)]; loaders[static_cast(AssetType::TEXTURE)] = dynamic_cast(new SHTextureLoader()); - loaders[static_cast(AssetType::MESH)] = dynamic_cast(new SHMeshLoader()); + loaders[static_cast(AssetType::MODEL)] = dynamic_cast(new SHModelLoader()); loaders[static_cast(AssetType::SCENE)] = dynamic_cast(new SHTextBasedLoader()); loaders[static_cast(AssetType::PREFAB)] = loaders[static_cast(AssetType::SCENE)]; loaders[static_cast(AssetType::MATERIAL)] = loaders[static_cast(AssetType::SCENE)]; + loaders[static_cast(AssetType::MESH)] = nullptr; } /**************************************************************************** @@ -464,9 +464,9 @@ namespace SHADE ****************************************************************************/ void SHAssetManager::Load() noexcept { - //CompileAll(); BuildAssetCollection(); InitLoaders(); + //CompileAll(); //LoadAllData(); } @@ -484,8 +484,12 @@ namespace SHADE SHAssetData* SHAssetManager::LoadData(SHAsset const& asset) noexcept { - SHAssetData* data = loaders[static_cast(asset.type)]->Load(asset.path); + if (asset.isSubAsset) + { + return LoadSubData(asset); + } + SHAssetData* data = loaders[static_cast(asset.type)]->Load(asset.path); if (data == nullptr) { SHLOG_ERROR("Unable to load asset into memory: {}\n", asset.path.string()); @@ -498,8 +502,120 @@ namespace SHADE return data; } + SHAssetData* SHAssetManager::LoadSubData(SHAsset const& asset) noexcept + { + auto const& parent = assetCollection[asset.parent]; + auto parentData = loaders[static_cast(parent.type)]->Load(parent.path); + + if (parentData == nullptr) + { + SHLOG_ERROR("Unable to load asset into memory: {}\n", parent.path.string()); + } + else + { + assetData.emplace(parent.id, parentData); + if (parent.type == AssetType::MODEL) + { + auto parentModel = reinterpret_cast(parentData); + for (auto i {0}; i < parent.subAssets.size(); ++i) + { + assetData.emplace( + parent.subAssets[i]->id, + parentModel->subMeshes[i] + ); + } + } + + return assetData[asset.id]; + } + + return parentData; + } + + void SHAssetManager::LoadNewData(AssetPath path) noexcept + { + } + + void SHAssetManager::GenerateNewMeta(AssetPath path) noexcept + { + auto const ext = path.extension().string(); + if (ext == SHADER_BUILT_IN_EXTENSION.data()) + { + SHAsset newAsset{ + path.stem().string(), + GenerateAssetID(AssetType::SHADER_BUILT_IN), + AssetType::SHADER_BUILT_IN, + path, + false + }; + + assetCollection.emplace(newAsset.id, newAsset); + SHAssetMetaHandler::WriteMetaData(newAsset); + } + else if (ext == TEXTURE_EXTENSION.data()) + { + SHAsset newAsset{ + path.stem().string(), + GenerateAssetID(AssetType::SHADER_BUILT_IN), + AssetType::SHADER_BUILT_IN, + path, + false + }; + + assetCollection.emplace(newAsset.id, newAsset); + SHAssetMetaHandler::WriteMetaData(newAsset); + } + else if (ext == MODEL_EXTENSION) + { + SHAsset newAsset{ + path.stem().string(), + GenerateAssetID(AssetType::MODEL), + AssetType::MODEL, + path, + false + }; + + assetCollection.emplace(newAsset.id, newAsset); + + SHModelAsset* const data = reinterpret_cast(LoadData(newAsset)); + assetData.emplace(newAsset.id, data); + for(auto const& subMesh : data->subMeshes) + { + SHAsset subAsset{ + .name = subMesh->header.name, + .id = GenerateAssetID(AssetType::MESH), + .type = AssetType::MESH, + .isSubAsset = true, + .parent = newAsset.id + }; + + assetCollection.emplace(subAsset.id, subAsset); + assetCollection[newAsset.id].subAssets.push_back(&assetCollection[subAsset.id]); + + assetData.emplace(subAsset.id, subMesh); + } + + SHAssetMetaHandler::WriteMetaData(assetCollection[newAsset.id]); + } + } + void SHAssetManager::BuildAssetCollection() noexcept { SHFileSystem::BuildDirectory(ASSET_ROOT.data(), folderRoot, assetCollection); + + for (auto& asset : std::ranges::views::values(assetCollection)) + { + if (!asset.subAssets.empty()) + { + // Add subasset data into map, replace pointer and free heap memory + for (auto i{ 0 }; i < asset.subAssets.size(); ++i) + { + auto const id = asset.subAssets[i]->id; + assetCollection[id] = *asset.subAssets[i]; + delete asset.subAssets[i]; + asset.subAssets[i] = &assetCollection[id]; + } + } + } } } diff --git a/SHADE_Engine/src/Assets/SHAssetManager.h b/SHADE_Engine/src/Assets/SHAssetManager.h index 64527e01..ba10d84f 100644 --- a/SHADE_Engine/src/Assets/SHAssetManager.h +++ b/SHADE_Engine/src/Assets/SHAssetManager.h @@ -87,7 +87,7 @@ namespace SHADE static std::vector GetAllDataOfType(AssetType type) noexcept; static std::vector GetAllRecordOfType(AssetType type) noexcept; - static AssetID CompileAsset(AssetPath const& path) noexcept; + static void CompileAsset(AssetPath const& path) noexcept; static FolderPointer GetRootFolder() noexcept; @@ -95,7 +95,11 @@ namespace SHADE static void InitLoaders() noexcept; static void LoadAllData() noexcept; - static SHAssetData* LoadData(SHAsset const& asset) noexcept; + static SHAssetData* LoadData(SHAsset const& asset) noexcept; + static SHAssetData* LoadSubData(SHAsset const& asset) noexcept; + static void LoadNewData(AssetPath path) noexcept; + static void GenerateNewMeta(AssetPath path) noexcept; + inline static void BuildAssetCollection() noexcept; static bool IsRecognised(char const*) noexcept; diff --git a/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp b/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp index 1bfec00d..9ae8cde2 100644 --- a/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp +++ b/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp @@ -9,7 +9,6 @@ ******************************************************************************/ #include "SHpch.h" #include "SHAssetMetaHandler.h" -#include #include namespace SHADE @@ -21,11 +20,15 @@ namespace SHADE * \brief Helper function to retrieve field value from meta data file * for processing ****************************************************************************/ - void GetFieldValue(std::ifstream& file, std::string& line) noexcept + bool GetFieldValue(std::ifstream& file, std::string& line) noexcept { line = ""; - std::getline(file, line); - line = line.substr(line.find_last_of(':') + 2, line.length()); + if (std::getline(file, line)) + { + line = line.substr(line.find_last_of(':') + 2, line.length()); + return true; + } + return false; } /**************************************************************************** @@ -66,7 +69,8 @@ namespace SHADE std::ifstream metaFile{ path.string(), std::ios_base::in }; if (!metaFile.is_open()) { - // Error unable to open + SHLOG_ERROR("Unable to open meta file: {}", path.string()); + return {}; } std::string line; @@ -92,6 +96,43 @@ namespace SHADE AssetTypeMeta type; typeStream >> type; meta.type = static_cast(type); + + meta.isSubAsset = false; + + // Burn Line + if (std::getline(metaFile, line)) + { + // Name Line + while(GetFieldValue(metaFile, line)) + { + auto subAsset = new SHAsset(); + + // Get resource name + std::stringstream nameStream{ line }; + AssetName name; + nameStream >> name; + subAsset->name = name; + + // Get resource id + GetFieldValue(metaFile, line); + std::stringstream idStream{ line }; + AssetID id; + idStream >> id; + subAsset->id = id; + + // Get resource type + GetFieldValue(metaFile, line); + std::stringstream typeStream{ line }; + AssetTypeMeta type; + typeStream >> type; + subAsset->type = static_cast(type); + + subAsset->isSubAsset = true; + subAsset->parent = meta.id; + + meta.subAssets.push_back(subAsset); + } + } metaFile.close(); @@ -108,6 +149,12 @@ namespace SHADE ****************************************************************************/ void SHAssetMetaHandler::WriteMetaData(SHAsset const& meta) noexcept { + if (meta.isSubAsset) + { + SHLOG_WARNING("Cannot write subasset meta: {}", meta.name); + return; + } + //TODO: Write into binary eventually std::string path{ meta.path.string() }; path.append(META_EXTENSION); @@ -124,7 +171,23 @@ namespace SHADE metaFile << "ID: " << meta.id << "\n"; metaFile << "Type: " << static_cast(meta.type) << std::endl; + if (!meta.subAssets.empty()) + { + metaFile << "Sub Assets:\n"; + + for (auto const& subAsset : meta.subAssets) + { + WriteSubAssetMeta(metaFile, *subAsset); + } + } + metaFile.close(); } + void SHAssetMetaHandler::WriteSubAssetMeta(std::ofstream& metaFile, SHAsset const& subAsset) noexcept + { + metaFile << "Name: " << subAsset.name << "\n"; + metaFile << "ID: " << subAsset.id << "\n"; + metaFile << "Type: " << static_cast(subAsset.type) << std::endl; + } } diff --git a/SHADE_Engine/src/Assets/SHAssetMetaHandler.h b/SHADE_Engine/src/Assets/SHAssetMetaHandler.h index 88b5329d..ffa965aa 100644 --- a/SHADE_Engine/src/Assets/SHAssetMetaHandler.h +++ b/SHADE_Engine/src/Assets/SHAssetMetaHandler.h @@ -12,6 +12,7 @@ #include "SHAssetMacros.h" #include "SHAsset.h" +#include namespace SHADE { @@ -45,6 +46,8 @@ namespace SHADE * \brief Writes meta data into text file ****************************************************************************/ static void WriteMetaData(SHAsset const&) noexcept; + + static void WriteSubAssetMeta(std::ofstream&, SHAsset const&) noexcept; }; } diff --git a/SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp b/SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp index c3c7ef03..c913030b 100644 --- a/SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp +++ b/SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp @@ -17,6 +17,8 @@ #include #include +const std::string AUDIO_FOLDER_PATH{ std::string(ASSET_ROOT)+ "/Audio/" }; + namespace SHADE { SHAudioSystem::SHAudioSystem() @@ -79,10 +81,10 @@ namespace SHADE //SHResourceManager::LoadAllAudio(system, soundList); - LoadBank("../../Assets/Audio/Master.bank"); - LoadBank("../../Assets/Audio/Master.strings.bank"); - //LoadBank("../../Assets/Audio/Music.bank"); - LoadBank("../../Assets/Audio/footsteps.bank"); + LoadBank((AUDIO_FOLDER_PATH + "Master.bank").data()); + LoadBank((AUDIO_FOLDER_PATH + "Master.strings.bank").data()); + //LoadBank((AUDIO_FOLDER_PATH + "Music.bank").data()); + LoadBank((AUDIO_FOLDER_PATH + "footsteps.bank").data()); //auto clip = CreateAudioClip("event:/Characters/sfx_footsteps_human"); //clip->Play(); diff --git a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp index 8c71eb8f..37b8ecd4 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp @@ -5,15 +5,19 @@ #include "Editor/SHImGuiHelpers.hpp" #include #include +#include #include "Assets/SHAssetManager.h" +#include "ECS_Base/Managers/SHSystemManager.h" #include "Editor/IconsFontAwesome6.h" +#include "Editor/SHEditor.h" #include "Editor/DragDrop/SHDragDrop.hpp" +#include "Editor/EditorWindow/MaterialInspector/SHMaterialInspector.h" namespace SHADE { SHAssetBrowser::SHAssetBrowser() - :SHEditorWindow("\xee\x8b\x87 Asset Browser", ImGuiWindowFlags_MenuBar), rootFolder(SHAssetManager::GetRootFolder()), prevFolder(rootFolder), currentFolder(rootFolder) + :SHEditorWindow("\xee\x8b\x87 Asset Browser", ImGuiWindowFlags_MenuBar), rootFolder(SHAssetManager::GetRootFolder()), prevFolder(rootFolder), currentFolder(rootFolder), assetBeingCreated(std::nullopt) { } @@ -53,14 +57,33 @@ namespace SHADE flags |= ImGuiTreeNodeFlags_Selected; if (folder == rootFolder) flags |= ImGuiTreeNodeFlags_DefaultOpen; - + bool isOpen = ImGui::TreeNodeEx(folder, flags, "%s %s", ICON_MD_FOLDER, folder->name.data()); + ImGuiID folderID = ImGui::GetItemID(); const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); - if(ImGui::IsItemClicked()) + + if (ImGui::BeginPopupContextItem()) + { + if (ImGui::BeginMenu("Create Asset")) + { + //TODO: Change to rttr type enum align + if (ImGui::Selectable("Material")) + { + assetBeingCreated = { folder, AssetType::MATERIAL, "New Material" }; + ImGui::TreeNodeSetOpen(folderID, true); + isOpen = true; + } + ImGui::EndMenu(); + } + ImGui::EndPopup(); + } + + if (ImGui::IsItemClicked()) { selectedFolders.clear(); selectedFolders.push_back(folder); } + if (isOpen) { const ImColor treeLineColor = ImGui::GetColorU32(ImGuiCol_CheckMark); @@ -79,13 +102,18 @@ namespace SHADE } for (auto const& file : files) { + if(file.assetMeta == nullptr) + continue; const float horizontalLineSize = 25.0f; - const ImRect childRect = DrawFile(file); + const ImRect childRect = DrawFile(file.assetMeta); const float midPoint = (childRect.Min.y + childRect.Max.y) * 0.5f; drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1); vertLineEnd.y = midPoint; } drawList->AddLine(vertLineStart, vertLineEnd, treeLineColor, 1); + if(assetBeingCreated.has_value() && std::get<0>(assetBeingCreated.value()) == folder) + DrawAssetBeingCreated(); + ImGui::TreePop(); } return nodeRect; @@ -120,45 +148,111 @@ namespace SHADE //} } - ImRect SHAssetBrowser::DrawFile(SHFile const& file) noexcept + ImRect SHAssetBrowser::DrawFile(SHAsset const* const asset) noexcept { - if (file.assetMeta == nullptr) + if (asset == nullptr) return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); - const bool isSelected = std::ranges::find(selectedAssets, file.assetMeta->id) != selectedAssets.end(); - ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Leaf; + const bool isSelected = std::ranges::find(selectedAssets, asset->id) != selectedAssets.end(); + ImGuiTreeNodeFlags flags = (!asset->subAssets.empty()) ? ImGuiTreeNodeFlags_OpenOnArrow : ImGuiTreeNodeFlags_Leaf; if (isSelected) flags |= ImGuiTreeNodeFlags_Selected; std::string icon{}; - switch(file.assetMeta->type) + switch (asset->type) { case AssetType::INVALID: break; case AssetType::SHADER: icon = ICON_FA_FILE_CODE; break; case AssetType::SHADER_BUILT_IN: icon = ICON_FA_FILE_CODE; break; case AssetType::TEXTURE: icon = ICON_FA_IMAGES; break; - case AssetType::MESH: icon = ICON_FA_CUBES; break; + case AssetType::MODEL: icon = ICON_FA_CUBES_STACKED; break; case AssetType::SCENE: icon = ICON_MD_IMAGE; break; case AssetType::PREFAB: icon = ICON_FA_BOX_OPEN; break; case AssetType::MATERIAL: break; + case AssetType::MESH: icon = ICON_FA_CUBES; break; case AssetType::MAX_COUNT: break; - default: ; + default:; } - - ImGui::TreeNodeEx(file.assetMeta, flags, "%s %s", icon.data(), file.assetMeta->name.data()); + + bool const isOpen = ImGui::TreeNodeEx(asset, flags, "%s %s", icon.data(), asset->name.data()); const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); - if(SHDragDrop::BeginSource()) + if (SHDragDrop::BeginSource()) { - auto id = file.assetMeta->id; - ImGui::Text("Moving Asset: %s [%zu]", file.name.data(), file.assetMeta->id); + auto id = asset->id; + ImGui::Text("Moving Asset: %s [%zu]", asset->name.data(), asset->id); SHDragDrop::SetPayload(SHDragDrop::DRAG_RESOURCE, &id); SHDragDrop::EndSource(); } - if(ImGui::IsItemClicked()) + if (ImGui::IsItemClicked()) { selectedAssets.clear(); - selectedAssets.push_back(file.assetMeta->id); + selectedAssets.push_back(asset->id); + } + if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) + { + switch (asset->type) + { + case AssetType::INVALID: break; + case AssetType::SHADER: break; + case AssetType::SHADER_BUILT_IN: break; + case AssetType::TEXTURE: break; + case AssetType::MESH: break; + case AssetType::SCENE: + if(auto editor = SHSystemManager::GetSystem()) + { + editor->LoadScene(asset->id); + } + break; + case AssetType::PREFAB: break; + case AssetType::MATERIAL: + if (auto matInspector = SHEditorWindowManager::GetEditorWindow()) + { + matInspector->OpenMaterial(asset->id); + } + break; + case AssetType::MAX_COUNT: break; + default:; + } + + } + + //TODO: Combine Draw asset and Draw Folder recursive drawing + const ImColor treeLineColor = ImGui::GetColorU32(ImGuiCol_CheckMark); + const float horizontalOffset = 0.0f; + ImDrawList* drawList = ImGui::GetWindowDrawList(); + ImVec2 vertLineStart = ImGui::GetCursorScreenPos(); + vertLineStart.x += horizontalOffset; + ImVec2 vertLineEnd = vertLineStart; + if(isOpen) + { + for(auto const& subAsset : asset->subAssets) + { + const float horizontalLineSize = 25.0f; + const ImRect childRect = DrawFile(subAsset); + const float midPoint = (childRect.Min.y + childRect.Max.y) * 0.5f; + drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1); + vertLineEnd.y = midPoint; + } + drawList->AddLine(vertLineStart, vertLineEnd, treeLineColor, 1); + ImGui::TreePop(); } - ImGui::TreePop(); return nodeRect; } + + void SHAssetBrowser::DrawAssetBeingCreated() noexcept + { + if (!assetBeingCreated.has_value()) + return; + auto& path = std::get<0>(assetBeingCreated.value()); + auto& type = std::get<1>(assetBeingCreated.value()); + auto& assetName = std::get<2>(assetBeingCreated.value()); + if (ImGui::InputText("##newAssetName", &assetName, ImGuiInputTextFlags_EnterReturnsTrue)) + { + AssetID assetId = SHAssetManager::CreateNewAsset(type, assetName); + if (auto matInspector = SHEditorWindowManager::GetEditorWindow()) + { + matInspector->OpenMaterial(assetId, true); + } + assetBeingCreated.reset(); + } + } } diff --git a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h index d56fc029..00023ebe 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h +++ b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h @@ -10,6 +10,7 @@ namespace SHADE class SHAssetBrowser final : public SHEditorWindow { public: + using AssetEntry = std::tuple; SHAssetBrowser(); void Init(); @@ -20,12 +21,13 @@ namespace SHADE void DrawMenuBar(); ImRect RecursivelyDrawTree(FolderPointer folder); void DrawCurrentFolder(); - ImRect DrawFile(SHFile const& file) noexcept; + ImRect DrawFile(SHAsset const* const asset) noexcept; + void DrawAssetBeingCreated() noexcept; FolderPointer rootFolder, prevFolder, currentFolder; + std::optional assetBeingCreated; std::vector selectedFolders; std::vector selectedAssets; static constexpr float tileWidth = 50.0f; - }; } diff --git a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp index 1b289a90..ff65ba58 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp @@ -45,7 +45,7 @@ namespace SHADE SHEditorWindow::Update(); isAnyNodeSelected = false; - + if (Begin()) { if (skipFrame) @@ -108,6 +108,12 @@ namespace SHADE } } + if(ImGui::IsWindowHovered() && !ImGui::IsAnyItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) + { + ParentSelectedEntities(MAX_EID, draggingEntities); + draggingEntities.clear(); + ImGui::ClearDragDrop(); + } ImGui::End(); } @@ -195,7 +201,7 @@ namespace SHADE if (SHDragDrop::BeginSource()) { std::string moveLabel = "Moving EID: "; - static std::vector draggingEntities = editor->selectedEntities; + draggingEntities = editor->selectedEntities; if (!isSelected) { draggingEntities.clear(); @@ -217,7 +223,8 @@ namespace SHADE { if (const std::vector* eidPayload = SHDragDrop::AcceptPayload>(SHDragDrop::DRAG_EID)) //If payload is valid { - ParentSelectedEntities(eid); + ParentSelectedEntities(eid, draggingEntities); + draggingEntities.clear(); SHDragDrop::EndTarget(); } } @@ -255,7 +262,7 @@ namespace SHADE if ((currentNode->GetParent() != sceneGraph.GetRoot()) && ImGui::Selectable(std::format("{} Unparent Selected", ICON_MD_NORTH_WEST).data())) { - ParentSelectedEntities(MAX_EID); + ParentSelectedEntities(MAX_EID, editor->selectedEntities); } ImGui::EndPopup(); } @@ -323,14 +330,16 @@ namespace SHADE SHEntityManager::CreateEntity(MAX_EID, "DefaultChild", parentEID); } - void SHHierarchyPanel::ParentSelectedEntities(EntityID parentEID) const noexcept + void SHHierarchyPanel::ParentSelectedEntities(EntityID parentEID, std::vector const& entities) const noexcept { auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); - auto const editor = SHSystemManager::GetSystem(); + //auto const editor = SHSystemManager::GetSystem(); SHEntityParentCommand::EntityParentData entityParentData; std::vector parentedEIDS; - for (auto const& eid : editor->selectedEntities) + for (auto const& eid : entities) { + if(eid == parentEID) + continue; if (sceneGraph.GetChild(eid, parentEID) == nullptr) { parentedEIDS.push_back(eid); @@ -410,7 +419,7 @@ namespace SHADE void SHEntityParentCommand::Execute() { - auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + auto& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); for (auto const& eid : entities) { if (entityParentData[eid].newParentEID == MAX_EID) @@ -422,7 +431,7 @@ namespace SHADE void SHEntityParentCommand::Undo() { - auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + auto& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); for (auto const& eid : entities) { if (entityParentData[eid].oldParentEID == MAX_EID) diff --git a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h index 9b26e9d6..64f841d6 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h +++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h @@ -28,7 +28,7 @@ namespace SHADE void DrawMenuBar() const noexcept; ImRect RecursivelyDrawEntityNode(SHSceneNode* const); void CreateChildEntity(EntityID parentEID) const noexcept; - void ParentSelectedEntities(EntityID parentEID) const noexcept; + void ParentSelectedEntities(EntityID parentEID, std::vector const& entities) const noexcept; void SelectRangeOfEntities(EntityID beginEID, EntityID EndEID); void SelectAllEntities(); void CopySelectedEntities(); @@ -37,6 +37,8 @@ namespace SHADE std::string filter; bool isAnyNodeSelected = false; EntityID scrollTo = MAX_EID; + std::vector draggingEntities; + };//class SHHierarchyPanel //Might move to a different file diff --git a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp index 4777fc6a..85d10c1a 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp +++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp @@ -224,9 +224,6 @@ namespace SHADE if (!component) return; - // Get transform component for extrapolating relative sizes - auto* transformComponent = SHComponentManager::GetComponent_s(component->GetEID()); - const auto componentType = rttr::type::get(*component); SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active"); ImGui::SameLine(); @@ -234,45 +231,43 @@ namespace SHADE { DrawContextMenu(component); - auto& colliders = component->GetColliders(); + auto& colliders = component->GetCollisionShapes(); int const size = static_cast(colliders.size()); - ImGui::BeginChild("Colliders", { 0.0f, colliders.empty() ? 1.0f : 250.0f }, true); + ImGui::BeginChild("Collision Shapes", { 0.0f, colliders.empty() ? 1.0f : 250.0f }, true); std::optional colliderToDelete{ std::nullopt }; for (int i{}; i < size; ++i) { ImGui::PushID(i); - SHCollider* collider = &component->GetCollider(i); + SHCollisionShape* collider = &component->GetCollisionShape(i); auto cursorPos = ImGui::GetCursorPos(); - if (collider->GetType() == SHCollider::Type::BOX) + //collider->IsTrigger + + if (collider->GetType() == SHCollisionShape::Type::BOX) { - SHEditorWidgets::BeginPanel(std::format("{} Box Collider #{}", ICON_FA_CUBE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y }); + SHEditorWidgets::BeginPanel(std::format("{} Box #{}", ICON_FA_CUBE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y }); auto box = reinterpret_cast(collider->GetShape()); SHEditorWidgets::DragVec3 ( "Half Extents", { "X", "Y", "Z" }, - [box, transformComponent] { return (box->GetHalfExtents() * 2.0f) / transformComponent->GetWorldScale(); }, + [box] { return box->GetRelativeExtents(); }, [collider](SHVec3 const& vec) { collider->SetBoundingBox(vec); }); } - else if (collider->GetType() == SHCollider::Type::SPHERE) + else if (collider->GetType() == SHCollisionShape::Type::SPHERE) { - SHEditorWidgets::BeginPanel(std::format("{} Sphere Collider #{}", ICON_MD_CIRCLE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y }); + SHEditorWidgets::BeginPanel(std::format("{} Sphere #{}", ICON_MD_CIRCLE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y }); auto sphere = reinterpret_cast(collider->GetShape()); SHEditorWidgets::DragFloat ( "Radius", - [sphere, transformComponent] - { - const SHVec3& TF_WORLD_SCALE = transformComponent->GetWorldScale(); - const float MAX_SCALE = SHMath::Max({ TF_WORLD_SCALE.x, TF_WORLD_SCALE.y, TF_WORLD_SCALE.z }); - return sphere->GetRadius() / MAX_SCALE; - }, - [collider](float const& value) { collider->SetBoundingSphere(value); }); + [sphere] { return sphere->GetRelativeRadius(); }, + [collider](float const& value) { collider->SetBoundingSphere(value); }); } - else if (collider->GetType() == SHCollider::Type::CAPSULE) + else if (collider->GetType() == SHCollisionShape::Type::CAPSULE) { } + { SHEditorWidgets::BeginPanel("Offsets",{ ImGui::GetContentRegionAvail().x, 30.0f }); SHEditorWidgets::DragVec3("Position", { "X", "Y", "Z" }, [&collider] {return collider->GetPositionOffset(); }, [&collider](SHVec3 const& vec) {collider->SetPositionOffset(vec); }); @@ -297,6 +292,9 @@ namespace SHADE }); SHEditorWidgets::EndPanel(); } + + SHEditorWidgets::CheckBox("Is Trigger", [collider] { return collider->IsTrigger(); }, [collider](bool value) { collider->SetIsTrigger(value); }); + if (ImGui::Button(std::format("{} Remove Collider #{}", ICON_MD_REMOVE, i).data())) { colliderToDelete = i; @@ -368,6 +366,7 @@ namespace SHADE { DrawContextMenu(component); Handle const& mesh = component->GetMesh(); + Handle const& mat = component->GetMaterial(); SHEditorWidgets::DragDropReadOnlyField("Mesh", std::to_string(SHResourceManager::GetAssetID(mesh).value_or(0)).data(), [component]() { @@ -379,6 +378,19 @@ namespace SHADE component->SetMesh(SHResourceManager::LoadOrGet(id)); SHResourceManager::FinaliseChanges(); }, SHDragDrop::DRAG_RESOURCE); + + SHEditorWidgets::DragDropReadOnlyField("Material", mat ? std::to_string(SHResourceManager::GetAssetID(mat->GetBaseMaterial()).value_or(0)).data() : "", [component]() + { + Handle const& mat = component->GetMaterial(); + if(!mat) + return static_cast(0); + return SHResourceManager::GetAssetID(mat->GetBaseMaterial()).value_or(0); + }, + [component](AssetID const& id) + { + auto gfxSystem = SHSystemManager::GetSystem(); + component->SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(SHResourceManager::LoadOrGet(id))); + }, SHDragDrop::DRAG_RESOURCE); } else { diff --git a/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp b/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp new file mode 100644 index 00000000..13ecb9fa --- /dev/null +++ b/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp @@ -0,0 +1,257 @@ +#include "SHpch.h" +#include "Serialization/SHSerializationHelper.hpp" +#include "SHMaterialInspector.h" +#include "Editor/SHImGuiHelpers.hpp" +#include + +#include "Assets/SHAssetManager.h" +#include "Editor/IconsMaterialDesign.h" +#include "Editor/SHEditorWidgets.hpp" +#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" +#include "Resource/SHResourceManager.h" + +namespace SHADE +{ + SHMaterialInspector::SHMaterialInspector() + :SHEditorWindow("Material Inspector", ImGuiWindowFlags_MenuBar), isDirty(false), isNewMaterial(false), currentViewedMaterial(0) + { + } + + void SHMaterialInspector::OpenMaterial(AssetID const& assetId, bool isNew) noexcept + { + //Get mat data + if(isDirty) + return; + isDirty = isNew; + isOpen = true; + SetFocusToWindow(); + currentViewedMaterial = assetId; + + //currentMatSpec = //Get mat spec + + currentMatSpec = SHResourceManager::LoadOrGet(assetId); + currentMaterial = SHResourceManager::LoadOrGet(assetId); + } + + void SHMaterialInspector::Init() + { + SHEditorWindow::Init(); + } + + void SHMaterialInspector::Update() + { + SHEditorWindow::Update(); + + if (Begin()) + { + if(currentViewedMaterial) + { + DrawMenuBar(); + + //if (SHEditorWidgets::DragDropReadOnlyField("Vertex Shader", std::to_string(currentMatSpec->vertexShader), [&]() {return currentMatSpec->vertexShader; }, [&](AssetID const& id) {currentMatSpec->vertexShader = id; }, SHDragDrop::DRAG_RESOURCE)) + //{ + // isDirty = true; + // vertShaderHandle = SHResourceManager::LoadOrGet(currentMatSpec->vertexShader); + //} + //if (SHEditorWidgets::DragDropReadOnlyField("Fragment Shader", std::to_string(currentMatSpec->fragShader), [&]() {return currentMatSpec->fragShader; }, [&](AssetID const& id) {currentMatSpec->fragShader = id; }, SHDragDrop::DRAG_RESOURCE)) + //{ + // isDirty = true; + // fragShaderHandle = SHResourceManager::LoadOrGet(currentMatSpec->fragShader); + //} + + DrawShaderProperties(/*fragShaderHandle*/); + } + + } + ImGui::End(); + } + + void SHMaterialInspector::Exit() + { + SHEditorWindow::Exit(); + } + + void SHMaterialInspector::DrawMenuBar() + { + if (ImGui::BeginMenuBar()) + { + ImGui::BeginDisabled(!isDirty); + if(ImGui::Button(std::format("{} Save", ICON_MD_SAVE).data())) + { + //save + if(auto matAsset = SHAssetManager::GetData(currentViewedMaterial)) + { + YAML::Emitter out; + out << YAML::BeginSeq; + out << YAML::convert::encode(*currentMatSpec); + out << YAML::EndSeq; + matAsset->data = out.c_str(); + + Handle pipelineProperties = currentMaterial->GetShaderBlockInterface(); + for (int i = 0; i < static_cast(pipelineProperties->GetVariableCount()); ++i) + { + const std::string& PROP_NAME = pipelineProperties->GetVariableName(i); + const YAML::Node& PROP_NODE = currentMatSpec->properties[PROP_NAME.data()]; + if (PROP_NODE.IsDefined()) + { + const std::string& VAR_NAME = pipelineProperties->GetVariableName(i); + const SHShaderBlockInterface::Variable* VARIABLE = pipelineProperties->GetVariable(i); + switch (VARIABLE->type) + { + case SHADE::SHShaderBlockInterface::Variable::Type::FLOAT: + currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as()); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::INT: + currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as()); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2: + currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as()); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR3: + currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as()); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR4: + currentMaterial->SetProperty(VARIABLE->offset, PROP_NODE.as()); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::OTHER: + default: + continue; + break; + } + } + } + + if(SHAssetManager::SaveAsset(currentViewedMaterial)) + { + isDirty = false; + } + } + } + ImGui::EndDisabled(); + ImGui::EndMenuBar(); + } + } + + void SHMaterialInspector::DrawShaderProperties(/*Handle shaderModule*/) + { + /*if(!shaderModule) + return;*/ + auto gfxSystem = SHSystemManager::GetSystem(); + auto interface = gfxSystem->GetDefaultMaterialInstance()->GetBaseMaterial()->GetShaderBlockInterface(); + //auto interface = shaderModule->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface(SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE, SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA); + + int const varCount = static_cast(interface->GetVariableCount()); + + for (int i = 0; i < varCount; ++i) + { + auto variable = interface->GetVariable(i); + const std::string& VAR_NAME = interface->GetVariableName(i); + if(VAR_NAME.empty()) + continue; + switch (variable->type) + { + case SHShaderBlockInterface::Variable::Type::FLOAT: + isDirty |= SHEditorWidgets::DragFloat(VAR_NAME, + [&]() + { + if (currentMatSpec->properties[VAR_NAME].IsDefined()) + return currentMatSpec->properties[VAR_NAME].as(); + else + return 0.0f; + }, + [&](float const& value) + { + currentMatSpec->properties[VAR_NAME] = value; + } + ); + break; + case SHShaderBlockInterface::Variable::Type::INT: + isDirty |= SHEditorWidgets::DragInt(VAR_NAME, + [&]() + { + if (currentMatSpec->properties[VAR_NAME].IsDefined()) + return currentMatSpec->properties[VAR_NAME].as(); + else + return 0; + }, + [&](int const& value) + { + currentMatSpec->properties[VAR_NAME] = value; + } + ); + if(SHDragDrop::BeginTarget()) + { + if(AssetID* payload = SHDragDrop::AcceptPayload(SHDragDrop::DRAG_RESOURCE)) + { + currentMatSpec->properties[VAR_NAME] = *payload; + isDirty = true; + SHDragDrop::EndTarget(); + } + } + break; + case SHShaderBlockInterface::Variable::Type::VECTOR2: + isDirty |= SHEditorWidgets::DragVec2(VAR_NAME, { "X", "Y" }, + [&]() + { + if (currentMatSpec->properties[VAR_NAME].IsDefined()) + return currentMatSpec->properties[VAR_NAME].as(); + else + return SHVec2::Zero; + }, + [&](SHVec2 const& value) + { + currentMatSpec->properties[VAR_NAME] = value; + } + ); + break; + case SHShaderBlockInterface::Variable::Type::VECTOR3: + isDirty |= SHEditorWidgets::DragVec3(VAR_NAME, { "X", "Y", "Z" }, + [&]() + { + if (currentMatSpec->properties[VAR_NAME].IsDefined()) + return currentMatSpec->properties[VAR_NAME].as(); + else + return SHVec3::Zero; + }, + [&](SHVec3 const& value) + { + currentMatSpec->properties[VAR_NAME] = value; + } + ); + break; + case SHShaderBlockInterface::Variable::Type::VECTOR4: + isDirty |= SHEditorWidgets::DragVec4(VAR_NAME, { "X", "Y", "Z", "W" }, + [&]() + { + if (currentMatSpec->properties[VAR_NAME].IsDefined()) + return currentMatSpec->properties[VAR_NAME].as(); + else + return SHVec4::Zero; + }, + [&](SHVec4 const& value) + { + currentMatSpec->properties[VAR_NAME] = value; + } + ); + break; + case SHShaderBlockInterface::Variable::Type::OTHER: + isDirty |= SHEditorWidgets::InputText(VAR_NAME, + [&]() + { + if (currentMatSpec->properties[VAR_NAME].IsDefined()) + return currentMatSpec->properties[VAR_NAME].as(); + else + return std::string(); + }, + [&](std::string const& value) + { + currentMatSpec->properties[VAR_NAME] = value; + } + ); + default: + continue; + break; + } + } + } +} diff --git a/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.h b/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.h new file mode 100644 index 00000000..79885399 --- /dev/null +++ b/SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.h @@ -0,0 +1,33 @@ +#pragma once +#include "Assets/SHAssetMacros.h" +#include "Editor/EditorWindow/SHEditorWindow.h" +#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" +#include "Graphics/Shaders/SHVkShaderModule.h" +#include "Resource/SHHandle.h" + + +namespace SHADE +{ + class SHMaterialInspector final : public SHEditorWindow + { + public: + SHMaterialInspector(); + ~SHMaterialInspector() = default; + + void Init() override; + void Update() override; + void Exit() override; + + void OpenMaterial(AssetID const& assetId, bool isNew = false) noexcept; + private: + void DrawMenuBar(); + void DrawShaderProperties(/*Handle shaderModule*/); + + bool isDirty; + bool isNewMaterial; + AssetID currentViewedMaterial; + Handle currentMatSpec; + Handle currentMaterial; + Handle vertShaderHandle, fragShaderHandle; + }; +} diff --git a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp index 06c0c2ae..cfb36cd0 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp @@ -3,6 +3,7 @@ //#==============================================================# //|| SHADE Includes || //#==============================================================# +#include "Editor/SHEditorWidgets.hpp" #include "Editor/SHEditor.h" #include "SHEditorMenuBar.h" #include "Editor/IconsMaterialDesign.h" @@ -17,7 +18,14 @@ #include #include +#include "Assets/SHAssetManager.h" +#include "Assets/Asset Types/SHSceneAsset.h" +#include "Scene/SHSceneManager.h" #include "Serialization/SHSerialization.h" +#include "Serialization/Configurations/SHConfigurationManager.h" + + +const std::string LAYOUT_FOLDER_PATH{ std::string(ASSET_ROOT) + "/Editor/Layouts" }; namespace SHADE { @@ -38,8 +46,7 @@ namespace SHADE void SHEditorMenuBar::Init() { SHEditorWindow::Init(); - constexpr std::string_view path = "../../Assets/Editor/Layouts"; - for(auto const& entry : std::filesystem::directory_iterator(path)) + for(auto const& entry : std::filesystem::directory_iterator(LAYOUT_FOLDER_PATH)) { layoutPaths.push_back(entry.path()); } @@ -75,13 +82,17 @@ namespace SHADE { if (ImGui::BeginMenu("File")) { + if(ImGui::Selectable("New Scene")) + { + SHSystemManager::GetSystem()->NewScene(); + } if(ImGui::Selectable("Save")) { - SHSerialization::SerializeSceneToFile("../../Assets/Scenes/Test.SHADE"); + SHSystemManager::GetSystem()->SaveScene(); } if(ImGui::Selectable("Load")) { - SHSerialization::DeserializeSceneFromFile("../../Assets/Scenes/Test.SHADE"); + //SHSystemManager::GetSystem()->LoadScene() } ImGui::EndMenu(); } @@ -108,16 +119,22 @@ namespace SHADE auto* scriptEngine = static_cast(SHSystemManager::GetSystem()); scriptEngine->GenerateScriptsCsProjFile(); } + ImGui::BeginDisabled(SHSystemManager::GetSystem()->editorState != SHEditor::State::STOP); if (ImGui::Selectable("Build Scripts - Debug")) { auto* scriptEngine = static_cast(SHSystemManager::GetSystem()); + SHSerialization::SerializeSceneToFile(SHSceneManager::GetCurrentSceneAssetID()); scriptEngine->BuildScriptAssembly(true, true); + SHSceneManager::RestartScene(SHSceneManager::GetCurrentSceneAssetID()); } if (ImGui::Selectable("Build Scripts - Release")) { auto* scriptEngine = static_cast(SHSystemManager::GetSystem()); - scriptEngine->BuildScriptAssembly(false, true); + SHSerialization::SerializeSceneToFile(SHSceneManager::GetCurrentSceneAssetID()); + scriptEngine->BuildScriptAssembly(false, true); + SHSceneManager::RestartScene(SHSceneManager::GetCurrentSceneAssetID()); } + ImGui::EndDisabled(); ImGui::EndMenu(); } @@ -155,6 +172,35 @@ namespace SHADE } ImGui::EndMenu(); } + + if (ImGui::BeginMenu("Application Config")) + { + auto& appConfig = SHConfigurationManager::applicationConfig; + ImGui::InputText("Window Title", &appConfig.windowTitle); + ImGui::Checkbox("Start in Fullscreen", &appConfig.startInFullScreen); + SHEditorWidgets::DragN("Window Size", { "Width", "Height" }, { &appConfig.windowSize.x, &appConfig.windowSize.y }); + //ImGui::InputScalar("Starting Scene", ImGuiDataType_U32, &appConfig.startingSceneID); + auto sceneAsset = SHAssetManager::GetData(appConfig.startingSceneID); + + if(ImGui::BeginCombo("Starting Scne", sceneAsset ? sceneAsset->name.data() : "")) + { + auto scenes = SHAssetManager::GetAllRecordOfType(AssetType::SCENE); + for(auto const& scene : scenes) + { + if(ImGui::Selectable(scene.name.data())) + { + appConfig.startingSceneID = scene.id; + } + } + ImGui::EndCombo(); + } + if (ImGui::Button("Save")) + { + SHConfigurationManager::SaveApplicationConfig(); + } + ImGui::EndMenu(); + } + ImGui::EndMainMenuBar(); } @@ -175,13 +221,16 @@ namespace SHADE ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY); if(ImGui::SmallButton(ICON_MD_PLAY_ARROW)) { - const SHEditorStateChangeEvent STATE_CHANGE_EVENT + if(editor->SaveScene()) { - .previousState = editor->editorState - }; - editor->editorState = SHEditor::State::PLAY; + const SHEditorStateChangeEvent STATE_CHANGE_EVENT + { + .previousState = editor->editorState + }; + editor->editorState = SHEditor::State::PLAY; - SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_PLAY_EVENT); + SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_PLAY_EVENT); + } } ImGui::EndDisabled(); ImGui::BeginDisabled(editor->editorState == SHEditor::State::PAUSE); @@ -206,6 +255,7 @@ namespace SHADE editor->editorState = SHEditor::State::STOP; SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_STOP_EVENT); + editor->LoadScene(SHSceneManager::GetCurrentSceneAssetID()); } ImGui::EndDisabled(); ImGui::EndMenuBar(); diff --git a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp index b5a691d8..5f00cc37 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp @@ -19,7 +19,7 @@ namespace SHADE //|| Public Member Functions || //#==============================================================# SHEditorWindow::SHEditorWindow(std::string_view const& name, ImGuiWindowFlags const& inFlags) - : windowName(name), windowFlags(inFlags), io(ImGui::GetIO()) + :isOpen(true), isWindowHovered(false), windowName(name), windowFlags(inFlags), io(ImGui::GetIO()) { } @@ -68,5 +68,10 @@ namespace SHADE void SHEditorWindow::OnPosChange() { } + + void SHEditorWindow::SetFocusToWindow() + { + ImGui::SetWindowFocus(windowName.data()); + } }//namespace SHADE diff --git a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h index 239d8223..faacd8f2 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h +++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h @@ -34,6 +34,7 @@ namespace SHADE virtual bool Begin(); virtual void OnResize(); virtual void OnPosChange(); + virtual void SetFocusToWindow(); ImGuiWindowFlags windowFlags = 0; ImGuiIO& io; diff --git a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h index 5208c6d9..2fcde2b2 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h +++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h @@ -1,7 +1,8 @@ #pragma once -#include "MenuBar/SHEditorMenuBar.h" //Menu Bar -#include "HierarchyPanel/SHHierarchyPanel.h" //Hierarchy Panel -#include "Inspector/SHEditorInspector.h" //Inspector -#include "Profiling/SHEditorProfiler.h" //Profiler -#include "ViewportWindow/SHEditorViewport.h" //Editor Viewport -#include "AssetBrowser/SHAssetBrowser.h" //Asset Browser \ No newline at end of file +#include "MenuBar/SHEditorMenuBar.h" //Menu Bar +#include "HierarchyPanel/SHHierarchyPanel.h" //Hierarchy Panel +#include "Inspector/SHEditorInspector.h" //Inspector +#include "Profiling/SHEditorProfiler.h" //Profiler +#include "ViewportWindow/SHEditorViewport.h" //Editor Viewport +#include "AssetBrowser/SHAssetBrowser.h" //Asset Browser +#include "MaterialInspector/SHMaterialInspector.h" //Material Inspector \ No newline at end of file diff --git a/SHADE_Engine/src/Editor/SHEditor.cpp b/SHADE_Engine/src/Editor/SHEditor.cpp index cf5056a5..c4ad3459 100644 --- a/SHADE_Engine/src/Editor/SHEditor.cpp +++ b/SHADE_Engine/src/Editor/SHEditor.cpp @@ -45,7 +45,12 @@ #include #include +#include "Assets/SHAssetManager.h" +#include "Assets/Asset Types/SHSceneAsset.h" #include "Graphics/MiddleEnd/Interface/SHMousePickSystem.h" +#include "Scene/SHSceneManager.h" +#include "Serialization/SHSerialization.h" +#include "Tools/SHDebugDraw.h" RTTR_REGISTRATION { @@ -60,6 +65,10 @@ RTTR_REGISTRATION ); } +const std::string USER_LAYOUT_PATH{ std::string(ASSET_ROOT) + "/Editor/Layouts/UserLayout.ini" }; +const std::string DEFAULT_LAYOUT_PATH{ std::string(ASSET_ROOT) + "/Editor/Layouts/Default.ini" }; +const std::string FONT_FOLDER_PATH{ std::string(ASSET_ROOT) + "/Editor/Fonts/"}; + namespace SHADE { @@ -77,7 +86,6 @@ namespace SHADE //#==============================================================# void SHEditor::Init() { - IMGUI_CHECKVERSION(); if(auto context = ImGui::CreateContext()) { @@ -93,6 +101,8 @@ namespace SHADE SHEditorWindowManager::CreateEditorWindow(); SHEditorWindowManager::CreateEditorWindow(); SHEditorWindowManager::CreateEditorWindow(); + SHEditorWindowManager::CreateEditorWindow(); + SHEditorWindowManager::CreateEditorWindow(); io = &ImGui::GetIO(); @@ -100,7 +110,7 @@ namespace SHADE io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls io->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; //Enable for Multi-Viewports io->ConfigFlags |= ImGuiConfigFlags_DockingEnable; //Enable docking - io->IniFilename = "../../Assets/Editor/Layouts/UserLayout.ini"; + io->IniFilename = USER_LAYOUT_PATH.data(); io->ConfigWindowsMoveFromTitleBarOnly = true; InitLayout(); @@ -120,6 +130,17 @@ namespace SHADE window->Init(); } + /* Editor View Gridlines */ + SetUpGridLines(true, true); + // Handle state changes so that we only show in edit mode + std::shared_ptr> stateChangeEventReceiver + { + std::make_shared>(this, &SHEditor::onEditorStateChanged) + }; + SHEventManager::SubscribeTo(SH_EDITOR_ON_PLAY_EVENT, std::dynamic_pointer_cast(stateChangeEventReceiver)); + SHEventManager::SubscribeTo(SH_EDITOR_ON_PAUSE_EVENT, std::dynamic_pointer_cast(stateChangeEventReceiver)); + SHEventManager::SubscribeTo(SH_EDITOR_ON_STOP_EVENT, std::dynamic_pointer_cast(stateChangeEventReceiver)); + SHLOG_INFO("Successfully initialised SHADE Engine Editor") } @@ -134,7 +155,9 @@ namespace SHADE window->Update(); } } - + + RenderSceneNamePrompt(); + RenderUnsavedChangesPrompt(); //PollPicking(); if(ImGui::IsKeyDown(ImGuiKey_LeftShift) && ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyReleased(ImGuiKey_Z)) @@ -159,27 +182,172 @@ namespace SHADE } } + void SHEditor::RenderSceneNamePrompt() noexcept + { + if(isSceneNamePromptOpen) + { + ImGui::OpenPopup(sceneNamePromptName.data()); + } + + if(ImGui::BeginPopupModal(sceneNamePromptName.data(), &isSceneNamePromptOpen)) + { + static std::string newSceneName{}; + ImGui::Text("Enter new scene name"); + ImGui::InputText("##name", &newSceneName); + ImGui::BeginDisabled(newSceneName.empty()); + if(ImGui::Button("Save")) + { + SaveScene(newSceneName); + newSceneName.clear(); + isSceneNamePromptOpen = false; + ImGui::CloseCurrentPopup(); + } + ImGui::EndDisabled(); + ImGui::SameLine(); + if(ImGui::Button("Cancel")) + { + isSceneNamePromptOpen = false; + ImGui::CloseCurrentPopup(); + } + ImGui::EndPopup(); + } + } + + void SHEditor::RenderUnsavedChangesPrompt() noexcept + { + if(isUnsavedChangesPromptOpen) + { + ImGui::OpenPopup(unsavedChangesPromptName.data()); + } + + if(ImGui::BeginPopupModal(unsavedChangesPromptName.data(), &isUnsavedChangesPromptOpen)) + { + ImGui::Text("You have unsaved changes!"); + if(ImGui::Button("Save")) + { + isSceneNamePromptOpen = true; + } + ImGui::SameLine(); + if(ImGui::Button("Cancel")) + { + isUnsavedChangesPromptOpen = false; + ImGui::CloseCurrentPopup(); + } + } + } + void SHEditor::InitLayout() noexcept { if(!std::filesystem::exists(io->IniFilename)) { - std::filesystem::copy_file("../../Assets/Editor/Layouts/Default.ini", io->IniFilename); + std::filesystem::copy_file(DEFAULT_LAYOUT_PATH.data(), io->IniFilename); } //eventually load preferred layout here } void SHEditor::InitFonts() noexcept { - ImFont* mainFont = io->Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/Segoe UI.ttf", 20.f);//TODO: Change to config based assets path + ImFont* mainFont = io->Fonts->AddFontFromFileTTF(std::string(FONT_FOLDER_PATH + "Segoe UI.ttf").data(), 20.f);//TODO: Change to config based assets path ImFontConfig icons_config{}; icons_config.MergeMode = true; icons_config.GlyphOffset.y = 5.f; constexpr ImWchar icon_ranges_fa[] = { ICON_MIN_FA, ICON_MAX_FA, 0 }; - ImFont* UIFontFA = io->Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/fa-solid-900.ttf", 20.f, &icons_config, icon_ranges_fa); //TODO: Change to config based assets path + ImFont* UIFontFA = io->Fonts->AddFontFromFileTTF(std::string(FONT_FOLDER_PATH + "fa-solid-900.ttf").data(), 20.f, &icons_config, icon_ranges_fa); //TODO: Change to config based assets path constexpr ImWchar icon_ranges_md[] = { ICON_MIN_MD, ICON_MAX_16_MD, 0 }; - ImFont* UIFontMD = io->Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/MaterialIcons-Regular.ttf", 20.f, &icons_config, icon_ranges_md); //TODO: Change to config based assets path + ImFont* UIFontMD = io->Fonts->AddFontFromFileTTF(std::string(FONT_FOLDER_PATH + "MaterialIcons-Regular.ttf").data(), 20.f, &icons_config, icon_ranges_md); //TODO: Change to config based assets path io->Fonts->Build(); } + void SHEditor::SetUpGridLines(bool drawGrid, bool drawAxes) + { + // Clear existing lines + SHDebugDraw::ClearPersistentDraws(); + + static constexpr float DELTA = 1.0f; + static constexpr int EXTENT_COUNT = static_cast(500.0f /* TODO: Remove hard code */ / DELTA); + static constexpr float LINE_HALF_LENGTH = (DELTA * static_cast(EXTENT_COUNT)) * 0.5f; + + // Render Grid + static const SHColour GRID_COL = { 0.2f, 0.2f, 0.2f, 1.0f }; + if (drawGrid) + { + for (int i = 1; i < EXTENT_COUNT; ++i) + { + // X-Axis Lines + SHDebugDraw::PersistentLine + ( + GRID_COL, + SHVec3 { -LINE_HALF_LENGTH, 0.0f, i * DELTA }, + SHVec3 { LINE_HALF_LENGTH, 0.0f, i * DELTA } + ); + SHDebugDraw::PersistentLine + ( + GRID_COL, + SHVec3 { -LINE_HALF_LENGTH, 0.0f, i * -DELTA }, + SHVec3 { LINE_HALF_LENGTH, 0.0f, i * -DELTA } + ); + // Y-Axis Lines + SHDebugDraw::PersistentLine + ( + GRID_COL, + SHVec3 { i * DELTA, 0.0f, -LINE_HALF_LENGTH }, + SHVec3 { i * DELTA, 0.0f, LINE_HALF_LENGTH } + ); + SHDebugDraw::PersistentLine + ( + GRID_COL, + SHVec3 { -i * DELTA, 0.0f, -LINE_HALF_LENGTH }, + SHVec3 { -i * DELTA, 0.0f, LINE_HALF_LENGTH } + ); + } + } + + // Render World Axes + if (drawAxes || drawGrid) + { + const SHColour X_AXIS_COL = drawAxes ? SHColour::RED : GRID_COL; + const SHColour Y_AXIS_COL = drawAxes ? SHColour::GREEN : GRID_COL; + const SHColour Z_AXIS_COL = drawAxes ? SHColour::BLUE : GRID_COL; + // X + SHDebugDraw::PersistentLine + ( + X_AXIS_COL, + SHVec3 { -LINE_HALF_LENGTH, 0.0f, 0.0f }, + SHVec3 { LINE_HALF_LENGTH, 0.0f, 0.0f } + ); + // Y + SHDebugDraw::PersistentLine + ( + Y_AXIS_COL, + SHVec3 { 0.0f, -LINE_HALF_LENGTH, 0.0f }, + SHVec3 { 0.0f, LINE_HALF_LENGTH, 0.0f } + ); + // Z + SHDebugDraw::PersistentLine + ( + Z_AXIS_COL, + SHVec3 { 0.0f, 0.0f, -LINE_HALF_LENGTH }, + SHVec3 { 0.0f, 0.0f, LINE_HALF_LENGTH } + ); + } + } + + SHEventHandle SHEditor::onEditorStateChanged(SHEventPtr eventPtr) + { + auto eventData = reinterpret_cast*>(eventPtr.get()); + switch (editorState) + { + case State::PAUSE: + case State::STOP: + SetUpGridLines(true, true); + break; + case State::PLAY: + default: + SHDebugDraw::ClearPersistentDraws(); + break; + } + return eventData->handle; + } + void SHEditor::Exit() { for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values) @@ -337,9 +505,12 @@ namespace SHADE ImGui_ImplVulkan_DestroyFontUploadObjects(); - renderGraph->GetNode("ImGui Node")->GetSubpass("ImGui Draw")->AddExteriorDrawCalls([](Handle& cmd) { + renderGraph->GetNode("ImGui Node")->GetSubpass("ImGui Draw")->AddExteriorDrawCalls([](Handle& cmd) + { + cmd->BeginLabeledSegment("ImGui Draw"); ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), cmd->GetVkCommandBuffer()); - }); + cmd->EndLabeledSegment(); + }); #endif } @@ -366,6 +537,66 @@ namespace SHADE } } + void SHEditor::NewScene() + { + if(shWindow->IsUnsavedChanges()) + { + //Unsaved changes prompt + sceneToLoad = 0; + isUnsavedChangesPromptOpen = true; + } + else + { + SHSceneManager::RestartScene(0); + shWindow->ToggleUnsavedChanges(); + } + } + + bool SHEditor::SaveScene(std::string const& newSceneName) + { + auto const data = SHAssetManager::GetData(SHSceneManager::GetCurrentSceneAssetID()); + if (!data) + { + if (newSceneName.empty()) + { + //Prompt for scene name + isSceneNamePromptOpen = true; + return false; + } + //Else We have a new name + + SHSceneManager::SetCurrentSceneName(newSceneName); + SHSceneManager::SetCurrentSceneAssetID(SHAssetManager::CreateNewAsset(AssetType::SCENE, newSceneName)); + } + //Get data, if data is null, asset doesn't exist, prompt for a name and create a new asset with the name + + //serialize the scene + if(SHSerialization::SerializeSceneToFile(SHSceneManager::GetCurrentSceneAssetID())) + { + if(shWindow->IsUnsavedChanges()) + shWindow->ToggleUnsavedChanges(); + + return true; + } + return false; + } + + void SHEditor::LoadScene(AssetID const& assetID) noexcept + { + if(shWindow->IsUnsavedChanges()) + { + //Unsaved changes prompt + isUnsavedChangesPromptOpen = true; + sceneToLoad = assetID; + } + else + { + //Load the scene + sceneToLoad = 0; + SHSceneManager::RestartScene(assetID); + } + } + void SHEditor::NewFrame() { SDL_Event event; diff --git a/SHADE_Engine/src/Editor/SHEditor.h b/SHADE_Engine/src/Editor/SHEditor.h index 624069db..0f5a3aaa 100644 --- a/SHADE_Engine/src/Editor/SHEditor.h +++ b/SHADE_Engine/src/Editor/SHEditor.h @@ -17,13 +17,17 @@ #include "EditorWindow/SHEditorWindow.h" #include "Tools/SHLog.h" #include "Gizmos/SHTransformGizmo.h" - +#include "Events/SHEventDefines.h" +#include "Events/SHEvent.h" +#include "Graphics/Windowing/SHWindow.h" //#==============================================================# //|| Library Includes || //#==============================================================# #include +#include "Assets/SHAssetMacros.h" + namespace SHADE { //#==============================================================# @@ -170,9 +174,16 @@ namespace SHADE void InitBackend(); void SetSDLWindow(SDL_Window* inSDLWindow){sdlWindow = inSDLWindow;}; + void SetSHWindow(SHWindow* inWindow){shWindow = inWindow;} void PollPicking(); + void NewScene(); + + bool SaveScene(std::string const& newSceneName = {}); + + void LoadScene(AssetID const& assetID) noexcept; + // List of selected entities std::vector selectedEntities; @@ -190,16 +201,34 @@ namespace SHADE */ void Render(); + void RenderSceneNamePrompt() noexcept; + + void RenderUnsavedChangesPrompt() noexcept; + void InitLayout() noexcept; void InitFonts() noexcept; + void SetUpGridLines(bool drawGrid, bool drawAxes); + + SHEventHandle onEditorStateChanged(SHEventPtr eventPtr); + + bool isSceneNamePromptOpen = false; + + bool isUnsavedChangesPromptOpen = false; + + static constexpr std::string_view sceneNamePromptName = "Save scene as..."; + static constexpr std::string_view unsavedChangesPromptName = "Unsaved Changes"; + + AssetID sceneToLoad = 0; + // Handle to command pool used for ImGui Vulkan Backend Handle imguiCommandPool; // Handle to command buffer used for ImGui Vulkan Backend Handle imguiCommandBuffer; SDL_Window* sdlWindow {nullptr}; + SHWindow* shWindow {nullptr}; ImGuiIO* io{nullptr}; diff --git a/SHADE_Engine/src/Editor/SHEditorUI.cpp b/SHADE_Engine/src/Editor/SHEditorUI.cpp index f3760b4d..49cfbfd6 100644 --- a/SHADE_Engine/src/Editor/SHEditorUI.cpp +++ b/SHADE_Engine/src/Editor/SHEditorUI.cpp @@ -157,7 +157,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::Checkbox("#", &value); + return ImGui::Checkbox("##", &value); } bool SHEditorUI::InputInt(const std::string& label, int& value, bool* isHovered) { @@ -165,7 +165,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::InputInt("#", &value, + return ImGui::InputInt("##", &value, 1, 10, ImGuiInputTextFlags_EnterReturnsTrue); } @@ -176,7 +176,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - const bool CHANGED = InputInt("#", signedVal); + const bool CHANGED = InputInt("##", signedVal); if (CHANGED) { signedVal = std::clamp(signedVal, 0, std::numeric_limits::max()); @@ -190,7 +190,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::InputFloat("#", &value, + return ImGui::InputFloat("##", &value, 0.1f, 1.0f, "%.3f", ImGuiInputTextFlags_EnterReturnsTrue); } @@ -200,7 +200,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::InputDouble("#", &value, + return ImGui::InputDouble("##", &value, 0.1, 1.0, "%.3f", ImGuiInputTextFlags_EnterReturnsTrue); } @@ -210,7 +210,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::InputDouble("#", &value, + return ImGui::InputDouble("##", &value, 1.0, 45.0, "%.3f", ImGuiInputTextFlags_EnterReturnsTrue); } @@ -280,7 +280,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - const bool CHANGED = ImGui::InputText("#", &buffer[0], TEXT_FIELD_MAX_LENGTH); + const bool CHANGED = ImGui::InputText("##", &buffer[0], TEXT_FIELD_MAX_LENGTH); if (CHANGED) { value = std::string(buffer.data(), buffer.data() + TEXT_FIELD_MAX_LENGTH); @@ -288,7 +288,7 @@ namespace SHADE return CHANGED; } - bool SHEditorUI::InputGameObjectField(const std::string& label, uint32_t& value, bool* isHovered) + bool SHEditorUI::InputGameObjectField(const std::string& label, uint32_t& value, bool* isHovered, bool alwaysNull) { ImGui::Text(label.c_str()); if (isHovered) @@ -296,7 +296,7 @@ namespace SHADE ImGui::SameLine(); SHEntity* entity = SHEntityManager::GetEntityByID(value); std::ostringstream oss; - if (entity) + if (!alwaysNull && entity) { oss << value << ": " << entity->name; } @@ -314,6 +314,13 @@ namespace SHADE SHDragDrop::EndTarget(); } } + ImGui::SameLine(); + if (ImGui::Button("Clear")) + { + value = MAX_EID; + changed = true; + } + return changed; } @@ -327,7 +334,7 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - if (ImGui::BeginCombo("#", INITIAL_NAME.c_str(), ImGuiComboFlags_None)) + if (ImGui::BeginCombo("##", INITIAL_NAME.c_str(), ImGuiComboFlags_None)) { for (int i = 0; i < enumNames.size(); ++i) { diff --git a/SHADE_Engine/src/Editor/SHEditorUI.h b/SHADE_Engine/src/Editor/SHEditorUI.h index d4104639..4e8f4400 100644 --- a/SHADE_Engine/src/Editor/SHEditorUI.h +++ b/SHADE_Engine/src/Editor/SHEditorUI.h @@ -313,8 +313,12 @@ namespace SHADE /// Label used to identify this widget. /// Reference to the variable to store the result. /// + /// If set, the field displayed will always be blank regardless of specified + /// GameObject. + /// /// True if the value was changed. - static bool InputGameObjectField(const std::string& label, uint32_t& value, bool* isHovered = nullptr); + static bool InputGameObjectField(const std::string& label, uint32_t& value, bool* isHovered = nullptr, bool alwaysNull = false); /// /// Creates a combo box for enumeration input. /// diff --git a/SHADE_Engine/src/Editor/SHEditorWidgets.hpp b/SHADE_Engine/src/Editor/SHEditorWidgets.hpp index 053348d7..0855d68d 100644 --- a/SHADE_Engine/src/Editor/SHEditorWidgets.hpp +++ b/SHADE_Engine/src/Editor/SHEditorWidgets.hpp @@ -422,12 +422,13 @@ namespace SHADE ImGui::BeginGroup(); ImGui::PushID(label.data()); TextLabel(label); - bool const changed = ImGui::InputText("##", &text, ImGuiInputTextFlags_ReadOnly, nullptr, nullptr); + bool changed = ImGui::InputText("##", &text, ImGuiInputTextFlags_ReadOnly, nullptr, nullptr); if(SHDragDrop::BeginTarget()) { if(T* payload = SHDragDrop::AcceptPayload(dragDropTag)) { SHCommandManager::PerformCommand(std::reinterpret_pointer_cast(std::make_shared>(get(), *payload, set)), false); + changed = true; SHDragDrop::EndTarget(); } } diff --git a/SHADE_Engine/src/Events/SHEventDefines.h b/SHADE_Engine/src/Events/SHEventDefines.h index d649fabf..d7bbf5f0 100644 --- a/SHADE_Engine/src/Events/SHEventDefines.h +++ b/SHADE_Engine/src/Events/SHEventDefines.h @@ -11,9 +11,11 @@ constexpr SHEventIdentifier SH_ENTITY_CREATION_EVENT { 2 }; constexpr SHEventIdentifier SH_COMPONENT_ADDED_EVENT { 3 }; constexpr SHEventIdentifier SH_COMPONENT_REMOVED_EVENT { 4 }; constexpr SHEventIdentifier SH_SCENEGRAPH_CHANGE_PARENT_EVENT { 5 }; -constexpr SHEventIdentifier SH_PHYSICS_COLLIDER_ADDED_EVENT { 6 }; -constexpr SHEventIdentifier SH_PHYSICS_COLLIDER_REMOVED_EVENT { 7 }; -constexpr SHEventIdentifier SH_EDITOR_ON_PLAY_EVENT { 8 }; -constexpr SHEventIdentifier SH_EDITOR_ON_PAUSE_EVENT { 9 }; -constexpr SHEventIdentifier SH_EDITOR_ON_STOP_EVENT { 10 }; +constexpr SHEventIdentifier SH_SCENEGRAPH_ADD_CHILD_EVENT { 6 }; +constexpr SHEventIdentifier SH_SCENEGRAPH_REMOVE_CHILD_EVENT { 7 }; +constexpr SHEventIdentifier SH_PHYSICS_COLLIDER_ADDED_EVENT { 8 }; +constexpr SHEventIdentifier SH_PHYSICS_COLLIDER_REMOVED_EVENT { 9 }; +constexpr SHEventIdentifier SH_EDITOR_ON_PLAY_EVENT { 10 }; +constexpr SHEventIdentifier SH_EDITOR_ON_PAUSE_EVENT { 11 }; +constexpr SHEventIdentifier SH_EDITOR_ON_STOP_EVENT { 12 }; diff --git a/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.cpp b/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.cpp index da4bc292..36108628 100644 --- a/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.cpp +++ b/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.cpp @@ -64,6 +64,11 @@ namespace SHADE return bufferUsageFlags; } + uint32_t SHVkBuffer::GetSizeStored(void) const noexcept + { + return sizeStored; + } + /***************************************************************************/ /*! @@ -212,9 +217,11 @@ namespace SHADE &bufferInfo.operator VkBufferCreateInfo & (), // TODO: Verify if this works (can use RenderDoc to check buffer variables?) &allocCreateInfo, &tempBuffer, &stagingAlloc, &allocInfo); + SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eDeviceMemory, allocInfo.deviceMemory, "[Memory] Staging - " + name); // then assign it to the hpp version stagingBuffer = tempBuffer; + SET_VK_OBJ_NAME(device, vk::ObjectType::eBuffer, stagingBuffer, "[Buffer] Staging - " + name); // Just map, copy then unmap void* stagingBufferMappedPtr = nullptr; @@ -246,7 +253,11 @@ namespace SHADE auto result = vmaCreateBuffer(vmaAllocator, &bufferCreateInfo.operator VkBufferCreateInfo & (), &allocCreateInfo, - &tempBuffer, &alloc, &allocInfo); + &tempBuffer, &alloc, &allocInfo); +#ifdef _DEBUG + if (!name.empty()) + SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eDeviceMemory, allocInfo.deviceMemory, "[Memory] " + name); +#endif if (result != VK_SUCCESS) SHVulkanDebugUtil::ReportVkError(vk::Result(result), "Failed to create vulkan buffer. "); @@ -264,7 +275,7 @@ namespace SHADE */ /***************************************************************************/ - SHVkBuffer::SHVkBuffer(std::reference_wrapper allocator) noexcept + SHVkBuffer::SHVkBuffer(Handle logicalDevice, std::reference_wrapper allocator) noexcept : vkBuffer{} , stagingBuffer{} , sizeStored{ 0 } @@ -272,19 +283,23 @@ namespace SHADE , alloc {nullptr} , randomAccessOptimized{false} , vmaAllocator{allocator} + , device { logicalDevice } {} SHVkBuffer::SHVkBuffer( + Handle logicalDevice, uint32_t inSize, void* data, uint32_t srcSize, std::reference_wrapper allocator, vk::BufferUsageFlags bufferUsage, + const std::string& name, VmaMemoryUsage memUsage, VmaAllocationCreateFlags allocFlags ) noexcept - : SHVkBuffer(allocator) + : SHVkBuffer(logicalDevice, allocator) { + this->name = name; Init(inSize, data, srcSize, bufferUsage, memUsage, allocFlags); } @@ -299,6 +314,8 @@ namespace SHADE , bufferUsageFlags {rhs.bufferUsageFlags} , bufferCreateInfo { rhs.bufferCreateInfo } , allocCreateInfo { rhs.allocCreateInfo } + , name { std::move(rhs.name) } + , device { rhs.device } { rhs.vkBuffer = VK_NULL_HANDLE; @@ -320,6 +337,8 @@ namespace SHADE bufferCreateInfo = rhs.bufferCreateInfo; allocCreateInfo = rhs.allocCreateInfo; bufferUsageFlags = rhs.bufferUsageFlags; + name = std::move(rhs.name); + device = rhs.device; return *this; } @@ -397,6 +416,8 @@ namespace SHADE auto [tempBuffer, allocInfo] = createBuffer(sizeStored); vkBuffer = tempBuffer; + if (!name.empty()) + SET_VK_OBJ_NAME(device, vk::ObjectType::eBuffer, vkBuffer, "[Buffer] " + name); // This probably means that a HOST_CACHED memory type is used on allocation if (allocFlags & VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) diff --git a/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.h b/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.h index aeda7d18..1119342c 100644 --- a/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.h +++ b/SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.h @@ -12,6 +12,7 @@ namespace SHADE //using SHVkBufferUsageBits = vk::BufferUsageFlagBits; class SHVkCommandBuffer; + class SHVkLogicalDevice; class SHVkBuffer { @@ -51,6 +52,11 @@ namespace SHADE //VmaAllocator const& vmaAllocator; std::reference_wrapper vmaAllocator; + //! Name of this buffer if any + std::string name; + //! Handle to the logical device that created this buffer + Handle device; + /*-----------------------------------------------------------------------*/ /* PRIVATE MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ @@ -62,13 +68,15 @@ namespace SHADE /* CTORS AND DTORS */ /*-----------------------------------------------------------------------*/ SHVkBuffer (void) noexcept = delete; - SHVkBuffer (std::reference_wrapper allocator) noexcept; + SHVkBuffer (Handle logicalDevice, std::reference_wrapper allocator) noexcept; SHVkBuffer ( + Handle logicalDevice, uint32_t inSize, void* data, uint32_t srcSize, std::reference_wrapper allocator, - vk::BufferUsageFlags bufferUsage, + vk::BufferUsageFlags bufferUsage, + const std::string& name = "", VmaMemoryUsage memUsage = VMA_MEMORY_USAGE_AUTO, VmaAllocationCreateFlags allocFlags = {} ) noexcept; @@ -84,7 +92,7 @@ namespace SHADE uint32_t inSize, void* data, uint32_t srcSize, - vk::BufferUsageFlags bufferUsage, + vk::BufferUsageFlags bufferUsage, VmaMemoryUsage memUsage, VmaAllocationCreateFlags allocFlags ) noexcept; @@ -102,8 +110,9 @@ namespace SHADE /*-----------------------------------------------------------------------*/ /* SETTERS AND GETTERS */ /*-----------------------------------------------------------------------*/ - vk::Buffer GetVkBuffer (void) const noexcept; + vk::Buffer GetVkBuffer (void) const noexcept; vk::BufferUsageFlags GetUsageBits(void) const noexcept; + uint32_t GetSizeStored (void) const noexcept; template T GetDataFromMappedPointer(uint32_t index) const noexcept diff --git a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp index a744c795..cc35303b 100644 --- a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp +++ b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp @@ -105,6 +105,9 @@ namespace SHADE // Set the state to recording if the call above succeeded. cmdBufferState = SH_CMD_BUFFER_STATE::RECORDING; + + // Reset segment count + segmentDepth = 0; } /***************************************************************************/ @@ -282,6 +285,11 @@ namespace SHADE } + void SHVkCommandBuffer::SetLineWidth(float lineWidth) noexcept + { + vkCommandBuffer.setLineWidth(lineWidth); + } + /***************************************************************************/ /*! @@ -502,6 +510,41 @@ namespace SHADE SetState(SH_CMD_BUFFER_STATE::PENDING); } + void SHVkCommandBuffer::BeginLabeledSegment(const std::string& label) noexcept + { +#ifdef _DEBUG + static const std::array SEGMENT_COLOURS = + { + SHColour::LIGHTPINK, + SHColour::LIGHTBLUE, + SHColour::LIGHTGREEN, + SHColour::YELLOW, + SHColour::PINK, + SHColour::TEAL, + SHColour::LIME, + SHColour::ORANGE, + SHColour::VIOLET, + SHColour::MAROON, + SHColour::DARKGREEN, + SHColour::SANDYBROWN + }; + + const SHColour COLOR = SEGMENT_COLOURS[segmentDepth]; + ++segmentDepth; + if (segmentDepth >= static_cast(SEGMENT_COLOURS.size())) + segmentDepth = 0; + vkCommandBuffer.beginDebugUtilsLabelEXT(vk::DebugUtilsLabelEXT().setPLabelName(label.data()).setColor({ COLOR.x, COLOR.y, COLOR.z, COLOR.w })); +#endif + } + + void SHVkCommandBuffer::EndLabeledSegment() noexcept + { +#ifdef _DEBUG + vkCommandBuffer.endDebugUtilsLabelEXT(); + segmentDepth = std::max(segmentDepth - 1, 0); +#endif + } + //void SHVkCommandBuffer::PipelineBarrier(vk::PipelineStageFlags ) const noexcept //{ // //vkCommandBuffer.pipelineBarrier() diff --git a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h index 4c978c34..fc348487 100644 --- a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h +++ b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h @@ -7,6 +7,7 @@ #include "Resource/SHResourceLibrary.h" #include "Graphics/Pipeline/SHVkPipelineLayout.h" #include "Graphics/Pipeline/SHPipelineType.h" +#include "Math/SHColour.h" namespace SHADE { @@ -78,7 +79,10 @@ namespace SHADE std::array(SH_PIPELINE_TYPE::NUM_TYPES)> bindPointData; //! The push constant data for the command buffer - uint8_t pushConstantData[PUSH_CONSTANT_SIZE]; + uint8_t pushConstantData[PUSH_CONSTANT_SIZE]; + + //! Depth of segmenting of the command buffer (used for debug data) + int segmentDepth; /*-----------------------------------------------------------------------*/ /* PRIVATE MEMBER FUNCTIONS */ @@ -107,7 +111,7 @@ namespace SHADE void Reset(void); // Begins and Ends - void BeginRecording (void) noexcept; + void BeginRecording () noexcept; void EndRecording (void) noexcept; void BeginRenderpass (Handle const& renderpassHdl, Handle const& framebufferHdl, vk::Offset2D offset = {0, 0}, vk::Extent2D extent = {0, 0}) noexcept; void EndRenderpass (void) noexcept; @@ -115,6 +119,7 @@ namespace SHADE // Dynamic State void SetViewportScissor (float vpWidth, float vpHeight, uint32_t sWidth, uint32_t sHeight, float vpX = 0.0f, float vpY = 0.0f, int32_t sX = 0.0f, int32_t sY = 0.0f, float vpMinDepth = 0.0f, float vpMaxDepth = 1.0f) noexcept; + void SetLineWidth (float lineWidth) noexcept; // Binding Commands void BindPipeline (Handle const& pipelineHdl) noexcept; @@ -147,6 +152,10 @@ namespace SHADE bool IsReadyToSubmit (void) const noexcept; void HandlePostSubmit (void) noexcept; + // Debugging + void BeginLabeledSegment(const std::string& label) noexcept; + void EndLabeledSegment() noexcept; + // Push Constant variable setting template void SetPushConstantVariable(std::string variableName, T const& data, SH_PIPELINE_TYPE bindPoint) noexcept diff --git a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp index 0943c489..4be8cc9e 100644 --- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp +++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp @@ -119,6 +119,18 @@ namespace SHADE return setIndex; } + uint32_t SHVkDescriptorSetLayout::GetNumDynamicOffsetsRequired(void) const noexcept + { + uint32_t numDynamicBindings = 0; + for (auto& binding : layoutDesc) + { + if (binding.Type == vk::DescriptorType::eUniformBufferDynamic || binding.Type == vk::DescriptorType::eStorageBufferDynamic) + ++numDynamicBindings; + } + + return numDynamicBindings; + } + SHVkDescriptorSetLayout& SHVkDescriptorSetLayout::operator=(SHVkDescriptorSetLayout&& rhs) noexcept { if (&rhs == this) diff --git a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h index 1639901d..caa3c057 100644 --- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h +++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h @@ -99,6 +99,7 @@ namespace SHADE inline const vk::DescriptorSetLayout& GetVkHandle() const { return setLayout; } std::vector const& GetBindings (void) const noexcept; SetIndex GetSetIndex (void) const noexcept; + uint32_t GetNumDynamicOffsetsRequired (void) const noexcept; private: /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp index 6bf2e731..808ce750 100644 --- a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp +++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp @@ -220,6 +220,7 @@ namespace SHADE else { SHVulkanDebugUtil::ReportVkSuccess("Successfully created a Logical Device. "); + SET_VK_OBJ_NAME(this, vk::ObjectType::eDevice, vkLogicalDevice, "Logical Device"); } InitializeVMA(); @@ -419,9 +420,9 @@ namespace SHADE */ /***************************************************************************/ - Handle SHVkLogicalDevice::CreateBuffer(uint32_t inSize, void* data, uint32_t srcSize, vk::BufferUsageFlags bufferUsage, VmaMemoryUsage memUsage, VmaAllocationCreateFlags allocFlags) const noexcept + Handle SHVkLogicalDevice::CreateBuffer(uint32_t inSize, void* data, uint32_t srcSize, vk::BufferUsageFlags bufferUsage, VmaMemoryUsage memUsage, VmaAllocationCreateFlags allocFlags, const std::string& name) const noexcept { - return SHVkInstance::GetResourceManager().Create(inSize, data, srcSize, std::cref(vmaAllocator), bufferUsage, memUsage, allocFlags); + return SHVkInstance::GetResourceManager().Create(GetHandle(), inSize, data, srcSize, std::cref(vmaAllocator), bufferUsage, name, memUsage, allocFlags); } /***************************************************************************/ @@ -455,12 +456,12 @@ namespace SHADE /***************************************************************************/ Handle SHVkLogicalDevice::CreateImage(uint32_t w, uint32_t h, uint8_t levels, vk::Format format, vk::ImageUsageFlags usage, vk::ImageCreateFlags create) const noexcept { - return SHVkInstance::GetResourceManager().Create(&vmaAllocator, w, h, levels, format, usage, create); + return SHVkInstance::GetResourceManager().Create(GetHandle(), &vmaAllocator, w, h, levels, format, usage, create); } Handle SHVkLogicalDevice::CreateImage(SHImageCreateParams const& imageDetails, unsigned char* data, uint32_t dataSize, std::span inMipOffsets, VmaMemoryUsage memUsage, VmaAllocationCreateFlags allocFlags) noexcept { - return SHVkInstance::GetResourceManager().Create(&vmaAllocator, imageDetails, data, dataSize, inMipOffsets, memUsage, allocFlags); + return SHVkInstance::GetResourceManager().Create(GetHandle(), &vmaAllocator, imageDetails, data, dataSize, inMipOffsets, memUsage, allocFlags); } /***************************************************************************/ diff --git a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h index 2aa59941..158c20b2 100644 --- a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h +++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h @@ -1,5 +1,4 @@ -#ifndef SH_LOGICAL_DEVICE_H -#define SH_LOGICAL_DEVICE_H +#pragma once #include #include @@ -67,7 +66,6 @@ namespace SHADE class SHVkLogicalDevice : public ISelfHandle { private: - /*-----------------------------------------------------------------------*/ /* PRIVATE MEMBER VARIABLES */ /*-----------------------------------------------------------------------*/ @@ -147,7 +145,8 @@ namespace SHADE uint32_t srcSize, vk::BufferUsageFlags bufferUsage, VmaMemoryUsage memUsage, - VmaAllocationCreateFlags allocFlags + VmaAllocationCreateFlags allocFlags, + const std::string& name = "" ) const noexcept; Handle CreateImage ( @@ -202,7 +201,33 @@ namespace SHADE Handle CreateSemaphore (void) const noexcept; void UpdateDescriptorSets(std::vector const& writeDescSets) noexcept; - void UpdateDescriptorSet (vk::WriteDescriptorSet const& writeDescSet) noexcept; + void UpdateDescriptorSet(vk::WriteDescriptorSet const& writeDescSet) noexcept; + + /*-----------------------------------------------------------------------*/ + /* Debug Tools */ + /*-----------------------------------------------------------------------*/ +#ifdef _DEBUG + /// + /// Sets a Vulkan HPP object's name for debugging purposes. This function will not be + /// compiled outside of Debug configurations. Hence, it is advised to use provided + /// macro function SET_VK_OBJ_NAME() instead of using this function directly. + /// + /// Type of the object. + /// Handle to the Vulkan Object to name. + /// Object's name. + template + inline void SetVulkanObjectName(vk::ObjectType objType, T objHandle, const std::string& objName); + /// + /// Sets a Vulkan object's name for debugging purposes. This function will not be + /// compiled outside of Debug configurations. Hence, it is advised to use provided + /// macro function SET_VK_OBJ_NAME_VK() instead of using this function directly. + /// + /// Type of the object. + /// Handle to the Vulkan Object to name. + /// Object's name. + template + inline void SetVulkanObjectNameVk(vk::ObjectType objType, T objVkHandle, const std::string& objName); +#endif /*-----------------------------------------------------------------------*/ /* SETTERS AND GETTERS */ @@ -220,4 +245,4 @@ namespace SHADE }; } -#endif +#include "SHVkLogicalDevice.hpp" diff --git a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.hpp b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.hpp new file mode 100644 index 00000000..e8de27fb --- /dev/null +++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.hpp @@ -0,0 +1,61 @@ +/************************************************************************************//*! +\file SHVkLogicalDevice.hpp +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 4, 2022 +\brief Contains implementation of inline and template functions of + SHVkLogicalDevice. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +#include "SHVkLogicalDevice.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Debug Tools */ + /*-----------------------------------------------------------------------------------*/ +#ifdef _DEBUG + template + void SHVkLogicalDevice::SetVulkanObjectName(vk::ObjectType objType, T objHandle, const std::string& objName) + { + if (objName.empty()) + return; + + vk::DebugUtilsObjectNameInfoEXT info; + info.objectType = objType; + info.objectHandle = (uint64_t) static_cast(objHandle); + info.pObjectName = objName.data(); + vkLogicalDevice.setDebugUtilsObjectNameEXT(info); + } + template + void SHVkLogicalDevice::SetVulkanObjectNameVk(vk::ObjectType objType, T objVkHandle, const std::string& objName) + { + if (objName.empty()) + return; + + vk::DebugUtilsObjectNameInfoEXT info; + info.objectType = objType; + info.objectHandle = (uint64_t) objVkHandle; + info.pObjectName = objName.data(); + vkLogicalDevice.setDebugUtilsObjectNameEXT(info); + } +#endif +} + +/*-------------------------------------------------------------------------------------*/ +/* Macro Definitions */ +/*-------------------------------------------------------------------------------------*/ +#ifdef _DEBUG +#define SET_VK_OBJ_NAME(DEVICE, OBJ_TYPE, OBJ_HDL, OBJ_NAME) \ + DEVICE->SetVulkanObjectName(OBJ_TYPE, OBJ_HDL, OBJ_NAME); +#define SET_VK_OBJ_NAME_VK(DEVICE, OBJ_TYPE, OBJ_HDL, OBJ_NAME) \ + DEVICE->SetVulkanObjectNameVk(OBJ_TYPE, OBJ_HDL, OBJ_NAME); +#else +#define SET_VK_OBJ_NAME(DEVICE, OBJ_TYPE, OBJ_HDL, OBJ_NAME) +#define SET_VK_OBJ_NAME_VK(DEVICE, OBJ_TYPE, OBJ_HDL, OBJ_NAME) +#endif diff --git a/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp b/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp index 00cc31bf..33bed1b5 100644 --- a/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp +++ b/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp @@ -61,6 +61,7 @@ namespace SHADE &bufferInfo.operator VkBufferCreateInfo & (), // TODO: Verify if this works (can use renderdoc to check buffer variables?) &allocCreateInfo, &tempBuffer, &stagingAlloc, &allocInfo); + SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eDeviceMemory, allocInfo.deviceMemory, "[Memory] Staging Buffer for Image"); // then assign it to the hpp version stagingBuffer = tempBuffer; @@ -107,6 +108,8 @@ namespace SHADE VkImage tempImage; auto result = vmaCreateImage(*vmaAllocator, &imageCreateInfo.operator VkImageCreateInfo & (), &allocCreateInfo, &tempImage, &alloc, &allocInfo); vkImage = tempImage; + //SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eImage, vkImage, "[Image] "); + SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eDeviceMemory, allocInfo.deviceMemory, "[Device Memory] Image Memory"); if (result != VK_SUCCESS) SHVulkanDebugUtil::ReportVkError(vk::Result(result), "Failed to create vulkan image. "); @@ -115,7 +118,8 @@ namespace SHADE } SHVkImage::SHVkImage( - VmaAllocator const* allocator, + Handle logicalDeviceHdl, + VmaAllocator const* allocator, SHImageCreateParams const& imageDetails, const unsigned char* data, uint32_t dataSize, @@ -137,6 +141,7 @@ namespace SHADE , boundToCoherent{false} , randomAccessOptimized {false} , mappedPtr{nullptr} + , device { logicalDeviceHdl } { usageFlags = imageDetails.usageFlags; createFlags = imageDetails.createFlags; @@ -175,7 +180,9 @@ namespace SHADE VmaAllocationInfo allocInfo{}; VkImage tempImage; - auto result = vmaCreateImage(*vmaAllocator, &imageCreateInfo.operator VkImageCreateInfo&(), &allocCreateInfo, &tempImage, &alloc, &allocInfo); + auto result = vmaCreateImage(*vmaAllocator, &imageCreateInfo.operator VkImageCreateInfo & (), &allocCreateInfo, &tempImage, &alloc, &allocInfo); + //SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eImage, vkImage, "[Image] "); + SET_VK_OBJ_NAME_VK(device, vk::ObjectType::eDeviceMemory, allocInfo.deviceMemory, "[Device Memory] Image Memory"); if (result != VK_SUCCESS) SHVulkanDebugUtil::ReportVkError(vk::Result(result), "Failed to create vulkan image. "); @@ -220,7 +227,7 @@ namespace SHADE //} } - SHVkImage::SHVkImage(VmaAllocator const* allocator, uint32_t w, uint32_t h, uint8_t levels, vk::Format format, vk::ImageUsageFlags usage, vk::ImageCreateFlags create) noexcept + SHVkImage::SHVkImage(Handle logicalDeviceHdl, VmaAllocator const* allocator, uint32_t w, uint32_t h, uint8_t levels, vk::Format format, vk::ImageUsageFlags usage, vk::ImageCreateFlags create) noexcept : width {w} , height{h} , depth {1} @@ -230,11 +237,12 @@ namespace SHADE , usageFlags{usage} , createFlags {create} , vmaAllocator {allocator} + , device { logicalDeviceHdl } { CreateFramebufferImage(); } - Handle SHVkImage::CreateImageView(Handle const& inLogicalDeviceHdl, Handle const& parent, SHImageViewDetails const& createParams) const noexcept + Handle SHVkImage::CreateImageView(Handle inLogicalDeviceHdl, Handle const& parent, SHImageViewDetails const& createParams) const noexcept { return SHVkInstance::GetResourceManager().Create(inLogicalDeviceHdl, parent, createParams); } diff --git a/SHADE_Engine/src/Graphics/Images/SHVkImage.h b/SHADE_Engine/src/Graphics/Images/SHVkImage.h index 4fb16017..ba459def 100644 --- a/SHADE_Engine/src/Graphics/Images/SHVkImage.h +++ b/SHADE_Engine/src/Graphics/Images/SHVkImage.h @@ -104,6 +104,9 @@ namespace SHADE //! Mipmap offsets for initializing the vk::BufferImageCopy during transfer to GPU resource std::span mipOffsets; + //! Handle to the device that creates these images + Handle device; + /*-----------------------------------------------------------------------*/ /* PRIVATE MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ @@ -117,6 +120,7 @@ namespace SHADE SHVkImage(void) noexcept = default; SHVkImage( + Handle logicalDeviceHdl, VmaAllocator const* allocator, SHImageCreateParams const& imageDetails, const unsigned char* data, @@ -126,7 +130,7 @@ namespace SHADE VmaAllocationCreateFlags allocFlags ) noexcept; - SHVkImage(VmaAllocator const* allocator, uint32_t w, uint32_t h, uint8_t levels, vk::Format format, vk::ImageUsageFlags usage, vk::ImageCreateFlags create) noexcept; + SHVkImage(Handle logicalDeviceHdl, VmaAllocator const* allocator, uint32_t w, uint32_t h, uint8_t levels, vk::Format format, vk::ImageUsageFlags usage, vk::ImageCreateFlags create) noexcept; SHVkImage(SHVkImage&& rhs) noexcept = default; SHVkImage& operator=(SHVkImage && rhs) noexcept = default; @@ -134,7 +138,7 @@ namespace SHADE /*-----------------------------------------------------------------------*/ /* PUBLIC MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ - Handle CreateImageView (Handle const& inLogicalDeviceHdl, Handle const& parent, SHImageViewDetails const& createParams) const noexcept; + Handle CreateImageView (Handle inLogicalDeviceHdl, Handle const& parent, SHImageViewDetails const& createParams) const noexcept; void TransferToDeviceResource (Handle cmdBufferHdl) noexcept; void PrepareImageTransitionInfo (vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept; void HandleResizeFramebufferImage(uint32_t newWidth, uint32_t newHeight) noexcept; diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp index 22d1875b..1829096f 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp @@ -392,20 +392,23 @@ namespace SHADE SHVkUtil::EnsureBufferAndCopyHostVisibleData ( device, drawDataBuffer[frameIndex], drawData.data(), DRAW_DATA_BYTES, - BuffUsage::eIndirectBuffer + BuffUsage::eIndirectBuffer, + "Batch Draw Data Buffer" ); // - Transform Buffer const uint32_t TF_DATA_BYTES = static_cast(transformData.size() * sizeof(SHMatrix)); SHVkUtil::EnsureBufferAndCopyHostVisibleData ( device, transformDataBuffer[frameIndex], transformData.data(), TF_DATA_BYTES, - BuffUsage::eVertexBuffer + BuffUsage::eVertexBuffer, + "Batch Transform Buffer" ); const uint32_t EID_DATA_BYTES = static_cast(instancedIntegerData.size() * sizeof(SHInstancedIntegerData)); SHVkUtil::EnsureBufferAndCopyHostVisibleData ( device, instancedIntegerBuffer[frameIndex], instancedIntegerData.data(), EID_DATA_BYTES, - BuffUsage::eVertexBuffer + BuffUsage::eVertexBuffer, + "Batch Instance Data Buffer" ); // - Material Properties Buffer rebuildMaterialBuffers(frameIndex, descPool); @@ -427,6 +430,7 @@ namespace SHADE // Bind all required objects before drawing static std::array dynamicOffset{ 0 }; + cmdBuffer->BeginLabeledSegment("SHBatch"); cmdBuffer->BindPipeline(pipeline); cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::TRANSFORM, transformDataBuffer[frameIndex], 0); cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::INTEGER_DATA, instancedIntegerBuffer[frameIndex], 0); @@ -441,6 +445,7 @@ namespace SHADE ); } cmdBuffer->DrawMultiIndirect(drawDataBuffer[frameIndex], static_cast(drawData.size())); + cmdBuffer->EndLabeledSegment(); } /*---------------------------------------------------------------------------------*/ @@ -460,7 +465,8 @@ namespace SHADE SHVkUtil::EnsureBufferAndCopyHostVisibleData ( device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast(matPropsDataSize), - vk::BufferUsageFlagBits::eStorageBuffer + vk::BufferUsageFlagBits::eStorageBuffer, + "Batch Material Data" ); if (!matPropsDescSet[frameIndex]) @@ -470,6 +476,13 @@ namespace SHADE { SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE] }, { 0 } ); +#ifdef _DEBUG + const auto& DESC_SETS = matPropsDescSet[frameIndex]->GetVkHandle(); + for (auto descSet : DESC_SETS) + { + SET_VK_OBJ_NAME(device, vk::ObjectType::eDescriptorSet, descSet, "[Descriptor Set] Batch Material Data"); + } +#endif } std::array, 1> bufferList = { matPropsBuffer[frameIndex] }; matPropsDescSet[frameIndex]->ModifyWriteDescBuffer diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h index de137b28..c9dd4eda 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h @@ -88,6 +88,7 @@ namespace SHADE /* Getter Functions */ /*-----------------------------------------------------------------------------*/ Handle GetPipeline() const noexcept { return pipeline; }; + bool IsEmpty() const noexcept { return subBatches.empty(); } private: /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp index df389879..b827652e 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp @@ -68,6 +68,10 @@ namespace SHADE return; batch->Remove(renderable); + + // If batch is empty, remove batch + if (batch->IsEmpty()) + batches.erase(batch); } void SHSuperBatch::Clear() noexcept diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp index d5fb81bd..53adf2fe 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp @@ -13,14 +13,13 @@ namespace SHADE /* Static Definitions */ /*-----------------------------------------------------------------------------------*/ std::vector> SHGraphicsGlobalData::globalDescSetLayouts; - Handle SHGraphicsGlobalData::globalDescSets; SHVertexInputState SHGraphicsGlobalData::defaultVertexInputState; Handle SHGraphicsGlobalData::dummyPipelineLayout; void SHGraphicsGlobalData::InitHighFrequencyGlobalData(void) noexcept { - } + } /*-----------------------------------------------------------------------------------*/ /* Function Definitions */ @@ -45,7 +44,8 @@ namespace SHADE }; // For global data (generic data and textures) - Handle staticGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::STATIC_GLOBALS,{ genericDataBinding, texturesBinding }); + Handle staticGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::STATIC_GLOBALS, { genericDataBinding, texturesBinding }); + SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSetLayout, staticGlobalLayout->GetVkHandle(), "[Descriptor Set Layout] Static Globals"); std::vector lightBindings{}; @@ -71,22 +71,22 @@ namespace SHADE }); } - // For Dynamic global data (lights) Handle dynamicGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS, lightBindings); + SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSetLayout, dynamicGlobalLayout->GetVkHandle(), "[Descriptor Set Layout] Dynamic Globals"); - + // For High frequency global data (camera) SHVkDescriptorSetLayout::Binding cameraDataBinding { .Type = vk::DescriptorType::eUniformBufferDynamic, - .Stage = vk::ShaderStageFlagBits::eVertex, + .Stage = vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eCompute, .BindPoint = SHGraphicsConstants::DescriptorSetBindings::CAMERA_DATA, .DescriptorCount = 1, }; - - // For High frequency global data (camera) Handle cameraDataGlobalLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, { cameraDataBinding }); + SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSetLayout, cameraDataGlobalLayout->GetVkHandle(), "[Descriptor Set Layout] High Frequency Globals"); + // For per instance data (transforms, materials, etc.) SHVkDescriptorSetLayout::Binding materialDataBinding { .Type = vk::DescriptorType::eStorageBufferDynamic, @@ -94,9 +94,8 @@ namespace SHADE .BindPoint = SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA, .DescriptorCount = 1, }; - - // For High frequency global data (camera) Handle materialDataPerInstanceLayout = logicalDevice->CreateDescriptorSetLayout(SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE, { materialDataBinding }); + SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSetLayout, materialDataPerInstanceLayout->GetVkHandle(), "[Descriptor Set Layout] Material Globals"); globalDescSetLayouts.push_back(staticGlobalLayout); globalDescSetLayouts.push_back(dynamicGlobalLayout); diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h index 344c2616..439acba5 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h @@ -17,9 +17,6 @@ namespace SHADE //! Global descriptor set layouts. Used to allocate descriptor sets static std::vector> globalDescSetLayouts; - //! Global Descriptor sets - static Handle globalDescSets; - //! Default vertex input state (used by everything). static SHVertexInputState defaultVertexInputState; diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp new file mode 100644 index 00000000..daa6a23d --- /dev/null +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp @@ -0,0 +1,331 @@ +/************************************************************************************//*! +\file SHDebugDrawSystem.cpp +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Oct 16, 2022 +\brief Contains the definition of functions of the SHDebugDrawSystem class. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#include "SHpch.h" +#include "SHDebugDrawSystem.h" +// STL Includes +#include +// Project Includes +#include "Assets/Asset Types/SHModelAsset.h" +#include "../Meshes/SHPrimitiveGenerator.h" +#include "ECS_Base/Managers/SHSystemManager.h" +#include "SHGraphicsSystem.h" +#include "Graphics/Devices/SHVkLogicalDevice.h" +#include "../../SHVkUtil.h" +#include "Graphics/MiddleEnd/Interface/SHViewport.h" +#include "Graphics/MiddleEnd/Interface/SHRenderer.h" + +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* DrawRoutine */ + /*---------------------------------------------------------------------------------*/ + SHDebugDrawSystem::ProcessPointsRoutine::ProcessPointsRoutine() + : SHSystemRoutine("Debug Draw", true) + { + SystemFamily::GetID(); + } + + void SHDebugDrawSystem::ProcessPointsRoutine::Execute(double dt) noexcept + { + auto gfxSys = SHSystemManager::GetSystem(); + if (!gfxSys) + { + SHLOG_WARNING("[DebugDraw] Attempted to do debug draw without a graphics system."); + return; + } + + // Get the system + SHDebugDrawSystem* system = static_cast(GetSystem()); + + // Get current frame index + const uint32_t FRAME_IDX = gfxSys->GetCurrentFrameIndex(); + + /* Non-Persistent Buffer */ + // Update the buffer + system->numPoints[FRAME_IDX] = system->points.size(); + const uint32_t DATA_SIZE = sizeof(PointVertex) * system->points.size(); + if (DATA_SIZE > 0) + { + system->vertexBuffers[FRAME_IDX]->WriteToMemory(system->points.data(), DATA_SIZE, 0, 0); + } + + // Reset for next frame + system->points.clear(); + + /* Persistent Buffer */ + // Check if there are changes + if (system->persistentBuffersCleared[FRAME_IDX] + || + system->numPersistentPoints[FRAME_IDX] != system->persistentPoints.size()) + { + // Update Buffer + system->numPersistentPoints[FRAME_IDX] = system->persistentPoints.size(); + const uint32_t DATA_SIZE = sizeof(PointVertex) * system->persistentPoints.size(); + if (DATA_SIZE > 0) + { + system->persistentVertexBuffers[FRAME_IDX]->WriteToMemory(system->persistentPoints.data(), DATA_SIZE, 0, 0); + } + + // Reset Flag + system->persistentBuffersCleared[FRAME_IDX] = false; + } + } + + /*---------------------------------------------------------------------------------*/ + /* SHSystem overrides */ + /*---------------------------------------------------------------------------------*/ + void SHDebugDrawSystem::Init() + { + // Register function for subpass + const auto* GFX_SYSTEM = SHSystemManager::GetSystem(); + auto const& RENDERERS = GFX_SYSTEM->GetDefaultViewport()->GetRenderers(); + auto renderGraph = RENDERERS[SHGraphicsConstants::RenderGraphIndices::WORLD]->GetRenderGraph(); + auto subPass = renderGraph->GetNode("Debug Draw")->GetSubpass("Debug Draw"); + subPass->AddExteriorDrawCalls([this, GFX_SYSTEM](Handle& cmdBuffer) + { + // Get Current frame index + const uint32_t FRAME_IDX = GFX_SYSTEM->GetCurrentFrameIndex(); + + // Don't draw if no points + if (numPoints[FRAME_IDX] > 0) + { + cmdBuffer->BeginLabeledSegment("SHDebugDraw"); + cmdBuffer->BindPipeline(GFX_SYSTEM->GetDebugDrawPipeline()); + cmdBuffer->SetLineWidth(LineWidth); + cmdBuffer->BindVertexBuffer(0, vertexBuffers[FRAME_IDX], 0); + cmdBuffer->DrawArrays(numPoints[FRAME_IDX], 1, 0, 0); + } + }); + auto subPassWithDepth = renderGraph->GetNode("Debug Draw with Depth")->GetSubpass("Debug Draw with Depth"); + subPassWithDepth->AddExteriorDrawCalls([this, GFX_SYSTEM](Handle& cmdBuffer) + { + // Get Current frame index + const uint32_t FRAME_IDX = GFX_SYSTEM->GetCurrentFrameIndex(); + + // Don't draw if no points + if (numPersistentPoints[FRAME_IDX] > 0) + { + cmdBuffer->BeginLabeledSegment("SHDebugDraw (Persistent)"); + cmdBuffer->BindPipeline(GFX_SYSTEM->GetDebugDrawDepthPipeline()); + cmdBuffer->SetLineWidth(LineWidth); + cmdBuffer->BindVertexBuffer(0, persistentVertexBuffers[FRAME_IDX], 0); + cmdBuffer->DrawArrays(numPersistentPoints[FRAME_IDX], 1, 0, 0); + cmdBuffer->EndLabeledSegment(); + } + }); + + // Reset trackers + std::fill_n(numPoints.begin(), numPoints.size(), 0); + std::fill_n(numPersistentPoints.begin(), numPersistentPoints.size(), 0); + for (bool& cleared : persistentBuffersCleared) + cleared = true; + + // Allocate buffers + // - Non-Persistent Draws + static constexpr uint32_t BUFFER_SIZE = MAX_POINTS * sizeof(PointVertex); + for (Handle& bufHandle : vertexBuffers) + { + bufHandle = GFX_SYSTEM->GetDevice()->CreateBuffer + ( + BUFFER_SIZE, + nullptr, + 0, + vk::BufferUsageFlagBits::eVertexBuffer, + VmaMemoryUsage::VMA_MEMORY_USAGE_AUTO, + VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_MAPPED_BIT, + "Debug Draw Non-Persistent Vertex Buffer" + ); + } + // - Persistent Draws + for (Handle& bufHandle : persistentVertexBuffers) + { + bufHandle = GFX_SYSTEM->GetDevice()->CreateBuffer + ( + BUFFER_SIZE, + nullptr, + 0, + vk::BufferUsageFlagBits::eVertexBuffer, + VmaMemoryUsage::VMA_MEMORY_USAGE_AUTO, + VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_MAPPED_BIT, + "Debug Draw Persistent Vertex Buffer" + ); + } + } + + void SHDebugDrawSystem::Exit() + { + for (auto vertexBuffer : vertexBuffers) + { + if (vertexBuffer) + vertexBuffer.Free(); + } + for (auto vertexBuffer : persistentVertexBuffers) + { + if (vertexBuffer) + vertexBuffer.Free(); + } + } + + /*---------------------------------------------------------------------------------*/ + /* Draw Functions */ + /*---------------------------------------------------------------------------------*/ + void SHDebugDrawSystem::DrawLine(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt) + { + drawLine(points, color, startPt, endPt); + } + + void SHDebugDrawSystem::DrawTri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3) + { + drawPoly(points, color, { pt1, pt2, pt3 }); + } + + void SHDebugDrawSystem::DrawQuad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4) + { + drawPoly(points, color, { pt1, pt2, pt3, pt4 }); + } + + void SHDebugDrawSystem::DrawPoly(const SHVec4& color, std::initializer_list pointList) + { + drawPoly(points, color, pointList.begin(), pointList.end()); + } + + void SHDebugDrawSystem::DrawCube(const SHVec4& color, const SHVec3& pos, const SHVec3& size) + { + drawCube(points, color, pos, size); + } + + void SHDebugDrawSystem::DrawSphere(const SHVec4& color, const SHVec3& pos, double radius) + { + drawSphere(points, color, pos, radius); + } + + /*---------------------------------------------------------------------------------*/ + /* Persistent Draw Functions */ + /*---------------------------------------------------------------------------------*/ + void SHDebugDrawSystem::DrawPersistentLine(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt) + { + drawLine(persistentPoints, color, startPt, endPt); + } + + void SHDebugDrawSystem::DrawPersistentTri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3) + { + drawPoly(persistentPoints, color, { pt1, pt2, pt3 }); + } + + void SHDebugDrawSystem::DrawPersistentQuad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4) + { + drawPoly(persistentPoints, color, { pt1, pt2, pt3, pt4 }); + } + + void SHDebugDrawSystem::DrawPersistentPoly(const SHVec4& color, std::initializer_list pointList) + { + drawPoly(persistentPoints, color, pointList.begin(), pointList.end()); + } + + void SHDebugDrawSystem::DrawPersistentCube(const SHVec4& color, const SHVec3& pos, const SHVec3& size) + { + drawCube(persistentPoints, color, pos, size); + } + + void SHDebugDrawSystem::DrawPersistentSphere(const SHVec4& color, const SHVec3& pos, double radius) + { + drawSphere(persistentPoints, color, pos, radius); + } + + void SHDebugDrawSystem::ClearPersistentDraws() + { + persistentPoints.clear(); + for (bool& cleared : persistentBuffersCleared) + cleared = true; + } + + void SHDebugDrawSystem::drawLine(std::vector& storage, const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt) + { + if (storage.size() > MAX_POINTS) + { + SHLOG_WARNING("[DebugDraw] Exceeded maximum size of drawable debug elements."); + return; + } + + storage.emplace_back(PointVertex{ startPt, color }); + storage.emplace_back(PointVertex{ endPt, color }); + } + + void SHDebugDrawSystem::drawLineSet(std::vector& storage, const SHVec4& color, std::initializer_list pointList) + { + drawLineSet(storage, color, pointList.begin(), pointList.end()); + } + + void SHDebugDrawSystem::drawPoly(std::vector& storage, const SHVec4& color, std::initializer_list pointList) + { + drawPoly(storage, color, pointList.begin(), pointList.end()); + } + + void SHDebugDrawSystem::drawCube(std::vector& storage, const SHVec4& color, const SHVec3& pos, const SHVec3& size) + { + static const SHVec3 EXTENTS = SHVec3{ 0.5f, 0.5f, 0.5f }; + static const SHVec3 UNIT_BOT_LEFT_FRONT = SHVec3{ pos - EXTENTS }; + static const SHVec3 UNIT_BOT_RIGHT_FRONT = SHVec3{ pos + SHVec3 { EXTENTS.x, -EXTENTS.y, -EXTENTS.z } }; + static const SHVec3 UNIT_BOT_RIGHT_BACK = SHVec3{ pos + SHVec3 { EXTENTS.x, -EXTENTS.y, EXTENTS.z } }; + static const SHVec3 UNIT_BOT_LEFT_BACK = SHVec3{ pos + SHVec3 { -EXTENTS.x, -EXTENTS.y, EXTENTS.z } }; + static const SHVec3 UNIT_TOP_LEFT_BACK = SHVec3{ pos + SHVec3 { -EXTENTS.x, EXTENTS.y, EXTENTS.z } }; + static const SHVec3 UNIT_TOP_RIGHT_FRONT = SHVec3{ pos + SHVec3 { EXTENTS.x, EXTENTS.y, -EXTENTS.z } }; + static const SHVec3 UNIT_TOP_LEFT_FRONT = SHVec3{ pos + SHVec3 { -EXTENTS.x, EXTENTS.y, -EXTENTS.z } }; + static const SHVec3 UNIT_TOP_RIGHT_BACK = SHVec3{ pos + EXTENTS }; + + const SHVec3 BOT_LEFT_BACK = UNIT_BOT_LEFT_BACK * size; + const SHVec3 BOT_RIGHT_BACK = UNIT_BOT_RIGHT_BACK * size; + const SHVec3 BOT_LEFT_FRONT = UNIT_BOT_LEFT_FRONT * size; + const SHVec3 BOT_RIGHT_FRONT = UNIT_BOT_RIGHT_FRONT * size; + const SHVec3 TOP_LEFT_BACK = UNIT_TOP_LEFT_BACK * size; + const SHVec3 TOP_RIGHT_BACK = UNIT_TOP_RIGHT_BACK * size; + const SHVec3 TOP_LEFT_FRONT = UNIT_TOP_LEFT_FRONT * size; + const SHVec3 TOP_RIGHT_FRONT = UNIT_TOP_RIGHT_FRONT * size; + + drawLineSet + ( + storage, + color, + { + // Bottom Square + BOT_LEFT_BACK , BOT_RIGHT_BACK, + BOT_RIGHT_BACK , BOT_RIGHT_FRONT, + BOT_RIGHT_FRONT, BOT_LEFT_FRONT, + BOT_LEFT_FRONT , BOT_LEFT_BACK, + // Top Square + TOP_LEFT_BACK , TOP_RIGHT_BACK, + TOP_RIGHT_BACK , TOP_RIGHT_FRONT, + TOP_RIGHT_FRONT, TOP_LEFT_FRONT, + TOP_LEFT_FRONT , TOP_LEFT_BACK, + // Middle Lines + TOP_LEFT_BACK , BOT_LEFT_BACK, + TOP_RIGHT_BACK , BOT_RIGHT_BACK, + TOP_RIGHT_FRONT, BOT_RIGHT_FRONT, + TOP_LEFT_FRONT , BOT_LEFT_FRONT + } + ); + } + + void SHDebugDrawSystem::drawSphere(std::vector& storage, const SHVec4& color, const SHVec3& pos, double radius) + { + if (spherePoints.empty()) + { + // Generate + static const SHMeshData SPHERE = SHPrimitiveGenerator::Sphere(); + for (const auto& idx : SPHERE.Indices) + { + spherePoints.emplace_back(SPHERE.VertexPositions[idx] * radius); + } + } + drawLineSet(storage, color, spherePoints.begin(), spherePoints.end()); + } +} \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h new file mode 100644 index 00000000..20ddcd42 --- /dev/null +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h @@ -0,0 +1,253 @@ +/************************************************************************************//*! +\file SHDebugDrawSystem.h +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Oct 16, 2022 +\brief Contains the definition of the SHDebugDrawSystem class. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// STL Includes +#include +// Project Includes +#include "SH_API.h" +#include "Math/Vector/SHVec2.h" +#include "Math/Vector/SHVec3.h" +#include "Math/Vector/SHVec4.h" +#include "ECS_Base/System/SHSystem.h" +#include "ECS_Base/System/SHSystemRoutine.h" +#include "Resource/SHHandle.h" +#include "Graphics/Buffers/SHVkBuffer.h" +#include "SHGraphicsConstants.h" +#include "Math/SHColour.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Forward Declarations */ + /*-----------------------------------------------------------------------------------*/ + class SHVkBuffer; + + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + /// + /// Manages the Debug Draw system. + /// + class SH_API SHDebugDrawSystem final : public SHSystem + { + public: + /*---------------------------------------------------------------------------------*/ + /* System Routines */ + /*---------------------------------------------------------------------------------*/ + class SH_API ProcessPointsRoutine final : public SHSystemRoutine + { + public: + ProcessPointsRoutine(); + virtual void Execute(double dt) noexcept override final; + }; + + /*---------------------------------------------------------------------------------*/ + /* SHSystem overrides */ + /*---------------------------------------------------------------------------------*/ + virtual void Init() override final; + virtual void Exit() override final; + + /*---------------------------------------------------------------------------------*/ + /* Configuration Functions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Configures the line width used to draw all lines in the Debug Draw system. + /// + float LineWidth = 1.0f; + + /*---------------------------------------------------------------------------------*/ + /* Draw Functions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Renders a line between two points in world space. + /// + /// Colour of the line. + /// First point of the line. + /// Second point of the line. + void DrawLine(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt); + /// + /// Renders a triangle indicated by three points in world space. + /// + /// Colour of the triangle. + /// First point of the triangle. + /// Second point of the triangle. + /// Third point of the triangle. + void DrawTri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3); + /// + /// Renders a quadrilateral indicated by four points in world space. + /// + /// Colour of the quadrilateral. + /// First point of the triangle. + /// Second point of the quadrilateral. + /// Third point of the quadrilateral. + /// Third point of the quadrilateral. + void DrawQuad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4); + /// + /// Renders a polygon indicated by the specified set of points in world space. + /// + /// Colour of the polygon. + /// List of points for the polygon. + void DrawPoly(const SHVec4& color, std::initializer_list pointList); + /// + /// Renders a polygon indicated by the specified set of points in world space. + /// + /// Iterator for a STL-like container. + /// Colour of the polygon. + /// + /// Iterator to the first point of the point container. + /// + /// + /// One past last iterator of the point container. + /// + template + void DrawPoly(const SHVec4& color, IterType pointListBegin, IterType pointListEnd); + /// + /// Renders a wireframe cube centered around the position specified in world space. + /// + /// Colour of the cube. + /// Position where the cube wil be centered at. + /// Size of the rendered cube. + void DrawCube(const SHVec4& color, const SHVec3& pos, const SHVec3& size); + /// + /// Renders a wireframe sphere centered around the position specified in world space. + /// + /// Colour of the sphere. + /// Position where the sphere wil be centered at. + /// Size of the rendered sphere. + void DrawSphere(const SHVec4& color, const SHVec3& pos, double radius); + + /*---------------------------------------------------------------------------------*/ + /* Persistent Draw Functions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Renders a line between two points in world space that will persist until + /// ClearPersistentDraws() is called. These lines are depth tested. + /// + /// Colour of the line. + /// First point of the line. + /// Second point of the line. + void DrawPersistentLine(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt); + /// + /// Renders a triangle indicated by three points in world space that will persist + /// until ClearPersistentDraws() is called. These lines are depth tested. + /// + /// Colour of the triangle. + /// First point of the triangle. + /// Second point of the triangle. + /// Third point of the triangle. + void DrawPersistentTri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3); + /// + /// Renders a quadrilateral indicated by four points in world space that will persist + /// until ClearPersistentDraws() is called. These lines are depth tested. + /// + /// Colour of the quadrilateral. + /// First point of the triangle. + /// Second point of the quadrilateral. + /// Third point of the quadrilateral. + /// Third point of the quadrilateral. + void DrawPersistentQuad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4); + /// + /// Renders a polygon indicated by the specified set of points in world space that + /// will persist until ClearPersistentDraws() is called. These lines are depth + /// tested. + /// + /// Colour of the polygon. + /// List of points for the polygon. + void DrawPersistentPoly(const SHVec4& color, std::initializer_list pointList); + /// + /// Renders a polygon indicated by the specified set of points in world space that + /// will persist until ClearPersistentDraws() is called. These lines are depth + /// tested. + /// + /// Iterator for a STL-like container. + /// Colour of the polygon. + /// + /// Iterator to the first point of the point container. + /// + /// + /// One past last iterator of the point container. + /// + template + void DrawPersistentPoly(const SHVec4& color, IterType pointListBegin, IterType pointListEnd); + /// + /// Renders a wireframe cube centered around the position specified in world space + /// that will persist until ClearPersistentDraws() is called. These lines are depth + /// tested. + /// + /// Colour of the cube. + /// Position where the cube wil be centered at. + /// Size of the rendered cube. + void DrawPersistentCube(const SHVec4& color, const SHVec3& pos, const SHVec3& size); + /// + /// Renders a wireframe sphere centered around the position specified in world space + /// that will persist until ClearPersistentDraws() is called. These lines are depth + /// tested. + /// + /// Colour of the sphere. + /// Position where the sphere wil be centered at. + /// Size of the rendered sphere. + void DrawPersistentSphere(const SHVec4& color, const SHVec3& pos, double radius); + /// + /// Clears any persistent drawn debug primitives. + /// + void ClearPersistentDraws(); + + private: + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + struct SH_API PointVertex + { + SHVec4 Position; + SHVec4 Color; + }; + using TripleBuffer = std::array, SHGraphicsConstants::NUM_FRAME_BUFFERS>; + using TripleUInt = std::array; + using TripleBool = std::array; + + /*---------------------------------------------------------------------------------*/ + /* Constants */ + /*---------------------------------------------------------------------------------*/ + static constexpr uint32_t MAX_POINTS = 100'000; + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + // CPU Buffers + std::vector points; + std::vector persistentPoints; + // GPU Buffers + TripleBuffer vertexBuffers; + TripleUInt numPoints; + TripleBuffer persistentVertexBuffers; + TripleUInt numPersistentPoints; + TripleBool persistentBuffersCleared; + // Cached Points for polygon drawing + std::vector spherePoints; + + /*---------------------------------------------------------------------------------*/ + /* Helper Draw Functions */ + /*---------------------------------------------------------------------------------*/ + void drawLine(std::vector& storage, const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt); + void drawLineSet(std::vector& storage, const SHVec4& color, std::initializer_list pointList); + template + void drawLineSet(std::vector& storage, const SHVec4& color, IterType pointListBegin, IterType pointListEnd); + void drawPoly(std::vector& storage, const SHVec4& color, std::initializer_list pointList); + template + void drawPoly(std::vector& storage, const SHVec4& color, IterType pointListBegin, IterType pointListEnd); + void drawCube(std::vector& storage, const SHVec4& color, const SHVec3& pos, const SHVec3& size); + void drawSphere(std::vector& storage, const SHVec4& color, const SHVec3& pos, double radius); + }; +} + +#include "SHDebugDrawSystem.hpp" \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.hpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.hpp new file mode 100644 index 00000000..2a171e73 --- /dev/null +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.hpp @@ -0,0 +1,89 @@ +/************************************************************************************//*! +\file SHDebugDrawSystem.hpp +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Oct 16, 2022 +\brief Contains the definition of template functions the SHDebugDrawSystem + class. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once +#include "SHDebugDrawSystem.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Draw Functions */ + /*-----------------------------------------------------------------------------------*/ + template + void SHDebugDrawSystem::DrawPoly(const SHVec4& color, IterType pointListBegin, IterType pointListEnd) + { + drawPoly(points, color, pointListBegin, pointListEnd); + } + + /*-----------------------------------------------------------------------------------*/ + /* Helper Draw Functions */ + /*-----------------------------------------------------------------------------------*/ + template + void SHDebugDrawSystem::drawLineSet(std::vector& storage, const SHVec4& color, IterType pointListBegin, IterType pointListEnd) + { + // Ensure dereferenced type is SHVec3 + static_assert(std::is_same_v>, "Parameters to DrawPoly must be SHVec3."); + + // Check if points exceeded max + if (storage.size() > MAX_POINTS) + { + SHLOG_WARNING("[DebugDraw] Exceeded maximum size of drawable debug elements."); + return; + } + + const size_t POINTS_COUNT = pointListEnd - pointListBegin; + // Invalid polygon + if (POINTS_COUNT < 2) + { + SHLOG_WARNING("[SHDebugDraw] Invalid polygon provided to DrawPoly()."); + return; + } + + const size_t POINTS_ROUNDED_COUNT = POINTS_COUNT / 2 * 2; + for (auto pointIter = pointListBegin; pointIter != (pointListBegin + POINTS_ROUNDED_COUNT); ++pointIter) + { + storage.emplace_back(PointVertex{ *pointIter, color }); + } + } + template + void SHDebugDrawSystem::drawPoly(std::vector& storage, const SHVec4& color, IterType pointListBegin, IterType pointListEnd) + { + // Ensure dereferenced type is SHVec3 + static_assert(std::is_same_v>, "Parameters to DrawPoly must be SHVec3."); + + // Check if points exceeded max + if (storage.size() > MAX_POINTS) + { + SHLOG_WARNING("[DebugDraw] Exceeded maximum size of drawable debug elements."); + return; + } + + const size_t POINTS_COUNT = pointListEnd - pointListBegin; + // Invalid polygon + if (POINTS_COUNT < 2) + { + SHLOG_WARNING("[SHDebugDraw] Invalid polygon provided to DrawPoly()."); + return; + } + + // Trace the polygon + for (auto pointIter = pointListBegin + 1; pointIter != pointListEnd; ++pointIter) + { + storage.emplace_back(PointVertex{ *(pointIter - 1), color }); + storage.emplace_back(PointVertex{ *pointIter , color }); + } + + // Close the line loop + storage.emplace_back(PointVertex{ *(pointListEnd - 1), color }); + storage.emplace_back(PointVertex{ *pointListBegin , color }); + } +} \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h index a39ec10e..0a67cd9f 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h @@ -70,7 +70,17 @@ namespace SHADE */ /***************************************************************************/ static constexpr uint32_t RENDERGRAPH_RESOURCE = 4; - + /***************************************************************************/ + /*! + \brief + DescriptorSet Index for render graph node compute resources. For data + that we wish to pass to compute shaders in the render graph, this is + the set to use. Unlike the sets from 1 to 3, this set index does not have + hard coded bindings and is NOT part of the layouts included in the global + data. + */ + /***************************************************************************/ + static constexpr uint32_t RENDERGRAPH_NODE_COMPUTE_RESOURCE = 5; }; @@ -119,6 +129,7 @@ namespace SHADE */ /***************************************************************************/ static constexpr uint32_t BATCHED_PER_INST_DATA = 0; + }; struct VertexBufferBindings diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp index 007c8639..15c8ec5d 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp @@ -1,5 +1,5 @@ /************************************************************************************//*! -\file SHGraphicsSystem.cpp +\file SHGrphicsSystem.cpp \author Tng Kah Wei, kahwei.tng, 390009620 \par email: kahwei.tng\@digipen.edu \date Aug 21, 2022 @@ -39,6 +39,9 @@ of DigiPen Institute of Technology is prohibited. #include "Graphics/MiddleEnd/Lights/SHLightingSubSystem.h" #include "Assets/SHAssetManager.h" #include "Resource/SHResourceManager.h" +#include "Graphics/SHVkUtil.h" +#include "Graphics/RenderGraph/SHRenderGraphNodeCompute.h" +#include "../Meshes/SHPrimitiveGenerator.h" namespace SHADE { @@ -50,7 +53,11 @@ namespace SHADE /* BACKEND BOILERPLATE */ /*-----------------------------------------------------------------------*/ // Set Up Instance + #ifdef _DEBUG SHVkInstance::Init(true, true, true); + #else + SHVkInstance::Init(true, false, true); + #endif // Get Physical Device and Construct Logical Device physicalDevice = SHVkInstance::CreatePhysicalDevice(SH_PHYSICAL_DEVICE_TYPE::BEST); @@ -111,7 +118,11 @@ namespace SHADE // Load Built In Shaders static constexpr AssetID VS_DEFAULT = 39210065; defaultVertShader = SHResourceManager::LoadOrGet(VS_DEFAULT); static constexpr AssetID FS_DEFAULT = 46377769; defaultFragShader = SHResourceManager::LoadOrGet(FS_DEFAULT); + static constexpr AssetID VS_DEBUG = 48002439; debugVertShader = SHResourceManager::LoadOrGet(VS_DEBUG); + static constexpr AssetID FS_DEBUG = 36671027; debugFragShader = SHResourceManager::LoadOrGet(FS_DEBUG); static constexpr AssetID CS_COMPOSITE = 45072428; deferredCompositeShader = SHResourceManager::LoadOrGet(CS_COMPOSITE); + static constexpr AssetID SSAO = 38430899; ssaoShader = SHResourceManager::LoadOrGet(SSAO); + static constexpr AssetID SSAO_BLUR = 39760835; ssaoBlurShader = SHResourceManager::LoadOrGet(SSAO_BLUR); } void SHGraphicsSystem::InitSceneRenderGraph(void) noexcept @@ -150,55 +161,122 @@ namespace SHADE renderContextCmdPools[i] = renderContext.GetFrameData(i).cmdPoolHdls[0]; } + /*-----------------------------------------------------------------------*/ + /* SCENE RENDER GRAPH RESOURCES */ + /*-----------------------------------------------------------------------*/ // Initialize world render graph - worldRenderGraph->Init(device, swapchain); + worldRenderGraph->Init("World Render Graph", device, swapchain); worldRenderGraph->AddResource("Position", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second, vk::Format::eR32G32B32A32Sfloat); worldRenderGraph->AddResource("Normals", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second, vk::Format::eR32G32B32A32Sfloat); + //worldRenderGraph->AddResource("Tangents", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second, vk::Format::eR32G32B32A32Sfloat); worldRenderGraph->AddResource("Albedo", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second); worldRenderGraph->AddResource("Depth Buffer", { SH_ATT_DESC_TYPE_FLAGS::DEPTH_STENCIL }, windowDims.first, windowDims.second, vk::Format::eD32SfloatS8Uint); worldRenderGraph->AddResource("Entity ID", { SH_ATT_DESC_TYPE_FLAGS::COLOR }, windowDims.first, windowDims.second, vk::Format::eR32Uint, 1, vk::ImageUsageFlagBits::eTransferSrc); worldRenderGraph->AddResource("Light Layer Indices", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second, vk::Format::eR32Uint, 1, vk::ImageUsageFlagBits::eTransferSrc); worldRenderGraph->AddResource("Scene", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second); + worldRenderGraph->AddResource("SSAO", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second, vk::Format::eR8Unorm); + worldRenderGraph->AddResource("SSAO Blur", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT, SH_ATT_DESC_TYPE_FLAGS::STORAGE }, windowDims.first, windowDims.second, vk::Format::eR8Unorm); + /*-----------------------------------------------------------------------*/ + /* MAIN NODE */ + /*-----------------------------------------------------------------------*/ auto gBufferNode = worldRenderGraph->AddNode("G-Buffer", { "Position", "Entity ID", "Light Layer Indices", "Normals", + //"Tangents", "Albedo", "Depth Buffer", - "Scene" + "Scene", + "SSAO", + "SSAO Blur" }, {}); // no predecessors + /*-----------------------------------------------------------------------*/ + /* G-BUFFER SUBPASS INIT */ + /*-----------------------------------------------------------------------*/ auto gBufferSubpass = gBufferNode->AddSubpass("G-Buffer Write"); gBufferSubpass->AddColorOutput("Position"); gBufferSubpass->AddColorOutput("Entity ID"); gBufferSubpass->AddColorOutput("Light Layer Indices"); gBufferSubpass->AddColorOutput("Normals"); + //gBufferSubpass->AddColorOutput("Tangents"); gBufferSubpass->AddColorOutput("Albedo"); gBufferSubpass->AddDepthOutput("Depth Buffer", SH_ATT_DESC_TYPE_FLAGS::DEPTH_STENCIL); - // deferred composite - gBufferNode->AddNodeCompute(deferredCompositeShader, { "Position", "Normals", "Albedo", "Light Layer Indices", "Scene" }); + /*-----------------------------------------------------------------------*/ + /* SSAO PASS AND DATA INIT */ + /*-----------------------------------------------------------------------*/ + ssaoStorage = resourceManager.Create(); + + ssaoTransferCmdBuffer = graphicsCmdPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY); + SET_VK_OBJ_NAME(device, vk::ObjectType::eCommandBuffer, ssaoTransferCmdBuffer->GetVkCommandBuffer(), "[Command Buffer] SSAO Pass (Graphics)"); + ssaoTransferCmdBuffer->BeginRecording(); + + ssaoStorage->Init(device, ssaoTransferCmdBuffer); + + ssaoTransferCmdBuffer->EndRecording(); + graphicsQueue->SubmitCommandBuffer({ ssaoTransferCmdBuffer }); + // Set up Debug Draw Passes + // - Depth Tested + auto debugDrawNodeDepth = worldRenderGraph->AddNode("Debug Draw with Depth", { "Scene", "Depth Buffer" }, {"G-Buffer"}); + auto debugDrawDepthSubpass = debugDrawNodeDepth->AddSubpass("Debug Draw with Depth"); + debugDrawDepthSubpass->AddColorOutput("Scene"); + debugDrawDepthSubpass->AddDepthOutput("Depth Buffer"); + // - No Depth Test + auto debugDrawNode = worldRenderGraph->AddNode("Debug Draw", { "Scene" }, { "Debug Draw with Depth" }); + auto debugDrawSubpass = debugDrawNode->AddSubpass("Debug Draw"); + debugDrawSubpass->AddColorOutput("Scene"); + + graphicsQueue->WaitIdle(); + + ssaoStorage->PrepareRotationVectorsVkData(device); + + Handle ssaoPass = gBufferNode->AddNodeCompute("SSAO", ssaoShader, { "Position", "Normals", "SSAO" }); + auto ssaoDataBuffer = ssaoStorage->GetBuffer(); + ssaoPass->ModifyWriteDescBufferComputeResource(SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_NODE_COMPUTE_RESOURCE, SHSSAO::DESC_SET_BUFFER_BINDING, { &ssaoDataBuffer, 1 }, 0, ssaoStorage->GetBuffer()->GetSizeStored()); + auto viewSamplerLayout = ssaoStorage->GetViewSamplerLayout(); + + ssaoPass->ModifyWriteDescImageComputeResource(SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_NODE_COMPUTE_RESOURCE, SHSSAO::DESC_SET_IMAGE_BINDING, {&viewSamplerLayout, 1}); - auto dummyNode = worldRenderGraph->AddNode("Dummy Pass", { "Scene" }, {"G-Buffer"}); // no predecessors + Handle ssaoBlurPass = gBufferNode->AddNodeCompute("SSAO Blur Step", ssaoBlurShader, {"SSAO", "SSAO Blur"}); + + /*-----------------------------------------------------------------------*/ + /* DEFERRED COMPOSITE SUBPASS INIT */ + /*-----------------------------------------------------------------------*/ + gBufferNode->AddNodeCompute("Deferred Composite", deferredCompositeShader, {"Position", "Normals", "Albedo", "Light Layer Indices", "SSAO Blur", "Scene"}); + + // Dummy Node + auto dummyNode = worldRenderGraph->AddNode("Dummy Pass", { "Scene" }, { "Debug Draw" }); // no predecessors auto dummySubpass = dummyNode->AddSubpass("Dummy Subpass"); dummySubpass->AddInput("Scene"); - + /*-----------------------------------------------------------------------*/ + /* GENERATE RENDER GRAPH */ + /*-----------------------------------------------------------------------*/ // Generate world render graph worldRenderGraph->Generate(); + /*-----------------------------------------------------------------------*/ + /* BIND RENDER GRAPH TO RENDERER */ + /*-----------------------------------------------------------------------*/ // Add world renderer to default viewport worldRenderer = worldViewport->AddRenderer(resourceManager, swapchain->GetNumImages(), renderContextCmdPools, descPool, SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS], worldRenderGraph); worldRenderer->SetCamera(worldCamera); worldRenderer->SetCameraDirector(cameraSystem->CreateDirector()); - defaultMaterial = AddMaterial(defaultVertShader, defaultFragShader, gBufferSubpass); + // Create debug draw pipeline + debugDrawPipeline = createDebugDrawPipeline(debugDrawNode->GetRenderpass(), debugDrawSubpass); + SET_VK_OBJ_NAME(device, vk::ObjectType::ePipeline, debugDrawPipeline->GetVkPipeline(), "[Pipeline] Debug Draw"); + SET_VK_OBJ_NAME(device, vk::ObjectType::ePipelineLayout, debugDrawPipeline->GetPipelineLayout()->GetVkPipelineLayout(), "[Pipeline Layout] Debug Draw Pipeline Layout"); + debugDrawDepthPipeline = createDebugDrawPipeline(debugDrawNodeDepth->GetRenderpass(), debugDrawDepthSubpass); + SET_VK_OBJ_NAME(device, vk::ObjectType::ePipeline, debugDrawDepthPipeline->GetVkPipeline(), "[Pipeline Layout] Debug Draw with Depth Test"); + SET_VK_OBJ_NAME(device, vk::ObjectType::ePipelineLayout, debugDrawDepthPipeline->GetPipelineLayout()->GetVkPipelineLayout(), "[Pipeline] Debug Draw with Depth Test Pipeline Layout"); } void SHGraphicsSystem::InitMiddleEnd(void) noexcept @@ -239,6 +317,29 @@ namespace SHADE lightingSubSystem->Init(device, descPool); } + void SHGraphicsSystem::InitBuiltInResources(void) + { + // Create default texture + std::array defaultTextureData = { 255, 255, 255, 255 }; + std::vector mipOffsets{}; + mipOffsets.push_back(0); + defaultTexture = AddTexture(4, defaultTextureData.data(), 1, 1, SHTexture::TextureFormat::eR8G8B8A8Unorm, mipOffsets); + BuildTextures(); + + // Create default meshes + primitiveMeshes[static_cast(PrimitiveType::Cube)] = SHPrimitiveGenerator::Cube(meshLibrary); + primitiveMeshes[static_cast(PrimitiveType::Sphere)] = SHPrimitiveGenerator::Sphere(meshLibrary); + BuildMeshBuffers(); + + // Create default materials + defaultMaterial = AddMaterial + ( + defaultVertShader, defaultFragShader, + worldRenderGraph->GetNode("G-Buffer")->GetSubpass("G-Buffer Write") + ); + defaultMaterial->SetProperty("data.textureIndex", defaultTexture->TextureArrayIndex); + } + #ifdef SHEDITOR void SHGraphicsSystem::InitEditorRenderGraph(void) noexcept { @@ -254,7 +355,7 @@ namespace SHADE for (uint32_t i = 0; i < renderContextCmdPools.size(); ++i) renderContextCmdPools[i] = renderContext.GetFrameData(i).cmdPoolHdls[0]; - editorRenderGraph->Init(device, swapchain); + editorRenderGraph->Init("Editor Render Graph", device, swapchain); editorRenderGraph->AddResource("Present", { SH_ATT_DESC_TYPE_FLAGS::COLOR_PRESENT }, windowDims.first, windowDims.second); @@ -279,8 +380,7 @@ namespace SHADE InitBoilerplate(); InitMiddleEnd(); InitSubsystems(); - - + InitBuiltInResources(); } void SHGraphicsSystem::Exit(void) @@ -342,6 +442,17 @@ namespace SHADE auto cameraSystem = SHSystemManager::GetSystem(); + { +#ifdef SHEDITOR + auto editorSystem = SHSystemManager::GetSystem(); + if (editorSystem->editorState != SHEditor::State::PLAY) + lightingSubSystem->Run(cameraSystem->GetEditorCamera()->GetViewMatrix(), frameIndex); + else + lightingSubSystem->Run(worldRenderer->GetCameraDirector()->GetViewMatrix(), frameIndex); +#else + lightingSubSystem->Run(worldRenderer->GetCameraDirector()->GetViewMatrix(), frameIndex); +#endif + } // For every viewport for (int vpIndex = 0; vpIndex < static_cast(viewports.size()); ++vpIndex) @@ -378,8 +489,7 @@ namespace SHADE currentCmdBuffer->BindIndexBuffer(buffer, 0); } - // Bind the descriptor set for lights - lightingSubSystem->Run(currentCmdBuffer, frameIndex); + lightingSubSystem->BindDescSet(currentCmdBuffer, frameIndex); // Bind textures auto textureDescSet = texLibrary.GetTextureDescriptorSetGroup(); @@ -403,7 +513,7 @@ namespace SHADE { auto editorSystem = SHSystemManager::GetSystem(); if (editorSystem->editorState != SHEditor::State::PLAY) - worldRenderer->UpdateDataAndBind(currentCmdBuffer, frameIndex, SHMatrix::Transpose(cameraSystem->GetEditorCamera()->GetProjMatrix() * cameraSystem->GetEditorCamera()->GetViewMatrix())); + worldRenderer->UpdateDataAndBind(currentCmdBuffer, frameIndex, cameraSystem->GetEditorCamera()->GetViewMatrix(), cameraSystem->GetEditorCamera()->GetProjMatrix()); else renderers[renIndex]->UpdateDataAndBind(currentCmdBuffer, frameIndex); } @@ -572,6 +682,8 @@ namespace SHADE auto renderGraphNode = subpass->GetParentNode(); auto pipeline = renderGraphNode->GetOrCreatePipeline(std::make_pair(vertShader, fragShader), subpass); + SET_VK_OBJ_NAME(device, vk::ObjectType::ePipeline, pipeline->GetVkPipeline(), "[Pipeline] Custom Pipeline"); + SET_VK_OBJ_NAME(device, vk::ObjectType::ePipelineLayout, pipeline->GetPipelineLayout()->GetVkPipelineLayout(), "[Pipeline] Custom Pipeline Layout"); mat->SetPipeline(pipeline); @@ -595,7 +707,7 @@ namespace SHADE SHADE::Handle SHGraphicsSystem::AddMaterialInstanceCopy(Handle materialInst) { - return resourceManager.Create(materialInst->GetBaseMaterial()); + return resourceManager.Create(materialInst->GetBaseMaterial()); } void SHGraphicsSystem::RemoveMaterialInstance(Handle materialInstance) @@ -608,24 +720,37 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ SHADE::Handle SHGraphicsSystem::AddMesh(uint32_t vertexCount, const SHMesh::VertexPosition* const positions, const SHMesh::VertexTexCoord* const texCoords, const SHMesh::VertexTangent* const tangents, const SHMesh::VertexNormal* const normals, uint32_t indexCount, const SHMesh::Index* const indices) { - return meshLibrary.AddMesh(vertexCount, positions, texCoords, tangents, normals, indexCount, indices); + return meshLibrary.AddMesh(vertexCount, positions, texCoords, tangents, normals, indexCount, indices); } void SHGraphicsSystem::RemoveMesh(Handle mesh) { - meshLibrary.RemoveMesh(mesh); + meshLibrary.RemoveMesh(mesh); } void SHGraphicsSystem::BuildMeshBuffers() { - transferCmdBuffer = graphicsCmdPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY); - device->WaitIdle(); - transferCmdBuffer->BeginRecording(); - meshLibrary.BuildBuffers(device, transferCmdBuffer); - transferCmdBuffer->EndRecording(); - graphicsQueue->SubmitCommandBuffer({ transferCmdBuffer }); - device->WaitIdle(); - transferCmdBuffer.Free(); transferCmdBuffer = {}; + transferCmdBuffer = graphicsCmdPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY); + SET_VK_OBJ_NAME(device, vk::ObjectType::eCommandBuffer, transferCmdBuffer->GetVkCommandBuffer(), "[Command Buffer] Mesh Buffer Building (Transfer)"); + device->WaitIdle(); + transferCmdBuffer->BeginRecording(); + meshLibrary.BuildBuffers(device, transferCmdBuffer); + transferCmdBuffer->EndRecording(); + graphicsQueue->SubmitCommandBuffer({ transferCmdBuffer }); + device->WaitIdle(); + transferCmdBuffer.Free(); transferCmdBuffer = {}; + } + + Handle SHGraphicsSystem::GetMeshPrimitive(PrimitiveType type) const noexcept + { + switch (type) + { + case PrimitiveType::Cube: + case PrimitiveType::Sphere: + return primitiveMeshes[static_cast(type)]; + default: + return {}; + } } /*---------------------------------------------------------------------------------*/ @@ -633,14 +758,18 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ Handle SHGraphicsSystem::AddTexture(const SHTextureAsset& texAsset) { - auto sampler = samplerCache.GetSampler(device, SHVkSamplerParams { .maxLod = static_cast(texAsset.mipOffsets.size()) }); - return texLibrary.Add(texAsset, sampler); + const int MIPS = texAsset.mipOffsets.size(); + auto sampler = samplerCache.GetSampler(device, SHVkSamplerParams { .maxLod = static_cast(MIPS) }); + SET_VK_OBJ_NAME(device, vk::ObjectType::eSampler, sampler->GetVkSampler(), "[Sampler] Mips " + std::to_string(MIPS)); + return texLibrary.Add(texAsset, sampler); } SHADE::Handle SHGraphicsSystem::AddTexture(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, uint32_t width, uint32_t height, SHTexture::TextureFormat format, std::vector mipOffsets) { - auto sampler = samplerCache.GetSampler(device, SHVkSamplerParams{ .maxLod = static_cast(mipOffsets.size()) }); - return texLibrary.Add(pixelCount, pixelData, width, height, format, mipOffsets, sampler); + const int MIPS = mipOffsets.size(); + auto sampler = samplerCache.GetSampler(device, SHVkSamplerParams{ .maxLod = static_cast(MIPS) }); + SET_VK_OBJ_NAME(device, vk::ObjectType::eSampler, sampler->GetVkSampler(), "[Sampler] Mips " + std::to_string(MIPS)); + return texLibrary.Add(pixelCount, pixelData, width, height, format, mipOffsets, sampler); } void SHGraphicsSystem::RemoveTexture(Handle tex) @@ -651,6 +780,7 @@ namespace SHADE void SHGraphicsSystem::BuildTextures() { graphicsTexCmdBuffer = graphicsCmdPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY); + SET_VK_OBJ_NAME(device, vk::ObjectType::eCommandBuffer, graphicsTexCmdBuffer->GetVkCommandBuffer(), "[Command Buffer] Texture Building (Graphics)"); device->WaitIdle(); texLibrary.BuildTextures ( @@ -660,6 +790,11 @@ namespace SHADE graphicsTexCmdBuffer.Free(); graphicsTexCmdBuffer = {}; } + Handle SHGraphicsSystem::GetTextureHandle(SHTexture::Index textureId) const + { + return texLibrary.GetTextureHandle(textureId); + } + #pragma endregion ADD_REMOVE #pragma region ROUTINES @@ -672,6 +807,7 @@ namespace SHADE void SHGraphicsSystem::BeginRoutine::Execute(double) noexcept { + SHResourceManager::FinaliseChanges(); reinterpret_cast(system)->BeginRender(); } @@ -697,7 +833,6 @@ namespace SHADE void SHGraphicsSystem::EndRoutine::Execute(double) noexcept { reinterpret_cast(system)->EndRender(); - SHResourceManager::FinaliseChanges(); } /*-----------------------------------------------------------------------------------*/ @@ -709,16 +844,11 @@ namespace SHADE void SHGraphicsSystem::BatcherDispatcherRoutine::Execute(double) noexcept { - auto& renderables = SHComponentManager::GetDense(); + auto& renderables = SHComponentManager::GetDense(); for (auto& renderable : renderables) { if (!renderable.HasChanged()) continue; - - if (!renderable.GetMesh()) - { - SHLOG_CRITICAL("NULL Mesh provided!"); - } // Remove from the SuperBatch it is previously in (prevMat if mat has changed) Handle prevMaterial = renderable.HasMaterialChanged() ? renderable.GetPrevMaterial() : renderable.GetMaterial(); @@ -729,8 +859,9 @@ namespace SHADE } // Add to new SuperBatch if there is a material + // Add to new SuperBatch if there is a material and a mesh to render Handle newMatInstance = renderable.GetMaterial(); - if (newMatInstance) + if (newMatInstance && renderable.GetMesh()) { Handle newSuperBatch = newMatInstance->GetBaseMaterial()->GetPipeline()->GetPipelineState().GetSubpass()->GetSuperBatch(); newSuperBatch->Add(&renderable); @@ -810,5 +941,57 @@ namespace SHADE return worldRenderGraph->GetNode(G_BUFFER_RENDER_GRAPH_NODE_NAME.data()); } + Handle SHGraphicsSystem::createDebugDrawPipeline(Handle renderPass, Handle subpass) + { + auto pipelineLayout = resourceManager.Create + ( + device, SHPipelineLayoutParams + { + .shaderModules = { debugVertShader, debugFragShader }, + .globalDescSetLayouts = SHGraphicsGlobalData::GetDescSetLayouts() + } + ); + auto pipeline = resourceManager.Create(device, pipelineLayout, nullptr, renderPass, subpass); + pipeline->GetPipelineState().SetRasterizationState(SHRasterizationState + { + .polygonMode = vk::PolygonMode::eLine, + .cull_mode = vk::CullModeFlagBits::eNone + }); + pipeline->GetPipelineState().SetInputAssemblyState(SHInputAssemblyState + { + .topology = vk::PrimitiveTopology::eLineList + }); + + SHVertexInputState debugDrawVertexInputState; + debugDrawVertexInputState.AddBinding(false, true, { SHVertexAttribute(SHAttribFormat::FLOAT_4D), SHVertexAttribute(SHAttribFormat::FLOAT_4D) }); + pipeline->GetPipelineState().SetVertexInputState(debugDrawVertexInputState); + SHColorBlendState colorBlendState{}; + colorBlendState.logic_op_enable = VK_FALSE; + colorBlendState.logic_op = vk::LogicOp::eCopy; + + auto const& subpassColorReferences = subpass->GetColorAttachmentReferences(); + colorBlendState.attachments.reserve(subpassColorReferences.size()); + + for (auto& att : subpassColorReferences) + { + colorBlendState.attachments.push_back(vk::PipelineColorBlendAttachmentState + { + .blendEnable = SHVkUtil::IsBlendCompatible(subpass->GetFormatFromAttachmentReference(att.attachment)), + .srcColorBlendFactor = vk::BlendFactor::eSrcAlpha, + .dstColorBlendFactor = vk::BlendFactor::eOneMinusSrcAlpha, + .colorBlendOp = vk::BlendOp::eAdd, + .srcAlphaBlendFactor = vk::BlendFactor::eOne, + .dstAlphaBlendFactor = vk::BlendFactor::eZero, + .alphaBlendOp = vk::BlendOp::eAdd, + .colorWriteMask = vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG | vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA, + }); + } + + pipeline->GetPipelineState().SetColorBlenState(colorBlendState); + pipeline->ConstructPipeline(); + + return pipeline; + } + #pragma endregion MISC } diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h index 3f899446..a5a5ada0 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h @@ -31,6 +31,7 @@ of DigiPen Institute of Technology is prohibited. #include "../Textures/SHVkSamplerCache.h" #include "Graphics/MiddleEnd/Interface/SHPostOffscreenRenderSystem.h" #include "Graphics/MiddleEnd/Lights/SHLightingSubSystem.h" +#include "Graphics/MiddleEnd/PostProcessing/SHSSAO.h" namespace SHADE { @@ -57,6 +58,19 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ /* Type Definitions */ /*---------------------------------------------------------------------------------*/ + /***********************************************************************************/ + /*! + \brief + Type of built-in primitive meshes that are available. + */ + /***********************************************************************************/ + enum class PrimitiveType + { + Cube, + Sphere + }; + static constexpr int MAX_PRIMITIVE_TYPES = 2; + /***********************************************************************************/ /*! \brief @@ -71,6 +85,7 @@ namespace SHADE void InitSceneRenderGraph (void) noexcept; void InitMiddleEnd (void) noexcept; void InitSubsystems (void) noexcept; + void InitBuiltInResources (void); #ifdef SHEDITOR void InitEditorRenderGraph (void) noexcept; @@ -80,25 +95,25 @@ namespace SHADE class SH_API BeginRoutine final : public SHSystemRoutine { public: - BeginRoutine(); + BeginRoutine(); virtual void Execute(double dt) noexcept override final; }; class SH_API RenderRoutine final : public SHSystemRoutine { public: - RenderRoutine(); + RenderRoutine(); virtual void Execute(double dt) noexcept override final; }; class SH_API EndRoutine final : public SHSystemRoutine { public: - EndRoutine(); + EndRoutine(); virtual void Execute(double dt) noexcept override final; }; class SH_API BatcherDispatcherRoutine final : public SHSystemRoutine { public: - BatcherDispatcherRoutine(); + BatcherDispatcherRoutine(); virtual void Execute(double dt) noexcept override final; }; @@ -151,34 +166,34 @@ namespace SHADE /*******************************************************************************/ /*! - \brief - Adds a mesh to the Mesh Library. But this does not mean that the meshes have - been added yet. A call to "BuildBuffers()" is required to transfer all - meshes into the GPU. + \brief + Adds a mesh to the Mesh Library. But this does not mean that the meshes have + been added yet. A call to "BuildBuffers()" is required to transfer all + meshes into the GPU. \param vertexCount Number of vertices in this Mesh. \param positions - Pointer to the first in a contiguous array of SHMathVec3s that define vertex - positions. - \param texCoords - Pointer to the first in a contiguous array of SHMathVec2s that define vertex - texture coordinates. - \param tangents - Pointer to the first in a contiguous array of SHMathVec3s that define vertex - tangents. - \param normals - Pointer to the first in a contiguous array of SHMathVec3s that define vertex - normals. + Pointer to the first in a contiguous array of SHMathVec3s that define vertex + positions. + \param texCoords + Pointer to the first in a contiguous array of SHMathVec2s that define vertex + texture coordinates. + \param tangents + Pointer to the first in a contiguous array of SHMathVec3s that define vertex + tangents. + \param normals + Pointer to the first in a contiguous array of SHMathVec3s that define vertex + normals. \param indexCount Number of indices in this mesh. \param indices - Pointer to the first in a contiguous array of uint32_ts that define mesh - indices. + Pointer to the first in a contiguous array of uint32_ts that define mesh + indices. - \return - Handle to the created Mesh. This is not valid to be used until a call to - BuildBuffers(). + \return + Handle to the created Mesh. This is not valid to be used until a call to + BuildBuffers(). */ /*******************************************************************************/ @@ -187,9 +202,9 @@ namespace SHADE /*! \brief - Removes a mesh from the MeshLibrary. But this does not mean that the meshes - have been removed yet. A call to "BuildBuffers()" is required to finalise all - changes. + Removes a mesh from the MeshLibrary. But this does not mean that the meshes + have been removed yet. A call to "BuildBuffers()" is required to finalise all + changes. \param mesh Handle to the mesh to remove. @@ -206,6 +221,21 @@ namespace SHADE */ /***************************************************************************/ void BuildMeshBuffers(); + /*******************************************************************************/ + /*! + + \brief + Retrieves the built-in mesh specified. + + \param type + Type of built-in mesh to retrieve. + + \returns + Handle to the mesh that was specfied. However, if an invalid type is specified, + a null Handle will be returned. + */ + /*******************************************************************************/ + Handle GetMeshPrimitive(PrimitiveType type) const noexcept; /*-----------------------------------------------------------------------------*/ /* Texture Registration Functions */ @@ -262,6 +292,33 @@ namespace SHADE */ /***************************************************************************/ void BuildTextures(); + /***************************************************************************/ + /*! + * + \brief + Retrieves the texture handle at the specified texture index. + + \param textureId + Index of the texture to look for. + + \returns + Handle to the texture + + */ + /***************************************************************************/ + Handle GetTextureHandle(SHTexture::Index textureId) const; + /***************************************************************************/ + /*! + * + \brief + Retrieves the handle to the default texture. A white 1x1 texture. + + \returns + Handle to the default texture. + + */ + /***************************************************************************/ + Handle GetDefaultTexture() const noexcept { return defaultTexture; } void PrepareResize(uint32_t newWidth, uint32_t newHeight) noexcept; void HandleResize(void) noexcept; @@ -288,9 +345,9 @@ namespace SHADE Handle GetMousePickSystem(void) const noexcept {return mousePickSystem;}; Handle GetPostOffscreenRenderSystem(void) const noexcept {return postOffscreenRender;}; Handle GetPrimaryRenderpass() const noexcept; - //SHRenderGraph const& GetRenderGraph(void) const noexcept; - - //Handle GetRenderPass() const { return renderPass; } + Handle GetDebugDrawPipeline(void) const noexcept { return debugDrawPipeline; } + Handle GetDebugDrawDepthPipeline(void) const noexcept { return debugDrawDepthPipeline; } + uint32_t GetCurrentFrameIndex(void) const noexcept { return renderContext.GetCurrentFrame(); } /*-----------------------------------------------------------------------------*/ /* Getters */ @@ -316,6 +373,7 @@ namespace SHADE Handle descPool; Handle graphicsCmdPool; Handle transferCmdBuffer; + Handle ssaoTransferCmdBuffer; Handle graphicsTexCmdBuffer; SHRenderContext renderContext; std::array, 2> graphSemaphores; @@ -339,10 +397,6 @@ namespace SHADE Handle worldViewport; // Whole screen std::vector> viewports; // Additional viewports - // Debug Renderers - Handle debugWorldRenderer; - Handle debugScreenRenderer; - // Temp renderers Handle worldRenderer; @@ -353,21 +407,40 @@ namespace SHADE // Built-In Shaders Handle defaultVertShader; Handle defaultFragShader; + Handle debugVertShader; + Handle debugFragShader; Handle deferredCompositeShader; + Handle ssaoShader; + Handle ssaoBlurShader; + // Built-In Materials Handle defaultMaterial; + Handle debugDrawPipeline; + Handle debugDrawDepthPipeline; + // Built-In Textures + Handle defaultTexture; + + // Built-In Meshes + std::array, MAX_PRIMITIVE_TYPES> primitiveMeshes; + + // Render Graphs Handle worldRenderGraph; // Sub systems Handle mousePickSystem; Handle postOffscreenRender; Handle lightingSubSystem; + Handle ssaoStorage; - uint32_t resizeWidth; - uint32_t resizeHeight; - bool restoredFromMinimize = false; + uint32_t resizeWidth = 1; + uint32_t resizeHeight = 1; + bool restoredFromMinimize = false; + /*---------------------------------------------------------------------------------*/ + /* Helper Functions */ + /*---------------------------------------------------------------------------------*/ + Handle createDebugDrawPipeline(Handle renderPass, Handle subpass); }; } \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMeshLibrary.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMeshLibrary.cpp index 3474fea3..d34c1b7d 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMeshLibrary.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMeshLibrary.cpp @@ -165,35 +165,40 @@ namespace SHADE device, cmdBuffer, vertPosBuffer, vertPosStorage.data(), static_cast(vertPosStorage.size()) * sizeof(SHMesh::VertexPosition), - BuffUsage::eVertexBuffer + BuffUsage::eVertexBuffer, + "Mesh Library Vertex Positions" ); SHVkUtil::EnsureBufferAndCopyData ( device, cmdBuffer, vertTexCoordBuffer, vertTexCoordStorage.data(), static_cast(vertTexCoordStorage.size()) * sizeof(SHMesh::VertexTexCoord), - BuffUsage::eVertexBuffer + BuffUsage::eVertexBuffer, + "Mesh Library Vertex TexCoords" ); SHVkUtil::EnsureBufferAndCopyData ( device, cmdBuffer, vertTangentBuffer, vertTangentStorage.data(), static_cast(vertTangentStorage.size()) * sizeof(SHMesh::VertexTangent), - BuffUsage::eVertexBuffer + BuffUsage::eVertexBuffer, + "Mesh Library Vertex Tangents" ); SHVkUtil::EnsureBufferAndCopyData ( device, cmdBuffer, vertNormalBuffer, vertNormalStorage.data(), static_cast(vertNormalStorage.size()) * sizeof(SHMesh::VertexNormal), - BuffUsage::eVertexBuffer + BuffUsage::eVertexBuffer, + "Mesh Library Vertex Normals" ); SHVkUtil::EnsureBufferAndCopyData ( device, cmdBuffer, indexBuffer, indexStorage.data(), static_cast(indexStorage.size()) * sizeof(SHMesh::Index), - BuffUsage::eIndexBuffer + BuffUsage::eIndexBuffer, + "Mesh Library Indices" ); isDirty = false; diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.cpp index 46126ae1..86d85c16 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.cpp @@ -76,7 +76,7 @@ namespace SHADE uint32_t bufferSize = entityIDAttachment->GetWidth() * entityIDAttachment->GetHeight() * SHVkUtil::GetBytesPerPixelFromFormat(entityIDAttachment->GetResourceFormat()); // Create the buffer - imageDataDstBuffer = logicalDevice->CreateBuffer(bufferSize, nullptr, bufferSize, vk::BufferUsageFlagBits::eTransferDst, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT); + imageDataDstBuffer = logicalDevice->CreateBuffer(bufferSize, nullptr, bufferSize, vk::BufferUsageFlagBits::eTransferDst, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, "Mouse Pick Image Data Destination"); } void SHMousePickSystem::SetViewportMousePos(SHVec2 vpMousePos) noexcept diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp index 962130be..63d374eb 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp @@ -39,9 +39,15 @@ namespace SHADE cameraDescriptorSet = descriptorPool->Allocate({ cameraDescLayout }, { 1 }); +#ifdef _DEBUG + const auto& CAM_DESC_SETS = cameraDescriptorSet->GetVkHandle(); + for (int i = 0; i < static_cast(CAM_DESC_SETS.size()); ++i) + SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSet, CAM_DESC_SETS[i], "[Descriptor Set] Camera Data Frame #" + std::to_string(i)); +#endif + cameraDataAlignedSize = logicalDevice->PadUBOSize(sizeof(SHShaderCameraData)); - cameraBuffer = logicalDevice->CreateBuffer(cameraDataAlignedSize * numFrames, nullptr, cameraDataAlignedSize * numFrames, vk::BufferUsageFlagBits::eUniformBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT); + cameraBuffer = logicalDevice->CreateBuffer(cameraDataAlignedSize * numFrames, nullptr, cameraDataAlignedSize * numFrames, vk::BufferUsageFlagBits::eUniformBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, "Camera Data"); std::array cameraBufferArray{cameraBuffer}; @@ -83,13 +89,14 @@ namespace SHADE { if (camera && cameraDirector) { - UpdateDataAndBind(cmdBuffer, frameIndex, SHMatrix::Transpose(cameraDirector->GetVPMatrix())); + //UpdateDataAndBind(cmdBuffer, frameIndex, SHMatrix::Transpose(cameraDirector->GetVPMatrix())); + UpdateDataAndBind(cmdBuffer, frameIndex, cameraDirector->GetViewMatrix(), cameraDirector->GetProjMatrix()); } } - void SHRenderer::UpdateDataAndBind(Handle cmdBuffer, uint32_t frameIndex, SHMatrix exteriorMatrix) noexcept + void SHRenderer::UpdateDataAndBind(Handle cmdBuffer, uint32_t frameIndex, SHMatrix const& viewMatrix, SHMatrix const& projMatrix) noexcept { - SetViewProjectionMatrix(exteriorMatrix); + SetViewProjectionMatrix(viewMatrix, projMatrix); //cpuCameraData.viewProjectionMatrix = camera->GetViewProjectionMatrix(); cameraBuffer->WriteToMemory(&cpuCameraData, sizeof(SHShaderCameraData), 0, cameraDataAlignedSize * frameIndex); @@ -97,16 +104,19 @@ namespace SHADE std::array dynamicOffsets{ frameIndex * cameraDataAlignedSize }; cmdBuffer->BindDescriptorSet(cameraDescriptorSet, SH_PIPELINE_TYPE::GRAPHICS, SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, std::span{ dynamicOffsets.data(), 1 }); + cmdBuffer->BindDescriptorSet(cameraDescriptorSet, SH_PIPELINE_TYPE::COMPUTE, SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, std::span{ dynamicOffsets.data(), 1 }); } void SHRenderer::UpdateCameraDataToBuffer(void) noexcept { } - void SHRenderer::SetViewProjectionMatrix(SHMatrix const& vpMatrix) noexcept + void SHRenderer::SetViewProjectionMatrix(SHMatrix const& viewMatrix, SHMatrix const& projMatrix) noexcept { //cpuCameraData.viewProjectionMatrix = camera->GetViewMatrix() * camera->GetProjectionMatrix(); - cpuCameraData.viewProjectionMatrix = vpMatrix; + cpuCameraData.viewProjectionMatrix = SHMatrix::Transpose(projMatrix * viewMatrix); + cpuCameraData.viewMatrix = SHMatrix::Transpose(viewMatrix); + cpuCameraData.projectionMatrix = SHMatrix::Transpose(projMatrix); } Handle SHRenderer::GetRenderGraph(void) const noexcept @@ -119,4 +129,9 @@ namespace SHADE return commandBuffers[frameIndex]; } + Handle SHRenderer::GetCameraDirector(void) const noexcept + { + return cameraDirector; + } + } diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.h b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.h index 87cf8ee9..140cf53b 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.h @@ -46,6 +46,8 @@ namespace SHADE { SHVec4 cameraPosition; SHMatrix viewProjectionMatrix; + SHMatrix viewMatrix; + SHMatrix projectionMatrix; }; /*---------------------------------------------------------------------------------*/ @@ -79,15 +81,16 @@ namespace SHADE /*-----------------------------------------------------------------------------*/ void Draw(uint32_t frameIndex, Handle descPool) noexcept; void UpdateDataAndBind(Handle cmdBuffer, uint32_t frameIndex) noexcept; - void UpdateDataAndBind(Handle cmdBuffer, uint32_t frameIndex, SHMatrix exteriorMatrix) noexcept; + void UpdateDataAndBind(Handle cmdBuffer, uint32_t frameIndex, SHMatrix const& viewMatrix, SHMatrix const& projMatrix) noexcept; void UpdateCameraDataToBuffer (void) noexcept; - void SetViewProjectionMatrix (SHMatrix const& vpMatrix) noexcept; + void SetViewProjectionMatrix (SHMatrix const& viewMatrix, SHMatrix const& projMatrix) noexcept; /*-----------------------------------------------------------------------------*/ /* Setters and Getters */ /*-----------------------------------------------------------------------------*/ - Handle GetRenderGraph (void) const noexcept; + Handle GetRenderGraph (void) const noexcept; Handle GetCommandBuffer(uint32_t frameIndex) const noexcept; + Handle GetCameraDirector (void) const noexcept; private: /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.cpp index fb8795fa..2ea6bc8b 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.cpp @@ -9,9 +9,9 @@ namespace SHADE { lightData.Reset(); SetType(SH_LIGHT_TYPE::DIRECTIONAL); - indexInBuffer = std::numeric_limits::max(); + //indexInBuffer = std::numeric_limits::max(); isActive = true; - Unbind(); + //Unbind(); } @@ -23,28 +23,28 @@ namespace SHADE void SHLightComponent::SetPosition(SHVec3 const& position) noexcept { lightData.position = position; - MakeDirty(); + //MakeDirty(); } void SHLightComponent::SetType(SH_LIGHT_TYPE type) noexcept { lightData.type = type; - MakeDirty(); + //MakeDirty(); } void SHLightComponent::SetDirection(SHVec3 const& direction) noexcept { lightData.direction = direction; - MakeDirty(); + //MakeDirty(); } void SHLightComponent::SetColor(SHVec4 const& color) noexcept { lightData.color = color; - MakeDirty(); + //MakeDirty(); } void SHLightComponent::ModifyCullingMask(uint8_t layerIndex, bool value) noexcept @@ -54,7 +54,7 @@ namespace SHADE else lightData.cullingMask &= ~(1u << layerIndex); - MakeDirty(); + //MakeDirty(); } void SHLightComponent::SetCullingMask(uint32_t const& value) noexcept @@ -65,43 +65,43 @@ namespace SHADE void SHLightComponent::SetAllLayers(void) noexcept { lightData.cullingMask = std::numeric_limits::max(); - MakeDirty(); + //MakeDirty(); } void SHLightComponent::ClearAllLayers(void) noexcept { lightData.cullingMask = 0; - MakeDirty(); + //MakeDirty(); } - void SHLightComponent::MakeDirty(void) noexcept - { - dirty = true; - } + //void SHLightComponent::MakeDirty(void) noexcept + //{ + // dirty = true; + //} - void SHLightComponent::ClearDirtyFlag(void) noexcept - { - dirty = false; - } + //void SHLightComponent::ClearDirtyFlag(void) noexcept + //{ + // dirty = false; + //} - void SHLightComponent::Unbind(void) noexcept - { - bound = false; - MakeDirty(); - } - - void SHLightComponent::SetBound(uint32_t inIndexInBuffer) noexcept -{ - bound = true; - indexInBuffer = inIndexInBuffer; - } +// void SHLightComponent::Unbind(void) noexcept +// { +// bound = false; +// MakeDirty(); +// } +// +// void SHLightComponent::SetBound(uint32_t inIndexInBuffer) noexcept +//{ +// bound = true; +// indexInBuffer = inIndexInBuffer; +// } void SHLightComponent::SetStrength(float value) noexcept { lightData.strength = value; - MakeDirty(); + //MakeDirty(); } SHLightData const& SHLightComponent::GetLightData(void) const noexcept @@ -135,20 +135,20 @@ namespace SHADE } - bool SHLightComponent::IsDirty(void) const noexcept - { - return dirty; - } + //bool SHLightComponent::IsDirty(void) const noexcept + //{ + // return dirty; + //} - bool SHLightComponent::GetBound(void) const noexcept - { - return bound; - } + //bool SHLightComponent::GetBound(void) const noexcept + //{ + // return bound; + //} - uint32_t SHLightComponent::GetIndexInBuffer(void) const noexcept - { - return indexInBuffer; - } + //uint32_t SHLightComponent::GetIndexInBuffer(void) const noexcept + //{ + // return indexInBuffer; + //} float SHLightComponent::GetStrength(void) const noexcept { diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.h b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.h index 81eb80f5..6b35559c 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightComponent.h @@ -17,13 +17,13 @@ namespace SHADE //! Since the lighting system is gonna be self contained and light weight, we store this //! so that we only write this to the CPU buffer when this light component change, we don't //! rewrite everything. However we still write to the GPU buffer when everything changes. - uint32_t indexInBuffer; + //uint32_t indexInBuffer; - //! If the light component changed some value we mark this true. - bool dirty; + ////! If the light component changed some value we mark this true. + //bool dirty; - //! If the light's data is already in the buffers, this will be set to true. - bool bound; + ////! If the light's data is already in the buffers, this will be set to true. + //bool bound; public: @@ -44,10 +44,10 @@ namespace SHADE void SetCullingMask (uint32_t const& value) noexcept; void SetAllLayers (void) noexcept; // serialized void ClearAllLayers (void) noexcept; // serialized - void MakeDirty (void) noexcept; - void ClearDirtyFlag (void) noexcept; - void Unbind (void) noexcept; - void SetBound (uint32_t inIndexInBuffer) noexcept; + //void MakeDirty (void) noexcept; + //void ClearDirtyFlag (void) noexcept; + //void Unbind (void) noexcept; + //void SetBound (uint32_t inIndexInBuffer) noexcept; void SetStrength (float value) noexcept; // serialized @@ -57,8 +57,8 @@ namespace SHADE SHVec3 const& GetDirection (void) const noexcept; // serialized SHVec4 const& GetColor (void) const noexcept; // serialized uint32_t const& GetCullingMask (void) const noexcept; // serialized - bool IsDirty (void) const noexcept; - bool GetBound (void) const noexcept; + //bool IsDirty (void) const noexcept; + //bool GetBound (void) const noexcept; uint32_t GetIndexInBuffer (void) const noexcept; float GetStrength (void) const noexcept; RTTR_ENABLE() diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp index 5ca879c4..02bd8f1f 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp @@ -8,6 +8,8 @@ #include "SHLightComponent.h" #include "ECS_Base/Managers/SHComponentManager.h" #include "SHLightComponent.h" +#include "Math/Vector/SHVec4.h" +#include "Math/SHMatrix.h" namespace SHADE { @@ -31,7 +33,7 @@ namespace SHADE */ /***************************************************************************/ - void SHLightingSubSystem::PerTypeData::WriteLightToAddress(void* address, SHLightComponent* lightComp) noexcept + void SHLightingSubSystem::PerTypeData::WriteLightToAddress(void* address, SHMatrix const& viewMat, SHLightComponent* lightComp) noexcept { auto const& lightData = lightComp->GetLightData(); switch (lightData.type) @@ -40,8 +42,12 @@ namespace SHADE { SHDirectionalLightData* lightPtr = reinterpret_cast(address); + // #NoteToSelf: NEED TO TRANSPOSE HERE BECAUSE MULTIPLICATION IS ROW MAJOR. + SHVec4 transformedDir = SHMatrix::Transpose(viewMat) * SHVec4(lightData.direction[0], lightData.direction[1], lightData.direction[2], 0.0f); + lightPtr->cullingMask = lightData.cullingMask; - lightPtr->direction = lightData.direction; + lightPtr->direction = SHVec3 (transformedDir.x, transformedDir.y, transformedDir.z); + //lightPtr->direction = lightData.direction; lightPtr->diffuseColor = lightData.color; lightPtr->active = lightComp->isActive; break; @@ -128,7 +134,7 @@ namespace SHADE lightDataTotalAlignedSize = logicalDevice->PadSSBOSize(lightDataAlignedSize * maxLights); // We want to initialize 3 times the amount of data required. - dataBuffer = logicalDevice->CreateBuffer(lightDataTotalAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, nullptr, lightDataTotalAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, vk::BufferUsageFlagBits::eStorageBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT); + dataBuffer = logicalDevice->CreateBuffer(lightDataTotalAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, nullptr, lightDataTotalAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, vk::BufferUsageFlagBits::eStorageBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, "Light Data"); } else { @@ -240,7 +246,7 @@ namespace SHADE */ /***************************************************************************/ - void SHLightingSubSystem::PerTypeData::AddLight(Handle logicalDevice, SHLightComponent* unboundLight, bool expanded) noexcept + void SHLightingSubSystem::PerTypeData::AddLight(Handle logicalDevice, SHLightComponent* unboundLight, SHMatrix const& viewMat, bool& expanded) noexcept { if (unboundLight) { @@ -259,10 +265,10 @@ namespace SHADE void* writeLocation = reinterpret_cast(intermediateData.get()) + (lightDataAlignedSize * numLights); // Write the light data to address - WriteLightToAddress(writeLocation, unboundLight); + WriteLightToAddress(writeLocation, viewMat, unboundLight); // Set the light component to be bound to that location - unboundLight->SetBound(numLights); + //unboundLight->SetBound(numLights); // Increase light count ++numLights; @@ -280,11 +286,11 @@ namespace SHADE */ /***************************************************************************/ - void SHLightingSubSystem::PerTypeData::ModifyLight(SHLightComponent* lightComp) noexcept - { - void* writeLocation = reinterpret_cast(intermediateData.get()) + (lightDataAlignedSize * lightComp->GetIndexInBuffer()); - WriteLightToAddress(writeLocation, lightComp); - } + //void SHLightingSubSystem::PerTypeData::ModifyLight(SHLightComponent* lightComp) noexcept + //{ + // void* writeLocation = reinterpret_cast(intermediateData.get()) + (lightDataAlignedSize * lightComp->GetIndexInBuffer()); + // WriteLightToAddress(writeLocation, lightComp); + //} void SHLightingSubSystem::PerTypeData::WriteToGPU(uint32_t frameIndex) noexcept { @@ -379,8 +385,12 @@ namespace SHADE std::fill (variableSizes.begin(), variableSizes.end(), 1); // Create the descriptor set - lightingDataDescSet = descPool->Allocate({SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS]}, variableSizes); - + lightingDataDescSet = descPool->Allocate({ SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS] }, variableSizes); +#ifdef _DEBUG + const auto& CAM_DESC_SETS = lightingDataDescSet->GetVkHandle(); + for (int i = 0; i < static_cast(CAM_DESC_SETS.size()); ++i) + SET_VK_OBJ_NAME(logicalDevice, vk::ObjectType::eDescriptorSet, CAM_DESC_SETS[i], "[Descriptor Set] Light Data Frame #" + std::to_string(i)); +#endif for (uint32_t i = 0; i < NUM_LIGHT_TYPES; ++i) { @@ -396,7 +406,7 @@ namespace SHADE lightCountsAlignedSize = logicalDevice->PadUBOSize(lightCountsAlignedSize); // Create the GPU buffer to hold light count - lightCountsBuffer = logicalDevice->CreateBuffer(lightCountsAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, nullptr, lightCountsAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, vk::BufferUsageFlagBits::eUniformBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT); + lightCountsBuffer = logicalDevice->CreateBuffer(lightCountsAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, nullptr, lightCountsAlignedSize * SHGraphicsConstants::NUM_FRAME_BUFFERS, vk::BufferUsageFlagBits::eUniformBuffer, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, "Light Count Data"); lightingDataDescSet->ModifyWriteDescBuffer(SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS, SHGraphicsConstants::DescriptorSetBindings::LIGHTING_COUNT, {&lightCountsBuffer, 1}, 0, sizeof (uint32_t) * NUM_LIGHT_TYPES); lightingDataDescSet->UpdateDescriptorSetBuffer(SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS, SHGraphicsConstants::DescriptorSetBindings::LIGHTING_COUNT); @@ -406,7 +416,7 @@ namespace SHADE dynamicOffsets[i].resize(NUM_LIGHT_TYPES + 1); // +1 for the count } - numLightComponents = 0; + //numLightComponents = 0; } /***************************************************************************/ @@ -419,21 +429,25 @@ namespace SHADE */ /***************************************************************************/ - void SHLightingSubSystem::Run(Handle cmdBuffer, uint32_t frameIndex) noexcept + void SHLightingSubSystem::Run(SHMatrix const& viewMat, uint32_t frameIndex) noexcept { static uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ToUnderlying(SH_LIGHT_TYPE::NUM_TYPES); auto& lightComps = SHComponentManager::GetDense(); bool expanded = false; - bool rewrite = false; - if (numLightComponents > lightComps.size()) - { - rewrite = true; - ResetNumLights(); - } + // First we reset the number of lights. We do this every frame so that we can count how many lights we have + ResetNumLights(); - numLightComponents = lightComps.size(); + //bool rewrite = false; + + //if (numLightComponents > lightComps.size()) + //{ + // rewrite = true; + // ResetNumLights(); + //} + + //numLightComponents = lightComps.size(); for (auto& light : lightComps) { @@ -441,22 +455,22 @@ namespace SHADE // First we want to make sure the light is already bound to the system. if it // isn't, we write it to the correct buffer. - if (!light.GetBound() || rewrite) + //if (!light.GetBound() || rewrite) { - perTypeData[enumValue].AddLight(logicalDevice, &light, expanded); + perTypeData[enumValue].AddLight(logicalDevice, &light, viewMat, expanded); - //// add to light count + // add to light count //++lightCountsData[enumValue]; } // if there was modification to the light data - if (light.IsDirty()) + //if (light.IsDirty()) { // Write the data to the CPU - perTypeData[enumValue].ModifyLight(&light); + //perTypeData[enumValue].ModifyLight(&light); // Light is now updated in the container - light.ClearDirtyFlag(); + //light.ClearDirtyFlag(); } } @@ -488,8 +502,6 @@ namespace SHADE // so we do it anyway. #NoteToSelf: if at any point it affects performance, do a check before computing. ComputeDynamicOffsets(); - // Bind descriptor set (We bind at an offset because the buffer holds NUM_FRAME_BUFFERS sets of data). - cmdBuffer->BindDescriptorSet(lightingDataDescSet, SH_PIPELINE_TYPE::COMPUTE, SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS, {dynamicOffsets[frameIndex]}); } @@ -505,4 +517,12 @@ namespace SHADE { } + + void SHLightingSubSystem::BindDescSet(Handle cmdBuffer, uint32_t frameIndex) noexcept + { + //Bind descriptor set(We bind at an offset because the buffer holds NUM_FRAME_BUFFERS sets of data). + cmdBuffer->BindDescriptorSet(lightingDataDescSet, SH_PIPELINE_TYPE::COMPUTE, SHGraphicsConstants::DescriptorSetIndex::DYNAMIC_GLOBALS, { dynamicOffsets[frameIndex] }); + + } + } diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.h b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.h index fb7aa2de..ae6caead 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.h @@ -95,15 +95,15 @@ namespace SHADE //! to the GPU that stores NUM_FRAME_BUFFERS copies. std::unique_ptr intermediateData; - void WriteLightToAddress (void* address, SHLightComponent* lightComp) noexcept; + void WriteLightToAddress (void* address, SHMatrix const& viewMat, SHLightComponent* lightComp) noexcept; public: /*-----------------------------------------------------------------------*/ /* PUBLIC MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ void InitializeData (Handle logicalDevice, SH_LIGHT_TYPE type) noexcept; void Expand (Handle logicalDevice) noexcept; - void AddLight (Handle logicalDevice, SHLightComponent* unboundLight, bool expanded) noexcept; - void ModifyLight (SHLightComponent* lightComp) noexcept; + void AddLight (Handle logicalDevice, SHLightComponent* unboundLight, SHMatrix const& viewMat, bool& expanded) noexcept; + //void ModifyLight (SHLightComponent* lightComp) noexcept; void WriteToGPU (uint32_t frameIndex) noexcept; void ResetNumLights (void) noexcept; @@ -144,7 +144,7 @@ namespace SHADE //! Number of SHLightComponents recorded. If at the beginning of the run function the size returned by the dense //! set is less than the size recorded, rewrite all light components into the its respective buffers. If its more, //! don't do anything. - uint32_t numLightComponents; + //uint32_t numLightComponents; /*-----------------------------------------------------------------------*/ /* PRIVATE MEMBER FUNCTIONS */ @@ -159,8 +159,10 @@ namespace SHADE /* PUBLIC MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ void Init (Handle device, Handle descPool) noexcept; - void Run (Handle cmdBuffer, uint32_t frameIndex) noexcept; + void Run (SHMatrix const& viewMat, uint32_t frameIndex) noexcept; void Exit (void) noexcept; + void BindDescSet (Handle cmdBuffer, uint32_t frameIndex) noexcept; + }; } diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.cpp new file mode 100644 index 00000000..0dabc4e8 --- /dev/null +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.cpp @@ -0,0 +1,74 @@ +/************************************************************************************//*! +\file SHMaterialSpec.cpp +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 2, 2022 +\brief Contains the function definitions of SHMaterialSpec. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#include "SHpch.h" +#include "SHMaterialSpec.h" +#include "Graphics/Shaders/SHVkShaderModule.h" +#include "Resource/SHResourceManager.h" +#include "Graphics/MiddleEnd/Interface/SHMaterial.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors */ + /*-----------------------------------------------------------------------------------*/ + SHMaterialSpec::SHMaterialSpec(const SHMaterial& material) + { + // Get Shader Handles + const auto& SHADERS = material.GetPipeline()->GetPipelineLayout()->GetShaderModules(); + Handle vShaderMod, fShaderMod; + for (const auto& shader : SHADERS) + { + const auto FLAG_BITS = shader->GetShaderStageFlagBits(); + if (FLAG_BITS & vk::ShaderStageFlagBits::eVertex) + vShaderMod = shader; + else if (FLAG_BITS & vk::ShaderStageFlagBits::eFragment) + fShaderMod = shader; + } + vertexShader = SHResourceManager::GetAssetID(vShaderMod).value_or(0); + fragShader = SHResourceManager::GetAssetID(fShaderMod).value_or(0); + subpassName = material.GetPipeline()->GetPipelineState().GetSubpass()->GetName(); + + // Write Properties + Handle pipelineProperties = material.GetShaderBlockInterface(); + for (int i = 0; i < static_cast(pipelineProperties->GetVariableCount()); ++i) + { + const SHShaderBlockInterface::Variable* VARIABLE = pipelineProperties->GetVariable(i); + if (!VARIABLE) + break; + const std::string& VAR_NAME = pipelineProperties->GetVariableName(i); + YAML::Node propNode; + switch (VARIABLE->type) + { + case SHADE::SHShaderBlockInterface::Variable::Type::FLOAT: + propNode = material.GetProperty(VARIABLE->offset); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::INT: + propNode = material.GetProperty(VARIABLE->offset); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2: + propNode = material.GetProperty(VARIABLE->offset); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR3: + propNode = material.GetProperty(VARIABLE->offset); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR4: + propNode = material.GetProperty(VARIABLE->offset); + break; + case SHADE::SHShaderBlockInterface::Variable::Type::OTHER: + default: + continue; + break; + } + properties[VAR_NAME.data()] = propNode; + } + } +} \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.h b/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.h index 338c34b2..9c2177c3 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialSpec.h @@ -16,9 +16,18 @@ of DigiPen Institute of Technology is prohibited. #include // Project Includes #include "Assets/SHAssetMacros.h" +#include namespace SHADE { + /*-----------------------------------------------------------------------------------*/ + /* Forward Declaration */ + /*-----------------------------------------------------------------------------------*/ + class SHMaterial; + + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ /*************************************************************************************/ /*! \brief @@ -32,5 +41,11 @@ namespace SHADE AssetID fragShader; std::string subpassName; YAML::Node properties; + + /*---------------------------------------------------------------------------------*/ + /* Constructors */ + /*---------------------------------------------------------------------------------*/ + SHMaterialSpec() = default; + explicit SHMaterialSpec(const SHMaterial& material); }; } diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHMeshData.h b/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHMeshData.h deleted file mode 100644 index 2f7d320b..00000000 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHMeshData.h +++ /dev/null @@ -1,36 +0,0 @@ -/************************************************************************************//*! -\file SHPrimitiveGenerator.h -\author Tng Kah Wei, kahwei.tng, 390009620 -\par email: kahwei.tng\@digipen.edu -\date Sep 18, 2022 -\brief Contains the static class definition of SHPrimitiveGenerator. - -Copyright (C) 2022 DigiPen Institute of Technology. -Reproduction or disclosure of this file or its contents without the prior written consent -of DigiPen Institute of Technology is prohibited. -*//*************************************************************************************/ -#pragma once - -// STL Includes -#include -// Project Includes -#include "Math/SHMath.h" -#include "Graphics/MiddleEnd/Interface/SHMeshLibrary.h" - -namespace SHADE -{ - /*************************************************************************************/ - /*! - \brief - Static class that contains functions for generating 3D primitives. - */ - /*************************************************************************************/ - struct SHMeshData - { - std::vector VertexPositions; - std::vector VertexTexCoords; - std::vector VertexTangents; - std::vector VertexNormals; - std::vector Indices; - }; -} \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.cpp index be181beb..60decded 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.cpp @@ -3,7 +3,7 @@ \author Tng Kah Wei, kahwei.tng, 390009620 \par email: kahwei.tng\@digipen.edu \date Aug 30, 2022 -\brief Contains definitions for all of the functions of the classes that deal +\brief Contains definitions for all of the functions of the classes that deal with storage and management of vertex and index buffers of meshes. Copyright (C) 2022 DigiPen Institute of Technology. @@ -18,6 +18,15 @@ of DigiPen Institute of Technology is prohibited. namespace SHADE { + /*-----------------------------------------------------------------------------------*/ + /* Static Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + SHMeshData SHPrimitiveGenerator::cubeMesh; + SHMeshData SHPrimitiveGenerator::sphereMesh; + + /*-----------------------------------------------------------------------------------*/ + /* Primitive Generation Functions */ + /*-----------------------------------------------------------------------------------*/ SHMeshData SHPrimitiveGenerator::Cube() noexcept { SHMeshData mesh; @@ -25,40 +34,40 @@ namespace SHADE mesh.VertexPositions = { // front - SHVec3(-0.5f, -0.5f, 0.5f), - SHVec3( 0.5f, -0.5f, 0.5f), - SHVec3( 0.5f, 0.5f, 0.5f), - SHVec3(-0.5f, 0.5f, 0.5f), + SHVec3(-0.5f, -0.5f, 0.5f), + SHVec3(0.5f, -0.5f, 0.5f), + SHVec3(0.5f, 0.5f, 0.5f), + SHVec3(-0.5f, 0.5f, 0.5f), // back - SHVec3(-0.5f, -0.5f, -0.5f), - SHVec3(-0.5f, 0.5f, -0.5f), - SHVec3( 0.5f, 0.5f, -0.5f), - SHVec3( 0.5f, -0.5f, -0.5f), + SHVec3(-0.5f, -0.5f, -0.5f), + SHVec3(-0.5f, 0.5f, -0.5f), + SHVec3(0.5f, 0.5f, -0.5f), + SHVec3(0.5f, -0.5f, -0.5f), - // top + // top SHVec3(-0.5f, 0.5f, -0.5f), SHVec3(-0.5f, 0.5f, 0.5f), - SHVec3( 0.5f, 0.5f, 0.5f), - SHVec3( 0.5f, 0.5f, -0.5f), - + SHVec3(0.5f, 0.5f, 0.5f), + SHVec3(0.5f, 0.5f, -0.5f), + // bottom - SHVec3(-0.5f, -0.5f, -0.5f), - SHVec3( 0.5f, -0.5f, -0.5f), - SHVec3( 0.5f, -0.5f, 0.5f), - SHVec3(-0.5f, -0.5f, 0.5f), - + SHVec3(-0.5f, -0.5f, -0.5f), + SHVec3(0.5f, -0.5f, -0.5f), + SHVec3(0.5f, -0.5f, 0.5f), + SHVec3(-0.5f, -0.5f, 0.5f), + // right - SHVec3(0.5f, -0.5f, -0.5f), - SHVec3(0.5f, 0.5f, -0.5f), - SHVec3(0.5f, 0.5f, 0.5f), - SHVec3(0.5f, -0.5f, 0.5f), - + SHVec3(0.5f, -0.5f, -0.5f), + SHVec3(0.5f, 0.5f, -0.5f), + SHVec3(0.5f, 0.5f, 0.5f), + SHVec3(0.5f, -0.5f, 0.5f), + // left - SHVec3(-0.5f, -0.5f, -0.5f), - SHVec3(-0.5f, -0.5f, 0.5f), - SHVec3(-0.5f, 0.5f, 0.5f), - SHVec3(-0.5f, 0.5f, -0.5f) + SHVec3(-0.5f, -0.5f, -0.5f), + SHVec3(-0.5f, -0.5f, 0.5f), + SHVec3(-0.5f, 0.5f, 0.5f), + SHVec3(-0.5f, 0.5f, -0.5f) }; mesh.VertexTexCoords = @@ -118,7 +127,7 @@ namespace SHADE SHVec3(1.0f, 0.0f, 0.0f), SHVec3(1.0f, 0.0f, 0.0f), SHVec3(1.0f, 0.0f, 0.0f), - + // bottom SHVec3(1.0f, 0.0f, 0.0f), SHVec3(1.0f, 0.0f, 0.0f), @@ -193,7 +202,90 @@ namespace SHADE Handle SHPrimitiveGenerator::Cube(SHMeshLibrary& meshLibrary) noexcept { - static SHMeshData meshData = Cube(); + if (cubeMesh.VertexPositions.empty()) + cubeMesh = Cube(); + return addMeshDataTo(cubeMesh, meshLibrary); + } + + Handle SHPrimitiveGenerator::Cube(SHGraphicsSystem& gfxSystem) noexcept + { + if (cubeMesh.VertexPositions.empty()) + cubeMesh = Cube(); + return addMeshDataTo(cubeMesh, gfxSystem); + } + + SHADE::SHMeshData SHPrimitiveGenerator::Sphere() noexcept + { + SHMeshData meshData; + + const int LAT_SLICES = 12; + const int LONG_SLICES = 12; + float radius = 1; + for (int latNum = 0; latNum <= LAT_SLICES; ++latNum) + { + float theta = static_cast(latNum * std::numbers::pi / LAT_SLICES); + float sinTheta = sin(theta); + float cosTheta = cos(theta); + + for (int longNum = 0; longNum <= LONG_SLICES; ++longNum) + { + float phi = static_cast(longNum * 2 * std::numbers::pi / LONG_SLICES); + float sinPhi = sin(phi); + float cosPhi = cos(phi); + + const SHVec3 NORMAL = SHVec3(cosPhi * sinTheta, cosTheta, sinPhi * sinTheta); + meshData.VertexNormals.emplace_back(NORMAL); + meshData.VertexTangents.emplace_back(/* TODO */); + meshData.VertexTexCoords.emplace_back + ( + 1.0f - (longNum / static_cast(LONG_SLICES)), + 1.0f - (latNum / static_cast(LAT_SLICES)) + ); + meshData.VertexPositions.emplace_back(radius * NORMAL.x, radius * NORMAL.y, radius * NORMAL.z); + } + } + + for (int latNumber{}; latNumber < LAT_SLICES; latNumber++) + { + for (int longNumber{}; longNumber < LONG_SLICES; longNumber++) + { + const auto FIRST = (latNumber * (LONG_SLICES + 1)) + longNumber; + const auto SECOND = (FIRST + LONG_SLICES + 1); + + meshData.Indices.emplace_back(FIRST); + meshData.Indices.emplace_back(SECOND); + meshData.Indices.emplace_back(FIRST + 1); + + meshData.Indices.emplace_back(SECOND); + meshData.Indices.emplace_back(SECOND + 1); + meshData.Indices.emplace_back(FIRST + 1); + } + } + + return meshData; + } + + SHADE::Handle SHPrimitiveGenerator::Sphere(SHMeshLibrary& meshLibrary) noexcept + { + if (sphereMesh.VertexPositions.empty()) + sphereMesh = Sphere(); + + return addMeshDataTo(sphereMesh, meshLibrary); + } + + SHADE::Handle SHPrimitiveGenerator::Sphere(SHGraphicsSystem& gfxSystem) noexcept + { + if (sphereMesh.VertexPositions.empty()) + sphereMesh = Sphere(); + + return addMeshDataTo(sphereMesh, gfxSystem); + } + + /*-----------------------------------------------------------------------------------*/ + /* Helper Functions */ + /*-----------------------------------------------------------------------------------*/ + SHADE::Handle SHPrimitiveGenerator::addMeshDataTo(const SHMeshData& meshData, SHMeshLibrary& meshLibrary) noexcept + { return meshLibrary.AddMesh ( static_cast(meshData.VertexPositions.size()), @@ -206,9 +298,8 @@ namespace SHADE ); } - Handle SHPrimitiveGenerator::Cube(SHGraphicsSystem& gfxSystem) noexcept + SHADE::Handle SHPrimitiveGenerator::addMeshDataTo(const SHMeshData& meshData, SHGraphicsSystem& gfxSystem) noexcept { - static SHMeshData meshData = Cube(); return gfxSystem.AddMesh ( static_cast(meshData.VertexPositions.size()), diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h b/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h index dd059a29..7719e4c3 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h @@ -4,16 +4,17 @@ \par email: kahwei.tng\@digipen.edu \date Sep 18, 2022 \brief Contains the static class definition of SHPrimitiveGenerator. - + Copyright (C) 2022 DigiPen Institute of Technology. -Reproduction or disclosure of this file or its contents without the prior written consent +Reproduction or disclosure of this file or its contents without the prior written consent of DigiPen Institute of Technology is prohibited. *//*************************************************************************************/ #pragma once // Project Includes #include "Math/SHMath.h" -#include "SHMeshData.h" +#include "Assets/Asset Types/SHModelAsset.h" +#include "Graphics/MiddleEnd/Interface/SHMeshLibrary.h" #include "SH_API.h" namespace SHADE @@ -29,12 +30,12 @@ namespace SHADE /*************************************************************************************/ /*! \brief - Static class that contains functions for generating 3D primitives. + Static class that contains functions for generating 3D primitives. */ /*************************************************************************************/ class SH_API SHPrimitiveGenerator { - public: + public: /*---------------------------------------------------------------------------------*/ /* Constructors */ /*---------------------------------------------------------------------------------*/ @@ -42,7 +43,7 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ /* Primitive Generation Functions */ - /*---------------------------------------------------------------------------------*/ + /*---------------------------------------------------------------------------------*/ /***********************************************************************************/ /*! \brief @@ -52,20 +53,20 @@ namespace SHADE SHMeshData object containing vertex data for the cube. */ /***********************************************************************************/ - [[nodiscard]] static SHMeshData Cube() noexcept; + [[nodiscard]] static SHMeshData Cube() noexcept; /***********************************************************************************/ /*! \brief Produces a cube and constructs a SHMesh using the SHMeshLibrary provided. \param meshLibrary - Reference to the SHMeshLibrary to procude and store a cube mesh in. + Reference to the SHMeshLibrary to produce and store a cube mesh in. \return SHMesh object that points to the generated cube mesh in the SHMeshLibrary. */ /***********************************************************************************/ - [[nodiscard]] static Handle Cube(SHMeshLibrary& meshLibrary) noexcept; + [[nodiscard]] static Handle Cube(SHMeshLibrary& meshLibrary) noexcept; /***********************************************************************************/ /*! \brief @@ -78,12 +79,55 @@ namespace SHADE SHMesh object that points to the generated cube mesh in the SHGraphicsSystem. */ /***********************************************************************************/ - [[nodiscard]] static Handle Cube(SHGraphicsSystem& gfxSystem) noexcept; + [[nodiscard]] static Handle Cube(SHGraphicsSystem& gfxSystem) noexcept; + /***********************************************************************************/ + /*! + \brief + Produces a sphere and stores the data in a SHMeshData object. - private: + \return + SHMeshData object containing vertex data for the sphere. + */ + /***********************************************************************************/ + [[nodiscard]] static SHMeshData Sphere() noexcept; + /***********************************************************************************/ + /*! + \brief + Produces a sphere and constructs a SHMesh using the SHMeshLibrary provided. + + \param meshLibrary + Reference to the SHMeshLibrary to produce and store a sphere mesh in. + + \return + SHMesh object that points to the generated sphere mesh in the SHMeshLibrary. + */ + /***********************************************************************************/ + [[nodiscard]] static Handle Sphere(SHMeshLibrary& meshLibrary) noexcept; + /***********************************************************************************/ + /*! + \brief + Produces a sphere and constructs a SHMesh using the SHGraphicsSystem provided. + + \param gfxSystem + Reference to the SHGraphicsSystem to produce and store a sphere mesh in. + + \return + SHMesh object that points to the generated sphere mesh in the SHGraphicsSystem. + */ + /***********************************************************************************/ + [[nodiscard]] static Handle Sphere(SHGraphicsSystem& gfxSystem) noexcept; + + private: /*---------------------------------------------------------------------------------*/ /* Helper Functions */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] static SHMeshData genCubeData() noexcept; + static Handle addMeshDataTo(const SHMeshData& meshData, SHMeshLibrary& meshLibrary) noexcept; + static Handle addMeshDataTo(const SHMeshData& meshData, SHGraphicsSystem& gfxSystem) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + static SHMeshData cubeMesh; + static SHMeshData sphereMesh; }; } \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.cpp index bbbdd015..96db1ad1 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.cpp @@ -26,7 +26,7 @@ namespace SHADE */ /***************************************************************************/ - void SHPerFrameData::Recreate(Handle const& logicalDeviceHdl) noexcept + void SHPerFrameData::Recreate(Handle logicalDeviceHdl) noexcept { // Swapchain recreation means the images are just relinked to SHVkImages. Handles will remain the same. There is no need for this line. //swapchainImageHdl = params.swapchainHdl->GetSwapchainImage(frameIndex); @@ -44,14 +44,17 @@ namespace SHADE // Create image views for the swapchain swapchainImageViewHdl = swapchainImageHdl->CreateImageView(logicalDeviceHdl, swapchainImageHdl, viewDetails); + SET_VK_OBJ_NAME(logicalDeviceHdl, vk::ObjectType::eImageView, swapchainImageViewHdl->GetImageView(), "[Image View] Swap Chain"); // Create a fence fenceHdl = logicalDeviceHdl->CreateFence(); + SET_VK_OBJ_NAME(logicalDeviceHdl, vk::ObjectType::eFence, fenceHdl->GetVkFence(), "[Fence] Swap Chain"); // scope makes it easier to navigate semImgAvailableHdl = logicalDeviceHdl->SHVkLogicalDevice::CreateSemaphore(); + SET_VK_OBJ_NAME(logicalDeviceHdl, vk::ObjectType::eSemaphore, semImgAvailableHdl->GetVkSem(), "[Semaphore] Swap Chain Image Available"); semRenderFinishHdl = logicalDeviceHdl->SHVkLogicalDevice::CreateSemaphore(); - + SET_VK_OBJ_NAME(logicalDeviceHdl, vk::ObjectType::eSemaphore, semRenderFinishHdl->GetVkSem(), "[Semaphore] Swap Chain Render Finish"); } /***************************************************************************/ diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.h b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.h index 5ac38503..d19764c2 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHPerFrameData.h @@ -63,7 +63,7 @@ namespace SHADE /* PRIVATE MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ // These are made into functions (instead of ctor and dtor) because we want to call these functions again when we resize the window - void Recreate (Handle const& logicalDeviceHdl) noexcept; + void Recreate (Handle logicalDeviceHdl) noexcept; void Destroy (void); friend class SHRenderContext; diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp index 45103819..1d24d6f7 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp @@ -50,7 +50,13 @@ namespace SHADE for (uint32_t j = 0; j < params.numThreads; ++j) { - frameData[i].cmdPoolHdls.push_back(logicalDeviceHdl->CreateCommandPool(params.cmdPoolQueueFamilyType, params.cmdPoolResetMode, params.cmdBufferTransient)); + auto cmdPool = logicalDeviceHdl->CreateCommandPool(params.cmdPoolQueueFamilyType, params.cmdPoolResetMode, params.cmdBufferTransient); + SET_VK_OBJ_NAME + ( + logicalDeviceHdl, vk::ObjectType::eCommandPool, cmdPool->GetVkCommandPool(), + "[Command Pool] Render Context #" + std::to_string(i) + " Pool #" + std::to_string(j) + ); + frameData[i].cmdPoolHdls.push_back(cmdPool); } } diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/PostProcessing/SHSSAO.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/PostProcessing/SHSSAO.cpp new file mode 100644 index 00000000..2bf32fd8 --- /dev/null +++ b/SHADE_Engine/src/Graphics/MiddleEnd/PostProcessing/SHSSAO.cpp @@ -0,0 +1,138 @@ +#include "SHpch.h" +#include "SHSSAO.h" +#include "Graphics/Devices/SHVkLogicalDevice.h" +#include "Graphics/Buffers/SHVkBuffer.h" +#include "Graphics/Images/SHVkImage.h" +#include "Graphics/Images/SHVkSampler.h" +#include + +namespace SHADE +{ + void SHSSAO::Init(Handle logicalDevice, Handle cmdBuffer) noexcept + { + // Initialize a distribution to get values from 0 to 1 + std::uniform_real_distribution distrib{0.0f, 1.0f}; + + // generator for random number + std::default_random_engine generator; + + // generate samples + for (uint32_t i = 0; i < NUM_SAMPLES; ++i) + { + //SHVec3 temp + //{ + // distrib(generator) * 2.0f - 1.0f, // -1.0f - 1.0f + // distrib(generator) * 2.0f - 1.0f, // -1.0f - 1.0f + // distrib(generator), // 0.0f - 1.0f so that sample space is a hemisphere + //}; + + //temp = SHVec3::Normalise(temp); + //temp *= distrib(generator); + + //// This makes sure that most points are closer to fragment's position + //float scale = 1.0f / static_cast(NUM_SAMPLES); + //scale = std::lerp(0.1f, 1.0f, scale * scale); + //temp *= scale; + //samples[i] = SHVec4 (temp.x, temp.y, temp.z, 0.0f); + + + samples[i] = SHVec4 + { + distrib(generator) * 2.0f - 1.0f, // -1.0f - 1.0f + distrib(generator) * 2.0f - 1.0f, // -1.0f - 1.0f + distrib(generator), // 0.0f - 1.0f so that sample space is a hemisphere + 0.0f + }; + + // This makes sure that most points are closer to fragment's position + float scale = 1.0f / static_cast(NUM_SAMPLES); + scale = std::lerp(0.1f, 1.0f, scale * scale); + samples[i] *= scale; + } + + // generate rotation vector + for (uint32_t i = 0; i < NUM_ROTATION_VECTORS; ++i) + { + rotationVectors[i] = SHVec4 + { + distrib(generator) * 2.0f - 1.0f, // -1.0f - 1.0f + distrib(generator) * 2.0f - 1.0f, // -1.0f - 1.0f + 0.0f, // we want to rotate about the z axis in tangent space + 0.0f + }; + } + + SHImageCreateParams imageDetails = + { + .imageType = vk::ImageType::e2D, + .width = NUM_ROTATION_VECTORS_W, + .height = NUM_ROTATION_VECTORS_H, + .depth = 1, + .levels = 1, + .arrayLayers = 1, + .imageFormat = vk::Format::eR32G32B32A32Sfloat, + .usageFlags = vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst, + .createFlags = {} + }; + + uint32_t mipOffset = 0; + rotationVectorsImage = logicalDevice->CreateImage(imageDetails, reinterpret_cast( rotationVectors.data()), static_cast(sizeof(rotationVectors)), {&mipOffset, 1}, VMA_MEMORY_USAGE_AUTO, {}); + + vk::ImageMemoryBarrier transferBarrier{}; + rotationVectorsImage->PrepareImageTransitionInfo(vk::ImageLayout::eUndefined, vk::ImageLayout::eTransferDstOptimal, transferBarrier); + + cmdBuffer->PipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe, vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, {transferBarrier}); + + rotationVectorsImage->TransferToDeviceResource(cmdBuffer); + + vk::ImageMemoryBarrier shaderReadBarrier{}; + rotationVectorsImage->PrepareImageTransitionInfo(vk::ImageLayout::eTransferDstOptimal, vk::ImageLayout::eShaderReadOnlyOptimal, shaderReadBarrier); + cmdBuffer->PipelineBarrier(vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eComputeShader, {}, {}, {}, { shaderReadBarrier }); + + + // Get aligned size for buffer + uint32_t alignedSize = logicalDevice->PadSSBOSize(sizeof (samples)); + + // Create buffer + ssaoDataBuffer = logicalDevice->CreateBuffer(alignedSize, samples.data(), alignedSize, vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eTransferDst, VMA_MEMORY_USAGE_AUTO, {}); + + ssaoDataBuffer->TransferToDeviceResource(cmdBuffer); + } + + void SHSSAO::PrepareRotationVectorsVkData(Handle logicalDevice) noexcept + { + SHImageViewDetails DETAILS = + { + .viewType = vk::ImageViewType::e2D, + .format = vk::Format::eR32G32B32A32Sfloat, + .imageAspectFlags = vk::ImageAspectFlagBits::eColor, + .baseMipLevel = 0, + .mipLevelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1 + }; + rotationVectorsImageView = rotationVectorsImage->CreateImageView(logicalDevice, rotationVectorsImage, DETAILS); + + SHVkSamplerParams samplerParams + { + .minFilter = vk::Filter::eNearest, + .magFilter = vk::Filter::eNearest, + .addressMode = vk::SamplerAddressMode::eRepeat, + .mipmapMode = vk::SamplerMipmapMode::eNearest, + .maxLod = 1u + }; + + rotationVectorsSampler = logicalDevice->CreateSampler(samplerParams); + } + + SHVkDescriptorSetGroup::viewSamplerLayout SHSSAO::GetViewSamplerLayout(void) const noexcept + { + return std::make_tuple(rotationVectorsImageView, rotationVectorsSampler, vk::ImageLayout::eShaderReadOnlyOptimal); + } + + Handle SHSSAO::GetBuffer(void) const noexcept + { + return ssaoDataBuffer; + } + +} diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/PostProcessing/SHSSAO.h b/SHADE_Engine/src/Graphics/MiddleEnd/PostProcessing/SHSSAO.h new file mode 100644 index 00000000..c7c133c5 --- /dev/null +++ b/SHADE_Engine/src/Graphics/MiddleEnd/PostProcessing/SHSSAO.h @@ -0,0 +1,49 @@ +#pragma once + +#include "Resource/SHHandle.h" +#include "Graphics/SHVulkanIncludes.h" +#include "Math/Vector/SHVec4.h" +#include "Graphics/Descriptors/SHVkDescriptorSetGroup.h" + +namespace SHADE +{ + class SHVkBuffer; + class SHVkLogicalDevice; + class SHVkCommandBuffer; + class SHVkImage; + class SHVkImageView; + class SHVkSampler; + + class SHSSAO + { + public: + static constexpr uint32_t DESC_SET_BUFFER_BINDING = 0; + static constexpr uint32_t DESC_SET_IMAGE_BINDING = 1; + + private: + static constexpr uint32_t NUM_SAMPLES = 64; + static constexpr uint32_t NUM_ROTATION_VECTORS_W = 4; + static constexpr uint32_t NUM_ROTATION_VECTORS_H = 4; + static constexpr uint32_t NUM_ROTATION_VECTORS = NUM_ROTATION_VECTORS_W * NUM_ROTATION_VECTORS_H; + + private: + //! distances from a pixel we want to sample + std::array samples; + + //! For passing SSAO samples and kernel to GPU + Handle ssaoDataBuffer; + + std::array rotationVectors; + + Handle rotationVectorsImage; + Handle rotationVectorsImageView; + Handle rotationVectorsSampler; + + public: + void Init (Handle logicalDevice, Handle cmdBuffer) noexcept; + void PrepareRotationVectorsVkData (Handle logicalDevice) noexcept; + SHVkDescriptorSetGroup::viewSamplerLayout GetViewSamplerLayout (void) const noexcept; + + Handle GetBuffer (void) const noexcept; + }; +} diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp index 8719458b..b92ccddf 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp @@ -23,6 +23,7 @@ of DigiPen Institute of Technology is prohibited. #include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h" #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h" #include "Graphics/Images/SHVkImage.h" +#include "Graphics/Images/SHVkImageView.h" #include "Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h" #include "Assets/Asset Types/SHTextureAsset.h" @@ -78,6 +79,7 @@ namespace SHADE { job.Image = resourceManager.Create ( + device, &device->GetVMAAllocator(), SHImageCreateParams { @@ -142,6 +144,7 @@ namespace SHADE .layerCount = 1 }; job.TextureHandle->ImageView = job.Image->CreateImageView(device, job.Image, DETAILS); + SET_VK_OBJ_NAME(device, vk::ObjectType::eImageView, job.TextureHandle->ImageView->GetImageView(), "[Image View] Texture Library Texture #" + std::to_string(job.TextureHandle->TextureArrayIndex)); } // Add Textures @@ -150,20 +153,28 @@ namespace SHADE texOrder.emplace_back(job.TextureHandle); combinedImageSamplers.emplace_back(std::make_tuple(job.TextureHandle->ImageView, job.Sampler, vk::ImageLayout::eShaderReadOnlyOptimal)); job.TextureHandle->TextureArrayIndex = static_cast(texOrder.size()) - 1U; + + SET_VK_OBJ_NAME(device, vk::ObjectType::eImage, job.Image->GetVkImage(), "[Image] Texture Library Texture #" + std::to_string(job.TextureHandle->TextureArrayIndex)); + SET_VK_OBJ_NAME(device, vk::ObjectType::eImageView, job.TextureHandle->ImageView->GetImageView(), "[Image View] Texture Library Texture #" + std::to_string(job.TextureHandle->TextureArrayIndex)); } addJobs.clear(); /* Build Descriptor Set with all the Textures only if there are textures */ if (!texOrder.empty()) { - if (!texDescriptors) + if (texDescriptors) { - texDescriptors = descPool->Allocate - ( - { SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::STATIC_GLOBALS] }, - { static_cast(texOrder.size()) } - ); + texDescriptors.Free(); } + texDescriptors = descPool->Allocate + ( + { SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::STATIC_GLOBALS] }, + { static_cast(texOrder.size()) } + ); +#ifdef _DEBUG + for (auto set : texDescriptors->GetVkHandle()) + SET_VK_OBJ_NAME(device, vk::ObjectType::eDescriptorSet, set, "[Descriptor Set] Static Globals"); +#endif texDescriptors->ModifyWriteDescImage ( SHGraphicsConstants::DescriptorSetIndex::STATIC_GLOBALS, diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.h b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.h index 9357b0e0..5b7e4914 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.h +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.h @@ -129,6 +129,21 @@ namespace SHADE /* Getter Functions */ /*-----------------------------------------------------------------------------*/ Handle GetTextureDescriptorSetGroup() const noexcept { return texDescriptors; } + /***************************************************************************/ + /*! + * + \brief + Retrieves the texture handle at the specified texture index. + + \param textureId + Index of the texture to look for. + + \returns + Handle to the texture + + */ + /***************************************************************************/ + Handle GetTextureHandle(SHTexture::Index textureId) const { return texOrder[textureId]; }; private: /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Graphics/Pipeline/SHPipelineLayoutParams.h b/SHADE_Engine/src/Graphics/Pipeline/SHPipelineLayoutParams.h index d696e4a3..010bed0e 100644 --- a/SHADE_Engine/src/Graphics/Pipeline/SHPipelineLayoutParams.h +++ b/SHADE_Engine/src/Graphics/Pipeline/SHPipelineLayoutParams.h @@ -2,8 +2,10 @@ #define SH_PIPELINE_LAYOUT_PARAMS_H #include "Graphics/SHVulkanIncludes.h" +#include "Graphics/SHVulkanDefines.h" #include "Resource/SHHandle.h" #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h" +#include namespace SHADE { @@ -24,6 +26,12 @@ namespace SHADE //! want to use the layout to initialize the pipeline layout but we do not //! want to use it for allocating descriptor sets. std::vector> const& globalDescSetLayouts = {}; + + //! Since both SPIRV-Reflect and GLSL don't provide ways to describe UBOs or + //! SSBOs as dynamic, we need to do it ourselves. This will store bindings + //! which we will use when parsing for descriptor set layouts. If a parsed + //! binding is in this container, we make that binding's descriptor dynamic. + std::unordered_set dynamicBufferBindings; }; struct SHPipelineLayoutParamsDummy diff --git a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.h b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.h index 7378cc48..7e313ed6 100644 --- a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.h +++ b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.h @@ -47,12 +47,13 @@ namespace SHADE /*-----------------------------------------------------------------------*/ /* CTORS AND DTORS */ /*-----------------------------------------------------------------------*/ + //! For constructing a graphics pipeline SHVkPipeline (Handle const& inLogicalDeviceHdl, Handle const& inPipelineLayout, SHVkPipelineState const* const state, Handle const& renderpassHdl, Handle subpass) noexcept; - + //! For constructing a compute pipeline SHVkPipeline(Handle const& inLogicalDeviceHdl, Handle const& inPipelineLayout) noexcept; diff --git a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp index 37d00795..47b2e010 100644 --- a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp +++ b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp @@ -165,6 +165,28 @@ namespace SHADE newBinding.Stage = shaderModule->GetShaderStageFlagBits(); newBinding.Type = descBindingInfo.ConvertFromReflectDescType(reflectedBinding->descriptor_type); + // Here we want to check if a binding is supposed to be dynamic. If it is, make it dynamic. + if (newBinding.Type == vk::DescriptorType::eUniformBuffer || newBinding.Type == vk::DescriptorType::eStorageBuffer) + { + for (auto& bsHash : dynamicBufferBindings) + { + uint32_t set = static_cast(bsHash >> 32); + uint32_t binding = static_cast(bsHash & 0xFFFFFFFF); + if (set == CURRENT_SET && binding == newBinding.BindPoint) + { + switch (newBinding.Type) + { + case vk::DescriptorType::eUniformBuffer: + newBinding.Type = vk::DescriptorType::eUniformBufferDynamic; + break; + case vk::DescriptorType::eStorageBuffer: + newBinding.Type = vk::DescriptorType::eStorageBufferDynamic; + break; + } + } + } + } + // In reality, the check for variable descriptor sets do not exists in spirv-reflect. Fortunately, when a shader // defines a boundless descriptor binding in the shader, the information reflected makes the array dimensions // contain a 1 element of value 1. Knowing that having an array [1] doesn't make sense, we can use this to @@ -300,6 +322,7 @@ namespace SHADE , vkDescriptorSetLayoutsAllocate{} , descriptorSetLayoutsPipeline{} , vkDescriptorSetLayoutsPipeline{} + , dynamicBufferBindings{std::move (pipelineLayoutParams.dynamicBufferBindings)} { for (auto& mod : shaderModules) { diff --git a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.h b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.h index b4298e00..e2af02a9 100644 --- a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.h +++ b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.h @@ -29,6 +29,9 @@ namespace SHADE //! Push constant interface SHPushConstantInterface pushConstantInterface; + //! See SHPipelineLayoutParams for details + std::unordered_set dynamicBufferBindings; + //! Push constant ranges std::vector vkPcRanges; diff --git a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp index 828f2974..dcb3ff6a 100644 --- a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp +++ b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp @@ -129,4 +129,9 @@ namespace SHADE return vkQueue; } + void SHVkQueue::WaitIdle(void) const noexcept + { + vkQueue.waitIdle(); + } + } \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.h b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.h index a647cb72..f27f3b0b 100644 --- a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.h +++ b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.h @@ -50,6 +50,8 @@ namespace SHADE void SubmitCommandBuffer (std::initializer_list> cmdBuffers, std::initializer_list> signalSems = {}, std::initializer_list> waitSems = {}, vk::PipelineStageFlags waitDstStageMask = {}, Handle const& fence = {}) noexcept; vk::Result Present (Handle const& swapchain, std::initializer_list> waitSems, uint32_t frameIndex) noexcept; vk::Queue GetVkQueue() noexcept; + + void WaitIdle (void) const noexcept; }; } diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp index 93be2413..500bcf04 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp @@ -59,7 +59,8 @@ namespace SHADE format = renderGraphStorage->swapchain->GetSurfaceFormatKHR().format; } - renderGraphStorage->graphResources->try_emplace(resourceName, resourceManager->Create(renderGraphStorage, resourceName, typeFlags, format, w, h, levels, usageFlags, createFlags)); + auto resource = resourceManager->Create(renderGraphStorage, resourceName, typeFlags, format, w, h, levels, usageFlags, createFlags); + renderGraphStorage->graphResources->try_emplace(resourceName, resource); } /***************************************************************************/ @@ -353,7 +354,7 @@ namespace SHADE */ /***************************************************************************/ - void SHRenderGraph::Init(Handle logicalDevice, Handle swapchain) noexcept + void SHRenderGraph::Init(std::string graphName, Handle logicalDevice, Handle swapchain) noexcept { resourceManager = std::make_shared(); @@ -365,6 +366,8 @@ namespace SHADE renderGraphStorage->resourceManager = resourceManager; renderGraphStorage->descriptorPool = logicalDevice->CreateDescriptorPools(); + + name = std::move(graphName); } /***************************************************************************/ @@ -390,6 +393,7 @@ namespace SHADE , nodeIndexing{ std::move(rhs.nodeIndexing) } , nodes{ std::move(rhs.nodes) } , resourceManager{ std::move(rhs.resourceManager) } + , name { std::move(rhs.name) } { } @@ -403,6 +407,7 @@ namespace SHADE nodeIndexing = std::move(rhs.nodeIndexing); nodes = std::move(rhs.nodes); resourceManager = std::move(rhs.resourceManager); + name = std::move(rhs.name); return *this; } @@ -467,9 +472,9 @@ namespace SHADE } } - nodes.emplace_back(resourceManager->Create(renderGraphStorage, std::move(descInitParams), std::move(predecessors))); - nodeIndexing.emplace(nodeName, static_cast(nodes.size()) - 1u); - return nodes.at(nodeIndexing[nodeName]); + auto node = nodes.emplace_back(resourceManager->Create(nodeName, renderGraphStorage, std::move(descInitParams), std::move(predecessors))); + nodeIndexing.emplace(std::move(nodeName), static_cast(nodes.size()) - 1u); + return node; } /***************************************************************************/ @@ -516,8 +521,10 @@ namespace SHADE // better way to manage these void SHRenderGraph::Execute(uint32_t frameIndex, Handle cmdBuffer, Handle descPool) noexcept { + cmdBuffer->BeginLabeledSegment(name); for (auto& node : nodes) node->Execute(cmdBuffer, descPool, frameIndex); + cmdBuffer->EndLabeledSegment(); } void SHRenderGraph::FinaliseBatch(uint32_t frameIndex, Handle descPool) diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h index d90b66df..741cc522 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h @@ -69,6 +69,9 @@ namespace SHADE //! Resource library for graph handles std::shared_ptr resourceManager; + //! Name of the RenderGraph + std::string name; + public: /*-----------------------------------------------------------------------*/ /* CTORS AND DTORS */ @@ -81,7 +84,7 @@ namespace SHADE /*-----------------------------------------------------------------------*/ /* PUBLIC MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ - void Init (Handle logicalDevice, Handle swapchain) noexcept; + void Init (std::string graphName, Handle logicalDevice, Handle swapchain) noexcept; void AddResource(std::string resourceName, std::initializer_list typeFlags, uint32_t w = static_cast(-1), uint32_t h = static_cast(-1), vk::Format format = vk::Format::eB8G8R8A8Unorm, uint8_t levels = 1, vk::ImageUsageFlagBits usageFlags = {}, vk::ImageCreateFlagBits createFlags = {}); Handle AddNode (std::string nodeName, std::initializer_list resourceInstruction, std::initializer_list predecessorNodes) noexcept; diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp index aa9c7944..b3b5b58b 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp @@ -25,6 +25,7 @@ namespace SHADE void SHRenderGraphNode::CreateRenderpass(void) noexcept { renderpass = graphStorage->logicalDevice->CreateRenderpass(attachmentDescriptions, spDescs, spDeps); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eRenderPass, renderpass->GetVkRenderpass(), "[RenderPass] " + name); } /***************************************************************************/ @@ -57,6 +58,7 @@ namespace SHADE framebuffers[i] = graphStorage->logicalDevice->CreateFramebuffer(renderpass, imageViews, fbWidth, fbHeight); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eFramebuffer, framebuffers[i]->GetVkFramebuffer(), "[Framebuffer] " + name + std::to_string(i)); } } @@ -116,7 +118,7 @@ namespace SHADE */ /***************************************************************************/ - SHRenderGraphNode::SHRenderGraphNode(Handle renderGraphStorage, std::vector attDescInitParams, std::vector> predecessors) noexcept + SHRenderGraphNode::SHRenderGraphNode(std::string nodeName, Handle renderGraphStorage, std::vector attDescInitParams, std::vector> predecessors) noexcept : graphStorage{ renderGraphStorage} , renderpass{} , framebuffers{} @@ -128,6 +130,7 @@ namespace SHADE , executed{ false } , configured{ false } , nodeComputes{} + , name { std::move(nodeName) } { // pipeline library initialization pipelineLibrary.Init(graphStorage->logicalDevice); @@ -189,6 +192,7 @@ namespace SHADE , spDescs{ std::move(rhs.spDescs) } , spDeps{ std::move(rhs.spDeps) } , nodeComputes{ std::move(rhs.nodeComputes) } + , name { std::move(rhs.name) } { rhs.renderpass = {}; @@ -213,7 +217,7 @@ namespace SHADE spDescs = std::move(rhs.spDescs); spDeps = std::move(rhs.spDeps); nodeComputes = std::move(rhs.nodeComputes); - + name = std::move(rhs.name); rhs.renderpass = {}; @@ -263,7 +267,7 @@ namespace SHADE return subpass; } - Handle SHRenderGraphNode::AddNodeCompute(Handle computeShaderModule, std::initializer_list resources, float numWorkGroupScale/* = 1.0f*/) noexcept + Handle SHRenderGraphNode::AddNodeCompute(std::string nodeName, Handle computeShaderModule, std::initializer_list resources, std::unordered_set&& dynamicBufferBindings, float numWorkGroupScale/* = 1.0f*/) noexcept { // Look for the required resources in the graph std::vector> nodeComputeResources{}; @@ -276,7 +280,7 @@ namespace SHADE } // Create the subpass compute with the resources - auto nodeCompute = graphStorage->resourceManager->Create(graphStorage, computeShaderModule, std::move(nodeComputeResources), nodeComputes.empty()); + auto nodeCompute = graphStorage->resourceManager->Create(std::move(nodeName), graphStorage, computeShaderModule, std::move(nodeComputeResources), std::move (dynamicBufferBindings), nodeComputes.empty()); nodeComputes.push_back(nodeCompute); return nodeCompute; diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h index 16f3f914..4fdac45c 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h @@ -78,8 +78,11 @@ namespace SHADE //! Whether or not the node has been configured already or not bool configured; + //! Manages batching for this RenderPass SHBatcher batcher; + //! Name of this node + std::string name; /*-----------------------------------------------------------------------*/ /* PRIVATE MEMBER FUNCTIONS */ @@ -92,7 +95,7 @@ namespace SHADE /*-----------------------------------------------------------------------*/ /* CTORS AND DTORS */ /*-----------------------------------------------------------------------*/ - SHRenderGraphNode(Handle renderGraphStorage, std::vector attDescInitParams, std::vector> predecessors) noexcept; + SHRenderGraphNode(std::string nodeName, Handle renderGraphStorage, std::vector attDescInitParams, std::vector> predecessors) noexcept; SHRenderGraphNode(SHRenderGraphNode&& rhs) noexcept; SHRenderGraphNode& operator= (SHRenderGraphNode&& rhs) noexcept; @@ -100,7 +103,7 @@ namespace SHADE /* PUBLIC MEMBER FUNCTIONS */ /*-----------------------------------------------------------------------*/ Handle AddSubpass(std::string subpassName) noexcept; - Handle AddNodeCompute(Handle computeShaderModule, std::initializer_list resources, float numWorkGroupScale = 1.0f) noexcept; + Handle AddNodeCompute(std::string nodeName, Handle computeShaderModule, std::initializer_list resources, std::unordered_set&& dynamicBufferBindings = {}, float numWorkGroupScale = 1.0f) noexcept; void AddDummySubpassIfNeeded (void) noexcept; // TODO: RemoveSubpass() diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.cpp b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.cpp index 5323d706..f4a103f7 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.cpp +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.cpp @@ -13,7 +13,7 @@ namespace SHADE { - SHRenderGraphNodeCompute::SHRenderGraphNodeCompute(Handle graphStorage, Handle computeShaderModule, std::vector>&& subpassComputeResources, bool followingEndRP, float inNumWorkGroupScale/* = 1.0f*/) noexcept + SHRenderGraphNodeCompute::SHRenderGraphNodeCompute(std::string nodeName, Handle graphStorage, Handle computeShaderModule, std::vector>&& subpassComputeResources, std::unordered_set&& dynamicBufferBindings, bool followingEndRP, float inNumWorkGroupScale/* = 1.0f*/) noexcept : computePipeline{} , pipelineLayout{} , resources{} @@ -21,37 +21,65 @@ namespace SHADE , groupSizeY{0} , followingEndRenderpass {followingEndRP} , numWorkGroupScale {std::clamp(inNumWorkGroupScale, 0.0f, 1.0f)} + , computeResource{} + , name { std::move(nodeName) } { SHPipelineLayoutParams pipelineLayoutParams { .shaderModules = {computeShaderModule}, - .globalDescSetLayouts = SHGraphicsGlobalData::GetDescSetLayouts() + .globalDescSetLayouts = SHGraphicsGlobalData::GetDescSetLayouts(), + .dynamicBufferBindings = std::move(dynamicBufferBindings), }; // Create pipeline layout from parameters - pipelineLayout = graphStorage->logicalDevice->CreatePipelineLayout (pipelineLayoutParams); + pipelineLayout = graphStorage->logicalDevice->CreatePipelineLayout(pipelineLayoutParams); // Create the compute pipeline computePipeline = graphStorage->logicalDevice->CreateComputePipeline(pipelineLayout); // and construct it computePipeline->ConstructPipeline(); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::ePipelineLayout, pipelineLayout->GetVkPipelineLayout(), "[Compute Pipeline Layout] " + name); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::ePipeline, computePipeline->GetVkPipeline(), "[Compute Pipeline] " + name); // save the resources resources = std::move (subpassComputeResources); //Get the descriptor set layouts required to allocate. We only want the ones for allocate because //global descriptors are already bound in the main system. - auto const& layouts = computePipeline->GetPipelineLayout()->GetDescriptorSetLayoutsAllocate(); - - //Variable counts for the descriptor sets (all should be 1). - std::vector variableCounts{ static_cast(layouts.size()) }; - std::fill(variableCounts.begin(), variableCounts.end(), 0); + auto const& graphResourceLayout = computePipeline->GetPipelineLayout()->GetDescriptorSetLayoutsPipeline()[SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE]; // Allocate descriptor sets to hold the images for reading (STORAGE_IMAGE) for (uint32_t i = 0; i < SHGraphicsConstants::NUM_FRAME_BUFFERS; ++i) { - descSetGroups[i] = graphStorage->descriptorPool->Allocate(layouts, variableCounts); + graphResourceDescSets[i] = graphStorage->descriptorPool->Allocate({graphResourceLayout}, { 1 }); +#ifdef _DEBUG + for (auto set : graphResourceDescSets[i]->GetVkHandle()) + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eDescriptorSet, set, "[Descriptor Set] " + name + " #" + std::to_string(i)); +#endif + } + + + auto const& layouts = computePipeline->GetPipelineLayout()->GetDescriptorSetLayoutsPipeline(); + + if (layouts.size() == SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_NODE_COMPUTE_RESOURCE + 1) + { + // create compute resources + computeResource = graphStorage->resourceManager->Create(); + auto computeResourceLayout = layouts[SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_NODE_COMPUTE_RESOURCE]; + computeResource->descSet = graphStorage->descriptorPool->Allocate({ computeResourceLayout }, { 1 }); +#ifdef _DEBUG + for (auto set : computeResource->descSet->GetVkHandle()) + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eDescriptorSet, set, "[Descriptor Set] " + name + " Resources"); +#endif + + // Allocate for descriptor offsets + for (uint32_t i = 0; i < SHGraphicsConstants::NUM_FRAME_BUFFERS; ++i) + computeResource->dynamicOffsets[i].resize(computeResourceLayout->GetNumDynamicOffsetsRequired()); + + // 1st set all start at 0 + for (auto& index : computeResource->dynamicOffsets[0]) + index = 0; } HandleResize(); @@ -63,7 +91,12 @@ namespace SHADE cmdBuffer->BindPipeline(computePipeline); // bind descriptor sets - cmdBuffer->BindDescriptorSet(descSetGroups[frameIndex], SH_PIPELINE_TYPE::COMPUTE, SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE, {}); + cmdBuffer->BindDescriptorSet(graphResourceDescSets[frameIndex], SH_PIPELINE_TYPE::COMPUTE, SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE, {}); + + if (computeResource) + { + cmdBuffer->BindDescriptorSet(computeResource->descSet, SH_PIPELINE_TYPE::COMPUTE, SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_NODE_COMPUTE_RESOURCE, computeResource->dynamicOffsets[frameIndex]); + } // dispatch compute cmdBuffer->ComputeDispatch(groupSizeX, groupSizeY, 1); @@ -89,8 +122,8 @@ namespace SHADE uint32_t imageIndex = (resources[i]->resourceTypeFlags & static_cast(SH_ATT_DESC_TYPE_FLAGS::COLOR_PRESENT)) ? frameIndex : 0; SHVkDescriptorSetGroup::viewSamplerLayout vsl = std::make_tuple(resources[i]->GetImageView(imageIndex), Handle{}, vk::ImageLayout::eGeneral); - descSetGroups[frameIndex]->ModifyWriteDescImage(SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE, binding.BindPoint, { &vsl, 1 }); - descSetGroups[frameIndex]->UpdateDescriptorSetImages(SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE, binding.BindPoint); + graphResourceDescSets[frameIndex]->ModifyWriteDescImage(SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE, binding.BindPoint, { &vsl, 1 }); + graphResourceDescSets[frameIndex]->UpdateDescriptorSetImages(SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_RESOURCE, binding.BindPoint); ++i; } } @@ -137,4 +170,27 @@ namespace SHADE } } + void SHRenderGraphNodeCompute::SetDynamicOffsets(std::span perFrameSizes) noexcept + { + for (uint32_t i = 0; i < SHGraphicsConstants::NUM_FRAME_BUFFERS; ++i) + { + auto dynamicOffsets = computeResource->dynamicOffsets[i]; + for (uint32_t j = 0; j < perFrameSizes.size(); ++j) + dynamicOffsets[j] = perFrameSizes[j] * i; + } + } + + void SHRenderGraphNodeCompute::ModifyWriteDescBufferComputeResource(uint32_t set, uint32_t binding, std::span> const& buffers, uint32_t offset, uint32_t range) noexcept + { + computeResource->descSet->ModifyWriteDescBuffer(set, binding, buffers, offset, range); + computeResource->descSet->UpdateDescriptorSetBuffer(set, binding); + } + + void SHRenderGraphNodeCompute::ModifyWriteDescImageComputeResource(uint32_t set, uint32_t binding, std::span const& viewSamplerLayouts) noexcept + { + computeResource->descSet->ModifyWriteDescImage(set, binding, viewSamplerLayouts); + computeResource->descSet->UpdateDescriptorSetImages(set, binding); + + } + } diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.h b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.h index 2cd3c948..580f018c 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.h +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.h @@ -2,6 +2,7 @@ #include "Resource/SHHandle.h" #include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h" +#include "Graphics/Descriptors/SHVkDescriptorSetGroup.h" #include "Graphics/SHVulkanIncludes.h" #include #include @@ -10,7 +11,6 @@ namespace SHADE { class SHVkPipeline; - class SHVkDescriptorSetGroup; class SHVkDescriptorPool; class SHVkLogicalDevice; class SHVkPipelineLayout; @@ -18,9 +18,22 @@ namespace SHADE class SHRenderGraphResource; class SHVkShaderModule; class SHVkCommandBuffer; + class SHVkBuffer; + class SHRenderGraphNodeCompute { + private: + // Binding of set SHGraphicsConstants::DescriptorSetIndex::RENDERGRAPH_NODE_COMPUTE_RESOURCE + struct ComputeResource + { + //! Descriptor set (initialized by parent class) + Handle descSet {}; + + //! Dynamic offsets into these resources (initialized from the outside). + std::array, SHGraphicsConstants::NUM_FRAME_BUFFERS> dynamicOffsets {}; + }; + private: static constexpr uint32_t workGroupSizeX = 16; static constexpr uint32_t workGroupSizeY = 16; @@ -32,7 +45,10 @@ namespace SHADE Handle pipelineLayout; //! Descriptor set group to hold the images for reading (STORAGE_IMAGE) - std::array, SHGraphicsConstants::NUM_FRAME_BUFFERS> descSetGroups; + std::array, SHGraphicsConstants::NUM_FRAME_BUFFERS> graphResourceDescSets; + + //! Compute resources + Handle computeResource; //! vector of resources needed by the subpass compute std::vector> resources; @@ -49,12 +65,21 @@ namespace SHADE std::array, SHGraphicsConstants::NUM_FRAME_BUFFERS> memoryBarriers; + //! Name of this node + std::string name; + public: - SHRenderGraphNodeCompute(Handle graphStorage, Handle computeShaderModule, std::vector>&& subpassComputeResources, bool followingEndRP, float inNumWorkGroupScale = 1.0f) noexcept; + SHRenderGraphNodeCompute(std::string nodeName, Handle graphStorage, Handle computeShaderModule, std::vector>&& subpassComputeResources, std::unordered_set&& dynamicBufferBindings, bool followingEndRP, float inNumWorkGroupScale = 1.0f) noexcept; void Execute (Handle cmdBuffer, uint32_t frameIndex) noexcept; void HandleResize (void) noexcept; + void SetDynamicOffsets (std::span perFrameSizes) noexcept; + + void ModifyWriteDescBufferComputeResource (uint32_t set, uint32_t binding, std::span> const& buffers, uint32_t offset, uint32_t range) noexcept; + void ModifyWriteDescImageComputeResource(uint32_t set, uint32_t binding, std::span const& viewSamplerLayouts) noexcept; + + friend class SHRenderGraph; friend class SHRenderGraphNode; }; diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphResource.cpp b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphResource.cpp index 502e09b2..4d4099c6 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphResource.cpp +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphResource.cpp @@ -82,6 +82,7 @@ namespace SHADE { images[i] = graphStorage->swapchain->GetSwapchainImage(i); imageViews[i] = images[i]->CreateImageView(graphStorage->logicalDevice, images[i], viewDetails); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eImageView, imageViews[i]->GetImageView(), "[Image View] " + resourceName + " #" + std::to_string(i)); } } else // if swapchain image resource @@ -129,7 +130,9 @@ namespace SHADE } // The resource is not a swapchain image, just use the first slot of the vector - images.push_back(graphStorage->logicalDevice->CreateImage(width, height, mipLevels, resourceFormat, usage, createFlags)); + auto image = graphStorage->logicalDevice->CreateImage(width, height, mipLevels, resourceFormat, usage, createFlags); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eImage, image->GetVkImage(), "[Image] " + resourceName); + images.push_back(image); // prepare image view details SHImageViewDetails viewDetails @@ -144,7 +147,9 @@ namespace SHADE }; // just 1 image view created - imageViews.push_back(images[0]->CreateImageView(graphStorage->logicalDevice, images[0], viewDetails)); + auto imageView = images[0]->CreateImageView(graphStorage->logicalDevice, images[0], viewDetails); + imageViews.push_back(imageView); + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eImageView, imageView->GetImageView(), "[Image View] " + resourceName); } } diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp b/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp index d8f4f8c2..2ed84d92 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp @@ -70,7 +70,7 @@ namespace SHADE , inputImageDescriptors{ std::move(rhs.inputImageDescriptors) } , inputDescriptorLayout{ rhs.inputDescriptorLayout } , inputSamplers{ rhs.inputSamplers } - + , name { rhs.name } { } @@ -105,6 +105,7 @@ namespace SHADE inputImageDescriptors = std::move(rhs.inputImageDescriptors); inputDescriptorLayout = rhs.inputDescriptorLayout; inputSamplers = rhs.inputSamplers; + name = std::move(rhs.name); return *this; } @@ -200,6 +201,7 @@ namespace SHADE void SHSubpass::Execute(Handle& commandBuffer, Handle descPool, uint32_t frameIndex) noexcept { + commandBuffer->BeginLabeledSegment(name); // Ensure correct transforms are provided superBatch->UpdateBuffers(frameIndex, descPool); @@ -211,7 +213,7 @@ namespace SHADE { drawCall(commandBuffer); } - + commandBuffer->EndLabeledSegment(); } void SHSubpass::HandleResize(void) noexcept @@ -300,6 +302,11 @@ namespace SHADE group.Free(); group = graphStorage->descriptorPool->Allocate({ inputDescriptorLayout }, variableCounts); +#ifdef _DEBUG + const auto& GROUP_HANDLES = group->GetVkHandle(); + for (int i = 0; i < static_cast(GROUP_HANDLES.size()); ++i) + SET_VK_OBJ_NAME(graphStorage->logicalDevice, vk::ObjectType::eDescriptorSet, GROUP_HANDLES[i], "[Descriptor Set] " + name + " #" + std::to_string(i)); +#endif uint32_t i = 0; for (auto& binding : bindings) diff --git a/SHADE_Engine/src/Graphics/SHVkUtil.cpp b/SHADE_Engine/src/Graphics/SHVkUtil.cpp index 8b21e7d1..a9ac543f 100644 --- a/SHADE_Engine/src/Graphics/SHVkUtil.cpp +++ b/SHADE_Engine/src/Graphics/SHVkUtil.cpp @@ -82,7 +82,7 @@ namespace SHADE } } - void SHVkUtil::EnsureBufferAndCopyData(Handle device, Handle cmdBuffer, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage) + void SHVkUtil::EnsureBufferAndCopyData(Handle device, Handle cmdBuffer, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage, const std::string& name) { if (bufferHandle) { @@ -100,7 +100,8 @@ namespace SHADE size, usage | BuffUsage::eTransferDst, VmaMemoryUsage::VMA_MEMORY_USAGE_AUTO, - VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT + VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT, + name ); } @@ -108,7 +109,7 @@ namespace SHADE bufferHandle->TransferToDeviceResource(cmdBuffer); } - void SHVkUtil::EnsureBufferAndCopyHostVisibleData(Handle device, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage) + void SHVkUtil::EnsureBufferAndCopyHostVisibleData(Handle device, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage, const std::string& name) { if (bufferHandle) { @@ -126,7 +127,8 @@ namespace SHADE size, usage, VmaMemoryUsage::VMA_MEMORY_USAGE_AUTO, - VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_MAPPED_BIT + VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VmaAllocationCreateFlagBits::VMA_ALLOCATION_CREATE_MAPPED_BIT, + name ); } } diff --git a/SHADE_Engine/src/Graphics/SHVkUtil.h b/SHADE_Engine/src/Graphics/SHVkUtil.h index de700ea5..07e8f02e 100644 --- a/SHADE_Engine/src/Graphics/SHVkUtil.h +++ b/SHADE_Engine/src/Graphics/SHVkUtil.h @@ -54,7 +54,7 @@ namespace SHADE */ /***********************************************************************************/ - static void EnsureBufferAndCopyData(Handle device, Handle cmdBuffer, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage); + static void EnsureBufferAndCopyData(Handle device, Handle cmdBuffer, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage, const std::string& name = ""); /***********************************************************************************/ /*! @@ -80,7 +80,7 @@ namespace SHADE */ /***********************************************************************************/ - static void EnsureBufferAndCopyHostVisibleData(Handle device, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage); + static void EnsureBufferAndCopyHostVisibleData(Handle device, Handle& bufferHandle, void* src, uint32_t size, vk::BufferUsageFlagBits usage, const std::string& name = ""); static BindingAndSetHash GenBindingSetHash (uint32_t set, uint32_t binding) noexcept; }; diff --git a/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp b/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp index f214c094..67c83266 100644 --- a/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp +++ b/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp @@ -54,17 +54,7 @@ namespace SHADE { return variables.size(); } - - SHShaderBlockInterface::SHShaderBlockInterface(void) noexcept - : bytesRequired{ 0 } - {} - - SHShaderBlockInterface::SHShaderBlockInterface(SHShaderBlockInterface&& rhs) noexcept - : variables { std::move(rhs.variables) } - , variableIndexing { std::move(rhs.variableIndexing) } - , bytesRequired { rhs.bytesRequired } - {} - + void SHShaderBlockInterface::SetBytesRequired(uint32_t bytes) noexcept { bytesRequired = bytes; @@ -75,16 +65,4 @@ namespace SHADE { return bytesRequired; } - - SHADE::SHShaderBlockInterface& SHShaderBlockInterface::operator=(SHShaderBlockInterface&& rhs) noexcept - { - if (&rhs == this) - return *this; - - variables = std::move(rhs.variables); - variableIndexing = std::move(rhs.variableIndexing); - bytesRequired = rhs.bytesRequired; - - return *this; - } } \ No newline at end of file diff --git a/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h b/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h index ae75e2c8..8b7ccb97 100644 --- a/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h +++ b/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h @@ -33,7 +33,7 @@ namespace SHADE std::unordered_map variableIndexing; //! bytes required by the block (includes padding). This variable is required - uint32_t bytesRequired; + uint32_t bytesRequired = 0; public: void AddVariable (std::string name, Variable&& newVariable) noexcept; @@ -43,13 +43,6 @@ namespace SHADE const std::string& GetVariableName(uint32_t index) const noexcept; size_t GetVariableCount() const noexcept; - /*-----------------------------------------------------------------------*/ - /* CTORS AND DTORS */ - /*-----------------------------------------------------------------------*/ - SHShaderBlockInterface(void) noexcept; - SHShaderBlockInterface(SHShaderBlockInterface&& rhs) noexcept; - SHShaderBlockInterface& operator=(SHShaderBlockInterface&& rhs) noexcept; - /*-----------------------------------------------------------------------*/ /* SETTERS AND GETTERS */ /*-----------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp b/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp index f28561c5..96fa77ab 100644 --- a/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp +++ b/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp @@ -142,6 +142,16 @@ namespace SHADE case SpvOp::SpvOpTypeRuntimeArray: recurseForInfo(&member, interfaceHdl, member.offset, biggestAlignment, parentVarName + std::string(member.name) + "."); break; + case SpvOp::SpvOpTypeArray: + interfaceHdl->AddVariable(parentVarName + std::string (member.name), + SHShaderBlockInterface::Variable + ( + parentOffset + member.offset, + SHShaderBlockInterface::Variable::Type::OTHER + ) + ); + biggestAlignment = std::max(biggestAlignment, member.size); + break; } } }; diff --git a/SHADE_Engine/src/Graphics/Windowing/SHWindow.cpp b/SHADE_Engine/src/Graphics/Windowing/SHWindow.cpp index e0dbc1a4..22ca5eba 100644 --- a/SHADE_Engine/src/Graphics/Windowing/SHWindow.cpp +++ b/SHADE_Engine/src/Graphics/Windowing/SHWindow.cpp @@ -4,7 +4,6 @@ #include "ECS_Base/Managers/SHSystemManager.h" #include "Input/SHInputManager.h" - namespace SHADE { SHWindow::SHWindow() @@ -151,11 +150,11 @@ namespace SHADE SetWindowText(wndHWND, LPCWSTR(wndData.title.c_str())); } - SHWindow::SHVec2 SHWindow::GetPosition() const + SHWindow::WindowSize SHWindow::GetPosition() const { RECT rect; GetWindowRect(wndHWND, &rect); - return SHVec2(static_cast(rect.left), static_cast(rect.top)); + return WindowSize(static_cast(rect.left), static_cast(rect.top)); } void SHWindow::SetPosition(unsigned x, unsigned y) @@ -165,18 +164,18 @@ namespace SHADE wndData.y = y; } - SHWindow::SHVec2 SHWindow::GetWindowSize() const + SHWindow::WindowSize SHWindow::GetWindowSize() const { RECT rect; GetClientRect(wndHWND, &rect); - return SHVec2(static_cast(rect.right - rect.left), static_cast(rect.bottom - rect.top)); + return WindowSize(static_cast(rect.right - rect.left), static_cast(rect.bottom - rect.top)); } - SHWindow::SHVec2 SHWindow::GetCurrentDisplaySize() const + SHWindow::WindowSize SHWindow::GetCurrentDisplaySize() const { unsigned screenWidth = GetSystemMetrics(SM_CXSCREEN); unsigned screenHeight = GetSystemMetrics(SM_CYSCREEN); - return SHVec2(screenWidth, screenHeight); + return WindowSize(screenWidth, screenHeight); } void SHWindow::SetMouseVisible(bool show) @@ -260,7 +259,7 @@ namespace SHADE return wndHWND; } - const WindowData SHWindow::GetWindowData() const + const WindowData SHWindow::GetWindowData() const noexcept { return wndData; } @@ -287,6 +286,15 @@ namespace SHADE windowCloseCallbacks.erase(callbackid); } + void SHWindow::ToggleUnsavedChanges() noexcept + { + unsavedChanges = !unsavedChanges; + std::wstring title = wndData.title; + if(unsavedChanges) + title.append(L"*"); + SetWindowText(wndHWND, title.data()); + } + LRESULT SHWindow::WndProcStatic(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { auto window = windowMap.GetWindow(hwnd); diff --git a/SHADE_Engine/src/Graphics/Windowing/SHWindow.h b/SHADE_Engine/src/Graphics/Windowing/SHWindow.h index 11308d90..06df9036 100644 --- a/SHADE_Engine/src/Graphics/Windowing/SHWindow.h +++ b/SHADE_Engine/src/Graphics/Windowing/SHWindow.h @@ -74,7 +74,7 @@ namespace SHADE class SH_API SHWindow { public: - using SHVec2 = std::pair; + using WindowSize = std::pair; typedef std::function WindowResizeCallbackFn; typedef std::function WindowCloseCallbackFn; typedef uint16_t CALLBACKID; @@ -92,15 +92,15 @@ namespace SHADE void SetTitle(std::wstring title); - SHVec2 GetPosition() const; + WindowSize GetPosition() const; void SetPosition(unsigned x, unsigned y); //void SetPosition(SHMathVec2U); - SHVec2 GetWindowSize() const; + WindowSize GetWindowSize() const; //Get size of display the window is in (whichever window contains the window origin) - SHVec2 GetCurrentDisplaySize() const; + WindowSize GetCurrentDisplaySize() const; void SetMouseVisible(bool show); @@ -123,7 +123,7 @@ namespace SHADE HWND GetHWND(); - const WindowData GetWindowData() const; + const WindowData GetWindowData() const noexcept; CALLBACKID RegisterWindowSizeCallback(WindowResizeCallbackFn); void UnregisterWindowSizeCallback(CALLBACKID const& callbackid); @@ -131,6 +131,8 @@ namespace SHADE void UnregisterWindowCloseCallback(CALLBACKID const& callbackid); bool IsMinimized() const { return wndData.isMinimised; } + void ToggleUnsavedChanges() noexcept; + bool IsUnsavedChanges() const noexcept{return unsavedChanges;} protected: static LRESULT CALLBACK WndProcStatic(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); @@ -164,7 +166,8 @@ namespace SHADE std::unordered_map windowCloseCallbacks; CALLBACKID windowResizeCallbackCount{}; CALLBACKID windowCloseCallbackCount{}; - //TODO: Shift to events abstraction + + bool unsavedChanges = false; void OnCreate(HWND hwnd, LPCREATESTRUCT create_struct); void OnClose(); diff --git a/SHADE_Engine/src/Input/SHInputManager.cpp b/SHADE_Engine/src/Input/SHInputManager.cpp index c665a9c9..4849a772 100644 --- a/SHADE_Engine/src/Input/SHInputManager.cpp +++ b/SHADE_Engine/src/Input/SHInputManager.cpp @@ -25,16 +25,16 @@ namespace SHADE std::map SHInputManager::bindings; unsigned SHInputManager::keyCount = 0; - bool SHInputManager::keys[MAX_KEYS]; - bool SHInputManager::keysLast[MAX_KEYS]; - double SHInputManager::keysHeldTime[MAX_KEYS]; - double SHInputManager::keysReleasedTime[MAX_KEYS]; + bool SHInputManager::keys[MAX_KEYS] = {}; + bool SHInputManager::keysLast[MAX_KEYS] = {}; + double SHInputManager::keysHeldTime[MAX_KEYS] = {}; + double SHInputManager::keysReleasedTime[MAX_KEYS] = {}; unsigned SHInputManager::keyToggleCount = 0; - bool SHInputManager::keysToggle[MAX_KEYS]; - bool SHInputManager::keysToggleLast[MAX_KEYS]; - double SHInputManager::keysToggleOnTime[MAX_KEYS]; - double SHInputManager::keysToggleOffTime[MAX_KEYS]; + bool SHInputManager::keysToggle[MAX_KEYS] = {}; + bool SHInputManager::keysToggleLast[MAX_KEYS] = {}; + double SHInputManager::keysToggleOnTime[MAX_KEYS] = {}; + double SHInputManager::keysToggleOffTime[MAX_KEYS] = {}; int SHInputManager::mouseScreenX = 0; int SHInputManager::mouseScreenY = 0; @@ -46,11 +46,11 @@ namespace SHADE int SHInputManager::mouseWheelVerticalDeltaPoll = 0; unsigned char SHInputManager::controllersConnectedCount = 0; - unsigned SHInputManager::controllersInputCount[XUSER_MAX_COUNT]; - unsigned SHInputManager::controllersButtonCount[XUSER_MAX_COUNT]; - short SHInputManager::controllers[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT]; - short SHInputManager::controllersLast[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT]; - double SHInputManager::controllersHeldTime[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT]; + unsigned SHInputManager::controllersInputCount[XUSER_MAX_COUNT] = {}; + unsigned SHInputManager::controllersButtonCount[XUSER_MAX_COUNT] = {}; + short SHInputManager::controllers[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT] = {}; + short SHInputManager::controllersLast[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT] = {}; + double SHInputManager::controllersHeldTime[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT] = {}; double SHInputManager::controllersReleasedTime[XUSER_MAX_COUNT][MAX_CONTROLLER_INPUT]; //Internal helper function for splitting between inputs @@ -106,9 +106,11 @@ namespace SHADE memcpy(keysLast, keys, sizeof(keys)); //Poll - unsigned char keyboardState[MAX_KEYS]; + unsigned char keyboardState[MAX_KEYS] = {}; + SecureZeroMemory(keyboardState, sizeof(keyboardState)); //if (GetKeyboardState(keyboardState) == false) return; - SHASSERT(GetKeyboardState(keyboardState), "SHInputManager:GetKeyboardState() failed ({})", GetLastError()); + bool keyboardStateGot = GetKeyboardState(keyboardState); + SHASSERT(keyboardStateGot, "SHInputManager:GetKeyboardState() failed ({})", GetLastError()); keyCount = 0; keyToggleCount = 0; for (size_t i = 0; i < MAX_KEYS; ++i) diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp b/SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp index d0ba2f14..5bbf5e15 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp +++ b/SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp @@ -25,11 +25,13 @@ namespace SHADE /*-----------------------------------------------------------------------------------*/ SHBoundingBox::SHBoundingBox() noexcept + : RelativeExtents { SHVec3::One } { type = Type::BOX; } SHBoundingBox::SHBoundingBox(const SHVec3& c, const SHVec3& hE) noexcept + : RelativeExtents { SHVec3::One } { type = Type::BOX; @@ -45,16 +47,18 @@ namespace SHADE type = Type::BOX; - Center = rhs.Center; - Extents = rhs.Extents; + Center = rhs.Center; + Extents = rhs.Extents; + RelativeExtents = rhs.RelativeExtents; } SHBoundingBox::SHBoundingBox(SHBoundingBox&& rhs) noexcept { type = Type::BOX; - Center = rhs.Center; - Extents = rhs.Extents; + Center = rhs.Center; + Extents = rhs.Extents; + RelativeExtents = rhs.RelativeExtents; } /*-----------------------------------------------------------------------------------*/ @@ -69,8 +73,9 @@ namespace SHADE } else if (this != &rhs) { - Center = rhs.Center; - Extents = rhs.Extents; + Center = rhs.Center; + Extents = rhs.Extents; + RelativeExtents = rhs.RelativeExtents; } return *this; @@ -84,8 +89,9 @@ namespace SHADE } else { - Center = rhs.Center; - Extents = rhs.Extents; + Center = rhs.Center; + Extents = rhs.Extents; + RelativeExtents = rhs.RelativeExtents; } return *this; @@ -100,11 +106,16 @@ namespace SHADE return Center; } - SHVec3 SHBoundingBox::GetHalfExtents() const noexcept + SHVec3 SHBoundingBox::GetWorldExtents() const noexcept { return Extents; } + const SHVec3& SHBoundingBox::GetRelativeExtents() const noexcept + { + return RelativeExtents; + } + SHVec3 SHBoundingBox::GetMin() const noexcept { return SHVec3{ Center.x - Extents.x, Center.y - Extents.y, Center.z - Extents.z }; @@ -124,9 +135,14 @@ namespace SHADE Center = newCenter; } - void SHBoundingBox::SetHalfExtents(const SHVec3& newHalfExtents) noexcept + void SHBoundingBox::SetWorldExtents(const SHVec3& newWorldExtents) noexcept { - Extents = newHalfExtents; + Extents = newWorldExtents; + } + + void SHBoundingBox::SetRelativeExtents(const SHVec3& newRelativeExtents) noexcept + { + RelativeExtents = newRelativeExtents; } void SHBoundingBox::SetMin(const SHVec3& min) noexcept diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.h b/SHADE_Engine/src/Math/Geometry/SHBoundingBox.h index 5b3d26d5..e2757c17 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.h +++ b/SHADE_Engine/src/Math/Geometry/SHBoundingBox.h @@ -54,21 +54,23 @@ namespace SHADE /* Getter Functions */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] SHVec3 GetCenter () const noexcept; - [[nodiscard]] SHVec3 GetHalfExtents() const noexcept; - [[nodiscard]] SHVec3 GetMin () const noexcept; - [[nodiscard]] SHVec3 GetMax () const noexcept; - [[nodiscard]] std::vector GetVertices () const noexcept; + [[nodiscard]] SHVec3 GetCenter () const noexcept; + [[nodiscard]] SHVec3 GetWorldExtents () const noexcept; + [[nodiscard]] const SHVec3& GetRelativeExtents () const noexcept; + [[nodiscard]] SHVec3 GetMin () const noexcept; + [[nodiscard]] SHVec3 GetMax () const noexcept; + [[nodiscard]] std::vector GetVertices () const noexcept; /*---------------------------------------------------------------------------------*/ /* Setter Functions */ /*---------------------------------------------------------------------------------*/ - void SetCenter (const SHVec3& newCenter) noexcept; - void SetHalfExtents (const SHVec3& newHalfExtents) noexcept; - void SetMin (const SHVec3& min) noexcept; - void SetMax (const SHVec3& max) noexcept; - void SetMinMax (const SHVec3& min, const SHVec3& max) noexcept; + void SetCenter (const SHVec3& newCenter) noexcept; + void SetWorldExtents (const SHVec3& newWorldExtents) noexcept; + void SetRelativeExtents (const SHVec3& newRelativeExtents) noexcept; + void SetMin (const SHVec3& min) noexcept; + void SetMax (const SHVec3& max) noexcept; + void SetMinMax (const SHVec3& min, const SHVec3& max) noexcept; /*---------------------------------------------------------------------------------*/ /* Function Members */ @@ -89,6 +91,13 @@ namespace SHADE [[nodiscard]] static bool Intersect (const SHBoundingBox& lhs, const SHBoundingBox& rhs) noexcept; [[nodiscard]] static SHBoundingBox BuildFromBoxes (const SHBoundingBox* boxes, size_t numBoxes) noexcept; [[nodiscard]] static SHBoundingBox BuildFromVertices (const SHVec3* vertices, size_t numVertices, size_t stride = 0) noexcept; + + private: + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + SHVec3 RelativeExtents; }; diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp b/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp index 62bf12b2..f843a6bb 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp +++ b/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp @@ -25,11 +25,13 @@ namespace SHADE /*-----------------------------------------------------------------------------------*/ SHBoundingSphere::SHBoundingSphere() noexcept + : RelativeRadius { 1.0f } { type = Type::SPHERE; } SHBoundingSphere::SHBoundingSphere(const SHVec3& center, float radius) noexcept + : RelativeRadius { 1.0f } { type = Type::SPHERE; @@ -44,16 +46,18 @@ namespace SHADE type = Type::SPHERE; - Center = rhs.Center; - Radius = rhs.Radius; + Center = rhs.Center; + Radius = rhs.Radius; + RelativeRadius = rhs.RelativeRadius; } SHBoundingSphere::SHBoundingSphere(SHBoundingSphere&& rhs) noexcept { type = Type::SPHERE; - Center = rhs.Center; - Radius = rhs.Radius; + Center = rhs.Center; + Radius = rhs.Radius; + RelativeRadius = rhs.RelativeRadius; } /*-----------------------------------------------------------------------------------*/ @@ -68,8 +72,9 @@ namespace SHADE } else if (this != &rhs) { - Center = rhs.Center; - Radius = rhs.Radius; + Center = rhs.Center; + Radius = rhs.Radius; + RelativeRadius = rhs.RelativeRadius; } return *this; @@ -83,8 +88,9 @@ namespace SHADE } else { - Center = rhs.Center; - Radius = rhs.Radius; + Center = rhs.Center; + Radius = rhs.Radius; + RelativeRadius = rhs.RelativeRadius; } return *this; @@ -99,11 +105,16 @@ namespace SHADE return Center; } - float SHBoundingSphere::GetRadius() const noexcept + float SHBoundingSphere::GetWorldRadius() const noexcept { return Radius; } - + + float SHBoundingSphere::GetRelativeRadius() const noexcept + { + return RelativeRadius; + } + /*-----------------------------------------------------------------------------------*/ /* Setter Function Definitions */ /*-----------------------------------------------------------------------------------*/ @@ -113,9 +124,14 @@ namespace SHADE Center = center; } - void SHBoundingSphere::SetRadius(float radius) noexcept + void SHBoundingSphere::SetWorldRadius(float newWorldRadius) noexcept { - Radius = radius; + Radius = newWorldRadius; + } + + void SHBoundingSphere::SetRelativeRadius(float newRelativeRadius) noexcept + { + RelativeRadius = newRelativeRadius; } /*-----------------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h b/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h index 001e889b..d94722d6 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h +++ b/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h @@ -48,15 +48,17 @@ namespace SHADE /* Getter Functions */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] SHVec3 GetCenter () const noexcept; - [[nodiscard]] float GetRadius () const noexcept; + [[nodiscard]] SHVec3 GetCenter () const noexcept; + [[nodiscard]] float GetWorldRadius () const noexcept; + [[nodiscard]] float GetRelativeRadius () const noexcept; /*---------------------------------------------------------------------------------*/ /* Setter Functions */ /*---------------------------------------------------------------------------------*/ - void SetCenter (const SHVec3& center) noexcept; - void SetRadius (float radius) noexcept; + void SetCenter (const SHVec3& center) noexcept; + void SetWorldRadius (float newWorldRadius) noexcept; + void SetRelativeRadius (float newRelativeRadius) noexcept; /*---------------------------------------------------------------------------------*/ /* Function Members */ @@ -79,5 +81,12 @@ namespace SHADE [[nodiscard]] static SHBoundingSphere BuildFromSpheres (const SHBoundingSphere* spheres, size_t numSpheres) noexcept; [[nodiscard]] static SHBoundingSphere BuildFromVertices (const SHVec3* vertices, size_t numVertices, size_t stride = 0) noexcept; + private: + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + float RelativeRadius; + }; } // namespace SHADE diff --git a/SHADE_Engine/src/Math/SHColour.cpp b/SHADE_Engine/src/Math/SHColour.cpp index 944c37cb..fc2f2a08 100644 --- a/SHADE_Engine/src/Math/SHColour.cpp +++ b/SHADE_Engine/src/Math/SHColour.cpp @@ -118,6 +118,17 @@ namespace SHADE } {} + SHColour::SHColour(uint32_t rgba) noexcept + : XMFLOAT4 { 0.0f, 0.0f, 0.0f, 1.0f } + { + const SHColour32 TMP { ._32bitValue = rgba }; + + x = static_cast(TMP._8bitValues[0]) / 255.0f; + y = static_cast(TMP._8bitValues[1]) / 255.0f; + z = static_cast(TMP._8bitValues[2]) / 255.0f; + w = static_cast(TMP._8bitValues[3]) / 255.0f; + } + SHColour::SHColour(const SHVec3& rgb) noexcept : XMFLOAT4 { rgb.x, rgb.y, rgb.z, 1.0f } {} diff --git a/SHADE_Engine/src/Math/SHColour.h b/SHADE_Engine/src/Math/SHColour.h index a6adf7bb..5dac0edd 100644 --- a/SHADE_Engine/src/Math/SHColour.h +++ b/SHADE_Engine/src/Math/SHColour.h @@ -34,6 +34,12 @@ namespace SHADE float v = 0.0f; }; + union SH_API SHColour32 + { + uint32_t _32bitValue; + uint8_t _8bitValues[4]; + }; + class SH_API SHColour : public DirectX::XMFLOAT4 { public: @@ -46,6 +52,7 @@ namespace SHADE SHColour (float r, float g, float b, float a) noexcept; SHColour (uint8_t r, uint8_t g, uint8_t b) noexcept; SHColour (uint8_t r, uint8_t g, uint8_t b, uint8_t a) noexcept; + SHColour (uint32_t rgba) noexcept; SHColour (const SHVec3& rgb) noexcept; SHColour (const SHVec4& rgba) noexcept; diff --git a/SHADE_Engine/src/Math/Transform/SHTransformSystem.cpp b/SHADE_Engine/src/Math/Transform/SHTransformSystem.cpp index f000aa5b..94c133dd 100644 --- a/SHADE_Engine/src/Math/Transform/SHTransformSystem.cpp +++ b/SHADE_Engine/src/Math/Transform/SHTransformSystem.cpp @@ -231,12 +231,12 @@ namespace SHADE tf.worldRotation = tf.localRotation + (parent ? parent->GetLocalRotation() : SHVec3::Zero); // Set the orientation - // Wrap rotations between -360 and 360 and convert to radians + // Wrap rotations between -720 and 720 and convert to radians SHVec3 worldRotRad, localRotRad; for (size_t i = 0; i < SHVec3::SIZE; ++i) { - worldRotRad[i] = SHMath::Wrap(tf.worldRotation[i], -SHMath::TWO_PI, SHMath::TWO_PI); - localRotRad[i] = SHMath::Wrap(tf.localRotation[i], -SHMath::TWO_PI, SHMath::TWO_PI); + worldRotRad[i] = SHMath::Wrap(tf.worldRotation[i], -2.0f * SHMath::TWO_PI, 2.0f * SHMath::TWO_PI); + localRotRad[i] = SHMath::Wrap(tf.localRotation[i], -2.0f * SHMath::TWO_PI, 2.0f * SHMath::TWO_PI); } tf.world.orientation = SHQuaternion::FromEuler(worldRotRad); diff --git a/SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp b/SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp index c7e327fa..93126fc5 100644 --- a/SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp +++ b/SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp @@ -48,17 +48,22 @@ namespace SHADE return orientation.ToEuler(); } - const SHColliderComponent::Colliders& SHColliderComponent::GetColliders() const noexcept + const SHVec3& SHColliderComponent::GetScale() const noexcept { - return colliders; + return scale; } - SHCollider& SHColliderComponent::GetCollider(int index) + const SHColliderComponent::CollisionShapes& SHColliderComponent::GetCollisionShapes() const noexcept { - if (index < 0 || static_cast(index) >= colliders.size()) + return collisionShapes; + } + + SHCollisionShape& SHColliderComponent::GetCollisionShape(int index) + { + if (index < 0 || static_cast(index) >= collisionShapes.size()) throw std::invalid_argument("Out-of-range access!"); - return colliders[index]; + return collisionShapes[index]; } /*-----------------------------------------------------------------------------------*/ @@ -75,39 +80,74 @@ namespace SHADE } - SHBoundingBox* SHColliderComponent::AddBoundingBox(const SHVec3& halfExtents, const SHVec3& posOffset) noexcept + void SHColliderComponent::RecomputeCollisionShapes() noexcept + { + for (auto& collisionShape : collisionShapes) + { + switch (collisionShape.GetType()) + { + case SHCollisionShape::Type::BOX: + { + auto* box = reinterpret_cast(collisionShape.GetShape()); + const SHVec3& RELATIVE_EXTENTS = box->GetRelativeExtents(); + + // Recompute world extents based on new scale and fixed relative extents + const SHVec3 WORLD_EXTENTS = RELATIVE_EXTENTS * (scale * 0.5f); + box->SetWorldExtents(WORLD_EXTENTS); + + continue; + } + case SHCollisionShape::Type::SPHERE: + { + auto* sphere = reinterpret_cast(collisionShape.GetShape()); + const float RELATIVE_RADIUS = sphere->GetRelativeRadius(); + + // Recompute world radius based on new scale and fixed radius + const float MAX_SCALE = SHMath::Max({ scale.x, scale.y, scale.z }); + const float WORLD_RADIUS = RELATIVE_RADIUS * MAX_SCALE * 0.5f; + sphere->SetWorldRadius(WORLD_RADIUS); + + continue; + } + default: continue; + } + } + } + + int SHColliderComponent::AddBoundingBox(const SHVec3& halfExtents, const SHVec3& posOffset, const SHVec3& rotOffset) noexcept { if (!system) { SHLOG_ERROR("Physics system does not exist, unable to add Box Collider!") - return nullptr; + return -1; } - static constexpr auto TYPE = SHCollider::Type::BOX; + static constexpr auto TYPE = SHCollisionShape::Type::BOX; - auto& collider = colliders.emplace_back(SHCollider{ GetEID(), TYPE }); + auto& collider = collisionShapes.emplace_back(SHCollisionShape{ GetEID(), TYPE }); collider.entityID = GetEID(); collider.SetPositionOffset(posOffset); + collider.SetRotationOffset(rotOffset); collider.SetBoundingBox(halfExtents); // Notify Physics System system->AddCollisionShape(GetEID(), &collider); - return reinterpret_cast(collider.GetShape()); + return static_cast(collisionShapes.size()) - 1; } - SHBoundingSphere* SHColliderComponent::AddBoundingSphere(float radius, const SHVec3& posOffset) noexcept + int SHColliderComponent::AddBoundingSphere(float radius, const SHVec3& posOffset) noexcept { if (!system) { SHLOG_ERROR("Physics system does not exist, unable to add Sphere Collider!") - return nullptr; + return -1; } - static constexpr auto TYPE = SHCollider::Type::SPHERE; + static constexpr auto TYPE = SHCollisionShape::Type::SPHERE; - auto& collider = colliders.emplace_back(SHCollider{ GetEID(), TYPE }); + auto& collider = collisionShapes.emplace_back(SHCollisionShape{ GetEID(), TYPE }); collider.entityID = GetEID(); collider.SetPositionOffset(posOffset); @@ -116,17 +156,17 @@ namespace SHADE // Notify Physics System system->AddCollisionShape(GetEID(), &collider); - return reinterpret_cast(collider.GetShape()); + return static_cast(collisionShapes.size()) - 1; } void SHColliderComponent::RemoveCollider(int index) { - if (index < 0 || static_cast(index) >= colliders.size()) + if (index < 0 || static_cast(index) >= collisionShapes.size()) throw std::invalid_argument("Out-of-range access!"); int idx = 0; - auto it = colliders.begin(); - for (; it != colliders.end(); ++it) + auto it = collisionShapes.begin(); + for (; it != collisionShapes.end(); ++it) { if (idx == index) break; @@ -134,7 +174,7 @@ namespace SHADE ++idx; } - it = colliders.erase(it); + it = collisionShapes.erase(it); // Notify Physics System if (!system) diff --git a/SHADE_Engine/src/Physics/Components/SHColliderComponent.h b/SHADE_Engine/src/Physics/Components/SHColliderComponent.h index 7ce272a9..5f9b7a1b 100644 --- a/SHADE_Engine/src/Physics/Components/SHColliderComponent.h +++ b/SHADE_Engine/src/Physics/Components/SHColliderComponent.h @@ -14,7 +14,7 @@ // Project Headers #include "ECS_Base/Components/SHComponent.h" -#include "Physics/SHCollider.h" +#include "Physics/SHCollisionShape.h" #include "Math/Geometry/SHBoundingBox.h" #include "Math/Geometry/SHBoundingSphere.h" @@ -43,7 +43,7 @@ namespace SHADE /* Type Definitions */ /*---------------------------------------------------------------------------------*/ - using Colliders = std::vector; + using CollisionShapes = std::vector; public: @@ -67,26 +67,29 @@ namespace SHADE /* Getter Functions */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] bool HasChanged () const noexcept; + [[nodiscard]] bool HasChanged () const noexcept; - [[nodiscard]] const SHVec3& GetPosition () const noexcept; - [[nodiscard]] const SHQuaternion& GetOrientation () const noexcept; - [[nodiscard]] SHVec3 GetRotation () const noexcept; + [[nodiscard]] const SHVec3& GetPosition () const noexcept; + [[nodiscard]] const SHQuaternion& GetOrientation () const noexcept; + [[nodiscard]] SHVec3 GetRotation () const noexcept; + [[nodiscard]] const SHVec3& GetScale () const noexcept; - [[nodiscard]] const Colliders& GetColliders () const noexcept; - [[nodiscard]] SHCollider& GetCollider (int index); + [[nodiscard]] const CollisionShapes& GetCollisionShapes() const noexcept; + [[nodiscard]] SHCollisionShape& GetCollisionShape (int index); /*---------------------------------------------------------------------------------*/ /* Function Members */ /*---------------------------------------------------------------------------------*/ - void OnCreate () override; - void OnDestroy () override; + void OnCreate () override; + void OnDestroy () override; - void RemoveCollider (int index); + void RecomputeCollisionShapes () noexcept; - SHBoundingBox* AddBoundingBox (const SHVec3& halfExtents = SHVec3::One, const SHVec3& posOffset = SHVec3::Zero) noexcept; - SHBoundingSphere* AddBoundingSphere (float radius = 1.0f, const SHVec3& posOffset = SHVec3::Zero) noexcept; + void RemoveCollider (int index); + + int AddBoundingBox (const SHVec3& halfExtents = SHVec3::One, const SHVec3& posOffset = SHVec3::Zero, const SHVec3& rotOffset = SHVec3::Zero) noexcept; + int AddBoundingSphere (float radius = 1.0f, const SHVec3& posOffset = SHVec3::Zero) noexcept; private: @@ -98,7 +101,8 @@ namespace SHADE SHVec3 position; SHQuaternion orientation; - Colliders colliders; + SHVec3 scale; + CollisionShapes collisionShapes; RTTR_ENABLE() }; diff --git a/SHADE_Engine/src/Physics/SHCollider.cpp b/SHADE_Engine/src/Physics/SHCollisionShape.cpp similarity index 62% rename from SHADE_Engine/src/Physics/SHCollider.cpp rename to SHADE_Engine/src/Physics/SHCollisionShape.cpp index 6cea3dc1..c8f8020c 100644 --- a/SHADE_Engine/src/Physics/SHCollider.cpp +++ b/SHADE_Engine/src/Physics/SHCollisionShape.cpp @@ -11,12 +11,12 @@ #include // Primary Header -#include "SHCollider.h" +#include "SHCollisionShape.h" // Project Headers #include "Math/Geometry/SHBoundingBox.h" #include "Math/Geometry/SHBoundingSphere.h" -#include "Math/Transform/SHTransformComponent.h" #include "Math/SHMathHelpers.h" +#include "Physics/Components/SHColliderComponent.h" #include "Reflection/SHReflectionMetadata.h" namespace SHADE @@ -25,7 +25,7 @@ namespace SHADE /* Constructors & Destructor Definitions */ /*-----------------------------------------------------------------------------------*/ - SHCollider::SHCollider(EntityID eid, Type colliderType, const SHPhysicsMaterial& physicsMaterial) + SHCollisionShape::SHCollisionShape(EntityID eid, Type colliderType, const SHPhysicsMaterial& physicsMaterial) : type { colliderType } , entityID { eid } , isTrigger { false } @@ -49,7 +49,7 @@ namespace SHADE } } - SHCollider::SHCollider(const SHCollider& rhs) noexcept + SHCollisionShape::SHCollisionShape(const SHCollisionShape& rhs) noexcept : type { rhs.type} , entityID { rhs.entityID } , isTrigger { rhs.isTrigger } @@ -61,7 +61,7 @@ namespace SHADE CopyShape(rhs.shape); } - SHCollider::SHCollider(SHCollider&& rhs) noexcept + SHCollisionShape::SHCollisionShape(SHCollisionShape&& rhs) noexcept : type { rhs.type} , entityID { rhs.entityID } , isTrigger { rhs.isTrigger } @@ -73,7 +73,7 @@ namespace SHADE CopyShape(rhs.shape); } - SHCollider::~SHCollider() noexcept + SHCollisionShape::~SHCollisionShape() noexcept { shape = nullptr; } @@ -82,7 +82,7 @@ namespace SHADE /* Operator Overload Definitions */ /*-----------------------------------------------------------------------------------*/ - SHCollider& SHCollider::operator=(const SHCollider& rhs) noexcept + SHCollisionShape& SHCollisionShape::operator=(const SHCollisionShape& rhs) noexcept { if (this == &rhs) return *this; @@ -100,7 +100,7 @@ namespace SHADE return *this; } - SHCollider& SHCollider::operator=(SHCollider&& rhs) noexcept + SHCollisionShape& SHCollisionShape::operator=(SHCollisionShape&& rhs) noexcept { type = rhs.type; entityID = rhs.entityID; @@ -119,52 +119,52 @@ namespace SHADE /* Getter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - bool SHCollider::HasChanged() const noexcept + bool SHCollisionShape::HasChanged() const noexcept { return dirty; } - bool SHCollider::IsTrigger() const noexcept + bool SHCollisionShape::IsTrigger() const noexcept { return isTrigger; } - SHCollider::Type SHCollider::GetType() const noexcept + SHCollisionShape::Type SHCollisionShape::GetType() const noexcept { return type; } - float SHCollider::GetFriction() const noexcept + float SHCollisionShape::GetFriction() const noexcept { return material.GetFriction(); } - float SHCollider::GetBounciness() const noexcept + float SHCollisionShape::GetBounciness() const noexcept { return material.GetBounciness(); } - float SHCollider::GetDensity() const noexcept + float SHCollisionShape::GetDensity() const noexcept { return material.GetDensity(); } - const SHPhysicsMaterial& SHCollider::GetMaterial() const noexcept + const SHPhysicsMaterial& SHCollisionShape::GetMaterial() const noexcept { return material; } - const SHVec3& SHCollider::GetPositionOffset() const noexcept + const SHVec3& SHCollisionShape::GetPositionOffset() const noexcept { return positionOffset; } - const SHVec3& SHCollider::GetRotationOffset() const noexcept + const SHVec3& SHCollisionShape::GetRotationOffset() const noexcept { return rotationOffset; } - SHShape* SHCollider::GetShape() noexcept + SHShape* SHCollisionShape::GetShape() noexcept { dirty = true; return shape; @@ -174,93 +174,80 @@ namespace SHADE /* Setter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHCollider::SetBoundingBox(const SHVec3& halfExtents) + void SHCollisionShape::SetBoundingBox(const SHVec3& halfExtents) { dirty = true; - // Set the half extents relative to transform - SHVec3 worldHalfExtents = halfExtents; + const auto* colliderComponent = SHComponentManager::GetComponent(entityID); + // Set the half extents relative to world scale + const SHVec3 WORLD_EXTENTS = halfExtents * colliderComponent->GetScale() * 0.5f; - const auto* transformComponent = SHComponentManager::GetComponent_s(entityID); - if (transformComponent != nullptr) - worldHalfExtents *= (transformComponent->GetWorldScale() * 0.5f); - - if (type == Type::BOX) - { - auto* box = reinterpret_cast(shape); - box->SetHalfExtents(worldHalfExtents); - } - else + if (type != Type::BOX) { type = Type::BOX; delete shape; - shape = new SHBoundingBox{ positionOffset, worldHalfExtents }; + shape = new SHBoundingBox{ positionOffset, WORLD_EXTENTS }; } + + auto* box = reinterpret_cast(shape); + box->SetWorldExtents(WORLD_EXTENTS); + box->SetRelativeExtents(halfExtents); } - void SHCollider::SetBoundingSphere(float radius) + void SHCollisionShape::SetBoundingSphere(float radius) { dirty = true; - // Set the radius relative to transform - float worldRadius = radius; + const auto* colliderComponent = SHComponentManager::GetComponent(entityID); + // Set the radius relative to world scale + const SHVec3 WORLD_SCALE = colliderComponent->GetScale(); + const float MAX_SCALE = SHMath::Max({ WORLD_SCALE.x, WORLD_SCALE.y, WORLD_SCALE.z }); + const float WORLD_RADIUS = radius * MAX_SCALE * 0.5f; - const auto* transformComponent = SHComponentManager::GetComponent_s(entityID); - if (transformComponent != nullptr) - { - const SHVec3 TF_WORLD_SCALE = transformComponent->GetWorldScale(); - const float MAX_SCALE = SHMath::Max({ TF_WORLD_SCALE.x, TF_WORLD_SCALE.y, TF_WORLD_SCALE.z }); - - worldRadius *= MAX_SCALE; - } - - if (type == Type::SPHERE) - { - auto* sphere = reinterpret_cast(shape); - sphere->SetRadius(worldRadius); - } - else + if (type != Type::SPHERE) { type = Type::SPHERE; delete shape; - shape = new SHBoundingSphere{ positionOffset, worldRadius }; + shape = new SHBoundingSphere{ positionOffset, WORLD_RADIUS }; } - + + auto* sphere = reinterpret_cast(shape); + sphere->SetWorldRadius(WORLD_RADIUS); } - void SHCollider::SetIsTrigger(bool trigger) noexcept + void SHCollisionShape::SetIsTrigger(bool trigger) noexcept { dirty = true; isTrigger = trigger; } - void SHCollider::SetFriction(float friction) noexcept + void SHCollisionShape::SetFriction(float friction) noexcept { dirty = true; material.SetFriction(friction); } - void SHCollider::SetBounciness(float bounciness) noexcept + void SHCollisionShape::SetBounciness(float bounciness) noexcept { dirty = true; material.SetBounciness(bounciness); } - void SHCollider::SetDensity(float density) noexcept + void SHCollisionShape::SetDensity(float density) noexcept { dirty = true; material.SetDensity(density); } - void SHCollider::SetMaterial(const SHPhysicsMaterial& newMaterial) noexcept + void SHCollisionShape::SetMaterial(const SHPhysicsMaterial& newMaterial) noexcept { dirty = true; material = newMaterial; } - void SHCollider::SetPositionOffset(const SHVec3& posOffset) noexcept + void SHCollisionShape::SetPositionOffset(const SHVec3& posOffset) noexcept { dirty = true; positionOffset = posOffset; @@ -281,7 +268,7 @@ namespace SHADE } } - void SHCollider::SetRotationOffset(const SHVec3& rotOffset) noexcept + void SHCollisionShape::SetRotationOffset(const SHVec3& rotOffset) noexcept { dirty = true; rotationOffset = rotOffset; @@ -291,7 +278,7 @@ namespace SHADE /* Private Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHCollider::CopyShape(const SHShape* rhs) + void SHCollisionShape::CopyShape(const SHShape* rhs) { switch (type) { @@ -299,14 +286,14 @@ namespace SHADE { const auto* RHS_BOX = reinterpret_cast(rhs); - shape = new SHBoundingBox{ positionOffset, RHS_BOX->GetHalfExtents() }; + shape = new SHBoundingBox{ positionOffset, RHS_BOX->GetWorldExtents() }; break; } case Type::SPHERE: { const auto* RHS_SPHERE = reinterpret_cast(rhs); - shape = new SHBoundingSphere{ positionOffset, RHS_SPHERE->GetRadius() }; + shape = new SHBoundingSphere{ positionOffset, RHS_SPHERE->GetWorldRadius() }; break; } default: break; @@ -320,14 +307,14 @@ RTTR_REGISTRATION using namespace SHADE; using namespace rttr; - registration::enumeration("Collider Type") + registration::enumeration("Collider Type") ( - value("Box", SHCollider::Type::BOX), - value("Sphere", SHCollider::Type::SPHERE) + value("Box", SHCollisionShape::Type::BOX), + value("Sphere", SHCollisionShape::Type::SPHERE) // TODO(Diren): Add More Shapes ); - registration::class_("Collider") - .property("Position Offset", &SHCollider::GetPositionOffset, &SHCollider::SetPositionOffset) - .property("Rotation Offset", &SHCollider::GetRotationOffset, &SHCollider::SetRotationOffset) (metadata(META::angleInRad, true)); + registration::class_("Collider") + .property("Position Offset", &SHCollisionShape::GetPositionOffset, &SHCollisionShape::SetPositionOffset) + .property("Rotation Offset", &SHCollisionShape::GetRotationOffset, &SHCollisionShape::SetRotationOffset) (metadata(META::angleInRad, true)); } \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHCollider.h b/SHADE_Engine/src/Physics/SHCollisionShape.h similarity index 91% rename from SHADE_Engine/src/Physics/SHCollider.h rename to SHADE_Engine/src/Physics/SHCollisionShape.h index 8cc233c4..9c8c1d41 100644 --- a/SHADE_Engine/src/Physics/SHCollider.h +++ b/SHADE_Engine/src/Physics/SHCollisionShape.h @@ -24,7 +24,7 @@ namespace SHADE /* Type Definitions */ /*-----------------------------------------------------------------------------------*/ - class SH_API SHCollider + class SH_API SHCollisionShape { private: @@ -51,18 +51,18 @@ namespace SHADE /* Constructors & Destructor */ /*---------------------------------------------------------------------------------*/ - SHCollider (EntityID eid, Type colliderType = Type::BOX, const SHPhysicsMaterial& physicsMaterial = SHPhysicsMaterial::DEFAULT); + SHCollisionShape (EntityID eid, Type colliderType = Type::BOX, const SHPhysicsMaterial& physicsMaterial = SHPhysicsMaterial::DEFAULT); - SHCollider (const SHCollider& rhs) noexcept; - SHCollider (SHCollider&& rhs) noexcept; - ~SHCollider () noexcept; + SHCollisionShape (const SHCollisionShape& rhs) noexcept; + SHCollisionShape (SHCollisionShape&& rhs) noexcept; + ~SHCollisionShape () noexcept; /*---------------------------------------------------------------------------------*/ /* Operator Overloads */ /*---------------------------------------------------------------------------------*/ - SHCollider& operator=(const SHCollider& rhs) noexcept; - SHCollider& operator=(SHCollider&& rhs) noexcept; + SHCollisionShape& operator=(const SHCollisionShape& rhs) noexcept; + SHCollisionShape& operator=(SHCollisionShape&& rhs) noexcept; /*---------------------------------------------------------------------------------*/ /* Getter Functions */ diff --git a/SHADE_Engine/src/Physics/SHPhysicsObject.cpp b/SHADE_Engine/src/Physics/SHPhysicsObject.cpp index 37c1269e..00c6943b 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsObject.cpp +++ b/SHADE_Engine/src/Physics/SHPhysicsObject.cpp @@ -128,24 +128,24 @@ namespace SHADE /* Public Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - int SHPhysicsObject::AddCollider(SHCollider* collider) + int SHPhysicsObject::AddCollider(SHCollisionShape* collider) { const rp3d::Transform OFFSETS{ collider->GetPositionOffset(), collider->GetRotationOffset() }; switch (collider->GetType()) { - case SHCollider::Type::BOX: + case SHCollisionShape::Type::BOX: { const auto* box = reinterpret_cast(collider->GetShape()); - rp3d::BoxShape* newBox = factory->createBoxShape(box->GetHalfExtents()); + rp3d::BoxShape* newBox = factory->createBoxShape(box->GetWorldExtents()); rp3dBody->addCollider(newBox, OFFSETS); break; } - case SHCollider::Type::SPHERE: + case SHCollisionShape::Type::SPHERE: { const auto* sphere = reinterpret_cast(collider->GetShape()); - rp3d::SphereShape* newSphere = factory->createSphereShape(sphere->GetRadius()); + rp3d::SphereShape* newSphere = factory->createSphereShape(sphere->GetWorldRadius()); rp3dBody->addCollider(newSphere, OFFSETS); break; @@ -173,7 +173,7 @@ namespace SHADE void SHPhysicsObject::SyncColliders(SHColliderComponent* c) const noexcept { int index = 0; - for (auto& collider : c->colliders) + for (auto& collider : c->collisionShapes) { if (!collider.dirty) continue; @@ -188,21 +188,21 @@ namespace SHADE switch (collider.GetType()) { - case SHCollider::Type::BOX: + case SHCollisionShape::Type::BOX: { const auto* box = reinterpret_cast(collider.GetShape()); auto* rp3dBoxShape = reinterpret_cast(rp3dCollider->getCollisionShape()); - rp3dBoxShape->setHalfExtents(box->GetHalfExtents()); + rp3dBoxShape->setHalfExtents(box->GetWorldExtents()); break; } - case SHCollider::Type::SPHERE: + case SHCollisionShape::Type::SPHERE: { const auto* sphere = reinterpret_cast(collider.GetShape()); auto* rp3dSphereShape = reinterpret_cast(rp3dCollider->getCollisionShape()); - rp3dSphereShape->setRadius(sphere->GetRadius()); + rp3dSphereShape->setRadius(sphere->GetWorldRadius()); break; } diff --git a/SHADE_Engine/src/Physics/SHPhysicsObject.h b/SHADE_Engine/src/Physics/SHPhysicsObject.h index 64caacdb..09b70b11 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsObject.h +++ b/SHADE_Engine/src/Physics/SHPhysicsObject.h @@ -69,7 +69,7 @@ namespace SHADE /* Function Members */ /*---------------------------------------------------------------------------------*/ - int AddCollider (SHCollider* collider); + int AddCollider (SHCollisionShape* collider); void RemoveCollider (int index); void SyncColliders (SHColliderComponent* c) const noexcept; diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp b/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp index e1acccd9..437b5ff8 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp +++ b/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp @@ -17,10 +17,12 @@ #include "ECS_Base/Managers/SHComponentManager.h" #include "ECS_Base/Managers/SHEntityManager.h" #include "ECS_Base/Managers/SHSystemManager.h" +#include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" #include "Math/SHMathHelpers.h" #include "Math/Transform/SHTransformComponent.h" #include "Scene/SHSceneManager.h" #include "Scripting/SHScriptEngine.h" +#include "Tools/SHUtilities.h" namespace SHADE { @@ -30,6 +32,7 @@ namespace SHADE SHPhysicsSystem::SHPhysicsSystem() : worldUpdated { false } + , debugDrawFlags { 0 } , interpolationFactor { 0.0 } , fixedDT { 60.0 } , world { nullptr } @@ -47,6 +50,11 @@ namespace SHADE : SHSystemRoutine { "Physics PostUpdate", false } {} + SHPhysicsSystem::PhysicsDebugDraw::PhysicsDebugDraw() + : SHSystemRoutine { "Physics DebugDraw", true } + {} + + /*-----------------------------------------------------------------------------------*/ /* Getter Function Definitions */ /*-----------------------------------------------------------------------------------*/ @@ -99,6 +107,31 @@ namespace SHADE return 0; } + bool SHPhysicsSystem::GetDrawColliders() const noexcept + { + return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER); + } + + bool SHPhysicsSystem::GetDrawColliderAABBs() const noexcept + { + return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER_AABB); + } + + bool SHPhysicsSystem::GetDrawBroadPhase() const noexcept + { + return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::BROAD_PHASE_AABB); + } + + bool SHPhysicsSystem::GetDrawContactPoints() const noexcept + { + return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_POINTS); + } + + bool SHPhysicsSystem::GetDrawContactNormals() const noexcept + { + return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_NORMALS); + } + const SHPhysicsSystem::CollisionEvents& SHPhysicsSystem::GetCollisionInfo() const noexcept { return collisionInfo; @@ -181,6 +214,96 @@ namespace SHADE } } + void SHPhysicsSystem::SetDrawColliders(bool shouldDraw) noexcept + { + static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER); + shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); + + if (world == nullptr) + { + SHLOGV_WARNING("No physics world has been initialised!") + return; + } + + world->getDebugRenderer().setIsDebugItemDisplayed + ( + rp3d::DebugRenderer::DebugItem::COLLISION_SHAPE, + shouldDraw + ); + } + + void SHPhysicsSystem::SetDrawColliderAABBs(bool shouldDraw) noexcept + { + static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER_AABB); + shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); + + if (world == nullptr) + { + SHLOGV_WARNING("No physics world has been initialised!") + return; + } + + world->getDebugRenderer().setIsDebugItemDisplayed + ( + rp3d::DebugRenderer::DebugItem::COLLIDER_AABB, + shouldDraw + ); + } + + void SHPhysicsSystem::SetDrawBroadPhase(bool shouldDraw) noexcept + { + static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::BROAD_PHASE_AABB); + shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); + + if (world == nullptr) + { + SHLOGV_WARNING("No physics world has been initialised!") + return; + } + + world->getDebugRenderer().setIsDebugItemDisplayed + ( + rp3d::DebugRenderer::DebugItem::COLLIDER_BROADPHASE_AABB, + shouldDraw + ); + } + + void SHPhysicsSystem::SetDrawContactPoints(bool shouldDraw) noexcept + { + static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_POINTS); + shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); + + if (world == nullptr) + { + SHLOGV_WARNING("No physics world has been initialised!") + return; + } + + world->getDebugRenderer().setIsDebugItemDisplayed + ( + rp3d::DebugRenderer::DebugItem::CONTACT_POINT, + shouldDraw + ); + } + + void SHPhysicsSystem::SetDrawContactNormals(bool shouldDraw) noexcept + { + static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_NORMALS); + shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); + + if (world == nullptr) + { + SHLOGV_WARNING("No physics world has been initialised!") + return; + } + + world->getDebugRenderer().setIsDebugItemDisplayed + ( + rp3d::DebugRenderer::DebugItem::CONTACT_NORMAL, + shouldDraw + ); + } + /*-----------------------------------------------------------------------------------*/ /* Public Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ @@ -198,6 +321,7 @@ namespace SHADE world = factory.createPhysicsWorld(settings); world->setEventListener(this); + world->setIsDebugRenderingEnabled(true); // Set up solvers world->setContactsPositionCorrectionTechnique(rp3d::ContactsPositionCorrectionTechnique::SPLIT_IMPULSES); @@ -224,7 +348,7 @@ namespace SHADE factory.destroyPhysicsWorld(world); } - void SHPhysicsSystem::AddCollisionShape(EntityID entityID, SHCollider* collider) + void SHPhysicsSystem::AddCollisionShape(EntityID entityID, SHCollisionShape* collider) { auto* physicsObject = GetPhysicsObject(entityID); @@ -271,6 +395,7 @@ namespace SHADE { const auto WORLD_POS = transformComponent->GetWorldPosition(); const auto WORLD_ROT = transformComponent->GetWorldOrientation(); + const auto WORLD_SCL = transformComponent->GetWorldScale(); physicsObject.SetPosition(WORLD_POS); physicsObject.SetOrientation(WORLD_ROT); @@ -285,8 +410,11 @@ namespace SHADE if (colliderComponent) { - colliderComponent->position = WORLD_POS; - colliderComponent->orientation = WORLD_ROT; + colliderComponent->position = WORLD_POS; + colliderComponent->orientation = WORLD_ROT; + colliderComponent->scale = WORLD_SCL; + + colliderComponent->RecomputeCollisionShapes(); } } @@ -323,7 +451,7 @@ namespace SHADE auto* scriptingSystem = SHSystemManager::GetSystem(); if (scriptingSystem == nullptr) { - SHLOGV_WARNING("Unable to invoke FixedUpdate() on scripts due to missing SHScriptEngine!"); + SHLOGV_ERROR("Unable to invoke FixedUpdate() on scripts due to missing SHScriptEngine!"); } fixedTimeStep = 1.0 / physicsSystem->fixedDT; @@ -353,7 +481,7 @@ namespace SHADE auto* scriptingSystem = SHSystemManager::GetSystem(); if (scriptingSystem == nullptr) { - SHLOGV_WARNING("Unable to invoke collision and trigger script events due to missing SHScriptEngine!"); + SHLOGV_ERROR("Unable to invoke collision and trigger script events due to missing SHScriptEngine!"); } // Interpolate transforms for rendering @@ -369,6 +497,40 @@ namespace SHADE } } + void SHPhysicsSystem::PhysicsDebugDraw::Execute(double) noexcept + { + const auto* PHYSICS_SYSTEM = reinterpret_cast(GetSystem()); + if (PHYSICS_SYSTEM->debugDrawFlags == 0) + return; + + auto* debugDrawSystem = SHSystemManager::GetSystem(); + if (debugDrawSystem == nullptr) + { + SHLOGV_ERROR("Unable to debug draw physics objects due to missing SHDebugDrawSystem!"); + return; + } + + const auto& RP3D_DEBUG_RENDERER = PHYSICS_SYSTEM->world->getDebugRenderer(); + + const auto& LINES = RP3D_DEBUG_RENDERER.getLines(); + const auto& TRIANGLES = RP3D_DEBUG_RENDERER.getTriangles(); + + // Draw all lines + for (uint32_t i = 0; i < RP3D_DEBUG_RENDERER.getNbLines(); ++i) + { + const auto& LINE = LINES[i]; + debugDrawSystem->DrawLine(SHColour{ LINE.color1 }, LINE.point1, LINE.point2); + } + + for (uint32_t i = 0; i < RP3D_DEBUG_RENDERER.getNbTriangles(); ++i) + { + const auto& TRIANGLE = TRIANGLES[i]; + SHColour triColour{ TRIANGLE.color1 }; + triColour.a() = 1.0f; + debugDrawSystem->DrawTri(triColour, TRIANGLE.point1, TRIANGLE.point2, TRIANGLE.point3); + } + } + void SHPhysicsSystem::onContact(const CallbackData& callbackData) { for (uint32_t i = 0; i < callbackData.getNbContactPairs(); ++i) @@ -447,7 +609,6 @@ namespace SHADE if (rigidBodyComponent != nullptr) { - if (rigidBodyComponent->GetType() == SHRigidBodyComponent::Type::STATIC) continue; @@ -500,8 +661,10 @@ namespace SHADE { const auto IT = std::ranges::find_if(container.begin(), container.end(), [&](const SHCollisionEvent& e) { - const bool ENTITY_MATCH = e.value[0] == collisionEvent.value[0]; - const bool COLLIDERS_MATCH = e.value[1] == collisionEvent.value[1]; + const bool ENTITY_MATCH = (e.ids[0] == collisionEvent.ids[0] && e.ids[1] == collisionEvent.ids[1]) + || (e.ids[0] == collisionEvent.ids[1] && e.ids[1] == collisionEvent.ids[0]); + const bool COLLIDERS_MATCH = (e.ids[2] == collisionEvent.ids[2] && e.ids[3] == collisionEvent.ids[3]) + || (e.ids[2] == collisionEvent.ids[3] && e.ids[3] == collisionEvent.ids[2]); return ENTITY_MATCH && COLLIDERS_MATCH; }); @@ -576,7 +739,7 @@ namespace SHADE // Add collision shapes back into the body if (colliderComponent != nullptr) { - for (auto& collider : colliderComponent->colliders) + for (auto& collider : colliderComponent->collisionShapes) physicsObject->AddCollider(&collider); } } @@ -585,8 +748,9 @@ namespace SHADE { SHASSERT(colliderComponent != nullptr, "Collider Component was not added to Entity " + std::to_string(ENTITY_ID) + "!"); - colliderComponent->position = transformComponent->GetWorldPosition(); - colliderComponent->orientation = transformComponent->GetWorldOrientation(); + colliderComponent->position = transformComponent->GetWorldPosition(); + colliderComponent->orientation = transformComponent->GetWorldOrientation(); + colliderComponent->scale = transformComponent->GetWorldScale(); if (physicsObject->rp3dBody == nullptr) { @@ -597,7 +761,7 @@ namespace SHADE } // Add Collision Shapes - for (auto& collider : colliderComponent->colliders) + for (auto& collider : colliderComponent->collisionShapes) physicsObject->AddCollider(&collider); } } @@ -642,7 +806,7 @@ namespace SHADE rp3d::Transform{ colliderComponent->position, colliderComponent->orientation } ); - for (auto& collider : colliderComponent->colliders) + for (auto& collider : colliderComponent->collisionShapes) physicsObject->AddCollider(&collider); } } diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystem.h b/SHADE_Engine/src/Physics/SHPhysicsSystem.h index 1d773618..55575c73 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsSystem.h +++ b/SHADE_Engine/src/Physics/SHPhysicsSystem.h @@ -51,6 +51,15 @@ namespace SHADE using CollisionEvents = std::vector; + enum class DebugDrawFlags : uint8_t + { + COLLIDER = 1 + , COLLIDER_AABB = 2 + , BROAD_PHASE_AABB = 4 + , CONTACT_POINTS = 8 + , CONTACT_NORMALS = 16 + }; + /*---------------------------------------------------------------------------------*/ /* Constructors & Destructor */ /*---------------------------------------------------------------------------------*/ @@ -69,6 +78,12 @@ namespace SHADE [[nodiscard]] uint16_t GetNumberVelocityIterations () const noexcept; [[nodiscard]] uint16_t GetNumberPositionIterations () const noexcept; + [[nodiscard]] bool GetDrawColliders () const noexcept; + [[nodiscard]] bool GetDrawColliderAABBs () const noexcept; + [[nodiscard]] bool GetDrawBroadPhase () const noexcept; + [[nodiscard]] bool GetDrawContactPoints () const noexcept; + [[nodiscard]] bool GetDrawContactNormals () const noexcept; + [[nodiscard]] const CollisionEvents& GetCollisionInfo () const noexcept; [[nodiscard]] const CollisionEvents& GetTriggerInfo () const noexcept; @@ -85,6 +100,13 @@ namespace SHADE void SetWorldSettings (const WorldSettings& settings) const noexcept; + // TODO(Diren): Can the debug draw flags be done through an enum? + void SetDrawColliders (bool shouldDraw) noexcept; + void SetDrawColliderAABBs (bool shouldDraw) noexcept; + void SetDrawBroadPhase (bool shouldDraw) noexcept; + void SetDrawContactPoints (bool shouldDraw) noexcept; + void SetDrawContactNormals (bool shouldDraw) noexcept; + /*---------------------------------------------------------------------------------*/ /* Function Members */ /*---------------------------------------------------------------------------------*/ @@ -92,7 +114,7 @@ namespace SHADE void Init () override; void Exit () override; - void AddCollisionShape (EntityID entityID, SHCollider* collider); + void AddCollisionShape (EntityID entityID, SHCollisionShape* collider); void RemoveCollisionShape (EntityID entityID, int index); void onContact (const rp3d::CollisionCallback::CallbackData& callbackData) override; @@ -105,48 +127,31 @@ namespace SHADE class SH_API PhysicsPreUpdate final : public SHSystemRoutine { public: - /*-------------------------------------------------------------------------------*/ - /* Constructors & Destructor */ - /*-------------------------------------------------------------------------------*/ PhysicsPreUpdate(); - - /*-------------------------------------------------------------------------------*/ - /* Function Members */ - /*-------------------------------------------------------------------------------*/ - void Execute(double dt) noexcept override; }; class SH_API PhysicsFixedUpdate final : public SHFixedSystemRoutine { public: - /*-------------------------------------------------------------------------------*/ - /* Constructors & Destructor */ - /*-------------------------------------------------------------------------------*/ PhysicsFixedUpdate(); - - /*-------------------------------------------------------------------------------*/ - /* Function Members */ - /*-------------------------------------------------------------------------------*/ - void Execute (double dt) noexcept override; }; class SH_API PhysicsPostUpdate final : public SHSystemRoutine { public: - /*-------------------------------------------------------------------------------*/ - /* Constructors & Destructor */ - /*-------------------------------------------------------------------------------*/ PhysicsPostUpdate(); + void Execute(double dt) noexcept override; + }; - /*-------------------------------------------------------------------------------*/ - /* Function Members */ - /*-------------------------------------------------------------------------------*/ - + class SH_API PhysicsDebugDraw final : public SHSystemRoutine + { + public: + PhysicsDebugDraw(); void Execute(double dt) noexcept override; }; @@ -162,6 +167,7 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ bool worldUpdated; + uint8_t debugDrawFlags; double interpolationFactor; double fixedDT; @@ -177,24 +183,24 @@ namespace SHADE /* Function Members */ /*---------------------------------------------------------------------------------*/ - SHPhysicsObject* EnsurePhysicsObject (EntityID entityID) noexcept; - SHPhysicsObject* GetPhysicsObject (EntityID entityID) noexcept; - void DestroyPhysicsObject (EntityID entityID) noexcept; + SHPhysicsObject* EnsurePhysicsObject (EntityID entityID) noexcept; + SHPhysicsObject* GetPhysicsObject (EntityID entityID) noexcept; + void DestroyPhysicsObject (EntityID entityID) noexcept; - static void SyncActiveStates (SHPhysicsObject& physicsObject, bool componentActive) noexcept; - void SyncTransforms () noexcept; + static void SyncActiveStates (SHPhysicsObject& physicsObject, bool componentActive) noexcept; + void SyncTransforms () noexcept; - static void UpdateEventContainers (const SHCollisionEvent& collisionEvent, CollisionEvents& container) noexcept; - void ClearInvalidCollisions () noexcept; + static void UpdateEventContainers (const SHCollisionEvent& collisionEvent, CollisionEvents& container) noexcept; + void ClearInvalidCollisions () noexcept; - SHEventHandle AddPhysicsComponent (SHEventPtr addComponentEvent); - SHEventHandle RemovePhysicsComponent (SHEventPtr removeComponentEvent); - SHEventHandle ResetWorld (SHEventPtr editorStopEvent); + SHEventHandle AddPhysicsComponent (SHEventPtr addComponentEvent); + SHEventHandle RemovePhysicsComponent (SHEventPtr removeComponentEvent); + SHEventHandle ResetWorld (SHEventPtr editorStopEvent); template || std::is_same_v>> - SHCollisionEvent GenerateCollisionEvent (const RP3DCollisionPair& cp) noexcept; + SHCollisionEvent GenerateCollisionEvent (const RP3DCollisionPair& cp) noexcept; }; } // namespace SHADE diff --git a/SHADE_Engine/src/Physics/SHPhysicsUtils.cpp b/SHADE_Engine/src/Physics/SHPhysicsUtils.cpp index 8d5bc956..14b6cc2f 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsUtils.cpp +++ b/SHADE_Engine/src/Physics/SHPhysicsUtils.cpp @@ -75,14 +75,14 @@ namespace SHADE return SHComponentManager::GetComponent_s(ids[ENTITY_B]); } - const SHCollider* SHCollisionEvent::GetColliderA() const noexcept + const SHCollisionShape* SHCollisionEvent::GetColliderA() const noexcept { - return &SHComponentManager::GetComponent(ids[ENTITY_A])->GetCollider(ids[COLLIDER_A]); + return &SHComponentManager::GetComponent(ids[ENTITY_A])->GetCollisionShape(ids[COLLIDER_A]); } - const SHCollider* SHCollisionEvent::GetColliderB() const noexcept + const SHCollisionShape* SHCollisionEvent::GetColliderB() const noexcept { - return &SHComponentManager::GetComponent(ids[ENTITY_B])->GetCollider(ids[COLLIDER_B]); + return &SHComponentManager::GetComponent(ids[ENTITY_B])->GetCollisionShape(ids[COLLIDER_B]); } SHCollisionEvent::State SHCollisionEvent::GetCollisionState() const noexcept diff --git a/SHADE_Engine/src/Physics/SHPhysicsUtils.h b/SHADE_Engine/src/Physics/SHPhysicsUtils.h index 57f9c6fc..753f8d3b 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsUtils.h +++ b/SHADE_Engine/src/Physics/SHPhysicsUtils.h @@ -24,7 +24,7 @@ namespace SHADE struct SHPhysicsColliderAddedEvent { EntityID entityID; - SHCollider::Type colliderType; + SHCollisionShape::Type colliderType; int colliderIndex; }; @@ -88,8 +88,8 @@ namespace SHADE [[nodiscard]] EntityID GetEntityB () const noexcept; [[nodiscard]] const SHRigidBodyComponent* GetRigidBodyA () const noexcept; [[nodiscard]] const SHRigidBodyComponent* GetRigidBodyB () const noexcept; - [[nodiscard]] const SHCollider* GetColliderA () const noexcept; - [[nodiscard]] const SHCollider* GetColliderB () const noexcept; + [[nodiscard]] const SHCollisionShape* GetColliderA () const noexcept; + [[nodiscard]] const SHCollisionShape* GetColliderB () const noexcept; [[nodiscard]] State GetCollisionState () const noexcept; private: diff --git a/SHADE_Engine/src/Resource/SHResourceManager.h b/SHADE_Engine/src/Resource/SHResourceManager.h index e5e303e1..d660ada7 100644 --- a/SHADE_Engine/src/Resource/SHResourceManager.h +++ b/SHADE_Engine/src/Resource/SHResourceManager.h @@ -13,17 +13,20 @@ of DigiPen Institute of Technology is prohibited. // STL Includes #include + +namespace SHADE { class SHMaterial; } // Project Includes #include "SH_API.h" #include "SHResourceLibrary.h" #include "Assets/SHAssetMacros.h" -#include "Assets/Asset Types/SHMeshAsset.h" +#include "Assets/Asset Types/SHModelAsset.h" #include "Assets/Asset Types/SHTextureAsset.h" #include "Assets/Asset Types/SHShaderAsset.h" #include "Graphics/Shaders/SHVkShaderModule.h" #include "Graphics/MiddleEnd/Textures/SHTextureLibrary.h" #include "Graphics/MiddleEnd/Interface/SHMeshLibrary.h" #include "Graphics/MiddleEnd/Interface/SHMaterial.h" +#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" #include "Assets/Asset Types/SHMaterialAsset.h" namespace SHADE @@ -33,12 +36,12 @@ namespace SHADE /// template struct SHResourceLoader { using AssetType = void; }; - template<> struct SHResourceLoader { using AssetType = SHMeshAsset; }; + template<> struct SHResourceLoader { using AssetType = SHMeshData; }; template<> struct SHResourceLoader { using AssetType = SHTextureAsset; }; template<> struct SHResourceLoader { using AssetType = SHShaderAsset; }; - template<> struct SHResourceLoader { using AssetType = SHMaterialAsset; }; - - /// + template<> struct SHResourceLoader { using AssetType = SHMaterialAsset; }; + template<> struct SHResourceLoader { using AssetType = SHMaterialSpec; }; +/// /// Static class responsible for loading and caching runtime resources from their /// serialised Asset IDs. /// @@ -61,6 +64,8 @@ namespace SHADE /// Handle to a loaded runtime asset. template static Handle LoadOrGet(AssetID assetId); + template<> + static inline Handle LoadOrGet(AssetID assetId); /// /// Unloads an existing loaded asset. Attempting to unload an invalid Handle will /// simply do nothing except emit a warning. diff --git a/SHADE_Engine/src/Resource/SHResourceManager.hpp b/SHADE_Engine/src/Resource/SHResourceManager.hpp index 1623d70a..01d82a7b 100644 --- a/SHADE_Engine/src/Resource/SHResourceManager.hpp +++ b/SHADE_Engine/src/Resource/SHResourceManager.hpp @@ -24,6 +24,7 @@ of DigiPen Institute of Technology is prohibited. #include "Graphics/Shaders/SHVkShaderModule.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" +#include "Serialization/SHYAMLConverters.h" namespace SHADE { @@ -34,7 +35,12 @@ namespace SHADE Handle SHResourceManager::LoadOrGet(AssetID assetId) { // Check if it is an unsupported type - if (!std::is_same_v && !std::is_same_v) + if (!std::is_same_v && + !std::is_same_v && + !std::is_same_v && + !std::is_same_v && + !std::is_same_v + ) { static_assert(true, "Unsupported Resource Type specified for SHResourceManager."); } @@ -60,8 +66,35 @@ namespace SHADE return handle; } + template<> + Handle SHResourceManager::LoadOrGet(AssetID assetId) + { + /* Attempt to get existing loaded asset */ + auto [typedHandleMap, typedAssetIdMap] = getAssetHandleMap(); + if (typedHandleMap.get().contains(assetId)) + return Handle(typedHandleMap.get()[assetId]); + + /* Otherwise, we need to load it! */ + // Get system + SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem(); + if (gfxSystem == nullptr) + throw std::runtime_error("[SHResourceManager] Attempted to load graphics resource without a SHGraphicsSystem installed."); + + // Get SHMaterialSpec + Handle matSpec = LoadOrGet(assetId); + if (!matSpec) + return {}; + + // Create the material + auto handle = load(assetId, *matSpec); + Handle genericHandle = Handle(handle); + typedHandleMap.get().emplace(assetId, genericHandle); + typedAssetIdMap.get().emplace(genericHandle, assetId); + return handle; + } + template - void SHResourceManager::Unload(Handle assetId) + void SHResourceManager::Unload(Handle asset) { // Check if it is an unsupported type if (!std::is_same_v && !std::is_same_v) @@ -71,14 +104,18 @@ namespace SHADE /* Attempt to get existing loaded asset */ auto [typedHandleMap, typedAssetIdMap] = getAssetHandleMap(); - if (typedHandleMap.get().contains(assetId)) + if (typedHandleMap.get().contains(asset)) { + // Remove from ResourceHub if SHMaterialSpec + if (std::is_same_v) + resourceHub.Free(asset); + // Dispose - Handle handle = typedHandleMap.get()[assetId]; - Handle typedHandle = static_cast>(handle); + Handle handle = typedHandleMap.get()[asset]; + auto typedHandle = static_cast>(handle); typedHandle.Free(); typedAssetIdMap.get().erase(handle); - typedHandleMap.get().erase(assetId); + typedHandleMap.get().erase(asset); } else { @@ -143,13 +180,13 @@ namespace SHADE return gfxSystem->AddMesh ( - assetData.vertexPosition.size(), - assetData.vertexPosition.data(), - assetData.texCoords.data(), - assetData.vertexTangent.data(), - assetData.vertexNormal.data(), - assetData.indices.size(), - assetData.indices.data() + assetData.VertexPositions.size(), + assetData.VertexPositions.data(), + assetData.VertexTexCoords.data(), + assetData.VertexTangents.data(), + assetData.VertexNormals.data(), + assetData.Indices.size(), + assetData.Indices.data() ); } // Textures @@ -181,15 +218,27 @@ namespace SHADE shader->Reflect(); return shader; } + // Material Spec + else if constexpr (std::is_same_v) + { + // Get the data we need to construct + auto matSpec = resourceHub.Create(); + YAML::convert::decode(*YAML::Load(assetData.data).begin(), *matSpec); + // Failed to load + if (matSpec->subpassName == "") + { + // Use default material + *matSpec = SHMaterialSpec(*gfxSystem->GetDefaultMaterial()); + } + + return matSpec; + } // Materials else if constexpr (std::is_same_v) { - // Get the data we need to construct - SHMaterialSpec matSpec = YAML::Node(assetData.data).as(); - // Load shaders - auto vertexShader = SHResourceManager::LoadOrGet(matSpec.vertexShader); - auto fragShader = SHResourceManager::LoadOrGet(matSpec.fragShader); + auto vertexShader = SHResourceManager::LoadOrGet(assetData.vertexShader); + auto fragShader = SHResourceManager::LoadOrGet(assetData.fragShader); // Ensure that both shaders are present if (!(vertexShader && fragShader)) @@ -205,7 +254,7 @@ namespace SHADE SHLOG_ERROR("[SHResourceManager] Failed to load material as RenderPass could not be found."); return {}; } - auto subPass = renderPass->GetSubpass(matSpec.subpassName); + auto subPass = renderPass->GetSubpass(assetData.subpassName); if (!subPass) { SHLOG_ERROR("[SHResourceManager] Failed to load material as SubPass could not be found."); @@ -220,8 +269,8 @@ namespace SHADE for (int i = 0; i < static_cast(pipelineProperties->GetVariableCount()); ++i) { const std::string& PROP_NAME = pipelineProperties->GetVariableName(i); - const auto& PROP_NODE = matSpec.properties; - if (PROP_NODE) + const YAML::Node& PROP_NODE = assetData.properties[PROP_NAME.data()]; + if (PROP_NODE.IsDefined()) { const std::string& VAR_NAME = pipelineProperties->GetVariableName(i); const SHShaderBlockInterface::Variable* VARIABLE = pipelineProperties->GetVariable(i); @@ -231,7 +280,21 @@ namespace SHADE matHandle->SetProperty(VARIABLE->offset, PROP_NODE.as()); break; case SHADE::SHShaderBlockInterface::Variable::Type::INT: - matHandle->SetProperty(VARIABLE->offset, PROP_NODE.as()); + { + Handle texture = LoadOrGet(PROP_NODE.as()); + // HACK: Need to split this out to a separate pass before loading the materials and subsequently, the scenes + gfxSystem->BuildTextures(); + + if (texture) + { + matHandle->SetProperty(VARIABLE->offset, texture->TextureArrayIndex); + } + else + { + SHLOG_WARNING("[] Attempted to load invalid texture! Setting to 0."); + matHandle->SetProperty(VARIABLE->offset, 0); + } + } break; case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2: matHandle->SetProperty(VARIABLE->offset, PROP_NODE.as()); diff --git a/SHADE_Engine/src/Scene/SHScene.h b/SHADE_Engine/src/Scene/SHScene.h index a81c70ef..1f06824e 100644 --- a/SHADE_Engine/src/Scene/SHScene.h +++ b/SHADE_Engine/src/Scene/SHScene.h @@ -13,6 +13,7 @@ #include #include "SHSceneGraph.h" +#include "Assets/SHAssetMacros.h" #include "ECS_Base/General/SHFamily.h" namespace SHADE @@ -32,6 +33,7 @@ namespace SHADE virtual ~SHScene() = default; std::string sceneName; + AssetID sceneAssetID; SHSceneGraph& GetSceneGraph() noexcept { return sceneGraph; } diff --git a/SHADE_Engine/src/Scene/SHSceneGraph.cpp b/SHADE_Engine/src/Scene/SHSceneGraph.cpp index df46b3fb..6240b7bf 100644 --- a/SHADE_Engine/src/Scene/SHSceneGraph.cpp +++ b/SHADE_Engine/src/Scene/SHSceneGraph.cpp @@ -1,7 +1,7 @@ /**************************************************************************************** * \file SHSceneGraph.cpp * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Implementation for a Scene Graph & Scene Nodes. + * \brief Implementation for a Scene Graph. * * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or * disclosure of this file or its contents without the prior written consent @@ -16,8 +16,6 @@ // Project Headers #include "ECS_Base/Managers/SHEntityManager.h" #include "Events/SHEventManager.hpp" -#include "Tools/SHLogger.h" -#include "Tools/SHException.h" namespace SHADE { @@ -25,56 +23,6 @@ namespace SHADE /* Constructors & Destructor Definitions */ /*-----------------------------------------------------------------------------------*/ - SHSceneNode::SHSceneNode(EntityID eid, SHSceneNode* parent) noexcept - : active { true } - , entityID { eid } - , parent { parent } - {} - - - SHSceneNode::SHSceneNode(const SHSceneNode& rhs) noexcept - : active { rhs.active } - , entityID { rhs.entityID } - , parent { rhs.parent } - { - std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); - } - - SHSceneNode::SHSceneNode(SHSceneNode&& rhs) noexcept - : active { rhs.active } - , entityID { rhs.entityID } - , parent { rhs.parent } - { - std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); - } - - SHSceneNode& SHSceneNode::operator=(const SHSceneNode& rhs) noexcept - { - if (this == &rhs) - return *this; - - active = rhs.active; - entityID = rhs.entityID; - parent = rhs.parent; - - children.clear(); - std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); - - return *this; - } - - SHSceneNode& SHSceneNode::operator=(SHSceneNode&& rhs) noexcept - { - active = rhs.active; - entityID = rhs.entityID; - parent = rhs.parent; - - children.clear(); - std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); - - return *this; - } - SHSceneGraph::SHSceneGraph() noexcept : root { nullptr } { @@ -110,56 +58,6 @@ namespace SHADE /* Getter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - bool SHSceneNode::IsActive() const noexcept - { - return active; - } - - EntityID SHSceneNode::GetEntityID() const noexcept - { - return entityID; - } - - SHSceneNode* SHSceneNode::GetParent() const noexcept - { - return parent; - } - - const std::vector& SHSceneNode::GetChildren() const noexcept - { - return children; - } - - SHSceneNode* SHSceneNode::GetChild(EntityID childID) const noexcept - { - //////////////////////////////////////// - // Error handling - if (!SHEntityManager::IsValidEID(childID)) - { - SHLOG_ERROR("Child Entity {} is invalid! Unable to get child from Entity {}", childID, entityID) - return nullptr; - } - - if (children.empty()) - { - SHLOG_WARNING("Entity {} has no children!", entityID) - return nullptr; - } - //////////////////////////////////////// - - // Find child - const auto ENTITY_MATCH = [&](const SHSceneNode* node) { return node->GetEntityID() == childID; }; - - const auto CHILD_ITER = std::ranges::find_if(children.begin(), children.end(),ENTITY_MATCH); - if (CHILD_ITER == children.end()) - { - SHLOG_WARNING("Entity {} is not a child of Entity {}! Unable to retrieve child node!", childID, entityID) - return nullptr; - } - - return *CHILD_ITER; - } - const SHSceneNode* SHSceneGraph::GetRoot() const noexcept { if (root != nullptr) @@ -313,41 +211,7 @@ namespace SHADE /* Setter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHSceneNode::SetParent(SHSceneNode* parentNode) noexcept - { - if (parentNode == nullptr) - { - SHLOG_WARNING("Removing Entity {}'s parent", entityID) - - if (parent) - parent->RemoveChild(this); - - return; - } - - // Handle self assignment - if (parent && parentNode->entityID == parent->entityID) - return; - - if (parent) - parent->RemoveChild(this); - - parent = parentNode; - // Update parent's children - parent->AddChild(this); - } - - void SHSceneNode::SetActive(bool newActiveState) noexcept - { - active = newActiveState; - - for (auto* child : children) - { - SetActive(newActiveState); - } - } - - void SHSceneGraph::SetParent(EntityID entityID, SHSceneNode* parent) const noexcept + void SHSceneGraph::SetParent(EntityID entityID, SHSceneNode* newParent) noexcept { //////////////////////////////////////// // Error Handling @@ -369,30 +233,31 @@ namespace SHADE { .node = NODE_ITER->second , .oldParent = NODE_ITER->second->GetParent() - , .newParent = parent ? parent : root + , .newParent = newParent ? newParent : root }; - if (parent == nullptr) - parent = root; + if (newParent == nullptr) + newParent = root; - NODE_ITER->second->SetParent(parent); + ChangeParent(NODE_ITER->second, newParent); SHEventManager::BroadcastEvent(EVENT_DATA, SH_SCENEGRAPH_CHANGE_PARENT_EVENT); } - void SHSceneGraph::SetParent(EntityID entityID, EntityID parent) const noexcept + void SHSceneGraph::SetParent(EntityID entityID, EntityID newParent) noexcept { //////////////////////////////////////// // Error Handling + if (!SHEntityManager::IsValidEID(entityID)) { SHLOG_ERROR("Entity {} is invalid! Unable to set parent of an invalid entity!", entityID) return; } - if (!SHEntityManager::IsValidEID(parent)) + if (!SHEntityManager::IsValidEID(newParent)) { - SHLOG_ERROR("Parent Entity {} is invalid! Unable to set Entity {}'s parent!", parent, entityID) + SHLOG_ERROR("Parent Entity {} is invalid! Unable to set Entity {}'s parent!", newParent, entityID) return; } @@ -403,10 +268,10 @@ namespace SHADE return; } - auto PARENT_ITER = entityNodeMap.find(parent); + auto PARENT_ITER = entityNodeMap.find(newParent); if (PARENT_ITER == entityNodeMap.end()) { - SHLOG_ERROR("Entity {} cannot be found in the scene! Unable to parent to Entity {}", parent, entityID) + SHLOG_ERROR("Entity {} cannot be found in the scene! Unable to parent to Entity {}", newParent, entityID) return; } //////////////////////////////////////// @@ -419,7 +284,7 @@ namespace SHADE }; SHSceneNode* currentNode = NODE_ITER->second; - currentNode->SetParent(PARENT_ITER->second); + ChangeParent(currentNode, PARENT_ITER->second); SHEventManager::BroadcastEvent(EVENT_DATA, SH_SCENEGRAPH_CHANGE_PARENT_EVENT); } @@ -428,84 +293,6 @@ namespace SHADE /* Public Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHSceneNode::AddChild(SHSceneNode* newChild) noexcept - { - //////////////////////////////////////// - // Error Handling - if (newChild == nullptr) - { - SHLOG_WARNING("Attempting to add a non-existent child to an entity!") - return; - } - //////////////////////////////////////// - - if (newChild->parent) - newChild->parent->RemoveChild(newChild); - - newChild->parent = this; - children.emplace_back(newChild); - } - - bool SHSceneNode::RemoveChild(EntityID childID) noexcept - { - //////////////////////////////////////// - // Error Handling - if (!SHEntityManager::IsValidEID(childID)) - { - SHLOG_ERROR("Entity {} is invalid!", childID) - return false; - } - //////////////////////////////////////// - - auto childIter = std::find_if(children.begin(), children.end(), [&](SHSceneNode* node) - { - return node->GetEntityID() == childID; - }); - - if (childIter == children.end()) - { - SHLOG_WARNING("Unable to remove Entity {} from Entity {} since it is not it's child!", childID, entityID) - return false; - } - - (*childIter)->parent = nullptr; - childIter = children.erase(childIter); - - return true; - } - - bool SHSceneNode::RemoveChild(SHSceneNode* childToRemove) noexcept - { - //////////////////////////////////////// - // Error Handling - if (childToRemove == nullptr) - { - SHLOG_WARNING("Attempting to remove non-existent child from Entity {}", entityID) - return false; - } - //////////////////////////////////////// - - auto childIter = std::find(children.begin(), children.end(), childToRemove); - if (childIter == children.end()) - { - SHLOG_WARNING("Unable to remove Entity {} from Entity {} since it is not it's child!", childToRemove->entityID, entityID) - return false; - } - - childIter = children.erase(childIter); - childToRemove->parent = nullptr; - - return true; - } - - void SHSceneNode::RemoveAllChildren() noexcept - { - for (const auto child : children) - child->parent = nullptr; - - children.clear(); - } - SHSceneNode* SHSceneGraph::AddNode(EntityID entityID, SHSceneNode* parent) { //////////////////////////////////////// @@ -528,13 +315,12 @@ namespace SHADE if (parent == nullptr) { // Specific handling for root to avoid a warning when removing a non-existent child - parent = root; newNode->parent = root; root->children.emplace_back(newNode); } else { - newNode->SetParent(parent); + ChangeParent(newNode, parent); } return newNode; @@ -542,6 +328,8 @@ namespace SHADE bool SHSceneGraph::RemoveNode(EntityID entityID) noexcept { + //////////////////////////////////////// + // Error Handling if (!SHEntityManager::IsValidEID(entityID)) { SHLOG_ERROR("Entity {} is invalid!", entityID) @@ -554,12 +342,12 @@ namespace SHADE SHLOG_ERROR("Entity {} does not exist in the scene!", entityID) return false; } + //////////////////////////////////////// // Remove reference of current node from parent SHSceneNode* currentNode = NODE_ITER->second; - SHSceneNode* parent = currentNode->GetParent(); - if (parent != nullptr) - parent->RemoveChild(currentNode); + if (currentNode->parent != nullptr) + RemoveChild(currentNode->parent, currentNode); ReleaseNode(currentNode); return true; @@ -568,9 +356,8 @@ namespace SHADE bool SHSceneGraph::RemoveNode(SHSceneNode* nodeToRemove) noexcept { // Remove reference of current node from parent - SHSceneNode* parent = nodeToRemove->GetParent(); - if (parent != nullptr) - parent->RemoveChild(nodeToRemove); + if (nodeToRemove->parent != nullptr) + RemoveChild(nodeToRemove->parent, nodeToRemove); ReleaseNode(nodeToRemove); return true; @@ -582,6 +369,91 @@ namespace SHADE ReleaseNode(node); } + bool SHSceneGraph::IsChildOf(EntityID entityID, SHSceneNode* targetNode) noexcept + { + //////////////////////////////////////// + // Error Handling + + if (!SHEntityManager::IsValidEID(entityID)) + { + SHLOG_ERROR("Entity {} is invalid!", entityID) + return false; + } + + auto NODE_ITER = entityNodeMap.find(entityID); + if (NODE_ITER == entityNodeMap.end()) + { + SHLOG_ERROR("Entity {} cannot be found in the scene! Unable to check child!", entityID) + return false; + } + + //////////////////////////////////////// + + // Handle self-checks + if (NODE_ITER->second == targetNode) + { + SHLOG_WARNING("Entity {} cannot be a child of itself!", entityID) + return false; + } + + // Search for a matching target until the root + const SHSceneNode* CURRENT_TARGET = NODE_ITER->second->parent; + while (CURRENT_TARGET != root) + { + if (CURRENT_TARGET == targetNode) + return true; + + CURRENT_TARGET = CURRENT_TARGET->parent; + } + + return false; + } + + bool SHSceneGraph::IsChildOf(EntityID entityID, EntityID targetID) noexcept + { + //////////////////////////////////////// + // Error Handling + + if (!SHEntityManager::IsValidEID(entityID)) + { + SHLOG_ERROR("Entity {} is invalid!", entityID) + return false; + } + + if (!SHEntityManager::IsValidEID(targetID)) + { + SHLOG_ERROR("Entity {} is invalid!", targetID) + return false; + } + + auto NODE_ITER = entityNodeMap.find(entityID); + if (NODE_ITER == entityNodeMap.end()) + { + SHLOG_ERROR("Entity {} cannot be found in the scene! Unable to check child!", entityID) + return false; + } + + auto TARGET_ITER = entityNodeMap.find(targetID); + if (TARGET_ITER == entityNodeMap.end()) + { + SHLOG_ERROR("Entity {} cannot be found in the scene! Unable to check child!", targetID) + return false; + } + + //////////////////////////////////////// + + const SHSceneNode* CURRENT_TARGET = NODE_ITER->second->parent; + while (CURRENT_TARGET != root) + { + if (CURRENT_TARGET == TARGET_ITER->second) + return true; + + CURRENT_TARGET = CURRENT_TARGET->parent; + } + + return false; + } + void SHSceneGraph::Traverse (const UnaryFunction& function) const { TraverseAndInvokeFunction(root, function); @@ -594,11 +466,6 @@ namespace SHADE SHSceneNode* SHSceneGraph::AllocateNode(EntityID entityID) { SHSceneNode* newNode = new SHSceneNode{entityID}; - - //#ifdef _DEBUG - // SHLOG_INFO("Allocated a new Scene Node for Entity {}!", entityID) - //#endif - entityNodeMap.emplace(entityID, newNode); return newNode; } @@ -608,19 +475,81 @@ namespace SHADE SHASSERT(node != nullptr, "Attempting to release Invalid Node!") // Remove parent's reference to this node if there is a parent - if (node->GetParent() != nullptr) - node->GetParent()->RemoveChild(node); + if (node->parent != nullptr) + RemoveChild(node->parent, node); // Remove child's references to this node. Children end up as floating nodes. for (auto* child : node->GetChildren()) { - child->SetParent(nullptr); + ChangeParent(child, nullptr); } entityNodeMap.erase(node->GetEntityID()); delete node; } + void SHSceneGraph::ChangeParent(SHSceneNode* node, SHSceneNode* newParent) + { + // Handle self assignment + if (node->parent != nullptr && newParent != nullptr && node->parent->entityID == newParent->entityID) + return; + + // Remove child + if (node->parent) + RemoveChild(node->parent, node); + + if (newParent == nullptr) + { + SHLOG_WARNING("Removing Entity {}'s parent", node->entityID) + return; + } + + node->parent = newParent; + // Update parent's children + AddChild(newParent, node); + } + + void SHSceneGraph::AddChild(SHSceneNode* node, SHSceneNode* newChild) + { + SHASSERT(node != nullptr, "Attempting to modify a non-existent scene node!") + SHASSERT(newChild != nullptr, "Attempting to add a non-existent child to a SceneNode!") + + if (newChild->parent) + RemoveChild(newChild->parent, newChild); + + newChild->parent = node; + node->children.emplace_back(newChild); + + const SHSceneGraphAddChildEvent EVENT_DATA + { + .parent = node + , .childAdded = newChild + }; + + SHEventManager::BroadcastEvent(EVENT_DATA, SH_SCENEGRAPH_ADD_CHILD_EVENT); + } + + void SHSceneGraph::RemoveChild(SHSceneNode* node, SHSceneNode* childToRemove) + { + SHASSERT(node != nullptr, "Attempting to modify a non-existent scene node!") + SHASSERT(childToRemove != nullptr, "Attempting to remove a non-existent child from a SceneNode!") + + auto childIter = std::find(node->children.begin(), node->children.end(), childToRemove); + if (childIter == node->children.end()) + return; + + childIter = node->children.erase(childIter); + childToRemove->parent = nullptr; + + const SHSceneGraphRemoveChildEvent EVENT_DATA + { + .parent = node + , .childRemoved = childToRemove + }; + + SHEventManager::BroadcastEvent(EVENT_DATA, SH_SCENEGRAPH_REMOVE_CHILD_EVENT); + } + void SHSceneGraph::TraverseAndInvokeFunction(const SHSceneNode* node, const UnaryFunction& function) { for (auto* child : node->children) diff --git a/SHADE_Engine/src/Scene/SHSceneGraph.h b/SHADE_Engine/src/Scene/SHSceneGraph.h index 45ab48e5..5747be7b 100644 --- a/SHADE_Engine/src/Scene/SHSceneGraph.h +++ b/SHADE_Engine/src/Scene/SHSceneGraph.h @@ -1,7 +1,7 @@ /**************************************************************************************** * \file SHSceneGraph.h * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Interface for a Scene Graph & Scene Nodes. + * \brief Interface for a Scene Graph. * * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or * disclosure of this file or its contents without the prior written consent @@ -15,81 +15,15 @@ // Project Headers #include "ECS_Base/Entity/SHEntity.h" #include "SH_API.h" +#include "SHSceneNode.h" +#include "SHSceneGraphEvents.h" namespace SHADE { - /*-----------------------------------------------------------------------------------*/ - /* Forward Declarations */ - /*-----------------------------------------------------------------------------------*/ - - class SHSceneGraph; - /*-----------------------------------------------------------------------------------*/ /* Type Definitions */ /*-----------------------------------------------------------------------------------*/ - class SH_API SHSceneNode - { - private: - /*---------------------------------------------------------------------------------*/ - /* Friends */ - /*---------------------------------------------------------------------------------*/ - - friend class SHSceneGraph; - - public: - /*---------------------------------------------------------------------------------*/ - /* Constructors & Destructor */ - /*---------------------------------------------------------------------------------*/ - - ~SHSceneNode () = default; - - SHSceneNode (EntityID eid, SHSceneNode* parent = nullptr) noexcept; - SHSceneNode (const SHSceneNode& rhs) noexcept; - SHSceneNode (SHSceneNode&& rhs) noexcept; - SHSceneNode& operator= (const SHSceneNode& rhs) noexcept; - SHSceneNode& operator= (SHSceneNode&& rhs) noexcept; - - /*---------------------------------------------------------------------------------*/ - /* Getter Functions */ - /*---------------------------------------------------------------------------------*/ - - [[nodiscard]] bool IsActive () const noexcept; - [[nodiscard]] EntityID GetEntityID () const noexcept; - [[nodiscard]] SHSceneNode* GetParent () const noexcept; - [[nodiscard]] const std::vector& GetChildren () const noexcept; - - [[nodiscard]] SHSceneNode* GetChild (EntityID childID) const noexcept; - - /*---------------------------------------------------------------------------------*/ - /* Setter Functions */ - /*---------------------------------------------------------------------------------*/ - - void SetParent (SHSceneNode* parentNode) noexcept; - void SetActive (bool newActiveState) noexcept; - - /*---------------------------------------------------------------------------------*/ - /* Function Members */ - /*---------------------------------------------------------------------------------*/ - - void AddChild (SHSceneNode* newChild) noexcept; - - bool RemoveChild (EntityID childID) noexcept; - bool RemoveChild (SHSceneNode* childToRemove) noexcept; - - void RemoveAllChildren () noexcept; - - private: - /*---------------------------------------------------------------------------------*/ - /* Data Members */ - /*---------------------------------------------------------------------------------*/ - - bool active; - EntityID entityID; - SHSceneNode* parent; - std::vector children; - }; - class SH_API SHSceneGraph { public: @@ -130,19 +64,22 @@ namespace SHADE /* Setter Functions */ /*---------------------------------------------------------------------------------*/ - void SetParent (EntityID entityID, SHSceneNode* parent) const noexcept; - void SetParent (EntityID entityID, EntityID parent) const noexcept; + void SetParent (EntityID entityID, SHSceneNode* newParent) noexcept; + void SetParent (EntityID entityID, EntityID newParent) noexcept; /*---------------------------------------------------------------------------------*/ /* Function Members */ /*---------------------------------------------------------------------------------*/ SHSceneNode* AddNode (EntityID entityID, SHSceneNode* parent = nullptr); - bool RemoveNode (EntityID entityID) noexcept; - bool RemoveNode (SHSceneNode* nodeToRemove) noexcept; - void Reset () noexcept; + bool RemoveNode (EntityID entityID) noexcept; + bool RemoveNode (SHSceneNode* nodeToRemove) noexcept; + void Reset () noexcept; - void Traverse (const UnaryFunction& function) const; + bool IsChildOf (EntityID entityID, SHSceneNode* targetNode) noexcept; + bool IsChildOf (EntityID entityID, EntityID targetID) noexcept; + + void Traverse (const UnaryFunction& function) const; private: /*---------------------------------------------------------------------------------*/ @@ -156,20 +93,14 @@ namespace SHADE /* Function Members */ /*---------------------------------------------------------------------------------*/ - SHSceneNode* AllocateNode (EntityID entityID); - void ReleaseNode (SHSceneNode* node) noexcept; - static void TraverseAndInvokeFunction (const SHSceneNode* node, const UnaryFunction& function); - }; + SHSceneNode* AllocateNode (EntityID entityID); + void ReleaseNode (SHSceneNode* node) noexcept; - /*-----------------------------------------------------------------------------------*/ - /* Event Data Definitions */ - /*-----------------------------------------------------------------------------------*/ + void ChangeParent (SHSceneNode* node, SHSceneNode* newParent); + void AddChild (SHSceneNode* node, SHSceneNode* newChild); + void RemoveChild (SHSceneNode* node, SHSceneNode* childToRemove); - struct SHSceneGraphChangeParentEvent - { - SHSceneNode* node; - SHSceneNode* oldParent; - SHSceneNode* newParent; + static void TraverseAndInvokeFunction (const SHSceneNode* node, const UnaryFunction& function); }; } // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Scene/SHSceneGraphEvents.h b/SHADE_Engine/src/Scene/SHSceneGraphEvents.h new file mode 100644 index 00000000..ccdf06be --- /dev/null +++ b/SHADE_Engine/src/Scene/SHSceneGraphEvents.h @@ -0,0 +1,41 @@ +/**************************************************************************************** + * \file SHSceneGraphEvents.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for Scene Graph Events. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +// Project Headers +#include "SHSceneNode.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Event Data Definitions */ + /*-----------------------------------------------------------------------------------*/ + + struct SHSceneGraphChangeParentEvent + { + SHSceneNode* node; + SHSceneNode* oldParent; + SHSceneNode* newParent; + }; + + struct SHSceneGraphAddChildEvent + { + SHSceneNode* parent; + SHSceneNode* childAdded; + }; + + struct SHSceneGraphRemoveChildEvent + { + SHSceneNode* parent; + SHSceneNode* childRemoved; + }; + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Scene/SHSceneManager.cpp b/SHADE_Engine/src/Scene/SHSceneManager.cpp index 2baf0b9c..be9c7755 100644 --- a/SHADE_Engine/src/Scene/SHSceneManager.cpp +++ b/SHADE_Engine/src/Scene/SHSceneManager.cpp @@ -29,7 +29,7 @@ namespace SHADE std::string SHSceneManager::newSceneName{}; uint32_t SHSceneManager::currentSceneID = UINT32_MAX; uint32_t SHSceneManager::nextSceneID = UINT32_MAX; - + AssetID SHSceneManager::currentSceneAssetID{}; SHScene* SHSceneManager::currentScene = nullptr; //SHScene* SHSceneManager::nextScene = nullptr; @@ -107,16 +107,18 @@ namespace SHADE } } - void SHSceneManager::RestartScene(std::string const& sceneName) noexcept + void SHSceneManager::RestartScene(AssetID const& assetID ) noexcept { - if (currentScene->sceneName != sceneName) + if (currentScene->sceneAssetID != assetID) { - cleanReload = true; - newSceneName = sceneName; + //cleanReload = true; + cleanReload = false; + //newSceneName = sceneName; } else cleanReload = false; + currentScene->sceneAssetID = assetID; nextSceneID = currentSceneID; sceneChanged = true; } @@ -151,4 +153,20 @@ namespace SHADE { return currentScene->sceneName; } + + void SHSceneManager::SetCurrentSceneName(std::string const& sceneName) noexcept + { + currentScene->sceneName = sceneName; + } + + AssetID SHSceneManager::GetCurrentSceneAssetID() noexcept + { + return currentScene->sceneAssetID; + } + + void SHSceneManager::SetCurrentSceneAssetID(AssetID const& newAssetID) + { + currentScene->sceneAssetID = newAssetID; + currentSceneAssetID = newAssetID; + } } diff --git a/SHADE_Engine/src/Scene/SHSceneManager.h b/SHADE_Engine/src/Scene/SHSceneManager.h index 2e4b1717..23d13261 100644 --- a/SHADE_Engine/src/Scene/SHSceneManager.h +++ b/SHADE_Engine/src/Scene/SHSceneManager.h @@ -20,6 +20,7 @@ //Project Headers #include "SH_API.h" #include "ECS_Base/General/SHFamily.h" +#include "Assets/SHAssetMacros.h" namespace SHADE { @@ -47,6 +48,9 @@ namespace SHADE //pointer to the current scene static SHScene* currentScene; + //Scene AssetID of the current scene + static AssetID currentSceneAssetID; + //Used in reloading scene. static std::string newSceneName; @@ -80,10 +84,10 @@ namespace SHADE * None. ***************************************************************************/ template - static std::enable_if_t, void> InitSceneManager(std::string const& sceneName) noexcept + static std::enable_if_t, void> InitSceneManager(AssetID const& sceneAssetID) noexcept { //prevSceneCreate = newScene; - newScene = [sceneName]() { currentScene = new T(); currentScene->sceneName = sceneName; }; + newScene = [sceneAssetID]() { currentScene = new T(); currentScene->sceneAssetID = sceneAssetID; }; //nextSceneID = SHFamilyID::GetID(); nextSceneID = 0; @@ -99,7 +103,7 @@ namespace SHADE * None. ***************************************************************************/ template - static std::enable_if_t, void> ChangeScene(std::string const& sceneName) noexcept + static std::enable_if_t, void> ChangeScene(AssetID const& sceneAssetID) noexcept { //check if this new Scene is current Scene (Use RestartScene instead) if (currentSceneID == SHFamilyID::GetID()) @@ -107,7 +111,7 @@ namespace SHADE return; } //prevSceneCreate = newScene; - newScene = [sceneName]() { currentScene = new T(); currentScene->sceneName; }; + newScene = [sceneAssetID]() { currentScene = new T(); currentScene->sceneAssetID = sceneAssetID; }; nextSceneID = SHFamilyID::GetID(); sceneChanged = true; } @@ -137,11 +141,11 @@ namespace SHADE * Restarts current scene. Only Scene::Init() and Scene::Free() * Scene::Load() and Scene::Unload() will not be called. * Edit: allows for RestartScene to restart the scene with a different - * scene name. - * If a sceneName is different from the current one, Load and Unload will + * scene asset ID. + * If a scene asset id is different from the current one, Load and Unload will * run. ***************************************************************************/ - static void RestartScene(std::string const& sceneName ) noexcept; + static void RestartScene(AssetID const& assetID ) noexcept; /*!************************************************************************* * \brief @@ -164,7 +168,10 @@ namespace SHADE static void Exit() noexcept; static std::string GetSceneName() noexcept; - + static void SetCurrentSceneName(std::string const& sceneName) noexcept; + static AssetID GetCurrentSceneAssetID() noexcept; + //Only if scene doesn't exist, and scene asset id needs to be updated to the new one + static void SetCurrentSceneAssetID(AssetID const& newAssetID); }; diff --git a/SHADE_Engine/src/Scene/SHSceneNode.cpp b/SHADE_Engine/src/Scene/SHSceneNode.cpp new file mode 100644 index 00000000..b619d464 --- /dev/null +++ b/SHADE_Engine/src/Scene/SHSceneNode.cpp @@ -0,0 +1,143 @@ +/**************************************************************************************** + * \file SHSceneNode.c[[ + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for a Scene Node. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHSceneNode.h" + +// Project Headers +#include "ECS_Base/Managers/SHEntityManager.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHSceneNode::SHSceneNode(EntityID eid, SHSceneNode* parent) noexcept + : active { true } + , entityID { eid } + , parent { parent } + {} + + + SHSceneNode::SHSceneNode(const SHSceneNode& rhs) noexcept + : active { rhs.active } + , entityID { rhs.entityID } + , parent { rhs.parent } + { + std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); + } + + SHSceneNode::SHSceneNode(SHSceneNode&& rhs) noexcept + : active { rhs.active } + , entityID { rhs.entityID } + , parent { rhs.parent } + { + std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); + } + + SHSceneNode& SHSceneNode::operator=(const SHSceneNode& rhs) noexcept + { + if (this == &rhs) + return *this; + + active = rhs.active; + entityID = rhs.entityID; + parent = rhs.parent; + + children.clear(); + std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); + + return *this; + } + + SHSceneNode& SHSceneNode::operator=(SHSceneNode&& rhs) noexcept + { + active = rhs.active; + entityID = rhs.entityID; + parent = rhs.parent; + + children.clear(); + std::ranges::copy(rhs.children.begin(), rhs.children.end(), std::back_inserter(children)); + + return *this; + } + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + bool SHSceneNode::IsActive() const noexcept + { + return active; + } + + EntityID SHSceneNode::GetEntityID() const noexcept + { + return entityID; + } + + SHSceneNode* SHSceneNode::GetParent() const noexcept + { + return parent; + } + + const std::vector& SHSceneNode::GetChildren() const noexcept + { + return children; + } + + SHSceneNode* SHSceneNode::GetChild(EntityID childID) const noexcept + { + //////////////////////////////////////// + // Error handling + if (!SHEntityManager::IsValidEID(childID)) + { + SHLOG_ERROR("Child Entity {} is invalid! Unable to get child from Entity {}", childID, entityID) + return nullptr; + } + + if (children.empty()) + { + SHLOG_WARNING("Entity {} has no children!", entityID) + return nullptr; + } + //////////////////////////////////////// + + // Find child + const auto ENTITY_MATCH = [&](const SHSceneNode* node) { return node->GetEntityID() == childID; }; + + const auto CHILD_ITER = std::ranges::find_if(children.begin(), children.end(),ENTITY_MATCH); + if (CHILD_ITER == children.end()) + { + SHLOG_WARNING("Entity {} is not a child of Entity {}! Unable to retrieve child node!", childID, entityID) + return nullptr; + } + + return *CHILD_ITER; + } + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHSceneNode::SetActive(bool newActiveState) noexcept + { + active = newActiveState; + + for (auto* child : children) + { + SetActive(newActiveState); + } + } + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Scene/SHSceneNode.h b/SHADE_Engine/src/Scene/SHSceneNode.h new file mode 100644 index 00000000..87bd8d0b --- /dev/null +++ b/SHADE_Engine/src/Scene/SHSceneNode.h @@ -0,0 +1,82 @@ +/**************************************************************************************** + * \file SHSceneNode.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for a Scene Node. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include + +// Project Headers +#include "ECS_Base/Entity/SHEntity.h" +#include "SH_API.h" +#include "SHSceneGraph.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Forward Declarations */ + /*-----------------------------------------------------------------------------------*/ + + class SHSceneGraph; + + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHSceneNode + { + private: + /*---------------------------------------------------------------------------------*/ + /* Friends */ + /*---------------------------------------------------------------------------------*/ + + friend class SHSceneGraph; + + public: + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + ~SHSceneNode () = default; + + SHSceneNode (EntityID eid, SHSceneNode* parent = nullptr) noexcept; + SHSceneNode (const SHSceneNode& rhs) noexcept; + SHSceneNode (SHSceneNode&& rhs) noexcept; + SHSceneNode& operator= (const SHSceneNode& rhs) noexcept; + SHSceneNode& operator= (SHSceneNode&& rhs) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + [[nodiscard]] bool IsActive () const noexcept; + [[nodiscard]] EntityID GetEntityID () const noexcept; + [[nodiscard]] SHSceneNode* GetParent () const noexcept; + [[nodiscard]] const std::vector& GetChildren () const noexcept; + + [[nodiscard]] SHSceneNode* GetChild (EntityID childID) const noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Setter Functions */ + /*---------------------------------------------------------------------------------*/ + + void SetActive (bool newActiveState) noexcept; + + private: + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + bool active; + EntityID entityID; + SHSceneNode* parent; + std::vector children; + }; +} // namespace SHADE + diff --git a/SHADE_Engine/src/Scripting/SHScriptEngine.cpp b/SHADE_Engine/src/Scripting/SHScriptEngine.cpp index 4a73342e..4f3fbce6 100644 --- a/SHADE_Engine/src/Scripting/SHScriptEngine.cpp +++ b/SHADE_Engine/src/Scripting/SHScriptEngine.cpp @@ -26,13 +26,15 @@ of DigiPen Institute of Technology is prohibited. #include "Events/SHEventManager.hpp" #include "Physics/SHPhysicsSystem.h" +#include "Assets/SHAssetMacros.h" + namespace SHADE { /*-----------------------------------------------------------------------------------*/ /* Static Definitions */ /*----------------------------------------------------------------------------------*/ const std::string SHScriptEngine::DEFAULT_CSHARP_NAMESPACE = std::string("SHADE"); - const std::string SHScriptEngine::CSPROJ_DIR = "..\\..\\TempScriptsFolder"; + const std::string SHScriptEngine::CSPROJ_DIR = std::string(ASSET_ROOT) + "/Scripts"; const std::string SHScriptEngine::CSPROJ_PATH = std::string(CSPROJ_DIR) + "\\SHADE_Scripting.csproj"; /*-----------------------------------------------------------------------------------*/ @@ -379,6 +381,12 @@ namespace SHADE DEFAULT_CSHARP_LIB_NAME, DEFAULT_CSHARP_NAMESPACE + ".ScriptStore", "ExecuteLateUpdate" + ); + csScriptsExecuteDrawGizmos = dotNet.GetFunctionPtr + ( + DEFAULT_CSHARP_LIB_NAME, + DEFAULT_CSHARP_NAMESPACE + ".ScriptStore", + "ExecuteOnDrawGizmos" ); csScriptsExecutePhysicsEvents = dotNet.GetFunctionPtr ( diff --git a/SHADE_Engine/src/Scripting/SHScriptEngine.h b/SHADE_Engine/src/Scripting/SHScriptEngine.h index 9ddd617a..7d83606e 100644 --- a/SHADE_Engine/src/Scripting/SHScriptEngine.h +++ b/SHADE_Engine/src/Scripting/SHScriptEngine.h @@ -55,6 +55,12 @@ namespace SHADE LateUpdateRoutine(); void Execute(double dt) noexcept override final; }; + class SH_API GizmosDrawRoutine final : public SHSystemRoutine + { + public: + GizmosDrawRoutine(); + void Execute(double dt) noexcept override final; + }; class SH_API FrameCleanUpRoutine final : public SHSystemRoutine { public: @@ -250,6 +256,7 @@ namespace SHADE CsFuncPtr csScriptsExecuteFixedUpdate = nullptr; CsFuncPtr csScriptsExecuteUpdate = nullptr; CsFuncPtr csScriptsExecuteLateUpdate = nullptr; + CsFuncPtr csScriptsExecuteDrawGizmos = nullptr; CsFuncPtr csScriptsExecutePhysicsEvents = nullptr; CsFuncPtr csScriptsFrameCleanUp = nullptr; CsScriptManipFuncPtr csScriptsAdd = nullptr; diff --git a/SHADE_Engine/src/Scripting/SHScriptEngineRoutines.cpp b/SHADE_Engine/src/Scripting/SHScriptEngineRoutines.cpp index a2981c06..699776ca 100644 --- a/SHADE_Engine/src/Scripting/SHScriptEngineRoutines.cpp +++ b/SHADE_Engine/src/Scripting/SHScriptEngineRoutines.cpp @@ -50,6 +50,17 @@ namespace SHADE reinterpret_cast(system)->csScriptsExecuteLateUpdate(); } + /*-----------------------------------------------------------------------------------*/ + /* System Routine Functions - GizmosDrawRoutine */ + /*-----------------------------------------------------------------------------------*/ + SHScriptEngine::GizmosDrawRoutine::GizmosDrawRoutine() + : SHSystemRoutine("Script Engine Gizmos Draw", true) + {} + void SHScriptEngine::GizmosDrawRoutine::Execute(double dt) noexcept + { + reinterpret_cast(system)->csScriptsExecuteDrawGizmos(); + } + /*-----------------------------------------------------------------------------------*/ /* System Routine Functions - FrameCleanUpRoutine */ /*-----------------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.cpp b/SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.cpp new file mode 100644 index 00000000..6fa4e9bf --- /dev/null +++ b/SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.cpp @@ -0,0 +1,89 @@ +#include "SHpch.h" +#include "SHConfigurationManager.h" +#include "Tools/FileIO/SHFileIO.h" +#include "Serialization/SHSerializationHelper.hpp" + +namespace SHADE +{ + SHApplicationConfig SHConfigurationManager::applicationConfig; +#ifdef SHEDITOR + SHEditorConfig SHConfigurationManager::editorConfig; +#endif + + void SHConfigurationManager::SaveApplicationConfig() + { + YAML::Emitter out; + out << SHSerializationHelper::RTTRToNode(applicationConfig); + SHFileIO::WriteStringToFile(applicationConfigPath, out.c_str()); + } + + SHApplicationConfig& SHConfigurationManager::LoadApplicationConfig(WindowData* wndData) + { + if(!std::filesystem::exists(applicationConfigPath)) + { + SaveApplicationConfig(); + return applicationConfig; + } + + auto const node = YAML::Load(SHFileIO::GetStringFromFile(applicationConfigPath)); + auto properties = rttr::type::get().get_properties(); + for(auto const& property : properties) + { + if(node[property.get_name().data()].IsDefined()) + SHSerializationHelper::InitializeProperty(&applicationConfig, property, node[property.get_name().data()]); + } + + if(wndData != nullptr) + { + wndData->isFullscreen = applicationConfig.startInFullScreen; + wndData->title = std::wstring(applicationConfig.windowTitle.begin(), applicationConfig.windowTitle.end()); + wndData->width = static_cast(applicationConfig.windowSize.x); + wndData->height = static_cast(applicationConfig.windowSize.y); + } + + return applicationConfig; + } + +#ifdef SHEDITOR + void SHConfigurationManager::SaveEditorConfig() + { + YAML::Emitter out; + out << SHSerializationHelper::RTTRToNode(editorConfig); + SHFileIO::WriteStringToFile(editorConfigPath, out.c_str()); + } + + SHEditorConfig& SHConfigurationManager::LoadEditorConfig() + { + auto const node = YAML::Load(SHFileIO::GetStringFromFile(editorConfigPath)); + auto properties = rttr::type::get().get_properties(); + for(auto const& property : properties) + { + if(node[property.get_name().data()].IsDefined()) + SHSerializationHelper::InitializeProperty(&editorConfig, property, node[property.get_name().data()]); + } + return editorConfig; + } + + void SHConfigurationManager::FetchEditorCameraData() + { + + } + + void SHConfigurationManager::SetEditorCameraData() + { + + } +#endif +} + +RTTR_REGISTRATION +{ + using namespace rttr; + using namespace SHADE; + + registration::class_("Application Config") + .property("Start in Fullscreen", &SHApplicationConfig::startInFullScreen) + .property("Starting Scene ID", &SHApplicationConfig::startingSceneID) + .property("Window Size", &SHApplicationConfig::windowSize) + .property("Window Title", &SHApplicationConfig::windowTitle); +} diff --git a/SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.h b/SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.h new file mode 100644 index 00000000..767b8c2b --- /dev/null +++ b/SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.h @@ -0,0 +1,44 @@ +#pragma once +#include +#include "Assets/SHAssetMacros.h" +#include "Graphics/Windowing/SHWindow.h" +#include "SH_API.h" +#include "Math/Vector/SHVec2.h" + +namespace SHADE +{ + + struct SHApplicationConfig + { + bool startInFullScreen{ false }; + AssetID startingSceneID{}; + SHVec2 windowSize {1920, 1080}; + std::string windowTitle {"SHADE Engine"}; + RTTR_ENABLE() + }; + + struct SHEditorConfig + { + + }; + + class SH_API SHConfigurationManager + { + public: + static inline std::string applicationConfigPath{ std::string(ASSET_ROOT) + "/Application.SHConfig"}; + static inline std::string editorConfigPath{ std::string(ASSET_ROOT) + "/Editor/Editor.SHConfig"}; + + static void SaveApplicationConfig(); + static SHApplicationConfig& LoadApplicationConfig(WindowData* wndData = nullptr); + static SHApplicationConfig applicationConfig; +#ifdef SHEDITOR + static void SaveEditorConfig(); + static SHEditorConfig& LoadEditorConfig(); + static SHEditorConfig editorConfig; + private: + static void FetchEditorCameraData(); + static void SetEditorCameraData(); +#endif + + }; +} diff --git a/SHADE_Engine/src/Serialization/SHSerialization.cpp b/SHADE_Engine/src/Serialization/SHSerialization.cpp index 03498951..f2829b95 100644 --- a/SHADE_Engine/src/Serialization/SHSerialization.cpp +++ b/SHADE_Engine/src/Serialization/SHSerialization.cpp @@ -1,8 +1,8 @@ #include "SHpch.h" #include -#include "SHSerializationHelper.hpp" #include "SHSerialization.h" +#include "SHSerializationHelper.hpp" #include "ECS_Base/Managers/SHEntityManager.h" #include "Scene/SHSceneManager.h" @@ -10,6 +10,7 @@ #include "Assets/SHAssetManager.h" #include +#include "Assets/Asset Types/SHSceneAsset.h" #include "Camera/SHCameraComponent.h" #include "Graphics/MiddleEnd/Interface/SHRenderable.h" #include "Math/Transform/SHTransformComponent.h" @@ -17,19 +18,23 @@ #include "ECS_Base/Managers/SHSystemManager.h" #include "Graphics/MiddleEnd/Lights/SHLightComponent.h" #include "Scripting/SHScriptEngine.h" +#include "Tools/FileIO/SHFileIO.h" namespace SHADE { - void SHSerialization::SerializeSceneToFile(std::filesystem::path const& path) + bool SHSerialization::SerializeSceneToFile(AssetID const& sceneAssetID) { + auto assetData = SHAssetManager::GetData(sceneAssetID); + if(!assetData) + { + SHLOG_ERROR("Asset does not exist: {}", sceneAssetID); + return false; + } YAML::Emitter out; SerializeSceneToEmitter(out); - std::ofstream file(path.c_str()); - if (file.good()) - { - file << out.c_str(); - file.close(); - } + assetData->data = out.c_str(); + + return SHAssetManager::SaveAsset(sceneAssetID); } std::string SHSerialization::SerializeSceneToString() @@ -91,31 +96,16 @@ namespace SHADE return eid; } - void SHSerialization::DeserializeSceneFromFile(std::filesystem::path const& path) + std::string SHSerialization::DeserializeSceneFromFile(AssetID const& sceneAssetID) noexcept { - //TODO:Shift to using XQ's FileIO - std::ifstream iFile; - iFile.exceptions(std::ifstream::failbit | std::ifstream::badbit); - std::string fileContent = ""; - - try + auto assetData = SHAssetManager::GetData(sceneAssetID); + if(!assetData) { - // Open file - // Read file's buffer contents into streams - iFile.open(path); - std::stringstream fileStream; - fileStream << iFile.rdbuf(); - - fileContent = fileStream.str(); - - // Close file handler - iFile.close(); + SHLOG_ERROR("Attempted to load scene that doesn't exist {}", sceneAssetID) + SHSceneManager::SetCurrentSceneAssetID(0); + return NewSceneName.data(); } - catch (std::ifstream::failure e) - { - SHLOG_ERROR("Could not read file"); - } - YAML::Node entities = YAML::Load(fileContent); + YAML::Node entities = YAML::Load(assetData->data); std::vector createdEntities{}; //Create Entities @@ -126,15 +116,24 @@ namespace SHADE if (createdEntities.empty()) { SHLOG_ERROR("Failed to create entities from deserializaiton") - return; + return NewSceneName.data(); } - //Initialize Entity auto entityVecIt = createdEntities.begin(); + AssetQueue assetQueue; + for (auto it = entities.begin(); it != entities.end(); ++it) + { + SHSerializationHelper::FetchAssetsFromComponent((*it)[ComponentsNode], *entityVecIt, assetQueue); + } + LoadAssetsFromAssetQueue(assetQueue); + //Initialize Entity + entityVecIt = createdEntities.begin(); for (auto it = entities.begin(); it != entities.end(); ++it) { InitializeEntity(*it, *entityVecIt++); } - } + + return assetData->name; + } void SHSerialization::EmitEntity(SHSceneNode* entityNode, YAML::Emitter& out) { @@ -264,6 +263,33 @@ namespace SHADE return componentIDList; } + void SHSerialization::LoadAssetsFromAssetQueue(AssetQueue& assetQueue) + { + for (auto& [assetId, assetType] : assetQueue) + { + switch(assetType) + { + case AssetType::INVALID: break; + case AssetType::SHADER: break; + case AssetType::SHADER_BUILT_IN: break; + case AssetType::TEXTURE: + SHResourceManager::LoadOrGet(assetId); + break; + case AssetType::MESH: + SHResourceManager::LoadOrGet(assetId); + break; + case AssetType::SCENE: break; + case AssetType::PREFAB: break; + case AssetType::MATERIAL: + SHResourceManager::LoadOrGet(assetId); + break; + case AssetType::MAX_COUNT: break; + default: ; + } + } + SHResourceManager::FinaliseChanges(); + } + void SHSerialization::InitializeEntity(YAML::Node const& entityNode, EntityID const& eid) { auto const componentsNode = entityNode[ComponentsNode]; diff --git a/SHADE_Engine/src/Serialization/SHSerialization.h b/SHADE_Engine/src/Serialization/SHSerialization.h index 018bf0c3..3cb268f2 100644 --- a/SHADE_Engine/src/Serialization/SHSerialization.h +++ b/SHADE_Engine/src/Serialization/SHSerialization.h @@ -4,7 +4,10 @@ #include #include -#include + +#include "ECS_Base/SHECSMacros.h" +#include +#include namespace YAML { @@ -25,12 +28,11 @@ namespace SHADE struct SH_API SHSerialization { - //TODO: change paths to resource ID - static void SerializeSceneToFile(std::filesystem::path const& path); + static bool SerializeSceneToFile(AssetID const& sceneAssetID); static std::string SerializeSceneToString(); static void SerializeSceneToEmitter(YAML::Emitter& out); - static void DeserializeSceneFromFile(std::filesystem::path const& path); + static std::string DeserializeSceneFromFile(AssetID const& sceneAssetID) noexcept; static void EmitEntity(SHSceneNode* entityNode, YAML::Emitter& out); @@ -42,7 +44,11 @@ namespace SHADE static EntityID DeserializeEntitiesFromString(std::string const& data, EntityID const& parentEID = MAX_EID) noexcept; static std::vector GetComponentIDList(YAML::Node const& componentsNode); + + static void LoadAssetsFromAssetQueue(std::unordered_map& assetQueue); private: static void InitializeEntity(YAML::Node const& entityNode, EntityID const& eid); + + static constexpr std::string_view NewSceneName = "New Scene"; }; } \ No newline at end of file diff --git a/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp b/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp index 2179d1cf..b062b348 100644 --- a/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp +++ b/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp @@ -1,392 +1,20 @@ #pragma once +#include "SHYAMLConverters.h" #include #include "ECS_Base/Components/SHComponent.h" #include +#include #include "ECS_Base/Managers/SHComponentManager.h" -#include "Math/Vector/SHVec2.h" -#include "Math/Vector/SHVec3.h" -#include "Math/Vector/SHVec4.h" -#include "Resource/SHResourceManager.h" -#include "Graphics/MiddleEnd/Interface/SHRenderable.h" -#include "Graphics/MiddleEnd/Interface/SHMaterial.h" -#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" -#include "SHSerializationTools.h" -#include "Physics/Components/SHColliderComponent.h" #include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" #include "Tools/SHLog.h" -namespace YAML -{ - using namespace SHADE; - - template<> - struct convert - { - static constexpr const char* x = "x"; - static constexpr const char* y = "y"; - static constexpr const char* z = "z"; - static constexpr const char* w = "w"; - - static Node encode(SHVec4 const& rhs) - { - Node node; - node.SetStyle(EmitterStyle::Flow); - node[x] = rhs.x; - node[y] = rhs.y; - node[z] = rhs.z; - node[w] = rhs.w; - return node; - } - static bool decode(Node const& node, SHVec4& rhs) - { - if (node[x].IsDefined()) - rhs.x = node[x].as(); - if (node[y].IsDefined()) - rhs.y = node[y].as(); - if (node[z].IsDefined()) - rhs.z = node[z].as(); - if (node[w].IsDefined()) - rhs.w = node[w].as(); - return true; - } - }; - - template<> - struct convert - { - static constexpr const char* x = "x"; - static constexpr const char* y = "y"; - static constexpr const char* z = "z"; - - static Node encode(SHVec3 const& rhs) - { - Node node; - node.SetStyle(EmitterStyle::Flow); - node[x] = rhs.x; - node[y] = rhs.y; - node[z] = rhs.z; - return node; - } - static bool decode(Node const& node, SHVec3& rhs) - { - if (node[x].IsDefined()) - rhs.x = node[x].as(); - if (node[y].IsDefined()) - rhs.y = node[y].as(); - if (node[z].IsDefined()) - rhs.z = node[z].as(); - return true; - } - }; - - template<> - struct convert - { - static constexpr const char* x = "x"; - static constexpr const char* y = "y"; - - static Node encode(SHVec2 const& rhs) - { - Node node; - node.SetStyle(EmitterStyle::Flow); - node[x] = rhs.x; - node[y] = rhs.y; - return node; - } - static bool decode(Node const& node, SHVec2& rhs) - { - if (node[x].IsDefined()) - rhs.x = node[x].as(); - if (node[y].IsDefined()) - rhs.y = node[y].as(); - return true; - } - }; - - template<> - struct convert - { - static constexpr const char* IsTrigger = "Is Trigger"; - - static constexpr const char* Type = "Type"; - static constexpr const char* HalfExtents = "Half Extents"; - static constexpr const char* Radius = "Radius"; - - static constexpr const char* Friction = "Friction"; - static constexpr const char* Bounciness = "Bounciness"; - static constexpr const char* Density = "Density"; - static constexpr const char* PositionOffset = "Position Offset"; - - static Node encode(SHCollider& rhs) - { - Node node; - - node[IsTrigger] = rhs.IsTrigger(); - - rttr::type const shapeRttrType = rttr::type::get(); - rttr::enumeration const enumAlign = shapeRttrType.get_enumeration(); - SHCollider::Type colliderType = rhs.GetType(); - - node[Type] = enumAlign.value_to_name(colliderType).data(); - - switch (colliderType) - { - case SHCollider::Type::BOX: - { - auto const bb = reinterpret_cast(rhs.GetShape()); - node[HalfExtents] = bb->GetHalfExtents(); - } - break; - case SHCollider::Type::SPHERE: - { - auto const bs = reinterpret_cast(rhs.GetShape()); - node[Radius] = bs->GetRadius(); - } - break; - case SHCollider::Type::CAPSULE: break; - default:; - } - - node[Friction] = rhs.GetFriction(); - node[Bounciness] = rhs.GetBounciness(); - node[Density] = rhs.GetDensity(); - node[PositionOffset] = rhs.GetPositionOffset(); - - return node; - } - static bool decode(Node const& node, SHCollider& rhs) - { - if (node[IsTrigger].IsDefined()) - rhs.SetIsTrigger(node[IsTrigger].as()); - if (!node[Type].IsDefined()) - return false; - rttr::type const shapeRttrType = rttr::type::get(); - rttr::enumeration const enumAlign = shapeRttrType.get_enumeration(); - bool ok; - const SHCollider::Type colliderType = enumAlign.name_to_value(node[Type].as()).convert(&ok); - if (!ok) - return false; - switch (colliderType) - { - case SHCollider::Type::BOX: - { - if(node[HalfExtents].IsDefined()) - rhs.SetBoundingBox(node[HalfExtents].as()); - } - break; - case SHCollider::Type::SPHERE: - { - if(node[Radius].IsDefined()) - rhs.SetBoundingSphere(node[Radius].as()); - } - break; - case SHCollider::Type::CAPSULE: break; - default:; - } - if (node[Friction].IsDefined()) - rhs.SetFriction(node[Friction].as()); - if (node[Bounciness].IsDefined()) - rhs.SetBounciness(rhs.GetBounciness()); - if (node[Density].IsDefined()) - rhs.SetDensity(node[Density].as()); - if (node[PositionOffset].IsDefined()) - rhs.SetPositionOffset(node[PositionOffset].as()); - - return true; - } - }; - - template<> - struct convert - { - static constexpr const char* Colliders = "Colliders"; - static Node encode(SHColliderComponent& rhs) - { - Node node, collidersNode; - auto const& colliders = rhs.GetColliders(); - int const numColliders = static_cast(colliders.size()); - for (int i = 0; i < numColliders; ++i) - { - auto& collider = rhs.GetCollider(i); - Node colliderNode = convert::encode(collider); - if (colliderNode.IsDefined()) - collidersNode[i] = colliderNode; - } - node[Colliders] = collidersNode; - return node; - } - static bool decode(Node const& node, SHColliderComponent& rhs) - { - if (node[Colliders].IsDefined()) - { - int numColliders{}; - for (auto const& colliderNode : node[Colliders]) - { - rttr::type const shapeRttrType = rttr::type::get(); - rttr::enumeration const enumAlign = shapeRttrType.get_enumeration(); - bool ok = false; - const SHCollider::Type colliderType = enumAlign.name_to_value(colliderNode[convert::Type].as()).convert(&ok); - if (!ok) - return false; - - switch (colliderType) - { - case SHCollider::Type::BOX: rhs.AddBoundingBox(); break; - case SHCollider::Type::SPHERE: rhs.AddBoundingSphere(); break; - case SHCollider::Type::CAPSULE: break; - default:; - } - YAML::convert::decode(colliderNode, rhs.GetCollider(numColliders++)); - } - } - return true; - } - }; - - template<> - struct convert - { - static constexpr std::string_view VERT_SHADER_YAML_TAG = "VertexShader"; - static constexpr std::string_view FRAG_SHADER_YAML_TAG = "FragmentShader"; - static constexpr std::string_view SUBPASS_YAML_TAG = "SubPass"; - static constexpr std::string_view PROPS_YAML_TAG = "Properties"; - - static YAML::Node encode(SHMaterial const& rhs) - { - // Write Properties - YAML::Node propertiesNode; - Handle pipelineProperties = rhs.GetShaderBlockInterface(); - for (int i = 0; i < static_cast(pipelineProperties->GetVariableCount()); ++i) - { - const SHShaderBlockInterface::Variable* VARIABLE = pipelineProperties->GetVariable(i); - if (!VARIABLE) - break; - const std::string& VAR_NAME = pipelineProperties->GetVariableName(i); - YAML::Node propNode; - switch (VARIABLE->type) - { - case SHADE::SHShaderBlockInterface::Variable::Type::FLOAT: - propNode = rhs.GetProperty(VARIABLE->offset); - break; - case SHADE::SHShaderBlockInterface::Variable::Type::INT: - propNode = rhs.GetProperty(VARIABLE->offset); - break; - case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2: - propNode = rhs.GetProperty(VARIABLE->offset); - break; - case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR3: - propNode = rhs.GetProperty(VARIABLE->offset); - break; - case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR4: - propNode = rhs.GetProperty(VARIABLE->offset); - break; - case SHADE::SHShaderBlockInterface::Variable::Type::OTHER: - default: - continue; - break; - } - propertiesNode[VAR_NAME.data()] = propNode; - } - - // Get Shader Handles - const auto& SHADERS = rhs.GetPipeline()->GetPipelineLayout()->GetShaderModules(); - Handle vertexShader, fragShader; - for (const auto& shader : SHADERS) - { - const auto FLAG_BITS = shader->GetShaderStageFlagBits(); - if (FLAG_BITS & vk::ShaderStageFlagBits::eVertex) - vertexShader = shader; - else if (FLAG_BITS & vk::ShaderStageFlagBits::eFragment) - fragShader = shader; - } - - // Write Material - YAML::Node node; - - node[VERT_SHADER_YAML_TAG.data()] = SHResourceManager::GetAssetID(vertexShader).value_or(0); - node[FRAG_SHADER_YAML_TAG.data()] = SHResourceManager::GetAssetID(fragShader).value_or(0); - node[SUBPASS_YAML_TAG.data()] = rhs.GetPipeline()->GetPipelineState().GetSubpass()->GetName(); - node[PROPS_YAML_TAG.data()] = propertiesNode; - - return node; - } - }; - - template<> - struct convert - { - static constexpr std::string_view VERT_SHADER_YAML_TAG = "VertexShader"; - static constexpr std::string_view FRAG_SHADER_YAML_TAG = "FragmentShader"; - static constexpr std::string_view SUBPASS_YAML_TAG = "SubPass"; - static constexpr std::string_view PROPS_YAML_TAG = "Properties"; - - static bool decode(YAML::Node const& node, SHMaterialSpec& rhs) - { - // Retrieve Shader Asset IDs - if (!node[VERT_SHADER_YAML_TAG.data()]) - return false; - rhs.vertexShader = node[VERT_SHADER_YAML_TAG.data()].as(); - if (!node[FRAG_SHADER_YAML_TAG.data()]) - return false; - rhs.fragShader = node[FRAG_SHADER_YAML_TAG.data()].as(); - - // Retrieve Subpass - if (!node[SUBPASS_YAML_TAG.data()]) - return false; - rhs.subpassName = node[SUBPASS_YAML_TAG.data()].as(); - - // Retrieve - if (!node[PROPS_YAML_TAG.data()]) - return false; - rhs.properties = node[PROPS_YAML_TAG.data()]; - - return true; - } - }; - - template<> - struct convert - { - static constexpr std::string_view MESH_YAML_TAG = "Mesh"; - static constexpr std::string_view MAT_YAML_TAG = "Material"; - - static YAML::Node encode(SHRenderable const& rhs) - { - YAML::Node node; - node[MESH_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMesh()).value_or(0); - node[MAT_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMaterial()->GetBaseMaterial()).value_or(0); - return node; - } - static bool decode(YAML::Node const& node, SHRenderable& rhs) - { - if (node[MESH_YAML_TAG.data()].IsDefined()) - { - rhs.SetMesh(SHResourceManager::LoadOrGet(node[MESH_YAML_TAG.data()].as())); - } - if (node[MAT_YAML_TAG.data()].IsDefined()) - { - // Temporarily, use default material - auto gfxSystem = SHSystemManager::GetSystem(); - if (!gfxSystem) - return false; - Handle baseMat = SHResourceManager::LoadOrGet(node[MAT_YAML_TAG.data()].as()); - if (!baseMat) - { - baseMat = gfxSystem->GetDefaultMaterial(); - SHLog::Warning("[SHSerializationHelper] Unable to load specified material. Falling back to default material."); - } - rhs.SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(baseMat)); - } - return true; - } - }; -} namespace SHADE { + using AssetQueue = std::unordered_map; struct SHSerializationHelper { @@ -460,6 +88,8 @@ namespace SHADE node = YAML::Null; } } + else if (varType == rttr::type::get()) + node = var.to_string(); else { auto properties = var.get_type().get_properties(); @@ -495,63 +125,65 @@ namespace SHADE return node; } - template , bool> = true> - static void InitializeProperty(ComponentType* component, rttr::property const& prop, YAML::Node const& propertyNode) + template + static void InitializeProperty(Type* object, rttr::property const& prop, YAML::Node const& propertyNode) { auto propType = prop.get_type(); if (propType == rttr::type::get()) { SHVec4 vec = propertyNode.as(); - prop.set_value(component, vec); + prop.set_value(object, vec); } else if (propType == rttr::type::get()) { SHVec3 vec = propertyNode.as(); - prop.set_value(component, vec); + prop.set_value(object, vec); } else if (propType == rttr::type::get()) { SHVec2 vec = propertyNode.as(); - prop.set_value(component, vec); + prop.set_value(object, vec); } else if (propType.is_arithmetic()) { bool ok = false; if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); else if (propType == rttr::type::get()) - prop.set_value(component, propertyNode.as()); + prop.set_value(object, propertyNode.as()); } else if (propType.is_enumeration()) { auto enumAlign = prop.get_enumeration(); - prop.set_value(component, enumAlign.name_to_value(propertyNode.as())); + prop.set_value(object, enumAlign.name_to_value(propertyNode.as())); } + else if (propType == rttr::type::get()) + prop.set_value(object, propertyNode.as()); else { auto properties = propType.get_properties(); for (auto const& property : properties) { if(propertyNode[property.get_name().data()].IsDefined()) - InitializeProperty(component, property, propertyNode[property.get_name().data()]); + InitializeProperty(object, property, propertyNode[property.get_name().data()]); } } } @@ -564,7 +196,7 @@ namespace SHADE return; auto rttrType = rttr::type::get(); auto componentNode = componentsNode[rttrType.get_name().data()]; - if(!componentNode.IsDefined()) + if (!componentNode.IsDefined()) return; auto properties = rttrType.get_properties(); for (auto const& prop : properties) @@ -576,18 +208,73 @@ namespace SHADE } } + template , bool> = true> + static YAML::Node GetComponentNode(YAML::Node const& componentsNode, EntityID const& eid) + { + auto component = SHComponentManager::GetComponent_s(eid); + if (componentsNode.IsNull() && !component) + return {}; + auto rttrType = rttr::type::get(); + auto componentNode = componentsNode[rttrType.get_name().data()]; + if (!componentNode.IsDefined()) + return {}; + return componentNode; + } + template , bool> = true> static void ConvertNodeToComponent(YAML::Node const& componentsNode, EntityID const& eid) { auto component = SHComponentManager::GetComponent_s(eid); if (componentsNode.IsNull() && !component) return; - auto rttrType = rttr::type::get(); - auto componentNode = componentsNode[rttrType.get_name().data()]; - if (!componentNode.IsDefined()) - return; - YAML::convert::decode(componentNode, *component); + + YAML::convert::decode(GetComponentNode(componentsNode, eid), *component); } + template , bool> = true> + static void FetchAssetsFromComponent(YAML::Node const& componentsNode, EntityID const& eid, AssetQueue& assetQueue) + { + } + + template<> + static void FetchAssetsFromComponent(YAML::Node const& componentsNode, EntityID const& eid, AssetQueue& assetQueue) + { + auto node = GetComponentNode(componentsNode, eid); + if(!node.IsDefined()) + return; + if (auto const& meshNode = node[YAML::convert::MESH_YAML_TAG.data()]; meshNode.IsDefined()) + { + assetQueue.insert({meshNode.as(), AssetType::MESH}); + //SHResourceManager::LoadOrGet(node[YAML::convert::MESH_YAML_TAG.data()].as()); + } + if (auto const& matNode = node[YAML::convert::MAT_YAML_TAG.data()]; matNode.IsDefined()) + { + auto const matAsset = SHAssetManager::GetData(matNode.as()); + if(matAsset) + { + SHMaterialSpec spec; + YAML::convert::decode(*YAML::Load(matAsset->data).begin(), spec); + if(spec.properties.IsDefined()) + { + auto fragShader = SHResourceManager::LoadOrGet(spec.fragShader); + auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface(SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE, SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA); + int const varCount = static_cast(interface->GetVariableCount()); + + for (int i = 0; i < varCount; ++i) + { + auto variable = interface->GetVariable(i); + if(variable->type != SHShaderBlockInterface::Variable::Type::INT) + continue; + const std::string& VAR_NAME = interface->GetVariableName(i); + if(VAR_NAME.empty()) + continue; + assetQueue.insert({spec.properties[VAR_NAME.data()].as(), AssetType::TEXTURE}); + } + } + } + //assetQueue.insert({matNode.as(), AssetType::MATERIAL}); + //SHResourceManager::LoadOrGet(node[YAML::convert::MAT_YAML_TAG.data()].as()); + } + } }; } diff --git a/SHADE_Engine/src/Serialization/SHYAMLConverters.h b/SHADE_Engine/src/Serialization/SHYAMLConverters.h new file mode 100644 index 00000000..1b93c63a --- /dev/null +++ b/SHADE_Engine/src/Serialization/SHYAMLConverters.h @@ -0,0 +1,317 @@ +#pragma once +#include "Graphics/MiddleEnd/Interface/SHRenderable.h" +#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" +#include "Math/Geometry/SHBoundingBox.h" +#include "Math/Geometry/SHBoundingSphere.h" +#include "Physics/SHCollisionShape.h" +#include "Resource/SHResourceManager.h" +#include "Math/Vector/SHVec2.h" +#include "Math/Vector/SHVec3.h" +#include "Math/Vector/SHVec4.h" +#include "Graphics/MiddleEnd/Interface/SHMaterial.h" +#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" +#include "SHSerializationTools.h" +#include "Physics/Components/SHColliderComponent.h" +namespace YAML +{ + using namespace SHADE; + + template<> + struct convert + { + static constexpr const char* x = "x"; + static constexpr const char* y = "y"; + static constexpr const char* z = "z"; + static constexpr const char* w = "w"; + + static Node encode(SHVec4 const& rhs) + { + Node node; + node.SetStyle(EmitterStyle::Flow); + node[x] = rhs.x; + node[y] = rhs.y; + node[z] = rhs.z; + node[w] = rhs.w; + return node; + } + static bool decode(Node const& node, SHVec4& rhs) + { + if (node[x].IsDefined()) + rhs.x = node[x].as(); + if (node[y].IsDefined()) + rhs.y = node[y].as(); + if (node[z].IsDefined()) + rhs.z = node[z].as(); + if (node[w].IsDefined()) + rhs.w = node[w].as(); + return true; + } + }; + + template<> + struct convert + { + static constexpr const char* x = "x"; + static constexpr const char* y = "y"; + static constexpr const char* z = "z"; + + static Node encode(SHVec3 const& rhs) + { + Node node; + node.SetStyle(EmitterStyle::Flow); + node[x] = rhs.x; + node[y] = rhs.y; + node[z] = rhs.z; + return node; + } + static bool decode(Node const& node, SHVec3& rhs) + { + if (node[x].IsDefined()) + rhs.x = node[x].as(); + if (node[y].IsDefined()) + rhs.y = node[y].as(); + if (node[z].IsDefined()) + rhs.z = node[z].as(); + return true; + } + }; + + template<> + struct convert + { + static constexpr const char* x = "x"; + static constexpr const char* y = "y"; + + static Node encode(SHVec2 const& rhs) + { + Node node; + node.SetStyle(EmitterStyle::Flow); + node[x] = rhs.x; + node[y] = rhs.y; + return node; + } + static bool decode(Node const& node, SHVec2& rhs) + { + if (node[x].IsDefined()) + rhs.x = node[x].as(); + if (node[y].IsDefined()) + rhs.y = node[y].as(); + return true; + } + }; + + template<> + struct convert + { + static constexpr const char* IsTrigger = "Is Trigger"; + + static constexpr const char* Type = "Type"; + static constexpr const char* HalfExtents = "Half Extents"; + static constexpr const char* Radius = "Radius"; + + static constexpr const char* Friction = "Friction"; + static constexpr const char* Bounciness = "Bounciness"; + static constexpr const char* Density = "Density"; + static constexpr const char* PositionOffset = "Position Offset"; + + static Node encode(SHCollisionShape& rhs) + { + Node node; + + node[IsTrigger] = rhs.IsTrigger(); + + rttr::type const shapeRttrType = rttr::type::get(); + rttr::enumeration const enumAlign = shapeRttrType.get_enumeration(); + SHCollisionShape::Type colliderType = rhs.GetType(); + + node[Type] = enumAlign.value_to_name(colliderType).data(); + + switch (colliderType) + { + case SHCollisionShape::Type::BOX: + { + auto const bb = reinterpret_cast(rhs.GetShape()); + node[HalfExtents] = bb->GetRelativeExtents(); + } + break; + case SHCollisionShape::Type::SPHERE: + { + auto const bs = reinterpret_cast(rhs.GetShape()); + node[Radius] = bs->GetRelativeRadius(); + } + break; + case SHCollisionShape::Type::CAPSULE: break; + default:; + } + + node[Friction] = rhs.GetFriction(); + node[Bounciness] = rhs.GetBounciness(); + node[Density] = rhs.GetDensity(); + node[PositionOffset] = rhs.GetPositionOffset(); + + return node; + } + static bool decode(Node const& node, SHCollisionShape& rhs) + { + if (node[IsTrigger].IsDefined()) + rhs.SetIsTrigger(node[IsTrigger].as()); + if (!node[Type].IsDefined()) + return false; + rttr::type const shapeRttrType = rttr::type::get(); + rttr::enumeration const enumAlign = shapeRttrType.get_enumeration(); + bool ok; + const SHCollisionShape::Type colliderType = enumAlign.name_to_value(node[Type].as()).convert(&ok); + if (!ok) + return false; + switch (colliderType) + { + case SHCollisionShape::Type::BOX: + { + if (node[HalfExtents].IsDefined()) + rhs.SetBoundingBox(node[HalfExtents].as()); + } + break; + case SHCollisionShape::Type::SPHERE: + { + if (node[Radius].IsDefined()) + rhs.SetBoundingSphere(node[Radius].as()); + } + break; + case SHCollisionShape::Type::CAPSULE: break; + default:; + } + if (node[Friction].IsDefined()) + rhs.SetFriction(node[Friction].as()); + if (node[Bounciness].IsDefined()) + rhs.SetBounciness(rhs.GetBounciness()); + if (node[Density].IsDefined()) + rhs.SetDensity(node[Density].as()); + if (node[PositionOffset].IsDefined()) + rhs.SetPositionOffset(node[PositionOffset].as()); + + return true; + } + }; + + template<> + struct convert + { + static constexpr const char* Colliders = "Colliders"; + static Node encode(SHColliderComponent& rhs) + { + Node node, collidersNode; + auto const& colliders = rhs.GetCollisionShapes(); + int const numColliders = static_cast(colliders.size()); + for (int i = 0; i < numColliders; ++i) + { + auto& collider = rhs.GetCollisionShape(i); + Node colliderNode = convert::encode(collider); + if (colliderNode.IsDefined()) + collidersNode[i] = colliderNode; + } + node[Colliders] = collidersNode; + return node; + } + static bool decode(Node const& node, SHColliderComponent& rhs) + { + if (node[Colliders].IsDefined()) + { + int numColliders{}; + for (auto const& colliderNode : node[Colliders]) + { + rttr::type const shapeRttrType = rttr::type::get(); + rttr::enumeration const enumAlign = shapeRttrType.get_enumeration(); + bool ok = false; + const SHCollisionShape::Type colliderType = enumAlign.name_to_value(colliderNode[convert::Type].as()).convert(&ok); + if (!ok) + return false; + + switch (colliderType) + { + case SHCollisionShape::Type::BOX: rhs.AddBoundingBox(); break; + case SHCollisionShape::Type::SPHERE: rhs.AddBoundingSphere(); break; + case SHCollisionShape::Type::CAPSULE: break; + default:; + } + YAML::convert::decode(colliderNode, rhs.GetCollisionShape(numColliders++)); + } + } + return true; + } + }; + + template<> + struct convert + { + static constexpr std::string_view VERT_SHADER_YAML_TAG = "VertexShader"; + static constexpr std::string_view FRAG_SHADER_YAML_TAG = "FragmentShader"; + static constexpr std::string_view SUBPASS_YAML_TAG = "SubPass"; + static constexpr std::string_view PROPS_YAML_TAG = "Properties"; + + static YAML::Node encode(SHMaterialSpec const& rhs) + { + YAML::Node node; + node[VERT_SHADER_YAML_TAG.data()] = rhs.vertexShader; + node[FRAG_SHADER_YAML_TAG.data()] = rhs.fragShader; + node[SUBPASS_YAML_TAG.data()] = rhs.subpassName; + node[PROPS_YAML_TAG.data()] = rhs.properties; + return node; + } + + static bool decode(YAML::Node const& node, SHMaterialSpec& rhs) + { + // Retrieve Shader Asset IDs + if (node[VERT_SHADER_YAML_TAG.data()].IsDefined()) + rhs.vertexShader = node[VERT_SHADER_YAML_TAG.data()].as(); + if (node[FRAG_SHADER_YAML_TAG.data()].IsDefined()) + rhs.fragShader = node[FRAG_SHADER_YAML_TAG.data()].as(); + + // Retrieve Subpass + if (node[SUBPASS_YAML_TAG.data()].IsDefined()) + rhs.subpassName = node[SUBPASS_YAML_TAG.data()].as(); + + // Retrieve + if (node[PROPS_YAML_TAG.data()].IsDefined()) + rhs.properties = node[PROPS_YAML_TAG.data()]; + + return true; + } + }; + + template<> + struct convert + { + static constexpr std::string_view MESH_YAML_TAG = "Mesh"; + static constexpr std::string_view MAT_YAML_TAG = "Material"; + + static YAML::Node encode(SHRenderable const& rhs) + { + YAML::Node node; + node[MESH_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMesh()).value_or(0); + node[MAT_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMaterial()->GetBaseMaterial()).value_or(0); + return node; + } + static bool decode(YAML::Node const& node, SHRenderable& rhs) + { + if (node[MESH_YAML_TAG.data()].IsDefined()) + { + rhs.SetMesh(SHResourceManager::LoadOrGet(node[MESH_YAML_TAG.data()].as())); + } + if (node[MAT_YAML_TAG.data()].IsDefined()) + { + // Temporarily, use default material + auto gfxSystem = SHSystemManager::GetSystem(); + if (!gfxSystem) + return false; + Handle baseMat = SHResourceManager::LoadOrGet(node[MAT_YAML_TAG.data()].as()); + if (!baseMat) + { + baseMat = gfxSystem->GetDefaultMaterial(); + SHLog::Warning("[SHSerializationHelper] Unable to load specified material. Falling back to default material."); + } + rhs.SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(baseMat)); + } + return true; + } + }; +} diff --git a/SHADE_Engine/src/Tools/FileIO/SHFieIO.cpp b/SHADE_Engine/src/Tools/FileIO/SHFieIO.cpp new file mode 100644 index 00000000..c4fec120 --- /dev/null +++ b/SHADE_Engine/src/Tools/FileIO/SHFieIO.cpp @@ -0,0 +1,31 @@ +#include "SHpch.h" +#include "SHFileIO.h" +#include + +namespace SHADE +{ + int SHFileIO::WriteStringToFile(std::filesystem::path const& filePath, std::string_view const& strView) + { + std::ofstream file(filePath); + if(file.good()) + { + file << strView; + file.close(); + return 1; + } + return 0; + } + + std::string SHFileIO::GetStringFromFile(std::filesystem::path const& filePath) + { + std::ifstream iFile; + iFile.exceptions(std::ifstream::failbit | std::ifstream::badbit); + std::string fileData{}; + iFile.open(filePath, std::iostream::binary); + std::stringstream ss; + ss << iFile.rdbuf(); + fileData = ss.str(); + iFile.close(); + return fileData; + } +} diff --git a/SHADE_Engine/src/Tools/FileIO/SHFileIO.h b/SHADE_Engine/src/Tools/FileIO/SHFileIO.h new file mode 100644 index 00000000..adc95d5b --- /dev/null +++ b/SHADE_Engine/src/Tools/FileIO/SHFileIO.h @@ -0,0 +1,14 @@ +#pragma once +#include +#include +#include +#include + +namespace SHADE +{ + struct SH_API SHFileIO + { + static int WriteStringToFile(std::filesystem::path const& filePath, std::string_view const& strView); + static std::string GetStringFromFile(std::filesystem::path const& file); + }; +} \ No newline at end of file diff --git a/SHADE_Engine/src/Tools/SHDebugDraw.cpp b/SHADE_Engine/src/Tools/SHDebugDraw.cpp new file mode 100644 index 00000000..b8aa8b0e --- /dev/null +++ b/SHADE_Engine/src/Tools/SHDebugDraw.cpp @@ -0,0 +1,109 @@ +/************************************************************************************//*! +\file SHDebugDrawSystem.cpp +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 2, 2022 +\brief Contains the definition of functions of the SHDebugDrawSystem class. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +// Precompiled Header +#include "SHpch.h" +// Primary Include +#include "SHDebugDraw.h" +// Project Includes +#include "Math/Vector/SHVec4.h" +#include "Math/SHColour.h" +#include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" +#include "ECS_Base/Managers/SHSystemManager.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Static Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + SHDebugDrawSystem* SHDebugDraw::dbgDrawSys = nullptr; + + /*-----------------------------------------------------------------------------------*/ + /* Lifecycle Functions */ + /*-----------------------------------------------------------------------------------*/ + void SHDebugDraw::Init(SHDebugDrawSystem* sys) + { + dbgDrawSys = sys; + if (dbgDrawSys == nullptr) + { + SHLOG_ERROR("[SHDebugDraw] Invalid SHDebugDrawSystem provided for initialization!"); + } + } + + /*-----------------------------------------------------------------------------------*/ + /* Draw Functions */ + /*-----------------------------------------------------------------------------------*/ + void SHDebugDraw::Line(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt) + { + dbgDrawSys->DrawLine(color, startPt, endPt); + } + + void SHDebugDraw::Tri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3) + { + dbgDrawSys->DrawTri(color, pt1, pt2, pt3); + } + + void SHDebugDraw::Quad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4) + { + dbgDrawSys->DrawQuad(color, pt1, pt2, pt3, pt4); + } + + void SHDebugDraw::Poly(const SHVec4& color, std::initializer_list pointList) + { + dbgDrawSys->DrawPoly(color, pointList); + } + + void SHDebugDraw::Cube(const SHVec4& color, const SHVec3& pos, const SHVec3& size) + { + dbgDrawSys->DrawCube(color, pos, size); + } + + void SHDebugDraw::Sphere(const SHVec4& color, const SHVec3& pos, double radius) + { + dbgDrawSys->DrawSphere(color, pos, radius); + } + + void SHDebugDraw::PersistentLine(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt) + { + dbgDrawSys->DrawPersistentLine(color, startPt, endPt); + } + + void SHDebugDraw::PersistentTri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3) + { + dbgDrawSys->DrawPersistentTri(color, pt1, pt2, pt3); + } + + void SHDebugDraw::PersistentQuad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4) + { + dbgDrawSys->DrawPersistentQuad(color, pt1, pt2, pt3, pt4); + } + + void SHDebugDraw::PersistentPoly(const SHVec4& color, std::initializer_list pointList) + { + dbgDrawSys->DrawPersistentPoly(color, pointList); + } + + void SHDebugDraw::PersistentCube(const SHVec4& color, const SHVec3& pos, const SHVec3& size) + { + dbgDrawSys->DrawPersistentCube(color, pos, size); + } + + void SHDebugDraw::PersistentSphere(const SHVec4& color, const SHVec3& pos, double radius) + { + dbgDrawSys->DrawPersistentSphere(color, pos, radius); + } + + void SHDebugDraw::ClearPersistentDraws() + { + dbgDrawSys->ClearPersistentDraws(); + } + +} \ No newline at end of file diff --git a/SHADE_Engine/src/Tools/SHDebugDraw.h b/SHADE_Engine/src/Tools/SHDebugDraw.h new file mode 100644 index 00000000..04504c3a --- /dev/null +++ b/SHADE_Engine/src/Tools/SHDebugDraw.h @@ -0,0 +1,159 @@ +/************************************************************************************//*! +\file SHDebugDraw.h +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 2, 2022 +\brief Contains the definition of the SHDebugDraw static class. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// Project Includes +#include "SH_API.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Forward Declarations */ + /*-----------------------------------------------------------------------------------*/ + class SHDebugDrawSystem; + class SHVec4; + class SHVec3; + class SHColour; + + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + /// + /// Static helper class to make it easier to do debug drawing and enable support for + /// managed code to execute it withot dependency hell due to graphics system + /// dependencies. + /// + class SH_API SHDebugDraw final + { + public: + /*---------------------------------------------------------------------------------*/ + /* Lifecycle Functions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Sets up the link with the SHDebugDrawSystem. Must be called after the + /// SHDebugDrawSystem is spawned. + /// + static void Init(SHDebugDrawSystem* sys); + + /*---------------------------------------------------------------------------------*/ + /* Draw Functions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Renders a line between two points in world space. + /// + /// Colour of the line. + /// First point of the line. + /// Second point of the line. + static void Line(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt); + /// + /// Renders a triangle indicated by three points in world space. + /// + /// Colour of the triangle. + /// First point of the triangle. + /// Second point of the triangle. + /// Third point of the triangle. + static void Tri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3); + /// + /// Renders a quadrilateral indicated by four points in world space. + /// + /// Colour of the quadrilateral. + /// First point of the triangle. + /// Second point of the quadrilateral. + /// Third point of the quadrilateral. + /// Third point of the quadrilateral. + static void Quad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4); + /// + /// Renders a polygon indicated by the specified set of points in world space. + /// + /// Colour of the polygon. + /// List of points for the polygon. + static void Poly(const SHVec4& color, std::initializer_list pointList); + /// + /// Renders a wireframe cube centered around the position specified in world space. + /// + /// Colour of the cube. + /// Position where the cube wil be centered at. + /// Size of the rendered cube. + static void Cube(const SHVec4& color, const SHVec3& pos, const SHVec3& size); + /// + /// Renders a wireframe sphere centered around the position specified in world space. + /// + /// Colour of the sphere. + /// Position where the sphere wil be centered at. + /// Size of the rendered sphere. + static void Sphere(const SHVec4& color, const SHVec3& pos, double radius); + + /*---------------------------------------------------------------------------------*/ + /* Persistent Draw Functions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Renders a line between two points in world space that will persist until + /// ClearPersistentDraws() is called. + /// + /// Colour of the line. + /// First point of the line. + /// Second point of the line. + static void PersistentLine(const SHVec4& color, const SHVec3& startPt, const SHVec3& endPt); + /// + /// Renders a triangle indicated by three points in world space that will persist + /// until ClearPersistentDraws() is called. + /// + /// Colour of the triangle. + /// First point of the triangle. + /// Second point of the triangle. + /// Third point of the triangle. + static void PersistentTri(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3); + /// + /// Renders a quadrilateral indicated by four points in world space that will persist + /// until ClearPersistentDraws() is called. + /// + /// Colour of the quadrilateral. + /// First point of the triangle. + /// Second point of the quadrilateral. + /// Third point of the quadrilateral. + /// Third point of the quadrilateral. + static void PersistentQuad(const SHVec4& color, const SHVec3& pt1, const SHVec3& pt2, const SHVec3& pt3, const SHVec3& pt4); + /// + /// Renders a polygon indicated by the specified set of points in world space that + /// will persist until ClearPersistentDraws() is called. + /// + /// Colour of the polygon. + /// List of points for the polygon. + static void PersistentPoly(const SHVec4& color, std::initializer_list pointList); + /// + /// Renders a wireframe cube centered around the position specified in world space + /// that will persist until ClearPersistentDraws() is called. + /// + /// Colour of the cube. + /// Position where the cube wil be centered at. + /// Size of the rendered cube. + static void PersistentCube(const SHVec4& color, const SHVec3& pos, const SHVec3& size); + /// + /// Renders a wireframe sphere centered around the position specified in world space + /// that will persist until ClearPersistentDraws() is called. + /// + /// Colour of the sphere. + /// Position where the sphere wil be centered at. + /// Size of the rendered sphere. + static void PersistentSphere(const SHVec4& color, const SHVec3& pos, double radius); + /// + /// Clears any persistent drawn debug primitives. + /// + static void ClearPersistentDraws(); + + private: + /*---------------------------------------------------------------------------------*/ + /* Static Data Members */ + /*---------------------------------------------------------------------------------*/ + static SHDebugDrawSystem* dbgDrawSys; + }; +} \ No newline at end of file diff --git a/SHADE_Engine/src/Tools/SHUtilities.h b/SHADE_Engine/src/Tools/SHUtilities.h index b3d840e7..287a827e 100644 --- a/SHADE_Engine/src/Tools/SHUtilities.h +++ b/SHADE_Engine/src/Tools/SHUtilities.h @@ -39,7 +39,7 @@ namespace SHADE * @param[in] enumClassMember A member of the specified enum class. * @returns The value of the enum class member in the output type. */ - template + template > static constexpr OutputType ConvertEnum(InputType enumClassMember) noexcept; /** diff --git a/SHADE_Managed/premake5.lua b/SHADE_Managed/premake5.lua index b383f002..88021071 100644 --- a/SHADE_Managed/premake5.lua +++ b/SHADE_Managed/premake5.lua @@ -38,6 +38,7 @@ project "SHADE_Managed" "%{IncludeDir.RTTR}/include", "%{IncludeDir.dotnet}\\include", "%{IncludeDir.reactphysics3d}\\include", + "%{IncludeDir.VULKAN}\\include", "%{wks.location}/SHADE_Engine/src" } diff --git a/SHADE_Managed/src/Components/Camera.cxx b/SHADE_Managed/src/Components/Camera.cxx index 5e570cc1..0d0dbced 100644 --- a/SHADE_Managed/src/Components/Camera.cxx +++ b/SHADE_Managed/src/Components/Camera.cxx @@ -123,5 +123,14 @@ namespace SHADE } + Vector3 Camera::GetRight() + { + auto system = SHSystemManager::GetSystem(); + SHVec3 forward, up, right; + system->GetCameraAxis(*GetNativeComponent(), forward, right, up); + return Convert::ToCLI(right); + + } + } \ No newline at end of file diff --git a/SHADE_Managed/src/Components/Camera.hxx b/SHADE_Managed/src/Components/Camera.hxx index 257bff11..c6afeb6d 100644 --- a/SHADE_Managed/src/Components/Camera.hxx +++ b/SHADE_Managed/src/Components/Camera.hxx @@ -66,5 +66,7 @@ namespace SHADE void SetMainCamera(); void LookAt(Vector3 targetPosition); Vector3 GetForward(); + Vector3 GetRight(); + }; } \ No newline at end of file diff --git a/SHADE_Managed/src/Components/Collider.cxx b/SHADE_Managed/src/Components/Collider.cxx index f2119b43..0e916b7b 100644 --- a/SHADE_Managed/src/Components/Collider.cxx +++ b/SHADE_Managed/src/Components/Collider.cxx @@ -55,11 +55,11 @@ namespace SHADE } Vector3 BoxCollider::HalfExtents::get() { - return Convert::ToCLI(getNativeBoundObject().GetHalfExtents()); + return Convert::ToCLI(getNativeBoundObject().GetWorldExtents()); } void BoxCollider::HalfExtents::set(Vector3 value) { - getNativeBoundObject().SetHalfExtents(Convert::ToNative(value)); + getNativeBoundObject().SetWorldExtents(Convert::ToNative(value)); } Vector3 BoxCollider::Min::get() { @@ -103,11 +103,11 @@ namespace SHADE } float SphereCollider::Radius::get() { - return getNativeBoundObject().GetRadius(); + return getNativeBoundObject().GetWorldRadius(); } void SphereCollider::Radius::set(float value) { - getNativeBoundObject().SetRadius(value); + getNativeBoundObject().SetWorldRadius(value); } /*---------------------------------------------------------------------------------*/ @@ -150,7 +150,7 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ int Collider::CollisionShapeCount::get() { - return static_cast(GetNativeComponent()->GetColliders().size()); + return static_cast(GetNativeComponent()->GetCollisionShapes().size()); } /*---------------------------------------------------------------------------------*/ @@ -230,18 +230,18 @@ namespace SHADE // Populate the list int i = 0; - for (const auto& collider : GetNativeComponent()->GetColliders()) + for (const auto& collider : GetNativeComponent()->GetCollisionShapes()) { CollisionShape^ bound = nullptr; switch (collider.GetType()) { - case SHCollider::Type::BOX: + case SHCollisionShape::Type::BOX: bound = gcnew BoxCollider(i, Owner.GetEntity()); break; - case SHCollider::Type::SPHERE: + case SHCollisionShape::Type::SPHERE: bound = gcnew SphereCollider(i, Owner.GetEntity()); break; - case SHCollider::Type::CAPSULE: + case SHCollisionShape::Type::CAPSULE: // TODO break; default: diff --git a/SHADE_Managed/src/Components/Collider.h++ b/SHADE_Managed/src/Components/Collider.h++ index 1f8b43eb..6e165619 100644 --- a/SHADE_Managed/src/Components/Collider.h++ +++ b/SHADE_Managed/src/Components/Collider.h++ @@ -27,11 +27,11 @@ namespace SHADE try { - auto& bounds = collider->GetCollider(arrayIndex); - if (bounds.GetType() != SHCollider::Type::BOX) + auto& shape = collider->GetCollisionShape(arrayIndex); + if (shape.GetType() != SHCollisionShape::Type::BOX) throw gcnew System::InvalidOperationException("Attempted to retrieve invalid ColliderBound."); - return reinterpret_cast(bounds); + return reinterpret_cast(shape); } catch (std::invalid_argument&) { diff --git a/SHADE_Managed/src/Components/Component.hxx b/SHADE_Managed/src/Components/Component.hxx index 5ffa3952..e52ab3a7 100644 --- a/SHADE_Managed/src/Components/Component.hxx +++ b/SHADE_Managed/src/Components/Component.hxx @@ -97,7 +97,7 @@ namespace SHADE /// /// Removes all Scripts of the specified type from this GameObject. /// - /// Type of PLushieScripts to remove. + /// Type of Scripts to remove. generic where T : ref class, Script void RemoveScript(); diff --git a/SHADE_Managed/src/Components/Light.cxx b/SHADE_Managed/src/Components/Light.cxx new file mode 100644 index 00000000..a220c79a --- /dev/null +++ b/SHADE_Managed/src/Components/Light.cxx @@ -0,0 +1,79 @@ +/************************************************************************************//*! +\file Light.cxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 8, 2022 +\brief Contains the definition of the functions of the managed Light class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +// Precompiled Headers +#include "SHpch.h" +// Primary Header +#include "Light.hxx" + +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* Constructors */ + /*---------------------------------------------------------------------------------*/ + Light::Light(Entity entity) + : Component(entity) + {} + + /*---------------------------------------------------------------------------------*/ + /* Properties */ + /*---------------------------------------------------------------------------------*/ + Vector3 Light::Position::get() + { + return Convert::ToCLI(GetNativeComponent()->GetPosition()); + } + void Light::Position::set(Vector3 value) + { + GetNativeComponent()->SetPosition(Convert::ToNative(value)); + } + Light::Type Light::LightType::get() + { + return static_cast(GetNativeComponent()->GetType()); + } + void Light::LightType::set(Light::Type value) + { + GetNativeComponent()->SetType(static_cast(value)); + } + Vector3 Light::Direction::get() + { + return Convert::ToCLI(GetNativeComponent()->GetDirection()); + } + void Light::Direction::set(Vector3 value) + { + GetNativeComponent()->SetDirection(Convert::ToNative(value)); + } + Color Light::Color::get() + { + return Convert::ToCLI(SHColour(GetNativeComponent()->GetColor())); + } + void Light::Color::set(SHADE::Color value) + { + GetNativeComponent()->SetColor(Convert::ToNative(value)); + } + System::UInt32 Light::CullingMask::get() + { + return GetNativeComponent()->GetCullingMask(); + } + void Light::CullingMask::set(System::UInt32 value) + { + GetNativeComponent()->SetCullingMask(value); + } + float Light::Strength::get() + { + return GetNativeComponent()->GetStrength(); + } + void Light::Strength::set(float value) + { + GetNativeComponent()->SetStrength(value); + } +} diff --git a/SHADE_Managed/src/Components/Light.hxx b/SHADE_Managed/src/Components/Light.hxx new file mode 100644 index 00000000..9abb05d5 --- /dev/null +++ b/SHADE_Managed/src/Components/Light.hxx @@ -0,0 +1,125 @@ +/************************************************************************************//*! +\file Light.hxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 8, 2022 +\brief Contains the definition of the managed Light class with the declaration + of functions for working with it. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// Project Includes +#include "Components/Component.hxx" +#include "Math/Vector3.hxx" +// External Dependencies +#include "Graphics/MiddleEnd/Lights/SHLightComponent.h" + +namespace SHADE +{ + /// + /// CLR version of the SHADE Engine's SHLightComponent. + /// + public ref class Light : public Component + { + internal: + /*-----------------------------------------------------------------------------*/ + /* Constructors */ + /*-----------------------------------------------------------------------------*/ + /// + /// Constructs a Light Component that represents a native Light component tied to + /// the specified Entity. + /// + /// Entity that this Component will be tied to. + Light(Entity entity); + + public: + /*-----------------------------------------------------------------------------*/ + /* Constants */ + /*-----------------------------------------------------------------------------*/ + /// + /// Supported types of the Light Component. + /// + enum class Type + { + /// + /// Light applied uniformly across the scene at a specified direction. + /// + Directional, + /// + /// Light that originates from a certain point in all directions. + /// Not implemented yet. + /// + Point, + /// + /// Light that originates from a certain point within a angle. + /// Not implemented yet. + /// + Spot, + /// + /// Light applied to all objects. Has no source point. + /// + Ambient + }; + + /*-----------------------------------------------------------------------------*/ + /* Properties */ + /*-----------------------------------------------------------------------------*/ + /// + /// Position of the light. Only works for Point Light (unimplemented). + /// + [System::ObsoleteAttribute("Not implemented yet.", true)] + property Vector3 Position + { + Vector3 get(); + void set(Vector3 val); + } + /// + /// Type of lighting that this Light component will apply onto the scene. + /// + property Type LightType + { + Type get(); + void set(Type val); + } + /// + /// Direction of the light. Only applicable for Directional Lights. + /// + property Vector3 Direction + { + Vector3 get(); + void set(Vector3 val); + } + /// + /// Colour of the Light. + /// + property SHADE::Color Color + { + SHADE::Color get(); + void set(SHADE::Color val); + } + /// + /// Culling mask that is used to control what types of Materials would be + /// affected by this Light. + /// + property System::UInt32 CullingMask + { + System::UInt32 get(); + void set(System::UInt32 val); + } + /// + /// Intensity of the Light + /// + property float Strength + { + float get(); + void set(float val); + } + }; +} + diff --git a/SHADE_Managed/src/Components/RigidBody.cxx b/SHADE_Managed/src/Components/RigidBody.cxx index 172b928b..12861600 100644 --- a/SHADE_Managed/src/Components/RigidBody.cxx +++ b/SHADE_Managed/src/Components/RigidBody.cxx @@ -148,6 +148,14 @@ namespace SHADE { return Convert::ToCLI(GetNativeComponent()->GetTorque()); } + bool RigidBody::Interpolating::get() + { + return GetNativeComponent()->IsInterpolating(); + } + void RigidBody::Interpolating::set(bool value) + { + GetNativeComponent()->SetInterpolate(value); + } /*---------------------------------------------------------------------------------*/ /* Force Functions */ diff --git a/SHADE_Managed/src/Components/RigidBody.hxx b/SHADE_Managed/src/Components/RigidBody.hxx index b3e031ba..d3a30612 100644 --- a/SHADE_Managed/src/Components/RigidBody.hxx +++ b/SHADE_Managed/src/Components/RigidBody.hxx @@ -129,6 +129,11 @@ namespace SHADE { Vector3 get(); } + property bool Interpolating + { + bool get(); + void set(bool value); + } /*-----------------------------------------------------------------------------*/ /* Force Functions */ diff --git a/SHADE_Managed/src/Editor/Editor.cxx b/SHADE_Managed/src/Editor/Editor.cxx index 55fe91da..54200c1e 100644 --- a/SHADE_Managed/src/Editor/Editor.cxx +++ b/SHADE_Managed/src/Editor/Editor.cxx @@ -290,9 +290,14 @@ namespace SHADE { GameObject gameObj = safe_cast(field->GetValue(object)); uint32_t entityId = gameObj.GetEntity(); - if (SHEditorUI::InputGameObjectField(Convert::ToNative(field->Name), entityId, &isHovered)) + if (SHEditorUI::InputGameObjectField(Convert::ToNative(field->Name), entityId, &isHovered, !gameObj)) { GameObject newVal = GameObject(entityId); + if (entityId != MAX_EID) + { + // Null GameObject set + newVal = GameObject(entityId); + } field->SetValue(object, newVal); registerUndoAction(object, field, newVal, gameObj); } @@ -409,19 +414,10 @@ namespace SHADE generic Attribute Editor::hasAttribute(System::Reflection::FieldInfo^ field) { - array^ attributes = field->GetCustomAttributes(true); - for each (System::Object^ attrib in attributes) + array^ attributes = field->GetCustomAttributes(Attribute::typeid, false); + if (attributes->Length > 0) { - try - { - Attribute attribute = safe_cast(attrib); - if (attribute != nullptr) - return attribute; - } - catch (System::InvalidCastException^) - { - continue; - } + return safe_cast(attributes[0]); } // Failed to find return Attribute{}; diff --git a/SHADE_Managed/src/Editor/Editor.hxx b/SHADE_Managed/src/Editor/Editor.hxx index 6b59589a..109842b5 100644 --- a/SHADE_Managed/src/Editor/Editor.hxx +++ b/SHADE_Managed/src/Editor/Editor.hxx @@ -39,10 +39,10 @@ namespace SHADE /// The Entity to render the Scripts of. static void RenderScriptsInInspector(Entity entity); /// - /// Renders a dropdown button that allows for the addition of PlushieScripts - /// onto the specified Entity. + /// Renders a dropdown button that allows for the addition of Scripts onto the + /// specified Entity. /// - /// The Entity to add PlushieScripts to. + /// The Entity to add Scripts to. static void RenderScriptAddButton(Entity entity); /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Engine/ECS.cxx b/SHADE_Managed/src/Engine/ECS.cxx index 3da39394..00c3c182 100644 --- a/SHADE_Managed/src/Engine/ECS.cxx +++ b/SHADE_Managed/src/Engine/ECS.cxx @@ -22,8 +22,8 @@ of DigiPen Institute of Technology is prohibited. // External Dependencies #include "ECS_Base/Managers/SHEntityManager.h" #include "Math/Transform/SHTransformComponent.h" -#include "Physics\Components\SHColliderComponent.h" -#include "Physics\Components\SHRigidBodyComponent.h" +#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Components/SHRigidBodyComponent.h" #include "Scene/SHSceneManager.h" #include "Scene/SHSceneGraph.h" #include "Tools/SHLog.h" @@ -31,10 +31,11 @@ of DigiPen Institute of Technology is prohibited. #include "Utility/Convert.hxx" #include "Utility/Debug.hxx" #include "Components/Transform.hxx" -#include "Components\RigidBody.hxx" -#include "Components\Collider.hxx" +#include "Components/RigidBody.hxx" +#include "Components/Collider.hxx" #include "Components/Camera.hxx" #include "Components/CameraArm.hxx" +#include "Components/Light.hxx" namespace SHADE { @@ -252,6 +253,7 @@ namespace SHADE componentMap.Add(createComponentSet()); componentMap.Add(createComponentSet()); componentMap.Add(createComponentSet()); + componentMap.Add(createComponentSet()); } /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Engine/EngineInterface.hxx b/SHADE_Managed/src/Engine/EngineInterface.hxx index 4fd8f7b3..37ded4eb 100644 --- a/SHADE_Managed/src/Engine/EngineInterface.hxx +++ b/SHADE_Managed/src/Engine/EngineInterface.hxx @@ -20,7 +20,7 @@ namespace SHADE { /// /// Static class that contains the functions for interfacing with the core - /// PlushieEngine written in C++ for managing the lifecycle of managed code. + /// SHADE Engine written in C++ for managing the lifecycle of managed code. /// private ref class EngineInterface abstract sealed { diff --git a/SHADE_Managed/src/Engine/GameObject.cxx b/SHADE_Managed/src/Engine/GameObject.cxx index 7ceabfed..bc17be8b 100644 --- a/SHADE_Managed/src/Engine/GameObject.cxx +++ b/SHADE_Managed/src/Engine/GameObject.cxx @@ -6,9 +6,9 @@ \brief Contains the definition of the functions for the GameObject managed class. Note: This file is written in C++17/CLI. - + Copyright (C) 2021 DigiPen Institute of Technology. -Reproduction or disclosure of this file or its contents without the prior written consent +Reproduction or disclosure of this file or its contents without the prior written consent of DigiPen Institute of Technology is prohibited. *//*************************************************************************************/ // Precompiled Headers @@ -36,10 +36,12 @@ namespace SHADE void GameObject::Destroy(GameObject obj) { + if (!obj.valid) + throw gcnew System::NullReferenceException("Attempted to destroy a null GameObject."); SHEntityManager::DestroyEntity(static_cast(obj.GetEntity())); } - System::Nullable GameObject::Find(System::String ^ name) + System::Nullable GameObject::Find(System::String^ name) { // Search the GameObjectLibrary for an Entity with the specified name const auto ENTITY_ID = SHEntityManager::GetEntityByName(Convert::ToNative(name)); @@ -50,21 +52,27 @@ namespace SHADE return GameObject(ENTITY_ID); } - + /*---------------------------------------------------------------------------------*/ /* Properties */ /*---------------------------------------------------------------------------------*/ System::String^ GameObject::Name::get() { + if (!valid) + throw gcnew System::NullReferenceException(); return Convert::ToCLI(GetNativeEntity().name); - - } + + } bool GameObject::IsActiveSelf::get() { + if (!valid) + throw gcnew System::NullReferenceException(); return GetNativeEntity().GetActive(); } bool GameObject::IsActiveInHierarchy::get() { + if (!valid) + throw gcnew System::NullReferenceException(); auto node = SHSceneManager::GetCurrentSceneGraph().GetNode(GetEntity()); if (!node) { @@ -75,39 +83,49 @@ namespace SHADE } Entity GameObject::EntityId::get() { + if (!valid) + throw gcnew System::NullReferenceException(); return entity; } GameObject^ GameObject::Parent::get() { - const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); - const auto* ROOT = SCENE_GRAPH.GetRoot(); + if (!valid) + throw gcnew System::NullReferenceException(); + const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); + const auto* ROOT = SCENE_GRAPH.GetRoot(); - const auto* NODE = SCENE_GRAPH.GetNode(entity); - if (NODE == nullptr) - throw gcnew System::InvalidOperationException("Unable to retrieve SceneGraphNode for Entity " + entity.ToString()); + const auto* NODE = SCENE_GRAPH.GetNode(entity); + if (NODE == nullptr) + throw gcnew System::InvalidOperationException("Unable to retrieve SceneGraphNode for Entity " + entity.ToString()); - const auto* PARENT = NODE->GetParent(); - return PARENT != ROOT ? gcnew GameObject(PARENT->GetEntityID()) : nullptr; + const auto* PARENT = NODE->GetParent(); + return PARENT != ROOT ? gcnew GameObject(PARENT->GetEntityID()) : nullptr; } void GameObject::Parent::set(GameObject^ newParent) { - const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); + if (!valid) + throw gcnew System::NullReferenceException(); + auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); - if (newParent == nullptr) - SCENE_GRAPH.SetParent(entity, nullptr); - else - SCENE_GRAPH.SetParent(entity, newParent->EntityId); + if (newParent == nullptr) + SCENE_GRAPH.SetParent(entity, nullptr); + else + SCENE_GRAPH.SetParent(entity, newParent->EntityId); } - + /*---------------------------------------------------------------------------------*/ /* GameObject Property Functions */ /*---------------------------------------------------------------------------------*/ void GameObject::SetName(System::String^ name) { + if (!valid) + throw gcnew System::NullReferenceException(); GetNativeEntity().name = Convert::ToNative(name); } void GameObject::SetActive(bool active) { + if (!valid) + throw gcnew System::NullReferenceException(); GetNativeEntity().SetActive(active); } @@ -117,63 +135,83 @@ namespace SHADE generic T GameObject::AddComponent() { + if (!valid) + throw gcnew System::NullReferenceException(); return ECS::AddComponent(entity); } generic T GameObject::GetComponent() { + if (!valid) + throw gcnew System::NullReferenceException(); return ECS::GetComponent(entity); } generic T GameObject::GetComponentInChildren() { + if (!valid) + throw gcnew System::NullReferenceException(); return ECS::GetComponentInChildren(entity); } generic T GameObject::EnsureComponent() { + if (!valid) + throw gcnew System::NullReferenceException(); return ECS::EnsureComponent(entity); } generic void GameObject::RemoveComponent() { + if (!valid) + throw gcnew System::NullReferenceException(); ECS::RemoveComponent(entity); } - + /*---------------------------------------------------------------------------------*/ /* Script Access Functions */ /*---------------------------------------------------------------------------------*/ generic T GameObject::AddScript() { + if (!valid) + throw gcnew System::NullReferenceException(); return ScriptStore::AddScript(entity); } generic T GameObject::GetScript() { + if (!valid) + throw gcnew System::NullReferenceException(); return ScriptStore::GetScript(entity); } generic T GameObject::GetScriptInChildren() { + if (!valid) + throw gcnew System::NullReferenceException(); return ScriptStore::GetScriptInChildren(entity); } generic System::Collections::Generic::IEnumerable^ GameObject::GetScripts() { + if (!valid) + throw gcnew System::NullReferenceException(); return ScriptStore::GetScripts(entity); } generic void GameObject::RemoveScript() { + if (!valid) + throw gcnew System::NullReferenceException(); ScriptStore::RemoveScript(entity); } @@ -181,20 +219,24 @@ namespace SHADE /* Constructors */ /*---------------------------------------------------------------------------------*/ GameObject::GameObject(const SHEntity& entity) - : entity { entity.GetEID() } - , children{ gcnew System::Collections::ArrayList } + : entity{ entity.GetEID() } + , children{ gcnew System::Collections::ArrayList } + , valid{ true } {} GameObject::GameObject(Entity entity) - : entity { entity } - , children{ gcnew System::Collections::ArrayList } + : entity{ entity } + , children{ gcnew System::Collections::ArrayList } + , valid{ true } {} - + /*---------------------------------------------------------------------------------*/ /* Getters */ /*---------------------------------------------------------------------------------*/ SHEntity& GameObject::GetNativeEntity() { + if (!valid) + throw gcnew System::NullReferenceException(); SHEntity* nativeEntity = SHEntityManager::GetEntityByID(entity); if (nativeEntity == nullptr) throw gcnew System::InvalidOperationException("[GameObject] Unable to obtain native Entity for GameObject."); @@ -202,14 +244,22 @@ namespace SHADE return *nativeEntity; } + /*---------------------------------------------------------------------------------*/ + /* Operator Overloads */ + /*---------------------------------------------------------------------------------*/ + GameObject::operator bool(GameObject gameObj) + { + return gameObj.valid; + } + /*---------------------------------------------------------------------------------*/ /* IEquatable */ /*---------------------------------------------------------------------------------*/ bool GameObject::Equals(GameObject other) { - return entity == other.entity; + return (!valid && !other.valid) || entity == other.entity; } - + /*---------------------------------------------------------------------------------*/ /* Object */ /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Engine/GameObject.hxx b/SHADE_Managed/src/Engine/GameObject.hxx index 99296a91..02a0ed4f 100644 --- a/SHADE_Managed/src/Engine/GameObject.hxx +++ b/SHADE_Managed/src/Engine/GameObject.hxx @@ -29,8 +29,9 @@ namespace SHADE /* Class Definitions */ /*---------------------------------------------------------------------------------*/ /// - /// Lightweight object for an PlushieEngine Entity that allows for easy access - /// to Component and Script operations. + /// Lightweight object for an Entity that allows for easy access to Component and + /// Script operations. + /// Can be set to a invalid/null GameObject by default construction. /// public value class GameObject : public System::IEquatable { @@ -98,8 +99,8 @@ namespace SHADE /// property GameObject^ Parent { - GameObject^ get(); - void set(GameObject^); + GameObject^ get(); + void set(GameObject^); } /*-----------------------------------------------------------------------------*/ @@ -209,7 +210,7 @@ namespace SHADE /// /// Removes all Scripts of the specified type from this GameObject. /// - /// Type of PLushieScripts to remove. + /// Type of Scripts to remove. generic where T : ref class, Script void RemoveScript(); @@ -247,12 +248,22 @@ namespace SHADE /// Native Entity object that this GameObject represents. SHEntity& GetNativeEntity(); + /*-----------------------------------------------------------------------------*/ + /* Operator Overloads */ + /*-----------------------------------------------------------------------------*/ + /// + /// Implicit conversion operator to enable checking if a GameObject is valid. + /// + /// GameObjects to check. + static operator bool(GameObject gameObj); + private: /*-----------------------------------------------------------------------------*/ /* Data Members */ /*-----------------------------------------------------------------------------*/ Entity entity; System::Collections::ArrayList^ children; + bool valid; public: /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Graphics/Color.hxx b/SHADE_Managed/src/Graphics/Color.hxx index d6a46216..64152394 100644 --- a/SHADE_Managed/src/Graphics/Color.hxx +++ b/SHADE_Managed/src/Graphics/Color.hxx @@ -25,95 +25,85 @@ namespace SHADE { public: /*-----------------------------------------------------------------------------*/ - /* Type Definitions */ + /* Properties */ /*-----------------------------------------------------------------------------*/ /// - /// A static class that contains a set of default Colors. + /// Pure black. /// - ref class Defaults abstract sealed + static property Color Black { - public: - /*-------------------------------------------------------------------------*/ - /* Properties */ - /*-------------------------------------------------------------------------*/ - /// - /// Pure black. - /// - static property Color Black - { - Color get() { return Color(0.0f, 0.0f, 0.0f); } - } - /// - /// Light Gray, lighter than gray. - /// - static property Color LightGray - { - Color get() { return Color(0.827451f, 0.827451f, 0.827451f); } - } - /// - /// Gray, halfway between black and white. - /// - static property Color Gray - { - Color get() { return Color(0.5f, 0.5f, 0.5f); } - } - /// - /// Dark Gray, darker than gray. - /// - static property Color DarkGray - { - Color get() { return Color(0.622f, 0.622f, 0.622f); } - } - /// - /// Pure white. - /// - static property Color White - { - Color get() { return Color(1.0f, 1.0f, 1.0f); } - } - /// - /// Pure red. - /// - static property Color Red - { - Color get() { return Color(1.0f, 0.0f, 0.0f); } - } - /// - /// Pure green. - /// - static property Color Green - { - Color get() { return Color(0.0f, 1.0f, 0.0f); } - } - /// - /// Pure blue. - /// - static property Color Blue - { - Color get() { return Color(0.0f, 0.0f, 1.0f); } - } - /// - /// Pure cyan, mix of pure green and blue. - /// - static property Color Cyan - { - Color get() { return Color(0.0f, 1.0f, 1.0f); } - } - /// - /// Pure magenta, mix of pure red and blue. - /// - static property Color Magenta - { - Color get() { return Color(1.0f, 0.0f, 1.0f); } - } - /// - /// Pure yellow, mix of pure red and green. - /// - static property Color Yellow - { - Color get() { return Color(1.0f, 1.0f, 0.0f); } - } - }; + Color get() { return Color(0.0f, 0.0f, 0.0f); } + } + /// + /// Light Gray, lighter than gray. + /// + static property Color LightGray + { + Color get() { return Color(0.827451f, 0.827451f, 0.827451f); } + } + /// + /// Gray, halfway between black and white. + /// + static property Color Gray + { + Color get() { return Color(0.5f, 0.5f, 0.5f); } + } + /// + /// Dark Gray, darker than gray. + /// + static property Color DarkGray + { + Color get() { return Color(0.622f, 0.622f, 0.622f); } + } + /// + /// Pure white. + /// + static property Color White + { + Color get() { return Color(1.0f, 1.0f, 1.0f); } + } + /// + /// Pure red. + /// + static property Color Red + { + Color get() { return Color(1.0f, 0.0f, 0.0f); } + } + /// + /// Pure green. + /// + static property Color Green + { + Color get() { return Color(0.0f, 1.0f, 0.0f); } + } + /// + /// Pure blue. + /// + static property Color Blue + { + Color get() { return Color(0.0f, 0.0f, 1.0f); } + } + /// + /// Pure cyan, mix of pure green and blue. + /// + static property Color Cyan + { + Color get() { return Color(0.0f, 1.0f, 1.0f); } + } + /// + /// Pure magenta, mix of pure red and blue. + /// + static property Color Magenta + { + Color get() { return Color(1.0f, 0.0f, 1.0f); } + } + /// + /// Pure yellow, mix of pure red and green. + /// + static property Color Yellow + { + Color get() { return Color(1.0f, 1.0f, 0.0f); } + } /*-----------------------------------------------------------------------------*/ /* Constructors */ diff --git a/SHADE_Managed/src/Math/Vector2.cxx b/SHADE_Managed/src/Math/Vector2.cxx index 42080d60..8242a11c 100644 --- a/SHADE_Managed/src/Math/Vector2.cxx +++ b/SHADE_Managed/src/Math/Vector2.cxx @@ -276,4 +276,4 @@ namespace SHADE { return !(lhs == rhs); } -} // namespace PlushieAPI::Mathematics \ No newline at end of file +} diff --git a/SHADE_Managed/src/Math/Vector3.cxx b/SHADE_Managed/src/Math/Vector3.cxx index 83adbb38..f2286aa7 100644 --- a/SHADE_Managed/src/Math/Vector3.cxx +++ b/SHADE_Managed/src/Math/Vector3.cxx @@ -294,4 +294,4 @@ namespace SHADE { return Vector3(vec); } -} // namespace PlushieAPI::Mathematics \ No newline at end of file +} diff --git a/SHADE_Managed/src/Math/Vector3.hxx b/SHADE_Managed/src/Math/Vector3.hxx index 4cdf653e..189f2930 100644 --- a/SHADE_Managed/src/Math/Vector3.hxx +++ b/SHADE_Managed/src/Math/Vector3.hxx @@ -439,4 +439,5 @@ namespace SHADE /// Vector2 to convert from. static explicit operator Vector3(Vector2 vec); }; -} // namespace PlushieAPI::Mathematics +} + diff --git a/SHADE_Managed/src/Scripts/Script.cxx b/SHADE_Managed/src/Scripts/Script.cxx index e476d69d..9d6cadb8 100644 --- a/SHADE_Managed/src/Scripts/Script.cxx +++ b/SHADE_Managed/src/Scripts/Script.cxx @@ -3,8 +3,7 @@ \author Tng Kah Wei, kahwei.tng, 390009620 \par email: kahwei.tng\@digipen.edu \date Oct 28, 2021 -\brief Contains the definition of the functions for the PlushieScript managed - class. +\brief Contains the definition of the functions for the Script managed class. Note: This file is written in C++17/CLI. @@ -140,6 +139,13 @@ namespace SHADE lateUpdate(); SAFE_NATIVE_CALL_END(this) } + void Script::OnDrawGizmos() + { + SAFE_NATIVE_CALL_BEGIN + OnGizmosDrawOverriden = true; + onDrawGizmos(); + SAFE_NATIVE_CALL_END(this) + } void Script::OnDestroy() { SAFE_NATIVE_CALL_BEGIN @@ -194,6 +200,7 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ Script::Script(GameObject gameObj) : owner { gameObj } + , OnGizmosDrawOverriden { false } {} /*---------------------------------------------------------------------------------*/ @@ -210,6 +217,10 @@ namespace SHADE void Script::fixedUpdate() {} void Script::update() {} void Script::lateUpdate() {} + void Script::onDrawGizmos() + { + OnGizmosDrawOverriden = false; + } void Script::onDestroy() {} /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Scripts/Script.hxx b/SHADE_Managed/src/Scripts/Script.hxx index afeaa8a0..bbe36784 100644 --- a/SHADE_Managed/src/Scripts/Script.hxx +++ b/SHADE_Managed/src/Scripts/Script.hxx @@ -164,6 +164,14 @@ namespace SHADE static operator bool(Script^ s); internal: + /*-----------------------------------------------------------------------------*/ + /* Properties */ + /*-----------------------------------------------------------------------------*/ + /// + /// If true, the OnGizmosDraw function was overridden. + /// + bool OnGizmosDrawOverriden; + /*-----------------------------------------------------------------------------*/ /* "All-Time" Lifecycle Functions */ /*-----------------------------------------------------------------------------*/ @@ -208,6 +216,11 @@ namespace SHADE /// void LateUpdate(); /// + /// Used to call onDrawGizmos(). This should be called just before rendering + /// the scene. This will only be called when working in the editor. + /// + void OnDrawGizmos(); + /// /// Used to call onDestroy(). This should be called at the end of the frame /// where the attached GameObject or this script is destroyed directly or /// indirectly due to destruction of the owner. @@ -308,6 +321,10 @@ namespace SHADE /// virtual void lateUpdate(); /// + /// Called every frame just before rendering but only if working in the editor. + /// + virtual void onDrawGizmos(); + /// /// Called just before the end of the frame where the attached GameObject or /// this script is destroyed directly or indirectly due to destruction of the /// owner. diff --git a/SHADE_Managed/src/Scripts/ScriptStore.cxx b/SHADE_Managed/src/Scripts/ScriptStore.cxx index 407d0fa8..a90b4f12 100644 --- a/SHADE_Managed/src/Scripts/ScriptStore.cxx +++ b/SHADE_Managed/src/Scripts/ScriptStore.cxx @@ -478,6 +478,24 @@ namespace SHADE SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") } + void ScriptStore::ExecuteOnDrawGizmos() + { + SAFE_NATIVE_CALL_BEGIN + for each (System::Collections::Generic::KeyValuePair entity in scripts) + { + // Check active state + if (!isEntityActive(entity.Key)) + continue; + + // Update each script + for each (Script^ script in entity.Value) + { + script->OnDrawGizmos(); + } + } + SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") + } + void ScriptStore::ExecuteCollisionFunctions() { SAFE_NATIVE_CALL_BEGIN diff --git a/SHADE_Managed/src/Scripts/ScriptStore.hxx b/SHADE_Managed/src/Scripts/ScriptStore.hxx index a4c6e824..23440f3d 100644 --- a/SHADE_Managed/src/Scripts/ScriptStore.hxx +++ b/SHADE_Managed/src/Scripts/ScriptStore.hxx @@ -36,7 +36,7 @@ namespace SHADE /// /// /// Type of script to add. - /// This needs to be a default constructable PlushieScript. + /// This needs to be a default constructable Script. /// /// The entity to add a script to. /// Reference to the script added. @@ -234,6 +234,10 @@ namespace SHADE /// static void ExecuteLateUpdate(); /// + /// Executes OnDrawGizmos() for all scripts. + /// + static void ExecuteOnDrawGizmos(); + /// /// Executes OnCollision*() and OnTrigger*() for all scripts. /// static void ExecuteCollisionFunctions(); diff --git a/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx b/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx index 4b4e44fc..651afb73 100644 --- a/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx +++ b/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx @@ -171,7 +171,7 @@ namespace SHADE else if (fieldInfo->FieldType == GameObject::typeid) { GameObject gameObj = safe_cast(fieldInfo->GetValue(object)); - fieldNode = gameObj.GetEntity(); + fieldNode = gameObj ? gameObj.GetEntity() : MAX_EID; } else // Not any of the supported types { @@ -250,7 +250,8 @@ namespace SHADE } else if (fieldInfo->FieldType == GameObject::typeid) { - fieldInfo->SetValue(object, GameObject(node.as())); + const uint32_t EID = node.as(); + fieldInfo->SetValue(object, EID == MAX_EID ? GameObject() : GameObject(EID)); } else // Not any of the supported types { diff --git a/SHADE_Managed/src/Utility/Convert.cxx b/SHADE_Managed/src/Utility/Convert.cxx index 1d89569f..3b1f0f38 100644 --- a/SHADE_Managed/src/Utility/Convert.cxx +++ b/SHADE_Managed/src/Utility/Convert.cxx @@ -72,6 +72,16 @@ namespace SHADE return Ray(ToCLI(vec.position), ToCLI(vec.direction)); } + SHColour Convert::ToNative(Color col) + { + return SHColour(col.r, col.g, col.b, col.a); + } + + Color Convert::ToCLI(const SHColour& vec) + { + return Color(vec.x, vec.y, vec.z, vec.w); + } + /*---------------------------------------------------------------------------------*/ /* String Conversions */ /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Utility/Convert.hxx b/SHADE_Managed/src/Utility/Convert.hxx index d3dca740..666b5062 100644 --- a/SHADE_Managed/src/Utility/Convert.hxx +++ b/SHADE_Managed/src/Utility/Convert.hxx @@ -29,6 +29,8 @@ of DigiPen Institute of Technology is prohibited. #include "Math/Quaternion.hxx" #include "Math/Ray.hxx" #include "Engine/GenericHandle.hxx" +#include "Math/SHColour.h" +#include "Graphics/Color.hxx" namespace SHADE { @@ -104,6 +106,17 @@ namespace SHADE /// The native Vector2 to convert from. /// Managed copy of a native Vector2. static Ray ToCLI(const SHRay& vec); + /// Converts from a managed Color to a native Colour. + /// + /// The managed Color to convert from. + /// Native copy of a managed Color. + static SHColour ToNative(Color col); + /// + /// Converts from a native Colour to a managed Color. + /// + /// The native Colour to convert from. + /// Managed copy of a native Colour. + static Color ToCLI(const SHColour& vec); /*-----------------------------------------------------------------------------*/ /* String Conversions */ diff --git a/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.cxx b/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.cxx index ebf2e987..e19c4d06 100644 --- a/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.cxx +++ b/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.cxx @@ -33,4 +33,4 @@ namespace SHADE { return nullptr; } -} // namespace PlushieAPI \ No newline at end of file +} diff --git a/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.hxx b/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.hxx index 433dd85e..14d612b3 100644 --- a/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.hxx +++ b/SHADE_Managed/src/Utility/DisposableAssemblyLoadContext.hxx @@ -36,4 +36,4 @@ namespace SHADE /*-----------------------------------------------------------------------------*/ System::Reflection::Assembly^ Load(System::Reflection::AssemblyName^ assemblyName) override; }; -} // namespace PlushieAPI \ No newline at end of file +} diff --git a/SHADE_Managed/src/Utility/Gizmos.cxx b/SHADE_Managed/src/Utility/Gizmos.cxx new file mode 100644 index 00000000..21636a5d --- /dev/null +++ b/SHADE_Managed/src/Utility/Gizmos.cxx @@ -0,0 +1,69 @@ +/************************************************************************************//*! +\file Gizmos.cxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 8, 2022 +\brief Contains the definition of the functions for the Convert managed static + class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +// Precompiled Headers +#include "SHpch.h" +// Primary Header +#include "Gizmos.hxx" +#include "Convert.hxx" +#include "Tools/SHDebugDraw.h" +// External Dependencies + +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* Public Properties */ + /*---------------------------------------------------------------------------------*/ + Color Gizmos::Color::get() + { + return defaultColor; + } + void Gizmos::Color::set(SHADE::Color color) + { + defaultColor = color; + } + + /*---------------------------------------------------------------------------------*/ + /* Debug Draw Functions */ + /*---------------------------------------------------------------------------------*/ + void Gizmos::DrawLine(Vector3 from, Vector3 to) + { + DrawLine(from, to, defaultColor); + } + + void Gizmos::DrawLine(Vector3 from, Vector3 to, SHADE::Color color) + { + SHDebugDraw::Line(Convert::ToNative(color), Convert::ToNative(from), Convert::ToNative(to)); + } + + void Gizmos::DrawWireCube(Vector3 center, Vector3 extents) + { + DrawWireCube(center, extents, defaultColor); + } + + void Gizmos::DrawWireCube(Vector3 center, Vector3 extents, SHADE::Color color) + { + SHDebugDraw::Cube(Convert::ToNative(color), Convert::ToNative(center), Convert::ToNative(extents)); + } + + void Gizmos::DrawWireSphere(Vector3 center, float radius) + { + DrawWireSphere(center, radius, defaultColor); + } + + void Gizmos::DrawWireSphere(Vector3 center, float radius, SHADE::Color color) + { + SHDebugDraw::Sphere(Convert::ToNative(color), Convert::ToNative(center), radius); + } +} diff --git a/SHADE_Managed/src/Utility/Gizmos.hxx b/SHADE_Managed/src/Utility/Gizmos.hxx new file mode 100644 index 00000000..1878d867 --- /dev/null +++ b/SHADE_Managed/src/Utility/Gizmos.hxx @@ -0,0 +1,97 @@ +/************************************************************************************//*! +\file Gizmos.hxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 8, 2022 +\brief Contains the definition of the Gizmos static class and the + declaration of its functions. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// Project Includes +#include "Math/Vector3.hxx" +#include "Graphics/Color.hxx" + +namespace SHADE +{ + /// + /// Provides functions for implementing debug drawing. + /// + public value class Gizmos abstract sealed + { + public: + /*-----------------------------------------------------------------------------*/ + /* Public Properties */ + /*-----------------------------------------------------------------------------*/ + /// + /// Default colour that will be used for drawing debug primitives if the color + /// parameter is not specified. + /// + static property Color Color + { + SHADE::Color get(); + void set(SHADE::Color color); + } + /*-----------------------------------------------------------------------------*/ + /* Debug Draw Functions */ + /*-----------------------------------------------------------------------------*/ + /// + /// Renders a line between two points in world space. + /// Uses Color to render. + /// + /// First point of the line. + /// Second point of the line. + static void DrawLine(Vector3 from, Vector3 to); + /// + /// Renders a line between two points in world space. + /// + /// First point of the line. + /// Second point of the line. + /// Colour of the line. + static void DrawLine(Vector3 from, Vector3 to, SHADE::Color color); + /// + /// Renders a wireframe cube centered around the position specified in world + /// space. + /// Uses Color to render. + /// + /// Position where the cube wil be centered at. + /// Size of the rendered cube. + static void DrawWireCube(Vector3 center, Vector3 extents); + /// + /// Renders a wireframe cube centered around the position specified in world + /// space. + /// + /// Position where the cube wil be centered at. + /// Size of the rendered cube. + /// Colour of the cube. + static void DrawWireCube(Vector3 center, Vector3 extents, SHADE::Color color); + /// + /// Renders a wireframe sphere centered around the position specified in world + /// space. + /// Uses Color to render. + /// + /// Position where the sphere wil be centered at. + /// Radius of the rendered sphere. + static void DrawWireSphere(Vector3 center, float radius); + /// + /// Renders a wireframe sphere centered around the position specified in world + /// space. + /// + /// Position where the sphere wil be centered at. + /// Radius of the rendered sphere. + /// Colour of the sphere. + static void DrawWireSphere(Vector3 center, float radius, SHADE::Color color); + + private: + /*-----------------------------------------------------------------------------*/ + /* Data Members */ + /*-----------------------------------------------------------------------------*/ + static SHADE::Color defaultColor = SHADE::Color::White; + }; +} diff --git a/TempShaderFolder/DeferredCompositeCs.glsl b/TempShaderFolder/DeferredCompositeCs.glsl deleted file mode 100644 index c1caf0aa..00000000 --- a/TempShaderFolder/DeferredCompositeCs.glsl +++ /dev/null @@ -1,83 +0,0 @@ -#version 450 - -struct DirectionalLightStruct -{ - vec3 direction; - uint isActive; - uint cullingMask; - vec4 diffuseColor; -}; - -struct AmbientLightStruct -{ - vec4 ambientColor; - float strength; - uint isActive; - uint cullingMask; -}; - -layout(local_size_x = 16, local_size_y = 16) in; -layout(set = 4, binding = 0, rgba32f) uniform image2D positions; -layout(set = 4, binding = 1, rgba32f) uniform image2D normals; -layout(set = 4, binding = 2, rgba8) uniform image2D albedo; -layout(set = 4, binding = 3, r32ui) uniform uimage2D lightLayerData; -layout(set = 4, binding = 4, rgba8) uniform image2D targetImage; - -layout(set = 1, binding = 0) uniform LightCounts -{ - uint directionalLights; - uint pointLights; - uint spotLights; - uint ambientLights; - -} lightCounts; - -layout(std430, set = 1, binding = 1) buffer DirectionalLightData -{ - DirectionalLightStruct dLightData[]; -} DirLightData; - -layout(std430, set = 1, binding = 4) buffer AmbientLightData -{ - AmbientLightStruct aLightData[]; -} AmbLightData; - -void main() -{ - // convenient variables - ivec2 globalThread = ivec2(gl_GlobalInvocationID); - - // Get the diffuse color of the pixel - vec3 pixelDiffuse = imageLoad (albedo, globalThread).rgb; - - // Get position of fragment in world space - vec3 positionWorld = imageLoad (positions, globalThread).rgb; - - // normal of fragment - vec3 normalWorld = imageLoad(normals, globalThread).rgb; - - vec3 fragColor = vec3 (0.0f); - - for (int i = 0; i < lightCounts.directionalLights; ++i) - { - // get normalized direction of light - vec3 dLightNormalized = normalize (DirLightData.dLightData[i].direction); - - // Get diffuse strength - float diffuseStrength = max (0, dot (dLightNormalized, normalWorld)); - - // Calculate the fragment color - fragColor += DirLightData.dLightData[i].diffuseColor.rgb * diffuseStrength.rrr * pixelDiffuse; - } - - for (int i = 0; i < lightCounts.ambientLights; ++i) - { - // Just do some add - //fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (0.5f); - fragColor += pixelDiffuse.rgb * AmbLightData.aLightData[i].ambientColor.rgb * vec3 (AmbLightData.aLightData[i].strength); - } - - // store result into result image - imageStore(targetImage, ivec2(gl_GlobalInvocationID.xy), vec4(fragColor, 1.0f)); - -} \ No newline at end of file diff --git a/TempShaderFolder/DeferredCompositeCs.spv b/TempShaderFolder/DeferredCompositeCs.spv deleted file mode 100644 index 03ef7ac5..00000000 Binary files a/TempShaderFolder/DeferredCompositeCs.spv and /dev/null differ diff --git a/TempShaderFolder/TestCubeFs.spv b/TempShaderFolder/TestCubeFs.spv deleted file mode 100644 index 2381b834..00000000 Binary files a/TempShaderFolder/TestCubeFs.spv and /dev/null differ diff --git a/TempShaderFolder/TestCubeVs.spv b/TempShaderFolder/TestCubeVs.spv deleted file mode 100644 index d8c3c3d0..00000000 Binary files a/TempShaderFolder/TestCubeVs.spv and /dev/null differ diff --git a/bin/Debug/SHADE_CSharp.xml b/bin/Debug/SHADE_CSharp.xml deleted file mode 100644 index daeaa3c5..00000000 --- a/bin/Debug/SHADE_CSharp.xml +++ /dev/null @@ -1,1029 +0,0 @@ - - - - SHADE_CSharp - - - - - Interface for a CallbackAction that all variants inherit from. - - - - - Whether or not this CallbackAction is runtime assigned. If it is, then the - TargetMethodName and TargetObject properties are invalid. - - - - - Name of the method that this CallbackAction is using. - - - - - Object which the specified target method is called on. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 1 parameter. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 2 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 3 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 4 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 5 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 6 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 7 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 8 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 9 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 10 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Interface for a CallbackEvent that all variants inherit from. - - - - - Registers an empty ICallbackAction. - - - - - Registers an ICallbackAction with the event such that it will be called in - future - - ICallbackAction to register with. - - - - Deregisters an ICallbackAction that was previously added. This should - only emit a warning if an action that was not previous added was - provided. - - ICallbackAction to remove. - - - - Iterable set of ICallbackActions that were registered to this event. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - diff --git a/bin/Debug/SHADE_Managed.xml b/bin/Debug/SHADE_Managed.xml deleted file mode 100644 index 7b653116..00000000 --- a/bin/Debug/SHADE_Managed.xml +++ /dev/null @@ -1,6250 +0,0 @@ - - - - "SHADE_Managed" - - - - -Retrieves the duration that the specified key has not been held or was last -not been held for. - - The key to check. - Time in seconds that the key was held. - - - -Retrieves the duration that the specified key has been held or was last held -for. - - The key to check. - Time in seconds that the key was held. - - - -Retrieves the duration that the specified key has not been held or was last -not been held for. - - The key to check. - Time in seconds that the key was held. - - - -Retrieves the duration that the specified key has been held or was last held -for. - - The key to check. - Time in seconds that the key was held. - - - -Sets the position of the mouse cursor relative to the top left corner of the -window. - - -Position of the mouse in window pixel coordinates to set. - - - - -Checks if a specified mouse button is no longer pressed and was pressed -before. - - MouseCode of the mouse button to check. - -True during the frame the user releases the given mouse button. - - - - -Checks if a specified mouse button is pressed and was not pressed before. - - MouseCode of the mouse button to check. - -True during the frame the user pressed the given mouse button. - - - - -Checks if a specified mouse button is being held down. -This will also be true if GetMouseButtonDown() is true. - - MouseCode of the mouse button to check. - True while the user holds down the mouse button specified. - - - -Checks if a specified key is no longer pressed pressed and was pressed -before. - - KeyCode of the key to check. - -True during the frame the user releases the key identified by name. - - - - -Checks if a specified key is pressed and was not pressed before. - - KeyCode of the key to check. - -True during the frame the user starts pressing down the key specified. - - - - -Checks if a specified key is being held down. -This will also be true if GetKeyDown() is true. - - KeyCode of the key to check. - True while the user holds down the key specified. - - - -Amnount of vertical mouse scroll in this frame. - - - - -Mouse position in screen coordinates relative to the top left of the window. -This value is a Vector3 for compatibility with functions that have Vector3 -arguments. The z component of the Vector3 is always 0 - - - - -Represents the available supported mouse keycodes that can be passed into the -mouse-button-based Input functions. - - - - -Represents the available supported keycodes that can be passed into the -key-based Input functions. - -Attempting to follow https://docs.unity3d.com/ScriptReference/KeyCode.html -Win32 keycodes are shift-insensitive, i.e. 'A' and 'a' are the same keycode and '1' and '!' are the same keycode - - - - -Static class responsible for providing access to Input-related functionality. - - - - -Simple attribute to mark that a field in a Script should be serialised. - - - - -Cleans up all required components for managed code. - - - - -Reloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. -Equivalent to calling UnloadScriptAssembly() and then LoadScriptAssembly(). - - - - -Loads the managed script assembly. Ensure this is only called after -UnloadScriptAssembly() has been called. - - - - -Unloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. - - - - -Initialises all required components for managed code. - - - - -Name of the Managed Library that contains the C# scripts written externally. - - - - -Static class that contains the functions for interfacing with the core -PlushieEngine written in C++ for managing the lifecycle of managed code. - - - - -Default Constructor - - - - -Custom AssemblyLoadContext marked as collectible so that it can be unloaded. - - - - -Time taken for Physics simulations. You should use this for operations -within Script.FixedUpdate() - - - - -Time taken to process the previous frame. - - - - -Static class that contains the functions for working with time. - - - - -Static class that wraps up certain functions in the SHPhysicsSystem so that -accessing it from SHADE_Managed would not cause issues due to C++20 features. - - - - -Constructor for a Tooltip attribute that fills in the description. - - Text to be shown when a field is hovered. - - - -Description that is to be shown in the Tooltip. - - - - -Simple attribute to provide a field in a script with a tooltip. - - - - -Checks if a specified file exists. - - File path to the file to check. - True if the file exists - - - -Deletes the folder and all files in it as specified by the file path. - - File path to the file to delete. - - - -Deletes the file as specified by the file path. - - File path to the file to delete. - - - -Reads the file via the specified path that represents a build log of error -and warning messages. - - -File path to the build log of script builds done by BuildScriptAssembly() to -dump and process. - - - - -Registers events for the scripting system - - - - -Loads all the function pointers to CLR code that we need to execute. - - - - -Generates a .csproj file for editing and compiling the C# scripts. - - File path to the generated file. - - - -Utilises execution of a external batch file for invoking the dotnet build -tool to compile C# scripts in the Assets folder into the SHADE_Scripting -C# assembly DLL. - - -Whether or not a debug build will be built. Only debug built C# assemblies -can be debugged. - - -Whether or not we are reloading the assembly, if so, unload and then reload it. - - Whether or not the build succeeded. - - - -Performs a redo for script inspector changes if it exists. - - - - -Performs an undo for script inspector changes if it exists. - - - - -Renders the set of attached Scripts for the specified Entity into the -inspector. -
-This function is meant for consumption from native code in the inspector -rendering code. - - The Entity to render the Scripts of. - - - -Creates scripts and sets fields for the specified Entity based on the specified -YAML node. - - The Entity to deserialise a Script on to. - -YAML Node that contains the serialised script data. - - True if successfully deserialised. - - - -Performs serialization of all scripts for the specified entity into the -YAML::Node specified. This node will contain all serialised scripts after -calling this function. - - The Entity to Serialise. - -YAML Node that will store the serialised scripts. - - True if successfully serialised. - - - -Removes all Scripts attached to the specified Entity. Unlike -RemoveAllScripts(), this removes all the scripts immediately. -Does not do anything if the specified Entity is invalid or does not have any -Scripts attached. - - The entity to remove the scripts from. - -Whether or not to call OnDestroy on the scripts. This is ignored if not in -play mode. - - - - -Removes all Scripts attached to the specified Entity. Does not do anything -if the specified Entity is invalid or does not have any Scripts -attached. - - The entity to remove the scripts from. - - - -Adds a Script to a specified Entity. Note that while you can call this -multiple times on a specified Entity, it will work for all intents and -purposes but GetScript<T>() (C# only) currently only -gives you the first Script added of the specified type. - - The entity to add a script to. - Type name of the script to add. - -True if successfully added. False otherwise with the error logged to the -console. - - - - -Shuts down the DotNetRuntime. - - - - -Executes the OnCollision*()s and OnTrigger*()s of the Scripts that are attached -to Entities. - - - - -Executes the FixedUpdate()s of the Scripts that are attached to -Entities. - - - - -Reloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. - - - - -Unloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. - - - - -Loads the managed script assembly. Ensure this is only called after -UnloadScriptAssembly() has been called. - - - - -Initialises the DotNetRuntime and retrieves function pointers to all -functions on the CLR used to interface with the engine. - - - - -Manages initialisation of the DotNetRuntime and interfacing with CLR code written -and executed on .NET. - - - - -Deserialises a YAML node that contains a map of Scripts and copies the -deserialised data into the specified object if there are matching fields. - - -The JSON string that contains the data to copy into this Script object. - - The object to copy deserialised data into. - - - -Creates a JSON node that represents the specified object and its associated -serialisable fields. Public fields and fields marked with the SerialiseField -attribute will be serialised. - - The object to serialise. - - - -Checks if a specified field is a candidate for serialisation. This means that -the field is public or private with the [SerialiseField] attribute. - - The field to check. - -True if the specified field is a candidate for serialisation. - - - - -Retrieves a set of all non-static (instance) fields from a specified object. - - The object to get non-static fields from. - Immutable list of non-static fields. - - - -Contains useful static functions for working with Reflection. - - - -Converts the node to a YAML string. - - -Emits the node to the given output stream. - - -Emits the node to the given {@link Emitter}. If there is an error in writing, -{@link Emitter#good} will return false. - - - - Loads the input file as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - @throws {@link BadFile} if the file cannot be loaded. - - - - Loads the input stream as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input file as a single YAML document. - - @throws {@link ParserException} if it is malformed. - @throws {@link BadFile} if the file cannot be loaded. - - - - Loads the input stream as a single YAML document. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a single YAML document. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a single YAML document. - - @throws {@link ParserException} if it is malformed. - - - -Handles a "TAG" directive, which should be of the form 'handle prefix', -where 'handle' is converted to 'prefix' in the file. - - - -Handles a "YAML" directive, which should be of the form 'major.minor' (like -a version number). - - - -Reads any directives that are next in the queue, setting the internal -{@code m_pDirectives} state. - - - - Handles the next document by calling events on the {@code eventHandler}. - - @throw a ParserException on error. - @return false if there are no more documents - - - -Resets the parser with the given input stream. Any existing state is -erased. - - - -Evaluates to true if the parser has some valid input to be read. - - -Constructs a parser from the given input stream. The input stream must -live as long as the parser. - - - -Constructs an empty parser (with no input. - - -A parser turns a stream of bytes into one stream of "events" per YAML -document in the input stream. - - - - -Renders a context menu when right clicked for the scripts - - The Entity to render the Scripts of. - The Script to render the inspector for. - - - -Renders a field specified into the inspector. - - The field to render. - -The object that contains the data of the field to render. - - - - -Renders a single specified Script's inspector. - - The Entity to render the Scripts of. - The Script to render the inspector for. - -Indices used internally to differentiate each rendered Script -inspector. This is required to open and close each Script's inspector -independently from each other. - - - - -Redoes the last script inspector change if there is any. - - - - -Undoes the last script inspector change if there is any. - - - - -Renders a dropdown button that allows for the addition of PlushieScripts -onto the specified Entity. - - The Entity to add PlushieScripts to. - - - -Renders the set of attached Scripts for the specified Entity into the -inspector. -
-This function is meant for consumption from native code in the inspector -rendering code. - - The Entity to render the Scripts of. - - - -Static class for Editor-related functions - - - - -Processes a YAML node that contains a list of multiple scripts to be loaded -into the specified Entity. -

-This function should only be called from native unmanaged code. - - -The Entity to attach the deserialised Scripts to. - - -Pointer to the YAML::Node that contains serialized script data. - - - - - -Populates a YAML node with the scripts for a specified Entity. -

-This function should only be called from native unmanaged code. - - The Entity to Serialise. - -Pointer to a YAML::Node that will be populated with all of the serialised -scripts and their associated fields. - - -True if serialisation is successful. False if the buffer is too small for -the serialised output. - - - - -Executes OnCollision*() and OnTrigger*() for all scripts. - - - - -Executes LateUpdate() for all scripts. - - - - -Executes Update() for all scripts. - - - - -Executes FixedUpdate() for all scripts. - - - - -Retrieves a immutable list of available scripts that can be added. - - Immutable list of available scripts that can be added. - - - -Cleans up data stored in the ScriptStore to free up memory for garbage -collection. - - - - -Cleans up scripts that were marked for deletion. This calls the OnDestroy() -for these Scripts. - - - - -Sets up scripts that were marked for initialization. This calls the Awake() -and Start() for Scripts that have yet to have done so. - - - - -Initializes the ScriptStore to allocate and pre-populate reflection data. - - - - -Removes all Scripts attached to the specified Entity. Unlike -RemoveAllScripts(), this removes all the scripts immediately. -Does not do anything if the specified Entity is invalid or does not have any -Scripts attached. - - The entity to remove the scripts from. - -Whether or not to call OnDestroy on the scripts.This is ignored if not in -play mode. - - - - -Removes all Scripts attached to the specified Entity. Does not do anything -if the specified Entity is invalid or does not have any Scripts -attached. - - The entity to remove the scripts from. - - - -Removes a specific script from the - - The entity to remove the script from. - The script to remove. - True if successfully removed. False otherwise. - - - -Removes all Scripts of the specified type from the specified Entity. - - -Type of script to remove. -This needs to be a default constructable Script. - - The entity to remove the script from. - -If the specified Entity is invalid. - - - - -Retrieves an immutable list of all scripts attached to a specified Entity. - - -The entity which the scripts to retrieve are attached. - - -Immutable list of references to scripts attached to the specified Entity. -This can also be null if there are no scripts at all or an invalid Entity -was specified. - - - - -Retrieves a immutable list of scripts from the specified Entity that -matches the specified type. -
-Note that this function allocates. It should be used sparingly. - - -Type of scripts to get. -This needs to be a default constructable Script. - - -The entity which the scripts to retrieve are attached. - - -Immutable list of references to scripts of the specified type. - - - - -Retrieves the first Script from the specified Entity's children that matches -the specified type. - - -Type of script to get. -This needs to be a default constructable Script. - - -The entity which the script to retrieve is attached. - - -Reference to the script. This can be null if no script of the specified -type is attached. - - -If the specified Entity is invalid. - - - - -Retrieves the first Script from the specified Entity that matches the -specified type. - - -Type of script to get. -This needs to be a default constructable Script. - - -The entity which the script to retrieve is attached. - - -Reference to the script. This can be null if no script of the specified -type is attached. - - -If the specified Entity is invalid. - - - - -Adds a Script to a specified Entity. -
-This function is meant for consumption from native code or for serialisation -purposes. If you are writing in C# or C++/CLI and not doing serialisation, -use AddScript<T>() instead as it is faster. - - The entity to add a script to. - The entity to add a script to. - -Out parameter handle to the Script that was created. - - -True if successfully added. False otherwise with the error logged to the -console. - - - - -Adds a Script to a specified Entity. -
-This function is meant for consumption from native code. If you are writing -in C# or C++/CLI, use AddScript<T>() instead as it is faster. - - The entity to add a script to. - The entity to add a script to. - -True if successfully added. False otherwise with the error logged to the -console. - - - - -Adds a Script to a specified Entity. - - -Type of script to add. -This needs to be a default constructable PlushieScript. - - The entity to add a script to. - Reference to the script added. - -If the specified Entity is invalid. - - - - -Responsible for managing all scripts attached to Entities as well as executing -all lifecycle functions of scripts. - - - - -Checks if two Colors are not approximately equal. - - Color to compare. - Another Color to compare. - -True if all components are not approximately equal within the default -tolerance value. - - - - -Checks if two Colors are approximately equal. - - Color to compare. - Another Color to compare. - -True if all components are approximately equal within the default -tolerance value. - - - - -Calculates the division of a Color with a scalar value and returns -the result. - - Scalar to divide with. - Color to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Color with a scalar value and returns -the result. - - Color to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the component-wise multiplication of two Colors and returns the -result. - - Color to multiply with. - Another Color to multiply with. - The result of rhs subtracted from lhs. - - - -Subtracts a Color from another Color and returns the result. - - Color to subtract from. - Another Color to subtract. - The result of rhs subtracted from lhs. - - - -Adds two Colors together and returns the result. - - Color to add. - Another Color to add. - The result of lhs added to rhs - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. -Unlike Lerp(), t is not clamped to a range at all. - - The start Color, returned when t = 0.0. - The end Color, returned when t = 1.0. - Value used to interpolate between a and b. - The interpolated Color. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. - - The start Color, returned when t = 0.0. - The end Color, returned when t = 1.0. - -Value used to interpolate between a and b which is clamped to -the range[0, 1]. - - The interpolated Vector3. - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Alpha component of the colour. Ranges from 0.0f to 1.0f. - - - - -Blue component of the colour. Ranges from 0.0f to 1.0f. - - - - -Green component of the colour. Ranges from 0.0f to 1.0f. - - - - -Red component of the colour. Ranges from 0.0f to 1.0f. - - - - -Constructor to construct a Color with the specified components. - - Red component to set. - Green component to set. - Blue component to set. - Alpha component to set. - - - -Constructor to construct a Color with the specified components with the -alpha component set to 1.0f. - - Red component to set. - Green component to set. - Blue component to set. - - - -Constructor to construct a Color with the specified components with the -blue and alpha component set to 1.0f. - - Red component to set. - Green component to set. - - - -Constructor to construct a Color with the specified components with the -green, blue and alpha component set to 1.0f. - - Red component to set. - - - -Pure yellow, mix of pure red and green. - - - - -Pure magenta, mix of pure red and blue. - - - - -Pure cyan, mix of pure green and blue. - - - - -Pure blue. - - - - -Pure green. - - - - -Pure red. - - - - -Pure white. - - - - -Dark Gray, darker than gray. - - - - -Gray, halfway between black and white. - - - - -Light Gray, lighter than gray. - - - - -Pure black. - - - - -A static class that contains a set of default Colors. - - - - -CLR version of the the SHADE Engine's Color struct which describes a Color -encoded using floating point numbers that range from 0.0f to 1.0f. - - - - -Creates a inline button widget. -
-Wraps up ImGui::Button(). - - Text to display. - True if button was pressed. - - - -Creates a small inline button widget. -
-Wraps up ImGui::SmallButton(). - - Text to display. - True if button was pressed. - - - -Creates a visual text widget. -
-Wraps up ImGui::Text(). - - Text to display. - - - -Creates a menu item in the list of items for a mini popup. -
-Wraps up ImGui::MenuItem(). - - Label used to identify this widget. - Whether or not the menu item was selected. - - - -Opens the popup that was defined with the specified label. -
-Wraps up ImGui::OpenPopup(). - - - - -Marks the end of a definition of a mini pop up that can show options. -
-Wraps up ImGui::EndPopup(). - - - - -Marks the start of a definition of a mini pop up that can show options. -
-Wraps up ImGui::BeginPopup(). - - Label used to identify this widget. - Whether or not the pop up is open. - - - -Creates a collapsing title header. -
-Wraps up ImGui::CollapsingHeader(). - - Label for the header. - True if the header is open, false otherwise. - - - -Unindents the widgets rendered after this call. -
-Wraps up ImGui::Unindent(). - - - - -Indents the widgets rendered after this call. -
-Wraps up ImGui::Indent(). - - - - -Marks the end of a stack of ImGui widgets from the last PushID() call. -
-Wraps up ImGui::PopID(). - - - - -Marks the start of a stack of ImGui widgets with the specified id. -
-Wraps up ImGui::PushID(). - - Integer-based ID. - - - -Marks the start of a stack of ImGui widgets with the specified id. -
-Wraps up ImGui::PushID(). - - String-based ID. - - - -Maximum length of a string supported by InputTextField() - - - - -Static class that contains useful functions for Editor UI using ImGui. - - - - -Redoes the last undo-ed command if it exists. - - - - -Undos the last added command if it exists. - - - - -Adds a command onto the stack. - - - - - -True if there is a redoable action in the stack. - - - - -True if there is an undoable action in the stack. - - - - -Command for the stack that represents a data modification. - - - - -Class that is able to store a stack of actions that can be done and redone. - - - - -To be called from native code when a Collision Shape has been changed. - - -The entity which has it's collision shape changed. - - - - -To be called from native code when a collision shape has been removed. - - The entity which has it's collision shape removed. - - - -Retrieves a ColliderBound at the specified index in the ColliderBound list -and casts it to the appropriate type. - - Type of the ColliderBound to cast to. - Index to retrieve a ColliderBound from. - ColliderBound for the specified index. - - - -Retrieves a ColliderBound at the specified index in the ColliderBound list. - - Index to retrieve a ColliderBound from. - ColliderBound for the specified index. - - - -Total number of ColliderShapes in the Collider component. - - - - -Constructs a Collider Component that represents a native SHColliderComponent -component tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the the SHADE Engine's SHColliderComponent. -A single Collider component can contain one or multiple Collider Bounds. - - - - - - - - - - -Radius of the Bounding Sphere formed by this bound. - - - - -Center of the Bounding Sphere formed by this bound. - - - - -Sphere-shaped Collider Bound. - - - - - - - - - - -Position of the top right front corner of the Bounding Box formed by this -bound. - - - - -Position of the bottom left back corner of the Bounding Box formed by this -bound. - - - - -Half of the scale of the Bounding Box formed by this bound. - - - - -Center of the Bounding Box formed by this bound. - - - - -Box-shaped Collider Bound. - - - - -Computes a Raycast and checks if there is a collision with any object. - - The ray to cast. - Maximum distance for the raycast check. - True if the ray intersects with an object in the scene. - - - -Checks if the specified point is within this shape's bounds. - - Point to test with. - True if the point is in the shape's bounds. - - - -Base interface for all Collider Shapes. - - - -@brief The density of the collider that determines the mass of the collision shape - if it is automatically computed. Must be a positive number. - - - -@brief The bounciness factor of the physics object., clamped between [0,1].
- 0 means the object will never bounce. - 1 means the object never loses energy on a bounce. - - - -@brief The friction coefficient of the physics object., clamped between [0,1].
- 0 means the object will never experience friction. - 1 means the friction force against the object is equal to the applied force. - - - -@brief Sets the mass density of the physics material. -@param newDensity The density value to set. Always made positive. - - - -@brief Sets the bounciness factor of the physics material. -@param newBounciness The bounciness value to set. Clamped between [0,1]. - - - -@brief Sets the friction coefficient of the physics material. -@param newFriction The friction value to set. Clamped between [0,1]. - - - -@brief Default constructor for a physics material. -@param friction The friction of the material. Clamped between [0,1]. Defaults to 0.4. -@param bounciness The bounciness of the material. Clamped between [0,1]. -@param density The mass density of the material. Always made positive. - - - - -Closes the current window, and depending on the implementation, should also -close the application. - - - - -Retrieves the current window fullscreen status. - - The current window fullscreen status.. - - - -Retrieves the current window height. - - The current window height. - - - -Retrieves the current window width. - - The current window width. - - - -Static class that wraps up certain functions in the SHGraphicsSystem so that -accessing it from SHADE_Managed would not cause issues due to C++20 features. - - - - @brief Perform ImGui and ImGui Backend Render - - - - - @brief Start new frame for editor - - - - - @brief Initialise Backend for ImGui (SDL and Vulkan backend) - - @param sdlWindow Pointer to SDL_Window - - - - @brief Set the Style for the editor - - @param style Desired style - - - - @brief Safely shutdown the editor - - - - - @brief Update the editor and add to ImGui DrawList - - @param dt Delta-time of the frame - - - - @brief Initialise the editor - - @param sdlWindow pointer to SDL_Window object created in application - - - - @brief Style options - - - - - @brief SHEditor static class contains editor variables and implementation of editor functions. - - - - - Get the YUV conversion mode, returning the correct mode for the resolution - when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC - - \since This function is available since SDL 2.0.8. - - - - Get the YUV conversion mode - - \since This function is available since SDL 2.0.8. - - - - Set the YUV conversion mode - - \since This function is available since SDL 2.0.8. - - - - Perform low-level surface scaled blitting only. - - This is a semi-private function and it performs low-level surface blitting, - assuming the input rectangles have already been clipped. - - \param src the SDL_Surface structure to be copied from - \param srcrect the SDL_Rect structure representing the rectangle to be - copied - \param dst the SDL_Surface structure that is the blit target - \param dstrect the SDL_Rect structure representing the rectangle that is - copied into - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitScaled - - - - Perform a scaled surface copy to a destination surface. - - SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is - merely a macro for this function with a less confusing name. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitScaled - - - - Perform bilinear scaling between two surfaces of the same format, 32BPP. - - \since This function is available since SDL 2.0.16. - - - - Perform a fast, low quality, stretch blit between two surfaces of the same - format. - - Please use SDL_BlitScaled() instead. - - \since This function is available since SDL 2.0.0. - - - - Perform low-level surface blitting only. - - This is a semi-private blit function and it performs low-level surface - blitting, assuming the input rectangles have already been clipped. - - Unless you know what you're doing, you should be using SDL_BlitSurface() - instead. - - \param src the SDL_Surface structure to be copied from - \param srcrect the SDL_Rect structure representing the rectangle to be - copied, or NULL to copy the entire surface - \param dst the SDL_Surface structure that is the blit target - \param dstrect the SDL_Rect structure representing the rectangle that is - copied into - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - - - - * Performs a fast blit from the source surface to the destination surface. - * - * This assumes that the source and destination rectangles are - * the same size. If either \c srcrect or \c dstrect are NULL, the entire - * surface (\c src or \c dst) is copied. The final blit rectangles are saved - * in \c srcrect and \c dstrect after all clipping is performed. - * - * \returns 0 if the blit is successful, otherwise it returns -1. - * - * The blit function should not be called on a locked surface. - * - * The blit semantics for surfaces with and without blending and colorkey - * are defined as follows: - * \verbatim - RGBA->RGB: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source alpha-channel and per-surface alpha) - SDL_SRCCOLORKEY ignored. - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy RGB. - if SDL_SRCCOLORKEY set, only copy the pixels matching the - RGB values of the source color key, ignoring alpha in the - comparison. - - RGB->RGBA: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source per-surface alpha) - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy RGB, set destination alpha to source per-surface alpha value. - both: - if SDL_SRCCOLORKEY set, only copy the pixels matching the - source color key. - - RGBA->RGBA: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source alpha-channel and per-surface alpha) - SDL_SRCCOLORKEY ignored. - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy all of RGBA to the destination. - if SDL_SRCCOLORKEY set, only copy the pixels matching the - RGB values of the source color key, ignoring alpha in the - comparison. - - RGB->RGB: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source per-surface alpha) - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy RGB. - both: - if SDL_SRCCOLORKEY set, only copy the pixels matching the - source color key. - \endverbatim - * - * You should call SDL_BlitSurface() unless you know exactly how SDL - * blitting works internally and how to use the other blit functions. - - Perform a fast blit from the source surface to the destination surface. - - SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a - macro for this function with a less confusing name. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - - - - Perform a fast fill of a set of rectangles with a specific color. - - `color` should be a pixel of the format used by the surface, and can be - generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an - alpha component then the destination is simply filled with that alpha - information, no blending takes place. - - If there is a clip rectangle set on the destination (set via - SDL_SetClipRect()), then this function will fill based on the intersection - of the clip rectangle and `rect`. - - \param dst the SDL_Surface structure that is the drawing target - \param rects an array of SDL_Rects representing the rectangles to fill. - \param count the number of rectangles in the array - \param color the color to fill with - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FillRect - - - - Perform a fast fill of a rectangle with a specific color. - - `color` should be a pixel of the format used by the surface, and can be - generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an - alpha component then the destination is simply filled with that alpha - information, no blending takes place. - - If there is a clip rectangle set on the destination (set via - SDL_SetClipRect()), then this function will fill based on the intersection - of the clip rectangle and `rect`. - - \param dst the SDL_Surface structure that is the drawing target - \param rect the SDL_Rect structure representing the rectangle to fill, or - NULL to fill the entire surface - \param color the color to fill with - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FillRects - - - - Premultiply the alpha on a block of pixels. - - This is safe to use with src == dst, but not for other overlapping areas. - - This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888. - - \param width the width of the block to convert, in pixels - \param height the height of the block to convert, in pixels - \param src_format an SDL_PixelFormatEnum value of the `src` pixels format - \param src a pointer to the source pixels - \param src_pitch the pitch of the source pixels, in bytes - \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format - \param dst a pointer to be filled in with premultiplied pixel data - \param dst_pitch the pitch of the destination pixels, in bytes - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.18. - - - - Copy a block of pixels of one format to another format. - - \param width the width of the block to copy, in pixels - \param height the height of the block to copy, in pixels - \param src_format an SDL_PixelFormatEnum value of the `src` pixels format - \param src a pointer to the source pixels - \param src_pitch the pitch of the source pixels, in bytes - \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format - \param dst a pointer to be filled in with new pixel data - \param dst_pitch the pitch of the destination pixels, in bytes - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - - - Copy an existing surface to a new surface of the specified format enum. - - This function operates just like SDL_ConvertSurface(), but accepts an - SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such, - it might be easier to call but it doesn't have access to palette - information for the destination surface, in case that would be important. - - \param src the existing SDL_Surface structure to convert - \param pixel_format the SDL_PixelFormatEnum that the new surface is - optimized for - \param flags the flags are unused and should be set to 0; this is a - leftover from SDL 1.2's API - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocFormat - \sa SDL_ConvertSurface - \sa SDL_CreateRGBSurface - - - - Copy an existing surface to a new surface of the specified format. - - This function is used to optimize images for faster *repeat* blitting. This - is accomplished by converting the original and storing the result as a new - surface. The new, optimized surface can then be used as the source for - future blits, making them faster. - - \param src the existing SDL_Surface structure to convert - \param fmt the SDL_PixelFormat structure that the new surface is optimized - for - \param flags the flags are unused and should be set to 0; this is a - leftover from SDL 1.2's API - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocFormat - \sa SDL_ConvertSurfaceFormat - \sa SDL_CreateRGBSurface - - - - Get the clipping rectangle for a surface. - - When `surface` is the destination of a blit, only the area within the clip - rectangle is drawn into. - - \param surface the SDL_Surface structure representing the surface to be - clipped - \param rect an SDL_Rect structure filled in with the clipping rectangle for - the surface - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_SetClipRect - - - - Set the clipping rectangle for a surface. - - When `surface` is the destination of a blit, only the area within the clip - rectangle is drawn into. - - Note that blits are automatically clipped to the edges of the source and - destination surfaces. - - \param surface the SDL_Surface structure to be clipped - \param rect the SDL_Rect structure representing the clipping rectangle, or - NULL to disable clipping - \returns SDL_TRUE if the rectangle intersects the surface, otherwise - SDL_FALSE and blits will be completely clipped. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_GetClipRect - - - - Get the blend mode used for blit operations. - - \param surface the SDL_Surface structure to query - \param blendMode a pointer filled in with the current SDL_BlendMode - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_SetSurfaceBlendMode - - - - Set the blend mode used for blit operations. - - To copy a surface to another surface (or texture) without blending with the - existing data, the blendmode of the SOURCE surface should be set to - `SDL_BLENDMODE_NONE`. - - \param surface the SDL_Surface structure to update - \param blendMode the SDL_BlendMode to use for blit blending - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceBlendMode - - - - Get the additional alpha value used in blit operations. - - \param surface the SDL_Surface structure to query - \param alpha a pointer filled in with the current alpha value - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceColorMod - \sa SDL_SetSurfaceAlphaMod - - - - Set an additional alpha value used in blit operations. - - When this surface is blitted, during the blit operation the source alpha - value is modulated by this alpha value according to the following formula: - - `srcA = srcA * (alpha / 255)` - - \param surface the SDL_Surface structure to update - \param alpha the alpha value multiplied into blit operations - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceAlphaMod - \sa SDL_SetSurfaceColorMod - - - - Get the additional color value multiplied into blit operations. - - \param surface the SDL_Surface structure to query - \param r a pointer filled in with the current red color value - \param g a pointer filled in with the current green color value - \param b a pointer filled in with the current blue color value - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceAlphaMod - \sa SDL_SetSurfaceColorMod - - - - Set an additional color value multiplied into blit operations. - - When this surface is blitted, during the blit operation each source color - channel is modulated by the appropriate color value according to the - following formula: - - `srcC = srcC * (color / 255)` - - \param surface the SDL_Surface structure to update - \param r the red color value multiplied into blit operations - \param g the green color value multiplied into blit operations - \param b the blue color value multiplied into blit operations - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceColorMod - \sa SDL_SetSurfaceAlphaMod - - - - Get the color key (transparent pixel) for a surface. - - The color key is a pixel of the format used by the surface, as generated by - SDL_MapRGB(). - - If the surface doesn't have color key enabled this function returns -1. - - \param surface the SDL_Surface structure to query - \param key a pointer filled in with the transparent pixel - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_SetColorKey - - - - Returns whether the surface has a color key - - It is safe to pass a NULL `surface` here; it will return SDL_FALSE. - - \param surface the SDL_Surface structure to query - \return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.9. - - \sa SDL_SetColorKey - \sa SDL_GetColorKey - - - - Set the color key (transparent pixel) in a surface. - - The color key defines a pixel value that will be treated as transparent in - a blit. For example, one can use this to specify that cyan pixels should be - considered transparent, and therefore not rendered. - - It is a pixel of the format used by the surface, as generated by - SDL_MapRGB(). - - RLE acceleration can substantially speed up blitting of images with large - horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details. - - \param surface the SDL_Surface structure to update - \param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key - \param key the transparent pixel - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_GetColorKey - - - - Returns whether the surface is RLE enabled - - It is safe to pass a NULL `surface` here; it will return SDL_FALSE. - - \param surface the SDL_Surface structure to query - \returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.14. - - \sa SDL_SetSurfaceRLE - - - - Save a surface to a file. - - Convenience macro. - - Set the RLE acceleration hint for a surface. - - If RLE is enabled, color key and alpha blending blits are much faster, but - the surface must be locked before directly accessing the pixels. - - \param surface the SDL_Surface structure to optimize - \param flag 0 to disable, non-zero to enable RLE acceleration - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_LockSurface - \sa SDL_UnlockSurface - - - - Load a surface from a file. - - Convenience macro. - - Save a surface to a seekable SDL data stream in BMP format. - - Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the - BMP directly. Other RGB formats with 8-bit or higher get converted to a - 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit - surface before they are saved. YUV and paletted 1-bit and 4-bit formats are - not supported. - - \param surface the SDL_Surface structure containing the image to be saved - \param dst a data stream to save to - \param freedst non-zero to close the stream after being written - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_LoadBMP_RW - \sa SDL_SaveBMP - - - - Load a BMP image from a seekable SDL data stream. - - The new surface should be freed with SDL_FreeSurface(). Not doing so will - result in a memory leak. - - src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile. - Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap - from a file, convert it to an SDL_Surface and then close the file. - - \param src the data stream for the surface - \param freesrc non-zero to close the stream after being read - \returns a pointer to a new SDL_Surface structure or NULL if there was an - error; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreeSurface - \sa SDL_RWFromFile - \sa SDL_LoadBMP - \sa SDL_SaveBMP_RW - - - - Release a surface after directly accessing the pixels. - - \param surface the SDL_Surface structure to be unlocked - - \since This function is available since SDL 2.0.0. - - \sa SDL_LockSurface - - - - Set up a surface for directly accessing the pixels. - - Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to - and read from `surface->pixels`, using the pixel format stored in - `surface->format`. Once you are done accessing the surface, you should use - SDL_UnlockSurface() to release it. - - Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to - 0, then you can read and write to the surface at any time, and the pixel - format of the surface will not change. - - \param surface the SDL_Surface structure to be locked - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_MUSTLOCK - \sa SDL_UnlockSurface - - - - Set the palette used by a surface. - - A single palette can be shared with many surfaces. - - \param surface the SDL_Surface structure to update - \param palette the SDL_Palette structure to use - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - - - Free an RGB surface. - - It is safe to pass NULL to this function. - - \param surface the SDL_Surface to free. - - \since This function is available since SDL 2.0.0. - - \sa SDL_CreateRGBSurface - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_LoadBMP - \sa SDL_LoadBMP_RW - - - - Allocate a new RGB surface with with a specific pixel format and existing - pixel data. - - This function operates mostly like SDL_CreateRGBSurfaceFrom(), except - instead of providing pixel color masks, you provide it with a predefined - format from SDL_PixelFormatEnum. - - No copy is made of the pixel data. Pixel data is not managed automatically; - you must free the surface before you free the pixel data. - - \param pixels a pointer to existing pixel data - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param pitch the pitch of the surface in bytes - \param format the SDL_PixelFormatEnum for the new surface's pixel format. - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.5. - - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_CreateRGBSurfaceWithFormat - \sa SDL_FreeSurface - - - - Allocate a new RGB surface with existing pixel data. - - This function operates mostly like SDL_CreateRGBSurface(), except it does - not allocate memory for the pixel data, instead the caller provides an - existing buffer of data for the surface to use. - - No copy is made of the pixel data. Pixel data is not managed automatically; - you must free the surface before you free the pixel data. - - \param pixels a pointer to existing pixel data - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param pitch the pitch of the surface in bytes - \param Rmask the red mask for the pixels - \param Gmask the green mask for the pixels - \param Bmask the blue mask for the pixels - \param Amask the alpha mask for the pixels - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_CreateRGBSurface - \sa SDL_CreateRGBSurfaceWithFormat - \sa SDL_FreeSurface - - - - Allocate a new RGB surface with a specific pixel format. - - This function operates mostly like SDL_CreateRGBSurface(), except instead - of providing pixel color masks, you provide it with a predefined format - from SDL_PixelFormatEnum. - - \param flags the flags are unused and should be set to 0 - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param format the SDL_PixelFormatEnum for the new surface's pixel format. - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.5. - - \sa SDL_CreateRGBSurface - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_FreeSurface - - - - Allocate a new RGB surface. - - If `depth` is 4 or 8 bits, an empty palette is allocated for the surface. - If `depth` is greater than 8 bits, the pixel format is set using the - [RGBA]mask parameters. - - The [RGBA]mask parameters are the bitmasks used to extract that color from - a pixel. For instance, `Rmask` being 0xFF000000 means the red data is - stored in the most significant byte. Using zeros for the RGB masks sets a - default value, based on the depth. For example: - - ```c++ - SDL_CreateRGBSurface(0,w,h,32,0,0,0,0); - ``` - - However, using zero for the Amask results in an Amask of 0. - - By default surfaces with an alpha mask are set up for blending as with: - - ```c++ - SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND) - ``` - - You can change this by calling SDL_SetSurfaceBlendMode() and selecting a - different `blendMode`. - - \param flags the flags are unused and should be set to 0 - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param Rmask the red mask for the pixels - \param Gmask the green mask for the pixels - \param Bmask the blue mask for the pixels - \param Amask the alpha mask for the pixels - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_CreateRGBSurfaceWithFormat - \sa SDL_FreeSurface - - - -Reference count -- used when freeing surface - - -info for fast blit mapping to other surfaces - - -clipping information - - -list of BlitMap that hold a reference to this surface - - -information needed for surfaces requiring locks - - -Application data associated with the surface - - - \brief A collection of pixels used in software blitting. - - \note This structure should be treated as read-only, except for \c pixels, - which, if not NULL, contains the raw pixel data for the surface. - - -\brief The type of function used for surface blitting functions. - - - - Compose a custom blend mode for renderers. - - The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept - the SDL_BlendMode returned by this function if the renderer supports it. - - A blend mode controls how the pixels from a drawing operation (source) get - combined with the pixels from the render target (destination). First, the - components of the source and destination pixels get multiplied with their - blend factors. Then, the blend operation takes the two products and - calculates the result that will get stored in the render target. - - Expressed in pseudocode, it would look like this: - - ```c - dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor); - dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor); - ``` - - Where the functions `colorOperation(src, dst)` and `alphaOperation(src, - dst)` can return one of the following: - - - `src + dst` - - `src - dst` - - `dst - src` - - `min(src, dst)` - - `max(src, dst)` - - The red, green, and blue components are always multiplied with the first, - second, and third components of the SDL_BlendFactor, respectively. The - fourth component is not used. - - The alpha component is always multiplied with the fourth component of the - SDL_BlendFactor. The other components are not used in the alpha - calculation. - - Support for these blend modes varies for each renderer. To check if a - specific SDL_BlendMode is supported, create a renderer and pass it to - either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will - return with an error if the blend mode is not supported. - - This list describes the support of custom blend modes for each renderer in - SDL 2.0.6. All renderers support the four blend modes listed in the - SDL_BlendMode enumeration. - - - **direct3d**: Supports all operations with all factors. However, some - factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and - `SDL_BLENDOPERATION_MAXIMUM`. - - **direct3d11**: Same as Direct3D 9. - - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all - factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL - 2.0.6. - - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all - factors. Color and alpha factors need to be the same. OpenGL ES 1 - implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT` - and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha - operations being different from each other. May support color and alpha - factors being different from each other. - - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`, - `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT` - operations with all factors. - - **psp**: No custom blend mode support. - - **software**: No custom blend mode support. - - Some renderers do not provide an alpha component for the default render - target. The `SDL_BLENDFACTOR_DST_ALPHA` and - `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this - case. - - \param srcColorFactor the SDL_BlendFactor applied to the red, green, and - blue components of the source pixels - \param dstColorFactor the SDL_BlendFactor applied to the red, green, and - blue components of the destination pixels - \param colorOperation the SDL_BlendOperation used to combine the red, - green, and blue components of the source and - destination pixels - \param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of - the source pixels - \param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of - the destination pixels - \param alphaOperation the SDL_BlendOperation used to combine the alpha - component of the source and destination pixels - \returns an SDL_BlendMode that represents the chosen factors and - operations. - - \since This function is available since SDL 2.0.6. - - \sa SDL_SetRenderDrawBlendMode - \sa SDL_GetRenderDrawBlendMode - \sa SDL_SetTextureBlendMode - \sa SDL_GetTextureBlendMode - - - - Calculate the intersection of a rectangle and line segment with float - precision. - - This function is used to clip a line segment to a rectangle. A line segment - contained entirely within the rectangle or that does not intersect will - remain unchanged. A line segment that crosses the rectangle at either or - both ends will be clipped to the boundary of the rectangle and the new - coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary. - - \param rect an SDL_FRect structure representing the rectangle to intersect - \param X1 a pointer to the starting X-coordinate of the line - \param Y1 a pointer to the starting Y-coordinate of the line - \param X2 a pointer to the ending X-coordinate of the line - \param Y2 a pointer to the ending Y-coordinate of the line - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.22. - - - - Calculate a minimal rectangle enclosing a set of points with float - precision. - - If `clip` is not NULL then only points inside of the clipping rectangle are - considered. - - \param points an array of SDL_FPoint structures representing points to be - enclosed - \param count the number of structures in the `points` array - \param clip an SDL_FRect used for clipping or NULL to enclose all points - \param result an SDL_FRect structure filled in with the minimal enclosing - rectangle - \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the - points were outside of the clipping rectangle. - - \since This function is available since SDL 2.0.22. - - - - Calculate the union of two rectangles with float precision. - - \param A an SDL_FRect structure representing the first rectangle - \param B an SDL_FRect structure representing the second rectangle - \param result an SDL_FRect structure filled in with the union of rectangles - `A` and `B` - - \since This function is available since SDL 2.0.22. - - - - Calculate the intersection of two rectangles with float precision. - - If `result` is NULL then this function will return SDL_FALSE. - - \param A an SDL_FRect structure representing the first rectangle - \param B an SDL_FRect structure representing the second rectangle - \param result an SDL_FRect structure filled in with the intersection of - rectangles `A` and `B` - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.22. - - \sa SDL_HasIntersectionF - - - - Determine whether two rectangles intersect with float precision. - - If either pointer is NULL the function will return SDL_FALSE. - - \param A an SDL_FRect structure representing the first rectangle - \param B an SDL_FRect structure representing the second rectangle - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.22. - - \sa SDL_IntersectRect - - - - Returns true if the two rectangles are equal, using a default epsilon. - - \since This function is available since SDL 2.0.22. - - - - Returns true if the two rectangles are equal, within some given epsilon. - - \since This function is available since SDL 2.0.22. - - - -Returns true if the rectangle has no area. - - - -Returns true if point resides inside a rectangle. - - - - Calculate the intersection of a rectangle and line segment. - - This function is used to clip a line segment to a rectangle. A line segment - contained entirely within the rectangle or that does not intersect will - remain unchanged. A line segment that crosses the rectangle at either or - both ends will be clipped to the boundary of the rectangle and the new - coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary. - - \param rect an SDL_Rect structure representing the rectangle to intersect - \param X1 a pointer to the starting X-coordinate of the line - \param Y1 a pointer to the starting Y-coordinate of the line - \param X2 a pointer to the ending X-coordinate of the line - \param Y2 a pointer to the ending Y-coordinate of the line - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.0. - - - - Calculate a minimal rectangle enclosing a set of points. - - If `clip` is not NULL then only points inside of the clipping rectangle are - considered. - - \param points an array of SDL_Point structures representing points to be - enclosed - \param count the number of structures in the `points` array - \param clip an SDL_Rect used for clipping or NULL to enclose all points - \param result an SDL_Rect structure filled in with the minimal enclosing - rectangle - \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the - points were outside of the clipping rectangle. - - \since This function is available since SDL 2.0.0. - - - - Calculate the union of two rectangles. - - \param A an SDL_Rect structure representing the first rectangle - \param B an SDL_Rect structure representing the second rectangle - \param result an SDL_Rect structure filled in with the union of rectangles - `A` and `B` - - \since This function is available since SDL 2.0.0. - - - - Calculate the intersection of two rectangles. - - If `result` is NULL then this function will return SDL_FALSE. - - \param A an SDL_Rect structure representing the first rectangle - \param B an SDL_Rect structure representing the second rectangle - \param result an SDL_Rect structure filled in with the intersection of - rectangles `A` and `B` - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.0. - - \sa SDL_HasIntersection - - - - Determine whether two rectangles intersect. - - If either pointer is NULL the function will return SDL_FALSE. - - \param A an SDL_Rect structure representing the first rectangle - \param B an SDL_Rect structure representing the second rectangle - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.0. - - \sa SDL_IntersectRect - - - -Returns true if the two rectangles are equal. - - - -Returns true if the rectangle has no area. - - - -Returns true if point resides inside a rectangle. - - - - A rectangle, with the origin at the upper left (floating point). - - \sa SDL_FRectEmpty - \sa SDL_FRectEquals - \sa SDL_FRectEqualsEpsilon - \sa SDL_HasIntersectionF - \sa SDL_IntersectFRect - \sa SDL_IntersectFRectAndLine - \sa SDL_UnionFRect - \sa SDL_EncloseFPoints - \sa SDL_PointInFRect - - - - A rectangle, with the origin at the upper left (integer). - - \sa SDL_RectEmpty - \sa SDL_RectEquals - \sa SDL_HasIntersection - \sa SDL_IntersectRect - \sa SDL_IntersectRectAndLine - \sa SDL_UnionRect - \sa SDL_EnclosePoints - - - - The structure that defines a point (floating point) - - \sa SDL_EncloseFPoints - \sa SDL_PointInFRect - - - - Use this function to write 64 bits in native format to a SDL_RWops as - big-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in big-endian format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteLE64 - - - - Use this function to write 64 bits in native format to a SDL_RWops as - little-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in little-endian - format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteBE64 - - - - Use this function to write 32 bits in native format to a SDL_RWops as - big-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in big-endian format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteLE32 - - - - Use this function to write 32 bits in native format to a SDL_RWops as - little-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in little-endian - format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteBE32 - - - - Use this function to write 16 bits in native format to a SDL_RWops as - big-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in big-endian format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteLE16 - - - - Use this function to write 16 bits in native format to a SDL_RWops as - little-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in little-endian - format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteBE16 - - - - \name Write endian functions - - Write an item of native format to the specified endianness. - - Use this function to write a byte to an SDL_RWops. - - \param dst the SDL_RWops to write to - \param value the byte value to write - \returns 1 on success or 0 on failure; call SDL_GetError() for more - information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadU8 - - - - Use this function to read 64 bits of big-endian data from an SDL_RWops and - return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 64 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadLE64 - - - - Use this function to read 64 bits of little-endian data from an SDL_RWops - and return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 64 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadBE64 - - - - Use this function to read 32 bits of big-endian data from an SDL_RWops and - return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 32 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadLE32 - - - - Use this function to read 32 bits of little-endian data from an SDL_RWops - and return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 32 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadBE32 - - - - Use this function to read 16 bits of big-endian data from an SDL_RWops and - return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 16 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadLE16 - - - - Use this function to read 16 bits of little-endian data from an SDL_RWops - and return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 16 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadBE16 - - - - \name Read endian functions - - Read an item of the specified endianness and return in native format. - - Use this function to read a byte from an SDL_RWops. - - \param src the SDL_RWops to read from - \returns the read byte on success or 0 on failure; call SDL_GetError() for - more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteU8 - - - - Load all the data from a file path. - - The data is allocated with a zero byte at the end (null terminated) for - convenience. This extra byte is not included in the value reported via - `datasize`. - - The data should be freed with SDL_free(). - - Prior to SDL 2.0.10, this function was a macro wrapping around - SDL_LoadFile_RW. - - \param file the path to read all available data from - \param datasize if not NULL, will store the number of bytes read - \returns the data, or NULL if there was an error. - - \since This function is available since SDL 2.0.10. - - - - Load all the data from an SDL data stream. - - The data is allocated with a zero byte at the end (null terminated) for - convenience. This extra byte is not included in the value reported via - `datasize`. - - The data should be freed with SDL_free(). - - \param src the SDL_RWops to read all available data from - \param datasize if not NULL, will store the number of bytes read - \param freesrc if non-zero, calls SDL_RWclose() on `src` before returning - \returns the data, or NULL if there was an error. - - \since This function is available since SDL 2.0.6. - - - - Close and free an allocated SDL_RWops structure. - - SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any - resources used by the stream and frees the SDL_RWops itself with - SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to - flush to its output (e.g. to disk). - - Note that if this fails to flush the stream to disk, this function reports - an error, but the SDL_RWops is still invalid once this function returns. - - Prior to SDL 2.0.10, this function was a macro. - - \param context SDL_RWops structure to close - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWwrite - - - - Write to an SDL_RWops data stream. - - This function writes exactly `num` objects each of size `size` from the - area pointed at by `ptr` to the stream. If this fails for any reason, it'll - return less than `num` to demonstrate how far the write progressed. On - success, it returns `num`. - - SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's - `write` method appropriately, to simplify application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a pointer to an SDL_RWops structure - \param ptr a pointer to a buffer containing data to write - \param size the size of an object to write, in bytes - \param num the number of objects to write - \returns the number of objects written, which will be less than **num** on - error; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - - - - Read from a data source. - - This function reads up to `maxnum` objects each of size `size` from the - data source to the area pointed at by `ptr`. This function may read less - objects than requested. It will return zero when there has been an error or - the data stream is completely read. - - SDL_RWread() is actually a function wrapper that calls the SDL_RWops's - `read` method appropriately, to simplify application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a pointer to an SDL_RWops structure - \param ptr a pointer to a buffer to read data into - \param size the size of each object to read, in bytes - \param maxnum the maximum number of objects to be read - \returns the number of objects read, or 0 at error or end of file; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWseek - \sa SDL_RWwrite - - - - Determine the current read/write offset in an SDL_RWops data stream. - - SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek` - method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify - application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a SDL_RWops data stream object from which to get the current - offset - \returns the current offset in the stream, or -1 if the information can not - be determined. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWwrite - - - - Seek within an SDL_RWops data stream. - - This function seeks to byte `offset`, relative to `whence`. - - `whence` may be any of the following values: - - - `RW_SEEK_SET`: seek from the beginning of data - - `RW_SEEK_CUR`: seek relative to current read point - - `RW_SEEK_END`: seek relative to the end of data - - If this stream can not seek, it will return -1. - - SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's - `seek` method appropriately, to simplify application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a pointer to an SDL_RWops structure - \param offset an offset in bytes, relative to **whence** location; can be - negative - \param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END` - \returns the final offset in the data stream after the seek or -1 on error. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWtell - \sa SDL_RWwrite - - - - Use this function to get the size of the data stream in an SDL_RWops. - - Prior to SDL 2.0.10, this function was a macro. - - \param context the SDL_RWops to get the size of the data stream from - \returns the size of the data stream in the SDL_RWops on success, -1 if - unknown or a negative error code on failure; call SDL_GetError() - for more information. - - \since This function is available since SDL 2.0.10. - - - - Use this function to free an SDL_RWops structure allocated by - SDL_AllocRW(). - - Applications do not need to use this function unless they are providing - their own SDL_RWops implementation. If you just need a SDL_RWops to - read/write a common data source, you should use the built-in - implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and - call the **close** method on those SDL_RWops pointers when you are done - with them. - - Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is - invalid as soon as this function returns. Any extra memory allocated during - creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must - be responsible for managing that memory in their **close** method. - - \param area the SDL_RWops structure to be freed - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocRW - - - - Use this function to allocate an empty, unpopulated SDL_RWops structure. - - Applications do not need to use this function unless they are providing - their own SDL_RWops implementation. If you just need a SDL_RWops to - read/write a common data source, you should use the built-in - implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc. - - You must free the returned pointer with SDL_FreeRW(). Depending on your - operating system and compiler, there may be a difference between the - malloc() and free() your program uses and the versions SDL calls - internally. Trying to mix the two can cause crashing such as segmentation - faults. Since all SDL_RWops must free themselves when their **close** - method is called, all SDL_RWops must be allocated through this function, so - they can all be freed correctly with SDL_FreeRW(). - - \returns a pointer to the allocated memory on success, or NULL on failure; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreeRW - - - - Use this function to prepare a read-only memory buffer for use with RWops. - - This function sets up an SDL_RWops struct based on a memory area of a - certain size. It assumes the memory area is not writable. - - Attempting to write to this RWops stream will report an error without - writing to the memory buffer. - - This memory buffer is not copied by the RWops; the pointer you provide must - remain valid until you close the stream. Closing the stream will not free - the original buffer. - - If you need to write to a memory buffer, you should use SDL_RWFromMem() - with a writable buffer of memory instead. - - \param mem a pointer to a read-only buffer to feed an SDL_RWops stream - \param size the buffer size, in bytes - \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - - - - Use this function to prepare a read-write memory buffer for use with - SDL_RWops. - - This function sets up an SDL_RWops struct based on a memory area of a - certain size, for both read and write access. - - This memory buffer is not copied by the RWops; the pointer you provide must - remain valid until you close the stream. Closing the stream will not free - the original buffer. - - If you need to make sure the RWops never writes to the memory buffer, you - should use SDL_RWFromConstMem() with a read-only buffer of memory instead. - - \param mem a pointer to a buffer to feed an SDL_RWops stream - \param size the buffer size, in bytes - \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - \sa SDL_RWwrite - - - - Use this function to create an SDL_RWops structure from a standard I/O file - pointer (stdio.h's `FILE*`). - - This function is not available on Windows, since files opened in an - application on that platform cannot be used by a dynamically linked - library. - - On some platforms, the first parameter is a `void*`, on others, it's a - `FILE*`, depending on what system headers are available to SDL. It is - always intended to be the `FILE*` type from the C runtime's stdio.h. - - \param fp the `FILE*` that feeds the SDL_RWops stream - \param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops, - SDL_FALSE to leave the `FILE*` open when the RWops is - closed - \returns a pointer to the SDL_RWops structure that is created, or NULL on - failure; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - \sa SDL_RWwrite - - - - \name RWFrom functions - - Functions to create SDL_RWops structures from various data streams. - - Use this function to create a new SDL_RWops structure for reading from - and/or writing to a named file. - - The `mode` string is treated roughly the same as in a call to the C - library's fopen(), even if SDL doesn't happen to use fopen() behind the - scenes. - - Available `mode` strings: - - - "r": Open a file for reading. The file must exist. - - "w": Create an empty file for writing. If a file with the same name - already exists its content is erased and the file is treated as a new - empty file. - - "a": Append to a file. Writing operations append data at the end of the - file. The file is created if it does not exist. - - "r+": Open a file for update both reading and writing. The file must - exist. - - "w+": Create an empty file for both reading and writing. If a file with - the same name already exists its content is erased and the file is - treated as a new empty file. - - "a+": Open a file for reading and appending. All writing operations are - performed at the end of the file, protecting the previous content to be - overwritten. You can reposition (fseek, rewind) the internal pointer to - anywhere in the file for reading, but writing operations will move it - back to the end of file. The file is created if it does not exist. - - **NOTE**: In order to open a file as a binary file, a "b" character has to - be included in the `mode` string. This additional "b" character can either - be appended at the end of the string (thus making the following compound - modes: "rb", "wb", "ab", "r+b", "w+b", "a+b") or be inserted between the - letter and the "+" sign for the mixed modes ("rb+", "wb+", "ab+"). - Additional characters may follow the sequence, although they should have no - effect. For example, "t" is sometimes appended to make explicit the file is - a text file. - - This function supports Unicode filenames, but they must be encoded in UTF-8 - format, regardless of the underlying operating system. - - As a fallback, SDL_RWFromFile() will transparently open a matching filename - in an Android app's `assets`. - - Closing the SDL_RWops will close the file handle SDL is holding internally. - - \param file a UTF-8 string representing the filename to open - \param mode an ASCII string representing the mode to be used for opening - the file. - \returns a pointer to the SDL_RWops structure that is created, or NULL on - failure; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - \sa SDL_RWwrite - - - -Return the size of the file in this rwops, or -1 if unknown - - - Seek to \c offset relative to \c whence, one of stdio's whence values: - RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END - - \return the final offset in the data stream, or -1 on error. - - - Read up to \c maxnum objects each of size \c size from the data - stream to the area pointed at by \c ptr. - - \return the number of objects read, or 0 at error or end of file. - - - Write exactly \c num objects each of size \c size from the area - pointed at by \c ptr to data stream. - - \return the number of objects written, or 0 at error or end of file. - - - Close and free an allocated SDL_RWops structure. - - \return 0 if successful or -1 on write error when flushing data. - - - - Clear any previous error message for this thread. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetError - \sa SDL_SetError - - - - Get the last error message that was set for the current thread. - - This allows the caller to copy the error string into a provided buffer, but - otherwise operates exactly the same as SDL_GetError(). - - \param errstr A buffer to fill with the last error message that was set for - the current thread - \param maxlen The size of the buffer pointed to by the errstr parameter - \returns the pointer passed in as the `errstr` parameter. - - \since This function is available since SDL 2.0.14. - - \sa SDL_GetError - - - - Retrieve a message about the last error that occurred on the current - thread. - - It is possible for multiple errors to occur before calling SDL_GetError(). - Only the last error is returned. - - The message is only applicable when an SDL function has signaled an error. - You must check the return values of SDL function calls to determine when to - appropriately call SDL_GetError(). You should *not* use the results of - SDL_GetError() to decide if an error has occurred! Sometimes SDL will set - an error string even when reporting success. - - SDL will *not* clear the error string for successful API calls. You *must* - check return values for failure cases before you can assume the error - string applies. - - Error strings are set per-thread, so an error set in a different thread - will not interfere with the current thread's operation. - - The returned string is internally allocated and must not be freed by the - application. - - \returns a message with information about the specific error that occurred, - or an empty string if there hasn't been an error message set since - the last call to SDL_ClearError(). The message is only applicable - when an SDL function has signaled an error. You must check the - return values of SDL function calls to determine when to - appropriately call SDL_GetError(). - - \since This function is available since SDL 2.0.0. - - \sa SDL_ClearError - \sa SDL_SetError - - - - Calculate a 256 entry gamma ramp for a gamma value. - - \param gamma a gamma value where 0.0 is black and 1.0 is identity - \param ramp an array of 256 values filled in with the gamma ramp - - \since This function is available since SDL 2.0.0. - - \sa SDL_SetWindowGammaRamp - - - - Get RGBA values from a pixel in the specified format. - - This function uses the entire 8-bit [0..255] range when converting color - components from pixel formats with less than 8-bits per RGB component - (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, - 0xff, 0xff] not [0xf8, 0xfc, 0xf8]). - - If the surface has no alpha component, the alpha will be returned as 0xff - (100% opaque). - - \param pixel a pixel value - \param format an SDL_PixelFormat structure describing the format of the - pixel - \param r a pointer filled in with the red component - \param g a pointer filled in with the green component - \param b a pointer filled in with the blue component - \param a a pointer filled in with the alpha component - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGB - \sa SDL_MapRGB - \sa SDL_MapRGBA - - - - Get RGB values from a pixel in the specified format. - - This function uses the entire 8-bit [0..255] range when converting color - components from pixel formats with less than 8-bits per RGB component - (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, - 0xff, 0xff] not [0xf8, 0xfc, 0xf8]). - - \param pixel a pixel value - \param format an SDL_PixelFormat structure describing the format of the - pixel - \param r a pointer filled in with the red component - \param g a pointer filled in with the green component - \param b a pointer filled in with the blue component - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGBA - \sa SDL_MapRGB - \sa SDL_MapRGBA - - - - Map an RGBA quadruple to a pixel value for a given pixel format. - - This function maps the RGBA color value to the specified pixel format and - returns the pixel value best approximating the given RGBA color value for - the given pixel format. - - If the specified pixel format has no alpha component the alpha value will - be ignored (as it will be in formats with a palette). - - If the format has a palette (8-bit) the index of the closest matching color - in the palette will be returned. - - If the pixel format bpp (color depth) is less than 32-bpp then the unused - upper bits of the return value can safely be ignored (e.g., with a 16-bpp - format the return value can be assigned to a Uint16, and similarly a Uint8 - for an 8-bpp format). - - \param format an SDL_PixelFormat structure describing the format of the - pixel - \param r the red component of the pixel in the range 0-255 - \param g the green component of the pixel in the range 0-255 - \param b the blue component of the pixel in the range 0-255 - \param a the alpha component of the pixel in the range 0-255 - \returns a pixel value - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGB - \sa SDL_GetRGBA - \sa SDL_MapRGB - - - - Map an RGB triple to an opaque pixel value for a given pixel format. - - This function maps the RGB color value to the specified pixel format and - returns the pixel value best approximating the given RGB color value for - the given pixel format. - - If the format has a palette (8-bit) the index of the closest matching color - in the palette will be returned. - - If the specified pixel format has an alpha component it will be returned as - all 1 bits (fully opaque). - - If the pixel format bpp (color depth) is less than 32-bpp then the unused - upper bits of the return value can safely be ignored (e.g., with a 16-bpp - format the return value can be assigned to a Uint16, and similarly a Uint8 - for an 8-bpp format). - - \param format an SDL_PixelFormat structure describing the pixel format - \param r the red component of the pixel in the range 0-255 - \param g the green component of the pixel in the range 0-255 - \param b the blue component of the pixel in the range 0-255 - \returns a pixel value - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGB - \sa SDL_GetRGBA - \sa SDL_MapRGBA - - - - Free a palette created with SDL_AllocPalette(). - - \param palette the SDL_Palette structure to be freed - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocPalette - - - - Set a range of colors in a palette. - - \param palette the SDL_Palette structure to modify - \param colors an array of SDL_Color structures to copy into the palette - \param firstcolor the index of the first palette entry to modify - \param ncolors the number of entries to modify - \returns 0 on success or a negative error code if not all of the colors - could be set; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocPalette - \sa SDL_CreateRGBSurface - - - - Set the palette for a pixel format structure. - - \param format the SDL_PixelFormat structure that will use the palette - \param palette the SDL_Palette structure that will be used - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocPalette - \sa SDL_FreePalette - - - - Create a palette structure with the specified number of color entries. - - The palette entries are initialized to white. - - \param ncolors represents the number of color entries in the color palette - \returns a new SDL_Palette structure on success or NULL on failure (e.g. if - there wasn't enough memory); call SDL_GetError() for more - information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreePalette - - - - Free an SDL_PixelFormat structure allocated by SDL_AllocFormat(). - - \param format the SDL_PixelFormat structure to free - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocFormat - - - - Create an SDL_PixelFormat structure corresponding to a pixel format. - - Returned structure may come from a shared global cache (i.e. not newly - allocated), and hence should not be modified, especially the palette. Weird - errors such as `Blit combination not supported` may occur. - - \param pixel_format one of the SDL_PixelFormatEnum values - \returns the new SDL_PixelFormat structure or NULL on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreeFormat - - - - Convert a bpp value and RGBA masks to an enumerated pixel format. - - This will return `SDL_PIXELFORMAT_UNKNOWN` if the conversion wasn't - possible. - - \param bpp a bits per pixel value; usually 15, 16, or 32 - \param Rmask the red mask for the format - \param Gmask the green mask for the format - \param Bmask the blue mask for the format - \param Amask the alpha mask for the format - \returns one of the SDL_PixelFormatEnum values - - \since This function is available since SDL 2.0.0. - - \sa SDL_PixelFormatEnumToMasks - - - - Convert one of the enumerated pixel formats to a bpp value and RGBA masks. - - \param format one of the SDL_PixelFormatEnum values - \param bpp a bits per pixel value; usually 15, 16, or 32 - \param Rmask a pointer filled in with the red mask for the format - \param Gmask a pointer filled in with the green mask for the format - \param Bmask a pointer filled in with the blue mask for the format - \param Amask a pointer filled in with the alpha mask for the format - \returns SDL_TRUE on success or SDL_FALSE if the conversion wasn't - possible; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_MasksToPixelFormatEnum - - - - Get the human readable name of a pixel format. - - \param format the pixel format to query - \returns the human readable name of the specified pixel format or - `SDL_PIXELFORMAT_UNKNOWN` if the format isn't recognized. - - \since This function is available since SDL 2.0.0. - - - -\note Everything in the pixel format structure is read-only. - - - -The bits of this structure can be directly reinterpreted as an integer-packed -color which uses the SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888 -on little-endian systems and SDL_PIXELFORMAT_RGBA8888 on big-endian systems). - - - - If a + b would overflow, return -1. Otherwise store a + b via ret - and return 0. - - \since This function is available since SDL 2.24.0. - - - - If a * b would overflow, return -1. Otherwise store a * b via ret - and return 0. - - \since This function is available since SDL 2.24.0. - - - - This function converts a string between encodings in one pass, returning a - string that must be freed with SDL_free() or NULL on error. - - \since This function is available since SDL 2.0.0. - - - - Get the number of outstanding (unfreed) allocations - - \since This function is available since SDL 2.0.7. - - - - Replace SDL's memory allocation functions with a custom set - - \since This function is available since SDL 2.0.7. - - - - Get the current set of SDL memory functions - - \since This function is available since SDL 2.0.7. - - - - Get the original set of SDL memory functions - - \since This function is available since SDL 2.24.0. - - - -\endcond - \file begin_code.h - - This file sets things up for C dynamic library function definitions, - static inlined functions, and structures aligned at 4-byte alignment. - If you don't like ugly C preprocessor code, don't look at this file. :) - - - -\name Floating-point constants - -\cond - - -\brief An unsigned 64-bit integer type. - - - -\brief A signed 64-bit integer type. - - - -\brief An unsigned 32-bit integer type. - - - -\brief A signed 32-bit integer type. - - - -\brief An unsigned 16-bit integer type. - - - -\brief A signed 16-bit integer type. - - - -\brief An unsigned 8-bit integer type. - - - -\brief A signed 8-bit integer type. - - - - \file close_code.h - - This file reverses the effects of begin_code.h and should be included - after you finish any function and structure declarations in your headers - - - - \file SDL_stdinc.h - - This is a general header that includes C language support. - - \file SDL_platform.h - - Try to get a standard set of platform defines. - - \file begin_code.h - - This file sets things up for C dynamic library function definitions, - static inlined functions, and structures aligned at 4-byte alignment. - If you don't like ugly C preprocessor code, don't look at this file. :) - - Get the name of the platform. - - Here are the names returned for some (but not all) supported platforms: - - - "Windows" - - "Mac OS X" - - "Linux" - - "iOS" - - "Android" - - \returns the name of the platform. If the correct platform name is not - available, returns a string beginning with the text "Unknown". - - \since This function is available since SDL 2.0.0. - - - -*!************************************************************************* - - - -Marks the application to stop at the end of the current frame. - - - - -Whether or not the application is currently in fullscreen mode or not. - - - - -Retrieves the designated height of the current window. - - - - -Retrieves the designated width of the current window. - - - - -Whether or not the engine is in a paused state where script updates and -physics are not in play. - - - - -Whether or not the engine is playing. This will always be true on Publish. -On Debug/Release builds, this is true when the editor is in Play Mode. It -will also be true even if the editor is in Play Mode but is paused. - - - - -Static class that contains useful properties for querying the state of the -engine. - - - - -Sets the parent of this Transform component. - - -Entity that contains the Transform component that this Transform will be -parented to. If null, unparenting will occur. - - -If true, the transform values of this Transform component will retain their -pre-parent-change global transforms. The local transform values will be -modified to ensure that the global transforms do not change. - - - - -Parent Transform that affects this Transform. - - - - -Global scale stored by this Transform. - - - - -Global euler angle rotations stored by this Transform. - - - - -Global rotation quaternion stored by this Transform. - - - - -Global position stored by this Transform. - - - - -Local scale stored by this Transform. - - - - -Local euler angle rotations stored by this Transform. - - - - -Local rotation quaternion stored by this Transform. - - - - -Local position stored by this Transform. - - - - -Constructs a Transform Component that represents a native Transform component -tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the SHADE Engine's TransformComponent. - - - - -Compares if two float values are close enough to be the same with the -specified tolerance value. - - One of the values to compare. - The other value to compare. - Tolerance for floating point comparison. - True if a and b are practically the same. - - - -Compares if two float values are close enough to be the same with a tolerance -of Epsilon. - - One of the values to compare. - The other value to compare. - True if a and b are practically the same. - - - -Calculates the linear parameter t that produces the interpolant value within -the range [a, b]. - - Start value. - End value. - Value between start and end. - Percentage of value between start and end. - - - -Linearly interpolates between a and b by t. -The parameter t is not clamped and a value based on a and b is supported. -If t is less than zero, or greater than one, then LerpUnclamped will result -in a return value outside the range a to b. - - The start value. - The end value. - The interpolation value between the two float. - The interpolated float result between the two float values. - - - -Linearly interpolates between a and b by t. -The parameter t is clamped to the range [0, 1]. - - The start value. - The end value. - The interpolation value between the two float. - The interpolated float result between the two float values. - - - -Converts an angle from radian representation to degree representation. - - Radian-based angle to convert. - The specified angle in degrees. - - - -Converts an angle from degree representation to radian representation. - - Degree-based angle to convert. - The specified angle in radians. - - - -Wraps a value if they get to low or too high. - - Value to wrap. - Minimum value to wrap at. - Maximum value to wrap at. - Wrapped value. - - - -Small value used for single precision floating point comparisons. - - - - -Radians-to-degrees conversion constant - - - - -Degrees-to-radians conversion constant - - - - -Contains utility Math functions. - - - - -Logs a native exception that is formatted nicely to the output. - - Native exception to log. - Name of the one responsible for the exception. - - - -Logs an exception that is formatted nicely to the output. - - Name of the one responsible for the exception. - Exception to log. - - - -Logs a native exception that is formatted nicely to the output. -Equivalent to calling -LogException(exception, Convert::ToNative(thrower->GetType()->Name)); - - Native exception to log. - -Object that threw the exception to label the exception message. -The name of the object will be used. - - - - -Logs an exception that is formatted nicely to the output. - - Exception to log. - -Object that threw the exception to label the exception message. -The name of the object will be used. - - - - -Logs an exception that is formatted nicely to the output. - - Exception to log. - - - -Logs a error message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the error to label the error message. -The name of the object will be used. - - - - -Logs a error message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the error to label the error message. -The name of the object will be used. - - - - -Logs a error message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Object that threw the error to label the error message. -The name of the object will be used. - - - - -Logs a error message to the output. - - The string to output. - - - -Logs a error message to the output. - - The string to output. - - - -Logs a warning message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the warning to label the warning message. -The name of the object will be used. - - - - -Logs a warning message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the warning to label the warning message. -The name of the object will be used. - - - - -Logs a warning message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Object that threw the warning to label the warning message. -The name of the object will be used. - - - - -Logs a warning message to the output. - - The string to output. - - - -Logs a warning message to the output. - - The string to output. - - - -Logs a message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that sent the message to label the message. -The name of the object will be used. - - - - -Logs a message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that sent the message to label the message. -The name of the object will be used. - - - - -Logs a message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Object that sent the message to label the message. -The name of the object will be used. - - - - -Logs a message to the output. - - The string to output. - - - -Logs a message to the output. - - The string to output. - - - -Static class that contains the functions for working with time. - - - - -Material used to render this Renderable. - - - - -Material used to render this Renderable. - - - - -Mesh used to render this Renderable. - - - - -Constructs a Renderable Component that represents a native Renderable -component tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the SHADE Engine's SHRenderableComponent. - - - - -Retrieves the value of a specified property on the material. - - Type of property to get. - Name of the property to get. - Value of that property on the material. - -If this Material object is invalid. - - -If the name or type was specified that does not match the material's shader's -defined properties. - - - - -Set the value of a specific property. - - Type of property to set. - Name of the property to set. - Value to set te property to. - -If this Material object is invalid. - - -If the name or type was specified that does not match the material's shader's -defined properties. - - - - -Constructor for the Material - - Handle to the native material object. - - - -Managed counterpart of the native MaterialInstance object containing material -data that can be fed to Renderables for rendering. - - - - -Constructor for the Mesh - - Handle to the mesh object. - - - -Managed counterpart of the native Mesh object containing vertex data that can -be fed to Renderables for rendering. - - - -@brief Decomposes a transformation matrix into translation, orientation and scale. -@param[out] scale The scaling factor of the matrix. -@param[out] orientation The orientation of the matrix. -@param[out] translation The translation of the matrix. -@return True if decomposition was successful. - - - -@brief Decomposes a transformation matrix into translation, euler angles and scale. -@param[out] scale The scaling factor of the matrix. -@param[out] rotation The euler angles of the matrix. -@param[out] translation The translation of the matrix. -@return True if decomposition was successful. - - - -@brief Interface for a Column-Major Row Vector 4x4 Matrix. - - - - -Constructs a RigidBody Component that represents a native -SHRigidBodyComponent component tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the the SHADE Engine's SHRigidBodyComponent. - - - - -Creates an instance of the Managed representation of a Component with a -native Entity. - - Type of Component to create. - Native Entity that this Component is tied to. - The created Managed representation of the Component. - - - -Static constructor to initialize static data - - - - -Pointer to a function for Component manipulation operations. - - -Contains a set of Component related data used for resolving operations for -each Component. - - - - -Removes a Component from the specified Entity. - - Type of the Component to remove. - -Entity object that should have the specified Component removed from/ - - - - -Checks if the specified Entity has the specified Component. - - Type of the Component to check for. - Entity object to check for the Component. - -True if the specified Entity has the specified Component. False otherwise. - - - - -Ensures a Component on the specified Entity. - - Type of the Component to ensure. - Entity object to ensure the Component on. - Reference to the Component. - - - -Retrieves the first Component from the specified GameObjectt's children that -matches the specified type. - - Type of the Component to get. - Entity object to get the Component from. - -Reference to the Component or null if the Entity does not have the -specified Component. - - - - -Gets a Component from the specified Entity. - - Type of the Component to get. - Entity object to get the Component from. - -Reference to the Component or null if the Entity does not have the -specified Component. - - - - -Adds a Component to the specified Entity. - - Type of the Component to add. - -Entity object that should have the specified Component added to. - - Reference to the Component that was added. - - - -Static class which contains functions that map Pls::ECS's Component manipulation -functions to managed generic functions. - - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Entity that this Component belongs to. - - - - -Constructor for BaseComponent to tie it to a specific Entity. -Constructors of derived Components should call this Constructor. - - Entity that this Component will be tied to. - - - -Implicit conversion operator to enable checking if a component is null. - - Component to check. - - - -Removes all Scripts of the specified type from this GameObject. - - Type of PLushieScripts to remove. - - - -Retrieves a immutable list of Scripts of the specified type from this -GameObject. - - Type of Scripts to Get. - Immutable list of Scripts of the specified type. - - - -Retrieves a Script of the specified type from this GameObject. -If multiple Scripts of the same specified type are added on the same -GameObject, this will retrieve the first one added. - - Type of Script to add. - Reference to the Script to retrieve. - - - -Adds a Script of the specified type to this GameObject. - - Type of Script to add. - Reference to the created Script. - - - -Removes a Component from this GameObject. If no Component exists to begin -with, nothing happens. - - Type of the Component to get. - - - -Gets a Component from this GameObject. - - Type of the Component to get. - -Reference to the Component or null if this GameObject does not have the -specified Component. - - - - -Adds a Component to this GameObject. - - Type of the Component to add. - Reference to the Component that was added. - - - -Retrieves the GameObject that this Component belongs to. - - - - -Class that serves as the base for a wrapper class to Components in native code. - - - - -Called when the attached GameObject has a Collider and leaves a -collision with another GameObject with a Collider2D. - - Information on the collision event. - - - -Called when the attached GameObject has a Collider and collides with -another GameObject with a Collider in subsequent frames of collision. - - Information on the collision event. - - - -Called when the attached GameObject has a Collider and collides with -another GameObject with a Collider in the first frame of collision. - - Information on the collision event. - - - -Called when the attached GameObject has a trigger Collider and leaves a -collision with another GameObject with a Collider2D. - - Information on the collision event. - - - -Called when the attached GameObject has a trigger Collider and collides with -another GameObject with a Collider in subsequent frames of collision. - - Information on the collision event. - - - -Called when the attached GameObject has a trigger Collider and collides with -another GameObject with a Collider in the first frame of collision. - - Information on the collision event. - - - -Called just before the end of the frame where the attached GameObject or -this script is destroyed directly or indirectly due to destruction of the -owner. - - - - -Called every frame after physics and collision resolution but before -rendering. - - - - -Called every frame before physics and collision resolution. - - - - -Called every frame in sync with Physics update steps and thus in most cases -will execute more than update() will. This will be called immediately before -a Physics update step. - - - - -Called on the first frame that the attached GameObject is active but always -after Awake(). - - - - -Called on the first frame that the attached GameObject is active if they are -a part of the scene. - - - - -Called immediately once this script is detached from a GameObject. - - - - -Called immediately once this script is attached to a GameObject. - - - - -Constructor for Script to tie it to a specific GameObject. -Constructors of derived Scripts should call this Constructor. - - -GameObject that this Script will be tied to. - - - - -Used to call onTriggerExit(). This should be called when a trigger-type -collision is detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onTriggerStay(). This should be called when a trigger-type -collision is detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onTriggerEnter(). This should be called when a trigger-type -collision is detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onCollisionExit(). This should be called when a collision ends -between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onCollisionStay(). This should be called when a collision is -persistent between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onCollisionEnter(). This should be called when a collision is -detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onDestroy(). This should be called at the end of the frame -where the attached GameObject or this script is destroyed directly or -indirectly due to destruction of the owner. - - - - -Used to call lateUpdate(). This should be called every frame after physics -and collision resolution but before rendering. - - - - -Used to call update(). This should be called every frame before physics and -collision resolution. - - - - -Used to call fixedUpdate(). This should be called in sync with Physics -update steps and thus in most cases will execute more than Update() will. -This will be called immediately before a Physics update step. - - - - -Used to call start(). This should be called on the first frame that the -attached GameObject is active but always after Awake(). - - - - -Used to call awake(). This should be called on the first frame that the -attached GameObject is active if they are a part of the scene. - - - - -Used to call onDetached(). This is called immediately when this script is -detached from a GameObject. - - - - -Used to call onAttached(). This is called immediately when this script is -attached to a GameObject. - - - - -Implicit conversion operator to enable checking if a component is null. - - Component to check. - - - -Removes all Scripts of the specified type from this GameObject. - - -Type of script to remove. -This needs to be a default constructable Script. - - - - -Retrieves a immutable list of scripts from the specified Entity that -matches the specified type. -
-Note that this function allocates. It should be used sparingly. - - -Type of scripts to get. -This needs to be a default constructable Script. - - -Immutable list of references to scripts of the specified type. - - - - -Retrieves the first Script from this GameObject's children that matches the -specified type. - - -Type of script to get. -This needs to be a default constructable Script. - - Reference to the script added - - - -Retrieves the first Script from this GameObject that matches the specified -type. - - -Type of script to get. -This needs to be a default constructable Script. - - Reference to the script added - - - -Adds a Script to this GameObject. - - -Type of script to add. -This needs to be a default constructable Script. - - Reference to the script added - - - -Removes a Component from the GameObject that this Script belongs to. - - -Type of the Component to remove. Must be derived from BaseComponent. - - - - -Ensures a Component on the GameObject that this Script belongs to. - - -Type of the Component to ensure. Must be derived from BaseComponent. - - Reference to the Component. - - - -Retrieves the first Component from this GameObject's children that matches -the specified type. - - -Type of the Component to get. Must be derived from BaseComponent. - - Reference to the Component that was retrieved. - - - -Gets a Component from the GameObject that this Script belongs to. - - -Type of the Component to get. Must be derived from BaseComponent. - - Reference to the Component that was retrieved. - - - -Adds a Component to the GameObject that this Script belongs to. - - -Type of the Component to add. Must be derived from BaseComponent. - - Reference to the Component that was added. - - - -GameObject that this Script belongs to. - - - - -Class that forms the basis of all "script"-objects that can be attached to -Entities to update each Entity's Components via C# code. - - - - -The RigidBody that you are colliding with. - - - - -The CollisionShape of the Collider that you are colliding with. - - - - -The Collider that you are colliding with. - - - - -The GameObject whose collider you are colliding with. - - - - -Struct that describes a collision - - - - -Checks if two GameObject references are different. - - GameObject to check. - Another GameObject to check with. - True if both Components are different. - - - -Checks if two GameObject references are the same. - - GameObject to check. - Another GameObject to check with. - True if both Components are the same. - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Retrieves the native Entity object that this GameObject represents. - - Native Entity object that this GameObject represents. - - - -Retrieves the CLR Entity object that this GameObject represents. - - Entity object that this GameObject represents. - - - -Constructor for the GameObject. - - -Managed numerical representation of the ECS Entity that this GameObject -should represent. - - - - -Constructor for the GameObject. - - -The ECS Entity that this GameObject should represent. - - - - -Removes all Scripts of the specified type from this GameObject. - - Type of PLushieScripts to remove. - - - -Retrieves a immutable list of Scripts of the specified type from this -GameObject. - - Type of Scripts to retrieve. - Immutable list of Scripts of the specified type. - - - -Retrieves a Script of the specified type from child GameObjects. -If multiple Scripts of the same specified type are added on the same -child GameObject, this will retrieve the first one added. - - Type of Script to retrieve. - Reference to the Script to retrieve. - - - -Retrieves a Script of the specified type from this GameObject. -If multiple Scripts of the same specified type are added on the same -GameObject, this will retrieve the first one added. - - Type of Script to retrieve. - Reference to the Script to retrieve. - - - -Adds a Script of the specified type to this GameObject. - - Type of Script to add. - Reference to the created Script. - - - -Removes a Component from this GameObject. If no Component exists to begin -with, nothing happens. - - Type of the Component to get. - - - -Ensures a Component on this GameObject. - - Type of the Component to ensure. - -Reference to the Component. - - - - -Retrieves the first Component from this GameObject's children that matches -the specified type. - - Type of the Component to get. - -Reference to the Component or null if neither of this GameObject's children -does not have the specified Component. - - - - -Gets a Component from this GameObject. - - Type of the Component to get. - -Reference to the Component or null if this GameObject does not have the -specified Component. - - - - -Adds a Component to this GameObject. - - Type of the Component to add. - Reference to the Component that was added. - - - -Sets the active state of this GameObject. -
-The actual "activeness" of this GameObject is still dependent on the parents' -active states. - - -Whether to activate or deactivate this GameObject. - - - - -Sets the name of this GameObject. - - The name to set. - - - -Native Entity ID value for this GameObject. - - - - -Whether or not this Entity is active in the Scene hierarchy. - - - - -Whether or not this Entity alone, is active. This does not mean that this -object is active in the scene. For example, if this Entity's parent is not -active, then this Entity would also be not active. - - - - -Name of the object that this Entity represents. - - - - -Retrieves a GameObject with the specified name. If there are multiple -GameObjects with the same name, the first found GameObject will be retrieved. -There is no guaranteed order of which GameObject is considered "first". - - Name of the GameObject to find. - GameObject that has the specified name. Null if not found. - - - -Destroys the specified GameObject. Note that the specified GameObject will no -longer be a valid GameObject after this function is called. - - The GameObject to be destroyed. - - - -Creates a new GameObject in the current Scene. If multiple Scenes are loaded, -and you would like to create an object in a specific Scene, call the Scene's -CreateGameObject(). - - GameObject that represents the newly created GameObject. - - - -Lightweight object for an PlushieEngine Entity that allows for easy access -to Component and Script operations. - - - - -Constructor for a Tooltip attribute that fills in the description. - - Text to be shown when a field is hovered. - - - -Maximum value for the Ranged field. - - - - -Minimum value for the Ranged field. - - - - -Simple attribute to constrain the range of values for a field on the editor. - - - - -Converts from a native std::Stringto a managed String. - - The native std::string to convert from. - Managed copy of a native std::string. - - - -Converts from a managed String to a native std::string. - - The managed String to convert from. - Native copy of a managed String. - - - -Converts from a native Vector2 to a managed Vector2. - - The native Vector2 to convert from. - Managed copy of a native Vector2. - - - -Converts from a native Quaternion to a managed Quaternion. - - The native Quaternion to convert from. - Managed copy of a native Quaternion. - - - -Converts from a managed Quaternion to a native Quaternion. - - The managed Quaternion to convert from. - Native copy of a managed Quaternion. - - - -Converts from a native Vector2 to a managed Vector2. - - The native Vector2 to convert from. - Managed copy of a native Vector2. - - - -Converts from a managed Vector2 to a native Vector2. - - The managed Vector2 to convert from. - Native copy of a managed Vector2. - - - -Converts from a native Vector3 to a managed Vector3. - - The native Vector3 to convert from. - Managed copy of a native Vector3. - - - -Converts from a managed Vector3 to a native Vector3. - - The managed Vector3 to convert from. - Native copy of a managed Vector3. - - - -Converts from a native Entity to a managed Entity (UInt32). - - Native Entity to convert from. - Managed representation of the specified Entity. - - - -Provides functions easy and consistent syntax for converting between custom -managed and native types that are aligned. - - - - -Converts to true if this is a valid Handle. - - - - -The library that the handle was issued by. - - - - -The internal ID of the handle. - - - - -Creates a ray starting at origin along direction. - - Source of the ray. - Direction the ray travels in. - - - -The direction that a ray travels in. - - - - -The start point of the ray. - - - - -CLR version of the the SHADE Engine's Ray class that represents a ray in -3-Dimensional space. - - - - -Are two quaternions equal to each other? - - Left-hand side quaternion. - Right-hand side quaternion. - - - -Combines rotations lhs and rhs. - - Left-hand side quaternion. - Right-hand side quaternion. - - - -Spherically interpolates between a and b by t. The parameter t is not clamped. - - - - -Spherically interpolates between quaternions a and b by ratio t. The parameter t is clamped to the range [0, 1]. - - Start value, returned when t = 0. - End value, returned when t = 1. - Interpolation ratio. - A quaternion spherically interpolated between quaternions a and b. - - - -Rotates a rotation from towards to.
-The from quaternion is rotated towards to by an angular step of maxDegreesDelta (but note that the rotation will not overshoot). -Negative values of maxDegreesDelta will move away from to until the rotation is exactly the opposite direction. - - - - -Converts this quaternion to one with the same orientation but with a magnitude of 1. - - - - -Creates a rotation with the specified forward and upwards directions.
-Z axis will be aligned with forward, X axis aligned with cross product between forward and upwards, and Y axis aligned with cross product between Z and X. - - - - -Interpolates between a and b by t and normalizes the result afterwards. The parameter t is not clamped. - - - - -Interpolates between a and b by t and normalizes the result afterwards. The parameter t is clamped to the range [0, 1]. - - Start value, returned when t = 0. - End value, returned when t = 1. - Interpolation ratio. - A quaternion interpolated between quaternions a and b. - - - -Returns the Inverse of rotation. - - - - -Creates a rotation which rotates from fromDirection to toDirection. - - - - -Returns a rotation that rotates y degrees around the y axis, x degrees around the x axis, and z degrees around the z axis; applied in that order. - - - - -The dot product between two rotations. - - - - -Creates a rotation which rotates angle degrees around axis. - - - - -Returns the angle in degrees between two rotations a and b.
 - The angle in degrees between the two vectors. - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Converts a rotation to angle-axis representation (angles in degrees). - - - - -Creates a rotation with the specified forward and upwards directions.
-The result is applied to this quaternion. -If used to orient a Transform, the Z axis will be aligned with forward and the Y axis with upwards, assuming these vectors are orthogonal. -Logs an error if the forward direction is zero. - - The direction to look in. - The vector that defines in which direction up is. - - - -Creates a rotation which rotates from fromDirection to toDirection.
-Use this to create a rotation which starts at the first Vector (fromDirection) and rotates to the second Vector (toDirection). -These Vectors must be set up in a script. - - - - -Constructor to construct a Quaternion with the specified components. - - X-coordinate to set. - Y-coordinate to set. - Z-coordinate to set. - W-coordinate to set. - - - -W-component of the Quaternion. Do not directly modify quaternions. - - - - -Z-component of the Quaternion. -Don't modify this directly unless you know quaternions inside out. - - - - -Y-component of the Quaternion. -Don't modify this directly unless you know quaternions inside out. - - - - -X-component of the Quaternion. -Don't modify this directly unless you know quaternions inside out. - - - - -Shorthand for writing Quaternion(0, 0, 0, 1). - - - - -CLR version of SHADE's Quaternion class that represents an orientation. -Designed to closely match Unity's Quaternion struct. - - - - -Explicit conversion operator to enable explicit casting from a Vector2 to a -Vector3. - - Vector2 to convert from. - - - -Explicit conversion operator to enable explicit casting from a Vector3 to a -Vector2. - - Vector3 to convert from. - - - -Checks if two Vector3s are not approximately equal. This is equivalent to -calling !Vector3.IsNear() with default tolerance values. - - Vector3 to compare. - Another Vector3 to compare. - -True if all components are not approximately equal within the default -tolerance value. - - - - -Checks if two Vector3s are approximately equal. This is equivalent to -calling Vector3.IsNear() with default tolerance values. - - Vector3 to compare. - Another Vector3 to compare. - -True if all components are approximately equal within the default -tolerance value. - - - - -Calculates the division of a Vector3 with a scalar value and returns -the result. - - Scalar to divide with. - Vector3 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector3 with a scalar value and returns -the result. - - Vector3 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the division of a Vector3 with a scalar value and returns -the result. - - Scalar to divide with. - Vector3 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector3 with a scalar value and returns -the result. - - Vector3 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the component-wise multiplication of two Vector3s and returns the -result. - - Vector3 to multiply with. - Another Vector3 to multiply with. - The result of rhs subtracted from lhs. - - - -Subtracts a Vector3 from another Vector3 and returns the result. - - Vector3 to subtract from. - Another Vector3 to subtract. - The result of rhs subtracted from lhs. - - - -Adds two Vector3s together and returns the result. - - Vector3 to add. - Another Vector3 to add. - The result of lhs added to rhs - - - -Moves a point current towards target. -Similar to Lerp(), however, the function will ensure that the distance never -exceeds maxDistanceDelta. Negative values of maxDistanceDelta pushes the -vector away from target - - The current position of the point. - The target position to move to. - Maximum distance moved per call. - Vector representing the moved point. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. -Unlike Lerp(), t is not clamped to a range at all. - - The start Vector3, returned when t = 0.0f. - The end Vector3, returned when t = 1.0f. - Value used to interpolate between a and b. - The interpolated Vector3. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. - - The start Vector3, returned when t = 0.0f. - The end Vector3, returned when t = 1.0f. - -Value used to interpolate between a and b which is clamped to -the range[0, 1]. - - The interpolated Vector3. - - - -Computes and returns a Vector3 that is made from the largest components of -the two specified Vector3s. - - Vector3 to calculate maximum Vector3 with. - Another Vector3 to calculate maximum Vector3 with. - -The Vector3 that contains the largest components of the two specified -Vector3s. - - - - -Computes and returns a Vector3 that is made from the smallest components of -the two specified Vector3s. - - Vector3 to calculate minimum Vector3 with. - Another Vector3 to calculate minimum Vector3 with. - -The Vector3 that contains the smallest components of the two specified -Vector3s. - - - - -Rotates a Vector3 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector3 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in degrees. - - The Vector3 that represents the rotated vector. - - - -Rotates a Vector3 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector3 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in radians. - - The Vector3 that represents the rotated vector. - - - -Reflects a Vector3 across another Vector3. - - A Vector3 to reflect. - A normal to reflect the Vector3 across. - The Vector3 that represents vec reflected across normal. - - - -Computes and returns a Vector3 projection. - - Vector3 to project. - Vector3 to project onto. - The Vector3 that represents the projected vec onto direction. - - - -Computes and returns the cross product of 2 specified Vector3s. - - Vector3 to calculate cross product with. - Another Vector3 to calculate cross product with. - The cross product of the two Vector3s. - - - -Computes and returns the dot product of 2 specified Vector3s. - - Vector3 to calculate dot product with. - Another Vector3 to calculate dot product with. - Scalar value representing the dot product of the two Vector3s. - - - -Checks if two specified Vector3s are near in value. - - Vector3 to check if is near in value. - Another Vector3 to check if is near in value. - Amount of tolerance to do the comparison with. - -True if the two Vector3s are within the tolerance value specified - - - - -Checks if two specified Vector3s are near in value. - - Vector3 to check if is near in value. - Another Vector3 to check if is near in value. - -True if the two Vector3s are within the tolerance value specified - - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Checks if a specified point is near this Vector3 that represents a point. - - The other point to check if we are near. - -The amount of tolerance before we consider these points as "near". - - -True if this Vector3 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Checks if a specified point is near this Vector3 that represents a point with -a tolerance value of PLS_EPSILON. - - The other point to check if we are near. - -True if this Vector3 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -180.0f and 180.0f. - - Returns the angle of this vector from the right vector in degrees. - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -Math.PI and Math.PI. - - Returns the angle of this vector from the right vector in radians. - - - -Calculates and returns the squared magnitude of this Vector3. - - Returns the squared length of this Vector3. - - - -Calculates and returns the magnitude of this Vector3. Note that this function -incurs a performance cost from the square root calculation. If you do not -need the precise magnitude, consider using GetSqrMagnitude() instead. - - Returns the length of this Vector3. - - - -Creates a copy of this Vector3 and returns a normalized version. - - -Returns a normalised copy of this Vector3. -If this Vector3 is a zero vector, a zero vector will be returned. - - - - -Normalises this current Vector3. This changes the data of this Vector3. -If you would like to get a copy, use GetNormalised() instead. -This function does nothing to a zero vector. - - - - -Conversion constructor to construct a Vector3 using a Vector2. - - - - - -Constructor to construct a Vector3 with the specified components. - - X-coordinate to set. - Y-coordinate to set. - Z-coordinate to set. - - - -Constructor to construct a Vector3 with the specified components with the -Z-component set to 0.0f. - - X-coordinate to set. - Y-coordinate to set. - - - -Constructor to construct a Vector3 with the specified components with the -Y and Z-component set to 0.0f. - - X-coordinate to set. - - - -Z-component of the Vector3. - - - - -Y-component of the Vector3. - - - - -X-component of the Vector3. - - - - -Shorthand for writing Vector3(0, 0, 0). - - - - -Shorthand for writing Vector3(0, 1, 0). - - - - -Shorthand for writing Vector3(1, 0, 0). - - - - -Shorthand for writing Vector3(float.PositiveInfinity, -float.PositiveInfinity, float.PositiveInfinity). - - - - -Shorthand for writing Vector3(1, 1, 1). - - - - -Shorthand for writing Vector3(float.NegativeInfinity, -float.NegativeInfinity, float.NegativeInfinity). - - - - -Shorthand for writing Vector3(-1, 0, 0). - - - - -Shorthand for writing Vector3(0, 0, 1). - - - - -Shorthand for writing Vector3(0, -1, 0). - - - - -Shorthand for writing Vector3(0, 0, -1). - - - - -CLR version of SHADE Engine's Vector3 class that represents a 3-Dimensional Vector. -Designed to closely match Unity's Vector3 struct. - - - - -Checks if two Vector2s are not approximately equal. This is equivalent to -calling !Vector2.IsNear() with default tolerance values. - - Vector2 to compare. - Another Vector2 to compare. - -True if all components are not approximately equal within the default -tolerance value. - - - - -Checks if two Vector2s are approximately equal. This is equivalent to -calling Vector2.IsNear() with default tolerance values. - - Vector2 to compare. - Another Vector2 to compare. - -True if all components are approximately equal within the default -tolerance value. - - - - -Calculates the division of a Vector2 with a scalar value and returns -the result. - - Scalar to divide with. - Vector2 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector2 with a scalar value and returns -the result. - - Vector2 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the division of a Vector2 with a scalar value and returns -the result. - - Scalar to divide with. - Vector2 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector2 with a scalar value and returns -the result. - - Vector2 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the component-wise multiplication of two Vector2s and returns the -result. - - Vector2 to multiply with. - Another Vector2 to multiply with. - The result of rhs subtracted from lhs. - - - -Subtracts a Vector2 from another Vector2 and returns the result. - - Vector2 to subtract from. - Another Vector2 to subtract. - The result of rhs subtracted from lhs. - - - -Adds two Vector2s together and returns the result. - - Vector2 to add. - Another Vector2 to add. - The result of lhs added to rhs - - - -Moves a point current towards target. -Similar to Lerp(), however, the function will ensure that the distance never -exceeds maxDistanceDelta. Negative values of maxDistanceDelta pushes the -vector away from target - - The current position of the point. - The target position to move to. - Maximum distance moved per call. - Vector representing the moved point. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. -Unlike Lerp(), t is not clamped to a range at all. - - The start Vector2, returned when t = 0.0f. - The end Vector2, returned when t = 1.0f. - Value used to interpolate between a and b. - The interpolated Vector2. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. - - The start Vector2, returned when t = 0.0f. - The end Vector2, returned when t = 1.0f. - -Value used to interpolate between a and b which is clamped to -the range[0, 1]. - - The interpolated Vector2. - - - -Computes and returns a Vector2 that is made from the largest components of -the two specified Vector2s. - - Vector2 to calculate maximum Vector2 with. - Another Vector2 to calculate maximum Vector2 with. - -The Vector2 that contains the largest components of the two specified -Vector2s. - - - - -Computes and returns a Vector2 that is made from the smallest components of -the two specified Vector2s. - - Vector2 to calculate minimum Vector2 with. - Another Vector2 to calculate minimum Vector2 with. - -The Vector2 that contains the smallest components of the two specified -Vector2s. - - - - -Rotates a Vector2 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector2 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in degrees. - - The Vector2 that represents the rotated vector. - - - -Rotates a Vector2 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector2 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in radians. - - The Vector2 that represents the rotated vector. - - - -Reflects a Vector2 across another Vector2. - - A Vector2 to reflect. - A normal to reflect the Vector2 across. - The Vector2 that represents vec reflected across normal. - - - -Computes and returns a Vector2 projection. - - Vector2 to project. - Vector2 to project onto. - The Vector2 that represents the projected vec onto direction. - - - -Computes a perpendicular Vector2 to the specified Vector2. - - Vector2 to find a perpendicular of. - -Whether the inward perpendicular Vector is retrieved. If true, the -resultant vector is rotated 90-degrees in a counter-clockwise. - - The perpendicular Vector2 relative to the specified Vector2. - - - - -Computes the inward perpendicular Vector2 to the specified Vector2. -Equivalent to calling Perpendicular(lhs, true). This means, the -resultant Vector2 is rotated 90-degrees in a counter-clockwise. - - Vector2 to find a perpendicular of. - -The perpendicular Vector2 relative to the specified Vector2. - - - - -Computes and returns the dot product of 2 specified Vector2s. - - Vector2 to calculate dot product with. - Another Vector2 to calculate dot product with. - -Scalar value representing the dot product of the two Vector2s. - - - - -Checks if two specified Vector2s are near in value. - - Vector2 to check if is near in value. - Another Vector2 to check if is near in value. - -Amount of tolerance to do the comparison with. - - -True if the two Vector2s are within the tolerance value specified - - - - -Checks if two specified Vector2s are near in value. - - Vector2 to check if is near in value. - Another Vector2 to check if is near in value. - -True if the two Vector2s are within the tolerance value specified - - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Checks if a specified point is near this Vector2 that represents a point. - - The other point to check if we are near. - -The amount of tolerance before we consider these points as "near". - - -True if this Vector2 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Checks if a specified point is near this Vector2 that represents a point with -a tolerance value of PLS_EPSILON. - - The other point to check if we are near. - -True if this Vector2 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -180.0f and 180.0f. - - Returns the angle of this vector from the right vector in degrees. - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -Math.PI and Math.PI. - - Returns the angle of this vector from the right vector in radians. - - - -Calculates and returns the squared magnitude of this Vector2. - - Returns the squared length of this Vector2. - - - -Calculates and returns the magnitude of this Vector2. Note that this function -incurs a performance cost from the square root calculation. If you do not -need the precise magnitude, consider using GetSqrMagnitude() instead. - - Returns the length of this Vector2. - - - -Creates a copy of this Vector2 and returns a normalized version. - - -Returns a normalised copy of this Vector2. -If this Vector2 is a zero vector, a zero vector will be returned. - - - - -Normalises this current Vector2. This changes the data of this Vector2. -If you would like to get a copy, use GetNormalised() instead. -This function does nothing to a zero vector. - - - - -Constructor to construct a Vector2 with the specified components.. - - X-coordinate to set. - Y-coordinate to set. - - - -Constructor to construct a Vector2 with the specified components with the -Y-component set to 0.0f. - - X-coordinate to set. - - - -Y-component of the Vector2. - - - - -X-component of the Vector2. - - - - -Shorthand for writing Vector2(0, 0). - - - - -Shorthand for writing Vector2(0, 1). - - - - -Shorthand for writing Vector2(1, 0). - - - - -Shorthand for writing Vector2(float.PositiveInfinity, -float.PositiveInfinity). - - - - -Shorthand for writing Vector2(1, 1). - - - - -Shorthand for writing Vector2(float.NegativeInfinity, -float.NegativeInfinity). - - - - -Shorthand for writing Vector2(-1, 0). - - - - -Shorthand for writing Vector2(0, -1). - - - - -CLR version of SHADE Engine's Vector2 class that represents a 2-Dimensional Vector. -Designed to closely match Unity's Vector2 struct. - - - - -Checks if the specified entity is valid. This is done by checking if it -matches Pls::Entity::INVALID. - - The Entity to check. - True if the specified Entity is valid. - - - -Static class that contains useful utility functions for working with Entity. - - - - -Manages all resources in multiple ResourceLibraries. - - - - -Base class for SHResourceLibrary that holds information about the library type. - - - - -Template Specialization for Handle that represents a type-less Handle. - - - - -Converts to true if this is a valid Handle. - - - - -Native ID type of a handle - - - - -Base implementation of the Handle that is not templated to allow for holding -generic non-type-specific Handles. - - - - -Exception thrown when a generic Handle is being casted to the wrong type. - - - - -Exception thrown when an invalid Handle was dereferenced. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/bin/Release/SHADE_CSharp.xml b/bin/Release/SHADE_CSharp.xml deleted file mode 100644 index daeaa3c5..00000000 --- a/bin/Release/SHADE_CSharp.xml +++ /dev/null @@ -1,1029 +0,0 @@ - - - - SHADE_CSharp - - - - - Interface for a CallbackAction that all variants inherit from. - - - - - Whether or not this CallbackAction is runtime assigned. If it is, then the - TargetMethodName and TargetObject properties are invalid. - - - - - Name of the method that this CallbackAction is using. - - - - - Object which the specified target method is called on. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 1 parameter. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 2 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 3 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 4 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 5 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 6 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 7 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 8 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 9 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Represents a function call that can be serialised and put togetheer with scripts. - This variant accepts functions with 10 parameters. - - - - - - - - - - - - - - Constructs an empty Callback action. - - - - - Constructs a CallbackAction that represents a call to the specified static - method. - - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a CallbackAction that represents a call to a specified member - method on the specified target. - - Object to call the method on. - Method to call. - - Thrown if a method that is not compatible with the target is specified. The method's - source type must match the target's type. - - - - - Constructs a Callback action based on an action. - - Action that wraps a function to be called. - - - - Invokes the CallbackAction's stored method/action with the specified parameters. - - - - - Interface for a CallbackEvent that all variants inherit from. - - - - - Registers an empty ICallbackAction. - - - - - Registers an ICallbackAction with the event such that it will be called in - future - - ICallbackAction to register with. - - - - Deregisters an ICallbackAction that was previously added. This should - only emit a warning if an action that was not previous added was - provided. - - ICallbackAction to remove. - - - - Iterable set of ICallbackActions that were registered to this event. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - - A container of CallbackActions that is correlated to a specific scenario as - specified by the user of this class. - This variant accepts CallbackEvents with 1 generic parameter. - - - - - - - - - - - - - - Adds a CallbackAction into the event. - - CallbackAction to add. - - - - Constructs and adds a CallbackACtion into the event. - - System.Action to add as a CallbackAction. - - - - Constructs and adds a CallbackACtion into the event. - - Object to call the method on. - Method to call. - - - - - - - Invokes all stored CallbackActions with the specified parameters. - - - - diff --git a/bin/Release/SHADE_Managed.xml b/bin/Release/SHADE_Managed.xml deleted file mode 100644 index 7b653116..00000000 --- a/bin/Release/SHADE_Managed.xml +++ /dev/null @@ -1,6250 +0,0 @@ - - - - "SHADE_Managed" - - - - -Retrieves the duration that the specified key has not been held or was last -not been held for. - - The key to check. - Time in seconds that the key was held. - - - -Retrieves the duration that the specified key has been held or was last held -for. - - The key to check. - Time in seconds that the key was held. - - - -Retrieves the duration that the specified key has not been held or was last -not been held for. - - The key to check. - Time in seconds that the key was held. - - - -Retrieves the duration that the specified key has been held or was last held -for. - - The key to check. - Time in seconds that the key was held. - - - -Sets the position of the mouse cursor relative to the top left corner of the -window. - - -Position of the mouse in window pixel coordinates to set. - - - - -Checks if a specified mouse button is no longer pressed and was pressed -before. - - MouseCode of the mouse button to check. - -True during the frame the user releases the given mouse button. - - - - -Checks if a specified mouse button is pressed and was not pressed before. - - MouseCode of the mouse button to check. - -True during the frame the user pressed the given mouse button. - - - - -Checks if a specified mouse button is being held down. -This will also be true if GetMouseButtonDown() is true. - - MouseCode of the mouse button to check. - True while the user holds down the mouse button specified. - - - -Checks if a specified key is no longer pressed pressed and was pressed -before. - - KeyCode of the key to check. - -True during the frame the user releases the key identified by name. - - - - -Checks if a specified key is pressed and was not pressed before. - - KeyCode of the key to check. - -True during the frame the user starts pressing down the key specified. - - - - -Checks if a specified key is being held down. -This will also be true if GetKeyDown() is true. - - KeyCode of the key to check. - True while the user holds down the key specified. - - - -Amnount of vertical mouse scroll in this frame. - - - - -Mouse position in screen coordinates relative to the top left of the window. -This value is a Vector3 for compatibility with functions that have Vector3 -arguments. The z component of the Vector3 is always 0 - - - - -Represents the available supported mouse keycodes that can be passed into the -mouse-button-based Input functions. - - - - -Represents the available supported keycodes that can be passed into the -key-based Input functions. - -Attempting to follow https://docs.unity3d.com/ScriptReference/KeyCode.html -Win32 keycodes are shift-insensitive, i.e. 'A' and 'a' are the same keycode and '1' and '!' are the same keycode - - - - -Static class responsible for providing access to Input-related functionality. - - - - -Simple attribute to mark that a field in a Script should be serialised. - - - - -Cleans up all required components for managed code. - - - - -Reloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. -Equivalent to calling UnloadScriptAssembly() and then LoadScriptAssembly(). - - - - -Loads the managed script assembly. Ensure this is only called after -UnloadScriptAssembly() has been called. - - - - -Unloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. - - - - -Initialises all required components for managed code. - - - - -Name of the Managed Library that contains the C# scripts written externally. - - - - -Static class that contains the functions for interfacing with the core -PlushieEngine written in C++ for managing the lifecycle of managed code. - - - - -Default Constructor - - - - -Custom AssemblyLoadContext marked as collectible so that it can be unloaded. - - - - -Time taken for Physics simulations. You should use this for operations -within Script.FixedUpdate() - - - - -Time taken to process the previous frame. - - - - -Static class that contains the functions for working with time. - - - - -Static class that wraps up certain functions in the SHPhysicsSystem so that -accessing it from SHADE_Managed would not cause issues due to C++20 features. - - - - -Constructor for a Tooltip attribute that fills in the description. - - Text to be shown when a field is hovered. - - - -Description that is to be shown in the Tooltip. - - - - -Simple attribute to provide a field in a script with a tooltip. - - - - -Checks if a specified file exists. - - File path to the file to check. - True if the file exists - - - -Deletes the folder and all files in it as specified by the file path. - - File path to the file to delete. - - - -Deletes the file as specified by the file path. - - File path to the file to delete. - - - -Reads the file via the specified path that represents a build log of error -and warning messages. - - -File path to the build log of script builds done by BuildScriptAssembly() to -dump and process. - - - - -Registers events for the scripting system - - - - -Loads all the function pointers to CLR code that we need to execute. - - - - -Generates a .csproj file for editing and compiling the C# scripts. - - File path to the generated file. - - - -Utilises execution of a external batch file for invoking the dotnet build -tool to compile C# scripts in the Assets folder into the SHADE_Scripting -C# assembly DLL. - - -Whether or not a debug build will be built. Only debug built C# assemblies -can be debugged. - - -Whether or not we are reloading the assembly, if so, unload and then reload it. - - Whether or not the build succeeded. - - - -Performs a redo for script inspector changes if it exists. - - - - -Performs an undo for script inspector changes if it exists. - - - - -Renders the set of attached Scripts for the specified Entity into the -inspector. -
-This function is meant for consumption from native code in the inspector -rendering code. - - The Entity to render the Scripts of. - - - -Creates scripts and sets fields for the specified Entity based on the specified -YAML node. - - The Entity to deserialise a Script on to. - -YAML Node that contains the serialised script data. - - True if successfully deserialised. - - - -Performs serialization of all scripts for the specified entity into the -YAML::Node specified. This node will contain all serialised scripts after -calling this function. - - The Entity to Serialise. - -YAML Node that will store the serialised scripts. - - True if successfully serialised. - - - -Removes all Scripts attached to the specified Entity. Unlike -RemoveAllScripts(), this removes all the scripts immediately. -Does not do anything if the specified Entity is invalid or does not have any -Scripts attached. - - The entity to remove the scripts from. - -Whether or not to call OnDestroy on the scripts. This is ignored if not in -play mode. - - - - -Removes all Scripts attached to the specified Entity. Does not do anything -if the specified Entity is invalid or does not have any Scripts -attached. - - The entity to remove the scripts from. - - - -Adds a Script to a specified Entity. Note that while you can call this -multiple times on a specified Entity, it will work for all intents and -purposes but GetScript<T>() (C# only) currently only -gives you the first Script added of the specified type. - - The entity to add a script to. - Type name of the script to add. - -True if successfully added. False otherwise with the error logged to the -console. - - - - -Shuts down the DotNetRuntime. - - - - -Executes the OnCollision*()s and OnTrigger*()s of the Scripts that are attached -to Entities. - - - - -Executes the FixedUpdate()s of the Scripts that are attached to -Entities. - - - - -Reloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. - - - - -Unloads the managed script assembly. -Take note that this will clear all existing scripts, ensure that the scene -is saved before doing so. - - - - -Loads the managed script assembly. Ensure this is only called after -UnloadScriptAssembly() has been called. - - - - -Initialises the DotNetRuntime and retrieves function pointers to all -functions on the CLR used to interface with the engine. - - - - -Manages initialisation of the DotNetRuntime and interfacing with CLR code written -and executed on .NET. - - - - -Deserialises a YAML node that contains a map of Scripts and copies the -deserialised data into the specified object if there are matching fields. - - -The JSON string that contains the data to copy into this Script object. - - The object to copy deserialised data into. - - - -Creates a JSON node that represents the specified object and its associated -serialisable fields. Public fields and fields marked with the SerialiseField -attribute will be serialised. - - The object to serialise. - - - -Checks if a specified field is a candidate for serialisation. This means that -the field is public or private with the [SerialiseField] attribute. - - The field to check. - -True if the specified field is a candidate for serialisation. - - - - -Retrieves a set of all non-static (instance) fields from a specified object. - - The object to get non-static fields from. - Immutable list of non-static fields. - - - -Contains useful static functions for working with Reflection. - - - -Converts the node to a YAML string. - - -Emits the node to the given output stream. - - -Emits the node to the given {@link Emitter}. If there is an error in writing, -{@link Emitter#good} will return false. - - - - Loads the input file as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - @throws {@link BadFile} if the file cannot be loaded. - - - - Loads the input stream as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a list of YAML documents. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input file as a single YAML document. - - @throws {@link ParserException} if it is malformed. - @throws {@link BadFile} if the file cannot be loaded. - - - - Loads the input stream as a single YAML document. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a single YAML document. - - @throws {@link ParserException} if it is malformed. - - - - Loads the input string as a single YAML document. - - @throws {@link ParserException} if it is malformed. - - - -Handles a "TAG" directive, which should be of the form 'handle prefix', -where 'handle' is converted to 'prefix' in the file. - - - -Handles a "YAML" directive, which should be of the form 'major.minor' (like -a version number). - - - -Reads any directives that are next in the queue, setting the internal -{@code m_pDirectives} state. - - - - Handles the next document by calling events on the {@code eventHandler}. - - @throw a ParserException on error. - @return false if there are no more documents - - - -Resets the parser with the given input stream. Any existing state is -erased. - - - -Evaluates to true if the parser has some valid input to be read. - - -Constructs a parser from the given input stream. The input stream must -live as long as the parser. - - - -Constructs an empty parser (with no input. - - -A parser turns a stream of bytes into one stream of "events" per YAML -document in the input stream. - - - - -Renders a context menu when right clicked for the scripts - - The Entity to render the Scripts of. - The Script to render the inspector for. - - - -Renders a field specified into the inspector. - - The field to render. - -The object that contains the data of the field to render. - - - - -Renders a single specified Script's inspector. - - The Entity to render the Scripts of. - The Script to render the inspector for. - -Indices used internally to differentiate each rendered Script -inspector. This is required to open and close each Script's inspector -independently from each other. - - - - -Redoes the last script inspector change if there is any. - - - - -Undoes the last script inspector change if there is any. - - - - -Renders a dropdown button that allows for the addition of PlushieScripts -onto the specified Entity. - - The Entity to add PlushieScripts to. - - - -Renders the set of attached Scripts for the specified Entity into the -inspector. -
-This function is meant for consumption from native code in the inspector -rendering code. - - The Entity to render the Scripts of. - - - -Static class for Editor-related functions - - - - -Processes a YAML node that contains a list of multiple scripts to be loaded -into the specified Entity. -

-This function should only be called from native unmanaged code. - - -The Entity to attach the deserialised Scripts to. - - -Pointer to the YAML::Node that contains serialized script data. - - - - - -Populates a YAML node with the scripts for a specified Entity. -

-This function should only be called from native unmanaged code. - - The Entity to Serialise. - -Pointer to a YAML::Node that will be populated with all of the serialised -scripts and their associated fields. - - -True if serialisation is successful. False if the buffer is too small for -the serialised output. - - - - -Executes OnCollision*() and OnTrigger*() for all scripts. - - - - -Executes LateUpdate() for all scripts. - - - - -Executes Update() for all scripts. - - - - -Executes FixedUpdate() for all scripts. - - - - -Retrieves a immutable list of available scripts that can be added. - - Immutable list of available scripts that can be added. - - - -Cleans up data stored in the ScriptStore to free up memory for garbage -collection. - - - - -Cleans up scripts that were marked for deletion. This calls the OnDestroy() -for these Scripts. - - - - -Sets up scripts that were marked for initialization. This calls the Awake() -and Start() for Scripts that have yet to have done so. - - - - -Initializes the ScriptStore to allocate and pre-populate reflection data. - - - - -Removes all Scripts attached to the specified Entity. Unlike -RemoveAllScripts(), this removes all the scripts immediately. -Does not do anything if the specified Entity is invalid or does not have any -Scripts attached. - - The entity to remove the scripts from. - -Whether or not to call OnDestroy on the scripts.This is ignored if not in -play mode. - - - - -Removes all Scripts attached to the specified Entity. Does not do anything -if the specified Entity is invalid or does not have any Scripts -attached. - - The entity to remove the scripts from. - - - -Removes a specific script from the - - The entity to remove the script from. - The script to remove. - True if successfully removed. False otherwise. - - - -Removes all Scripts of the specified type from the specified Entity. - - -Type of script to remove. -This needs to be a default constructable Script. - - The entity to remove the script from. - -If the specified Entity is invalid. - - - - -Retrieves an immutable list of all scripts attached to a specified Entity. - - -The entity which the scripts to retrieve are attached. - - -Immutable list of references to scripts attached to the specified Entity. -This can also be null if there are no scripts at all or an invalid Entity -was specified. - - - - -Retrieves a immutable list of scripts from the specified Entity that -matches the specified type. -
-Note that this function allocates. It should be used sparingly. - - -Type of scripts to get. -This needs to be a default constructable Script. - - -The entity which the scripts to retrieve are attached. - - -Immutable list of references to scripts of the specified type. - - - - -Retrieves the first Script from the specified Entity's children that matches -the specified type. - - -Type of script to get. -This needs to be a default constructable Script. - - -The entity which the script to retrieve is attached. - - -Reference to the script. This can be null if no script of the specified -type is attached. - - -If the specified Entity is invalid. - - - - -Retrieves the first Script from the specified Entity that matches the -specified type. - - -Type of script to get. -This needs to be a default constructable Script. - - -The entity which the script to retrieve is attached. - - -Reference to the script. This can be null if no script of the specified -type is attached. - - -If the specified Entity is invalid. - - - - -Adds a Script to a specified Entity. -
-This function is meant for consumption from native code or for serialisation -purposes. If you are writing in C# or C++/CLI and not doing serialisation, -use AddScript<T>() instead as it is faster. - - The entity to add a script to. - The entity to add a script to. - -Out parameter handle to the Script that was created. - - -True if successfully added. False otherwise with the error logged to the -console. - - - - -Adds a Script to a specified Entity. -
-This function is meant for consumption from native code. If you are writing -in C# or C++/CLI, use AddScript<T>() instead as it is faster. - - The entity to add a script to. - The entity to add a script to. - -True if successfully added. False otherwise with the error logged to the -console. - - - - -Adds a Script to a specified Entity. - - -Type of script to add. -This needs to be a default constructable PlushieScript. - - The entity to add a script to. - Reference to the script added. - -If the specified Entity is invalid. - - - - -Responsible for managing all scripts attached to Entities as well as executing -all lifecycle functions of scripts. - - - - -Checks if two Colors are not approximately equal. - - Color to compare. - Another Color to compare. - -True if all components are not approximately equal within the default -tolerance value. - - - - -Checks if two Colors are approximately equal. - - Color to compare. - Another Color to compare. - -True if all components are approximately equal within the default -tolerance value. - - - - -Calculates the division of a Color with a scalar value and returns -the result. - - Scalar to divide with. - Color to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Color with a scalar value and returns -the result. - - Color to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the component-wise multiplication of two Colors and returns the -result. - - Color to multiply with. - Another Color to multiply with. - The result of rhs subtracted from lhs. - - - -Subtracts a Color from another Color and returns the result. - - Color to subtract from. - Another Color to subtract. - The result of rhs subtracted from lhs. - - - -Adds two Colors together and returns the result. - - Color to add. - Another Color to add. - The result of lhs added to rhs - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. -Unlike Lerp(), t is not clamped to a range at all. - - The start Color, returned when t = 0.0. - The end Color, returned when t = 1.0. - Value used to interpolate between a and b. - The interpolated Color. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. - - The start Color, returned when t = 0.0. - The end Color, returned when t = 1.0. - -Value used to interpolate between a and b which is clamped to -the range[0, 1]. - - The interpolated Vector3. - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Alpha component of the colour. Ranges from 0.0f to 1.0f. - - - - -Blue component of the colour. Ranges from 0.0f to 1.0f. - - - - -Green component of the colour. Ranges from 0.0f to 1.0f. - - - - -Red component of the colour. Ranges from 0.0f to 1.0f. - - - - -Constructor to construct a Color with the specified components. - - Red component to set. - Green component to set. - Blue component to set. - Alpha component to set. - - - -Constructor to construct a Color with the specified components with the -alpha component set to 1.0f. - - Red component to set. - Green component to set. - Blue component to set. - - - -Constructor to construct a Color with the specified components with the -blue and alpha component set to 1.0f. - - Red component to set. - Green component to set. - - - -Constructor to construct a Color with the specified components with the -green, blue and alpha component set to 1.0f. - - Red component to set. - - - -Pure yellow, mix of pure red and green. - - - - -Pure magenta, mix of pure red and blue. - - - - -Pure cyan, mix of pure green and blue. - - - - -Pure blue. - - - - -Pure green. - - - - -Pure red. - - - - -Pure white. - - - - -Dark Gray, darker than gray. - - - - -Gray, halfway between black and white. - - - - -Light Gray, lighter than gray. - - - - -Pure black. - - - - -A static class that contains a set of default Colors. - - - - -CLR version of the the SHADE Engine's Color struct which describes a Color -encoded using floating point numbers that range from 0.0f to 1.0f. - - - - -Creates a inline button widget. -
-Wraps up ImGui::Button(). - - Text to display. - True if button was pressed. - - - -Creates a small inline button widget. -
-Wraps up ImGui::SmallButton(). - - Text to display. - True if button was pressed. - - - -Creates a visual text widget. -
-Wraps up ImGui::Text(). - - Text to display. - - - -Creates a menu item in the list of items for a mini popup. -
-Wraps up ImGui::MenuItem(). - - Label used to identify this widget. - Whether or not the menu item was selected. - - - -Opens the popup that was defined with the specified label. -
-Wraps up ImGui::OpenPopup(). - - - - -Marks the end of a definition of a mini pop up that can show options. -
-Wraps up ImGui::EndPopup(). - - - - -Marks the start of a definition of a mini pop up that can show options. -
-Wraps up ImGui::BeginPopup(). - - Label used to identify this widget. - Whether or not the pop up is open. - - - -Creates a collapsing title header. -
-Wraps up ImGui::CollapsingHeader(). - - Label for the header. - True if the header is open, false otherwise. - - - -Unindents the widgets rendered after this call. -
-Wraps up ImGui::Unindent(). - - - - -Indents the widgets rendered after this call. -
-Wraps up ImGui::Indent(). - - - - -Marks the end of a stack of ImGui widgets from the last PushID() call. -
-Wraps up ImGui::PopID(). - - - - -Marks the start of a stack of ImGui widgets with the specified id. -
-Wraps up ImGui::PushID(). - - Integer-based ID. - - - -Marks the start of a stack of ImGui widgets with the specified id. -
-Wraps up ImGui::PushID(). - - String-based ID. - - - -Maximum length of a string supported by InputTextField() - - - - -Static class that contains useful functions for Editor UI using ImGui. - - - - -Redoes the last undo-ed command if it exists. - - - - -Undos the last added command if it exists. - - - - -Adds a command onto the stack. - - - - - -True if there is a redoable action in the stack. - - - - -True if there is an undoable action in the stack. - - - - -Command for the stack that represents a data modification. - - - - -Class that is able to store a stack of actions that can be done and redone. - - - - -To be called from native code when a Collision Shape has been changed. - - -The entity which has it's collision shape changed. - - - - -To be called from native code when a collision shape has been removed. - - The entity which has it's collision shape removed. - - - -Retrieves a ColliderBound at the specified index in the ColliderBound list -and casts it to the appropriate type. - - Type of the ColliderBound to cast to. - Index to retrieve a ColliderBound from. - ColliderBound for the specified index. - - - -Retrieves a ColliderBound at the specified index in the ColliderBound list. - - Index to retrieve a ColliderBound from. - ColliderBound for the specified index. - - - -Total number of ColliderShapes in the Collider component. - - - - -Constructs a Collider Component that represents a native SHColliderComponent -component tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the the SHADE Engine's SHColliderComponent. -A single Collider component can contain one or multiple Collider Bounds. - - - - - - - - - - -Radius of the Bounding Sphere formed by this bound. - - - - -Center of the Bounding Sphere formed by this bound. - - - - -Sphere-shaped Collider Bound. - - - - - - - - - - -Position of the top right front corner of the Bounding Box formed by this -bound. - - - - -Position of the bottom left back corner of the Bounding Box formed by this -bound. - - - - -Half of the scale of the Bounding Box formed by this bound. - - - - -Center of the Bounding Box formed by this bound. - - - - -Box-shaped Collider Bound. - - - - -Computes a Raycast and checks if there is a collision with any object. - - The ray to cast. - Maximum distance for the raycast check. - True if the ray intersects with an object in the scene. - - - -Checks if the specified point is within this shape's bounds. - - Point to test with. - True if the point is in the shape's bounds. - - - -Base interface for all Collider Shapes. - - - -@brief The density of the collider that determines the mass of the collision shape - if it is automatically computed. Must be a positive number. - - - -@brief The bounciness factor of the physics object., clamped between [0,1].
- 0 means the object will never bounce. - 1 means the object never loses energy on a bounce. - - - -@brief The friction coefficient of the physics object., clamped between [0,1].
- 0 means the object will never experience friction. - 1 means the friction force against the object is equal to the applied force. - - - -@brief Sets the mass density of the physics material. -@param newDensity The density value to set. Always made positive. - - - -@brief Sets the bounciness factor of the physics material. -@param newBounciness The bounciness value to set. Clamped between [0,1]. - - - -@brief Sets the friction coefficient of the physics material. -@param newFriction The friction value to set. Clamped between [0,1]. - - - -@brief Default constructor for a physics material. -@param friction The friction of the material. Clamped between [0,1]. Defaults to 0.4. -@param bounciness The bounciness of the material. Clamped between [0,1]. -@param density The mass density of the material. Always made positive. - - - - -Closes the current window, and depending on the implementation, should also -close the application. - - - - -Retrieves the current window fullscreen status. - - The current window fullscreen status.. - - - -Retrieves the current window height. - - The current window height. - - - -Retrieves the current window width. - - The current window width. - - - -Static class that wraps up certain functions in the SHGraphicsSystem so that -accessing it from SHADE_Managed would not cause issues due to C++20 features. - - - - @brief Perform ImGui and ImGui Backend Render - - - - - @brief Start new frame for editor - - - - - @brief Initialise Backend for ImGui (SDL and Vulkan backend) - - @param sdlWindow Pointer to SDL_Window - - - - @brief Set the Style for the editor - - @param style Desired style - - - - @brief Safely shutdown the editor - - - - - @brief Update the editor and add to ImGui DrawList - - @param dt Delta-time of the frame - - - - @brief Initialise the editor - - @param sdlWindow pointer to SDL_Window object created in application - - - - @brief Style options - - - - - @brief SHEditor static class contains editor variables and implementation of editor functions. - - - - - Get the YUV conversion mode, returning the correct mode for the resolution - when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC - - \since This function is available since SDL 2.0.8. - - - - Get the YUV conversion mode - - \since This function is available since SDL 2.0.8. - - - - Set the YUV conversion mode - - \since This function is available since SDL 2.0.8. - - - - Perform low-level surface scaled blitting only. - - This is a semi-private function and it performs low-level surface blitting, - assuming the input rectangles have already been clipped. - - \param src the SDL_Surface structure to be copied from - \param srcrect the SDL_Rect structure representing the rectangle to be - copied - \param dst the SDL_Surface structure that is the blit target - \param dstrect the SDL_Rect structure representing the rectangle that is - copied into - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitScaled - - - - Perform a scaled surface copy to a destination surface. - - SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is - merely a macro for this function with a less confusing name. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitScaled - - - - Perform bilinear scaling between two surfaces of the same format, 32BPP. - - \since This function is available since SDL 2.0.16. - - - - Perform a fast, low quality, stretch blit between two surfaces of the same - format. - - Please use SDL_BlitScaled() instead. - - \since This function is available since SDL 2.0.0. - - - - Perform low-level surface blitting only. - - This is a semi-private blit function and it performs low-level surface - blitting, assuming the input rectangles have already been clipped. - - Unless you know what you're doing, you should be using SDL_BlitSurface() - instead. - - \param src the SDL_Surface structure to be copied from - \param srcrect the SDL_Rect structure representing the rectangle to be - copied, or NULL to copy the entire surface - \param dst the SDL_Surface structure that is the blit target - \param dstrect the SDL_Rect structure representing the rectangle that is - copied into - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - - - - * Performs a fast blit from the source surface to the destination surface. - * - * This assumes that the source and destination rectangles are - * the same size. If either \c srcrect or \c dstrect are NULL, the entire - * surface (\c src or \c dst) is copied. The final blit rectangles are saved - * in \c srcrect and \c dstrect after all clipping is performed. - * - * \returns 0 if the blit is successful, otherwise it returns -1. - * - * The blit function should not be called on a locked surface. - * - * The blit semantics for surfaces with and without blending and colorkey - * are defined as follows: - * \verbatim - RGBA->RGB: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source alpha-channel and per-surface alpha) - SDL_SRCCOLORKEY ignored. - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy RGB. - if SDL_SRCCOLORKEY set, only copy the pixels matching the - RGB values of the source color key, ignoring alpha in the - comparison. - - RGB->RGBA: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source per-surface alpha) - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy RGB, set destination alpha to source per-surface alpha value. - both: - if SDL_SRCCOLORKEY set, only copy the pixels matching the - source color key. - - RGBA->RGBA: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source alpha-channel and per-surface alpha) - SDL_SRCCOLORKEY ignored. - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy all of RGBA to the destination. - if SDL_SRCCOLORKEY set, only copy the pixels matching the - RGB values of the source color key, ignoring alpha in the - comparison. - - RGB->RGB: - Source surface blend mode set to SDL_BLENDMODE_BLEND: - alpha-blend (using the source per-surface alpha) - Source surface blend mode set to SDL_BLENDMODE_NONE: - copy RGB. - both: - if SDL_SRCCOLORKEY set, only copy the pixels matching the - source color key. - \endverbatim - * - * You should call SDL_BlitSurface() unless you know exactly how SDL - * blitting works internally and how to use the other blit functions. - - Perform a fast blit from the source surface to the destination surface. - - SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a - macro for this function with a less confusing name. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - - - - Perform a fast fill of a set of rectangles with a specific color. - - `color` should be a pixel of the format used by the surface, and can be - generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an - alpha component then the destination is simply filled with that alpha - information, no blending takes place. - - If there is a clip rectangle set on the destination (set via - SDL_SetClipRect()), then this function will fill based on the intersection - of the clip rectangle and `rect`. - - \param dst the SDL_Surface structure that is the drawing target - \param rects an array of SDL_Rects representing the rectangles to fill. - \param count the number of rectangles in the array - \param color the color to fill with - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FillRect - - - - Perform a fast fill of a rectangle with a specific color. - - `color` should be a pixel of the format used by the surface, and can be - generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an - alpha component then the destination is simply filled with that alpha - information, no blending takes place. - - If there is a clip rectangle set on the destination (set via - SDL_SetClipRect()), then this function will fill based on the intersection - of the clip rectangle and `rect`. - - \param dst the SDL_Surface structure that is the drawing target - \param rect the SDL_Rect structure representing the rectangle to fill, or - NULL to fill the entire surface - \param color the color to fill with - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FillRects - - - - Premultiply the alpha on a block of pixels. - - This is safe to use with src == dst, but not for other overlapping areas. - - This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888. - - \param width the width of the block to convert, in pixels - \param height the height of the block to convert, in pixels - \param src_format an SDL_PixelFormatEnum value of the `src` pixels format - \param src a pointer to the source pixels - \param src_pitch the pitch of the source pixels, in bytes - \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format - \param dst a pointer to be filled in with premultiplied pixel data - \param dst_pitch the pitch of the destination pixels, in bytes - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.18. - - - - Copy a block of pixels of one format to another format. - - \param width the width of the block to copy, in pixels - \param height the height of the block to copy, in pixels - \param src_format an SDL_PixelFormatEnum value of the `src` pixels format - \param src a pointer to the source pixels - \param src_pitch the pitch of the source pixels, in bytes - \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format - \param dst a pointer to be filled in with new pixel data - \param dst_pitch the pitch of the destination pixels, in bytes - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - - - Copy an existing surface to a new surface of the specified format enum. - - This function operates just like SDL_ConvertSurface(), but accepts an - SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such, - it might be easier to call but it doesn't have access to palette - information for the destination surface, in case that would be important. - - \param src the existing SDL_Surface structure to convert - \param pixel_format the SDL_PixelFormatEnum that the new surface is - optimized for - \param flags the flags are unused and should be set to 0; this is a - leftover from SDL 1.2's API - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocFormat - \sa SDL_ConvertSurface - \sa SDL_CreateRGBSurface - - - - Copy an existing surface to a new surface of the specified format. - - This function is used to optimize images for faster *repeat* blitting. This - is accomplished by converting the original and storing the result as a new - surface. The new, optimized surface can then be used as the source for - future blits, making them faster. - - \param src the existing SDL_Surface structure to convert - \param fmt the SDL_PixelFormat structure that the new surface is optimized - for - \param flags the flags are unused and should be set to 0; this is a - leftover from SDL 1.2's API - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocFormat - \sa SDL_ConvertSurfaceFormat - \sa SDL_CreateRGBSurface - - - - Get the clipping rectangle for a surface. - - When `surface` is the destination of a blit, only the area within the clip - rectangle is drawn into. - - \param surface the SDL_Surface structure representing the surface to be - clipped - \param rect an SDL_Rect structure filled in with the clipping rectangle for - the surface - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_SetClipRect - - - - Set the clipping rectangle for a surface. - - When `surface` is the destination of a blit, only the area within the clip - rectangle is drawn into. - - Note that blits are automatically clipped to the edges of the source and - destination surfaces. - - \param surface the SDL_Surface structure to be clipped - \param rect the SDL_Rect structure representing the clipping rectangle, or - NULL to disable clipping - \returns SDL_TRUE if the rectangle intersects the surface, otherwise - SDL_FALSE and blits will be completely clipped. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_GetClipRect - - - - Get the blend mode used for blit operations. - - \param surface the SDL_Surface structure to query - \param blendMode a pointer filled in with the current SDL_BlendMode - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_SetSurfaceBlendMode - - - - Set the blend mode used for blit operations. - - To copy a surface to another surface (or texture) without blending with the - existing data, the blendmode of the SOURCE surface should be set to - `SDL_BLENDMODE_NONE`. - - \param surface the SDL_Surface structure to update - \param blendMode the SDL_BlendMode to use for blit blending - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceBlendMode - - - - Get the additional alpha value used in blit operations. - - \param surface the SDL_Surface structure to query - \param alpha a pointer filled in with the current alpha value - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceColorMod - \sa SDL_SetSurfaceAlphaMod - - - - Set an additional alpha value used in blit operations. - - When this surface is blitted, during the blit operation the source alpha - value is modulated by this alpha value according to the following formula: - - `srcA = srcA * (alpha / 255)` - - \param surface the SDL_Surface structure to update - \param alpha the alpha value multiplied into blit operations - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceAlphaMod - \sa SDL_SetSurfaceColorMod - - - - Get the additional color value multiplied into blit operations. - - \param surface the SDL_Surface structure to query - \param r a pointer filled in with the current red color value - \param g a pointer filled in with the current green color value - \param b a pointer filled in with the current blue color value - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceAlphaMod - \sa SDL_SetSurfaceColorMod - - - - Set an additional color value multiplied into blit operations. - - When this surface is blitted, during the blit operation each source color - channel is modulated by the appropriate color value according to the - following formula: - - `srcC = srcC * (color / 255)` - - \param surface the SDL_Surface structure to update - \param r the red color value multiplied into blit operations - \param g the green color value multiplied into blit operations - \param b the blue color value multiplied into blit operations - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetSurfaceColorMod - \sa SDL_SetSurfaceAlphaMod - - - - Get the color key (transparent pixel) for a surface. - - The color key is a pixel of the format used by the surface, as generated by - SDL_MapRGB(). - - If the surface doesn't have color key enabled this function returns -1. - - \param surface the SDL_Surface structure to query - \param key a pointer filled in with the transparent pixel - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_SetColorKey - - - - Returns whether the surface has a color key - - It is safe to pass a NULL `surface` here; it will return SDL_FALSE. - - \param surface the SDL_Surface structure to query - \return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.9. - - \sa SDL_SetColorKey - \sa SDL_GetColorKey - - - - Set the color key (transparent pixel) in a surface. - - The color key defines a pixel value that will be treated as transparent in - a blit. For example, one can use this to specify that cyan pixels should be - considered transparent, and therefore not rendered. - - It is a pixel of the format used by the surface, as generated by - SDL_MapRGB(). - - RLE acceleration can substantially speed up blitting of images with large - horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details. - - \param surface the SDL_Surface structure to update - \param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key - \param key the transparent pixel - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_GetColorKey - - - - Returns whether the surface is RLE enabled - - It is safe to pass a NULL `surface` here; it will return SDL_FALSE. - - \param surface the SDL_Surface structure to query - \returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.14. - - \sa SDL_SetSurfaceRLE - - - - Save a surface to a file. - - Convenience macro. - - Set the RLE acceleration hint for a surface. - - If RLE is enabled, color key and alpha blending blits are much faster, but - the surface must be locked before directly accessing the pixels. - - \param surface the SDL_Surface structure to optimize - \param flag 0 to disable, non-zero to enable RLE acceleration - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_BlitSurface - \sa SDL_LockSurface - \sa SDL_UnlockSurface - - - - Load a surface from a file. - - Convenience macro. - - Save a surface to a seekable SDL data stream in BMP format. - - Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the - BMP directly. Other RGB formats with 8-bit or higher get converted to a - 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit - surface before they are saved. YUV and paletted 1-bit and 4-bit formats are - not supported. - - \param surface the SDL_Surface structure containing the image to be saved - \param dst a data stream to save to - \param freedst non-zero to close the stream after being written - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_LoadBMP_RW - \sa SDL_SaveBMP - - - - Load a BMP image from a seekable SDL data stream. - - The new surface should be freed with SDL_FreeSurface(). Not doing so will - result in a memory leak. - - src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile. - Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap - from a file, convert it to an SDL_Surface and then close the file. - - \param src the data stream for the surface - \param freesrc non-zero to close the stream after being read - \returns a pointer to a new SDL_Surface structure or NULL if there was an - error; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreeSurface - \sa SDL_RWFromFile - \sa SDL_LoadBMP - \sa SDL_SaveBMP_RW - - - - Release a surface after directly accessing the pixels. - - \param surface the SDL_Surface structure to be unlocked - - \since This function is available since SDL 2.0.0. - - \sa SDL_LockSurface - - - - Set up a surface for directly accessing the pixels. - - Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to - and read from `surface->pixels`, using the pixel format stored in - `surface->format`. Once you are done accessing the surface, you should use - SDL_UnlockSurface() to release it. - - Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to - 0, then you can read and write to the surface at any time, and the pixel - format of the surface will not change. - - \param surface the SDL_Surface structure to be locked - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_MUSTLOCK - \sa SDL_UnlockSurface - - - - Set the palette used by a surface. - - A single palette can be shared with many surfaces. - - \param surface the SDL_Surface structure to update - \param palette the SDL_Palette structure to use - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - - - Free an RGB surface. - - It is safe to pass NULL to this function. - - \param surface the SDL_Surface to free. - - \since This function is available since SDL 2.0.0. - - \sa SDL_CreateRGBSurface - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_LoadBMP - \sa SDL_LoadBMP_RW - - - - Allocate a new RGB surface with with a specific pixel format and existing - pixel data. - - This function operates mostly like SDL_CreateRGBSurfaceFrom(), except - instead of providing pixel color masks, you provide it with a predefined - format from SDL_PixelFormatEnum. - - No copy is made of the pixel data. Pixel data is not managed automatically; - you must free the surface before you free the pixel data. - - \param pixels a pointer to existing pixel data - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param pitch the pitch of the surface in bytes - \param format the SDL_PixelFormatEnum for the new surface's pixel format. - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.5. - - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_CreateRGBSurfaceWithFormat - \sa SDL_FreeSurface - - - - Allocate a new RGB surface with existing pixel data. - - This function operates mostly like SDL_CreateRGBSurface(), except it does - not allocate memory for the pixel data, instead the caller provides an - existing buffer of data for the surface to use. - - No copy is made of the pixel data. Pixel data is not managed automatically; - you must free the surface before you free the pixel data. - - \param pixels a pointer to existing pixel data - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param pitch the pitch of the surface in bytes - \param Rmask the red mask for the pixels - \param Gmask the green mask for the pixels - \param Bmask the blue mask for the pixels - \param Amask the alpha mask for the pixels - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_CreateRGBSurface - \sa SDL_CreateRGBSurfaceWithFormat - \sa SDL_FreeSurface - - - - Allocate a new RGB surface with a specific pixel format. - - This function operates mostly like SDL_CreateRGBSurface(), except instead - of providing pixel color masks, you provide it with a predefined format - from SDL_PixelFormatEnum. - - \param flags the flags are unused and should be set to 0 - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param format the SDL_PixelFormatEnum for the new surface's pixel format. - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.5. - - \sa SDL_CreateRGBSurface - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_FreeSurface - - - - Allocate a new RGB surface. - - If `depth` is 4 or 8 bits, an empty palette is allocated for the surface. - If `depth` is greater than 8 bits, the pixel format is set using the - [RGBA]mask parameters. - - The [RGBA]mask parameters are the bitmasks used to extract that color from - a pixel. For instance, `Rmask` being 0xFF000000 means the red data is - stored in the most significant byte. Using zeros for the RGB masks sets a - default value, based on the depth. For example: - - ```c++ - SDL_CreateRGBSurface(0,w,h,32,0,0,0,0); - ``` - - However, using zero for the Amask results in an Amask of 0. - - By default surfaces with an alpha mask are set up for blending as with: - - ```c++ - SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND) - ``` - - You can change this by calling SDL_SetSurfaceBlendMode() and selecting a - different `blendMode`. - - \param flags the flags are unused and should be set to 0 - \param width the width of the surface - \param height the height of the surface - \param depth the depth of the surface in bits - \param Rmask the red mask for the pixels - \param Gmask the green mask for the pixels - \param Bmask the blue mask for the pixels - \param Amask the alpha mask for the pixels - \returns the new SDL_Surface structure that is created or NULL if it fails; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_CreateRGBSurfaceFrom - \sa SDL_CreateRGBSurfaceWithFormat - \sa SDL_FreeSurface - - - -Reference count -- used when freeing surface - - -info for fast blit mapping to other surfaces - - -clipping information - - -list of BlitMap that hold a reference to this surface - - -information needed for surfaces requiring locks - - -Application data associated with the surface - - - \brief A collection of pixels used in software blitting. - - \note This structure should be treated as read-only, except for \c pixels, - which, if not NULL, contains the raw pixel data for the surface. - - -\brief The type of function used for surface blitting functions. - - - - Compose a custom blend mode for renderers. - - The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept - the SDL_BlendMode returned by this function if the renderer supports it. - - A blend mode controls how the pixels from a drawing operation (source) get - combined with the pixels from the render target (destination). First, the - components of the source and destination pixels get multiplied with their - blend factors. Then, the blend operation takes the two products and - calculates the result that will get stored in the render target. - - Expressed in pseudocode, it would look like this: - - ```c - dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor); - dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor); - ``` - - Where the functions `colorOperation(src, dst)` and `alphaOperation(src, - dst)` can return one of the following: - - - `src + dst` - - `src - dst` - - `dst - src` - - `min(src, dst)` - - `max(src, dst)` - - The red, green, and blue components are always multiplied with the first, - second, and third components of the SDL_BlendFactor, respectively. The - fourth component is not used. - - The alpha component is always multiplied with the fourth component of the - SDL_BlendFactor. The other components are not used in the alpha - calculation. - - Support for these blend modes varies for each renderer. To check if a - specific SDL_BlendMode is supported, create a renderer and pass it to - either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will - return with an error if the blend mode is not supported. - - This list describes the support of custom blend modes for each renderer in - SDL 2.0.6. All renderers support the four blend modes listed in the - SDL_BlendMode enumeration. - - - **direct3d**: Supports all operations with all factors. However, some - factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and - `SDL_BLENDOPERATION_MAXIMUM`. - - **direct3d11**: Same as Direct3D 9. - - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all - factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL - 2.0.6. - - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all - factors. Color and alpha factors need to be the same. OpenGL ES 1 - implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT` - and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha - operations being different from each other. May support color and alpha - factors being different from each other. - - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`, - `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT` - operations with all factors. - - **psp**: No custom blend mode support. - - **software**: No custom blend mode support. - - Some renderers do not provide an alpha component for the default render - target. The `SDL_BLENDFACTOR_DST_ALPHA` and - `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this - case. - - \param srcColorFactor the SDL_BlendFactor applied to the red, green, and - blue components of the source pixels - \param dstColorFactor the SDL_BlendFactor applied to the red, green, and - blue components of the destination pixels - \param colorOperation the SDL_BlendOperation used to combine the red, - green, and blue components of the source and - destination pixels - \param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of - the source pixels - \param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of - the destination pixels - \param alphaOperation the SDL_BlendOperation used to combine the alpha - component of the source and destination pixels - \returns an SDL_BlendMode that represents the chosen factors and - operations. - - \since This function is available since SDL 2.0.6. - - \sa SDL_SetRenderDrawBlendMode - \sa SDL_GetRenderDrawBlendMode - \sa SDL_SetTextureBlendMode - \sa SDL_GetTextureBlendMode - - - - Calculate the intersection of a rectangle and line segment with float - precision. - - This function is used to clip a line segment to a rectangle. A line segment - contained entirely within the rectangle or that does not intersect will - remain unchanged. A line segment that crosses the rectangle at either or - both ends will be clipped to the boundary of the rectangle and the new - coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary. - - \param rect an SDL_FRect structure representing the rectangle to intersect - \param X1 a pointer to the starting X-coordinate of the line - \param Y1 a pointer to the starting Y-coordinate of the line - \param X2 a pointer to the ending X-coordinate of the line - \param Y2 a pointer to the ending Y-coordinate of the line - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.22. - - - - Calculate a minimal rectangle enclosing a set of points with float - precision. - - If `clip` is not NULL then only points inside of the clipping rectangle are - considered. - - \param points an array of SDL_FPoint structures representing points to be - enclosed - \param count the number of structures in the `points` array - \param clip an SDL_FRect used for clipping or NULL to enclose all points - \param result an SDL_FRect structure filled in with the minimal enclosing - rectangle - \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the - points were outside of the clipping rectangle. - - \since This function is available since SDL 2.0.22. - - - - Calculate the union of two rectangles with float precision. - - \param A an SDL_FRect structure representing the first rectangle - \param B an SDL_FRect structure representing the second rectangle - \param result an SDL_FRect structure filled in with the union of rectangles - `A` and `B` - - \since This function is available since SDL 2.0.22. - - - - Calculate the intersection of two rectangles with float precision. - - If `result` is NULL then this function will return SDL_FALSE. - - \param A an SDL_FRect structure representing the first rectangle - \param B an SDL_FRect structure representing the second rectangle - \param result an SDL_FRect structure filled in with the intersection of - rectangles `A` and `B` - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.22. - - \sa SDL_HasIntersectionF - - - - Determine whether two rectangles intersect with float precision. - - If either pointer is NULL the function will return SDL_FALSE. - - \param A an SDL_FRect structure representing the first rectangle - \param B an SDL_FRect structure representing the second rectangle - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.22. - - \sa SDL_IntersectRect - - - - Returns true if the two rectangles are equal, using a default epsilon. - - \since This function is available since SDL 2.0.22. - - - - Returns true if the two rectangles are equal, within some given epsilon. - - \since This function is available since SDL 2.0.22. - - - -Returns true if the rectangle has no area. - - - -Returns true if point resides inside a rectangle. - - - - Calculate the intersection of a rectangle and line segment. - - This function is used to clip a line segment to a rectangle. A line segment - contained entirely within the rectangle or that does not intersect will - remain unchanged. A line segment that crosses the rectangle at either or - both ends will be clipped to the boundary of the rectangle and the new - coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary. - - \param rect an SDL_Rect structure representing the rectangle to intersect - \param X1 a pointer to the starting X-coordinate of the line - \param Y1 a pointer to the starting Y-coordinate of the line - \param X2 a pointer to the ending X-coordinate of the line - \param Y2 a pointer to the ending Y-coordinate of the line - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.0. - - - - Calculate a minimal rectangle enclosing a set of points. - - If `clip` is not NULL then only points inside of the clipping rectangle are - considered. - - \param points an array of SDL_Point structures representing points to be - enclosed - \param count the number of structures in the `points` array - \param clip an SDL_Rect used for clipping or NULL to enclose all points - \param result an SDL_Rect structure filled in with the minimal enclosing - rectangle - \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the - points were outside of the clipping rectangle. - - \since This function is available since SDL 2.0.0. - - - - Calculate the union of two rectangles. - - \param A an SDL_Rect structure representing the first rectangle - \param B an SDL_Rect structure representing the second rectangle - \param result an SDL_Rect structure filled in with the union of rectangles - `A` and `B` - - \since This function is available since SDL 2.0.0. - - - - Calculate the intersection of two rectangles. - - If `result` is NULL then this function will return SDL_FALSE. - - \param A an SDL_Rect structure representing the first rectangle - \param B an SDL_Rect structure representing the second rectangle - \param result an SDL_Rect structure filled in with the intersection of - rectangles `A` and `B` - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.0. - - \sa SDL_HasIntersection - - - - Determine whether two rectangles intersect. - - If either pointer is NULL the function will return SDL_FALSE. - - \param A an SDL_Rect structure representing the first rectangle - \param B an SDL_Rect structure representing the second rectangle - \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise. - - \since This function is available since SDL 2.0.0. - - \sa SDL_IntersectRect - - - -Returns true if the two rectangles are equal. - - - -Returns true if the rectangle has no area. - - - -Returns true if point resides inside a rectangle. - - - - A rectangle, with the origin at the upper left (floating point). - - \sa SDL_FRectEmpty - \sa SDL_FRectEquals - \sa SDL_FRectEqualsEpsilon - \sa SDL_HasIntersectionF - \sa SDL_IntersectFRect - \sa SDL_IntersectFRectAndLine - \sa SDL_UnionFRect - \sa SDL_EncloseFPoints - \sa SDL_PointInFRect - - - - A rectangle, with the origin at the upper left (integer). - - \sa SDL_RectEmpty - \sa SDL_RectEquals - \sa SDL_HasIntersection - \sa SDL_IntersectRect - \sa SDL_IntersectRectAndLine - \sa SDL_UnionRect - \sa SDL_EnclosePoints - - - - The structure that defines a point (floating point) - - \sa SDL_EncloseFPoints - \sa SDL_PointInFRect - - - - Use this function to write 64 bits in native format to a SDL_RWops as - big-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in big-endian format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteLE64 - - - - Use this function to write 64 bits in native format to a SDL_RWops as - little-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in little-endian - format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteBE64 - - - - Use this function to write 32 bits in native format to a SDL_RWops as - big-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in big-endian format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteLE32 - - - - Use this function to write 32 bits in native format to a SDL_RWops as - little-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in little-endian - format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteBE32 - - - - Use this function to write 16 bits in native format to a SDL_RWops as - big-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in big-endian format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteLE16 - - - - Use this function to write 16 bits in native format to a SDL_RWops as - little-endian data. - - SDL byteswaps the data only if necessary, so the application always - specifies native format, and the data written will be in little-endian - format. - - \param dst the stream to which data will be written - \param value the data to be written, in native format - \returns 1 on successful write, 0 on error. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteBE16 - - - - \name Write endian functions - - Write an item of native format to the specified endianness. - - Use this function to write a byte to an SDL_RWops. - - \param dst the SDL_RWops to write to - \param value the byte value to write - \returns 1 on success or 0 on failure; call SDL_GetError() for more - information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadU8 - - - - Use this function to read 64 bits of big-endian data from an SDL_RWops and - return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 64 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadLE64 - - - - Use this function to read 64 bits of little-endian data from an SDL_RWops - and return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 64 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadBE64 - - - - Use this function to read 32 bits of big-endian data from an SDL_RWops and - return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 32 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadLE32 - - - - Use this function to read 32 bits of little-endian data from an SDL_RWops - and return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 32 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadBE32 - - - - Use this function to read 16 bits of big-endian data from an SDL_RWops and - return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 16 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadLE16 - - - - Use this function to read 16 bits of little-endian data from an SDL_RWops - and return in native format. - - SDL byteswaps the data only if necessary, so the data returned will be in - the native byte order. - - \param src the stream from which to read data - \returns 16 bits of data in the native byte order of the platform. - - \since This function is available since SDL 2.0.0. - - \sa SDL_ReadBE16 - - - - \name Read endian functions - - Read an item of the specified endianness and return in native format. - - Use this function to read a byte from an SDL_RWops. - - \param src the SDL_RWops to read from - \returns the read byte on success or 0 on failure; call SDL_GetError() for - more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_WriteU8 - - - - Load all the data from a file path. - - The data is allocated with a zero byte at the end (null terminated) for - convenience. This extra byte is not included in the value reported via - `datasize`. - - The data should be freed with SDL_free(). - - Prior to SDL 2.0.10, this function was a macro wrapping around - SDL_LoadFile_RW. - - \param file the path to read all available data from - \param datasize if not NULL, will store the number of bytes read - \returns the data, or NULL if there was an error. - - \since This function is available since SDL 2.0.10. - - - - Load all the data from an SDL data stream. - - The data is allocated with a zero byte at the end (null terminated) for - convenience. This extra byte is not included in the value reported via - `datasize`. - - The data should be freed with SDL_free(). - - \param src the SDL_RWops to read all available data from - \param datasize if not NULL, will store the number of bytes read - \param freesrc if non-zero, calls SDL_RWclose() on `src` before returning - \returns the data, or NULL if there was an error. - - \since This function is available since SDL 2.0.6. - - - - Close and free an allocated SDL_RWops structure. - - SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any - resources used by the stream and frees the SDL_RWops itself with - SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to - flush to its output (e.g. to disk). - - Note that if this fails to flush the stream to disk, this function reports - an error, but the SDL_RWops is still invalid once this function returns. - - Prior to SDL 2.0.10, this function was a macro. - - \param context SDL_RWops structure to close - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWwrite - - - - Write to an SDL_RWops data stream. - - This function writes exactly `num` objects each of size `size` from the - area pointed at by `ptr` to the stream. If this fails for any reason, it'll - return less than `num` to demonstrate how far the write progressed. On - success, it returns `num`. - - SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's - `write` method appropriately, to simplify application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a pointer to an SDL_RWops structure - \param ptr a pointer to a buffer containing data to write - \param size the size of an object to write, in bytes - \param num the number of objects to write - \returns the number of objects written, which will be less than **num** on - error; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - - - - Read from a data source. - - This function reads up to `maxnum` objects each of size `size` from the - data source to the area pointed at by `ptr`. This function may read less - objects than requested. It will return zero when there has been an error or - the data stream is completely read. - - SDL_RWread() is actually a function wrapper that calls the SDL_RWops's - `read` method appropriately, to simplify application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a pointer to an SDL_RWops structure - \param ptr a pointer to a buffer to read data into - \param size the size of each object to read, in bytes - \param maxnum the maximum number of objects to be read - \returns the number of objects read, or 0 at error or end of file; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWseek - \sa SDL_RWwrite - - - - Determine the current read/write offset in an SDL_RWops data stream. - - SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek` - method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify - application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a SDL_RWops data stream object from which to get the current - offset - \returns the current offset in the stream, or -1 if the information can not - be determined. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWwrite - - - - Seek within an SDL_RWops data stream. - - This function seeks to byte `offset`, relative to `whence`. - - `whence` may be any of the following values: - - - `RW_SEEK_SET`: seek from the beginning of data - - `RW_SEEK_CUR`: seek relative to current read point - - `RW_SEEK_END`: seek relative to the end of data - - If this stream can not seek, it will return -1. - - SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's - `seek` method appropriately, to simplify application development. - - Prior to SDL 2.0.10, this function was a macro. - - \param context a pointer to an SDL_RWops structure - \param offset an offset in bytes, relative to **whence** location; can be - negative - \param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END` - \returns the final offset in the data stream after the seek or -1 on error. - - \since This function is available since SDL 2.0.10. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWtell - \sa SDL_RWwrite - - - - Use this function to get the size of the data stream in an SDL_RWops. - - Prior to SDL 2.0.10, this function was a macro. - - \param context the SDL_RWops to get the size of the data stream from - \returns the size of the data stream in the SDL_RWops on success, -1 if - unknown or a negative error code on failure; call SDL_GetError() - for more information. - - \since This function is available since SDL 2.0.10. - - - - Use this function to free an SDL_RWops structure allocated by - SDL_AllocRW(). - - Applications do not need to use this function unless they are providing - their own SDL_RWops implementation. If you just need a SDL_RWops to - read/write a common data source, you should use the built-in - implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and - call the **close** method on those SDL_RWops pointers when you are done - with them. - - Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is - invalid as soon as this function returns. Any extra memory allocated during - creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must - be responsible for managing that memory in their **close** method. - - \param area the SDL_RWops structure to be freed - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocRW - - - - Use this function to allocate an empty, unpopulated SDL_RWops structure. - - Applications do not need to use this function unless they are providing - their own SDL_RWops implementation. If you just need a SDL_RWops to - read/write a common data source, you should use the built-in - implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc. - - You must free the returned pointer with SDL_FreeRW(). Depending on your - operating system and compiler, there may be a difference between the - malloc() and free() your program uses and the versions SDL calls - internally. Trying to mix the two can cause crashing such as segmentation - faults. Since all SDL_RWops must free themselves when their **close** - method is called, all SDL_RWops must be allocated through this function, so - they can all be freed correctly with SDL_FreeRW(). - - \returns a pointer to the allocated memory on success, or NULL on failure; - call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreeRW - - - - Use this function to prepare a read-only memory buffer for use with RWops. - - This function sets up an SDL_RWops struct based on a memory area of a - certain size. It assumes the memory area is not writable. - - Attempting to write to this RWops stream will report an error without - writing to the memory buffer. - - This memory buffer is not copied by the RWops; the pointer you provide must - remain valid until you close the stream. Closing the stream will not free - the original buffer. - - If you need to write to a memory buffer, you should use SDL_RWFromMem() - with a writable buffer of memory instead. - - \param mem a pointer to a read-only buffer to feed an SDL_RWops stream - \param size the buffer size, in bytes - \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - - - - Use this function to prepare a read-write memory buffer for use with - SDL_RWops. - - This function sets up an SDL_RWops struct based on a memory area of a - certain size, for both read and write access. - - This memory buffer is not copied by the RWops; the pointer you provide must - remain valid until you close the stream. Closing the stream will not free - the original buffer. - - If you need to make sure the RWops never writes to the memory buffer, you - should use SDL_RWFromConstMem() with a read-only buffer of memory instead. - - \param mem a pointer to a buffer to feed an SDL_RWops stream - \param size the buffer size, in bytes - \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - \sa SDL_RWwrite - - - - Use this function to create an SDL_RWops structure from a standard I/O file - pointer (stdio.h's `FILE*`). - - This function is not available on Windows, since files opened in an - application on that platform cannot be used by a dynamically linked - library. - - On some platforms, the first parameter is a `void*`, on others, it's a - `FILE*`, depending on what system headers are available to SDL. It is - always intended to be the `FILE*` type from the C runtime's stdio.h. - - \param fp the `FILE*` that feeds the SDL_RWops stream - \param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops, - SDL_FALSE to leave the `FILE*` open when the RWops is - closed - \returns a pointer to the SDL_RWops structure that is created, or NULL on - failure; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFile - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - \sa SDL_RWwrite - - - - \name RWFrom functions - - Functions to create SDL_RWops structures from various data streams. - - Use this function to create a new SDL_RWops structure for reading from - and/or writing to a named file. - - The `mode` string is treated roughly the same as in a call to the C - library's fopen(), even if SDL doesn't happen to use fopen() behind the - scenes. - - Available `mode` strings: - - - "r": Open a file for reading. The file must exist. - - "w": Create an empty file for writing. If a file with the same name - already exists its content is erased and the file is treated as a new - empty file. - - "a": Append to a file. Writing operations append data at the end of the - file. The file is created if it does not exist. - - "r+": Open a file for update both reading and writing. The file must - exist. - - "w+": Create an empty file for both reading and writing. If a file with - the same name already exists its content is erased and the file is - treated as a new empty file. - - "a+": Open a file for reading and appending. All writing operations are - performed at the end of the file, protecting the previous content to be - overwritten. You can reposition (fseek, rewind) the internal pointer to - anywhere in the file for reading, but writing operations will move it - back to the end of file. The file is created if it does not exist. - - **NOTE**: In order to open a file as a binary file, a "b" character has to - be included in the `mode` string. This additional "b" character can either - be appended at the end of the string (thus making the following compound - modes: "rb", "wb", "ab", "r+b", "w+b", "a+b") or be inserted between the - letter and the "+" sign for the mixed modes ("rb+", "wb+", "ab+"). - Additional characters may follow the sequence, although they should have no - effect. For example, "t" is sometimes appended to make explicit the file is - a text file. - - This function supports Unicode filenames, but they must be encoded in UTF-8 - format, regardless of the underlying operating system. - - As a fallback, SDL_RWFromFile() will transparently open a matching filename - in an Android app's `assets`. - - Closing the SDL_RWops will close the file handle SDL is holding internally. - - \param file a UTF-8 string representing the filename to open - \param mode an ASCII string representing the mode to be used for opening - the file. - \returns a pointer to the SDL_RWops structure that is created, or NULL on - failure; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_RWclose - \sa SDL_RWFromConstMem - \sa SDL_RWFromFP - \sa SDL_RWFromMem - \sa SDL_RWread - \sa SDL_RWseek - \sa SDL_RWtell - \sa SDL_RWwrite - - - -Return the size of the file in this rwops, or -1 if unknown - - - Seek to \c offset relative to \c whence, one of stdio's whence values: - RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END - - \return the final offset in the data stream, or -1 on error. - - - Read up to \c maxnum objects each of size \c size from the data - stream to the area pointed at by \c ptr. - - \return the number of objects read, or 0 at error or end of file. - - - Write exactly \c num objects each of size \c size from the area - pointed at by \c ptr to data stream. - - \return the number of objects written, or 0 at error or end of file. - - - Close and free an allocated SDL_RWops structure. - - \return 0 if successful or -1 on write error when flushing data. - - - - Clear any previous error message for this thread. - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetError - \sa SDL_SetError - - - - Get the last error message that was set for the current thread. - - This allows the caller to copy the error string into a provided buffer, but - otherwise operates exactly the same as SDL_GetError(). - - \param errstr A buffer to fill with the last error message that was set for - the current thread - \param maxlen The size of the buffer pointed to by the errstr parameter - \returns the pointer passed in as the `errstr` parameter. - - \since This function is available since SDL 2.0.14. - - \sa SDL_GetError - - - - Retrieve a message about the last error that occurred on the current - thread. - - It is possible for multiple errors to occur before calling SDL_GetError(). - Only the last error is returned. - - The message is only applicable when an SDL function has signaled an error. - You must check the return values of SDL function calls to determine when to - appropriately call SDL_GetError(). You should *not* use the results of - SDL_GetError() to decide if an error has occurred! Sometimes SDL will set - an error string even when reporting success. - - SDL will *not* clear the error string for successful API calls. You *must* - check return values for failure cases before you can assume the error - string applies. - - Error strings are set per-thread, so an error set in a different thread - will not interfere with the current thread's operation. - - The returned string is internally allocated and must not be freed by the - application. - - \returns a message with information about the specific error that occurred, - or an empty string if there hasn't been an error message set since - the last call to SDL_ClearError(). The message is only applicable - when an SDL function has signaled an error. You must check the - return values of SDL function calls to determine when to - appropriately call SDL_GetError(). - - \since This function is available since SDL 2.0.0. - - \sa SDL_ClearError - \sa SDL_SetError - - - - Calculate a 256 entry gamma ramp for a gamma value. - - \param gamma a gamma value where 0.0 is black and 1.0 is identity - \param ramp an array of 256 values filled in with the gamma ramp - - \since This function is available since SDL 2.0.0. - - \sa SDL_SetWindowGammaRamp - - - - Get RGBA values from a pixel in the specified format. - - This function uses the entire 8-bit [0..255] range when converting color - components from pixel formats with less than 8-bits per RGB component - (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, - 0xff, 0xff] not [0xf8, 0xfc, 0xf8]). - - If the surface has no alpha component, the alpha will be returned as 0xff - (100% opaque). - - \param pixel a pixel value - \param format an SDL_PixelFormat structure describing the format of the - pixel - \param r a pointer filled in with the red component - \param g a pointer filled in with the green component - \param b a pointer filled in with the blue component - \param a a pointer filled in with the alpha component - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGB - \sa SDL_MapRGB - \sa SDL_MapRGBA - - - - Get RGB values from a pixel in the specified format. - - This function uses the entire 8-bit [0..255] range when converting color - components from pixel formats with less than 8-bits per RGB component - (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, - 0xff, 0xff] not [0xf8, 0xfc, 0xf8]). - - \param pixel a pixel value - \param format an SDL_PixelFormat structure describing the format of the - pixel - \param r a pointer filled in with the red component - \param g a pointer filled in with the green component - \param b a pointer filled in with the blue component - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGBA - \sa SDL_MapRGB - \sa SDL_MapRGBA - - - - Map an RGBA quadruple to a pixel value for a given pixel format. - - This function maps the RGBA color value to the specified pixel format and - returns the pixel value best approximating the given RGBA color value for - the given pixel format. - - If the specified pixel format has no alpha component the alpha value will - be ignored (as it will be in formats with a palette). - - If the format has a palette (8-bit) the index of the closest matching color - in the palette will be returned. - - If the pixel format bpp (color depth) is less than 32-bpp then the unused - upper bits of the return value can safely be ignored (e.g., with a 16-bpp - format the return value can be assigned to a Uint16, and similarly a Uint8 - for an 8-bpp format). - - \param format an SDL_PixelFormat structure describing the format of the - pixel - \param r the red component of the pixel in the range 0-255 - \param g the green component of the pixel in the range 0-255 - \param b the blue component of the pixel in the range 0-255 - \param a the alpha component of the pixel in the range 0-255 - \returns a pixel value - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGB - \sa SDL_GetRGBA - \sa SDL_MapRGB - - - - Map an RGB triple to an opaque pixel value for a given pixel format. - - This function maps the RGB color value to the specified pixel format and - returns the pixel value best approximating the given RGB color value for - the given pixel format. - - If the format has a palette (8-bit) the index of the closest matching color - in the palette will be returned. - - If the specified pixel format has an alpha component it will be returned as - all 1 bits (fully opaque). - - If the pixel format bpp (color depth) is less than 32-bpp then the unused - upper bits of the return value can safely be ignored (e.g., with a 16-bpp - format the return value can be assigned to a Uint16, and similarly a Uint8 - for an 8-bpp format). - - \param format an SDL_PixelFormat structure describing the pixel format - \param r the red component of the pixel in the range 0-255 - \param g the green component of the pixel in the range 0-255 - \param b the blue component of the pixel in the range 0-255 - \returns a pixel value - - \since This function is available since SDL 2.0.0. - - \sa SDL_GetRGB - \sa SDL_GetRGBA - \sa SDL_MapRGBA - - - - Free a palette created with SDL_AllocPalette(). - - \param palette the SDL_Palette structure to be freed - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocPalette - - - - Set a range of colors in a palette. - - \param palette the SDL_Palette structure to modify - \param colors an array of SDL_Color structures to copy into the palette - \param firstcolor the index of the first palette entry to modify - \param ncolors the number of entries to modify - \returns 0 on success or a negative error code if not all of the colors - could be set; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocPalette - \sa SDL_CreateRGBSurface - - - - Set the palette for a pixel format structure. - - \param format the SDL_PixelFormat structure that will use the palette - \param palette the SDL_Palette structure that will be used - \returns 0 on success or a negative error code on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocPalette - \sa SDL_FreePalette - - - - Create a palette structure with the specified number of color entries. - - The palette entries are initialized to white. - - \param ncolors represents the number of color entries in the color palette - \returns a new SDL_Palette structure on success or NULL on failure (e.g. if - there wasn't enough memory); call SDL_GetError() for more - information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreePalette - - - - Free an SDL_PixelFormat structure allocated by SDL_AllocFormat(). - - \param format the SDL_PixelFormat structure to free - - \since This function is available since SDL 2.0.0. - - \sa SDL_AllocFormat - - - - Create an SDL_PixelFormat structure corresponding to a pixel format. - - Returned structure may come from a shared global cache (i.e. not newly - allocated), and hence should not be modified, especially the palette. Weird - errors such as `Blit combination not supported` may occur. - - \param pixel_format one of the SDL_PixelFormatEnum values - \returns the new SDL_PixelFormat structure or NULL on failure; call - SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_FreeFormat - - - - Convert a bpp value and RGBA masks to an enumerated pixel format. - - This will return `SDL_PIXELFORMAT_UNKNOWN` if the conversion wasn't - possible. - - \param bpp a bits per pixel value; usually 15, 16, or 32 - \param Rmask the red mask for the format - \param Gmask the green mask for the format - \param Bmask the blue mask for the format - \param Amask the alpha mask for the format - \returns one of the SDL_PixelFormatEnum values - - \since This function is available since SDL 2.0.0. - - \sa SDL_PixelFormatEnumToMasks - - - - Convert one of the enumerated pixel formats to a bpp value and RGBA masks. - - \param format one of the SDL_PixelFormatEnum values - \param bpp a bits per pixel value; usually 15, 16, or 32 - \param Rmask a pointer filled in with the red mask for the format - \param Gmask a pointer filled in with the green mask for the format - \param Bmask a pointer filled in with the blue mask for the format - \param Amask a pointer filled in with the alpha mask for the format - \returns SDL_TRUE on success or SDL_FALSE if the conversion wasn't - possible; call SDL_GetError() for more information. - - \since This function is available since SDL 2.0.0. - - \sa SDL_MasksToPixelFormatEnum - - - - Get the human readable name of a pixel format. - - \param format the pixel format to query - \returns the human readable name of the specified pixel format or - `SDL_PIXELFORMAT_UNKNOWN` if the format isn't recognized. - - \since This function is available since SDL 2.0.0. - - - -\note Everything in the pixel format structure is read-only. - - - -The bits of this structure can be directly reinterpreted as an integer-packed -color which uses the SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888 -on little-endian systems and SDL_PIXELFORMAT_RGBA8888 on big-endian systems). - - - - If a + b would overflow, return -1. Otherwise store a + b via ret - and return 0. - - \since This function is available since SDL 2.24.0. - - - - If a * b would overflow, return -1. Otherwise store a * b via ret - and return 0. - - \since This function is available since SDL 2.24.0. - - - - This function converts a string between encodings in one pass, returning a - string that must be freed with SDL_free() or NULL on error. - - \since This function is available since SDL 2.0.0. - - - - Get the number of outstanding (unfreed) allocations - - \since This function is available since SDL 2.0.7. - - - - Replace SDL's memory allocation functions with a custom set - - \since This function is available since SDL 2.0.7. - - - - Get the current set of SDL memory functions - - \since This function is available since SDL 2.0.7. - - - - Get the original set of SDL memory functions - - \since This function is available since SDL 2.24.0. - - - -\endcond - \file begin_code.h - - This file sets things up for C dynamic library function definitions, - static inlined functions, and structures aligned at 4-byte alignment. - If you don't like ugly C preprocessor code, don't look at this file. :) - - - -\name Floating-point constants - -\cond - - -\brief An unsigned 64-bit integer type. - - - -\brief A signed 64-bit integer type. - - - -\brief An unsigned 32-bit integer type. - - - -\brief A signed 32-bit integer type. - - - -\brief An unsigned 16-bit integer type. - - - -\brief A signed 16-bit integer type. - - - -\brief An unsigned 8-bit integer type. - - - -\brief A signed 8-bit integer type. - - - - \file close_code.h - - This file reverses the effects of begin_code.h and should be included - after you finish any function and structure declarations in your headers - - - - \file SDL_stdinc.h - - This is a general header that includes C language support. - - \file SDL_platform.h - - Try to get a standard set of platform defines. - - \file begin_code.h - - This file sets things up for C dynamic library function definitions, - static inlined functions, and structures aligned at 4-byte alignment. - If you don't like ugly C preprocessor code, don't look at this file. :) - - Get the name of the platform. - - Here are the names returned for some (but not all) supported platforms: - - - "Windows" - - "Mac OS X" - - "Linux" - - "iOS" - - "Android" - - \returns the name of the platform. If the correct platform name is not - available, returns a string beginning with the text "Unknown". - - \since This function is available since SDL 2.0.0. - - - -*!************************************************************************* - - - -Marks the application to stop at the end of the current frame. - - - - -Whether or not the application is currently in fullscreen mode or not. - - - - -Retrieves the designated height of the current window. - - - - -Retrieves the designated width of the current window. - - - - -Whether or not the engine is in a paused state where script updates and -physics are not in play. - - - - -Whether or not the engine is playing. This will always be true on Publish. -On Debug/Release builds, this is true when the editor is in Play Mode. It -will also be true even if the editor is in Play Mode but is paused. - - - - -Static class that contains useful properties for querying the state of the -engine. - - - - -Sets the parent of this Transform component. - - -Entity that contains the Transform component that this Transform will be -parented to. If null, unparenting will occur. - - -If true, the transform values of this Transform component will retain their -pre-parent-change global transforms. The local transform values will be -modified to ensure that the global transforms do not change. - - - - -Parent Transform that affects this Transform. - - - - -Global scale stored by this Transform. - - - - -Global euler angle rotations stored by this Transform. - - - - -Global rotation quaternion stored by this Transform. - - - - -Global position stored by this Transform. - - - - -Local scale stored by this Transform. - - - - -Local euler angle rotations stored by this Transform. - - - - -Local rotation quaternion stored by this Transform. - - - - -Local position stored by this Transform. - - - - -Constructs a Transform Component that represents a native Transform component -tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the SHADE Engine's TransformComponent. - - - - -Compares if two float values are close enough to be the same with the -specified tolerance value. - - One of the values to compare. - The other value to compare. - Tolerance for floating point comparison. - True if a and b are practically the same. - - - -Compares if two float values are close enough to be the same with a tolerance -of Epsilon. - - One of the values to compare. - The other value to compare. - True if a and b are practically the same. - - - -Calculates the linear parameter t that produces the interpolant value within -the range [a, b]. - - Start value. - End value. - Value between start and end. - Percentage of value between start and end. - - - -Linearly interpolates between a and b by t. -The parameter t is not clamped and a value based on a and b is supported. -If t is less than zero, or greater than one, then LerpUnclamped will result -in a return value outside the range a to b. - - The start value. - The end value. - The interpolation value between the two float. - The interpolated float result between the two float values. - - - -Linearly interpolates between a and b by t. -The parameter t is clamped to the range [0, 1]. - - The start value. - The end value. - The interpolation value between the two float. - The interpolated float result between the two float values. - - - -Converts an angle from radian representation to degree representation. - - Radian-based angle to convert. - The specified angle in degrees. - - - -Converts an angle from degree representation to radian representation. - - Degree-based angle to convert. - The specified angle in radians. - - - -Wraps a value if they get to low or too high. - - Value to wrap. - Minimum value to wrap at. - Maximum value to wrap at. - Wrapped value. - - - -Small value used for single precision floating point comparisons. - - - - -Radians-to-degrees conversion constant - - - - -Degrees-to-radians conversion constant - - - - -Contains utility Math functions. - - - - -Logs a native exception that is formatted nicely to the output. - - Native exception to log. - Name of the one responsible for the exception. - - - -Logs an exception that is formatted nicely to the output. - - Name of the one responsible for the exception. - Exception to log. - - - -Logs a native exception that is formatted nicely to the output. -Equivalent to calling -LogException(exception, Convert::ToNative(thrower->GetType()->Name)); - - Native exception to log. - -Object that threw the exception to label the exception message. -The name of the object will be used. - - - - -Logs an exception that is formatted nicely to the output. - - Exception to log. - -Object that threw the exception to label the exception message. -The name of the object will be used. - - - - -Logs an exception that is formatted nicely to the output. - - Exception to log. - - - -Logs a error message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the error to label the error message. -The name of the object will be used. - - - - -Logs a error message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the error to label the error message. -The name of the object will be used. - - - - -Logs a error message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Object that threw the error to label the error message. -The name of the object will be used. - - - - -Logs a error message to the output. - - The string to output. - - - -Logs a error message to the output. - - The string to output. - - - -Logs a warning message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the warning to label the warning message. -The name of the object will be used. - - - - -Logs a warning message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that threw the warning to label the warning message. -The name of the object will be used. - - - - -Logs a warning message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Object that threw the warning to label the warning message. -The name of the object will be used. - - - - -Logs a warning message to the output. - - The string to output. - - - -Logs a warning message to the output. - - The string to output. - - - -Logs a message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that sent the message to label the message. -The name of the object will be used. - - - - -Logs a message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Name of the object that sent the message to label the message. -The name of the object will be used. - - - - -Logs a message to the output with a label such that it looks like this: -"[Label] Message" - - The string to output. - -Object that sent the message to label the message. -The name of the object will be used. - - - - -Logs a message to the output. - - The string to output. - - - -Logs a message to the output. - - The string to output. - - - -Static class that contains the functions for working with time. - - - - -Material used to render this Renderable. - - - - -Material used to render this Renderable. - - - - -Mesh used to render this Renderable. - - - - -Constructs a Renderable Component that represents a native Renderable -component tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the SHADE Engine's SHRenderableComponent. - - - - -Retrieves the value of a specified property on the material. - - Type of property to get. - Name of the property to get. - Value of that property on the material. - -If this Material object is invalid. - - -If the name or type was specified that does not match the material's shader's -defined properties. - - - - -Set the value of a specific property. - - Type of property to set. - Name of the property to set. - Value to set te property to. - -If this Material object is invalid. - - -If the name or type was specified that does not match the material's shader's -defined properties. - - - - -Constructor for the Material - - Handle to the native material object. - - - -Managed counterpart of the native MaterialInstance object containing material -data that can be fed to Renderables for rendering. - - - - -Constructor for the Mesh - - Handle to the mesh object. - - - -Managed counterpart of the native Mesh object containing vertex data that can -be fed to Renderables for rendering. - - - -@brief Decomposes a transformation matrix into translation, orientation and scale. -@param[out] scale The scaling factor of the matrix. -@param[out] orientation The orientation of the matrix. -@param[out] translation The translation of the matrix. -@return True if decomposition was successful. - - - -@brief Decomposes a transformation matrix into translation, euler angles and scale. -@param[out] scale The scaling factor of the matrix. -@param[out] rotation The euler angles of the matrix. -@param[out] translation The translation of the matrix. -@return True if decomposition was successful. - - - -@brief Interface for a Column-Major Row Vector 4x4 Matrix. - - - - -Constructs a RigidBody Component that represents a native -SHRigidBodyComponent component tied to the specified Entity. - - Entity that this Component will be tied to. - - - -CLR version of the the SHADE Engine's SHRigidBodyComponent. - - - - -Creates an instance of the Managed representation of a Component with a -native Entity. - - Type of Component to create. - Native Entity that this Component is tied to. - The created Managed representation of the Component. - - - -Static constructor to initialize static data - - - - -Pointer to a function for Component manipulation operations. - - -Contains a set of Component related data used for resolving operations for -each Component. - - - - -Removes a Component from the specified Entity. - - Type of the Component to remove. - -Entity object that should have the specified Component removed from/ - - - - -Checks if the specified Entity has the specified Component. - - Type of the Component to check for. - Entity object to check for the Component. - -True if the specified Entity has the specified Component. False otherwise. - - - - -Ensures a Component on the specified Entity. - - Type of the Component to ensure. - Entity object to ensure the Component on. - Reference to the Component. - - - -Retrieves the first Component from the specified GameObjectt's children that -matches the specified type. - - Type of the Component to get. - Entity object to get the Component from. - -Reference to the Component or null if the Entity does not have the -specified Component. - - - - -Gets a Component from the specified Entity. - - Type of the Component to get. - Entity object to get the Component from. - -Reference to the Component or null if the Entity does not have the -specified Component. - - - - -Adds a Component to the specified Entity. - - Type of the Component to add. - -Entity object that should have the specified Component added to. - - Reference to the Component that was added. - - - -Static class which contains functions that map Pls::ECS's Component manipulation -functions to managed generic functions. - - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Entity that this Component belongs to. - - - - -Constructor for BaseComponent to tie it to a specific Entity. -Constructors of derived Components should call this Constructor. - - Entity that this Component will be tied to. - - - -Implicit conversion operator to enable checking if a component is null. - - Component to check. - - - -Removes all Scripts of the specified type from this GameObject. - - Type of PLushieScripts to remove. - - - -Retrieves a immutable list of Scripts of the specified type from this -GameObject. - - Type of Scripts to Get. - Immutable list of Scripts of the specified type. - - - -Retrieves a Script of the specified type from this GameObject. -If multiple Scripts of the same specified type are added on the same -GameObject, this will retrieve the first one added. - - Type of Script to add. - Reference to the Script to retrieve. - - - -Adds a Script of the specified type to this GameObject. - - Type of Script to add. - Reference to the created Script. - - - -Removes a Component from this GameObject. If no Component exists to begin -with, nothing happens. - - Type of the Component to get. - - - -Gets a Component from this GameObject. - - Type of the Component to get. - -Reference to the Component or null if this GameObject does not have the -specified Component. - - - - -Adds a Component to this GameObject. - - Type of the Component to add. - Reference to the Component that was added. - - - -Retrieves the GameObject that this Component belongs to. - - - - -Class that serves as the base for a wrapper class to Components in native code. - - - - -Called when the attached GameObject has a Collider and leaves a -collision with another GameObject with a Collider2D. - - Information on the collision event. - - - -Called when the attached GameObject has a Collider and collides with -another GameObject with a Collider in subsequent frames of collision. - - Information on the collision event. - - - -Called when the attached GameObject has a Collider and collides with -another GameObject with a Collider in the first frame of collision. - - Information on the collision event. - - - -Called when the attached GameObject has a trigger Collider and leaves a -collision with another GameObject with a Collider2D. - - Information on the collision event. - - - -Called when the attached GameObject has a trigger Collider and collides with -another GameObject with a Collider in subsequent frames of collision. - - Information on the collision event. - - - -Called when the attached GameObject has a trigger Collider and collides with -another GameObject with a Collider in the first frame of collision. - - Information on the collision event. - - - -Called just before the end of the frame where the attached GameObject or -this script is destroyed directly or indirectly due to destruction of the -owner. - - - - -Called every frame after physics and collision resolution but before -rendering. - - - - -Called every frame before physics and collision resolution. - - - - -Called every frame in sync with Physics update steps and thus in most cases -will execute more than update() will. This will be called immediately before -a Physics update step. - - - - -Called on the first frame that the attached GameObject is active but always -after Awake(). - - - - -Called on the first frame that the attached GameObject is active if they are -a part of the scene. - - - - -Called immediately once this script is detached from a GameObject. - - - - -Called immediately once this script is attached to a GameObject. - - - - -Constructor for Script to tie it to a specific GameObject. -Constructors of derived Scripts should call this Constructor. - - -GameObject that this Script will be tied to. - - - - -Used to call onTriggerExit(). This should be called when a trigger-type -collision is detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onTriggerStay(). This should be called when a trigger-type -collision is detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onTriggerEnter(). This should be called when a trigger-type -collision is detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onCollisionExit(). This should be called when a collision ends -between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onCollisionStay(). This should be called when a collision is -persistent between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onCollisionEnter(). This should be called when a collision is -detected between the attached GameObject and another GameObject. - - Information on the collision event. - - - -Used to call onDestroy(). This should be called at the end of the frame -where the attached GameObject or this script is destroyed directly or -indirectly due to destruction of the owner. - - - - -Used to call lateUpdate(). This should be called every frame after physics -and collision resolution but before rendering. - - - - -Used to call update(). This should be called every frame before physics and -collision resolution. - - - - -Used to call fixedUpdate(). This should be called in sync with Physics -update steps and thus in most cases will execute more than Update() will. -This will be called immediately before a Physics update step. - - - - -Used to call start(). This should be called on the first frame that the -attached GameObject is active but always after Awake(). - - - - -Used to call awake(). This should be called on the first frame that the -attached GameObject is active if they are a part of the scene. - - - - -Used to call onDetached(). This is called immediately when this script is -detached from a GameObject. - - - - -Used to call onAttached(). This is called immediately when this script is -attached to a GameObject. - - - - -Implicit conversion operator to enable checking if a component is null. - - Component to check. - - - -Removes all Scripts of the specified type from this GameObject. - - -Type of script to remove. -This needs to be a default constructable Script. - - - - -Retrieves a immutable list of scripts from the specified Entity that -matches the specified type. -
-Note that this function allocates. It should be used sparingly. - - -Type of scripts to get. -This needs to be a default constructable Script. - - -Immutable list of references to scripts of the specified type. - - - - -Retrieves the first Script from this GameObject's children that matches the -specified type. - - -Type of script to get. -This needs to be a default constructable Script. - - Reference to the script added - - - -Retrieves the first Script from this GameObject that matches the specified -type. - - -Type of script to get. -This needs to be a default constructable Script. - - Reference to the script added - - - -Adds a Script to this GameObject. - - -Type of script to add. -This needs to be a default constructable Script. - - Reference to the script added - - - -Removes a Component from the GameObject that this Script belongs to. - - -Type of the Component to remove. Must be derived from BaseComponent. - - - - -Ensures a Component on the GameObject that this Script belongs to. - - -Type of the Component to ensure. Must be derived from BaseComponent. - - Reference to the Component. - - - -Retrieves the first Component from this GameObject's children that matches -the specified type. - - -Type of the Component to get. Must be derived from BaseComponent. - - Reference to the Component that was retrieved. - - - -Gets a Component from the GameObject that this Script belongs to. - - -Type of the Component to get. Must be derived from BaseComponent. - - Reference to the Component that was retrieved. - - - -Adds a Component to the GameObject that this Script belongs to. - - -Type of the Component to add. Must be derived from BaseComponent. - - Reference to the Component that was added. - - - -GameObject that this Script belongs to. - - - - -Class that forms the basis of all "script"-objects that can be attached to -Entities to update each Entity's Components via C# code. - - - - -The RigidBody that you are colliding with. - - - - -The CollisionShape of the Collider that you are colliding with. - - - - -The Collider that you are colliding with. - - - - -The GameObject whose collider you are colliding with. - - - - -Struct that describes a collision - - - - -Checks if two GameObject references are different. - - GameObject to check. - Another GameObject to check with. - True if both Components are different. - - - -Checks if two GameObject references are the same. - - GameObject to check. - Another GameObject to check with. - True if both Components are the same. - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Retrieves the native Entity object that this GameObject represents. - - Native Entity object that this GameObject represents. - - - -Retrieves the CLR Entity object that this GameObject represents. - - Entity object that this GameObject represents. - - - -Constructor for the GameObject. - - -Managed numerical representation of the ECS Entity that this GameObject -should represent. - - - - -Constructor for the GameObject. - - -The ECS Entity that this GameObject should represent. - - - - -Removes all Scripts of the specified type from this GameObject. - - Type of PLushieScripts to remove. - - - -Retrieves a immutable list of Scripts of the specified type from this -GameObject. - - Type of Scripts to retrieve. - Immutable list of Scripts of the specified type. - - - -Retrieves a Script of the specified type from child GameObjects. -If multiple Scripts of the same specified type are added on the same -child GameObject, this will retrieve the first one added. - - Type of Script to retrieve. - Reference to the Script to retrieve. - - - -Retrieves a Script of the specified type from this GameObject. -If multiple Scripts of the same specified type are added on the same -GameObject, this will retrieve the first one added. - - Type of Script to retrieve. - Reference to the Script to retrieve. - - - -Adds a Script of the specified type to this GameObject. - - Type of Script to add. - Reference to the created Script. - - - -Removes a Component from this GameObject. If no Component exists to begin -with, nothing happens. - - Type of the Component to get. - - - -Ensures a Component on this GameObject. - - Type of the Component to ensure. - -Reference to the Component. - - - - -Retrieves the first Component from this GameObject's children that matches -the specified type. - - Type of the Component to get. - -Reference to the Component or null if neither of this GameObject's children -does not have the specified Component. - - - - -Gets a Component from this GameObject. - - Type of the Component to get. - -Reference to the Component or null if this GameObject does not have the -specified Component. - - - - -Adds a Component to this GameObject. - - Type of the Component to add. - Reference to the Component that was added. - - - -Sets the active state of this GameObject. -
-The actual "activeness" of this GameObject is still dependent on the parents' -active states. - - -Whether to activate or deactivate this GameObject. - - - - -Sets the name of this GameObject. - - The name to set. - - - -Native Entity ID value for this GameObject. - - - - -Whether or not this Entity is active in the Scene hierarchy. - - - - -Whether or not this Entity alone, is active. This does not mean that this -object is active in the scene. For example, if this Entity's parent is not -active, then this Entity would also be not active. - - - - -Name of the object that this Entity represents. - - - - -Retrieves a GameObject with the specified name. If there are multiple -GameObjects with the same name, the first found GameObject will be retrieved. -There is no guaranteed order of which GameObject is considered "first". - - Name of the GameObject to find. - GameObject that has the specified name. Null if not found. - - - -Destroys the specified GameObject. Note that the specified GameObject will no -longer be a valid GameObject after this function is called. - - The GameObject to be destroyed. - - - -Creates a new GameObject in the current Scene. If multiple Scenes are loaded, -and you would like to create an object in a specific Scene, call the Scene's -CreateGameObject(). - - GameObject that represents the newly created GameObject. - - - -Lightweight object for an PlushieEngine Entity that allows for easy access -to Component and Script operations. - - - - -Constructor for a Tooltip attribute that fills in the description. - - Text to be shown when a field is hovered. - - - -Maximum value for the Ranged field. - - - - -Minimum value for the Ranged field. - - - - -Simple attribute to constrain the range of values for a field on the editor. - - - - -Converts from a native std::Stringto a managed String. - - The native std::string to convert from. - Managed copy of a native std::string. - - - -Converts from a managed String to a native std::string. - - The managed String to convert from. - Native copy of a managed String. - - - -Converts from a native Vector2 to a managed Vector2. - - The native Vector2 to convert from. - Managed copy of a native Vector2. - - - -Converts from a native Quaternion to a managed Quaternion. - - The native Quaternion to convert from. - Managed copy of a native Quaternion. - - - -Converts from a managed Quaternion to a native Quaternion. - - The managed Quaternion to convert from. - Native copy of a managed Quaternion. - - - -Converts from a native Vector2 to a managed Vector2. - - The native Vector2 to convert from. - Managed copy of a native Vector2. - - - -Converts from a managed Vector2 to a native Vector2. - - The managed Vector2 to convert from. - Native copy of a managed Vector2. - - - -Converts from a native Vector3 to a managed Vector3. - - The native Vector3 to convert from. - Managed copy of a native Vector3. - - - -Converts from a managed Vector3 to a native Vector3. - - The managed Vector3 to convert from. - Native copy of a managed Vector3. - - - -Converts from a native Entity to a managed Entity (UInt32). - - Native Entity to convert from. - Managed representation of the specified Entity. - - - -Provides functions easy and consistent syntax for converting between custom -managed and native types that are aligned. - - - - -Converts to true if this is a valid Handle. - - - - -The library that the handle was issued by. - - - - -The internal ID of the handle. - - - - -Creates a ray starting at origin along direction. - - Source of the ray. - Direction the ray travels in. - - - -The direction that a ray travels in. - - - - -The start point of the ray. - - - - -CLR version of the the SHADE Engine's Ray class that represents a ray in -3-Dimensional space. - - - - -Are two quaternions equal to each other? - - Left-hand side quaternion. - Right-hand side quaternion. - - - -Combines rotations lhs and rhs. - - Left-hand side quaternion. - Right-hand side quaternion. - - - -Spherically interpolates between a and b by t. The parameter t is not clamped. - - - - -Spherically interpolates between quaternions a and b by ratio t. The parameter t is clamped to the range [0, 1]. - - Start value, returned when t = 0. - End value, returned when t = 1. - Interpolation ratio. - A quaternion spherically interpolated between quaternions a and b. - - - -Rotates a rotation from towards to.
-The from quaternion is rotated towards to by an angular step of maxDegreesDelta (but note that the rotation will not overshoot). -Negative values of maxDegreesDelta will move away from to until the rotation is exactly the opposite direction. - - - - -Converts this quaternion to one with the same orientation but with a magnitude of 1. - - - - -Creates a rotation with the specified forward and upwards directions.
-Z axis will be aligned with forward, X axis aligned with cross product between forward and upwards, and Y axis aligned with cross product between Z and X. - - - - -Interpolates between a and b by t and normalizes the result afterwards. The parameter t is not clamped. - - - - -Interpolates between a and b by t and normalizes the result afterwards. The parameter t is clamped to the range [0, 1]. - - Start value, returned when t = 0. - End value, returned when t = 1. - Interpolation ratio. - A quaternion interpolated between quaternions a and b. - - - -Returns the Inverse of rotation. - - - - -Creates a rotation which rotates from fromDirection to toDirection. - - - - -Returns a rotation that rotates y degrees around the y axis, x degrees around the x axis, and z degrees around the z axis; applied in that order. - - - - -The dot product between two rotations. - - - - -Creates a rotation which rotates angle degrees around axis. - - - - -Returns the angle in degrees between two rotations a and b.
 - The angle in degrees between the two vectors. - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Converts a rotation to angle-axis representation (angles in degrees). - - - - -Creates a rotation with the specified forward and upwards directions.
-The result is applied to this quaternion. -If used to orient a Transform, the Z axis will be aligned with forward and the Y axis with upwards, assuming these vectors are orthogonal. -Logs an error if the forward direction is zero. - - The direction to look in. - The vector that defines in which direction up is. - - - -Creates a rotation which rotates from fromDirection to toDirection.
-Use this to create a rotation which starts at the first Vector (fromDirection) and rotates to the second Vector (toDirection). -These Vectors must be set up in a script. - - - - -Constructor to construct a Quaternion with the specified components. - - X-coordinate to set. - Y-coordinate to set. - Z-coordinate to set. - W-coordinate to set. - - - -W-component of the Quaternion. Do not directly modify quaternions. - - - - -Z-component of the Quaternion. -Don't modify this directly unless you know quaternions inside out. - - - - -Y-component of the Quaternion. -Don't modify this directly unless you know quaternions inside out. - - - - -X-component of the Quaternion. -Don't modify this directly unless you know quaternions inside out. - - - - -Shorthand for writing Quaternion(0, 0, 0, 1). - - - - -CLR version of SHADE's Quaternion class that represents an orientation. -Designed to closely match Unity's Quaternion struct. - - - - -Explicit conversion operator to enable explicit casting from a Vector2 to a -Vector3. - - Vector2 to convert from. - - - -Explicit conversion operator to enable explicit casting from a Vector3 to a -Vector2. - - Vector3 to convert from. - - - -Checks if two Vector3s are not approximately equal. This is equivalent to -calling !Vector3.IsNear() with default tolerance values. - - Vector3 to compare. - Another Vector3 to compare. - -True if all components are not approximately equal within the default -tolerance value. - - - - -Checks if two Vector3s are approximately equal. This is equivalent to -calling Vector3.IsNear() with default tolerance values. - - Vector3 to compare. - Another Vector3 to compare. - -True if all components are approximately equal within the default -tolerance value. - - - - -Calculates the division of a Vector3 with a scalar value and returns -the result. - - Scalar to divide with. - Vector3 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector3 with a scalar value and returns -the result. - - Vector3 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the division of a Vector3 with a scalar value and returns -the result. - - Scalar to divide with. - Vector3 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector3 with a scalar value and returns -the result. - - Vector3 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the component-wise multiplication of two Vector3s and returns the -result. - - Vector3 to multiply with. - Another Vector3 to multiply with. - The result of rhs subtracted from lhs. - - - -Subtracts a Vector3 from another Vector3 and returns the result. - - Vector3 to subtract from. - Another Vector3 to subtract. - The result of rhs subtracted from lhs. - - - -Adds two Vector3s together and returns the result. - - Vector3 to add. - Another Vector3 to add. - The result of lhs added to rhs - - - -Moves a point current towards target. -Similar to Lerp(), however, the function will ensure that the distance never -exceeds maxDistanceDelta. Negative values of maxDistanceDelta pushes the -vector away from target - - The current position of the point. - The target position to move to. - Maximum distance moved per call. - Vector representing the moved point. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. -Unlike Lerp(), t is not clamped to a range at all. - - The start Vector3, returned when t = 0.0f. - The end Vector3, returned when t = 1.0f. - Value used to interpolate between a and b. - The interpolated Vector3. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. - - The start Vector3, returned when t = 0.0f. - The end Vector3, returned when t = 1.0f. - -Value used to interpolate between a and b which is clamped to -the range[0, 1]. - - The interpolated Vector3. - - - -Computes and returns a Vector3 that is made from the largest components of -the two specified Vector3s. - - Vector3 to calculate maximum Vector3 with. - Another Vector3 to calculate maximum Vector3 with. - -The Vector3 that contains the largest components of the two specified -Vector3s. - - - - -Computes and returns a Vector3 that is made from the smallest components of -the two specified Vector3s. - - Vector3 to calculate minimum Vector3 with. - Another Vector3 to calculate minimum Vector3 with. - -The Vector3 that contains the smallest components of the two specified -Vector3s. - - - - -Rotates a Vector3 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector3 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in degrees. - - The Vector3 that represents the rotated vector. - - - -Rotates a Vector3 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector3 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in radians. - - The Vector3 that represents the rotated vector. - - - -Reflects a Vector3 across another Vector3. - - A Vector3 to reflect. - A normal to reflect the Vector3 across. - The Vector3 that represents vec reflected across normal. - - - -Computes and returns a Vector3 projection. - - Vector3 to project. - Vector3 to project onto. - The Vector3 that represents the projected vec onto direction. - - - -Computes and returns the cross product of 2 specified Vector3s. - - Vector3 to calculate cross product with. - Another Vector3 to calculate cross product with. - The cross product of the two Vector3s. - - - -Computes and returns the dot product of 2 specified Vector3s. - - Vector3 to calculate dot product with. - Another Vector3 to calculate dot product with. - Scalar value representing the dot product of the two Vector3s. - - - -Checks if two specified Vector3s are near in value. - - Vector3 to check if is near in value. - Another Vector3 to check if is near in value. - Amount of tolerance to do the comparison with. - -True if the two Vector3s are within the tolerance value specified - - - - -Checks if two specified Vector3s are near in value. - - Vector3 to check if is near in value. - Another Vector3 to check if is near in value. - -True if the two Vector3s are within the tolerance value specified - - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Checks if a specified point is near this Vector3 that represents a point. - - The other point to check if we are near. - -The amount of tolerance before we consider these points as "near". - - -True if this Vector3 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Checks if a specified point is near this Vector3 that represents a point with -a tolerance value of PLS_EPSILON. - - The other point to check if we are near. - -True if this Vector3 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -180.0f and 180.0f. - - Returns the angle of this vector from the right vector in degrees. - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -Math.PI and Math.PI. - - Returns the angle of this vector from the right vector in radians. - - - -Calculates and returns the squared magnitude of this Vector3. - - Returns the squared length of this Vector3. - - - -Calculates and returns the magnitude of this Vector3. Note that this function -incurs a performance cost from the square root calculation. If you do not -need the precise magnitude, consider using GetSqrMagnitude() instead. - - Returns the length of this Vector3. - - - -Creates a copy of this Vector3 and returns a normalized version. - - -Returns a normalised copy of this Vector3. -If this Vector3 is a zero vector, a zero vector will be returned. - - - - -Normalises this current Vector3. This changes the data of this Vector3. -If you would like to get a copy, use GetNormalised() instead. -This function does nothing to a zero vector. - - - - -Conversion constructor to construct a Vector3 using a Vector2. - - - - - -Constructor to construct a Vector3 with the specified components. - - X-coordinate to set. - Y-coordinate to set. - Z-coordinate to set. - - - -Constructor to construct a Vector3 with the specified components with the -Z-component set to 0.0f. - - X-coordinate to set. - Y-coordinate to set. - - - -Constructor to construct a Vector3 with the specified components with the -Y and Z-component set to 0.0f. - - X-coordinate to set. - - - -Z-component of the Vector3. - - - - -Y-component of the Vector3. - - - - -X-component of the Vector3. - - - - -Shorthand for writing Vector3(0, 0, 0). - - - - -Shorthand for writing Vector3(0, 1, 0). - - - - -Shorthand for writing Vector3(1, 0, 0). - - - - -Shorthand for writing Vector3(float.PositiveInfinity, -float.PositiveInfinity, float.PositiveInfinity). - - - - -Shorthand for writing Vector3(1, 1, 1). - - - - -Shorthand for writing Vector3(float.NegativeInfinity, -float.NegativeInfinity, float.NegativeInfinity). - - - - -Shorthand for writing Vector3(-1, 0, 0). - - - - -Shorthand for writing Vector3(0, 0, 1). - - - - -Shorthand for writing Vector3(0, -1, 0). - - - - -Shorthand for writing Vector3(0, 0, -1). - - - - -CLR version of SHADE Engine's Vector3 class that represents a 3-Dimensional Vector. -Designed to closely match Unity's Vector3 struct. - - - - -Checks if two Vector2s are not approximately equal. This is equivalent to -calling !Vector2.IsNear() with default tolerance values. - - Vector2 to compare. - Another Vector2 to compare. - -True if all components are not approximately equal within the default -tolerance value. - - - - -Checks if two Vector2s are approximately equal. This is equivalent to -calling Vector2.IsNear() with default tolerance values. - - Vector2 to compare. - Another Vector2 to compare. - -True if all components are approximately equal within the default -tolerance value. - - - - -Calculates the division of a Vector2 with a scalar value and returns -the result. - - Scalar to divide with. - Vector2 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector2 with a scalar value and returns -the result. - - Vector2 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the division of a Vector2 with a scalar value and returns -the result. - - Scalar to divide with. - Vector2 to divide with. - The result of the scalar division. - - - -Calculates the multiplication of a Vector2 with a scalar value and returns -the result. - - Vector2 to multiply with. - Scalar to multiply with. - The result of the scalar multiplication. - - - -Calculates the component-wise multiplication of two Vector2s and returns the -result. - - Vector2 to multiply with. - Another Vector2 to multiply with. - The result of rhs subtracted from lhs. - - - -Subtracts a Vector2 from another Vector2 and returns the result. - - Vector2 to subtract from. - Another Vector2 to subtract. - The result of rhs subtracted from lhs. - - - -Adds two Vector2s together and returns the result. - - Vector2 to add. - Another Vector2 to add. - The result of lhs added to rhs - - - -Moves a point current towards target. -Similar to Lerp(), however, the function will ensure that the distance never -exceeds maxDistanceDelta. Negative values of maxDistanceDelta pushes the -vector away from target - - The current position of the point. - The target position to move to. - Maximum distance moved per call. - Vector representing the moved point. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. -Unlike Lerp(), t is not clamped to a range at all. - - The start Vector2, returned when t = 0.0f. - The end Vector2, returned when t = 1.0f. - Value used to interpolate between a and b. - The interpolated Vector2. - - - -Linearly interpolates between two specified points. -This is most commonly used to find a point some fraction of the way along a -line between two endpoints. - - The start Vector2, returned when t = 0.0f. - The end Vector2, returned when t = 1.0f. - -Value used to interpolate between a and b which is clamped to -the range[0, 1]. - - The interpolated Vector2. - - - -Computes and returns a Vector2 that is made from the largest components of -the two specified Vector2s. - - Vector2 to calculate maximum Vector2 with. - Another Vector2 to calculate maximum Vector2 with. - -The Vector2 that contains the largest components of the two specified -Vector2s. - - - - -Computes and returns a Vector2 that is made from the smallest components of -the two specified Vector2s. - - Vector2 to calculate minimum Vector2 with. - Another Vector2 to calculate minimum Vector2 with. - -The Vector2 that contains the smallest components of the two specified -Vector2s. - - - - -Rotates a Vector2 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector2 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in degrees. - - The Vector2 that represents the rotated vector. - - - -Rotates a Vector2 on the Z-axis by a specified angle in an anti-clockwise -direction. - - A Vector2 to rotate. - -Angle to rotate the vector by in an anti-clockwise direction in radians. - - The Vector2 that represents the rotated vector. - - - -Reflects a Vector2 across another Vector2. - - A Vector2 to reflect. - A normal to reflect the Vector2 across. - The Vector2 that represents vec reflected across normal. - - - -Computes and returns a Vector2 projection. - - Vector2 to project. - Vector2 to project onto. - The Vector2 that represents the projected vec onto direction. - - - -Computes a perpendicular Vector2 to the specified Vector2. - - Vector2 to find a perpendicular of. - -Whether the inward perpendicular Vector is retrieved. If true, the -resultant vector is rotated 90-degrees in a counter-clockwise. - - The perpendicular Vector2 relative to the specified Vector2. - - - - -Computes the inward perpendicular Vector2 to the specified Vector2. -Equivalent to calling Perpendicular(lhs, true). This means, the -resultant Vector2 is rotated 90-degrees in a counter-clockwise. - - Vector2 to find a perpendicular of. - -The perpendicular Vector2 relative to the specified Vector2. - - - - -Computes and returns the dot product of 2 specified Vector2s. - - Vector2 to calculate dot product with. - Another Vector2 to calculate dot product with. - -Scalar value representing the dot product of the two Vector2s. - - - - -Checks if two specified Vector2s are near in value. - - Vector2 to check if is near in value. - Another Vector2 to check if is near in value. - -Amount of tolerance to do the comparison with. - - -True if the two Vector2s are within the tolerance value specified - - - - -Checks if two specified Vector2s are near in value. - - Vector2 to check if is near in value. - Another Vector2 to check if is near in value. - -True if the two Vector2s are within the tolerance value specified - - - - -Gets a unique hash for this object. - - Unique hash for this object. - - - -Compares equality with another unboxed object. - - The unboxed object to compare with. - True if both objects are the same. - - - -Compares equality with an object of the same type. - - The object to compare with. - True if both objects are the same. - - - -Checks if a specified point is near this Vector2 that represents a point. - - The other point to check if we are near. - -The amount of tolerance before we consider these points as "near". - - -True if this Vector2 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Checks if a specified point is near this Vector2 that represents a point with -a tolerance value of PLS_EPSILON. - - The other point to check if we are near. - -True if this Vector2 representing a point and the specified point are within -the range of the specified tolerance. False otherwise. - - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -180.0f and 180.0f. - - Returns the angle of this vector from the right vector in degrees. - - - -Calculates and returns the angle of this vector from the right vector. This -function returns values between -Math.PI and Math.PI. - - Returns the angle of this vector from the right vector in radians. - - - -Calculates and returns the squared magnitude of this Vector2. - - Returns the squared length of this Vector2. - - - -Calculates and returns the magnitude of this Vector2. Note that this function -incurs a performance cost from the square root calculation. If you do not -need the precise magnitude, consider using GetSqrMagnitude() instead. - - Returns the length of this Vector2. - - - -Creates a copy of this Vector2 and returns a normalized version. - - -Returns a normalised copy of this Vector2. -If this Vector2 is a zero vector, a zero vector will be returned. - - - - -Normalises this current Vector2. This changes the data of this Vector2. -If you would like to get a copy, use GetNormalised() instead. -This function does nothing to a zero vector. - - - - -Constructor to construct a Vector2 with the specified components.. - - X-coordinate to set. - Y-coordinate to set. - - - -Constructor to construct a Vector2 with the specified components with the -Y-component set to 0.0f. - - X-coordinate to set. - - - -Y-component of the Vector2. - - - - -X-component of the Vector2. - - - - -Shorthand for writing Vector2(0, 0). - - - - -Shorthand for writing Vector2(0, 1). - - - - -Shorthand for writing Vector2(1, 0). - - - - -Shorthand for writing Vector2(float.PositiveInfinity, -float.PositiveInfinity). - - - - -Shorthand for writing Vector2(1, 1). - - - - -Shorthand for writing Vector2(float.NegativeInfinity, -float.NegativeInfinity). - - - - -Shorthand for writing Vector2(-1, 0). - - - - -Shorthand for writing Vector2(0, -1). - - - - -CLR version of SHADE Engine's Vector2 class that represents a 2-Dimensional Vector. -Designed to closely match Unity's Vector2 struct. - - - - -Checks if the specified entity is valid. This is done by checking if it -matches Pls::Entity::INVALID. - - The Entity to check. - True if the specified Entity is valid. - - - -Static class that contains useful utility functions for working with Entity. - - - - -Manages all resources in multiple ResourceLibraries. - - - - -Base class for SHResourceLibrary that holds information about the library type. - - - - -Template Specialization for Handle that represents a type-less Handle. - - - - -Converts to true if this is a valid Handle. - - - - -Native ID type of a handle - - - - -Base implementation of the Handle that is not templated to allow for holding -generic non-type-specific Handles. - - - - -Exception thrown when a generic Handle is being casted to the wrong type. - - - - -Exception thrown when an invalid Handle was dereferenced. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/premake5.lua b/premake5.lua index 35bff9d2..2164d649 100644 --- a/premake5.lua +++ b/premake5.lua @@ -30,4 +30,5 @@ workspace "SHADE" --include "Dependencies/tracy" include "Dependencies/yamlcpp" include "Dependencies/reactphysics3d" + include "Dependencies/ModelCompiler" group ""