public static Eixos2 operator +(Eixos2 a, Eixos2 b)
{
Eixos2 ret = (Eixos2)a.NovaInstancia();
ret.X = a.X + b.X;
ret.Y = a.Y + b.Y;
return(ret);
}
public Eixos2(Eixos2 eixos)
{
Obj = eixos.Obj;
this.X = eixos.X;
this.Y = eixos.Y;
Nome = eixos.Nome;
Tag = eixos.Tag;
}
/// <summary>
/// Obtém a posição no espaço 2D através da coordenada x e y da tela
/// </summary>
/// <param name="cam"></param>
/// <param name="mouseXY"></param>
/// <returns>Retorna ponto 2d pela coordenada X e Y da tela</returns>
public static Eixos2 ObterPosEspaco2DMouseXY(
this Camera2D cam, Eixos2 mouseXY)
{
Vetor2 PosCamZoomDiff = new Vetor2();
PosCamZoomDiff = cam.Pos / cam.PosZ * cam.ZoomCamera - cam.Pos;
float x = cam.Left + mouseXY.X + PosCamZoomDiff.X;
float y = cam.Top + mouseXY.Y + PosCamZoomDiff.Y;
Vetor2 ponto = new Vetor2(x * cam.PosZ / cam.ZoomCamera, y * cam.PosZ / cam.ZoomCamera); // Reduz escala para tamanho real em 2D
Eixos2 ponto2D = Util2D.RotacionarPonto2D(cam.Pos, ponto, cam.Angulo.Z); // Rotaciona ponto no tamanho real
return(ponto2D);
}
public static PointF ObterXYTelaPeloEspaco2D(this Camera2D cam, Eixos2 pos2D)
{
Vetor2 PosCam = new Vetor2(cam.Pos);
Vetor2 PosCamZoomDiff = new Vetor2();
PosCamZoomDiff = cam.Pos / cam.PosZ * cam.ZoomCamera - cam.Pos;
Vetor2 globalPos = (Vetor2)pos2D * cam.ZoomCamera / cam.PosZ;
Eixos2 rot = Util2D.RotacionarPonto2D(PosCam * cam.ZoomCamera / cam.PosZ,
globalPos, -cam.Angulo.Z);
PointF pontoTela = new PointF();
pontoTela.X = -cam.Left - PosCamZoomDiff.X + rot.X;
pontoTela.Y = -cam.Top - PosCamZoomDiff.Y + rot.Y;
return(pontoTela);
}
/// <summary>
/// Obtém objetos no espaço 2D conforme a seleção pela tela da câmera
/// </summary>
/// <param name="engine"></param>
/// <param name="cam"></param>
/// <param name="verticesTela"></param>
/// <returns></returns>
public static IEnumerable <Objeto2D> ObterObjetos2DMouseXY(this EpicoGraphics engine, Camera2D cam, params Vertice2[] verticesTela)
{
for (int i = 0; i < verticesTela.Length; i++)
{
// Converte X e Y da tela para as coordenadas X e Y no mundo 2D
Eixos2 xy = ObterPosEspaco2DMouseXY(cam, verticesTela[i]);
verticesTela[i].X = xy.X;
verticesTela[i].Y = xy.Y;
}
for (int i = 0; i < engine.objetos2D.Count; i++)
{
if (IntersecaoEntrePoligonos(verticesTela,
engine.objetos2D[i].Vertices.Select(x => new Vertice2(x.Global.X, x.Global.Y)).ToArray()))
{
yield return(engine.objetos2D[i]);
}
}
}
/// <summary>
/// Interseção entre uma reta e um retângulo
/// </summary>
/// <param name="pontoA"></param>
/// <param name="pontoB"></param>
/// <param name="minX"></param>
/// <param name="minY"></param>
/// <param name="maxX"></param>
/// <param name="maxY"></param>
/// <returns></returns>
public static bool IntersecaoRetaRetangulo(Eixos2 pontoA, Eixos2 pontoB, float minX, float minY, float maxX, float maxY)
{
// Completamente fora!
if ((pontoA.X <= minX && pontoB.X <= minX) || (pontoA.Y <= minY && pontoB.Y <= minY) ||
(pontoA.X >= maxX && pontoB.X >= maxX) || (pontoA.Y >= maxY && pontoB.Y >= maxY))
{
return(false);
}
float m = (pontoB.Y - pontoA.Y) / (pontoB.X - pontoA.X);
float y = m * (minX - pontoA.X) + pontoA.Y;
if (y >= minY && y <= maxY)
{
return(true);
}
y = m * (maxX - pontoA.X) + pontoA.Y;
if (y >= minY && y <= maxY)
{
return(true);
}
float x = (minY - pontoA.Y) / m + pontoA.X;
if (x >= minX && x <= maxX)
{
return(true);
}
x = (maxY - pontoA.Y) / m + pontoA.X;
if (x >= minX && x <= maxX)
{
return(true);
}
return(false);
}
public static IEnumerable <Origem2> ObterOrigensObjeto2DPelaTela(this Camera2D cam, List <Objeto2D> objs, params Vertice2[] verticesTela)
{
for (int i = 0; i < verticesTela.Length; i++)
{
// Converte X e Y da tela para as coordenadas X e Y no mundo 2D
Eixos2 xy = ObterPosEspaco2DMouseXY(cam, verticesTela[i]);
verticesTela[i].X = xy.X;
verticesTela[i].Y = xy.Y;
}
for (int o = 0; o < objs.Count; o++)
{
Objeto2D obj = objs[o];
for (int i = 0; i < obj.Origens.Count; i++)
{
Origem2 origem = obj.Origens[i];
if (IntersecaoEntrePoligonos(verticesTela,
new Vertice2(origem.Global.X, origem.Global.Y)))
{
yield return(origem);
}
}
}
}
/// <summary>
/// Rotaciona um ponto 2D a partir de um ponto de origem
/// </summary>
/// <param name="origem">Ponto de origem do objeto</param>
/// <param name="p">Ponto a ser rotacionado</param>
/// <param name="graus">Diferença de ângulos no caso de rotação ou soma dos ângulo no caso de acoplamento de objetos.</param>
/// <returns></returns>
public static Eixos2 RotacionarPonto2D(Eixos2 origem, Eixos2 ponto, float graus)
{
return(RotacionarPonto2D(origem.X, origem.Y, ponto.X, ponto.Y, graus));
}
public static bool IntersecaoRetaRetangulo(Eixos2 pontoA, Eixos2 pontoB, RectangleF rect)
{
return(IntersecaoRetaRetangulo(pontoA, pontoB, rect.X, rect.Y, rect.Right, rect.Bottom));
}
public static float AnguloEntreDoisPontos(this Eixos2 pontoA, Eixos2 pontoB)
{
return(AnguloEntreDoisPontos(pontoA.X, pontoA.Y, pontoB.X, pontoB.Y));
}
public static float DistanciaEntreDoisPontos(this Eixos2 pontoA, Eixos2 pontoB)
{
return(DistanciaEntreDoisPontos(pontoA.X, pontoA.Y, pontoB.X, pontoB.Y));
}
public static Objeto2D ObterUnicoObjeto2DMouseXY(this EpicoGraphics engine, Camera2D camera, Eixos2 ponto)
{
return(ObterObjetos2DMouseXY(engine, camera, ponto).LastOrDefault());
}
public static IEnumerable <Objeto2D> ObterObjetos2DMouseXY(
this EpicoGraphics engine, Camera2D camera, Eixos2 ponto)
{
return(ObterObjetos2DMouseXY(engine, camera, new Vertice2(ponto.X, ponto.Y)));
}
public Vetor3(Eixos2 eixos2) : base(eixos2)
{
}
public Eixos2(ObjetoEpico Obj, Eixos2 eixos)
{
base.Obj = Obj;
this.X = eixos.X;
this.Y = eixos.Y;
}
public Vertice2(Eixos2 eixos2) : base(eixos2)
{
}
