Minor performance improvement

Pjbomb2 · Pjbomb2 · commit 804325d6cfcf · 2024-11-07T17:26:37.000-07:00
Super minor performance improvement to the gaussian tree
diff --git a/TrueTrace/DemoScene.asset b/TrueTrace/DemoScene.asset
@@ -19,7 +19,7 @@ MonoBehaviour:
   UseRussianRoulette: 1
   UseNEE: 1
   DoTLASUpdates: 1
-  Accumulate: 0
+  Accumulate: 1
   PPBloom: 0
   BloomStrength: 0.372
   PPDoF: 0
@@ -31,7 +31,7 @@ MonoBehaviour:
   PPToneMap: 1
   PPTAA: 0
   RenderScale: 1
-  DenoiserMethod: 1
+  DenoiserMethod: 0
   UpscalerMethod: 2
   ReSTIRGIUpdateRate: 7
   UseReSTIRGITemporal: 1
diff --git a/TrueTrace/DemoScene.unity b/TrueTrace/DemoScene.unity
@@ -8856,7 +8856,7 @@ GameObject:
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &388393756
 Transform:
   m_ObjectHideFlags: 0
@@ -8905,7 +8905,7 @@ MeshRenderer:
   m_RenderingLayerMask: 1
   m_RendererPriority: 0
   m_Materials:
-  - {fileID: 1360625002}
+  - {fileID: 1073644332}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
@@ -8957,6 +8957,7 @@ MonoBehaviour:
   IntersectBackFacing: 0
   MaxStepCount: 1000
   MinValidSize: 0.01
+  FramesSinceStart: 0
   GenShader: {fileID: 7200000, guid: 7981b89bc7490e249a79ecb4b0a63c8d, type: 3}
   Rend: {fileID: 388393758}
 --- !u!64 &388613071
@@ -15245,7 +15246,7 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   MaterialOptions: 00000000
   TransmissionColor:
-  - {x: 0, y: 0, z: 0}
+  - {x: 1, y: 1, z: 1}
   BaseColor:
   - {x: 1, y: 1, z: 1}
   MetallicRemap:
@@ -23597,6 +23598,34 @@ MeshFilter:
   m_CorrespondingSourceObject: {fileID: -5940954344850330600, guid: 16500a523b718314091d7e9b83146c62, type: 3}
   m_PrefabInstance: {fileID: 1770587712}
   m_PrefabAsset: {fileID: 0}
+--- !u!21 &1073644332
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Unlit/TTSDFShader
+  m_Shader: {fileID: 4800000, guid: eb7fd76a4d67a9542b324c9861b9cc66, type: 3}
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats: []
+    m_Colors: []
+  m_BuildTextureStacks: []
 --- !u!64 &1074459676
 MeshCollider:
   m_ObjectHideFlags: 0
@@ -29047,34 +29076,6 @@ Transform:
   m_CorrespondingSourceObject: {fileID: 3775568952777743791, guid: 16500a523b718314091d7e9b83146c62, type: 3}
   m_PrefabInstance: {fileID: 1770587712}
   m_PrefabAsset: {fileID: 0}
---- !u!21 &1360625002
-Material:
-  serializedVersion: 8
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_Name: Unlit/TTSDFShader
-  m_Shader: {fileID: 4800000, guid: eb7fd76a4d67a9542b324c9861b9cc66, type: 3}
-  m_ValidKeywords: []
-  m_InvalidKeywords: []
-  m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
-  disabledShaderPasses: []
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs:
-    - _MainTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    m_Ints: []
-    m_Floats: []
-    m_Colors: []
-  m_BuildTextureStacks: []
 --- !u!64 &1362832271
 MeshCollider:
   m_ObjectHideFlags: 0
diff --git a/TrueTrace/Resources/Builders/CommonVars.cs b/TrueTrace/Resources/Builders/CommonVars.cs
@@ -38,6 +38,7 @@ public struct GaussianTreeNode {
         public float sharpness;
         public float intensity;
         public int left;
+        // public float pad;
     }
 
     [System.Serializable]
