public override void Update() { PreUpdate(); var velocidadCaminar = VELOCIDAD_DESPLAZAMIENTO * ElapsedTime; //Calcular proxima posicion de personaje segun Input var moving = false; var movement = TGCVector3.Empty; //Adelante if (Input.keyDown(Key.W)) { movement.Z = velocidadCaminar; moving = true; } //Atras if (Input.keyDown(Key.S)) { movement.Z = -velocidadCaminar; moving = true; } //Derecha if (Input.keyDown(Key.D)) { movement.X = velocidadCaminar; moving = true; } //Izquierda if (Input.keyDown(Key.A)) { movement.X = -velocidadCaminar; moving = true; } //Salto if (Input.keyDown(Key.Space)) { movement.Y = velocidadCaminar; moving = true; } //Agachar if (Input.keyDown(Key.LeftControl)) { movement.Y = -velocidadCaminar; moving = true; } //Si hubo desplazamiento if (moving) { //Aplicar movimiento, internamente suma valores a la posicion actual del mesh. mesh.Position = mesh.Position + movement; mesh.Transform = TGCMatrix.Translation(mesh.Position); mesh.updateBoundingBox(); } //Hacer que la camara siga al personaje en su nueva posicion camaraInterna.Target = mesh.Position; //Detectar colision con triangulo if (TgcCollisionUtils.testTriangleAABB(TGCVector3.FromVector3(triangle[0].Position), TGCVector3.FromVector3(triangle[1].Position), TGCVector3.FromVector3(triangle[2].Position), mesh.BoundingBox)) { triangle[0].Color = Color.Red.ToArgb(); triangle[1].Color = Color.Red.ToArgb(); triangle[2].Color = Color.Red.ToArgb(); } else { triangle[0].Color = Color.Green.ToArgb(); triangle[1].Color = Color.Green.ToArgb(); triangle[2].Color = Color.Green.ToArgb(); } //Detectar colision con el otro AABB if (TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, box2.BoundingBox)) { box2.Color = Color.Red; box2.updateValues(); } else { box2.Color = Color.Violet; box2.updateValues(); } //Detectar colision con la esfera if (TgcCollisionUtils.testSphereAABB(boundingSphere, mesh.BoundingBox)) { boundingSphere.setRenderColor(Color.Red); } else { boundingSphere.setRenderColor(Color.Yellow); } //Detectar colision con la obb if (TgcCollisionUtils.testObbAABB(obb, mesh.BoundingBox)) { obb.setRenderColor(Color.Red); } else { obb.setRenderColor(Color.Yellow); } PostUpdate(); }
public void Update() { var velocidadCaminar = 300f; var velocidadSalto = 100f; var velocidadRotacion = 120f; vectorDesplazamiento = TGCVector3.Empty; vectorColision = TGCVector3.Empty; //Calcular proxima posicion de personaje segun Input var Input = GModel.Input; var moveForward = 0f; var moveJump = 0f; float rotate = 0; var moving = false; var rotating = false; var lastPos = personaje.Position; desplazamientoDePlataforma = TGCVector3.Empty; //Adelante if (Input.keyDown(Key.W)) { moveForward = velocidadCaminar * GModel.ElapsedTime; moving = true; } //Atras if (Input.keyDown(Key.S)) { moveForward = -velocidadCaminar * GModel.ElapsedTime; moving = true; } //Derecha if (Input.keyDown(Key.D)) { rotate = velocidadRotacion; rotating = true; } //Izquierda if (Input.keyDown(Key.A)) { rotate = -velocidadRotacion; rotating = true; } //Si hubo rotacion if (rotating) { //Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware var rotAngle = FastMath.ToRad(rotate * GModel.ElapsedTime); matrizRotacionPersonajeY *= TGCMatrix.RotationY(rotAngle); GModel.camaraInterna.rotateY(rotAngle); anguloDeRotacion += rotAngle; //Ajustar la matriz de rotacion segun el angulo de rotacion (sobre el sentido de la orientacion) //Lo que se desplaza en cada eje depende del angulo de rotacion //Cada componente podria separarse en funcion del seno y coseno orientacion.X = FastMath.Sin(anguloDeRotacion); orientacion.Z = FastMath.Cos(anguloDeRotacion); } if (moving) { //Activar animacion de caminando personaje.playAnimation("Caminando", true); //Ajustar el vector desplazamiento en base a lo que se movio y la orientacion que tiene vectorDesplazamiento.X += moveForward * orientacion.X; vectorDesplazamiento.Z += moveForward * orientacion.Z; } //Si no se esta moviendo, activar animacion de Parado else { personaje.playAnimation("Parado", true); } //----------Salto //Por el momento solamente parece que flota if (Input.keyDown(Key.Space) /*&& colliderY != null*/) { moveJump = velocidadSalto * GModel.ElapsedTime; vectorDesplazamiento.Y += moveJump; } //---------prueba gravedad---------- vectorDesplazamiento.Y += FastMath.Clamp(gravedad * GModel.ElapsedTime, -10, 10); //--------Colision con el piso a nivel triangulo TgcBoundingAxisAlignBox colliderPlano = null; foreach (var obstaculo in GModel.escenario1.getPiso()) { if (TgcCollisionUtils.testAABBAABB(personaje.BoundingBox, obstaculo.BoundingBox)) { colliderPlano = obstaculo.BoundingBox; //No le afecta la gravedad si está en el piso vectorDesplazamiento.Y -= FastMath.Clamp(gravedad * GModel.ElapsedTime, -10, 10); break; } } this.posicion = posicion + vectorDesplazamiento; //Reseteo el vector desplazamiento una vez que lo sume vectorDesplazamiento = TGCVector3.Empty; //---------Colisiones objetos-------------------------- var collide = false; foreach (var obstaculo in GModel.escenario1.getAABBDelEscenario() /*GModel.escenario1.getPared1()*/) { if (TgcCollisionUtils.testAABBAABB(personaje.BoundingBox, obstaculo)) { collide = true; collider = obstaculo; break; } } //Una buena idea seria diferenciar las plataformas del resto de los objetos foreach (var plataforma in GModel.escenario1.getPlataformasDelEscenario()) { if (TgcCollisionUtils.testAABBAABB(personaje.BoundingBox, plataforma)) { collide = true; collider = plataforma; //Pensamos en calcular cuanto se desplaza la plataforma y mandarselo al personaje para que se muevan juntos //Todavia no funciona como esperamos desplazamientoDePlataforma = GModel.escenario1.desplazamientoDePlataforma(collider); break; } } if (collide) { var movementRay = lastPos - posicion; //Cuando choca con algo que se ponga rojo, nos sirve para probar collider.setRenderColor(Color.Red); var rs = TGCVector3.Empty; if (((personaje.BoundingBox.PMax.X > collider.PMax.X && movementRay.X > 0) || (personaje.BoundingBox.PMin.X < collider.PMin.X && movementRay.X < 0)) && ((personaje.BoundingBox.PMax.Z > collider.PMax.Z && movementRay.Z > 0) || (personaje.BoundingBox.PMin.Z < collider.PMin.Z && movementRay.Z < 0)) && ((personaje.BoundingBox.PMax.Y > collider.PMax.Y && movementRay.Y > 0) || (personaje.BoundingBox.PMin.Y < collider.PMin.Y && movementRay.Y < 0))) { if (personaje.Position.X > collider.PMin.X && personaje.Position.X < collider.PMax.X) { //El personaje esta contenido en el bounding X rs = new TGCVector3(movementRay.X, movementRay.Y, 0); } if (personaje.Position.Z > collider.PMin.Z && personaje.Position.Z < collider.PMax.Z) { //El personaje esta contenido en el bounding Z rs = new TGCVector3(0, movementRay.Y, movementRay.Z); } if (personaje.Position.Y > collider.PMin.Y && personaje.Position.Y < collider.PMax.Y) { //El personaje esta contenido en el bounding Y rs = new TGCVector3(movementRay.X, 0, movementRay.Z); } } else { if ((personaje.BoundingBox.PMax.X > collider.PMax.X && movementRay.X > 0) || (personaje.BoundingBox.PMin.X < collider.PMin.X && movementRay.X < 0)) { rs = new TGCVector3(0, movementRay.Y, movementRay.Z); } if ((personaje.BoundingBox.PMax.Z > collider.PMax.Z && movementRay.Z > 0) || (personaje.BoundingBox.PMin.Z < collider.PMin.Z && movementRay.Z < 0)) { rs = new TGCVector3(movementRay.X, movementRay.Y, 0); } if ((personaje.BoundingBox.PMax.Y > collider.PMax.Y && movementRay.Y > 0) || (personaje.BoundingBox.PMin.Y < collider.PMin.Y && movementRay.Y < 0)) { //Si esta sobre un plano XZ tampoco deberia afectarle la gravedad vectorDesplazamiento.Y -= FastMath.Clamp(gravedad * GModel.ElapsedTime, -10, 10); rs = new TGCVector3(movementRay.X, 0, movementRay.Z); } } //El vector rs actua como "freno" al movimiento del personaje //Le "descuento" la gravedad si es que colisiona con el plano XZ personaje.Position = lastPos - rs + new TGCVector3(0, vectorDesplazamiento.Y, 0); posicion = personaje.Position; } personaje.Position = posicion; //Una forma de reiniciar, que se active con R o cuando el personaje muere //Por ahora el personaje muere solamente si su coordenada en Y es inferior a un valor determinado if (Input.keyDown(Key.R) || this.estaMuerto()) { posicion = this.checkpoint; } matrizPosicionamientoPersonaje = TGCMatrix.Translation(posicion /*+ desplazamientoDePlataforma*/); GModel.camaraInterna.Target = GModel.tgcPersonaje.getPosicion(); }
public TGCMatrix CalcularMatriz2(TGCVector3 Pos, TGCVector3 Scale, TGCVector3 Dir, TGCVector3 VUP) { var matWorld = TGCMatrix.Scaling(Scale); matWorld = matWorld * TGCMatrix.RotationY(-(float)Math.PI / 2.0f) * TGCMatrix.RotationYawPitchRoll(yaw, pitch, 0); // determino la orientacion var U = TGCVector3.Cross(VUP, Dir); U.Normalize(); var V = TGCVector3.Cross(Dir, U); V.Normalize(); TGCMatrix Orientacion = new TGCMatrix(); Orientacion.M11 = U.X; Orientacion.M12 = U.Y; Orientacion.M13 = U.Z; Orientacion.M14 = 0; Orientacion.M21 = V.X; Orientacion.M22 = V.Y; Orientacion.M23 = V.Z; Orientacion.M24 = 0; Orientacion.M31 = Dir.X; Orientacion.M32 = Dir.Y; Orientacion.M33 = Dir.Z; Orientacion.M34 = 0; Orientacion.M41 = 0; Orientacion.M42 = 0; Orientacion.M43 = 0; Orientacion.M44 = 1; matWorld = matWorld * Orientacion; // traslado matWorld = matWorld * TGCMatrix.Translation(Pos); return(matWorld); }
/// <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 var origVertexBuffer = (TgcSceneLoader.DiffuseMapVertex[])mesh.D3dMesh.LockVertexBuffer( typeof(TgcSceneLoader.DiffuseMapVertex), LockFlags.ReadOnly, mesh.D3dMesh.NumberVertices); mesh.D3dMesh.UnlockVertexBuffer(); //Crear nuevo Mesh de DirectX var triCount = origVertexBuffer.Length / 3; var d3dMesh = new Mesh(triCount, origVertexBuffer.Length, MeshFlags.Managed, BumpMappingVertexElements, D3DDevice.Instance.Device); //Calcular normales recorriendo los triangulos var normals = new TGCVector3[origVertexBuffer.Length]; for (var i = 0; i < normals.Length; i++) { normals[i] = TGCVector3.Empty; } for (var i = 0; i < triCount; i++) { //Los 3 vertices del triangulo var v1 = origVertexBuffer[i * 3]; var v2 = origVertexBuffer[i * 3 + 1]; var v3 = origVertexBuffer[i * 3 + 2]; //Face-normal (left-handend) var a = v2.Position - v1.Position; var b = v3.Position - v1.Position; var n = TGCVector3.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 (var i = 0; i < normals.Length; i++) { normals[i] = TGCVector3.Normalize(normals[i]); } //Crear nuevo VertexBuffer using (var vb = d3dMesh.VertexBuffer) { //Iterar sobre triangulos var data = vb.Lock(0, 0, LockFlags.None); for (var i = 0; i < triCount; i++) { //Vertices originales var vOrig1 = origVertexBuffer[i * 3]; var vOrig2 = origVertexBuffer[i * 3 + 1]; var vOrig3 = origVertexBuffer[i * 3 + 2]; //Nuevo vertice 1 var 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 var 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 var 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 TGCVector3 tangent; TGCVector3 binormal; 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 (var ib = d3dMesh.IndexBuffer) { var indices = new short[origVertexBuffer.Length]; for (var i = 0; i < indices.Length; i++) { indices[i] = (short)i; } ib.SetData(indices, 0, LockFlags.None); } //Clonar texturas y materials var diffuseMaps = new TgcTexture[mesh.DiffuseMaps.Length]; var materials = new Material[mesh.Materials.Length]; for (var i = 0; i < mesh.DiffuseMaps.Length; i++) { diffuseMaps[i] = mesh.DiffuseMaps[i].Clone(); materials[i] = D3DDevice.DEFAULT_MATERIAL; } //Cargar attributeBuffer if (diffuseMaps.Length > 1) { var origAttributeBuffer = mesh.D3dMesh.LockAttributeBufferArray(LockFlags.None); var newAttributeBuffer = d3dMesh.LockAttributeBufferArray(LockFlags.None); Array.Copy(origAttributeBuffer, newAttributeBuffer, origAttributeBuffer.Length); mesh.D3dMesh.UnlockAttributeBuffer(); d3dMesh.UnlockAttributeBuffer(newAttributeBuffer); } //Crear mesh de BumpMapping Mesh var 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); }
public TgcMesh createNewMeshInstance(string meshName, TgcMesh originalMesh, TGCVector3 translation, TGCVector3 rotation, TGCVector3 scale) { return(new TgcMeshBumpMapping(meshName, originalMesh, translation, rotation, scale)); }
public RigidBody CreatePlane(TgcPlane plane) { var halfSize = new TGCVector3(plane.Size.X / 2, 2000, plane.Size.Z / 2).ToBulletVector3(); return(CreateRigidBody(new TGCVector3(plane.Position.X, plane.Position.Y - 2000, plane.Position.Z), halfSize, 0)); }
/// <summary> /// Mover objeto /// </summary> public abstract void move(TGCVector3 move);
/// <summary> /// Crea una caja con centro (0,0,0) y el tamaño especificado /// </summary> /// <param name="size">Tamaño de la caja</param> /// <returns>Caja creada</returns> public static TGCBox fromSize(TGCVector3 size) { return(fromSize(TGCVector3.Empty, size)); }
/// <summary> /// Crea una caja con centro (0,0,0) y el tamaño especificado, con el color especificado /// </summary> /// <param name="size">Tamaño de la caja</param> /// <param name="color">Color de la caja</param> /// <returns>Caja creada</returns> public static TGCBox fromSize(TGCVector3 size, Color color) { return(fromSize(TGCVector3.Empty, size, color)); }
/// <summary> /// Configurar valores de posicion y tamaño en forma conjunta /// </summary> /// <param name="position">Centro de la caja</param> /// <param name="size">Tamaño de la caja</param> public void setPositionSize(TGCVector3 position, TGCVector3 size) { translation = position; this.size = size; updateBoundingBox(); }
/// <summary> /// Actualiza el BoundingBox de la caja. /// No contempla rotacion /// </summary> private void updateBoundingBox() { var midSize = TGCVector3.Scale(size, 0.5f); BoundingBox.setExtremes(TGCVector3.Subtract(translation, midSize), TGCVector3.Add(translation, midSize)); }
/// <summary> /// Obtiene la posicion absoluta de la malla, recibiendo un vector ya creado para /// almacenar el resultado /// </summary> /// <param name="pos">Vector ya creado en el que se carga el resultado</param> public void GetPosition(TGCVector3 pos) { pos.X = translation.X; pos.Y = translation.Y; pos.Z = translation.Z; }
public void Move(TGCVector3 v) { Move(v.X, v.Y, v.Z); }
public override void Init() { var loader = new TgcSceneLoader(); var scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Meshes\\Vehiculos\\Patrullero\\Patrullero-TgcScene.xml"); mesh = scene.Meshes[0]; mesh.Scale = new TGCVector3(0.25f, 0.25f, 0.25f); //triangulo triangle = new CustomVertex.PositionColored[3]; triangle[0] = new CustomVertex.PositionColored(-100, 0, 0, Color.Green.ToArgb()); triangle[1] = new CustomVertex.PositionColored(0, 0, 50, Color.Green.ToArgb()); triangle[2] = new CustomVertex.PositionColored(0, 100, 0, Color.Green.ToArgb()); triagleAABB = TgcBoundingAxisAlignBox.computeFromPoints(new[] { TGCVector3.FromVector3(triangle[0].Position), TGCVector3.FromVector3(triangle[1].Position), TGCVector3.FromVector3(triangle[2].Position) }); //box2 box2 = TGCBox.fromSize(new TGCVector3(-50, 10, -20), new TGCVector3(15, 15, 15), Color.Violet); //sphere boundingSphere = new TgcBoundingSphere(new TGCVector3(30, 20, -20), 15); //OBB: computar OBB a partir del AABB del mesh. meshObb = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Meshes\\Objetos\\Catapulta\\Catapulta-TgcScene.xml") .Meshes[0]; meshObb.Scale = new TGCVector3(0.1f, 0.1f, 0.1f); meshObb.Position = new TGCVector3(100, 0, 30); meshObb.updateBoundingBox(); //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 = TgcBoundingOrientedBox.computeFromAABB(meshObb.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 = TgcBoundingOrientedBox.computeFromPoints(mesh.getVertexPositions()); //Rotar mesh y rotar OBB. A diferencia del AABB, nosotros tenemos que mantener el OBB actualizado segun cada movimiento del mesh meshObb.Rotation = new TGCVector3(0, FastMath.PI / 4, 0); //Los obb tienen una especie de autotransform aun. obb.rotate(new TGCVector3(0, FastMath.PI / 4, 0)); //Configurar camara en Tercer Persona camaraInterna = new TgcThirdPersonCamera(mesh.Position, 30, -75); Camara = camaraInterna; }
/// <summary> /// Constructor de la camara a partir de un TgcD3dInput y un positionEye. Los atributos mouseCenter a partir del centro del a pantalla, RotationSpeed 1.0f, /// MovementSpeed y JumpSpeed 500f, el directionView (0,0,-1) /// </summary> /// <param name="positionEye"></param> /// <param name="input"></param> public TgcFpsCamera(TGCVector3 positionEye, TgcD3dInput input) : this(input) { this.positionEye = positionEye; }
/// <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(TGCVector3 size, TgcTexture texture) { return(fromSize(TGCVector3.Empty, size, texture)); }
/// <summary> /// Constructor de la camara a partir de un TgcD3dInput y un positionEye, moveSpeed y jumpSpeed. Los atributos mouseCenter a partir del centro del a pantalla, RotationSpeed 1.0f, /// el directionView (0,0,-1) /// </summary> /// <param name="positionEye"></param> /// <param name="moveSpeed"></param> /// <param name="jumpSpeed"></param> /// <param name="input"></param> public TgcFpsCamera(TGCVector3 positionEye, float moveSpeed, float jumpSpeed, TgcD3dInput input) : this(positionEye, input) { this.MovementSpeed = moveSpeed; this.JumpSpeed = jumpSpeed; }
public void Init(string MediaDir) { #region Configuracion Basica de World //Creamos el mundo fisico por defecto. collisionConfiguration = new DefaultCollisionConfiguration(); dispatcher = new CollisionDispatcher(collisionConfiguration); GImpactCollisionAlgorithm.RegisterAlgorithm(dispatcher); constraintSolver = new SequentialImpulseConstraintSolver(); overlappingPairCache = new DbvtBroadphase(); //AxisSweep3(new BsVector3(-5000f, -5000f, -5000f), new BsVector3(5000f, 5000f, 5000f), 8192); dynamicsWorld = new DiscreteDynamicsWorld(dispatcher, overlappingPairCache, constraintSolver, collisionConfiguration); dynamicsWorld.Gravity = new TGCVector3(0, -100f, 0).ToBulletVector3(); #endregion Configuracion Basica de World #region Capsula //Cuerpo rigido de una capsula basica capsuleRigidBody = BulletRigidBodyFactory.Instance.CreateCapsule(10, 50, new TGCVector3(200, 500, 200), 10, false); //Valores que podemos modificar a partir del RigidBody base capsuleRigidBody.SetDamping(0.1f, 0f); capsuleRigidBody.Restitution = 0.1f; capsuleRigidBody.Friction = 1; //Agregamos el RidigBody al World dynamicsWorld.AddRigidBody(capsuleRigidBody); #endregion Capsula #region Terreno //Creamos el RigidBody basico del Terreno var meshRigidBody = BulletRigidBodyFactory.Instance.CreateSurfaceFromHeighMap(triangleDataVB); //Agregamos algo de friccion al RigidBody ya que este va a interactuar con objetos moviles //del World meshRigidBody.Friction = 0.5f; //Agregamos el RigidBody del terreno al World dynamicsWorld.AddRigidBody(meshRigidBody); #endregion Terreno #region Esfera //Creamos una esfera para interactuar pokeball = BulletRigidBodyFactory.Instance.CreateBall(10f, 0.5f, new TGCVector3(100f, 500f, 100f)); pokeball.SetDamping(0.1f, 0.5f); pokeball.Restitution = 1f; //Agregamos la pokebola al World dynamicsWorld.AddRigidBody(pokeball); //Textura de pokebola var texturePokeball = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + @"Texturas\pokeball.jpg"); //Se crea una esfera de tamaño 1 para escalarla luego (en render) sphereMesh = new TGCSphere(1, texturePokeball, TGCVector3.Empty); //Tgc no crea el vertex buffer hasta invocar a update values. sphereMesh.updateValues(); #endregion Esfera #region Personaje //Cargamos personaje var skeletalLoader = new TgcSkeletalLoader(); personaje = skeletalLoader.loadMeshAndAnimationsFromFile( MediaDir + "SkeletalAnimations\\Robot\\Robot-TgcSkeletalMesh.xml", MediaDir + "SkeletalAnimations\\Robot\\", new[] { MediaDir + "SkeletalAnimations\\Robot\\Caminando-TgcSkeletalAnim.xml", MediaDir + "SkeletalAnimations\\Robot\\Parado-TgcSkeletalAnim.xml" }); //Le cambiamos la textura para diferenciarlo un poco personaje.changeDiffuseMaps(new[] { TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + "SkeletalAnimations\\Robot\\Textures\\uvwGreen.jpg") }); //Configurar animacion inicial personaje.playAnimation("Parado", true); #endregion Personaje #region Cajas var sizeBox = 20f; //Textura de caja var textureBox = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + @"MeshCreator\Textures\Madera\cajaMadera2.jpg"); box = BulletRigidBodyFactory.Instance.CreateBox(new TGCVector3(sizeBox, sizeBox, sizeBox), 0, new TGCVector3(0, 12, 0), 0, 0, 0, 0.5f, true); dynamicsWorld.AddRigidBody(box); boxMesh = TGCBox.fromSize(new TGCVector3(40f, 40f, 40f), textureBox); boxMesh.updateValues(); sizeBox = 40f; boxB = BulletRigidBodyFactory.Instance.CreateBox(new TGCVector3(sizeBox, sizeBox, sizeBox), 0, new TGCVector3(100, 40, 0), 0, 0, 0, 0.5f, true); dynamicsWorld.AddRigidBody(boxB); boxMeshB = TGCBox.fromSize(new TGCVector3(80f, 80f, 80f), textureBox); boxMeshB.updateValues(); box45 = BulletRigidBodyFactory.Instance.CreateBox(new TGCVector3(sizeBox, sizeBox, sizeBox), 0, new TGCVector3(200, 40, 0), BulletSharp.MathUtil.SIMD_QUARTER_PI, 0, 0, 0.5f, true); dynamicsWorld.AddRigidBody(box45); boxPush = BulletRigidBodyFactory.Instance.CreateBox(new TGCVector3(sizeBox, sizeBox, sizeBox), 0.5f, new TGCVector3(-200, 60, 0), BulletSharp.MathUtil.SIMD_QUARTER_PI, 0, 0, 0.25f, true); dynamicsWorld.AddRigidBody(boxPush); boxMeshPush = TGCBox.fromSize(new TGCVector3(80f, 80f, 80f), textureBox); boxMeshPush.updateValues(); #endregion Cajas #region Escalera var a = 0; var textureStones = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + @"Texturas\stones.bmp"); //la altura de cualquier cubo que quiera subir una capsula debe ser menor a la mitad del radio var size = new TGCVector3(50, 4, 20); escalon = TGCBox.fromSize(size, textureStones); //Se crean 10 escalonescd d while (a < 10) { escalonRigidBody = BulletRigidBodyFactory.Instance.CreateBox(size, 0, new TGCVector3(200, a * 4 + 10, a * 20 + 100), 0, 0, 0, 0.1f, true); escalonesRigidBodies.Add(escalonRigidBody); dynamicsWorld.AddRigidBody(escalonRigidBody); a++; } #endregion Escalera #region Plataforma textureStones = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + @"Texturas\cobblestone_quad.jpg"); rigidBodyPlataforma = BulletRigidBodyFactory.Instance.CreateBox(new TGCVector3(50f, 15f, 50f), 0, new TGCVector3(200, 42.5f, 315), 0, 0, 0, 0.5f, true); dynamicsWorld.AddRigidBody(rigidBodyPlataforma); plataforma = TGCBox.fromSize(new TGCVector3(50f, 15f, 50f), textureStones); plataforma.updateValues(); #endregion Plataforma #region Columna columnaRigidBody = BulletRigidBodyFactory.Instance.CreateCylinder(new TGCVector3(10, 50, 10), new TGCVector3(100, 50, 100), 0); dynamicsWorld.AddRigidBody(columnaRigidBody); var columnaLoader = new TgcSceneLoader(); columnaMesh = columnaLoader.loadSceneFromFile(MediaDir + @"MeshCreator\Meshes\Cimientos\PilarEgipcio\PilarEgipcio-TgcScene.xml", MediaDir + @"MeshCreator\Meshes\Cimientos\PilarEgipcio\").Meshes[0]; columnaMesh.Position = new TGCVector3(100, 7.5f, 100); columnaMesh.UpdateMeshTransform(); #endregion Columna director = new TGCVector3(0, 0, 1); }
/// <summary> /// Iniciar creacion de primitiva /// </summary> public abstract void initCreation(TGCVector3 gridPoint);
const float border = 60f; //para evitar atravesar esquinas alineadas con los vectores de movimiento //parece que con 30 es seguro, por las dudas lo subi hasta //justo antes de que sea notable cuando te deslizas por la pared public bool intersectRay(TgcRay ray, out float dist, out TGCVector3 q) { float t; dist = 9999999; var face = new TGCVector3[4]; // // // 6 --- 7 // /| /| // 2 --- 3 | // | 4 --| 5 // |/ |/ // 0 --- 1 // // face[0] = transformedVertex[0] + new TGCVector3(-border, 0, 0); face[1] = transformedVertex[2] + new TGCVector3(-border, 0, 0); face[2] = transformedVertex[3] + new TGCVector3(border, 0, 0); face[3] = transformedVertex[1] + new TGCVector3(border, 0, 0); if (TgcCollisionUtils.intersectRayConvexPolygon(ray, face, out t, out q)) { dist = Math.Min(t, dist); } face[0] = transformedVertex[2]; face[1] = transformedVertex[6]; face[2] = transformedVertex[4]; face[3] = transformedVertex[0]; if (TgcCollisionUtils.intersectRayConvexPolygon(ray, face, out t, out q)) { dist = Math.Min(t, dist); } face[0] = transformedVertex[6] + new TGCVector3(-border, 0, 0); face[1] = transformedVertex[7] + new TGCVector3(border, 0, 0); face[2] = transformedVertex[5] + new TGCVector3(border, 0, 0); face[3] = transformedVertex[4] + new TGCVector3(-border, 0, 0); if (TgcCollisionUtils.intersectRayConvexPolygon(ray, face, out t, out q)) { dist = Math.Min(t, dist); } face[0] = transformedVertex[7]; face[1] = transformedVertex[5]; face[2] = transformedVertex[1]; face[3] = transformedVertex[3]; if (TgcCollisionUtils.intersectRayConvexPolygon(ray, face, out t, out q)) { dist = Math.Min(t, dist); } face[0] = transformedVertex[6]; face[1] = transformedVertex[7]; face[2] = transformedVertex[3]; face[3] = transformedVertex[2]; if (TgcCollisionUtils.intersectRayConvexPolygon(ray, face, out t, out q)) { dist = Math.Min(t, dist); } face[0] = transformedVertex[0]; face[1] = transformedVertex[4]; face[2] = transformedVertex[5]; face[3] = transformedVertex[1]; if (TgcCollisionUtils.intersectRayConvexPolygon(ray, face, out t, out q)) { dist = Math.Min(t, dist); } if (dist != 9999999) { t = dist; return(true); } return(false); }
/// <summary> /// Aplicar rotacion absoluta del objeto respecto de un pivote /// </summary> public abstract void setRotationFromPivot(TGCVector3 rotation, TGCVector3 pivot);
public void setTargetOffsets(TGCVector3 target, float offsetHeight, float offsetForward) { Target = target; OffsetHeight = offsetHeight; OffsetForward = offsetForward; }
/// <summary> /// Calcular Tangent y Binormal en base a los 3 vertices de un triangulo y la normal del primero de ellos /// Basado en: http://www.dhpoware.com/demos/d3d9NormalMapping.html /// </summary> public static void computeTangentBinormal(BumpMappingVertex v1, BumpMappingVertex v2, BumpMappingVertex v3, out TGCVector3 tangent, out TGCVector3 binormal) { // Given the 3 vertices (position and texture coordinates) of a triangle // calculate and return the triangle's tangent vector. The handedness of // the local coordinate system is stored in tangent.w. The bitangent is // then: float3 bitangent = cross(normal, tangent.xyz) * tangent.w. // Create 2 vectors in object space. // // edge1 is the vector from vertex positions v1 to v2. // edge2 is the vector from vertex positions v1 to v3. var edge1 = v2.Position - v1.Position; var edge2 = v3.Position - v1.Position; edge1.Normalize(); edge2.Normalize(); // Create 2 vectors in tangent (texture) space that point in the same // direction as edge1 and edge2 (in object space). // // texEdge1 is the vector from texture coordinates texCoord1 to texCoord2. // texEdge2 is the vector from texture coordinates texCoord1 to texCoord3. var texEdge1 = new TGCVector2(v2.Tu - v1.Tu, v2.Tv - v1.Tv); var texEdge2 = new TGCVector2(v3.Tu - v1.Tu, v3.Tv - v1.Tv); texEdge1.Normalize(); texEdge2.Normalize(); // These 2 sets of vectors form the following system of equations: // // edge1 = (texEdge1.x * tangent) + (texEdge1.y * bitangent) // edge2 = (texEdge2.x * tangent) + (texEdge2.y * bitangent) // // Using matrix notation this system looks like: // // [ edge1 ] [ texEdge1.x texEdge1.y ] [ tangent ] // [ ] = [ ] [ ] // [ edge2 ] [ texEdge2.x texEdge2.y ] [ bitangent ] // // The solution is: // // [ tangent ] 1 [ texEdge2.y -texEdge1.y ] [ edge1 ] // [ ] = ------- [ ] [ ] // [ bitangent ] det A [-texEdge2.x texEdge1.x ] [ edge2 ] // // where: // [ texEdge1.x texEdge1.y ] // A = [ ] // [ texEdge2.x texEdge2.y ] // // det A = (texEdge1.x * texEdge2.y) - (texEdge1.y * texEdge2.x) // // From this solution the tangent space basis vectors are: // // tangent = (1 / det A) * ( texEdge2.y * edge1 - texEdge1.y * edge2) // bitangent = (1 / det A) * (-texEdge2.x * edge1 + texEdge1.x * edge2) // normal = cross(tangent, bitangent) var det = texEdge1.X * texEdge2.Y - texEdge1.Y * texEdge2.X; if (FastMath.Abs(det) < 0.0001f) // almost equal to zero { tangent = new TGCVector3(1.0f, 0.0f, 0.0f); binormal = new TGCVector3(0.0f, 1.0f, 0.0f); } else { det = 1.0f / det; tangent = TGCVector3.Empty; tangent.X = (texEdge2.Y * edge1.X - texEdge1.Y * edge2.X) * det; tangent.Y = (texEdge2.Y * edge1.Y - texEdge1.Y * edge2.Y) * det; tangent.Z = (texEdge2.Y * edge1.Z - texEdge1.Y * edge2.Z) * det; //tangent.W = 0.0f; binormal = TGCVector3.Empty; binormal.X = (-texEdge2.X * edge1.X + texEdge1.X * edge2.X) * det; binormal.Y = (-texEdge2.X * edge1.Y + texEdge1.X * edge2.Y) * det; binormal.Z = (-texEdge2.X * edge1.Z + texEdge1.X * edge2.Z) * det; tangent.Normalize(); binormal.Normalize(); } // Calculate the handedness of the local tangent space. // The bitangent vector is the cross product between the triangle face // normal vector and the calculated tangent vector. The resulting bitangent // vector should be the same as the bitangent vector calculated from the // set of linear equations above. If they point in different directions // then we need to invert the cross product calculated bitangent vector. var b = TGCVector3.Cross(v1.Normal, tangent); var w = TGCVector3.Dot(b, binormal) < 0.0f ? -1.0f : 1.0f; binormal = b * w; }
public Health(TGCVector3 pos) : base(pos, "Heart", Game.Default.MediaDirectory + Game.Default.FXDirectory + "healthPickup.wav") { respawnTime = 10f; }
public TgcMeshBumpMapping(string name, TgcMesh parentInstance, TGCVector3 translation, TGCVector3 rotation, TGCVector3 scale) : base(name, parentInstance, translation, rotation, scale) { }
/// <summary> /// Constructor de la camara a partir de un TgcD3dInput y un positionEye, moveSpeed, jumpSpeed y rotationSpeed. Los atributos mouseCenter a partir del centro del a pantalla, /// el directionView (0,0,-1) /// </summary> /// <param name="positionEye"></param> /// <param name="moveSpeed"></param> /// <param name="jumpSpeed"></param> /// <param name="rotationSpeed"></param> /// <param name="input"></param> public TgcFpsCamera(TGCVector3 positionEye, float moveSpeed, float jumpSpeed, float rotationSpeed, TgcD3dInput input) : this(positionEye, moveSpeed, jumpSpeed, input) { this.RotationSpeed = rotationSpeed; }
private void ChangePosition(TGCVector3 newPosition) { Body.CenterOfMassTransform = TGCMatrix.Translation(newPosition).ToBulletMatrix(); Camera.Position = new TGCVector3(Body.CenterOfMassPosition); RestartBodySpeed(); }
/// <summary> /// Realiza un update de la camara a partir del elapsedTime, actualizando Position,LookAt y UpVector. /// Presenta movimientos basicos a partir de input de teclado W, A, S, D, Espacio, Control y rotraciones con el mouse. /// </summary> /// <param name="elapsedTime"></param> public override void UpdateCamera(float elapsedTime) { var moveVector = TGCVector3.Empty; //Forward if (Input.keyDown(Key.W)) { moveVector += new TGCVector3(0, 0, -1) * MovementSpeed; } //Backward if (Input.keyDown(Key.S)) { moveVector += new TGCVector3(0, 0, 1) * MovementSpeed; } //Strafe right if (Input.keyDown(Key.D)) { moveVector += new TGCVector3(-1, 0, 0) * MovementSpeed; } //Strafe left if (Input.keyDown(Key.A)) { moveVector += new TGCVector3(1, 0, 0) * MovementSpeed; } //Jump if (Input.keyDown(Key.Space)) { moveVector += TGCVector3.Up * JumpSpeed; } //Crouch if (Input.keyDown(Key.LeftControl)) { moveVector += TGCVector3.Down * JumpSpeed; } if (Input.keyPressed(Key.L) || Input.keyPressed(Key.Escape)) { LockCam = !lockCam; } //Solo rotar si se esta aprentando el boton izq del mouse if (lockCam || Input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT)) { leftrightRot -= -Input.XposRelative * RotationSpeed; updownRot -= Input.YposRelative * RotationSpeed; //Se actualiza matrix de rotacion, para no hacer este calculo cada vez y solo cuando en verdad es necesario. cameraRotation = TGCMatrix.RotationX(updownRot) * TGCMatrix.RotationY(leftrightRot); } if (lockCam) { Cursor.Position = mouseCenter; } //Calculamos la nueva posicion del ojo segun la rotacion actual de la camara. var cameraRotatedPositionEye = TGCVector3.TransformNormal(moveVector * elapsedTime, cameraRotation); positionEye += cameraRotatedPositionEye; //Calculamos el target de la camara, segun su direccion inicial y las rotaciones en screen space x,y. var cameraRotatedTarget = TGCVector3.TransformNormal(directionView, cameraRotation); var cameraFinalTarget = positionEye + cameraRotatedTarget; //Se calcula el nuevo vector de up producido por el movimiento del update. var cameraOriginalUpVector = DEFAULT_UP_VECTOR; var cameraRotatedUpVector = TGCVector3.TransformNormal(cameraOriginalUpVector, cameraRotation); base.SetCamera(positionEye, cameraFinalTarget, cameraRotatedUpVector); }
public TGCVector3 rotar_xz(TGCVector3 v, float an) { return(new TGCVector3((float)(v.X * Math.Cos(an) - v.Z * Math.Sin(an)), v.Y, (float)(v.X * Math.Sin(an) + v.Z * Math.Cos(an)))); }
public Arma(TGCVector3 tamanioDisparo, Color colorDisparo, int danio, int cdDisparo, TGCVector3 startPosition, float minDistance = -1f) { this.Danio = danio; this.shotSize = tamanioDisparo; this.shotColor = colorDisparo; this.disparos = new List <Disparo>(); shotLimiter = Stopwatch.StartNew(); position = startPosition; cooldownDisparo = cdDisparo; this.minDistance = minDistance; }