---

/home/landauf/painter/miniproject/framewk/framewk.cpp

Go to the documentation of this file.

//
//    Title: framewk.cc
//  Created: Tue Oct 16 09:53:01 2001
//   Author: Tim Weyrich <weyrich@inf.ethz.ch>
//
//  copyright (c) 2001--2003, Computer Graphics Laboratory, ETH Zuerich
//

#include <stdlib.h>
#include <math.h>

#include <imagergba.h>

#include "framewk.h"



typedef struct
{
  int  width;
  int  height;

  int  bytesPerPixel;

  void  *data;
} Image;

static const Image  *displayImage = NULL;  /* let this pointer point to the
                                              image you want to display */
static GLdouble      displayZoom = 1.0;    /* read only (is set by redrawCB);
                                              don't change it directly */
static GLint  displayHotSpotX = 0;
static GLint  displayHotSpotY = 0;

static GLdouble  displayRasterX = 0;
static GLdouble  displayRasterY = 0;

static bool  displayChanged = true;

static int  glutWindowId = -1;          /* for internal use */


//  Static Function Prototypes                                               //

static void  fwkPostRedisplayNoChange(void);

static void  fwkWindowToImageCoordinates(int x, int y, float *ix, float *iy);

static void  fwkSetDisplayHotSpot(int x, int y);

//  Functions for Zoom Calculations                                          //

#include <iostream.h>

#define  HAVE_GLCOPYTEXSUBIMAGE2D

static bool  fwkUpdateRasterPos(void)
  /* compute raster position */
{
  GLdouble  oldRasterX = displayRasterX;
  GLdouble  oldRasterY = displayRasterY;

  {
    GLdouble  displayWidth = displayZoom * displayImage->width;
    GLdouble  displayHeight = displayZoom * displayImage->height;
    GLint     vp[4];
        
    glGetIntegerv(GL_VIEWPORT, vp);
        
    if (vp[2] >= displayWidth)
      displayRasterX = (vp[2] - displayWidth) / 2;
    else
      {
#ifdef HAVE_GLCOPYTEXSUBIMAGE2D
        displayRasterX = displayHotSpotX - displayWidth * displayHotSpotX / (float)vp[2];
#else
        displayRasterX = 0;  // as long as I'm using glDrawPixels, I'm not allowed to have a negative displayRasterX.
#endif
      }

    if (vp[3] >= displayHeight)
      displayRasterY = (vp[3] - displayHeight) / 2;
    else
      {
#ifdef HAVE_GLCOPYTEXSUBIMAGE2D
        displayRasterY = displayHotSpotY - displayHeight * displayHotSpotY / (float)vp[3];
#else
        displayRasterY = 0;  // as long as I'm using glDrawPixels, I'm not allowed to have a negative displayRasterY.
#endif
      }
  }

  return displayRasterX != oldRasterX || displayRasterY != oldRasterY;
}

void  fwkWindowToImageCoordinates(int x, int y, float *ix, float *iy)
{
  *ix = (float)((x+0.5-displayRasterX) / displayZoom);
  *iy = (float)((y+0.5-displayRasterY) / displayZoom);
}

//  Callback Functions                                                       //

#ifdef HAVE_GLCOPYTEXSUBIMAGE2D
GLuint  imageTexID = 0;
#endif
static unsigned  nextPowerOfTwo(unsigned x)
{
  int       n;
  unsigned  m = x;
  for (n=0; m; m>>=1, n++);
  if (x == (1u << (n-1)))
    return (1u << (n-1));
  else
    return (1u << n);
}

#ifdef HAVE_GLCOPYTEXSUBIMAGE2D
unsigned  texWidth = 0;
unsigned  texHeight = 0;
GLenum    texId = 0;
#endif

