Material GetMetallicMaterial(MetallicShaderFeatures metallicShaderFeatures)
{
bool doubleSided = (metallicShaderFeatures & MetallicShaderFeatures.DoubleSided) != 0;
if (!metallicShaders.TryGetValue(metallicShaderFeatures, value: out var shader))
{
ShaderMode mode = (ShaderMode)(metallicShaderFeatures & MetallicShaderFeatures.ModeMask);
// TODO: add ClearCoat support
bool coat = false; // (metallicShaderFeatures & MetallicShaderFeatures.ClearCoat) != 0;
// TODO: add sheen support
bool sheen = false; // (metallicShaderFeatures & MetallicShaderFeatures.Sheen) != 0;
var shaderName = string.Format(
"Shader Graphs/glTF-metallic-{0}{1}{2}{3}",
mode,
coat ? "-coat" : "",
sheen ? "-sheen" : "",
doubleSided ? "-double" : ""
);
shader = FindShader(shaderName);
metallicShaders[metallicShaderFeatures] = shader;
}
if (shader == null)
{
return(null);
}
var mat = new Material(shader);
#if UNITY_EDITOR
mat.doubleSidedGI = doubleSided;
#endif
return(mat);
}
private bool compileShader(string source, ShaderMode shaderType)
{
if (string.IsNullOrEmpty(source))
{
return(true);
}
int shader = _graphics.CreateShader(shaderType);
_graphics.ShaderSource(shader, source);
_graphics.CompileShader(shader);
string info = _graphics.GetShaderInfoLog(shader);
int errorCode = _graphics.GetShaderCompilationErrorCode(shader);
if (errorCode != 1)
{
Debug.WriteLine($@"Failed to compile {shaderType}.{Environment.NewLine}Error code: {errorCode}.{Environment.NewLine}
Error message(s): {info ?? "null"}.{Environment.NewLine}Shader Source: {source}{Environment.NewLine}");
_graphics.DeleteShader(shader);
_program = 0;
return(false);
}
_graphics.AttachShader(_program, shader);
_graphics.DeleteShader(shader);
return(true);
}
private void lblShaderMode_OnClick(object sender, EventArgs e)
{
fShaderMode = fShaderMode + 1;
if (fShaderMode == ShaderMode.Last)
{
fShaderMode = ShaderMode.Basic;
}
}
public static void setShader(ShaderMode mode, Material mat, Color color, bool show = true)
{
switch (mode)
{
case ShaderMode.Normal:
mat.color = new Color(color.r, color.g, color.b, 120);
//mat.shader = Shaders.transparent;
break;
case ShaderMode.RedOutline:
mat.shader = Shaders.transparent;
mat.color = new Color(color.r, color.g, color.b, 120);
break;
}
}
public void setShader(ShaderMode mode, Color color = default(Color))
{
meshRendered.enabled = true;
switch (mode)
{
case ShaderMode.Normal:
mat.shader = originalShader;
if (color == default(Color))
{
mat.color = originalColor;
}
else
{
mat.color = color;
}
break;
case ShaderMode.RedOutline:
mat.shader = Shaders.outline;
mat.color = new Color(221, 0, 0, 255);
break;
case ShaderMode.Outline:
mat.shader = Shaders.outline;
mat.color = originalColor;
break;
case ShaderMode.Transparent:
mat.shader = Shaders.silhouetteOnly;
mat.color = originalColor;
isTransparent = true;
break;
case ShaderMode.Invisible:
mat.shader = originalShader;
mat.color = originalColor;
meshRendered.enabled = false;
break;
}
}
private ShaderType getShaderType(ShaderMode shader)
{
switch (shader)
{
case ShaderMode.ComputeShader: return(ShaderType.ComputeShader);
case ShaderMode.FragmentShader: return(ShaderType.FragmentShader);
case ShaderMode.GeometryShader: return(ShaderType.GeometryShader);
case ShaderMode.GeometryShaderExt: return(ShaderType.GeometryShaderExt);
case ShaderMode.TessControlShader: return(ShaderType.TessControlShader);
case ShaderMode.TessEvaluationShader: return(ShaderType.TessEvaluationShader);
case ShaderMode.VertexShader: return(ShaderType.VertexShader);
default: throw new NotSupportedException(shader.ToString());
}
}
public void setShader(ShaderMode mode, Color color = default(Color))
{
meshRendered.enabled = true;
switch (mode)
{
case ShaderMode.Normal:
mat.shader = originalShader;
if (color == default(Color)) {
mat.color = originalColor;
} else {
mat.color = color;
}
break;
case ShaderMode.RedOutline:
mat.shader = Shaders.outline;
mat.color = new Color(221, 0, 0, 255);
break;
case ShaderMode.Outline:
mat.shader = Shaders.outline;
mat.color = originalColor;
break;
case ShaderMode.Transparent:
mat.shader = Shaders.silhouetteOnly;
mat.color = originalColor;
isTransparent = true;
break;
case ShaderMode.Invisible:
mat.shader = originalShader;
mat.color = originalColor;
meshRendered.enabled = false;
break;
}
}
public int CreateShader(ShaderMode shaderType) => GL.CreateShader(getShaderType(shaderType));
public override Material GenerateMaterial(
Schema.Material gltfMaterial,
ref Schema.Texture[] textures,
ref Schema.Image[] schemaImages,
ref Dictionary <int, Texture2D>[] imageVariants
)
{
Material material;
MaterialType?materialType = null;
ShaderMode shaderMode = ShaderMode.Opaque;
if (gltfMaterial.extensions?.KHR_materials_unlit != null)
{
material = GetUnlitMaterial(gltfMaterial);
materialType = MaterialType.Unlit;
shaderMode = gltfMaterial.alphaModeEnum != AlphaMode.OPAQUE ? ShaderMode.Blend : ShaderMode.Opaque;
}
else
{
bool isMetallicRoughness = gltfMaterial.extensions?.KHR_materials_pbrSpecularGlossiness == null;
if (isMetallicRoughness)
{
materialType = MaterialType.MetallicRoughness;
var metallicShaderFeatures = GetMetallicShaderFeatures(gltfMaterial);
material = GetMetallicMaterial(metallicShaderFeatures);
shaderMode = (ShaderMode)(metallicShaderFeatures & MetallicShaderFeatures.ModeMask);
}
else
{
materialType = MaterialType.SpecularGlossiness;
var specularShaderFeatures = GetSpecularShaderFeatures(gltfMaterial);
material = GetSpecularMaterial(specularShaderFeatures);
if ((specularShaderFeatures & SpecularShaderFeatures.AlphaBlend) != 0)
{
shaderMode = ShaderMode.Blend;
}
}
}
if (material == null)
{
return(null);
}
material.name = gltfMaterial.name;
Color baseColorLinear = Color.white;
RenderQueue?renderQueue = null;
//added support for KHR_materials_pbrSpecularGlossiness
if (gltfMaterial.extensions != null)
{
Schema.PbrSpecularGlossiness specGloss = gltfMaterial.extensions.KHR_materials_pbrSpecularGlossiness;
if (specGloss != null)
{
baseColorLinear = specGloss.diffuseColor;
material.SetVector(specColorPropId, specGloss.specularColor);
material.SetFloat(smoothnessPropId, specGloss.glossinessFactor);
TrySetTexture(specGloss.diffuseTexture, material, baseMapPropId, ref textures, ref schemaImages, ref imageVariants);
if (TrySetTexture(specGloss.specularGlossinessTexture, material, specGlossMapPropId, ref textures, ref schemaImages, ref imageVariants))
{
// material.EnableKeyword();
}
}
}
if (gltfMaterial.pbrMetallicRoughness != null)
{
baseColorLinear = gltfMaterial.pbrMetallicRoughness.baseColor;
if (materialType != MaterialType.SpecularGlossiness)
{
// baseColorTexture can be used by both MetallicRoughness AND Unlit materials
TrySetTexture(
gltfMaterial.pbrMetallicRoughness.baseColorTexture,
material,
baseMapPropId,
ref textures,
ref schemaImages,
ref imageVariants
);
}
if (materialType == MaterialType.MetallicRoughness)
{
material.SetFloat(metallicPropId, gltfMaterial.pbrMetallicRoughness.metallicFactor);
material.SetFloat(smoothnessPropId, 1 - gltfMaterial.pbrMetallicRoughness.roughnessFactor);
if (TrySetTexture(gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture, material, metallicRoughnessTexturePropId, ref textures, ref schemaImages, ref imageVariants))
{
// material.EnableKeyword(KW_METALLIC_ROUGHNESS_MAP);
}
// TODO: When the occlusionTexture equals the metallicRoughnessTexture, we could sample just once instead of twice.
// if (!DifferentIndex(gltfMaterial.occlusionTexture,gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture)) {
// ...
// }
}
}
if (TrySetTexture(gltfMaterial.normalTexture, material, bumpMapPropId, ref textures, ref schemaImages, ref imageVariants))
{
// material.EnableKeyword(KW_NORMALMAP);
material.SetFloat(bumpScalePropId, gltfMaterial.normalTexture.scale);
}
if (TrySetTexture(gltfMaterial.occlusionTexture, material, occlusionMapPropId, ref textures, ref schemaImages, ref imageVariants))
{
material.EnableKeyword(KW_OCCLUSION);
material.SetFloat(occlusionStrengthPropId, gltfMaterial.occlusionTexture.strength);
}
if (TrySetTexture(gltfMaterial.emissiveTexture, material, emissionMapPropId, ref textures, ref schemaImages, ref imageVariants))
{
material.EnableKeyword(KW_EMISSION);
}
if (gltfMaterial.extensions != null)
{
// Transmission - Approximation
var transmission = gltfMaterial.extensions.KHR_materials_transmission;
if (transmission != null)
{
renderQueue = ApplyTransmission(ref baseColorLinear, ref textures, ref schemaImages, ref imageVariants, transmission, material, renderQueue);
}
}
if (gltfMaterial.alphaModeEnum == AlphaMode.MASK)
{
material.SetFloat(cutoffPropId, gltfMaterial.alphaCutoff);
}
else
{
material.SetFloat(cutoffPropId, 0);
// double sided opaque would make errors in HDRP 7.3 otherwise
material.SetOverrideTag("MotionVector", "User");
material.SetShaderPassEnabled("MOTIONVECTORS", false);
}
if (!renderQueue.HasValue)
{
if (shaderMode == ShaderMode.Opaque)
{
renderQueue = gltfMaterial.alphaModeEnum == AlphaMode.MASK
? RenderQueue.AlphaTest
: RenderQueue.Geometry;
}
else
{
renderQueue = RenderQueue.Transparent;
}
}
material.renderQueue = (int)renderQueue.Value;
material.SetVector(baseColorPropId, baseColorLinear);
if (gltfMaterial.emissive != Color.black)
{
material.SetColor(emissionColorPropId, gltfMaterial.emissive);
material.EnableKeyword(KW_EMISSION);
}
return(material);
}
public Shader(ShaderMode mode)
{
this.mode = mode;
this.fragmentShaderFilename = "shader/fragment_shader.glsl";
this.vertexShaderFilename = "shader/vertex_shader.glsl";
}
public int CreateShader(ShaderMode shaderType)
{
return(GL.CreateShader(getShaderType(shaderType)));
}
public override Material GenerateMaterial(Schema.Material gltfMaterial, IGltfReadable gltf)
{
Material material;
MaterialType?materialType = null;
ShaderMode shaderMode = ShaderMode.Opaque;
if (gltfMaterial.extensions?.KHR_materials_unlit != null)
{
material = GetUnlitMaterial(gltfMaterial);
materialType = MaterialType.Unlit;
shaderMode = gltfMaterial.alphaModeEnum == AlphaMode.BLEND ? ShaderMode.Blend : ShaderMode.Opaque;
}
else
{
bool isMetallicRoughness = gltfMaterial.extensions?.KHR_materials_pbrSpecularGlossiness == null;
if (isMetallicRoughness)
{
materialType = MaterialType.MetallicRoughness;
var metallicShaderFeatures = GetMetallicShaderFeatures(gltfMaterial);
material = GetMetallicMaterial(metallicShaderFeatures);
shaderMode = (ShaderMode)(metallicShaderFeatures & MetallicShaderFeatures.ModeMask);
}
else
{
materialType = MaterialType.SpecularGlossiness;
var specularShaderFeatures = GetSpecularShaderFeatures(gltfMaterial);
material = GetSpecularMaterial(specularShaderFeatures);
if ((specularShaderFeatures & SpecularShaderFeatures.AlphaBlend) != 0)
{
shaderMode = ShaderMode.Blend;
}
}
}
if (material == null)
{
return(null);
}
material.name = gltfMaterial.name;
Color baseColorLinear = Color.white;
RenderQueue?renderQueue = null;
//added support for KHR_materials_pbrSpecularGlossiness
if (gltfMaterial.extensions != null)
{
Schema.PbrSpecularGlossiness specGloss = gltfMaterial.extensions.KHR_materials_pbrSpecularGlossiness;
if (specGloss != null)
{
baseColorLinear = specGloss.diffuseColor;
#if UNITY_SHADER_GRAPH_12_OR_NEWER
material.SetVector(specularFactorPropId, specGloss.specularColor);
#else
material.SetVector(specColorPropId, specGloss.specularColor);
#endif
material.SetFloat(smoothnessPropId, specGloss.glossinessFactor);
TrySetTexture(
specGloss.diffuseTexture,
material,
gltf,
baseMapPropId,
baseMapScaleTransformPropId,
baseMapRotationPropId,
baseMapUVChannelPropId
);
if (TrySetTexture(
specGloss.specularGlossinessTexture,
material,
gltf,
specGlossMapPropId,
specGlossScaleTransformMapPropId,
specGlossMapRotationPropId,
specGlossMapUVChannelPropId
))
{
// material.EnableKeyword();
}
}
}
if (gltfMaterial.pbrMetallicRoughness != null
// If there's a specular-glossiness extension, ignore metallic-roughness
// (according to extension specification)
&& gltfMaterial.extensions?.KHR_materials_pbrSpecularGlossiness == null)
{
baseColorLinear = gltfMaterial.pbrMetallicRoughness.baseColor;
if (materialType != MaterialType.SpecularGlossiness)
{
// baseColorTexture can be used by both MetallicRoughness AND Unlit materials
TrySetTexture(
gltfMaterial.pbrMetallicRoughness.baseColorTexture,
material,
gltf,
baseMapPropId,
baseMapScaleTransformPropId,
baseMapRotationPropId,
baseMapUVChannelPropId
);
}
if (materialType == MaterialType.MetallicRoughness)
{
material.SetFloat(metallicPropId, gltfMaterial.pbrMetallicRoughness.metallicFactor);
material.SetFloat(smoothnessPropId, 1 - gltfMaterial.pbrMetallicRoughness.roughnessFactor);
if (TrySetTexture(
gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture,
material,
gltf,
metallicRoughnessMapPropId,
metallicRoughnessMapScaleTransformPropId,
metallicRoughnessMapRotationPropId,
metallicRoughnessMapUVChannelPropId
))
{
// material.EnableKeyword(KW_METALLIC_ROUGHNESS_MAP);
}
// TODO: When the occlusionTexture equals the metallicRoughnessTexture, we could sample just once instead of twice.
// if (!DifferentIndex(gltfMaterial.occlusionTexture,gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture)) {
// ...
// }
}
}
if (TrySetTexture(
gltfMaterial.normalTexture,
material,
gltf,
bumpMapPropId,
bumpMapScaleTransformPropId,
bumpMapRotationPropId,
bumpMapUVChannelPropId
))
{
// material.EnableKeyword(Constants.kwNormalMap);
material.SetFloat(bumpScalePropId, gltfMaterial.normalTexture.scale);
}
if (TrySetTexture(
gltfMaterial.occlusionTexture,
material,
gltf,
occlusionMapPropId,
occlusionMapScaleTransformPropId,
occlusionMapRotationPropId,
occlusionMapUVChannelPropId
))
{
material.EnableKeyword(KW_OCCLUSION);
material.SetFloat(occlusionStrengthPropId, gltfMaterial.occlusionTexture.strength);
}
if (TrySetTexture(
gltfMaterial.emissiveTexture,
material,
gltf,
emissionMapPropId,
emissionMapScaleTransformPropId,
emissionMapRotationPropId,
emissionMapUVChannelPropId
))
{
material.EnableKeyword(KW_EMISSION);
}
if (gltfMaterial.extensions != null)
{
// Transmission - Approximation
var transmission = gltfMaterial.extensions.KHR_materials_transmission;
if (transmission != null)
{
renderQueue = ApplyTransmission(ref baseColorLinear, gltf, transmission, material, renderQueue);
}
}
if (gltfMaterial.alphaModeEnum == AlphaMode.MASK)
{
SetAlphaModeMask(gltfMaterial, material);
#if USING_HDRP
if (gltfMaterial.extensions?.KHR_materials_unlit != null)
{
renderQueue = RenderQueue.Transparent;
}
else
#endif
renderQueue = RenderQueue.AlphaTest;
}
else
{
material.SetFloat(cutoffPropId, 0);
// double sided opaque would make errors in HDRP 7.3 otherwise
material.SetOverrideTag(TAG_MOTION_VECTOR, TAG_MOTION_VECTOR_USER);
material.SetShaderPassEnabled(k_MotionVectorsPass, false);
}
if (!renderQueue.HasValue)
{
if (shaderMode == ShaderMode.Opaque)
{
renderQueue = gltfMaterial.alphaModeEnum == AlphaMode.MASK
? RenderQueue.AlphaTest
: RenderQueue.Geometry;
}
else
{
renderQueue = RenderQueue.Transparent;
}
}
material.renderQueue = (int)renderQueue.Value;
if (gltfMaterial.doubleSided)
{
SetDoubleSided(gltfMaterial, material);
}
switch (shaderMode)
{
case ShaderMode.Opaque:
SetShaderModeOpaque(gltfMaterial, material);
break;
case ShaderMode.Blend:
SetShaderModeBlend(gltfMaterial, material);
break;
case ShaderMode.Premultiply:
SetShaderModePremultiply(gltfMaterial, material);
break;
}
material.SetVector(baseColorPropId, baseColorLinear);
if (gltfMaterial.emissive != Color.black)
{
material.SetColor(emissionColorPropId, gltfMaterial.emissive);
material.EnableKeyword(KW_EMISSION);
}
return(material);
}
private bool compileShader(string source, ShaderMode shaderType)
{
if (string.IsNullOrEmpty(source)) return true;
int shader = _graphics.CreateShader(shaderType);
_graphics.ShaderSource(shader, source);
_graphics.CompileShader(shader);
string info = _graphics.GetShaderInfoLog(shader);
int errorCode = _graphics.GetShaderCompilationErrorCode(shader);
if (errorCode != 1)
{
Debug.WriteLine(string.Format("Failed to compile {0}.{4}Error code: {1}.{4}Error message(s): {2}.{4}Shader Source: {3}{4}",
shaderType, errorCode, info ?? "null", source, Environment.NewLine));
_graphics.DeleteShader(shader);
_program = 0;
return false;
}
_graphics.AttachShader(_program, shader);
_graphics.DeleteShader(shader);
return true;
}
