← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal-proposed

« back to all changes in this revision

Viewing changes to src/glu/sgi/libnurbs/interface/bezierPatch.cc

  • Committer: Package Import Robot
  • Author(s): Timo Aaltonen
  • Date: 2012-09-17 13:24:35 UTC
  • mfrom: (1.7.9)
  • Revision ID: package-import@ubuntu.com-20120917132435-fqt9q6beebhc8t9r
Tags: 9.0~git20120917.7cfd42ce-0ubuntu1
https://launchpad.net/bugs/1047306
Merge from unreleased debian git. (LP: #1047306)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glu/sgi/libnurbs/interface/bezierPatch.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 <assert.h>
42
 
#include <GL/glu.h> /*for drawing bzier patch*/
43
 
#include "bezierPatch.h"
44
 
#include "bezierEval.h"
45
 
 
46
 
/*
47
 
 *allocate an instance of bezierPatch. The control points are unknown. But
48
 
 *the space of this array is allocated with size of 
49
 
 *   uorder*vorder*dimension
50
 
 *
51
 
 */
52
 
bezierPatch* bezierPatchMake(float umin, float vmin, float umax, float vmax, int uorder, int vorder, int dimension)
53
 
{
54
 
  bezierPatch* ret = (bezierPatch*) malloc(sizeof(bezierPatch));
55
 
  assert(ret);
56
 
  ret->umin = umin;
57
 
  ret->vmin = vmin;
58
 
  ret->umax = umax;
59
 
  ret->vmax = vmax;
60
 
  ret->uorder = uorder;
61
 
  ret->vorder = vorder;
62
 
  ret->dimension = dimension;
63
 
  ret->ctlpoints = (float*) malloc(sizeof(float) * dimension * uorder * vorder);
64
 
  assert(ret->ctlpoints);
65
 
 
66
 
  ret->next = NULL;
67
 
 
68
 
  return ret;
69
 
}
70
 
 
71
 
bezierPatch* bezierPatchMake2(float umin, float vmin, float umax, float vmax, int uorder, int vorder, int dimension, int ustride, int vstride,  float* ctlpoints)
72
 
{
73
 
  bezierPatch* ret = (bezierPatch*) malloc(sizeof(bezierPatch));
74
 
  assert(ret);
75
 
  ret->umin = umin;
76
 
  ret->vmin = vmin;
77
 
  ret->umax = umax;
78
 
  ret->vmax = vmax;
79
 
  ret->uorder = uorder;
80
 
  ret->vorder = vorder;
81
 
  ret->dimension = dimension;
82
 
  ret->ctlpoints = (float*) malloc(sizeof(float) * dimension * uorder * vorder);
83
 
  assert(ret->ctlpoints);
84
 
 
85
 
  /*copy the control points there*/
86
 
  int the_ustride = vorder * dimension;
87
 
  int the_vstride = dimension;
88
 
  for(int i=0; i<uorder; i++)
89
 
    for(int j=0; j<vorder; j++)
90
 
      for(int k=0; k<dimension; k++)
91
 
        ret->ctlpoints[i * the_ustride + j*the_vstride+k] = ctlpoints[i*ustride+j*vstride+k];
92
 
  
93
 
  ret->next = NULL;
94
 
 
95
 
  return ret;
96
 
}
97
 
 
98
 
/*
99
 
 *deallocate the space as allocated by Make
100
 
 */
101
 
void bezierPatchDelete(bezierPatch *b)
102
 
{
103
 
  free(b->ctlpoints);
104
 
  free(b);
105
 
}
106
 
 
107
 
/*delete the whole linked list
108
 
 */
109
 
void bezierPatchDeleteList(bezierPatch *b)
110
 
{
111
 
  bezierPatch *temp;
112
 
  while (b != NULL) {
113
 
    temp = b;
114
 
    b = b->next;
115
 
    bezierPatchDelete(temp);    
116
 
  }
117
 
}
118
 
 
119
 
bezierPatch* bezierPatchInsert(bezierPatch *list, bezierPatch *b)
120
 
{
121
 
  b->next = list;
122
 
  return b;
123
 
}
124
 
 
125
 
/*print the data stored in this patch*/
126
 
void bezierPatchPrint(bezierPatch *b)
127
 
{
128
 
  printf("bezierPatch:\n");
129
 
  printf("umin,umax=(%f,%f), (vmin, vmax)=(%f,%f)\n", b->umin, b->umax, b->vmin, b->vmax);
130
 
  printf("uorder=%i, vorder=%i\n", b->uorder, b->vorder);
131
 
  printf("idmension = %i\n", b->dimension);
132
 
}
133
 
       
134
 
/*print the whole list*/
135
 
void bezierPatchPrintList(bezierPatch *list)
136
 
{
137
 
  bezierPatch* temp;
138
 
  for(temp=list; temp != NULL; temp = temp->next)
139
 
    bezierPatchPrint(temp);
140
 
}
141
 
 
142
 
void bezierPatchEval(bezierPatch *b, float u, float v, float ret[])
143
 
{
144
 
  if(   u >= b->umin && u<= b->umax
145
 
     && v >= b->vmin && v<= b->vmax)
146
 
    {
147
 
 
148
 
      bezierSurfEval(b->umin, b->umax, b->uorder, b->vmin, b->vmax, b->vorder, b->dimension, b->ctlpoints, b->dimension * b->vorder, b->dimension, u, v, ret);
149
 
 
150
 
     }
151
 
  else if(b->next != NULL)
152
 
    bezierPatchEval(b->next, u,v, ret);
153
 
  else 
154
 
    bezierSurfEval(b->umin, b->umax, b->uorder, b->vmin, b->vmax, b->vorder, b->dimension, b->ctlpoints, b->dimension * b->vorder, b->dimension, u, v, ret);    
155
 
}
156
 
 
157
 
/*the returned normal is normlized
158
 
 */
159
 
void bezierPatchEvalNormal(bezierPatch *b, float u, float v, float ret[])
160
 
{
161
 
  bezierSurfEvalNormal(b->umin, b->umax, b->uorder, b->vmin, b->vmax, b->vorder, b->dimension, b->ctlpoints, b->dimension * b->vorder, b->dimension, u, v, ret);  
162
 
 
163
 
  if(   u >= b->umin && u<= b->umax
164
 
     && v >= b->vmin && v<= b->vmax)
165
 
    {
166
 
      bezierSurfEvalNormal(b->umin, b->umax, b->uorder, b->vmin, b->vmax, b->vorder, b->dimension, b->ctlpoints, b->dimension * b->vorder, b->dimension, u, v, ret);
167
 
     }
168
 
  else if(b->next != NULL)
169
 
    bezierPatchEvalNormal(b->next, u,v, ret);
170
 
  else 
171
 
    bezierSurfEvalNormal(b->umin, b->umax, b->uorder, b->vmin, b->vmax, b->vorder, b->dimension, b->ctlpoints, b->dimension * b->vorder, b->dimension, u, v, ret);    
172
 
 
173
 
}
174
 
 
175
 
void bezierPatchDraw(bezierPatch *bpatch, int u_reso, int v_reso)
176
 
{
177
 
  if(bpatch->dimension == 3)
178
 
    glMap2f(GL_MAP2_VERTEX_3, bpatch->umin, bpatch->umax, 3*bpatch->vorder, bpatch->uorder, bpatch->vmin, bpatch->vmax,3, bpatch->vorder, (GLfloat*) bpatch->ctlpoints);
179
 
  else
180
 
    glMap2f(GL_MAP2_VERTEX_4, bpatch->umin, bpatch->umax, 4*bpatch->vorder, bpatch->uorder, bpatch->vmin, bpatch->vmax,3, bpatch->vorder, (GLfloat*) bpatch->ctlpoints);    
181
 
 
182
 
  glMapGrid2f(u_reso, bpatch->umin, bpatch->umax, 
183
 
              v_reso, bpatch->vmin, bpatch->vmax);
184
 
  glEvalMesh2(GL_LINE, 0, u_reso, 0, v_reso);
185
 
}
186
 
 
187
 
void bezierPatchListDraw(bezierPatch *list, int u_reso, int v_reso)
188
 
{
189
 
  bezierPatch *temp;
190
 
glEnable(GL_LIGHTING);
191
 
glEnable(GL_LIGHT0);
192
 
glEnable(GL_MAP2_VERTEX_3);
193
 
glEnable(GL_AUTO_NORMAL);
194
 
glEnable(GL_NORMALIZE);
195
 
glColor3f(1,0,0);
196
 
#ifdef DEBUG
197
 
printf("mapmap\n");
198
 
#endif
199
 
 
200
 
 
201
 
  for(temp = list; temp != NULL; temp = temp->next)
202
 
    bezierPatchDraw(temp, u_reso, v_reso);
203
 
}
204
 
            
205
 
 
206