int main( int argc, char **argv )
{
osgInit(argc,argv);
QApplication::setColorSpec( QApplication::CustomColor );
QApplication a( argc, argv );
if ( !QGLFormat::hasOpenGL() ) {
qWarning( "This system has no OpenGL support. Exiting." );
return -1;
}
OpenSGWidget w(QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba |
QGL::DirectRendering));
// create the scene
NodePtr scene;
if(argc > 1)
{
scene = Node::create();
GroupPtr g = Group::create();
beginEditCP(scene);
scene->setCore(g);
for(UInt16 i = 1; i < argc; ++i)
scene->addChild(SceneFileHandler::the().read(argv[i]));
endEditCP(scene);
}
else
{
scene = makeTorus(.5, 3, 16, 16);
}
w.getManager()->setRoot(scene);
w.getManager()->showAll();
w.show();
return a.exec();
}
/***************************************************************************\
* Instance methods *
\***************************************************************************/
ComponentPtr DefaultDialogComponentGenerator::getResponseComponent(DialogInterfacePtr Parent, const boost::any& Value)
{
std::string responseString("");
try
{
responseString = lexical_cast(Value);
}
catch (boost::bad_lexical_cast &)
{
std::cout<<"Unable to display response"<<std::endl;
}
ButtonPtr TheResponseButton = Button::Ptr::dcast(getResponseButtonPrototype()->shallowCopy());
beginEditCP(TheResponseButton, Button::TextFieldMask);
TheResponseButton->setText(responseString);
endEditCP(TheResponseButton, Button::TextFieldMask);
return TheResponseButton;
}
// Helper function to add a rational trimcurve to an OSG::Surface NodeCore
void addTrimCurve(SurfacePtr surf, const int numcps, const float xyw[][3],
const int dim, const int numknots, const float *knots,
bool startnewloop = false)
{
std::vector<Real64> knotv;
std::vector<Pnt3f> cps;
int i;
for (i = 0; i < numcps; ++i)
{
cps.push_back(Pnt3f(xyw[i][0], xyw[i][1], xyw[i][2]));
}
for (i = 0; i < numknots; ++i)
{
knotv.push_back(knots[i]);
}
beginEditCP(surf, Surface::CurveFieldMask);
surf->addCurve(dim, knotv, cps, startnewloop);
endEditCP (surf, Surface::CurveFieldMask);
}
void CharacterModel::changed(BitVector whichField, UInt32 origin)
{
Inherited::changed(whichField, origin);
if(whichField & ConfigFileFieldMask)
{
_coreModel = loadConfig(getConfigFile());
if(_coreModel)
{
// Only need to do this once, not every time the
// Cal3D Model is needed, that's why it's not
// done in loadConfig()
convertMaterials(getConfigFile());
CharacterModelPtr cp(this);
beginEditCP(cp, NumAnimationsFieldMask);
cp->setNumAnimations(_coreModel->getCoreAnimationCount());
endEditCP(cp, NumAnimationsFieldMask);
}
}
}
void VRMLLODBinder::init(VRMLToOSGAction *)
{
if(_pNode == NULL)
return;
VRMLLOD *pNode = dynamic_cast<VRMLLOD *>(_pNode);
if(pNode == NULL)
return;
NodePtr pLODNode = Node ::create();
DistanceLODPtr pLOD = DistanceLOD::create();
beginEditCP(pLODNode, Node::CoreFieldMask);
{
pLODNode->setCore(pLOD);
}
endEditCP (pLODNode, Node::CoreFieldMask);
_pFieldContainer = pLODNode;
}
/*!
* \brief Replaces corrupted geometrie nodes with group nodes.
* \return true if something was repaired.
*/
bool VerifyGraphOp::repairGeometry(void)
{
if (!_corruptedGeos.empty())
{
if (_verbose)
{
SINFO << "Repairing corrupted geos:" << endLog;
}
for (UInt32 i=0;i<_corruptedGeos.size();++i)
{
// now replace corrupted geometry core with a group core.
for (UInt32 j=0;j<_corruptedGeos[i]->getParents().size();++j)
{
NodePtr parent = _corruptedGeos[i]->getParents()[j];
if (parent != NullFC)
{
std::string nname;
if(OSG::getName(parent) != NULL)
{
nname = OSG::getName(parent);
}
if (_verbose)
{
SINFO << "Removing corrupted geom from node: "
<< nname << endLog;
}
nname += "_CORRUPTED";
OSG::setName(parent, nname.c_str());
beginEditCP(parent, Node::CoreFieldMask);
parent->setCore(Group::create());
endEditCP(parent, Node::CoreFieldMask);
}
}
}
return true;
}
return false;
}
// redraw the window
void display(void)
{
if (animate)
{
// Eventually switch between different hardware modes
float ctime = glutGet(GLUT_ELAPSED_TIME);
int dtime = ctime / 1000 / 2;
newMode = dtime % numModes;
// Make the volume rotate
int movement = (int) (ctime - lastFrame) * aniSpeed;
if (movement != 0) lastFrame = ctime;
mgr->mouseButtonPress (GLUT_LEFT_BUTTON, 0, 0);
mgr->mouseMove (movement, 0);
mgr->mouseButtonRelease(GLUT_LEFT_BUTTON, movement, 0);
}
// Switch shader mode if desired
if (newMode != curMode)
{
beginEditCP(shader, DVRSimpleLUTShader::LutModeFieldMask);
setField<Int8>(shader, "lutMode", newMode);
endEditCP(shader, DVRSimpleLUTShader::LutModeFieldMask);
}
mgr->redraw();
// Output active shader mode - field is valid after redraw only
if (newMode != curMode)
{
SLOG << "Mode " << newMode
<< ": " << shaderTests[newMode].name << " --> "
<< shaderTests[getField<Int8>(shader, "activeLutMode")].name << std::endl;
curMode = newMode;
}
}
void VRMLAppearanceBinder::setTexture(TextureChunkPtr pTex)
{
if(pTex == NullFC)
return;
ChunkMaterialPtr pChunkMat =
ChunkMaterialPtr::dcast(_pFieldContainer);
if(pChunkMat != NullFC)
{
beginEditCP(pChunkMat, ChunkMaterial::ChunksFieldMask);
{
pChunkMat->addChunk(pTex);
}
endEditCP (pChunkMat, ChunkMaterial::ChunksFieldMask);
// check for alpha
ImagePtr img = pTex->getImage();
if(img != NullFC && img->getBpp() == 4)
_has_alpha = true;
}
}
ImageComponentPtr IconManager::createIconImageComponent(const std::string& IconSetName)
{
IconSetPtr TheSet(getIconSet(IconSetName));
if(TheSet != NULL)
{
//Editor Icon
ImageComponentPtr IconImageComponent = ImageComponent::create();
beginEditCP(IconImageComponent, ImageComponent::TextureFieldMask | ImageComponent::RolloverTextureFieldMask | ImageComponent::FocusedTextureFieldMask | ImageComponent::DisabledTextureFieldMask);
IconImageComponent->setTexture(TheSet->getTexture(IconSet::ICON_NORMAL));
IconImageComponent->setRolloverTexture(TheSet->getTexture(IconSet::ICON_ROLLOVER));
IconImageComponent->setFocusedTexture(TheSet->getTexture(IconSet::ICON_FOCUSED));
IconImageComponent->setDisabledTexture(TheSet->getTexture(IconSet::ICON_DISABLED));
IconImageComponent->setScale(ImageComponent::SCALE_MIN_AXIS);
endEditCP(IconImageComponent, ImageComponent::TextureFieldMask | ImageComponent::RolloverTextureFieldMask | ImageComponent::FocusedTextureFieldMask | ImageComponent::DisabledTextureFieldMask);
return IconImageComponent;
}
else
{
return ImageComponent::create();
}
}
osg::Real32 FieldAnimationAdvancer::getValue(void) const
{
if(getFieldId() == 0)
{
//Check if the Field Container is defined
if(getContainer() == osg::NullFC)
{
SWARNING << "There is no Field Container defined to get Field Advancer" << std::endl;
return 0.0f;
}
//Check if the field in this container is defined
FieldDescription * f = getContainer()->getType().findFieldDescription(getFieldName().c_str());
if( f == NULL )
{
SWARNING << "Could not find Field "<< getFieldName() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return 0.0f;
}
//Found the Field so set my Field Id
beginEditCP(FieldAnimationAdvancerPtr(this), FieldIdFieldMask);
const_cast<SFUInt32*>(&_sfFieldId)->setValue(f->getFieldId());
endEditCP(FieldAnimationAdvancerPtr(this), FieldIdFieldMask);
//The Field was not found
if(getFieldId() == 0)
{
SWARNING << "Could not find Field "<< getFieldName() << " in Field Container " << getContainer()->getTypeName() << std::endl;
return 0.0f;
}
//Check if the field is a Real32
if(getContainer()->getField( getFieldId() )->getType() != SFReal32::getClassType())
{
SWARNING << "Field "<< getFieldName() << " in Field Container " << getContainer()->getTypeName() << "Is not a SFReal32 Field." << std::endl;
return 0.0f;
}
}
return static_cast<SFReal32*>(getContainer()->getField( getFieldId() ))->getValue();
}
void CFlystickTranslateTool::OnTrackingMove(Quaternion q, Vec3f position){
if (!m_bToolActive) return;
// the new position in tracking space should be the new position of the flystick
// plus the properly rotated vector with the length of the pick distance
Vec3f eNegZPickVec;
eNegZPickVec = Vec3f(0.0, 0.0, -1.0) * m_dPickDistance;
Vec3f pickVec;
q.multVec(eNegZPickVec, pickVec);
Vec3f trackingSpacePos = position + pickVec;
// evaluate the transformation in world space since pick event
NodePtr cameraBeacon = m_pSceneManager->GetPerspectiveCamera()->getBeacon();
Matrix cameraToWorld = cameraBeacon->getToWorld();
Vec3f trackingWorldSpacePos = trackingSpacePos;
cameraToWorld.multFullMatrixPnt(trackingWorldSpacePos);
Vec3f worldSpaceDiffVector = trackingWorldSpacePos - m_osgPickTimeWorldSpaceTrackingPos;
// transform the "transformation since pick event" (worldSpaceDiffVector) into object space
Matrix worldToPickedObjectTransformMatrix;
Vec3f pickedObjectSpaceDiffVector;
m_osgPickedObjectTransformToWorldMatrix.inverse3(worldToPickedObjectTransformMatrix);
worldToPickedObjectTransformMatrix.mult(worldSpaceDiffVector, pickedObjectSpaceDiffVector);
// transform the object appropriately
Matrix m = m_osgOldPickedObjectTransformMatrix;
Vec3f oldTranslation, vecDummy;
Quaternion qDummy1, qDummy2;
m.getTransform(oldTranslation, qDummy1, vecDummy, qDummy2);
Vec3f newTranslation = oldTranslation + pickedObjectSpaceDiffVector;
m.setTranslate(newTranslation);
beginEditCP(m_posgPickedObjectTransform, Transform::MatrixFieldMask);{
m_posgPickedObjectTransform->setMatrix(m);
};endEditCP(m_posgPickedObjectTransform, Transform::MatrixFieldMask);
}
// redraw the window
void display( void )
{
// create the matrix
Matrix m;
Real32 t = glutGet(GLUT_ELAPSED_TIME );
// set the transforms' matrices
for(UInt16 i=0; i<ncopies; ++i)
{
m.setTransform(Vec3f( osgsin(t / 1000.f + i * 4 * ncopies / Pi),
osgcos(t / 1000.f + i * 6 * ncopies / Pi),
osgsin(t / 1000.f + i * 7 * ncopies / Pi)),
Quaternion( Vec3f (1,1,0),
t / 1000.f + i * 4 * ncopies / Pi));
beginEditCP(trans[i], Transform::MatrixFieldMask);
{
trans[i]->setMatrix(m);
}
endEditCP (trans[i], Transform::MatrixFieldMask);
}
mgr->redraw();
}
void Image::diff(Image img)
{
if( _image->getWidth() != img._image->getWidth() ||
_image->getHeight() != img._image->getHeight() ||
_image->getPixelFormat() != img._image->getPixelFormat())
{
FWARNING(("Image::diff: incompatible images!"));
return;
}
beginEditCP(_image);
OSG::UInt8 *sdata = img._image->getData();
OSG::UInt8 *ddata = _image->getData();
OSG::UInt32 nb = _image->getSize(false,false,false);
for(OSG::UInt32 i = 0; i < nb; ++i, ++sdata, ++ddata)
{
*ddata = OSG::osgabs(*ddata - *sdata);
}
endEditCP(_image);
}
void display(void)
{
Real32 time = glutGet(GLUT_ELAPSED_TIME);
updateMesh(time);
// we extract the core out of the root node
// as we now this is a geometry node
GeometryPtr geo = GeometryPtr::dcast(scene->getCore());
//now modify it's content
// first we need a pointer to the position data field
GeoPositions3fPtr pos = GeoPositions3fPtr::dcast(geo->getPositions());
//this loop is similar to when we generted the data during createScenegraph()
beginEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
// here they all come
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
pos->setValue(Pnt3f(x, wMesh[x][z], z), N*x+z);
endEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
mgr->redraw();
}
// redraw the window
void display(void)
{
static Real32 speed = 10000.0f;
static Real32 t = glutGet(GLUT_ELAPSED_TIME);
static Real32 t2 = 0.0;
Real32 td = glutGet(GLUT_ELAPSED_TIME) - t;
if(td > speed)
t = glutGet(GLUT_ELAPSED_TIME);
if(_animation)
{
t2 = (2 * OSG::Pi / speed) * td;
beginEditCP(_shl, SHLChunk::ParametersFieldMask);
_shl->setUniformParameter("cos_time_0_2PI", osgcos(t2));
_shl->setUniformParameter("sin_time_0_2PI", osgsin(t2));
endEditCP(_shl, SHLChunk::ParametersFieldMask);
}
// render scene
_mgr->redraw();
}
void OSGLoader::endField(void)
{
PINFO << "End Field" << std::endl;
_fStack.pop();
if(_fStack.size() != 0)
{
_pCurrentField = _fStack.top();
}
else
{
_pCurrentField = NULL;
}
if(_pCurrentFC != NullFC && _pCurrentFieldDesc != NULL)
{
endEditCP(_pCurrentFC,
_pCurrentFieldDesc->getFieldMask(),
ChangedOrigin::Abstract |
ChangedOrigin::AbstrIgnoreCore |
ChangedOrigin::AbstrIgnoreChild );
}
_fdStack.pop();
if(_fdStack.size() != 0)
{
_pCurrentFieldDesc = _fdStack.top();
}
else
{
_pCurrentFieldDesc = NULL;
}
}
void Particles::createSymmetricEmitterLine(Vec3f dir, Real32 dist, UInt16 num)
{
NodePtr localTransNode;
TransformPtr localTrans;
Matrix m;
dir.normalize();
for (int i = 1; i < num; i++)
{
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(-i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
} // for
} // createSymmetricEmitterLine
/*! Create LineChunk from fetched data.
* The DXF line pattern description is mapped to a 16 bit stipple pattern
* suitable for OpenGL line stippling. This mapping only approximately
* resembles the DXF line pattern.
*
* \todo
* Currently it's not checked, whether the fetched data is consistent!
*/
DXFResult DXFLtype::endEntity(void)
{
if(_linetypeMapP->find(_name) != _linetypeMapP->end())
{
FWARNING(("DXF Loader: before line %d: "
"LTYPE entity '%s' already exists. "
"Overwriting with new one!\n",
DXFRecord::getLineNumber(),
_name.c_str()
));
}
// Do consistency checks
Real32 checkedPatternLen = 0.0;
for(std::vector<Real64>::iterator itr = _elementLen.begin();
itr != _elementLen.end();
++ itr)
{
checkedPatternLen += osgabs(*itr);
}
if(osgabs(checkedPatternLen - _patternLen) > Eps)
{
FWARNING(("DXF Loader: before line %d: "
"LTYPE entity defines inconsistent pattern lenght!\n",
DXFRecord::getLineNumber()
));
// we go on, but will use consistent data: checkedPatternLen
}
if(_nElements != _elementLen.size())
{
FWARNING(("DXF Loader: before line %d: "
"LTYPE entity declares %d pattern elements but provides %d!\n",
DXFRecord::getLineNumber(),
_nElements,
_elementLen.size()
));
// we go on, but will use consistent data: _elementLen.size()
}
UInt16 pattern = 0;
LineChunkPtr linetype = LineChunk::create();
beginEditCP(linetype);
{
// linetype->setWidth(1);
if(_elementLen.size() != 0)
{
// Build OpenGL 16 bit stipple pattern: for each bit calculate, which
// pattern element it belongs to and set it if the pattern element is
// positive, otherwise leave it unset.
Real32 s = checkedPatternLen/16.0;
UInt8 j = 0;
Real32 elementLenSum = osgabs(_elementLen[j]);
for(UInt8 i = 0;
i < 16;
++ i)
{
if(elementLenSum < (0.5 + i) * s && j < _elementLen.size())
{
++ j;
elementLenSum += osgabs( _elementLen[j] );
}
if( _elementLen[j] > 0.0)
pattern |= 1<<i;
}
linetype->setStippleRepeat(1);
linetype->setStipplePattern(pattern);
}
linetype->setSmooth(true); //TODO: make this configurable by an option?
}
endEditCP(linetype);
#if 1 // DEBUG TODO: raus?!?!
std::string pstr("");
for(UInt8 i=0; i<16; ++i)
pstr += (pattern & (1<<i)) ? "1" : "0";
FDEBUG(("DXFLtype::endEntity(): pattern '%s' = %s\n",
_name.c_str(),
pstr.c_str()));
#endif // DEBUG
(*_linetypeMapP)[_name] = linetype;
return DXFStateContinue;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene or load it from a .osg-file
if (argc == 1)
{
scene = makeVolume("00_data64x64x64.dat");
}
else if(!strcmp(argv[1], "RGBA"))
{
ImagePtr imageP = Image::create();
const int res=64;
Real32 rres = res;
beginEditCP(imageP);
imageP->set(Image::OSG_RGBA_PF,res,res,res);
UInt8 *d = imageP->editData();
for(Int16 z = 0; z < res; ++z)
for(Int16 y = 0; y < res; ++y)
for(Int16 x = 0; x < res; ++x)
{
Real32 dx = x/rres - .5f;
Real32 dy = y/rres - .5f;
Real32 dz = z/rres - .5f;
Real32 dsq = (dx*dx + dy*dy + dz*dz);
int bx = (x<2 || x >=res-2),
by = (y<2 || y >=res-2),
bz = (z<2 || z >=res-2);
if(bx + by + bz >=2)
{
*d++ = 0;
*d++ = 255;
*d++ = 0;
*d++ = 64;
}
else if (osgabs(dx) < .2 && osgabs(dy) < .2)
{
*d++ = 0;
*d++ = 0;
*d++ = 0;
*d++ = 0;
}
else if(dsq <= .25f)
{
*d++ = static_cast<UInt8>(x/rres * 255.f);
*d++ = static_cast<UInt8>(y/rres * 255.f);
*d++ = static_cast<UInt8>(z/rres * 255.f);
*d++ = static_cast<UInt8>((.3f-dsq*dsq*dsq) * 255.f);
}
else
{
*d++ = 0;
*d++ = 0;
*d++ = 0;
*d++ = 0;
}
}
endEditCP(imageP);
imageP->setAttachmentField( "SliceThickness", "1 1 1" );
scene = makeVolume(imageP);
}
else if(!strcmp(argv[1], "RGB"))
{
ImagePtr imageP = Image::create();
const int res=64;
Real32 rres = res;
beginEditCP(imageP);
imageP->set(Image::OSG_RGB_PF,res,res,res);
UInt8 *d = imageP->editData();
for(Int16 z = 0; z < res; ++z)
for(Int16 y = 0; y < res; ++y)
for(Int16 x = 0; x < res; ++x)
{
Real32 dx = x/rres - .5f;
Real32 dy = y/rres - .5f;
Real32 dz = z/rres - .5f;
Real32 dsq = (dx*dx + dy*dy + dz*dz);
int bx = (x<2 || x >=res-2),
by = (y<2 || y >=res-2),
bz = (z<2 || z >=res-2);
if(bx + by + bz >=2)
{
*d++ = 0;
*d++ = 255;
*d++ = 0;
}
else if (osgabs(dx) < .2 && osgabs(dy) < .2)
{
*d++ = 0;
*d++ = 0;
*d++ = 0;
}
else if(dsq <= .25f)
{
*d++ = static_cast<UInt8>(x/rres * 255.f);
*d++ = static_cast<UInt8>(y/rres * 255.f);
*d++ = static_cast<UInt8>(z/rres * 255.f);
}
else
{
*d++ = 0;
*d++ = 0;
*d++ = 0;
}
}
endEditCP(imageP);
imageP->setAttachmentField( "SliceThickness", "1 1 1" );
scene = makeVolume(imageP);
}
else if(!strcmp(argv[1], "LA16"))
{
ImagePtr imageP = Image::create();
const int res=64;
Real32 rres = res;
beginEditCP(imageP);
imageP->set(Image::OSG_LA_PF,res,res,res,1,1,0,0,
Image::OSG_UINT16_IMAGEDATA);
UInt16 *d = reinterpret_cast<UInt16 *>(imageP->editData());
for(Int16 z = 0; z < res; ++z)
for(Int16 y = 0; y < res; ++y)
for(Int16 x = 0; x < res; ++x)
{
Real32 dx = x/rres - .5f;
Real32 dy = y/rres - .5f;
Real32 dz = z/rres - .5f;
Real32 dsq = (dx*dx + dy*dy + dz*dz);
int bx = (x<2 || x >=res-2),
by = (y<2 || y >=res-2),
bz = (z<2 || z >=res-2);
if(bx + by + bz >=2)
{
*d++ = 65535;
*d++ = 16384;
}
else if (osgabs(dx) < .2 && osgabs(dy) < .2)
{
*d++ = 0;
*d++ = 0;
}
else if(dsq <= .25f)
{
*d++ = static_cast<UInt16>(z/rres * 65535.f);
*d++ = static_cast<UInt16>((.3f-dsq*dsq*dsq) * 65535.f);
}
else
{
*d++ = 0;
*d++ = 0;
}
}
endEditCP(imageP);
imageP->setAttachmentField( "SliceThickness", "1 1 1" );
scene = makeVolume(imageP);
}
else if(!strcmp(argv[1], "LA"))
{
ImagePtr imageP = Image::create();
const int res=64;
Real32 rres = res;
beginEditCP(imageP);
imageP->set(Image::OSG_LA_PF,res,res,res);
UInt8 *d = imageP->editData();
for(Int16 z = 0; z < res; ++z)
for(Int16 y = 0; y < res; ++y)
for(Int16 x = 0; x < res; ++x)
{
Real32 dx = x/rres - .5f;
Real32 dy = y/rres - .5f;
Real32 dz = z/rres - .5f;
Real32 dsq = (dx*dx + dy*dy + dz*dz);
int bx = (x<2 || x >=res-2),
by = (y<2 || y >=res-2),
bz = (z<2 || z >=res-2);
if(bx + by + bz >=2)
{
*d++ = 32;
*d++ = 64;
}
else if (osgabs(dx) < .2 && osgabs(dy) < .2)
{
*d++ = 0;
*d++ = 0;
}
else if(dsq <= .25f)
{
*d++ = static_cast<UInt8>(z/rres * 255.f);
*d++ = static_cast<UInt8>((.3f-dsq*dsq*dsq) * 255.f);
}
else
{
*d++ = 0;
*d++ = 0;
}
}
endEditCP(imageP);
imageP->setAttachmentField( "SliceThickness", "1 1 1" );
scene = makeVolume(imageP);
}
else if(!strcmp(argv[1], "L"))
{
ImagePtr imageP = Image::create();
const int res=64;
Real32 rres = res;
beginEditCP(imageP);
imageP->set(Image::OSG_L_PF,res,res,res);
UInt8 *d = imageP->editData();
for(Int16 z = 0; z < res; ++z)
for(Int16 y = 0; y < res; ++y)
for(Int16 x = 0; x < res; ++x)
{
Real32 dx = x/rres - .5f;
Real32 dy = y/rres - .5f;
Real32 dz = z/rres - .5f;
Real32 dsq = (dx*dx + dy*dy + dz*dz);
int bx = (x<2 || x >=res-2),
by = (y<2 || y >=res-2),
bz = (z<2 || z >=res-2);
if(bx + by + bz >=2)
{
*d++ = 32;
}
else if (osgabs(dx) < .2 && osgabs(dy) < .2)
{
*d++ = 0;
}
else if(dsq <= .25f)
{
*d++ = static_cast<UInt8>(z/rres * 255.f);
}
else
{
*d++ = 0;
}
}
endEditCP(imageP);
imageP->setAttachmentField( "SliceThickness", "1 1 1" );
scene = makeVolume(imageP);
}
else
{
scene = SceneFileHandler::the().read(argv[1]);
if (scene == NullFC)
{
SLOG << "Could not read file " << argv[1] << std::endl;
exit(-1);
}
traverse(scene,
osgTypedFunctionFunctor1CPtrRef<Action::ResultE,
NodePtr >(findVolume));
}
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
Pnt3f from = mgr->getNavigator()->getFrom();
from[2] = 3 * from[2];
mgr->getNavigator()->setFrom(from);
// GLUT main loop
glutMainLoop();
return 0;
}
void OSGLoader::beginNode(const Char8 *szNodeTypename,
const Char8 *szNodename)
{
FieldContainerPtr pNewNode;
if(szNodeTypename == NULL)
return;
PINFO << "Begin node : " << szNodeTypename << " | ";
if(szNodename == NULL)
{
PINFO << "NULL";
}
else
{
PINFO << szNodename;
}
PINFO << std::endl;
pNewNode =
FieldContainerFactory::the()->createFieldContainer(szNodeTypename);
if(szNodename != NULL && pNewNode != NullFC)
{
AttachmentContainerPtr pAttCon =
AttachmentContainerPtr::dcast(pNewNode);
if(pAttCon != NullFC)
{
setName(pAttCon, szNodename);
}
_defMap.insert(std::make_pair(std::string(szNodename), pNewNode));
}
// assign nodepointer to current sf|mf field
setFieldContainerValue(pNewNode);
_pCurrentFC = pNewNode;
_fcStack.push(_pCurrentFC);
if(_fcStack.size() == 1)
{
NodePtr pNode;
if(_pCurrentFC->getType().isNode())
{
pNode = NodePtr::dcast(_pCurrentFC);
}
else if(_pCurrentFC->getType().isNodeCore())
{
pNode = Node::create();
pNode->setCore(NodeCorePtr::dcast(_pCurrentFC));
}
else
{
SLOG << "Fieldcontainer " << szNodeTypename
<< "is neither Node nor NodeCore " << std::endl;
}
if(_pRootNode == NullFC)
{
GroupPtr pGroup = Group::create();
_pRootNode = Node::create();
beginEditCP(_pRootNode, Node::CoreFieldMask);
{
_pRootNode->setCore(pGroup);
}
endEditCP (_pRootNode, Node::CoreFieldMask);
}
beginEditCP(_pRootNode, Node::ChildrenFieldMask);
{
_pRootNode->addChild(pNode);
}
endEditCP (_pRootNode, Node::ChildrenFieldMask);
}
}
void CharacterModel::convertMaterials(std::string configfile)
{
getMaterials().clear();
UInt32 mcnt = 0;
PathHandler ph;
ph.setBaseFile(configfile.c_str());
for(int mid = 0; mid < _coreModel->getCoreMaterialCount(); mid++)
{
CalCoreMaterial *coremat = _coreModel->getCoreMaterial(mid);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
CalCoreMaterial::Color &calamb = coremat->getAmbientColor();
CalCoreMaterial::Color &caldif = coremat->getDiffuseColor();
CalCoreMaterial::Color &calspec = coremat->getSpecularColor();
mat->setAmbient(Color3f(calamb.red / 255.0f, calamb.green / 255.0f, calamb.blue / 255.0f));
mat->setDiffuse(Color3f(caldif.red / 255.0f, caldif.green / 255.0f, caldif.blue / 255.0f));
mat->setSpecular(Color3f(calspec.red / 255.0f, calspec.green / 255.0f, calspec.blue / 255.0f));
mat->setShininess(coremat->getShininess() * 100.f);
mat->setLit(true);
mat->setColorMaterial(GL_NONE);
for(int mapId = 0; mapId < coremat->getMapCount(); mapId++)
{
std::string file = coremat->getMapFilename(mapId);
std::string pfile = ph.findFile(file.c_str());
SINFO << "Loading texture '" << pfile << "'..." << endLog;
ImagePtr img = Image::create();
if(!img->read(pfile.c_str()))
{
SWARNING << "CharacterModel::convertMaterials: error "
<< "loading image " << file << endLog;
}
else
{
// amz with my test scene paladin.cfg all textures were
// upside down so I disabled the vertical flipping perhaps
// they fixed the bug in Cal3D?
#if 0
beginEditCP(img);
{
// For some reason Cal3D expects textures upside down ???
UInt32 bpl = img->getBpp() * img->getWidth();
UChar8 *t = img->getData(),
*b = t + (img->getHeight() - 1) * bpl,
dum;
for(UInt32 y = img->getHeight() / 2; y > 0; --y)
{
for(UInt32 x = bpl; x > 0; --x, ++t, ++b)
{
dum = *t;
*t = *b;
*b = dum;
}
b -= bpl * 2;
}
}
endEditCP(img);
#endif
TextureChunkPtr tex = TextureChunk::create();
beginEditCP(tex);
tex->setImage(img);
tex->setEnvMode(GL_MODULATE);
endEditCP(tex);
mat->addChunk(tex);
}
}
endEditCP(mat);
coremat->setUserData((Cal::UserData)mcnt);
getMaterials().push_back(mat);
mcnt ++;
}
}
bool VerifyGraphOp::verifyIndexMap(GeometryPtr &geo, bool &repair)
{
repair = false;
if(geo == NullFC)
return true;
if(geo->getIndices() == NullFC)
return true;
if(!geo->getMFIndexMapping()->empty())
return true;
if(geo->getPositions() == NullFC)
return true;
UInt32 positions_size = geo->getPositions()->getSize();
UInt32 normals_size = 0;
if(geo->getNormals() != NullFC)
normals_size = geo->getNormals()->getSize();
UInt32 colors_size = 0;
if(geo->getColors() != NullFC)
colors_size = geo->getColors()->getSize();
UInt32 secondary_colors_size = 0;
if(geo->getSecondaryColors() != NullFC)
secondary_colors_size = geo->getSecondaryColors()->getSize();
UInt32 texccords_size = 0;
if(geo->getTexCoords() != NullFC)
texccords_size = geo->getTexCoords()->getSize();
UInt32 texccords1_size = 0;
if(geo->getTexCoords1() != NullFC)
texccords1_size = geo->getTexCoords1()->getSize();
UInt32 texccords2_size = 0;
if(geo->getTexCoords2() != NullFC)
texccords2_size = geo->getTexCoords2()->getSize();
UInt32 texccords3_size = 0;
if(geo->getTexCoords3() != NullFC)
texccords3_size = geo->getTexCoords3()->getSize();
/*
printf("sizes: %u %u %u %u %u %u %u %u\n", positions_size, normals_size,
colors_size, secondary_colors_size,
texccords_size, texccords1_size,
texccords2_size, texccords3_size);
*/
if((positions_size == normals_size || normals_size == 0) &&
(positions_size == colors_size || colors_size == 0) &&
(positions_size == secondary_colors_size || secondary_colors_size == 0) &&
(positions_size == texccords_size || texccords_size == 0) &&
(positions_size == texccords1_size || texccords1_size == 0) &&
(positions_size == texccords2_size || texccords2_size == 0) &&
(positions_size == texccords3_size || texccords3_size == 0)
)
{
UInt16 indexmap = 0;
if(positions_size > 0)
indexmap |= Geometry::MapPosition;
if(normals_size > 0)
indexmap |= Geometry::MapNormal;
if(colors_size > 0)
indexmap |= Geometry::MapColor;
if(secondary_colors_size > 0)
indexmap |= Geometry::MapSecondaryColor;
if(texccords_size > 0)
indexmap |= Geometry::MapTexCoords;
if(texccords1_size > 0)
indexmap |= Geometry::MapTexCoords1;
if(texccords2_size > 0)
indexmap |= Geometry::MapTexCoords2;
if(texccords3_size > 0)
indexmap |= Geometry::MapTexCoords3;
beginEditCP(geo, Geometry::IndexMappingFieldMask);
geo->editMFIndexMapping()->push_back(indexmap);
endEditCP(geo, Geometry::IndexMappingFieldMask);
repair = true;
return false;
}
else
{
return false;
}
}
/** Verify geometry method. */
Action::ResultE VerifyGraphOp::verifyGeometry(NodePtr &node)
{
GeometryPtr geo = GeometryPtr::dcast(node->getCore());
if(geo == NullFC)
return Action::Continue;
if(geo->getPositions() == NullFC)
return Action::Continue;
UInt32 start_errors = _numErrors;
Int32 positions_size = geo->getPositions()->getSize();
Int32 normals_size = 0;
if(geo->getNormals() != NullFC)
normals_size = geo->getNormals()->getSize();
Int32 colors_size = 0;
if(geo->getColors() != NullFC)
colors_size = geo->getColors()->getSize();
Int32 secondary_colors_size = 0;
if(geo->getSecondaryColors() != NullFC)
secondary_colors_size = geo->getSecondaryColors()->getSize();
Int32 texccords_size = 0;
if(geo->getTexCoords() != NullFC)
texccords_size = geo->getTexCoords()->getSize();
Int32 texccords1_size = 0;
if(geo->getTexCoords1() != NullFC)
texccords1_size = geo->getTexCoords1()->getSize();
Int32 texccords2_size = 0;
if(geo->getTexCoords2() != NullFC)
texccords2_size = geo->getTexCoords2()->getSize();
Int32 texccords3_size = 0;
if(geo->getTexCoords3() != NullFC)
texccords3_size = geo->getTexCoords3()->getSize();
UInt32 pos_errors = 0;
UInt32 norm_errors = 0;
UInt32 col_errors = 0;
UInt32 col2_errors = 0;
UInt32 tex0_errors = 0;
UInt32 tex1_errors = 0;
UInt32 tex2_errors = 0;
UInt32 tex3_errors = 0;
PrimitiveIterator it;
for(it = geo->beginPrimitives(); it != geo->endPrimitives(); ++it)
{
for(UInt32 v=0; v < it.getLength(); ++v)
{
if(it.getPositionIndex(v) >= positions_size)
++pos_errors;
if(it.getNormalIndex(v) >= normals_size)
++norm_errors;
if(it.getColorIndex(v) >= colors_size)
++col_errors;
if(it.getSecondaryColorIndex(v) >= secondary_colors_size)
++col2_errors;
if(it.getTexCoordsIndex(v) >= texccords_size)
++tex0_errors;
if(it.getTexCoordsIndex1(v) >= texccords1_size)
++tex1_errors;
if(it.getTexCoordsIndex2(v) >= texccords2_size)
++tex2_errors;
if(it.getTexCoordsIndex3(v) >= texccords3_size)
++tex3_errors;
}
}
if(norm_errors > 0)
{
norm_errors = 0;
if(_verbose) SINFO << "removed corrupted normals!\n";
beginEditCP(geo);
geo->setNormals(NullFC);
endEditCP(geo);
}
if(col_errors > 0)
{
col_errors = 0;
if(_verbose) SINFO << "removed corrupted colors!\n";
beginEditCP(geo);
geo->setColors(NullFC);
endEditCP(geo);
}
if(tex0_errors > 0)
{
tex0_errors = 0;
if(_verbose) SINFO << "removed corrupted tex coords0!\n";
beginEditCP(geo);
geo->setTexCoords(NullFC);
endEditCP(geo);
}
_numErrors += (pos_errors + norm_errors + col_errors +
col2_errors + tex0_errors + tex1_errors +
tex2_errors + tex3_errors);
// found some errors.
if(_numErrors > start_errors)
{
_corruptedGeos.push_back(geo);
}
// ok we found no errors now check for missing index map.
bool need_repair(false);
if(!verifyIndexMap(geo, need_repair))
{
if(need_repair)
{
SINFO << "verifyGeometry : added missing index map!" << endLog;
}
else
{
SINFO << "verifyGeometry : couldn't add missing index map!\n"
<< endLog;
}
}
return Action::Continue;
}
int main(int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
bool stereobuffer = false;
bool amberblue = false;
if(argc >= 2 && !strcmp(argv[1],"-s"))
{
stereobuffer = true;
--argc, ++argv;
}
if(argc >= 2 && !strcmp(argv[1],"-a"))
{
amberblue = true;
--argc, ++argv;
}
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE |
(stereobuffer?GLUT_STEREO:0) );
glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
PassiveWindowPtr pwin=PassiveWindow::create();
pwin->init();
// create the scene
NodePtr scene;
if(argc > 1)
{
scene = SceneFileHandler::the().read(argv[1]);
}
else
{
scene = makeBox(2,2,2, 1,1,1);
}
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// create the window and initial camera/viewport
mgr->setWindow(pwin );
// tell the manager what to manage
mgr->setRoot (scene);
// now create the second vp for stereo
ViewportPtr vp = pwin->getPort(0);
PerspectiveCameraPtr cam = PerspectiveCameraPtr::dcast(vp->getCamera());
beginEditCP(cam);
cam->setFov(deg2rad(90));
cam->setAspect(1);
endEditCP (cam);
Navigator *nav = mgr->getNavigator();
nav->setAt(Pnt3f(0,0,0));
nav->setDistance(1.5);
mgr->showAll();
// create the decorators and the second viewport
ViewportPtr vpleft,vpright;
decoleft = ShearedStereoCameraDecorator::create();
decoright = ShearedStereoCameraDecorator::create();
beginEditCP(decoleft);
decoleft->setEyeSeparation(ed);
decoleft->setZeroParallaxDistance(zpp);
decoleft->setLeftEye(true);
decoleft->setDecoratee(cam);
endEditCP (decoleft);
beginEditCP(decoright);
decoright->setEyeSeparation(ed);
decoright->setZeroParallaxDistance(zpp);
decoright->setLeftEye(false);
decoright->setDecoratee(cam);
endEditCP (decoright);
if(amberblue)
{
ColorBufferViewportPtr svpleft = ColorBufferViewport::create();
ColorBufferViewportPtr svpright = ColorBufferViewport::create();
beginEditCP(svpleft);
svpleft->setLeft(0);
svpleft->setRight(1);
svpleft->setBottom(0);
svpleft->setTop(1);
svpleft->setCamera(decoleft);
svpleft->setBackground(vp->getBackground());
svpleft->setRoot(vp->getRoot());
svpleft->setRed(GL_TRUE);
svpleft->setGreen(GL_TRUE);
svpleft->setBlue(GL_FALSE);
svpleft->setAlpha(GL_TRUE);
endEditCP (svpleft);
beginEditCP(svpright);
svpright->setLeft(0);
svpright->setRight(1);
svpright->setBottom(0);
svpright->setTop(1);
svpright->setCamera(decoright);
svpright->setBackground(vp->getBackground());
svpright->setRoot(vp->getRoot());
svpright->setRed(GL_FALSE);
svpright->setGreen(GL_FALSE);
svpright->setBlue(GL_TRUE);
svpright->setAlpha(GL_FALSE);
endEditCP (svpright);
vpleft = svpleft;
vpright = svpright;
}
else if(stereobuffer)
{
StereoBufferViewportPtr svpleft = StereoBufferViewport::create();
StereoBufferViewportPtr svpright = StereoBufferViewport::create();
beginEditCP(svpleft);
svpleft->setLeft(0);
svpleft->setRight(1);
svpleft->setBottom(0);
svpleft->setTop(1);
svpleft->setCamera(decoleft);
svpleft->setBackground(vp->getBackground());
svpleft->setRoot(vp->getRoot());
svpleft->setLeftBuffer(true);
svpleft->setRightBuffer(false);
endEditCP (svpleft);
beginEditCP(svpright);
svpright->setLeft(0);
svpright->setRight(1);
svpright->setBottom(0);
svpright->setTop(1);
svpright->setCamera(decoright);
svpright->setBackground(vp->getBackground());
svpright->setRoot(vp->getRoot());
svpright->setLeftBuffer(false);
svpright->setRightBuffer(true);
endEditCP (svpright);
vpleft = svpleft;
vpright = svpright;
}
else
{
vpleft = vp;
vpright = Viewport::create();
beginEditCP(vpleft);
vpleft->setLeft(0);
vpleft->setRight(1);
vpleft->setBottom(0);
vpleft->setTop(0.5);
endEditCP (vpleft);
beginEditCP(vpright);
vpright->setLeft(0);
vpright->setRight(1);
vpright->setBottom(0.5);
vpright->setTop(1);
vpright->setBackground(vp->getBackground());
vpright->setRoot(vp->getRoot());
endEditCP (vpright);
}
beginEditCP(vpleft);
vpleft->setCamera(decoleft);
endEditCP (vpleft);
beginEditCP(vpright);
vpright->setCamera(decoright);
endEditCP (vpright);
beginEditCP(pwin);
pwin->subPort(vp);
pwin->addPort(vpleft);
pwin->addPort(vpright);
endEditCP (pwin);
// make it notice the changes
mgr->setWindow(pwin );
// show the whole scene
mgr->showAll();
// OpenGL info
GLint val;
#define cv(v)\
glGetIntegerv((v),&val);\
printf("%s: %d\n", #v, val)
cv(GL_RED_BITS);
cv(GL_GREEN_BITS);
cv(GL_BLUE_BITS);
cv(GL_DEPTH_BITS);
glEnable(GL_DEPTH_TEST);
// GLUT main loop
glutMainLoop();
return 0;
}
void OpenSGLatticeGeometry::updateGeometry(const bool all)
{
showAll = all;
calcNumOfPoints(all);
// set number of points for each OPEN_GL type for lattice
beginEditCP(numOfPointsPerType, GeoPLengthsUI32::GeoPropDataFieldMask);
numOfPointsPerType->setValue(numOfLatticePoints, 0);
numOfPointsPerType->setValue(numOfLatticeLinePoints, 1);
endEditCP(numOfPointsPerType, GeoPLengthsUI32::GeoPropDataFieldMask);
cellDivisions = lattice.getCellDivisions();
const Lattice::Vector3d& cellPoints = lattice.getCellPoints();
// create all used vertices for the lattice (gl_points)
beginEditCP(latticePoints, GeoPositions3f::GeoPropDataFieldMask);
latticePoints->clear();
// vertices for gl_points
for (int h = 0; h <= cellDivisions[0]; h+=step)
for (int w = 0; w <= cellDivisions[1]; w+=step)
for (int l = 0; l <= cellDivisions[2]; l+=step)
latticePoints->addValue(Pnt3f(cellPoints[h][w][l][0],
cellPoints[h][w][l][1],
cellPoints[h][w][l][2]));
// vertices for gl_lines
for (int h = 0; h < cellDivisions[0]; h+=step)
for (int w = 0; w <= cellDivisions[1]; w+=step)
for (int l = 0; l <= cellDivisions[2]; l+=step)
{
latticePoints->addValue(Pnt3f(cellPoints[h][w][l][0],
cellPoints[h][w][l][1],
cellPoints[h][w][l][2]));
latticePoints->addValue(Pnt3f(cellPoints[h + step][w][l][0],
cellPoints[h + step][w][l][1],
cellPoints[h + step][w][l][2])
);
}
for (int h = 0; h <= cellDivisions[0]; h+=step)
for (int w = 0; w < cellDivisions[1]; w+=step)
for (int l = 0; l <= cellDivisions[2]; l+=step)
{
latticePoints->addValue(Pnt3f(cellPoints[h][w][l][0],
cellPoints[h][w][l][1],
cellPoints[h][w][l][2]));
latticePoints->addValue(Pnt3f(cellPoints[h][w + step][l][0],
cellPoints[h][w + step][l][1],
cellPoints[h][w + step][l][2])
);
}
for (int h = 0; h <= cellDivisions[0]; h+=step)
for (int w = 0; w <= cellDivisions[1]; w+=step)
for (int l = 0; l < cellDivisions[2]; l+=step)
{
latticePoints->addValue(Pnt3f(cellPoints[h][w][l][0],
cellPoints[h][w][l][1],
cellPoints[h][w][l][2]));
latticePoints->addValue(Pnt3f(cellPoints[h][w][l + step][0],
cellPoints[h][w][l + step][1],
cellPoints[h][w][l + step][2])
);
}
endEditCP(latticePoints, GeoPositions3f::GeoPropDataFieldMask);
// create all indices for lattice <-> vertex assignment
beginEditCP(latticeIndices, GeoIndicesUI32::GeoPropDataFieldMask);
latticeIndices->clear();
for (size_t i = 0; i < numOfLatticePoints; ++i)
latticeIndices->addValue(i);
for (size_t i = 0; i < numOfLatticeLinePoints; ++i)
latticeIndices->addValue(numOfLatticePoints + i);
endEditCP(latticeIndices, GeoIndicesUI32::GeoPropDataFieldMask);
// assign vertices, colors, indices to geometry
#if OSG_MAJOR_VERSION >= 2
beginEditCP(latticeGeo);
#else
beginEditCP(latticeGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::IndicesFieldMask |
Geometry::ColorsFieldMask);
#endif
latticeGeo->setTypes(latticeTypes);
latticeGeo->setLengths(numOfPointsPerType);
latticeGeo->setIndices(latticeIndices);
latticeGeo->setPositions(latticePoints);
latticeGeo->setColors(latticeColors);
calcVertexNormals(latticeGeo);
#if OSG_MAJOR_VERSION >= 2
endEditCP(latticeGeo);
#else
endEditCP(latticeGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::IndicesFieldMask |
Geometry::ColorsFieldMask);
#endif
changeColor();
}
NodePtr createScenegraph(){
// the scene must be created here
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
wMesh[x][z] = 0;
// GeoPTypes will define the types of primitives to be used
GeoPTypesPtr type = GeoPTypesUI8::create();
beginEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
// we want to use quads ONLY
type->addValue(GL_QUADS);
endEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
// GeoPLength will define the number of vertices of
// the used primitives
GeoPLengthsPtr length = GeoPLengthsUI32::create();
beginEditCP(length, GeoPLengthsUI32::GeoPropDataFieldMask);
// the length of our quads is four ;-)
length->addValue((N-1)*(N-1)*4);
endEditCP(length, GeoPLengthsUI32::GeoPropDataFieldMask);
// GeoPositions3f stores the positions of all vertices used in
// this specific geometry core
GeoPositions3fPtr pos = GeoPositions3f::create();
beginEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
// here they all come
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
pos->addValue(Pnt3f(x, wMesh[x][z], z));
endEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
//GeoColors3f stores all color values that will be used
GeoColors3fPtr colors = GeoColors3f::create();
beginEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
colors->addValue(Color3f(0,0,1));
endEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
GeoNormals3fPtr norms = GeoNormals3f::create();
beginEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
// As initially all heights are set to zero thus yielding a plane,
// we set all normals to (0,1,0) parallel to the y-axis
norms->addValue(Vec3f(0,1,0));
endEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(0,0,1));
endEditCP(mat);
// GeoIndicesUI32 points to all relevant data used by the
// provided primitives
GeoIndicesUI32Ptr indices = GeoIndicesUI32::create();
beginEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
for (int x = 0; x < N-1; x++)
for (int z = 0; z < N-1; z++){
// points to four vertices that will
// define a single quad
indices->addValue(z*N+x);
indices->addValue((z+1)*N+x);
indices->addValue((z+1)*N+x+1);
indices->addValue(z*N+x+1);
}
endEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
GeometryPtr geo = Geometry::create();
beginEditCP(geo,
Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask |
Geometry::DlistCacheFieldMask
);
geo->setTypes(type);
geo->setLengths(length);
geo->setIndices(indices);
geo->setPositions(pos);
geo->setNormals(norms);
geo->setMaterial(mat);
//geo->setColors(colors);
geo->setDlistCache(false);
endEditCP(geo,
Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask |
Geometry::DlistCacheFieldMask
);
PointLightPtr pLight = PointLight::create();
NodePtr root = Node::create();
NodePtr water = Node::create();
NodePtr pLightTransformNode = Node::create();
TransformPtr pLightTransform = Transform::create();
NodePtr pLightNode = Node::create();
beginEditCP(pLightNode);
pLightNode->setCore(Group::create());
endEditCP(pLightNode);
Matrix m;
m.setIdentity();
m.setTranslate(50,25,50);
beginEditCP(pLightTransform);
pLightTransform->setMatrix(m);
endEditCP(pLightTransform);
//we add a little spehere that will represent the light source
GeometryPtr sphere = makeSphereGeo(2,2);
SimpleMaterialPtr sm = SimpleMaterial::create();
beginEditCP(sm, SimpleMaterial::DiffuseFieldMask |
SimpleMaterial::LitFieldMask);
{
sm->setLit(false);
sm->setDiffuse(Color3f(1,1,1));
}
endEditCP (sm, SimpleMaterial::DiffuseFieldMask |
SimpleMaterial::LitFieldMask);
beginEditCP(sphere, Geometry::MaterialFieldMask);
{
sphere->setMaterial(sm);
}
endEditCP (sphere, Geometry::MaterialFieldMask);
NodePtr sphereNode = Node::create();
beginEditCP(sphereNode);
sphereNode->setCore(sphere);
endEditCP(sphereNode);
beginEditCP(pLightTransformNode);
pLightTransformNode->setCore(pLightTransform);
pLightTransformNode->addChild(pLightNode);
pLightTransformNode->addChild(sphereNode);
endEditCP(pLightTransformNode);
beginEditCP(pLight);
pLight->setPosition(Pnt3f(0,0,0));
//Attenuation parameters
pLight->setConstantAttenuation(1);
pLight->setLinearAttenuation(0);
pLight->setQuadraticAttenuation(0);
//color information
pLight->setDiffuse(Color4f(1,1,1,1));
pLight->setAmbient(Color4f(0.2,0.2,0.2,1));
pLight->setSpecular(Color4f(1,1,1,1));
//set the beacon
pLight->setBeacon(pLightNode);
endEditCP (pLight);
beginEditCP(water);
water->setCore(geo);
endEditCP(water);
beginEditCP(root);
root->setCore(pLight);
root->addChild(water);
root->addChild(pLightTransformNode);
endEditCP(root);
return root;
}
virtual void keyPressed(const KeyEventPtr e)
{
if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
TutorialWindowEventProducer->closeWindow();
}
if(e->getKey() == KeyEvent::KEY_S && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
TutorialStat = !TutorialStat;
mgr->setStatistics(TutorialStat);
}
//Toggle animation
if(e->getKey() == KeyEvent::KEY_SPACE)
{
if(animationPaused)
animationPaused = false;
else
animationPaused = true;
}
//Toggle bind pose
if(e->getKey() == KeyEvent::KEY_B)
{
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_SHIFT)
{
//Toggle mesh
for(int i(0); i < UnboundGeometries.size(); ++i)
{
if(UnboundGeometries[i]->getTravMask() == 0)
{
beginEditCP(UnboundGeometries[i], Node::TravMaskFieldMask);
UnboundGeometries[i]->setTravMask(1);
endEditCP(UnboundGeometries[i], Node::TravMaskFieldMask);
}
else
{
beginEditCP(UnboundGeometries[i], Node::TravMaskFieldMask);
UnboundGeometries[i]->setTravMask(0);
endEditCP(UnboundGeometries[i], Node::TravMaskFieldMask);
}
}
}
else
{
//Toggle skeleton
for(int i(0); i < SkeletonNodes.size(); ++i)
{
if(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore())->getDrawBindPose() == false)
{
beginEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawBindPoseFieldMask);
SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore())->setDrawBindPose(true);
endEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawBindPoseFieldMask);
}
else
{
beginEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawBindPoseFieldMask);
SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore())->setDrawBindPose(false);
endEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawBindPoseFieldMask);
}
}
}
}
//Toggle current pose
if(e->getKey() == KeyEvent::KEY_P)
{
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_SHIFT)
{
//Toggle mesh
for(int i(0); i < MeshNodes.size(); ++i)
{
if(MeshNodes[i]->getTravMask() == 0)
{
beginEditCP(MeshNodes[i], Node::TravMaskFieldMask);
MeshNodes[i]->setTravMask(1);
endEditCP(MeshNodes[i], Node::TravMaskFieldMask);
}
else
{
beginEditCP(MeshNodes[i], Node::TravMaskFieldMask);
MeshNodes[i]->setTravMask(0);
endEditCP(MeshNodes[i], Node::TravMaskFieldMask);
}
}
}
else
{
//Toggle skeleton
for(int i(0); i < SkeletonNodes.size(); ++i)
{
if(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore())->getDrawPose() == false)
{
beginEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawPoseFieldMask);
SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore())->setDrawPose(true);
endEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawPoseFieldMask);
}
else
{
beginEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawPoseFieldMask);
SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore())->setDrawPose(false);
endEditCP(SkeletonDrawable::Ptr::dcast(SkeletonNodes[i]->getCore()), SkeletonDrawable::DrawPoseFieldMask);
}
}
}
}
//Toggle axes
if(e->getKey() == KeyEvent::KEY_A)
{
if(Axes->getTravMask() == 0)
Axes->setTravMask(1);
else
Axes->setTravMask(0);
}
//Toggle grid
if(e->getKey() == KeyEvent::KEY_G)
{
if(Grid->getTravMask() == 0)
Grid->setTravMask(1);
else
Grid->setTravMask(0);
}
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
TutorialUpdateListener TheTutorialUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(MainWindow);
//Print key command info
std::cout << "\n\nKEY COMMANDS:" << std::endl;
std::cout << "space Play/Pause the animation" << std::endl;
std::cout << "G Show/Hide the grid" << std::endl;
std::cout << "A Show/Hide the axes" << std::endl;
std::cout << "B Show/Hide the bind pose skeleton" << std::endl;
std::cout << "SHIFT-B Show/Hide the bind pose mesh" << std::endl;
std::cout << "P Show/Hide the current pose skeleton" << std::endl;
std::cout << "SHIFT-P Show/Hide the current pose mesh" << std::endl;
std::cout << "CTRL-Q Exit\n\n" << std::endl;
//Setup axes
LineChunkPtr AxesLineChunk = LineChunk::create();
beginEditCP(AxesLineChunk);
AxesLineChunk->setWidth(0.0f);
AxesLineChunk->setSmooth(true);
endEditCP(AxesLineChunk);
//Axes material
ChunkMaterialPtr AxesMaterial = ChunkMaterial::create();
beginEditCP(AxesMaterial, ChunkMaterial::ChunksFieldMask);
AxesMaterial->addChunk(AxesLineChunk);
endEditCP(AxesMaterial, ChunkMaterial::ChunksFieldMask);
//Grid material
ChunkMaterialPtr gridMaterial = ChunkMaterial::create();
beginEditCP(gridMaterial, ChunkMaterial::ChunksFieldMask);
gridMaterial->addChunk(AxesLineChunk);
endEditCP(gridMaterial, ChunkMaterial::ChunksFieldMask);
//Axes should render as lines
GeoPTypesPtr axesType = GeoPTypesUI8::create();
beginEditCP(axesType, GeoPTypesUI8::GeoPropDataFieldMask);
{
axesType->addValue(GL_LINES);
}
endEditCP (axesType, GeoPTypesUI8::GeoPropDataFieldMask);
//Grid type
GeoPTypesPtr gridType = GeoPTypesUI8::create();
beginEditCP(gridType, GeoPTypesUI8::GeoPropDataFieldMask);
{
gridType->addValue(GL_LINES);
}
endEditCP (gridType, GeoPTypesUI8::GeoPropDataFieldMask);
//Axes lens
GeoPLengthsPtr axesLens = GeoPLengthsUI32::create();
beginEditCP(axesLens, GeoPLengthsUI32::GeoPropDataFieldMask);
{
axesLens->addValue(6);
}
endEditCP (axesLens, GeoPLengthsUI32::GeoPropDataFieldMask);
//Grid lens
GeoPLengthsPtr gridLens = GeoPLengthsUI32::create();
beginEditCP(gridLens, GeoPLengthsUI32::GeoPropDataFieldMask);
{
gridLens->addValue(84);
}
endEditCP (gridLens, GeoPLengthsUI32::GeoPropDataFieldMask);
//Axes points
GeoPositions3fPtr axesPnts = GeoPositions3f::create();
beginEditCP(axesPnts, GeoPositions3f::GeoPropDataFieldMask);
{
// X-Axis
axesPnts->addValue(Pnt3f(0, 0, 0));
axesPnts->addValue(Pnt3f(15, 0, 0));
// Y-Axis
axesPnts->addValue(Pnt3f(0, 0, 0));
axesPnts->addValue(Pnt3f(0, 15, 0));
// Z-Axis
axesPnts->addValue(Pnt3f(0, 0, 0));
axesPnts->addValue(Pnt3f(0, 0, 15));
}
endEditCP (axesPnts, GeoPositions3f::GeoPropDataFieldMask);
//Grid points
GeoPositions3fPtr gridPnts = GeoPositions3f::create();
beginEditCP(gridPnts, GeoPositions3f::GeoPropDataFieldMask);
{
float height = 0;
gridPnts->addValue(Pnt3f(-10, height, 0));
if(height == 0)
gridPnts->addValue(Pnt3f(0, height, 0));
else
gridPnts->addValue(Pnt3f(10, height, 0));
gridPnts->addValue(Pnt3f(-10, height, 1));
gridPnts->addValue(Pnt3f(10, height, 1));
gridPnts->addValue(Pnt3f(-10, height, 2));
gridPnts->addValue(Pnt3f(10, height, 2));
gridPnts->addValue(Pnt3f(-10, height, 3));
gridPnts->addValue(Pnt3f(10, height, 3));
gridPnts->addValue(Pnt3f(-10, height, 4));
gridPnts->addValue(Pnt3f(10, height, 4));
gridPnts->addValue(Pnt3f(-10, height, 5));
gridPnts->addValue(Pnt3f(10, height, 5));
gridPnts->addValue(Pnt3f(-10, height, 6));
gridPnts->addValue(Pnt3f(10, height, 6));
gridPnts->addValue(Pnt3f(-10, height, 7));
gridPnts->addValue(Pnt3f(10, height, 7));
gridPnts->addValue(Pnt3f(-10, height, 8));
gridPnts->addValue(Pnt3f(10, height, 8));
gridPnts->addValue(Pnt3f(-10, height, 9));
gridPnts->addValue(Pnt3f(10, height, 9));
gridPnts->addValue(Pnt3f(-10, height, 10));
gridPnts->addValue(Pnt3f(10, height, 10));
gridPnts->addValue(Pnt3f(-10, height, -1));
gridPnts->addValue(Pnt3f(10, height, -1));
gridPnts->addValue(Pnt3f(-10, height, -2));
gridPnts->addValue(Pnt3f(10, height, -2));
gridPnts->addValue(Pnt3f(-10, height, -3));
gridPnts->addValue(Pnt3f(10, height, -3));
gridPnts->addValue(Pnt3f(-10, height, -4));
gridPnts->addValue(Pnt3f(10, height, -4));
gridPnts->addValue(Pnt3f(-10, height, -5));
gridPnts->addValue(Pnt3f(10, height, -5));
gridPnts->addValue(Pnt3f(-10, height, -6));
gridPnts->addValue(Pnt3f(10, height, -6));
gridPnts->addValue(Pnt3f(-10, height, -7));
gridPnts->addValue(Pnt3f(10, height, -7));
gridPnts->addValue(Pnt3f(-10, height, -8));
gridPnts->addValue(Pnt3f(10, height, -8));
gridPnts->addValue(Pnt3f(-10, height, -9));
gridPnts->addValue(Pnt3f(10, height, -9));
gridPnts->addValue(Pnt3f(-10, height, -10));
gridPnts->addValue(Pnt3f(10, height, -10));
gridPnts->addValue(Pnt3f(0, height, -10));
if(height == 0)
gridPnts->addValue(Pnt3f(0, height, 0));
else
gridPnts->addValue(Pnt3f(0, height, 10));
gridPnts->addValue(Pnt3f(1, height, -10));
gridPnts->addValue(Pnt3f(1, height, 10));
gridPnts->addValue(Pnt3f(2, height, -10));
gridPnts->addValue(Pnt3f(2, height, 10));
gridPnts->addValue(Pnt3f(3, height, -10));
gridPnts->addValue(Pnt3f(3, height, 10));
gridPnts->addValue(Pnt3f(4, height, -10));
gridPnts->addValue(Pnt3f(4, height, 10));
gridPnts->addValue(Pnt3f(5, height, -10));
gridPnts->addValue(Pnt3f(5, height, 10));
gridPnts->addValue(Pnt3f(6, height, -10));
gridPnts->addValue(Pnt3f(6, height, 10));
gridPnts->addValue(Pnt3f(7, height, -10));
gridPnts->addValue(Pnt3f(7, height, 10));
gridPnts->addValue(Pnt3f(8, height, -10));
gridPnts->addValue(Pnt3f(8, height, 10));
gridPnts->addValue(Pnt3f(9, height, -10));
gridPnts->addValue(Pnt3f(9, height, 10));
gridPnts->addValue(Pnt3f(10, height, -10));
gridPnts->addValue(Pnt3f(10, height, 10));
gridPnts->addValue(Pnt3f(-1, height, -10));
gridPnts->addValue(Pnt3f(-1, height, 10));
gridPnts->addValue(Pnt3f(-2, height, -10));
gridPnts->addValue(Pnt3f(-2, height, 10));
gridPnts->addValue(Pnt3f(-3, height, -10));
gridPnts->addValue(Pnt3f(-3, height, 10));
gridPnts->addValue(Pnt3f(-4, height, -10));
gridPnts->addValue(Pnt3f(-4, height, 10));
gridPnts->addValue(Pnt3f(-5, height, -10));
gridPnts->addValue(Pnt3f(-5, height, 10));
gridPnts->addValue(Pnt3f(-6, height, -10));
gridPnts->addValue(Pnt3f(-6, height, 10));
gridPnts->addValue(Pnt3f(-7, height, -10));
gridPnts->addValue(Pnt3f(-7, height, 10));
gridPnts->addValue(Pnt3f(-8, height, -10));
gridPnts->addValue(Pnt3f(-8, height, 10));
gridPnts->addValue(Pnt3f(-9, height, -10));
gridPnts->addValue(Pnt3f(-9, height, 10));
gridPnts->addValue(Pnt3f(-10, height, -10));
gridPnts->addValue(Pnt3f(-10, height, 10));
}
endEditCP (gridPnts, GeoPositions3f::GeoPropDataFieldMask);
//Axes normals
GeoNormals3fPtr axesNorms = GeoNormals3f::create();
beginEditCP(axesNorms, GeoNormals3f::GeoPropDataFieldMask);
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 1.0,0.0,0.0));
axesNorms->addValue(Vec3f( 1.0,0.0,0.0));
endEditCP(axesNorms, GeoNormals3f::GeoPropDataFieldMask);
//Grid normals
GeoNormals3fPtr gridNorms = GeoNormals3f::create();
beginEditCP(gridNorms, GeoNormals3f::GeoPropDataFieldMask);
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
endEditCP(gridNorms, GeoNormals3f::GeoPropDataFieldMask);
//Axes colors
GeoColors3fPtr axesColors = GeoColors3f::create();
beginEditCP(axesColors, GeoColors3f::GeoPropDataFieldMask);
//X-Axis = Red
axesColors->addValue(Color3f( 1.0,0.0,0.0));
axesColors->addValue(Color3f( 1.0,0.0,0.0));
//Y-Axis = Green
axesColors->addValue(Color3f( 0.0,1.0,0.0));
axesColors->addValue(Color3f( 0.0,1.0,0.0));
//Z-Axis = Blue
axesColors->addValue(Color3f( 0.0,0.0,1.0));
axesColors->addValue(Color3f( 0.0,0.0,1.0));
endEditCP(axesColors, GeoColors3f::GeoPropDataFieldMask);
//Grid gridColors
GeoColors3fPtr gridColors = GeoColors3f::create();
beginEditCP(gridColors, GeoColors3f::GeoPropDataFieldMask);
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
endEditCP(gridColors, GeoColors3f::GeoPropDataFieldMask);
//Create axes geometry
GeometryPtr axesGeo = Geometry::create();
beginEditCP(axesGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask);
{
axesGeo->setTypes (axesType);
axesGeo->setLengths (axesLens);
axesGeo->setPositions(axesPnts);
axesGeo->setNormals(axesNorms);
axesGeo->setColors(axesColors);
// assign a material to the geometry to make it visible. The details
// of materials are defined later.
axesGeo->setMaterial(AxesMaterial);
}
endEditCP (axesGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask );
//Create grid geometry
GeometryPtr gridGeo = Geometry::create();
beginEditCP(gridGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask);
{
gridGeo->setTypes (gridType);
gridGeo->setLengths (gridLens);
gridGeo->setPositions(gridPnts);
gridGeo->setNormals(gridNorms);
gridGeo->setColors(gridColors);
// assign a material to the geometry to make it visible. The details
// of materials are defined later.
gridGeo->setMaterial(AxesMaterial);
}
endEditCP (gridGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask );
//Create unbound geometry Node
Axes = osg::Node::create();
beginEditCP(Axes, Node::CoreFieldMask);
Axes->setCore(axesGeo);
endEditCP(Axes, Node::CoreFieldMask);
//Create unbound geometry Node
Grid = osg::Node::create();
beginEditCP(Grid, Node::CoreFieldMask);
Grid->setCore(gridGeo);
endEditCP(Grid, Node::CoreFieldMask);
//Import scene from an XML file
ChunkMaterialPtr ExampleMaterial;
std::vector<SkeletonPtr> SkeletonPtrs;
std::vector<SkeletonBlendedGeometryPtr> SkeletonBlendedGeometryPtrs;
std::vector<GeometryPtr> GeometryPtrs;
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(Path("./Data/21SceneFromMaya.xml"));
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
if( (*Itor)->getType() == (ChunkMaterial::getClassType()))
{
//Set ExampleMaterial to the ChunkMaterial we just read in
ExampleMaterial = (ChunkMaterial::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Skeleton::getClassType()))
{
//Add the skeleton we just read in to SkeletonPtrs
SkeletonPtrs.push_back(Skeleton::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (SkeletonBlendedGeometry::getClassType()))
{
//Add the SkeletonBlendedGeometry we just read in to SkeletonBlendedGeometryPtrs
SkeletonBlendedGeometryPtrs.push_back(SkeletonBlendedGeometry::Ptr::dcast(*Itor));
}
if( (*Itor)->getType().isDerivedFrom(SkeletonAnimation::getClassType()))
{
//Set TheSkeletonAnimation to the Animation we just read in
TheSkeletonAnimation = (Animation::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Geometry::getClassType()))
{
//Add the Geometry we just read in to GeometryPtrs
GeometryPtrs.push_back(Geometry::Ptr::dcast(*Itor));
}
}
//Create unbound geometry Node (to show the mesh in its bind pose)
for (int i(0); i < GeometryPtrs.size(); ++i)
{
NodePtr UnboundGeometry = Node::create();
beginEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometry->setCore(GeometryPtrs[i]);
UnboundGeometry->setTravMask(0);
endEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometries.push_back(UnboundGeometry);
}
//Create skeleton nodes
for (int i(0); i < SkeletonPtrs.size(); ++i)
{
//SkeletonDrawer
SkeletonDrawablePtr ExampleSkeletonDrawable = osg::SkeletonDrawable::create();
beginEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask);
ExampleSkeletonDrawable->setSkeleton(SkeletonPtrs[i]);
ExampleSkeletonDrawable->setMaterial(AxesMaterial);
ExampleSkeletonDrawable->setDrawPose(true); //By default we draw the current skeleton
ExampleSkeletonDrawable->setPoseColor(Color4f(1.0, 0.0, 1.0, 1.0)); //Set color of current skeleton
ExampleSkeletonDrawable->setDrawBindPose(false); //By default we don't draw the bind pose skeleton
ExampleSkeletonDrawable->setBindPoseColor(Color4f(1.0, 1.0, 0.0, 1.0)); //Set color of bind pose skeleton
endEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask);
//Skeleton Node
NodePtr SkeletonNode = osg::Node::create();
beginEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNode->setCore(ExampleSkeletonDrawable);
endEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNodes.push_back(SkeletonNode);
}
//Create skeleton blended geometry nodes
for (int i(0); i < SkeletonBlendedGeometryPtrs.size(); ++i)
{
NodePtr MeshNode = osg::Node::create();
beginEditCP(MeshNode, Node::CoreFieldMask);
MeshNode->setCore(SkeletonBlendedGeometryPtrs[i]);
endEditCP(MeshNode, Node::CoreFieldMask);
MeshNodes.push_back(MeshNode);
}
//Create Animation Advancer
TheAnimationAdvancer = osg::ElapsedTimeAnimationAdvancer::create();
osg::beginEditCP(TheAnimationAdvancer);
osg::ElapsedTimeAnimationAdvancer::Ptr::dcast(TheAnimationAdvancer)->setStartTime( 0.0 );
osg::beginEditCP(TheAnimationAdvancer);
//Add nodes to scene
NodePtr scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(Axes);
scene->addChild(Grid);
//Add all imported skeletons to scene
for (int i(0); i < SkeletonNodes.size(); ++i)
{
scene->addChild(SkeletonNodes[i]);
}
//Add all imported geometries to scene
for (int i(0); i < UnboundGeometries.size(); ++i)
{
scene->addChild(UnboundGeometries[i]);
}
//Add all imported SkeletonBlendedGeometries to scene
for (int i(0); i < MeshNodes.size(); ++i)
{
scene->addChild(MeshNodes[i]);
}
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
mgr->setRoot(scene);
//By default the animation is not paused
animationPaused = false;
// Show the whole Scene
mgr->showAll();
TheAnimationAdvancer->start();
//Show window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"21LoadXMLSceneFromMaya");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodePtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodePtr scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(TorusGeometryNode);
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Create the Graphics
GraphicsPtr TutorialGraphics = osg::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Create InventoryItems
ExampleInventory = Inventory::create();
GenericInventoryItemPtr ExampleItem1 = GenericInventoryItem::create();
GenericInventoryItemPtr ExampleItem2 = GenericInventoryItem::create();
GenericInventoryItemPtr ExampleItem3 = GenericInventoryItem::create();
GenericInventoryItemPtr ExampleItem4 = GenericInventoryItem::create();
GenericInventoryItemPtr ExampleItem5 = GenericInventoryItem::create();
GenericInventoryItemPtr ExampleItem6 = GenericInventoryItem::create();
GenericInventoryItemPtr ExampleItem7 = GenericInventoryItem::create();
beginEditCP(ExampleItem1, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem1->setName(std::string("David K"));
ExampleItem1->setDetails(std::string("Major: Human Computer Interaction \nDegree: PhD \nDepartment: Computer Science \nCollege: LAS"));
endEditCP(ExampleItem1, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
beginEditCP(ExampleItem2, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem2->setName(std::string("Eve W"));
ExampleItem2->setDetails(std::string("Department: Genetics Development and Cell Biology\n\nCollege: Agriculture"));
endEditCP(ExampleItem2, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
beginEditCP(ExampleItem3, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem3->setName(std::string("Will S"));
ExampleItem3->setDetails(std::string("Major: Art And Design\nDegree: BFA\nDepartment: Art and Design\nCollege: Design"));
endEditCP(ExampleItem3, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
beginEditCP(ExampleItem4, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem4->setName(std::string("Eric L"));
ExampleItem4->setDetails(std::string("Major: Software Engineering\nDegree: BS\nDepartment: Software Engineering\nCollege: Engineering"));
endEditCP(ExampleItem4, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
beginEditCP(ExampleItem5, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem5->setName(std::string("Jeffery F"));
ExampleItem5->setDetails(std::string("Major: Integrated Studio Arts\nDegree: BFA\nDepartment: Art and Design\nCollege: Design"));
endEditCP(ExampleItem5, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
beginEditCP(ExampleItem6, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem6->setName(std::string("Tao L"));
ExampleItem6->setDetails(std::string("Major: Computer Engineering\nDegree: PhD\nDepartment: Computer Engineering\nCollege: Engineering"));
endEditCP(ExampleItem6, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
beginEditCP(ExampleItem7, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleItem7->setName(std::string("Daniel G"));
ExampleItem7->setDetails(std::string("Major: Computer Engineering\nDegree: BS\nDepartment: Computer Engineering\nCollege: Engineering"));
endEditCP(ExampleItem7, InventoryItem::NameFieldMask | GenericInventoryItem::DetailsFieldMask);
ExampleInventory->addItem(ExampleItem1);
ExampleInventory->addItem(ExampleItem2);
ExampleInventory->addItem(ExampleItem3);
ExampleInventory->addItem(ExampleItem4);
ExampleInventory->addItem(ExampleItem5);
ExampleInventory->addItem(ExampleItem6);
ExampleInventory->addItem(ExampleItem7);
/******************************************************
Create a List. A List has several
parts to it:
-ListModel: Contains the data which is to be
displayed in the List. Data is added
as shown below
-ListCellRenderer: Creates the Components to
be used within the List (the default
setting is to create Labels using
the desired text).
-ListSelectionModel: Determines how
the List may be selected.
To add values to the list:
First, create SFStrings and use the
.setValue("Value") function to set their
values. Then, use the .pushBack(&SFStringName)
to add them to the List.
Next, create the CellRenderer and ListSelectionModel
defaults.
Finally, actually create the List. Set
its Model, CellRenderer, and SelectionModel
as shown below. Finally, choose the
type of display for the List (choices outlined
below).
******************************************************/
// Add data to it
ExampleListModel = InventoryListModel::create();
beginEditCP(ExampleListModel, InventoryListModel::CurrentInventoryFieldMask);
ExampleListModel->setCurrentInventory(ExampleInventory);
endEditCP(ExampleListModel, InventoryListModel::CurrentInventoryFieldMask);
/******************************************************
Create ListCellRenderer and
ListSelectionModel. Most
often the defauls will be used.
Note: the ListSelectionModel was
created above and is referenced
by the ActionListeners.
******************************************************/
/******************************************************
Create List itself and assign its
Model, CellRenderer, and SelectionModel
to it.
-setOrientation(ENUM): Determine the
Layout of the cells (Horizontal
or Vertical). Takes List::VERTICAL_ORIENTATION
and List::HORIZONTAL_ORIENTATION arguments.
******************************************************/
ExampleList = List::create();
beginEditCP(ExampleList, List::PreferredSizeFieldMask | List::OrientationFieldMask | List::ModelFieldMask);
ExampleList->setPreferredSize(Vec2f(200, 300));
ExampleList->setOrientation(List::VERTICAL_ORIENTATION);
//ExampleList->setOrientation(List::HORIZONTAL_ORIENTATION);
ExampleList->setModel(ExampleListModel);
endEditCP(ExampleList, List::PreferredSizeFieldMask | List::OrientationFieldMask | List::ModelFieldMask);
ExampleList->setSelectionModel(ExampleListSelectionModel);
InventoryListListener TheInventoryListListener;
ExampleList->getSelectionModel()->addListSelectionListener(&TheInventoryListListener);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerPtr MainInternalWindowBackground = osg::ColorLayer::create();
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
/******************************************************
Determine the SelectionModel
-SINGLE_SELECTION lets you select ONE item
via a single mouse click
-SINGLE_INTERVAL_SELECTION lets you select
one interval via mouse and SHIFT key
-MULTIPLE_INTERVAL_SELECTION lets you select
via mouse, and SHIFT and CONTRL keys
Note: this tutorial is currently set up
to allow for this to be changed via
TogggleButtons with ActionListeners attached
to them so this code is commented out.
******************************************************/
//SelectionModel.setMode(DefaultListSelectionModel::SINGLE_SELECTION);
//SelectionModel.setMode(DefaultListSelectionModel::SINGLE_INTERVAL_SELECTION);
//SelectionModel.setMode(DefaultListSelectionModel::MULTIPLE_INTERVAL_SELECTION);
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
ScrollPanelPtr ExampleScrollPanel = ScrollPanel::create();
beginEditCP(ExampleScrollPanel, ScrollPanel::PreferredSizeFieldMask | ScrollPanel::HorizontalResizePolicyFieldMask | ScrollPanel::BackgroundFieldMask);
ExampleScrollPanel->setPreferredSize(Vec2f(200,100));
ExampleScrollPanel->setBackgrounds(MainInternalWindowBackground);
ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
//ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
endEditCP(ExampleScrollPanel, ScrollPanel::PreferredSizeFieldMask | ScrollPanel::HorizontalResizePolicyFieldMask | ScrollPanel::BackgroundFieldMask);
ExampleScrollPanel->setViewComponent(ExampleList);
// Create MainFramelayout
FlowLayoutPtr MainInternalWindowLayout = osg::FlowLayout::create();
beginEditCP(MainInternalWindowLayout, FlowLayout::OrientationFieldMask | FlowLayout::MajorAxisAlignmentFieldMask | FlowLayout::MinorAxisAlignmentFieldMask);
MainInternalWindowLayout->setOrientation(FlowLayout::HORIZONTAL_ORIENTATION);
MainInternalWindowLayout->setMajorAxisAlignment(0.5f);
MainInternalWindowLayout->setMinorAxisAlignment(0.5f);
endEditCP(MainInternalWindowLayout, FlowLayout::OrientationFieldMask | FlowLayout::MajorAxisAlignmentFieldMask | FlowLayout::MinorAxisAlignmentFieldMask);
DetailsWindow = osg::TextArea::create();
beginEditCP(DetailsWindow, TextArea::PreferredSizeFieldMask);
DetailsWindow->setPreferredSize(Pnt2f(200,100));
DetailsWindow->setMinSize(Vec2f(200,100));
endEditCP(DetailsWindow, TextArea::PreferredSizeFieldMask);
InternalWindowPtr MainInternalWindow = osg::InternalWindow::create();
beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
MainInternalWindow->getChildren().push_back(ExampleScrollPanel);
MainInternalWindow->getChildren().push_back(DetailsWindow);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.7f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
// Create the Drawing Surface
UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create();
beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer);
endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundPtr TutorialUIForeground = osg::UIForeground::create();
beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(MainWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
TutorialViewport->getForegrounds().push_back(TutorialUIForeground);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
// Show the whole Scene
mgr->showAll();
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"09Inventory");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
NodePtr createScenegraph(){
// the scene must be created here
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
wMesh[x][z] = 0;
// GeoPTypes will define the types of primitives to be used
GeoPTypesPtr type = GeoPTypesUI8::create();
beginEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
// we want to use quads ONLY
type->addValue(GL_QUADS);
endEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
// GeoPLength will define the number of vertices of
// the used primitives
GeoPLengthsPtr length = GeoPLengthsUI32::create();
beginEditCP(length, GeoPLengthsUI32::GeoPropDataFieldMask);
// the length of our quads is four ;-)
length->addValue((N-1)*(N-1)*4);
endEditCP(length, GeoPLengthsUI32::GeoPropDataFieldMask);
// GeoPositions3f stores the positions of all vertices used in
// this specific geometry core
GeoPositions3fPtr pos = GeoPositions3f::create();
beginEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
// here they all come
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
pos->addValue(Pnt3f(x, wMesh[x][z], z));
endEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
//GeoColors3f stores all color values that will be used
GeoColors3fPtr colors = GeoColors3f::create();
beginEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
colors->addValue(Color3f(0,0,1));
endEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
GeoNormals3fPtr norms = GeoNormals3f::create();
beginEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
// As initially all heights are set to zero thus yielding a plane,
// we set all normals to (0,1,0) parallel to the y-axis
norms->addValue(Vec3f(0,1,0));
endEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
SimpleMaterialPtr mat = SimpleMaterial::create();
// GeoIndicesUI32 points to all relevant data used by the
// provided primitives
GeoIndicesUI32Ptr indices = GeoIndicesUI32::create();
beginEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
for (int x = 0; x < N-1; x++)
for (int z = 0; z < N-1; z++){
// points to four vertices that will
// define a single quad
indices->addValue(z*N+x);
indices->addValue((z+1)*N+x);
indices->addValue((z+1)*N+x+1);
indices->addValue(z*N+x+1);
}
endEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
GeometryPtr geo = Geometry::create();
beginEditCP(geo,
Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask
);
geo->setTypes(type);
geo->setLengths(length);
geo->setIndices(indices);
geo->setPositions(pos);
geo->setNormals(norms);
geo->setMaterial(mat);
geo->setColors(colors);
endEditCP(geo,
Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask
);
NodePtr root = Node::create();
beginEditCP(root);
root->setCore(geo);
endEditCP(root);
return root;
}
