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