Jump to content
  • Advertisement
Sign in to follow this  
Niff

OpenGL Subwindow help

This topic is 3689 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Ok, so I am in the middle of writing a C program that will create a visualization for a tri-diagonal heat diffusion equation, and have made tremendous progress.Now, our renderScene function is a color gradient-esqe visualization of heat diffusion, but the blue part of the color scale is not quite working, so any help there is much appreciated. Now, my main problem lies in the fact that our render function (both render and renderScene work separately (a graph and a color scale, respectively)) do not work when combined(I end up with random colors on the screen, nothing visible that can be made sense of), using a subwindow for renderScene. any assistance that can be offered as to fixing this problem is greatly appreciated. PS: some things are commented out based on our troubleshooting, and some names are redundant, so bare with us. PPS: The most important part is the subwindow init. at the very bottom, but I left in our other important functions so it would make more sense, I will append a link to entire source code if you are interested in compiling. Full source: http://www.shortText.com/0s98qe The code is as follows:
// gcc scale.c -lglut -lGL -lGLU && a.out
//on windows gcc scale.c -lglut32 -lopengl32 -lglu32
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include<math.h>
#define TITLE "Visualization"

int winIdMain;
int winIdSub;
//initializes constants for tri-diagonal solver
double delta_t = .01;
double delta_x = 1;
//size of all the complete arrays
int size = 41;
int rows = 40;
int columns = 40;
//Arrays required for rendering
double * data;
float * green;
float * blue;
float * red;



//Intializes the arrays for the rendering
void fillData()
{
    int i, b, dimension;
    dimension = size - 1;
    data = malloc(size * sizeof(double));
    fill(data, size);
    green = malloc(size * sizeof(float));
    red = malloc(size * sizeof(float));
    blue = malloc(size * sizeof(float));
    data = run(delta_x, delta_t, data, size, dimension);
}
//Fills the blue array with colors based on the temps
void fillBlue(double avg)
{
    int i;
    double slope;
    slope = 1.0;
    for(i = 0; i < size; ++i){
        if(slope < .01) slope = 0;
        blue = slope;
        //slope = (data[0] / data) - 1;
        slope = 1-(data/avg);
    }
    //blue[size-1] = 0;
}
//Fills the red array with colors based on the temps
void fillRed(double avg)
{
    int i;
    double slope;
    slope = 1.0;
    for(i = size - 1; i >= 0; --i){
        //if(data < avg) slope = 0;
        if(slope < .01) slope = 0;
        red = slope;    
        slope = data / data[size-1];
        //slope = 1-data/avg;
    }
}
//Wrapper for fillRed() and fillBlue() also fills the green array
//with values based on the valuse in blue and red
void fillColor()
{
    int i, avg;
    double slope, a;
    a = (data[0] + data[size-1]) / 2;
    avg = myRound(a);
    //printf("%d\n", avg);
    fillBlue(a);
    fillRed(a);
    for(i = 0; i < size; ++i){
        slope = 1 - blue - red;
        if(slope < .01) slope = 0;
        green = slope;
    }
}

//fills the screen with rectangles for the each segment of the array of temperatures
void fillRectangles()
{
    int width, height;
    width = getWidth();
    height = getHeight();
    double t = width / size;
    int length = myRound(t);
    double previous = 0;
    int i;
    
    //printf("length = %d\n", length);
    //printf("run through function\n");
    glClear(GL_COLOR_BUFFER_BIT);
    
    //draws a segment with a color that will be based on the temp of the segment
    for(i = 0; i < size; ++i) {
        glColor3f(red, green, blue);
        glRectf( (GLdouble) previous, 0.0, (GLdouble) previous + length,  (GLdouble) height);
        previous = length + previous;
        //glFlush();
    }
    //makes the last segment fill the remainder of the screen
    if( width - previous >= 0 ) {
        glColor3f(red, green, blue);
        glRectf( (GLdouble) previous, (GLdouble) height, (GLdouble) width , 0.0);
        glFlush();
    }
}

void MyInit() {
  
  glClearColor( 0, 0, 0, 0 );
  
  glMatrixMode( GL_PROJECTION );      /* Subsequent matrix commands will affect the projection matrix */
  glLoadIdentity();                   /* Initialise the projection matrix to identity */
  glFrustum( -1, 1, -1, 1, 1, 1000 ); /* Apply a perspective-projection matrix */
  
  glMatrixMode( GL_MODELVIEW );       /* Subsequent matrix commands will affect the modelview matrix */
  glLoadIdentity();                   /* Initialise the modelview to identity */
  glTranslatef( -20, -20, -25 );           /* Translate the modelview 3 units along the Z axis */
  
}



void render() {

    int i = 0;  
  
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  glBegin(GL_LINES);
  glColor3f(0,0,1);
  
  //        Horizontal lines.
  for (i=0; i<=rows; i++) {
    glVertex2f(0, i);
    glVertex2f(columns, i);
  }

  glColor3f(1,0,1);

  
  //        Vertical lines.
  for (i=0; i<=columns; i++) {
    glVertex2f(i, 0);
    glVertex2f(i, rows);
  }
  
  glEnd();
  
  
  glBegin(GL_LINE_STRIP);
  glColor3f(1,1,1);
  
  glVertex2f(0,0);
  
  for (i=0; i<= rows; i++) {
    glVertex2f(i, data);
  }
  
  glEnd();

  
  glutSwapBuffers();
    increment();
  
}

//redenders the whole thing
void renderScene()
{
    //printf("%f\t%d\n", data[size-2], i);
    //increment();
    fillColor();
    //printer();
    fillRectangles();
    glutSwapBuffers();
}

//Initializes the GLUT window
void openWindow(GLsizei w, GLsizei h)
{
            
    // Set viewport to window dimensions
    glViewport(0, 0, w, h);

    // Reset coordinate system
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, (GLdouble) w, 0.0, (GLdouble) h);

}



// Initialize the rendering state
//Sets background color
void initialize()
{
    // Set background color to black
    glClearColor(0.0, 0.0, 0.0, 0.0);
}

void subDisplay() {
  glutSetWindow(winIdSub);
  glClearColor(0.0, 0.0,0.0,0.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  glColor3f (0.0F, 0.0F, 1.0F);
  glBegin (GL_LINE_LOOP);
  glVertex2f (0.0F, 0.0F);
  glVertex2f (0.0F, 0.99F);
  glVertex2f (0.999F, 0.99F);
  glVertex2f (0.999F, 0.0F);
  glEnd ();

  //glColor3ub(255,255,255);

    initialize();
    glutDisplayFunc(renderScene);
    glutReshapeFunc(openWindow);
    glutIdleFunc(renderScene);
    
  
// glEnd();
  glutSwapBuffers();

}

//Runs the program
int main(int argc, char** argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    glutInitWindowPosition(0, 0);
    
    glutInitWindowSize(1000,1000);
        
    winIdMain = glutCreateWindow (TITLE);    

    fillData();
    
    
    glutDisplayFunc(render);
    //glutReshapeFunc(openWindow);
    glutIdleFunc(render);
    MyInit();
    //glutMainLoop();
    

    /* Sub window creation and setup */
      winIdSub = glutCreateSubWindow (winIdMain, 0, 0, 1000, 1000 / 22);
     glutDisplayFunc (subDisplay);
    // glutReshapeFunc(openWindow);
    //glutIdleFunc(renderScene);
     glutMainLoop();
    
    return -1;
}
	

Share this post


Link to post
Share on other sites
Advertisement
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!