/// <summary> /// Export an AnimationCurve. /// NOTE: This is not used for rotations, because we need to convert from /// quaternion to euler and various other stuff. /// </summary> protected void ExportAnimCurve(UnityEngine.Object unityObj, AnimationCurve unityAnimCurve, string unityPropertyName, FbxScene fbxScene, FbxAnimLayer fbxAnimLayer) { FbxPropertyChannelPair fbxPropertyChannelPair; if (!FbxPropertyChannelPair.TryGetValue(unityPropertyName, out fbxPropertyChannelPair)) { Debug.LogWarning(string.Format("no mapping from Unity '{0}' to fbx property", unityPropertyName)); return; } GameObject unityGo = GetGameObject(unityObj); if (unityGo == null) { Debug.LogError(string.Format("cannot find gameobject for {0}", unityObj.ToString())); return; } FbxNode fbxNode; if (!MapUnityObjectToFbxNode.TryGetValue(unityGo, out fbxNode)) { Debug.LogError(string.Format("no fbx node for {0}", unityGo.ToString())); return; } // map unity property name to fbx property var fbxProperty = fbxNode.FindProperty(fbxPropertyChannelPair.Property, false); if (!fbxProperty.IsValid()) { Debug.LogError(string.Format("no fbx property {0} found on {1} ", fbxPropertyChannelPair.Property, fbxNode.GetName())); return; } if (Verbose) { Debug.Log("Exporting animation for " + unityObj.ToString() + " (" + unityPropertyName + ")"); } // Create the AnimCurve on the channel FbxAnimCurve fbxAnimCurve = fbxProperty.GetCurve(fbxAnimLayer, fbxPropertyChannelPair.Channel, true); // copy Unity AnimCurve to FBX AnimCurve. fbxAnimCurve.KeyModifyBegin(); for (int keyIndex = 0, n = unityAnimCurve.length; keyIndex < n; ++keyIndex) { var key = unityAnimCurve [keyIndex]; var fbxTime = FbxTime.FromSecondDouble(key.time); fbxAnimCurve.KeyAdd(fbxTime); fbxAnimCurve.KeySet(keyIndex, fbxTime, key.value); } fbxAnimCurve.KeyModifyEnd(); }
public FbxScene GetPoseScene() { global::System.IntPtr cPtr = fbx_wrapperPINVOKE.FbxCharacterPose_GetPoseScene(swigCPtr); FbxScene ret = (cPtr == global::System.IntPtr.Zero) ? null : new FbxScene(cPtr, false); return(ret); }
/// <summary> /// Process fbxScene. If system units don't match then bake the convertion into the position /// and vertices of objects. /// </summary> public void ProcessScene(FbxScene fbxScene) { Debug.Log(string.Format("Scene name: {0}", fbxScene.GetName())); var fbxSettings = fbxScene.GetGlobalSettings(); FbxSystemUnit fbxSystemUnit = fbxSettings.GetSystemUnit(); if (fbxSystemUnit != UnitySystemUnit) { Debug.Log(string.Format("converting system unit to match Unity. Expected {0}, found {1}", UnitySystemUnit, fbxSystemUnit)); ConvertScene(fbxScene, UnitySystemUnit); } else { Debug.Log(string.Format("file system units {0}", fbxSystemUnit)); } // The Unity axis system has Y up, Z forward, X to the right (left-handed). FbxAxisSystem fbxAxisSystem = fbxSettings.GetAxisSystem(); if (fbxAxisSystem != UnityAxisSystem) { Debug.LogWarning(string.Format("file axis system do not match Unity, Expected {0} found {1}", AxisSystemToString(UnityAxisSystem), AxisSystemToString(fbxAxisSystem))); } ProcessNode(fbxScene.GetRootNode()); return; }
/// <summary> /// Export the Animator component on this game object /// </summary> protected void ExportAnimationClips(GameObject unityRoot, FbxScene fbxScene) { var animator = unityRoot.GetComponent <Animator> (); if (!animator) { return; } // Get the controller. var controller = animator.runtimeAnimatorController; if (!controller) { return; } // Only export each clip once per game object. var exported = new HashSet <AnimationClip> (); foreach (var clip in controller.animationClips) { if (exported.Add(clip)) { ExportAnimationClip(clip, unityRoot, fbxScene); } } }
protected override void CheckScene(FbxScene scene) { FbxScene origScene = CreateScene(FbxManager); Assert.IsNotNull(origScene); Assert.IsNotNull(scene); // Retrieve the mesh from each scene FbxMesh origMesh = origScene.GetRootNode().GetChild(0).GetMesh(); FbxMesh importMesh = scene.GetRootNode().GetChild(0).GetMesh(); Assert.IsNotNull(origMesh); Assert.IsNotNull(importMesh); // check that the control points match Assert.AreEqual(origMesh.GetControlPointsCount(), importMesh.GetControlPointsCount()); for (int i = 0; i < origMesh.GetControlPointsCount(); i++) { FbxVector4 origControlPoint = origMesh.GetControlPointAt(i); FbxVector4 importControlPoint = importMesh.GetControlPointAt(i); // Note: Ignoring W as no matter what it is set to it always imports as 0 Assert.AreEqual(origControlPoint.X, importControlPoint.X); Assert.AreEqual(origControlPoint.Y, importControlPoint.Y); Assert.AreEqual(origControlPoint.Z, importControlPoint.Z); } }
protected override void CheckScene(FbxScene scene) { base.CheckScene(scene); FbxScene origScene = CreateScene(FbxManager); Assert.AreEqual(origScene.GetRootNode().GetChildCount(), origScene.GetRootNode().GetChildCount()); FbxNode origMeshNode = origScene.GetRootNode().GetChild(0); FbxNode importMeshNode = scene.GetRootNode().GetChild(0); FbxNode origSkelRootNode = origScene.GetRootNode().GetChild(1); FbxNode importSkelRootNode = scene.GetRootNode().GetChild(1); // Check that the skeletons match CheckSkeleton(origSkelRootNode, importSkelRootNode); // TODO: Fix so that calling GetDeformer either allows us to downcast // to FbxSkin, or so that it just returns the correct type. // Check that the mesh is correctly linked to the skeleton //CheckMeshLinkedToSkeleton(origMeshNode.GetMesh(), importMeshNode.GetMesh()); origMeshNode.GetMesh(); importMeshNode.GetMesh(); // Check that bind pose is set correctly CheckExportBindPose(origScene, scene); }
/// <summary> /// Unconditionally export components on this game object /// </summary> protected void ExportComponents(GameObject unityGo, FbxScene fbxScene, FbxNode fbxParentNode) { // create an FbxNode and add it as a child of fbxParentNode FbxNode fbxNode = FbxNode.Create(fbxScene, unityGo.name); NumNodes++; ExportTransform(unityGo.transform, fbxNode); var fbxProperty = ExportCustomData(unityGo.transform, fbxNode); if (Verbose) { Debug.Log(string.Format("exporting {0} ({1} components)", fbxNode.GetName(), (int)fbxProperty.GetFloat())); } fbxParentNode.AddChild(fbxNode); // now go through our children and recurse foreach (Transform uniChildT in unityGo.transform) { ExportComponents(uniChildT.gameObject, fbxScene, fbxNode); } return; }
protected override FbxScene CreateScene(FbxManager manager) { // create the following node hierarchy to test: // Root // / \ // Child0 Child1 // | // Child2 // / | \ // Child3 Child4 Child5 FbxScene scene = FbxScene.Create(manager, "myScene"); FbxNode root = FbxNode.Create(scene, "Root"); FbxNode[] children = new FbxNode[6]; for (int i = 0; i < children.Length; i++) { children [i] = FbxNode.Create(scene, "Child" + i); } scene.GetRootNode().AddChild(root); root.AddChild(children [0]); root.AddChild(children [1]); children [1].AddChild(children [2]); children [2].AddChild(children [3]); children [2].AddChild(children [4]); children [2].AddChild(children [5]); return(scene); }
public static FbxAudio Create(FbxScene pContainer, string pName) { global::System.IntPtr cPtr = FbxWrapperNativePINVOKE.FbxAudio_Create__SWIG_2(FbxScene.getCPtr(pContainer), pName); FbxAudio ret = (cPtr == global::System.IntPtr.Zero) ? null : new FbxAudio(cPtr, false); return(ret); }
/// <summary> /// Unconditionally export this mesh object to the file. /// We have decided; this mesh is definitely getting exported. /// </summary> public FbxMesh ExportMesh(GameObject unityGo, FbxScene fbxScene) { var meshInfo = GetMeshInfo(unityGo); if (!meshInfo.IsValid) { return(null); } // create the mesh structure. FbxMesh fbxMesh = FbxMesh.Create(fbxScene, "Scene"); // Create control points. int NumControlPoints = meshInfo.VertexCount; fbxMesh.InitControlPoints(NumControlPoints); // copy control point data from Unity to FBX for (int v = 0; v < NumControlPoints; v++) { fbxMesh.SetControlPointAt(new FbxVector4(meshInfo.Vertices [v].x, meshInfo.Vertices [v].y, meshInfo.Vertices [v].z), v); } for (int f = 0; f < meshInfo.Triangles.Length / 3; f++) { fbxMesh.BeginPolygon(); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 1]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 2]); fbxMesh.EndPolygon(); } return(fbxMesh); }
public FbxScene GetScene() { global::System.IntPtr cPtr = FbxWrapperNativePINVOKE.FbxObject_GetScene(swigCPtr); FbxScene ret = (cPtr == global::System.IntPtr.Zero) ? null : new FbxScene(cPtr, false); return(ret); }
protected override FbxScene CreateScene(FbxManager manager) { FbxScene scene = base.CreateScene(manager); // mesh shared by all instances FbxMesh sharedMesh = FbxMesh.Create(scene, m_meshName); FbxSurfaceMaterial sharedMaterial = FbxSurfacePhong.Create(scene, m_materialName); // add mesh to all nodes Queue <FbxNode> nodes = new Queue <FbxNode>(); for (int i = 0; i < scene.GetRootNode().GetChildCount(); i++) { nodes.Enqueue(scene.GetRootNode().GetChild(i)); } while (nodes.Count > 0) { FbxNode node = nodes.Dequeue(); node.SetNodeAttribute(sharedMesh); node.AddMaterial(sharedMaterial); for (int i = 0; i < node.GetChildCount(); i++) { nodes.Enqueue(node.GetChild(i)); } } return(scene); }
public void Load(FbxScene scene, FbxManager manager, ImportOptions options, Matrix4 additionalTransform /*nodeTransform*/) { this.scene = scene; FbxNode rootNode = scene.GetRootNode(); if (rootNode != null) { LoadAnimations(scene); var skins = new List <FbxSkin>(); LoadSkinsFromNodeRecursive(rootNode, skins); Skins = skins.ToArray(); if (HasSceneSkeleton(rootNode)) { Skeleton = new Skeleton(rootNode, this, Skins, AnimationTracks); } //for (int i = 0; i < rootNode.GetChildCount(); i++) // EnumerateNodeRecursive(rootNode.GetChild(i)); //CheckTransparencyInverting(); ReadMeshGeometriesRecursive(manager, rootNode, options, additionalTransform); //if (options.ImportPostProcessFlags.HasFlag(ImportPostProcessFlags.MergeGeometriesByMaterials)) // MergeGeometriesByMaterials(); } }
private void ImportAnimations(FbxScene scene) { foreach (var animation in scene.Animations.List) { var n = Model.TryFind <Node3D>(animation.AnimationKey); var scaleKeys = Vector3KeyReducer.Default.Reduce(animation.ScaleKeys); if (scaleKeys.Count != 0) { (n.Animators["Scale", animation.MarkerId] as Animator <Vector3>).Keys.AddRange(scaleKeys); } var rotKeys = QuaternionKeyReducer.Default.Reduce(animation.RotationKeys); if (rotKeys.Count != 0) { if (n is Camera3D) { CorrectCameraAnimationKeys(rotKeys); } (n.Animators["Rotation", animation.MarkerId] as Animator <Quaternion>).Keys.AddRange(rotKeys); } var posKeys = Vector3KeyReducer.Default.Reduce(animation.PositionKeys); if (posKeys.Count != 0) { (n.Animators["Position", animation.MarkerId] as Animator <Vector3>).Keys.AddRange(posKeys); } if (!Model.Animations.Any(a => a.Id == animation.MarkerId)) { Model.Animations.Add(new Lime.Animation { Id = animation.MarkerId, }); } } }
public new static FbxScene Create(FbxManager pManager, string pName) { global::System.IntPtr cPtr = fbx_wrapperPINVOKE.FbxScene_Create__SWIG_0(FbxManager.getCPtr(pManager), pName); FbxScene ret = (cPtr == global::System.IntPtr.Zero) ? null : new FbxScene(cPtr, false); return(ret); }
public void Scene_Create_HasProperties() { // given: var scene = new FbxScene(""); FbxProperty prop; // then: Assert.AreEqual(2, CountProperties(scene)); Assert.AreEqual(0, scene.GetSrcPropertyCount()); Assert.AreEqual(0, scene.GetDstPropertyCount()); prop = scene.FindProperty("SourceObject"); Assert.NotNull(prop); Assert.True(prop.IsValid()); Assert.NotNull(scene.Roots); Assert.True(scene.Roots.IsValid()); Assert.AreEqual("SourceObject", scene.Roots.GetName()); Assert.AreSame(prop, scene.Roots); prop = scene.FindProperty("ActiveAnimStackName"); Assert.NotNull(prop); Assert.True(prop.IsValid()); Assert.NotNull(scene.ActiveAnimStackName); Assert.True(scene.ActiveAnimStackName.IsValid()); Assert.AreEqual("ActiveAnimStackName", scene.ActiveAnimStackName.GetName()); Assert.AreSame(prop, scene.ActiveAnimStackName); }
public new static FbxScene Create(FbxObject pContainer, string pName) { global::System.IntPtr cPtr = FbxWrapperNativePINVOKE.FbxScene_Create__SWIG_1(FbxObject.getCPtr(pContainer), pName); FbxScene ret = (cPtr == global::System.IntPtr.Zero) ? null : new FbxScene(cPtr, false); return(ret); }
public static FbxAnimCurve Create(FbxScene pContainer, string pName) { global::System.IntPtr cPtr = fbx_wrapperPINVOKE.FbxAnimCurve_Create__SWIG_1(FbxScene.getCPtr(pContainer), pName); FbxAnimCurve ret = (cPtr == global::System.IntPtr.Zero) ? null : new FbxAnimCurve(cPtr, false); return(ret); }
/// <summary> /// Unconditionally export components on this game object /// </summary> protected void ExportComponents(GameObject unityGo, FbxScene fbxScene, FbxNode fbxNodeParent) { // create an FbxNode and add it as a child of parent FbxNode fbxNode = FbxNode.Create(fbxScene, unityGo.name); NumNodes++; ExportTransform(unityGo.transform, fbxNode); ExportMesh(GetMeshInfo(unityGo), fbxNode, fbxScene); if (Verbose) { Debug.Log(string.Format("exporting {0}", fbxNode.GetName())); } fbxNodeParent.AddChild(fbxNode); // now unityGo through our children and recurse foreach (Transform childT in unityGo.transform) { ExportComponents(childT.gameObject, fbxScene, fbxNode); } return; }
protected void ExportBindPose(FbxNode meshNode, FbxScene fbxScene, List <FbxNode> boneNodes) { FbxPose fbxPose = FbxPose.Create(fbxScene, "Pose"); // set as bind pose fbxPose.SetIsBindPose(true); // assume each bone node has one weighted vertex cluster foreach (FbxNode fbxNode in boneNodes) { // EvaluateGlobalTransform returns an FbxAMatrix (affine matrix) // which has to be converted to an FbxMatrix so that it can be passed to fbxPose.Add(). // The hierarchy for FbxMatrix and FbxAMatrix is as follows: // // FbxDouble4x4 // / \ // FbxMatrix FbxAMatrix // // Therefore we can't convert directly from FbxAMatrix to FbxMatrix, // however FbxMatrix has a constructor that takes an FbxAMatrix. FbxMatrix fbxBindMatrix = new FbxMatrix(fbxNode.EvaluateGlobalTransform()); fbxPose.Add(fbxNode, fbxBindMatrix); } FbxMatrix bindMatrix = new FbxMatrix(meshNode.EvaluateGlobalTransform()); fbxPose.Add(meshNode, bindMatrix); // add the pose to the scene fbxScene.AddPose(fbxPose); }
/// <summary> /// Unconditionally export components on this game object /// </summary> protected void ExportComponents(GameObject unityGo, FbxScene fbxScene, FbxNode fbxParentNode) { // create an FbxNode and add it as a child of fbxParentNode FbxNode fbxNode = FbxNode.Create(fbxScene, unityGo.name); NumNodes++; ExportTransform(unityGo.transform, fbxNode); var fbxNodeAttr = ExportNull(fbxScene); // set the fbxNode's node attribute fbxNode.SetNodeAttribute(fbxNodeAttr); fbxNode.SetShadingMode(FbxNode.EShadingMode.eWireFrame); if (Verbose) { Debug.Log(string.Format("exporting {0}", fbxNode.GetName())); } fbxParentNode.AddChild(fbxNode); // now unityGo through our children and recurse foreach (Transform uniChildT in unityGo.transform) { ExportComponents(uniChildT.gameObject, fbxScene, fbxNode); } return; }
protected FbxNode CreateSkeleton(FbxScene scene) { FbxSkeleton skelRoot = FbxSkeleton.Create(scene, "SkelRoot"); skelRoot.SetSkeletonType(FbxSkeleton.EType.eRoot); FbxNode skelRootNode = FbxNode.Create(scene, "SkelRootNode"); skelRootNode.SetNodeAttribute(skelRoot); skelRootNode.LclTranslation.Set(new FbxDouble3(0.0, -40.0, 0.0)); // create skeleton limb nodes FbxSkeleton skelLimb1 = FbxSkeleton.Create(scene, "SkelLimb1"); skelLimb1.SetSkeletonType(FbxSkeleton.EType.eLimbNode); skelLimb1.Size.Set(1.5); FbxNode skelLimbNode1 = FbxNode.Create(scene, "SkelLimbNode1"); skelLimbNode1.SetNodeAttribute(skelLimb1); skelLimbNode1.LclTranslation.Set(new FbxDouble3(0.0, 40.0, 0.0)); FbxSkeleton skelLimb2 = FbxSkeleton.Create(scene, "SkelLimb2"); skelLimb2.SetSkeletonType(FbxSkeleton.EType.eLimbNode); skelLimb2.Size.Set(1.5); FbxNode skelLimbNode2 = FbxNode.Create(scene, "SkelLimbNode2"); skelLimbNode2.SetNodeAttribute(skelLimb2); skelLimbNode2.LclTranslation.Set(new FbxDouble3(0.0, 40.0, 0.0)); // build skeleton hierarchy skelRootNode.AddChild(skelLimbNode1); skelLimbNode1.AddChild(skelLimbNode2); return(skelRootNode); }
public SkeletonExporter(FbxScene scene, FLVER2 flver, HKX.HKASkeleton hKASkeleton, List <DsBone> bones) { Scene = scene; this.Flver = flver; this.bones = bones; this.hkaSkeleton = hKASkeleton; }
protected override FbxScene CreateScene(FbxManager manager) { // Create a scene with a single node that has an animation clip // attached to it FbxScene scene = FbxScene.Create(manager, "myScene"); FbxNode animNode = FbxNode.Create(scene, "animNode"); // setup anim stack FbxAnimStack fbxAnimStack = CreateAnimStack(scene); // add an animation layer FbxAnimLayer fbxAnimLayer = FbxAnimLayer.Create(scene, "animBaseLayer"); fbxAnimStack.AddMember(fbxAnimLayer); // set up the translation CreateAnimCurves( animNode, fbxAnimLayer, PropertyComponentList, (index) => { return(index * 2.0); }, (index) => { return(index * 3.0f - 1); } ); // TODO: avoid needing to this by creating typemaps for // FbxObject::GetSrcObjectCount and FbxCast. // Not trivial to do as both fbxobject.i and fbxemitter.i // have to be moved up before the ignore all statement // to allow use of templates. scene.SetCurrentAnimationStack(fbxAnimStack); scene.GetRootNode().AddChild(animNode); return(scene); }
/// <summary> /// if this game object is a model prefab then export with shared components /// </summary> protected void ExportInstance(GameObject unityGo, FbxNode fbxNode, FbxScene fbxScene) { PrefabType unityPrefabType = PrefabUtility.GetPrefabType(unityGo); if (unityPrefabType != PrefabType.PrefabInstance) { return; } Object unityPrefabParent = PrefabUtility.GetPrefabParent(unityGo); if (Verbose) { Debug.Log(string.Format("exporting instance {0}({1})", unityGo.name, unityPrefabParent.name)); } FbxMesh fbxMesh = null; if (!SharedMeshes.TryGetValue(unityPrefabParent.name, out fbxMesh)) { fbxMesh = ExportMesh(GetMeshInfo(unityGo), fbxNode, fbxScene); SharedMeshes [unityPrefabParent.name] = fbxMesh; } if (fbxMesh == null) { return; } // set the fbxNode containing the mesh fbxNode.SetNodeAttribute(fbxMesh); fbxNode.SetShadingMode(FbxNode.EShadingMode.eWireFrame); return; }
protected override void CheckScene(FbxScene scene) { FbxScene origScene = CreateScene(FbxManager); FbxNode origAnimNode = origScene.GetRootNode().GetChild(0); FbxNode importAnimNode = scene.GetRootNode().GetChild(0); Assert.AreEqual(origScene.GetRootNode().GetChildCount(), scene.GetRootNode().GetChildCount()); Assert.IsNotNull(origAnimNode); Assert.IsNotNull(importAnimNode); Assert.AreEqual(origAnimNode.GetName(), importAnimNode.GetName()); FbxAnimStack origStack = origScene.GetCurrentAnimationStack(); FbxAnimStack importStack = scene.GetCurrentAnimationStack(); CheckAnimStack(origStack, importStack); FbxAnimLayer origLayer = origStack.GetAnimLayerMember(); FbxAnimLayer importLayer = importStack.GetAnimLayerMember(); Assert.IsNotNull(origLayer); Assert.IsNotNull(importLayer); Assert.AreEqual(FbxTime.EMode.eFrames30, scene.GetGlobalSettings().GetTimeMode()); CheckAnimCurve(origAnimNode, importAnimNode, origLayer, importLayer, PropertyComponentList); }
public void TestBasics() { var scene = FbxScene.Create(Manager, "scene"); var node = FbxNode.Create(scene, "node"); /* Test all we can test with a non-composite curve node, namely one that points to * a lcl translation. */ var animNode = FbxAnimCurveNode.CreateTypedCurveNode(node.LclTranslation, scene); Assert.IsFalse(animNode.IsComposite()); Assert.AreEqual(3, animNode.GetChannelsCount()); Assert.AreEqual(0, animNode.GetChannelIndex(Globals.FBXSDK_CURVENODE_COMPONENT_X)); Assert.AreEqual(Globals.FBXSDK_CURVENODE_COMPONENT_Y, animNode.GetChannelName(1)); var xcurve = animNode.CreateCurve(animNode.GetName(), Globals.FBXSDK_CURVENODE_COMPONENT_X); Assert.IsNotNull(xcurve); var xcurve2 = animNode.CreateCurve(animNode.GetName()); Assert.IsNotNull(xcurve2); var ycurve = animNode.CreateCurve(animNode.GetName(), 1); Assert.IsNotNull(ycurve); animNode.SetChannelValue(Globals.FBXSDK_CURVENODE_COMPONENT_Z, 6); Assert.AreEqual(6, animNode.GetChannelValue(Globals.FBXSDK_CURVENODE_COMPONENT_Z, 0)); Assert.AreEqual(6, animNode.GetChannelValue(2, 0)); animNode.SetChannelValue(2, 0); Assert.AreEqual(2, animNode.GetCurveCount(0)); Assert.AreEqual(1, animNode.GetCurveCount(1, animNode.GetName())); Assert.AreEqual(xcurve, animNode.GetCurve(0)); Assert.AreEqual(xcurve2, animNode.GetCurve(0, 1)); Assert.AreEqual(xcurve2, animNode.GetCurve(0, 1, animNode.GetName())); Assert.IsNull(animNode.GetCurve(1, 1)); var key = xcurve.KeyAdd(FbxTime.FromSecondDouble(0)); xcurve.KeySet(key, FbxTime.FromSecondDouble(0), 5); key = xcurve.KeyAdd(FbxTime.FromSecondDouble(1)); xcurve.KeySet(key, FbxTime.FromSecondDouble(1), -5); Assert.IsTrue(animNode.IsAnimated()); /* TODO: build a composite anim node and test this for real. */ Assert.IsTrue(animNode.IsAnimated(true)); var timespan = new FbxTimeSpan(); Assert.IsTrue(animNode.GetAnimationInterval(timespan)); Assert.AreEqual(FbxTime.FromSecondDouble(0), timespan.GetStart()); Assert.AreEqual(FbxTime.FromSecondDouble(1), timespan.GetStop()); /* Get a property that isn't a Double3; add a channel for it. */ var boolNode = FbxAnimCurveNode.CreateTypedCurveNode(node.VisibilityInheritance, scene); Assert.IsFalse(boolNode.IsComposite()); Assert.IsFalse(boolNode.IsAnimated()); Assert.IsTrue(boolNode.AddChannel("vis", 1)); }
public void ConvertScene(FbxScene pScene) { NativeMethods.FbxAxisSystem_ConvertScene(swigCPtr, FbxScene.getCPtr(pScene)); if (NativeMethods.SWIGPendingException.Pending) { throw NativeMethods.SWIGPendingException.Retrieve(); } }
public virtual void ReadBegin(FbxScene pScene) { FbxWrapperNativePINVOKE.FbxPlugin_ReadBegin(swigCPtr, FbxScene.getCPtr(pScene)); if (FbxWrapperNativePINVOKE.SWIGPendingException.Pending) { throw FbxWrapperNativePINVOKE.SWIGPendingException.Retrieve(); } }
public bool Equals(FbxScene other) { if (object.ReferenceEquals(other, null)) { return(false); } return(this.swigCPtr.Handle.Equals(other.swigCPtr.Handle)); }