gldesign_tools.c

Go to the documentation of this file.

/* file GLDESIGN_TOOLS.C  */

// This file contains copies of some functions that are needed in the DLL but
// cannot be accessed from the main Designer program because it is part of the GLDESIGN DLL
// The funcions here also allow the modeller's tools to be used in the non-rectangular
// windows of the OpenGL based shanded view (in Otho-projection mode)

#define _DSCRUCT_SUB 1

#include "gldesign1.h"

extern SelXs,SelYs,SelXc,SelYc;
extern GLfloat vertex_scale,ortho_width;
extern GLfloat up_angle,round_angle;
extern int *Tool;
extern RECT oldrect;

extern void Ortho2Dto3D(int x, int y, GLfloat *xx, GLfloat *yy);
extern void Ortho3Dto2D(int *x, int *y, GLfloat xx, GLfloat yy);
extern BOOL inview(vertex  *vp);

static void m4by4(GLfloat t1[4][4], GLfloat t2[4][4], GLfloat tr[4][4]){
 short n=4,i,j,k;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  for(k=0;k<4;k++)tr[i][j]=tr[i][j]+t1[i][k]*t2[k][j];
 }
 return;
}

static m4by1(GLfloat t4[4][4], GLfloat x, GLfloat y, GLfloat z,
           GLfloat *xx, GLfloat *yy, GLfloat *zz){
 *xx=t4[0][0]*x+t4[0][1]*y+t4[0][2]*z+t4[0][3];
 *yy=t4[1][0]*x+t4[1][1]*y+t4[1][2]*z+t4[1][3];
 *zz=t4[2][0]*x+t4[2][1]*y+t4[2][2]*z+t4[2][3];
 return;
}

static void rotz(GLfloat tr[4][4], GLfloat ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][1]=-sin(ang);
  tr[1][0]= sin(ang);
  tr[1][1]= cos(ang);
  return;
}

static void rotx(GLfloat tr[4][4], GLfloat ang){
 long i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[1][1]= cos(ang);
  tr[1][2]=-sin(ang);
  tr[2][1]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

static void roty(GLfloat tr[4][4], GLfloat ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][2]=-sin(ang);
  tr[2][0]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

static void rotate_round_vector(double angle, vector v, double t[4][4]){
  double dx,dy,dz,phi,theta,dxy;
  double t1[4][4],t2[4][4],t3[4][4];
  angle *= 3.14159/180.0;
  dx=v[0]; dy=v[1]; dz=v[2];
  dxy=dx*dx+dy*dy;
  if(dxy < 0.00001){ /* vertical so just rotate about z  and return */
    if(dz > 0.0)rotz(t, angle);
    else        rotz(t,-angle);
    return;
  }
  dxy=sqrt(dxy);
  if     (dx == 0.0 && dy > 0.0)phi =  3.14159/2.0;
  else if(dx == 0.0 && dy < 0.0)phi = -3.14159/2.0;
  else phi = atan2(dy,dx);
  theta = atan2(dz,dxy);
  rotz(t3, -phi);
  roty(t2, -theta);
  m4by4(t2,t3,t1);
  rotx(t2, angle);
  m4by4(t2,t1,t3);
  roty(t2,theta);
  m4by4(t2,t3,t1);
  rotz(t2,phi);
  m4by4(t2,t1,t);
}

void SelectVertexInRectGL(void){
 int i;
 vertex *vp;
 GLfloat x,y,z,xx,yy,zz,scale,m[16],t[4][4];
 GLfloat xs,ys,xe,ye,xmin,xmax,ymin,ymax;
 scale=vertex_scale/TVsizeX;
 // Get the OpenGL transformation 
 glPushMatrix();
 glLoadIdentity();
 glTranslatef(0.0, 0.0, -5.0);
 glRotatef(up_angle,1.0,0.0,0.0);
 glRotatef(round_angle,0.0,1.0,0.0);
 glGetFloatv(GL_MODELVIEW_MATRIX,m);
 glPopMatrix();
 t[0][0]=m[0]; t[0][1]=m[4]; t[0][2]=m[ 8]; t[0][3]=m[12]; // convert to "C" matrix order
 t[1][0]=m[1]; t[1][1]=m[5]; t[1][2]=m[ 9]; t[1][3]=m[13];
 t[2][0]=m[2]; t[2][1]=m[6]; t[2][2]=m[10]; t[2][3]=m[14];
 t[3][0]=m[3]; t[3][1]=m[7]; t[3][2]=m[11]; t[3][3]=m[15]; 
 Ortho2Dto3D(SelXs,SelYs,&xs,&ys);   // get the Open GL coordinates of the selection
 Ortho2Dto3D(SelXc,SelYc,&xe,&ye);
 xmin=min(xs,xe); xmax=max(xs,xe);
 ymin=min(ys,ye); ymax=max(ys,ye);
 if(Nvert > 0){
   for(i=0,vp=MainVp;i<Nvert;i++,vp++){
     if(inview(vp)){
       x=((GLfloat)(vp->xyz[0]-TVpointX-TVsizeX/2))*scale;
       y=((GLfloat)(vp->xyz[1]-TVpointY-TVsizeY/2))*scale;
       z=((GLfloat)(vp->xyz[2]-TVpointZ-TVsizeZ/2))*scale;
       m4by1(t,x,z,-y,&xx,&yy,&zz);  // in OpenGL frame of reference
       x=xx; y=yy;  // extract the coordinates perpendicular to Ortho Window
       if(*Tool == SELECTOR){
         if(x > xmin && x < xmax && y > ymin && y < ymax && vp->status == DESELECTED){
           vp->status=SELECTED;
           NvertSelect++; NvertDeselect--;
         }
       }
       else if(*Tool == DESELECTOR){
         if(x > xmin && x < xmax && y > ymin && y < ymax && vp->status == SELECTED){
           vp->status=DESELECTED;
           NvertSelect--; NvertDeselect++;
         }
       }
     }
   }
   DrawModel();
   UpdateCounters();
 }
}

void MoveInPerspectiveGL(double dx, double dy){
 vertex *vp;
 GLfloat x1,y1,z1,dr,aspect;
 GLfloat scale,tt1[4][4],tt2[4][4],rrt[4][4];
 int i;
 dr=3.14159/180.0;
 rotz(tt2,-round_angle*dr);
 rotx(tt1,-up_angle*dr);
 m4by4(tt2,tt1,rrt);
 scale=1.0/TVsizeX;
 aspect = (GLfloat) oldrect.right / (GLfloat)oldrect.bottom;;
 dx = aspect*dx/(GLfloat)oldrect.right;
 dy = dy/(GLfloat)oldrect.bottom;
 m4by1(rrt,(GLfloat)dx*(GLfloat)TVsizeX,0.0,-(GLfloat)dy*TVsizeX,&x1,&y1,&z1);
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     vp->xyz[0] += (long)x1;
     vp->xyz[1] += (long)y1;
     vp->xyz[2] += (long)z1;
   }
   vp++;
 }
 DrawModel();
}

