/Users/craigcornelius/Projects/SPRING Mac Release 0.2/screen.cpp

Go to the documentation of this file.

// $Id: screen.cpp,v 1.24 2006/05/30 18:48:02 craig Exp $
// $Copyright: (c)2001 National Biocomputation Center, Stanford University $

#include "object.h"
#include "objectarray.h"
#include "facearray.h"
#include "nodearray.h"
#include "node.h"
#include "face.h"
#include "edgearray.h"
#include "edge.h"
#include "point3d.h"
#include "cyberware.h"
//#include "Fbus.h"



#include "screen.h"
/* */
#include <stdlib.h>  // for malloc, free, qsort, ...
#include <assert.h>  // for assert functions...
#include <stdio.h>

#ifdef _WIN32
#include <windows.h>
#else
#include <strings.h>
#endif


#ifndef __APPLE__
#include <GL/gl.h>
#include <GL/glu.h>
#else
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#endif //__APPLE__ 

#define NumSources 4

int NP2(int num)
{
    int res = 1;
    while (res < num) res *= 2;
    return res;
}


// globals
int Screen::debug = 0;
const char* Screen::rcsid = "@(#) $Id: screen.cpp,v 1.24 2006/05/30 18:48:02 craig Exp $ $Copyright: (c)2001 National Biocomputation Center, Stanford University $";

Screen::Screen() : Object()
{ 
    if (debug) cerr << "Screen::constructor()\n";
    objectarray_p = NULL;
    type = nodes_only; 
    dynamics = rest;
    behavior = none;
    nummethod = quasi_ordered;
    visible = 1;
    selected = 0;
    texture = NULL;
    nodearray.Init(&edgearray);
    strncpy(name, "UNINITIALIZED", NAME_LENGTH);
    sensor_p = NULL;    // not linked to any sensor
    linked_part = 0;    // entire object (class/color 0)
 
    closest_node = NULL;
    being_grabbed = 0;
    sensor_offset = Point3D(0,0,0);     
    uses_viagra = 1;
    
    // collision stuff
    collision_extent = no_collisions;
    collision_pairs.Init();
    boundingSphereRoot = NULL;
    
    // graphics stuff
    dl_needs_refresh = 1;
    dl_id = -1;
    
    // initial params
    display_mode.mode = DisplayMode::smooth; 
    display_mode.draw_subobjcolormode = 0;
    last_display_mode = display_mode;
    
    Video = 0;
    View = 0;
    Source = 0;
    Dict = 0;
    Scan = 0;
    scan_index = 1;
    Dictation.x = -200.0;
    Dictation.y = 200.0;
    Dictation.z = 0.0;
    
    // set default material properties, based on dynamics
    set_default_material_properties();
}

Screen::~Screen() 
{ 
    if (debug) cerr << "Screen[" << name << "]::destructor()\n";
    strncpy(name, "DESTROYED", NAME_LENGTH);
}

void Screen::Init(ObjectArray* objectarray_in, char* name_in)
{
    objectarray_p = objectarray_in;
    if (!name_in) name_in = "UNNAMED";
    strncpy(name, name_in, NAME_LENGTH);
    nodearray.computeTextureCoords(Node::linear);
    
}




void Screen::TVscreen(Point3D corner1, Point3D corner2,
                      Point3D corner3, Point3D corner4)
{
    type = faces_only;
    dynamics = rest;
    set_default_material_properties(); // setup wall properties appropriately
    
    // calculate how many nodes and edges there will be and allocate enough
    nodearray.reset();
    edgearray.reset();
    facearray.reset();
    nodearray.allocateNodes(4);
    edgearray.allocateEdges(5);
    facearray.allocateFaces(2);
    
    // creates the nodes
    int index1 = nodearray.addNode(corner1);
    int index2 = nodearray.addNode(corner2);
    int index3 = nodearray.addNode(corner3);
    int index4 = nodearray.addNode(corner4);
    
    // create the faces (in clockwise order)
    facearray.addFace(index1, index2, index3);    
    facearray.addFace(index3, index4, index1);    
    
    // tell nodearray to recalculate bounding boxes, etc
    nodearray.computeStats();
    
    // put the sensor "hot spot" in the middle of the box
    //  sensor_offset = -(nodearray.getCenter());
    
    // recompute surface normals (since is a new surface)
    facearray.computeNormals();
    
    // average face normals to get per-vertex normals
    nodearray.interpolateNormals();
    
    // and compute the texture coords (assume linear)
    nodearray.computeTextureCoords(Node::linear);
    
    
}

