public void renderScene(float elapsedTime, bool cubemap)
{
Device device = GuiController.Instance.D3dDevice;
//Renderizar terreno
if (!cubemap)
{
effect.Technique = "RenderSceneShadows";
terrain.executeRender(effect);
}
else
{
terrain.render();
}
//Renderizar SkyBox
skyBox.render();
barcoUser.render();
bool showQuadtree = (bool)GuiController.Instance.Modifiers["showQuadtree"];
quadtree.render(GuiController.Instance.Frustum, showQuadtree);
/*foreach (Enemigo elemento in enemigos)
* {
* elemento.getBarco().render();
* elemento.getIDBarco().render();
* }*/
if (!cubemap)
{
// dibujo el mesh
ship.Technique = "RenderScene";
ship.render();
}
}
public static void Render(EstadoRender Estado)
{
if (ParametrosDeConfiguracion.Embarcacion != EmbarcacionActual)
{
LoadEmbarcacion(ParametrosDeConfiguracion.Embarcacion);
}
if (!ParametrosDeConfiguracion.RenderBarco)
{
return;
}
Device d3dDevice = GuiController.Instance.D3dDevice;
CalcularFisica();
// cago la posicion a la camara para seguir al bote
if (!ParametrosDeConfiguracion.VerFrustumCulling)
{
GuiController.Instance.ThirdPersonCamera.Target = mesh.Position;
}
// material source para que el color del reflejo sea mejor
d3dDevice.RenderState.DiffuseMaterialSource = ColorSource.Color1;
d3dDevice.RenderState.SpecularMaterialSource = ColorSource.Color1;
d3dDevice.RenderState.AmbientMaterialSource = ColorSource.Color1;
if (ParametrosDeConfiguracion.RenderBoundingBoxes)
{
mesh.BoundingBox.setRenderColor(Color.Red);
mesh.BoundingBox.render();
}
mesh.render();
}
public void RenderScene(bool shadow)
{
foreach (var T in scene.Meshes)
{
if (shadow)
{
T.Technique = "RenderShadow";
}
else
{
T.Technique = "RenderScene";
}
T.render();
}
// avion
if (shadow)
{
avion.Technique = "RenderShadow";
}
else
{
avion.Technique = "RenderScene";
}
avion.render();
}
public void Render(Snipers scene)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
if (this.vidas == 0)
{
scene.GameOver();
}
if (!scope)
{
// dibuja el rifle enfrente del viewport, sacandole
// la matriz actual de vista
//
Matrix old_vm = d3dDevice.Transform.View;
d3dDevice.Transform.View = Matrix.Identity;
rifle.render();
d3dDevice.Transform.View = old_vm;
}
scene.PostProcessing.LensDistortion = scope;
scene.PostProcessing.LensRadius = scope_radius;
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
time += elapsedTime;
if (time > 1f)
{
Mesh d3dMesh = new Mesh(boxMesh.NumberTriangles, boxMesh.NumberVertices, MeshFlags.Managed, TgcSceneLoader.VertexColorVertexElements, d3dDevice);
TgcSceneLoader.VertexColorVertex[] origVert = (TgcSceneLoader.VertexColorVertex[])boxMesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, boxMesh.D3dMesh.NumberVertices);
boxMesh.D3dMesh.UnlockVertexBuffer();
TgcSceneLoader.VertexColorVertex[] newVert = (TgcSceneLoader.VertexColorVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.None, d3dMesh.NumberVertices);
for (int i = 0; i < origVert.Length; i++)
{
newVert[i] = origVert[i];
}
//d3dMesh.SetVertexBufferData(newVert, LockFlags.None);
d3dMesh.UnlockVertexBuffer();
boxMesh.changeD3dMesh(d3dMesh);
time = 0;
}
boxMesh.render();
}
public override void Render()
{
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene();
ClearTextures();
//Actualizar transformacion y renderizar el sol
sun.Transform = getSunTransform(ElapsedTime);
sun.render();
//Actualizar transformacion y renderizar la tierra
earth.Transform = getEarthTransform(ElapsedTime);
earth.render();
//Actualizar transformacion y renderizar la luna
moon.Transform = getMoonTransform(ElapsedTime, earth.Transform);
moon.render();
axisRotation += AXIS_ROTATION_SPEED * ElapsedTime;
earthAxisRotation += EARTH_AXIS_ROTATION_SPEED * ElapsedTime;
earthOrbitRotation += EARTH_ORBIT_SPEED * ElapsedTime;
moonOrbitRotation += MOON_ORBIT_SPEED * ElapsedTime;
//Limpiamos todas las transformaciones con la Matrix identidad
D3DDevice.Instance.Device.Transform.World = Matrix.Identity;
PostRender();
}
public override void Render()
{
PreRender();
time += ElapsedTime;
if (time > 1f)
{
var d3dMesh = new Mesh(boxMesh.NumberTriangles, boxMesh.NumberVertices, MeshFlags.Managed,
TgcSceneLoader.VertexColorVertexElements, D3DDevice.Instance.Device);
var origVert = (TgcSceneLoader.VertexColorVertex[])boxMesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, boxMesh.D3dMesh.NumberVertices);
boxMesh.D3dMesh.UnlockVertexBuffer();
var newVert = (TgcSceneLoader.VertexColorVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.None, d3dMesh.NumberVertices);
for (var i = 0; i < origVert.Length; i++)
{
newVert[i] = origVert[i];
}
d3dMesh.UnlockVertexBuffer();
boxMesh.changeD3dMesh(d3dMesh);
time = 0;
}
boxMesh.render();
PostRender();
}
private static void Render()
{
// Guardo la transformacion
Matrix old = Moneda.Transform;
Device d3dDevice = GuiController.Instance.D3dDevice;
// Adaptar la altura de la moneda a la marea + offset para que quede flotando
float Altura = Oceano.AplicarCPUShader(Moneda.Position).Y + 50f;
Matrix MatrizTraslacion = Matrix.Translation(Moneda.Position.X, Altura, Moneda.Position.Z);
// Acumular rotacion actual, sin pasarnos de una vuelta entera
rotacionY = (rotacionY + Geometry.DegreeToRadian(1)) % (float)(2 * Math.PI);
Matrix MatrizRotacion = Matrix.RotationYawPitchRoll(rotacionY, 0, 0);
// Aplicar transformaciones
Moneda.Transform = MatrizRotacion * MatrizTraslacion;
Moneda.BoundingBox.transform(Moneda.Transform);
// Render verdadero de la moneda
Moneda.render();
if (ParametrosDeConfiguracion.RenderBoundingBoxes)
{
Moneda.BoundingBox.setRenderColor(Color.Red);
Moneda.BoundingBox.render();
}
// Restaurar la transformacion
Moneda.Transform = old;
ContadorMonedas.Render();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Dibujar el modelo 3D
mesh.render();
}
public void renderScene(float elapsedTime, bool cubemap)
{
Device device = GuiController.Instance.D3dDevice;
//Renderizar terreno
terrain.render();
//Renderizar SkyBox
skyBox.render();
// dibujo el bosque
foreach (TgcMesh instance in bosque)
{
instance.render();
}
// avion
//avion.Technique = cubemap ? "RenderCubeMap" : "RenderScene";
avion.render();
if (!cubemap)
{
// dibujo el mesh
mesh.Technique = "RenderCubeMap";
mesh.render();
}
}
public override void Render()
{
//BackgroundColor
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene();
ClearTextures();
//Cargar variables shader
mesh.Effect.SetValue("ambientColor", ColorValue.FromColor(Color.Gray));
mesh.Effect.SetValue("diffuseColor", ColorValue.FromColor(Color.LightBlue));
mesh.Effect.SetValue("specularColor", ColorValue.FromColor(Color.White));
mesh.Effect.SetValue("specularExp", 10f);
mesh.Effect.SetValue("lightPosition", lightPos);
mesh.Effect.SetValue("eyePosition",
TgcParserUtils.vector3ToFloat4Array(Camara.Position));
mesh.rotateY(-ElapsedTime / 2);
mesh.render();
textHelp.render();
//Help
if (Input.keyPressed(Key.H))
{
helpForm.ShowDialog();
}
PostRender();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener rotacion de mesh (pasar a radianes)
float rotation = FastMath.ToRad((float)GuiController.Instance.Modifiers["rotation"]);
//Rotar mesh y rotar OBB. A diferencia del AABB, nosotros tenemos que mantener el OBB actualizado segun cada movimiento del mesh
Vector3 lastRot = mesh.Rotation;
float rotationDiff = rotation - lastRot.Y;
mesh.rotateY(rotationDiff);
obb.rotate(new Vector3(0, rotationDiff, 0));
//Actualizar posicion
Vector3 position = (Vector3)GuiController.Instance.Modifiers["position"];
Vector3 lastPos = mesh.Position;
Vector3 posDiff = position - lastPos;
mesh.move(posDiff);
obb.move(posDiff);
//Renderizar modelo
mesh.render();
//Renderizar obb
obb.render();
}
public override void Render()
{
PreRender();
//Obtener rotacion de mesh (pasar a radianes)
var rotation = FastMath.ToRad((float)Modifiers["rotation"]);
//Rotar mesh y rotar OBB. A diferencia del AABB, nosotros tenemos que mantener el OBB actualizado segun cada movimiento del mesh
var lastRot = mesh.Rotation;
var rotationDiff = rotation - lastRot.Y;
mesh.rotateY(rotationDiff);
obb.rotate(new Vector3(0, rotationDiff, 0));
//Actualizar posicion
var position = (Vector3)Modifiers["position"];
var lastPos = mesh.Position;
var posDiff = position - lastPos;
mesh.move(posDiff);
obb.move(posDiff);
//Renderizar modelo
mesh.render();
//Renderizar obb
obb.render();
PostRender();
}
public void render(float elapsedTime)
{
var matrizView = GuiController.Instance.D3dDevice.Transform.View;
if (bandera == false)
{
meshTrofeo.render();
}
else
{
meshTrofeo.rotateY(elapsedTime * velocidad);
velocidad = velocidad + (2 * elapsedTime);
meshTrofeo.move(new Vector3(0, 0.001f * velocidad, 0));
meshTrofeo.render();
}
meshMesa.render();
}
public void flotar(float random, float elapsedTime, float alturaOriginal, Boolean noRender)
{
mesh.Position = new Vector3(mesh.Position.X, alturaOriginal + random, mesh.Position.Z);
if (!encontrado && !noRender)
{
mesh.render();
}
}
public void render()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
calcularFisica();
meshBarco.render();
calcularDisparo();
}
public void render()
{
meshCanion.render();
if (elevacion_visible)
{
texto_elevacion.render();
}
}
public override void Render()
{
PreRender();
DrawText.drawText("Cantidad de elementos liberados: " + disposed, 5, 20, Color.Red);
//Renderisamos todo hasta que pase cierto tiempo y ahi liberamos todos los recursos.
if (time >= 0f && time < 30f)
{
var d3dMesh = new Mesh(boxMesh.NumberTriangles, boxMesh.NumberVertices, MeshFlags.Managed,
TgcSceneLoader.VertexColorVertexElements, D3DDevice.Instance.Device);
var origVert = (TgcSceneLoader.VertexColorVertex[])boxMesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, boxMesh.D3dMesh.NumberVertices);
boxMesh.D3dMesh.UnlockVertexBuffer();
var newVert = (TgcSceneLoader.VertexColorVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.None, d3dMesh.NumberVertices);
for (var i = 0; i < origVert.Length; i++)
{
newVert[i] = origVert[i];
newVert[i].Position.Y += time;
}
d3dMesh.UnlockVertexBuffer();
boxMesh.changeD3dMesh(d3dMesh);
//Render de todas las palmeras.
foreach (var m in meshes)
{
m.render();
}
//Render de una esena.
scene1.renderAll();
//Render de la caja.
boxMesh.render();
time += ElapsedTime;
}
else
{
//ATENCION ESTO QUE SIGUE es solo para el ejemplo este, no es buena practica invocar al dispose completo.
//En su lugar se puede invocar caso por caso segun las necidades.
//Hacemos el dispose 1 vez sola.
if (time != -1)
{
time = -1;
Dispose();
}
}
PostRender();
}
public override void Render()
{
PreRender();
//Dibujar el modelo 3D
mesh.render();
PostRender();
}
public override void Render(Item item, Effect shader)
{
if (Game.Current.IsMeshVisible)
{
Mesh.Technique = Game.Current.IsToonShaderEnabled ? "NormalMap" : _Technique;
Mesh.Effect = shader;
Mesh.render();
}
}
public override void render(float elapsedTime)
{
Device device = GuiController.Instance.D3dDevice;
Control panel3d = GuiController.Instance.Panel3d;
float aspectRatio = (float)panel3d.Width / (float)panel3d.Height;
time += elapsedTime;
// animo la pos del avion
float alfa = -time *Geometry.DegreeToRadian(115.0f);
avion.Position = new Vector3(80f * (float)Math.Cos(alfa), 20 - 20 * (float)Math.Sin(alfa), 80f * (float)Math.Sin(alfa));
dir_avion = new Vector3(-(float)Math.Sin(alfa), 0, (float)Math.Cos(alfa));
avion.Transform = CalcularMatriz(avion.Position, avion.Scale, dir_avion);
g_LightPos = (Vector3)GuiController.Instance.Modifiers["LightLookFrom"];
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
// dibujo la escena pp dicha
device.BeginScene();
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
// piso
scene.Meshes[0].Technique = "RenderScene";
scene.Meshes[0].render();
// dibujo las sombra del avion sobre el piso
effect.SetValue("matViewProj", device.Transform.View * device.Transform.Projection);
effect.SetValue("g_vLightPos", new Vector4(g_LightPos.X, g_LightPos.Y, g_LightPos.Z, 1));
device.RenderState.ZBufferEnable = false;
avion.Technique = "RenderShadows";
avion.render();
device.RenderState.ZBufferEnable = true;
// avion
avion.Technique = "RenderScene";
avion.render();
// dibujo la luz
box.setPositionSize(g_LightPos, new Vector3(5, 5, 5));
box.updateValues();
box.render();
device.EndScene();
}
public void render()
{
time += GuiController.Instance.ElapsedTime;
GuiController.Instance.CustomRenderEnabled = true;
mesh.Effect.SetValue("time", time);
mesh.Effect.Technique = "DIFFUSE_MAP";
mesh.render();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Renderizar modelo
mesh.render();
//Renderizar BoundingBox
mesh.BoundingBox.render();
}
public void render()
{
//Mesh.BoundingBox.render();
//obb.render();
var DrawText = new Core.Text.TgcText2D();
//DrawText.drawText("anguloFinal ", 0, 520, Color.White);
//DrawText.drawText((anguloFinal * 180 / (float)Math.PI).ToString(), 150, 520, Color.White);
Mesh.render();
}
public override void render()
{
if (editablePolyEnabled)
{
editablePoly.render();
}
else
{
mesh.render();
}
}
public void Render()
{
if (tgcMesh != null)
{
tgcMesh.render();
}
else
{
tgcSkeletalMesh.render();
}
}
public void renderScene(float elapsedTime, string Technique)
{
//Dibujamos todos los meshes del escenario
/*foreach (TgcMesh m in meshes)
* {
* m.Effect = effect;
* m.Technique = Technique;
* m.UpdateMeshTransform();
* m.render();
* }*/
var rnd = new Random(1);
pasto.Effect = effect;
pasto.Technique = Technique;
for (var i = 0; i < 10; ++i)
{
for (var j = 0; j < 10; ++j)
{
pasto.Position = new Vector3(-i * 200 + rnd.Next(0, 50), 0, -j * 200 + rnd.Next(0, 50));
pasto.Scale = new Vector3(3, 4 + rnd.Next(0, 4), 5);
pasto.UpdateMeshTransform();
//pasto.Transform = Matrix.Identity*Matrix.Scaling(3, 4 + rnd.Next(0, 4), 5) * Matrix.Translation(-i * 200 + rnd.Next(0, 50), 0, -j * 200 + rnd.Next(0, 50));
pasto.render();
}
}
arbusto.Effect = effect;
arbusto.Technique = Technique;
for (var i = 0; i < 5; ++i)
{
for (var j = 0; j < 5; ++j)
{
arbusto.Position = new Vector3(-i * 400 + rnd.Next(0, 50), 0, -j * 400 + rnd.Next(0, 50));
//arbusto.Transform = Matrix.Identity*Matrix.Translation(-i * 400 + rnd.Next(0, 50), 0, -j * 400 + rnd.Next(0, 50));
arbusto.UpdateMeshTransform();
arbusto.render();
}
}
arbol.Effect = effect;
arbol.Technique = Technique;
for (var i = 0; i < 3; ++i)
{
for (var j = 0; j < 3; ++j)
{
arbol.Position = new Vector3(-i * 700 + rnd.Next(0, 50), 0, -j * 700 + rnd.Next(0, 50));
//arbol.Transform = Matrix.Identity*Matrix.Translation(-i * 700 + rnd.Next(0, 50), 0, -j * 700 + rnd.Next(0, 50));
arbol.UpdateMeshTransform();
arbol.render();
}
}
}
public override void Render()
{
PreRender();
//Renderizar modelo
mesh.render();
//Renderizar BoundingBox
mesh.BoundingBox.render();
PostRender();
}
public override void Render()
{
PreRender();
//Dibujar el modelo 3D
mesh.render();
//Dibujar la escena entera
scene.renderAll();
PostRender();
}
public void Render(bool BB_activado)
{
plane.BoundingBox.scaleTranslate(GetPosition(), plane.Scale);
if (BB_activado)
{
plane.BoundingBox.render();
}
updateShaders();
plane.render();
exhaust.render();
}