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;
}