static void  fwkRedrawCB(void)
  /* This callback function is called, whenever a redraw of the
   * current window is needed. For your work on the exercise, there
   * is no need to touch this function.
   *
   * Actually, this function displays the image pointed at by
   * displayImage.
   */
{
  if (displayImage)
    { /* there is a valid image to display */
      GLint     vp[4];
        
      glGetIntegerv(GL_VIEWPORT, vp);

      fwkUpdateRasterPos();

      /* set up OpenGL projection matrix */
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glOrtho(0, vp[2], vp[3], 0, -1, 1);
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();

      /* set up memory alignment */
      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
      glPixelStorei(GL_PACK_ALIGNMENT, 1);

      /* clear buffer and draw image */
      glClearColor(0.2f,0.2f,0.4f,1.0f);
      glClear(GL_COLOR_BUFFER_BIT);

#ifdef HAVE_GLCOPYTEXSUBIMAGE2D
      {
        if (texId==0 || displayChanged)
          {
            unsigned  w2p = nextPowerOfTwo((unsigned)displayImage->width);
            unsigned  h2p = nextPowerOfTwo((unsigned)displayImage->width);
            if (texId > 0 && (w2p != texWidth || h2p != texHeight))
              {
                glDeleteTextures(1, &texId);
                texId = 0;
              }
            if (texId == 0)
              {
                glGenTextures(1, &texId);
                glBindTexture(GL_TEXTURE_2D, texId);

                texWidth = w2p;
                texHeight = h2p;
                // Create Null Texture
                glTexImage2D(GL_TEXTURE_2D, 0, 
                             displayImage->bytesPerPixel,
                             texWidth, texHeight, 0,
                             displayImage->bytesPerPixel == 4 ? GL_RGBA : GL_LUMINANCE,
                             GL_UNSIGNED_BYTE,
                             NULL);
              }
            else
              glBindTexture(GL_TEXTURE_2D, texId);
            
            glTexSubImage2D(GL_TEXTURE_2D, 0,
                            0, 0, displayImage->width, displayImage->height,
                            displayImage->bytesPerPixel == 4 ? GL_RGBA : GL_LUMINANCE,
                            GL_UNSIGNED_BYTE,
                            displayImage->data);
          }
        else
          glBindTexture(GL_TEXTURE_2D, texId);
        
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            
        glEnable(GL_TEXTURE_2D);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_LIGHTING);
        glBegin(GL_QUADS);
        {
          GLfloat  displayWidth = displayZoom * displayImage->width;
          GLfloat  displayHeight = displayZoom * displayImage->height;

          GLfloat  maxS = (GLfloat)displayImage->width / texWidth;
          GLfloat  maxT = (GLfloat)displayImage->height / texHeight;

          glTexCoord2f(0, 0);
          glVertex2f(displayRasterX, displayRasterY);
          
          glTexCoord2f(maxS, 0);
          glVertex2f(displayRasterX+displayWidth, displayRasterY);
          
          glTexCoord2f(maxS, maxT);
          glVertex2f(displayRasterX+displayWidth, displayRasterY+displayHeight);
          
          glTexCoord2f(0, maxT);
          glVertex2f(displayRasterX, displayRasterY+displayHeight);
        }
        glEnd();
        glEnable(GL_DEPTH_TEST);
        glDisable(GL_TEXTURE_2D);
      }
#else
      {
        glRasterPos2d(displayRasterX, displayRasterY);
        glPixelZoom(displayZoom, -displayZoom);
        if (displayImage->bytesPerPixel == 4)
          {
            glDrawPixels(displayImage->width, displayImage->height,
                         GL_RGBA,
                         GL_UNSIGNED_BYTE,
                         displayImage->data);
          }
        else
          {
            glDrawPixels(displayImage->width, displayImage->height,
                         GL_LUMINANCE,
                         GL_UNSIGNED_BYTE,
                         displayImage->data);
          }
      }
#endif
    }
  else
    /* if no image is available, just clear buffer */
    glClear(GL_COLOR_BUFFER_BIT);

  /* transfer buffer to window */
  glutSwapBuffers();

  displayChanged = false;
}

