public override void Init()
{
//Modifiers para variar parametros de la pared
originModifier = AddVertex3f("origin", new TGCVector3(-100, -100, -100), new TGCVector3(100, 100, 100), TGCVector3.Empty);
dimensionModifier = AddVertex3f("dimension", new TGCVector3(-100, -100, -100), new TGCVector3(1000, 1000, 100), new TGCVector3(100, 100, 100));
orientationModifier = AddInterval("orientation", new[] { "XY", "XZ", "YZ" }, 0);
tilingModifier = AddVertex2f("tiling", TGCVector2.Zero, new TGCVector2(10, 10), TGCVector2.One);
autoAdjustModifier = AddBoolean("autoAdjust", "autoAdjust", false);
//Modifier de textura
var texturePath = MediaDir + "Texturas\\Quake\\TexturePack2\\brick1_1.jpg";
currentTexture = TgcTexture.createTexture(D3DDevice.Instance.Device, texturePath);
textureModifier = AddTexture("texture", currentTexture.FilePath);
//Crear pared
plane = new TgcPlane();
plane.setTexture(currentTexture);
//Actualizar segun valores cargados
updateTGCPlane();
//Ajustar camara segun tamano de la pared
Camara = new TgcRotationalCamera(plane.BoundingBox.calculateBoxCenter(), plane.BoundingBox.calculateBoxRadius() * 2, Input);
}
public override void Init()
{
//Crear esfera
sphere = new TGCSphere();
//No recomendamos utilizar AutoTransformEnable, con juegos complejos se pierde el control.
sphere.AutoTransform = true;
currentTexture = null;
//Modifiers para vararis sus parametros
baseModifier = AddEnum("base", typeof(TGCSphere.eBasePoly), TGCSphere.eBasePoly.ICOSAHEDRON);
inflateModifier = AddBoolean("inflate", "yes", true);
levelOfDetailModifier = AddInterval("level of detail", new object[] { 0, 1, 2, 3, 4 }, 2);
edgesModifier = AddBoolean("edges", "show", false);
radiusModifier = AddFloat("radius", 0, 100, 10);
positionModifier = AddVertex3f("position", new TGCVector3(-100, -100, -100), new TGCVector3(100, 100, 100), TGCVector3.Empty);
rotationModifier = AddVertex3f("rotation", new TGCVector3(-180, -180, -180), new TGCVector3(180, 180, 180), TGCVector3.Empty);
useTextureModifier = AddBoolean("Use texture", "yes", true);
textureModifier = AddTexture("texture", MediaDir + "\\Texturas\\madera.jpg");
offsetModifier = AddVertex2f("offset", new TGCVector2(-0.5f, -0.5f), new TGCVector2(0.9f, 0.9f), TGCVector2.Zero);
tilingModifier = AddVertex2f("tiling", new TGCVector2(0.1f, 0.1f), new TGCVector2(4, 4), TGCVector2.One);
colorModifier = AddColor("color", Color.White);
boundingsphereModifier = AddBoolean("boundingsphere", "show", false);
UserVars.addVar("Vertices");
UserVars.addVar("Triangulos");
Camara = new TgcRotationalCamera(TGCVector3.Empty, 50f, Input);
}
public override void Init()
{
//Cargar escenario
var loader = new TgcSceneLoader();
//Configurar MeshFactory customizado
scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
//Camara en 1ra persona
Camera = new TgcFpsCamera(new TGCVector3(200, 250, 175), 400f, 300f, Input);
//Mesh para la luz
lightMesh = TGCBox.fromSize(new TGCVector3(10, 10, 10), Color.Red);
//Modifiers de la luz
lightEnableModifier = AddBoolean("lightEnable", "lightEnable", true);
lightPosModifier = AddVertex3f("lightPos", new TGCVector3(-200, -100, -200), new TGCVector3(200, 200, 300), new TGCVector3(-60, 90, 175));
lightDirModifier = AddVertex3f("lightDir", new TGCVector3(-1, -1, -1), TGCVector3.One, new TGCVector3(-0.05f, 0, 0));
lightColorModifier = AddColor("lightColor", Color.White);
lightIntensityModifier = AddFloat("lightIntensity", 0, 150, 35);
lightAttenuationModifier = AddFloat("lightAttenuation", 0.1f, 2, 0.3f);
specularExModifier = AddFloat("specularEx", 0, 20, 9f);
spotAngleModifier = AddFloat("spotAngle", 0, 180, 39f);
spotExponentModifier = AddFloat("spotExponent", 0, 20, 7f);
//Modifiers de material
mEmissiveModifier = AddColor("mEmissive", Color.Black);
mAmbientModifier = AddColor("mAmbient", Color.White);
mDiffuseModifier = AddColor("mDiffuse", Color.White);
mSpecularModifier = AddColor("mSpecular", Color.White);
}
/// <summary>
/// Modificador para valores floats (X,Y,Z) de un vertice.
/// </summary>
/// <param name="varName">Nombre del modificador.</param>
/// <param name="minValue">Valor minimo.</param>
/// <param name="maxValue">Valor maximo.</param>
/// <param name="defaultValue">Valor default.</param>
/// <returns>Modificador que se agrego.</returns>
public TGCVertex3fModifier AddVertex3f(string varName, TGCVector3 minValue, TGCVector3 maxValue, TGCVector3 defaultValue)
{
var vertex3Modifier = new TGCVertex3fModifier(varName, minValue, maxValue, defaultValue);
AddModifier(vertex3Modifier);
return(vertex3Modifier);
}
public override void Init()
{
//Triangulo 1.
//Definir array de vertices para el triangulo, del tipo Coordendas (X,Y,Z) + Color
simpleTriangleData = new CustomVertex.PositionColored[3];
//Cargar informacion de vertices. Nesitamos 3 vertices para crear un triangulo
simpleTriangleData[0] = new CustomVertex.PositionColored(-1, 0, 0, Color.Red.ToArgb());
simpleTriangleData[1] = new CustomVertex.PositionColored(1, 0, 0, Color.Green.ToArgb());
simpleTriangleData[2] = new CustomVertex.PositionColored(0, 1, 0, Color.Blue.ToArgb());
//Cargar variables de usuario con alguna informacion util para ver en pantalla
UserVars.addVar("Triangle 1 vertices", simpleTriangleData.Length);
//Triangulo 2.
//Current texture
currentTexurePah = MediaDir + "Texturas\\baldosaFacultad.jpg";
texture = TextureLoader.FromFile(D3DDevice.Instance.Device, currentTexurePah);
//Modifiers
vertex1Modifier = AddVertex3f("vertex1", new TGCVector3(-3, -3, -3), new TGCVector3(3, 3, 3), new TGCVector3(-1, 0, 0));
texCoord1Modifier = AddVertex2f("texCoord1", TGCVector2.Zero, TGCVector2.One, new TGCVector2(1, 0));
color1Modifier = AddColor("color1", Color.White);
vertex2Modifier = AddVertex3f("vertex2", new TGCVector3(-3, -3, -3), new TGCVector3(3, 3, 3), new TGCVector3(1, 0, 0));
texCoord2Modifier = AddVertex2f("texCoord2", TGCVector2.Zero, TGCVector2.One, new TGCVector2(0, 1));
color2Modifier = AddColor("color2", Color.White);
vertex3Modifier = AddVertex3f("vertex3", new TGCVector3(-3, -3, -3), new TGCVector3(3, 3, 3), TGCVector3.Up);
texCoord3Modifier = AddVertex2f("texCoord3", TGCVector2.Zero, TGCVector2.One, TGCVector2.One);
color3Modifier = AddColor("color3", Color.White);
rotationModifier = AddFloat("rotation", -2, 2f, 0f);
textureEnableModifier = AddBoolean("TextureEnable", "Con textura", true);
textureImageModifier = AddTexture("Texture image", currentTexurePah);
//Triangulo 3.
//Crear vertexBuffer
vertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), 3, D3DDevice.Instance.Device, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
//Cargar informacion de vertices: (X,Y,Z) + Color
var data = new CustomVertex.PositionColored[3];
data[0] = new CustomVertex.PositionColored(-1, 0, 0, Color.Red.ToArgb());
data[1] = new CustomVertex.PositionColored(1, 0, 0, Color.Green.ToArgb());
data[2] = new CustomVertex.PositionColored(0, 1, 0, Color.Blue.ToArgb());
//Almacenar informacion en VertexBuffer
vertexBuffer.SetData(data, 0, LockFlags.None);
//User Vars
UserVars.addVar("Triangle 3 vertices");
UserVars.setValue("Triangle 3 vertices", data.Length);
//Configurar camara en rotacion
Camara = new TgcRotationalCamera(new TGCVector3(0, 0.5f, 0), 7.5f, Input);
}
public override void Init()
{
//Objetos en movimiento.
colliderCylinder = new TgcBoundingCylinder(TGCVector3.Empty, 2, 4);
colliderCylinder.setRenderColor(Color.LimeGreen);
colliderCylinderFixedY = new TgcBoundingCylinderFixedY(TGCVector3.Empty, 2, 4);
colliderCylinderFixedY.setRenderColor(Color.LimeGreen);
//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"
});
//Configurar animacion inicial
personaje.playAnimation("Parado", true);
//Escalarlo porque es muy grande
personaje.Scale = new TGCVector3(0.04f, 0.04f, 0.04f);
//El personaje esta en el 0,0,0 hay que bajarlo
var size = personaje.BoundingBox.PMax.Y - personaje.BoundingBox.PMin.Y;
personaje.Position = new TGCVector3(0, -3f, 0);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.Rotation = new TGCVector3(0, FastMath.PI, 0);
personaje.Transform = TGCMatrix.RotationY(personaje.Rotation.Y) * TGCMatrix.Translation(personaje.Position);
//Objetos estaticos, pueden ser mesh o objetos simplificados.
var loader = new TgcSceneLoader();
var scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Meshes\\Vehiculos\\Patrullero\\Patrullero-TgcScene.xml");
collisionableMeshAABB = scene.Meshes[0];
collisionableMeshAABB.Scale = new TGCVector3(0.1f, 0.1f, 0.1f);
collisionableMeshAABB.Position = new TGCVector3(6, 0, -2);
collisionableCylinder = new TgcBoundingCylinderFixedY(new TGCVector3(-6, 0, 0), 2, 2);
collisionableSphere = new TgcBoundingSphere(new TGCVector3(-3, 0, 10), 3);
fixedYModifier = AddBoolean("fixedY", "use fixed Y", true);
//Modifier para ver BoundingBox del personaje
showBoundingBoxModifier = AddBoolean("showBoundingBox", "Personaje Bouding Box", false);
sizeModifier = AddVertex2f("size", TGCVector2.One, new TGCVector2(5, 10), new TGCVector2(2, 5));
var angle = FastMath.TWO_PI;
rotationModifier = AddVertex3f("rotation", new TGCVector3(-angle, -angle, -angle), new TGCVector3(angle, angle, angle), new TGCVector3(FastMath.TWO_PI / 8, 0, FastMath.TWO_PI / 8));
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(personaje.Position, 25, -45);
Camera = camaraInterna;
}
public override void Init()
{
time = 0f;
var d3dDevice = D3DDevice.Instance.Device;
var MyShaderDir = ShadersDir + "WorkshopShaders\\";
//Crear loader
var loader = new TgcSceneLoader();
// parallax oclussion
scene = loader.loadSceneFromFile(MediaDir + "ModelosTgc\\Piso\\Piso-Custom-TgcScene.xml");
g_pBaseTexture = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\wood.bmp");
g_pHeightmap = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_four_height.tga");
g_pBaseTexture2 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\stones.bmp");
g_pHeightmap2 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_height_stones.tga");
g_pBaseTexture3 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\rocks.jpg");
g_pHeightmap3 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_height_rocks.tga");
mesh = scene.Meshes[0];
var adj = new int[mesh.D3dMesh.NumberFaces * 3];
mesh.D3dMesh.GenerateAdjacency(0, adj);
mesh.D3dMesh.ComputeNormals(adj);
//Cargar Shader
string compilationErrors;
effect = Effect.FromFile(d3dDevice, MyShaderDir + "Parallax.fx", null, null, ShaderFlags.None, null, out compilationErrors);
if (effect == null)
{
throw new Exception("Error al cargar shader. Errores: " + compilationErrors);
}
lightDirModifier = AddVertex3f("LightDir", new TGCVector3(-1, -1, -1), TGCVector3.One, TGCVector3.Down);
minSampleModifier = AddFloat("minSample", 1f, 10f, 10f);
maxSampleModifier = AddFloat("maxSample", 11f, 50f, 50f);
heightMapScaleModifier = AddFloat("HeightMapScale", 0.001f, 0.5f, 0.1f);
//Centrar camara rotacional respecto a este mesh
var rotCamera = new TgcRotationalCamera(mesh.BoundingBox.calculateBoxCenter(), mesh.BoundingBox.calculateBoxRadius() * 2, Input);
rotCamera.CameraCenter = rotCamera.CameraCenter + new TGCVector3(0, 20f, 0);
rotCamera.CameraDistance = 75;
rotCamera.RotationSpeed = 50f;
Camera = rotCamera;
pom = false;
phong = true;
nro_textura = 0;
}
private void ConfigureModifiers()
{
lightPositionModifier = AddVertex3f("LightPosition", new TGCVector3(-500f, 0f, -500f), new TGCVector3(500f, 500f, 500f), new TGCVector3(100f, 80f, 0f));
ambientModifier = AddFloat("Ambient", 0, 1, 0.5f);
diffuseModifier = AddFloat("Diffuse", 0, 1, 0.75f);
specularModifier = AddFloat("Specular", 0, 1, 0.5f);
specularPowerModifier = AddFloat("Shininess", 0f, 50.0f, 15f);
ambientColorModifier = AddColor("ambient", Color.Gray);
diffuseColorModifier = AddColor("diffuse", Color.LightGoldenrodYellow);
specularColorModifier = AddColor("specular", Color.White);
toggleBlinn = AddBoolean("Blinn Phong", "Usar Blinn Phong", true);
previousValue = toggleBlinn.Value;
}
public override void Init()
{
//Cargar escenario
var loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
//Cargar mesh con animaciones
var skeletalLoader = new TgcSkeletalLoader();
skeletalMesh = skeletalLoader.loadMeshAndAnimationsFromFile(MediaDir + "SkeletalAnimations\\Robot\\Robot-TgcSkeletalMesh.xml",
new[] { MediaDir + "SkeletalAnimations\\Robot\\Parado-TgcSkeletalAnim.xml" });
//Configurar animacion inicial
skeletalMesh.playAnimation("Parado", true);
//Corregir normales
skeletalMesh.computeNormals();
//Pongo al mesh en posicion
skeletalMesh.Position = new TGCVector3(0, 0, 100);
skeletalMesh.Transform = TGCMatrix.RotationYawPitchRoll(skeletalMesh.Rotation.Y + FastMath.PI, skeletalMesh.Rotation.X, skeletalMesh.Rotation.Z) *
TGCMatrix.Translation(skeletalMesh.Position);
skeletalMesh.RotateY(FastMath.PI);
//Camara en 1ra persona
Camara = new TgcFpsCamera(new TGCVector3(250, 140, 150), Input);
//Mesh para la luz
lightMesh = TGCBox.fromSize(new TGCVector3(10, 10, 10));
//Pongo al mesh en posicion
lightMesh.Position = new TGCVector3(0, 150, 150);
lightMesh.Transform = TGCMatrix.Translation(lightMesh.Position);
//Modifiers de la luz
lightEnableModifier = AddBoolean("lightEnable", "lightEnable", lightMesh.Enabled);
lightPosModifier = AddVertex3f("lightPos", new TGCVector3(-200, -100, -200), new TGCVector3(200, 200, 300), lightMesh.Position);
lightColorModifier = AddColor("lightColor", lightMesh.Color);
lightIntensityModifier = AddFloat("lightIntensity", 0, 150, 20);
lightAttenuationModifier = AddFloat("lightAttenuation", 0.1f, 2, 0.3f);
specularExModifier = AddFloat("specularEx", 0, 20, 9f);
//Modifiers de material
mEmissiveModifier = AddColor("mEmissive", Color.Black);
mAmbientModifier = AddColor("mAmbient", Color.White);
mDiffuseModifier = AddColor("mDiffuse", Color.White);
mSpecularModifier = AddColor("mSpecular", Color.White);
}
public override void Init()
{
var textureEuler = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + "Texturas\\madera.jpg");
boxEuler = TGCBox.fromSize(new TGCVector3(-50, 0, 0), new TGCVector3(50, 50, 50), textureEuler);
var textureQuat = TgcTexture.createTexture(D3DDevice.Instance.Device,
MediaDir + "Texturas\\paredMuyRugosa.jpg");
boxTGCQuaternion = TGCBox.fromSize(new TGCVector3(50, 0, 0), new TGCVector3(50, 50, 50), textureQuat);
rotacionModifier = AddVertex3f("Rotacion", TGCVector3.Empty, new TGCVector3(360, 360, 360), TGCVector3.Empty);
Camara.SetCamera(new TGCVector3(0f, 1f, -200f), new TGCVector3(0f, 1f, 500f));
}
public override void Init()
{
//Crear Quad vacio
quad = new TGCQuad();
//Modifiers para vararia sus parametros
sizeModifier = AddVertex2f("size", TGCVector2.Zero, new TGCVector2(100, 100), new TGCVector2(20, 20));
normalModifier = AddVertex3f("normal", new TGCVector3(-10, -10, -10), new TGCVector3(10, 10, 10), new TGCVector3(0, 1, 0));
centerModifier = AddVertex3f("center", new TGCVector3(-10, -10, -10), new TGCVector3(10, 10, 10), TGCVector3.Empty);
colorModifier = AddColor("color", Color.Coral);
//Flecha para mostrar el sentido del vector normal
normalArrow = new TgcArrow();
showNormalModifier = AddBoolean("showNormal", "Show normal", true);
Camera = new TgcRotationalCamera(new TGCVector3(0, 5, 0), 50f, Input);
}
public override void Init()
{
var loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(MediaDir + "\\XWing\\xwing-TgcScene.xml");
eulerMesh = scene.Meshes[0];
quaternionMesh = scene.Meshes[0].clone("quat");
baseEulerTranslation = TGCMatrix.Translation(new TGCVector3(-10.0f, 0.0f, 0.0f));
baseQuaternionTranslation = TGCMatrix.Translation(new TGCVector3(10.0f, 0.0f, 0.0f));
rotacionModifier = AddVertex3f("Rotacion", TGCVector3.Empty, new TGCVector3(360, 360, 360), TGCVector3.Empty);
baseScaleRotation = TGCMatrix.Scaling(new TGCVector3(0.05f, 0.05f, 0.05f)) * TGCMatrix.RotationY(FastMath.PI_HALF);
Camera.SetCamera(new TGCVector3(0f, 1f, -25f), new TGCVector3(0f, 1f, 200f));
}
public override void Init()
{
cylinder = new TgcCylinder(TGCVector3.Empty, 2, 4);
cylinder.AlphaBlendEnable = true;
boundingCylinderModifier = AddBoolean("boundingCylinder", "boundingCylinder", false);
colorModifier = AddColor("color", Color.White);
alphaModifier = AddInt("alpha", 0, 255, 255);
textureModifier = AddTexture("texture", MediaDir + "\\Texturas\\madera.jpg");
useTextureModifier = AddBoolean("useTexture", "useTexture", true);
sizeModifier = AddVertex3f("size", new TGCVector3(-3, -3, 1), new TGCVector3(7, 7, 10), new TGCVector3(2, 2, 5));
positionModifier = AddVertex3f("position", new TGCVector3(-20, -20, -20), new TGCVector3(20, 20, 20), TGCVector3.Empty);
var angle = FastMath.TWO_PI;
rotationModifier = AddVertex3f("rotation", new TGCVector3(-angle, -angle, -angle), new TGCVector3(angle, angle, angle), TGCVector3.Empty);
Camara = new TgcRotationalCamera(Input);
}
public override void Init()
{
MyMediaDir = MediaDir + "WorkshopShaders\\";
//Crear loader
TgcSceneLoader 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 TGCVector3(0.1f, 0.1f, 0.1f);
avion.Position = new TGCVector3(100f, 100f, 0f);
avion.AutoTransform = false;
dir_avion = new TGCVector3(0, 0, 1);
Camara = new TgcRotationalCamera(new TGCVector3(0, 20, 125), 50, 0.15f, 50f, Input);
//Cargar Shader personalizado
effect = TgcShaders.loadEffect(ShadersDir + "WorkshopShaders\\PlanarShadows.fx");
// le asigno el efecto a las mallas
foreach (TgcMesh T in scene.Meshes)
{
T.Scale = new TGCVector3(1f, 1f, 1f);
T.Effect = effect;
}
avion.Effect = effect;
box = new TGCBox();
box.Color = Color.Yellow;
//GuiController.Instance.RotCamera.targetObject(scene.Meshes[0].BoundingBox);
float K = 300;
lightLookFromModifier = AddVertex3f("LightLookFrom", new TGCVector3(-K, -K, -K), new TGCVector3(K, K, K), new TGCVector3(80, 120, 0));
}
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 override void Init()
{
time = 0f;
Device d3dDevice = D3DDevice.Instance.Device;
MyShaderDir = ShadersDir + "WorkshopShaders\\";
g_pBaseTexture = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\rocks.jpg");
g_pHeightmap = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_height_rocks.tga");
//Cargar Shader
string compilationErrors;
effect = Effect.FromFile(d3dDevice, MyShaderDir + "Parallax.fx", null, null, ShaderFlags.None, null, out compilationErrors);
if (effect == null)
{
throw new Exception("Error al cargar shader. Errores: " + compilationErrors);
}
effect.Technique = "ParallaxOcclusion";
effect.SetValue("aux_Tex", g_pBaseTexture);
effect.SetValue("height_map", g_pHeightmap);
effect.SetValue("phong_lighting", true);
effect.SetValue("k_alpha", 0.75f);
lightDirModifier = AddVertex3f("LightDir", new TGCVector3(-1, -1, -1), new TGCVector3(1, 1, 1), TGCVector3.Down);
minSampleModifier = AddFloat("minSample", 1f, 10f, 10f);
maxSampleModifier = AddFloat("maxSample", 11f, 50f, 50f);
heightMapScaleModifier = AddFloat("HeightMapScale", 0.001f, 0.5f, 0.1f);
// ------------------------------------------------------------
// Creo el Heightmap para el terreno:
terrain = new POMTerrain();
terrain.ftex = 250f;
terrain.loadHeightmap(MediaDir + "Heighmaps\\" + "Heightmap3.jpg", 100f, 2.25f, new TGCVector3(0, 0, 0));
terrain.loadTexture(MediaDir + "Heighmaps\\" + "TerrainTexture3.jpg");
Camara.SetCamera(new TGCVector3(-350, 1000, -1100), new TGCVector3(0, 0, 0), TGCVector3.Up);
}
public override void Init()
{
this.time = 0;
this.techniques = AddEnum("Tecnica", typeof(Techniques), Techniques.RenderMesh);
this.rotation = AddFloat("Rotacion", 0, FastMath.TWO_PI, 0);
this.factor = AddFloat("Factor", 0, 1, 0.5f);
this.effectVector = AddVertex3f("Vector", new TGCVector3(-20, -20, -20), new TGCVector3(20, 20, 20), TGCVector3.Empty);
this.center = AddVertex3f("Centro", new TGCVector3(-10, -10, -10), new TGCVector3(10, 10, 10), TGCVector3.Empty);
this.wireframe = AddBoolean("Wireframe", "Prende el efecto wireframe", false);
this.showArrow = AddBoolean("Vector del Efecto", "Muestra el vector del efecto", false);
this.CreateEffect();
this.CreateMesh();
this.CreateArrow();
this.scale = TGCMatrix.Scaling(20, 20, 20);
var cameraPosition = new TGCVector3(0, 0, 125);
var lookAt = TGCVector3.Empty;
Camara.SetCamera(cameraPosition, lookAt);
}
public override void Init()
{
//Crear caja vacia
box = new TGCBox();
//Crear caja debug vacia
debugBox = new TgcBoxDebug();
currentTexture = null;
//Modifiers para vararis sus parametros
boxModifier = AddBoolean("box", "box", true);
boundingBoxModifier = AddBoolean("boundingBox", "BoundingBox", false);
debugBoxModifier = AddBoolean("debugBox", "debugBox", true);
thicknessModifier = AddFloat("thickness", 0.1f, 5, 0.2f);
textureModifier = AddTexture("texture", MediaDir + "\\Texturas\\madera.jpg");
offsetModifier = AddVertex2f("offset", new TGCVector2(-0.5f, -0.5f), new TGCVector2(0.9f, 0.9f), TGCVector2.Zero);
tilingModifier = AddVertex2f("tiling", new TGCVector2(0.1f, 0.1f), new TGCVector2(4, 4), TGCVector2.One);
colorModifier = AddColor("color", Color.BurlyWood);
sizeModifier = AddVertex3f("size", TGCVector3.Empty, new TGCVector3(100, 100, 100), new TGCVector3(20, 20, 20));
positionModifier = AddVertex3f("position", new TGCVector3(-100, -100, -100), new TGCVector3(100, 100, 100), TGCVector3.Empty);
rotationModifier = AddVertex3f("rotation", new TGCVector3(-180, -180, -180), new TGCVector3(180, 180, 180), TGCVector3.Empty);
Camera = new TgcRotationalCamera(TGCVector3.Empty, 200f, Input);
}
public override void Init()
{
//Directorio de texturas
texturePath = MediaDir + "Texturas\\Particles\\";
//Texturas de particulas a utilizar
textureNames = new[]
{
"pisada.png",
"fuego.png",
"humo.png",
"hoja.png",
"agua.png",
"nieve.png"
};
//Modifiers
textureModifier = AddInterval("texture", textureNames, 0);
cantidadModifier = AddInt("cantidad", 1, 30, 10);
minSizeModifier = AddFloat("minSize", 0.25f, 10, 4);
maxSizeModifier = AddFloat("maxSize", 0.25f, 10, 6);
timeToLiveModifier = AddFloat("timeToLive", 0.25f, 2, 1);
frecuenciaModifier = AddFloat("frecuencia", 0.25f, 4, 1);
dispersionModifier = AddInt("dispersion", 50, 400, 100);
speedDirModifier = AddVertex3f("speedDir", new TGCVector3(-50, -50, -50), new TGCVector3(50, 50, 50), new TGCVector3(30, 30, 30));
//Crear emisor de particulas
selectedTextureName = textureNames[0];
selectedParticleCount = 10;
emitter = new ParticleEmitter(texturePath + selectedTextureName, selectedParticleCount);
emitter.Position = TGCVector3.Empty;
box = TGCBox.fromSize(new TGCVector3(0, -30, 0), new TGCVector3(10, 10, 10), Color.Blue);
Camara = new TgcRotationalCamera(TGCVector3.Empty, 300f, Input);
}
public override void Init()
{
//Crear loader
var loader = new TgcSceneLoader();
//Cargar mesh
var scene = loader.loadSceneFromFile(MediaDir + "ModelosTgc\\Olla\\Olla-TgcScene.xml");
mesh = scene.Meshes[0];
//Crear caja para indicar ubicacion de la luz
lightMesh = TGCBox.fromSize(new TGCVector3(20, 20, 20), Color.Yellow).ToMesh("Box");
//Modifiers de la luz
lightEnableModifier = AddBoolean("lightEnable", "lightEnable", true);
lightPosModifier = AddVertex3f("lightPos", new TGCVector3(-500, -500, -500), new TGCVector3(500, 800, 500), new TGCVector3(0, 500, 0));
ambientModifier = AddColor("ambient", Color.Gray);
diffuseModifier = AddColor("diffuse", Color.Blue);
specularModifier = AddColor("specular", Color.White);
specularExModifier = AddFloat("specularEx", 0, 40, 20f);
//Centrar camara rotacional respecto a este mesh
Camera = new TgcRotationalCamera(mesh.BoundingBox.calculateBoxCenter(), mesh.BoundingBox.calculateBoxRadius() * 2, Input);
}
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"
});
//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.AutoTransform = true;
//Configurar animacion inicial
personaje.playAnimation("StandBy", true);
//Escalarlo porque es muy grande
personaje.Position = new TGCVector3(0, 1000, -450);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.RotateY(Geometry.DegreeToRadian(180f));
//escalamos un poco el personaje.
personaje.Scale = new TGCVector3(0.75f, 0.75f, 0.75f);
//BoundingSphere que va a usar el personaje
personaje.AutoUpdateBoundingBox = false;
characterElipsoid = new TgcBoundingElipsoid(personaje.BoundingBox.calculateBoxCenter() + TGCVector3.Empty, new TGCVector3(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 TGCVector2(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 TGCVector2(2, 5);
//Caja para marcar punto de colision
collisionPoint = TGCBox.fromSize(new TGCVector3(4, 4, 4), Color.Red);
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(personaje.Position, new TGCVector3(0, 45, 0), 20, -120);
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
collisionsModifier = AddBoolean("Collisions", "Collisions", true);
showBoundingBoxModifier = AddBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
velocidadCaminarModifier = AddFloat("VelocidadCaminar", 0, 20, 2);
velocidadRotacionModifier = AddFloat("VelocidadRotacion", 1f, 360f, 150f);
habilitarGravedadModifier = AddBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
gravedadModifier = AddVertex3f("Gravedad", new TGCVector3(-5, -5, -5), new TGCVector3(5, 5, 5), new TGCVector3(0, -4, 0));
slideFactorModifier = AddFloat("SlideFactor", 0f, 2f, 1f);
pendienteModifier = AddFloat("Pendiente", 0f, 1f, 0.72f);
velocidadSaltoModifier = AddFloat("VelocidadSalto", 0f, 50f, 10f);
tiempoSaltoModifier = AddFloat("TiempoSalto", 0f, 2f, 0.5f);
UserVars.addVar("Movement");
}
public override void Init()
{
MyMediaDir = MediaDir + "WorkshopShaders\\";
MyShaderDir = ShadersDir + "WorkshopShaders\\";
//Crear loader
var loader = new TgcSceneLoader();
// Cargo la escena del cornell box.
scene = loader.loadSceneFromFile(MyMediaDir + "cornell_box\\cornell_box-TgcScene.xml");
mesh = scene.Meshes[0];
//Cargar Shader personalizado
effect = TGCShaders.Instance.LoadEffect(MyShaderDir + "PhongShading.fx");
// Pasos standard:
// le asigno el efecto a la malla
mesh.Effect = effect;
mesh.Technique = "DefaultTechnique";
viewportsModifier = AddBoolean("viewports", "See Viewports", false);
lightPositionModifier = AddVertex3f("LightPosition", new TGCVector3(-100, -100, -100), new TGCVector3(100, 100, 100), new TGCVector3(0, 40, 0));
ambientModifier = AddFloat("Ambient", 0, 1, 0.5f);
diffuseModifier = AddFloat("Diffuse", 0, 1, 0.6f);
specularModifier = AddFloat("Specular", 0, 1, 0.5f);
specularPowerModifier = AddFloat("SpecularPower", 1, 100, 16);
//Crear caja para indicar ubicacion de la luz
lightBox = TGCBox.fromSize(new TGCVector3(5, 5, 5), Color.Yellow);
// Creo 3 viewport, para mostrar una comparativa entre los metodos de iluminacion
Camara = new TgcRotationalCamera(new TGCVector3(20, 20, 0), 200, Input);
View1 = new Viewport();
View1.X = 0;
View1.Y = 0;
View1.Width = 400;
View1.Height = 250;
View1.MinZ = 0;
View1.MaxZ = 1;
View2 = new Viewport();
View2.X = 0;
View2.Y = 250;
View2.Width = 400;
View2.Height = 250;
View2.MinZ = 0;
View2.MaxZ = 1;
View3 = new Viewport();
View3.X = 400;
View3.Y = 0;
View3.Width = 400;
View3.Height = 250;
View3.MinZ = 0;
View3.MaxZ = 1;
ViewF = D3DDevice.Instance.Device.Viewport;
// Creo la luz para el fixed pipeline
D3DDevice.Instance.Device.Lights[0].Type = LightType.Point;
D3DDevice.Instance.Device.Lights[0].Diffuse = Color.FromArgb(255, 255, 255, 255);
D3DDevice.Instance.Device.Lights[0].Specular = Color.FromArgb(255, 255, 255, 255);
D3DDevice.Instance.Device.Lights[0].Attenuation0 = 0.0f;
D3DDevice.Instance.Device.Lights[0].Range = 50000.0f;
D3DDevice.Instance.Device.Lights[0].Enabled = true;
}
public override void Init()
{
//Crear loader
var loader = new TgcSceneLoader();
//Cargar mesh
scene = loader.loadSceneFromFile(MediaDir + "ModelosTgc\\Teapot\\Teapot-TgcScene.xml");
mesh = scene.Meshes[0];
mesh.Scale = TGCVector3.One;
mesh.Position = new TGCVector3(-100f, -5f, 0f);
// Arreglo las normales
var adj = new int[mesh.D3dMesh.NumberFaces * 3];
mesh.D3dMesh.GenerateAdjacency(0, adj);
mesh.D3dMesh.ComputeNormals(adj);
//Cargar Shader personalizado
effect = TGCShaders.Instance.LoadEffect(ShadersDir + "WorkshopShaders\\ToonShading.fx");
// le asigno el efecto a la malla
mesh.Effect = effect;
mesh.Technique = "DefaultTechnique";
// Creo las instancias de malla
instances = new List <TgcMesh>();
for (var i = -5; i < 5; i++)
{
for (var j = -5; j < 5; j++)
{
var instance = mesh.createMeshInstance(mesh.Name + i);
instance.Position = new TGCVector3(i * 50, (i + j) * 5, j * 50);
instance.Transform = TGCMatrix.Scaling(instance.Scale)
* TGCMatrix.RotationYawPitchRoll(instance.Rotation.X, instance.Rotation.Y, instance.Rotation.Z)
* TGCMatrix.Translation(instance.Position);
instances.Add(instance);
}
}
blurActivatedModifier = AddBoolean("blurActivated", "activar blur", false);
lightPositionModifier = AddVertex3f("LightPosition", new TGCVector3(-100, -100, -100), new TGCVector3(100, 100, 100), new TGCVector3(0, 40, 0));
ambientModifier = AddFloat("Ambient", 0, 1, 0.5f);
diffuseModifier = AddFloat("Diffuse", 0, 1, 0.6f);
specularModifier = AddFloat("Specular", 0, 1, 0.5f);
specularPowerModifier = AddFloat("SpecularPower", 1, 100, 16);
Camera = new TgcRotationalCamera(new TGCVector3(20, 20, 0), 300, TgcRotationalCamera.DEFAULT_ZOOM_FACTOR, 1.5f, Input);
// Creo un depthbuffer sin multisampling, para que sea compatible con el render to texture
// Nota:
// El render to Texture no es compatible con el multisampling en dx9
// Por otra parte la mayor parte de las placas de ultima generacion no soportan
// mutisampling para texturas de punto flotante con lo cual
// hay que suponer con generalidad que no se puede usar multisampling y render to texture
// Para resolverlo hay que crear un depth buffer que no tenga multisampling,
// (de lo contrario falla el zbuffer y se producen artifacts tipicos de que no tiene zbuffer)
// Si uno quisiera usar el multisampling, la tecnica habitual es usar un RenderTarget
// en lugar de una textura.
// Por ejemplo en c++:
//
// Render Target formato color buffer con multisampling
//
// g_pd3dDevice->CreateRenderTarget(Ancho,Alto,
// D3DFMT_A8R8G8B8, D3DMULTISAMPLE_2_SAMPLES, 0,
// FALSE, &g_pRenderTarget, NULL);
//
// Luego, ese RenderTarget NO ES una textura, y nosotros necesitamos acceder a esos
// pixeles, ahi lo que se hace es COPIAR del rendertartet a una textura,
// para poder trabajar con esos datos en el contexto del Pixel shader:
//
// Eso se hace con la funcion StretchRect:
// copia de rendertarget ---> sceneSurface (que es la superficie asociada a una textura)
// g_pd3dDevice->StretchRect(g_pRenderTarget, NULL, g_pSceneSurface, NULL, D3DTEXF_NONE);
//
// Esta tecnica se llama downsampling
// Y tiene el costo adicional de la transferencia de memoria entre el rendertarget y la
// textura, pero que no traspasa los limites de la GPU. (es decir es muy performante)
// no es lo mismo que lockear una textura para acceder desde la CPU, que tiene el problema
// de transferencia via AGP.
g_pDepthStencil = D3DDevice.Instance.Device.CreateDepthStencilSurface(D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, DepthFormat.D24S8, MultiSampleType.None, 0, true);
// inicializo el render target
g_pRenderTarget = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
effect.SetValue("g_RenderTarget", g_pRenderTarget);
// inicializo el mapa de normales
g_pNormals = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.A16B16G16R16F, Pool.Default);
effect.SetValue("g_Normals", g_pNormals);
// Resolucion de pantalla
effect.SetValue("screen_dx", D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth);
effect.SetValue("screen_dy", D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight);
//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(-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.Instance.Device, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
g_pVBV3D.SetData(vertices, 0, LockFlags.None);
}
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 override void Init()
{
time = 0f;
Device d3dDevice = D3DDevice.Instance.Device;
MyShaderDir = ShadersDir + "WorkshopShaders\\";
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(MediaDir + "WorkshopShaders\\comborata\\comborata-TgcScene.xml");
g_pBaseTexture = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\rocks.jpg");
g_pHeightmap = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_height_rocks.tga");
g_pBaseTexture2 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\stones.bmp");
g_pHeightmap2 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_height_stones.tga");
g_pBaseTexture3 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\granito.jpg");
g_pHeightmap3 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_height_saint.tga");
g_pBaseTexture4 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\granito.jpg");
g_pHeightmap4 = TextureLoader.FromFile(d3dDevice, MediaDir + "Texturas\\NM_four_height.tga");
foreach (TgcMesh mesh in scene.Meshes)
{
if (mesh.Name.Contains("Floor"))
{
rooms.Add(mesh.BoundingBox);
}
}
//Cargar Shader
string compilationErrors;
effect = Effect.FromFile(d3dDevice, MyShaderDir + "Parallax.fx", null, null, ShaderFlags.None, null, out compilationErrors);
if (effect == null)
{
throw new Exception("Error al cargar shader. Errores: " + compilationErrors);
}
lightDirModifier = AddVertex3f("LightDir", new TGCVector3(-1, -1, -1), new TGCVector3(1, 1, 1), TGCVector3.Down);
minSampleModifier = AddFloat("minSample", 1f, 10f, 10f);
maxSampleModifier = AddFloat("maxSample", 11f, 50f, 50f);
heightMapScaleModifier = AddFloat("HeightMapScale", 0.001f, 0.5f, 0.1f);
Camera = new TgcFpsCamera(new TGCVector3(147.2558f, 8.0f, 262.2509f), 100f, 10f, Input);
Camera.SetCamera(new TGCVector3(147.2558f, 8.0f, 262.2509f), new TGCVector3(148.2558f, 8.0f, 263.2509f));
//Cargar personaje con animaciones
TgcSkeletalLoader skeletalLoader = new TgcSkeletalLoader();
Random rnd = new Random();
// meto un enemigo por cada cuarto
cant_enemigos = 0;
foreach (TgcMesh mesh in scene.Meshes)
{
if (mesh.Name.Contains("Floor"))
{
float kx = rnd.Next(25, 75) / 100.0f;
float kz = rnd.Next(25, 75) / 100.0f;
float pos_x = mesh.BoundingBox.PMin.X * kx + mesh.BoundingBox.PMax.X * (1 - kx);
float pos_z = mesh.BoundingBox.PMin.Z * kz + mesh.BoundingBox.PMax.Z * (1 - kz);
TgcSkeletalMesh enemigo = skeletalLoader.loadMeshAndAnimationsFromFile(MediaDir + "SkeletalAnimations\\BasicHuman\\" + "CombineSoldier-TgcSkeletalMesh.xml", MediaDir + "SkeletalAnimations\\BasicHuman\\", new string[] { MediaDir + "SkeletalAnimations\\BasicHuman\\Animations\\" + "Walk-TgcSkeletalAnim.xml", });
enemigos.Add(enemigo);
//Configurar animacion inicial
enemigos[cant_enemigos].playAnimation("Walk", true);
enemigos[cant_enemigos].Position = new TGCVector3(pos_x, 1f, pos_z);
enemigos[cant_enemigos].Scale = new TGCVector3(0.3f, 0.3f, 0.3f);
enemigos[cant_enemigos].Transform = TGCMatrix.Scaling(enemigos[cant_enemigos].Scale) *
TGCMatrix.RotationYawPitchRoll(enemigos[cant_enemigos].Rotation.Y, enemigos[cant_enemigos].Rotation.X, enemigos[cant_enemigos].Rotation.Z) *
TGCMatrix.Translation(enemigos[cant_enemigos].Position);
enemigo_an[cant_enemigos] = 0;
cant_enemigos++;
}
}
// levanto el GUI
float W = D3DDevice.Instance.Width;
float H = D3DDevice.Instance.Height;
gui.Create(MediaDir);
gui.InitDialog(false);
gui.InsertFrame("Combo Rata", 10, 10, 200, 200, Color.FromArgb(32, 120, 255, 132), frameBorder.sin_borde);
gui.InsertFrame("", 10, (int)H - 150, 200, 140, Color.FromArgb(62, 120, 132, 255), frameBorder.sin_borde);
gui.cursor_izq = gui.cursor_der = tipoCursor.sin_cursor;
// le cambio el font
gui.font.Dispose();
// Fonts
gui.font = new Microsoft.DirectX.Direct3D.Font(d3dDevice, 12, 0, FontWeight.Bold, 0, false, CharacterSet.Default, Precision.Default, FontQuality.Default, PitchAndFamily.DefaultPitch, "Lucida Console");
gui.font.PreloadGlyphs('0', '9');
gui.font.PreloadGlyphs('a', 'z');
gui.font.PreloadGlyphs('A', 'Z');
gui.RTQ = gui.rectToQuad(0, 0, W, H, 0, 0, W - 150, 160, W - 200, H - 150, 0, H);
}
public override void Init()
{
//Cargar textura de CubeMap para Environment Map
cubeMap = TextureLoader.FromCubeFile(D3DDevice.Instance.Device, MediaDir + "CubeMap.dds");
//Crear 3 paredes y un piso con textura comun y textura de normalMap
var diffuseMap = TgcTexture.createTexture(MediaDir + "Texturas//BM_DiffuseMap_pared.jpg");
var normalMap = TgcTexture.createTexture(MediaDir + "Texturas//BM_NormalMap.jpg");
TgcTexture[] normalMapArray = { normalMap };
var paredSur = TGCBox.fromExtremes(new TGCVector3(-200, 0, -210), new TGCVector3(200, 100, -200), diffuseMap);
paredSur.Transform = TGCMatrix.Translation(paredSur.Position);
var paredOeste = TGCBox.fromExtremes(new TGCVector3(-210, 0, -200), new TGCVector3(-200, 100, 200), diffuseMap);
paredOeste.Transform = TGCMatrix.Translation(paredOeste.Position);
var paredEste = TGCBox.fromExtremes(new TGCVector3(200, 0, -200), new TGCVector3(210, 100, 200), diffuseMap);
paredEste.Transform = TGCMatrix.Translation(paredEste.Position);
var piso = TGCBox.fromExtremes(new TGCVector3(-200, -1, -200), new TGCVector3(200, 0, 200), diffuseMap);
piso.Transform = TGCMatrix.Translation(piso.Position);
//Convertir TgcBox a TgcMesh
var m1 = paredSur.ToMesh("paredSur");
var m2 = paredOeste.ToMesh("paredOeste");
var m3 = paredEste.ToMesh("paredEste");
var m4 = piso.ToMesh("piso");
//Convertir TgcMesh a TgcMeshBumpMapping
meshes = new List <TgcMeshBumpMapping>();
meshes.Add(TgcMeshBumpMapping.fromTgcMesh(m1, normalMapArray));
meshes.Add(TgcMeshBumpMapping.fromTgcMesh(m2, normalMapArray));
meshes.Add(TgcMeshBumpMapping.fromTgcMesh(m3, normalMapArray));
meshes.Add(TgcMeshBumpMapping.fromTgcMesh(m4, normalMapArray));
//Borrar TgcMesh y TgcBox, ya no se usan
paredSur.Dispose();
paredOeste.Dispose();
paredEste.Dispose();
piso.Dispose();
m1.Dispose();
m2.Dispose();
m3.Dispose();
m4.Dispose();
//Camara en 1ra persona
Camera = new TgcFpsCamera(new TGCVector3(200, 60, 50), Input);
//Cargar Shader personalizado para EnviromentMap
effect = TGCShaders.Instance.LoadEffect(ShadersDir + "EnvironmentMap.fx");
//Cargar shader en meshes
foreach (var m in meshes)
{
m.Effect = effect;
m.Technique = "EnvironmentMapTechnique";
}
//Mesh para la luz
lightMesh = TGCBox.fromSize(new TGCVector3(10, 10, 10), Color.Red);
reflectionModifier = AddFloat("reflection", 0, 1, 0.35f);
bumpinessModifier = AddFloat("bumpiness", 0, 1, 1f);
lightPosModifier = AddVertex3f("lightPos", new TGCVector3(-200, 0, -200), new TGCVector3(200, 100, 200), new TGCVector3(0, 80, 0));
lightColorModifier = AddColor("lightColor", Color.White);
lightIntensityModifier = AddFloat("lightIntensity", 0, 150, 20);
lightAttenuationModifier = AddFloat("lightAttenuation", 0.1f, 2, 0.3f);
specularExModifier = AddFloat("specularEx", 0, 20, 9f);
mEmissiveModifier = AddColor("mEmissive", Color.Black);
mAmbientModifier = AddColor("mAmbient", Color.White);
mDiffuseModifier = AddColor("mDiffuse", Color.White);
mSpecularModifier = AddColor("mSpecular", Color.White);
}
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.AutoTransform = true;
//Configurar animacion inicial
personaje.playAnimation("Parado", true);
//Escalarlo porque es muy grande
personaje.Position = new TGCVector3(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 TGCVector3(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 TGCVector2(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 TGCVector2(2, 5);
//Caja para marcar punto de colision
collisionPoint = TGCBox.fromSize(new TGCVector3(4, 4, 4), Color.Red);
collisionPoint.AutoTransform = true;
//Crear manejador de colisiones
collisionManager = new SphereTriangleCollisionManager();
collisionManager.GravityEnabled = true;
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(personaje.Position, new TGCVector3(0, 45, 0), 35, -150);
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
collisionsModifier = AddBoolean("Collisions", "Collisions", true);
showBoundingBoxModifier = AddBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
velocidadCaminarModifier = AddFloat("VelocidadCaminar", 0, 10, 2);
velocidadRotacionModifier = AddFloat("VelocidadRotacion", 1f, 360f, 150f);
habilitarGravedadModifier = AddBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
gravedadModifier = AddVertex3f("Gravedad", new TGCVector3(-5, -10, -5), new TGCVector3(5, 5, 5), new TGCVector3(0, -6, 0));
slideFactorModifier = AddFloat("SlideFactor", 0f, 2f, 1f);
pendienteModifier = AddFloat("Pendiente", 0f, 1f, 0.7f);
velocidadSaltoModifier = AddFloat("VelocidadSalto", 0f, 10f, 2f);
tiempoSaltoModifier = AddFloat("TiempoSalto", 0f, 2f, 0.5f);
UserVars.addVar("Movement");
UserVars.addVar("ySign");
}
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 TGCVector3(0.1f, 0.1f, 0.1f);
avion.Position = new TGCVector3(100f, 100f, 0f);
avion.Transform = TGCMatrix.Scaling(avion.Scale) * TGCMatrix.Translation(avion.Position);
dir_avion = new TGCVector3(0, 0, 1);
//Cargar Shader personalizado
effect = TGCShaders.Instance.LoadEffect(MyShaderDir + "ShadowMap.fx");
// le asigno el efecto a las mallas
foreach (var T in scene.Meshes)
{
T.Scale = TGCVector3.One;
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 = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(80), aspectRatio, 50, 5000);
D3DDevice.Instance.Device.Transform.Projection = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f), aspectRatio, near_plane, far_plane).ToMatrix();
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new TGCVector2(2f, 2f);
arrow.BodyColor = Color.Blue;
float K = 300;
lightLookFromModifier = AddVertex3f("LightLookFrom", new TGCVector3(-K, -K, -K), new TGCVector3(K, K, K), new TGCVector3(80, 120, 0));
lightLookAtModifier = AddVertex3f("LightLookAt", new TGCVector3(-K, -K, -K), new TGCVector3(K, K, K), TGCVector3.Empty);
var rotCamera = new TgcRotationalCamera(scene.Meshes[0].BoundingBox.calculateBoxCenter(), scene.Meshes[0].BoundingBox.calculateBoxRadius() * 2, Input);
rotCamera.CameraCenter = rotCamera.CameraCenter + new TGCVector3(0, 50f, 0);
rotCamera.CameraDistance = 300;
rotCamera.RotationSpeed = 50f;
Camera = rotCamera;
}
