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