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