int Screen::IsViewOn()
{
    return (View);
}

void Screen::SwitchOnView()
{
    View = 1;
}

void Screen::SwitchOffView()
{
    View = 0;
}


int Screen::IsVideoOn()
{
    return (Video);
}

void Screen::SwitchOnVideo()
{
    Video = 1;
}

void Screen::SwitchOffVideo()
{
    Video = 0;
}
int Screen::IsDictationOn()
{
    return (Dict);
}

void Screen::SwitchOnDictation()
{
    Dict = 1;
}

void Screen::SwitchOffDictation()
{
    Dict = 0;
}

int Screen::IsScanOn()
{
    return (Scan);
}

void Screen::SwitchOnScan()
{
    Scan = 1;
}

void Screen::SwitchOffScan()
{
    Scan = 0;
}

void Screen::ScanInit(int numscan, int scangrp)
{
    scan_stopped = 1;
    scan_index = 1;
    scan_speed = 1;
    scan_count = numscan;
    scan_dir = 1;
    scan_group = scangrp;
    Scan = 1;
}

void Screen::ScanFaster()
{
    scan_stopped = 0;
    if (scan_speed < 50) scan_speed *=1.5;
}

void Screen::ScanSlower()
{
    scan_stopped = 0;
    if (scan_speed > 0.2) scan_speed /=1.5;
}

void Screen::ScanRefresh()
{
    if (!scan_stopped)
    {
        scan_index = ((int)floor(scan_index + scan_speed*scan_dir) % scan_count);
        if (scan_index < 0) scan_index += scan_count;
    }
}

void Screen::ScanStop()
{
    scan_stopped = 1;
}

void Screen::ScanReverse()
{
    scan_dir *= -1;
}

int Screen::getScanIndex()
{
    return scan_index;
}

void Screen::showMarker(wall_pos dir)
{
    double  coeff;
    coeff = (scan_count) ? (double)scan_index/scan_count : 0;
    glColor4f((GLfloat)0.0, (GLfloat)1.0, (GLfloat)0.0, (GLfloat)0.3);
    glBegin(GL_POLYGON);
    switch (dir) {
    case LEFT : {
        glVertex3d(min.x + coeff*(max.x - min.x), min.y, min.z);
        glVertex3d(min.x + coeff*(max.x - min.x), max.y, min.z);
        glVertex3d(min.x + coeff*(max.x - min.x), max.y, max.z);
        glVertex3d(min.x + coeff*(max.x - min.x), min.y, max.z);
        break;
                }
    case RIGHT : {
        glVertex3d(max.x - coeff*(max.x - min.x), min.y, min.z);
        glVertex3d(max.x - coeff*(max.x - min.x), max.y, min.z);
        glVertex3d(max.x - coeff*(max.x - min.x), max.y, max.z);
        glVertex3d(max.x - coeff*(max.x - min.x), min.y, max.z);
        break;
                 }
    case UP : {
        glVertex3d(min.x,max.y - coeff*(max.y - min.y),min.z);
        glVertex3d(min.x,max.y - coeff*(max.y - min.y),max.z);
        glVertex3d(max.x,max.y - coeff*(max.y - min.y),max.z);
        glVertex3d(max.x,max.y - coeff*(max.y - min.y),min.z);
        break;
              }
    case DOWN : {
        glVertex3d(min.x,min.y + coeff*(max.y - min.y),min.z);
        glVertex3d(min.x,min.y + coeff*(max.y - min.y),max.z);
        glVertex3d(max.x,min.y + coeff*(max.y - min.y),max.z);
        glVertex3d(max.x,min.y + coeff*(max.y - min.y),min.z);
        break;
                }
    case BACK : {
        glVertex3d(min.x,min.y,min.z + coeff*(max.z - min.z));
        glVertex3d(max.x,min.y,min.z + coeff*(max.z - min.z));
        glVertex3d(max.x,max.y,min.z + coeff*(max.z - min.z));
        glVertex3d(min.x,max.y,min.z + coeff*(max.z - min.z));
        break;
                }
    case FRONT : {
        glVertex3d(min.x,min.y,max.z - coeff*(max.z - min.z));
        glVertex3d(max.x,min.y,max.z - coeff*(max.z - min.z));
        glVertex3d(max.x,max.y,max.z - coeff*(max.z - min.z));
        glVertex3d(min.x,max.y,max.z - coeff*(max.z - min.z));
        break;
                 }
    }
    glEnd();
    
    dl_needs_refresh = 1;
    
}