diff --git a/TrueTrace/Resources/Builders/LightBVHBuilder.cs b/TrueTrace/Resources/Builders/LightBVHBuilder.cs
@@ -279,7 +279,31 @@ private void Refit2(int Depth, int CurrentIndex) {
             Refit2(Depth + 1, nodes[CurrentIndex].left + 1);
         }
 
-  
+        float expm1_over_x(float x)
+        {
+            float u = Mathf.Exp(x);
+
+            if (u == 1.0f)
+            {
+                return 1.0f;
+            }
+
+            float y = u - 1.0f;
+
+            if (Mathf.Abs(x) < 1.0f)
+            {
+                return y / Mathf.Log(u);
+            }
+
+            return y / x;
+        }
+
+        float SGIntegral(float sharpness)
+        {
+            return 4.0f * Mathf.PI * expm1_over_x(-2.0f * sharpness);
+        }
+
+
         public unsafe LightBVHBuilder(List<LightTriData> Tris, List<Vector3> Norms, float phi, List<float> LuminanceWeights) {//need to make sure incomming is transformed to world space already
             PrimCount = Tris.Count;          
             MaxDepth = 0;
@@ -426,6 +450,7 @@ public unsafe LightBVHBuilder(List<LightTriData> Tris, List<Vector3> Norms, floa
                         TempNode.S.Radius = radius;
 
                         TempNode.left = LBVHNode.left;
+                        // TempNode.pad = intensity / (variance * SGIntegral(TempNode.sharpness));
                         SGTree[WriteIndex] = TempNode;
                     }
                 }
@@ -577,6 +602,7 @@ public LightBVHBuilder(LightBounds[] Tris,ref GaussianTreeNode[] SGTree, LightBV
                         }
 
                         TempNode.left = LBVHNode.left;
+                        // TempNode.pad = TempNode.intensity / (TempNode.variance * SGIntegral(TempNode.sharpness));
                         SGTree[WriteIndex] = TempNode;
                     }
                 }
diff --git a/TrueTrace/Resources/MainCompute/CommonData.cginc b/TrueTrace/Resources/MainCompute/CommonData.cginc
@@ -1274,7 +1274,6 @@ inline float VMFHemisphericalIntegral(const float cosine, const float sharpness)
 	return lerp(e, 1.0, lerpFactor) / (e + 1.0);
 }
 
-
 struct SGLobe {
 	float3 axis ;
 	float sharpness ;
@@ -1304,7 +1303,7 @@ inline float UpperSGClampedCosineIntegralOverTwoPi(const float sharpness)
 		return (((((((-1.0 / 362880.0) * sharpness + 1.0 / 40320.0) * sharpness - 1.0 / 5040.0) * sharpness + 1.0 / 720.0) * sharpness - 1.0 / 120.0) * sharpness + 1.0 / 24.0) * sharpness - 1.0 / 6.0) * sharpness + 0.5;
 	}
 
-	return (expm1(-sharpness) + sharpness) / (sharpness * sharpness);
+	return (expm1(-sharpness) + sharpness) * rcp(sharpness * sharpness);
 }
 
 // [Tokuyoshi et al. 2024 "Hierarchical Light Sampling with Accurate Spherical Gaussian Lighting (Supplementary Document)" Listing. 6]
@@ -1319,7 +1318,7 @@ inline float LowerSGClampedCosineIntegralOverTwoPi(const float sharpness)
 		return e * (((((((((1.0 / 403200.0) * sharpness - 1.0 / 45360.0) * sharpness + 1.0 / 5760.0) * sharpness - 1.0 / 840.0) * sharpness + 1.0 / 144.0) * sharpness - 1.0 / 30.0) * sharpness + 1.0 / 8.0) * sharpness - 1.0 / 3.0) * sharpness + 0.5);
 	}
 
-	return e * (-expm1(-sharpness) - sharpness * e) / (sharpness * sharpness);
+	return e * (-expm1(-sharpness) - sharpness * e) * rcp(sharpness * sharpness);
 }
 
 // Approximate product integral of an SG and clamped cosine / pi.
