Gracias Gracias:  0
Resultados 1 al 4 de 4

Tema: ayuda con mi programa opengl

  1. #1
    Miembro Nuevo
    Fecha de ingreso
    Jun 2013
    Mensajes
    1

    Ayuda con mi programa (opengl)

    resulta que hice un programa en codeblocks con opengl...esta fucional todo ..pero por más que trato no puedo hacerlo con listas de visualización (glnewlist)
    por fa ayuda
    acxa les dejo el código ..el progrma genra una curva dado dos puntos

    #ifdef __APPLE__
    #include <GLUT/glut.h>
    #else
    #include <GL/glut.h>
    #include <iostream>
    #endif
    #include<conio.h>
    #include<stdio.h>
    #include<math.h>
    #include<iostream>
    #include <stdlib.h>
    #define NUM_PUNTOS 200
    #define NUM_EXTREMOS 200
    #include <GL/glut.h>
    #include <iostream>
    #include<math.h>
    #include<stdio.h>
    #include <stdlib.h>
    #define max 70000000

    using namespace std;

    int comparar(int x, int y);

    void dda(float x0,float y0,float x1,float y1);
    void init(void);
    void hermite(void);
    void dibujar_puntos(void);
    void dibujar_rectas(void);
    int dim=600;

    float P_Control[NUM_PUNTOS][2];
    float P_Extremo[NUM_EXTREMOS][2];

    int num_punto=0,inc=50;

    int activ_add_point=0;
    int activ_ver_recta=0;
    int activ_mov_point=0;
    int activ_curve=0;

    int MOVENAME =-1;
    int MOVEPOINT =-1;

    void init(void)
    {
    glutCreateWindow("Labo_1");
    glClearColor(1.0, 1.0, 1.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, dim, 0.0, dim);

    }

    static void display(void)
    {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3d(1,0,0);

    glPushMatrix();

    dibujar_puntos();
    dibujar_rectas();

    if(activ_curve==1){
    hermite();
    }

    glPopMatrix();

    glutSwapBuffers();
    }

    void ControlRaton( int button, int state, int x, int y ){

    if(activ_add_point==1 && num_punto != 2){

    if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ){

    P_Control[num_punto][0]=x;
    P_Control[num_punto][1]=dim-y;
    P_Extremo[num_punto][0]=x+inc;
    P_Extremo[num_punto][1]=dim-y+inc;

    cout<<x<<" "<<dim-y<<endl;

    num_punto++;
    }

    }
    else{
    if(activ_mov_point==1){
    if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ){

    int newX=x;
    int newY=dim-y;

    int choiceFound = 0;

    for (int i = 0; i < num_punto && !choiceFound; i++){

    if ((abs(P_Control[i][0] - newX) <= 20) &&
    (abs(P_Control[i][1] - newY) <= 20)){

    MOVEPOINT = i;
    choiceFound = 1;

    }
    }

    }

    if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {

    MOVEPOINT = -1;
    }

    }
    else{
    if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ){
    int newX=x;
    int newY=dim-y;

    int choiceFound = 0;

    for (int i = 0; i < num_punto && !choiceFound; i++){

    if ((abs(P_Extremo[i][0] - newX) <= 50) &&
    (abs(P_Extremo[i][1] - newY) <= 50)){

    MOVENAME = i;
    choiceFound = 1;

    }
    }

    }

    if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {

    MOVENAME = -1;
    }
    }
    }
    glutPostRedisplay();

    }

    void myMouseMove(int x, int y)
    {
    if (MOVENAME > -1 && activ_ver_recta==1)
    {
    int newX = x;
    int newY = dim- y;

    P_Extremo[MOVENAME][0] = newX;
    P_Extremo[MOVENAME][1] = newY;

    glutPostRedisplay();
    }

    if (MOVEPOINT > -1 && activ_mov_point==1)
    {
    int newX = x;
    int newY = dim- y;

    P_Control[MOVEPOINT][0] = newX;
    P_Control[MOVEPOINT][1] = newY;

    glutPostRedisplay();
    }
    }

    void dibujar_puntos(void){

    glColor3d(1,0,0);

    for(int i=0;i<num_punto;i++){

    glPointSize(10);
    glBegin(GL_POINTS);

    glVertex2f(P_Control[i][0],P_Control[i][1]);

    glEnd();

    }

    }

    void dibujar_rectas(void){

    if(activ_ver_recta==1){
    for(int i=0;i<num_punto;i++){

    dda(P_Control[i][0],P_Control[i][1],P_Extremo[i][0],P_Extremo[i][1]);
    }
    }
    }

    void hermite()
    {

    glLineWidth(4.0);

    glColor3f(1,1,0);

    float fu[4];

    glBegin(GL_LINE_STRIP);

    for (float uInt = 0; uInt <= 1; uInt+=0.01)
    {
    float u = uInt;
    float u2 = u*u;
    float u3 = u2*u;

    fu[0] = 2.0*u3 - 3.0*u2 + 1.0;
    fu[1] = -2.0*u3 + 3.0*u2;
    fu[2] = u3 - 2.0*u2 + u;
    fu[3] = u3 - u2;

    float x = 0.0;
    float y = 0.0;

    // p0 = P_Control[0]
    x += fu[0]*P_Control[0][0];
    y += fu[0]*P_Control[0][1];

    // p1 = P_Control[1]
    x += fu[1]*P_Control[1][0];
    y += fu[1]*P_Control[1][1];

    // tangent at p0 = ctrlPoints[1]-ctrlPoints[0]
    x += fu[2]*(P_Extremo[0][0]-P_Control[0][0]);
    y += fu[2]*(P_Extremo[0][1]-P_Control[0][1]);

    // tangent at p1 = ctrlPoints[3]-ctrlPoints[2]
    x += fu[3]*(P_Extremo[1][0]-P_Control[1][0]);
    y += fu[3]*(P_Extremo[1][1]-P_Control[1][1]);

    glVertex2i(x,y);
    }

    glEnd();
    glFlush();
    }

    void dda(float x0,float y0,float x1,float y1){

    glColor3d(1,0,0);
    glBegin(GL_LINES);

    glVertex2f(x0,y0);
    glVertex2f(x1,y1);

    glEnd();

    }

    static void idle(void)
    {
    glutPostRedisplay();
    }

    void menu_principal(int opción){

    switch(opción){

    case 4:
    exit(-1);
    break;
    }
    }
    void menu_puntos(int opción){

    switch(opción){
    }
    }

    void menu_mod_puntos(int opción){

    switch(opción){

    case 1:
    activ_mov_point=1;
    activ_add_point=0;
    break;
    case 2:
    activ_mov_point=0;
    break;
    }
    }

    void menu_add_puntos(int opción){

    switch(opción){
    case 1:
    if(num_punto!=2){
    activ_add_point=1;
    }

    break;

    case 2:
    activ_add_point=0;
    break;
    }
    }

    void menu_recta(int opción){

    switch(opción){
    case 1:
    activ_ver_recta=1;
    activ_mov_point=0;
    break;

    case 2:
    activ_ver_recta=0;
    break;
    }

    }
    void menu_curva(int opción){

    switch(opción){
    case 1:
    if(num_punto==2){
    activ_curve=1;
    }
    break;

    case 2:
    activ_curve=0;
    break;
    }
    }
    int main(int argc, char *argv[])
    {
    glutInit(&argc, argv);
    glutInitWindowSize(dim,dim);
    glutInitWindowPosition(100,100);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    init();
    int submenu_curva = glutCreateMenu(menu_curva);
    glutAddMenuEntry("Activar",1);
    glutAddMenuEntry("Desactivar",2);
    int submenu_rectas = glutCreateMenu(menu_recta);
    glutAddMenuEntry("Activar",1);
    glutAddMenuEntry("Desactivar",2);

    int submenu_add = glutCreateMenu(menu_add_puntos);
    glutAddMenuEntry("Activar",1);
    glutAddMenuEntry("Desactivar",2);
    int submenu_mod = glutCreateMenu(menu_mod_puntos);
    glutAddMenuEntry("Activar",1);
    glutAddMenuEntry("Desactivar",2);
    int submenu_puntos = glutCreateMenu(menu_puntos);
    glutAddSubMenu("Ingreso de puntos ",submenu_add);
    glutAddSubMenu("Modificar posición",submenu_mod);
    int menú = glutCreateMenu(menu_principal);
    glutAddSubMenu("Puntos de control",submenu_puntos);
    glutAddSubMenu("Rectas tangentes ",submenu_rectas);
    glutAddSubMenu("Curva de Hermite ",submenu_curva);
    glutAddMenuEntry("salir",4);

    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutDisplayFunc(display);
    glutIdleFunc(idle);
    glClearColor(1,1,1,1);
    glutMouseFunc(ControlRaton);
    glutMotionFunc(myMouseMove);

    glutMainLoop();

    return 0;
    }


  2. #2
    El cabreador
    Fecha de ingreso
    Oct 2002
    Ubicación
    S.Compostela.
    Mensajes
    8,790

    Re: Ayuda con mi programa (opengl)

    Lo mejor es que primero te presentes, entrar sin presentarse y pedir ayuda queda feo.
    Y segundo te lo muevo a general que modelado no es el apartado correcto...

    Un saludo y bienvenido..

  3. #3
    Sunset Melodies Avatar de ciberspace
    Fecha de ingreso
    Jan 2013
    Mensajes
    553

    Re: Ayuda con mi programa (opengl)


  4. #4
    El cabreador
    Fecha de ingreso
    Oct 2002
    Ubicación
    S.Compostela.
    Mensajes
    8,790

    Re: Ayuda con mi programa (opengl)

    Os liais cosa mala, los DPI se usan en impresión ya que definen la cantidad de puntos que hay en una pulgada, (2.54 cm) o sea un tamaño físico, pero en texturas hablamos de resolución, y esos son los puntos totales de una imagen, su ancho por su alto...si aumentamos los PDI aumentamos la resolución por lo tanto el tamaño de la imagen en pixels, lo que logramos con esto es que el motor de turno nos diga que la imagen no es valida porque no tiene un tamaño potencia de 2...

    Nada de DPI ni PPI, en 3d hablamos de pixels, cuantos hay de ancho por cuantos hay de alto... otra cosa es el render final pero eso ya se mira ne potochó...

    Saludos.