void Screen::newTexture(unsigned char* base)
{
    
    //  for (int i = 0; i < texture_size.x*texture_size.y; i+=3)
    //          swap(*(base+i),*(base+i+2));
    texture = base;
    
    // setup other vars
    dl_needs_refresh = 1;
    
}

void Screen::setGrayTexture(unsigned* my_texture)
{
    int length = 512*512;
    texture = (unsigned char*)malloc(4*length*sizeof(unsigned char));
    for (int i = 0; i < length; i++)
    {
        texture[4*i] = my_texture[i];
        texture[4*i+1] = my_texture[i];
        texture[4*i+2] = my_texture[i];
        texture[4*i+3] = 0xff;
    }
    dl_needs_refresh = 1;
}





void Screen::MakeTexture(int large, int haut)
{
    glReadBuffer(GL_BACK);
    glReadPixels(0,0,large,haut,GL_RGBA,GL_UNSIGNED_BYTE, texture);
}

void Screen::InitTexture(int large, int haut, int depth)
{
    texture_size.x = large;
    texture_size.y = haut;
    texture_size.z = depth;
}

void Screen::ScreenTranslate(wall_pos dir)
{
    Point3D e1 = nodearray.getHorizontalVector();
    Point3D e2 = nodearray.getVerticalVector();
    Point3D e3;
    e3.x = e1.y*e2.z - e1.z*e2.y;
    e3.y = e1.z*e2.x - e1.x*e2.z;
    e3.z = e1.x*e2.y - e1.y*e2.x;
    float d = (float)0.04;
    float d2 = (float)0.0002;
    
    switch (dir) {
    case RIGHT:
        {
            nodearray.translate(e1.x*d, e1.y*d, e1.z*d);
            dl_needs_refresh = 1;
            break;
        }
    case LEFT:
        {
            nodearray.translate(-e1.x*d, -e1.y*d, -e1.z*d);
            dl_needs_refresh = 1;
            break;
        }
    case UP:
        {
            nodearray.translate(e2.x*d, e2.y*d, e2.z*d);
            dl_needs_refresh = 1;
            break;
        }
    case DOWN:
        {
            nodearray.translate(-e2.x*d, -e2.y*d, -e2.z*d);
            dl_needs_refresh = 1;
            break;
        }
    case FRONT:
        {
            nodearray.translate(e3.x*d2, e3.y*d2, e3.z*d2);
            dl_needs_refresh = 1;
            break;
        }
    case BACK:
        {
            nodearray.translate(-e3.x*d2, -e3.y*d2, -e3.z*d2);
            dl_needs_refresh = 1;
            break;
        }
    }
}



void Screen::ScreenRotate(wall_pos dir)
{
    nodearray.pivote(dir);
    dl_needs_refresh = 1;
}


void Screen::ScreenStretch(wall_pos dir)
{
    nodearray.stretch(dir);
    dl_needs_refresh = 1;
}

int Screen::SwitchSource()
{
    Source = (Source + 1) % NumSources;
    return (Source);
}


void Screen::ShowDictation(char* buf)
{
    
}



// top level draw function
void Screen::Draw()
{
    if (visible)
        DrawGeometry();
    if (selected)
        DrawBoundingBox();
}