static void  fwkKeyboardCB(unsigned char key, int x, int y)
{
  float  imageX;
  float  imageY;
  
  fwkSetDisplayHotSpot(x, y);
  fwkWindowToImageCoordinates(x, y, &imageX, &imageY);
  
  keyboardCB(key, imageX, imageY);
}

static void  fwkSpecialCB(int key, int x, int y)
{
  float  imageX;
  float  imageY;
  
  fwkSetDisplayHotSpot(x, y);
  fwkWindowToImageCoordinates(x, y, &imageX, &imageY);
  
  specialCB(key, imageX, imageY);
}

static void  fwkMouseCB(int button, int state, int x, int y)
{
  float  imageX;
  float  imageY;
  
  fwkSetDisplayHotSpot(x, y);
  fwkWindowToImageCoordinates(x, y, &imageX, &imageY);
  
  mouseCB(button, state, imageX, imageY);
}

static void  fwkMotionCB(int x, int y)
{
  float  imageX;
  float  imageY;
  
  fwkSetDisplayHotSpot(x, y);
  fwkWindowToImageCoordinates(x, y, &imageX, &imageY);
  
  motionCB(imageX, imageY);
}

static void  fwkPassiveMotionCB(int x, int y)
{
  fwkSetDisplayHotSpot(x, y);
}

// Initializations                                                           //

void  fwkInit(int *argc, const char *argv[])
{
  /* Initialize Display */
  {
    if (argc && *argc >= 1 && argv)
      glutInit(argc, (char **)argv);
    else
      {
        int    fake_argc = 1;
        char  *fake_argv[] = {"painter"};
        glutInit(&fake_argc, fake_argv);
      }
  }

  /* Get double-buffered rgb display without depth-buffer. */
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

  /* Open Window */
  glutInitWindowSize(512, 512);
  glutWindowId = glutCreateWindow("Paint Application");
  
  /* Register Callbacks. */
  glutDisplayFunc(fwkRedrawCB);
  glutKeyboardFunc(fwkKeyboardCB);
  glutSpecialFunc(fwkSpecialCB);
  glutMouseFunc(fwkMouseCB);
  glutMotionFunc(fwkMotionCB);
  glutPassiveMotionFunc(fwkPassiveMotionCB);
  glutIdleFunc(idleCB);
}

void  fwkMainLoop(void)
{
  glutMainLoop();
}


void  fwkSetDisplayImage(const void *img)
{
  assert(((const Image *)img)->bytesPerPixel == 1 ||
         ((const Image *)img)->bytesPerPixel == 4);
  
  if (displayImage != img && glutWindowId >= 0)
    {
      displayImage = (const Image *)img;
      glutPostRedisplay();
    }
  else
    displayImage = (const Image *)img;
}

float  fwkGetDisplayZoom(void)
{
  return (float)displayZoom;
}

void  fwkSetDisplayZoom(float zoom)
{
  if (displayZoom != zoom)
    {
      displayZoom = zoom;
      fwkPostRedisplayNoChange();
    }
}

void  fwkSetDisplayHotSpot(int x, int y)
{
  if (displayHotSpotX != x || displayHotSpotY != y)
    {
      GLint     vp[4];
        
      glGetIntegerv(GL_VIEWPORT, vp);

      if (x >= vp[0] && x-vp[0] < vp[2])
        displayHotSpotX = x;
          
      if(y >= vp[1] && y-vp[1] < vp[3])
        displayHotSpotY = y;

      if (fwkUpdateRasterPos())
        fwkPostRedisplayNoChange();
    }
}

void  fwkPostRedisplay(void)
{
  displayChanged = true;
  glutPostRedisplay();
}

void  fwkPostRedisplayNoChange(void)
{
  glutPostRedisplay();
}

---