/// <summary>
/// Dibujar objetos de la isla en forma optimizada, utilizando la grilla para Frustm Culling
/// </summary>
public void render(TgcFrustum frustum, bool debugEnabled, Escenario esc)
{
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
foreach (var mesh in modelos)
{
mesh.Enabled = false;
}
findVisibleMeshes(frustum);
DrawCount = 0;
//Renderizar
foreach (var mesh in modelos)
{
if (mesh.Enabled)
{
esc.RenderObject(mesh);
DrawCount++;
}
}
if (debugEnabled)
{
foreach (var debugBox in debugBoxes)
{
debugBox.Render();
}
}
}
public override void render(float elapsedTime)
{
bool frustumCullingEnabled = (bool)GuiController.Instance.Modifiers["culling"];
//Renderizar sin ninguna optimizacion
if (!frustumCullingEnabled)
{
tgcScene.renderAll();
GuiController.Instance.UserVars.setValue("Meshes renderizadas", tgcScene.Meshes.Count);
}
//Renderizar con Frustum Culling
else
{
//Analizar cada malla contra el Frustum - con fuerza bruta
TgcFrustum frustum = GuiController.Instance.Frustum;
int totalMeshes = 0;
foreach (TgcMesh mesh in tgcScene.Meshes)
{
//Nos ocupamos solo de las mallas habilitadas
if (mesh.Enabled)
{
//Solo mostrar la malla si colisiona contra el Frustum
TgcCollisionUtils.FrustumResult r = TgcCollisionUtils.classifyFrustumAABB(frustum, mesh.BoundingBox);
if (r != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh.render();
totalMeshes++;
}
}
}
//Actualizar cantidad de meshes dibujadas
GuiController.Instance.UserVars.setValue("Meshes renderizadas", totalMeshes);
}
}
//====================================
// Renderiza las imagenes
//====================================
public override void render(float Tiempo)
{
Device device = GuiController.Instance.D3dDevice;
//Mover mesh
//Vector3 meshPos = (Vector3)GuiController.Instance.Modifiers["MeshPos"];
//mesh4.Position = meshPos;
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//FRUSTUM CULLING
TgcFrustum frustum = GuiController.Instance.Frustum;
if (mesh4.Enabled)
{
//Solo mostrar la malla si colisiona contra el Frustum
TgcCollisionUtils.FrustumResult r = TgcCollisionUtils.classifyFrustumAABB(frustum, mesh4.BoundingBox);
if (r != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh4.render();
}
if (showBB)
{
mesh4.BoundingBox.render();
}
}
if (disparando)
{
disparar(Tiempo);
}
}
/// <summary>
/// Hacer visible las meshes de un nodo si es visible por el Frustum
/// </summary>
private void testChildVisibility(TgcFrustum frustum, QuadtreeNode childNode,
float boxLowerX, float boxLowerY, float boxLowerZ, float boxUpperX, float boxUpperY, float boxUpperZ)
{
//test frustum-box intersection
var caja = new TgcBoundingAxisAlignBox(
new TGCVector3(boxLowerX, boxLowerY, boxLowerZ),
new TGCVector3(boxUpperX, boxUpperY, boxUpperZ));
var distanceToCamera = caja.calculateBoxCenter() - Camera.Position;
if (TGCVector3.Length(distanceToCamera) > 10000 + caja.calculateBoxRadius())
{
return;
}
var c = TgcCollisionUtils.classifyFrustumAABB(frustum, caja);
//complementamente adentro: cargar todos los hijos directamente, sin testeos
if (c == TgcCollisionUtils.FrustumResult.INSIDE)
{
addAllLeafMeshes(childNode);
}
//parte adentro: seguir haciendo testeos con hijos
else if (c == TgcCollisionUtils.FrustumResult.INTERSECT)
{
findVisibleMeshes(frustum, childNode, boxLowerX, boxLowerY, boxLowerZ, boxUpperX, boxUpperY, boxUpperZ);
}
}
/// <summary>
/// Renderizar en forma optimizado utilizando el Quadtree para hacer FrustumCulling
/// </summary>
public void render(TgcFrustum frustum, bool debugEnabled, string name)
{
Vector3 pMax = sceneBounds.PMax;
Vector3 pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, quadtreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
//Renderizar
foreach (TgcMesh mesh in modelos)
{
if (mesh.Enabled && mesh.Name.Contains(name))
{
mesh.render();
mesh.Enabled = false;
GameManager.Instance.vegetacionVisible++;
if (debugEnabled)
{
mesh.BoundingBox.render();
}
}
}
if (debugEnabled)
{
foreach (TgcDebugBox debugBox in debugQuadtreeBoxes)
{
debugBox.render();
}
}
}
/// <summary>
/// Renderiza el terreno
/// </summary>
public void render()
{
TgcFrustum frustum = GuiController.Instance.Frustum;
for (int i = 0; i < vbTerrains.Count; i++)
{
TgcCollisionUtils.FrustumResult c = TgcCollisionUtils.classifyFrustumAABB(frustum, boundingBoxes[i]);
if (c == TgcCollisionUtils.FrustumResult.INSIDE || c == TgcCollisionUtils.FrustumResult.INTERSECT)
{
Vector3 centroBB = (boundingBoxes[i].PMax + boundingBoxes[i].PMin);
centroBB.Multiply(0.5f);
if (((CustomFpsCamera.Instance.eye - centroBB).Length() < CustomFpsCamera.FAR_PLANE / 1.5f))
{
renderTerrain(vbTerrains[i]);
GameManager.Instance.terrenosVisibles++;
}
}
bool drawBoundingBoxes = GameManager.Instance.drawBoundingBoxes;
if (drawBoundingBoxes)
{
boundingBoxes[i].render();
}
}
}
/// <summary>
/// Renderizar en forma optimizado utilizando el Octree para hacer FrustumCulling
/// </summary>
public void render(TgcFrustum frustum, bool debugEnabled)
{
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, octreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
//Renderizar
foreach (var mesh in modelos)
{
if (mesh.Enabled)
{
mesh.Render();
mesh.Enabled = false;
}
}
if (debugEnabled)
{
foreach (var debugBox in debugOctreeBoxes)
{
debugBox.Render();
}
}
}
/// <summary>
/// Renderizar en forma optimizado utilizando el Quadtree para hacer FrustumCulling
/// </summary>
public void render(TgcFrustum frustum, bool debugEnabled)
{
Vector3 pMax = sceneBounds.PMax;
Vector3 pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, quadtreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
//Renderizar
foreach (TgcMesh mesh in modelos)
{
if (mesh.Enabled)
{
mesh.render();
mesh.Enabled = false;
}
}
if (debugEnabled)
{
foreach (TgcDebugBox debugBox in debugQuadtreeBoxes)
{
debugBox.render();
}
}
}
/// <summary>
/// Recorrer recursivamente el Quadtree para encontrar los nodos visibles
/// </summary>
private void findVisibleMeshes(TgcFrustum frustum, QuadtreeNode node,
float boxLowerX, float boxLowerY, float boxLowerZ,
float boxUpperX, float boxUpperY, float boxUpperZ)
{
var children = node.children;
//es hoja, cargar todos los meshes
if (children == null)
{
selectLeafMeshes(node);
}
//recursividad sobre hijos
else
{
var midX = FastMath.Abs((boxUpperX - boxLowerX) / 2);
var midZ = FastMath.Abs((boxUpperZ - boxLowerZ) / 2);
//00
testChildVisibility(frustum, children[0], boxLowerX + midX, boxLowerY, boxLowerZ + midZ, boxUpperX,
boxUpperY, boxUpperZ);
//01
testChildVisibility(frustum, children[1], boxLowerX + midX, boxLowerY, boxLowerZ, boxUpperX, boxUpperY,
boxUpperZ - midZ);
//10
testChildVisibility(frustum, children[2], boxLowerX, boxLowerY, boxLowerZ + midZ, boxUpperX - midX,
boxUpperY, boxUpperZ);
//11
testChildVisibility(frustum, children[3], boxLowerX, boxLowerY, boxLowerZ, boxUpperX - midX, boxUpperY,
boxUpperZ - midZ);
}
}
/// <summary>
/// Hacer visible las meshes de un nodo si es visible por el Frustum
/// </summary>
private void testChildVisibility(TgcFrustum frustum, OctreeNode childNode,
float boxLowerX, float boxLowerY, float boxLowerZ, float boxUpperX, float boxUpperY, float boxUpperZ)
{
if (childNode == null)
{
return;
}
//test frustum-box intersection
var caja = new TgcBoundingAxisAlignBox(
new TGCVector3(boxLowerX, boxLowerY, boxLowerZ),
new TGCVector3(boxUpperX, boxUpperY, boxUpperZ));
var c = TgcCollisionUtils.classifyFrustumAABB(frustum, caja);
//complementamente adentro: cargar todos los hijos directamente, sin testeos
if (c == TgcCollisionUtils.FrustumResult.INSIDE)
{
addAllLeafMeshes(childNode);
}
//parte adentro: seguir haciendo testeos con hijos
else if (c == TgcCollisionUtils.FrustumResult.INTERSECT)
{
findVisibleMeshes(frustum, childNode, boxLowerX, boxLowerY, boxLowerZ, boxUpperX, boxUpperY, boxUpperZ);
}
}
/// <summary>
/// Actualiza la visibilidad de todos los modelos de las celdas.
/// Las modelos visibles se cargan como Enable = true, mientras que el
/// resto se deshabilita.
/// </summary>
/// <param name="cameraPos">Posición de la cámara</param>
public void updateVisibility(Vector3 cameraPos, TgcFrustum frustum)
{
//Armar Frustum para uso internor, en base al Frustum actual
var currentFrustumPlanes = new Plane[6];
currentFrustumPlanes = new Plane[6];
currentFrustumPlanes[0] = frustum.NearPlane;
currentFrustumPlanes[1] = frustum.FarPlane;
currentFrustumPlanes[2] = frustum.LeftPlane;
currentFrustumPlanes[3] = frustum.RightPlane;
currentFrustumPlanes[4] = frustum.BottomPlane;
currentFrustumPlanes[5] = frustum.TopPlane;
//Deshabilitar todas las celdas
foreach (var cell in Cells)
{
cell.Visited = false;
foreach (var connection in cell.Connections)
{
connection.Portal.Visited = false;
}
}
//Buscar la celda actual en la que se encuentra la cámara
var currentCell = findCellFromPoint(cameraPos);
if (currentCell == null)
{
return;
}
//Recorrer grafo de celdas desde la celda actual
currentCell.Visited = true;
traverseCellGraph(cameraPos, currentFrustumPlanes, currentCell);
}
override public void Render(TgcFrustum frustum)
{
ClearScreen();
skyBox.Render();
drawer.BeginDrawSprite();
//drawer.DrawSprite(spriteSubnautica);
drawer.DrawSprite(spriteBlackRectangle);
drawer.DrawSprite(title);
drawer.EndDrawSprite();
DrawTextSmall.drawText("Start", (int)x, yStartWord, colors[(int)pointer]);
DrawTextSmall.drawText("Exit", (int)x, yStartWord + yOffset, colors[(((int)pointer) + 1) % 2]);
DrawTextSmall.drawText("->", (int)x - 40, yStartWord + (int)pointer * yOffset, Color.OrangeRed);
if (Cheats.GodMode)
{
this.DrawTextSmall.drawText("God Mode", 300, 300, Color.Gold);
}
if (Cheats.StartingItems)
{
this.DrawTextSmall.drawText("Starting items", 300, 360, Color.Gold);
}
}
/// <summary>
/// Dibujar objetos de la isla en forma optimizada, utilizando la grilla para Frustm Culling
/// </summary>
public void render(TgcFrustum frustum, bool debugEnabled)
{
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
findVisibleMeshes(frustum);
//Renderizar
foreach (var mesh in modelos)
{
if (mesh.Enabled)
{
mesh.render();
mesh.Enabled = false;
}
}
if (debugEnabled)
{
foreach (var debugBox in debugBoxes)
{
debugBox.render();
}
}
}
/// <summary>
/// Renderizar en forma optimizado utilizando el Quadtree para hacer FrustumCulling
/// </summary>
public void render(TgcFrustum frustum, bool debugEnabled)
{
cantModelosRender = 0;
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, quadtreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
//Renderizar
foreach (var mesh in modelos)
{
if (mesh.Enabled)
{
mesh.Render();
mesh.Enabled = false;
cantModelosRender++;
}
}
/*
* if (debugEnabled)
* {
* foreach (var debugBox in debugQuadtreeBoxes)
* {
* debugBox.Render();
* }
* }
*/
}
public void Render(TgcCamera camera, TgcFrustum frustum)
{
var toRender = ToRender(camera.Position, frustum);
var elements = new List <Element>();
elements.AddRange(elementsToUpdate.FindAll(entity => entity.asCube().isIn(frustum)));
elements.ForEach(element => {
if (element.Mesh != null)
{
if (!element.HasDefaultShader())
{
element.Mesh.Effect = ShaderRepository.WorldWaterFog;
element.Mesh.Technique = "WorldWaterFog";
}
}
element.Render();
});
elementsRendered = elements.Count;
toRender.ForEach(chunk => chunk.Render());
shark.Mesh.Effect = ShaderRepository.WorldWaterFog;
shark.Mesh.Technique = "WorldWaterFog";
shark.Render();
//waterSurface.Render(camera.Position);
//Floor.Render();
}
public void render(float deltaTime, TgcFrustum frustum)
{
if (escenarioActual == -1)
{
return;
}
escenarios[escenarioActual].render(deltaTime, frustum);
}
/// <summary>
/// Actualiza modelos que se deberán dibujar
/// </summary>
/// <param name="frustum"></param>
public void update(TgcFrustum frustum)
{
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, octreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
}
/// <summary>
/// Crea todos los modulos necesarios de la aplicacion
/// </summary>
internal void initGraphics(MainForm mainForm, Control panel3d)
{
this.mainForm = mainForm;
this.panel3d = panel3d;
this.fullScreenPanel = new FullScreenPanel();
panel3d.Focus();
//Iniciar graficos
this.tgcD3dDevice = new TgcD3dDevice(panel3d);
this.texturesManager = new TgcTexture.Manager();
this.tgcD3dDevice.OnResetDevice(tgcD3dDevice.D3dDevice, null);
//Iniciar otras herramientas
this.texturesPool = new TgcTexture.Pool();
this.logger = new Logger(mainForm.LogConsole);
this.text3d = new TgcDrawText(tgcD3dDevice.D3dDevice);
this.tgcD3dInput = new TgcD3dInput(mainForm, panel3d);
this.fpsCamera = new TgcFpsCamera();
this.rotCamera = new TgcRotationalCamera();
this.thirdPersonCamera = new TgcThirdPersonCamera();
this.axisLines = new TgcAxisLines(tgcD3dDevice.D3dDevice);
this.userVars = new TgcUserVars(mainForm.getDataGridUserVars());
this.modifiers = new TgcModifiers(mainForm.getModifiersPanel());
this.elapsedTime = -1;
this.frustum = new TgcFrustum();
this.mp3Player = new TgcMp3Player();
this.directSound = new TgcDirectSound();
this.fog = new TgcFog();
this.currentCamera = this.rotCamera;
this.customRenderEnabled = false;
this.drawer2D = new TgcDrawer2D();
this.shaders = new TgcShaders();
//toogles
this.rotCamera.Enable = true;
this.fpsCamera.Enable = false;
this.thirdPersonCamera.Enable = false;
this.fpsCounterEnable = true;
this.axisLines.Enable = true;
//Cargar algoritmos
exampleLoader = new ExampleLoader();
examplesDir = System.Environment.CurrentDirectory + "\\" + ExampleLoader.EXAMPLES_DIR + "\\";
examplesMediaDir = examplesDir + "Media" + "\\";
alumnoEjemplosDir = System.Environment.CurrentDirectory + "\\" + "AlumnoEjemplos" + "\\";
alumnoEjemplosMediaDir = alumnoEjemplosDir + "AlumnoMedia" + "\\";
exampleLoader.loadExamplesInGui(mainForm.TreeViewExamples, new string[] { examplesDir, alumnoEjemplosDir });
//Cargar shaders del framework
this.shaders.loadCommonShaders();
//Cargar ejemplo default
TgcExample defaultExample = exampleLoader.getExampleByName(mainForm.Config.defaultExampleName, mainForm.Config.defaultExampleCategory);
executeExample(defaultExample);
}
internal void RenderDull(float elapsedTime)
{
terrain.Technique = "DullRender";
Device d3dDevice = GuiController.Instance.D3dDevice;
terrain.render();
TgcFrustum frustum = GuiController.Instance.Frustum;
}
public override void Render()
{
D3DDevice.Instance.Device.BeginScene();
TexturesManager.Instance.clearAll();
CurrentScene.Render(this.Frustum);
GameModel.frustum = this.Frustum;
PostRender();
}
public override void Render(TgcFrustum frustum)
{
if (stateID == StateID.CLOSED)
{
return;
}
drawer.BeginDrawSprite();
drawer.DrawSprite(darknessCover);
drawer.DrawSprite(PDA);
drawer.EndDrawSprite();
this.itemHighlighted = null;
if (stateID == StateID.OPENED)
{
bool hovering = false;
TGCVector2 baseVector = PDA.Position + new TGCVector2(375, 175);
drawer.BeginDrawSprite();
byte xOffset = 110;
byte yOffset = 110;
byte maxItemsPerLine = 5;
byte i = 0;
foreach (var item in character.Inventory.Items)
{
int x = i % maxItemsPerLine;
int y = i / maxItemsPerLine;
//text.drawText("-" + i++ + ": " + item.Name + " | " + item.Description + " | " + item.type.ToString(), 500, 300 + 30 * i, Color.White);
bubble.Position = baseVector + new TGCVector2(xOffset * x, yOffset * y);
if (cursorOverBubble())
{
bubble.Scaling = bubbleDefaultScale + GetScaleForSpriteByPixels(bubble, 10, 10);
item.Icon.Scaling = item.DefaultScale + GetScaleForSpriteByPixels(item.Icon, 10, 10);
hovering = true;
this.itemHighlighted = item;
}
else
{
bubble.Scaling = bubbleDefaultScale;
item.Icon.Scaling = item.DefaultScale;
}
CenterIconToCurrentBubble(item.Icon);
drawer.DrawSprite(bubble);
drawer.DrawSprite(item.Icon);
++i;
}
cursor.Color = hovering ? Color.Yellow : cursorDefaultColor;
drawer.DrawSprite(cursor);
drawer.EndDrawSprite();
}
}
public void render(float deltaTime, TgcFrustum frustum)
{
sprite.Begin(SpriteFlags.AlphaBlend | SpriteFlags.SortDepthFrontToBack);
var scaling = new TGCVector3((float)vp.Width / trustMe.Width, (float)vp.Height / trustMe.Height, 0);
sprite.Transform = TGCMatrix.Scaling(scaling);
sprite.Draw(trustMe.D3dTexture, Rectangle.Empty, Vector3.Empty, Vector3.Empty, Color.White);
sprite.End();
inicio.Render();
}
public override void Render(TgcFrustum frustum)
{
preRender();
drawer.BeginDrawSprite();
drawer.DrawSprite(darknessCover);
drawer.EndDrawSprite();
textBig.drawText("PAUSE", xTitle + 50, yTitle, Color.DarkGray);
textSmall.drawText("BACK TO THE GAME", xTitle, yTitle + yOffsetFirstOption, colors[(int)pointer]);
textSmall.drawText("GO TO START MENU", xTitle, yTitle + yOffsetFirstOption + ySecondOption, colors[(((int)pointer) + 1) % 2]);
textSmall.drawText("->", xTitle - 45, yTitle + yOffsetFirstOption + (int)pointer * ySecondOption, Color.White);
}
public void update(TgcFrustum frustum)
{
foreach (var modelo in modelos)
{
modelo.mesh.Enabled = false;
}
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, quadtreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
}
public void UpdateVisibleObjects(TgcFrustum frustum)
{
foreach (var objeto in objetos)
{
objeto.RenderEnabled = false;
} //???
var pMax = sceneBounds.PMax;
var pMin = sceneBounds.PMin;
findVisibleMeshes(frustum, QuadTreeRootNode,
pMin.X, pMin.Y, pMin.Z,
pMax.X, pMax.Y, pMax.Z);
}
protected CustomModel(UnderseaModel gameModel,
TgcCamera camera,
TgcD3dInput input,
string mediaDir,
string shadersDir,
TgcFrustum frustum,
TgcText2D drawText)
{
GameModel = gameModel;
Camera = camera;
Input = input;
MediaDir = mediaDir;
ShadersDir = shadersDir;
Frustum = frustum;
DrawText = drawText;
}
/// <summary>
/// Hacer FrustumCulling por fuerza bruta para detectar que modelos se ven
/// </summary>
private void doFrustumCulling()
{
TgcFrustum frustum = GuiController.Instance.Frustum;
foreach (SceneEditorMeshObject meshObj in meshObjects)
{
TgcCollisionUtils.FrustumResult r = TgcCollisionUtils.classifyFrustumAABB(frustum, meshObj.mesh.BoundingBox);
if (r == TgcCollisionUtils.FrustumResult.OUTSIDE)
{
meshObj.visible = false;
}
else
{
meshObj.visible = true;
}
}
}
internal void RenderBrigth(float elapsedTime)
{
TgcFrustum frustum = GuiController.Instance.Frustum;
foreach (Enemy enemigo in enemies)
{
TgcCollisionUtils.FrustumResult result = TgcCollisionUtils.classifyFrustumAABB(frustum, enemigo.mesh.BoundingBox);
if (result == TgcCollisionUtils.FrustumResult.INSIDE || result == TgcCollisionUtils.FrustumResult.INTERSECT)
{
enemigo.Render(elapsedTime);
}
}
proyectiles.ForEach(proyectil => proyectil.Render(elapsedTime));
quadTree.render(frustum, drawBoundingBoxes, "Oil");
}
/// <summary>
/// Activar modelos dentro de celdas visibles
/// </summary>
public void UpdateVisibleMeshes(TgcFrustum frustum)
{
for (int x = 0; x < grid.GetUpperBound(0); x++)
{
for (int y = 0; y < grid.GetUpperBound(1); y++)
{
for (int z = 0; z < grid.GetUpperBound(2); z++)
{
GrillaRegularNode node = grid[x, y, z];
TgcCollisionUtils.FrustumResult r = TgcCollisionUtils.classifyFrustumAABB(frustum, node.BoundingBox);
if (r != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
node.activateCellMeshes();
}
}
}
}
}
/// <summary>
/// Activar modelos dentro de celdas visibles
/// </summary>
private void findVisibleMeshes(TgcFrustum frustum)
{
for (var x = 0; x < grid.GetUpperBound(0); x++)
{
for (var y = 0; y < grid.GetUpperBound(1); y++)
{
for (var z = 0; z < grid.GetUpperBound(2); z++)
{
var node = grid[x, y, z];
var r = TgcCollisionUtils.classifyFrustumAABB(frustum, node.BoundingBox);
if (r != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
node.activateCellMeshes();
}
}
}
}
}
