public Punto(double x, double y, double z, Punto origenCoordenadas)
{
this.X = x;
this.Y = y;
this.Z = z;
this.OrigenCoordenadas = origenCoordenadas;
}
public GuardabarroTren(
double ancho,
double largo,
double alto,
Punto posicion,
float[] luz,
float[] luzAmbiente,
float[] luzBrillo,
int shininess)
: base(ancho, largo, alto, posicion, luz, luzAmbiente, luzBrillo, shininess)
{
}
protected override Punto CalculateNormalForPunto(int posVertexActual, Punto verticeActual, int posSeccionActual, Seccion seccionActual)
{
Punto puntoNorte = null;
Punto puntoSur = null;
Punto puntoEste = null;
Punto puntoOeste = null;
if (posSeccionActual + 1 < (this.Width * this.VertexRatio) - 1) puntoNorte = this.secciones[posSeccionActual + 1].Vertices[posVertexActual];
if (posSeccionActual - 1 > 0) puntoSur = this.secciones[posSeccionActual - 1].Vertices[posVertexActual];
if (posVertexActual + 1 < (this.Height * this.VertexRatio) - 1) puntoEste = this.secciones[posSeccionActual].Vertices[posVertexActual + 1];
if (posVertexActual - 1 > 0) puntoOeste = this.secciones[posSeccionActual].Vertices[posVertexActual - 1];
return Punto.CalcularNormal(this.secciones[posSeccionActual].Vertices[posVertexActual], puntoNorte, puntoEste, puntoSur, puntoOeste, true);
}
public Punto(double x, double y, double z)
{
this.X = x;
this.Y = y;
this.Z = z;
Punto origen = new Punto();
origen.X = 0;
origen.Y = 0;
origen.Z = 0;
this.OrigenCoordenadas = origen;
}
public Figura(double ancho, double largo, double alto, Punto posicion, float[] luz, float[] luzAmbiente, float[] luzBrillo, int shininess)
{
this.LongitudX = ancho;
this.LongitudZ = alto;
this.LongitudY = largo;
this.Posicion = posicion;
this.Luz = luz;
this.LuzAmbiente = luzAmbiente;
this.LuzBrillo = luzBrillo;
this.Shininess = shininess;
this.CalcularDivisionesYPasos();
this.Generar();
}
public Rueda(
Punto centro,
Double anguloRotacion,
double radioInterno,
double radioExterno,
double ancho,
float[] luz,
float[] luzBrillo,
float[] luzAmbiente,
int shininess)
{
this.Centro = centro;
this.AnguloRotacion = anguloRotacion;
this.RadioExterno = radioExterno;
this.RadioInterno = radioInterno;
this.Luz = luz;
this.LuzAmbiente = luzAmbiente;
this.LuzBrillo = luzBrillo;
this.Ancho = ancho;
this.Shininess = shininess;
}
public static Arbol[] GenerarArbolesAleatorios(int cantidad)
{
Arbol[] arboles = new Arbol[cantidad];
for (int i = 0; i < cantidad; ++i)
{
Punto[] formaCopa = new Punto[FORMA_COPA_DEFAULT.Length];
for (int j = 0; j < formaCopa.Length; ++j)
{
if (j == 0 || j == formaCopa.Length - 1) // siempre terminan y empiezan en el mismo lugar
{
formaCopa[j] = new Punto(
Arbol.FORMA_COPA_DEFAULT[j].X,
Arbol.FORMA_COPA_DEFAULT[j].Y,
Arbol.FORMA_COPA_DEFAULT[j].Z
);
}
else
{
double nuevoX = Arbol.FORMA_COPA_DEFAULT[j].X + MathUtils.RandomBetween(0f, +2.0f);
double nuevoY = Arbol.FORMA_COPA_DEFAULT[j].Y;
double nuevoZ = Arbol.FORMA_COPA_DEFAULT[j].Z;
formaCopa[j] = new Punto(
nuevoX > MINIMO_RADIO ? nuevoX : MINIMO_RADIO,
nuevoY,
nuevoZ
);
}
}
double longitudTronco = LONGITUD_TRONCO_DEFAULT + MathUtils.RandomBetween(0f, +2.5f);
Arbol arbol = new Arbol(longitudTronco, formaCopa);
arboles[i] = arbol;
}
return arboles;
}
protected abstract Punto CompletarPunto(Punto puntoCentro);
protected override void GenerarNormales()
{
normales = new List <Punto>();
Boolean invertirNormal = false;
Punto puntoNorte = null;
Punto puntoSur = null;
Punto puntoEste = null;
Punto puntoOeste = null;
Punto puntoCentro = null;
if (Orientacion.Equals(OrientacionesCara.Arriba) ||
Orientacion.Equals(OrientacionesCara.Adelante) ||
Orientacion.Equals(OrientacionesCara.Izquierda))
{
invertirNormal = true;
}
if (Orientacion.Equals(OrientacionesCara.Arriba) || Orientacion.Equals(OrientacionesCara.Abajo))
{
for (int indiceFila = 0; indiceFila < CantidadPixelesAlto; indiceFila++) // indice fila
{
for (int indiceColumna = 0; indiceColumna < CantidadPixelesAncho; indiceColumna++) // indice columna
{
puntoCentro = vertices[indiceFila * CantidadPixelesAncho + indiceColumna];
if (indiceFila + 1 < CantidadPixelesAlto - 1) // Hay punto norte
{
puntoNorte = vertices[(indiceFila + 1) * CantidadPixelesAncho + indiceColumna];
}
else
{
puntoNorte = this.CompletarPunto(puntoCentro);
}
if (indiceFila - 1 >= 0) // Hay punto sur
{
puntoSur = vertices[(indiceFila - 1) * CantidadPixelesAncho + indiceColumna];
}
else
{
puntoSur = this.CompletarPunto(puntoCentro);
}
if (indiceColumna - 1 >= 0) // Hay punto este
{
puntoOeste = vertices[indiceFila * CantidadPixelesAncho + indiceColumna - 1];
}
else
{
puntoOeste = this.CompletarPunto(puntoCentro);
}
if (indiceColumna + 1 < CantidadPixelesAncho - 1) // Hay punto oeste
{
puntoEste = vertices[indiceFila * CantidadPixelesAncho + indiceColumna + 1];
}
else
{
puntoEste = this.CompletarPunto(puntoCentro);
}
normales.Add(Punto.CalcularNormal(puntoCentro, puntoNorte, puntoEste, puntoSur, puntoOeste, invertirNormal));
}
}
}
else
{
for (int indiceColumna = 0; indiceColumna < CantidadPixelesAncho; indiceColumna++) // indice columna
{
for (int indiceFila = 0; indiceFila < CantidadPixelesAlto; indiceFila++) // indice fila
{
puntoCentro = vertices[indiceFila + (indiceColumna * CantidadPixelesAlto)];
if (indiceColumna + 1 < CantidadPixelesAncho - 1) // Hay punto norte
{
puntoNorte = vertices[(indiceColumna + 1) * CantidadPixelesAlto + indiceFila];
}
else
{
puntoNorte = this.CompletarPunto(puntoCentro);
}
if (indiceColumna - 1 >= 0) // Hay punto sur
{
puntoSur = vertices[(indiceColumna - 1) * CantidadPixelesAlto + indiceFila];
}
else
{
puntoSur = this.CompletarPunto(puntoCentro);
}
if (indiceFila + 1 < CantidadPixelesAlto) // Hay punto este
{
puntoEste = vertices[indiceColumna * CantidadPixelesAlto + indiceFila + 1];
}
else
{
puntoEste = this.CompletarPunto(puntoCentro);
}
if (indiceFila - 1 >= 0) // Hay punto oeste
{
puntoOeste = vertices[indiceColumna * CantidadPixelesAlto + indiceFila - 1];
}
else
{
puntoOeste = this.CompletarPunto(puntoCentro);
}
normales.Add(Punto.CalcularNormal(puntoCentro, puntoNorte, puntoEste, puntoSur, puntoOeste, invertirNormal));
}
}
}
}
private Punto[][] generarMatrizVertices(Punto[] curva, double gradosRevolucion, int cantidadCaras)
{
double anguloRotacionRadianes = MathUtils.DegreeToRadian(gradosRevolucion / cantidadCaras);
CurvaBzierSegmentosCubicos curvaBS = new CurvaBzierSegmentosCubicos(curva);
IList<Punto> curvaDiscretizada1 = curvaBS.GetPuntosDiscretos(PASO_BEZIER);
curvaDiscretizada1.RemoveAt(curvaDiscretizada1.Count - 2);
Punto[] curvaDiscretizada = curvaDiscretizada1.ToArray<Punto>();
Punto[] normales = this.ObtenerNormalesCurva2D(curvaDiscretizada);
Punto[][] matriz = new Punto[cantidadCaras + 2][];
for (int iteradorRotacion = 0; iteradorRotacion < cantidadCaras; ++iteradorRotacion)
{
matriz[iteradorRotacion] = new Punto[curvaDiscretizada.Length];
for (int iteradorBezier = 0; iteradorBezier < curvaDiscretizada.Length; ++iteradorBezier)
{
Punto puntoCurva = curvaDiscretizada[iteradorBezier];
matriz[iteradorRotacion][iteradorBezier] = puntoCurva.Clone();
// roto, al mismo tiempo, los puntos de la curva alrededor del eje Y
Punto puntoCurvaBack = puntoCurva.Clone();
puntoCurva.X = puntoCurvaBack.X * Math.Cos(anguloRotacionRadianes) + puntoCurvaBack.Z * Math.Sin(anguloRotacionRadianes);
puntoCurva.Z = puntoCurvaBack.Z * Math.Cos(anguloRotacionRadianes) - puntoCurvaBack.X * Math.Sin(anguloRotacionRadianes);
curvaDiscretizada[iteradorBezier] = puntoCurva;
// roto, al mismo tiempo, los puntos de la normal alrededor del eje Y
Punto puntoNormal = normales[iteradorBezier];
matriz[iteradorRotacion][iteradorBezier].NormalX = puntoNormal.X;
matriz[iteradorRotacion][iteradorBezier].NormalY = puntoNormal.Y;
matriz[iteradorRotacion][iteradorBezier].NormalZ = puntoNormal.Z;
Punto puntoNormalBack = puntoNormal.Clone();
puntoNormal.X = puntoNormalBack.X * Math.Cos(anguloRotacionRadianes) + puntoNormalBack.Z * Math.Sin(anguloRotacionRadianes);
puntoNormal.Z = puntoNormalBack.Z * Math.Cos(anguloRotacionRadianes) - puntoNormalBack.X * Math.Sin(anguloRotacionRadianes);
normales[iteradorBezier] = puntoNormal;
}
}
matriz[cantidadCaras] = matriz[0];
matriz[cantidadCaras + 1] = matriz[1]; // OJO solo si los grados son 360
/*
// calculo las normales en toda la matriz
Boolean invertirNormal = true;
Punto puntoNorte = null;
Punto puntoSur = null;
Punto puntoEste = null;
Punto puntoOeste = null;
Punto puntoCentro = null;
int cantidadPixelesAlto = curvaDiscretizada.Length;
int cantidadPixelesAncho = matriz.Length;
for (int indiceFila = 0; indiceFila < cantidadPixelesAncho; ++indiceFila)
{
for (int indiceColumna = 0; indiceColumna < cantidadPixelesAlto; ++indiceColumna)
{
puntoCentro = matriz[indiceFila][indiceColumna];
if (indiceFila + 1 < cantidadPixelesAncho - 1) // Hay punto norte
puntoNorte = matriz[indiceFila + 1][indiceColumna];
else puntoNorte = null;
if (indiceFila - 1 >= 0) // Hay punto sur
puntoSur = matriz[indiceFila - 1][indiceColumna];
else puntoSur = null;
if (indiceColumna - 1 >= 0) // Hay punto este
puntoOeste = matriz[indiceFila][indiceColumna - 1];
else puntoOeste = null;
if (indiceColumna + 1 < cantidadPixelesAlto - 1) // Hay punto oeste
puntoEste = matriz[indiceFila][indiceColumna + 1];
else puntoEste = null;
Punto normal = Punto.CalcularNormal(puntoCentro, puntoNorte, puntoEste, puntoSur, puntoOeste, invertirNormal);
matriz[indiceFila][indiceColumna].NormalX = normal.X;
matriz[indiceFila][indiceColumna].NormalY = normal.Y;
matriz[indiceFila][indiceColumna].NormalZ = normal.Z;
}
}
*/
return matriz;
}
public Punto RestarPunto(Punto punto)
{
return new Punto(this.X - punto.X, this.Y - punto.Y, this.Z - punto.Z);
}
private Punto[] ObtenerNormalesCurva2D(Punto[] curva)
{
// a(x,y)(ortogonal) = (-ay, ax)
Punto[] normales = new Punto[curva.Length];
for (int i = 0; i < curva.Length - 1; ++i)
{
Punto p = curva[i + 1] - curva[i];
Punto normal = new Punto( -p.Y , p.X, p.Z);
if (p.X != 0)
{
double pendiente = p.Y / p.X;
if (pendiente < 0)
{
normal = new Punto(- normal.X, - normal.Y, - normal.Z);
}
}
normales[i] = normal + curva[i];
}
normales[curva.Length - 1] = normales[curva.Length - 2];
return normales;
}
public double CalcularDistancia(Punto punto)
{
Punto vectorEnOrigen = this.RestarPunto(punto);
return vectorEnOrigen.Modulo();
}
// Producto vectorial, normalizado
public static Punto operator *(Punto punto1, Punto punto2)
{
Punto punto = new Punto(0, 0, 0);
punto.X = punto1.Y * punto2.Z - punto1.Z * punto2.Y;
punto.Y = punto1.Z * punto2.X - punto1.X * punto2.Z;
punto.Z = punto1.X * punto2.Y - punto1.Y * punto2.X;
double modulo = punto.Modulo();
if (modulo != 0)
{
punto.X = punto.X / modulo;
punto.Y = punto.Y / modulo;
punto.Z = punto.Z / modulo;
}
return punto;
}
public Punto RestarPunto(Punto punto)
{
return(new Punto(this.X - punto.X, this.Y - punto.Y, this.Z - punto.Z));
}
/// <summary>
/// Promedia las normales calculadas con todos los puntos de alrededor
/// </summary>
/// <param name="verticeCentro"></param>
/// <param name="verticeNorte"></param>
/// <param name="verticeEste"></param>
/// <param name="verticeSur"></param>
/// <param name="verticeOeste"></param>
/// <returns></returns>
public static Punto CalcularNormal(Punto verticeCentro, Punto verticeNorte, Punto verticeEste, Punto verticeSur, Punto verticeOeste, Boolean invertirSentido)
{
if (verticeCentro == null)
{
throw new InvalidOperationException("Este método no puede ser invocado con el vertice central nulo");
}
// Numeradas en sentido horario son 4
Punto normalNorEste = null;
Punto normalSurEste = null;
Punto normalSurOeste = null;
Punto normalNorOeste = null;
Punto normalRetorno = null;
if (verticeNorte != null && verticeEste != null)
{
if (invertirSentido)
{
normalNorEste = (verticeNorte - verticeCentro) * (verticeEste - verticeCentro);
}
else
{
normalNorEste = (verticeEste - verticeCentro) * (verticeNorte - verticeCentro);
}
}
if (verticeSur != null && verticeEste != null)
{
if (invertirSentido)
{
normalSurEste = (verticeEste - verticeCentro) * (verticeSur - verticeCentro);
}
else
{
normalSurEste = (verticeSur - verticeCentro) * (verticeEste - verticeCentro);
}
}
if (verticeSur != null && verticeOeste != null)
{
if (invertirSentido)
{
normalSurOeste = (verticeSur - verticeCentro) * (verticeOeste - verticeCentro);
}
else
{
normalSurOeste = (verticeOeste - verticeCentro) * (verticeSur - verticeCentro);
}
}
if (verticeNorte != null && verticeOeste != null)
{
if (invertirSentido)
{
normalNorOeste = (verticeOeste - verticeCentro) * (verticeNorte - verticeCentro);
}
else
{
normalNorOeste = (verticeNorte - verticeCentro) * (verticeOeste - verticeCentro);
}
}
normalRetorno = new Punto(0, 0, 0);
if (normalNorEste != null)
{
normalRetorno = normalRetorno.SumarPunto(normalNorEste);
}
if (normalNorOeste != null)
{
normalRetorno = normalRetorno.SumarPunto(normalNorOeste);
}
if (normalSurEste != null)
{
normalRetorno = normalRetorno.SumarPunto(normalSurEste);
}
if (normalSurOeste != null)
{
normalRetorno = normalRetorno.SumarPunto(normalSurOeste);
}
return(normalRetorno);
}
public double ProductoEscalar(Punto punto)
{
return((this.X * punto.X) + (this.Y * punto.Y) + (this.Z * punto.Z));
}
/// <summary>
/// No modifica el valor de this, ni del otro, devuelve un nuevo punto flotante con el valor de la suma de ambos
/// </summary>
/// <param name="punto"></param>
/// <returns></returns>
public Punto SumarPunto(Punto punto)
{
return(new Punto(this.X + punto.X, this.Y + punto.Y, this.Z + punto.Z));
}
public virtual void Trasladar(double x, double y, double z)
{
this.trasladoOriginal = new Punto(x, y, z);
}
public virtual void Escalar(double x, double y, double z)
{
this.escaladoOriginal = new Punto(x, y, z);
}
protected abstract Punto CompletarPunto(Punto puntoCentro);
public double CalcularDistancia(Punto punto)
{
Punto vectorEnOrigen = this.RestarPunto(punto);
return(vectorEnOrigen.Modulo());
}
public Arbol(double longitudTronco, Punto[] formaCopa)
{
this.longitudTronco = longitudTronco;
this.radioBaseTronco = this.longitudTronco / FACTOR_TRONCO;
this.matrizPuntosCopa = this.generarMatrizVertices(formaCopa, 360.0f, CANTIDAD_CARAS);
}
protected override Punto CalculateNormalForPunto(int posVertexActual, Punto verticeActual, int posSeccionActual, Seccion seccionActual)
{
return new Punto(0, 0, 1);
}
/// <summary>
/// Promedia las normales calculadas con todos los puntos de alrededor
/// </summary>
/// <param name="verticeCentro"></param>
/// <param name="verticeNorte"></param>
/// <param name="verticeEste"></param>
/// <param name="verticeSur"></param>
/// <param name="verticeOeste"></param>
/// <returns></returns>
public static Punto CalcularNormal(Punto verticeCentro, Punto verticeNorte, Punto verticeEste, Punto verticeSur, Punto verticeOeste, Boolean invertirSentido)
{
if (verticeCentro == null) throw new InvalidOperationException("Este método no puede ser invocado con el vertice central nulo");
// Numeradas en sentido horario son 4
Punto normalNorEste = null;
Punto normalSurEste = null;
Punto normalSurOeste = null;
Punto normalNorOeste = null;
Punto normalRetorno = null;
if (verticeNorte != null && verticeEste != null)
{
if (invertirSentido) normalNorEste = (verticeNorte - verticeCentro) * (verticeEste - verticeCentro);
else normalNorEste = (verticeEste - verticeCentro) * (verticeNorte - verticeCentro);
}
if (verticeSur != null && verticeEste != null)
{
if (invertirSentido) normalSurEste = (verticeEste - verticeCentro) * (verticeSur - verticeCentro);
else normalSurEste = (verticeSur - verticeCentro) * (verticeEste - verticeCentro);
}
if (verticeSur != null && verticeOeste != null)
{
if (invertirSentido) normalSurOeste = (verticeSur - verticeCentro) * (verticeOeste - verticeCentro);
else normalSurOeste = (verticeOeste - verticeCentro) * (verticeSur - verticeCentro);
}
if (verticeNorte != null && verticeOeste != null)
{
if (invertirSentido) normalNorOeste = (verticeOeste - verticeCentro) * (verticeNorte - verticeCentro);
else normalNorOeste = (verticeNorte - verticeCentro) * (verticeOeste - verticeCentro);
}
normalRetorno = new Punto(0, 0, 0);
if (normalNorEste != null)
normalRetorno = normalRetorno.SumarPunto(normalNorEste);
if (normalNorOeste != null)
normalRetorno = normalRetorno.SumarPunto(normalNorOeste);
if (normalSurEste != null)
normalRetorno = normalRetorno.SumarPunto(normalSurEste);
if (normalSurOeste != null)
normalRetorno = normalRetorno.SumarPunto(normalSurOeste);
return normalRetorno;
}
protected override Punto CompletarPunto(Punto puntoCentro)
{
return null;
}
public Punto Clone()
{
Punto puntoNuevo = new Punto();
puntoNuevo.NormalX = this.NormalX;
puntoNuevo.NormalY = this.NormalY;
puntoNuevo.NormalZ = this.NormalZ;
puntoNuevo.OrigenCoordenadas = this.OrigenCoordenadas;
puntoNuevo.X = this.X;
puntoNuevo.Y = this.Y;
puntoNuevo.Z = this.Z;
return puntoNuevo;
}
public virtual void Trasladar(double x, double y, double z)
{
this.trasladoOriginal = new Punto(x, y, z);
}
public double ProductoEscalar(Punto punto)
{
return (this.X * punto.X) + (this.Y * punto.Y) + (this.Z * punto.Z);
}
private void DibujarCopa()
{
Gl.glPushMatrix();
Gl.glRotated(90.0f, 1, 0, 0);
if (texturaCopa == null)
texturaCopa = new Textura(@"../../Imagenes/Texturas/Arbol/copa.bmp", false);
Gl.glEnable(Gl.GL_TEXTURE_2D);
texturaCopa.Activate();
float[] colorGray = new float[4] { .5f, .5f, .5f, .15f };
float[] colorNone = new float[4] { 0.0f, 0.0f, 0.0f, 0.0f };
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, colorGray);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, new float[] { 0f, 0f, 0f, 1.0f });
Punto[] posicionesTextura = new Punto[]
{
new Punto ( 0, 0, 0 ),
new Punto ( 1, 0, 0 ),
new Punto ( 0, 1, 0 ),
new Punto ( 1, 1, 0 )
};
for (int i = 0; i < matrizPuntosCopa.Length - 2; i++) // por columnas duplicadas
{
int cicloPosicionTextura = 0;
Punto posicionTextura = null;
Gl.glBegin(Gl.GL_TRIANGLE_STRIP);
for (int j = 0; j < matrizPuntosCopa[i].Length; j++)
{
double ancho = (matrizPuntosCopa[i + 1][j] - matrizPuntosCopa[i][j]).Modulo();
double alto = 1.0f;
if (j < matrizPuntosCopa[i].Length-1)
{
alto = (matrizPuntosCopa[i][j + 1] - matrizPuntosCopa[i][j]).Modulo();
}
double anchoSobreAlto = ancho / alto;
posicionTextura = posicionesTextura[cicloPosicionTextura];
cicloPosicionTextura = (cicloPosicionTextura + 1) % posicionesTextura.Length;
Gl.glNormal3d(matrizPuntosCopa[i][j].NormalX, matrizPuntosCopa[i][j].NormalY, matrizPuntosCopa[i][j].NormalZ);
Gl.glVertex3d(matrizPuntosCopa[i][j].X, matrizPuntosCopa[i][j].Y, matrizPuntosCopa[i][j].Z);
Gl.glTexCoord2d(posicionTextura.X, posicionTextura.Y);
posicionTextura = posicionesTextura[cicloPosicionTextura];
cicloPosicionTextura = (cicloPosicionTextura + 1) % posicionesTextura.Length;
Gl.glNormal3d(matrizPuntosCopa[i + 1][j].NormalX, matrizPuntosCopa[i + 1][j].NormalY, matrizPuntosCopa[i + 1][j].NormalZ);
Gl.glVertex3d(matrizPuntosCopa[i + 1][j].X, matrizPuntosCopa[i + 1][j].Y, matrizPuntosCopa[i + 1][j].Z);
Gl.glTexCoord2d(posicionTextura.X, posicionTextura.Y);
}
Gl.glEnd();
}
Gl.glDisable(Gl.GL_TEXTURE_2D);
if (DIBUJAR_NORMALES)
{
Gl.glDisable(Gl.GL_LIGHTING);
for (int i = 0; i < matrizPuntosCopa.Length - 2; i++) // por columnas duplicadas
{
for (int j = 0; j < matrizPuntosCopa[i].Length; j++)
{
Gl.glBegin(Gl.GL_LINES);
Gl.glColor3d(1, 0, 0);
Gl.glVertex3d(matrizPuntosCopa[i][j].X, matrizPuntosCopa[i][j].Y, matrizPuntosCopa[i][j].Z);
Gl.glColor3d(.2, 0, 0);
Gl.glVertex3d(matrizPuntosCopa[i][j].NormalX, matrizPuntosCopa[i][j].NormalY, matrizPuntosCopa[i][j].NormalZ);
Gl.glEnd();
}
}
Gl.glEnable(Gl.GL_LIGHTING);
}
Gl.glPopMatrix();
}
/// <summary>
/// No modifica el valor de this, ni del otro, devuelve un nuevo punto flotante con el valor de la suma de ambos
/// </summary>
/// <param name="punto"></param>
/// <returns></returns>
public Punto SumarPunto(Punto punto)
{
return new Punto(this.X + punto.X, this.Y + punto.Y, this.Z + punto.Z);
}
private Punto CalcularPuntoXCoordenadasPixeles(int indicePixelX, int indicePixelY, int indicePixelZ)
{
Punto punto = new Punto();
punto.X = this.xInicial + indicePixelX * this.Figura.PasoX;
punto.Y = this.yInicial + indicePixelY * this.Figura.PasoY;
punto.Z = this.zInicial + indicePixelZ * this.Figura.PasoZ;
return punto;
}
private Punto CalcularPuntoXindices(int indicePixelX, int indicePixelZ)
{
Punto punto = new Punto();
punto.X = this.xInicial + ((double)indicePixelX) * this.Figura.PasoX;
punto.Z = this.zInicial + ((double)indicePixelZ) * this.Figura.PasoZ;
punto.Y = this.CalcularY(punto.X, punto.Z);
return punto;
}
protected override Punto CompletarPunto(Punto puntoCentro)
{
return(null);
}
public virtual void Escalar(double x, double y, double z)
{
this.escaladoOriginal = new Punto(x, y, z);
}
protected override Punto CalculateNormalForPunto(int posVertexActual, Punto verticeActual, int posSeccionActual, Seccion seccionActual)
{
return(new Punto(0, 0, 1));
}
protected override Punto CompletarPunto(Punto puntoCentro)
{
if (Orientacion.Equals(OrientacionesCara.Abajo))
{
return puntoCentro.SumarPunto(new Punto(0, 0, Figura.PasoZ));
}
else if (Orientacion.Equals(OrientacionesCara.Adelante))
{
return puntoCentro.SumarPunto(new Punto(-Figura.PasoX, 0, 0));
}
else if (Orientacion.Equals(OrientacionesCara.Arriba))
{
return puntoCentro.SumarPunto(new Punto(0, 0, -Figura.PasoZ));
}
else if (Orientacion.Equals(OrientacionesCara.Atraz))
{
return puntoCentro.SumarPunto(new Punto(Figura.PasoX, 0, 0));
}
else if (Orientacion.Equals(OrientacionesCara.Derecha))
{
return puntoCentro.SumarPunto(new Punto(0, -Figura.PasoY, 0));
}
else //if (Orientacion.Equals(OrientacionesCara.Izquierda))
{
return puntoCentro.SumarPunto(new Punto(0, Figura.PasoY, 0));
}
}
protected virtual Punto CalculateNormalForPunto(int posVertexActual, Punto verticeActual, int posSeccionActual, Seccion seccionActual)
{
Punto normalSeccion = (seccionActual.Vertices[1] - seccionActual.Vertices[0]) * (seccionActual.Vertices[2] - seccionActual.Vertices[1]);
if (posVertexActual == 0)
{
return (seccionActual.Vertices[posVertexActual + 1] - seccionActual.Vertices[posVertexActual]) * normalSeccion;
}
else if (posVertexActual == (seccionActual.Vertices.Count - 1))
{
return (seccionActual.Vertices[posVertexActual] - seccionActual.Vertices[posVertexActual - 1]) * normalSeccion;
}
else
{
return (seccionActual.Vertices[posVertexActual + 1] - seccionActual.Vertices[posVertexActual - 1]) * normalSeccion;
}
}