/// <summary>
/// Trabalha o Zoom orientado a escala do objeto
/// </summary>
/// <param name="obj"></param>
/// <param name="zoom"></param>
/// <returns></returns>
private Objeto2D ZoomEscalaObjeto2D(Objeto2D obj, float zoom)
{
for (int i = 0; i < obj.Vertices.Length; i++)
{
obj.Vertices[i].x = (float)(Math.Sin(obj.Vertices[i].rad + Util.Angulo2Radiano(obj.Angulo)) * obj.Vertices[i].raio * zoom);
obj.Vertices[i].y = (float)(Math.Cos(obj.Vertices[i].rad + Util.Angulo2Radiano(obj.Angulo)) * obj.Vertices[i].raio * zoom);
}
obj.AtualizarXYMinMax();
return(obj);
}
/// <summary>
/// Trabalha o Zoom orientado a posição do objeto em relação ao centro da camera
/// </summary>
/// <param name="obj"></param>
/// <param name="zoom"></param>
/// <returns></returns>
private Objeto2D ZoomPosObjeto2D(Objeto2D obj, float zoom)
{
// TODO: Precisa rever este conceito. Há erro no cálculo!
float radZoom = Util.Angulo2Radiano(Util.AnguloEntreDoisPontos(Pos, obj.Pos));
float distZoom = (float)(Util.DistanciaEntreDoisPontos(Pos, obj.Pos) * zoom);
obj.Pos.x += (float)(Math.Cos(radZoom) * distZoom);
obj.Pos.y += (float)(Math.Sin(radZoom) * distZoom);
return(obj);
}
public bool Objeto2DVisivel(Objeto2D obj)
{
float xMax = -(Pos.x - ResWidth / 2) + obj.Pos.x + obj.XMax;
float xMin = -(Pos.x - ResWidth / 2) + obj.Pos.x + obj.XMin;
float yMax = -(Pos.y - ResHeigth / 2) + obj.Pos.y + obj.YMax;
float yMin = -(Pos.y - ResHeigth / 2) + obj.Pos.y + obj.YMin;
if (xMax >= 0 && xMin <= ResWidth)
{
if (yMax >= 0 && yMin <= ResHeigth)
{
return(true);
}
}
return(false);
}
public Bitmap Renderizar()
{
TempoDelta = DateTime.Now.Ticks - _tickRender; // Calcula o tempo delta (tempo de atraso)
_tickRender = DateTime.Now.Ticks;
if (ResWidth > 0 && ResHeigth > 0) // Janela não minimizada?
{
g.Clear(Color.Black);
// Obtém o fator da câmera conforme sua posição
fatorCam.X = (int)Pos.x - ResWidth / 2;
fatorCam.Y = (int)Pos.y - ResHeigth / 2;
for (int i = 0; i < engine.objetos.Count; i++)
{
Objeto2DRenderizar obj = engine.objetos[i] as Objeto2DRenderizar;
if (obj != null)
{
#region ZOOM
if (!DesligarSistemaZoom)
{
obj = (Objeto2DRenderizar)obj.Clone();
Objeto2D objZoom = ZoomEscalaObjeto2D(obj, ZoomCamera);
Objeto2D objPosZoom = ZoomPosObjeto2D(obj, ZoomCamera);
objZoom.Pos = objPosZoom.Pos;
}
#endregion
if (Objeto2DVisivel(obj))
{
if (obj.Mat_render.CorSolida.A > 0) // Pinta objeto materialmente visível
{
GraphicsPath preenche = new GraphicsPath(FillMode.Alternate);
preenche.AddLines(obj.Vertices.ToList().Select(ponto => new Point(
(int)(-fatorCam.X + obj.Pos.x + ponto.x),
(int)(-fatorCam.Y + obj.Pos.y + ponto.y))).ToArray());
g.FillPath(new SolidBrush(Color.FromArgb(obj.Mat_render.CorSolida.A, obj.Mat_render.CorSolida.R, obj.Mat_render.CorSolida.G, obj.Mat_render.CorSolida.B)), preenche);
}
// Materialização do objeto na Câmera
Material mat;
if (obj.Selecionado)
{
mat = obj.Mat_render_sel;
}
else
{
mat = obj.Mat_render;
}
if (mat.CorBorda.A > 0) // Desenha borda materialmente visível
{
// Cor da borda do objeto
pen.Color = Color.FromArgb(mat.CorBorda.A, mat.CorBorda.R, mat.CorBorda.G, mat.CorBorda.B);
pen.Width = mat.LarguraBorda;
for (int v = 1; v < obj.Vertices.Length; v++)
{
Vertice2D v1 = obj.Vertices[v - 1]; // Ponto A
Vertice2D v2 = obj.Vertices[v]; // Ponto B
// Desenha as linhas entre as vértices na câmera
pontoA.X = (int)(-fatorCam.X + obj.Pos.x + v1.x);
pontoA.Y = (int)(-fatorCam.Y + obj.Pos.y + v1.y);
pontoB.X = (int)(-fatorCam.X + obj.Pos.x + v2.x);
pontoB.Y = (int)(-fatorCam.Y + obj.Pos.y + v2.y);
g.DrawLine(pen, pontoA, pontoB);
}
}
}
}
}
// A iluminação deve ser renderizada após pintar todos os objetos.
for (int i = 0; i < engine.objetos.Count; i++)
{
Luz2DRenderizar luz = engine.objetos[i] as Luz2DRenderizar;
if (luz != null)
{
if (luz is LuzPonto)
{
if (Objeto2DVisivel(luz))
{
GraphicsPath preenche = new GraphicsPath();
preenche.AddLines(luz.Vertices.ToList().Select(ponto => new Point(
(int)(-fatorCam.X + luz.Pos.x + ponto.x),
(int)(-fatorCam.Y + luz.Pos.y + ponto.y))).ToArray());
PathGradientBrush pthGrBrush = new PathGradientBrush(preenche);
pthGrBrush.CenterColor = Color.FromArgb(luz.Cor.A, luz.Cor.R, luz.Cor.G, luz.Cor.B);
Color[] colors = { Color.FromArgb(0, 0, 0, 0) };
pthGrBrush.SurroundColors = colors;
g.FillPath(pthGrBrush, preenche);
}
}
}
// Sombras devem ser renderizadas após a renderização da iluminação
#region Sombras
#endregion
}
#region Exibe informações de depuração
if (engine.Debug)
{
g.DrawString(Nome.ToUpper(), font_debug, new SolidBrush(Color.Aquamarine), new Point(10, 10));
g.DrawString("FPS: " + FPS, font_debug, new SolidBrush(Color.Aquamarine), new Point(10, 30));
}
#endregion
}
#region Calcula o FPS
if (Environment.TickCount - _tickFPS >= 1000)
{
_tickFPS = Environment.TickCount;
FPS = _fps;
_fps = 0;
}
else
{
_fps++;
}
#endregion
#region Limita o FPS
// TODO: Limitar o FPS
#endregion
return(render);
}
/// <summary>
/// Centraliza a camera em cima do objeto alvo
/// </summary>
/// <param name="obj"></param>
public void FocarNoObjeto2D(Objeto2D obj)
{
Pos = obj.Pos;
}