// this draws the edges and/or faces and/or nodes of the actual object
void Screen::DrawGeometry()
{ 
    if (debug) cerr << "Object[" << name << "]::Draw(" << &display_mode << ")\n";
    
    
    // find out if we're selecting/picking
    GLint rendermode;
    glGetIntegerv(GL_RENDER_MODE, &rendermode);
    
    // if have updated, assume we need to refresh graphics
    extern int do_display_lists;
    if (do_display_lists && !dl_needs_refresh &&
        (display_mode == last_display_mode) && (rendermode == GL_RENDER)) {
        glCallList(dl_id);
        return;
    }
    
    // if never here before, create a new list
    if (dl_id == -1) dl_id = glGenLists(1);
    else glDeleteLists(dl_id, 1);
    
    // setup for DL list refresh
    glNewList(dl_id, GL_COMPILE_AND_EXECUTE);
    dl_needs_refresh = 0;
    last_display_mode = display_mode;
    if (debug) cerr << "Object[" << getName() << "- regen display-list\n";
    
    // since have updated node positions, recalculate our stats here
    // (we used to do it on every iteration, but that was overkill)
    nodearray.computeStats();
    
    // if doing selection, load up the object number on the name stack
    if (rendermode == GL_SELECT)
        glPushName(objectarray_p->getIndex(this));
    
    
    // draw special things- labels, normals, etc
    {
        glDisable(GL_LIGHTING);
        glShadeModel(GL_FLAT);
        
        // if to draw normals on nodes
        if (display_mode.draw_nodenormals) 
        { nodearray.drawnormals(); }
        
        // if to draw normals on faces
        if (display_mode.draw_facenormals) 
        { facearray.drawnormals(); }
        
        // if to draw mesh over polys
        if ((type == faces_only) && display_mode.draw_wireover) 
        { glColor3d(0.0, 0.0, 0.0); edgearray.drawover(drawover_amount); }
        
        // if to draw initial position
        if (display_mode.draw_initial) 
        { edgearray.drawinitial(); nodearray.drawinitial(); }
        
        // if to draw labels for nodes
        if (display_mode.draw_nodelabels) 
        { glColor3d(0.5, 1.0, 1.0); nodearray.drawlabels(label_offset); }
        
        // if to draw labels for edges
        if (display_mode.draw_edgelabels) 
        { glColor3d(1.0, 1.0, 0.5); edgearray.drawlabels(label_offset); }
        
        // if to draw labels for faces
        if (display_mode.draw_facelabels) 
        { glColor3d(0.5, 1.0, 0.5); facearray.drawlabels(label_offset); } 
        
        // if to draw labels for objects
        if (display_mode.draw_objectlabels) 
        { glColor3d(1.0, 0.0, 0.0); DrawLabel(); }
    }
    
    // do textures if supposed to
    extern int do_textures;
    if (do_textures && texture && (type == faces_only) &&
        ((display_mode.mode == DisplayMode::flat) || 
        (display_mode.mode == DisplayMode::smooth))){
        // if we have a texture, deal with it here
        glEnable(GL_TEXTURE_2D);
        
        // 4-byte-wise alignment (word-align) for speed
        glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
        
        // setup texturing parameters
        //MODULATE,BLEND,DECAL,REPLACE
        if (texture_mode == Object::texture_env_mode(0))
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        else if (texture_mode == texture_env_mode(1))
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
        else if (texture_mode == Object::texture_env_mode(2))
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
        else if (texture_mode == Object::texture_env_mode(3))
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        
        if (texture_wrap == Object::texture_wrap_st(0)) {       
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
        }
        else {
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        }
        
        if (texture_filter == Object::texture_min_mag_filter(0)) {
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        }
        else {
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        }
        
        // debugging if we need it
        if (debug) 
            cerr << "applying " << texture_size.x << "x" << texture_size.y 
            << " texture...\n";
            /*
            // Uses "billboarding" [see OpenGL PG- p201] to render textures
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, NP2(texture_size.x), 
            NP2(texture_size.y), 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
            }
            
              glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,texture_size.x, 
              texture_size.y, GL_RGB, GL_UNSIGNED_BYTE, texture);
        */
        
        //      gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGB, texture_size.x, texture_size.y, GL_RGB,
        //              GL_UNSIGNED_BYTE, texture);
        int crop_w = 1,crop_h = 1;
        int grab_w = 256,grab_h = 256;
        if ((texture_size.x == 256) || (texture_size.x == 512))
        {
            grab_w = texture_size.x;
            crop_w = 0;
        }
        if ((texture_size.y == 256) || (texture_size.y == 512))
        {
            grab_h = texture_size.y;
            crop_h = 0;
        }
        
        
        unsigned char*texture2 = NULL;
        int d = texture_size.z;
        if (crop_w*crop_h) {
            
            if (!texture2)
                texture2 = (unsigned char*)malloc(grab_w*grab_h*d*sizeof(unsigned char));
            
            //GLint status = -13 ;
            //status = gluScaleImage(GL_RGB, texture_size.x, texture_size.y, GL_UNSIGNED_BYTE, texture, grab, grab, GL_UNSIGNED_BYTE,
            //          texture2);
            
            
            int texWidth = (grab_w > texture_size.x ? texture_size.x : grab_w);
            int texHeight = (grab_h > texture_size.y ? texture_size.y : grab_h);
            
            for (int count = 0; count < texHeight; count++)
                memcpy((char *)texture2 + count*grab_w*d, (char *)texture + (count)*texture_size.x*d, texWidth*d);
        }
        else 
            texture2 = (unsigned char*)texture;
        
        switch (d) {
        case 1:
            glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, grab_w, 
                grab_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, texture2);
            break;
        case 3:
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, grab_w, 
                grab_h, 0, GL_RGB, GL_UNSIGNED_BYTE, texture2);
            break;
        case 4:
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, grab_w, 
                grab_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture2);
            break;
        default:
            break;
        }
        
        //  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, grab_w, 
        //              grab_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
        
  }
  
  
  // if we should just display nodes, do so
  switch (type) {
  case nodes_only: {
      glDisable(GL_LIGHTING);
      nodearray.DrawNodes();
      break;
                   }
  case edges_only: {
      glDisable(GL_LIGHTING);
      edgearray.DrawEdges();
      if (display_mode.mode == DisplayMode::wireframe)
          nodearray.DrawNodes();
      break;
                   }
  case faces_only: {
      // recompute normals (since surface is changing)
      facearray.computeNormals();
      
      // average face normals to get per-vertex normals
      nodearray.interpolateNormals();
      
      // depending on the display mode
      if (display_mode.mode == DisplayMode::wireframe) {
          glDisable(GL_LIGHTING);
          edgearray.DrawEdges();
          nodearray.DrawNodes();
      }
      
      // for flat or solid shaded modes
      if ((display_mode.mode == DisplayMode::flat) || 
          (display_mode.mode == DisplayMode::smooth)) {
          // turn on lights
          glEnable(GL_LIGHTING);
          
          // setup shading
          if (display_mode.mode == DisplayMode::flat) glShadeModel(GL_FLAT);
          else glShadeModel(GL_SMOOTH);
          
          { // do colors/material properties
              glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
              glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
              glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
              glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
              
              glMaterialfv(GL_BACK, GL_AMBIENT, back_mat_ambient);
              glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
              glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
              glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);                                          
          }
          
          // do the draw
          facearray.DrawFaces(int(do_textures && texture));
      }
      break;
                   }
  } // end switch(type)
  
  // finish up - other objects may not be textured, so turn off
  glDisable(GL_TEXTURE_2D);    
  
  {   // draw tie nodes if set to yes

          if (display_mode.draw_tienodes) {

                  nodearray.drawtienodes();

          }
      
      // if to draw bounding sphere
      if (display_mode.draw_boundingspheres && boundingSphereRoot)
          boundingSphereRoot->drawSubtree(); 
                
          //draw the principal axis
          if (display_mode.draw_principalaxis){
                        getNodeArray()->PrincipalAxes();
                        DrawPrincipalAxes();
          }
  }
  
  // if doing selection, pop the object number off the name stack
  if (rendermode == GL_SELECT)
      glPopName();
  
  // end of display list
  glEndList();
}

---