jueves, 26 de abril de 2012

Examen de Graficación 3a. Evaluación


1.- Crea al proyecto en modo consola CLR con tú nombre completo seguido de un guión y una letra R mayúscula, por ejemplo si te llamas Juan Pérez Hernández, el proyecto de Visual C++ deberá de ser: Juan Perez Hernandez – R.

2.- Deberás de especificar un tamaño de ventana de 800X600 y una proyección en perspectiva con 80 grados de ángulo de visión, un plano cercano de .1 y el lejano de 30. Escoge un color negro como color de limpiado de la pantalla. (10%)

3.- Especifica un ocultamiento de caras traseras, donde las caras frontales se definen a favor de las manecillas del reloj. (10%)

4.- Dada el siguiente objeto tridimensional dibújalo en OpenGL. Para esto tendrás que determinar las coordenadas de sus vértices y el orden de las caras. Debes de dibujarlo usando solamente la primitiva GL_QUADS, además debes de usar la técnica de arreglos, es decir la debes de dibujar en base a ciclos. Por último debes de meter este objeto dentro de una lista. (40%)


5.- Debes de colorearlo usando un rellenado plano aplicando la técnica de coloreado en base a índices. Tu elije el patrón de colores que más te guste. (15%)

6.- Como el objeto está dentro de una lista deberás de dibujarlo dos veces en total en la pantalla. Para esto cada vez que mandes llamar la lista que contiene al objeto deberá de ser usando distintas transformaciones geométricas y al menos una de cada una, es decir, deberás dibujar el objeto dos veces, cada una con una translación, rotación y escalado distintos. (10%)

7.- Crea otra lista con un piso para el escenario. Este piso puede tener cualquier tamaño, pero debe de estar a la altura de y = -5. No es necesario que apliques transformaciones al piso y deberá de ser de color azul. (10%)

8.-Limpieza en el código. (5%)


viernes, 20 de abril de 2012

Festival Latinoamericano de Instalación de Software Libre 2012


Más información: http://www.gulag.org.mx

Espero que asistan!

jueves, 19 de abril de 2012

Práctica de listas. Graficación.


#include "stdafx.h"
#include < glut.h >
void Dibuja();
void Inicializa();
void crealistas();


float prismaV[6][3]={
{-2,0,2},
{-2,0,-2},
{2,0,-2},
{2,0,2},
{0,4,0},
{0,-4,0}};
int prismaC[8][3]={
{4,3,0},
{4,2,3},
{0,3,5},
{3,2,5},
{2,4,1},
{1,4,0},
{2,5,1},
{5,1,0}};
////////////////////////////////////////////////////////////////////
float cuboV[8][3]={
{-2,2,2},
{2,2,2},
{2,-2,2},
{-2,-2,2},
{-2,2,-2},
{2,2,-2},
{2,-2,-2},
{-2,-2,-2}};
int cuboC[6][4]={
{0,1,2,3},
{7,6,5,4},
{1,5,6,2},
{0,3,7,4},
{0,4,5,1},
{3,2,6,7}};
 int prisma=1, cubo=2,piso=3;
void main()
{
glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
glutInitWindowSize(800,600);
glutInitWindowPosition(100,50);
glutCreateWindow("practica2.4 ");
glutDisplayFunc(Dibuja);
Inicializa();
glutMainLoop();
}
void Inicializa()
{
glEnable(GL_DEPTH_TEST);
glClearColor(-.8,-.5,.6,-.45);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(120,1.33,.01,50);
glMatrixMode(GL_MODELVIEW);
crealistas();
}
void crealistas()
{
int i,j;
glNewList(prisma,GL_COMPILE);
glBegin(GL_TRIANGLES);
for(i=0;i<8;i++)
{
for(j=0;j<3;j++)
{
glColor3f(i/0.9+0.9,j,0);
glVertex3fv(prismaV[prismaC[i][j]]);
}
}
glEnd();
glEndList();
glNewList(cubo,GL_COMPILE);
glBegin(GL_QUADS);
for(i=0;i<6;i++)
{
for(j=0;j<4;j++)
{
glColor3f(i/0.6+0.6,j/6.0,0);
glVertex3fv(cuboV[cuboC[i][j]]);
}
}
glEnd();
glEndList();
glNewList(piso,GL_COMPILE);
glColor3f(0,.5,0);
glBegin(GL_QUADS);
glVertex3f(-15,-5,-15);
glVertex3f(15,-5,-15);
glVertex3f(15,-5,15);
glVertex3f(-15,-5,15);
glEnd();
glEndList();
}
void Dibuja()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslated(0,1,-10);
glRotated(45,0,1,0);
glCallList(prisma);


