示例#1
0
 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)
 {
 }
示例#3
0
        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);
        }
示例#4
0
        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;
        }
示例#5
0
        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();
        }
示例#6
0
 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;
 }
示例#7
0
        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;
        }
示例#8
0
 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));
                    }
                }
            }
        }
示例#10
0
        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;
        }
示例#11
0
 public Punto RestarPunto(Punto punto)
 {
     return new Punto(this.X - punto.X, this.Y - punto.Y, this.Z - punto.Z);
 }
示例#12
0
        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;
        }
示例#13
0
        public double CalcularDistancia(Punto punto)
        {
            Punto vectorEnOrigen = this.RestarPunto(punto);

            return vectorEnOrigen.Modulo();
        }
示例#14
0
        // 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;
        }
示例#15
0
 public Punto RestarPunto(Punto punto)
 {
     return(new Punto(this.X - punto.X, this.Y - punto.Y, this.Z - punto.Z));
 }
示例#16
0
        /// <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);
        }
示例#17
0
 public double ProductoEscalar(Punto punto)
 {
     return((this.X * punto.X) + (this.Y * punto.Y) + (this.Z * punto.Z));
 }
示例#18
0
 /// <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);
 }
示例#21
0
 protected abstract Punto CompletarPunto(Punto puntoCentro);
示例#22
0
        public double CalcularDistancia(Punto punto)
        {
            Punto vectorEnOrigen = this.RestarPunto(punto);

            return(vectorEnOrigen.Modulo());
        }
示例#23
0
 public Arbol(double longitudTronco, Punto[] formaCopa)
 {
     this.longitudTronco = longitudTronco;
     this.radioBaseTronco = this.longitudTronco / FACTOR_TRONCO;
     this.matrizPuntosCopa = this.generarMatrizVertices(formaCopa, 360.0f, CANTIDAD_CARAS);
 }
示例#24
0
 protected override Punto CalculateNormalForPunto(int posVertexActual, Punto verticeActual, int posSeccionActual, Seccion seccionActual)
 {
     return new Punto(0, 0, 1);
 }
示例#25
0
        /// <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;
 }
示例#27
0
        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;
        }
示例#28
0
 public virtual void Trasladar(double x, double y, double z)
 {
     this.trasladoOriginal = new Punto(x, y, z);
 }
示例#29
0
 public double ProductoEscalar(Punto punto)
 {
     return (this.X * punto.X) + (this.Y * punto.Y) + (this.Z * punto.Z);
 }
示例#30
0
        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();
        }
示例#31
0
 /// <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);
 }
示例#32
0
        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);
 }
示例#35
0
 public virtual void Escalar(double x, double y, double z)
 {
     this.escaladoOriginal = new Punto(x, y, z);
 }
示例#36
0
 protected override Punto CalculateNormalForPunto(int posVertexActual, Punto verticeActual, int posSeccionActual, Seccion seccionActual)
 {
     return(new Punto(0, 0, 1));
 }
示例#37
0
 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));
     }
 }
示例#38
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;
            }
        }