src/glu/sgi/libnurbs/nurbtess/gridWrap.h

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30 /*
  31 */
  32
  33 #ifndef _GRIDWRAP_H
  34 #define _GRIDWRAP_H
  35
  36 #include <stdio.h>
  37 #include "definitions.h"
  38
  39 #include "primitiveStream.h"
  40 #include "zlassert.h"
  41
  42 class gridWrap{
  43   Int n_ulines;
  44   Int n_vlines;
  45   Real u_min, u_max;
  46   Real v_min, v_max;
  47
  48   /*cache the coordinate values for efficiency.
  49    *these are redundant information when
  50    *the grid is uniform.
  51    */
  52   Real* u_values; /*size is n_ulines*/
  53   Real* v_values; /*size is n_vlines*/
  54
  55   Int is_uniform;
  56
  57 public:
  58   //uniform grid constructor
  59   gridWrap(Int nUlines, Int nVlines,
  60            Real uMin, Real uMax,
  61            Real vMin, Real vMax
  62            );
  63
  64   //nonuniform grid constructor.
  65   gridWrap(Int nUlines, Real *uvals,
  66            Int nVlines, Real *vvlas
  67            );
  68   ~gridWrap();
  69
  70   void print();
  71   Int get_n_ulines() {return n_ulines;}
  72   Int get_n_vlines() {return n_vlines;}
  73   Real get_u_min() {return u_min;}
  74   Real get_u_max() {return u_max;}
  75   Real get_v_min() {return v_min;}
  76   Real get_v_max() {return v_max;}
  77
  78   Real get_u_value(Int i)
  79     {
  80       assert(i<n_ulines);
  81       /*if(i>=n_ulines){printf("ERROR, n_ulines=%i,i=%i\n",n_ulines,i);exit(0);}*/
  82       return u_values[i];}
  83   Real get_v_value(Int j) {return v_values[j];}
  84
  85   Real* get_u_values() {return u_values;}
  86   Real* get_v_values() {return v_values;}
  87
  88   void outputFanWithPoint(Int v, Int uleft, Int uright,
  89                           Real vert[2], primStream* pStream);
  90
  91   void draw();
  92
  93   Int isUniform() {return is_uniform;}
  94 };
  95
  96 class gridBoundaryChain{
  97   gridWrap* grid;
  98   Int firstVlineIndex;
  99   Int nVlines;
 100   Int* ulineIndices; /*each v line has a boundary*/
 101   Int* innerIndices; /*the segment of the vertical gridline from */
 102                      /*(innerIndices[i], i) to (innerIndices[i+1], i-1) */
 103                      /*is inside the polygon: i=1,...,nVlines-1*/
 104
 105   Real2* vertices; /*one grid point at each grid V-line, cached for efficiency*/
 106
 107 public:
 108   gridBoundaryChain(gridWrap* gr, Int first_vline_index, Int n_vlines, Int* uline_indices, Int* inner_indices);
 109
 110   ~gridBoundaryChain()
 111     {
 112       free(innerIndices);
 113       free(ulineIndices);
 114       free(vertices);
 115     }
 116
 117   /*i indexes the vlines in this chain.
 118    */
 119   Int getVlineIndex(Int i) {return firstVlineIndex-i;}
 120   Int getUlineIndex(Int i) {return ulineIndices[i];}
 121   Real get_u_value(Int i) {return vertices[i][0];}
 122   Real get_v_value(Int i) {return vertices[i][1];}
 123   Int get_nVlines() {return nVlines;}
 124   Int getInnerIndex(Int i) {return innerIndices[i];}
 125   Real getInner_u_value(Int i) {return grid->get_u_value(innerIndices[i]);}
 126
 127   Real* get_vertex(Int i) {return vertices[i];}
 128   gridWrap* getGrid() {return grid;}
 129   void leftEndFan(Int i, primStream* pStream);
 130   void rightEndFan(Int i, primStream* pStream);
 131
 132   Int lookfor(Real v, Int i1, Int i2); //find i in [i1,i2] so that  vertices[i][1]>= v > vertices[i+1][1]
 133   void draw();
 134   void drawInner();
 135 };
 136
 137 #endif