public Ship(Vector3 pos, TgcMesh mesh, Canion canion) { Vector3 size = new Vector3(15, 10, 30); this.mesh = mesh; this.mesh.Position = pos; movZ = pos.Z; movY = pos.Y; movX = pos.X; traslacion = Matrix.Translation(pos); movementSpeed = 0f; this.mesh.AutoTransformEnable = false; vida = VIDA_MAX; timer = new TimerFinito(5); // Calcular dimensiones Vector3 BoundingBoxSize = mesh.BoundingBox.calculateSize(); LargoBote = Math.Abs(BoundingBoxSize.Z); AnchoBote = Math.Abs(BoundingBoxSize.X); AltoBote = Math.Abs(BoundingBoxSize.Y); this.canion = canion; canion.barco = this; iniciarBarra(); }
public void BorrarModelo(TgcMesh modelo) { string[] grillas; string[] posicion; int x; int y; int z; grillas = modelo.UserProperties["gid"].Split('+'); foreach (string grilla in grillas) { posicion = grilla.Split('.'); x = Convert.ToInt32(posicion[0]); y = Convert.ToInt32(posicion[1]); z = Convert.ToInt32(posicion[2]); GrillaRegularNode nodo = grid[x, y, z]; for (int i = 0; i < nodo.Models.Count; i++) { if (nodo.Models[i] == modelo) nodo.Models.RemoveAt(i); } } }
public MeshTranslatedScaledPart(TgcMesh mesh, Vector3 translation, Vector3 scaleFactor) : base(mesh) { Position = _TranslationCurrent = Translation = translation; Scale = scaleFactor.MemberwiseMult(_ItemScale = Item.DefaultScale); ScaleFactor = scaleFactor; }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; //Crear loader TgcSceneLoader loader = new TgcSceneLoader(); //Cargar los mesh: scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\TanqueFuturistaRuedas\\TanqueFuturistaRuedas-TgcScene.xml"); mesh = scene.Meshes[0]; mesh.Scale = new Vector3(0.5f, 0.5f, 0.5f); mesh.Position = new Vector3(0f, 0f, 0f); //Cargar Shader personalizado effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\BasicShader.fx"); // le asigno el efecto a la malla mesh.Effect = effect; // indico que tecnica voy a usar // Hay effectos que estan organizados con mas de una tecnica. mesh.Technique = "RenderScene"; //Centrar camara rotacional respecto a este mesh GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox); time = 0; }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; //Crear loader TgcSceneLoader loader = new TgcSceneLoader(); //Cargar mesh TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Olla\\Olla-TgcScene.xml"); mesh = scene.Meshes[0]; //Crear caja para indicar ubicacion de la luz lightMesh = TgcBox.fromSize(new Vector3(20, 20, 20), Color.Yellow); //Modifiers de la luz GuiController.Instance.Modifiers.addBoolean("lightEnable", "lightEnable", true); GuiController.Instance.Modifiers.addVertex3f("lightPos", new Vector3(-500, -500, -500), new Vector3(500, 800, 500), new Vector3(0, 500, 0)); GuiController.Instance.Modifiers.addColor("ambient", Color.Gray); GuiController.Instance.Modifiers.addColor("diffuse", Color.Blue); GuiController.Instance.Modifiers.addColor("specular", Color.White); GuiController.Instance.Modifiers.addFloat("specularEx", 0, 40, 20f); //Centrar camara rotacional respecto a este mesh GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox); }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; TgcSceneLoader loader = new TgcSceneLoader(); TgcScene sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Box\\" + "Box-TgcScene.xml"); TgcMesh meshOriginal = sceneOriginal.Meshes[0]; TgcMesh meshInstance1 = new TgcMesh(meshOriginal.Name + "-1", meshOriginal, new Vector3(50, 0, 0), meshOriginal.Rotation, meshOriginal.Scale); meshInstance1.Enabled = true; TgcMesh meshInstance2 = new TgcMesh(meshOriginal.Name + "-2", meshOriginal, new Vector3(100, 0, 0), meshOriginal.Rotation, meshOriginal.Scale); meshInstance2.Enabled = true; meshes = new List<TgcMesh>(); meshes.Add(meshOriginal); meshes.Add(meshInstance1); meshes.Add(meshInstance2); TgcTexture texture = TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Piso\\Textures\\piso2.jpg"); meshOriginal.changeDiffuseMaps(new TgcTexture[] { texture }); GuiController.Instance.FpsCamera.Enable = true; }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; //Cargar mesh TgcSceneLoader loader = new TgcSceneLoader(); mesh = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\LogoTGC\\LogoTGC-TgcScene.xml").Meshes[0]; //Cargar Shader de PhongShading mesh.Effect = GuiController.Instance.Shaders.TgcMeshPhongShader; mesh.Technique = GuiController.Instance.Shaders.getTgcMeshTechnique(mesh.RenderType); //Texto help textHelp = new TgcText2d(); textHelp.Position = new Point(15, 260); textHelp.Size = new Size(500, 100); textHelp.changeFont(new System.Drawing.Font("TimesNewRoman", 16, FontStyle.Regular)); textHelp.Color = Color.Yellow; textHelp.Align = TgcText2d.TextAlign.LEFT; textHelp.Text = "¿Por dónde empezar? Presionar \"H\""; //Help form string helpRtf = File.ReadAllText(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\LogoTGC\\help.rtf"); helpForm = new EjemploDefaultHelpForm(helpRtf); //Camara GuiController.Instance.RotCamera.Enable = true; GuiController.Instance.RotCamera.CameraCenter = new Vector3(0, 0, 0); GuiController.Instance.RotCamera.CameraDistance = 150; GuiController.Instance.BackgroundColor = Color.Black; }
/// <summary> /// Crear a partir de un mesh /// </summary> public static TgcTriangleArray fromMesh(TgcMesh mesh) { TgcTriangleArray triangleArray = new TgcTriangleArray(); Vector3[] vertices = mesh.getVertexPositions(); int triCount = vertices.Length / 3; List<TgcTriangle> triangles = new List<TgcTriangle>(triCount); for (int i = 0; i < triCount; i++) { Vector3 v1 = vertices[i * 3]; Vector3 v2 = vertices[i * 3 + 1]; Vector3 v3 = vertices[i * 3 + 2]; TgcTriangle t = new TgcTriangle(); t.A = v1; t.B = v2; t.C = v3; t.Color = Color.Red; t.updateValues(); triangles.Add(t); } triangleArray.triangles.AddRange(triangles); return triangleArray; }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; string sphere = GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Sphere\\Sphere-TgcScene.xml"; TgcSceneLoader loader = new TgcSceneLoader(); //Cargar modelos para el sol, la tierra y la luna. Son esfereas a las cuales le cambiamos la textura sun = loader.loadSceneFromFile(sphere).Meshes[0]; sun.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesDir + "Transformations\\SistemaSolar\\SunTexture.jpg") }); earth = loader.loadSceneFromFile(sphere).Meshes[0]; earth.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesDir + "Transformations\\SistemaSolar\\EarthTexture.jpg") }); moon = loader.loadSceneFromFile(sphere).Meshes[0]; moon.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesDir + "Transformations\\SistemaSolar\\MoonTexture.jpg") }); //Deshabilitamos el manejo automático de Transformaciones de TgcMesh, para poder manipularlas en forma customizada sun.AutoTransformEnable = false; earth.AutoTransformEnable = false; moon.AutoTransformEnable = false; //Color de fondo GuiController.Instance.BackgroundColor = Color.Black; //Camara en primera persona GuiController.Instance.FpsCamera.Enable = true; GuiController.Instance.FpsCamera.setCamera(new Vector3(705.2938f, 305.347f, -888.1567f), new Vector3(183.6915f, 19.6596f, -84.2204f)); }
public Chispa() { TgcSceneLoader loader = new TgcSceneLoader(); mesh = loader.loadSceneFromFile(sphere).Meshes[0]; mesh.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, Shared.mediaPath + "\\otros\\giallo.png") }); mesh.Scale = new Vector3(0.08f, 0.08f, 0.08f); }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; //Cargar modelo TgcSceneLoader loader = new TgcSceneLoader(); TgcScene scene = loader.loadSceneFromFile( GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\StarWars-ATST\\StarWars-ATST-TgcScene.xml"); mesh = scene.Meshes[0]; //Computar OBB a partir del AABB del mesh. Inicialmente genera el mismo volumen que el AABB, pero luego te permite rotarlo (cosa que el AABB no puede) obb = TgcObb.computeFromAABB(mesh.BoundingBox); //Otra alternativa es computar OBB a partir de sus vertices. Esto genera un OBB lo mas apretado posible pero es una operacion costosa //obb = TgcObb.computeFromPoints(mesh.getVertexPositions()); //Alejar camara rotacional segun tamaño del BoundingBox del objeto GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox); //Modifier para poder rotar y mover el mesh GuiController.Instance.Modifiers.addFloat("rotation", 0, 360, 0); GuiController.Instance.Modifiers.addVertex3f("position", new Vector3(0, 0, 0), new Vector3(50, 50, 50), new Vector3(0, 0, 0)); }
public ObstaculoRigido(string _pathMesh, Vector3 _posicion, Vector3 _escala ) { this.mesh = MeshUtils.loadMesh(_pathMesh); this.mesh.Position = _posicion; this.mesh.Scale = _escala; this.obb = TgcObb.computeFromAABB(this.mesh.BoundingBox); }
public Checkpoint(float x, float z, float y, TgcMesh _modelo) { _modelo.Position = new Vector3(x, y, z); this.modelo = _modelo; this.modelo.Scale = new Vector3(5, 5, 5); this.obb = TgcObb.computeFromAABB(this.modelo.BoundingBox); }
public MeshTemporalRecursivePart(TgcMesh mesh, Int32 snapshots = 100) : base(mesh) { _Last = snapshots - 1; _Snapshots = new Matrix[snapshots]; _DeltaAlpha = .666f / snapshots; }
protected TgcMesh instanceOf(TgcMesh m) { TgcMesh i = m.createMeshInstance(m.Name+m.MeshInstances.Count.ToString()); i.AlphaBlendEnable = m.AlphaBlendEnable; return i; }
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(); }
/// <summary> /// Crear un modelo adjunto a un hueso /// </summary> /// <param name="model">Modelo a adjuntar</param> /// <param name="bone">Hueso al cual adjuntarse</param> /// <param name="offset">Offset desde el cual el modelo sigue al hueso</param> public TgcSkeletalBoneAttach(TgcMesh mesh, TgcSkeletalBone bone, Matrix offset) { this.bone = bone; this.mesh = mesh; this.offset = offset; updateValues(); }
public EnemyShip(Ship player, Vector3 pos, TgcMesh mesh, Canion canion) : base(pos, mesh, canion) { nombre = "ENEMIGO"; this.player = player; anguloRotacion = FastMath.PI / 2; iniciarBarra(); }
public MeshPart(TgcMesh mesh) { Mesh = mesh; mesh.AlphaBlendEnable = true; mesh.AutoTransformEnable = false; mesh.AutoUpdateBoundingBox = false; _Technique = mesh.Technique; }
public MeshTransformedPart(TgcMesh mesh) : base(mesh) { Scale = Item.DefaultScale; Rotation = Item.DefaultRotation; Position = Item.DefaultPosition; RotationMatrix = Item.DefaultRotationMatrix; }
public BarcoBot(int vida, int danio, float velocidad,float aceleracion, float rotacion, TgcMesh mesh, double pot, Barco barcoEnemigo,TgcSceneLoader bm,TgcMesh bala) : base(vida, danio, velocidad, rotacion, mesh,pot,bm,bala) { BarcoEnemigo = barcoEnemigo; LastPos = Mesh.Position; BarcosEnemigos.Add(barcoEnemigo); daniado = false; }
public override void init() { time = 0f; Device d3dDevice = GuiController.Instance.D3dDevice; MyMediaDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Media\\"; MyShaderDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\"; //Crear loader TgcSceneLoader loader = new TgcSceneLoader(); // parallax oclussion scene = loader.loadSceneFromFile(MyMediaDir +"Piso\\Piso-TgcScene.xml"); g_pBaseTexture = TextureLoader.FromFile(d3dDevice, MyMediaDir + "Piso\\Textures\\wood.bmp"); g_pHeightmap = TextureLoader.FromFile(d3dDevice, MyMediaDir + "Piso\\Textures\\four_NM_height.tga"); g_pBaseTexture2 = TextureLoader.FromFile(d3dDevice, MyMediaDir + "Piso\\Textures\\stones.bmp"); g_pHeightmap2 = TextureLoader.FromFile(d3dDevice, MyMediaDir + "Piso\\Textures\\stones_NM_height.tga"); g_pBaseTexture3 = TextureLoader.FromFile(d3dDevice, MyMediaDir + "Piso\\Textures\\rocks.jpg"); g_pHeightmap3 = TextureLoader.FromFile(d3dDevice, MyMediaDir + "Piso\\Textures\\rocks_NM_height.tga"); mesh = scene.Meshes[0]; int[] adj = new int[mesh.D3dMesh.NumberFaces * 3]; mesh.D3dMesh.GenerateAdjacency(0, adj); mesh.D3dMesh.ComputeNormals(adj); //Cargar Shader string compilationErrors; effect = Effect.FromFile(d3dDevice, MyShaderDir + "Parallax.fx", null, null, ShaderFlags.None, null, out compilationErrors); if (effect == null) { throw new Exception("Error al cargar shader. Errores: " + compilationErrors); } GuiController.Instance.Modifiers.addVertex3f("LightDir", new Vector3(-1, -1, -1), new Vector3(1, 1, 1), new Vector3(0, -1, 0)); GuiController.Instance.Modifiers.addFloat("minSample", 1f, 10f, 10f); GuiController.Instance.Modifiers.addFloat("maxSample", 11f, 50f, 50f); GuiController.Instance.Modifiers.addFloat("HeightMapScale", 0.001f, 0.5f, 0.1f); //Centrar camara rotacional respecto a este mesh GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox); GuiController.Instance.RotCamera.CameraCenter = new Vector3(0, 0, 0); GuiController.Instance.RotCamera.CameraDistance = 100; GuiController.Instance.RotCamera.RotationSpeed = 1000f; pom = false; phong = true; nro_textura = 0; }
public override void init() { Device d3dDevice = GuiController.Instance.D3dDevice; TgcBox box = TgcBox.fromSize(new Vector3(10, 10, 10), Color.Red); boxMesh = box.toMesh("box"); box.dispose(); time = 0; }
// Constructor public ObstaculoRigido(float _x, float _z, float _y, float ancho, float alto, float largo, string textura) { TgcBox box = TgcBox.fromSize( new Vector3(_x, _z, _y), //posicion new Vector3(ancho, alto, largo), //tamaño TgcTexture.createTexture(textura)); //Computar OBB a partir del AABB del mesh. Inicialmente genera el mismo volumen que el AABB, pero luego te permite rotarlo (cosa que el AABB no puede) this.obb = TgcObb.computeFromAABB(box.BoundingBox); this.mesh = box.toMesh("caja"); }
public TankPlayer(Vector3 initialPosition, Terrain.Terrain terrain, string scenePath) : base(initialPosition, terrain, scenePath) { var loader = new TgcSceneLoader { MeshFactory = new MeshShaderFactory() }; var turretScene = loader.loadSceneFromFile(Path.Turret); this.turret = turretScene.Meshes[0]; this.turretAngle = 0; this.turret.AutoUpdateBoundingBox = this.turret.AutoTransformEnable = false; }
public Missile(Vector3 tankPosition,Vector3 tankRotation) { var loader = new TgcSceneLoader(); var scene = loader.loadSceneFromFile(Path.TankScene); this.mesh = scene.Meshes[1]; this.mesh.Position = new Vector3(tankPosition.X, tankPosition.Y + ALTURA_CANION, tankPosition.Z); this.mesh.Rotation = new Vector3(tankRotation.X, tankRotation.Y, tankRotation.Z ); this.initialVeticalSpeed = 8f; }
public static TgcMesh getMesh() { if (originalMesh == null) { TgcScene sceneBarril = EscenarioManager.Instance.loader.loadSceneFromFile(GuiController.Instance.AlumnoEjemplosMediaDir + "RenderMan\\modelos\\BarrilPolvora\\BarrilPolvora-TgcScene.xml"); TgcMesh barrilMesh = sceneBarril.Meshes[0]; originalMesh = barrilMesh; } return originalMesh.createMeshInstance("barril"); }
/// <summary> /// Construir un EditablePoly a partir de un mesh /// </summary> public EditablePoly(MeshCreatorControl control, TgcMesh origMesh) { this.control = control; this.currentPrimitive = PrimitiveType.None; this.rectMesh = new SelectionRectangleMesh(); this.selectionList = new List<EditPolyPrimitive>(); this.primitiveRenderer = new PrimitiveRenderer(this); this.translateGizmo = new EditablePolyTranslateGizmo(this); this.deletedTriangles = new List<int>(); loadMesh(origMesh); }
public TgcRTLMesh(TgcMesh parent, Color ambientColor, Color diffuseColor, Color specularColor, float shininess) : base(parent.Name, parent, parent.Position, parent.Rotation, parent.Scale) { this.Enabled = true; material.Ambient = ambientColor; material.Diffuse = diffuseColor; material.Specular = specularColor; material.SpecularSharpness = shininess; //TODO: Autoinicializar el efecto }
/// <summary> /// Crear un nuevo mesh igual /// </summary> /// <param name="cloneName">Nombre del mesh clonado</param> /// <returns>Mesh clonado</returns> public TgcMesh clone(string cloneName) { Device device = GuiController.Instance.D3dDevice; //Clonar D3dMesh Mesh d3dCloneMesh = this.d3dMesh.Clone(MeshFlags.Managed, this.d3dMesh.Declaration, device); //Crear mesh de TGC y cargar atributos generales TgcMesh cloneMesh = new TgcMesh(d3dCloneMesh, cloneName, this.renderType); cloneMesh.Materials = this.Materials; cloneMesh.layer = this.layer; cloneMesh.boundingBox = this.boundingBox.clone(); cloneMesh.alphaBlendEnable = this.alphaBlendEnable; cloneMesh.enabled = true; cloneMesh.autoUpdateBoundingBox = this.autoUpdateBoundingBox; //Transformaciones cloneMesh.translation = this.translation; cloneMesh.rotation = this.rotation; cloneMesh.scale = this.scale; cloneMesh.transform = this.transform; cloneMesh.autoTransformEnable = this.autoTransformEnable; //Clonar userProperties if (this.userProperties != null) { cloneMesh.userProperties = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> entry in this.userProperties) { cloneMesh.userProperties.Add(entry.Key, entry.Value); } } //Clonar DiffuseMaps if (this.diffuseMaps != null) { cloneMesh.diffuseMaps = new TgcTexture[this.diffuseMaps.Length]; for (int i = 0; i < this.diffuseMaps.Length; i++) { cloneMesh.diffuseMaps[i] = this.diffuseMaps[i].clone(); } } //Clonar LightMap if (this.lightMap != null) { cloneMesh.lightMap = this.lightMap.clone(); } return(cloneMesh); }
/// <summary> /// Crear una malla instancia de una original /// </summary> private TgcMesh crearMeshInstance(TgcMeshData meshData, List <TgcMesh> meshes) { TgcMesh originalMesh = meshes[meshData.originalMesh]; Vector3 translation = new Vector3(meshData.position[0], meshData.position[1], meshData.position[2]); Quaternion rotationQuat = new Quaternion(meshData.rotation[0], meshData.rotation[1], meshData.rotation[2], meshData.rotation[3]); Vector3 rotation = quaternionToEuler(rotationQuat); Vector3 scale = new Vector3(meshData.scale[0], meshData.scale[1], meshData.scale[2]); TgcMesh tgcMesh = new TgcMesh(meshData.name, originalMesh, translation, rotation, scale); return(tgcMesh); }
public void mover(LightData luz, TgcMesh meshLuz, float elapsedTime) { Matrix directionRotationMatrix = Matrix.RotationX(FastMath.QUARTER_PI * elapsedTime); luz.direccion.TransformCoordinate(directionRotationMatrix); Matrix trans = Matrix.Translation(meshLuz.Position); Matrix trasp = Matrix.Invert(trans); meshLuz.Transform = Matrix.Multiply(trasp, directionRotationMatrix) * trans * meshLuz.Transform; meshLuz.render(); }
/// <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 una nueva malla que es una instancia de esta malla original /// Reutiliza toda la geometría de la malla original sin duplicarla. /// Solo se puede crear instancias a partir de originales. /// </summary> /// <param name="name">Nombre de la malla</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 createMeshInstance(string name, Vector3 translation, Vector3 rotation, Vector3 scale) { if (this.parentInstance != null) { throw new Exception("No se puede crear una instancia de otra malla instancia. Hay que partir del original."); } //Crear instancia TgcMesh instance = new TgcMesh(name, this, translation, rotation, scale); //BoundingBox instance.boundingBox = new TgcBoundingBox(this.boundingBox.PMin, this.boundingBox.PMax); instance.updateBoundingBox(); instance.enabled = true; return(instance); }
/// <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> /// Cargar datos iniciales /// </summary> protected void initData(Mesh mesh, string name, MeshRenderType renderType) { this.d3dMesh = mesh; this.name = name; this.renderType = renderType; this.enabled = false; this.parentInstance = null; this.meshInstances = new List <TgcMesh>(); this.alphaBlendEnable = false; this.autoTransformEnable = true; this.autoUpdateBoundingBox = true; this.translation = new Vector3(0f, 0f, 0f); this.rotation = new Vector3(0f, 0f, 0f); this.scale = new Vector3(1f, 1f, 1f); this.transform = Matrix.Identity; vertexDeclaration = new VertexDeclaration(mesh.Device, mesh.Declaration); }
/// <summary> /// Carga la escena a partir de un objeto TgcSceneData ya parseado /// </summary> /// <param name="sceneData">Objeto con datos de la escena ya parseados</param> /// <param name="mediaPath">Path a partir del cual hay que buscar los recursos de escena (Texturas, LightMaps, etc.)</param> /// <returns></returns> public TgcScene loadScene(TgcSceneData sceneData, string mediaPath) { TgcScene tgcScene = new TgcScene(sceneData.name, null); //Cargar Texturas TgcSceneLoaderMaterialAux[] materialsArray = new TgcSceneLoaderMaterialAux[sceneData.materialsData.Length]; for (int i = 0; i < sceneData.materialsData.Length; i++) { TgcMaterialData materialData = sceneData.materialsData[i]; string texturesPath = mediaPath + sceneData.texturesDir + "\\"; //Crear StandardMaterial if (materialData.type.Equals(TgcMaterialData.StandardMaterial)) { materialsArray[i] = createTextureAndMaterial(materialData, texturesPath); } //Crear MultiMaterial else if (materialData.type.Equals(TgcMaterialData.MultiMaterial)) { TgcSceneLoaderMaterialAux matAux = new TgcSceneLoaderMaterialAux(); materialsArray[i] = matAux; matAux.subMaterials = new TgcSceneLoaderMaterialAux[materialData.subMaterials.Length]; for (int j = 0; j < materialData.subMaterials.Length; j++) { matAux.subMaterials[j] = createTextureAndMaterial(materialData.subMaterials[j], texturesPath); } } } //Cargar Meshes for (int i = 0; i < sceneData.meshesData.Length; i++) { TgcMeshData meshData = sceneData.meshesData[i]; TgcMesh tgcMesh = null; //Crear malla original if (meshData.instanceType.Equals(TgcMeshData.ORIGINAL)) { //Crear mesh que no tiene Material, con un color simple if (meshData.materialId == -1) { tgcMesh = crearMeshSoloColor(meshData); } //Para los que si tienen Material else { //Crear MeshFormat que soporte LightMaps if (meshData.lightmapEnabled) { tgcMesh = crearMeshDiffuseMapLightmap(sceneData, mediaPath, materialsArray, meshData); } //Formato de Mesh con Textura pero sin Lightmap else { tgcMesh = crearMeshDiffuseMap(materialsArray, meshData); } } } //Crear malla instancia else if (meshData.instanceType.Equals(TgcMeshData.INSTANCE)) { tgcMesh = crearMeshInstance(meshData, tgcScene.Meshes); } //Crear BoundingBox, aprovechar lo que viene del XML o crear uno por nuestra cuenta if (meshData.pMin != null && meshData.pMax != null) { tgcMesh.BoundingBox = new TgcBoundingBox( TgcParserUtils.float3ArrayToVector3(meshData.pMin), TgcParserUtils.float3ArrayToVector3(meshData.pMax), tgcMesh.Position, tgcMesh.Scale ); } else { tgcMesh.createBoundingBox(); } //Cargar layer tgcMesh.Layer = meshData.layerName; //Cargar AlphaBlending tgcMesh.AlphaBlendEnable = meshData.alphaBlending; //agregar mesh a escena tgcMesh.Enabled = true; tgcScene.Meshes.Add(tgcMesh); //Cargar userProperties, si hay tgcMesh.UserProperties = meshData.userProperties; } //BoundingBox del escenario, utilizar el que viene del XML o crearlo nosotros if (sceneData.pMin != null && sceneData.pMax != null) { tgcScene.BoundingBox = new TgcBoundingBox( new Vector3(sceneData.pMin[0], sceneData.pMin[1], sceneData.pMin[2]), new Vector3(sceneData.pMax[0], sceneData.pMax[1], sceneData.pMax[2]) ); } else { List <TgcBoundingBox> boundingBoxes = new List <TgcBoundingBox>(); foreach (TgcMesh mesh in tgcScene.Meshes) { boundingBoxes.Add(mesh.BoundingBox); } tgcScene.BoundingBox = TgcBoundingBox.computeFromBoundingBoxes(boundingBoxes); } //Cargar parte de PortalRendering, solo hay información if (sceneData.portalData != null) { TgcPortalRenderingLoader portalLoader = new TgcPortalRenderingLoader(); tgcScene.PortalRendering = portalLoader.loadFromData(tgcScene, sceneData.portalData); } return(tgcScene); }
/// <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); }
/// <summary> /// Crea un mesh sin texturas, solo con VertexColors /// </summary> /// <param name="meshData"></param> private TgcMesh crearMeshSoloColor(TgcMeshData meshData) { //Crear Mesh Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, VertexColorVertexElements, 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++) { VertexColorVertex v = new VertexColorVertex(); //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] ); } //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 i = 0; i < indices.Length; i++) { indices[i] = (short)i; } ib.SetData(indices, 0, LockFlags.None); } //Crear mesh de TGC TgcMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcMesh.MeshRenderType.VERTEX_COLOR); return(tgcMesh); }
public TgcMesh createNewMeshInstance(string meshName, TgcMesh originalMesh, Vector3 translation, Vector3 rotation, Vector3 scale) { return(new TgcMesh(meshName, originalMesh, translation, rotation, scale)); }
/// <summary> /// Método que se llama una sola vez, al principio cuando se ejecuta el ejemplo. /// Escribir aquí todo el código de inicialización: cargar modelos, texturas, modifiers, uservars, etc. /// Borrar todo lo que no haga falta /// </summary> public override void init() { EjemploAlumno.Instance = this; //GuiController.Instance: acceso principal a todas las herramientas del Framework //Device de DirectX para crear primitivas Device d3dDevice = GuiController.Instance.D3dDevice; //Carpeta de archivos Media del alumno string alumnoMediaFolder = GuiController.Instance.AlumnoEjemplosMediaDir; //Terreno currentHeightmap = GuiController.Instance.AlumnoEjemplosMediaDir + "Heightmap3.jpg"; currentTexture = GuiController.Instance.AlumnoEjemplosMediaDir + "TerrainTexture3.jpg"; terrain = new TerrenoSimple(); terrain.loadHeightmap(currentHeightmap, currentScaleXZ, currentScaleY, new Vector3(0, -125, 0)); terrain.loadTexture(currentTexture); //Agua agua = new TerrenoSimple(); agua.loadHeightmap(GuiController.Instance.AlumnoEjemplosMediaDir + "18_vertex_texture_02.jpg", 50f, 0.5f, new Vector3(0, -125, 0)); agua.loadTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "4141-diffuse.jpg"); agua.AlphaBlendEnable = true; //heightOlas = agua.heightOlas; //Modifier GuiController.Instance.Modifiers.addFloat("heightOlas", 10, 50, 40); //Estado EjemploAlumno.Instance.estado = EstadoDelJuego.SinEmpezar; menu = new Menu(); // Crear SkyBox: skyBox = new TgcSkyBox(); skyBox.Center = new Vector3(0, 0, 0); skyBox.Size = new Vector3(12000, 12000, 12000); skyboxSoleado(skyBox); skyBoundingBox = new TgcBox(); skyBoundingBox.Size = skyBox.Size; skyBoundingBox.Position = skyBox.Center; skyBoundingBox.AlphaBlendEnable = true; skyBoundingBox.updateValues(); lloviendo = false; //Cargar meshes TgcViewer.Utils.TgcSceneLoader.TgcSceneLoader loader = new TgcViewer.Utils.TgcSceneLoader.TgcSceneLoader(); TgcViewer.Utils.TgcSceneLoader.TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Canoa\\Canoa-TgcScene.xml"); meshShip = scene.Meshes[0]; meshShip.setColor(Color.Chocolate); scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Canoa\\Canoa-TgcScene.xml"); meshes.Add(meshShip); meshShipContrincante = scene.Meshes[0]; meshShipContrincante.setColor(Color.BlueViolet); meshes.Add(meshShipContrincante); scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Armas\\Canon\\Canon.max-TgcScene.xml"); meshCanion = scene.Meshes[0]; meshes.Add(meshCanion); scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Armas\\Canon\\Canon.max-TgcScene.xml"); meshCanionContrincante = scene.Meshes[0]; meshes.Add(meshCanionContrincante); //Shader effect = TgcShaders.loadEffect(alumnoMediaFolder + "shader agua.fx"); agua.Effect = effect; agua.Technique = "RenderScene"; time = 0; agua.AlphaBlendEnable = true; efectoSombra = TgcShaders.loadEffect(alumnoMediaFolder + "shader agua.fx"); //Creaciones ship = new Ship(POS_SHIP, meshShip, new Canion(POS_SHIP, 5, meshCanion, true)); shipContrincante = new EnemyShip(ship, POS_CONTRINCANTE, meshShipContrincante, new Canion(POS_CONTRINCANTE, 5, meshCanionContrincante, false)); mainCamera = new MainCamera(ship); //Crear caja para indicar ubicacion de la luz lightMesh = TgcBox.fromSize(new Vector3(20, 20, 20), Color.Yellow); }