SceneObject *Scene::addDynamicOpaqueObject(Model *model, float scale, const Float3 &pos, const Quaternion &rot)
{
Assert_(model != nullptr);
Assert_(_numObjectBases < MAX_DYNAMIC_OBJECTS);
Assert_(_numTotalModelsShared < MAX_MODELS);
Assert_(_numObjectBases < MAX_OBJECT_MATRICES);
Assert_(_numPrevWVPs < MAX_OBJECT_MATRICES);
uint64 modelIndex = getModelIndex(model);
Assert_(modelIndex != -1);
_objectBases[_numObjectBases] = createBase(scale, pos, rot);
_prevWVPs[_numPrevWVPs] = _objectBases[_numObjectBases];
_sceneStaticOpaqueObjectBounds[_numStaticOpaqueObjects] = SceneObjectBound();
SceneObject &obj = _dynamicOpaqueObjects[_numDynamicOpaqueObjects];
obj.base = &_objectBases[_numObjectBases];
obj.model = model;
obj.bound = &_sceneDynamicOpaqueObjectBounds[_numDynamicOpaqueObjects];
obj.prevWVP = &_prevWVPs[_numPrevWVPs];
obj.id = _highestSceneObjId++;
genSceneObjectBounds(DYNAMIC_OBJ | OPAQUE_OBJ, _numDynamicOpaqueObjects, modelIndex);
_numObjectBases++;
_numPrevWVPs++;
_numDynamicOpaqueObjects++;
return &obj;
}
osg::Node* createModel(bool overlay, osgSim::OverlayNode::OverlayTechnique technique)
{
osg::Vec3 center(0.0f,0.0f,0.0f);
float radius = 100.0f;
osg::Group* root = new osg::Group;
float baseHeight = center.z()-radius*0.5;
osg::Node* baseModel = createBase(osg::Vec3(center.x(), center.y(), baseHeight),radius);
osg::Node* movingModel = createMovingModel(center,radius*0.8f);
if (overlay)
{
osgSim::OverlayNode* overlayNode = new osgSim::OverlayNode(technique);
overlayNode->setContinuousUpdate(true);
overlayNode->setOverlaySubgraph(movingModel);
overlayNode->setOverlayBaseHeight(baseHeight-0.01);
overlayNode->addChild(baseModel);
root->addChild(overlayNode);
}
else
{
root->addChild(baseModel);
}
root->addChild(movingModel);
return root;
}
osg::Node* createModel()
{
osg::Vec3 center(0.0f,0.0f,0.0f);
float radius = 100.0f;
osg::Group* root = new osg::Group;
root->addChild(createMovingModel(center,radius*0.8f));
root->addChild(createBase(center-osg::Vec3(0.0f,0.0f,radius*0.5),radius));
return root;
}
void geHorizontalSlider::create(rendererGL10* renderer, geGUIBase* parent, const char* name, float x, float y, float cx)
{
createBase(renderer, parent);
setSize(cx, 5);
setPos(x, y);
STRCPY(m_szName, name);
setClientAreaPrimaryActiveForeColor(0.21f, 0.21f, 0.21f, 1.0f);
applyPrimaryColorToVBClientArea(EGRADIENT_VERTICAL_DOWN, 0.4f);
setColor(&m_cVBGrabberArea, 0.6f, 0.6f, 0.6f, 1.0f, EGRADIENT_VERTICAL_UP, 0.5f);
m_fSliderPos=0.0f;
m_bGrabbed=false;
m_fMousePrevXPos=0.0f;
setMouseBoundCheck(false);
setRange(0.0f, 1.0f);
}
void Scene::setProxySceneObject(const std::wstring &modelPath, float scale, const Float3 &pos, const Quaternion &rot)
{
Model *m = addModel(modelPath);
_objectBases[_numObjectBases] = createBase(scale, pos, rot);
_prevWVPs[_numPrevWVPs] = _objectBases[_numObjectBases];
SceneObject &obj = _proxySceneObject;
obj.base = &_objectBases[_numObjectBases];
obj.model = m;
obj.bound = nullptr;
obj.prevWVP = &_prevWVPs[_numPrevWVPs];
obj.id = _highestSceneObjId++;
_numObjectBases++;
_numPrevWVPs++;
_hasProxySceneObject = true;
}
osg::Node* createModel(osg::ArgumentParser& /*arguments*/)
{
osg::Vec3 center(0.0f,0.0f,0.0f);
float radius = 100.0f;
// the shadower model
osg::Node* shadower = createMovingModel(center,radius*0.5f);
shadower->setNodeMask(CastsShadowTraversalMask);
// the shadowed model
osg::Node* shadowed = createBase(center-osg::Vec3(0.0f,0.0f,radius*0.25),radius);
shadowed->setNodeMask(ReceivesShadowTraversalMask);
osg::Group* group = new osg::Group;
group->addChild(shadowed);
group->addChild(shadower);
return group;
}
osg::Node* createModel()
{
osg::Vec3 center(0.0f,0.0f,0.0f);
float radius = 100.0f;
// the shadower model
osg::Node* shadower = createMovingModel(center,radius*0.5f);
// the shadowed model
osg::Node* shadowed = createBase(center-osg::Vec3(0.0f,0.0f,radius*0.1),radius);
// combine the models together to create one which has the shadower and the shadowed with the required callback.
osg::Group* root = new osg::Group;
root->setStateSet(createSpotLightDecoratorState(0,1));
root->addChild(shadower);
root->addChild(shadowed);
return root;
}
SceneObject *Scene::addStaticOpaquePlaneObject(float scale, const Float3 &pos, const Quaternion &rot)
{
Assert_(_numObjectBases < MAX_STATIC_OBJECTS);
Assert_(_numTotalModelsShared < MAX_MODELS);
Assert_(_numObjectBases < MAX_OBJECT_MATRICES);
Assert_(_numPrevWVPs < MAX_OBJECT_MATRICES);
if (!_planeModel)
{
addPlaneModel();
_modelIndices.push_back(_numTotalModelsShared - 1);
}
uint64 modelIndex = getModelIndex(_planeModel);
Assert_(modelIndex != -1);
_objectBases[_numObjectBases] = createBase(scale, pos, rot);
_prevWVPs[_numPrevWVPs] = _objectBases[_numObjectBases];
_sceneStaticOpaqueObjectBounds[_numStaticOpaqueObjects] = SceneObjectBound();
SceneObject &obj = _staticOpaqueObjects[_numStaticOpaqueObjects];
obj.base = &_objectBases[_numObjectBases];
obj.model = _planeModel;
obj.bound = &_sceneStaticOpaqueObjectBounds[_numStaticOpaqueObjects];
obj.prevWVP = &_prevWVPs[_numPrevWVPs];
obj.id = _highestSceneObjId++;
genSceneObjectBounds(STATIC_OBJ | OPAQUE_OBJ, _numStaticOpaqueObjects, modelIndex);
_numObjectBases++;
_numPrevWVPs++;
_numStaticOpaqueObjects++;
return &obj;
}
Index::Index(const std::string &language):
language_(language)
{
findDirectories();
createBase();
}
Index::Index()
{
findDirectories();
createBase();
}
void
f ()
{
createBase().memberFunction();
}
osg::Group* QOSG::ProjectiveARViewer::createProjectorScene() {
unsigned int tex_width = 2048;
unsigned int tex_height = 2048;
unsigned int samples = 0;
unsigned int colorSamples = 0;
osg::Camera::RenderTargetImplementation renderImplementation = osg::Camera::FRAME_BUFFER_OBJECT;
// load model to view
osg::Node* model = viewerPerspective->getSceneData();
if(!model)
model = osgDB::readNodeFile("cessna.osgt");
if (!model){
return NULL;
}
// texture to render to and to use for rendering of graph.
osg::Texture2D* texture = new osg::Texture2D;
texture->setTextureSize(tex_width, tex_height);
texture->setInternalFormat(GL_RGBA);
texture->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::LINEAR);
texture->setFilter(osg::Texture2D::MAG_FILTER, osg::Texture2D::LINEAR);
// create the camera node to do the render to texture
if (!renderCamera)
renderCamera = new osg::Camera;
// set up the background color and clear mask.
renderCamera->setClearColor(osg::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
renderCamera->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
double fovy, aspectRatio, zNear, zFar;
viewerPerspective->getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio, zNear, zFar);
renderCamera->setProjectionMatrixAsPerspective(viewerFOV, 1.0, zNear, zFar);
if(useGraph){
const osg::BoundingSphere& bs = model->getBound();
if (!bs.valid())
{
return NULL;
}
osg::Vec3d viewerRelPos(viewerPos - graphPos);
osg::Vec3d renderCameraRelPos(viewerRelPos * (bs.radius() / graphRadius));
renderCamera->setViewMatrixAsLookAt(renderCameraRelPos + bs.center(), bs.center(), osg::Vec3(0.0f, 0.0f, 1.0f));
}
else{
renderCamera->setViewMatrix(viewerPerspective->getCamera()->getViewMatrix());
}
renderCamera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
// set viewport
renderCamera->setViewport(0, 0, tex_width, tex_height);
// set the camera to render before the main camera.
renderCamera->setRenderOrder(osg::Camera::PRE_RENDER);
// tell the camera to use OpenGL frame buffer object where supported.
renderCamera->setRenderTargetImplementation(renderImplementation);
// attach the texture and use it as the color buffer.
renderCamera->attach(osg::Camera::COLOR_BUFFER, texture,
0, 0, false,
samples, colorSamples);
// add subgraph to render
renderCamera->addChild(model);
osg::Group* projectorScene = new osg::Group;
base = createBase();
/* Enable projective texturing for all objects of base */
if(useGraph){
base->setStateSet(createProjectorState(texture, viewerPos, graphPos - viewerPos, viewerFOV));
}
else{
base->setStateSet(createProjectorState(texture, viewerPos, viewerDir, viewerFOV));
}
projectorScene->addChild(base);
projectorScene->addChild(renderCamera);
return projectorScene;
}
