void Virvo::initStateset()
{
StateSet *stateset = new StateSet();
stateset->setMode(GL_LIGHTING, StateAttribute::OFF);
stateset->setMode(GL_BLEND, StateAttribute::ON);
stateset->setRenderBinDetails(100, "RenderBin"); // draw after everything else
setStateSet(stateset);
}
// 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;
}
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;
}
ImpostorSprite* Impostor::createImpostorSprite(osgUtil::CullVisitor* cv)
{
unsigned int contextID = cv->getState() ? cv->getState()->getContextID() : 0;
osgSim::ImpostorSpriteManager* impostorSpriteManager = dynamic_cast<osgSim::ImpostorSpriteManager*>(cv->getUserData());
if (!impostorSpriteManager)
{
impostorSpriteManager = new osgSim::ImpostorSpriteManager;
cv->setUserData(impostorSpriteManager);
}
// default to true right now, will dertermine if perspective from the
// projection matrix...
bool isPerspectiveProjection = true;
const Matrix& matrix = *(cv->getModelViewMatrix());
const BoundingSphere& bs = getBound();
osg::Vec3 eye_local = cv->getEyeLocal();
if (!bs.valid())
{
OSG_WARN << "bb invalid"<<std::endl;
return NULL;
}
Vec3 center_local = bs.center();
Vec3 camera_up_local = cv->getUpLocal();
Vec3 lv_local = center_local-eye_local;
float distance_local = lv_local.length();
lv_local /= distance_local;
Vec3 sv_local = lv_local^camera_up_local;
sv_local.normalize();
Vec3 up_local = sv_local^lv_local;
float width = bs.radius();
if (isPerspectiveProjection)
{
// expand the width to account for projection onto sprite.
width *= (distance_local/sqrtf(distance_local*distance_local-bs.radius2()));
}
// scale up and side vectors to sprite width.
up_local *= width;
sv_local *= width;
// create the corners of the sprite.
Vec3 c00(center_local - sv_local - up_local);
Vec3 c10(center_local + sv_local - up_local);
Vec3 c01(center_local - sv_local + up_local);
Vec3 c11(center_local + sv_local + up_local);
// calc texture size for eye, bs.
// convert the corners of the sprite (in world coords) into their
// equivalent window coordinates by using the camera's project method.
const osg::Matrix& MVPW = *(cv->getMVPW());
Vec3 c00_win = c00 * MVPW;
Vec3 c11_win = c11 * MVPW;
// adjust texture size to be nearest power of 2.
float s = c11_win.x()-c00_win.x();
float t = c11_win.y()-c00_win.y();
// may need to reverse sign of width or height if a matrix has
// been applied which flips the orientation of this subgraph.
if (s<0.0f) s = -s;
if (t<0.0f) t = -t;
// bias value used to assist the rounding up or down of
// the texture dimensions to the nearest power of two.
// bias near 0.0 will almost always round down.
// bias near 1.0 will almost always round up.
float bias = 0.7f;
float sp2 = logf((float)s)/logf(2.0f);
float rounded_sp2 = floorf(sp2+bias);
int new_s = (int)(powf(2.0f,rounded_sp2));
float tp2 = logf((float)t)/logf(2.0f);
float rounded_tp2 = floorf(tp2+bias);
int new_t = (int)(powf(2.0f,rounded_tp2));
const osg::Viewport& viewport = *(cv->getViewport());
// if dimension is bigger than window divide it down.
while (new_s>viewport.width()) new_s /= 2;
// if dimension is bigger than window divide it down.
while (new_t>viewport.height()) new_t /= 2;
// create the impostor sprite.
ImpostorSprite* impostorSprite =
impostorSpriteManager->createOrReuseImpostorSprite(new_s,new_t,cv->getTraversalNumber()-cv->getNumberOfFrameToKeepImpostorSprites());
if (impostorSprite==NULL)
{
OSG_WARN<<"Warning: unable to create required impostor sprite."<<std::endl;
return NULL;
}
// update frame number to show that impostor is in action.
impostorSprite->setLastFrameUsed(cv->getTraversalNumber());
// have successfully created an impostor sprite so now need to
// add it into the impostor.
addImpostorSprite(contextID,impostorSprite);
if (cv->getDepthSortImpostorSprites())
{
// the depth sort bin should probably be user definable,
// will look into this later. RO July 2001.
StateSet* stateset = impostorSprite->getStateSet();
stateset->setRenderBinDetails(10,"DepthSortedBin");
}
osg::Texture2D* texture = impostorSprite->getTexture();
texture->setTextureSize(new_s, new_t);
texture->setInternalFormat(GL_RGBA);
texture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
texture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
// update frame number to show that impostor is in action.
impostorSprite->setLastFrameUsed(cv->getTraversalNumber());
Vec3* coords = impostorSprite->getCoords();
Vec2* texcoords = impostorSprite->getTexCoords();
coords[0] = c01;
texcoords[0].set(0.0f,1.0f);
coords[1] = c00;
texcoords[1].set(0.0f,0.0f);
coords[2] = c10;
texcoords[2].set(1.0f,0.0f);
coords[3] = c11;
texcoords[3].set(1.0f,1.0f);
impostorSprite->dirtyBound();
Vec3* controlcoords = impostorSprite->getControlCoords();
if (isPerspectiveProjection)
{
// deal with projection issue by moving the coorners of the quad
// towards the eye point.
float ratio = width/(center_local-eye_local).length();
float one_minus_ratio = 1.0f-ratio;
Vec3 eye_local_ratio = eye_local*ratio;
controlcoords[0] = coords[0]*one_minus_ratio + eye_local_ratio;
controlcoords[1] = coords[1]*one_minus_ratio + eye_local_ratio;
controlcoords[2] = coords[2]*one_minus_ratio + eye_local_ratio;
controlcoords[3] = coords[3]*one_minus_ratio + eye_local_ratio;
}
else
{
// project the control points forward towards the eyepoint,
// but since this an othographics projection this projection is
// parallel.
Vec3 dv = lv_local*width;
controlcoords[0] = coords[0]-dv;
controlcoords[1] = coords[1]-dv;
controlcoords[2] = coords[2]-dv;
controlcoords[3] = coords[3]-dv;
}
impostorSprite->setStoredLocalEyePoint(eye_local);
Vec3 eye_world(0.0,0.0,0.0);
Vec3 center_world = bs.center()*matrix;
osg::Camera* camera = impostorSprite->getCamera();
if (!camera)
{
camera = new osg::Camera;
impostorSprite->setCamera(camera);
}
camera->setCullCallback(new ImpostorTraverseNodeCallback(this));
osgUtil::RenderStage* previous_stage = cv->getRenderStage();
// set up the background color and clear mask.
osg::Vec4 clear_color = previous_stage->getClearColor();
clear_color[3] = 0.0f; // set thae alpha to zero.
camera->setClearColor(clear_color);
camera->setClearMask(previous_stage->getClearMask());
// adjust camera left,right,up,down to fit (in world coords)
Vec3 near_local ( center_local-lv_local*width );
Vec3 far_local ( center_local+lv_local*width );
Vec3 top_local ( center_local+up_local);
Vec3 right_local ( center_local+sv_local);
Vec3 near_world = near_local * matrix;
Vec3 far_world = far_local * matrix;
Vec3 top_world = top_local * matrix;
Vec3 right_world = right_local * matrix;
float znear = (near_world-eye_world).length();
float zfar = (far_world-eye_world).length();
float top = (top_world-center_world).length();
float right = (right_world-center_world).length();
znear *= 0.9f;
zfar *= 1.1f;
// set up projection.
if (isPerspectiveProjection)
{
// deal with projection issue move the top and right points
// onto the near plane.
float ratio = znear/(center_world-eye_world).length();
top *= ratio;
right *= ratio;
camera->setProjectionMatrixAsFrustum(-right,right,-top,top,znear,zfar);
}
else
{
camera->setProjectionMatrixAsOrtho(-right,right,-top,top,znear,zfar);
}
Vec3 rotate_from = bs.center()-eye_local;
Vec3 rotate_to = cv-> getLookVectorLocal();
osg::Matrix rotate_matrix =
osg::Matrix::translate(-eye_local)*
osg::Matrix::rotate(rotate_from,rotate_to)*
osg::Matrix::translate(eye_local)*
*cv->getModelViewMatrix();
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setViewMatrix(rotate_matrix);
camera->setViewport(0,0,new_s,new_t);
// tell the camera to use OpenGL frame buffer object where supported.
camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT, osg::Camera::FRAME_BUFFER);
// set the camera to render before the main camera.
camera->setRenderOrder(osg::Camera::PRE_RENDER);
// attach the texture and use it as the color buffer.
camera->attach(osg::Camera::COLOR_BUFFER, texture);
// do the cull traversal on the subgraph
camera->accept(*cv);
return impostorSprite;
}