glLoadIdentity();
glTranslated(15,-1,-10);
glRotated(45,0,1,0);
glCallList(prisma);


glLoadIdentity();
glTranslated(-10,6,-20);
glRotated(45,0,1,0);
glCallList(prisma);


glLoadIdentity();
glTranslated(-10,-5,-10);
glRotated(50,0,0,0);
glCallList(cubo);


glLoadIdentity();
glTranslated(-20,5,-15);
glRotated(20,0,1,0);
glCallList(cubo);

glLoadIdentity();
glTranslated(0,-5,-10);
glRotated(5,0,0,0);
glCallList(cubo);

glLoadIdentity();
glCallList(piso);


glutSwapBuffers();
}

Práctica de Hilos 2.


//Programa 1


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;


namespace ThreadsPropiedades
{
   


    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            Thread t = new Thread(new ThreadStart(p.met1));
            t.Start();
             //Este método no interrumpe el thread
            


            Console.WriteLine(t.IsAlive);
            Console.WriteLine(t.ThreadState);
            Thread.Sleep(10000);
            Console.WriteLine("-----------------------");
            t.Interrupt();
            Console.WriteLine(t.ThreadState);
            Console.WriteLine("-----------------------");
            Thread.Sleep(5000);
            Console.WriteLine(t.IsAlive);
            Console.WriteLine(t.ThreadState);


            Console.ReadKey();
        }


        public void met1() {


            try
            {
                Thread.Sleep(Timeout.Infinite);


            }
            catch (ThreadInterruptedException) {


                Console.WriteLine("Forzado....");
            
            }


            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Despierta........");
            
        }


        
       
    }
}


//---------------------------------------------------------------



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;


namespace SeguridadThreadsMutex1
{
    class DataBase
    {
        Mutex mutex = new Mutex();


        public void SaveData(string text)
        {
            mutex.WaitOne();
            
           Console.WriteLine("------------------------------");
           Console.WriteLine("DataBase.SaveData: Iniciado.....");
           Console.WriteLine("DataBase.SaveData:
Ejecutándose.....");
                Console.WriteLine("---------------------------------------");
                for (int i = 0; i <= 100; i++)
                {
                    Console.Write(i + text);
                }
                Console.WriteLine("---------------------------------------");
                Console.WriteLine("DataBase.SaveData: Finalizado.....");


                mutex.ReleaseMutex();
        }


    }


    class ThreadMutexApp
    {


        public static DataBase db = new DataBase();


        public static void WorkedThreadMethod1()
        {
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("Hilo de ejecución secundario #1.-Iniciado..........");
            Console.WriteLine("Hilo de ejecución secundario #1.-Invocando DataBase.SaveData");
            Console.WriteLine("---------------------------------------------------------------");
            db.SaveData("x");
            Console.WriteLine("----------------------------------------------------------------");
            Console.WriteLine("Hilo de ejecución secundario #1.-Retornando desde Output");
        }


        public static void WorkedThreadMethod2()
        {
            Console.WriteLine("-------------------------------------------------------------");
            Console.WriteLine("Hilo de ejecución secundario #2.-Iniciado..........");
            Console.WriteLine("Hilo de ejecución secundario #2.-Invocando DataBase.SaveData");
            Console.WriteLine("--------------------------------------------------------------");
            db.SaveData("o");
            Console.WriteLine("--------------------------------------------------------------");
            Console.WriteLine("Hilo de ejecución secundario #2.-Retornando desde Output");
        }




        public static void Main()
        {


            Console.BackgroundColor = ConsoleColor.Black;
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Clear();


            ThreadStart worker1 = new ThreadStart(WorkedThreadMethod1);
            ThreadStart worker2 = new ThreadStart(WorkedThreadMethod2);


            Console.WriteLine("Principal.- Creando Hilos de ejecución secundarios......");


            Thread t1 = new Thread(worker1);
            Thread t2 = new Thread(worker2);


            t1.Start();
            t2.Start();


            Console.ReadKey();
        }
    }
}


//---------------------En las conclusiones--------------------------------------------------
Nota: Poner qué es lo que hace cada programa. Agregar información teórica a la práctica.