| 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: SoBox
32 /* Description: Represents the G4Box Gean
33 /* Author: Joe Boudreau Nov 11 1996
34 /*
35 /*--------------------------------------------
36
37 // this :
38 #include "HEPVis/nodes/SoBox.h"
39
40 #include <assert.h>
41 #include <cmath>
42
43 #include <Inventor/SbBox.h>
44 #include <Inventor/fields/SoSFFloat.h>
45 #include <Inventor/misc/SoChildList.h>
46 #include <Inventor/nodes/SoSeparator.h>
47 #include <Inventor/nodes/SoCube.h>
48 #include <Inventor/nodes/SoScale.h>
49 #include <Inventor/actions/SoAction.h>
50 #include <Inventor/nodes/SoIndexedFaceSet.h>
51 #include <Inventor/SoPrimitiveVertex.h>
52 #include <Inventor/elements/SoTextureCoordinat
53
54 // This statement is required
55 SO_NODE_SOURCE(SoBox)
56
57 // Constructor
58 SoBox::SoBox() {
59 // This statement is required
60 SO_NODE_CONSTRUCTOR(SoBox);
61
62 // Data fields are initialized like this:
63 SO_NODE_ADD_FIELD(fDx, (1.0))
64 SO_NODE_ADD_FIELD(fDy, (1.0))
65 SO_NODE_ADD_FIELD(fDz, (1.0))
66 SO_NODE_ADD_FIELD(alternateRep, (NULL)
67 children = new SoChildList(this);
68 }
69
70 // Destructor
71 SoBox::~SoBox() {
72 delete children;
73 }
74
75
76 // initClass
77 void SoBox::initClass(){
78 // This statement is required.
79 static bool first = true;
80 if (first) {
81 first = false;
82 SO_NODE_INIT_CLASS(SoBox,SoShape,"Shape");
83 }
84 }
85
86
87 // generatePrimitives
88 void SoBox::generatePrimitives(SoAction *actio
89 // This variable is used to store each verte
90 SoPrimitiveVertex pv;
91
92 // Access the stat from the action
93 SoState *state = action->getState();
94
95 // See if we have to use a texture coordinat
96 // rather than generating explicit texture c
97 SbBool useTexFunction=
98 (SoTextureCoordinateElement::getType(state
99 SoTextureCoordinateElement::FUNCTION);
100
101 // If we need to generate texture coordinate
102 // we'll need an SoGLTextureCoordinateElemen
103 // set up the coordinates directly.
104 const SoTextureCoordinateElement *tce = NULL
105 SbVec4f texCoord;
106 if (useTexFunction) {
107 tce = SoTextureCoordinateElement::getInsta
108 }
109 else {
110 texCoord[2] = 0.0;
111 texCoord[3] = 1.0;
112 }
113 SbVec3f point, normal;
114
115
116 //////////////////////////////////////////
117 //----------------------------------------
118 #define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \
119 point.setValue(x,y,z); \
120 normal.setValue(nx,ny,nz); \
121 if (useTexFunction) { \
122 texCoord=tce->get(point,normal); \
123 } \
124 else { \
125 texCoord[0]=s; \
126 texCoord[1]=t; \
127 } \
128 pv.setPoint(point); \
129 pv.setNormal(normal); \
130 pv.setTextureCoords(texCoord); \
131 shapeVertex(&pv);
132 //----------------------------------------
133 //////////////////////////////////////////
134
135 const int NPOINTS=8, NFACES=6, NINDICES = NF
136 int indices[NINDICES] = {3,2,1,0, SO_END_FAC
137 4,5,6,7, SO_END_FACE_INDEX, //z fron
138 0,1,5,4, SO_END_FACE_INDEX, //y up.
139 1,2,6,5, SO_END_FACE_INDEX, //x left
140 2,3,7,6, SO_END_FACE_INDEX, //y down
141 3,0,4,7, SO_END_FACE_INDEX}; //x righ
142
143
144 // points for the eight vertices
145 float points[NPOINTS][3];
146 points[0][0] = fDx.getValue();
147 points[0][1] = fDy.getValue();
148 points[0][2] = -fDz.getValue();
149
150 points[1][0] = -fDx.getValue();
151 points[1][1] = fDy.getValue();
152 points[1][2] = -fDz.getValue();
153
154 points[2][0] = -fDx.getValue();
155 points[2][1] = -fDy.getValue();
156 points[2][2] = -fDz.getValue();
157
158 points[3][0] = fDx.getValue();
159 points[3][1] = -fDy.getValue();
160 points[3][2] = -fDz.getValue();
161
162 points[4][0] = fDx.getValue();
163 points[4][1] = fDy.getValue();
164 points[4][2] = fDz.getValue();
165
166 points[5][0] = -fDx.getValue();
167 points[5][1] = fDy.getValue();
168 points[5][2] = fDz.getValue();
169
170 points[6][0] = -fDx.getValue();
171 points[6][1] = -fDy.getValue();
172 points[6][2] = fDz.getValue();
173
174 points[7][0] = fDx.getValue();
175 points[7][1] = -fDy.getValue();
176 points[7][2] = fDz.getValue();
177
178 float normals[NFACES][3];
179 //z back.
180 normals[0][0] = 0 ; normals[0][1] = 0;
181 //z front.
182 normals[1][0] = 0 ; normals[1][1] = 0;
183 //y up.
184 normals[2][0] = 0 ; normals[2][1] = 1;
185 //x left.
186 normals[3][0] = -1 ; normals[3][1] = 0;
187 //y down.
188 normals[4][0] = 0 ; normals[4][1] = -1;
189 //x right.
190 normals[5][0] = 1 ; normals[5][1] = 0;
191
192 float x,y,z;
193 int index;
194 for (int nf=0;nf<NFACES;nf++) {
195 beginShape(action,TRIANGLE_FAN);
196 index = indices[nf * 5];
197 x = points[index][0];
198 y = points[index][1];
199 z = points[index][2];
200 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0]
201 index = indices[nf * 5 + 1];
202 x = points[index][0];
203 y = points[index][1];
204 z = points[index][2];
205 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0]
206 index = indices[nf * 5 + 2];
207 x = points[index][0];
208 y = points[index][1];
209 z = points[index][2];
210 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0]
211 index = indices[nf * 5 + 3];
212 x = points[index][0];
213 y = points[index][1];
214 z = points[index][2];
215 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0]
216 endShape();
217 }
218 }
219
220 // getChildren
221 SoChildList *SoBox::getChildren() const {
222 return children;
223 }
224
225
226 // computeBBox
227 void SoBox::computeBBox(SoAction *, SbBox3f &b
228 SbVec3f vmin(-fDx.getValue(),-fDy.getValue()
229 vmax( fDx.getValue(), fDy.getValue()
230 center.setValue(0,0,0);
231 box.setBounds(vmin,vmax);
232 }
233
234
235
236
237 // updateChildren
238 void SoBox::updateChildren() {
239
240
241 // Redraw the G4Box....
242
243 assert(children->getLength()==1);
244 SoSeparator *sep = (SoS
245 SoScale *scale = (SoS
246 //SoCube *cube = (S
247 scale->scaleFactor.setValue(fDx.getValue(),
248 }
249
250 // generateChildren
251 void SoBox::generateChildren() {
252
253 // A box consists of a set of scale factors
254 // cube.
255
256 assert(children->getLength() ==0);
257 SoSeparator *sep = new SoS
258 SoScale *scale = new SoS
259 SoCube *cube = new SoC
260
261 sep->addChild(scale);
262 sep->addChild(cube);
263 children->append(sep);
264 }
265
266 // generateAlternateRep
267 void SoBox::generateAlternateRep() {
268
269 // This routine sets the alternate represent
270 // list of this mode.
271
272 if (children->getLength() == 0) generateChil
273 updateChildren();
274 alternateRep.setValue((SoSeparator *) ( *ch
275 }
276
277 // clearAlternateRep
278 void SoBox::clearAlternateRep() {
279 alternateRep.setValue(NULL);
280 }
281