src/glu/sgi/libnurbs/nurbtess/rectBlock.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 */
  35 /*
  36 */
  37
  38 #include "gluos.h"
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41 #include "glimports.h"
  42 #include "zlassert.h"
  43 #include <GL/gl.h>
  44
  45 #include "rectBlock.h"
  46
  47 rectBlock::rectBlock(gridBoundaryChain* left, gridBoundaryChain* right, Int beginVline, Int endVline)
  48 {
  49   Int i;
  50
  51
  52   upGridLineIndex = left->getVlineIndex(beginVline);
  53
  54   lowGridLineIndex = left->getVlineIndex(endVline);
  55
  56   Int n = upGridLineIndex-lowGridLineIndex+1; //number of grid lines
  57   leftIndices = (Int*) malloc(sizeof(Int) * n);
  58   assert(leftIndices);
  59   rightIndices = (Int*) malloc(sizeof(Int) * n);
  60   assert(rightIndices);
  61   for(i=0; i<n; i++)
  62     {
  63
  64       leftIndices[i] = left->getInnerIndex(i+beginVline);
  65       rightIndices[i] = right->getInnerIndex(i+beginVline);
  66     }
  67 }
  68
  69
  70 rectBlock::~rectBlock()
  71 {
  72   free(leftIndices);
  73   free(rightIndices);
  74 }
  75
  76 void rectBlock::print()
  77 {
  78   Int i;
  79   printf("block:\n");
  80   for(i=upGridLineIndex; i >= lowGridLineIndex; i--)
  81     {
  82       printf("gridline %i, (%i,%i)\n", i, leftIndices[upGridLineIndex-i], rightIndices[upGridLineIndex-i]);
  83     }
  84 }
  85
  86
  87
  88 void rectBlock::draw(Real* u_values, Real* v_values)
  89 {
  90   Int i,j,k;
  91   //upgrid line to bot grid line
  92 #ifdef DEBUG
  93 printf("upGridLineIndex=%i, lowGridLineIndex=%i\n", upGridLineIndex, lowGridLineIndex);
  94 #endif
  95   for(k=0, i=upGridLineIndex; i > lowGridLineIndex; i--, k++)
  96     {
  97       glBegin(GL_QUAD_STRIP);
  98
  99       for(j=leftIndices[k+1]; j<= rightIndices[k+1]; j++)
 100         {
 101           glVertex2f(u_values[j], v_values[i]);
 102           glVertex2f(u_values[j], v_values[i-1]);
 103         }
 104       glEnd();
 105     }
 106 }
 107
 108
 109 Int rectBlock::num_quads()
 110 {
 111   Int ret=0;
 112   Int k,i;
 113   for(k=0, i=upGridLineIndex; i>lowGridLineIndex; i--, k++)
 114     {
 115       ret += (rightIndices[k+1]-leftIndices[k+1]);
 116     }
 117   return ret;
 118 }
 119
 120 Int rectBlockArray::num_quads()
 121 {
 122   Int ret=0;
 123   for(Int i=0; i<n_elements; i++)
 124     ret += array[i]->num_quads();
 125   return ret;
 126 }
 127
 128 rectBlockArray::rectBlockArray(Int s)
 129 {
 130   Int i;
 131   n_elements = 0;
 132   size = s;
 133   array = (rectBlock**) malloc(sizeof(rectBlock*) * s);
 134   assert(array);
 135 //initialization
 136   for(i=0; i<s; i++)
 137     array[i] = NULL;
 138 }
 139
 140 rectBlockArray::~rectBlockArray()
 141 {
 142   Int i;
 143   for(i=0; i<size; i++)
 144     {
 145       if(array[i] != NULL)
 146         delete array[i];
 147     }
 148   free(array);
 149 }
 150
 151 //put to the end of the array, check the size
 152 void rectBlockArray::insert(rectBlock* newBlock)
 153 {
 154   Int i;
 155   if(n_elements == size) //full
 156     {
 157       rectBlock** temp = (rectBlock**) malloc(sizeof(rectBlock) * (2*size+1));
 158       assert(temp);
 159       //initialization
 160       for(i=0; i<2*size+1; i++)
 161         temp[i] = NULL;
 162
 163       for(i=0; i<n_elements; i++)
 164         temp[i] = array[i];
 165
 166       free(array);
 167       array = temp;
 168       size = 2*size +  1;
 169     }
 170
 171   array[n_elements++] = newBlock;
 172 }
 173
 174 void rectBlockArray::print()
 175 {
 176   Int i;
 177   for(i=0; i<n_elements; i++)
 178     array[i]->print();
 179 }
 180
 181 void rectBlockArray::draw(Real* u_values, Real* v_values)
 182 {
 183   Int i;
 184   for(i=0; i<n_elements; i++)
 185     array[i]->draw(u_values, v_values);
 186 }
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196