/***************************************************************
* Function: createText()
***************************************************************/
Geode *CAVEGroupReferenceAxis::createText3D(osgText::Text3D **text)
{
Geode *textGeode = new Geode;
*text = new osgText::Text3D;
textGeode->addDrawable(*text);
(*text)->setFont(CAVEGeode::getDataDir() + "Fonts/TN.ttf");
(*text)->setCharacterSize(gCharSize, 0.7);
(*text)->setCharacterDepth(gCharDepth);
(*text)->setPosition(Vec3(0, 0, 0));
(*text)->setAlignment(osgText::Text3D::CENTER_BOTTOM);
(*text)->setDrawMode(osgText::Text3D::TEXT);
(*text)->setAxisAlignment(osgText::Text3D::XZ_PLANE);
(*text)->setRenderMode(osgText::Text3D::PER_GLYPH);
(*text)->setText("");
Material *material = new Material;
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(0, 1, 0, 1));
material->setAmbient(Material::FRONT_AND_BACK, Vec4(0, 1, 0, 1));
material->setAlpha(Material::FRONT_AND_BACK, 1.0f);
StateSet *stateset = textGeode->getOrCreateStateSet();
stateset->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON);
stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
return textGeode;
}
/***************************************************************
* Function: applyColorTexture()
***************************************************************/
void CAVEGeode::applyColorTexture(const Vec3 &diffuse, const Vec3 &specular, const float &alpha, const string &texFilename)
{
StateSet *stateset = getOrCreateStateSet();
/* update material parameters */
Material *material = dynamic_cast <Material*> (stateset->getAttribute(StateAttribute::MATERIAL));
if (!material)
material = new Material;
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(diffuse, 1.f));
material->setSpecular(Material::FRONT_AND_BACK, Vec4(specular, 1.f));
material->setAlpha(Material::FRONT_AND_BACK, alpha);
stateset->setAttributeAndModes(material, StateAttribute::ON);
/* update texture image */
Texture2D *texture = dynamic_cast <Texture2D*> (stateset->getAttribute(StateAttribute::TEXTURE));
if (!texture)
texture = new Texture2D;
Image* texImage = osgDB::readImageFile(texFilename);
texture->setImage(texImage);
texture->setWrap(Texture::WRAP_S,Texture::REPEAT);
texture->setWrap(Texture::WRAP_T,Texture::REPEAT);
texture->setDataVariance(Object::DYNAMIC);
stateset->setTextureAttributeAndModes(0, texture, StateAttribute::ON);
stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | osg::StateAttribute::ON );
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
/* update of color & texture properties */
mDiffuse = diffuse;
mSpecular = specular;
mAlpha = alpha;
mTexFilename = texFilename;
}
// Constructor: CAVEGeodeSnapWireframe
CAVEGeodeSnapWireframe::CAVEGeodeSnapWireframe()
{
// unit grid size 'mSnappingUnitDist' will inherit the default value 'gSnappingUnitDist' unless modified
mSnappingUnitDist = gSnappingUnitDist;
mInitPosition = Vec3(0, 0, 0);
mScaleVect = Vec3(1, 1, 1);
mDiagonalVect = Vec3(1, 1, 1);
mBaseGeometry = new Geometry();
mSnapwireGeometry = new Geometry();
addDrawable(mBaseGeometry);
addDrawable(mSnapwireGeometry);
Material* material = new Material;
material->setAmbient(Material::FRONT_AND_BACK, Vec4(0.0, 1.0, 0.0, 1.0));
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1.0, 1.0, 0.0, 1.0));
material->setSpecular(Material::FRONT_AND_BACK, osg::Vec4( 1.f, 1.f, 1.f, 1.0f));
material->setAlpha(Material::FRONT_AND_BACK, 0.f);
StateSet* stateset = new StateSet();
stateset->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON);
stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | osg::StateAttribute::ON );
stateset->setMode(GL_LIGHTING, StateAttribute::OVERRIDE | StateAttribute::ON );
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
setStateSet(stateset);
}
//Constructor
CAVEGeodeShape::CAVEGeodeShape(const Type &typ, const Vec3 &initVect, const Vec3 &sVect):
mCenterVect(Vec3(0, 0, 0)), mNumVertices(0), mNumNormals(0), mNumTexcoords(0),
mDOCollectorIndex(-1)
{
mVertexArray = new Vec3Array;
mNormalArray = new Vec3Array;
mUDirArray = new Vec3Array;
mVDirArray = new Vec3Array;
mTexcoordArray = new Vec2Array;
mVertexMaskingVector.clear();
switch (typ)
{
case BOX: initGeometryBox(initVect, sVect); break;
case CYLINDER: initGeometryCylinder(initVect, sVect); break;
default: break;
}
/* texture coordinates is associated with size of the geometry */
Image* img = osgDB::readImageFile(CAVEGeode::getDataDir() + "Textures/White.JPG");
Texture2D* texture = new Texture2D(img);
texture->setWrap(Texture::WRAP_S, Texture::MIRROR);
texture->setWrap(Texture::WRAP_T, Texture::MIRROR);
Material *material = new Material;
material->setSpecular(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
material->setAlpha(Material::FRONT_AND_BACK, 1.0f);
StateSet *stateset = getOrCreateStateSet();
stateset->setTextureAttributeAndModes(0, texture, StateAttribute::ON);
stateset->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON);
stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
}
int main()
{
using namespace osg;
// // read Neuron Obj file from desk
// ref_ptr<Node> model = osgDB::readNodeFile( "Neuron.obj" );
// model->setName("Neuron");
ref_ptr<MatrixTransform> mt = new MatrixTransform;
// mt->addChild( model.get() );
myModel model1 ("Neuron.obj","Neuron");
mt = model1.getMatrix();
osgUtil::SmoothingVisitor sv;
model->accept( sv );
// BlendFunc
ref_ptr<BlendFunc> blendFunc = new BlendFunc;
blendFunc->setFunction( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
StateSet* stateset = model->getOrCreateStateSet();
stateset->setAttributeAndModes( blendFunc );
// Material
ref_ptr<StateSet> nodess = model->getOrCreateStateSet();
ref_ptr<Material> nodeMaterial = new Material;
nodeMaterial->setDiffuse( Material::FRONT , Vec4(0.5f,0.5f,0.5f,1.0f));
nodeMaterial->setAmbient( Material::FRONT , Vec4(2.0f,0.0f,0.0f,1.0f) );
nodeMaterial->setTransparency(Material::FRONT , 0.25f);
//nodeMaterial->setAlpha( Material::FRONT , 0.5f );
nodess->setAttribute( nodeMaterial.get() );
// create camera
ref_ptr<Camera> camera = new Camera();
camera->setClearMask( GL_DEPTH_BUFFER_BIT );
camera->setRenderOrder( Camera::POST_RENDER );
camera->setReferenceFrame( Camera::ABSOLUTE_RF );
camera->setViewMatrixAsLookAt( Vec3d(-1.0f,0.0f,0.0f) , Vec3d(0.0,0.0,0.0) , Vec3d(0.0f,1.0f,0.0f) );
// create root node
ref_ptr<Group> root = new Group;
// add child to it
root->addChild( mt.get() );
root->addChild( camera.get() );
ref_ptr<PickHandler> picker = new PickHandler;
root->addChild( picker->getOrCreateSelectionBox() );
ref_ptr<ModelController> ctrler = new ModelController( mt.get() );
// create viewer to display data
osgViewer::Viewer viewer;
viewer.addEventHandler( picker.get() );
viewer.addEventHandler( ctrler.get() );
viewer.setSceneData( root.get() );
return viewer.run();
}
/***************************************************************
* Function: applyAlpha()
***************************************************************/
void CAVEGeode::applyAlpha(const float &alpha)
{
StateSet *stateset = getOrCreateStateSet();
/* update material parameters */
Material *material = dynamic_cast <Material*> (stateset->getAttribute(StateAttribute::MATERIAL));
if (!material) material = new Material;
material->setAlpha(Material::FRONT_AND_BACK, alpha);
stateset->setAttributeAndModes(material, StateAttribute::ON);
/* update alpha value */
mAlpha = alpha;
}
void Wire::coverStuff(void)
{
//start of design functions
geom = new osg::Geometry();
geode = new Geode();
geode->setNodeMask(geode->getNodeMask() & ~(Isect::Walk | Isect::Intersection | Isect::Collision | Isect::Touch | Isect::Pick));
geom->setUseDisplayList(true);
geom->setUseVertexBufferObjects(false);
geode->addDrawable(geom.get());
vert = new Vec3Array;
primitives = new DrawArrayLengths(PrimitiveSet::POLYGON);
indices = new UShortArray();
normals = new Vec3Array;
//cindices = new UShortArray() //colors = new Vec4Array();
StateSet *geoState = geom->getOrCreateStateSet();
this->createGeom();
geom->setVertexArray(vert.get());
geom->setVertexIndices(indices.get());
geom->setNormalIndices(indices.get());
geom->setNormalArray(normals.get());
//geom->setColorIndices(cindices.get());
//geom->setColorArray(colors.get());
geom->addPrimitiveSet(primitives.get());
geoState = geode->getOrCreateStateSet();
if (globalmtl.get() == NULL)
{
globalmtl = new Material;
globalmtl->ref();
globalmtl->setColorMode(Material::OFF);
globalmtl->setAmbient(Material::FRONT_AND_BACK, Vec4(0.2f, 0.2f, 0.2f, 1.0));
globalmtl->setDiffuse(Material::FRONT_AND_BACK, Vec4(0.9f, 0.9f, 0.9f, 1.0));
globalmtl->setSpecular(Material::FRONT_AND_BACK, Vec4(0.9f, 0.9f, 0.9f, 1.0));
globalmtl->setEmission(Material::FRONT_AND_BACK, Vec4(0.0f, 0.0f, 0.0f, 1.0));
globalmtl->setShininess(Material::FRONT_AND_BACK, 10.0f);
}
geoState->setRenderingHint(StateSet::OPAQUE_BIN);
geoState->setMode(GL_BLEND, StateAttribute::OFF);
geoState->setAttributeAndModes(globalmtl.get(), StateAttribute::ON);
//char name[1000];
//sprintf(name,"Wire %d", this->getID());
coVRShader *SolidClipping = coVRShaderList::instance()->get("SolidClipping");
if (SolidClipping)
SolidClipping->apply(geode, geom);
geode->setName(this->getName());
this->coverGroup->addChild(geode.get());
//end of design functions
}
// Create and return a StateSet appropriate for performing an occlusion
// query test (disable lighting, texture mapping, etc). Probably some
// room for improvement here. Could disable shaders, for example.
StateSet* initOQState()
{
StateSet* state = new StateSet;
// TBD Possible bug, need to allow user to set render bin number.
state->setRenderBinDetails( 9, "RenderBin" );
state->setMode( GL_LIGHTING, StateAttribute::OFF | StateAttribute::PROTECTED);
state->setTextureMode( 0, GL_TEXTURE_2D, StateAttribute::OFF | StateAttribute::PROTECTED);
state->setMode( GL_CULL_FACE, StateAttribute::ON | StateAttribute::PROTECTED);
ColorMask* cm = new ColorMask( false, false, false, false );
state->setAttributeAndModes( cm, StateAttribute::ON | StateAttribute::PROTECTED);
Depth* d = new Depth( Depth::LEQUAL, 0.f, 1.f, false );
state->setAttributeAndModes( d, StateAttribute::ON | StateAttribute::PROTECTED);
PolygonMode* pm = new PolygonMode( PolygonMode::FRONT_AND_BACK, PolygonMode::FILL );
state->setAttributeAndModes( pm, StateAttribute::ON | StateAttribute::PROTECTED);
PolygonOffset* po = new PolygonOffset( -1., -1. );
state->setAttributeAndModes( po, StateAttribute::ON | StateAttribute::PROTECTED);
return state;
}
//Constructor: CAVEGeodeSnapSolidshape
CAVEGeodeSnapSolidshape::CAVEGeodeSnapSolidshape(): mSnappingUnitDist(0.0f)
{
mInitPosition = Vec3(0, 0, 0);
mScaleVect = Vec3(1, 1, 1);
Material* material = new Material;
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1.0f, 0.5f, 0.0f, 1.0f));
material->setSpecular(Material::FRONT_AND_BACK, osg::Vec4( 1.0f, 0.5f, 0.0f, 1.0f));
material->setAlpha(Material::FRONT, 0.8f);
StateSet* stateset = new StateSet();
stateset->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON);
stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | osg::StateAttribute::ON );
stateset->setMode(GL_LIGHTING, StateAttribute::OVERRIDE | StateAttribute::ON );
stateset->setRenderingHint(StateSet::TRANSPARENT_BIN);
setStateSet(stateset);
}
/***************************************************************
* Function: setVSParamountPreviewHighlight()
***************************************************************/
void VirtualScenicHandler::setVSParamountPreviewHighlight(bool flag, Geode *paintGeode)
{
StateSet *stateset = paintGeode->getOrCreateStateSet();
Material *material = dynamic_cast<Material*> (stateset->getAttribute(StateAttribute::MATERIAL));
if (!material)
material = new Material;
if (flag)
{
material->setAlpha(Material::FRONT_AND_BACK, 0.5f);
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(0.3, 1.0, 0.3, 1.0));
material->setSpecular(Material::FRONT_AND_BACK, Vec4(0.3, 1.0, 0.3, 1.0));
}
else
{
material->setAlpha(Material::FRONT_AND_BACK, 1.0f);
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
material->setSpecular(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
}
stateset->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON);
}
/***************************************************************
* Function: ANIMCreateSinglePageGeodeAnimation()
***************************************************************/
void ANIMCreateSinglePageGeodeAnimation(const string& texfilename, Geode **flipUpGeode, Geode **flipDownGeode,
AnimationPathCallback **flipUpCallback, AnimationPathCallback **flipDownCallback)
{
/* coordinates of page object */
Vec3 topleft = Vec3(-0.19, 0, 0);
Vec3 bottomleft = Vec3(-0.19, 0, -0.28);
Vec3 bottomright = Vec3( 0.19, 0, -0.28);
Vec3 topright = Vec3( 0.19, 0, 0);
Vec3 start = Vec3(0, -0.004, 0);
Vec3 end = Vec3(0, 0.008, 0);
float pageH = 0.28, pageW = 0.38;
/* create page pain geometry */
*flipUpGeode = new Geode;
*flipDownGeode = new Geode;
Geometry *pageGeometry = new Geometry();
Vec3Array* vertices = new Vec3Array;
Vec2Array* texcoords = new Vec2Array(4);
Vec3Array* normals = new Vec3Array;
vertices->push_back(topleft); (*texcoords)[0].set(0, 1);
vertices->push_back(bottomleft); (*texcoords)[1].set(0, 0);
vertices->push_back(bottomright); (*texcoords)[2].set(1, 0);
vertices->push_back(topright); (*texcoords)[3].set(1, 1);
for (int i = 0; i < 4; i++)
{
normals->push_back(Vec3(0, -1, 0));
}
DrawElementsUInt* rectangle = new DrawElementsUInt(PrimitiveSet::POLYGON, 0);
rectangle->push_back(0); rectangle->push_back(1);
rectangle->push_back(2); rectangle->push_back(3);
pageGeometry->addPrimitiveSet(rectangle);
pageGeometry->setVertexArray(vertices);
pageGeometry->setTexCoordArray(0, texcoords);
pageGeometry->setNormalArray(normals);
pageGeometry->setNormalBinding(Geometry::BIND_PER_VERTEX);
(*flipUpGeode)->addDrawable(pageGeometry);
(*flipDownGeode)->addDrawable(pageGeometry);
/* apply image textures to page geodes */
Image* imgFloorplan = osgDB::readImageFile(texfilename);
int imgW = imgFloorplan->s();
int imgH = imgFloorplan->t();
Texture2D* texFloorplan = new Texture2D(imgFloorplan);
texFloorplan->setWrap(Texture::WRAP_S, Texture::CLAMP);
texFloorplan->setWrap(Texture::WRAP_T, Texture::CLAMP);
float imgRatio = (float) imgW / imgH;
float pageRatio = pageW / pageH;
if (imgRatio <= pageRatio)
{
(*texcoords)[0].set((1.0 - pageRatio / imgRatio) * 0.5, 1);
(*texcoords)[1].set((1.0 - pageRatio / imgRatio) * 0.5, 0);
(*texcoords)[2].set((1.0 + pageRatio / imgRatio) * 0.5, 0);
(*texcoords)[3].set((1.0 + pageRatio / imgRatio) * 0.5, 1);
}
else
{
(*texcoords)[0].set(0, (1.0 + imgRatio / pageRatio) * 0.5);
(*texcoords)[1].set(0, (1.0 - imgRatio / pageRatio) * 0.5);
(*texcoords)[2].set(1, (1.0 - imgRatio / pageRatio) * 0.5);
(*texcoords)[3].set(1, (1.0 + imgRatio / pageRatio) * 0.5);
}
Material *transmaterial = new Material;
transmaterial->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
transmaterial->setAlpha(Material::FRONT_AND_BACK, 0.8f);
Material *solidmaterial = new Material;
solidmaterial->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
solidmaterial->setAlpha(Material::FRONT_AND_BACK, 1.0f);
StateSet *flipUpStateSet = (*flipUpGeode)->getOrCreateStateSet();
flipUpStateSet->setTextureAttributeAndModes(0, texFloorplan, StateAttribute::ON);
flipUpStateSet->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
flipUpStateSet->setRenderingHint(StateSet::TRANSPARENT_BIN);
flipUpStateSet->setAttributeAndModes(transmaterial, StateAttribute::OVERRIDE | StateAttribute::ON);
StateSet *flipDownStateSet = (*flipDownGeode)->getOrCreateStateSet();
flipDownStateSet->setTextureAttributeAndModes(0, texFloorplan, StateAttribute::ON);
flipDownStateSet->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
flipDownStateSet->setRenderingHint(StateSet::TRANSPARENT_BIN);
flipDownStateSet->setAttributeAndModes(solidmaterial, StateAttribute::OVERRIDE | StateAttribute::ON);
/* create page flipping animation call backs */
AnimationPath* animationPathFlipUp = new AnimationPath;
AnimationPath* animationPathFlipDown = new AnimationPath;
animationPathFlipUp->setLoopMode(AnimationPath::NO_LOOPING);
animationPathFlipDown->setLoopMode(AnimationPath::NO_LOOPING);
Vec3 flipUpOffset, flipDownOffset;
Quat flipUpQuat, flipDownQuat;
Vec3 offsetstep = (end - start) / ANIM_SKETCH_BOOK_PAGE_FLIP_SAMPS;
float anglestep = M_PI * 2 / ANIM_SKETCH_BOOK_PAGE_FLIP_SAMPS;
float timestep = 1.0f / ANIM_SKETCH_BOOK_PAGE_FLIP_SAMPS;
for (int i = 0; i < ANIM_SKETCH_BOOK_PAGE_FLIP_SAMPS + 1; i++)
{
float val = i * timestep;
flipUpOffset = start + offsetstep * i;
flipDownOffset = end - offsetstep * i;
flipUpQuat = Quat(i * anglestep, Vec3(-1, 0, 0));
flipDownQuat = Quat(i * anglestep, Vec3(1, 0, 0));
animationPathFlipUp->insert(val, AnimationPath::ControlPoint(flipUpOffset, flipUpQuat, Vec3(1, 1, 1)));
animationPathFlipDown->insert(val, AnimationPath::ControlPoint(flipDownOffset, flipDownQuat, Vec3(1, 1, 1)));
}
*flipUpCallback = new AnimationPathCallback(animationPathFlipUp, 0.0, 1.0f / ANIM_SKETCH_BOOK_PAGE_FLIP_TIME);
*flipDownCallback = new AnimationPathCallback(animationPathFlipDown, 0.0, 1.0f / ANIM_SKETCH_BOOK_PAGE_FLIP_TIME);
}
void JTOpenPlugin::setMaterial(osg::Node *osgNode, JtkHierarchy *CurrNode)
{
JtkMaterial *partMaterial = NULL;
((JtkPart *)CurrNode)->getMaterial(partMaterial);
if (partMaterial)
{
float *ambient = NULL,
*diffuse = NULL,
*specular = NULL,
*emission = NULL,
shininess = -999.0;
StateSet *stateset = NULL;
osg::Geode *osgGeode = dynamic_cast<osg::Geode *>(osgNode);
if (osgGeode)
{
osg::Drawable *drawable = osgGeode->getDrawable(0);
if (drawable)
{
stateset = drawable->getOrCreateStateSet();
}
else
stateset = osgGeode->getOrCreateStateSet();
}
else
stateset = osgNode->getOrCreateStateSet();
osg::Material *mtl = new osg::Material();
partMaterial->getAmbientColor(ambient);
if (ambient)
{
mtl->setAmbient(Material::FRONT_AND_BACK, Vec4(ambient[0], ambient[1], ambient[2], ambient[3]));
JtkEntityFactory::deleteMemory(ambient);
}
partMaterial->getDiffuseColor(diffuse);
if (diffuse)
{
mtl->setDiffuse(Material::FRONT_AND_BACK, Vec4(diffuse[0], diffuse[1], diffuse[2], diffuse[3]));
JtkEntityFactory::deleteMemory(diffuse);
}
partMaterial->getSpecularColor(specular);
if (specular)
{
mtl->setSpecular(Material::FRONT_AND_BACK, Vec4(specular[0], specular[1], specular[2], specular[3]));
JtkEntityFactory::deleteMemory(specular);
}
partMaterial->getEmissionColor(emission);
if (emission)
{
mtl->setEmission(Material::FRONT_AND_BACK, Vec4(emission[0], emission[1], emission[2], emission[3]));
JtkEntityFactory::deleteMemory(emission);
}
partMaterial->getShininess(shininess);
if (shininess != -999.0)
{
mtl->setShininess(Material::FRONT_AND_BACK, shininess);
}
stateset->setAttributeAndModes(mtl, StateAttribute::ON);
}
}
Geode *ClipPlanePlugin::loadPlane()
{
// *5---*6---*7
// | | |
// *3--------*4
// | | |
// *0---*1---*2
float w = cover->getSceneSize() * 0.1; // width of plane
Vec3Array *lineCoords = new Vec3Array(12);
(*lineCoords)[0].set(-w, -0.01, -w);
(*lineCoords)[1].set(w, -0.01, -w);
(*lineCoords)[2].set(-w, -0.01, 0.0f);
(*lineCoords)[3].set(w, -0.01, 0.0f);
(*lineCoords)[4].set(-w, -0.01, w);
(*lineCoords)[5].set(w, -0.01, w);
(*lineCoords)[6].set(-w, -0.01, -w);
(*lineCoords)[7].set(-w, -0.01, w);
(*lineCoords)[8].set(0.0f, -0.01, -w);
(*lineCoords)[9].set(0.0f, -0.01, w);
(*lineCoords)[10].set(w, -0.01, -w);
(*lineCoords)[11].set(w, -0.01, w);
DrawArrayLengths *primitives = new DrawArrayLengths(PrimitiveSet::LINE_STRIP);
for (int i = 0; i < 6; i++)
{
primitives->push_back(2);
}
Vec3Array *lineColors = new Vec3Array(12);
for (int i = 0; i < 12; i++)
{
(*lineColors)[i].set(Vec3(1.0f, 1.0f, 1.0f));
}
Geometry *geoset = new Geometry();
geoset->setVertexArray(lineCoords);
geoset->addPrimitiveSet(primitives);
geoset->setColorArray(lineColors);
Material *mtl = new Material;
mtl->setColorMode(Material::AMBIENT_AND_DIFFUSE);
mtl->setAmbient(Material::FRONT_AND_BACK, Vec4(0.2f, 0.2f, 0.2f, 1.0f));
mtl->setDiffuse(Material::FRONT_AND_BACK, Vec4(0.9f, 0.9f, 0.9f, 1.0f));
mtl->setSpecular(Material::FRONT_AND_BACK, Vec4(0.9f, 0.9f, 0.9f, 1.0f));
mtl->setEmission(Material::FRONT_AND_BACK, Vec4(0.0f, 0.0f, 0.0f, 1.0f));
mtl->setShininess(Material::FRONT_AND_BACK, 16.0f);
Geode *geode = new Geode;
geode->setName("ClipPlane");
geode->addDrawable(geoset);
StateSet *geostate = geode->getOrCreateStateSet();
geostate->setAttributeAndModes(mtl, StateAttribute::ON);
geostate->setMode(GL_LIGHTING, StateAttribute::OFF);
LineWidth *lineWidth = new LineWidth(3.0);
geostate->setAttributeAndModes(lineWidth, StateAttribute::ON);
geode->setStateSet(geostate);
return geode;
}
void CircleShape::generate()
{
/********************************************************************
* *
* Vertices *
* *
********************************************************************
*/
int numVertices = 0;
vertices = new Vec3Array;
for (int i=0; i <= 360; i = i + degree )
{
double angle = (i*2*PI)/360;
double x,z;
x = cos(angle)*radius;
z = sin(angle)*radius;
vertices->push_back(center);
vertices->push_back(Vec3d(x,0,z)+center);
numVertices+=2;
}
vertices->push_back(center);
setVertexArray(vertices);
/********************************************************************
* *
* colors *
* *
********************************************************************
*/
colors = new Vec4Array(numVertices);
for (int g = 0; g < numVertices; g+=2)
{
(*colors)[g].set(color.x(), color.y(), color.z(), color.w());
(*colors)[g+1].set(gradient.x(), gradient.y(), gradient.z(), gradient.w());
}
setColorArray(colors);
setColorBinding(Geometry::BIND_PER_VERTEX);
addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLE_STRIP, 0,2+(360*2/degree)));
/********************************************************************
* *
* stateset and material *
* *
********************************************************************
*/
// stateset and material
StateSet* state = getOrCreateStateSet();
state->setMode(GL_BLEND,StateAttribute::ON|StateAttribute::OVERRIDE);
Material* mat = new Material();
mat->setAlpha(Material::FRONT_AND_BACK, 0.1);
mat->setColorMode(Material::AMBIENT_AND_DIFFUSE);
state->setAttributeAndModes(mat,StateAttribute::ON | StateAttribute::OVERRIDE);
/********************************************************************
* *
* blending *
* *
********************************************************************
*/
// blending
BlendFunc* bf = new BlendFunc(BlendFunc::SRC_ALPHA, BlendFunc::ONE_MINUS_SRC_ALPHA );
state->setAttributeAndModes(bf);
state->setRenderingHint(StateSet::TRANSPARENT_BIN);
state->setMode(GL_LIGHTING, StateAttribute::ON);
setStateSet(state);
}
/***************************************************************
* Function: createFloorplanGeometry()
***************************************************************/
void VirtualScenicHandler::createFloorplanGeometry(const int numPages,
CAVEAnimationModeler::ANIMPageEntry **pageEntryArray)
{
if (numPages <= 0)
{
return;
}
for (int i = 0; i < numPages; i++)
{
// create floorplan geometry
float length = pageEntryArray[i]->mLength;
float width = pageEntryArray[i]->mWidth;
float altitude = pageEntryArray[i]->mAlti;
Geode *floorplanGeode = new Geode;
Geometry *floorplanGeometry = new Geometry;
Vec3Array* vertices = new Vec3Array;
Vec3Array* normals = new Vec3Array;
Vec2Array* texcoords = new Vec2Array(4);
vertices->push_back(Vec3(-length / 2, width / 2, altitude)); (*texcoords)[0].set(0, 1);
vertices->push_back(Vec3(-length / 2, -width / 2, altitude)); (*texcoords)[1].set(0, 0);
vertices->push_back(Vec3( length / 2, -width / 2, altitude)); (*texcoords)[2].set(1, 0);
vertices->push_back(Vec3( length / 2, width / 2, altitude)); (*texcoords)[3].set(1, 1);
for (int k = 0; k < 4; k++)
{
normals->push_back(Vec3(0, 0, 1));
}
DrawElementsUInt* rectangle = new DrawElementsUInt(PrimitiveSet::POLYGON, 0);
rectangle->push_back(0); rectangle->push_back(1);
rectangle->push_back(2); rectangle->push_back(3);
floorplanGeometry->addPrimitiveSet(rectangle);
floorplanGeometry->setVertexArray(vertices);
floorplanGeometry->setNormalArray(normals);
floorplanGeometry->setTexCoordArray(0, texcoords);
floorplanGeometry->setNormalBinding(Geometry::BIND_PER_VERTEX);
floorplanGeode->addDrawable(floorplanGeometry);
mFloorplanSwitch->addChild(floorplanGeode);
/* load floorplan images */
Material *transmaterial = new Material;
transmaterial->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
transmaterial->setAlpha(Material::FRONT_AND_BACK, 1.0f);
Image* imgFloorplan = osgDB::readImageFile(pageEntryArray[i]->mTexFilename);
Texture2D* texFloorplan = new Texture2D(imgFloorplan);
StateSet *floorplanStateSet = floorplanGeode->getOrCreateStateSet();
floorplanStateSet->setTextureAttributeAndModes(0, texFloorplan, StateAttribute::ON);
floorplanStateSet->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
floorplanStateSet->setRenderingHint(StateSet::TRANSPARENT_BIN);
floorplanStateSet->setAttributeAndModes(transmaterial, StateAttribute::OVERRIDE | StateAttribute::ON);
}
}
Node *makeSky( void )
{
int i, j;
float lev[] = { -5, -1.0, 1.0, 15.0, 30.0, 60.0, 90.0 };
float cc[][4] =
{
{ 0.0, 0.0, 0.15 },
{ 0.0, 0.0, 0.15 },
{ 0.4, 0.4, 0.7 },
{ 0.2, 0.2, 0.6 },
{ 0.1, 0.1, 0.6 },
{ 0.1, 0.1, 0.6 },
{ 0.1, 0.1, 0.6 },
};
float x, y, z;
float alpha, theta;
float radius = 20.0f;
int nlev = sizeof( lev )/sizeof(float);
Geometry *geom = new Geometry;
Vec3Array& coords = *(new Vec3Array(19*nlev));
Vec4Array& colors = *(new Vec4Array(19*nlev));
Vec2Array& tcoords = *(new Vec2Array(19*nlev));
int ci = 0;
for( i = 0; i < nlev; i++ )
{
for( j = 0; j <= 18; j++ )
{
alpha = osg::DegreesToRadians(lev[i]);
theta = osg::DegreesToRadians((float)(j*20));
x = radius * cosf( alpha ) * cosf( theta );
y = radius * cosf( alpha ) * -sinf( theta );
z = radius * sinf( alpha );
coords[ci][0] = x;
coords[ci][1] = y;
coords[ci][2] = z;
colors[ci][0] = cc[i][0];
colors[ci][1] = cc[i][1];
colors[ci][2] = cc[i][2];
colors[ci][3] = 1.0;
tcoords[ci][0] = (float)j/18.0;
tcoords[ci][1] = (float)i/(float)(nlev-1);
ci++;
}
}
for( i = 0; i < nlev-1; i++ )
{
DrawElementsUShort* drawElements = new DrawElementsUShort(PrimitiveSet::TRIANGLE_STRIP);
drawElements->reserve(38);
for( j = 0; j <= 18; j++ )
{
drawElements->push_back((i+1)*19+j);
drawElements->push_back((i+0)*19+j);
}
geom->addPrimitiveSet(drawElements);
}
geom->setVertexArray( &coords );
geom->setTexCoordArray( 0, &tcoords );
geom->setColorArray( &colors );
geom->setColorBinding( Geometry::BIND_PER_VERTEX );
Texture2D *tex = new Texture2D;
tex->setImage(osgDB::readImageFile("Images/white.rgb"));
StateSet *dstate = new StateSet;
dstate->setTextureAttributeAndModes(0, tex, StateAttribute::OFF );
dstate->setTextureAttribute(0, new TexEnv );
dstate->setMode( GL_LIGHTING, StateAttribute::OFF );
dstate->setMode( GL_CULL_FACE, StateAttribute::ON );
// clear the depth to the far plane.
osg::Depth* depth = new osg::Depth;
depth->setFunction(osg::Depth::ALWAYS);
depth->setRange(1.0,1.0);
dstate->setAttributeAndModes(depth,StateAttribute::ON );
dstate->setRenderBinDetails(-2,"RenderBin");
geom->setStateSet( dstate );
Geode *geode = new Geode;
geode->addDrawable( geom );
geode->setName( "Sky" );
return geode;
}
//----------------------------------------------------------------------
void MathematicPlugin::drawBoundingBox(BoundingBox *box)
{
if (cover->debugLevel(3))
fprintf(stderr, "MathematicPlugin::drawBoundingBox\n");
boxGeode_ = new Geode();
Vec3 bpoints[8];
bpoints[0].set(box->xMin(), box->yMin(), box->zMin());
bpoints[1].set(box->xMax(), box->yMin(), box->zMin());
bpoints[2].set(box->xMax(), box->yMax(), box->zMin());
bpoints[3].set(box->xMin(), box->yMax(), box->zMin());
bpoints[4].set(box->xMin(), box->yMin(), box->zMax());
bpoints[5].set(box->xMax(), box->yMin(), box->zMax());
bpoints[6].set(box->xMax(), box->yMax(), box->zMax());
bpoints[7].set(box->xMin(), box->yMax(), box->zMax());
Geometry *lineGeometry[12];
Vec3Array *vArray[12];
DrawArrays *drawable[12];
for (int i = 0; i < 12; i++)
{
lineGeometry[i] = new Geometry();
vArray[i] = new Vec3Array();
//fprintf(stderr,"MathematicPlugin::drawBoundingBox bpoints[0] %f %f %f\n", bpoints[0].x(), bpoints[0].y(), bpoints[0].z());
//fprintf(stderr,"MathematicPlugin::drawBoundingBox bpoints[1] %f %f %f\n", bpoints[1].x(), bpoints[1].y(), bpoints[1].z());
lineGeometry[i]->setVertexArray(vArray[i]);
drawable[i] = new DrawArrays(PrimitiveSet::LINES, 0, 2);
lineGeometry[i]->addPrimitiveSet(drawable[i]);
LineWidth *linewidth = new LineWidth();
linewidth->setWidth(1.0);
boxGeode_->addDrawable(lineGeometry[i]);
}
// lines
vArray[0]->push_back(bpoints[0]);
vArray[0]->push_back(bpoints[1]);
vArray[1]->push_back(bpoints[1]);
vArray[1]->push_back(bpoints[2]);
vArray[2]->push_back(bpoints[2]);
vArray[2]->push_back(bpoints[3]);
vArray[3]->push_back(bpoints[3]);
vArray[3]->push_back(bpoints[0]);
vArray[4]->push_back(bpoints[4]);
vArray[4]->push_back(bpoints[5]);
vArray[5]->push_back(bpoints[5]);
vArray[5]->push_back(bpoints[6]);
vArray[6]->push_back(bpoints[6]);
vArray[6]->push_back(bpoints[7]);
vArray[7]->push_back(bpoints[7]);
vArray[7]->push_back(bpoints[4]);
vArray[8]->push_back(bpoints[0]);
vArray[8]->push_back(bpoints[4]);
vArray[9]->push_back(bpoints[3]);
vArray[9]->push_back(bpoints[7]);
vArray[10]->push_back(bpoints[2]);
vArray[10]->push_back(bpoints[6]);
vArray[11]->push_back(bpoints[1]);
vArray[11]->push_back(bpoints[5]);
Material *material = new Material();
material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1.0, 1.0, 1.0, 1.0));
material->setAmbient(Material::FRONT_AND_BACK, Vec4(1.0, 1.0, 1.0, 1.0));
material->setSpecular(Material::FRONT_AND_BACK, Vec4(1.0, 1.0, 1.0, 1.0));
StateSet *stateSet = VRSceneGraph::instance()->loadDefaultGeostate();
stateSet->setMode(GL_BLEND, StateAttribute::ON);
stateSet->setAttributeAndModes(material);
stateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
boxGeode_->setStateSet(stateSet);
boxGeode_->setNodeMask(boxGeode_->getNodeMask() & (~Isect::Intersection) & (~Isect::Pick));
cover->getObjectsRoot()->addChild(boxGeode_);
}
/***************************************************************
* Function: ANIMLoadGeometryCreator()
*
* xformScaleFwd: Root transform node for inflating geometries
* xformScaleBwd: Root transform node for shrinking geometries
* sphereExteriorSwitch: Switch control for single exterior sphere
*
***************************************************************/
void ANIMLoadGeometryCreator(PositionAttitudeTransform** xformScaleFwd, PositionAttitudeTransform** xformScaleBwd,
Switch **sphereExteriorSwitch, Geode **sphereExteriorGeode,
int &numTypes, ANIMShapeSwitchEntry ***shapeSwitchEntryArray)
{
*xformScaleFwd = new PositionAttitudeTransform;
*xformScaleBwd = new PositionAttitudeTransform;
MatrixTransform *geomCreatorTrans = new MatrixTransform;
MatrixTransform *sphereExteriorTrans = new MatrixTransform;
*sphereExteriorSwitch = new Switch;
Switch *createBoxSwitch = new Switch;
Switch *createCylinderSwitch = new Switch;
(*xformScaleFwd)->addChild(geomCreatorTrans);
(*xformScaleBwd)->addChild(geomCreatorTrans);
geomCreatorTrans->addChild(*sphereExteriorSwitch);
geomCreatorTrans->addChild(createBoxSwitch);
geomCreatorTrans->addChild(createCylinderSwitch);
osg::Vec3 pos(-1, 0, 0);
// create drawables, geodes and attach them to animation switches
*sphereExteriorGeode = new Geode();
Sphere *sphere = new Sphere(osg::Vec3(), ANIM_VIRTUAL_SPHERE_RADIUS);
ShapeDrawable *sphereDrawable = new ShapeDrawable(sphere);
(*sphereExteriorGeode)->addDrawable(sphereDrawable);
Box *box = new Box(osg::Vec3(0.1, 0, 0), ANIM_VIRTUAL_SPHERE_RADIUS / 1.9);
(*sphereExteriorGeode)->addDrawable(new ShapeDrawable(box));
float r = ANIM_VIRTUAL_SPHERE_RADIUS / 3.0;
Cylinder *cylinder = new Cylinder(osg::Vec3(-0.05, 0, -0.05), r, r * 2);
(*sphereExteriorGeode)->addDrawable(new ShapeDrawable(cylinder));
Cone *cone = new osg::Cone(osg::Vec3(0, -0.1, 0.05), r, r * 2);
(*sphereExteriorGeode)->addDrawable(new ShapeDrawable(cone));
Material *transmaterial = new Material;
transmaterial->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1));
transmaterial->setAlpha(Material::FRONT_AND_BACK, 0.6f);
Image* envMap = osgDB::readImageFile(ANIMDataDir() + "Textures/ShapeContainer.JPG");
Texture2D* envTex = new Texture2D(envMap);
StateSet *sphereStateSet = (sphereDrawable)->getOrCreateStateSet();
sphereStateSet->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON );
sphereStateSet->setRenderingHint(StateSet::TRANSPARENT_BIN);
sphereStateSet->setAttributeAndModes(transmaterial, StateAttribute::OVERRIDE | StateAttribute::ON);
sphereStateSet->setTextureAttributeAndModes(0, envTex, StateAttribute::ON);
sphereStateSet->setMode(GL_CULL_FACE, StateAttribute::ON);
sphereExteriorTrans->addChild(*sphereExteriorGeode);
(*sphereExteriorSwitch)->addChild(sphereExteriorTrans);
(*sphereExteriorSwitch)->setAllChildrenOn();
// write into shape switch entry array record
numTypes = 2;
*shapeSwitchEntryArray = new ANIMShapeSwitchEntry*[numTypes];
(*shapeSwitchEntryArray)[0] = new ANIMShapeSwitchEntry;
(*shapeSwitchEntryArray)[1] = new ANIMShapeSwitchEntry;
(*shapeSwitchEntryArray)[0]->mSwitch = createBoxSwitch;
(*shapeSwitchEntryArray)[1]->mSwitch = createCylinderSwitch;
ANIMCreateSingleShapeSwitchAnimation(&((*shapeSwitchEntryArray)[0]), CAVEGeodeShape::BOX);
ANIMCreateSingleShapeSwitchAnimation(&((*shapeSwitchEntryArray)[1]), CAVEGeodeShape::CYLINDER);
/* set up the forward / backward scale animation paths for geometry creator */
AnimationPath* animationPathScaleFwd = new AnimationPath;
AnimationPath* animationPathScaleBwd = new AnimationPath;
animationPathScaleFwd->setLoopMode(AnimationPath::NO_LOOPING);
animationPathScaleBwd->setLoopMode(AnimationPath::NO_LOOPING);
Vec3 scaleFwd, scaleBwd;
float step = 1.f / ANIM_VIRTUAL_SPHERE_NUM_SAMPS;
for (int i = 0; i < ANIM_VIRTUAL_SPHERE_NUM_SAMPS + 1; i++)
{
float val = i * step;
scaleFwd = Vec3(val, val, val);
scaleBwd = Vec3(1.f-val, 1.f-val, 1.f-val);
animationPathScaleFwd->insert(val, AnimationPath::ControlPoint(pos, Quat(), scaleFwd));
animationPathScaleBwd->insert(val, AnimationPath::ControlPoint(pos, Quat(), scaleBwd));
}
AnimationPathCallback *animCallbackFwd = new AnimationPathCallback(animationPathScaleFwd,
0.0, 1.f / ANIM_VIRTUAL_SPHERE_LAPSE_TIME);
AnimationPathCallback *animCallbackBwd = new AnimationPathCallback(animationPathScaleBwd,
0.0, 1.f / ANIM_VIRTUAL_SPHERE_LAPSE_TIME);
(*xformScaleFwd)->setUpdateCallback(animCallbackFwd);
(*xformScaleBwd)->setUpdateCallback(animCallbackBwd);
}
void TriangleShape::generate()
{
/****************************************************************
* *
* Vertices *
* *
****************************************************************
*/
// check if all 3 points are present, otherwise use default method to calculate vertices
if(!genVer)
{
vertices = new Vec3Array(3);
(*vertices)[0].set(p1);
(*vertices)[1].set(p2);
(*vertices)[2].set(p3);
}
else if (genVer)
{
vertices = new Vec3Array();
// top point
Vec3d v1(center.x(), center.y(), center.z()+length/2);
// bottom left point
Vec3d v2((center.x()-cos(120)*length/2), center.y(), (center.z()-sin(-60)*length/2));
// bottom right point
Vec3d v3((center.x()-cos(60)*length/2), center.y(), (center.z()-sin(-60)*length/2));
vertices->push_back(center);
vertices->push_back(v1);
vertices->push_back(center);
vertices->push_back(v2);
vertices->push_back(center);
vertices->push_back(v3);
vertices->push_back(center);
vertices->push_back(v1);
}
setVertexArray(vertices);
/****************************************************************
* *
* normals *
* *
****************************************************************
*/
Vec3Array* normals = new Vec3Array(1);
(*normals)[0].set(1.0f, 1.0f, 0.0f);
setNormalArray(normals);
setNormalBinding(Geometry::BIND_OVERALL);
/****************************************************************
* *
* colors *
* *
****************************************************************
*/
if (!genVer)
{
colors = new Vec4Array(3);
(*colors)[0].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[1].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[2].set(color3.x(), color3.y(), color3.z(), color3.w());
addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLES, 0, 3));
}
else
{
colors = new Vec4Array();
colors->push_back(color1);
colors->push_back(color2);
colors->push_back(color1);
colors->push_back(color2);
colors->push_back(color1);
colors->push_back(color2);
colors->push_back(color1);
colors->push_back(color2);
addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLE_STRIP, 0, 8));
}
setColorArray(colors);
setColorBinding(Geometry::BIND_PER_VERTEX);
/****************************************************************
* *
* stateset and material *
* *
****************************************************************
*/
StateSet* state = getOrCreateStateSet();
state->setMode(GL_BLEND,StateAttribute::ON|StateAttribute::OVERRIDE);
Material* mat = new Material();
mat->setAlpha(Material::FRONT_AND_BACK, 0.1);
mat->setColorMode(Material::AMBIENT_AND_DIFFUSE);
state->setAttributeAndModes(mat,StateAttribute::ON | StateAttribute::OVERRIDE);
/****************************************************************
* *
* blending *
* *
****************************************************************
*/
BlendFunc* bf = new BlendFunc(BlendFunc::SRC_ALPHA, BlendFunc::ONE_MINUS_SRC_ALPHA );
state->setAttributeAndModes(bf);
state->setRenderingHint(StateSet::TRANSPARENT_BIN);
state->setMode(GL_LIGHTING, StateAttribute::ON);
setStateSet(state);
}
void BoxShape::generate()
{
/****************************************************************
* *
* Vertices *
* *
****************************************************************
*/
vertices = new Vec3Array();
//assuming box points coming this way: 5-----------6
// /| /|
// / | / |
// / | / |
// 0---4-------3---7
// | / | /
// | / | /
// |/ |/
// 1-----------2
// check if all 4 points are present, otherwise use default method to calculate vertices
if(!genVer)
{
vertices->push_back(p1);
vertices->push_back(p2);
vertices->push_back(p3);
vertices->push_back(p4);
vertices->push_back(p5);
vertices->push_back(p6);
vertices->push_back(p7);
vertices->push_back(p8);
//setVertexArray(vertices);
}
else if (genVer)
{ // -y = coming out of screen?
vertices->push_back(Vec3( center.x()-(width/2) , center.y()-(depth/2) , center.z()+(height/2) ));
vertices->push_back(Vec3( center.x()-(width/2) , center.y()-(depth/2) , center.z()-(height/2) ));
vertices->push_back(Vec3( center.x()+(width/2) , center.y()-(depth/2) , center.z()-(height/2) ));
vertices->push_back(Vec3( center.x()+(width/2) , center.y()-(depth/2) , center.z()+(height/2) ));
vertices->push_back(Vec3( center.x()-(width/2) , center.y()+(depth/2) , center.z()-(height/2) ));
vertices->push_back(Vec3( center.x()-(width/2) , center.y()+(depth/2) , center.z()+(height/2) ));
vertices->push_back(Vec3( center.x()+(width/2) , center.y()+(depth/2) , center.z()+(height/2) ));
vertices->push_back(Vec3( center.x()+(width/2) , center.y()+(depth/2) , center.z()-(height/2) ));
//setVertexArray(vertices);
}
setVertexArray(vertices);
//front face
DrawElementsUInt* frontface = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
frontface->push_back(0);
frontface->push_back(1);
frontface->push_back(2);
frontface->push_back(3);
addPrimitiveSet(frontface);
//back face
DrawElementsUInt* backface = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
backface->push_back(4);
backface->push_back(5);
backface->push_back(6);
backface->push_back(7);
addPrimitiveSet(backface);
//top face
DrawElementsUInt* topface = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
topface->push_back(5);
topface->push_back(0);
topface->push_back(3);
topface->push_back(6);
addPrimitiveSet(topface);
//bottom face
DrawElementsUInt* bottomface = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
bottomface->push_back(1);
bottomface->push_back(4);
bottomface->push_back(7);
bottomface->push_back(2);
addPrimitiveSet(bottomface);
//left face
DrawElementsUInt* leftface = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
leftface->push_back(0);
leftface->push_back(5);
leftface->push_back(4);
leftface->push_back(1);
addPrimitiveSet(leftface);
//right face
DrawElementsUInt* rightface = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
rightface->push_back(3);
rightface->push_back(2);
rightface->push_back(7);
rightface->push_back(6);
addPrimitiveSet(rightface);
/****************************************************************
* *
* normals *
* *
****************************************************************
*/
Vec3Array* normals = new Vec3Array(1);
(*normals)[0].set(1.0f, 1.0f, 1.0f);
setNormalArray(normals);
setNormalBinding(Geometry::BIND_OVERALL);
/****************************************************************
* *
* colors *
* *
****************************************************************
*/
/*if (!genVer)
{
colors = new Vec4Array(8);
(*colors)[0].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[1].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[2].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[3].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[4].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[5].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[6].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[7].set(color2.x(), color2.y(), color2.z(), color2.w());
}
else
{*/
colors = new Vec4Array(8);
(*colors)[0].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[1].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[2].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[3].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[4].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[5].set(color2.x(), color2.y(), color2.z(), color2.w());
(*colors)[6].set(color1.x(), color1.y(), color1.z(), color1.w());
(*colors)[7].set(color2.x(), color2.y(), color2.z(), color2.w());
//(*colors)[8].set(color1.x(), color1.y(), color1.z(), color1.w());
//(*colors)[9].set(color2.x(), color2.y(), color2.z(), color2.w());
//}
setColorArray(colors);
setColorBinding(Geometry::BIND_PER_VERTEX);
/****************************************************************
* *
* stateset and material *
* *
****************************************************************
*/
StateSet* state = getOrCreateStateSet();
state->setMode(GL_BLEND,StateAttribute::ON|StateAttribute::OVERRIDE);
Material* mat = new Material();
mat->setAlpha(Material::FRONT_AND_BACK, 0.1);
mat->setColorMode(Material::AMBIENT_AND_DIFFUSE);
state->setAttributeAndModes(mat,StateAttribute::ON | StateAttribute::OVERRIDE);
/****************************************************************
* *
* blending *
* *
****************************************************************
*/
BlendFunc* bf = new BlendFunc(BlendFunc::SRC_ALPHA, BlendFunc::ONE_MINUS_SRC_ALPHA );
state->setAttributeAndModes(bf);
state->setRenderingHint(StateSet::TRANSPARENT_BIN);
state->setMode(GL_LIGHTING, StateAttribute::ON);
setStateSet(state);
}
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
if (arguments.argc() <= 1) {
cerr << "Need a scene.\n";
return 1;
}
osg::ref_ptr<osg::Node> loadedModel = osgDB::readRefNodeFiles(arguments);
if (!loadedModel) {
cerr << "couldn't load " << argv[1] << "\n";
return 1;
}
osgUtil::Optimizer optimizer;
optimizer.optimize(loadedModel.get());
const BoundingSphere bound = loadedModel->getBound();
const float displacement = 2.25 * bound.radius();
Group* scene = new Group;
StateSet* rootSS = scene->getOrCreateStateSet();
Shader* vertexShader = new Shader(Shader::VERTEX);
vertexShader->setShaderSource(vertexShaderSource);
Shader* fragmentShader = new Shader(Shader::FRAGMENT);
fragmentShader->setShaderSource(fragmentShaderSource);
Program* prog = new Program;
prog->addShader(vertexShader);
prog->addShader(fragmentShader);
prog->addBindUniformBlock("colors0", 0);
rootSS->setAttributeAndModes(prog, StateAttribute::ON);
// Place 3 instances of the loaded model with different uniform
// blocks for each.
//
// The blocksize is known because of the std140 format.
const unsigned blockSize = 20 * sizeof(GLfloat);
ref_ptr<FloatArray> colorArray
= new FloatArray(&colors1[0],
&colors1[sizeof(colors1) / sizeof(GLfloat)]);
ref_ptr<UniformBufferObject> ubo = new UniformBufferObject;
colorArray->setBufferObject(ubo.get());
Group* group1 = new Group;
StateSet* ss1 = group1->getOrCreateStateSet();
group1->addChild(loadedModel.get());
scene->addChild(group1);
ref_ptr<UniformBufferBinding> ubb1
= new UniformBufferBinding(0, ubo.get(), 0, blockSize);
ss1->setAttributeAndModes(ubb1.get(), StateAttribute::ON);
ref_ptr<FloatArray> colorArray2
= new FloatArray(&colors2[0],
&colors2[sizeof(colors2) / sizeof(GLfloat)]);
ref_ptr<UniformBufferObject> ubo2 = new UniformBufferObject;
colorArray2->setBufferObject(ubo2.get());
MatrixTransform* group2 = new MatrixTransform;
Matrix mat2 = Matrix::translate(-displacement, 0.0, 0.0);
group2->setMatrix(mat2);
StateSet* ss2 = group2->getOrCreateStateSet();
group2->addChild(loadedModel.get());
scene->addChild(group2);
ref_ptr<UniformBufferBinding> ubb2
= new UniformBufferBinding(0, ubo2.get(), 0, blockSize);
ss2->setAttributeAndModes(ubb2.get(), StateAttribute::ON);
ref_ptr<FloatArray> colorArray3
= new FloatArray(&colors2[0],
&colors2[sizeof(colors2) / sizeof(GLfloat)]);
ref_ptr<UniformBufferObject> ubo3 = new UniformBufferObject;
colorArray3->setBufferObject(ubo3.get());
MatrixTransform* group3 = new MatrixTransform;
Matrix mat3 = Matrix::translate(displacement, 0.0, 0.0);
group3->setMatrix(mat3);
StateSet* ss3 = group3->getOrCreateStateSet();
group3->addChild(loadedModel.get());
scene->addChild(group3);
ref_ptr<UniformBufferBinding> ubb3
= new UniformBufferBinding(0, ubo3.get(), 0, blockSize);
ubb3->setUpdateCallback(new UniformBufferCallback);
ubb3->setDataVariance(Object::DYNAMIC);
ss3->setAttributeAndModes(ubb3.get(), StateAttribute::ON);
viewer.setSceneData(scene);
viewer.realize();
return viewer.run();
}
Node *makeTrees( void )
{
Group *group = new Group;
int i;
getDatabaseCenterRadius( dbcenter, &dbradius );
struct _tree *t;
Texture2D *tex = new Texture2D;
tex->setImage(osgDB::readImageFile("Images/tree0.rgba"));
StateSet *dstate = new StateSet;
dstate->setTextureAttributeAndModes(0, tex, StateAttribute::ON );
dstate->setTextureAttribute(0, new TexEnv );
dstate->setAttributeAndModes( new BlendFunc, StateAttribute::ON );
AlphaFunc* alphaFunc = new AlphaFunc;
alphaFunc->setFunction(AlphaFunc::GEQUAL,0.05f);
dstate->setAttributeAndModes( alphaFunc, StateAttribute::ON );
dstate->setMode( GL_LIGHTING, StateAttribute::OFF );
dstate->setRenderingHint( StateSet::TRANSPARENT_BIN );
int tt[] = { 15, 30, 45, 58, 72, 75, 93, 96, 105, -1 };
int *ttp = tt;
i = 0;
while( i < 105 )
{
ttx = trees[i].x;
tty = trees[i].y;
qsort( &trees[i], 105 - i, sizeof( _tree ), ct );
i += *ttp;
ttp++;
}
t = trees;
i = 0;
ttp = tt;
while( *ttp != -1 )
{
Billboard *bb = new Billboard;
//int starti = i;
for( ; i < (*ttp); i++ )
{
t->x -= 0.3f;
float h = Hat(t->x, t->y, t->z );
Vec3 pos( t->x, t->y, t->z-h );
Geometry *geom = makeTree( t, dstate );
bb->addDrawable( geom, pos );
t++;
}
group->addChild( bb );
ttp++;
}
return group;
}
int main(int argc, char **argv)
{
// use an ArgumentParser object to manage the program arguments.
ArgumentParser arguments(&argc,argv);
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()
+ " demonstrates using a floating point depth buffer.\nThe user can invert the depth buffer range and choose among available multi-sample configurations.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
arguments.getApplicationUsage()->addCommandLineOption("--far <number>", "Set far plane value");
// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
arguments.getApplicationUsage()->write(std::cout);
return 1;
}
float zFar = 500.0f;
while (arguments.read("--far", zFar))
;
// construct the viewer.
osgViewer::Viewer viewer;
ref_ptr<AppState> appState = new AppState(&viewer);
viewer.addEventHandler(new osgViewer::StatsHandler);
viewer.addEventHandler(new osgViewer::WindowSizeHandler);
viewer.addEventHandler(new osgViewer::ScreenCaptureHandler);
// The aspect ratio is set to the correct ratio for the window in
// setupGC().
viewer.getCamera()
->setProjectionMatrixAsPerspective(40.0, 1.0, appState->zNear, zFar);
GraphicsContext* gc = setupGC(viewer, arguments);
if (!gc)
return 1;
gc->setResizedCallback(new ResizedCallback(appState.get()));
const GraphicsContext::Traits* traits = gc->getTraits();
width = traits->width;
height = traits->height;
if (arguments.argc()<=1)
{
arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
return 1;
}
ref_ptr<Node> loadedModel = osgDB::readNodeFiles(arguments);
if (!loadedModel) {
cerr << "couldn't load " << argv[1] << "\n";
return 1;
}
osgUtil::Optimizer optimizer;
optimizer.optimize(loadedModel.get());
// creates texture to be rendered
Switch* sw = makeTexturesAndGeometry(width, height, appState->sw.get());
ref_ptr<Camera> rttCamera = makeRttCamera(gc, width, height);
rttCamera->setRenderOrder(Camera::PRE_RENDER);
viewer.addSlave(rttCamera.get());
appState->camera = rttCamera;
// geometry and slave camera to display the result
Group* displayRoot = new Group;
displayRoot->addChild(sw);
displayRoot->addChild(appState->textProjection.get());
StateSet* displaySS = displayRoot->getOrCreateStateSet();
displaySS->setMode(GL_LIGHTING, StateAttribute::OFF);
displaySS->setMode(GL_DEPTH_TEST, StateAttribute::OFF);
Camera* texCamera = new Camera;
texCamera->setGraphicsContext(gc);
texCamera->setClearMask(GL_COLOR_BUFFER_BIT);
texCamera->setClearColor(Vec4(0.0, 0.0, 0.0, 0.0));
texCamera->setReferenceFrame(Camera::ABSOLUTE_RF);
texCamera->setViewport(0, 0, width, height);
texCamera->setDrawBuffer(GL_BACK);
texCamera->setReadBuffer(GL_BACK);
texCamera->addChild(displayRoot);
texCamera->setAllowEventFocus(false);
texCamera->setCullingMode(CullSettings::NO_CULLING);
texCamera->setProjectionResizePolicy(Camera::FIXED);
viewer.addSlave(texCamera, Matrixd(), Matrixd(), false);
viewer.addEventHandler(new ConfigHandler(appState.get()));
// add model to the viewer.
Group* sceneRoot = new Group;
StateSet* sceneSS = sceneRoot->getOrCreateStateSet();
Depth* depth = new Depth(Depth::GEQUAL, 1.0, 0.0);
sceneSS->setAttributeAndModes(depth,(StateAttribute::ON
| StateAttribute::OVERRIDE));
#if 0
// Hack to work around Blender osg export bug
sceneSS->setAttributeAndModes(new CullFace(CullFace::BACK));
#endif
sceneRoot->addChild(loadedModel.get());
appState->setStateFromConfig(validConfigs[0]);
appState->updateNear();
viewer.addEventHandler(new DepthHandler(appState.get(), depth));
// add the help handler
viewer.addEventHandler(new osgViewer
::HelpHandler(arguments.getApplicationUsage()));
viewer.setSceneData(sceneRoot);
return viewer.run();
}
