public static void PointInstancerTest()
{
var scene = USD.NET.Scene.Create();
var stageWeakRef = new pxr.UsdStageWeakPtr(scene.Stage);
var pi = new PointInstancerSample();
var cube = new CubeSample();
pi.prototypes.targetPaths = new string[] { "/Instancer/Cube" };
// Three instances, all prototype index zero.
pi.protoIndices = new int[3];
pi.positions = new UnityEngine.Vector3[3];
pi.positions[0] = new UnityEngine.Vector3(-2.5f, 0, 0);
pi.positions[1] = new UnityEngine.Vector3(0, 0, 0);
pi.positions[2] = new UnityEngine.Vector3(2.5f, 0, 0);
scene.Write("/Instancer", pi);
scene.Write("/Instancer/Cube", cube);
scene.Stage.Export("D:\\instancer-high-level.usda");
var piSample = new PointInstancerSample();
scene.Read("/Instancer", piSample);
var matrices = piSample.ComputeInstanceMatrices(scene, "/Instancer");
Console.WriteLine(String.Join(",", matrices.Select(p => p.ToString()).ToArray()));
Console.WriteLine(String.Join(",", piSample.prototypes.targetPaths.Select(p => p.ToString()).ToArray()));
Console.WriteLine(String.Join(",", piSample.protoIndices.Select(p => p.ToString()).ToArray()));
}
/// <summary>
/// Read and write materials with as little code as possible.
/// </summary>
public static void MaterialIoTest()
{
var scene = Scene.Create();
scene.Write("/Model/Geom/Cube", new CubeSample(1.0));
scene.Write("/Model/Geom/Cube", new MaterialBindingSample("/Model/Materials/SampleMat"));
scene.Write("/Model/Materials/SampleMat", new MaterialSample("/Model/Materials/PrevewShader.outputs:result"));
var previewSurface = new PreviewSurfaceSample();
previewSurface.diffuseColor.SetConnectedPath("/Model/Materials/Tex.outputs:result");
scene.Write("/Model/Materials/PrevewShader", previewSurface);
scene.Write("/Model/Materials/Tex", new TextureReaderSample("C:\\foo\\bar.png"));
PrintScene(scene);
var cube = new CubeSample();
scene.Read("/Model/Geom/Cube", cube);
var binding = new MaterialBindingSample();
scene.Read("/Model/Geom/Cube", binding);
var material = new MaterialSample();
scene.Read(binding.binding.GetOnlyTarget(), material);
var shader = new PreviewSurfaceSample();
scene.Read(material.surface.GetConnectedPath(), shader);
}
public static void WriteOverOnlyTest()
{
// Create the base scene layer.
var strongerLayer = Scene.Create("D:\\stronger-no-sublayer.usda");
strongerLayer.UpAxis = Scene.UpAxes.Z;
// Create a cube for testing.
var cubeSample = new CubeSample();
// Write some data to the cube.
// Set the WriteMode to "Over" and write a different /Cube value.
strongerLayer.WriteMode = Scene.WriteModes.Over;
cubeSample.size = 1.1;
strongerLayer.Write("/Cube", cubeSample);
// Save.
strongerLayer.Save();
}
public static void WriteToUnderTest()
{
// Create the base scene layer.
var strongerLayer = Scene.Create("D:\\stronger.usda");
strongerLayer.UpAxis = Scene.UpAxes.Z;
// Create a layer for overrides.
var weakerLayer = Scene.Create("D:\\weaker.usda");
weakerLayer.UpAxis = Scene.UpAxes.Z;
// Create a cube for testing.
var cubeSample = new CubeSample();
// Add the subLayer to the main layer.
strongerLayer.AddSubLayer(weakerLayer);
// Write some data to the cube.
// Set the WriteMode to "Over" and write a different /Cube value.
strongerLayer.WriteMode = Scene.WriteModes.Over;
cubeSample.size = 1.1;
strongerLayer.Write("/Cube", cubeSample);
// Change the edit target.
strongerLayer.SetEditTarget(weakerLayer);
// Set the WriteMode to "Define" and write a different /Cube value.
strongerLayer.WriteMode = Scene.WriteModes.Define;
cubeSample.size = 2.2;
strongerLayer.Write("/Cube", cubeSample);
// Save.
strongerLayer.Save();
weakerLayer.Save();
}
public static void WriteToOverTest()
{
var cubeSample = new CubeSample();
var sceneUnder = Scene.Create();
sceneUnder.UpAxis = Scene.UpAxes.Z;
var sceneOver = Scene.Create();
sceneOver.UpAxis = Scene.UpAxes.Z;
sceneUnder.AddSubLayer(sceneOver);
cubeSample.size = 1.1;
sceneUnder.Write("/Cube", cubeSample);
sceneOver.WriteMode = Scene.WriteModes.Over;
cubeSample.size = 2.2;
sceneOver.Write("/Cube", cubeSample);
PrintScene(sceneUnder);
PrintScene(sceneOver);
}
public static void BasicTest()
{
var cubeSample = new CubeSample();
var meshSample = new MeshSample();
meshSample.visibility = Visibility.Invisible;
var scene = Scene.Create();
scene.Write("/Root/Cube", cubeSample);
scene.Write("/Root/Mesh", meshSample);
scene.Write("/Root/Mesh2", meshSample);
foreach (var mesh in scene.ReadAll <XformableQuery>(rootPath:"/Root"))
{
Console.WriteLine("ReadAll Test: " + mesh.path);
}
foreach (var path in scene.Find <XformableQuery>(rootPath: "/Root"))
{
Console.WriteLine("Find Test: " + path);
}
try {
Util.DiagnosticHandler.Instance.LastError = null;
foreach (var mesh in scene.ReadAll <XformableQuery>(rootPath: "/Bogus/Root/Path"))
{
Console.WriteLine("Query Test: " + mesh.path);
}
// TODO: for some reason, these stop working after the first exception is thrown,
// but it seems like *only* this code path is affected.
if (!string.IsNullOrEmpty(Util.DiagnosticHandler.Instance.LastError))
{
throw new ApplicationException(Util.DiagnosticHandler.Instance.LastError);
}
else
{
throw new Exception("Expected exception but was not thrown.");
}
} catch (ApplicationException ex) {
Console.WriteLine("Caught expected exception: " + ex.Message);
}
try {
Util.DiagnosticHandler.Instance.LastError = null;
foreach (var mesh in scene.ReadAll <BadBaseTypeQuery>(rootPath: "/Root"))
{
Console.WriteLine("Query Test: " + mesh.path);
}
// TODO: for some reason, these stop working after the first exception is thrown,
// but it seems like *only* this code path is affected.
if (!string.IsNullOrEmpty(Util.DiagnosticHandler.Instance.LastError))
{
throw new ApplicationException(Util.DiagnosticHandler.Instance.LastError);
}
else
{
throw new Exception("Expected exception but was not thrown.");
}
} catch (ApplicationException ex) {
Console.WriteLine("Caught expected exception: " + ex.Message);
}
}
//
// Start generates a USD scene procedurally, containing a single cube with a material, shader
// and texture bound. It then inspects the cube to discover the material. A Unity material is
// constructed and the parameters are copied in a generic way. Similarly, the texture is
// discovered and loaded as a Unity Texture2D and bound to the material.
//
// Also See: https://docs.unity3d.com/Manual/MaterialsAccessingViaScript.html
//
void Start()
{
// Create a scene for this test, but could also be read from disk.
Scene usdScene = CreateSceneWithShading();
// Read the material and shader ID.
var usdMaterial = new MaterialSample();
string shaderId;
// ReadMaterial was designed for Unity and assumes there is one "surface" shader bound.
if (!MaterialSample.ReadMaterial(usdScene, kCubePath, usdMaterial, out shaderId))
{
throw new System.Exception("Failed to read material");
}
// Map the shader ID to the corresponding Unity/USD shader pair.
ShaderPair shader;
if (shaderId == null || !m_shaderMap.TryGetValue(shaderId, out shader))
{
throw new System.Exception("Material had no surface bound");
}
//
// Read and process the shader-specific parameters.
//
// UsdShade requires all connections target an attribute, but we actually want to deserialize
// the entire prim, so we get just the prim path here.
var shaderPath = new pxr.SdfPath(usdMaterial.surface.connectedPath).GetPrimPath();
usdScene.Read(shaderPath, shader.usdShader);
//
// Construct material & process the inputs, textures, and keywords.
//
var mat = new UnityEngine.Material(shader.unityShader);
// Apply material keywords.
foreach (string keyword in usdMaterial.requiredKeywords ?? new string[0])
{
mat.EnableKeyword(keyword);
}
// Iterate over all input parameters and copy values and/or construct textures.
foreach (var param in shader.usdShader.GetInputParameters())
{
if (!SetMaterialParameter(mat, param.unityName, param.value))
{
throw new System.Exception("Incompatible shader data type: " + param.ToString());
}
}
foreach (var param in shader.usdShader.GetInputTextures())
{
if (string.IsNullOrEmpty(param.connectedPath))
{
// Not connected to a texture.
continue;
}
// Only 2D textures are supported in this example.
var usdTexture = new Texture2DSample();
// Again, we want the prim path, not the attribute path.
var texturePath = new pxr.SdfPath(param.connectedPath).GetPrimPath();
usdScene.Read(texturePath, usdTexture);
// This example also only supports explicit sourceFiles, they cannot be connected.
if (string.IsNullOrEmpty(usdTexture.sourceFile.defaultValue))
{
continue;
}
// For details, see: https://docs.unity3d.com/Manual/MaterialsAccessingViaScript.html
foreach (string keyword in param.requiredShaderKeywords)
{
mat.EnableKeyword(keyword);
}
var data = System.IO.File.ReadAllBytes(usdTexture.sourceFile.defaultValue);
var unityTex = new Texture2D(2, 2);
unityTex.LoadImage(data);
mat.SetTexture(param.unityName, unityTex);
Debug.Log("Set " + param.unityName + " to " + usdTexture.sourceFile.defaultValue);
unityTex.Apply(updateMipmaps: true, makeNoLongerReadable: false);
}
//
// Create and bind the geometry.
//
// Create a cube and set the material.
// Note that geometry is handled minimally here and is incomplete.
var cubeSample = new CubeSample();
usdScene.Read(kCubePath, cubeSample);
var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
go.transform.SetParent(transform, worldPositionStays: false);
go.transform.localScale = Vector3.one * (float)cubeSample.size;
m_cube = transform;
go.GetComponent <MeshRenderer>().material = mat;
}
// ------------------------------------------------------------------------------------------ //
// Create a USD scene for testing
// ------------------------------------------------------------------------------------------ //
static private Scene CreateSceneWithShading()
{
var scene = Scene.Create();
var cubePath = kCubePath;
var materialPath = "/Model/Materials/SimpleMat";
var shaderPath = "/Model/Materials/SimpleMat/StandardShader";
var albedoMapPath = "/Model/Materials/SimpleMat/AlbedoMap";
var normalMapPath = "/Model/Materials/SimpleMat/NormalMap";
var emissionMapPath = "/Model/Materials/SimpleMat/EmissionMap";
var metallicMapPath = "/Model/Materials/SimpleMat/MetallicMap";
var occlusionMapPath = "/Model/Materials/SimpleMat/OcclusionMap";
var parallaxMapPath = "/Model/Materials/SimpleMat/ParallaxMap";
var detailNormalMapPath = "/Model/Materials/SimpleMat/DetailNormalMap";
var detailMaskPath = "/Model/Materials/SimpleMat/DetailMask";
var textureFilePath = @"Assets/Samples/USD/1.0.1-preview.1/ImportMaterials/Textures/";
var cube = new CubeSample();
cube.size = 7;
cube.transform = Matrix4x4.identity;
//
// Setup Material.
//
var material = new MaterialSample();
material.surface.SetConnectedPath(shaderPath, "outputs:out");
// Various shader keywords are required to enable the standard shader to work as intended,
// while these can be encoded as part of the schema, often they require some logic (e.g. is
// emission color != black?).
material.requiredKeywords = new string[] { "_EMISSION" };
//
// Setup Shader.
//
var shader = new StandardShaderSample();
shader.id = new pxr.TfToken("Unity.Standard");
// Note that USD requires all connections target attributes, hence "outputs:out" appended to
// the paths below. Think of this as a shader network graph, where a texture object could
// be executed per pixel with a sampler, "outputs:out" would be the sampled color.
shader.smoothnessScale.defaultValue = 0.99f;
shader.enableSpecularHighlights.defaultValue = true;
shader.enableGlossyReflections.defaultValue = true;
shader.albedo.defaultValue = Color.white;
shader.albedoMap.SetConnectedPath(albedoMapPath, "outputs:out");
shader.normalMapScale.defaultValue = 0.76f;
shader.normalMap.SetConnectedPath(normalMapPath, "outputs:out");
shader.emission.defaultValue = Color.white * 0.3f;
shader.emissionMap.SetConnectedPath(emissionMapPath, "outputs:out");
shader.metallicMap.SetConnectedPath(metallicMapPath, "outputs:out");
shader.occlusionMapScale.defaultValue = 0.65f;
shader.occlusionMap.SetConnectedPath(occlusionMapPath, "outputs:out");
shader.parallaxMapScale.defaultValue = 0.1f;
shader.parallaxMap.SetConnectedPath(parallaxMapPath, "outputs:out");
shader.detailMask.SetConnectedPath(detailMaskPath);
shader.detailNormalMapScale.defaultValue = .05f;
shader.detailNormalMap.SetConnectedPath(detailNormalMapPath, "outputs:out");
//
// Setup Textures.
//
var albedoTexture = new Texture2DSample();
albedoTexture.sourceFile.defaultValue = textureFilePath + "albedoMap.png";
albedoTexture.sRgb = true;
var normalTexture = new Texture2DSample();
normalTexture.sourceFile.defaultValue = textureFilePath + "normalMap.png";
normalTexture.sRgb = true;
var emissionTexture = new Texture2DSample();
emissionTexture.sourceFile.defaultValue = textureFilePath + "emissionMap.png";
emissionTexture.sRgb = true;
var metallicTexture = new Texture2DSample();
metallicTexture.sourceFile.defaultValue = textureFilePath + "metallicMap.png";
metallicTexture.sRgb = true;
var occlusionTexture = new Texture2DSample();
occlusionTexture.sourceFile.defaultValue = textureFilePath + "occlusionMap.png";
occlusionTexture.sRgb = true;
var parallaxTexture = new Texture2DSample();
parallaxTexture.sourceFile.defaultValue = textureFilePath + "parallaxMap.png";
parallaxTexture.sRgb = true;
var detailNormalTexture = new Texture2DSample();
detailNormalTexture.sourceFile.defaultValue = textureFilePath + "detailMap.png";
detailNormalTexture.sRgb = true;
var detailMaskTexture = new Texture2DSample();
detailMaskTexture.sourceFile.defaultValue = textureFilePath + "metallicMap.png";
detailMaskTexture.sRgb = true;
//
// Write Everything.
//
scene.Write(cubePath, cube);
scene.Write(materialPath, material);
scene.Write(shaderPath, shader);
scene.Write(albedoMapPath, albedoTexture);
scene.Write(normalMapPath, normalTexture);
scene.Write(emissionMapPath, emissionTexture);
scene.Write(metallicMapPath, metallicTexture);
scene.Write(occlusionMapPath, occlusionTexture);
scene.Write(parallaxMapPath, parallaxTexture);
scene.Write(detailNormalMapPath, detailNormalTexture);
scene.Write(detailMaskPath, detailMaskTexture);
//
// Bind Material.
//
MaterialSample.Bind(scene, cubePath, materialPath);
//
// Write out the scene as a string, for debugging.
//
string s;
scene.Stage.ExportToString(out s);
Debug.Log("Loading:\n" + s);
return(scene);
}
public static void MaterialBindTest()
{
// Game plan:
// 1. Create a cube
// 2. Create a material
// 3. Create a shader
// 4. Create a texture
// 5. Connect the material to the shader's output
// 6. Connect the shader's albedo parameter to the texture's output
// 7. Connect the texture to the source file on disk
// 8. Write all values
// 9. Bind the cube to the material
var scene = Scene.Create();
var cubePath = "/Model/Geom/Cube";
var materialPath = "/Model/Materials/SimpleMat";
var shaderPath = "/Model/Materials/SimpleMat/StandardShader";
var texturePath = "/Model/Materials/SimpleMat/AlbedoTexture";
var cube = new CubeSample();
cube.size = 1;
var material = new MaterialSample();
material.surface.SetConnectedPath(shaderPath, "outputs:out");
var shader = new StandardShaderSample();
shader.albedo.defaultValue = Color.white;
shader.albedo.SetConnectedPath(texturePath, "outputs:out");
AssertEqual(shader.albedo.connectedPath, texturePath + ".outputs:out");
var texture = new Texture2DSample();
texture.sourceFile.defaultValue = @"C:\A\Bogus\Texture\Path.png";
texture.sRgb = true;
scene.Write("/Model", new XformSample());
scene.Write("/Model/Geom", new XformSample());
scene.Write("/Model/Materials", new XformSample());
scene.Write(cubePath, cube);
scene.Write(materialPath, material);
scene.Write(shaderPath, shader);
scene.Write(texturePath, texture);
MaterialSample.Bind(scene, cubePath, materialPath);
var material2 = new MaterialSample();
var shader2 = new StandardShaderSample();
var texture2 = new Texture2DSample();
scene.Read(materialPath, material2);
scene.Read(shaderPath, shader2);
scene.Read(texturePath, texture2);
var param = shader2.GetInputParameters().First();
AssertEqual(shader.albedo.connectedPath, param.connectedPath);
AssertEqual("albedo", param.usdName);
AssertEqual(shader.albedo.defaultValue, param.value);
AssertEqual("_Color", param.unityName);
var paramTex = shader2.GetInputTextures().First();
AssertEqual(shader.albedoMap.connectedPath, paramTex.connectedPath);
AssertEqual("albedoMap", paramTex.usdName);
AssertEqual(shader.albedoMap.defaultValue, paramTex.value);
AssertEqual("_MainTex", paramTex.unityName);
AssertEqual(material.surface.defaultValue, material2.surface.defaultValue);
AssertEqual(material.surface.connectedPath, material2.surface.connectedPath);
AssertEqual(shader.albedo.defaultValue, shader2.albedo.defaultValue);
AssertEqual(shader.albedo.connectedPath, shader2.albedo.connectedPath);
AssertEqual(shader.id, shader2.id);
AssertEqual(texture.sourceFile.defaultValue, texture2.sourceFile.defaultValue);
AssertEqual(texture.sRgb, texture2.sRgb);
PrintScene(scene);
}
/// <summary>
/// Copy cube data from USD to Unity with the given import options.
/// </summary>
/// <param name="skinnedMesh">
/// Whether the Cube to build is skinned or not. This will allow to determine which Renderer to create
/// on the GameObject (MeshRenderer or SkinnedMeshRenderer). Default value is false (not skinned).
/// </param>
public static void BuildCube(CubeSample usdCube,
GameObject go,
SceneImportOptions options,
bool skinnedMesh = false)
{
Material mat = null;
var cubeGo = GameObject.CreatePrimitive(PrimitiveType.Cube);
var unityMesh = cubeGo.GetComponent <MeshFilter>().sharedMesh;
GameObject.DestroyImmediate(cubeGo);
// Because Unity only handle a cube with a default size, the custom size of it is define by the localScale
// transform. This also need to be taken into account while computing the Unity extent of the mesh (see bellow).
// This is doable because xformable data are always handled before mesh data, so go.transform already
// contains any transform of the geometry.
float size = (float)usdCube.size;
go.transform.localScale = go.transform.localScale * size;
bool changeHandedness = options.changeHandedness == BasisTransformation.SlowAndSafe;
bool hasBounds = usdCube.extent.size.x > 0 ||
usdCube.extent.size.y > 0 ||
usdCube.extent.size.z > 0;
if (ShouldImport(options.meshOptions.boundingBox) && hasBounds)
{
if (changeHandedness)
{
usdCube.extent.center = UnityTypeConverter.ChangeBasis(usdCube.extent.center);
// Divide the extent by the size of the cube. A custom size of the extent is define by
// the localScale transform (see above).
usdCube.extent.extents = UnityTypeConverter.ChangeBasis(usdCube.extent.extents) / size;
}
unityMesh.bounds = usdCube.extent;
}
else if (ShouldCompute(options.meshOptions.boundingBox))
{
unityMesh.RecalculateBounds();
}
if (usdCube.colors != null && ShouldImport(options.meshOptions.color))
{
// NOTE: The following color conversion assumes PlayerSettings.ColorSpace == Linear.
// For best performance, convert color space to linear off-line and skip conversion.
if (usdCube.colors.Length == 1)
{
// Constant color can just be set on the material.
mat = options.materialMap.InstantiateSolidColor(usdCube.colors[0].gamma);
Debug.Log("constant colors assigned");
}
else if (usdCube.colors.Length == 6)
{
// Uniform colors to verts.
// Note that USD cubes have 6 uniform colors and Unity cube mesh has 24 (6*4)
// TODO: move the conversion to C++ and use the color management API.
Debug.Log(unityMesh.vertexCount);
for (int i = 0; i < usdCube.colors.Length; i++)
{
usdCube.colors[i] = usdCube.colors[i];
}
var unityColors = new Color[24];
// Front:0, Back:1, Top:2, Bottom:3, Right:4, Left:5
unityColors[0] = usdCube.colors[0]; // front bottom right
unityColors[1] = usdCube.colors[0]; // front bottom left
unityColors[2] = usdCube.colors[0]; // front top right
unityColors[3] = usdCube.colors[0]; // front top left
unityColors[4] = usdCube.colors[2]; // top back right
unityColors[5] = usdCube.colors[2]; // top back left
unityColors[6] = usdCube.colors[1]; // back bottom right
unityColors[7] = usdCube.colors[1]; // back bottom left
unityColors[8] = usdCube.colors[2]; // top front right
unityColors[9] = usdCube.colors[2]; // top front left
unityColors[10] = usdCube.colors[1]; // back top right
unityColors[11] = usdCube.colors[1]; // back top left
unityColors[12] = usdCube.colors[3]; // Bottom back right
unityColors[13] = usdCube.colors[3]; // Bottom front right
unityColors[14] = usdCube.colors[3]; // Bottom front left
unityColors[15] = usdCube.colors[3]; // Bottom back left
unityColors[16] = usdCube.colors[5]; // left front bottom
unityColors[17] = usdCube.colors[5]; // left front top
unityColors[18] = usdCube.colors[5]; // left back top
unityColors[19] = usdCube.colors[5]; // left back bottom
unityColors[20] = usdCube.colors[4]; // right back bottom
unityColors[21] = usdCube.colors[4]; // right back top
unityColors[22] = usdCube.colors[4]; // right front top
unityColors[23] = usdCube.colors[4]; // right front bottom
unityMesh.colors = unityColors;
}
else if (usdCube.colors.Length == 24)
{
// Face varying colors to verts.
// Note that USD cubes have 24 face varying colors and Unity cube mesh has 24 (6*4)
// TODO: move the conversion to C++ and use the color management API.
Debug.Log(unityMesh.vertexCount);
for (int i = 0; i < usdCube.colors.Length; i++)
{
usdCube.colors[i] = usdCube.colors[i];
}
// USD order: front, back, top, bottom, right, left
var unityColors = new Color[24];
unityColors[0] = usdCube.colors[3]; // front bottom right
unityColors[1] = usdCube.colors[2]; // front bottom left
unityColors[2] = usdCube.colors[0]; // front top right
unityColors[3] = usdCube.colors[1]; // front top left
unityColors[4] = usdCube.colors[8 + 1]; // top back right
unityColors[5] = usdCube.colors[8 + 2]; // top back left
unityColors[6] = usdCube.colors[4 + 3]; // back bottom right
unityColors[7] = usdCube.colors[4 + 0]; // back bottom left
unityColors[8] = usdCube.colors[8 + 0]; // top front right
unityColors[9] = usdCube.colors[8 + 3]; // top front left
unityColors[10] = usdCube.colors[4 + 2]; // back top right
unityColors[11] = usdCube.colors[4 + 1]; // back top left
unityColors[12] = usdCube.colors[12 + 1]; // Bottom back right
unityColors[13] = usdCube.colors[12 + 2]; // Bottom front right
unityColors[14] = usdCube.colors[12 + 3]; // Bottom front left
unityColors[15] = usdCube.colors[12 + 0]; // Bottom back left
unityColors[16] = usdCube.colors[20 + 1]; // left front bottom
unityColors[17] = usdCube.colors[20 + 2]; // left front top
unityColors[18] = usdCube.colors[20 + 3]; // left back top
unityColors[19] = usdCube.colors[20 + 0]; // left back bottom
unityColors[20] = usdCube.colors[16 + 2]; // right back bottom
unityColors[21] = usdCube.colors[16 + 3]; // right back top
unityColors[22] = usdCube.colors[16 + 0]; // right front top
unityColors[23] = usdCube.colors[16 + 1]; // right front bottom
unityMesh.colors = unityColors;
}
else if (usdCube.colors.Length == 8)
{
// Vertex colors map on to verts.
// Note that USD cubes have 8 verts but Unity cube mesh has 24 (6*4)
// TODO: move the conversion to C++ and use the color management API.
Debug.Log(unityMesh.vertexCount);
for (int i = 0; i < usdCube.colors.Length; i++)
{
usdCube.colors[i] = usdCube.colors[i];
}
// USD order: front (top-right -> ccw)
// back (bottom-left -> ccw (from back perspective))
var unityColors = new Color[24];
unityColors[0] = usdCube.colors[3]; // front bottom right
unityColors[1] = usdCube.colors[2]; // front bottom left
unityColors[2] = usdCube.colors[0]; // front top right
unityColors[3] = usdCube.colors[1]; // front top left
unityColors[4] = usdCube.colors[6]; // top back right
unityColors[5] = usdCube.colors[5]; // top back left
unityColors[6] = usdCube.colors[7]; // back bottom right
unityColors[7] = usdCube.colors[4]; // back bottom left
unityColors[8] = usdCube.colors[0]; // top front right
unityColors[9] = usdCube.colors[1]; // top front left
unityColors[10] = usdCube.colors[6]; // back top right
unityColors[11] = usdCube.colors[5]; // back top left
unityColors[12] = usdCube.colors[7]; // Bottom back right
unityColors[13] = usdCube.colors[3]; // Bottom front right
unityColors[14] = usdCube.colors[2]; // Bottom front left
unityColors[15] = usdCube.colors[4]; // Bottom back left
unityColors[16] = usdCube.colors[2]; // left front bottom
unityColors[17] = usdCube.colors[1]; // left front top
unityColors[18] = usdCube.colors[5]; // left back top
unityColors[19] = usdCube.colors[4]; // left back bottom
unityColors[20] = usdCube.colors[7]; // right back bottom
unityColors[21] = usdCube.colors[6]; // right back top
unityColors[22] = usdCube.colors[0]; // right front top
unityColors[23] = usdCube.colors[3]; // right front bottom
unityMesh.colors = unityColors;
Debug.Log("vertex colors assigned");
}
else
{
// FaceVarying and uniform both require breaking up the mesh and are not yet handled in
// this example.
Debug.LogWarning("Uniform (color per face) and FaceVarying (color per vert per face) "
+ "display color not supported in this example");
}
}
if (mat == null)
{
mat = options.materialMap.InstantiateSolidColor(Color.white);
}
// Create Unity mesh.
Renderer renderer;
if (skinnedMesh)
{
SkinnedMeshRenderer skinnedRenderer = ImporterBase.GetOrAddComponent <SkinnedMeshRenderer>(go);
if (skinnedRenderer.sharedMesh == null)
{
skinnedRenderer.sharedMesh = Mesh.Instantiate(unityMesh);
}
renderer = skinnedRenderer;
}
else
{
renderer = ImporterBase.GetOrAddComponent <MeshRenderer>(go);
MeshFilter meshFilter = ImporterBase.GetOrAddComponent <MeshFilter>(go);
if (meshFilter.sharedMesh == null)
{
meshFilter.sharedMesh = Mesh.Instantiate(unityMesh);
}
}
if (unityMesh.subMeshCount == 1)
{
renderer.sharedMaterial = mat;
}
else
{
var mats = new Material[unityMesh.subMeshCount];
for (int i = 0; i < mats.Length; i++)
{
mats[i] = mat;
}
renderer.sharedMaterials = mats;
}
}
public static void ReadWriteTest()
{
// Game plan:
// 1. Create a cube
// 2. Create a material
// 3. Create a shader
// 4. Create a texture
// 5. Connect the material to the shader's output
// 6. Connect the shader's albedo parameter to the texture's output
// 7. Connect the texture to the source file on disk
// 8. Write all values
// 9. Bind the cube to the material
var scene = Scene.Create();
var cubePath = "/Model/Geom/Cube";
var materialPath = "/Model/Materials/SimpleMat";
var shaderPath = "/Model/Materials/SimpleMat/PreviewMaterial";
var texturePath = "/Model/Materials/SimpleMat/TextureReader";
var primvarReaderPath = "/Model/Materials/SimpleMat/UvReader";
var cube = new CubeSample();
cube.size = 1;
var material = new MaterialSample();
material.surface.SetConnectedPath(shaderPath, "outputs:result");
var shader = new PreviewSurfaceSample();
shader.diffuseColor.defaultValue = Vector3.one;
shader.diffuseColor.SetConnectedPath(texturePath, "outputs:rgb");
var texture = new TextureReaderSample();
texture.file.defaultValue = new SdfAssetPath(@"C:\A\Bogus\Texture\Path.png");
var primvarReader = new PrimvarReaderSample <Vector2>();
primvarReader.varname.defaultValue = new TfToken("st");
scene.Write("/Model", new XformSample());
scene.Write("/Model/Geom", new XformSample());
scene.Write("/Model/Materials", new XformSample());
scene.Write(cubePath, cube);
scene.Write(materialPath, material);
scene.Write(shaderPath, shader);
scene.Write(texturePath, texture);
scene.Write(primvarReaderPath, primvarReader);
MaterialSample.Bind(scene, cubePath, materialPath);
var material2 = new MaterialSample();
var shader2 = new PreviewSurfaceSample();
var texture2 = new TextureReaderSample();
var primvarReader2 = new PrimvarReaderSample <Vector2>();
scene.Read(materialPath, material2);
scene.Read(shaderPath, shader2);
scene.Read(texturePath, texture2);
scene.Read(primvarReaderPath, primvarReader2);
var param = shader2.GetInputParameters().First();
AssertEqual(shader.diffuseColor.connectedPath, param.connectedPath);
AssertEqual("diffuseColor", param.usdName);
AssertEqual(shader.diffuseColor.defaultValue, param.value);
AssertEqual("_DiffuseColor", param.unityName);
AssertEqual(material.surface.defaultValue, material2.surface.defaultValue);
AssertEqual(material.surface.connectedPath, material2.surface.connectedPath);
AssertEqual(shader.diffuseColor.defaultValue, shader2.diffuseColor.defaultValue);
AssertEqual(shader.diffuseColor.connectedPath, shader2.diffuseColor.connectedPath);
AssertEqual(shader.id, shader2.id);
AssertEqual(texture.file.defaultValue, texture2.file.defaultValue);
AssertEqual(primvarReader.varname.defaultValue, primvarReader.varname.defaultValue);
PrintScene(scene);
}
