/// <summary>
/// Convierte la pared en un TgcMesh
/// </summary>
/// <param name="meshName">Nombre de la malla que se va a crear</param>
public TgcMesh toMesh(string meshName)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Crear Mesh
Mesh d3dMesh = new Mesh(vertices.Length / 3, vertices.Length, MeshFlags.Managed, TgcSceneLoader.TgcSceneLoader.DiffuseMapVertexElements, d3dDevice);
//Cargar VertexBuffer
using (VertexBuffer vb = d3dMesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
Vector3 ceroNormal = new Vector3(0, 0, 0);
int whiteColor = Color.White.ToArgb();
for (int j = 0; j < vertices.Length; j++)
{
TgcSceneLoader.TgcSceneLoader.DiffuseMapVertex v = new TgcSceneLoader.TgcSceneLoader.DiffuseMapVertex();
CustomVertex.PositionTextured vWall = vertices[j];
//vertices
v.Position = vWall.Position;
//normals
v.Normal = ceroNormal;
//texture coordinates diffuseMap
v.Tu = vWall.Tu;
v.Tv = vWall.Tv;
//color
v.Color = whiteColor;
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = d3dMesh.IndexBuffer)
{
short[] indices = new short[vertices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Calcular normales
d3dMesh.ComputeNormals();
//Malla de TGC
TgcMesh tgcMesh = new TgcMesh(d3dMesh, meshName, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.DiffuseMaps = new TgcTexture[] { texture.clone() };
tgcMesh.Materials = new Material[] { TgcD3dDevice.DEFAULT_MATERIAL };
tgcMesh.createBoundingBox();
tgcMesh.Enabled = true;
return tgcMesh;
}
/// <summary>
/// Tomar los valores configurados y crear el SkyBox
/// </summary>
public void updateValues()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Crear cada cara
for (int i = 0; i < faces.Length; i++)
{
//Crear mesh de D3D
Mesh m = new Mesh(2, 4, MeshFlags.Managed, TgcSceneLoader.DiffuseMapVertexElements, d3dDevice);
SkyFaces skyFace = (SkyFaces)i;
// Cargo los vértices
using (VertexBuffer vb = m.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
int colorRgb = this.color.ToArgb();
cargarVertices(skyFace, data, colorRgb);
vb.Unlock();
}
// Cargo los índices
using (IndexBuffer ib = m.IndexBuffer)
{
short[] ibArray = new short[6];
cargarIndices(ibArray);
ib.SetData(ibArray, 0, LockFlags.None);
}
//Crear TgcMesh
string faceName = Enum.GetName(typeof(SkyFaces), skyFace);
TgcMesh faceMesh = new TgcMesh(m, "SkyBox-" + faceName, TgcMesh.MeshRenderType.DIFFUSE_MAP);
faceMesh.Materials = new Material[] { TgcD3dDevice.DEFAULT_MATERIAL };
faceMesh.createBoundingBox();
faceMesh.Enabled = true;
//textura
TgcTexture texture = TgcTexture.createTexture(d3dDevice, faceTextures[i]);
faceMesh.DiffuseMaps = new TgcTexture[] { texture };
faceMesh.AutoTransformEnable = false;
faces[i] = faceMesh;
matrices[i] = faceMesh.Transform;
}
}
/// <summary>
/// Convierte el terreno en un TgcMesh
/// </summary>
/// <param name="meshName">Nombre de la malla que se va a crear</param>
public TgcMesh toMesh(string meshName)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener matriz para transformar vertices
if (autoTransformEnable)
{
this.transform = Matrix.Scaling(scale) * Matrix.RotationYawPitchRoll(rotation.Y, rotation.X, rotation.Z) * Matrix.Translation(translation);
}
//Crear Mesh con DiffuseMap
Mesh d3dMesh = new Mesh(vertices.Length / 3, vertices.Length, MeshFlags.Managed, TgcSceneLoader.TgcSceneLoader.DiffuseMapVertexElements, d3dDevice);
//Cargar VertexBuffer
using (VertexBuffer vb = d3dMesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < vertices.Length; j++)
{
TgcSceneLoader.TgcSceneLoader.DiffuseMapVertex v = new TgcSceneLoader.TgcSceneLoader.DiffuseMapVertex();
CustomVertex.PositionTextured vLand = vertices[j];
//vertices
v.Position = Vector3.TransformCoordinate(vLand.Position, this.transform);
//normals
v.Normal = Vector3.Empty;
//texture coordinates diffuseMap
v.Tu = vLand.Tu;
v.Tv = vLand.Tv;
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = d3dMesh.IndexBuffer)
{
short[] indices = new short[vertices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Calcular normales
d3dMesh.ComputeNormals();
//Malla de TGC
TgcMesh tgcMesh = new TgcMesh(d3dMesh, meshName, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.DiffuseMaps = new TgcTexture[] { texture };
tgcMesh.Materials = new Material[] { TgcD3dDevice.DEFAULT_MATERIAL };
tgcMesh.createBoundingBox();
tgcMesh.Enabled = true;
return tgcMesh;
}
/// <summary>
/// Convierte el TgcSphere en un TgcMesh
/// </summary>
/// <param name="meshName">Nombre de la malla que se va a crear</param>
public TgcMesh toMesh(string meshName)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener matriz para transformar vertices
if (autoTransformEnable)
{
this.transform = Matrix.Scaling(radius, radius, radius) * Matrix.Scaling(Scale) * Matrix.RotationYawPitchRoll(rotation.Y, rotation.X, rotation.Z) * Matrix.Translation(translation);
}
//Crear mesh con DiffuseMap
if (texture != null)
{
//Crear Mesh
Mesh d3dMesh = new Mesh(indices.Count / 3, indices.Count, MeshFlags.Managed, TgcSceneLoader.TgcSceneLoader.DiffuseMapVertexElements, d3dDevice);
//Cargar VertexBuffer
using (VertexBuffer vb = d3dMesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < indices.Count; j++)
{
TgcSceneLoader.TgcSceneLoader.DiffuseMapVertex v = new TgcSceneLoader.TgcSceneLoader.DiffuseMapVertex();
Vertex.PositionColoredTexturedNormal vSphere = vertices[indices[j]];
//vertices
v.Position = Vector3.TransformCoordinate(vSphere.getPosition(), this.transform);
//normals
v.Normal = vSphere.getNormal();
//texture coordinates diffuseMap
v.Tu = vSphere.Tu;
v.Tv = vSphere.Tv;
//color
v.Color = vSphere.Color;
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = d3dMesh.IndexBuffer)
{
short[] vIndices = new short[indices.Count];
for (int j = 0; j < vIndices.Length; j++)
{
vIndices[j] = (short)j;
}
ib.SetData(vIndices, 0, LockFlags.None);
}
//Calcular normales
//d3dMesh.ComputeNormals();
//Malla de TGC
TgcMesh tgcMesh = new TgcMesh(d3dMesh, meshName, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.DiffuseMaps = new TgcTexture[] { texture.clone() };
tgcMesh.Materials = new Material[] { TgcD3dDevice.DEFAULT_MATERIAL };
tgcMesh.createBoundingBox();
tgcMesh.Enabled = true;
return tgcMesh;
}
//Crear mesh con solo color
else
{
//Crear Mesh
Mesh d3dMesh = new Mesh(indices.Count / 3, indices.Count, MeshFlags.Managed, TgcSceneLoader.TgcSceneLoader.VertexColorVertexElements, d3dDevice);
//Cargar VertexBuffer
using (VertexBuffer vb = d3dMesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < indices.Count; j++)
{
TgcSceneLoader.TgcSceneLoader.VertexColorVertex v = new TgcSceneLoader.TgcSceneLoader.VertexColorVertex();
Vertex.PositionColoredTexturedNormal vSphere = vertices[indices[j]];
//vertices
v.Position = Vector3.TransformCoordinate(vSphere.getPosition(), this.transform);
//normals
v.Normal = vSphere.getNormal();
//color
v.Color = vSphere.Color;
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = d3dMesh.IndexBuffer)
{
short[] vIndices = new short[indices.Count];
for (int j = 0; j < vIndices.Length; j++)
{
vIndices[j] = (short)j;
}
ib.SetData(vIndices, 0, LockFlags.None);
}
//Malla de TGC
TgcMesh tgcMesh = new TgcMesh(d3dMesh, meshName, TgcMesh.MeshRenderType.VERTEX_COLOR);
tgcMesh.Materials = new Material[] { TgcD3dDevice.DEFAULT_MATERIAL };
tgcMesh.createBoundingBox();
tgcMesh.Enabled = true;
return tgcMesh;
}
}
/// <summary>
/// Convierte el Triángulo en un TgcMesh
/// </summary>
/// <param name="meshName">Nombre de la malla que se va a crear</param>
public TgcMesh toMesh(string meshName)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Crear Mesh con solo color
Mesh d3dMesh = new Mesh(1, 3, MeshFlags.Managed, TgcSceneLoader.TgcSceneLoader.VertexColorVertexElements, d3dDevice);
//Calcular normal: left-handed
Vector3 normal = computeNormal();
int ci = color.ToArgb();
//Cargar VertexBuffer
using (VertexBuffer vb = d3dMesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
TgcSceneLoader.TgcSceneLoader.VertexColorVertex v;
//a
v = new TgcSceneLoader.TgcSceneLoader.VertexColorVertex();
v.Position = a;
v.Normal = normal;
v.Color = ci;
data.Write(v);
//b
v = new TgcSceneLoader.TgcSceneLoader.VertexColorVertex();
v.Position = b;
v.Normal = normal;
v.Color = ci;
data.Write(v);
//c
v = new TgcSceneLoader.TgcSceneLoader.VertexColorVertex();
v.Position = c;
v.Normal = normal;
v.Color = ci;
data.Write(v);
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = d3dMesh.IndexBuffer)
{
short[] indices = new short[3];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Malla de TGC
TgcMesh tgcMesh = new TgcMesh(d3dMesh, meshName, TgcMesh.MeshRenderType.VERTEX_COLOR);
tgcMesh.Materials = new Material[] { TgcD3dDevice.DEFAULT_MATERIAL };
tgcMesh.createBoundingBox();
tgcMesh.Enabled = true;
return tgcMesh;
}
/// <summary>
/// Une dos meshes en uno solo.
/// Crea un nuevo mesh con un merge de los dos. Toma el nombre, layer, userProperties, etc del primer mesh.
/// No se hace dispose de los dos meshes originales.
/// Ambos mesh tienen que ser del mismo RenderType.
/// No se puede hacer merge de un mesh con Lightmap
/// </summary>
/// <param name="mesh1">Primer mesh</param>
/// <param name="mesh2">Segundo mesh</param>
/// <returns>Nueve mesh con el merge de los dos</returns>
public TgcMesh mergeTwoMeshes(TgcMesh mesh1, TgcMesh mesh2)
{
//Chequear que sea mismo tipo de malla
if (mesh1.RenderType != mesh2.RenderType)
{
throw new Exception("Se intentó juntar dos Mallas de formato distintos: " + mesh1.Name + " y " + mesh2.Name);
}
//Por ahora no se pueden unificar LightMaps
if (mesh1.RenderType == TgcMesh.MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP)
{
throw new Exception("Actualmente no esta soportado juntar dos Mallas que tienen LightMaps: " + mesh1.Name + " y " + mesh2.Name);
}
//Crear Mesh de D3D
int triCount = mesh1.NumberTriangles + mesh2.NumberTriangles;
int vertexCount = mesh1.NumberVertices + mesh2.NumberVertices;
VertexElement[] vertexElements = mesh1.RenderType == TgcMesh.MeshRenderType.VERTEX_COLOR ? TgcSceneLoader.VertexColorVertexElements : TgcSceneLoader.DiffuseMapVertexElements;
Mesh mesh = new Mesh(triCount, vertexCount, MeshFlags.Managed, vertexElements, GuiController.Instance.D3dDevice);
//VertexColor
if (mesh1.RenderType == TgcMesh.MeshRenderType.VERTEX_COLOR)
{
//Cargar VertexBuffer
TgcSceneLoader.VertexColorVertex[] vertsData = new TgcSceneLoader.VertexColorVertex[vertexCount];
//Agregar los datos del mesh1
TgcSceneLoader.VertexColorVertex[] verts1 = (TgcSceneLoader.VertexColorVertex[])mesh1.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, mesh1.D3dMesh.NumberVertices);
for (int i = 0; i < verts1.Length; i++)
{
verts1[i].Position = TgcVectorUtils.transform(verts1[i].Position, mesh1.Transform);
}
Array.Copy(verts1, vertsData, verts1.Length);
mesh1.D3dMesh.UnlockVertexBuffer();
verts1 = null;
//Agregar los datos del mesh1
TgcSceneLoader.VertexColorVertex[] verts2 = (TgcSceneLoader.VertexColorVertex[])mesh2.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, mesh2.D3dMesh.NumberVertices);
for (int i = 0; i < verts2.Length; i++)
{
verts2[i].Position = TgcVectorUtils.transform(verts2[i].Position, mesh2.Transform);
}
Array.Copy(verts2, 0, vertsData, mesh1.NumberVertices, verts2.Length);
mesh2.D3dMesh.UnlockVertexBuffer();
verts2 = null;
mesh.SetVertexBufferData(vertsData, LockFlags.None);
}
//DiffuseMap
else if (mesh1.RenderType == TgcMesh.MeshRenderType.DIFFUSE_MAP)
{
//Cargar VertexBuffer
TgcSceneLoader.DiffuseMapVertex[] vertsData = new TgcSceneLoader.DiffuseMapVertex[vertexCount];
//Agregar los datos del mesh1 (aplicarle la transformacion actual)
TgcSceneLoader.DiffuseMapVertex[] verts1 = (TgcSceneLoader.DiffuseMapVertex[])mesh1.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), LockFlags.ReadOnly, mesh1.D3dMesh.NumberVertices);
for (int i = 0; i < verts1.Length; i++)
{
verts1[i].Position = TgcVectorUtils.transform(verts1[i].Position, mesh1.Transform);
}
Array.Copy(verts1, vertsData, verts1.Length);
mesh1.D3dMesh.UnlockVertexBuffer();
verts1 = null;
//Agregar los datos del mesh1
TgcSceneLoader.DiffuseMapVertex[] verts2 = (TgcSceneLoader.DiffuseMapVertex[])mesh2.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), LockFlags.ReadOnly, mesh2.D3dMesh.NumberVertices);
for (int i = 0; i < verts2.Length; i++)
{
verts2[i].Position = TgcVectorUtils.transform(verts2[i].Position, mesh2.Transform);
}
Array.Copy(verts2, 0, vertsData, mesh1.NumberVertices, verts2.Length);
mesh2.D3dMesh.UnlockVertexBuffer();
verts2 = null;
mesh.SetVertexBufferData(vertsData, LockFlags.None);
}
//Cargar indexBuffer en forma plana
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[vertexCount];
for (int i = 0; i < indices.Length; i++)
{
indices[i] = (short)i;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Cargar texturas y attributeBuffer
TgcTexture[] textures = null;
Material[] materials = null;
if (mesh1.RenderType == TgcMesh.MeshRenderType.DIFFUSE_MAP)
{
//Cargar materials
materials = new Material[mesh1.DiffuseMaps.Length + mesh2.DiffuseMaps.Length];
int mIdx = 0;
foreach (Material m in mesh1.Materials)
{
materials[mIdx++] = m;
}
foreach (Material m in mesh2.Materials)
{
materials[mIdx++] = m;
}
//Texturas del mesh1
textures = new TgcTexture[mesh1.DiffuseMaps.Length + mesh2.DiffuseMaps.Length];
int tIdx = 0;
foreach (TgcTexture t in mesh1.DiffuseMaps)
{
textures[tIdx++] = t.clone();
}
//Texturas del mesh2
foreach (TgcTexture t in mesh2.DiffuseMaps)
{
textures[tIdx++] = t.clone();
}
//Cargar el AttributeBuffer con la suma de ambos mesh
int attIdx = 0;
int textureId = 0;
int[] attributeBuffer = mesh.LockAttributeBufferArray(LockFlags.None);
//AttributeBuffer del mesh 1
if (mesh1.DiffuseMaps.Length > 1)
{
//Copiar el AttributeBuffer del mesh1 tal cual al mesh unificado
int[] attributeBuffer1 = mesh1.D3dMesh.LockAttributeBufferArray(LockFlags.ReadOnly);
Array.Copy(attributeBuffer1, attributeBuffer, attributeBuffer1.Length);
mesh1.D3dMesh.UnlockAttributeBuffer(attributeBuffer1);
}
else
{
//Hay una sola textura, llenar el AttributeBuffer para que apunte solo a esa textura
for (int i = 0; i < mesh1.NumberTriangles; i++)
{
attributeBuffer[i] = textureId;
}
}
attIdx += mesh1.NumberTriangles;
textureId += mesh1.DiffuseMaps.Length;
//AttributeBuffer del mesh 2
if (mesh2.DiffuseMaps.Length > 1)
{
//Copiar el AttributeBuffer del mesh2 al mesh unificado pero sumando el offset de texturas del primero
int[] attributeBuffer2 = mesh2.D3dMesh.LockAttributeBufferArray(LockFlags.ReadOnly);
int[] attributeBuffer2Offset = new int[attributeBuffer2.Length];
for (int i = 0; i < attributeBuffer2.Length; i++)
{
attributeBuffer2Offset[i] = attributeBuffer2[i] + textureId;
}
mesh2.D3dMesh.UnlockAttributeBuffer(attributeBuffer2);
Array.Copy(attributeBuffer2Offset, 0, attributeBuffer, attIdx, attributeBuffer2Offset.Length);
attributeBuffer2Offset = null;
}
else
{
//Hay una sola textura, llenar el AttributeBuffer para que apunte solo a esa textura
for (int i = 0; i < mesh2.NumberTriangles; i++)
{
attributeBuffer[attIdx++] = textureId;
}
textureId++;
}
mesh.UnlockAttributeBuffer(attributeBuffer);
}
//Crear mesh de TGC
TgcMesh tgcMesh = new TgcMesh(mesh, mesh1.Name, mesh1.RenderType);
tgcMesh.Layer = mesh1.Layer;
tgcMesh.createBoundingBox();
tgcMesh.Materials = materials;
tgcMesh.DiffuseMaps = textures;
tgcMesh.AlphaBlendEnable = mesh1.AlphaBlendEnable;
tgcMesh.Enabled = mesh1.Enabled;
//Transformaciones con la identidad (porque ya transformamos los vertices)
tgcMesh.Position = new Vector3(0, 0, 0);
tgcMesh.Rotation = new Vector3(0, 0, 0);
tgcMesh.Scale = new Vector3(1, 1, 1);
tgcMesh.Transform = Matrix.Identity;
tgcMesh.AutoTransformEnable = mesh1.AutoTransformEnable;
//Agregar userProperties de ambos
if (mesh1.UserProperties != null || mesh2.UserProperties != null)
{
tgcMesh.UserProperties = new Dictionary<string, string>();
if (mesh1.UserProperties != null)
{
foreach (KeyValuePair<string, string> entry in mesh1.UserProperties)
{
tgcMesh.UserProperties.Add(entry.Key, entry.Value);
}
}
if (mesh2.UserProperties != null)
{
foreach (KeyValuePair<string, string> entry in mesh2.UserProperties)
{
tgcMesh.UserProperties.Add(entry.Key, entry.Value);
}
}
}
return tgcMesh;
}
/// <summary>
/// Adaptar mesh de DirectX a mesh de TGC
/// </summary>
public TgcMesh CreateTgcMesh(BspMap bspMap, Mesh mesh,int surfaceId)
{
QSurface surface = bspMap.Data.drawSurfaces[surfaceId];
TgcTexture lightmap = surface.lightmapNum >= 0 ? lightMaps[surface.lightmapNum] : null;
var texture = textures[surface.shaderNum];
//asigno el shader si es que tiene
bspMap.Data.shaderXSurface[surfaceId] = shaderXTextura[surface.shaderNum];
if (bspMap.Data.shaderXSurface[surfaceId] != null)
bspMap.Data.shaderXSurface[surfaceId].BuildFx();
if (texture == null && bspMap.Data.shaderXSurface[surfaceId] != null)
{
foreach (QShaderStage stage in bspMap.Data.shaderXSurface[surfaceId].Stages)
{
if (stage.Textures.Count > 0)
{
texture = stage.Textures[0];
break;
}
}
}
//Cargar lightMap
TgcTexture tgcLightMap = lightmap;
if (lightmap == null)
tgcLightMap = emptyLightMap;
TgcTexture[] meshTextures = new TgcTexture[1];
if (texture != null)
{
meshTextures[0] = texture;
}
else
{
meshTextures[0] = emptyTexture;
}
TgcMesh.MeshRenderType renderType = TgcMesh.MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP;
Material mat = new Material();
mat.Ambient = Color.White;
//Crear mesh de TGC
TgcMesh tgcMesh = new TgcMesh(mesh, "mesh" + surfaceId, renderType);
tgcMesh.Materials = new Material[] { mat };
tgcMesh.DiffuseMaps = meshTextures;
tgcMesh.LightMap = tgcLightMap;
tgcMesh.Enabled = true;
tgcMesh.createBoundingBox();
return tgcMesh;
}
/// <summary>
/// Transformar fisicamente los vertices del mesh segun su transformacion actual
/// </summary>
private void applyMeshTransformToVertices(TgcMesh m)
{
//Transformacion actual
Matrix transform = Matrix.Scaling(m.Scale)
* Matrix.RotationYawPitchRoll(m.Rotation.Y, m.Rotation.X, m.Rotation.Z)
* Matrix.Translation(m.Position);
switch (m.RenderType)
{
case TgcMesh.MeshRenderType.VERTEX_COLOR:
TgcSceneLoader.VertexColorVertex[] verts1 = (TgcSceneLoader.VertexColorVertex[])m.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, m.D3dMesh.NumberVertices);
for (int i = 0; i < verts1.Length; i++)
{
verts1[i].Position = TgcVectorUtils.transform(verts1[i].Position, transform);
}
m.D3dMesh.SetVertexBufferData(verts1, LockFlags.None);
m.D3dMesh.UnlockVertexBuffer();
break;
case TgcMesh.MeshRenderType.DIFFUSE_MAP:
TgcSceneLoader.DiffuseMapVertex[] verts2 = (TgcSceneLoader.DiffuseMapVertex[])m.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), LockFlags.ReadOnly, m.D3dMesh.NumberVertices);
for (int i = 0; i < verts2.Length; i++)
{
verts2[i].Position = TgcVectorUtils.transform(verts2[i].Position, transform);
}
m.D3dMesh.SetVertexBufferData(verts2, LockFlags.None);
m.D3dMesh.UnlockVertexBuffer();
break;
case TgcMesh.MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP:
TgcSceneLoader.DiffuseMapAndLightmapVertex[] verts3 = (TgcSceneLoader.DiffuseMapAndLightmapVertex[])m.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapAndLightmapVertex), LockFlags.ReadOnly, m.D3dMesh.NumberVertices);
for (int i = 0; i < verts3.Length; i++)
{
verts3[i].Position = TgcVectorUtils.transform(verts3[i].Position, transform);
}
m.D3dMesh.SetVertexBufferData(verts3, LockFlags.None);
m.D3dMesh.UnlockVertexBuffer();
break;
}
//Quitar movimientos del mesh
m.Position = new Vector3(0, 0, 0);
m.Scale = new Vector3(1, 1, 1);
m.Rotation = new Vector3(0, 0, 0);
m.Transform = Matrix.Identity;
m.AutoTransformEnable = true;
//Calcular nuevo bounding box
m.createBoundingBox();
}
/// <summary>
/// Carga la escena a partir de un objeto TgcSceneData ya parseado
/// </summary>
/// <param name="sceneData">Objeto con datos de la escena ya parseados</param>
/// <param name="mediaPath">Path a partir del cual hay que buscar los recursos de escena (Texturas, LightMaps, etc.)</param>
/// <returns></returns>
public TgcScene loadScene(TgcSceneData sceneData, string mediaPath)
{
TgcScene tgcScene = new TgcScene(sceneData.name, null);
//Cargar Texturas
TgcSceneLoaderMaterialAux[] materialsArray = new TgcSceneLoaderMaterialAux[sceneData.materialsData.Length];
for (int i = 0; i < sceneData.materialsData.Length; i++)
{
TgcMaterialData materialData = sceneData.materialsData[i];
string texturesPath = mediaPath + sceneData.texturesDir + "\\";
//Crear StandardMaterial
if (materialData.type.Equals(TgcMaterialData.StandardMaterial))
{
materialsArray[i] = createTextureAndMaterial(materialData, texturesPath);
}
//Crear MultiMaterial
else if (materialData.type.Equals(TgcMaterialData.MultiMaterial))
{
TgcSceneLoaderMaterialAux matAux = new TgcSceneLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcSceneLoaderMaterialAux[materialData.subMaterials.Length];
for (int j = 0; j < materialData.subMaterials.Length; j++)
{
matAux.subMaterials[j] = createTextureAndMaterial(materialData.subMaterials[j], texturesPath);
}
}
}
//Cargar Meshes
for (int i = 0; i < sceneData.meshesData.Length; i++)
{
TgcMeshData meshData = sceneData.meshesData[i];
TgcMesh tgcMesh = null;
//Crear malla original
if (meshData.instanceType.Equals(TgcMeshData.ORIGINAL))
{
//Crear mesh que no tiene Material, con un color simple
if (meshData.materialId == -1)
{
tgcMesh = crearMeshSoloColor(meshData);
}
//Para los que si tienen Material
else
{
//Crear MeshFormat que soporte LightMaps
if (meshData.lightmapEnabled)
{
tgcMesh = crearMeshDiffuseMapLightmap(sceneData, mediaPath, materialsArray, meshData);
}
//Formato de Mesh con Textura pero sin Lightmap
else
{
tgcMesh = crearMeshDiffuseMap(materialsArray, meshData);
}
}
}
//Crear malla instancia
else if (meshData.instanceType.Equals(TgcMeshData.INSTANCE))
{
tgcMesh = crearMeshInstance(meshData, tgcScene.Meshes);
}
//Crear BoundingBox, aprovechar lo que viene del XML o crear uno por nuestra cuenta
if (meshData.pMin != null && meshData.pMax != null)
{
tgcMesh.BoundingBox = new TgcBoundingBox(
TgcParserUtils.float3ArrayToVector3(meshData.pMin),
TgcParserUtils.float3ArrayToVector3(meshData.pMax),
tgcMesh.Position,
tgcMesh.Scale
);
}
else
{
tgcMesh.createBoundingBox();
}
//Cargar layer
tgcMesh.Layer = meshData.layerName;
//Cargar AlphaBlending
tgcMesh.AlphaBlendEnable = meshData.alphaBlending;
//agregar mesh a escena
tgcMesh.Enabled = true;
tgcScene.Meshes.Add(tgcMesh);
//Cargar userProperties, si hay
tgcMesh.UserProperties = meshData.userProperties;
}
//BoundingBox del escenario, utilizar el que viene del XML o crearlo nosotros
if (sceneData.pMin != null && sceneData.pMax != null)
{
tgcScene.BoundingBox = new TgcBoundingBox(
new Vector3(sceneData.pMin[0], sceneData.pMin[1], sceneData.pMin[2]),
new Vector3(sceneData.pMax[0], sceneData.pMax[1], sceneData.pMax[2])
);
}
else
{
List <TgcBoundingBox> boundingBoxes = new List <TgcBoundingBox>();
foreach (TgcMesh mesh in tgcScene.Meshes)
{
boundingBoxes.Add(mesh.BoundingBox);
}
tgcScene.BoundingBox = TgcBoundingBox.computeFromBoundingBoxes(boundingBoxes);
}
//Cargar parte de PortalRendering, solo hay información
if (sceneData.portalData != null)
{
TgcPortalRenderingLoader portalLoader = new TgcPortalRenderingLoader();
tgcScene.PortalRendering = portalLoader.loadFromData(tgcScene, sceneData.portalData);
}
return(tgcScene);
}
