Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
SoBox.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27//
28//
29/*----------------------------HEPVis----------------------------------------*/
30/* */
31/* Node: SoBox */
32/* Description: Represents the G4Box Geant Geometry entity */
33/* Author: Joe Boudreau Nov 11 1996 */
34/* */
35/*--------------------------------------------------------------------------*/
36
37#ifdef G4VIS_BUILD_OI_DRIVER
38
39// this :
40#include "HEPVis/nodes/SoBox.h"
41
42#include <assert.h>
43#include <cmath>
44
45#include <Inventor/SbBox.h>
46#include <Inventor/fields/SoSFFloat.h>
47#include <Inventor/misc/SoChildList.h>
48#include <Inventor/nodes/SoSeparator.h>
49#include <Inventor/nodes/SoCube.h>
50#include <Inventor/nodes/SoScale.h>
51#include <Inventor/actions/SoAction.h>
52#include <Inventor/nodes/SoIndexedFaceSet.h>
53#include <Inventor/SoPrimitiveVertex.h>
54#include <Inventor/elements/SoTextureCoordinateElement.h>
55
56// This statement is required
57SO_NODE_SOURCE(SoBox)
58
59// Constructor
60SoBox::SoBox() {
61 // This statement is required
62 SO_NODE_CONSTRUCTOR(SoBox);
63
64 // Data fields are initialized like this:
65 SO_NODE_ADD_FIELD(fDx, (1.0));
66 SO_NODE_ADD_FIELD(fDy, (1.0));
67 SO_NODE_ADD_FIELD(fDz, (1.0));
68 SO_NODE_ADD_FIELD(alternateRep, (NULL));
69 children = new SoChildList(this);
70}
71
72// Destructor
73SoBox::~SoBox() {
74 delete children;
75}
76
77
78// initClass
79void SoBox::initClass(){
80 // This statement is required.
81 static bool first = true;
82 if (first) {
83 first = false;
84 SO_NODE_INIT_CLASS(SoBox,SoShape,"Shape");
85 }
86}
87
88
89// generatePrimitives
90void SoBox::generatePrimitives(SoAction *action) {
91 // This variable is used to store each vertex
92 SoPrimitiveVertex pv;
93
94 // Access the stat from the action
95 SoState *state = action->getState();
96
97 // See if we have to use a texture coordinate function,
98 // rather than generating explicit texture coordinates.
99 SbBool useTexFunction=
100 (SoTextureCoordinateElement::getType(state) ==
101 SoTextureCoordinateElement::FUNCTION);
102
103 // If we need to generate texture coordinates with a function,
104 // we'll need an SoGLTextureCoordinateElement. Otherwise, we'll
105 // set up the coordinates directly.
106 const SoTextureCoordinateElement *tce = NULL;
107 SbVec4f texCoord;
108 if (useTexFunction) {
109 tce = SoTextureCoordinateElement::getInstance(state);
110 }
111 else {
112 texCoord[2] = 0.0;
113 texCoord[3] = 1.0;
114 }
115 SbVec3f point, normal;
116
117
118 //////////////////////////////////////////
119 //----------------------------------------
120#define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \
121 point.setValue(x,y,z); \
122 normal.setValue(nx,ny,nz); \
123 if (useTexFunction) { \
124 texCoord=tce->get(point,normal); \
125 } \
126 else { \
127 texCoord[0]=s; \
128 texCoord[1]=t; \
129 } \
130 pv.setPoint(point); \
131 pv.setNormal(normal); \
132 pv.setTextureCoords(texCoord); \
133 shapeVertex(&pv);
134 //----------------------------------------
135 //////////////////////////////////////////
136
137 const int NPOINTS=8, NFACES=6, NINDICES = NFACES*5;
138 int indices[NINDICES] = {3,2,1,0, SO_END_FACE_INDEX, //z back.
139 4,5,6,7, SO_END_FACE_INDEX, //z front.
140 0,1,5,4, SO_END_FACE_INDEX, //y up.
141 1,2,6,5, SO_END_FACE_INDEX, //x left.
142 2,3,7,6, SO_END_FACE_INDEX, //y down.
143 3,0,4,7, SO_END_FACE_INDEX}; //x right.
144
145
146 // points for the eight vertices
147 float points[NPOINTS][3];
148 points[0][0] = fDx.getValue();
149 points[0][1] = fDy.getValue();
150 points[0][2] = -fDz.getValue();
151
152 points[1][0] = -fDx.getValue();
153 points[1][1] = fDy.getValue();
154 points[1][2] = -fDz.getValue();
155
156 points[2][0] = -fDx.getValue();
157 points[2][1] = -fDy.getValue();
158 points[2][2] = -fDz.getValue();
159
160 points[3][0] = fDx.getValue();
161 points[3][1] = -fDy.getValue();
162 points[3][2] = -fDz.getValue();
163
164 points[4][0] = fDx.getValue();
165 points[4][1] = fDy.getValue();
166 points[4][2] = fDz.getValue();
167
168 points[5][0] = -fDx.getValue();
169 points[5][1] = fDy.getValue();
170 points[5][2] = fDz.getValue();
171
172 points[6][0] = -fDx.getValue();
173 points[6][1] = -fDy.getValue();
174 points[6][2] = fDz.getValue();
175
176 points[7][0] = fDx.getValue();
177 points[7][1] = -fDy.getValue();
178 points[7][2] = fDz.getValue();
179
180 float normals[NFACES][3];
181 //z back.
182 normals[0][0] = 0 ; normals[0][1] = 0; normals [0][2] = -1;
183 //z front.
184 normals[1][0] = 0 ; normals[1][1] = 0; normals [1][2] = 1;
185 //y up.
186 normals[2][0] = 0 ; normals[2][1] = 1; normals [2][2] = 0;
187 //x left.
188 normals[3][0] = -1 ; normals[3][1] = 0; normals [3][2] = 0;
189 //y down.
190 normals[4][0] = 0 ; normals[4][1] = -1; normals [4][2] = 0;
191 //x right.
192 normals[5][0] = 1 ; normals[5][1] = 0; normals [5][2] = 0;
193
194 float x,y,z;
195 int index;
196 for (int nf=0;nf<NFACES;nf++) {
197 beginShape(action,TRIANGLE_FAN);
198 index = indices[nf * 5];
199 x = points[index][0];
200 y = points[index][1];
201 z = points[index][2];
202 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
203 index = indices[nf * 5 + 1];
204 x = points[index][0];
205 y = points[index][1];
206 z = points[index][2];
207 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
208 index = indices[nf * 5 + 2];
209 x = points[index][0];
210 y = points[index][1];
211 z = points[index][2];
212 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
213 index = indices[nf * 5 + 3];
214 x = points[index][0];
215 y = points[index][1];
216 z = points[index][2];
217 GEN_VERTEX(pv,x,y,z,0.0,0.0,normals[nf][0],normals[nf][1],normals[nf][2]);
218 endShape();
219 }
220}
221
222// getChildren
223SoChildList *SoBox::getChildren() const {
224 return children;
225}
226
227
228// computeBBox
229void SoBox::computeBBox(SoAction *, SbBox3f &box, SbVec3f &center ){
230 SbVec3f vmin(-fDx.getValue(),-fDy.getValue(),-fDz.getValue()),
231 vmax( fDx.getValue(), fDy.getValue(), fDz.getValue());
232 center.setValue(0,0,0);
233 box.setBounds(vmin,vmax);
234}
235
236
237
238
239// updateChildren
240void SoBox::updateChildren() {
241
242
243 // Redraw the G4Box....
244
245 assert(children->getLength()==1);
246 SoSeparator *sep = (SoSeparator *) ( *children)[0];
247 SoScale *scale = (SoScale *)( sep->getChild(0));
248 //SoCube *cube = (SoCube *)( sep->getChild(1));
249 scale->scaleFactor.setValue(fDx.getValue(), fDy.getValue(), fDz.getValue());
250}
251
252// generateChildren
253void SoBox::generateChildren() {
254
255 // A box consists of a set of scale factors and a
256 // cube.
257
258 assert(children->getLength() ==0);
259 SoSeparator *sep = new SoSeparator();
260 SoScale *scale = new SoScale();
261 SoCube *cube = new SoCube();
262
263 sep->addChild(scale);
264 sep->addChild(cube);
265 children->append(sep);
266}
267
268// generateAlternateRep
269void SoBox::generateAlternateRep() {
270
271 // This routine sets the alternate representation to the child
272 // list of this mode.
273
274 if (children->getLength() == 0) generateChildren();
275 updateChildren();
276 alternateRep.setValue((SoSeparator *) ( *children)[0]);
277}
278
279// clearAlternateRep
280void SoBox::clearAlternateRep() {
281 alternateRep.setValue(NULL);
282}
283
284#endif
SoBox
Definition: SoBox.h:63
SoBox::SoBox
SoBox()
Constructor, required.
SoBox::fDx
SoSFFloat fDx
Half-length along X.
Definition: SoBox.h:73
SoBox::generateAlternateRep
virtual void generateAlternateRep()
SoBox::alternateRep
SoSFNode alternateRep
Alternate rep - for use by users without HEPVis shared objects.
Definition: SoBox.h:85
SoBox::fDy
SoSFFloat fDy
Half-length along Y.
Definition: SoBox.h:77
SoBox::getChildren
virtual SoChildList * getChildren() const
GetChildList, required whenever the class has hidden children.
SoBox::~SoBox
virtual ~SoBox()
Destructor, required.
SoBox::fDz
SoSFFloat fDz
Half-length along Z.
Definition: SoBox.h:81
SoBox::initClass
static void initClass()
Class Initializer, required.
SoBox::computeBBox
virtual void computeBBox(SoAction *action, SbBox3f &box, SbVec3f &center)
compute bounding Box, required
SoBox::generatePrimitives
virtual void generatePrimitives(SoAction *action)
Generate Primitives, required.
SoBox::clearAlternateRep
virtual void clearAlternateRep()
We better be able to clear it, too!