private void CrearEjes()
{
Vector3 centroEjes = new Vector3(50, 10, 0);
TgcArrow normalX = new TgcArrow();
normalX.PStart = centroEjes;
normalX.PEnd = centroEjes + new Vector3(10, 0, 0);
normalX.updateValues();
this.normales.Add(normalX);
TgcArrow normalY = new TgcArrow();
normalY.PStart = centroEjes;
normalY.PEnd = centroEjes + new Vector3(0, 10, 0);
normalY.updateValues();
this.normales.Add(normalY);
TgcArrow normalZ = new TgcArrow();
normalZ.PStart = centroEjes;
normalZ.PEnd = centroEjes + new Vector3(0, 0, 10);
normalZ.updateValues();
this.normales.Add(normalZ);
}
public void InstanciarSombras()
{
//Cargar Shader personalizado
effect = TGCShaders.Instance.LoadEffect(MyShaderDir + "Sombras.fx");
// le asigno el efecto a las mallas
// Creo el shadowmap.
// Format.R32F
// Format.X8R8G8B8
g_pShadowMap = new Texture(D3DDevice.Instance.Device, SHADOWMAP_SIZE, SHADOWMAP_SIZE, 1, Usage.RenderTarget, Format.R32F, Pool.Default);
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new TGCVector2(2f, 2f);
arrow.BodyColor = Color.Blue;
// tengo que crear un stencilbuffer para el shadowmap manualmente
// para asegurarme que tenga la el mismo tamano que el shadowmap, y que no tenga
// multisample, etc etc.
g_pDSShadow = D3DDevice.Instance.Device.CreateDepthStencilSurface(SHADOWMAP_SIZE, SHADOWMAP_SIZE, DepthFormat.D24S8, MultiSampleType.None, 0, true);
// por ultimo necesito una matriz de proyeccion para el shadowmap, ya
// que voy a dibujar desde el pto de vista de la luz.
// El angulo tiene que ser mayor a 45 para que la sombra no falle en los extremos del cono de luz
// de hecho, un valor mayor a 90 todavia es mejor, porque hasta con 90 grados es muy dificil
// lograr que los objetos del borde generen sombras
var aspectRatio = D3DDevice.Instance.AspectRatio;
g_mShadowProj = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(80), aspectRatio, 550, 3000);
D3DDevice.Instance.Device.Transform.Projection = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f), aspectRatio, near_plane, far_plane).ToMatrix();
//lightLookFromModifier = camara.getPosition();
//lightLookAtModifier = camara.getLookAt();
}
private void cargarPreview()
{
// inicio unos segundos de preview
timer_preview = 0;
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new Vector2(2f, 2f);
arrow.BodyColor = Color.Blue;
/*View1 = new Viewport();
* View1.X = 0;
* View1.Y = 0;
* View1.Width = panel3d.Width;
* View1.Height = panel3d.Height / 2;
* View1.MinZ = 0;
* View1.MaxZ = 1;
* View2 = new Viewport();
* View2.X = 0;
* View2.Y = View1.Height;
* View2.Width = panel3d.Width;
* View2.Height = panel3d.Height / 2;
* View2.MinZ = 0;
* View2.MaxZ = 1;
*
* ViewF = d3dDevice.Viewport;*/
}
private void CrearPlanos()
{
Vector3 centroOriginal = new Vector3(0, 0, 0);
Vector3 centroActual = centroOriginal;
for (int i = 0; i < 20; i++)
{
centroActual = new Vector3(i * 5, 0, 0);
for (int j = 0; j < 20; j++)
{
centroActual = centroActual + new Vector3(0, 0, 5);
//Crear un quad (pequeño plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
TgcQuad quad = new TgcQuad();
quad.Center = centroActual;
quad.Color = this.AdaptColorRandom(Color.SteelBlue);
quad.Size = new Vector2(5, 5);
quad.Effect = this.effect;
quad.Technique = "VS1";
quad.updateValues();
this.planos.Add(quad);
TgcArrow normal = new TgcArrow();
normal.PStart = quad.Center;
normal.PEnd = quad.Center + quad.Normal * 2;
normal.updateValues();
this.normales.Add(normal);
}
}
}
public ShadowMap(GameModel gm)
{
effect = TgcShaders.loadEffect(gm.ShadersDir + "ShadowMap.fx");
gameModel = gm;
mapScene = gm.MapScene;
Camara = gm.Camara;
foreach (var m in mapScene.Meshes)
{
m.Effect = effect;
m.Technique = "RenderShadow";
}
//--------------------------------------------------------------------------------------
// Creo el shadowmap.
// Format.R32F
// Format.X8R8G8B8
g_pShadowMap = new Texture(D3DDevice.Instance.Device, SHADOWMAP_SIZE, SHADOWMAP_SIZE,
1, Usage.RenderTarget, Format.R32F,
Pool.Default);
// tengo que crear un stencilbuffer para el shadowmap manualmente
// para asegurarme que tenga la el mismo tamano que el shadowmap, y que no tenga
// multisample, etc etc.
g_pDSShadow = D3DDevice.Instance.Device.CreateDepthStencilSurface(SHADOWMAP_SIZE,
SHADOWMAP_SIZE,
DepthFormat.D24S8,
MultiSampleType.None,
0,
true);
// por ultimo necesito una matriz de proyeccion para el shadowmap, ya
// que voy a dibujar desde el pto de vista de la luz.
// El angulo tiene que ser mayor a 45 para que la sombra no falle en los extremos del cono de luz
// de hecho, un valor mayor a 90 todavia es mejor, porque hasta con 90 grados es muy dificil
// lograr que los objetos del borde generen sombras
var aspectRatio = D3DDevice.Instance.AspectRatio;
g_mShadowProj = Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(80), aspectRatio, 50, 5000);
D3DDevice.Instance.Device.Transform.Projection =
Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f), aspectRatio, near_plane, far_plane);
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new Vector2(2f, 2f);
arrow.BodyColor = Color.Blue;
//donde esta y a donde apunta la luz
lightLookFrom = new Vector3(80, 120, 0);
g_LightPos = lightLookFrom;
lightLookAt = new Vector3(0, 0, 0);
g_LightDir = lightLookAt;
float K = 300;
}
private void CreateArrow()
{
this.effectVectorArrow = new TgcArrow();
effectVectorArrow.HeadColor = Color.Blue;
effectVectorArrow.BodyColor = Color.Red;
effectVectorArrow.Thickness = 1;
effectVectorArrow.Enabled = false;
effectVectorArrow.HeadSize = new TGCVector2(1, 1);
effectVectorArrow.updateValues();
}
override public void initData(Mesh d3dMesh, string meshName, TgcMesh.MeshRenderType renderType)
{
normalDibujable = new TgcArrow();
normalDibujable.BodyColor = Color.Red;
normalDibujable.HeadColor = Color.Yellow;
normalDibujable.Thickness = 1f;
normalDibujable.HeadSize = new Vector2(2, 5);
base.initData(d3dMesh, meshName, renderType);
}
private void initVector()
{
this.arrow = new TgcArrow();
arrow.HeadColor = Color.Blue;
arrow.BodyColor = Color.Red;
arrow.Thickness = 1;
arrow.Enabled = false;
arrow.HeadSize = new TGCVector2(1, 1);
arrow.updateValues();
this.effectVector = new TGCVector3(1, 1, 1);
}
public Personaje(TgcThirdPersonCamera camaraParametro, Explosion explosion)
{
//Crear personaje
TgcSkeletalLoader skeletalLoader = new TgcSkeletalLoader();
this.personaje = skeletalLoader.loadMeshAndAnimationsFromFile(
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\" + "CS_Arctic-TgcSkeletalMesh.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\",
new string[] {
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Walk-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "StandBy-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Jump-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Run-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "HighKick-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Talk-TgcSkeletalAnim.xml",
GuiController.Instance.AlumnoEjemplosMediaDir + "Kamikaze3D\\Animations\\WeaponPos-TgcSkeletalAnim.xml",
GuiController.Instance.AlumnoEjemplosMediaDir + "Kamikaze3D\\Animations\\Muerte-TgcSkeletalAnim.xml",
});
//Configurar animacion inicial
this.personaje.playAnimation("StandBy", true);
//Escalarlo y posicionarlo
this.personaje.Position = new Vector3(-100f, 3.5f, -340f);
this.personaje.Scale = new Vector3(0.7f, 0.7f, 0.7f);
//Rotarlo 180° porque esta mirando para el otro lado
this.personaje.rotateY(Geometry.DegreeToRadian(180f));
this.personaje.AutoUpdateBoundingBox = false;
//Crear manejador de colisiones
this.collisionManager = new SphereCollisionManager();
this.collisionManager.GravityEnabled = false;
this.characterSphere = new TgcBoundingSphere(personaje.BoundingBox.calculateBoxCenter(), personaje.BoundingBox.calculateBoxRadius());
//Crear linea para mostrar la direccion del movimiento del personaje
this.directionArrow = new TgcArrow();
this.directionArrow.BodyColor = Color.Red;
this.directionArrow.HeadColor = Color.Green;
this.directionArrow.Thickness = 1;
this.directionArrow.HeadSize = new Vector2(10, 20);
this.camara = camaraParametro;
this.weapon = new Weapon(personaje.Position);
//Agregar el arma al personaje
this.addWeapon(personaje, weapon);
this.explosion = explosion;
}
private void Iniciar(Vector3 puntoMinimo, Vector3 puntoMaximo, float valorMaximo)
{
PuntoMinimo = puntoMinimo;
PuntoMaximo = puntoMaximo;
ValorMaximo = valorMaximo;
linea = new TgcArrow();
linea.PStart = puntoMinimo;
linea.PEnd = puntoMaximo;
linea.BodyColor = Color.Green;
linea.HeadColor = Color.Green;
linea.Thickness = 3;
linea.HeadSize = new Vector2(1, 1);
}
/// <summary>
/// Crear flechas de debug para normales, tangentes y binormales
/// </summary>
private void loadDebugArrows(TgcMeshBumpMapping mesh)
{
//Obtener vertexBuffer
TgcMeshBumpMapping.BumpMappingVertex[] vertexBuffer = (TgcMeshBumpMapping.BumpMappingVertex[])mesh.D3dMesh.LockVertexBuffer(
typeof(TgcMeshBumpMapping.BumpMappingVertex), LockFlags.ReadOnly, mesh.D3dMesh.NumberVertices);
mesh.D3dMesh.UnlockVertexBuffer();
for (int i = 0; i < vertexBuffer.Length; i++)
{
TgcMeshBumpMapping.BumpMappingVertex v = vertexBuffer[i];
normals.Add(TgcArrow.fromDirection(v.Position, v.Normal * 50, Color.Blue, Color.Yellow, 0.5f, new Vector2(2f, 4f)));
tangents.Add(TgcArrow.fromDirection(v.Position, v.Tangent * 50, Color.Red, Color.Yellow, 0.5f, new Vector2(2f, 4f)));
binormals.Add(TgcArrow.fromDirection(v.Position, v.Binormal * 50, Color.Green, Color.Yellow, 0.5f, new Vector2(2f, 4f)));
}
}
public override void Init()
{
//Crea flecha genérica
arrow = new TgcArrow();
//Crear modifiers
Modifiers.addVertex3f("start", new Vector3(-50, -50, -50), new Vector3(50, 50, 50), new Vector3(0, 0, 0));
Modifiers.addVertex3f("end", new Vector3(-50, -50, -50), new Vector3(50, 50, 50), new Vector3(0, 10, 0));
Modifiers.addFloat("thickness", 0.01f, 1, 0.06f);
Modifiers.addVertex2f("headSize", new Vector2(0.01f, 0.01f), new Vector2(1, 1), new Vector2(0.3f, 0.6f));
Modifiers.addColor("bodyColor", Color.Blue);
Modifiers.addColor("headColor", Color.LightBlue);
//Camara FPS
Camara = new TgcFpsCamera(new Vector3(0.0302f, 5.842f, -18.97f), 10f, 10f);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar suelo
TgcTexture texture = TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesMediaDir + "Texturas\\granito.jpg");
suelo = TgcBox.fromSize(new Vector3(0, 0, 0), new Vector3(5000, 0.1f, 5000), texture);
//Iniciarlizar PickingRay
pickingRay = new TgcPickingRay();
//Cargar nave
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\NaveEspacial\\NaveEspacial-TgcScene.xml");
mesh = scene.Meshes[0];
//Rotación original de la malla, hacia -Z
originalMeshRot = new Vector3(0, 0, -1);
//Manipulamos los movimientos del mesh a mano
mesh.AutoTransformEnable = false;
meshRotationMatrix = Matrix.Identity;
newPosition = mesh.Position;
applyMovement = false;
//Crear caja para marcar en que lugar hubo colision
collisionPointMesh = TgcBox.fromSize(new Vector3(3, 100, 3), Color.Red);
//Flecha para marcar la dirección
directionArrow = new TgcArrow();
directionArrow.Thickness = 5;
directionArrow.HeadSize = new Vector2(10, 10);
//Camara en tercera persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(mesh.Position, 800, 1500);
GuiController.Instance.Modifiers.addFloat("speed", 1000, 5000, 2500);
}
public MovimientoController(Camara camaraParametro)
{
TgcSkeletalLoader skeletalLoader = new TgcSkeletalLoader();
personaje = skeletalLoader.loadMeshAndAnimationsFromFile(
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\" + "CS_Arctic-TgcSkeletalMesh.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\",
new string[] {
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Walk-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "StandBy-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Jump-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Run-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "HighKick-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Talk-TgcSkeletalAnim.xml",
GuiController.Instance.AlumnoEjemplosMediaDir + "Kamikaze3D\\Animations\\WeaponPos-TgcSkeletalAnim.xml",
});
//Configurar animacion inicial
personaje.playAnimation("StandBy", true);
//Escalarlo para que sea mas grande
personaje.Position = new Vector3(0, -10, 0);
personaje.Scale = new Vector3(3f, 3f, 3f);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.rotateY(Geometry.DegreeToRadian(180f));
personaje.AutoUpdateBoundingBox = false;
//Crear manejador de colisiones
collisionManager = new SphereCollisionManager();
collisionManager.GravityEnabled = true;
characterSphere = new TgcBoundingSphere(personaje.BoundingBox.calculateBoxCenter(), personaje.BoundingBox.calculateBoxRadius());
//Crear linea para mostrar la direccion del movimiento del personaje
directionArrow = new TgcArrow();
directionArrow.BodyColor = Color.Red;
directionArrow.HeadColor = Color.Green;
directionArrow.Thickness = 1;
directionArrow.HeadSize = new Vector2(10, 20);
Cursor.Hide();
camara = camaraParametro;
weapon = new Weapon(personaje.Position);
//Agregar el arma al personaje
//Personaje.addWeapon(personaje, weapon);
}
public override void Init()
{
//Crear Quad vacio
quad = new TgcQuad();
//Modifiers para vararia sus parametros
Modifiers.addVertex2f("size", new Vector2(0, 0), new Vector2(100, 100), new Vector2(20, 20));
Modifiers.addVertex3f("normal", new Vector3(-10, -10, -10), new Vector3(10, 10, 10), new Vector3(0, 1, 1));
Modifiers.addVertex3f("center", new Vector3(-10, -10, -10), new Vector3(10, 10, 10), new Vector3(0, 0, 0));
Modifiers.addColor("color", Color.Coral);
//Flecha para mostrar el sentido del vector normal
normalArrow = new TgcArrow();
Modifiers.addBoolean("showNormal", "Show normal", true);
Camara = new TgcRotationalCamera(new Vector3(), 50f, Input);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Crear Quad vacio
quad = new TgcQuad();
//Modifiers para vararia sus parametros
GuiController.Instance.Modifiers.addVertex2f("size", new Vector2(0, 0), new Vector2(100, 100), new Vector2(20, 20));
GuiController.Instance.Modifiers.addVertex3f("normal", new Vector3(-10, -10, -10), new Vector3(10, 10, 10), new Vector3(0, 1, 1));
GuiController.Instance.Modifiers.addVertex3f("center", new Vector3(-10, -10, -10), new Vector3(10, 10, 10), new Vector3(0, 0, 0));
GuiController.Instance.Modifiers.addColor("color", Color.Coral);
//Flecha para mostrar el sentido del vector normal
normalArrow = new TgcArrow();
GuiController.Instance.Modifiers.addBoolean("showNormal", "Show normal", true);
GuiController.Instance.RotCamera.CameraDistance = 50;
}
public Auto(string pathMeshAuto, string _nombre, Vector3 _posicionInicial, float _velocidadMaxima, float _velocidadRotacion, float _aceleracion, float _masa, Vector3 _escala, Vector3 _rotacionInicial)
{
this.nombre = _nombre;
this.posicionInicial = _posicionInicial;
this.mesh = MeshUtils.loadMesh(pathMeshAuto);
// sceneAuto = loadMesh(pathMeshAuto);
//this.mesh = sceneAuto.Meshes[0];
this.mesh.Scale = _escala;
this.rotacionInicial = _rotacionInicial;
this.backupVertices();
this.velocidadActual = 0;
this.velocidadMaxima = _velocidadMaxima;
this.velocidadMaximaInicial = _velocidadMaxima;
this.velocidadRotacion = _velocidadRotacion;
this.velocidadRotacionOriginal = _velocidadRotacion;
this.masa = _masa;
this.aceleracion = _aceleracion;
//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(this.mesh.BoundingBox);
this.puntoChoque = this.obb.Center;
this.direccion = new TgcArrow();
direccion.PStart = this.obb.Center;
Vector3 rotacion = this.mesh.Rotation;
direccion.PEnd = this.obb.Center + Vector3.Multiply(new Vector3(rotacion.X, rotacion.Y, rotacion.Z), 500f);
//// acá defino un mesh auxiliar para probar con el Debug mode
string sphere = GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Sphere\\Sphere-TgcScene.xml";
TgcSceneLoader loader = new TgcSceneLoader();
moon = loader.loadSceneFromFile(sphere).Meshes[0];
moon.Scale = new Vector3(0.6f, 0.6f, 0.6f);
//le asignamos una cantidad de chispas cada vez que choca
for (int i = 0; i < cantidadDeChispas; i++)
{
chispas.Add(new Chispa());
}
//... y un poco de sonido a los choques
this.sonidoChoque = new Sonido(Shared.mediaPath + "\\sonidos\\choque.wav");
}
public override void Init()
{
//Cargar suelo
var texture = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + "Texturas\\granito.jpg");
suelo = new TgcPlane(new TGCVector3(-5000, 0, -5000), new TGCVector3(10000, 0f, 10000), TgcPlane.Orientations.XZplane, texture);
//Iniciarlizar PickingRay
pickingRay = new TgcPickingRay(Input);
//Cargar nave
var loader = new TgcSceneLoader();
var scene =
loader.loadSceneFromFile(MediaDir +
"MeshCreator\\Meshes\\Vehiculos\\NaveEspacial\\NaveEspacial-TgcScene.xml");
mesh = scene.Meshes[0];
//Rotación original de la malla, hacia -Z
originalMeshRot = new TGCVector3(0, 0, -1);
//Manipulamos los movimientos del mesh a mano
mesh.AutoTransform = false;
meshRotationMatrix = TGCMatrix.Identity;
newPosition = mesh.Position;
applyMovement = false;
//Crear caja para marcar en que lugar hubo colision
collisionPointMesh = TGCBox.fromSize(new TGCVector3(3, 100, 3), Color.Red);
//Flecha para marcar la dirección
directionArrow = new TgcArrow();
directionArrow.Thickness = 5;
directionArrow.HeadSize = new TGCVector2(10, 10);
//Camara en tercera persona
camaraInterna = new TgcThirdPersonCamera(mesh.Position, 800, 1500);
Camara = camaraInterna;
speedModifier = AddFloat("speed", 1000, 5000, 2500);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Crea flecha genérica
arrow = new TgcArrow();
//Crear modifiers
GuiController.Instance.Modifiers.addVertex3f("start", new Vector3(-50, -50, -50), new Vector3(50, 50, 50), new Vector3(0, 0, 0));
GuiController.Instance.Modifiers.addVertex3f("end", new Vector3(-50, -50, -50), new Vector3(50, 50, 50), new Vector3(0, 10, 0));
GuiController.Instance.Modifiers.addFloat("thickness", 0.01f, 1, 0.06f);
GuiController.Instance.Modifiers.addVertex2f("headSize", new Vector2(0.01f, 0.01f), new Vector2(1, 1), new Vector2(0.3f, 0.6f));
GuiController.Instance.Modifiers.addColor("bodyColor", Color.Blue);
GuiController.Instance.Modifiers.addColor("headColor", Color.LightBlue);
//Camara FPS
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(0.0302f, 5.842f, -18.97f), new Vector3(27.9348f, -29.0575f, 980.0311f));
GuiController.Instance.FpsCamera.MovementSpeed = 10f;
GuiController.Instance.FpsCamera.JumpSpeed = 10f;
}
public override void Init()
{
//Crea flecha generica
arrow = new TgcArrow();
//Crear modifiers
startModifier = AddVertex3f("start", new TGCVector3(-50, -50, -50), new TGCVector3(50, 50, 50), TGCVector3.Empty);
endModifier = AddVertex3f("end", new TGCVector3(-50, -50, -50), new TGCVector3(50, 50, 50), new TGCVector3(0, 10, 0));
thicknessModifier = AddFloat("thickness", 0.01f, 1, 0.06f);
headSizeModifier = AddVertex2f("headSize", new TGCVector2(0.01f, 0.01f), TGCVector2.One, new TGCVector2(0.3f, 0.6f));
bodyColorModifier = AddColor("bodyColor", Color.Blue);
headColorModifier = AddColor("headColor", Color.LightBlue);
//Crea linea generica
box = new TgcBoxDebug();
//Crear modifiers
boxColorModifier = AddColor("boxColor", Color.Red);
//Camera FPS
Camera = new TgcRotationalCamera(new TGCVector3(0, 10f, 0), 30f, Input);
}
public static List <TgcArrow> PrepareClosestCheckPoint(Vector3 position, Checkpoint lastCheckPoint, out Checkpoint updatedChekPoint)
{
updatedChekPoint = GetClosestCheckPoint(position);
if (lastCheckPoint != updatedChekPoint)
{
lastCheckPoint = updatedChekPoint;
lastCheckPointArrows = updatedChekPoint.Neighbors.Select(c =>
{
TgcArrow arrow = new TgcArrow();
arrow.PStart = lastCheckPoint.Position;
arrow.PEnd = c.Position;
arrow.BodyColor = Color.Black;
arrow.HeadColor = Color.White;
arrow.Thickness = 0.4f;
arrow.HeadSize = new Vector2(8, 10);
arrow.updateValues();
return(arrow);
}).ToList();
}
return(lastCheckPointArrows);
}
private void InitializeArrows()
{
fromArrow = new TgcArrow();
fromArrow.BodyColor = Color.DarkBlue;
fromArrow.HeadColor = Color.Blue;
fromArrow.HeadSize = new TGCVector2(0.2f, 0.2f);
fromArrow.Thickness = 0.1f;
fromArrow.PStart = TGCVector3.Empty;
toArrow = new TgcArrow();
toArrow.BodyColor = Color.DarkRed;
toArrow.HeadColor = Color.Red;
toArrow.HeadSize = new TGCVector2(0.2f, 0.2f);
toArrow.Thickness = 0.1f;
toArrow.PStart = TGCVector3.Empty;
crossArrow = new TgcArrow();
crossArrow.BodyColor = Color.DarkGoldenrod;
crossArrow.HeadColor = Color.Yellow;
crossArrow.HeadSize = new TGCVector2(0.2f, 0.2f);
crossArrow.Thickness = 0.1f;
crossArrow.PStart = TGCVector3.Empty;
}
private void CrearEjes()
{
Vector3 centroEjes = new Vector3(50, 10, 0);
TgcArrow normalX = new TgcArrow();
normalX.PStart = centroEjes;
normalX.PEnd = centroEjes + new Vector3(10, 0, 0);
normalX.updateValues();
this.normales.Add(normalX);
TgcArrow normalY = new TgcArrow();
normalY.PStart = centroEjes;
normalY.PEnd = centroEjes + new Vector3(0, 10, 0);
normalY.updateValues();
this.normales.Add(normalY);
TgcArrow normalZ = new TgcArrow();
normalZ.PStart = centroEjes;
normalZ.PEnd = centroEjes + new Vector3(0, 0, 10);
normalZ.updateValues();
this.normales.Add(normalZ);
}
public override void Init()
{
//Cargar escenario específico para este ejemplo
var loader = new TgcSceneLoader();
escenario = loader.loadSceneFromFile(MediaDir + "PatioDeJuegos\\PatioDeJuegos-TgcScene.xml");
//Cargar personaje con animaciones
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);
//Escalarlo porque es muy grande
personaje.Position = new TGCVector3(0, 500, -100);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.RotateY(Geometry.DegreeToRadian(180f));
//Escalamos el personaje ya que sino la escalera es demaciado grande.
personaje.Scale = new TGCVector3(1.5f, 1.5f, 1.5f);
characterSphere = new TgcBoundingSphere(personaje.BoundingBox.calculateBoxCenter(), personaje.BoundingBox.calculateBoxRadius());
//Almacenar volumenes de colision del escenario
objetosColisionables.Clear();
foreach (var mesh in escenario.Meshes)
{
objetosColisionables.Add(mesh.BoundingBox);
}
//Crear linea para mostrar la direccion del movimiento del personaje
directionArrow = new TgcArrow();
directionArrow.BodyColor = Color.Red;
directionArrow.HeadColor = Color.Green;
directionArrow.Thickness = 1;
directionArrow.HeadSize = new TGCVector2(10, 20);
//Crear manejador de colisiones
collisionManager = new SphereCollisionManager();
collisionManager.GravityEnabled = true;
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(personaje.Position, new TGCVector3(0, 100, 0), 100, -400);
Camara = camaraInterna;
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = TGCVector3.Empty;
skyBox.Size = new TGCVector3(10000, 10000, 10000);
var texturesPath = MediaDir + "Texturas\\Quake\\SkyBox3\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "Up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "Down.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "Left.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "Right.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "Back.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "Front.jpg");
skyBox.Init();
//Modifier para ver BoundingBox
showBoundingBoxModifier = AddBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
velocidadCaminarModifier = AddFloat("VelocidadCaminar", 0, 20, 10);
velocidadRotacionModifier = AddFloat("VelocidadRotacion", 1f, 360f, 150f);
habilitarGravedadModifier = AddBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
gravedadModifier = AddVertex3f("Gravedad", new TGCVector3(-50, -50, -50), new TGCVector3(50, 50, 50), new TGCVector3(0, -10, 0));
slideFactorModifier = AddFloat("SlideFactor", 1f, 2f, 1.3f);
UserVars.addVar("Movement");
}
public unsafe override void Init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
GuiController.Instance.CustomRenderEnabled = true;
MyMediaDir = MediaDir + "WorkshopShaders\\";
MyShaderDir = ShadersDir + "WorkshopShaders\\";
time = 0f;
vel_x = new float[MAX_DS, MAX_DS];
vel_z = new float[MAX_DS, MAX_DS];
pos_x = new float[MAX_DS, MAX_DS];
pos_y = new float[MAX_DS, MAX_DS];
pos_z = new float[MAX_DS, MAX_DS];
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
// ------------------------------------------------------------
//Path de Heightmap default del terreno y Path de Textura default del terreno
TGCVector3 PosTerrain = new TGCVector3(0, 0, 0);
currentHeightmap = MyMediaDir + "Heighmaps\\" + "Heightmap2.jpg";
currentScaleXZ = 100f;
currentScaleY = 6f;
currentTexture = MyMediaDir + "Heighmaps\\" + "Heightmap2.JPG"; //+ "grid.JPG";
terrain = new TgcSimpleTerrain();
terrain.loadHeightmap(currentHeightmap, currentScaleXZ, currentScaleY, PosTerrain);
terrain.loadTexture(currentTexture);
// tomo el ancho de la textura, ojo tiene que ser cuadrada
float terrain_width = (float)terrain.HeightmapData.GetLength(0);
// mesh principal
scene = loader.loadSceneFromFile(MediaDir + "ModelosTgc\\Sphere\\Sphere-TgcScene.xml");
Bitmap b = (Bitmap)Bitmap.FromFile(MyMediaDir + "Heighmaps\\grid.jpg");
g_pBaseTexture = Texture.FromBitmap(d3dDevice, b, Usage.None, Pool.Managed);
b.Dispose();
mesh = scene.Meshes[0];
mesh.Scale = new TGCVector3(0.5f, 0.5f, 0.5f);
mesh.Position = new TGCVector3(0f, 0f, 0f);
mesh.AutoTransformEnable = false;
TGCVector3 size = mesh.BoundingBox.calculateSize();
esfera_radio = Math.Abs(size.Y) / 2;
//Cargar Shader
string compilationErrors;
effect = Effect.FromFile(d3dDevice, MyShaderDir + "GPUCompute.fx", null, null, ShaderFlags.None, null, out compilationErrors);
if (effect == null)
{
throw new Exception("Error al cargar shader. Errores: " + compilationErrors);
}
//Configurar Technique
effect.Technique = "DefaultTechnique";
effect.SetValue("map_size", terrain_width);
effect.SetValue("map_desf", 0.5f / terrain_width);
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new TGCVector2(2f, 2f);
arrow.BodyColor = Color.Blue;
arrowN = new TgcArrow();
arrowN.Thickness = 1f;
arrowN.HeadSize = new TGCVector2(2f, 2f);
arrowN.BodyColor = Color.Red;
arrowT = new TgcArrow();
arrowT.Thickness = 1f;
arrowT.HeadSize = new TGCVector2(2f, 2f);
arrowT.BodyColor = Color.Green;
GuiController.Instance.RotCamera.CameraCenter = new TGCVector3(0, 0, 0);
GuiController.Instance.RotCamera.CameraDistance = 3200;
GuiController.Instance.RotCamera.RotationSpeed = 2f;
LookAt = new TGCVector3(0, 0, 0);
LookFrom = new TGCVector3(3200, 3000, 3200);
float aspectRatio = (float)GuiController.Instance.Panel3d.Width / GuiController.Instance.Panel3d.Height;
GuiController.Instance.CurrentCamera.updateCamera();
d3dDevice.Transform.Projection = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f), aspectRatio, 5f, 40000f);
// Creo el mapa de velocidad
g_pVelocidad = new Texture(d3dDevice, MAX_DS, MAX_DS, 1, Usage.RenderTarget, Format.A32B32G32R32F, Pool.Default);
g_pVelocidadOut = new Texture(d3dDevice, MAX_DS, MAX_DS, 1, Usage.RenderTarget, Format.A32B32G32R32F, Pool.Default);
// Mapa de Posicion
g_pPos = new Texture(d3dDevice, MAX_DS, MAX_DS, 1, Usage.RenderTarget, Format.A32B32G32R32F, Pool.Default);
g_pPosOut = new Texture(d3dDevice, MAX_DS, MAX_DS, 1, Usage.RenderTarget, Format.A32B32G32R32F, Pool.Default);
// stencil compatible sin multisampling
g_pDepthStencil = d3dDevice.CreateDepthStencilSurface(MAX_DS, MAX_DS, DepthFormat.D24S8, MultiSampleType.None, 0, true);
// temporaria para recuperar los valores
g_pTempVel = new Texture(d3dDevice, MAX_DS, MAX_DS, 1, 0, Format.A32B32G32R32F, Pool.SystemMemory);
g_pTempPos = new Texture(d3dDevice, MAX_DS, MAX_DS, 1, 0, Format.A32B32G32R32F, Pool.SystemMemory);
effect.SetValue("g_pVelocidad", g_pVelocidad);
effect.SetValue("g_pPos", g_pPos);
// Textura del heigmap
g_pHeightmap = TextureLoader.FromFile(d3dDevice, currentHeightmap);
effect.SetValue("height_map", g_pHeightmap);
// Resolucion de pantalla
effect.SetValue("screen_dx", d3dDevice.PresentationParameters.BackBufferWidth);
effect.SetValue("screen_dy", d3dDevice.PresentationParameters.BackBufferHeight);
effect.SetValue("currentScaleXZ", currentScaleXZ);
effect.SetValue("currentScaleY", currentScaleY);
//Se crean 2 triangulos 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[] vertices = 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
g_pVBV3D = new VertexBuffer(typeof(CustomVertex.PositionTextured), 4, d3dDevice, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionTextured.Format, Pool.Default);
g_pVBV3D.SetData(vertices, 0, LockFlags.None);
g_pVB = new VertexBuffer(typeof(CustomVertex.PositionColored), MAX_DS * MAX_DS, d3dDevice, Usage.Dynamic | Usage.None, CustomVertex.PositionColored.Format, Pool.Default);
// inicializo el mapa de velocidades
Device device = GuiController.Instance.D3dDevice;
TGCMatrix ant_Proj = device.Transform.Projection;
TGCMatrix ant_World = device.Transform.World;
TGCMatrix ant_View = device.Transform.View;
device.Transform.Projection = TGCMatrix.Identity;
device.Transform.World = TGCMatrix.Identity;
device.Transform.View = TGCMatrix.Identity;
// rt1 = velocidad
Surface pOldRT = device.GetRenderTarget(0);
Surface pSurf = g_pVelocidad.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
Surface pOldDS = device.DepthStencilSurface;
device.DepthStencilSurface = g_pDepthStencil;
// rt2 = posicion
Surface pSurf2 = g_pPos.GetSurfaceLevel(0);
device.SetRenderTarget(1, pSurf2);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
device.BeginScene();
effect.Technique = "ComputeVel";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.Begin(FX.None);
effect.BeginPass(0);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
device.EndScene();
effect.SetValue("Kp", esfera_radio * (float)Math.PI / 2);
// restauro los RT
device.SetRenderTarget(0, pOldRT);
device.SetRenderTarget(1, null);
device.DepthStencilSurface = pOldDS;
// restauro las Transf.
device.Transform.Projection = ant_Proj;
device.Transform.World = ant_World;
device.Transform.View = ant_View;
Modifiers.addBoolean("dibujar_terreno", "Dibujar Terreno", true);
}
public PantallaJuego(Auto autito)
{
/*En PantallaInicio le paso a Pantalla juego con qué auto jugar. Acá lo asigno a la pantalla, cargo el coso
* que capta el teclado, creo el Nivel1 y lo pongo en la lista de renderizables, para que sepa con qué
* escenario cargarse */
this.auto = autito;
auto.mesh.move(new Vector3(0, 0, -3100));
auto.mesh.rotateY(-1.57f);
this.entrada = GuiController.Instance.D3dInput;
this.nivel = EjemploAlumno.getInstance().getNiveles(0);
//Barrita de vida
vida = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\vidaPersonaje\\vida.jpg");
barra = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\vidaPersonaje\\fondobarra.png");
barra2 = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\vidaPersonaje\\fondobarra2.png");
vida.setEscala(escalaInicial);
barra.setEscala(new Vector2(6.81f, 1f));
barra2.setEscala(new Vector2(6.81f, 1f));
Vector2 posicionbarra = new Vector2(10, 5);
vida.setPosicion(new Vector2(155f, 9.3f));
//CUENTA REGRESIVA
uno = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\cuentaRegresiva\\1.png");
uno.setCentrarYEscalar();
dos = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\cuentaRegresiva\\2.png");
dos.setCentrarYEscalar();
tres = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\cuentaRegresiva\\3.png");
tres.setCentrarYEscalar();
//Instrucción de misión del juego
misionMario = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\Mision\\m_mario.png");
misionMario.setCentrarYEscalar();
misionLuigi = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\Mision\\m_luigi.png");
misionLuigi.setCentrarYEscalar();
// CAMARA TERCERA PERSONA
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.resetValues();
Vector2 vectorCam = (Vector2)GuiController.Instance.Modifiers["AlturaCamara"];
GuiController.Instance.ThirdPersonCamera.setCamera(auto.mesh.Position, vectorCam.X, vectorCam.Y);
GuiController.Instance.ThirdPersonCamera.rotateY(auto.mesh.Rotation.Y);
//CARGAR MÚSICA.
Musica track = new Musica("ramones.mp3");
this.musica = track;
musica.playMusica();
musica.setVolume(35);
Shared.debugMode = false;
//Puntos de juego
puntos = new TgcText2d();
puntos.Text = "0";
puntos.Color = Color.DarkRed;
puntos.Align = TgcText2d.TextAlign.RIGHT;
puntos.Position = new Point(30, 30);
puntos.Size = new Size(100, 50);
puntos.changeFont(new System.Drawing.Font("TimesNewRoman", 25, FontStyle.Bold));
//Reloxxxx
this.horaInicio = DateTime.Now;
this.tiempoRestante = new TgcText2d();
this.tiempoRestante.Text = "65";
this.tiempoRestante.Color = Color.Green;
this.tiempoRestante.Align = TgcText2d.TextAlign.RIGHT;
this.tiempoRestante.Position = new Point(300, 30);
this.tiempoRestante.Size = new Size(100, 50);
this.tiempoRestante.changeFont(new System.Drawing.Font("TimesNewRoman", 25, FontStyle.Bold));
this.comienzoNivel = true;
//FLECHA NORMAL colision
collisionNormalArrow = new TgcArrow();
collisionNormalArrow.BodyColor = Color.Blue;
collisionNormalArrow.HeadColor = Color.Yellow;
collisionNormalArrow.Thickness = 1.4f;
collisionNormalArrow.HeadSize = new Vector2(10, 20);
//FLECHA debug (la usamos para conocer posiciones donde querramos posicionar meshes)
debugArrow = new TgcArrow();
debugArrow.BodyColor = Color.Purple;
debugArrow.HeadColor = Color.Yellow;
debugArrow.Thickness = 3f;
debugArrow.HeadSize = new Vector2(10, 20);
debugArrow.PStart = new Vector3(0, 400f, 0);
debugArrow.PEnd = new Vector3(0, 10f, 0);
debugArrow.updateValues();
//USER VARS
GuiController.Instance.UserVars.addVar("DistMinima");
GuiController.Instance.UserVars.addVar("Velocidad");
GuiController.Instance.UserVars.addVar("Vida");
GuiController.Instance.UserVars.addVar("AngCol");
GuiController.Instance.UserVars.addVar("AngRot");
GuiController.Instance.UserVars.addVar("NormalObstaculoX");
GuiController.Instance.UserVars.addVar("NormalObstaculoZ");
}
public override void Init()
{
//Cargar escenario específico para este ejemplo
var loader = new TgcSceneLoader();
escenario = loader.loadSceneFromFile(MediaDir + "\\MeshCreator\\Scenes\\Mountains\\Mountains-TgcScene.xml");
//Cargar personaje con animaciones
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")
});
//Se utiliza autotransform, aunque este es un claro ejemplo de que no se debe usar autotransform,
//hay muchas operaciones y la mayoria las maneja el manager de colisiones, con lo cual se esta
//perdiendo el control de las transformaciones del personaje.
personaje.AutoTransformEnable = true;
//Configurar animacion inicial
personaje.playAnimation("Parado", true);
//Escalarlo porque es muy grande
personaje.Position = new Vector3(0, 2500, -150);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.rotateY(Geometry.DegreeToRadian(180f));
//escalamos el personaje porque es muy grande.
personaje.Scale = new Vector3(0.5f, 0.5f, 0.5f);
//BoundingSphere que va a usar el personaje
personaje.AutoUpdateBoundingBox = false;
characterSphere = new TgcBoundingSphere(personaje.BoundingBox.calculateBoxCenter(),
personaje.BoundingBox.calculateBoxRadius());
jumping = false;
//Almacenar volumenes de colision del escenario
objetosColisionables.Clear();
foreach (var mesh in escenario.Meshes)
{
//Los objetos del layer "TriangleCollision" son colisiones a nivel de triangulo
if (mesh.Layer == "TriangleCollision")
{
objetosColisionables.Add(TriangleMeshCollider.fromMesh(mesh));
}
//El resto de los objetos son colisiones de BoundingBox
else
{
objetosColisionables.Add(BoundingBoxCollider.fromBoundingBox(mesh.BoundingBox));
}
}
//Crear linea para mostrar la direccion del movimiento del personaje
directionArrow = new TgcArrow();
directionArrow.BodyColor = Color.Red;
directionArrow.HeadColor = Color.Green;
directionArrow.Thickness = 0.4f;
directionArrow.HeadSize = new Vector2(5, 10);
//Linea para normal de colision
collisionNormalArrow = new TgcArrow();
collisionNormalArrow.BodyColor = Color.Blue;
collisionNormalArrow.HeadColor = Color.Yellow;
collisionNormalArrow.Thickness = 0.4f;
collisionNormalArrow.HeadSize = new Vector2(2, 5);
//Caja para marcar punto de colision
collisionPoint = TgcBox.fromSize(new Vector3(4, 4, 4), Color.Red);
collisionPoint.AutoTransformEnable = true;
//Crear manejador de colisiones
collisionManager = new SphereTriangleCollisionManager();
collisionManager.GravityEnabled = true;
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(personaje.Position, new Vector3(0, 45, 0), 35, -150);
Camara = camaraInterna;
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(10000, 10000, 10000);
var texturesPath = MediaDir + "Texturas\\Quake\\SkyBox3\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "Up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "Down.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "Left.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "Right.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "Back.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "Front.jpg");
skyBox.Init();
//Modifier para ver BoundingBox
Modifiers.addBoolean("Collisions", "Collisions", true);
Modifiers.addBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
Modifiers.addFloat("VelocidadCaminar", 0, 10, 2);
Modifiers.addFloat("VelocidadRotacion", 1f, 360f, 150f);
Modifiers.addBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
Modifiers.addVertex3f("Gravedad", new Vector3(-5, -10, -5), new Vector3(5, 5, 5),
new Vector3(0, -6, 0));
Modifiers.addFloat("SlideFactor", 0f, 2f, 1f);
Modifiers.addFloat("Pendiente", 0f, 1f, 0.7f);
Modifiers.addFloat("VelocidadSalto", 0f, 10f, 2f);
Modifiers.addFloat("TiempoSalto", 0f, 2f, 0.5f);
UserVars.addVar("Movement");
UserVars.addVar("ySign");
}
public override void Init()
{
//Cargar escenario específico para este ejemplo. Este escenario tiene dos layers: objetos normales y objetos con colisión a nivel de triángulo.
//La colisión a nivel de triángulos es costosa. Solo debe utilizarse para objetos puntuales (como el piso). Y es recomendable dividirlo en varios
//meshes (y no hacer un único piso que ocupe todo el escenario)
var loader = new TgcSceneLoader();
escenario = loader.loadSceneFromFile(MediaDir + "\\MeshCreator\\Scenes\\Mountains\\Mountains-TgcScene.xml");
//Cargar personaje con animaciones
var skeletalLoader = new TgcSkeletalLoader();
personaje =
skeletalLoader.loadMeshAndAnimationsFromFile(
MediaDir + "SkeletalAnimations\\BasicHuman\\BasicHuman-TgcSkeletalMesh.xml",
new[]
{
MediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\Walk-TgcSkeletalAnim.xml",
MediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\StandBy-TgcSkeletalAnim.xml",
MediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\Jump-TgcSkeletalAnim.xml"
});
//Configurar animacion inicial
personaje.playAnimation("StandBy", true);
//Escalarlo porque es muy grande
personaje.Position = new Vector3(0, 1000, -150);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.rotateY(Geometry.DegreeToRadian(180f));
//BoundingSphere que va a usar el personaje
personaje.AutoUpdateBoundingBox = false;
characterElipsoid = new TgcElipsoid(personaje.BoundingBox.calculateBoxCenter() + new Vector3(0, 0, 0),
new Vector3(12, 28, 12));
jumping = false;
//Almacenar volumenes de colision del escenario
objetosColisionables.Clear();
foreach (var mesh in escenario.Meshes)
{
//Los objetos del layer "TriangleCollision" son colisiones a nivel de triangulo
if (mesh.Layer == "TriangleCollision")
{
objetosColisionables.Add(TriangleMeshCollider.fromMesh(mesh));
}
//El resto de los objetos son colisiones de BoundingBox. Las colisiones a nivel de triangulo son muy costosas asi que deben utilizarse solo
//donde es extremadamente necesario (por ejemplo en el piso). El resto se simplifica con un BoundingBox
else
{
objetosColisionables.Add(BoundingBoxCollider.fromBoundingBox(mesh.BoundingBox));
}
}
//Crear manejador de colisiones
collisionManager = new ElipsoidCollisionManager();
collisionManager.GravityEnabled = true;
//Crear linea para mostrar la direccion del movimiento del personaje
directionArrow = new TgcArrow();
directionArrow.BodyColor = Color.Red;
directionArrow.HeadColor = Color.Green;
directionArrow.Thickness = 0.4f;
directionArrow.HeadSize = new Vector2(5, 10);
//Linea para normal de colision
collisionNormalArrow = new TgcArrow();
collisionNormalArrow.BodyColor = Color.Blue;
collisionNormalArrow.HeadColor = Color.Yellow;
collisionNormalArrow.Thickness = 0.4f;
collisionNormalArrow.HeadSize = new Vector2(2, 5);
//Caja para marcar punto de colision
collisionPoint = TgcBox.fromSize(new Vector3(4, 4, 4), Color.Red);
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(personaje.Position, new Vector3(0, 45, 0), 20, -120);
Camara = camaraInterna;
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(10000, 10000, 10000);
var texturesPath = MediaDir + "Texturas\\Quake\\SkyBox3\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "Up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "Down.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "Left.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "Right.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "Back.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "Front.jpg");
skyBox.InitSkyBox();
//Modifier para ver BoundingBox
Modifiers.addBoolean("Collisions", "Collisions", true);
Modifiers.addBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
Modifiers.addFloat("VelocidadCaminar", 0, 20, 2);
Modifiers.addFloat("VelocidadRotacion", 1f, 360f, 150f);
Modifiers.addBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
Modifiers.addVertex3f("Gravedad", new Vector3(-50, -50, -50), new Vector3(50, 50, 50),
new Vector3(0, -4, 0));
Modifiers.addFloat("SlideFactor", 0f, 2f, 1f);
Modifiers.addFloat("Pendiente", 0f, 1f, 0.72f);
Modifiers.addFloat("VelocidadSalto", 0f, 50f, 10f);
Modifiers.addFloat("TiempoSalto", 0f, 2f, 0.5f);
UserVars.addVar("Movement");
}
private void CrearPlanos()
{
Vector3 centroOriginal = new Vector3(0, 0, 0);
Vector3 centroActual = centroOriginal;
for (int i = 0; i < 20; i++)
{
centroActual = new Vector3(i * 5, 0, 0);
for (int j = 0; j < 20; j++)
{
centroActual = centroActual + new Vector3(0, 0, 5);
//Crear un quad (pequeño plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
TgcQuad quad = new TgcQuad();
quad.Center = centroActual;
quad.Color = this.AdaptColorRandom(Color.SteelBlue);
quad.Size = new Vector2(5, 5);
quad.Effect = this.effect;
quad.Technique = "VS1";
quad.updateValues();
this.planos.Add(quad);
TgcArrow normal = new TgcArrow();
normal.PStart = quad.Center;
normal.PEnd = quad.Center + quad.Normal * 2;
normal.updateValues();
this.normales.Add(normal);
}
}
}
public override void init()
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar escenario específico para este ejemplo
TgcSceneLoader loader = new TgcSceneLoader();
escenario = loader.loadSceneFromFile(GuiController.Instance.ExamplesDir + "\\Collision\\SphereCollision\\PatioDeJuegos\\PatioDeJuegos-TgcScene.xml");
//Cargar personaje con animaciones
TgcSkeletalLoader skeletalLoader = new TgcSkeletalLoader();
personaje = skeletalLoader.loadMeshAndAnimationsFromFile(
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\" + "Robot-TgcSkeletalMesh.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\",
new string[] {
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\" + "Caminando-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\" + "Parado-TgcSkeletalAnim.xml",
});
//Le cambiamos la textura para diferenciarlo un poco
personaje.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\Textures\\" + "uvwGreen.jpg") });
//Configurar animacion inicial
personaje.playAnimation("Parado", true);
//Escalarlo porque es muy grande
personaje.Position = new Vector3(0, 500, -100);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.rotateY(Geometry.DegreeToRadian(180f));
//BoundingSphere que va a usar el personaje
personaje.AutoUpdateBoundingBox = false;
characterSphere = new TgcBoundingSphere(personaje.BoundingBox.calculateBoxCenter(), personaje.BoundingBox.calculateBoxRadius());
//Almacenar volumenes de colision del escenario
objetosColisionables.Clear();
foreach (TgcMesh mesh in escenario.Meshes)
{
objetosColisionables.Add(mesh.BoundingBox);
}
//Crear linea para mostrar la direccion del movimiento del personaje
directionArrow = new TgcArrow();
directionArrow.BodyColor = Color.Red;
directionArrow.HeadColor = Color.Green;
directionArrow.Thickness = 1;
directionArrow.HeadSize = new Vector2(10, 20);
//Crear manejador de colisiones
collisionManager = new SphereCollisionManager();
collisionManager.GravityEnabled = true;
//Configurar camara en Tercer Persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(personaje.Position, 100, -400);
GuiController.Instance.ThirdPersonCamera.TargetDisplacement = new Vector3(0, 100, 0);
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(10000, 10000, 10000);
string texturesPath = GuiController.Instance.ExamplesMediaDir + "Texturas\\Quake\\SkyBox3\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "Up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "Down.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "Left.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "Right.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "Back.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "Front.jpg");
skyBox.updateValues();
//Modifier para ver BoundingBox
GuiController.Instance.Modifiers.addBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
GuiController.Instance.Modifiers.addFloat("VelocidadCaminar", 0, 100, 16);
GuiController.Instance.Modifiers.addFloat("VelocidadRotacion", 1f, 360f, 150f);
GuiController.Instance.Modifiers.addBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
GuiController.Instance.Modifiers.addVertex3f("Gravedad", new Vector3(-50, -50, -50), new Vector3(50, 50, 50), new Vector3(0, -10, 0));
GuiController.Instance.Modifiers.addFloat("SlideFactor", 1f, 2f, 1.3f);
GuiController.Instance.UserVars.addVar("Movement");
}
public override void Init()
{
MyMediaDir = MediaDir + "WorkshopShaders\\";
MyShaderDir = ShadersDir + "WorkshopShaders\\";
//Crear loader
var loader = new TgcSceneLoader();
// ------------------------------------------------------------
//Cargar la escena
scene = loader.loadSceneFromFile(MyMediaDir + "shadowTest\\ShadowTest-TgcScene.xml");
scene2 =
loader.loadSceneFromFile(MediaDir + "MeshCreator\\Meshes\\Vehiculos\\AvionCaza\\AvionCaza-TgcScene.xml");
avion = scene2.Meshes[0];
avion.Scale = new Vector3(0.1f, 0.1f, 0.1f);
avion.Position = new Vector3(100f, 100f, 0f);
avion.AutoTransformEnable = false;
dir_avion = new Vector3(0, 0, 1);
//Cargar Shader personalizado
effect =
TgcShaders.loadEffect(MyShaderDir + "ShadowMap.fx");
// le asigno el efecto a las mallas
foreach (var T in scene.Meshes)
{
T.Scale = new Vector3(1f, 1f, 1f);
T.Effect = effect;
}
avion.Effect = effect;
//--------------------------------------------------------------------------------------
// Creo el shadowmap.
// Format.R32F
// Format.X8R8G8B8
g_pShadowMap = new Texture(D3DDevice.Instance.Device, SHADOWMAP_SIZE, SHADOWMAP_SIZE,
1, Usage.RenderTarget, Format.R32F,
Pool.Default);
// tengo que crear un stencilbuffer para el shadowmap manualmente
// para asegurarme que tenga la el mismo tamano que el shadowmap, y que no tenga
// multisample, etc etc.
g_pDSShadow = D3DDevice.Instance.Device.CreateDepthStencilSurface(SHADOWMAP_SIZE,
SHADOWMAP_SIZE,
DepthFormat.D24S8,
MultiSampleType.None,
0,
true);
// por ultimo necesito una matriz de proyeccion para el shadowmap, ya
// que voy a dibujar desde el pto de vista de la luz.
// El angulo tiene que ser mayor a 45 para que la sombra no falle en los extremos del cono de luz
// de hecho, un valor mayor a 90 todavia es mejor, porque hasta con 90 grados es muy dificil
// lograr que los objetos del borde generen sombras
var aspectRatio = D3DDevice.Instance.AspectRatio;
g_mShadowProj = Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(80), aspectRatio, 50, 5000);
D3DDevice.Instance.Device.Transform.Projection =
Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f), aspectRatio, near_plane, far_plane);
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new Vector2(2f, 2f);
arrow.BodyColor = Color.Blue;
float K = 300;
Modifiers.addVertex3f("LightLookFrom", new Vector3(-K, -K, -K), new Vector3(K, K, K),
new Vector3(80, 120, 0));
Modifiers.addVertex3f("LightLookAt", new Vector3(-K, -K, -K), new Vector3(K, K, K),
new Vector3(0, 0, 0));
var rotCamera = new TgcRotationalCamera(scene.Meshes[0].BoundingBox.calculateBoxCenter(),
scene.Meshes[0].BoundingBox.calculateBoxRadius() * 2, Input);
rotCamera.CameraCenter = rotCamera.CameraCenter +
new Vector3(0, 50f, 0);
rotCamera.CameraDistance = 300;
rotCamera.RotationSpeed = 50f;
Camara = rotCamera;
}
public void renderConEfectos(float elapsedTime)
{
var device = D3DDevice.Instance.Device;
// dibujo la escena una textura
effect.Technique = "DefaultTechnique";
// guardo el Render target anterior y seteo la textura como render target
var pOldRT = device.GetRenderTarget(0);
var pSurf = g_pRenderTarget.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
// hago lo mismo con el depthbuffer, necesito el que no tiene multisampling
var pOldDS = device.DepthStencilSurface;
device.DepthStencilSurface = g_pDepthStencil;
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
device.BeginScene();
//Dibujamos todos los meshes del escenario
renderScene(elapsedTime, "DefaultTechnique");
//Render personames enemigos
foreach (var m in enemigos)
{
m.UpdateMeshTransform();
m.Render();
}
device.EndScene();
pSurf.Dispose();
// dibujo el glow map
effect.Technique = "DefaultTechnique";
pSurf = g_pGlowMap.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
device.BeginScene();
//Dibujamos SOLO los meshes que tienen glow brillantes
//Render personaje brillante
//Render personames enemigos
foreach (var m in enemigos)
{
m.UpdateMeshTransform();
m.Render();
}
if (Input.keyDown(Key.F))
{
for (var i = 0; i < cant_balas; ++i)
{
if (timer_firing[i] > 0)
{
var bala = new TgcArrow();
bala.PStart = pos_bala[i];
bala.PEnd = pos_bala[i] + dir_bala[i] * 3;
bala.Thickness = 0.05f;
bala.HeadSize = new TGCVector2(0.01f, 0.01f);
bala.Effect = effect;
bala.Technique = "DefaultTechnique";
bala.updateValues();
bala.Render();
}
}
}
// El resto opacos
renderScene(elapsedTime, "DibujarObjetosOscuros");
device.EndScene();
pSurf.Dispose();
// Hago un blur sobre el glow map
// 1er pasada: downfilter x 4
// -----------------------------------------------------
pSurf = g_pRenderTarget4.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
device.BeginScene();
effect.Technique = "DownFilter4";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pGlowMap);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(0);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
pSurf.Dispose();
device.EndScene();
device.DepthStencilSurface = pOldDS;
// Pasadas de blur
for (var P = 0; P < cant_pasadas; ++P)
{
// Gaussian blur Horizontal
// -----------------------------------------------------
pSurf = g_pRenderTarget4Aux.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
// dibujo el quad pp dicho :
device.BeginScene();
effect.Technique = "GaussianBlurSeparable";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget4);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(0);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
pSurf.Dispose();
device.EndScene();
pSurf = g_pRenderTarget4.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
pSurf.Dispose();
// Gaussian blur Vertical
// -----------------------------------------------------
device.BeginScene();
effect.Technique = "GaussianBlurSeparable";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget4Aux);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(1);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
device.EndScene();
}
// To Gray Scale
// -----------------------------------------------------
// Ultima pasada vertical va sobre la pantalla pp dicha
device.SetRenderTarget(0, pOldRT);
//pSurf = g_pRenderTarget4Aux.GetSurfaceLevel(0);
//device.SetRenderTarget(0, pSurf);
device.BeginScene();
effect.Technique = "GrayScale";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget);
effect.SetValue("g_GlowMap", g_pRenderTarget4Aux);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(0);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
device.EndScene();
}