@@ -1354,28 +1353,28 @@ inline float SGClampedCosineProductIntegralOverPi2024(const float cosine, const
 		const float B5 = 4.90735564e-3;
 		const float B6 = -5.58853149e-4;
 
-
+		float a;
 		if (abs(tz) >= 4.0) {
 			ERFCTZ = mulsign(1.0, -tz);
 		} else if (abs(tz) > 1.0) {
-			const float a = abs(tz);
-			const float y = 1.0 - exp2(-(((((((A7 * a + A6) * a + A5) * a + A4) * a + A3) * a + A2) * a + A1) * a));
+			a = abs(tz);
+			a = 1.0 - exp2(-(((((((A7 * a + A6) * a + A5) * a + A4) * a + A3) * a + A2) * a + A1) * a));
 
-			ERFCTZ = mulsign(y, -tz);
+			ERFCTZ = mulsign(a, -tz);
 		} else {
-			const float x2 = tz * tz;
-			ERFCTZ = (((((B6 * x2 + B5) * x2 + B4) * x2 + B3) * x2 + B2) * x2 + B1) * -tz;
+			a = tz * tz;
+			ERFCTZ = (((((B6 * a + B5) * a + B4) * a + B3) * a + B2) * a + B1) * -tz;
 		}
 
 		[branch]if (t >= 4.0) {
 			ERFCT = mulsign(1.0, t);
 		} else if (t > 1.0) {
-			const float y = 1.0 - exp2(-(((((((A7 * t + A6) * t + A5) * t + A4) * t + A3) * t + A2) * t + A1) * t));
+			a = 1.0 - exp2(-(((((((A7 * t + A6) * t + A5) * t + A4) * t + A3) * t + A2) * t + A1) * t));
 
-			ERFCT = mulsign(y, t);
+			ERFCT = mulsign(a, t);
 		} else {
-			const float x2 = t * t;
-			ERFCT = (((((B6 * x2 + B5) * x2 + B4) * x2 + B3) * x2 + B2) * x2 + B1) * t;
+			a = t * t;
+			ERFCT = (((((B6 * a + B5) * a + B4) * a + B3) * a + B2) * a + B1) * t;
 		}
 		ERFCT = 1.0f - ERFCT;
 		ERFCTZ = 1.0f - ERFCTZ;
@@ -1386,7 +1385,7 @@ inline float SGClampedCosineProductIntegralOverPi2024(const float cosine, const
 
 
 
-	const float lerpFactor = saturate(max(0.5 * (cosine * ERFCTZ + ERFCT) - 0.5 * INV_SQRTPI * exp(-tz * tz) * expm1(t * t * (cosine * cosine - 1.0)) / t, CLAMPING_THRESHOLD));
+	const float lerpFactor = saturate(max(0.5f * (cosine * ERFCTZ + ERFCT) - 0.5f * INV_SQRTPI * exp(-tz * tz) * expm1(t * t * (cosine * cosine - 1.0)) * rcp(t), CLAMPING_THRESHOLD));
 
 	// Interpolation between lower and upper hemispherical integrals.
 	const float lowerIntegral = LowerSGClampedCosineIntegralOverTwoPi(sharpness);
@@ -1410,7 +1409,7 @@ inline float SGGX(const float3 m, const float2x2 roughnessMat)
 // [Tokuyoshi et al. 2024 "Hierarchical Light Sampling with Accurate Spherical Gaussian Lighting", Section 5.2]
 inline float SGGXReflectionPDF(const float3 wi, const float3 m, const float2x2 roughnessMat)
 {
-	return SGGX(m, roughnessMat) / max(4.0 * sqrt(dot(wi.xz, mul(roughnessMat, wi.xz)) + wi.y * wi.y), EPSILON); // TODO: Use Kahan's algorithm for precise mul and dot. [https://pharr.org/matt/blog/2019/11/03/difference-of-floats]
+	return SGGX(m, roughnessMat) * rcp(max(4.0 * sqrt(dot(wi.xz, mul(roughnessMat, wi.xz)) + wi.y * wi.y), EPSILON)); // TODO: Use Kahan's algorithm for precise mul and dot. [https://pharr.org/matt/blog/2019/11/03/difference-of-floats]
 }
 
 
@@ -1427,10 +1426,10 @@ inline float expm1_over_x(const float x)
 
 	if (abs(x) < 1.0)
 	{
-		return y / log(u);
+		return y * rcp(log(u));
 	}
 
-	return y / x;
+	return y * rcp(x);
 }
 
 
@@ -1455,33 +1454,29 @@ inline float SGIntegral(const float sharpness)
 
 	*/
 
-inline bool IsFinite(float x)
+bool IsFinite(float x)
 {
     return (asuint(x) & 0x7F800000) != 0x7F800000;
 }
 
-inline float SGImportance(const GaussianTreeNode TargetNode, const float3 viewDir, const float3 p, const float3 n, const float2 projRoughness2, const float reflecSharpness, const float3x3 tangentFrame, const float metallic) {
+inline float SGImportance(const GaussianTreeNode TargetNode, const float3 viewDirTS, const float3 p, const float3 n, const float2 projRoughness2, const float3 reflecVec, const float3x3 tangentFrame) {
 	// if(TargetNode.intensity <= 0) return 0;	
 	float3 to_light = TargetNode.position - p;
 	const float squareddist = dot(to_light, to_light);
 
-	const float c = clamp(dot(n, -(to_light)) / sqrt(squareddist), 0, 1);
+	// const float c = clamp(dot(n, -(to_light)) / sqrt(squareddist), 0, 1);
 
 	// Compute the Jacobian J for the transformation between halfvetors and reflection vectors at halfvector = normal.
-	const float3 viewDirTS = mul(tangentFrame, viewDir);//their origional one constructs the tangent frame from N,T,BT, whereas mine constructs it from T,N,BT; problem? I converted all .y to .z and vice versa, but... 
+	// const float3 viewDirTS = mul(tangentFrame, viewDir);//their origional one constructs the tangent frame from N,T,BT, whereas mine constructs it from T,N,BT; problem? I converted all .y to .z and vice versa, but... 
 
 	const float vlen = length(viewDirTS.xz);
 	const float2 v = (vlen != 0.0) ? (viewDirTS.xz / vlen) : float2(1.0, 0.0);
-	const float2x2 reflecJacobianMat = mul(float2x2(v.x, -v.y, v.y, v.x), float2x2(0.5, 0.0, 0.0, 0.5 / viewDirTS.y));
+	const float2x2 reflecJacobianMat = mul(float2x2(v.x, -v.y, v.y, v.x), float2x2(0.5, 0.0, 0.0, 0.5f / viewDirTS.y));
 
 	// Compute JJ^T matrix.
 	const float2x2 jjMat = mul(reflecJacobianMat, transpose(reflecJacobianMat));
-	const float detJJ4 = 1.0 / (4.0 * viewDirTS.y * viewDirTS.y); // = 4 * determiant(JJ^T).
+	const float detJJ4 = rcp(4.0 * viewDirTS.y * viewDirTS.y); // = 4 * determiant(JJ^T).
 
-	// Preprocess for the lobe visibility.
-	// Approximate the reflection lobe with an SG whose axis is the perfect specular reflection vector.
-	// We use a conservative sharpness to filter the visibility.
-	const float3 reflecVec = reflect(-viewDir, n) * reflecSharpness;
 
 	// TargetNode.variance = 0.5f * TargetNode.radius * TargetNode.radius;
 	const float Variance = max(TargetNode.variance, (1.0f / pow(2, 31)) * squareddist);// * (1.0f - c) + 0.5f * (TargetNode.radius * TargetNode.radius) * c;
@@ -1517,11 +1512,11 @@ inline float SGImportance(const GaussianTreeNode TargetNode, const float3 viewDi
 	// NDF filtering in a numerically stable manner.
 	// See the supplementary document (Section 5.2) of the paper for the derivation.
 	const float tr = filteredProjRoughnessMat._11 + filteredProjRoughnessMat._22;
-	const float2x2 filteredRoughnessMat = IsFinite(1.0 + tr + det) ? min(filteredProjRoughnessMat + float2x2(det, 0.0, 0.0, det), FLT_MAX) / (1.0 + tr + det) : (float2x2(min(filteredProjRoughnessMat._11, FLT_MAX) / min(filteredProjRoughnessMat._11 + 1.0, FLT_MAX), 0.0, 0.0, min(filteredProjRoughnessMat._22, FLT_MAX) / min(filteredProjRoughnessMat._22 + 1.0, FLT_MAX)));
+	const float2x2 filteredRoughnessMat = min(filteredProjRoughnessMat + float2x2(det, 0.0, 0.0, det), FLT_MAX) * rcp(1.0 + tr + det);//IsFinite(1.0 + tr + det) ? min(filteredProjRoughnessMat + float2x2(det, 0.0, 0.0, det), FLT_MAX) / (1.0 + tr + det) : (float2x2(min(filteredProjRoughnessMat._11, FLT_MAX) / min(filteredProjRoughnessMat._11 + 1.0, FLT_MAX), 0.0, 0.0, min(filteredProjRoughnessMat._22, FLT_MAX) / min(filteredProjRoughnessMat._22 + 1.0, FLT_MAX)));
 
 	// Evaluate the filtered distribution.
 	const float3 halfvecUnormalized = viewDirTS + mul(tangentFrame, LightLobe.axis);
-	const float3 halfvec = halfvecUnormalized / max(length(halfvecUnormalized), EPSILON);
+	const float3 halfvec = halfvecUnormalized * rsqrt(max(dot(halfvecUnormalized, halfvecUnormalized), EPSILON));
 	const float pdf = SGGXReflectionPDF(viewDirTS, halfvec, filteredRoughnessMat);
 
 	// Visibility of the SG light in the upper hemisphere.
@@ -1625,6 +1620,8 @@ void CalcLightPDF(inout float lightPDF, float3 p, float3 p2, float3 n, const int
 	const float2 roughness2 = sharpness * sharpness;
 	const float2 ProjRoughness2 = roughness2 / max(1.0 - roughness2, EPSILON);
 	const float reflecSharpness = (1.0 - max(roughness2.x, roughness2.y)) / max(2.0f * max(roughness2.x, roughness2.y), EPSILON);
+	float3 viewDirTS = mul(tangentFrame, viewDir);//their origional one constructs the tangent frame from N,T,BT, whereas mine constructs it from T,N,BT; problem? I converted all .y to .z and vice versa, but... 
+	float3 reflecVec = reflect(-viewDir, n) * reflecSharpness;
 
 	while(Reps < 100) {
 		Reps++;
@@ -1636,8 +1633,8 @@ void CalcLightPDF(inout float lightPDF, float3 p, float3 p2, float3 n, const int
 		[branch]if(node.left >= 0) {
 #ifdef UseSGTree
 			const float2 ci = float2(
-				SGImportance(SGTree[node.left + NodeOffset], viewDir, p, n, ProjRoughness2, reflecSharpness, tangentFrame, metallic),
-				SGImportance(SGTree[node.left + 1 + NodeOffset], viewDir, p, n, ProjRoughness2, reflecSharpness, tangentFrame, metallic)
+				SGImportance(SGTree[node.left + NodeOffset], viewDirTS, p, n, ProjRoughness2, reflecVec, tangentFrame),
+				SGImportance(SGTree[node.left + 1 + NodeOffset], viewDirTS, p, n, ProjRoughness2, reflecVec, tangentFrame)
 			);
 #else
 			const float2 ci = float2(
@@ -1688,10 +1685,12 @@ void CalcLightPDF(inout float lightPDF, float3 p, float3 p2, float3 n, const int
 			    float3 Scale = pow(rcp(float3(scalex, scaley, scalez)),2);
 				n = normalize(mul(_MeshData[MeshIndex].W2L, float4(n,0)).xyz / Scale);
 				viewDir = normalize(mul(_MeshData[MeshIndex].W2L, float4(viewDir,0)).xyz / Scale);
+				tangentFrame = GetTangentSpace2(n);//Need to maybe check to see if this holds up when the traversal backtracks due to dead end
+				viewDirTS = mul(tangentFrame, viewDir);
+				reflecVec = reflect(-viewDir, n) * reflecSharpness;
 				NodeOffset = _MeshData[MeshIndex].LightNodeOffset;
 				node_index = NodeOffset;
 				HasHitTLAS = true;
-				tangentFrame = GetTangentSpace2(n);//Need to maybe check to see if this holds up when the traversal backtracks due to dead end
 				if(MeshIndex != _LightMeshes[-(node.left+1)].LockedMeshIndex) {
 					lightPDF = 1;
 					return;
@@ -1719,6 +1718,8 @@ int SampleLightBVH(float3 p, float3 n, inout float pmf, const int pixel_index, i
 	const float2 roughness2 = sharpness * sharpness;
 	const float2 ProjRoughness2 = roughness2 / max(1.0 - roughness2, EPSILON);
 	const float reflecSharpness = (1.0 - max(roughness2.x, roughness2.y)) / max(2.0f * max(roughness2.x, roughness2.y), EPSILON);
+	float3 viewDirTS = mul(tangentFrame, viewDir);//their origional one constructs the tangent frame from N,T,BT, whereas mine constructs it from T,N,BT; problem? I converted all .y to .z and vice versa, but... 
+	float3 reflecVec = reflect(-viewDir, n) * reflecSharpness;
 	float RandNum = random(264 + Reps, pixel_index).x;
 	while(Reps < 222) {
 		Reps++;
@@ -1730,8 +1731,8 @@ int SampleLightBVH(float3 p, float3 n, inout float pmf, const int pixel_index, i
 		[branch]if(node.left >= 0) {
 #ifdef UseSGTree
 			const float2 ci = float2(
-				SGImportance(SGTree[node.left + NodeOffset], viewDir, p, n, ProjRoughness2, reflecSharpness, tangentFrame, metallic),
-				SGImportance(SGTree[node.left + 1 + NodeOffset], viewDir, p, n, ProjRoughness2, reflecSharpness, tangentFrame, metallic)
+				SGImportance(SGTree[node.left + NodeOffset], viewDirTS, p, n, ProjRoughness2, reflecVec, tangentFrame),
+				SGImportance(SGTree[node.left + 1 + NodeOffset], viewDirTS, p, n, ProjRoughness2, reflecVec, tangentFrame)
 			);
 #else
 			const float2 ci = float2(
@@ -1774,6 +1775,8 @@ int SampleLightBVH(float3 p, float3 n, inout float pmf, const int pixel_index, i
 				n = normalize(mul(_MeshData[MeshIndex].W2L, float4(n,0)).xyz / Scale);
 				viewDir = normalize(mul(_MeshData[MeshIndex].W2L, float4(viewDir,0)).xyz / Scale);
 				tangentFrame = GetTangentSpace2(n);
+				viewDirTS = mul(tangentFrame, viewDir);
+				reflecVec = reflect(-viewDir, n) * reflecSharpness;
 				NodeOffset = _MeshData[MeshIndex].LightNodeOffset;
 				node_index = NodeOffset;
 				HasHitTLAS = true;
diff --git a/TrueTrace/Resources/MainCompute/CommonStructs.cginc b/TrueTrace/Resources/MainCompute/CommonStructs.cginc
diff --git a/TrueTrace/Resources/Utility/BVHRefitter.compute b/TrueTrace/Resources/Utility/BVHRefitter.compute

Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,7 @@ public struct GaussianTreeNode {`
`38`	`38`	`public float sharpness;`
`39`	`39`	`public float intensity;`
`40`	`40`	`public int left;`
	`41`	`+ // public float pad;`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`[System.Serializable]`