public void Load() { LogMessage("Instantiating the FBX Manager..."); FBXManager managerInstance = ArcManagedFBX.FBXManager.Create(); if (string.IsNullOrEmpty(Filename)) { throw new FileNotFoundException("The file that is being loaded in does not exist!"); } if (!File.Exists(Filename)) { throw new FileNotFoundException("The file that is being loaded was not found on disk."); } LogMessage("Instantiating the FBX Settings..."); FBXIOSettings settings = FBXIOSettings.Create(managerInstance, "IOSRoot"); managerInstance.SetIOSettings(settings); LogMessage("Loading plugins directory..."); managerInstance.LoadPluginsDirectory(Environment.CurrentDirectory, ""); int fileMajorNumber = 0, fileMinorNumber = 0, fileRevisionNumber = 0; LogMessage("Instantiating the Scene..."); FBXScene scene = FBXScene.Create(managerInstance, "My Scene"); FBXImporter importer = FBXImporter.Create(managerInstance, ""); // Instantiate the framework for the scene as required. m_SceneFramework = new SceneFramework(scene); LogMessage("Load the importer for the file '{0}'", Filename); bool initializeResult = importer.Initialize(Filename, -1, managerInstance.GetIOSettings()); FBXManager.GetFileFormatVersion(ref fileMajorNumber, ref fileMinorNumber, ref fileRevisionNumber); bool importResult = importer.Import(scene); m_SceneFramework.Operation(); if (importResult) { PerformTests(scene); } else { LogError("Import failed. Nothing to do!"); } }
/// <summary> /// Creates a Cirrus light node /// </summary> /// <param name="_FBXMesh"></param> /// <param name="_Parent"></param> /// <returns></returns> protected Scene.Nodes.Light CreateLight( FBXImporter.NodeLight _FBXLight, Scene.Nodes.Node _Parent ) { // Create the cirrus mesh and tie it to our temporary mesh Scene.Nodes.Light Light = m_Scene.CreateLight( _FBXLight.Name, _Parent, _FBXLight.LocalTransform ); // Add some properties Light.Visible = _FBXLight.Visible; Light.Type = (Scene.Nodes.Light.LIGHT_TYPE) _FBXLight.LightType; Light.CastShadow = _FBXLight.CastShadows; Light.Color = _FBXLight.Color; Light.Intensity = _FBXLight.Intensity; Light.EnableNearAttenuation = _FBXLight.EnableNearAttenuation; Light.NearAttenuationStart = _FBXLight.NearAttenuationStart * m_ScaleFactor; Light.NearAttenuationEnd = _FBXLight.NearAttenuationEnd * m_ScaleFactor; Light.EnableFarAttenuation = _FBXLight.EnableFarAttenuation; Light.FarAttenuationStart = _FBXLight.FarAttenuationStart * m_ScaleFactor; Light.FarAttenuationEnd = _FBXLight.FarAttenuationEnd * m_ScaleFactor; Light.HotSpot = _FBXLight.HotSpot; Light.ConeAngle = _FBXLight.ConeAngle; Light.DecayType = (Scene.Nodes.Light.DECAY_TYPE) _FBXLight.DecayType; Light.DecayStart = _FBXLight.DecayStart * m_ScaleFactor; return Light; }
/// <summary> /// Creates a Cirrus camera node /// </summary> /// <param name="_FBXMesh"></param> /// <param name="_Parent"></param> /// <returns></returns> protected Scene.Nodes.Camera CreateCamera( FBXImporter.NodeCamera _FBXCamera, Scene.Nodes.Node _Parent ) { // Create the cirrus mesh and tie it to our temporary mesh Scene.Nodes.Camera Camera = m_Scene.CreateCamera( _FBXCamera.Name, _Parent, _FBXCamera.LocalTransform ); // Add some properties Camera.Visible = _FBXCamera.Visible; Camera.Type = (Scene.Nodes.Camera.PROJECTION_TYPE) _FBXCamera.ProjectionType; Camera.Target = m_ScaleFactor * (Vector) _FBXCamera.Target; Camera.FOV = _FBXCamera.FOVY; Camera.AspectRatio = _FBXCamera.AspectRatio; Camera.ClipNear = _FBXCamera.NearClipPlane * m_ScaleFactor; Camera.ClipFar = _FBXCamera.FarClipPlane * m_ScaleFactor; Camera.Roll = _FBXCamera.Roll; return Camera; }
public static bool LoadScene(FBXManager pManager, FBXDocument pScene, string pFilename) { int sdkMajor = 0; int sdkMinor = 0; int sdkRevision = 0; // int lFileFormat = -1; string lPassword = new string(new char[1024]); // Get the file version number generate by the FBX SDK. FBXManager.GetFileFormatVersion(ref sdkMajor, ref sdkMinor, ref sdkRevision); // Create an importer. FBXImporter lImporter = FBXImporter.Create(pManager, string.Empty); // Initialize the importer by providing a filename. bool lImportStatus = lImporter.Initialize(pFilename, -1, pManager.GetIOSettings()); // lImporter.GetFileVersion(ref lFileMajor, ref lFileMinor, ref lFileRevision); if (!lImportStatus) { var error = lImporter.GetStatus().GetErrorString(); Debug.WriteLine("Call to FBXImporter::Initialize() failed"); Debug.WriteLine("Error returned: {0}", error); // if (lImporter.GetStatus().GetCode() == FBXStatus.eInvalidFileVersion) // { // Debug.WriteLine("FBX file format version for this FBX SDK is %d.%d.%d\n", lSDKMajor, lSDKMinor, lSDKRevision); // Debug.WriteLine("FBX file format version for file '%s' is %d.%d.%d\n\n", pFilename, lFileMajor, lFileMinor, lFileRevision); // } return(false); } Debug.WriteLine("FBX file format version for this FBX SDK is {0}.{1}.{2}", sdkMajor, sdkMinor, sdkRevision); if (lImporter.IsFBX()) { // Debug.WriteLine("FBX file format version for file '%s' is %d.%d.%d\n\n", pFilename, lFileMajor, lFileMinor, lFileRevision); // From this point, it is possible to access animation stack information without // the expense of loading the entire file. Debug.WriteLine("Animation Stack Information"); var lAnimStackCount = lImporter.GetAnimStackCount(); Debug.WriteLine(" Number of Animation Stacks: {0}", lAnimStackCount); Debug.WriteLine(" Current Animation Stack: {0}", lImporter.GetActiveAnimStackName()); int i; for (i = 0; i < lAnimStackCount; i++) { // FbxTakeInfo lTakeInfo = lImporter.GetTakeInfo(i); // Debug.WriteLine(" Animation Stack %d\n", i); // Debug.WriteLine(" Name: \"%s\"\n", lTakeInfo.mName.Buffer()); // Debug.WriteLine(" Description: \"%s\"\n", lTakeInfo.mDescription.Buffer()); //// Change the value of the import name if the animation stack should be imported //// under a different name. // Debug.WriteLine(" Import Name: \"%s\"\n", lTakeInfo.mImportName.Buffer()); //// Set the value of the import state to false if the animation stack should be not //// be imported. // Debug.WriteLine(" Import State: %s\n", lTakeInfo.mSelect ? "true" : "false"); // Debug.WriteLine("\n"); } //// Set the import states. By default, the import states are always set to //// true. The code below shows how to change these states. // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_MATERIAL, true); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_TEXTURE, true); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_LINK, true); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_SHAPE, true); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_GOBO, true); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_ANIMATION, true); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_GLOBAL_SETTINGS, true); } // Import the scene. var lStatus = lImporter.Import(pScene); // if (lStatus == false && lImporter.GetStatus().GetCode() == FbxStatus.ePasswordError) // { // Debug.WriteLine("Please enter password: "******"%s", lPassword); // FBXSDK_CRT_SECURE_NO_WARNING_END FbxString lString(lPassword); // (*(pManager.GetIOSettings())).SetStringProp(IMP_FBX_PASSWORD, lString); // (*(pManager.GetIOSettings())).SetBoolProp(IMP_FBX_PASSWORD_ENABLE, true); // lStatus = lImporter.Import(pScene); // if (lStatus == false && lImporter.GetStatus().GetCode() == FbxStatus.ePasswordError) // { // Debug.WriteLine("\nPassword is wrong, import aborted.\n"); // } // } return(lStatus); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(FBXImporter obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public Primitive( LoaderTempMesh _OwnerMesh, SceneLoader _Owner, string _Name, FBXImporter.Material _Material ) : base(_Owner, _Name) { m_OwnerMesh = _OwnerMesh; m_Material = _Material; // if ( m_Material == null ) // throw new Exception( "Invalid material for primitive \"" + _Name + "\"!" ); }
/// <summary> /// Processes a FBX node and converts it into a Cirrus object /// </summary> /// <param name="_FBXNode"></param> /// <param name="_ParentNode"></param> protected void RecurseProcessNode( FBXImporter.Node _FBXNode, Scene.Nodes.Node _ParentNode ) { Scene.Nodes.Node NewNode = _ParentNode; if ( _FBXNode is FBXImporter.NodeMesh ) NewNode = CreateMesh( _FBXNode as FBXImporter.NodeMesh, _ParentNode ); // Create a new mesh else if ( _FBXNode is FBXImporter.NodeCamera ) NewNode = CreateCamera( _FBXNode as FBXImporter.NodeCamera, _ParentNode ); else if ( _FBXNode is FBXImporter.NodeLight ) NewNode = CreateLight( _FBXNode as FBXImporter.NodeLight, _ParentNode ); else { // Create a default node that is just here to respect the hierarchy for PRS evaluation Matrix4x4 LocalTransform = _FBXNode.LocalTransform; if ( _ParentNode == null ) { if ( _FBXNode.ParentScene.UpAxis == FBXImporter.Scene.UP_AXIS.Y ) { // Nothing to change here... LocalTransform.SetRow0( new Vector( 1.0f, 0.0f, 0.0f ) ); LocalTransform.SetRow1( new Vector( 0.0f, 1.0f, 0.0f ) ); LocalTransform.SetRow2( new Vector( 0.0f, 0.0f, 1.0f ) ); } else { // Tweak the root node's transform to match DirectX representation LocalTransform.SetRow0( new Vector( 1.0f, 0.0f, 0.0f ) ); LocalTransform.SetRow1( new Vector( 0.0f, 0.0f, -1.0f ) ); LocalTransform.SetRow2( new Vector( 0.0f, 1.0f, 0.0f ) ); } } NewNode = m_Scene.CreateNode( _FBXNode.Name, _ParentNode, LocalTransform ); } // Recurse through children foreach ( FBXImporter.Node Child in _FBXNode.Children ) RecurseProcessNode( Child, NewNode ); }
protected bool CreateTextureParameter( FBXImporter.Material _Material, string _PropertyName, Scene.Materials.MaterialParameters _MaterialParameters, string _ParameterName, string _OpacityPropertyName ) { FBXImporter.ObjectProperty Property = _Material.FindProperty( _PropertyName ); if ( Property == null ) return false; // No such property... if ( Property.Textures.Length == 0 ) return false; // That property has no texture... // Check for opacity string OpacityTextureRelativeFileName = null; if ( _OpacityPropertyName != null ) { FBXImporter.ObjectProperty OpacityProperty = _Material.FindProperty( _OpacityPropertyName ); if ( OpacityProperty != null && OpacityProperty.Textures.Length != 0 ) OpacityTextureRelativeFileName = OpacityProperty.Textures[0].RelativeFileName; } // Create the parameter with that texture Scene.Materials.Texture2D Tex = m_Scene.CreateTexture( Property.Textures[0].RelativeFileName, OpacityTextureRelativeFileName, Property.Textures[0].UseMipMap ); _MaterialParameters.CreateParameter( _ParameterName, Scene.Materials.MaterialParameters.PARAMETER_TYPE.TEXTURE2D ).AsTexture2D.Value = Tex; return true; }
/// <summary> /// Sets the source FBX texture to get the parameters from /// </summary> /// <remarks>You can override individual parameters using the "SetSamplerParam()" function, /// if a parameter exists in the parameters table, it will be used instead /// of the one that would be generated from the texture /// </remarks> /// <param name="_Texture"></param> public void SetSourceFBXTexture( FBXImporter.Texture _Texture ) { m_SourceTexture = _Texture; // // Build default sampler params // SetSamplerParam( "o3d.addressModeU", Helpers.FormatParamObject( ConvertWrapMode( _Texture.WrapModeU ) ) ); // SetSamplerParam( "o3d.addressModeV", Helpers.FormatParamObject( ConvertWrapMode( _Texture.WrapModeV ) ) ); // SetSamplerParam( "o3d.borderColor", Helpers.FormatParamObject( new Vector4D( 0, 0, 0, 0 ) ) ); // SetSamplerParam( "o3d.magFilter", Helpers.FormatParamObject( (int) FILTER_TYPE.LINEAR ) ); // SetSamplerParam( "o3d.minFilter", Helpers.FormatParamObject( (int) FILTER_TYPE.LINEAR ) ); // SetSamplerParam( "o3d.mipFilter", Helpers.FormatParamObject( (int) FILTER_TYPE.LINEAR ) ); // SetSamplerParam( "o3d.maxAnisotropy", Helpers.FormatParamObject( 1 ) ); }
/// <summary> /// Sets the mesh's array of faces /// </summary> /// <param name="_Faces"></param> public void SetFaces( FBXImporter.NodeMesh.Triangle[] _Faces ) { m_Faces = _Faces; }
/// <summary> /// Replaces a layer element from this mesh by a reference to another element from another mesh /// </summary> /// <param name="_LayerElementSource">The source layer element to replace</param> /// <param name="_OwnerMesh">The mesh that owns the referenced layer element</param> /// <param name="_LayerElementReference">The layer element to reference in place of our own layer element</param> public void ReplaceLayerElementByAReference( FBXImporter.LayerElement _LayerElementSource, LoaderTempMesh _OwnerMesh, FBXImporter.LayerElement _LayerElementReference ) { m_LayerElements.Remove( _LayerElementSource ); ReferenceLayerElement RLE = new ReferenceLayerElement(); RLE.m_Owner = _OwnerMesh; RLE.m_LayerElement = _LayerElementReference; m_LayerElementsReference.Add( RLE ); }
/// <summary> /// Adds a layer element to the mesh, hence adding a new entry to the vertex buffer /// </summary> /// <param name="_LayerElement"></param> public void AddLayerElement( FBXImporter.LayerElement _LayerElement ) { if ( _LayerElement == null ) throw new Exception( "Invalid layer element!" ); // Compact identical UV sets if ( m_Owner.CompactUVs && _LayerElement.ElementType == FBXImporter.LayerElement.ELEMENT_TYPE.UV ) { m_UVSetsCount++; // DEBUG // if ( m_Name == "Body" ) // m_Pivot = null; // DEBUG // Compare the new layer element with any existing UV element if ( m_UVSetsCount > m_Owner.MinUVsCount ) foreach ( FBXImporter.LayerElement Element in m_LayerElements ) if ( Element.ElementType == FBXImporter.LayerElement.ELEMENT_TYPE.UV ) { object[] ExistingUV = Element.ToArray(); object[] NewUV = _LayerElement.ToArray(); // This array is cached, so the cost of evaluation is only one if ( ExistingUV.Length != NewUV.Length ) continue; // They already differ by length... // Compare each entry of the arrays bool bEqual = true; for ( int i=0; i < ExistingUV.Length; i++ ) { Vector2D UV0 = ExistingUV[i] as Vector2D; Vector2D UV1 = NewUV[i] as Vector2D; if ( UV0 != UV1 ) { // They differ! bEqual = false; break; } } if ( bEqual ) return; // Both UV sets are equal, so we don't add the new one... } } // Add this as a new entry... m_LayerElements.Add( _LayerElement ); }
/// <summary> /// Adds a layer element from another (slave) mesh /// </summary> /// <param name="_OwnerMesh">The mesh owning the layer element to add</param> /// <param name="_LayerElement">The external layer element</param> public void AddExternalLayerElement( LoaderTempMesh _OwnerMesh, FBXImporter.LayerElement _LayerElement ) { ExternalLayerElement ELE = new ExternalLayerElement(); ELE.m_Owner = _OwnerMesh; ELE.m_LayerElement = _LayerElement; m_LayerElementsExternal.Add( ELE ); // Add this mesh to our list of slave meshes if ( m_SlaveMesh2Registered.ContainsKey( _OwnerMesh ) ) return; // Already registered! m_SlaveMeshes.Add( _OwnerMesh ); m_SlaveMesh2Registered[_OwnerMesh] = true; }
protected VERTEX_INFO_TYPE m_Type = VERTEX_INFO_TYPE.UNKNOWN; // The vertex stream type #endregion Fields #region Constructors public VertexStream( FBXImporter.LayerElement _Source, VERTEX_INFO_TYPE _Type, int _Index, int _StreamLength ) { m_SourceLayerElement = _Source; m_Type = _Type; m_Index = _Index; m_Stream = new object[_StreamLength]; }
/// <summary> /// Creates a Cirrus mesh node /// </summary> /// <param name="_Scene"></param> /// <param name="_FBXMesh"></param> /// <returns></returns> protected Scene.Nodes.Mesh CreateMesh( FBXImporter.NodeMesh _FBXMesh, Scene.Nodes.Node _Parent ) { // Create a temporary mesh that will be optimized later, when all meshes have been loaded LoaderTempMesh TempMesh = new LoaderTempMesh( this, _FBXMesh.Name ); if ( m_bGenerateBoundingBoxes ) TempMesh.BoundingBox = new WMath.BoundingBox( m_ScaleFactor * _FBXMesh.BoundingBox.m_Min, m_ScaleFactor * _FBXMesh.BoundingBox.m_Max ); // Handle pivot & reset X-Form if ( m_bResetXForm ) TempMesh.Pivot = _FBXMesh.Pivot; // Storing the mesh's pivot will have the effect of composing vertices with that matrix, actually performing the "reset X-Form" operation // else // Transform.Pivot = _FBXNode.Pivot; // Storing the mesh's pivot here will simply compose the mesh's transform with its pivot // Setup compulsory vertices and triangles Point[] SourceVertices = _FBXMesh.Vertices; Point[] ScaledVertices = new Point[SourceVertices.Length]; for ( int VertexIndex=0; VertexIndex < _FBXMesh.VerticesCount; VertexIndex++ ) ScaledVertices[VertexIndex] = m_ScaleFactor * SourceVertices[VertexIndex]; TempMesh.SetVertices( ScaledVertices ); TempMesh.SetFaces( _FBXMesh.Triangles ); // Setup all the possible recognized layers foreach ( FBXImporter.Layer Layer in _FBXMesh.Layers ) foreach ( FBXImporter.LayerElement LE in Layer.Elements ) { switch ( LE.ElementType ) { case FBXImporter.LayerElement.ELEMENT_TYPE.MATERIAL: case FBXImporter.LayerElement.ELEMENT_TYPE.UV: case FBXImporter.LayerElement.ELEMENT_TYPE.NORMAL: case FBXImporter.LayerElement.ELEMENT_TYPE.TANGENT: case FBXImporter.LayerElement.ELEMENT_TYPE.BINORMAL: case FBXImporter.LayerElement.ELEMENT_TYPE.VERTEX_COLOR: case FBXImporter.LayerElement.ELEMENT_TYPE.SMOOTHING: TempMesh.AddLayerElement( LE ); break; default: break; // Other types are not supported (or irrelevant)... } } // Build un-optimized primitives TempMesh.BuildPrimitives(); // Create the final scene mesh and tie it to our temporary mesh FBX.Scene.Nodes.Mesh Mesh = m_Scene.CreateMesh( _FBXMesh.Name, _Parent, _FBXMesh.LocalTransform ); m_TempMesh2FinalMesh[TempMesh] = Mesh; // Add some properties Mesh.Visible = _FBXMesh.Visible; // FBXImporter.ObjectProperty PropertyCastShadow = _FBXMesh.FindUserProperty( "CastShadow" ); // Mesh.CastShadow = PropertyCastShadow != null ? (bool) PropertyCastShadow.Value : true; Mesh.CastShadow = true; Mesh.ReceiveShadow = true; return Mesh; }
/// <summary> /// Creates a texture parameter from a material property that contains a texture (e.g. DiffuseColor, SpecularColor, etc.) /// </summary> /// <param name="_Material"></param> /// <param name="_PropertyName"></param> /// <param name="_MaterialParameters"></param> /// <param name="_ParameterName"></param> /// <returns>True if a texture is available</returns> protected bool CreateTextureParameter( FBXImporter.Material _Material, string _PropertyName, Scene.Materials.MaterialParameters _MaterialParameters, string _ParameterName ) { return CreateTextureParameter( _Material, _PropertyName, _MaterialParameters, _ParameterName, null ); }
/// <summary> /// Converts an FBX wrap mode into an O3D wrap mode /// </summary> /// <param name="_WrapMode"></param> /// <returns></returns> protected int ConvertWrapMode( FBXImporter.Texture.WRAP_MODE _WrapMode ) { switch ( _WrapMode ) { case FBXImporter.Texture.WRAP_MODE.CLAMP: return (int) WRAP_MODE.CLAMP; case FBXImporter.Texture.WRAP_MODE.REPEAT: return (int) WRAP_MODE.WRAP; } return (int) WRAP_MODE.WRAP; }
/// <summary> /// Attempts to map FBX materials to render techniques /// </summary> /// <param name="_Materials">The list of materials to process</param> protected void ProcessMaterials( FBXImporter.Material[] _Materials ) { m_Material2Parameters.Clear(); foreach ( FBXImporter.Material Mat in _Materials ) { Scene.Materials.MaterialParameters MatParams = null; // DEBUG // if ( Mat.Name == "sp_00_svod" ) // MatParams = null; // DEBUG if ( m_MaterialsDatabase != null ) { // Handle the special case of scenes that were exported as OBJ format and whos material informations lie in the diffuse color "texture" FBXImporter.ObjectProperty DiffuseColorProperty = Mat.FindProperty( "DiffuseColor" ); if ( DiffuseColorProperty != null && DiffuseColorProperty.Textures.Length > 0 ) { string PseudoTextureName = DiffuseColorProperty.Textures[0].AbsoluteFileName; // Actually a material name! MaterialsDatabase.Material MatOverride = m_MaterialsDatabase.FindByName( PseudoTextureName ); if ( MatOverride != null ) { // Replace this material's textures by the actual material's textures (does it make sense? ^^) if ( MatOverride.TextureDiffuse != null ) { FBXImporter.ObjectProperty TextureProperty = Mat.FindProperty( "DiffuseColor" ); if ( TextureProperty != null ) { TextureProperty.Textures = new FBXImporter.Texture[] { new FBXImporter.Texture( Mat.ParentScene , MatOverride.TextureDiffuse, MatOverride.TextureDiffuse, MatOverride.TextureDiffuse ) }; } } if ( MatOverride.TextureNormal != null ) { FBXImporter.ObjectProperty TextureProperty = Mat.FindProperty( "NormalMap" ); if ( TextureProperty != null ) { TextureProperty.Textures = new FBXImporter.Texture[] { new FBXImporter.Texture( Mat.ParentScene , MatOverride.TextureNormal, MatOverride.TextureNormal, MatOverride.TextureNormal ) }; } } if ( MatOverride.TextureSpecular != null ) { FBXImporter.ObjectProperty TextureProperty = Mat.FindProperty( "SpecularColor" ); if ( TextureProperty != null ) { TextureProperty.Textures = new FBXImporter.Texture[] { new FBXImporter.Texture( Mat.ParentScene , MatOverride.TextureSpecular, MatOverride.TextureSpecular, MatOverride.TextureSpecular ) }; } } } } } // Specialize the material if ( Mat is FBXImporter.MaterialHardwareShader ) { FBXImporter.MaterialHardwareShader HardwareMaterial = Mat as FBXImporter.MaterialHardwareShader; MatParams = m_Scene.CreateMaterialParameters( Mat.Name, HardwareMaterial.RelativeURL ); foreach ( FBXImporter.MaterialHardwareShader.TableEntry Entry in HardwareMaterial.ShaderEntries ) { switch ( Entry.TypeName ) { case "Boolean": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.BOOL ).AsBool.Value = (bool) Entry.Value; break; case "Integer": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.INT ).AsInt.Value = (int) Entry.Value; break; case "Float": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = (float) Entry.Value; break; case "Float2": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT2 ).AsFloat2.Value = Entry.Value as Vector2D; break; case "Float3": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = Entry.Value as Vector; break; case "Float4": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT4 ).AsFloat4.Value = Entry.Value as Vector4D; break; case "Matrix": MatParams.CreateParameter( Entry.Name, Scene.Materials.MaterialParameters.PARAMETER_TYPE.MATRIX4 ).AsMatrix4.Value = Entry.Value as Matrix4x4; break; case "Texture": CreateTextureParameter( Mat, Entry.Name, MatParams, Entry.Name ); break; } } m_Material2Parameters[Mat] = MatParams; continue; } FBXImporter.Material SpecificMaterial= null; if ( Mat is FBXImporter.MaterialPhong ) { SpecificMaterial = Mat as FBXImporter.MaterialPhong; MatParams = m_Scene.CreateMaterialParameters( Mat.Name, "Phong" ); } else if ( Mat is FBXImporter.MaterialLambert ) { SpecificMaterial = Mat as FBXImporter.MaterialLambert; MatParams = m_Scene.CreateMaterialParameters( Mat.Name, "Lambert" ); } else continue; // Unrecognized hence unsupported material type... // // Lambert parameters // MatParams.CreateParameter( "AmbientColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.AmbientColor; // CreateTextureParameter( Mat, "AmbientColor", MatParams, "AmbientTexture" ); // MatParams.CreateParameter( "AmbientFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.AmbientFactor; // // MatParams.CreateParameter( "DiffuseColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.DiffuseColor; // MatParams.CreateParameter( "DiffuseFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.DiffuseFactor; // bool bHasDiffuseTexture = CreateTextureParameter( Mat, "DiffuseColor", MatParams, "DiffuseTexture", "TransparentColor" ); // MatParams.CreateParameter( "HasDiffuseTexture", Scene.Materials.MaterialParameters.PARAMETER_TYPE.BOOL ).AsBool.Value = bHasDiffuseTexture; // // MatParams.CreateParameter( "EmissiveColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.EmissiveColor; // MatParams.CreateParameter( "EmissiveFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.EmissiveFactor; // CreateTextureParameter( Mat, "EmissiveColor", MatParams, "EmissiveTexture" ); // // FBXImporter.ObjectProperty OpacityProp = SpecificMaterial.FindProperty( "Opacity" ); // float fOpacity = OpacityProp != null ? (float) OpacityProp.Value : 1.0f; // MatParams.CreateParameter( "Opacity", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = fOpacity; // // MatParams.IsOpaque = fOpacity >= 1.0f; // // bool bHasNormalTexture = CreateTextureParameter( Mat, "Bump", MatParams, "NormalTexture" ); // MatParams.CreateParameter( "HasNormalTexture", Scene.Materials.MaterialParameters.PARAMETER_TYPE.BOOL ).AsBool.Value = bHasNormalTexture; // Lambert parameters MatParams.CreateParameter( "AmbientColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.FindProperty( "AmbientColor" ).AsVector3; CreateTextureParameter( Mat, "AmbientColor", MatParams, "AmbientTexture" ); MatParams.CreateParameter( "AmbientFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.FindProperty( "AmbientFactor" ).AsFloat; MatParams.CreateParameter( "DiffuseColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.FindProperty( "DiffuseColor" ).AsVector3; MatParams.CreateParameter( "DiffuseFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.FindProperty( "DiffuseFactor" ).AsFloat; bool bHasDiffuseTexture = CreateTextureParameter( Mat, "DiffuseColor", MatParams, "DiffuseTexture", "TransparentColor" ); MatParams.CreateParameter( "HasDiffuseTexture", Scene.Materials.MaterialParameters.PARAMETER_TYPE.BOOL ).AsBool.Value = bHasDiffuseTexture; MatParams.CreateParameter( "EmissiveColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.FindProperty( "EmissiveColor" ).AsVector3; MatParams.CreateParameter( "EmissiveFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.FindProperty( "EmissiveFactor" ).AsFloat; bool bHasEmissiveTexture = CreateTextureParameter( Mat, "EmissiveColor", MatParams, "EmissiveTexture" ); float fOpacity = SpecificMaterial.FindProperty( "Opacity" ).AsFloat; MatParams.CreateParameter( "Opacity", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = fOpacity; // MatParams.IsOpaque = fOpacity >= 1.0f; bool bHasNormalTexture = false; if ( Mat.FindProperty( "Bump" ).Textures.Length > 0 ) bHasNormalTexture = CreateTextureParameter( Mat, "Bump", MatParams, "NormalTexture" ); else if ( Mat.FindProperty( "NormalMap" ).Textures.Length > 0 ) bHasNormalTexture = CreateTextureParameter( Mat, "NormalMap", MatParams, "NormalTexture" ); MatParams.CreateParameter( "HasNormalTexture", Scene.Materials.MaterialParameters.PARAMETER_TYPE.BOOL ).AsBool.Value = bHasNormalTexture; // Phong parameters try { MatParams.CreateParameter( "ReflectionColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.FindProperty( "ReflectionColor" ).AsVector3; CreateTextureParameter( Mat, "ReflectionColor", MatParams, "ReflectionTexture" ); MatParams.CreateParameter( "ReflectionFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.FindProperty( "ReflectionFactor" ).AsFloat; MatParams.CreateParameter( "Shininess", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.FindProperty( "Shininess" ).AsFloat; MatParams.CreateParameter( "SpecularColor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT3 ).AsFloat3.Value = SpecificMaterial.FindProperty( "SpecularColor" ).AsVector3; MatParams.CreateParameter( "SpecularFactor", Scene.Materials.MaterialParameters.PARAMETER_TYPE.FLOAT ).AsFloat.Value = SpecificMaterial.FindProperty( "SpecularFactor" ).AsFloat; bool bHasSpecularTexture = CreateTextureParameter( Mat, "SpecularColor", MatParams, "SpecularTexture" ); MatParams.CreateParameter( "HasSpecularTexture", Scene.Materials.MaterialParameters.PARAMETER_TYPE.BOOL ).AsBool.Value = bHasSpecularTexture; } catch ( Exception ) { } // Register the material m_Material2Parameters[Mat] = MatParams; } }
public void SetAnimationTrackRotations( FBXImporter.AnimationTrack[] _Tracks ) { m_AnimR = _Tracks; m_bAnimated = true; }
private void ImportFBX(string path) { FBXManager man = FBXManager.Create(); FBXIOSettings io = FBXIOSettings.Create(man, "IOSRoot"); man.SetIOSettings(io); FBXImporter fbx = FBXImporter.Create(man, ""); fbx.Initialize(path, -1, man.GetIOSettings()); FBXScene scene = FBXScene.Create(man, "importScene"); fbx.Import(scene); fbx.Destroy(); var root = scene.GetRootNode(); for (int i = 0; i < root.GetChildCount(); i++) { var child = root.GetChild(i); if (child.GetName() == "Root") { ParseNode(child, true); break; } } List <VMeshDataFile> lst_vmesh_data = new List <VMeshDataFile>(); VMeshDataFile cur_meshdata_file = null; for (int i = 0; i < cmpndData.Count; i++) { var cmpnd = cmpndData[i]; for (uint lod = 0; lod < cmpnd.object_data.lods; lod++) { if (cur_meshdata_file == null || cmpnd.object_data.data[lod].vmeshref.NumIndex + cur_meshdata_file.ref_vertices > 0xFFFF) { cur_meshdata_file = new VMeshDataFile(); cur_meshdata_file.filename = UniqueName + lst_vmesh_data.Count + ".vms"; cur_meshdata_file.ref_vertices = 0; cur_meshdata_file.vertices = 0; cur_meshdata_file.meshes = 0; lst_vmesh_data.Add(cur_meshdata_file); } cur_meshdata_file.ref_vertices += cmpnd.object_data.data[lod].vmeshref.NumIndex; cur_meshdata_file.vertices += cmpnd.object_data.data[lod].vmeshref.NumVert; cur_meshdata_file.meshes += cmpnd.object_data.data[lod].vmeshref.NumMeshes; cmpnd.object_data.data[lod].vmeshref.VMeshLibId = Utilities.FLModelCRC(cur_meshdata_file.filename); cmpnd.object_data.data[lod].vmeshdata = cur_meshdata_file; } cmpnd.object_data.file_name = UniqueName + "." + cmpnd.object_name + ".3db"; cmpndData.RemoveAt(i); cmpndData.Insert(i, cmpnd); } foreach (var vmesh in lst_vmesh_data) { /*VMeshData vmeshdata = new VMeshData(); * * switch (VertexType) * { * case ModelImportVertexType.Normals: * vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX1); * break; * case ModelImportVertexType.VertexColors: * vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_DIFFUSE | VMeshData.D3DFVF_TEX1); * break; * case ModelImportVertexType.VertexColorsNormals: * vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_DIFFUSE | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_DIFFUSE); * break; * case ModelImportVertexType.ExtraUVs: * vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX2); * break; * case ModelImportVertexType.TangentsBinormals: * vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX4); * break; * case ModelImportVertexType.ExtraUVsTangentsBinormals: * vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX5); * break; * }*/ const uint HEADER_SIZE = 2 * 4 + 4 * 2; const uint MESH_HEADER_SIZE = 4 + 3 * 2 + 2; const uint INDEX_SIZE = 2; uint VERTEX_SIZE = 0; switch (VertexType) { case ModelImportVertexType.Normals: VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4; break; case ModelImportVertexType.VertexColors: VERTEX_SIZE = 3 * 4 + 1 * 4 + 2 * 4; break; case ModelImportVertexType.VertexColorsNormals: VERTEX_SIZE = 3 * 4 + 3 * 4 + 1 * 4 + 2 * 4; break; case ModelImportVertexType.ExtraUVs: VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4 + 2 * 4; break; case ModelImportVertexType.TangentsBinormals: VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4 + 3 * 4 + 3 * 4; break; case ModelImportVertexType.ExtraUVsTangentsBinormals: VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4 + 2 * 4 + 3 * 4 + 3 * 4; break; } int meshCount = 0; int indicesCount = 0; int verticesCount = 0; foreach (var cmpnd in cmpndData) { for (int lod = 0; lod < cmpnd.object_data.lods; lod++) { if (cmpnd.object_data.data[lod].vmeshdata == vmesh) { meshCount += cmpnd.object_data.data[lod].meshes.Count; foreach (var m in cmpnd.object_data.data[lod].meshes) { indicesCount += m.t.Length * 3; verticesCount += m.v.Length; } } } } byte[] data = new byte[HEADER_SIZE + MESH_HEADER_SIZE * meshCount + INDEX_SIZE * indicesCount + VERTEX_SIZE * verticesCount]; int pos = 0; // write header Utilities.WriteInt(data, 1, ref pos); Utilities.WriteInt(data, 4, ref pos); Utilities.WriteWord(data, (ushort)vmesh.meshes, ref pos); Utilities.WriteWord(data, (ushort)vmesh.ref_vertices, ref pos); ushort fvf = 0; switch (VertexType) { case ModelImportVertexType.Normals: fvf = 0x112; break; case ModelImportVertexType.VertexColors: fvf = 0x142; break; case ModelImportVertexType.VertexColorsNormals: fvf = 0x152; break; case ModelImportVertexType.ExtraUVs: fvf = 0x212; break; case ModelImportVertexType.TangentsBinormals: fvf = 0x412; break; case ModelImportVertexType.ExtraUVsTangentsBinormals: fvf = 0x512; break; } Utilities.WriteWord(data, fvf, ref pos); Utilities.WriteWord(data, (ushort)vmesh.vertices, ref pos); uint iMesh = 0; uint iGlobalStartVertex = 0; uint iGlobalStartIndex = 0; // save mesh header data foreach (var cmpnd in cmpndData) { for (int lod = 0; lod < cmpnd.object_data.lods; lod++) { if (cmpnd.object_data.data[lod].vmeshdata == vmesh) { cmpnd.object_data.data[lod].vmeshref.StartMesh = (ushort)iMesh; cmpnd.object_data.data[lod].vmeshref.StartVert = (ushort)iGlobalStartVertex; cmpnd.object_data.data[lod].vmeshref.StartIndex = (ushort)iGlobalStartIndex; uint iStartVert = 0; foreach (var m in cmpnd.object_data.data[lod].meshes) { Utilities.WriteDWord(data, Utilities.FLModelCRC(m.material_name), ref pos); Utilities.WriteWord(data, (ushort)iStartVert, ref pos); Utilities.WriteWord(data, (ushort)(iStartVert + m.nVerts - 1), ref pos); Utilities.WriteWord(data, (ushort)(m.nTris * 3), ref pos); Utilities.WriteWord(data, 0xCC, ref pos); iStartVert += (uint)m.nVerts; iGlobalStartIndex += (uint)m.nTris * 3; iGlobalStartVertex += (uint)m.nVerts; iMesh++; } } } } // save indices foreach (var cmpnd in cmpndData) { for (int lod = 0; lod < cmpnd.object_data.lods; lod++) { if (cmpnd.object_data.data[lod].vmeshdata == vmesh) { foreach (var m in cmpnd.object_data.data[lod].meshes) { foreach (var t in m.t) { Utilities.WriteWord(data, t.vertices[0], ref pos); Utilities.WriteWord(data, t.vertices[1], ref pos); Utilities.WriteWord(data, t.vertices[2], ref pos); } } } } } // save vertices foreach (var cmpnd in cmpndData) { for (int lod = 0; lod < cmpnd.object_data.lods; lod++) { if (cmpnd.object_data.data[lod].vmeshdata == vmesh) { foreach (var m in cmpnd.object_data.data[lod].meshes) { foreach (var v in m.v) { Utilities.WriteFloat(data, v.vert.X, ref pos); Utilities.WriteFloat(data, v.vert.Y, ref pos); Utilities.WriteFloat(data, v.vert.Z, ref pos); if (VertexType != ModelImportVertexType.VertexColors) { Utilities.WriteFloat(data, v.normal.X, ref pos); Utilities.WriteFloat(data, v.normal.Y, ref pos); Utilities.WriteFloat(data, v.normal.Z, ref pos); } if (VertexType == ModelImportVertexType.VertexColors || VertexType == ModelImportVertexType.VertexColorsNormals) { Utilities.WriteDWord(data, v.diffuse, ref pos); } Utilities.WriteFloat(data, v.uv.X, ref pos); Utilities.WriteFloat(data, v.uv.Y, ref pos); if (VertexType == ModelImportVertexType.ExtraUVs || VertexType == ModelImportVertexType.ExtraUVsTangentsBinormals) { Utilities.WriteFloat(data, v.uv2.X, ref pos); Utilities.WriteFloat(data, v.uv2.Y, ref pos); } if (VertexType == ModelImportVertexType.ExtraUVsTangentsBinormals || VertexType == ModelImportVertexType.TangentsBinormals) { Utilities.WriteFloat(data, v.tangent.X, ref pos); Utilities.WriteFloat(data, v.tangent.Y, ref pos); Utilities.WriteFloat(data, v.tangent.Z, ref pos); Utilities.WriteFloat(data, v.binormal.X, ref pos); Utilities.WriteFloat(data, v.binormal.Y, ref pos); Utilities.WriteFloat(data, v.binormal.Z, ref pos); } } } } } } TreeNode vmeshnode = CreateNode(vmesh.filename); vmeshlib.Nodes.Add(vmeshnode); TreeNode vmeshdatanode = CreateNode("VMeshData", data); vmeshnode.Nodes.Add(vmeshdatanode); } uint iTotalVWireIndices = 0; if (Wireframe) { } TreeNode consnode = CreateNode("Cons"); cmpnd.Nodes.Add(consnode); if (rev.Parts.Count > 0) { TreeNode revnode = CreateNode("Rev", rev.GetBytes()); consnode.Nodes.Add(revnode); } if (pris.Parts.Count > 0) { TreeNode prisnode = CreateNode("Pris", pris.GetBytes()); consnode.Nodes.Add(prisnode); } if (fix.Parts.Count > 0) { TreeNode fixnode = CreateNode("Fix", fix.GetBytes()); consnode.Nodes.Add(fixnode); } foreach (var cmpnd in cmpndData) { // Cmpnd child node { TreeNode cmpndnode = CreateNode(cmpnd.name); this.cmpnd.Nodes.Add(cmpndnode); TreeNode file_name = CreateNode("File name", Encoding.ASCII.GetBytes(cmpnd.object_data.file_name + "\u0000")); TreeNode index = CreateNode("Index", BitConverter.GetBytes(cmpnd.index)); TreeNode object_name = CreateNode("Object name", Encoding.ASCII.GetBytes(cmpnd.object_name + "\u0000")); cmpndnode.Nodes.Add(file_name); cmpndnode.Nodes.Add(index); cmpndnode.Nodes.Add(object_name); } // Root child node { TreeNode threedbnode = CreateNode(cmpnd.object_data.file_name); rootCMP.Nodes.Add(threedbnode); if (Wireframe) { } TreeNode multilevel = CreateNode("MultiLevel"); threedbnode.Nodes.Add(multilevel); if (cmpnd.object_data.lods > 1) { byte[] data = new byte[4 * cmpnd.object_data.lods]; int pos = 0; Utilities.WriteFloat(data, 0.0f, ref pos); for (int lod = 1; lod < cmpnd.object_data.lods; lod++) { Utilities.WriteFloat(data, (float)Math.Pow(10.0f, (float)(lod + 1)), ref pos); } Utilities.WriteFloat(data, 1000000.0f, ref pos); TreeNode switch2 = CreateNode("Switch2", data); multilevel.Nodes.Add(switch2); } for (int lod = 0; lod < cmpnd.object_data.lods; lod++) { TreeNode levelnode = CreateNode("Level" + lod); multilevel.Nodes.Add(levelnode); TreeNode vmeshpart = CreateNode("VMeshPart"); levelnode.Nodes.Add(vmeshpart); TreeNode vmeshref = CreateNode("VMeshRef", cmpnd.object_data.data[lod].vmeshref.GetBytes()); vmeshpart.Nodes.Add(vmeshref); } } } }
public void SetAnimationTrackScales( FBXImporter.AnimationTrack[] _Tracks ) { m_AnimS = _Tracks; m_bAnimated = true; }