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