/// <summary>
/// Carga una textura como parámetro de un Shader
/// </summary>
/// <param name="effect">Shader</param>
/// <param name="parameterName">Nombre del parámetro en el Shader</param>
/// <param name="texture">Textura a aplicar</param>
public void shaderSet(Effect effect, string parameterName, TgcTexture texture)
{
if (texture != null && texture.D3dTexture != null)
{
effect.SetValue(parameterName, texture.D3dTexture);
}
}
private void InitEmptyTextures()
{
if (emptyLightMap != null && emptyTexture != null)
return;
//algunos mesh no tienen textura o lightmap. Por compatibilidad con el exporter es conveniente que todas tengan Una textura
//para eso creo una textura vacia de 1x1 negro como textura y una de 1x1 blanco para lightmap.
var texture = new Texture(GuiController.Instance.D3dDevice, 1, 1, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
GraphicsStream graphicsStream = texture.LockRectangle(0, LockFlags.None);
uint color = 0x00000000;
graphicsStream.Write(color);
texture.UnlockRectangle(0);
TextureLoader.Save("emptyTexture.jpg", ImageFileFormat.Jpg, texture);
emptyTexture = new TgcTexture("emptyTexture.jpg","emptyTexture.jpg", texture, false);
texture = new Texture(GuiController.Instance.D3dDevice, 1, 1, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
graphicsStream = texture.LockRectangle(0, LockFlags.None);
color = 0x00000000;
graphicsStream.Write(color);
texture.UnlockRectangle(0);
TextureLoader.Save("emptyLightMap.jpg", ImageFileFormat.Jpg, texture);
emptyLightMap = new TgcTexture("emptyLightMap.jpg", "emptyLightMap.jpg", texture, false);
}
/// <summary>
/// Crear un emisor de particulas
/// </summary>
/// <param name="texturePath">textura a utilizar</param>
/// <param name="particlesCount">cantidad maxima de particlas a generar</param>
public ParticleEmitter(string texturePath, int particlesCount)
{
Device device = GuiController.Instance.D3dDevice;
//valores default
enabled = true;
playing = true;
random = new Random(0);
creationFrecuency = 1.0f;
particleTimeToLive = 5.0f;
minSizeParticle = 0.25f;
maxSizeParticle = 0.5f;
dispersion = 100;
speed = new Vector3(1, 1, 1);
particleVertexArray = new Particle.ParticleVertex[1];
vertexDeclaration = new VertexDeclaration(device, Particle.ParticleVertexElements);
position = new Vector3(0, 0, 0);
this.particlesCount = particlesCount;
this.particles = new Particle[particlesCount];
this.particlesAlive = new ColaDeParticulas(particlesCount);
this.particlesDead = new Stack<Particle>(particlesCount);
//Creo todas las particulas. Inicialmente estan todas muertas.
for (int i = 0; i < particlesCount; i++)
{
this.particles[i] = new Particle();
this.particlesDead.Push(this.particles[i]);
}
//Cargo la textura que tendra cada particula
this.texture = TgcTexture.createTexture(device, texturePath);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(
GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Box\\" + "Box-TgcScene.xml",
GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Box\\");
mesh = scene.Meshes[0];
mesh.Scale = new Vector3(0.25f, 0.25f, 0.25f);
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(7.9711f, 11.7f, -32.5475f), new Vector3(7.972f, 11.4178f, -31.5475f));
GuiController.Instance.Modifiers.addVertex3f("origin", new Vector3(-100, -100, -100), new Vector3(100, 100, 100), new Vector3(0, 0, 0));
GuiController.Instance.Modifiers.addVertex3f("dimension", new Vector3(-100, -100, -100), new Vector3(1000, 1000, 100), new Vector3(10, 10, 10));
GuiController.Instance.Modifiers.addInterval("orientation", new string[] { "XY", "XZ", "YZ" }, 0);
GuiController.Instance.Modifiers.addVertex2f("tiling", new Vector2(0,0), new Vector2(10,10),new Vector2(1,1));
string texturePath = GuiController.Instance.ExamplesMediaDir + "Texturas\\Quake\\TexturePack2\\brick1_1.jpg";
currentTexture = TgcTexture.createTexture(d3dDevice, texturePath);
GuiController.Instance.Modifiers.addTexture("texture", currentTexture.FilePath);
updateWall();
}
private static TgcTexture getTexture()
{
if (texture == null)
{
texture = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "RenderMan\\texturas\\fuego.png");
}
return texture;
}
/// <summary>
/// Agregar una nueva textura a la lista de texturas que tiene el mesh.
/// Esta nueva textura no va a ser utilizada por ningún triángulo si no se
/// adapta correctamente el attributeBuffer.
/// No se controla si esa textura ya esta repetida en el mesh.
/// </summary>
/// <param name="newDiffuseMap">Nueva textura</param>
public void addDiffuseMap(TgcTexture newDiffuseMap)
{
//Solo aplicar si la malla tiene texturas
if (renderType == MeshRenderType.DIFFUSE_MAP || renderType == MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP)
{
TgcTexture[] newDiffuseMapsArray = new TgcTexture[diffuseMaps.Length + 1];
Array.Copy(diffuseMaps, newDiffuseMapsArray, diffuseMaps.Length);
newDiffuseMapsArray[newDiffuseMapsArray.Length - 1] = newDiffuseMap;
this.diffuseMaps = newDiffuseMapsArray;
}
}
public PostProcesadoManager(EjemploAlumno ejemAlumno)
{
ejemploAlumno = ejemAlumno;
GuiController.Instance.CustomRenderEnabled = true;
Device d3dDevice = GuiController.Instance.D3dDevice;
//Activamos el renderizado customizado. De esta forma el framework nos delega control total sobre como dibujar en pantalla
//La responsabilidad cae toda de nuestro lado
GuiController.Instance.CustomRenderEnabled = true;
//Se crean 2 triangulos (o Quad) con las dimensiones de la pantalla con sus posiciones ya transformadas
// x = -1 es el extremo izquiedo de la pantalla, x = 1 es el extremo derecho
// Lo mismo para la Y con arriba y abajo
// la Z en 1 simpre
CustomVertex.PositionTextured[] screenQuadVertices = new CustomVertex.PositionTextured[]
{
new CustomVertex.PositionTextured( -1, 1, 1, 0,0),
new CustomVertex.PositionTextured(1, 1, 1, 1,0),
new CustomVertex.PositionTextured(-1, -1, 1, 0,1),
new CustomVertex.PositionTextured(1,-1, 1, 1,1)
};
//vertex buffer de los triangulos
screenQuadVB = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
screenQuadVB.SetData(screenQuadVertices, 0, LockFlags.None);
// stencil
g_pDepthStencil = d3dDevice.CreateDepthStencilSurface(d3dDevice.PresentationParameters.BackBufferWidth,
d3dDevice.PresentationParameters.BackBufferHeight,
DepthFormat.D24S8,
MultiSampleType.None,
0,
true);
//Creamos un Render Targer sobre el cual se va a dibujar la pantalla
renderTarget2D = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
effect = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosDir + "SRC\\Renderman\\Efectos\\PostProcesado\\PocaVidaRestante.fx");
//Cargar textura que se va a dibujar arriba de la escena del Render Target
alarmTexture = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "\\RenderMan\\texturas\\efecto_alarma.png");
//Interpolador para efecto de variar la intensidad de la textura de alarma
intVaivenAlarm = new InterpoladorVaiven();
intVaivenAlarm.Min = 0;
intVaivenAlarm.Max = 1;
intVaivenAlarm.Speed = 5;
intVaivenAlarm.reset();
}
/// <summary>
/// Libera los recursos de la malla.
/// Si la malla es una instancia se deshabilita pero no se liberan recursos.
/// Si la malla es el original y tiene varias instancias adjuntadas, se hace dispose() también de las instancias.
/// </summary>
public void dispose()
{
this.enabled = false;
if (boundingBox != null)
{
boundingBox.dispose();
}
//Si es una instancia no liberar nada, lo hace el original.
if (parentInstance != null)
{
parentInstance = null;
return;
}
//hacer dispose de instancias
if (meshInstances != null)
{
foreach (TgcMesh meshInstance in meshInstances)
{
meshInstance.dispose();
}
meshInstances = null;
}
//Dispose de mesh
this.d3dMesh.Dispose();
this.d3dMesh = null;
//Dispose de texturas
if (diffuseMaps != null)
{
for (int i = 0; i < diffuseMaps.Length; i++)
{
if (diffuseMaps[i] != null)
{
diffuseMaps[i].dispose();
}
}
diffuseMaps = null;
}
if (lightMap != null)
{
lightMap.dispose();
lightMap = null;
}
//VertexDeclaration
vertexDeclaration.Dispose();
vertexDeclaration = null;
}
/// <summary>
/// Crea Material y Textura
/// </summary>
private TgcSceneLoaderMaterialAux createTextureAndMaterial(TgcMaterialData materialData, string texturesPath)
{
TgcSceneLoaderMaterialAux matAux = new TgcSceneLoaderMaterialAux();
//Crear material
Material material = new Material();
matAux.materialId = material;
material.AmbientColor = new ColorValue(
materialData.ambientColor[0],
materialData.ambientColor[1],
materialData.ambientColor[2],
materialData.ambientColor[3]);
material.DiffuseColor = new ColorValue(
materialData.diffuseColor[0],
materialData.diffuseColor[1],
materialData.diffuseColor[2],
materialData.diffuseColor[3]);
material.SpecularColor = new ColorValue(
materialData.specularColor[0],
materialData.specularColor[1],
materialData.specularColor[2],
materialData.specularColor[3]);
//TODO ver que hacer con la opacity
//crear textura
texturesDict.Clear();
if (materialData.fileName != null)
{
//revisar que esa imagen no se haya cargado previamente
TgcTexture texture;
if (texturesDict.ContainsKey(materialData.fileName))
{
texture = texturesDict[materialData.fileName];
}
else
{
texture = TgcTexture.createTexture(device, materialData.fileName, texturesPath + "\\" + materialData.fileName);
texturesDict[materialData.fileName] = texture;
//TODO usar para algo el OFFSET y el TILING
}
matAux.texture = texture;
}
else
{
matAux.texture = null;
}
return(matAux);
}
/// <summary>
/// Crea una pared con un punto de origen, el tamaño de la pared y la orientación de la misma, especificando
/// el tiling de la textura
/// </summary>
/// <param name="origin">Punto de origen de la pared</param>
/// <param name="size">Dimensiones de la pared. Uno de los valores será ignorado, según la orientación elegida</param>
/// <param name="orientation">Orientacion de la pared</param>
/// <param name="texture">Textura de la pared</param>
/// <param name="uTile">Cantidad de tile de la textura en coordenada U</param>
/// <param name="vTile">Cantidad de tile de la textura en coordenada V</param>
public TgcPlaneWall(Vector3 origin, Vector3 size, Orientations orientation, TgcTexture texture, float uTile, float vTile)
: this()
{
setTexture(texture);
autoAdjustUv = false;
this.origin = origin;
this.size = size;
this.orientation = orientation;
this.uTile = uTile;
this.vTile = vTile;
updateValues();
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
box1Texture = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.ExamplesMediaDir + "Texturas\\pasto.jpg");
box2Texture = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.ExamplesMediaDir + "Texturas\\tierra.jpg");
box3Texture = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.ExamplesMediaDir + "Texturas\\madera.jpg");
GuiController.Instance.Modifiers.addEnum("Render Method", typeof(RenderMethod), RenderMethod.Unsorted);
createMeshes(25);
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(32.1944f, 42.1327f, -68.7882f), new Vector3(265.5333f, -258.1551f, 856.0794f));
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
updateWall();
string text = (string)GuiController.Instance.Modifiers["texture"];
if (text != currentTexture.FilePath)
{
currentTexture = TgcTexture.createTexture(d3dDevice, text);
wall.setTexture(currentTexture);
}
wall.render();
mesh.render();
}
/// <summary>
/// Crea una nueva malla que es una instancia de otra malla original.
/// Reutiliza toda la geometría de la malla original sin duplicarla.
/// </summary>
/// <param name="name">Nombre de la malla</param>
/// <param name="parentInstance">Malla original desde la cual basarse</param>
/// <param name="translation">Traslación respecto de la malla original</param>
/// <param name="rotation">Rotación respecto de la malla original</param>
/// <param name="scale">Escala respecto de la malla original</param>
public TgcMesh(string name, TgcMesh parentInstance, Vector3 translation, Vector3 rotation, Vector3 scale)
{
//Cargar datos en base al original
this.initData(parentInstance.d3dMesh, name, parentInstance.renderType);
this.diffuseMaps = parentInstance.diffuseMaps;
this.materials = parentInstance.materials;
this.lightMap = parentInstance.lightMap;
//Almacenar transformación inicial
this.translation = translation;
this.rotation = rotation;
this.scale = scale;
//almacenar instancia en el padre
this.parentInstance = parentInstance;
parentInstance.meshInstances.Add(this);
}
/// <summary>
/// Crea una nueva malla que es una instancia de otra malla original.
/// Reutiliza toda la geometría de la malla original sin duplicarla.
/// </summary>
/// <param name="name">Nombre de la malla</param>
/// <param name="parentInstance">Malla original desde la cual basarse</param>
/// <param name="translation">Traslación respecto de la malla original</param>
/// <param name="rotation">Rotación respecto de la malla original</param>
/// <param name="scale">Escala respecto de la malla original</param>
public TgcMesh(string name, TgcMesh parentInstance, Vector3 translation, Vector3 rotation, Vector3 scale)
{
//Cargar datos en base al original
this.initData(parentInstance.d3dMesh, name, parentInstance.renderType);
this.diffuseMaps = parentInstance.diffuseMaps;
this.materials = parentInstance.materials;
this.lightMap = parentInstance.lightMap;
//Almacenar transformación inicial
this.translation = translation;
this.rotation = rotation;
this.scale = scale;
//almacenar instancia en el padre
this.parentInstance = parentInstance;
parentInstance.meshInstances.Add(this);
}
/// <summary>
/// Eliminar un slot de textura del mesh.
/// Se modifica el attributeBuffer para que todos los triangulos que
/// apuntaban a esta textura ahora apunten a replacementSlot
/// </summary>
/// <param name="diffuseMapSlot">Slot de textura a eliminar</param>
/// <param name="replacementSlot">Nuevo slot al que apuntan los triangulos que usaban el anterior</param>
public void deleteDiffuseMap(int diffuseMapSlot, int replacementSlot)
{
//Solo aplicar si la malla tiene texturas
if (renderType == MeshRenderType.DIFFUSE_MAP || renderType == MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP)
{
if (diffuseMapSlot < 0 || diffuseMapSlot >= diffuseMaps.Length)
{
throw new Exception("Incorrect diffuseMap slot: " + diffuseMapSlot + ". Total: " + diffuseMaps.Length);
}
if (replacementSlot < 0 || replacementSlot >= diffuseMaps.Length - 1)
{
replacementSlot = 0;
}
//Crear nuevo array sin la textura que se quiere eliminar
TgcTexture[] newDiffuseMapsArray = new TgcTexture[diffuseMaps.Length - 1];
int w = 0;
for (int i = 0; i < diffuseMaps.Length; i++)
{
if (i != diffuseMapSlot)
{
newDiffuseMapsArray[w++] = diffuseMaps[i];
}
}
this.diffuseMaps = newDiffuseMapsArray;
//Modificar attributeBuffer. Hay que reemplazar el id que se elimino y hacer shift de todo lo que estaba a la derecha
int[] attributeBuffer = d3dMesh.LockAttributeBufferArray(LockFlags.None);
for (int i = 0; i < attributeBuffer.Length; i++)
{
if (attributeBuffer[i] == diffuseMapSlot)
{
attributeBuffer[i] = replacementSlot;
}
else if (attributeBuffer[i] > diffuseMapSlot)
{
attributeBuffer[i]--;
}
}
d3dMesh.UnlockAttributeBuffer(attributeBuffer);
}
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Modifiers para variar parámetros de la pared
GuiController.Instance.Modifiers.addVertex3f("origin", new Vector3(-100, -100, -100), new Vector3(100, 100, 100), new Vector3(0, 0, 0));
GuiController.Instance.Modifiers.addVertex3f("dimension", new Vector3(-100, -100, -100), new Vector3(1000, 1000, 100), new Vector3(100, 100, 100));
GuiController.Instance.Modifiers.addInterval("orientation", new string[] { "XY", "XZ", "YZ" }, 0);
GuiController.Instance.Modifiers.addVertex2f("tiling", new Vector2(0,0), new Vector2(10,10),new Vector2(1,1));
GuiController.Instance.Modifiers.addBoolean("autoAdjust", "autoAdjust", false);
//Modifier de textura
string texturePath = GuiController.Instance.ExamplesMediaDir + "Texturas\\Quake\\TexturePack2\\brick1_1.jpg";
currentTexture = TgcTexture.createTexture(d3dDevice, texturePath);
GuiController.Instance.Modifiers.addTexture("texture", currentTexture.FilePath);
//Crear pared
wall = new TgcPlaneWall();
wall.setTexture(currentTexture);
//Actualizar según valores cargados
updateWall();
}
/// <summary>
/// Configurar color de la esfera y setea la technique POSITION_COLORED. Unsetea la textura.
/// </summary>
/// <param name="color"></param>
public virtual void setColor(Color color)
{
this.texture = null;
this.technique = TgcShaders.T_POSITION_COLORED;
if (this.color != color) mustUpdate = true;
this.color = color;
}
private void drawDiffuseMap(int pass, TgcTexture.Manager texturesManager)
{
//Dibujar cada subset con su DiffuseMap correspondiente
for (int i = 0; i < materials.Length; i++)
{
//Setear textura en shader
texturesManager.shaderSet(effect, "texDiffuseMap", diffuseMaps[i]);
//Iniciar pasada de shader
drawSubset(i, pass);
}
}
/// <summary>
/// Crea una nueva textura, haciendo el Loading del archivo de imagen especificado.
/// Infiere el nombre de la textura en base al path completo
/// Se utiliza un Pool de Texturas para no cargar mas de una vez el mismo archivo.
/// </summary>
/// <param name="d3dDevice">Device de Direct3D</param>
/// <param name="filePath">Ruta completa de la textura. Ejemplo: C:\Texturas\miTextura.jpg</param>
/// <returns>Textura creada</returns>
public static TgcTexture createTexture(Device d3dDevice, string filePath)
{
FileInfo fInfo = new FileInfo(filePath);
return(TgcTexture.createTexture(d3dDevice, fInfo.Name, filePath));
}
/// <summary>
/// Carga una textura en el Stage especificado.
/// Si la textura es null, es similar aa hacer clear()
/// </summary>
/// <param name="stage">Stage en el cual configurar la textura</param>
/// <param name="texture">Textura a configurar</param>
public void set(int stage, TgcTexture texture)
{
GuiController.Instance.D3dDevice.SetTexture(stage, texture.d3dTexture);
}
/// <summary>
/// Permite cambiar las texturas de DiffuseMap de esta malla
/// </summary>
/// <param name="newDiffuseMaps">Array de nuevas texturas. Tiene que tener la misma cantidad que el original</param>
public void changeDiffuseMaps(TgcTexture[] newDiffuseMaps)
{
//Solo aplicar si la malla tiene texturas
if (renderType == MeshRenderType.DIFFUSE_MAP)
{
if (diffuseMaps.Length != newDiffuseMaps.Length)
{
throw new Exception("The new DiffuseMap array does not have the same length than the original.");
}
//Liberar texturas anteriores
foreach (TgcTexture t in diffuseMaps)
{
t.dispose();
}
//Asignar nuevas texturas
this.diffuseMaps = newDiffuseMaps;
}
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar textura de CubeMap para Environment Map, fijo para todos los meshes
cubeMap = TextureLoader.FromCubeFile(d3dDevice, GuiController.Instance.ExamplesMediaDir + "Shaders\\CubeMap.dds");
//Cargar Shader personalizado de EnvironmentMap
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesMediaDir + "Shaders\\EnvironmentMap.fx");
//Cargar escenario, pero inicialmente solo hacemos el parser, para separar los objetos que son solo luces y no meshes
string scenePath = GuiController.Instance.ExamplesDir + "Lights\\NormalMapRoom\\NormalMapRoom-TgcScene.xml";
string mediaPath = GuiController.Instance.ExamplesDir + "Lights\\NormalMapRoom\\";
TgcSceneParser parser = new TgcSceneParser();
TgcSceneData sceneData = parser.parseSceneFromString(File.ReadAllText(scenePath));
//Separar modelos reales de las luces, segun layer "Lights"
lights = new List<LightData>();
List<TgcMeshData> realMeshData = new List<TgcMeshData>();
for (int i = 0; i < sceneData.meshesData.Length; i++)
{
TgcMeshData meshData = sceneData.meshesData[i];
//Es una luz, no cargar mesh, solo importan sus datos
if (meshData.layerName == "Lights")
{
//Guardar datos de luz
LightData light = new LightData();
light.color = Color.FromArgb((int)meshData.color[0], (int)meshData.color[1], (int)meshData.color[2]);
light.aabb = new TgcBoundingBox(TgcParserUtils.float3ArrayToVector3(meshData.pMin), TgcParserUtils.float3ArrayToVector3(meshData.pMax));
light.pos = light.aabb.calculateBoxCenter();
lights.Add(light);
}
//Es un mesh real, agregar a array definitivo
else
{
realMeshData.Add(meshData);
}
}
//Reemplazar array original de meshData de sceneData por el definitivo
sceneData.meshesData = realMeshData.ToArray();
//Ahora si cargar meshes reales
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadScene(sceneData, mediaPath);
//Separar meshes con bumpMapping de los comunes
bumpMeshes = new List<TgcMeshBumpMapping>();
commonMeshes = new List<TgcMesh>();
foreach (TgcMesh mesh in scene.Meshes)
{
//Mesh con BumpMapping
if (mesh.Layer == "BumpMap")
{
//Por convencion de este ejemplo el NormalMap se llama igual que el DiffuseMap (y cada mesh tiene una sola)
string path = mesh.DiffuseMaps[0].FilePath;
string[] split = path.Split('.');
path = split[0] + "_NormalMap.png";
//Convertir TgcMesh a TgcMeshBumpMapping
TgcTexture normalMap = TgcTexture.createTexture(path);
TgcTexture[] normalMapArray = new TgcTexture[] { normalMap };
TgcMeshBumpMapping bumpMesh = TgcMeshBumpMapping.fromTgcMesh(mesh, normalMapArray);
bumpMesh.Effect = effect;
bumpMesh.Technique = "EnvironmentMapTechnique";
bumpMeshes.Add(bumpMesh);
//Liberar original
mesh.dispose();
}
//Mesh normal
else
{
commonMeshes.Add(mesh);
}
}
//Camara en 1ra persona
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(0, 50, 100), new Vector3(0, 50, -1));
//Modifiers
GuiController.Instance.Modifiers.addBoolean("lightEnable", "lightEnable", true);
GuiController.Instance.Modifiers.addFloat("reflection", 0, 1, 0.2f);
GuiController.Instance.Modifiers.addFloat("bumpiness", 0, 2, 1f);
GuiController.Instance.Modifiers.addFloat("lightIntensity", 0, 150, 20);
GuiController.Instance.Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.3f);
GuiController.Instance.Modifiers.addFloat("specularEx", 0, 20, 9f);
GuiController.Instance.Modifiers.addColor("mEmissive", Color.Black);
GuiController.Instance.Modifiers.addColor("mAmbient", Color.White);
GuiController.Instance.Modifiers.addColor("mDiffuse", Color.White);
GuiController.Instance.Modifiers.addColor("mSpecular", Color.White);
}
protected void configure(float radius, Color color, TgcTexture texture, Vector3 center)
{
this.autoTransformEnable = true;
this.transform = Matrix.Identity;
this.translation = center;
this.rotation = new Vector3(0, 0, 0);
this.enabled = true;
this.scale = new Vector3(1, 1, 1);
this.alphaBlendEnable = false;
this.uvOffset = new Vector2(0, 0);
//BoundingSphere
boundingSphere = new TgcBoundingSphere();
//Shader
this.effect = GuiController.Instance.Shaders.VariosShader;
//Tipo de vertice y technique
if (texture != null) this.setTexture(texture);
else this.setColor(color);
basePoly = eBasePoly.ICOSAHEDRON;
levelOfDetail = 2;
inflate = true;
ForceUpdate = false;
uvTiling = new Vector2(1, 1);
}
/// <summary>
/// Configurar textura de la esfera y setea la technique POSITION_TEXTURED.
/// </summary>
public virtual void setTexture(TgcTexture texture)
{
if (this.texture != null) this.texture.dispose();
this.texture = texture;
this.technique = TgcShaders.T_POSITION_TEXTURED;
}
public override void init()
{
//GuiController.Instance: acceso principal a todas las herramientas del Framework
enemigos = new List<Barco>();
terminoJuego = false;
//Device de DirectX para crear primitivas
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Activamos el renderizado customizado. De esta forma el framework nos delega control total sobre como dibujar en pantalla
//La responsabilidad cae toda de nuestro lado
GuiController.Instance.CustomRenderEnabled = true;
g_pCubeMapAgua = TextureLoader.FromCubeFile(d3dDevice, GuiController.Instance.ExamplesMediaDir + "Shaders\\CubeMap.dds");
//sol = TgcBox.fromSize(new Vector3(50, 50, 50), Color.LightYellow);
//Cargo la escena completa que tendria que ser la del escenario con el cielo / la del agua
//PROXIMAMENTE, ahora cargo otro escenario
//Pruebo postprocess lluvia
CustomVertex.PositionTextured[] screenQuadVertices = new CustomVertex.PositionTextured[]
{
new CustomVertex.PositionTextured( -1, 1, 1, 0,0),
new CustomVertex.PositionTextured(1, 1, 1, 1,0),
new CustomVertex.PositionTextured(-1, -1, 1, 0,1),
new CustomVertex.PositionTextured(1,-1, 1, 1,1)
};
//vertex buffer de los triangulos
screenQuadVB = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
screenQuadVB.SetData(screenQuadVertices, 0, LockFlags.None);
//Creamos un Render Targer sobre el cual se va a dibujar la pantalla
renderTarget2D = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
//Cargar shader con efectos de Post-Procesado
effectlluvia = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\PostProcess.fx");
//Configurar Technique dentro del shader
effectlluvia.Technique = "AlarmaTechnique";
//Cargar textura que se va a dibujar arriba de la escena del Render Target
alarmTexture = TgcTexture.createTexture(d3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\rain.png");
//Interpolador para efecto de variar la intensidad de la textura de alarma
intVaivenAlarm = new InterpoladorVaiven();
intVaivenAlarm.Min = 0;
intVaivenAlarm.Max = 2;
intVaivenAlarm.Speed = 10;
intVaivenAlarm.reset();
//Modifier para activar/desactivar efecto de alarma
GuiController.Instance.Modifiers.addBoolean("activar_efecto", "Activar efecto", true);
//termina post process
//inicio//
spriteFondo = new TgcSprite();
spriteFondo.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\MenuPrincipal.jpg");
Size screenSize = GuiController.Instance.Panel3d.Size;
Size textureSize = spriteFondo.Texture.Size;
spriteFondo.Scaling = new Vector2(1f, 0.8f);
spriteFondo.Position = new Vector2(FastMath.Max(screenSize.Width / 2 - textureSize.Width / 2, 0), FastMath.Max(screenSize.Height / 2 - textureSize.Height / 2, 0));
spriteLetras = new TgcSprite();
spriteLetras.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\Texto.png");
spriteInicio = new TgcSprite();
spriteInicio.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\inicio.png");
spriteLetras.Scaling = new Vector2(0.4f*1.65f, 0.3f*1.65f);
Size textureSize2 = spriteLetras.Texture.Size;
spriteInicio.Scaling = new Vector2(0.4f, 0.3f);
Size textureSize3 = spriteInicio.Texture.Size;
spriteTermino = new TgcSprite();
spriteTermino.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\termino.png");
//spriteTermino.Scaling = new Vector2(0.5f,0.5f);
spriteTermino.Position = new Vector2(screenSize.Width / 4, screenSize.Height / 2);
spriteLetras.Position = new Vector2(FastMath.Max(screenSize.Width / 2 - textureSize2.Width / 2, 0), FastMath.Max(screenSize.Height / 2 - textureSize2.Height / 2, 0));
spriteLetras.Position = new Vector2(spriteLetras.Position.X + 110, spriteLetras.Position.Y);
spriteInicio.Position = new Vector2(FastMath.Max(screenSize.Width / 2 - textureSize3.Width / 2, 0), FastMath.Max(screenSize.Height / 2 - textureSize3.Height / 2, 0));
spriteInicio.Position = new Vector2(spriteInicio.Position.X + 210, spriteLetras.Position.Y+95);
spriteMinimapa = new TgcSprite();
spriteMinimapa.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\minimapa.png");
spriteMinimapa.Scaling = new Vector2(0.2f, 0.2f);
Size minimapSize = spriteMinimapa.Texture.Size;
spriteMinimapa.Position = new Vector2(FastMath.Max(screenSize.Width - 210, 0), FastMath.Max(screenSize.Height - minimapSize.Height , 0));
spriteBarcoPrincipal = new TgcSprite();
spriteBarcoPrincipal.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\pointgreen.png");
spriteBarcoPrincipal.Scaling = new Vector2(0.5f,0.5f);
//inicio//
//ui
sprBarraVida = new TgcSprite();
sprBarraVida.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\BarraVacia.png");
Size textureSize4 = sprBarraVida.Texture.Size;
sprBarraVida.Scaling = new Vector2(1f, 1f);
sprBarraVida.Position = new Vector2(1, 1);
sprVidaLLena = new TgcSprite();
sprVidaLLena.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\vidallena.png");
Size textureSize5 = sprVidaLLena.Texture.Size;
sprVidaLLena.Scaling = new Vector2(1f, 1f);
sprVidaLLena.Position = new Vector2(1, 15);
//ui
Bitmap b = (Bitmap)Bitmap.FromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\wallhaven-276951.jpg"); //"water_water_0056_01_preview.jpg");
b.RotateFlip(RotateFlipType.Rotate90FlipX);
textura = Texture.FromBitmap(d3dDevice, b, Usage.None, Pool.Managed);
b = (Bitmap)Bitmap.FromFile(GuiController.Instance.ExamplesMediaDir
+ "Shaders\\BumpMapping_DiffuseMap.jpg");
diffuseMapTexture = Texture.FromBitmap(d3dDevice, b, Usage.None, Pool.Managed);
oceano = new SmartTerrain();
//oceano.loadHeightmap(GuiController.Instance.ExamplesMediaDir + "Heighmaps\\" + "TerrainTexture1-256x256.jpg", 30.00f, 1.0f, new Vector3(0, 0, 0));
oceano.loadPlainHeightmap(256, 256, 0, 50.0f, 1.0f, new Vector3(0, 0, 0));
oceano.loadTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\water_water_0056_01_preview.jpg");
TgcSceneLoader loader = new TgcSceneLoader();
//escena = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Isla\\Isla-TgcScene.xml");
//Textura del skybox
string texturesPath = GuiController.Instance.ExamplesMediaDir + "Texturas\\Quake\\SkyBox LostAtSeaDay\\";
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(10000, 10000, 10000);
//Configurar color
//skyBox.Color = Color.OrangeRed;
//Configurar las texturas para cada una de las 6 caras
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "lostatseaday_up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "lostatseaday_dn.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "lostatseaday_lf.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "lostatseaday_rt.jpg");
//Hay veces es necesario invertir las texturas Front y Back si se pasa de un sistema RightHanded a uno LeftHanded
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "lostatseaday_bk.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "lostatseaday_ft.jpg");
//Actualizar todos los valores para crear el SkyBox
skyBox.updateValues();
//Cargo el mesh del/los barco/s -> porque se carga como escena y no cargo el mesh directamente?
TgcScene scene2 = loader.loadSceneFromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\Boteconcañon\\BoteConCanion-TgcScene.xml");
mainMesh = scene2.Meshes[0];
mainMesh.Position = new Vector3(-200f,0f, 200f);
mainMesh.Scale = new Vector3(2f,2f,2f);
TgcScene scene4 = loader.loadSceneFromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\Boteconcañon\\BoteConCanion-TgcScene.xml");
meshBot = scene4.Meshes[0];
meshBot.Position = new Vector3(-200f,0f,200f);
meshBot.Scale = new Vector3(1.8f, 1.8f, 1.8f);
TgcScene scene3 = loader.loadSceneFromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\Hacha\\Bala-TgcScene.xml");
balaMesh1 = scene3.Meshes[0];
TgcScene scene5 = loader.loadSceneFromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\Hacha\\Hacha-TgcScene.xml");
balaMesh2 = scene5.Meshes[0];
barcoPrincipal = new BarcoPlayer(150, 50, VELOCIDAD_MOVIMIENTO, ACELERACION, VELOCIDAD_ROTACION, mainMesh, 0.06, loader,balaMesh2);
//pongo enemigos
int rows = 12;
float offset = 3000;
for (int i = 0; i < rows; i++)
{
//Crear instancia de modelo
TgcMesh instance = meshBot.createMeshInstance(meshBot.Name + i + "_" );
//Desplazarlo
instance.move(offset * (FastMath.Cos((float)i * 0.523599f)),0,offset * FastMath.Sin((float)i * 0.523599f));
instance.Scale = new Vector3(1.5f, 1.5f, 1.5f);
var barcoenem = new BarcoBot(100, 10, 100, ACELERACION, 18, instance, 0.05, barcoPrincipal, loader,balaMesh1);
barcoenem.Mesh.Effect = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\shader_bote.fx"); //efectosAguaIluminacion;
barcoenem.Mesh.Technique = GuiController.Instance.Shaders.getTgcMeshTechnique(barcoenem.Mesh.RenderType);//"EnvironmentMapTechnique";
barcoenem.BarcosEnemigos = new List<Barco>();
barcoenem.BarcosEnemigos.Add(barcoPrincipal);
enemigos.Add(barcoenem);
}
//TgcScene scene3 = loader.loadSceneFromFile(GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Media\\Piso\\Agua-TgcScene.xml");
//agua = scene3.Meshes[0];
//agua.Scale = new Vector3(25f, 1f, 25f);
//agua.Position = new Vector3(0f, 0f, 0f);
efectosAguaIluminacion = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\shader_agua.fx");
oceano.Effect = efectosAguaIluminacion;
oceano.Technique = "RenderAgua";//"EnvironmentMapTechnique"; //"RenderAgua";
oceano.AlphaBlendEnable = true;
//barcoEnemigo = new BarcoBot(100, 35,100, ACELERACION, 18, meshBot, 0.05,barcoPrincipal,loader);
barcoPrincipal.BarcosEnemigos = enemigos;
// iluminacion en los barcos
barcoPrincipal.Mesh.Effect = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "quicksort\\shader_bote.fx");//GuiController.Instance.Shaders.TgcMeshPointLightShader;// efectosAguaIluminacion; //GuiController.Instance.Shaders.TgcMeshPointLightShader;// efectosAguaIluminacion;
barcoPrincipal.Mesh.Technique = GuiController.Instance.Shaders.getTgcMeshTechnique(barcoPrincipal.Mesh.RenderType); //"EnvironmentMapTechnique";
//barcoEnemigo.Mesh.Effect = GuiController.Instance.Shaders.TgcMeshPointLightShader; //efectosAguaIluminacion;
//barcoEnemigo.Mesh.Technique = GuiController.Instance.Shaders.getTgcMeshTechnique(barcoEnemigo.Mesh.RenderType);//"EnvironmentMapTechnique";
//Camara en tercera persona focuseada en el barco (canoa)
//PARA DESARROLLO DEL ESCENARIO ES MEJOR MOVERSE CON ESTA CAMARA
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.Velocity = new Vector3(0.0f,0.0f,0.0f);
GuiController.Instance.FpsCamera.JumpSpeed = 0f;
GuiController.Instance.FpsCamera.setCamera(new Vector3(0f,700f,-2300f), new Vector3(900f, 100f, -300f));
GuiController.Instance.ThirdPersonCamera.rotateY(Geometry.DegreeToRadian(180));
////GuiController.Instance.Fog.Enabled = true;
//GuiController.Instance.Modifiers.addFloat("reflection", 0, 1, 0.35f);
//GuiController.Instance.Modifiers.addVertex3f("lightPos", new Vector3(-3000, 0, -3000), new Vector3(3000, 3000, 3000), new Vector3(-300, 1500, 3000));
GuiController.Instance.Modifiers.addColor("lightColor", Color.LightYellow);
//GuiController.Instance.Modifiers.addFloat("bumpiness", 0, 1, 1f);
GuiController.Instance.Modifiers.addFloat("lightIntensity", 0, 500, 150);
GuiController.Instance.Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.1f);
GuiController.Instance.Modifiers.addFloat("specularEx", 0, 100, 20f);
GuiController.Instance.Modifiers.addColor("mEmissive", Color.Black);
GuiController.Instance.Modifiers.addColor("mAmbient", Color.White);
GuiController.Instance.Modifiers.addColor("mDiffuse", Color.White);
GuiController.Instance.Modifiers.addColor("mSpecular", Color.White);
//Carpeta de archivos Media del alumno
//string alumnoMediaFolder = GuiController.Instance.AlumnoEjemplosMediaDir;
Mapa.oceano_mesh = oceano;
}
/// <summary>
/// Carga una textura como parámetro de un Shader
/// </summary>
/// <param name="effect">Shader</param>
/// <param name="parameterName">Nombre del parámetro en el Shader</param>
/// <param name="texture">Textura a aplicar</param>
public void shaderSet(Effect effect, string parameterName, TgcTexture texture)
{
effect.SetValue(parameterName, texture.D3dTexture);
}
/// <summary>
/// Carga una textura en el Stage especificado.
/// Si la textura es null, es similar aa hacer clear()
/// </summary>
/// <param name="stage">Stage en el cual configurar la textura</param>
/// <param name="texture">Textura a configurar</param>
public void set(int stage, TgcTexture texture)
{
GuiController.Instance.D3dDevice.SetTexture(stage, texture.d3dTexture);
}
/// <summary>
/// Crear un TgcMeshBumpMapping en base a un TgcMesh y su normalMap.
/// Solo esta soportado un TgcMehs MeshRenderType = DiffuseMap
/// </summary>
public static TgcMeshBumpMapping fromTgcMesh(TgcMesh mesh, TgcTexture[] normalMaps)
{
if (mesh.RenderType != MeshRenderType.DIFFUSE_MAP)
{
throw new Exception("Solo esta soportado MeshRenderType = DiffuseMap");
}
//Obtener vertexBuffer original
TgcSceneLoader.DiffuseMapVertex[] origVertexBuffer = (TgcSceneLoader.DiffuseMapVertex[])mesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), LockFlags.ReadOnly, mesh.D3dMesh.NumberVertices);
mesh.D3dMesh.UnlockVertexBuffer();
//Crear nuevo Mesh de DirectX
int triCount = origVertexBuffer.Length / 3;
Mesh d3dMesh = new Mesh(triCount, origVertexBuffer.Length, MeshFlags.Managed, BumpMappingVertexElements, GuiController.Instance.D3dDevice);
//Calcular normales recorriendo los triangulos
Vector3[] normals = new Vector3[origVertexBuffer.Length];
for (int i = 0; i < normals.Length; i++)
{
normals[i] = new Vector3(0, 0, 0);
}
for (int i = 0; i < triCount; i++)
{
//Los 3 vertices del triangulo
TgcSceneLoader.DiffuseMapVertex v1 = origVertexBuffer[i * 3];
TgcSceneLoader.DiffuseMapVertex v2 = origVertexBuffer[i * 3 + 1];
TgcSceneLoader.DiffuseMapVertex v3 = origVertexBuffer[i * 3 + 2];
//Face-normal (left-handend)
Vector3 a = v2.Position - v1.Position;
Vector3 b = v3.Position - v1.Position;
Vector3 n = Vector3.Cross(a, b);
//Acumular normal del vertice segun todas sus Face-normal
normals[i * 3] += n;
normals[i * 3 + 1] += n;
normals[i * 3 + 2] += n;
}
//Normalizar normales
for (int i = 0; i < normals.Length; i++)
{
normals[i] = Vector3.Normalize(normals[i]);
}
//Crear nuevo VertexBuffer
using (VertexBuffer vb = d3dMesh.VertexBuffer)
{
//Iterar sobre triangulos
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int i = 0; i < triCount; i++)
{
//Vertices originales
TgcSceneLoader.DiffuseMapVertex vOrig1 = origVertexBuffer[i * 3];
TgcSceneLoader.DiffuseMapVertex vOrig2 = origVertexBuffer[i * 3 + 1];
TgcSceneLoader.DiffuseMapVertex vOrig3 = origVertexBuffer[i * 3 + 2];
//Nuevo vertice 1
BumpMappingVertex v1 = new BumpMappingVertex();
v1.Position = vOrig1.Position;
v1.Color = vOrig1.Color;
v1.Tu = vOrig1.Tu;
v1.Tv = vOrig1.Tv;
v1.Normal = normals[i * 3];
//Nuevo vertice 2
BumpMappingVertex v2 = new BumpMappingVertex();
v2.Position = vOrig2.Position;
v2.Color = vOrig2.Color;
v2.Tu = vOrig2.Tu;
v2.Tv = vOrig2.Tv;
v2.Normal = normals[i * 3 + 1];
//Nuevo vertice 3
BumpMappingVertex v3 = new BumpMappingVertex();
v3.Position = vOrig3.Position;
v3.Color = vOrig3.Color;
v3.Tu = vOrig3.Tu;
v3.Tv = vOrig3.Tv;
v3.Normal = normals[i * 3 + 2];
//Calcular tangente y binormal para todo el triangulo y cargarlas en cada vertice
Vector3 tangent;
Vector3 binormal;
TgcMeshBumpMapping.computeTangentBinormal(v1, v2, v3, out tangent, out binormal);
v1.Tangent = tangent;
v1.Binormal = binormal;
v2.Tangent = tangent;
v2.Binormal = binormal;
v3.Tangent = tangent;
v3.Binormal = binormal;
//Cargar VertexBuffer
data.Write(v1);
data.Write(v2);
data.Write(v3);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = d3dMesh.IndexBuffer)
{
short[] indices = new short[origVertexBuffer.Length];
for (int i = 0; i < indices.Length; i++)
{
indices[i] = (short)i;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Clonar texturas y materials
TgcTexture[] diffuseMaps = new TgcTexture[mesh.DiffuseMaps.Length];
Material[] materials = new Material[mesh.Materials.Length];
for (int i = 0; i < mesh.DiffuseMaps.Length; i++)
{
diffuseMaps[i] = mesh.DiffuseMaps[i].clone();
materials[i] = TgcD3dDevice.DEFAULT_MATERIAL;
}
//Cargar attributeBuffer
if (diffuseMaps.Length > 1)
{
int[] origAttributeBuffer = mesh.D3dMesh.LockAttributeBufferArray(LockFlags.None);
int[] newAttributeBuffer = d3dMesh.LockAttributeBufferArray(LockFlags.None);
Array.Copy(origAttributeBuffer, newAttributeBuffer, origAttributeBuffer.Length);
mesh.D3dMesh.UnlockAttributeBuffer();
d3dMesh.UnlockAttributeBuffer(newAttributeBuffer);
}
//Crear mesh de BumpMapping Mesh
TgcMeshBumpMapping bumpMesh = new TgcMeshBumpMapping(d3dMesh, mesh.Name, mesh.RenderType);
bumpMesh.diffuseMaps = diffuseMaps;
bumpMesh.materials = materials;
bumpMesh.normalMaps = normalMaps;
bumpMesh.layer = mesh.Layer;
bumpMesh.alphaBlendEnable = mesh.AlphaBlendEnable;
bumpMesh.UserProperties = mesh.UserProperties;
bumpMesh.boundingBox = mesh.BoundingBox.clone();
bumpMesh.enabled = true;
return bumpMesh;
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcSkeletalMesh crearMeshDiffuseMap(TgcSkeletalLoaderMaterialAux[] materialsArray, TgcSkeletalMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, DiffuseMapVertexElements, device);
//Cargar esqueleto
TgcSkeletalBone[] bones = loadSkeleton(meshData);
TgcSkeletalVertexWeight[] verticesWeights = loadVerticesWeights(meshData, bones);
//Cargar VertexBuffer
using (VertexBuffer vb = mesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < meshData.coordinatesIndices.Length; j++)
{
DiffuseMapVertex v = new DiffuseMapVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//texture coordinates diffuseMap
int texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
int colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
//normal
if (meshData.verticesNormals != null)
{
v.Normal = new Vector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
else
{
v.Normal = new Vector3(0, 0, 0);
}
//tangent
if (meshData.verticesTangents != null)
{
v.Tangent = new Vector3(
meshData.verticesTangents[coordIdx],
meshData.verticesTangents[coordIdx + 1],
meshData.verticesTangents[coordIdx + 2]
);
}
else
{
v.Tangent = new Vector3(0, 0, 0);
}
//binormal
if (meshData.verticesBinormals != null)
{
v.Binormal = new Vector3(
meshData.verticesBinormals[coordIdx],
meshData.verticesBinormals[coordIdx + 1],
meshData.verticesBinormals[coordIdx + 2]
);
}
else
{
v.Binormal = new Vector3(0, 0, 0);
}
//BlendWeights y BlendIndices
TgcSkeletalVertexWeight vWeight = verticesWeights[meshData.coordinatesIndices[j]];
vWeight.createVector4WeightsAndIndices(out v.BlendWeights, out v.BlendIndices);
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[meshData.coordinatesIndices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
TgcSkeletalLoaderMaterialAux matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new Material[] { matAux.materialId };
meshTextures = new TgcTexture[] { matAux.texture };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
int[] attributeBuffer = mesh.LockAttributeBufferArray(LockFlags.None);
Array.Copy(meshData.materialsIds, attributeBuffer, attributeBuffer.Length);
mesh.UnlockAttributeBuffer(attributeBuffer);
//Cargar array de Materials y Texturas
meshMaterials = new Material[matAux.subMaterials.Length];
meshTextures = new TgcTexture[matAux.subMaterials.Length];
for (int m = 0; m < matAux.subMaterials.Length; m++)
{
meshMaterials[m] = matAux.subMaterials[m].materialId;
meshTextures[m] = matAux.subMaterials[m].texture;
}
}
//Crear mesh de TGC
TgcSkeletalMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcSkeletalMesh.MeshRenderType.DIFFUSE_MAP, bones);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return tgcMesh;
}
/// <summary>
/// Crea una esfera con radio, textura y posicion del centro.
/// </summary>
/// <param name="radius"></param>
/// <param name="texture"></param>
/// <param name="center"></param>
public TgcSphere(float radius, TgcTexture texture, Vector3 center)
{
this.configure(radius, Color.White, texture, center);
}
/// <summary>
/// Configurar textura de la pared
/// </summary>
public void setTexture(TgcTexture texture)
{
if (this.texture != null)
{
this.texture.dispose();
}
this.texture = texture;
this.technique = TgcShaders.T_POSITION_COLORED_TEXTURED;
}
/// <summary>
/// Liberar los recursos de la esfera
/// </summary>
public virtual void dispose()
{
if (texture != null)
{
texture.dispose();
texture = null;
}
if (vertexBuffer != null && !vertexBuffer.Disposed) vertexBuffer.Dispose();
if (indexBuffer != null && !indexBuffer.Disposed) indexBuffer.Dispose();
boundingSphere.dispose();
}
/// <summary>
/// Crea una caja con el centro y tamaño especificado, con la textura especificada
/// </summary>
/// <param name="center">Centro de la caja</param>
/// <param name="size">Tamaño de la caja</param>
/// <param name="texture">Textura de la caja</param>
/// <returns>Caja creada</returns>
public static TgcBox fromSize(Vector3 center, Vector3 size, TgcTexture texture)
{
TgcBox box = TgcBox.fromSize(center, size);
box.setTexture(texture);
return box;
}
/// <summary>
/// Configurar textura de la pared
/// </summary>
public void setTexture(TgcTexture texture)
{
if (this.texture != null)
{
this.texture.dispose();
}
this.texture = texture;
}
/// <summary>
/// Crea una caja con centro (0,0,0) y el tamaño especificado, con la textura especificada
/// </summary>
/// <param name="size">Tamaño de la caja</param>
/// <param name="texture">Textura de la caja</param>
/// <returns>Caja creada</returns>
public static TgcBox fromSize(Vector3 size, TgcTexture texture)
{
return TgcBox.fromSize(new Vector3(0, 0, 0), size, texture);
}
/// <summary>
/// Setea la textura
/// </summary>
public void setTexture(TgcTexture _texture)
{
if (this.texture != null)
this.texture.dispose();
this.texture = _texture;
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcMesh crearMeshDiffuseMap(TgcSceneLoaderMaterialAux[] materialsArray, TgcMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, DiffuseMapVertexElements, device);
//Cargar VertexBuffer
using (VertexBuffer vb = mesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < meshData.coordinatesIndices.Length; j++)
{
DiffuseMapVertex v = new DiffuseMapVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//normals
//puede haber una normal compartida para cada vertice del mesh
if (meshData.verticesNormals.Length == meshData.verticesCoordinates.Length)
{
v.Normal = new Vector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
//o una normal propia por cada vertice de cada triangulo (version mejorada del exporter)
else
{
int normalIdx = j * 3;
v.Normal = new Vector3(
meshData.verticesNormals[normalIdx],
meshData.verticesNormals[normalIdx + 1],
meshData.verticesNormals[normalIdx + 2]
);
}
//texture coordinates diffuseMap
int texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
int colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[meshData.coordinatesIndices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
TgcSceneLoaderMaterialAux matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new Material[] { matAux.materialId };
meshTextures = new TgcTexture[] { TgcTexture.createTexture(device, matAux.textureFileName, matAux.texturePath) };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
int[] attributeBuffer = mesh.LockAttributeBufferArray(LockFlags.None);
Array.Copy(meshData.materialsIds, attributeBuffer, attributeBuffer.Length);
mesh.UnlockAttributeBuffer(attributeBuffer);
//Cargar array de Materials y Texturas
meshMaterials = new Material[matAux.subMaterials.Length];
meshTextures = new TgcTexture[matAux.subMaterials.Length];
for (int m = 0; m < matAux.subMaterials.Length; m++)
{
meshMaterials[m] = matAux.subMaterials[m].materialId;
meshTextures[m] = TgcTexture.createTexture(device, matAux.subMaterials[m].textureFileName, matAux.subMaterials[m].texturePath);
}
}
//Crear mesh de TGC
TgcMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return(tgcMesh);
}
public override void setTexture(TgcTexture texture, int slot)
{
mesh.setTexture(texture);
}
/// <summary>
/// Crea una caja en base al punto minimo y maximo, con el color especificado
/// </summary>
/// <param name="pMin">Punto mínimo</param>
/// <param name="pMax">Punto máximo</param>
/// <param name="texture">Textura de la caja</param>
/// <returns>Caja creada</returns>
public static TgcBox fromExtremes(Vector3 pMin, Vector3 pMax, TgcTexture texture)
{
TgcBox box = TgcBox.fromExtremes(pMin, pMax);
box.setTexture(texture);
return box;
}
