| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
27 // 24 //
>> 25 // $Id: SoTrd.cc,v 1.7 2004/12/16 12:33:10 gcosmo Exp $
>> 26 // GEANT4 tag $Name: geant4-07-01 $
28 // 27 //
29 /*-----------------------------HEPVis--------- 28 /*-----------------------------HEPVis---------------------------------------*/
30 /* 29 /* */
31 /* Node: SoTrd 30 /* Node: SoTrd */
32 /* Description: Represents the G4Trd Gean 31 /* Description: Represents the G4Trd Geant Geometry entity */
33 /* Author: Joe Boudreau Nov 11 1996 32 /* Author: Joe Boudreau Nov 11 1996 */
34 /* 33 /* */
35 /*-------------------------------------------- 34 /*--------------------------------------------------------------------------*/
36 35
>> 36 #ifdef G4VIS_BUILD_OI_DRIVER
>> 37
37 #include <assert.h> 38 #include <assert.h>
38 #include <cmath> 39 #include <cmath>
39 40
40 #include <Inventor/SbBox.h> 41 #include <Inventor/SbBox.h>
41 #include <Inventor/actions/SoAction.h> 42 #include <Inventor/actions/SoAction.h>
42 #include <Inventor/fields/SoSFFloat.h> 43 #include <Inventor/fields/SoSFFloat.h>
43 #include <Inventor/misc/SoChildList.h> 44 #include <Inventor/misc/SoChildList.h>
44 #include <Inventor/nodes/SoSeparator.h> 45 #include <Inventor/nodes/SoSeparator.h>
45 #include <Inventor/nodes/SoIndexedFaceSet.h> 46 #include <Inventor/nodes/SoIndexedFaceSet.h>
46 #include <Inventor/nodes/SoNormal.h> 47 #include <Inventor/nodes/SoNormal.h>
47 #include <Inventor/nodes/SoCoordinate3.h> 48 #include <Inventor/nodes/SoCoordinate3.h>
48 #include <Inventor/nodes/SoNormalBinding.h> 49 #include <Inventor/nodes/SoNormalBinding.h>
49 #include <Inventor/SoPrimitiveVertex.h> 50 #include <Inventor/SoPrimitiveVertex.h>
50 #include <Inventor/elements/SoTextureCoordinat 51 #include <Inventor/elements/SoTextureCoordinateElement.h>
51 52
52 #include "HEPVis/SbMath.h" 53 #include "HEPVis/SbMath.h"
53 #include "HEPVis/nodes/SoTrd.h" 54 #include "HEPVis/nodes/SoTrd.h"
54 55
55 // This statement is required 56 // This statement is required
56 SO_NODE_SOURCE(SoTrd) 57 SO_NODE_SOURCE(SoTrd)
57 58
58 // initClass 59 // initClass
59 void SoTrd::initClass(){ 60 void SoTrd::initClass(){
60 static bool first = true; << 61 SO_NODE_INIT_CLASS(SoTrd,SoShape,"Shape");
61 if (first) { <<
62 first = false; <<
63 SO_NODE_INIT_CLASS(SoTrd,SoShape,"Shape"); <<
64 } <<
65 } 62 }
66 // Constructor 63 // Constructor
67 SoTrd::SoTrd() { 64 SoTrd::SoTrd() {
68 // This statement is required 65 // This statement is required
69 SO_NODE_CONSTRUCTOR(SoTrd); 66 SO_NODE_CONSTRUCTOR(SoTrd);
70 // Data fields are initialized like this: 67 // Data fields are initialized like this:
71 SO_NODE_ADD_FIELD(fDx1,(1.0)); 68 SO_NODE_ADD_FIELD(fDx1,(1.0));
72 SO_NODE_ADD_FIELD(fDx2,(1.0)); 69 SO_NODE_ADD_FIELD(fDx2,(1.0));
73 SO_NODE_ADD_FIELD(fDy1,(1.0)); 70 SO_NODE_ADD_FIELD(fDy1,(1.0));
74 SO_NODE_ADD_FIELD(fDy2,(1.0)); 71 SO_NODE_ADD_FIELD(fDy2,(1.0));
75 SO_NODE_ADD_FIELD(fDz,(1.0)); 72 SO_NODE_ADD_FIELD(fDz,(1.0));
76 SO_NODE_ADD_FIELD(alternateRep,(NULL)); 73 SO_NODE_ADD_FIELD(alternateRep,(NULL));
77 children = new SoChildList(this); 74 children = new SoChildList(this);
78 } 75 }
79 // Destructor 76 // Destructor
80 SoTrd::~SoTrd() { 77 SoTrd::~SoTrd() {
81 delete children; 78 delete children;
82 } 79 }
83 // generatePrimitives 80 // generatePrimitives
84 void SoTrd::generatePrimitives(SoAction *actio 81 void SoTrd::generatePrimitives(SoAction *action) {
85 // This variable is used to store each verte 82 // This variable is used to store each vertex
86 SoPrimitiveVertex pv; 83 SoPrimitiveVertex pv;
87 84
88 // Access the stat from the action 85 // Access the stat from the action
89 SoState *state = action->getState(); 86 SoState *state = action->getState();
90 87
91 // See if we have to use a texture coordinat 88 // See if we have to use a texture coordinate function,
92 // rather than generating explicit texture c 89 // rather than generating explicit texture coordinates.
93 SbBool useTexFunction= 90 SbBool useTexFunction=
94 (SoTextureCoordinateElement::getType(state 91 (SoTextureCoordinateElement::getType(state) ==
95 SoTextureCoordinateElement::FUNCTION); 92 SoTextureCoordinateElement::FUNCTION);
96 93
97 // If we need to generate texture coordinate 94 // If we need to generate texture coordinates with a function,
98 // we'll need an SoGLTextureCoordinateElemen 95 // we'll need an SoGLTextureCoordinateElement. Otherwise, we'll
99 // set up the coordinates directly. 96 // set up the coordinates directly.
100 const SoTextureCoordinateElement *tce = NULL 97 const SoTextureCoordinateElement *tce = NULL;
101 SbVec4f texCoord; 98 SbVec4f texCoord;
102 if (useTexFunction) { 99 if (useTexFunction) {
103 tce = SoTextureCoordinateElement::getInsta 100 tce = SoTextureCoordinateElement::getInstance(state);
104 } 101 }
105 else { 102 else {
106 texCoord[2] = 0.0; 103 texCoord[2] = 0.0;
107 texCoord[3] = 1.0; 104 texCoord[3] = 1.0;
108 } 105 }
109 SbVec3f point, normal; 106 SbVec3f point, normal;
110 107
111 108
112 ////////////////////////////////////////// 109 //////////////////////////////////////////
113 //---------------------------------------- 110 //----------------------------------------
114 #define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \ 111 #define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \
115 point.setValue(x,y,z); \ 112 point.setValue(x,y,z); \
116 normal.setValue(nx,ny,nz); \ 113 normal.setValue(nx,ny,nz); \
117 if (useTexFunction) { \ 114 if (useTexFunction) { \
118 texCoord=tce->get(point,normal); \ 115 texCoord=tce->get(point,normal); \
119 } \ 116 } \
120 else { \ 117 else { \
121 texCoord[0]=s; \ 118 texCoord[0]=s; \
122 texCoord[1]=t; \ 119 texCoord[1]=t; \
123 } \ 120 } \
124 pv.setPoint(point); \ 121 pv.setPoint(point); \
125 pv.setNormal(normal); \ 122 pv.setNormal(normal); \
126 pv.setTextureCoords(texCoord); \ 123 pv.setTextureCoords(texCoord); \
127 shapeVertex(&pv); 124 shapeVertex(&pv);
128 //---------------------------------------- 125 //----------------------------------------
129 ////////////////////////////////////////// 126 //////////////////////////////////////////
130 127
131 const int NPOINTS=8, NFACES=6, NINDICES = NF 128 const int NPOINTS=8, NFACES=6, NINDICES = NFACES*5;
132 int indices[NINDICES] = {3,2,1,0, SO_END_FAC 129 int indices[NINDICES] = {3,2,1,0, SO_END_FACE_INDEX, //z back.
133 4,5,6,7, SO_END_FACE_INDEX, //z fron 130 4,5,6,7, SO_END_FACE_INDEX, //z front.
134 0,1,5,4, SO_END_FACE_INDEX, //y up. 131 0,1,5,4, SO_END_FACE_INDEX, //y up.
135 1,2,6,5, SO_END_FACE_INDEX, //x left 132 1,2,6,5, SO_END_FACE_INDEX, //x left.
136 2,3,7,6, SO_END_FACE_INDEX, //y down 133 2,3,7,6, SO_END_FACE_INDEX, //y down.
137 3,0,4,7, SO_END_FACE_INDEX}; //x righ 134 3,0,4,7, SO_END_FACE_INDEX}; //x right.
138 135
139 136
140 // points for the eight vertices 137 // points for the eight vertices
141 float points[NPOINTS][3]; 138 float points[NPOINTS][3];
142 points[0][0] = fDx1.getValue(); 139 points[0][0] = fDx1.getValue();
143 points[0][1] = fDy1.getValue(); 140 points[0][1] = fDy1.getValue();
144 points[0][2] = -fDz.getValue(); 141 points[0][2] = -fDz.getValue();
145 142
146 points[1][0] = -fDx1.getValue(); 143 points[1][0] = -fDx1.getValue();
147 points[1][1] = fDy1.getValue(); 144 points[1][1] = fDy1.getValue();
148 points[1][2] = -fDz.getValue(); 145 points[1][2] = -fDz.getValue();
149 146
150 points[2][0] = -fDx1.getValue(); 147 points[2][0] = -fDx1.getValue();
151 points[2][1] = -fDy1.getValue(); 148 points[2][1] = -fDy1.getValue();
152 points[2][2] = -fDz.getValue(); 149 points[2][2] = -fDz.getValue();
153 150
154 points[3][0] = fDx1.getValue(); 151 points[3][0] = fDx1.getValue();
155 points[3][1] = -fDy1.getValue(); 152 points[3][1] = -fDy1.getValue();
156 points[3][2] = -fDz.getValue(); 153 points[3][2] = -fDz.getValue();
157 154
158 points[4][0] = fDx2.getValue(); 155 points[4][0] = fDx2.getValue();
159 points[4][1] = fDy2.getValue(); 156 points[4][1] = fDy2.getValue();
160 points[4][2] = fDz.getValue(); 157 points[4][2] = fDz.getValue();
161 158
162 points[5][0] = -fDx2.getValue(); 159 points[5][0] = -fDx2.getValue();
163 points[5][1] = fDy2.getValue(); 160 points[5][1] = fDy2.getValue();
164 points[5][2] = fDz.getValue(); 161 points[5][2] = fDz.getValue();
165 162
166 points[6][0] = -fDx2.getValue(); 163 points[6][0] = -fDx2.getValue();
167 points[6][1] = -fDy2.getValue(); 164 points[6][1] = -fDy2.getValue();
168 points[6][2] = fDz.getValue(); 165 points[6][2] = fDz.getValue();
169 166
170 points[7][0] = fDx2.getValue(); 167 points[7][0] = fDx2.getValue();
171 points[7][1] = -fDy2.getValue(); 168 points[7][1] = -fDy2.getValue();
172 points[7][2] = fDz.getValue(); 169 points[7][2] = fDz.getValue();
173 170
174 float t1 = FATAN((fDx2.getValue()-fDx1.getV 171 float t1 = FATAN((fDx2.getValue()-fDx1.getValue())/(2*fDz.getValue()));
175 float t2 = FATAN((fDy2.getValue()-fDy1.getV 172 float t2 = FATAN((fDy2.getValue()-fDy1.getValue())/(2*fDz.getValue()));
176 float st1 = FSIN(t1); 173 float st1 = FSIN(t1);
177 float st2 = FSIN(t2); 174 float st2 = FSIN(t2);
178 float ct1 = FCOS(t1); 175 float ct1 = FCOS(t1);
179 float ct2 = FCOS(t2); 176 float ct2 = FCOS(t2);
180 177
181 float normals[NFACES][3]; 178 float normals[NFACES][3];
182 //z back. 179 //z back.
183 normals[0][0] = 0 ; normals[0][1] = 0; 180 normals[0][0] = 0 ; normals[0][1] = 0; normals [0][2] = -1;
184 //z front. 181 //z front.
185 normals[1][0] = 0 ; normals[1][1] = 0; 182 normals[1][0] = 0 ; normals[1][1] = 0; normals [1][2] = 1;
186 //y up. 183 //y up.
187 normals[2][0] = 0 ; normals[2][1] = ct2; 184 normals[2][0] = 0 ; normals[2][1] = ct2; normals [2][2] = -st2;
188 //x left. 185 //x left.
189 normals[3][0] = -ct1; normals[3][1] = 0; 186 normals[3][0] = -ct1; normals[3][1] = 0; normals [3][2] = -st1;
190 //y down. 187 //y down.
191 normals[4][0] = 0 ; normals[4][1] = -ct2; 188 normals[4][0] = 0 ; normals[4][1] = -ct2; normals [4][2] = -st2;
192 //x right. 189 //x right.
193 normals[5][0] = ct1; normals[5][1] = 0; 190 normals[5][0] = ct1; normals[5][1] = 0; normals [5][2] = -st1;
194 191
195 float x,y,z; 192 float x,y,z;
196 int index; 193 int index;
197 for (int nf=0;nf<NFACES;nf++) { 194 for (int nf=0;nf<NFACES;nf++) {
198 beginShape(action,TRIANGLE_FAN); 195 beginShape(action,TRIANGLE_FAN);
199 index = indices[nf * 5]; 196 index = indices[nf * 5];
200 x = points[index][0]; 197 x = points[index][0];
201 y = points[index][1]; 198 y = points[index][1];
202 z = points[index][2]; 199 z = points[index][2];
203 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0] 200 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
204 index = indices[nf * 5 + 1]; 201 index = indices[nf * 5 + 1];
205 x = points[index][0]; 202 x = points[index][0];
206 y = points[index][1]; 203 y = points[index][1];
207 z = points[index][2]; 204 z = points[index][2];
208 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0] 205 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
209 index = indices[nf * 5 + 2]; 206 index = indices[nf * 5 + 2];
210 x = points[index][0]; 207 x = points[index][0];
211 y = points[index][1]; 208 y = points[index][1];
212 z = points[index][2]; 209 z = points[index][2];
213 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0] 210 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
214 index = indices[nf * 5 + 3]; 211 index = indices[nf * 5 + 3];
215 x = points[index][0]; 212 x = points[index][0];
216 y = points[index][1]; 213 y = points[index][1];
217 z = points[index][2]; 214 z = points[index][2];
218 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0] 215 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
219 endShape(); 216 endShape();
220 } 217 }
221 } 218 }
222 219
223 // getChildren 220 // getChildren
224 SoChildList *SoTrd::getChildren() const { 221 SoChildList *SoTrd::getChildren() const {
225 return children; 222 return children;
226 } 223 }
227 224
228 225
229 // computeBBox 226 // computeBBox
230 void SoTrd::computeBBox(SoAction *, SbBox3f &b 227 void SoTrd::computeBBox(SoAction *, SbBox3f &box, SbVec3f ¢er ){
231 float fDx= fDx1.getValue(),fDy=fDy1.getValue 228 float fDx= fDx1.getValue(),fDy=fDy1.getValue();
232 229
233 if (fDx2.getValue() > fDx) fDx = fDx2.getVal 230 if (fDx2.getValue() > fDx) fDx = fDx2.getValue();
234 if (fDy2.getValue() > fDy) fDy = fDy2.getVal 231 if (fDy2.getValue() > fDy) fDy = fDy2.getValue();
235 232
236 SbVec3f vmin(-fDx,-fDy,-fDz.getValue()), 233 SbVec3f vmin(-fDx,-fDy,-fDz.getValue()),
237 vmax( fDx, fDy, fDz.getValue()); 234 vmax( fDx, fDy, fDz.getValue());
238 235
239 center.setValue(0,0,0); 236 center.setValue(0,0,0);
240 box.setBounds(vmin,vmax); 237 box.setBounds(vmin,vmax);
241 } 238 }
242 239
243 240
244 241
245 242
246 // updateChildren 243 // updateChildren
247 void SoTrd::updateChildren() { 244 void SoTrd::updateChildren() {
248 245
249 246
250 // Redraw the G4Trd.... 247 // Redraw the G4Trd....
251 248
252 assert(children->getLength()==1); 249 assert(children->getLength()==1);
253 SoSeparator *sep = (SoS 250 SoSeparator *sep = (SoSeparator *) ( *children)[0];
254 SoCoordinate3 *theCoordinates = (SoC 251 SoCoordinate3 *theCoordinates = (SoCoordinate3 *) ( sep->getChild(0));
255 SoNormal *theNormals = (SoN 252 SoNormal *theNormals = (SoNormal *) ( sep->getChild(1));
256 SoNormalBinding *theNormalBinding = (SoN 253 SoNormalBinding *theNormalBinding = (SoNormalBinding *) ( sep->getChild(2));
257 SoIndexedFaceSet *theFaceSet = (SoI 254 SoIndexedFaceSet *theFaceSet = (SoIndexedFaceSet *) ( sep->getChild(3));
258 255
259 const int NPOINTS=8, NFACES=6, NINDICES = NF 256 const int NPOINTS=8, NFACES=6, NINDICES = NFACES*5;
260 float points[NPOINTS][3]; 257 float points[NPOINTS][3];
261 float normals[NFACES][3]= {{0,0,-1}, {0,0,1} 258 float normals[NFACES][3]= {{0,0,-1}, {0,0,1}, {0,1,0}, {-1, 0, 0}, {0, -1, 0}, {1,0,0}};
262 259
263 // Indices for the eight faces 260 // Indices for the eight faces
264 #ifdef INVENTOR2_0 261 #ifdef INVENTOR2_0
265 static long 262 static long
266 #else 263 #else
267 static int32_t 264 static int32_t
268 #endif 265 #endif
269 indices[NINDICES] = {3,2,1,0, SO_END_FACE_IN 266 indices[NINDICES] = {3,2,1,0, SO_END_FACE_INDEX, // bottom
270 4,5,6,7 267 4,5,6,7, SO_END_FACE_INDEX, // top
271 0,1,5,4 268 0,1,5,4, SO_END_FACE_INDEX,
272 1,2,6,5 269 1,2,6,5, SO_END_FACE_INDEX,
273 2,3,7,6 270 2,3,7,6, SO_END_FACE_INDEX,
274 3,0,4,7 271 3,0,4,7, SO_END_FACE_INDEX};
275 272
276 273
277 // points for the eight vertices 274 // points for the eight vertices
278 points[0][0] = fDx1.getValue(); points[0][1 275 points[0][0] = fDx1.getValue(); points[0][1] = fDy1.getValue(); points[0][2] = -fDz.getValue();
279 points[1][0] = -fDx1.getValue(); points[1][1 276 points[1][0] = -fDx1.getValue(); points[1][1] = fDy1.getValue(); points[1][2] = -fDz.getValue();
280 points[2][0] = -fDx1.getValue(); points[2][1 277 points[2][0] = -fDx1.getValue(); points[2][1] = -fDy1.getValue(); points[2][2] = -fDz.getValue();
281 points[3][0] = fDx1.getValue(); points[3][1 278 points[3][0] = fDx1.getValue(); points[3][1] = -fDy1.getValue(); points[3][2] = -fDz.getValue();
282 points[4][0] = fDx2.getValue(); points[4][1 279 points[4][0] = fDx2.getValue(); points[4][1] = fDy2.getValue(); points[4][2] = fDz.getValue();
283 points[5][0] = -fDx2.getValue(); points[5][1 280 points[5][0] = -fDx2.getValue(); points[5][1] = fDy2.getValue(); points[5][2] = fDz.getValue();
284 points[6][0] = -fDx2.getValue(); points[6][1 281 points[6][0] = -fDx2.getValue(); points[6][1] = -fDy2.getValue(); points[6][2] = fDz.getValue();
285 points[7][0] = fDx2.getValue(); points[7][1 282 points[7][0] = fDx2.getValue(); points[7][1] = -fDy2.getValue(); points[7][2] = fDz.getValue();
286 283
287 float t1 = FATAN((fDx2.getValue()-fDx1.getVa 284 float t1 = FATAN((fDx2.getValue()-fDx1.getValue())/(2*fDz.getValue()));
288 float t2 = FATAN((fDy2.getValue()-fDy1.getVa 285 float t2 = FATAN((fDy2.getValue()-fDy1.getValue())/(2*fDz.getValue()));
289 float st1 = FSIN(t1); 286 float st1 = FSIN(t1);
290 float st2 = FSIN(t2); 287 float st2 = FSIN(t2);
291 float ct1 = FCOS(t1); 288 float ct1 = FCOS(t1);
292 float ct2 = FCOS(t2); 289 float ct2 = FCOS(t2);
293 290
294 normals[0][0] = 0 ; normals[0][1] = 0; 291 normals[0][0] = 0 ; normals[0][1] = 0; normals [0][2] = -1;
295 normals[1][0] = 0 ; normals[1][1] = 0; 292 normals[1][0] = 0 ; normals[1][1] = 0; normals [1][2] = 1;
296 normals[2][0] = 0 ; normals[2][1] = ct2; 293 normals[2][0] = 0 ; normals[2][1] = ct2; normals [2][2] = -st2;
297 normals[3][0] = -ct1; normals[3][1] = 0; 294 normals[3][0] = -ct1; normals[3][1] = 0; normals [3][2] = -st1;
298 normals[4][0] = 0 ; normals[4][1] = -ct2; 295 normals[4][0] = 0 ; normals[4][1] = -ct2; normals [4][2] = -st2;
299 normals[5][0] = ct1; normals[5][1] = 0; 296 normals[5][0] = ct1; normals[5][1] = 0; normals [5][2] = -st1;
300 297
301 for (int np=0;np<NPOINTS;np++) theCoordinate 298 for (int np=0;np<NPOINTS;np++) theCoordinates->point.set1Value(np,points[np][0],points[np][1],points[np][2]);
302 theFaceSet->coordIndex.setValues(0,NINDICES, 299 theFaceSet->coordIndex.setValues(0,NINDICES,indices);
303 for (int nf=0;nf<NFACES;nf++) theNormals->ve 300 for (int nf=0;nf<NFACES;nf++) theNormals->vector.set1Value(nf,normals[nf][0],normals[nf][1],normals[nf][2]);
304 theNormalBinding->value=SoNormalBinding::PER 301 theNormalBinding->value=SoNormalBinding::PER_FACE;
305 } 302 }
306 303
307 // generateChildren 304 // generateChildren
308 void SoTrd::generateChildren() { 305 void SoTrd::generateChildren() {
309 306
310 // This routines creates one SoSeparator, on 307 // This routines creates one SoSeparator, one SoCoordinate3, and
311 // one SoLineSet, and puts it in the child l 308 // one SoLineSet, and puts it in the child list. This is done only
312 // once, whereas redrawing the position of t 309 // once, whereas redrawing the position of the coordinates occurs each
313 // time an update is necessary, in the updat 310 // time an update is necessary, in the updateChildren routine.
314 311
315 assert(children->getLength() ==0); 312 assert(children->getLength() ==0);
316 SoSeparator *sep = new SoS 313 SoSeparator *sep = new SoSeparator();
317 SoCoordinate3 *theCoordinates = new SoC 314 SoCoordinate3 *theCoordinates = new SoCoordinate3();
318 SoNormal *theNormals = new SoN 315 SoNormal *theNormals = new SoNormal();
319 SoNormalBinding *theNormalBinding = new SoN 316 SoNormalBinding *theNormalBinding = new SoNormalBinding();
320 SoIndexedFaceSet *theFaceSet = new SoI 317 SoIndexedFaceSet *theFaceSet = new SoIndexedFaceSet();
321 // 318 //
322 // This line costs some in render quality! b 319 // This line costs some in render quality! but gives speed.
323 // 320 //
324 sep->addChild(theCoordinates); 321 sep->addChild(theCoordinates);
325 sep->addChild(theNormals); 322 sep->addChild(theNormals);
326 sep->addChild(theNormalBinding); 323 sep->addChild(theNormalBinding);
327 sep->addChild(theFaceSet); 324 sep->addChild(theFaceSet);
328 children->append(sep); 325 children->append(sep);
329 } 326 }
330 327
331 // generateAlternateRep 328 // generateAlternateRep
332 void SoTrd::generateAlternateRep() { 329 void SoTrd::generateAlternateRep() {
333 330
334 // This routine sets the alternate represent 331 // This routine sets the alternate representation to the child
335 // list of this mode. 332 // list of this mode.
336 333
337 if (children->getLength() == 0) generateChil 334 if (children->getLength() == 0) generateChildren();
338 updateChildren(); 335 updateChildren();
339 alternateRep.setValue((SoSeparator *) ( *ch 336 alternateRep.setValue((SoSeparator *) ( *children)[0]);
340 } 337 }
341 338
342 // clearAlternateRep 339 // clearAlternateRep
343 void SoTrd::clearAlternateRep() { 340 void SoTrd::clearAlternateRep() {
344 alternateRep.setValue(NULL); 341 alternateRep.setValue(NULL);
345 } 342 }
>> 343
>> 344 #endif
346 345