562 lines
28 KiB
C#
562 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using GLTF.Schema;
|
|
using UnityEngine;
|
|
|
|
namespace UnityGLTF.Plugins
|
|
{
|
|
public class MaterialPointerPropertyMap
|
|
{
|
|
public enum PropertyTypeOption
|
|
{
|
|
LinearColor,
|
|
SRGBColor,
|
|
Texture,
|
|
LinearTexture,
|
|
TextureTransform,
|
|
Float
|
|
}
|
|
|
|
public enum CombineResultType
|
|
{
|
|
SameAsPrimary,
|
|
Override
|
|
}
|
|
|
|
public PropertyTypeOption PropertyType = PropertyTypeOption.Float;
|
|
|
|
public string[] PropertyNames
|
|
{
|
|
get => _propertyNames;
|
|
set
|
|
{
|
|
_propertyNames = value;
|
|
CreatePropertyIds();
|
|
}
|
|
}
|
|
|
|
public string GltfPropertyName = null;
|
|
public string GltfSecondaryPropertyName = null;
|
|
|
|
public bool IsColor => PropertyType == PropertyTypeOption.LinearColor ||
|
|
PropertyType == PropertyTypeOption.SRGBColor;
|
|
public bool IsTexture => PropertyType == PropertyTypeOption.Texture ||
|
|
PropertyType == PropertyTypeOption.LinearTexture;
|
|
|
|
/// <summary>
|
|
/// When Data is splitted into primary and secondary, the data gets combined on import.
|
|
/// Don't forget to set CombinePrimaryAndSecondaryDataFunction if you set this to true.
|
|
/// </summary>
|
|
public bool CombinePrimaryAndSecondaryOnImport = false;
|
|
|
|
/// <summary>
|
|
/// Possibility to override the result type of the combined data.
|
|
/// E.g. for combining two Vec2 properties into Vec4 (as for texture transform)
|
|
/// </summary>
|
|
public CombineResultType CombineComponentResult = CombineResultType.SameAsPrimary;
|
|
public GLTFAccessorAttributeType OverrideCombineResultType = GLTFAccessorAttributeType.VEC4;
|
|
|
|
// Export settings
|
|
public bool ExportKeepColorAlpha = true;
|
|
public bool ExportConvertToLinearColor = false;
|
|
public bool ExportFlipValueRange = false;
|
|
public float ExportValueMultiplier = 1f;
|
|
public string ExtensionName = null;
|
|
|
|
// The arrays contains the components of the primary and secondary properties. e.g. for a Vector3, the arrays will contain 3 elements
|
|
public delegate float[] CombinePrimaryAndSecondaryData(float[] primary, float[] secondary, int expectedResultLength);
|
|
|
|
/// <summary>
|
|
/// Function to combine primary and secondary data on import.
|
|
/// This used by the AnimationPointer system to combine data from two glTF properties into a single Unity property
|
|
/// The arrays contains the components of the primary and secondary properties. e.g. for a Vector3, the arrays will contain 3 elements
|
|
/// </summary>
|
|
public CombinePrimaryAndSecondaryData CombinePrimaryAndSecondaryDataFunction = null;
|
|
|
|
private string[] _propertyNames = new string[0];
|
|
internal int[] propertyIds = new int[0];
|
|
internal int[] propertyTextureIds = new int[0];
|
|
|
|
public MaterialPointerPropertyMap(PropertyTypeOption propertyType)
|
|
{
|
|
PropertyType = propertyType;
|
|
switch (PropertyType)
|
|
{
|
|
case PropertyTypeOption.LinearColor:
|
|
break;
|
|
case PropertyTypeOption.SRGBColor:
|
|
ExportConvertToLinearColor = true;
|
|
break;
|
|
case PropertyTypeOption.Texture:
|
|
break;
|
|
case PropertyTypeOption.LinearTexture:
|
|
break;
|
|
case PropertyTypeOption.TextureTransform:
|
|
SetupAsTextureTransform();
|
|
break;
|
|
case PropertyTypeOption.Float:
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
private void CreatePropertyIds()
|
|
{
|
|
propertyIds = new int[PropertyNames.Length];
|
|
for (int i = 0; i < PropertyNames.Length; i++)
|
|
propertyIds[i] = Shader.PropertyToID(PropertyNames[i]);
|
|
|
|
if (PropertyType == PropertyTypeOption.TextureTransform)
|
|
{
|
|
propertyTextureIds = new int[PropertyNames.Length];
|
|
for (int i = 0; i < PropertyNames.Length; i++)
|
|
{
|
|
var pWithoutST = PropertyNames[i].Remove(PropertyNames[i].Length - 3, 3);
|
|
|
|
propertyTextureIds[i] = Shader.PropertyToID(pWithoutST);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static float[] CombineTextureTransform(float[] primary, float[] secondary, int expectedResultLength)
|
|
{
|
|
var result = new float[expectedResultLength];
|
|
|
|
if (primary.Length >= 2)
|
|
{
|
|
result[0] = primary[0];
|
|
result[1] = primary[1];
|
|
}
|
|
|
|
if (primary.Length == 0)
|
|
{
|
|
result[0] = 1;
|
|
result[1] = 1;
|
|
}
|
|
|
|
if (secondary.Length == 2)
|
|
{
|
|
result[2] = secondary[0];
|
|
result[3] = 1f - secondary[1] - result[1];
|
|
}
|
|
else
|
|
{
|
|
result[2] = 0;
|
|
result[3] = 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void SetupAsTextureTransform()
|
|
{
|
|
PropertyType = PropertyTypeOption.TextureTransform;
|
|
CombinePrimaryAndSecondaryDataFunction = CombineTextureTransform;
|
|
CombinePrimaryAndSecondaryOnImport = true;
|
|
CombineComponentResult = MaterialPointerPropertyMap.CombineResultType.Override;
|
|
OverrideCombineResultType = GLTFAccessorAttributeType.VEC4;
|
|
}
|
|
}
|
|
|
|
public class MaterialPropertiesRemapper
|
|
{
|
|
public enum ImportExportUsageOption
|
|
{
|
|
ImportOnly,
|
|
ExportOnly,
|
|
ImportAndExport
|
|
}
|
|
|
|
private Dictionary<string, MaterialPointerPropertyMap> importMaps = new Dictionary<string, MaterialPointerPropertyMap>();
|
|
private Dictionary<string,MaterialPointerPropertyMap> exportMaps = new Dictionary<string,MaterialPointerPropertyMap> ();
|
|
|
|
public void AddTextureExtTransforms(string gltfTextureName, string[] unityTextureNames, string extension = null)
|
|
{
|
|
var stNames = new string[unityTextureNames.Length];
|
|
for (int i = 0; i < stNames.Length; i++)
|
|
stNames[i] = $"{unityTextureNames[i]}_ST";
|
|
|
|
var stMap = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.TextureTransform)
|
|
{
|
|
PropertyNames = stNames,
|
|
GltfPropertyName = $"{gltfTextureName}/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.SCALE}",
|
|
GltfSecondaryPropertyName = $"{gltfTextureName}/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.OFFSET}",
|
|
ExtensionName = extension
|
|
};
|
|
AddMap(stMap);
|
|
|
|
var rotNames = new string[unityTextureNames.Length];
|
|
for (int i = 0; i < stNames.Length; i++)
|
|
rotNames[i] = $"{unityTextureNames[i]}Rotation";
|
|
|
|
var rotMap = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = rotNames,
|
|
GltfPropertyName = $"{gltfTextureName}/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.ROTATION}",
|
|
ExtensionName = extension
|
|
};
|
|
AddMap(rotMap);
|
|
|
|
var texCoordNames = new string[unityTextureNames.Length];
|
|
for (int i = 0; i < stNames.Length; i++)
|
|
texCoordNames[i] = $"{unityTextureNames[i]}TexCoord";
|
|
|
|
var texCoordMap = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = texCoordNames,
|
|
GltfPropertyName = $"{gltfTextureName}/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.TEXCOORD}",
|
|
ExtensionName = extension
|
|
};
|
|
AddMap(texCoordMap);
|
|
}
|
|
|
|
public void AddMap(MaterialPointerPropertyMap map, ImportExportUsageOption importExport = ImportExportUsageOption.ImportAndExport)
|
|
{
|
|
if (importExport == ImportExportUsageOption.ImportOnly ||
|
|
importExport == ImportExportUsageOption.ImportAndExport)
|
|
{
|
|
if (importMaps.ContainsKey(map.GltfPropertyName))
|
|
{
|
|
Debug.LogError("MaterialPropertiesRemapper: Import Map with the same glTF property name already exists: " + map.GltfPropertyName);
|
|
return;
|
|
}
|
|
importMaps.Add(map.GltfPropertyName, map);
|
|
}
|
|
if (importExport == ImportExportUsageOption.ExportOnly ||
|
|
importExport == ImportExportUsageOption.ImportAndExport)
|
|
{
|
|
for (int i = 0; i < map.PropertyNames.Length; i++)
|
|
{
|
|
if (exportMaps.ContainsKey(map.PropertyNames[i]))
|
|
{
|
|
Debug.LogError("MaterialPropertiesRemapper: Export Map with the same unity property name already exists: " + map.PropertyNames[i]);
|
|
continue;
|
|
}
|
|
|
|
exportMaps.Add(map.PropertyNames[i], map);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool GetMapByUnityProperty(string unityPropertyName, out MaterialPointerPropertyMap map)
|
|
{
|
|
return exportMaps.TryGetValue(unityPropertyName, out map);
|
|
}
|
|
|
|
public bool GetMapFromUnityMaterial(Material mat, string unityPropertyName, out MaterialPointerPropertyMap map)
|
|
{
|
|
map = null;
|
|
if (!exportMaps.TryGetValue(unityPropertyName, out map))
|
|
return false;
|
|
|
|
if (map.PropertyType == MaterialPointerPropertyMap.PropertyTypeOption.TextureTransform)
|
|
{
|
|
bool valid = false;
|
|
for (int i = 0; i < map.propertyTextureIds.Length; i++)
|
|
valid |= (mat.HasProperty(map.propertyTextureIds[i]) && mat.GetTexture(map.propertyTextureIds[i]));
|
|
if (!valid)
|
|
{
|
|
map = null;
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool valid = false;
|
|
for (int i = 0; i < map.propertyIds.Length; i++)
|
|
valid |= (mat.HasProperty(map.propertyIds[i]));
|
|
if (!valid)
|
|
{
|
|
map = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
public bool GetUnityPropertyName(Material mat, string gltfPropertyName, out string propertyName,
|
|
out MaterialPointerPropertyMap map, out bool isSecondary)
|
|
{
|
|
foreach (var kvp in importMaps)
|
|
{
|
|
var currentMap = kvp.Value;
|
|
if (currentMap.GltfPropertyName != gltfPropertyName && currentMap.GltfSecondaryPropertyName != gltfPropertyName)
|
|
continue;
|
|
|
|
for (int i = 0; i < currentMap.PropertyNames.Length; i++)
|
|
{
|
|
if (currentMap.PropertyType == MaterialPointerPropertyMap.PropertyTypeOption.TextureTransform)
|
|
{
|
|
for (int j = 0; j < currentMap.PropertyNames.Length; j++)
|
|
{
|
|
if (mat.HasProperty(currentMap.propertyTextureIds[j]))
|
|
{
|
|
map = currentMap;
|
|
propertyName = currentMap.PropertyNames[j];
|
|
isSecondary = currentMap.GltfSecondaryPropertyName == gltfPropertyName;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else if (mat.HasProperty(currentMap.propertyIds[i]))
|
|
{
|
|
map = currentMap;
|
|
propertyName = currentMap.PropertyNames[i];
|
|
isSecondary = currentMap.GltfSecondaryPropertyName == gltfPropertyName;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
map = null;
|
|
propertyName = "";
|
|
isSecondary = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class DefaultMaterialPropertiesRemapper : MaterialPropertiesRemapper
|
|
{
|
|
public DefaultMaterialPropertiesRemapper()
|
|
{
|
|
var baseColor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.SRGBColor)
|
|
{
|
|
PropertyNames = new[] { "_Color", "_BaseColor", "_BaseColorFactor", "baseColorFactor" },
|
|
GltfPropertyName = "pbrMetallicRoughness/baseColorFactor",
|
|
};
|
|
AddMap(baseColor);
|
|
|
|
var smoothness = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_Smoothness", "_Glossiness" },
|
|
ExportFlipValueRange = true,
|
|
GltfPropertyName = "pbrMetallicRoughness/roughnessFactor",
|
|
};
|
|
AddMap(smoothness, ImportExportUsageOption.ExportOnly);
|
|
|
|
var roughness = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_Roughness", "_RoughnessFactor", "roughnessFactor" },
|
|
GltfPropertyName = "pbrMetallicRoughness/roughnessFactor"
|
|
};
|
|
AddMap(roughness);
|
|
|
|
var dispersion = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "dispersion"},
|
|
GltfPropertyName = "dispersion"
|
|
};
|
|
AddMap(dispersion);
|
|
|
|
var metallic = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_Metallic", "_MetallicFactor", "metallicFactor" },
|
|
GltfPropertyName = "pbrMetallicRoughness/metallicFactor"
|
|
};
|
|
AddMap(metallic);
|
|
|
|
var emissiveFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.SRGBColor)
|
|
{
|
|
PropertyNames = new[] { "_EmissionColor", "_EmissiveFactor", "emissiveFactor" },
|
|
GltfPropertyName = "emissiveFactor",
|
|
GltfSecondaryPropertyName =
|
|
$"extensions/{KHR_materials_emissive_strength_Factory.EXTENSION_NAME}/{nameof(KHR_materials_emissive_strength.emissiveStrength)}",
|
|
ExtensionName = KHR_materials_emissive_strength_Factory.EXTENSION_NAME,
|
|
CombinePrimaryAndSecondaryOnImport = true,
|
|
ExportKeepColorAlpha = false,
|
|
CombinePrimaryAndSecondaryDataFunction = (primary, secondary, exptedResultLength) =>
|
|
{
|
|
float strength = (secondary != null && secondary.Length > 0) ? secondary[0] : 1f;
|
|
var result = new float[exptedResultLength];
|
|
for (int i = 0; i < 3; i++)
|
|
result[i] = primary[i] * strength;
|
|
if (result.Length == 4)
|
|
result[3] = primary[3];
|
|
|
|
Color color = result.Length == 3 ? new Color(result[0], result[1], result[2]) : new Color(result[0], result[1], result[2], result[3]);
|
|
color = color.gamma;
|
|
result[0] = color.r;
|
|
result[1] = color.g;
|
|
result[2] = color.b;
|
|
if (result.Length == 4)
|
|
result[3] = color.a;
|
|
return result;
|
|
}
|
|
};
|
|
AddMap(emissiveFactor);
|
|
|
|
var alphaCutoff = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_AlphaCutoff", "alphaCutoff", "_Cutoff" },
|
|
GltfPropertyName = "alphaCutoff"
|
|
};
|
|
AddMap(alphaCutoff);
|
|
|
|
var normalScale = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_BumpScale", "_NormalScale", "normalScale", "normalTextureScale" },
|
|
GltfPropertyName = "normalTexture/scale"
|
|
};
|
|
AddMap(normalScale);
|
|
|
|
var occlusionStrength = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_OcclusionStrength", "occlusionStrength", "occlusionTextureStrength" },
|
|
GltfPropertyName = "occlusionTexture/strength"
|
|
};
|
|
AddMap(occlusionStrength);
|
|
|
|
// KHR_materials_transmission
|
|
var transmissionFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_TransmissionFactor", "transmissionFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_transmission_Factory.EXTENSION_NAME}/{nameof(KHR_materials_transmission.transmissionFactor)}",
|
|
ExtensionName = KHR_materials_transmission_Factory.EXTENSION_NAME
|
|
};
|
|
AddMap(transmissionFactor);
|
|
|
|
// KHR_materials_volume
|
|
var thicknessFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_ThicknessFactor", "thicknessFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_volume_Factory.EXTENSION_NAME}/{nameof(KHR_materials_volume.thicknessFactor)}",
|
|
ExtensionName = KHR_materials_volume_Factory.EXTENSION_NAME
|
|
};
|
|
AddMap(thicknessFactor);
|
|
|
|
var attenuationDistance = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_AttenuationDistance", "attenuationDistance" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_volume_Factory.EXTENSION_NAME}/{nameof(KHR_materials_volume.attenuationDistance)}",
|
|
ExtensionName = KHR_materials_volume_Factory.EXTENSION_NAME
|
|
};
|
|
AddMap(attenuationDistance);
|
|
|
|
var attenuationColor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.LinearColor)
|
|
{
|
|
PropertyNames = new[] { "_AttenuationColor", "attenuationColor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_volume_Factory.EXTENSION_NAME}/{nameof(KHR_materials_volume.attenuationColor)}",
|
|
ExtensionName = KHR_materials_volume_Factory.EXTENSION_NAME,
|
|
ExportKeepColorAlpha = false,
|
|
};
|
|
AddMap(attenuationColor);
|
|
|
|
// KHR_materials_ior
|
|
var ior = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_IOR", "ior" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_ior_Factory.EXTENSION_NAME}/{nameof(KHR_materials_ior.ior)}",
|
|
ExtensionName = KHR_materials_ior_Factory.EXTENSION_NAME
|
|
};
|
|
AddMap(ior);
|
|
|
|
// KHR_materials_iridescence
|
|
var iridescenceFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_IridescenceFactor", "iridescenceFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_iridescence_Factory.EXTENSION_NAME}/{nameof(KHR_materials_iridescence.iridescenceFactor)}",
|
|
ExtensionName = KHR_materials_iridescence_Factory.EXTENSION_NAME
|
|
};
|
|
AddMap(iridescenceFactor);
|
|
|
|
// KHR_materials_specular
|
|
var specularFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_SpecularFactor", "specularFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_specular_Factory.EXTENSION_NAME}/{nameof(KHR_materials_specular.specularFactor)}",
|
|
ExtensionName = KHR_materials_specular_Factory.EXTENSION_NAME
|
|
};
|
|
AddMap(specularFactor);
|
|
|
|
var specularColorFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.LinearColor)
|
|
{
|
|
PropertyNames = new[] { "_SpecularColorFactor", "specularColorFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_specular_Factory.EXTENSION_NAME}/{nameof(KHR_materials_specular.specularColorFactor)}",
|
|
ExtensionName = KHR_materials_specular_Factory.EXTENSION_NAME,
|
|
ExportKeepColorAlpha = false,
|
|
};
|
|
AddMap(specularColorFactor);
|
|
|
|
var clearcoatFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_ClearcoatFactor", "clearcoatFactor" },
|
|
GltfPropertyName = $"extensions/{KHR_materials_clearcoat_Factory.EXTENSION_NAME}/{nameof(KHR_materials_clearcoat.clearcoatFactor)}",
|
|
ExtensionName = KHR_materials_clearcoat_Factory.EXTENSION_NAME,
|
|
};
|
|
AddMap(clearcoatFactor);
|
|
|
|
var clearcoatRoughnessFactor = new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "_ClearcoatRoughnessFactor", "clearcoatRoughnessFactor" },
|
|
GltfPropertyName = $"extensions/{KHR_materials_clearcoat_Factory.EXTENSION_NAME}/{nameof(KHR_materials_clearcoat.clearcoatRoughnessFactor)}",
|
|
ExtensionName = KHR_materials_clearcoat_Factory.EXTENSION_NAME,
|
|
};
|
|
AddMap(clearcoatRoughnessFactor);
|
|
|
|
var sheenRoughnessFactor =
|
|
new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "sheenRoughness", "_sheenRoughness", "sheenRoughnessFactor", "_sheenRoughnessFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_sheen_Factory.EXTENSION_NAME}/{nameof(KHR_materials_sheen.sheenRoughnessFactor)}",
|
|
ExtensionName = KHR_materials_sheen_Factory.EXTENSION_NAME,
|
|
};
|
|
AddMap(sheenRoughnessFactor);
|
|
var sheenColorFactor =
|
|
new MaterialPointerPropertyMap(MaterialPointerPropertyMap.PropertyTypeOption.Float)
|
|
{
|
|
PropertyNames = new[] { "sheenColor", "_sheenColor", "sheenColorFactor", "_sheenColorFactor" },
|
|
GltfPropertyName =
|
|
$"extensions/{KHR_materials_sheen_Factory.EXTENSION_NAME}/{nameof(KHR_materials_sheen.sheenColorFactor)}",
|
|
ExtensionName = KHR_materials_sheen_Factory.EXTENSION_NAME,
|
|
};
|
|
AddMap(sheenColorFactor);
|
|
|
|
AddTextureExtTransforms("pbrMetallicRoughness/baseColorTexture", new[] { "_MainTex", "_BaseMap", "_BaseColorTexture", "baseColorTexture" });
|
|
AddTextureExtTransforms("emissiveTexture", new[] { "_EmissionMap", "_EmissiveTexture", "emissiveTexture" } );
|
|
AddTextureExtTransforms("normalTexture", new[] { "_BumpMap", "_NormalTexture", "normalTexture" });
|
|
AddTextureExtTransforms("occlusionTexture", new[] { "_OcclusionMap", "_OcclusionTexture", "occlusionTexture" });
|
|
AddTextureExtTransforms("pbrMetallicRoughness/metallicRoughnessTexture", new[] { "metallicRoughnessTexture", "_metallicRoughnessTexture", "_MetallicRoughnessTexture" });
|
|
|
|
string clearCoatExt = "extensions/"+nameof(KHR_materials_clearcoat)+"/";
|
|
AddTextureExtTransforms(clearCoatExt+ nameof(KHR_materials_clearcoat.clearcoatTexture), new[] { "_ClearcoatTexture", "clearcoatTexture", "ClearcoatTexture" }, nameof(KHR_materials_clearcoat));
|
|
AddTextureExtTransforms(clearCoatExt+ nameof(KHR_materials_clearcoat.clearcoatRoughnessTexture), new[] { "_ClearcoatRoughnessTexture", "clearcoatRoughnessTexture", "ClearcoatRoughnessTexture" }, nameof(KHR_materials_clearcoat));
|
|
AddTextureExtTransforms(clearCoatExt+ nameof(KHR_materials_clearcoat.clearcoatNormalTexture), new[] { "_ClearcoatNormalTexture_", "clearcoatNormalTexture", "ClearcoatNormalTexture" }, nameof(KHR_materials_clearcoat));
|
|
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_volume)+"/"+nameof(KHR_materials_volume.thicknessTexture), new[] {"thicknessTexture", "_thicknessTexture"}, nameof(KHR_materials_volume));
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_transmission)+"/"+nameof(KHR_materials_transmission.transmissionTexture), new[] {"transmissionTexture", "_transmissionTexture"}, nameof(KHR_materials_transmission));
|
|
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_iridescence)+"/"+nameof(KHR_materials_iridescence.iridescenceTexture), new[] { "iridescenceTexture", "_iridescenceTexture"}, nameof(KHR_materials_iridescence));
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_iridescence)+"/"+nameof(KHR_materials_iridescence.iridescenceThicknessTexture), new[] { "iridescenceThicknessTexture", "_iridescenceThicknessTexture"}, nameof(KHR_materials_iridescence));
|
|
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_specular)+"/"+nameof(KHR_materials_specular.specularTexture), new[] { "specularTexture", "_specularTexture"}, nameof(KHR_materials_specular));
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_specular)+"/"+nameof(KHR_materials_specular.specularColorTexture), new[] { "specularColorTexture", "_specularColorTexture"}, nameof(KHR_materials_specular));
|
|
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_sheen)+"/"+nameof(KHR_materials_sheen.sheenColorTexture), new[] {"sheenColorTexture", "_sheenColorTexture"}, nameof(KHR_materials_sheen));
|
|
AddTextureExtTransforms("extensions/"+nameof(KHR_materials_sheen)+"/"+nameof(KHR_materials_sheen.sheenRoughnessTexture), new[] {"sheenRoughnessTexture", "_sheenRoughnessTexture"}, nameof(KHR_materials_sheen));
|
|
|
|
// TODO KHR_materials_sheen
|
|
// case "_SheenColorFactor":
|
|
// case "sheenColorFactor":
|
|
// propertyName = $"extensions/{KHR_materials_sheen_Factory.EXTENSION_NAME}/{nameof(KHR_materials_sheen.sheenColorFactor)}";
|
|
// extensionName = KHR_materials_sheen_Factory.EXTENSION_NAME;
|
|
// keepColorAlpha = false;
|
|
// break;
|
|
// case "_SheenRoughnessFactor":
|
|
// case "sheenRoughnessFactor":
|
|
// propertyName = $"extensions/{KHR_materials_sheen_Factory.EXTENSION_NAME}/{nameof(KHR_materials_sheen.sheenRoughnessFactor)}";
|
|
// extensionName = KHR_materials_sheen_Factory.EXTENSION_NAME;
|
|
// break;
|
|
}
|
|
}
|
|
} |