src/glu/sgi/libnurbs/interface/glrenderer.cc

   1 /*
   2 ** License Applicability. Except to the extent portions of this file are
   3 ** made subject to an alternative license as permitted in the SGI Free
   4 ** Software License B, Version 1.1 (the "License"), the contents of this
   5 ** file are subject only to the provisions of the License. You may not use
   6 ** this file except in compliance with the License. You may obtain a copy
   7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
   8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
   9 **
  10 ** http://oss.sgi.com/projects/FreeB
  11 **
  12 ** Note that, as provided in the License, the Software is distributed on an
  13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
  14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
  15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
  16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
  17 **
  18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
  19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
  20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
  21 ** Copyright in any portions created by third parties is as indicated
  22 ** elsewhere herein. All Rights Reserved.
  23 **
  24 ** Additional Notice Provisions: The application programming interfaces
  25 ** established by SGI in conjunction with the Original Code are The
  26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
  27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
  28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
  29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
  30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
  31 ** published by SGI, but has not been independently verified as being
  32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
  33 **
  34 ** $Date: 2001/03/17 00:25:40 $ $Revision: 1.1 $
  35 */
  36 /*
  37 ** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/interface/glrenderer.cc,v 1.1 2001/03/17 00:25:40 brianp Exp $
  38 */
  39
  40 #include "gluos.h"
  41 #include "glimports.h"
  42 #include "glrenderer.h"
  43
  44 GLUnurbs::GLUnurbs()
  45         : NurbsTessellator(curveEvaluator, surfaceEvaluator)
  46 {
  47     redefineMaps();
  48     defineMap(GL_MAP2_NORMAL, 0, 3);
  49     defineMap(GL_MAP1_NORMAL, 0, 3);
  50     defineMap(GL_MAP2_TEXTURE_COORD_1, 0, 1);
  51     defineMap(GL_MAP1_TEXTURE_COORD_1, 0, 1);
  52     defineMap(GL_MAP2_TEXTURE_COORD_2, 0, 2);
  53     defineMap(GL_MAP1_TEXTURE_COORD_2, 0, 2);
  54     defineMap(GL_MAP2_TEXTURE_COORD_3, 0, 3);
  55     defineMap(GL_MAP1_TEXTURE_COORD_3, 0, 3);
  56     defineMap(GL_MAP2_TEXTURE_COORD_4, 1, 4);
  57     defineMap(GL_MAP1_TEXTURE_COORD_4, 1, 4);
  58     defineMap(GL_MAP2_VERTEX_4, 1, 4);
  59     defineMap(GL_MAP1_VERTEX_4, 1, 4);
  60     defineMap(GL_MAP2_VERTEX_3, 0, 3);
  61     defineMap(GL_MAP1_VERTEX_3, 0, 3);
  62     defineMap(GL_MAP2_COLOR_4, 0, 4);
  63     defineMap(GL_MAP1_COLOR_4, 0, 4);
  64     defineMap(GL_MAP2_INDEX, 0, 1);
  65     defineMap(GL_MAP1_INDEX, 0, 1);
  66
  67     setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
  68     setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
  69     setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
  70     setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
  71
  72     setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, (float) 50.0);
  73     setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, (float) 50.0);
  74     setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, (float) 50.0);
  75     setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, (float) 50.0);
  76
  77     setnurbsproperty(GL_MAP1_VERTEX_3, N_ERROR_TOLERANCE, (float) 0.50);
  78     setnurbsproperty(GL_MAP1_VERTEX_4, N_ERROR_TOLERANCE, (float) 0.50);
  79     setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, (float) 0.50);
  80     setnurbsproperty(GL_MAP2_VERTEX_4, N_ERROR_TOLERANCE, (float) 0.50);
  81
  82     setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, (float) 100.0);
  83     setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, (float) 100.0);
  84     setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, (float) 100.0);
  85     setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, (float) 100.0);
  86
  87     //added for optimizing untrimmed case
  88     set_domain_distance_u_rate(100.0);
  89
  90     setnurbsproperty(GL_MAP1_VERTEX_3, N_T_STEPS, (float) 100.0);
  91     setnurbsproperty(GL_MAP1_VERTEX_4, N_T_STEPS, (float) 100.0);
  92     setnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, (float) 100.0);
  93     setnurbsproperty(GL_MAP2_VERTEX_4, N_T_STEPS, (float) 100.0);
  94
  95     //added for optimizing untrimmed case
  96     set_domain_distance_v_rate(100.0);
  97     set_is_domain_distance_sampling(0); //since the default is path_length
  98
  99     //default autoloadmode is true
 100     autoloadmode = 1;
 101
 102     //default callbackFlag is 0
 103     callbackFlag = 0;
 104
 105     errorCallback = NULL;
 106 }
 107
 108 void
 109 GLUnurbs::bgnrender(void)
 110 {
 111     if (autoloadmode) {
 112         loadGLMatrices();
 113     }
 114 }
 115
 116 void
 117 GLUnurbs::endrender(void)
 118 {
 119 }
 120
 121 void
 122 GLUnurbs::errorHandler(int i)
 123 {
 124     int gluError;
 125
 126     gluError = i + (GLU_NURBS_ERROR1 - 1);
 127     postError( gluError );
 128 }
 129
 130 void
 131 GLUnurbs::loadGLMatrices(void)
 132 {
 133     GLfloat vmat[4][4];
 134     GLint viewport[4];
 135
 136     grabGLMatrix((GLfloat (*)[4]) vmat);
 137     loadCullingMatrix((GLfloat (*)[4]) vmat);
 138     ::glGetIntegerv((GLenum) GL_VIEWPORT, (GLint *) viewport);
 139     loadSamplingMatrix((const GLfloat (*)[4]) vmat, (const GLint *) viewport);
 140 }
 141
 142 void
 143 GLUnurbs::useGLMatrices(const GLfloat modelMatrix[16],
 144                           const GLfloat projMatrix[16],
 145                           const GLint viewport[4])
 146 {
 147     GLfloat vmat[4][4];
 148
 149     multmatrix4d(vmat, (const GLfloat (*)[4]) modelMatrix,
 150             (const GLfloat (*)[4]) projMatrix);
 151     loadCullingMatrix((GLfloat (*)[4]) vmat);
 152     loadSamplingMatrix((const GLfloat (*)[4]) vmat, (const GLint *) viewport);
 153 }
 154
 155 /*--------------------------------------------------------------------------
 156  * grabGLMatrix
 157  *--------------------------------------------------------------------------
 158  */
 159
 160 void
 161 GLUnurbs::grabGLMatrix(GLfloat vmat[4][4])
 162 {
 163     GLfloat m1[4][4], m2[4][4];
 164
 165     ::glGetFloatv((GLenum) GL_MODELVIEW_MATRIX, (GLfloat *) &(m1[0][0]));
 166     ::glGetFloatv((GLenum) GL_PROJECTION_MATRIX, (GLfloat *) &(m2[0][0]));
 167     multmatrix4d((GLfloat (*)[4]) vmat,
 168             (GLfloat (*)[4]) m1, (GLfloat (*)[4]) m2);
 169 }
 170
 171 //for object space tesselation: view independent
 172 void
 173 GLUnurbs::setSamplingMatrixIdentity( void )
 174 {
 175   INREAL smat[4][4] = {
 176     {1,0,0,0},
 177     {0,1,0,0},
 178     {0,0,1,0},
 179     {0,0,0,1}
 180   };
 181   const long rstride = sizeof(smat[0]) / sizeof(smat[0][0]);
 182   const long cstride = 1;
 183
 184   setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 185                    cstride);
 186   setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 187                    cstride);
 188   setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 189                    cstride);
 190   setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 191                    cstride);
 192 }
 193
 194
 195 void
 196 GLUnurbs::loadSamplingMatrix(const GLfloat vmat[4][4],
 197                                const GLint viewport[4])
 198 {
 199
 200     /* rescale the mapping to correspond to pixels in x/y */
 201     REAL xsize = 0.5 * (REAL) (viewport[2]);
 202     REAL ysize = 0.5 * (REAL) (viewport[3]);
 203
 204     INREAL smat[4][4];
 205     smat[0][0] = vmat[0][0] * xsize;
 206     smat[1][0] = vmat[1][0] * xsize;
 207     smat[2][0] = vmat[2][0] * xsize;
 208     smat[3][0] = vmat[3][0] * xsize;
 209
 210     smat[0][1] = vmat[0][1] * ysize;
 211     smat[1][1] = vmat[1][1] * ysize;
 212     smat[2][1] = vmat[2][1] * ysize;
 213     smat[3][1] = vmat[3][1] * ysize;
 214
 215     smat[0][2] = 0.0;
 216     smat[1][2] = 0.0;
 217     smat[2][2] = 0.0;
 218     smat[3][2] = 0.0;
 219
 220     smat[0][3] = vmat[0][3];
 221     smat[1][3] = vmat[1][3];
 222     smat[2][3] = vmat[2][3];
 223     smat[3][3] = vmat[3][3];
 224
 225     const long rstride = sizeof(smat[0]) / sizeof(smat[0][0]);
 226     const long cstride = 1;
 227
 228     setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 229             cstride);
 230     setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 231             cstride);
 232     setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 233             cstride);
 234     setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
 235             cstride);
 236 }
 237
 238 void
 239 GLUnurbs::loadCullingMatrix(GLfloat vmat[4][4])
 240 {
 241     INREAL cmat[4][4];
 242
 243     cmat[0][0] = vmat[0][0];
 244     cmat[0][1] = vmat[0][1];
 245     cmat[0][2] = vmat[0][2];
 246     cmat[0][3] = vmat[0][3];
 247
 248     cmat[1][0] = vmat[1][0];
 249     cmat[1][1] = vmat[1][1];
 250     cmat[1][2] = vmat[1][2];
 251     cmat[1][3] = vmat[1][3];
 252
 253     cmat[2][0] = vmat[2][0];
 254     cmat[2][1] = vmat[2][1];
 255     cmat[2][2] = vmat[2][2];
 256     cmat[2][3] = vmat[2][3];
 257
 258     cmat[3][0] = vmat[3][0];
 259     cmat[3][1] = vmat[3][1];
 260     cmat[3][2] = vmat[3][2];
 261     cmat[3][3] = vmat[3][3];
 262
 263     const long rstride = sizeof(cmat[0]) / sizeof(cmat[0][0]);
 264     const long cstride = 1;
 265
 266     setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLINGMATRIX, &cmat[0][0], rstride,
 267             cstride);
 268     setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLINGMATRIX, &cmat[0][0], rstride,
 269             cstride);
 270         //added for curves by zl
 271     setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLINGMATRIX, &cmat[0][0], rstride,
 272             cstride);
 273     setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLINGMATRIX, &cmat[0][0], rstride,
 274             cstride);
 275 }
 276
 277 /*---------------------------------------------------------------------
 278  * A = B * MAT ; transform a 4d vector through a 4x4 matrix
 279  *---------------------------------------------------------------------
 280  */
 281 void
 282 GLUnurbs::transform4d(GLfloat A[4], GLfloat B[4], GLfloat mat[4][4])
 283 {
 284
 285     A[0] = B[0]*mat[0][0] + B[1]*mat[1][0] + B[2]*mat[2][0] + B[3]*mat[3][0];
 286     A[1] = B[0]*mat[0][1] + B[1]*mat[1][1] + B[2]*mat[2][1] + B[3]*mat[3][1];
 287     A[2] = B[0]*mat[0][2] + B[1]*mat[1][2] + B[2]*mat[2][2] + B[3]*mat[3][2];
 288     A[3] = B[0]*mat[0][3] + B[1]*mat[1][3] + B[2]*mat[2][3] + B[3]*mat[3][3];
 289 }
 290
 291 /*---------------------------------------------------------------------
 292  * new = [left][right] ; multiply two matrices together
 293  *---------------------------------------------------------------------
 294  */
 295 void
 296 GLUnurbs::multmatrix4d (GLfloat n[4][4], const GLfloat left[4][4],
 297                  const GLfloat right[4][4])
 298 {
 299     transform4d ((GLfloat *) n[0],(GLfloat *) left[0],(GLfloat (*)[4]) right);
 300     transform4d ((GLfloat *) n[1],(GLfloat *) left[1],(GLfloat (*)[4]) right);
 301     transform4d ((GLfloat *) n[2],(GLfloat *) left[2],(GLfloat (*)[4]) right);
 302     transform4d ((GLfloat *) n[3],(GLfloat *) left[3],(GLfloat (*)[4]) right);
 303 }