public static void CreatePointInstancerManualTest()
        {
            var scene        = USD.NET.Scene.Create();
            var stageWeakRef = new pxr.UsdStageWeakPtr(scene.Stage);
            var pi           = pxr.UsdGeomPointInstancer.Define(stageWeakRef, new pxr.SdfPath("/Instancer"));
            var cube         = pxr.UsdGeomCube.Define(stageWeakRef, new pxr.SdfPath("/Instancer/Cube"));

            // The cube is the only prototype.
            pi.CreatePrototypesRel().AddTarget(cube.GetPath());

            // Create three instances of the cube (proto index=0).
            var intArray = new pxr.VtIntArray(3, 0);

            pi.CreateProtoIndicesAttr().Set(intArray);

            var mesh        = new pxr.UsdGeomMesh();
            var meshSamples = new USD.NET.Unity.MeshSample[0];

            // Create three positions.
            var vec3fArray = new pxr.VtVec3fArray(3);

            vec3fArray[0] = new pxr.GfVec3f(-2.5f, 0, 0);
            vec3fArray[1] = new pxr.GfVec3f(0, 0, 0);
            vec3fArray[2] = new pxr.GfVec3f(2.5f, 0, 0);
            pi.CreatePositionsAttr().Set(vec3fArray);

            scene.Stage.Export("D:\\instancer.usda");

            //
            // Compute the root transform for each instance.
            //
            var xforms = new pxr.VtMatrix4dArray(3);

            pi.ComputeInstanceTransformsAtTime(xforms, time: 1.0, baseTime: 0.0);

            for (int i = 0; i < xforms.size(); i++)
            {
                Console.WriteLine(xforms[i]);
            }
        }
示例#2
0
        public static void ExportSkelAnimation(ObjectContext objContext, ExportContext exportContext)
        {
            var scene     = exportContext.scene;
            var sample    = (SkelAnimationSample)objContext.sample;
            var go        = objContext.gameObject;
            var boneNames = exportContext.skelSortedMap[go.transform];
            var skelRoot  = go.transform;

            sample.joints = new string[boneNames.Count];

            var worldXf    = new Matrix4x4[boneNames.Count];
            var worldXfInv = new Matrix4x4[boneNames.Count];

            string rootPath = UnityTypeConverter.GetPath(go.transform);

            var basisChange = Matrix4x4.identity;

            basisChange[2, 2] = -1;

            for (int i = 0; i < boneNames.Count; i++)
            {
                var bonePath = boneNames[i];
                if (!exportContext.pathToBone.ContainsKey(bonePath))
                {
                    sample.joints[i] = "";
                    continue;
                }

                var bone = exportContext.pathToBone[bonePath];
                sample.joints[i] = bonePath.Replace(rootPath + "/", "");

                worldXf[i] = bone.localToWorldMatrix;
                if (exportContext.basisTransform == BasisTransformation.SlowAndSafe)
                {
                    worldXf[i] = UnityTypeConverter.ChangeBasis(worldXf[i]);
                }

                worldXfInv[i] = worldXf[i].inverse;
            }

            var rootXf = skelRoot.localToWorldMatrix.inverse;

            if (exportContext.basisTransform == BasisTransformation.SlowAndSafe)
            {
                rootXf = UnityTypeConverter.ChangeBasis(rootXf);
            }

            var skelWorldTransform = UnityTypeConverter.ToGfMatrix(rootXf);

            pxr.VtMatrix4dArray vtJointsLS    = new pxr.VtMatrix4dArray((uint)boneNames.Count);
            pxr.VtMatrix4dArray vtJointsWS    = UnityTypeConverter.ToVtArray(worldXf);
            pxr.VtMatrix4dArray vtJointsWSInv = UnityTypeConverter.ToVtArray(worldXfInv);

            var translations = new pxr.VtVec3fArray();
            var rotations    = new pxr.VtQuatfArray();

            sample.scales = new pxr.VtVec3hArray();

            var topo = new pxr.UsdSkelTopology(UnityTypeConverter.ToVtArray(sample.joints));

            pxr.UsdCs.UsdSkelComputeJointLocalTransforms(topo,
                                                         vtJointsWS,
                                                         vtJointsWSInv,
                                                         vtJointsLS,
                                                         skelWorldTransform);

            pxr.UsdCs.UsdSkelDecomposeTransforms(
                vtJointsLS,
                translations,
                rotations,
                sample.scales);
            sample.translations = UnityTypeConverter.FromVtArray(translations);
            sample.rotations    = UnityTypeConverter.FromVtArray(rotations);

            scene.Write(objContext.path, sample);
        }