void RotateInPerspectiveGL(double dx, double dy){
 int i;
 vertex *vp;
 GLfloat x,y,z,xx,yy,zz,dr,xf,yf,aspect,rt;
 GLfloat scale,tt1[4][4],tt2[4][4],rrt[4][4],urrt[4][4],r[4][4];
 dr=3.14159/180.0;
 rt=-(GLfloat)dx/10.0;
 roty(r,rt*dr);
 rotz(tt2,round_angle*dr);
 rotx(tt1,up_angle*dr);
 m4by4(tt1,tt2,rrt);
 rotx(tt1,-up_angle*dr);
 rotz(tt2,-round_angle*dr);
 m4by4(tt2,tt1,urrt);
 scale=vertex_scale/TVsizeX;
 aspect = (GLfloat) oldrect.right / (GLfloat)oldrect.bottom;;
 xf=(GLfloat)SelXs/(GLfloat)oldrect.right*vertex_scale-0.5*vertex_scale;
 yf=(GLfloat)SelYs/(GLfloat)oldrect.bottom*vertex_scale-0.5*vertex_scale;
 yf=yf/aspect; 
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     x=((GLfloat)(vp->xyz[0]-TVpointX-TVsizeX/2))*scale;
     y=((GLfloat)(vp->xyz[1]-TVpointY-TVsizeY/2))*scale;
     z=((GLfloat)(vp->xyz[2]-TVpointZ-TVsizeZ/2))*scale;
     m4by1(rrt,x,y,z,&xx,&yy,&zz);
     xx -= xf; 
     zz += yf;
     m4by1(r,xx,yy,zz,&x,&y,&z);
     x += xf; 
     z -= yf;
     m4by1(urrt,x,y,z,&xx,&yy,&zz); 
     vp->xyz[0]= (long)(xx/scale+TVpointX+TVsizeX/2);
     vp->xyz[1]= (long)(yy/scale+TVpointY+TVsizeY/2);
     vp->xyz[2]= (long)(zz/scale+TVpointZ+TVsizeZ/2);
   }
   vp++;
 }
 DrawModel();
}

void ShapeInPerspectiveGL(double dx, double dy){
 vertex *vp;
 GLfloat x1,y1,z1,dr,aspect;
 GLfloat scale,tt1[4][4],tt2[4][4],rrt[4][4];
 int i;
 dr=3.14159/180.0;
 rotz(tt2,-round_angle*dr);
 rotx(tt1,-up_angle*dr);
 m4by4(tt2,tt1,rrt);
 scale=1.0/TVsizeX;
 aspect = (GLfloat) oldrect.right / (GLfloat)oldrect.bottom;;
 dx = aspect*dx/(GLfloat)oldrect.right;
 dy = dy/(GLfloat)oldrect.bottom;
 m4by1(rrt,(GLfloat)dx*(GLfloat)TVsizeX,0.0,-(GLfloat)dy*TVsizeX,&x1,&y1,&z1);
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
//     vp->xyz[0] += (long)x1;
//     vp->xyz[1] += (long)y1;
//     vp->xyz[2] += (long)z1;
   }
   vp++;
 }
 DrawModel();
}