public override void Render()
{
PreRender();
// Primero asignamos la transformacion de la base, esta solo se escala.
box.Transform = escalaBase;
box.render();
// Asignamos la transformacion del brazo, se escala ya que estamos utilizando siempre la misma caja
// y se aplica la transformacion calculada en update.
box.Transform = escalaBrazo * transformacionBrazo;
box.render();
// Asignamos la transformacion del antebrazo, se escala ya que estamos utilizando siempre la misma caja
// y se aplica la transformacion calculada en update.
box.Transform = escalaAntebrazo * transformacionAntebrazo;
box.render();
// Asignamos la transformacion de la mano, se escala ya que estamos utilizando siempre la misma caja
// y se aplica la transformacion calculada en update.
box.Transform = escalaPinza * transformacionPinzaIzquierda;
box.render();
// Asignamos la transformacion de la pinza, se escala ya que estamos utilizando siempre la misma caja
// y se aplica la transformacion calculada en update.
box.Transform = escalaPinza * transformacionPinzaDerecha;
box.render();
PostRender();
}
public override void Render()
{
PreRender();
// Primero asignamos la transformacion de la base, esta solo se escala.
box.Transform = escalaAvion * transformacionAvion;
box.render();
// Asignamos la transformacion del brazo, se escala ya que estamos utilizando siempre la misma caja
// y se aplica la transformacion calculada en update.
box.Transform = escalaHelice * transformacionHelice;
box.render();
PostRender();
}
public override void Render()
{
PreRender();
//Rotación Euler
var rotEuler = (Vector3)Modifiers["Rot-Euler"];
rotEuler.X = Geometry.DegreeToRadian(rotEuler.X);
rotEuler.Y = Geometry.DegreeToRadian(rotEuler.Y);
rotEuler.Z = Geometry.DegreeToRadian(rotEuler.Z);
boxEuler.Rotation = rotEuler;
//Rotación Quaternion
var rotQuat = (Vector3)Modifiers["Rot-Quaternion"];
rotQuat.X = Geometry.DegreeToRadian(rotQuat.X);
rotQuat.Y = Geometry.DegreeToRadian(rotQuat.Y);
rotQuat.Z = Geometry.DegreeToRadian(rotQuat.Z);
var q = Quaternion.RotationYawPitchRoll(rotQuat.Y, rotQuat.X, rotQuat.Z);
boxQuaternion.Transform = Matrix.RotationQuaternion(q) * Matrix.Translation(boxQuaternion.Position);
boxEuler.render();
boxQuaternion.render();
PostRender();
}
public override void render(float elapsedTime)
{
Device device = GuiController.Instance.D3dDevice;
Vector3 lightPosition = (Vector3)GuiController.Instance.Modifiers["LightPosition"];
//Cargar variables de shader globales a todos los objetos
mesh.Effect.SetValue("fvLightPosition", TgcParserUtils.vector3ToFloat3Array(lightPosition));
mesh.Effect.SetValue("fvEyePosition", TgcParserUtils.vector3ToFloat3Array(GuiController.Instance.RotCamera.getPosition()));
mesh.Effect.SetValue("fvAmbient", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["AmbientColor"]));
mesh.Effect.SetValue("fvDiffuse", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["DiffuseColor"]));
mesh.Effect.SetValue("fvSpecular", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["SpecularColor"]));
mesh.Effect.SetValue("fSpecularPower", (float)GuiController.Instance.Modifiers["SpecularPower"]);
//Mover mesh que representa la luz
lightBox.Position = lightPosition;
//Mover mesh
Vector3 meshPos = (Vector3)GuiController.Instance.Modifiers["MeshPos"];
mesh.Position = meshPos;
mesh.render();
lightBox.render();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
TgcKinectSkeletonData data = tgcKinect.update();
if (data.Active)
{
tgcKinect.DebugSkeleton.render(data.Current.KinectSkeleton);
Vector3 headPos = TgcKinectUtils.toVector3(data.Current.KinectSkeleton.Joints[JointType.Head].Position);
Vector3 centerPos = TgcKinectUtils.toVector3(data.Current.KinectSkeleton.Joints[JointType.HipCenter].Position);
float length = Vector3.Length(headPos - centerPos);
BigLogger.log("Length", length);
BigLogger.log("HipCenter", data.Current.CenterPos);
BigLogger.log("RightHandPos", data.Current.RightHandPos);
BigLogger.log("LefttHandPos", data.Current.LefttHandPos);
BigLogger.renderLog();
}
GuiController.Instance.UserVars["tracking"] = data.Active.ToString();
center.render();
bounds.render();
}
public void render(float elapsedTime)
{
this.time += elapsedTime;
box.render();
if (this.mostrarBounding)
{
box.BoundingBox.render();
}
foreach (IRenderObject componente in this.componentesEstaticos)
{
componente.render();
}
foreach (LimiteCancha limite in this.limitesCancha)
{
limite.render();
}
foreach (Luz lux in this.luces)
{
lux.render();
}
foreach (TgcBox cartel in this.carteles)
{
cartel.Effect.SetValue("time", time);
cartel.render();
}
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Actualizar valores cargados en modifiers
sprite.Position = (Vector2)GuiController.Instance.Modifiers["position"];
sprite.Scaling = (Vector2)GuiController.Instance.Modifiers["scaling"];
sprite.Rotation = FastMath.ToRad((float)GuiController.Instance.Modifiers["rotation"]);
//Dibujar box3D. Se deben dibujar primero todos los objetos 3D. Recien al final dibujar los Sprites
box.render();
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
sprite.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
}
/// <summary>
/// Dibujar el esqueleto de la malla
/// </summary>
protected void renderSkeletonMesh()
{
Device device = GuiController.Instance.D3dDevice;
Vector3 ceroVec = new Vector3(0, 0, 0);
//Dibujar huesos y joints
for (int i = 0; i < bones.Length; i++)
{
TgcSkeletalBone bone = bones[i];
//Renderizar Joint
TgcBox jointBox = skeletonRenderJoints[i];
jointBox.Transform = bone.MatFinal * this.transform;
jointBox.render();
//Modificar línea del bone
if (bone.ParentBone != null)
{
TgcLine boneLine = skeletonRenderBones[i];
boneLine.PStart = TgcVectorUtils.transform(ceroVec, bone.MatFinal * this.transform);
boneLine.PEnd = TgcVectorUtils.transform(ceroVec, bone.ParentBone.MatFinal * this.transform);
boneLine.updateValues();
}
}
//Dibujar bones
foreach (TgcLine boneLine in skeletonRenderBones)
{
if (boneLine != null)
{
boneLine.render();
}
}
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Rotación Euler
Vector3 rotEuler = (Vector3)GuiController.Instance.Modifiers["Rot-Euler"];
rotEuler.X = Geometry.DegreeToRadian(rotEuler.X);
rotEuler.Y = Geometry.DegreeToRadian(rotEuler.Y);
rotEuler.Z = Geometry.DegreeToRadian(rotEuler.Z);
boxEuler.Rotation = rotEuler;
//Rotación Quaternion
Vector3 rotQuat = (Vector3)GuiController.Instance.Modifiers["Rot-Quaternion"];
rotQuat.X = Geometry.DegreeToRadian(rotQuat.X);
rotQuat.Y = Geometry.DegreeToRadian(rotQuat.Y);
rotQuat.Z = Geometry.DegreeToRadian(rotQuat.Z);
Quaternion q = Quaternion.RotationYawPitchRoll(rotQuat.Y, rotQuat.X, rotQuat.Z);
boxQuaternion.Transform = Matrix.RotationQuaternion(q) * Matrix.Translation(boxQuaternion.Position);
boxEuler.render();
boxQuaternion.render();
}
public override void Render()
{
PreRender();
//Actualizar valores cargados en modifiers
animatedSprite.setFrameRate((float)Modifiers["frameRate"]);
animatedSprite.Position = (Vector2)Modifiers["position"];
animatedSprite.Scaling = (Vector2)Modifiers["scaling"];
animatedSprite.Rotation = FastMath.ToRad((float)Modifiers["rotation"]);
//Dibujar box3D. Se deben dibujar primero todos los objetos 3D. Recien al final dibujar los Sprites
box.render();
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
TgcDrawer2D.Instance.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
//Actualizamos el estado de la animacion y renderizamos
animatedSprite.updateAndRender(ElapsedTime);
//Finalizar el dibujado de Sprites
TgcDrawer2D.Instance.endDrawSprite();
PostRender();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Si hacen clic con el mouse, ver si hay colision RayAABB
if (GuiController.Instance.D3dInput.buttonPressed(TgcViewer.Utils.Input.TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Actualizar Ray de colisión en base a posición del mouse
pickingRay.updateRay();
//Testear Ray contra el AABB de todos los meshes
foreach (TgcBox box in boxes)
{
TgcBoundingBox aabb = box.BoundingBox;
//Ejecutar test, si devuelve true se carga el punto de colision collisionPoint
selected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionPoint);
if (selected)
{
selectedMesh = box;
break;
}
}
}
//Renderizar modelos
foreach (TgcBox box in boxes)
{
box.render();
}
//Renderizar BoundingBox del mesh seleccionado
if (selected)
{
//Render de AABB
selectedMesh.BoundingBox.render();
//Cargar punto de colision
GuiController.Instance.UserVars.setValue("CollP-X:", collisionPoint.X);
GuiController.Instance.UserVars.setValue("CollP-Y:", collisionPoint.Y);
GuiController.Instance.UserVars.setValue("CollP-Z:", collisionPoint.Z);
//Dibujar caja que representa el punto de colision
collisionPointMesh.Position = collisionPoint;
collisionPointMesh.render();
}
else
{
//Reset de valores
GuiController.Instance.UserVars.setValue("CollP-X:", 0);
GuiController.Instance.UserVars.setValue("CollP-Y:", 0);
GuiController.Instance.UserVars.setValue("CollP-Z:", 0);
}
}
/// <summary>
/// Método que se invoca todo el tiempo. Es el render-loop de una aplicación gráfica.
/// En este método se deben dibujar todos los objetos que se desean mostrar.
/// Antes de llamar a este método el framework limpia toda la pantalla.
/// Por lo tanto para que un objeto se vea hay volver a dibujarlo siempre.
/// La variable elapsedTime indica la cantidad de segundos que pasaron entre esta invocación
/// y la anterior de render(). Es útil para animar e interpolar valores.
/// </summary>
public override void render(float elapsedTime)
{
//Acceso a Device de DirectX. Siempre conviene tenerlo a mano. Suele ser pedido como parámetro de varios métodos
Device d3dDevice = GuiController.Instance.D3dDevice;
//Dibujar la caja en pantalla
box.render();
}
public override void Render()
{
PreRender();
box.render();
PostRender();
}
private void renderJuego(float elapsedTime, Device d3dDevice)
{
//Poner luz a los meshes
Vector3 posLuz = new Vector3(POS_SHIP.X - 10000, POS_SHIP.Y + 5000, POS_SHIP.Z - 25000);
lightMesh.Position = posLuz;
this.cargarLuces(posLuz);
lightMesh.render();
//Obtener valor modifier
heightOlas = (float)GuiController.Instance.Modifiers["heightOlas"];
//Device device = GuiController.Instance.D3dDevice;
time += elapsedTime;
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.DarkSlateBlue, 1.0f, 0);
update(elapsedTime, time);
terrain.render();
skyBox.render();
//skyBoundingBox.render();
// Cargar variables de shader, por ejemplo el tiempo transcurrido.
effect.SetValue("time", time);
effect.SetValue("height", heightOlas);
effect.SetValue("menorAltura", terrain.menorVerticeEnY);
effect.SetValue("offset", (float)(terrain.Center.Y * currentScaleY));
effect.SetValue("texHeightmap", TerrenoSimple.toTexture(currentHeightmap));
//GuiController.Instance.Logger.log("OFFSET: " + (terrain.Center.Y * currentScaleY).ToString() + "MENOR ALTURA: " + terrain.menorVerticeEnY);
efectoSombra.SetValue("time", time);
efectoSombra.SetValue("height", heightOlas);
efectoSombra.SetValue("menorAltura", terrain.menorVerticeEnY);
efectoSombra.SetValue("offset", (float)(terrain.Center.Y * currentScaleY));
efectoSombra.SetValue("texHeightmap", TerrenoSimple.toTexture(currentHeightmap));
agua.heightOlas = heightOlas;
agua.AlphaBlendEnable = true;
agua.render();
d3dDevice.Transform.World = Matrix.Identity;
TgcD3dInput input = GuiController.Instance.D3dInput;
if (input.keyPressed(Microsoft.DirectX.DirectInput.Key.L))
{
lloviendo = lloviendo ? false : true;
}
ship.renderizar();
shipContrincante.renderizar();
lluvia.render();
}
public override void render(float elapsedTime)
{
Device device = GuiController.Instance.D3dDevice;
//Actualzar posición de la luz
Vector3 lightPos = (Vector3)GuiController.Instance.Modifiers["lightPos"];
lightMesh.Position = lightPos;
Vector3 eyePosition = GuiController.Instance.FpsCamera.getPosition();
//Renderizar meshes
foreach (TgcMeshBumpMapping mesh in meshes)
{
//Cargar variables shader de la luz
mesh.Effect.SetValue("lightColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["lightColor"]));
mesh.Effect.SetValue("lightPosition", TgcParserUtils.vector3ToFloat4Array(lightPos));
mesh.Effect.SetValue("eyePosition", TgcParserUtils.vector3ToFloat4Array(eyePosition));
mesh.Effect.SetValue("lightIntensity", (float)GuiController.Instance.Modifiers["lightIntensity"]);
mesh.Effect.SetValue("lightAttenuation", (float)GuiController.Instance.Modifiers["lightAttenuation"]);
mesh.Effect.SetValue("bumpiness", (float)GuiController.Instance.Modifiers["bumpiness"]);
//Material
mesh.Effect.SetValue("materialEmissiveColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mEmissive"]));
mesh.Effect.SetValue("materialAmbientColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mAmbient"]));
mesh.Effect.SetValue("materialDiffuseColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mDiffuse"]));
mesh.Effect.SetValue("materialSpecularColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mSpecular"]));
mesh.Effect.SetValue("materialSpecularExp", (float)GuiController.Instance.Modifiers["specularEx"]);
//Renderizar modelo
mesh.render();
}
//Renderizar mesh de luz
lightMesh.render();
//Dibujar flechas de debug
bool showNormals = (bool)GuiController.Instance.Modifiers["showNormals"];
bool showTangents = (bool)GuiController.Instance.Modifiers["showTangents"];
bool showBinormals = (bool)GuiController.Instance.Modifiers["showBinormals"];
for (int i = 0; i < normals.Count; i++)
{
if (showNormals)
{
normals[i].render();
}
if (showTangents)
{
tangents[i].render();
}
if (showBinormals)
{
binormals[i].render();
}
}
}
/// <summary>
/// Dibujamos toda la escena pero en vez de a la pantalla, la dibujamos al Render Target con floating point.
/// De esa forma todos los calculos de iluminacion que superen 1.0 no son clampeados
/// </summary>
private void drawSceneToRenderTarget(Device d3dDevice)
{
Surface pSurf = sceneRT.GetSurfaceLevel(0);
d3dDevice.SetRenderTarget(0, pSurf);
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
//Arrancamos el renderizado
d3dDevice.BeginScene();
//Actualzar posición de la luz
Vector3 lightPos = (Vector3)GuiController.Instance.Modifiers["lightPos"];
lightMesh.Position = lightPos;
//Dibujar mesh de fuente de luz
lightMesh.Effect.Technique = "DrawLightSource";
lightMesh.render();
//Renderizar meshes
foreach (TgcMesh mesh in meshes)
{
mesh.Effect.Technique = "LightPass";
//Cargar variables shader de la luz
mesh.Effect.SetValue("lightPosition", TgcParserUtils.vector3ToFloat4Array(lightPos));
mesh.Effect.SetValue("eyePosition", TgcParserUtils.vector3ToFloat4Array(GuiController.Instance.FpsCamera.getPosition()));
mesh.Effect.SetValue("lightIntensity", (float)GuiController.Instance.Modifiers["lightIntensity"]);
//Cargar variables de shader de Material
mesh.Effect.SetValue("materialAmbientColor", ColorValue.FromColor(Color.DarkGray));
mesh.Effect.SetValue("materialSpecularExp", 9f);
//Renderizar modelo
mesh.render();
}
//Renderizar mesh de luz
lightMesh.render();
d3dDevice.EndScene();
pSurf.Dispose();
}
public override void Render()
{
PreRender();
boxEuler.render();
boxQuaternion.render();
PostRender();
}
/// <summary>
/// Dibujar vertices
/// </summary>
private void renderVertices(Matrix transform)
{
foreach (EditPolyVertex v in editablePoly.Vertices)
{
Vector3 pos = Vector3.TransformCoordinate(v.position, transform);
TgcBox box = v.Selected ? selectedVertexBox : vertexBox;
box.Position = pos /*+ new Vector3(0.5f, 0.5f, 0.5f)*/;
box.render();
}
}
public void render(TgcTerrainEditor editor)
{
if (Enabled)
{
configureTerrainEffect(editor.Terrain);
bBrush.render();
}
renderText();
editor.doRender();
}
public override void render(float elapsedTime)
{
Device device = GuiController.Instance.D3dDevice;
//Habilitar luz
bool lightEnable = (bool)GuiController.Instance.Modifiers["lightEnable"];
Effect currentShader;
if (lightEnable)
{
//Con luz: Cambiar el shader actual por el shader default que trae el framework para iluminacion dinamica con PointLight para Skeletal Mesh
currentShader = GuiController.Instance.Shaders.TgcSkeletalMeshPointLightShader;
}
else
{
//Sin luz: Restaurar shader default
currentShader = GuiController.Instance.Shaders.TgcSkeletalMeshShader;
}
//Aplicar al mesh el shader actual
mesh.Effect = currentShader;
//El Technique depende del tipo RenderType del mesh
mesh.Technique = GuiController.Instance.Shaders.getTgcSkeletalMeshTechnique(mesh.RenderType);
//Actualzar posición de la luz
Vector3 lightPos = (Vector3)GuiController.Instance.Modifiers["lightPos"];
lightMesh.Position = lightPos;
//Renderizar mesh
if (lightEnable)
{
//Cargar variables shader de la luz
mesh.Effect.SetValue("lightColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["lightColor"]));
mesh.Effect.SetValue("lightPosition", TgcParserUtils.vector3ToFloat4Array(lightPos));
mesh.Effect.SetValue("eyePosition", TgcParserUtils.vector3ToFloat4Array(GuiController.Instance.FpsCamera.getPosition()));
mesh.Effect.SetValue("lightIntensity", (float)GuiController.Instance.Modifiers["lightIntensity"]);
mesh.Effect.SetValue("lightAttenuation", (float)GuiController.Instance.Modifiers["lightAttenuation"]);
//Cargar variables de shader de Material. El Material en realidad deberia ser propio de cada mesh. Pero en este ejemplo se simplifica con uno comun para todos
mesh.Effect.SetValue("materialEmissiveColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mEmissive"]));
mesh.Effect.SetValue("materialAmbientColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mAmbient"]));
mesh.Effect.SetValue("materialDiffuseColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mDiffuse"]));
mesh.Effect.SetValue("materialSpecularColor", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["mSpecular"]));
mesh.Effect.SetValue("materialSpecularExp", (float)GuiController.Instance.Modifiers["specularEx"]);
}
mesh.animateAndRender();
//Renderizar mesh de luz
lightMesh.render();
}
public override void Render()
{
PreRender();
//Obtenemos acceso al objeto que maneja input de mouse y teclado del framework
var input = TgcD3dInput.Instance;
//Declaramos un vector de movimiento inicializado todo en cero.
//El movimiento sobre el suelo es sobre el plano XZ.
//El movimiento en altura es sobre el eje Y.
//Sobre XZ nos movemos con las flechas del teclado o con las letas WASD.
//Sobre el eje Y nos movemos con Space y Ctrl.
var movement = new Vector3(0, 0, 0);
//Movernos de izquierda a derecha, sobre el eje X.
if (input.keyDown(Key.Left) || input.keyDown(Key.A))
{
movement.X = 1;
}
else if (input.keyDown(Key.Right) || input.keyDown(Key.D))
{
movement.X = -1;
}
//Movernos arriba y abajo, sobre el eje Y.
if (input.keyDown(Key.Space))
{
movement.Y = 1;
}
else if (input.keyDown(Key.LeftControl) || input.keyDown(Key.RightControl))
{
movement.Y = -1;
}
//Movernos adelante y atras, sobre el eje Z.
if (input.keyDown(Key.Up) || input.keyDown(Key.W))
{
movement.Z = -1;
}
else if (input.keyDown(Key.Down) || input.keyDown(Key.S))
{
movement.Z = 1;
}
//Multiplicar movimiento por velocidad y elapsedTime
movement *= MOVEMENT_SPEED * ElapsedTime;
//Aplicar movimiento
box.move(movement);
box.render();
PostRender();
}
/// <summary>
/// Método que se invoca todo el tiempo. Es el render-loop de una aplicación gráfica.
/// En este método se deben dibujar todos los objetos que se desean mostrar.
/// Antes de llamar a este método el framework limpia toda la pantalla.
/// Por lo tanto para que un objeto se vea hay volver a dibujarlo siempre.
/// La variable elapsedTime indica la cantidad de segundos que pasaron entre esta invocación
/// y la anterior de render(). Es útil para animar e interpolar valores.
/// </summary>
public override void Render()
{
//Iniciamoss la escena
PreRender();
//Render de la super clase
//Dibujar la caja en pantalla
box.render();
//Finalizamos el renderizado de la escena
PostRender();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Renderizar suelo
suelo.render();
//Renderizar instancias
foreach (TgcMesh mesh in meshes)
{
mesh.render();
}
}
/// <summary>
/// Método que se invoca todo el tiempo. Es el render-loop de una aplicación gráfica.
/// En este método se deben dibujar todos los objetos que se desean mostrar.
/// Antes de llamar a este método el framework limpia toda la pantalla.
/// Por lo tanto para que un objeto se vea hay volver a dibujarlo siempre.
/// La variable elapsedTime indica la cantidad de segundos que pasaron entre esta invocación
/// y la anterior de render(). Es útil para animar e interpolar valores.
/// </summary>
public override void Render()
{
//Iniciamoss la escena
PreRender();
//Dibujar las cajas en pantalla
box1.render();
box2.render();
box3.render();
//Finalizamos el renderizado de la escena
PostRender();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Renderizar suelo
suelo.render();
//Renderizar original e instancias
original.animateAndRender();
foreach (TgcSkeletalMesh instance in instances)
{
instance.animateAndRender();
}
}
/// <summary>
/// Este render debe realizarse despues de renderizar el mapScene!
/// </summary>
public void Update()
{
Effect currentShader = TgcShaders.Instance.TgcMeshSpotLightShader;
foreach (var mesh in lstMeshes)
{
mesh.Effect = currentShader;
//El Technique depende del tipo RenderType del mesh
mesh.Technique = TgcShaders.Instance.getTgcMeshTechnique(mesh.RenderType);
}
ProcesarLuces();
lightMesh.render();
}
public override void Render()
{
PreRender();
//Renderizar suelo
suelo.render();
//Renderizar instancias
foreach (var mesh in meshes)
{
mesh.render();
}
PostRender();
}
public void renderizar()
{
#region RENDERIZAR ESCENARIO
skyBox.render();
lightMesh.render();
#endregion
#region RENDERIZAR PANTALLA
GuiController.Instance.Drawer2D.beginDrawSprite();
camara = (Boolean)GuiController.Instance.Modifiers["camaraEnBarco"];
if (camara)
{
animatedSprite2.Scaling = new Vector2(1.4f, 1.4f);
animatedSprite2.Position = new Vector2(traslacion, 0);
animatedSprite2.setFrameRate(3);
traslacion = traslacion + 12;
}
else
{
animatedSprite2.Scaling = new Vector2(0.4f, 0.4f);
animatedSprite2.Position = new Vector2(traslacion, screenSize.Height / 3);
animatedSprite2.setFrameRate(1);
traslacion = traslacion + 4;
}
if (traslacion > screenSize.Width)
{
animatedSprite2.dispose();
}
else
{
animatedSprite2.updateAndRender();
}
llueve = (Boolean)GuiController.Instance.Modifiers["lluvia"];
if (llueve)
{
animatedSprite.updateAndRender();
}
boton1.render();
boton2.render();
barra.render();
timon.render();
GuiController.Instance.Drawer2D.endDrawSprite();
#endregion
}
public override void Render()
{
PreRender();
//Habilitar luz
var lightEnable = (bool)Modifiers["lightEnable"];
Effect currentShader;
if (lightEnable)
{
//Con luz: Cambiar el shader actual por el shader default que trae el framework para iluminacion dinamica con PhongShading
currentShader = TgcShaders.Instance.TgcMeshPhongShader;
}
else
{
//Sin luz: Restaurar shader default
currentShader = TgcShaders.Instance.TgcMeshShader;
}
//Aplicar al mesh el shader actual
mesh.Effect = currentShader;
//El Technique depende del tipo RenderType del mesh
mesh.Technique = TgcShaders.Instance.getTgcMeshTechnique(mesh.RenderType);
//Actualzar posición de la luz
var lightPos = (Vector3)Modifiers["lightPos"];
lightMesh.Position = lightPos;
if (lightEnable)
{
//Cargar variables shader
mesh.Effect.SetValue("lightPosition", TgcParserUtils.vector3ToFloat4Array(lightPos));
mesh.Effect.SetValue("eyePosition", TgcParserUtils.vector3ToFloat4Array(Camara.Position));
mesh.Effect.SetValue("ambientColor", ColorValue.FromColor((Color)Modifiers["ambient"]));
mesh.Effect.SetValue("diffuseColor", ColorValue.FromColor((Color)Modifiers["diffuse"]));
mesh.Effect.SetValue("specularColor", ColorValue.FromColor((Color)Modifiers["specular"]));
mesh.Effect.SetValue("specularExp", (float)Modifiers["specularEx"]);
}
//Renderizar modelo
mesh.render();
//Renderizar mesh de luz
lightMesh.render();
PostRender();
}
public void render()
{
if (meshObj == null)
{
return;
}
boxX.render();
boxY.render();
boxZ.render();
if (selectedAxis != Axis.None)
{
selectedAxisBox.BoundingBox.render();
}
}