public GFSubMesh(H3DSubMesh SubMesh, H3DMesh Parent, List <PICAVertex> Vertices, string Name) : this()
{
this.Name = Name;
BoneIndicesCount = (byte)SubMesh.BoneIndicesCount;
BoneIndices = new byte[SubMesh.BoneIndicesCount];
for (int i = 0; i < SubMesh.BoneIndicesCount; i++)
{
BoneIndices[i] = (byte)SubMesh.BoneIndices[i];
}
Indices = SubMesh.Indices;
PrimitiveMode = SubMesh.PrimitiveMode;
VertexStride = Parent.VertexStride;
Attributes = Parent.Attributes;
foreach (PICAFixedAttribute Old in Parent.FixedAttributes)
{
PICAFixedAttribute New = new PICAFixedAttribute()
{
Name = Old.Name,
Value = Old.Value
};
FixedAttributes.Add(New);
}
List <PICAVertex> NewVertices = new List <PICAVertex>();
Dictionary <ushort, ushort> OldNewIndexMap = new Dictionary <ushort, ushort>();
ushort[] NewIndices = new ushort[Indices.Length];
for (int i = 0; i < NewIndices.Length; i++)
{
if (OldNewIndexMap.ContainsKey(Indices[i]))
{
NewIndices[i] = OldNewIndexMap[Indices[i]];
}
else
{
PICAVertex Vertex = Vertices[Indices[i]];
ushort NewIndex = (ushort)NewVertices.Count;
NewVertices.Add(Vertex);
NewIndices[i] = NewIndex;
OldNewIndexMap.Add(Indices[i], NewIndex);
}
}
Indices = NewIndices;
IsIdx8Bits = /*NewIndices.Length <= 0x100*/ false;
RawBuffer = VerticesConverter.GetBuffer(NewVertices, Attributes);
}
public GFSubMesh(H3DSubMesh SubMesh, H3DMesh Parent, List <PICAVertex> Vertices, string Name)
{
this.Name = Name;
BoneIndicesCount = (byte)SubMesh.BoneIndicesCount;
BoneIndices = new byte[SubMesh.BoneIndicesCount];
for (int i = 0; i < SubMesh.BoneIndicesCount; i++)
{
BoneIndices[i] = (byte)SubMesh.BoneIndices[i];
}
Indices = SubMesh.Indices;
IsIdx8Bits = true;
foreach (ushort Index in Indices)
{
if (Index > 0xFF)
{
IsIdx8Bits = false;
break;
}
}
PrimitiveMode = SubMesh.PrimitiveMode;
VertexStride = Parent.VertexStride;
Attributes = Parent.Attributes;
FixedAttributes = Parent.FixedAttributes;
List <PICAVertex> NewVertices = new List <PICAVertex>();
ushort[] NewIndices = new ushort[Indices.Length];
for (int i = 0; i < NewIndices.Length; i++)
{
PICAVertex Vertex = Vertices[Indices[i]];
int NewIndex = NewVertices.IndexOf(Vertex);
if (NewIndex == -1)
{
NewIndex = NewVertices.Count;
NewVertices.Add(Vertex);
}
NewIndices[i] = (ushort)NewIndex;
}
Indices = NewIndices;
RawBuffer = VerticesConverter.GetBuffer(NewVertices, Attributes);
}
public H3D ToH3D()
{
H3D Output = new H3D();
H3DModel Model = new H3DModel();
Model.MeshNodesTree = new H3DPatriciaTree();
Model.Flags = BoneIndicesGroups.Length > 0 ? H3DModelFlags.HasSkeleton : 0;
Model.Name = "Model";
foreach (MTMaterial Mat in Materials)
{
H3DMaterial Mtl = H3DMaterial.GetSimpleMaterial(
Model.Name,
Mat.Name,
Path.GetFileNameWithoutExtension(Mat.Texture0Name));
Mtl.MaterialParams.ColorOperation.BlendMode = Mat.AlphaBlend.BlendMode;
Mtl.MaterialParams.BlendFunction = Mat.AlphaBlend.BlendFunction;
Mtl.MaterialParams.DepthColorMask.RedWrite = Mat.AlphaBlend.RedWrite;
Mtl.MaterialParams.DepthColorMask.GreenWrite = Mat.AlphaBlend.GreenWrite;
Mtl.MaterialParams.DepthColorMask.BlueWrite = Mat.AlphaBlend.BlueWrite;
Mtl.MaterialParams.DepthColorMask.AlphaWrite = Mat.AlphaBlend.AlphaWrite;
Mtl.MaterialParams.DepthColorMask.Enabled = Mat.DepthStencil.DepthTest;
Mtl.MaterialParams.DepthColorMask.DepthWrite = Mat.DepthStencil.DepthWrite;
Mtl.MaterialParams.DepthColorMask.DepthFunc = Mat.DepthStencil.DepthFunc;
Model.Materials.Add(Mtl);
}
ushort Index = 0;
foreach (MTMesh Mesh in Meshes)
{
if (Mesh.RenderType != -1)
{
continue;
}
H3DMesh M = new H3DMesh(
Mesh.RawBuffer,
Mesh.VertexStride,
Mesh.Attributes,
null,
null)
{
MaterialIndex = (ushort)Mesh.MaterialIndex,
NodeIndex = Index,
Priority = Mesh.RenderPriority
};
byte[] BoneIndices = BoneIndicesGroups[Mesh.BoneIndicesIndex];
if ((Model.Flags & H3DModelFlags.HasSkeleton) != 0 && BoneIndices.Length > 0)
{
M.Skinning = H3DMeshSkinning.Smooth;
PICAVertex[] Vertices = M.GetVertices();
for (int v = 0; v < Vertices.Length; v++)
{
Vector4 Position = Vector4.Zero;
float WeightSum = 0;
for (int i = 0; i < 4; i++)
{
if (Vertices[v].Weights[i] == 0)
{
break;
}
WeightSum += Vertices[v].Weights[i];
int bi = BoneIndicesGroups[Mesh.BoneIndicesIndex][Vertices[v].Indices[i]];
Vector4 Trans = Vector4.Zero;
for (int b = bi; b != -1; b = Skeleton[b].ParentIndex)
{
Trans += new Vector4(
Skeleton[b].LocalTransform.M41,
Skeleton[b].LocalTransform.M42,
Skeleton[b].LocalTransform.M43, 0);
}
Matrix4x4 WT = Skeleton[bi].WorldTransform;
Vector3 P = new Vector3(
Vertices[v].Position.X,
Vertices[v].Position.Y,
Vertices[v].Position.Z);
Vector4 TP = Vector4.Transform(P, WT);
Position += (TP + Trans) * Vertices[v].Weights[i];
}
if (WeightSum < 1)
{
Position += Vertices[v].Position * (1 - WeightSum);
}
Vertices[v].Position = Position;
}
/*
* Removes unused bone from bone indices list, also splits sub meshes on exceeding bones if
* current Mesh uses more than 20 (BCH only supports up to 20).
*/
Queue <ushort> IndicesQueue = new Queue <ushort>(Mesh.Indices);
while (IndicesQueue.Count > 0)
{
int Count = IndicesQueue.Count / 3;
List <ushort> Indices = new List <ushort>();
List <int> Bones = new List <int>();
while (Count-- > 0)
{
ushort i0 = IndicesQueue.Dequeue();
ushort i1 = IndicesQueue.Dequeue();
ushort i2 = IndicesQueue.Dequeue();
List <int> TempBones = new List <int>(12);
for (int j = 0; j < 4; j++)
{
int b0 = Vertices[i0].Indices[j];
int b1 = Vertices[i1].Indices[j];
int b2 = Vertices[i2].Indices[j];
if (!(Bones.Contains(b0) || TempBones.Contains(b0)))
{
TempBones.Add(b0);
}
if (!(Bones.Contains(b1) || TempBones.Contains(b1)))
{
TempBones.Add(b1);
}
if (!(Bones.Contains(b2) || TempBones.Contains(b2)))
{
TempBones.Add(b2);
}
}
if (Bones.Count + TempBones.Count > 20)
{
IndicesQueue.Enqueue(i0);
IndicesQueue.Enqueue(i1);
IndicesQueue.Enqueue(i2);
}
else
{
Indices.Add(i0);
Indices.Add(i1);
Indices.Add(i2);
Bones.AddRange(TempBones);
}
}
H3DSubMesh SM = new H3DSubMesh();
SM.Skinning = H3DSubMeshSkinning.Smooth;
SM.Indices = Indices.ToArray();
SM.BoneIndicesCount = (ushort)Bones.Count;
for (int i = 0; i < Bones.Count; i++)
{
SM.BoneIndices[i] = BoneIndices[Bones[i]];
}
bool[] Visited = new bool[Vertices.Length];
foreach (ushort i in Indices)
{
if (!Visited[i])
{
Visited[i] = true;
Vertices[i].Indices[0] = Bones.IndexOf(Vertices[i].Indices[0]);
Vertices[i].Indices[1] = Bones.IndexOf(Vertices[i].Indices[1]);
Vertices[i].Indices[2] = Bones.IndexOf(Vertices[i].Indices[2]);
Vertices[i].Indices[3] = Bones.IndexOf(Vertices[i].Indices[3]);
}
}
M.SubMeshes.Add(SM);
}
M.RawBuffer = VerticesConverter.GetBuffer(Vertices, M.Attributes);
}
else
{
M.SubMeshes.Add(new H3DSubMesh()
{
Indices = Mesh.Indices
});
}
Model.AddMesh(M);
Model.MeshNodesTree.Add($"Mesh_{Index++}");
Model.MeshNodesVisibility.Add(true);
}
int BoneIndex = 0;
foreach (MTBone Bone in Skeleton)
{
Model.Skeleton.Add(new H3DBone()
{
Name = $"Bone_{BoneIndex++}",
ParentIndex = Bone.ParentIndex,
Translation = Bone.Position,
Scale = Vector3.One
});
}
foreach (H3DBone Bone in Model.Skeleton)
{
Bone.CalculateTransform(Model.Skeleton);
}
if (Model.Materials.Count == 0)
{
Model.Materials.Add(H3DMaterial.GetSimpleMaterial(Model.Name, "DummyMaterial", null));
}
Output.Models.Add(Model);
Output.CopyMaterials();
return(Output);
}
public H3D ToH3D()
{
H3D Output = new H3D();
foreach (GfxModel Model in Models)
{
H3DModel Mdl = new H3DModel();
Mdl.Name = Model.Name;
Mdl.WorldTransform = Model.WorldTransform;
foreach (GfxMaterial Material in Model.Materials)
{
H3DMaterial Mat = new H3DMaterial()
{
Name = Material.Name
};
Mat.MaterialParams.ModelReference = $"{Mat.Name}@{Model.Name}";
Mat.MaterialParams.ShaderReference = "0@DefaultShader";
Mat.MaterialParams.Flags = (H3DMaterialFlags)Material.Flags;
Mat.MaterialParams.TranslucencyKind = (H3DTranslucencyKind)Material.TranslucencyKind;
Mat.MaterialParams.TexCoordConfig = (H3DTexCoordConfig)Material.TexCoordConfig;
Mat.MaterialParams.EmissionColor = Material.Colors.Emission;
Mat.MaterialParams.AmbientColor = Material.Colors.Ambient;
Mat.MaterialParams.DiffuseColor = Material.Colors.Diffuse;
Mat.MaterialParams.Specular0Color = Material.Colors.Specular0;
Mat.MaterialParams.Specular1Color = Material.Colors.Specular1;
Mat.MaterialParams.Constant0Color = Material.Colors.Constant0;
Mat.MaterialParams.Constant1Color = Material.Colors.Constant1;
Mat.MaterialParams.Constant2Color = Material.Colors.Constant2;
Mat.MaterialParams.Constant3Color = Material.Colors.Constant3;
Mat.MaterialParams.Constant4Color = Material.Colors.Constant4;
Mat.MaterialParams.Constant5Color = Material.Colors.Constant5;
Mat.MaterialParams.ColorScale = Material.Colors.Scale;
if (Material.Rasterization.IsPolygonOffsetEnabled)
{
Mat.MaterialParams.Flags |= H3DMaterialFlags.IsPolygonOffsetEnabled;
}
Mat.MaterialParams.FaceCulling = Material.Rasterization.FaceCulling.ToPICAFaceCulling();
Mat.MaterialParams.PolygonOffsetUnit = Material.Rasterization.PolygonOffsetUnit;
Mat.MaterialParams.DepthColorMask = Material.FragmentOperation.Depth.ColorMask;
Mat.MaterialParams.DepthColorMask.RedWrite = true;
Mat.MaterialParams.DepthColorMask.GreenWrite = true;
Mat.MaterialParams.DepthColorMask.BlueWrite = true;
Mat.MaterialParams.DepthColorMask.AlphaWrite = true;
Mat.MaterialParams.DepthColorMask.DepthWrite = true;
Mat.MaterialParams.ColorBufferRead = false;
Mat.MaterialParams.ColorBufferWrite = true;
Mat.MaterialParams.StencilBufferRead = false;
Mat.MaterialParams.StencilBufferWrite = false;
Mat.MaterialParams.DepthBufferRead = true;
Mat.MaterialParams.DepthBufferWrite = true;
Mat.MaterialParams.ColorOperation = Material.FragmentOperation.Blend.ColorOperation;
Mat.MaterialParams.LogicalOperation = Material.FragmentOperation.Blend.LogicalOperation;
Mat.MaterialParams.BlendFunction = Material.FragmentOperation.Blend.Function;
Mat.MaterialParams.BlendColor = Material.FragmentOperation.Blend.Color;
Mat.MaterialParams.StencilOperation = Material.FragmentOperation.Stencil.Operation;
Mat.MaterialParams.StencilTest = Material.FragmentOperation.Stencil.Test;
int TCIndex = 0;
foreach (GfxTextureCoord TexCoord in Material.TextureCoords)
{
H3DTextureCoord TC = new H3DTextureCoord();
TC.MappingType = (H3DTextureMappingType)TexCoord.MappingType;
TC.ReferenceCameraIndex = (sbyte)TexCoord.ReferenceCameraIndex;
TC.TransformType = (H3DTextureTransformType)TexCoord.TransformType;
TC.Scale = TexCoord.Scale;
TC.Rotation = TexCoord.Rotation;
TC.Translation = TexCoord.Translation;
switch (TexCoord.MappingType)
{
case GfxTextureMappingType.UvCoordinateMap:
Mat.MaterialParams.TextureSources[TCIndex] = TexCoord.SourceCoordIndex;
break;
case GfxTextureMappingType.CameraCubeEnvMap:
Mat.MaterialParams.TextureSources[TCIndex] = 3;
break;
case GfxTextureMappingType.CameraSphereEnvMap:
Mat.MaterialParams.TextureSources[TCIndex] = 4;
break;
}
Mat.MaterialParams.TextureCoords[TCIndex++] = TC;
if (TCIndex == Material.UsedTextureCoordsCount)
{
break;
}
}
int TMIndex = 0;
foreach (GfxTextureMapper TexMapper in Material.TextureMappers)
{
if (TexMapper == null)
{
break;
}
H3DTextureMapper TM = new H3DTextureMapper();
TM.WrapU = TexMapper.WrapU;
TM.WrapV = TexMapper.WrapV;
TM.MagFilter = (H3DTextureMagFilter)TexMapper.MinFilter;
switch ((uint)TexMapper.MagFilter | ((uint)TexMapper.MipFilter << 1))
{
case 0: TM.MinFilter = H3DTextureMinFilter.NearestMipmapNearest; break;
case 1: TM.MinFilter = H3DTextureMinFilter.LinearMipmapNearest; break;
case 2: TM.MinFilter = H3DTextureMinFilter.NearestMipmapLinear; break;
case 3: TM.MinFilter = H3DTextureMinFilter.LinearMipmapLinear; break;
}
TM.LODBias = TexMapper.LODBias;
TM.MinLOD = TexMapper.MinLOD;
TM.BorderColor = TexMapper.BorderColor;
Mat.TextureMappers[TMIndex++] = TM;
}
Mat.EnabledTextures[0] = Material.TextureMappers[0] != null;
Mat.EnabledTextures[1] = Material.TextureMappers[1] != null;
Mat.EnabledTextures[2] = Material.TextureMappers[2] != null;
Mat.Texture0Name = Material.TextureMappers[0]?.Texture.Path;
Mat.Texture1Name = Material.TextureMappers[1]?.Texture.Path;
Mat.Texture2Name = Material.TextureMappers[2]?.Texture.Path;
GfxFragmentFlags SrcFlags = Material.FragmentShader.Lighting.Flags;
H3DFragmentFlags DstFlags = 0;
if ((SrcFlags & GfxFragmentFlags.IsClampHighLightEnabled) != 0)
{
DstFlags |= H3DFragmentFlags.IsClampHighLightEnabled;
}
if ((SrcFlags & GfxFragmentFlags.IsLUTDist0Enabled) != 0)
{
DstFlags |= H3DFragmentFlags.IsLUTDist0Enabled;
}
if ((SrcFlags & GfxFragmentFlags.IsLUTDist1Enabled) != 0)
{
DstFlags |= H3DFragmentFlags.IsLUTDist1Enabled;
}
if ((SrcFlags & GfxFragmentFlags.IsLUTGeoFactor0Enabled) != 0)
{
DstFlags |= H3DFragmentFlags.IsLUTGeoFactor0Enabled;
}
if ((SrcFlags & GfxFragmentFlags.IsLUTGeoFactor1Enabled) != 0)
{
DstFlags |= H3DFragmentFlags.IsLUTGeoFactor1Enabled;
}
if ((SrcFlags & GfxFragmentFlags.IsLUTReflectionEnabled) != 0)
{
DstFlags |= H3DFragmentFlags.IsLUTReflectionEnabled;
}
if (Material.FragmentShader.Lighting.IsBumpRenormalize)
{
DstFlags |= H3DFragmentFlags.IsBumpRenormalizeEnabled;
}
Mat.MaterialParams.FragmentFlags = DstFlags;
Mat.MaterialParams.FresnelSelector = (H3DFresnelSelector)Material.FragmentShader.Lighting.FresnelSelector;
Mat.MaterialParams.BumpTexture = (byte)Material.FragmentShader.Lighting.BumpTexture;
Mat.MaterialParams.BumpMode = (H3DBumpMode)Material.FragmentShader.Lighting.BumpMode;
Mat.MaterialParams.LUTInputSelection.ReflecR = Material.FragmentShader.LUTs.ReflecR?.Input ?? 0;
Mat.MaterialParams.LUTInputSelection.ReflecG = Material.FragmentShader.LUTs.ReflecG?.Input ?? 0;
Mat.MaterialParams.LUTInputSelection.ReflecB = Material.FragmentShader.LUTs.ReflecB?.Input ?? 0;
Mat.MaterialParams.LUTInputSelection.Dist0 = Material.FragmentShader.LUTs.Dist0?.Input ?? 0;
Mat.MaterialParams.LUTInputSelection.Dist1 = Material.FragmentShader.LUTs.Dist1?.Input ?? 0;
Mat.MaterialParams.LUTInputSelection.Fresnel = Material.FragmentShader.LUTs.Fresnel?.Input ?? 0;
Mat.MaterialParams.LUTInputScale.ReflecR = Material.FragmentShader.LUTs.ReflecR?.Scale ?? 0;
Mat.MaterialParams.LUTInputScale.ReflecG = Material.FragmentShader.LUTs.ReflecG?.Scale ?? 0;
Mat.MaterialParams.LUTInputScale.ReflecB = Material.FragmentShader.LUTs.ReflecB?.Scale ?? 0;
Mat.MaterialParams.LUTInputScale.Dist0 = Material.FragmentShader.LUTs.Dist0?.Scale ?? 0;
Mat.MaterialParams.LUTInputScale.Dist1 = Material.FragmentShader.LUTs.Dist1?.Scale ?? 0;
Mat.MaterialParams.LUTInputScale.Fresnel = Material.FragmentShader.LUTs.Fresnel?.Scale ?? 0;
Mat.MaterialParams.LUTReflecRTableName = Material.FragmentShader.LUTs.ReflecR?.Sampler.TableName;
Mat.MaterialParams.LUTReflecGTableName = Material.FragmentShader.LUTs.ReflecG?.Sampler.TableName;
Mat.MaterialParams.LUTReflecBTableName = Material.FragmentShader.LUTs.ReflecB?.Sampler.TableName;
Mat.MaterialParams.LUTDist0TableName = Material.FragmentShader.LUTs.Dist0?.Sampler.TableName;
Mat.MaterialParams.LUTDist1TableName = Material.FragmentShader.LUTs.Dist1?.Sampler.TableName;
Mat.MaterialParams.LUTFresnelTableName = Material.FragmentShader.LUTs.Fresnel?.Sampler.TableName;
Mat.MaterialParams.LUTReflecRSamplerName = Material.FragmentShader.LUTs.ReflecR?.Sampler.SamplerName;
Mat.MaterialParams.LUTReflecGSamplerName = Material.FragmentShader.LUTs.ReflecG?.Sampler.SamplerName;
Mat.MaterialParams.LUTReflecBSamplerName = Material.FragmentShader.LUTs.ReflecB?.Sampler.SamplerName;
Mat.MaterialParams.LUTDist0SamplerName = Material.FragmentShader.LUTs.Dist0?.Sampler.SamplerName;
Mat.MaterialParams.LUTDist1SamplerName = Material.FragmentShader.LUTs.Dist1?.Sampler.SamplerName;
Mat.MaterialParams.LUTFresnelSamplerName = Material.FragmentShader.LUTs.Fresnel?.Sampler.SamplerName;
Mat.MaterialParams.TexEnvStages[0] = Material.FragmentShader.TextureEnvironments[0].Stage;
Mat.MaterialParams.TexEnvStages[1] = Material.FragmentShader.TextureEnvironments[1].Stage;
Mat.MaterialParams.TexEnvStages[2] = Material.FragmentShader.TextureEnvironments[2].Stage;
Mat.MaterialParams.TexEnvStages[3] = Material.FragmentShader.TextureEnvironments[3].Stage;
Mat.MaterialParams.TexEnvStages[4] = Material.FragmentShader.TextureEnvironments[4].Stage;
Mat.MaterialParams.TexEnvStages[5] = Material.FragmentShader.TextureEnvironments[5].Stage;
Mat.MaterialParams.AlphaTest = Material.FragmentShader.AlphaTest.Test;
Mat.MaterialParams.TexEnvBufferColor = Material.FragmentShader.TexEnvBufferColor;
Mdl.Materials.Add(Mat);
}
foreach (GfxMesh Mesh in Model.Meshes)
{
GfxShape Shape = Model.Shapes[Mesh.ShapeIndex];
H3DMesh M = new H3DMesh();
PICAVertex[] Vertices = null;
foreach (GfxVertexBuffer VertexBuffer in Shape.VertexBuffers)
{
/*
* CGfx supports 3 types of vertex buffer:
* - Non-Interleaved: Each attribute is stored on it's on stream, like this:
* P0 P1 P2 P3 P4 P5 ... N0 N1 N2 N3 N4 N5
* - Interleaved: All attributes are stored on the same stream, like this:
* P0 N0 P1 N1 P2 N2 P3 N3 P4 N4 P5 N5 ...
* - Fixed: The attribute have only a single fixed value, so instead of a stream,
* it have a single vector.
*/
if (VertexBuffer is GfxAttribute)
{
//Non-Interleaved buffer
GfxAttribute Attr = (GfxAttribute)VertexBuffer;
M.Attributes.Add(Attr.ToPICAAttribute());
int Length = Attr.Elements;
switch (Attr.Format)
{
case GfxGLDataType.GL_SHORT: Length <<= 1; break;
case GfxGLDataType.GL_FLOAT: Length <<= 2; break;
}
M.VertexStride += Length;
Vector4[] Vectors = Attr.GetVectors();
if (Vertices == null)
{
Vertices = new PICAVertex[Vectors.Length];
}
for (int i = 0; i < Vectors.Length; i++)
{
switch (Attr.AttrName)
{
case PICAAttributeName.Position: Vertices[i].Position = Vectors[i]; break;
case PICAAttributeName.Normal: Vertices[i].Normal = Vectors[i]; break;
case PICAAttributeName.Tangent: Vertices[i].Tangent = Vectors[i]; break;
case PICAAttributeName.TexCoord0: Vertices[i].TexCoord0 = Vectors[i]; break;
case PICAAttributeName.TexCoord1: Vertices[i].TexCoord1 = Vectors[i]; break;
case PICAAttributeName.TexCoord2: Vertices[i].TexCoord2 = Vectors[i]; break;
case PICAAttributeName.Color: Vertices[i].Color = Vectors[i]; break;
case PICAAttributeName.BoneIndex:
Vertices[i].Indices[0] = (int)Vectors[i].X;
Vertices[i].Indices[1] = (int)Vectors[i].Y;
Vertices[i].Indices[2] = (int)Vectors[i].Z;
Vertices[i].Indices[3] = (int)Vectors[i].W;
break;
case PICAAttributeName.BoneWeight:
Vertices[i].Weights[0] = Vectors[i].X;
Vertices[i].Weights[1] = Vectors[i].Y;
Vertices[i].Weights[2] = Vectors[i].Z;
Vertices[i].Weights[3] = Vectors[i].W;
break;
}
}
}
else if (VertexBuffer is GfxVertexBufferFixed)
{
//Fixed vector
float[] Vector = ((GfxVertexBufferFixed)VertexBuffer).Vector;
M.FixedAttributes.Add(new PICAFixedAttribute()
{
Name = VertexBuffer.AttrName,
Value = new PICAVectorFloat24(
Vector.Length > 0 ? Vector[0] : 0,
Vector.Length > 1 ? Vector[1] : 0,
Vector.Length > 2 ? Vector[2] : 0,
Vector.Length > 3 ? Vector[3] : 0)
});
}
else
{
//Interleaved buffer
GfxVertexBufferInterleaved VtxBuff = (GfxVertexBufferInterleaved)VertexBuffer;
foreach (GfxAttribute Attr in ((GfxVertexBufferInterleaved)VertexBuffer).Attributes)
{
M.Attributes.Add(Attr.ToPICAAttribute());
}
M.RawBuffer = VtxBuff.RawBuffer;
M.VertexStride = VtxBuff.VertexStride;
}
}
if (Vertices != null)
{
M.RawBuffer = VerticesConverter.GetBuffer(Vertices, M.Attributes);
}
Vector4 PositionOffset = new Vector4(Shape.PositionOffset, 0);
int Layer = (int)Model.Materials[Mesh.MaterialIndex].TranslucencyKind;
M.MaterialIndex = (ushort)Mesh.MaterialIndex;
M.NodeIndex = (ushort)Mesh.MeshNodeIndex;
M.PositionOffset = PositionOffset;
M.MeshCenter = Shape.BoundingBox.Center;
M.Layer = Layer;
M.Priority = Mesh.RenderPriority;
H3DBoundingBox OBB = new H3DBoundingBox()
{
Center = Shape.BoundingBox.Center,
Orientation = Shape.BoundingBox.Orientation,
Size = Shape.BoundingBox.Size
};
M.MetaData = new H3DMetaData();
M.MetaData.Add(new H3DMetaDataValue(OBB));
int SmoothCount = 0;
foreach (GfxSubMesh SubMesh in Shape.SubMeshes)
{
foreach (GfxFace Face in SubMesh.Faces)
{
foreach (GfxFaceDescriptor Desc in Face.FaceDescriptors)
{
H3DSubMesh SM = new H3DSubMesh();
SM.BoneIndicesCount = (ushort)SubMesh.BoneIndices.Count;
for (int i = 0; i < SubMesh.BoneIndices.Count; i++)
{
SM.BoneIndices[i] = (ushort)SubMesh.BoneIndices[i];
}
switch (SubMesh.Skinning)
{
case GfxSubMeshSkinning.None: SM.Skinning = H3DSubMeshSkinning.None; break;
case GfxSubMeshSkinning.Rigid: SM.Skinning = H3DSubMeshSkinning.Rigid; break;
case GfxSubMeshSkinning.Smooth: SM.Skinning = H3DSubMeshSkinning.Smooth; break;
}
SM.Indices = Desc.Indices;
SM.Indices = new ushort[Desc.Indices.Length];
Array.Copy(Desc.Indices, SM.Indices, SM.Indices.Length);
M.SubMeshes.Add(SM);
}
}
if (SubMesh.Skinning == GfxSubMeshSkinning.Smooth)
{
SmoothCount++;
}
}
if (SmoothCount == Shape.SubMeshes.Count)
{
M.Skinning = H3DMeshSkinning.Smooth;
}
else if (SmoothCount > 0)
{
M.Skinning = H3DMeshSkinning.Mixed;
}
else
{
M.Skinning = H3DMeshSkinning.Rigid;
}
GfxMaterial Mat = Model.Materials[Mesh.MaterialIndex];
M.UpdateBoolUniforms(Mdl.Materials[Mesh.MaterialIndex]);
Mdl.AddMesh(M);
}
//Workaround to fix blending problems until I can find a proper way.
Mdl.MeshesLayer1.Reverse();
Mdl.MeshNodesTree = new H3DPatriciaTree();
foreach (GfxMeshNodeVisibility MeshNode in Model.MeshNodeVisibilities)
{
Mdl.MeshNodesTree.Add(MeshNode.Name);
Mdl.MeshNodesVisibility.Add(MeshNode.IsVisible);
}
if (Model is GfxModelSkeletal)
{
foreach (GfxBone Bone in ((GfxModelSkeletal)Model).Skeleton.Bones)
{
H3DBone B = new H3DBone()
{
Name = Bone.Name,
ParentIndex = (short)Bone.ParentIndex,
Translation = Bone.Translation,
Rotation = Bone.Rotation,
Scale = Bone.Scale,
InverseTransform = Bone.InvWorldTransform
};
bool ScaleCompensate = (Bone.Flags & GfxBoneFlags.IsSegmentScaleCompensate) != 0;
if (ScaleCompensate)
{
B.Flags |= H3DBoneFlags.IsSegmentScaleCompensate;
}
Mdl.Skeleton.Add(B);
}
Mdl.Flags |= H3DModelFlags.HasSkeleton;
Mdl.BoneScaling = (H3DBoneScaling)((GfxModelSkeletal)Model).Skeleton.ScalingRule;
}
Output.Models.Add(Mdl);
}
foreach (GfxTexture Texture in Textures)
{
H3DTexture Tex = new H3DTexture()
{
Name = Texture.Name,
Width = Texture.Width,
Height = Texture.Height,
Format = Texture.HwFormat,
MipmapSize = (byte)Texture.MipmapSize
};
if (Texture is GfxTextureCube)
{
Tex.RawBufferXPos = ((GfxTextureCube)Texture).ImageXPos.RawBuffer;
Tex.RawBufferXNeg = ((GfxTextureCube)Texture).ImageXNeg.RawBuffer;
Tex.RawBufferYPos = ((GfxTextureCube)Texture).ImageYPos.RawBuffer;
Tex.RawBufferYNeg = ((GfxTextureCube)Texture).ImageYNeg.RawBuffer;
Tex.RawBufferZPos = ((GfxTextureCube)Texture).ImageZPos.RawBuffer;
Tex.RawBufferZNeg = ((GfxTextureCube)Texture).ImageZNeg.RawBuffer;
}
else
{
Tex.RawBuffer = ((GfxTextureImage)Texture).Image.RawBuffer;
}
Output.Textures.Add(Tex);
}
foreach (GfxLUT LUT in LUTs)
{
H3DLUT L = new H3DLUT()
{
Name = LUT.Name
};
foreach (GfxLUTSampler Sampler in LUT.Samplers)
{
L.Samplers.Add(new H3DLUTSampler()
{
Flags = Sampler.IsAbsolute ? H3DLUTFlags.IsAbsolute : 0,
Name = Sampler.Name,
Table = Sampler.Table
});
}
Output.LUTs.Add(L);
}
foreach (GfxCamera Camera in Cameras)
{
Output.Cameras.Add(Camera.ToH3DCamera());
}
foreach (GfxLight Light in Lights)
{
Output.Lights.Add(Light.ToH3DLight());
}
foreach (GfxAnimation SklAnim in SkeletalAnimations)
{
Output.SkeletalAnimations.Add(SklAnim.ToH3DAnimation());
}
foreach (GfxAnimation MatAnim in MaterialAnimations)
{
Output.MaterialAnimations.Add(new H3DMaterialAnim(MatAnim.ToH3DAnimation()));
}
foreach (GfxAnimation VisAnim in VisibilityAnimations)
{
Output.VisibilityAnimations.Add(VisAnim.ToH3DAnimation());
}
foreach (GfxAnimation CamAnim in CameraAnimations)
{
Output.CameraAnimations.Add(CamAnim.ToH3DAnimation());
}
Output.CopyMaterials();
return(Output);
}
