浏览代码

First draft

/Improve-shader-generator
Sebastien Lagarde 7 年前
当前提交
ea8ce865
共有 8 个文件被更改,包括 106 次插入257 次删除
  1. 4
      ScriptableRenderPipeline/Core/CoreRP/Editor/ShaderGenerator/CSharpToHLSL.cs
  2. 71
      ScriptableRenderPipeline/Core/CoreRP/Editor/ShaderGenerator/ShaderTypeGeneration.cs
  3. 9
      ScriptableRenderPipeline/Core/CoreRP/ShaderGenerator/ShaderGeneratorAttributes.cs
  4. 261
      ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs
  5. 4
      ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Builtin/BuiltinData.cs
  6. 6
      ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.cs
  7. 4
      ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs
  8. 4
      ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.cs

4
ScriptableRenderPipeline/Core/CoreRP/Editor/ShaderGenerator/CSharpToHLSL.cs


writer.Write("\n#endif\n");
// User can specify a custom file to add at the end of the generated file by creating a file name: "filename.custom.hlsl" in the same directory
writer.Write(Environment.NewLine); // TODO: we should use this everywhere ?
}
}
}

71
ScriptableRenderPipeline/Core/CoreRP/Editor/ShaderGenerator/ShaderTypeGeneration.cs


return mergedFields;
}
public static readonly string[] CoordString = { "X", "Y", "Z", "W" };
public string EmitTypeDecl()
{
string shaderText = string.Empty;

shaderText += "struct " + type.Name + "\n";
shaderText += "{\n";
foreach (var shaderFieldInfo in m_PackedFields)
if (attr.packingRules == PackingRules.AtomicElement)
{
foreach (var shaderFieldInfo in m_PackedFields)
{
if (shaderFieldInfo.cols == 0)
{
for (int i = 0; i < shaderFieldInfo.rows; ++i)
{
shaderText += " " + PrimitiveToString(shaderFieldInfo.type, 0, 0) + " " + shaderFieldInfo.name + CoordString[i];
}
}
else
{
for (int i = 0; i < shaderFieldInfo.rows; ++i)
{
for (int j = 0; j < shaderFieldInfo.cols; ++j)
{
shaderText += " " + PrimitiveToString(shaderFieldInfo.type, 0, 0) + " " + shaderFieldInfo.name + CoordString[i] + CoordString[j];
}
}
}
shaderText += "\n";
}
}
else
shaderText += " " + shaderFieldInfo.ToString() + "\n";
foreach (var shaderFieldInfo in m_PackedFields)
{
shaderText += " " + shaderFieldInfo.ToString() + "\n";
}
}
shaderText += "};\n";

}
}
shaderText += "\treturn value." + acc.name + swizzle + ";\n";
if (attr.packingRules == PackingRules.AtomicElement)
{
shaderText += "\treturn " + PrimitiveToString(shaderField.type, shaderField.rows, shaderField.cols) + "(";
if (shaderField.cols == 0)
{
for (int i = 0; i < shaderField.rows; ++i)
{
shaderText += "value." + shaderField.name + CoordString[i];
if (i < shaderField.rows - 1)
shaderText += ", ";
}
}
else
{
for (int i = 0; i < shaderField.rows; ++i)
{
for (int j = 0; j < shaderField.cols; ++j)
{
shaderText += "value." + shaderField.name + CoordString[i] + CoordString[j];
if (i < shaderField.rows - 1 || j < shaderField.cols - 1)
shaderText += ", ";
}
}
}
shaderText += ";\n";
}
else
{
shaderText += "\treturn value." + acc.name + swizzle + ";\n";
}
shaderText += "}\n";
}