Temas similares

  1. Ayuda, como funciona Shader Model y OpenGl
    Por SIG-raster en el foro Quien eres tu - Aqui puedes presentarte
    Respuestas: 2
    Último mensaje: 04-08-2016, 16:51
  2. 3ds Max ayuda con mi programa opengl
    Por elLocoCibernetico en el foro Modelado
    Respuestas: 1
    Último mensaje: 18-06-2013, 00:07
  3. 3ds Max ayuda con un programa en OpenGL simulador de particulas
    Por HybridRain en el foro Partículas y Dinámicas
    Respuestas: 0
    Último mensaje: 13-04-2009, 07:21
  4. ayuda con programa 3ds max
    Por elplana en el foro Videojuegos
    Respuestas: 1
    Último mensaje: 02-09-2008, 09:34
  5. aYUDa CON OpenGL
    Por cdxcxn en el foro Peticiones y Búsquedas
    Respuestas: 0
    Último mensaje: 09-04-2007, 20:30

Actualmente estos son sus permisos de publicación en el foro.

  • -No puedes crear nuevos temas al no estar registrado o no haber iniciado sesión en el foro.
  • -No puedes responder temas al no estar registrado o no haber iniciado sesión en el foro.
  • -No puedes subir archivos adjuntos al no estar registrado o no haber iniciado sesión en el foro.
  • -No puedes editar tus mensajes al no estar registrado o no haber iniciado sesión en el foro.
  •