public bool needAccessors
{
get { return attr.needAccessors; }
get { return attr.packingRules != PackingRules.AtomicElement; }
}
public bool needParamDebug
{

9
ScriptableRenderPipeline/Core/CoreRP/ShaderGenerator/ShaderGeneratorAttributes.cs


{
public enum PackingRules
{
Exact,
Aggressive
Exact, // Do nothing
AtomicElement, // Generate accessor to access element that are declare as individual parameters (i.e vecX, vecY, vecZ instead of vec)
Aggressive // ?
};
[AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class | AttributeTargets.Enum)]

public bool needAccessors; // Whether or not to generate the accessors
public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needParamDebug = false, int paramDefinesStart = 1)
public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needParamDebug = false, int paramDefinesStart = 1)
this.needAccessors = needAccessors;
this.needParamDebug = needParamDebug;
this.paramDefinesStart = paramDefinesStart;
}

261
ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs


};
// These structures share between C# and hlsl need to be align on float4, so we pad them.
[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
[GenerateHLSL]
public struct DirectionalLightData
{

public Vector4 shadowMaskSelector; // Use with ShadowMask feature
};
[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
[GenerateHLSL]
public struct LightData
{

// It allow to have more coherence for the dynamic if in shader code.
// Users can also chose to not have any projection, in this case we use the property minProjectionDistance to minimize code change. minProjectionDistance is set to huge number
// that simulate effect of no shape projection
[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
public float capturePositionWSX;
public float capturePositionWSY;
public float capturePositionWSZ;
public Vector3 capturePositionWS;
public float proxyExtentsX;
public float proxyExtentsY;
public float proxyExtentsZ;
public Vector3 proxyExtents;
public float proxyPositionWSX;
public float proxyPositionWSY;
public float proxyPositionWSZ;
public float proxyForwardX;
public float proxyForwardY;
public float proxyForwardZ;
public float proxyUpX;
public float proxyUpY;
public float proxyUpZ;
public float proxyRightX;
public float proxyRightY;
public float proxyRightZ;
public Vector3 proxyPositionWS;
public Vector3 proxyForward;
public Vector3 proxyUp;
public Vector3 proxyRight;
public float influencePositionWSX;
public float influencePositionWSY;
public float influencePositionWSZ;
public float influenceForwardX;
public float influenceForwardY;
public float influenceForwardZ;
public float influenceUpX;
public float influenceUpY;
public float influenceUpZ;
public float influenceRightX;
public float influenceRightY;
public float influenceRightZ;
public Vector3 influencePositionWS;
public Vector3 influenceForward;
public Vector3 influenceUp;
public Vector3 influenceRight;
public float influenceExtentsX;
public float influenceExtentsY;
public float influenceExtentsZ;
public Vector3 influenceExtents;
public float blendDistancePositiveX;
public float blendDistancePositiveY;
public float blendDistancePositiveZ;
public float blendDistanceNegativeX;
public float blendDistanceNegativeY;
public float blendDistanceNegativeZ;
public float blendNormalDistancePositiveX;
public float blendNormalDistancePositiveY;
public float blendNormalDistancePositiveZ;
public float blendNormalDistanceNegativeX;
public float blendNormalDistanceNegativeY;
public float blendNormalDistanceNegativeZ;
public Vector3 blendDistancePositive;
public Vector3 blendDistanceNegative;
public Vector3 blendNormalDistancePositive;
public Vector3 blendNormalDistanceNegative;
public float boxSideFadePositiveX;
public float boxSideFadePositiveY;
public float boxSideFadePositiveZ;
public float boxSideFadeNegativeX;
public float boxSideFadeNegativeY;
public float boxSideFadeNegativeZ;
public Vector3 boxSideFadePositive;
public Vector3 boxSideFadeNegative;
public float sampleDirectionDiscardWSX;
public float sampleDirectionDiscardWSY;
public float sampleDirectionDiscardWSZ;
public Vector3 sampleDirectionDiscardWS;
public Vector3 capturePositionWS
{
get { return new Vector3(capturePositionWSX, capturePositionWSY, capturePositionWSZ); }
set
{
capturePositionWSX = value.x;
capturePositionWSY = value.y;
capturePositionWSZ = value.z;
}
}
public Vector3 proxyExtents
{
get { return new Vector3(proxyExtentsX, proxyExtentsY, proxyExtentsZ); }
set
{
proxyExtentsX = value.x;
proxyExtentsY = value.y;
proxyExtentsZ = value.z;
}
}
public Vector3 proxyPositionWS
{
get { return new Vector3(proxyPositionWSX, proxyPositionWSY, proxyPositionWSZ); }
set
{
proxyPositionWSX = value.x;
proxyPositionWSY = value.y;
proxyPositionWSZ = value.z;
}
}
public Vector3 proxyForward
{
get { return new Vector3(proxyForwardX, proxyForwardY, proxyForwardZ); }
set
{
proxyForwardX = value.x;
proxyForwardY = value.y;
proxyForwardZ = value.z;
}
}
public Vector3 proxyUp
{
get { return new Vector3(proxyUpX, proxyUpY, proxyUpZ); }
set
{
proxyUpX = value.x;
proxyUpY = value.y;
proxyUpZ = value.z;
}
}
public Vector3 proxyRight
{
get { return new Vector3(proxyRightX, proxyRightY, proxyRightZ); }
set
{
proxyRightX = value.x;
proxyRightY = value.y;
proxyRightZ = value.z;
}
}
public Vector3 influenceExtents
{
get { return new Vector3(influenceExtentsX, influenceExtentsY, influenceExtentsZ); }
set
{
influenceExtentsX = value.x;
influenceExtentsY = value.y;
influenceExtentsZ = value.z;
}
}
public Vector3 influencePositionWS
{
get { return new Vector3(influencePositionWSX, influencePositionWSY, influencePositionWSZ); }
set
{
influencePositionWSX = value.x;
influencePositionWSY = value.y;
influencePositionWSZ = value.z;
}
}
public Vector3 influenceForward
{
get { return new Vector3(influenceForwardX, influenceForwardY, influenceForwardZ); }
set
{
influenceForwardX = value.x;
influenceForwardY = value.y;
influenceForwardZ = value.z;
}
}
public Vector3 influenceUp
{
get { return new Vector3(influenceUpX, influenceUpY, influenceUpZ); }
set
{
influenceUpX = value.x;
influenceUpY = value.y;
influenceUpZ = value.z;
}
}
public Vector3 influenceRight
{
get { return new Vector3(influenceRightX, influenceRightY, influenceRightZ); }
set
{
influenceRightX = value.x;
influenceRightY = value.y;
influenceRightZ = value.z;
}
}
public Vector3 blendDistancePositive
{
get { return new Vector3(blendDistancePositiveX, blendDistancePositiveY, blendDistancePositiveZ); }
set
{
blendDistancePositiveX = value.x;
blendDistancePositiveY = value.y;
blendDistancePositiveZ = value.z;
}
}
public Vector3 blendDistanceNegative
{
get { return new Vector3(blendDistanceNegativeX, blendDistanceNegativeY, blendDistanceNegativeZ); }
set
{
blendDistanceNegativeX = value.x;
blendDistanceNegativeY = value.y;
blendDistanceNegativeZ = value.z;
}
}
public Vector3 blendNormalDistancePositive
{
get { return new Vector3(blendNormalDistancePositiveX, blendNormalDistancePositiveY, blendNormalDistancePositiveZ); }
set
{
blendNormalDistancePositiveX = value.x;
blendNormalDistancePositiveY = value.y;
blendNormalDistancePositiveZ = value.z;
}
}
public Vector3 blendNormalDistanceNegative
{
get { return new Vector3(blendNormalDistanceNegativeX, blendNormalDistanceNegativeY, blendNormalDistanceNegativeZ); }
set
{
blendNormalDistanceNegativeX = value.x;
blendNormalDistanceNegativeY = value.y;
blendNormalDistanceNegativeZ = value.z;
}
}
public Vector3 boxSideFadePositive
{
get { return new Vector3(boxSideFadePositiveX, boxSideFadePositiveY, boxSideFadePositiveZ); }
set
{
boxSideFadePositiveX = value.x;
boxSideFadePositiveY = value.y;
boxSideFadePositiveZ = value.z;
}
}
public Vector3 boxSideFadeNegative
{
get { return new Vector3(boxSideFadeNegativeX, boxSideFadeNegativeY, boxSideFadeNegativeZ); }
set
{
boxSideFadeNegativeX = value.x;
boxSideFadeNegativeY = value.y;
boxSideFadeNegativeZ = value.z;
}
}
public Vector3 sampleDirectionDiscardWS
{
get { return new Vector3(sampleDirectionDiscardWSX, sampleDirectionDiscardWSY, sampleDirectionDiscardWSZ); }
set
{
sampleDirectionDiscardWSX = value.x;
sampleDirectionDiscardWSY = value.y;
sampleDirectionDiscardWSZ = value.z;
}
}
};
[GenerateHLSL]

4
ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Builtin/BuiltinData.cs


// and are independent from the BSDF parametrization.
// Note: These parameters can be store in GBuffer if the writer wants
//-----------------------------------------------------------------------------
[GenerateHLSL(PackingRules.Exact, false, true, 100)]
[GenerateHLSL(PackingRules.Exact, true, 100)]
public struct BuiltinData
{
[SurfaceDataAttributes("Opacity")]

// LightTransportData
// This struct is use to store information for Enlighten/Progressive light mapper. both at runtime or off line.
//-----------------------------------------------------------------------------
[GenerateHLSL(PackingRules.Exact, false, true, 120)]
[GenerateHLSL(PackingRules.Exact, true, 120)]
public struct LightTransportData
{
[SurfaceDataAttributes("", false, true)]

6
ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.cs


public partial class Decal
{
// Main structure that store the user data (i.e user input of master node in material graph)
[GenerateHLSL(PackingRules.Exact, false, true, 10000)]
[GenerateHLSL(PackingRules.Exact, true, 10000)]
public struct DecalSurfaceData
{
[SurfaceDataAttributes("Base Color", false, true)]

[SurfaceDataAttributes("Mask", true)]
public Vector4 mask;
[SurfaceDataAttributes("HTileMask")]
public uint HTileMask;
public uint HTileMask;
};
[GenerateHLSL(PackingRules.Exact)]

[GenerateHLSL(PackingRules.Exact)]
public enum DBufferHTileBit
{
{
Diffuse = 1,
Normal = 2,
Mask = 4

4
ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs


//-----------------------------------------------------------------------------
// Main structure that store the user data (i.e user input of master node in material graph)
[GenerateHLSL(PackingRules.Exact, false, true, 1000)]
[GenerateHLSL(PackingRules.Exact, true, 1000)]
public struct SurfaceData
{
[SurfaceDataAttributes("MaterialFeatures")]

// BSDFData
//-----------------------------------------------------------------------------
[GenerateHLSL(PackingRules.Exact, false, true, 1030)]
[GenerateHLSL(PackingRules.Exact, true, 1030)]
public struct BSDFData
{
public uint materialFeatures;

4
ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.cs


//-----------------------------------------------------------------------------
// Main structure that store the user data (i.e user input of master node in material graph)
[GenerateHLSL(PackingRules.Exact, false, true, 1100)]
[GenerateHLSL(PackingRules.Exact, true, 1100)]
public struct SurfaceData
{
[SurfaceDataAttributes("Color", false, true)]

// BSDFData
//-----------------------------------------------------------------------------
[GenerateHLSL(PackingRules.Exact, false, true, 1130)]
[GenerateHLSL(PackingRules.Exact, true, 1130)]
public struct BSDFData
{
[SurfaceDataAttributes("", false, true)]

正在加载...
取消
保存