bool BaseRenderer::pre_visit(Object& obj) {
modelview().push();
kmMat4 trans;
kmMat4Identity(&trans);
kmMat4Translation(&trans, obj.absolute_position().x, obj.absolute_position().y, obj.absolute_position().z);
kmMat4Multiply(&modelview().top(), &modelview().top(), &trans);
return true;
}
void Pane::DrawCursor() const
{
if (m_visible == false)
return;
if (!m_cursorInPane)
return;
// Restore current program when we're done; we are rendering to FBO
GLint prog = 0;
glGetIntegerv(GL_CURRENT_PROGRAM, &prog);
glUseProgram(m_cursorShader.prog());
{
glm::mat4 modelview(1.0f);
modelview = glm::translate(modelview, glm::vec3(m_pointerCoords, 0.0f));
glm::mat4 projection = glm::ortho(0.0f, 1.0f, 1.0f, 0.0f, -1.0f, 1.0f);
glUniformMatrix4fv(m_cursorShader.GetUniLoc("mvmtx"), 1, false, glm::value_ptr(modelview));
glUniformMatrix4fv(m_cursorShader.GetUniLoc("prmtx"), 1, false, glm::value_ptr(projection));
m_cursorShader.bindVAO();
{
glDrawArrays(GL_TRIANGLE_FAN, 0, 3);
}
glBindVertexArray(0);
}
glUseProgram(prog);
}
void TextEngine::draw( const kvs::Vec3& p, const std::string& text, kvs::ScreenBase* screen ) const
{
GLdouble model[16]; kvs::OpenGL::GetModelViewMatrix( model );
GLdouble proj[16]; kvs::OpenGL::GetProjectionMatrix( proj );
GLint view[4]; kvs::OpenGL::GetViewport( view );
GLdouble winx = 0, winy = 0, winz = 0;
kvs::OpenGL::Project( p.x(), p.y(), p.z(), model, proj, view, &winx, &winy, &winz );
kvs::OpenGL::WithPushedAttrib attrib( GL_ALL_ATTRIB_BITS );
attrib.disable( GL_TEXTURE_1D );
attrib.disable( GL_TEXTURE_2D );
// attrib.enable( GL_TEXTURE_2D );
attrib.disable( GL_TEXTURE_3D );
attrib.enable( GL_DEPTH_TEST );
attrib.enable( GL_BLEND );
{
kvs::OpenGL::SetBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
kvs::OpenGL::WithPushedMatrix modelview( GL_MODELVIEW );
modelview.loadIdentity();
{
kvs::OpenGL::WithPushedMatrix projection( GL_PROJECTION );
projection.loadIdentity();
{
const GLint left = view[0];
const GLint top = view[1];
const GLint right = view[0] + view[2];
const GLint bottom = view[1] + view[3];
kvs::OpenGL::SetOrtho( left, right, bottom, top, 0, 1 );
kvs::OpenGL::Translate( 0, 0, -winz );
m_font.draw( kvs::Vec2( winx, top - ( winy - bottom ) ), text );
}
}
}
}
void TextEngine::draw( const kvs::Vec2& p, const std::string& text, kvs::ScreenBase* screen ) const
{
GLint view[4]; kvs::OpenGL::GetViewport( view );
kvs::OpenGL::WithPushedAttrib attrib( GL_ALL_ATTRIB_BITS );
attrib.disable( GL_TEXTURE_1D );
attrib.disable( GL_TEXTURE_2D );
// attrib.enable( GL_TEXTURE_2D );
attrib.disable( GL_TEXTURE_3D );
attrib.disable( GL_DEPTH_TEST );
attrib.enable( GL_BLEND );
attrib.enable( GL_CULL_FACE );
{
kvs::OpenGL::SetBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
kvs::OpenGL::WithPushedMatrix modelview( GL_MODELVIEW );
modelview.loadIdentity();
{
kvs::OpenGL::WithPushedMatrix projection( GL_PROJECTION );
projection.loadIdentity();
{
kvs::OpenGL::Enable( GL_TEXTURE_2D );
kvs::OpenGL::Enable( GL_BLEND );
kvs::OpenGL::SetBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
const GLint left = view[0];
const GLint top = view[1];
const GLint right = view[0] + view[2];
const GLint bottom = view[1] + view[3];
kvs::OpenGL::SetOrtho( left, right, bottom, top, 0, 1 );
m_font.draw( p, text );
}
}
}
}
void BaseRenderer::render(Scene& scene) {
on_start_render(scene);
//FIXME: This is ugly and inconsistent
scene.active_camera().apply(&modelview().top());
kmMat4Assign(&projection().top(), &scene.active_camera().projection_matrix());
for(Scene::iterator it = scene.begin(); it != scene.end(); ++it) {
Object& object = static_cast<Object&>(*it);
if(pre_visit(object)) {
(*this)(object);
post_visit(object);
}
}
//Reset the modelview and projection for the overlay
kmMat4Identity(&modelview().top());
kmMat4Identity(&projection().top());
/*
Once the entire scene has been rendered, it's time to handle the
overlays.
*/
for(uint32_t i = 0; i < scene.overlay_count(); ++i) {
Overlay& overlay = scene.overlay_ordered_by_zindex(i);
projection().push();
for(Scene::iterator it = overlay.begin(); it != overlay.end(); ++it) {
Object& object = static_cast<Object&>(*it);
if(pre_visit(object)) {
(*this)(object);
post_visit(object);
}
}
projection().pop();
}
on_finish_render(scene);
}
void Gameobject::draw(glm::mat4 object)
{
glm::mat4 modelview(1.0);
glUseProgram(shaderProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
object = glm::translate(object, glm::vec3(position.x, position.y, position.z));
object = glm::scale(object, glm::vec3(scale.x, scale.y, scale.z));
object = glm::rotate(object, float(rotation*DEG_TO_RAD), glm::vec3(0.0f, 1.0f, 0.0f));
rt3d::setUniformMatrix4fv(shaderProgram, "modelview", glm::value_ptr(object));
rt3d::drawIndexedMesh(meshObject, meshIndexCount, GL_TRIANGLES);
}
bool ossimPlanetSceneView::pickObjects(osgUtil::IntersectVisitor::HitList& hits,
osg::Node* startNode,
double vx, double vy,
double /*startPointShift*/)
{
osg::Node* rootNode = 0;
if(startNode)
{
rootNode = startNode;
}
else
{
rootNode = getSceneData();
}
osg::Matrixd proj = getProjectionMatrix();
osg::Matrixd view = getViewMatrix();
const osg::Viewport* viewport = getViewport();
osg::Matrixd projToWindow = viewport->computeWindowMatrix();
osg::Vec3d projPt(vx, vy, 1.0);
osg::Vec3d windowPt = projPt*projToWindow;
osg::NodePathList parentNodePaths = rootNode->getParentalNodePaths(rootNode);
for(unsigned int i=0;i<parentNodePaths.size();++i)
{
osg::NodePath& nodePath = parentNodePaths[i];
// remove the intersection node from the nodePath as it'll be accounted for
// in the PickVisitor traversal, so we don't double account for its transform.
if (!nodePath.empty()) nodePath.pop_back();
osg::Matrixd modelview(view);
// modify the view matrix so that it accounts for this nodePath's accumulated transform
if (!nodePath.empty()) modelview.preMult(computeLocalToWorld(nodePath));
osgUtil::PickVisitor pick(viewport, proj, modelview, windowPt[0], windowPt[1]);
pick.setTraversalMask(0xffffffff);
rootNode->accept(pick);
// copy all the hits across to the external hits list
for(osgUtil::PickVisitor::LineSegmentHitListMap::iterator itr = pick.getSegHitList().begin();
itr != pick.getSegHitList().end();
++itr)
{
hits.insert(hits.end(), itr->second.begin(), itr->second.end());
}
}
return !hits.empty();
}
void Draw2D::drawSegment(SDL_Surface *screen,Point3D _ptA, Point3D _ptB, Uint8 r, Uint8 g, Uint8 b)
{
bool ptAOut = false, ptBOut = false;
Point3D ptA = _ptA;
geometryTransformation(ptA);
ptAOut = !modelview(ptA);
Point3D ptB = _ptB;
geometryTransformation(ptB);
ptBOut = !modelview(ptB);
if(ptAOut && ptBOut){return;}
float threahold = 1.0;
if (ptAOut )// A is out
{
Point3D ptBA = ptA-ptB;
if (ptBA.z<threahold&&ptBA.z>-threahold) { ptBA.z = threahold; }
float t = (near-ptB.z)/ptBA.z;
ptA = ptB + ptBA*t;
}
if ( ptBOut)// B is out
{
Point3D ptAB = ptB-ptA;
if (ptAB.z<threahold&&ptAB.z>-threahold) { ptAB.z = threahold; }
float t = (near-ptA.z)/ptAB.z;
ptB = ptA + ptAB*t;
}
Point2D result1 = project(ptA);
Point2D result2 = project(ptB);
drawSegment(screen, result1.x,result1.y,result2.x,result2.y,r,g,b);
}
dVector dSceneRender::ScreenToGlobal (const dVector& screen) const
{
dFloat width = dFloat (GetViewPortWidth());
dFloat height = dFloat (GetViewPortHeight());
dVector p0 (2.0f * screen.m_x / width - 1.0f, 2.0f * (height - screen.m_y) / height - 1.0f, 2.0f * screen.m_z - 1.0f, 1.0f);
dMatrix modelview (GetModelViewMatrix());
dMatrix projection (GetProjectionMatrix());
dMatrix matrix (modelview * projection);
dMatrix invMatrix (matrix.Inverse4x4());
dVector p1 (invMatrix.RotateVector4x4(p0));
p1.m_w = 1.0f / p1.m_w;
p1 = p1.Scale(p1.m_w);
p1.m_w = 1.0f;
return p1;
}
dVector dSceneRender::GlobalToScreen (const dVector& global) const
{
dMatrix modelview (GetModelViewMatrix());
dMatrix projection (GetProjectionMatrix());
dVector screen (projection.RotateVector4x4(modelview.TransformVector(global)));
//dMatrix matrix (modelview * projection);
//dMatrix invMatrix (matrix.Inverse4x4());
//dVector p2 (invMatrix.RotateVector4x4(screen));
dAssert (screen.m_w > 0.0f);
screen.m_w = 1.0f / screen.m_w;
screen = screen.Scale(screen.m_w);
dFloat width = dFloat (GetViewPortWidth());
dFloat height = dFloat (GetViewPortHeight());
screen.m_x = 0.5f * (screen.m_x + 1.0f) * width;
screen.m_y = height - 0.5f * (screen.m_y + 1.0f) * height;
screen.m_z = 0.5f * (screen.m_z + 1.0f);
screen.m_w = 1.0f;
return screen;
}
int main( int argc, char **argv )
{
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);
// set up the usage document, in case we need to print out how to use this program.
arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName());
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the application for presenting 3D interactive slide shows.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
arguments.getApplicationUsage()->addCommandLineOption("-a","Turn auto stepping on by default");
arguments.getApplicationUsage()->addCommandLineOption("-d <float>","Time duration in seconds between layers/slides");
arguments.getApplicationUsage()->addCommandLineOption("-s <float> <float> <float>","width, height, distance and of the screen away from the viewer");
arguments.getApplicationUsage()->addCommandLineOption("--viewer","Start Present3D as the viewer version.");
arguments.getApplicationUsage()->addCommandLineOption("--authoring","Start Present3D as the authoring version, license required.");
arguments.getApplicationUsage()->addCommandLineOption("--master","Start Present3D as the master version, license required.");
arguments.getApplicationUsage()->addCommandLineOption("--slave","Start Present3D as the slave version, license required.");
arguments.getApplicationUsage()->addCommandLineOption("--publishing","Start Present3D as the publishing version, license required.");
arguments.getApplicationUsage()->addCommandLineOption("--timeDelayOnNewSlideWithMovies","Set the time delay on new slide with movies, done to allow movie threads to get in sync with rendering thread.");
arguments.getApplicationUsage()->addCommandLineOption("--targetFrameRate","Set the target frame rate, defaults to 80Hz.");
arguments.getApplicationUsage()->addCommandLineOption("--version","Report the Present3D version.");
arguments.getApplicationUsage()->addCommandLineOption("--print <filename>","Print out slides to a series of image files.");
arguments.getApplicationUsage()->addCommandLineOption("--html <filename>","Print out slides to a series of html & image files.");
arguments.getApplicationUsage()->addCommandLineOption("--loop","Switch on looping of presentation.");
arguments.getApplicationUsage()->addCommandLineOption("--devices","Print the Video input capability via QuickTime and exit.");
// add alias from xml to p3d to provide backwards compatibility for old p3d files.
osgDB::Registry::instance()->addFileExtensionAlias("xml","p3d");
// if user requests devices video capability.
if (arguments.read("-devices") || arguments.read("--devices"))
{
// Force load QuickTime plugin, probe video capability, exit
osgDB::readImageFile("devices.live");
return 1;
}
// read any env vars from presentations before we create viewer to make sure the viewer
// utilises these env vars
if (p3d::readEnvVars(arguments))
{
osg::DisplaySettings::instance()->readEnvironmentalVariables();
}
// set up any logins required for http access
std::string url, username, password;
while(arguments.read("--login",url, username, password))
{
if (!osgDB::Registry::instance()->getAuthenticationMap())
{
osgDB::Registry::instance()->setAuthenticationMap(new osgDB::AuthenticationMap);
osgDB::Registry::instance()->getAuthenticationMap()->addAuthenticationDetails(
url,
new osgDB::AuthenticationDetails(username, password)
);
}
}
#ifdef USE_SDL
SDLIntegration sdlIntegration;
osg::notify(osg::INFO)<<"USE_SDL"<<std::endl;
#endif
bool doSetViewer = true;
std::string configurationFile;
// check env vars for configuration file
const char* str = getenv("PRESENT3D_CONFIG_FILE");
if (!str) str = getenv("OSG_CONFIG_FILE");
if (str) configurationFile = str;
// check command line parameters for configuration file.
while (arguments.read("-c",configurationFile)) {}
osg::Vec4 clearColor(0.0f,0.0f,0.0f,0.0f);
while (arguments.read("--clear-color",clearColor[0],clearColor[1],clearColor[2],clearColor[3])) {}
std::string filename;
if (arguments.read("--spell-check",filename))
{
p3d::SpellChecker spellChecker;
spellChecker.checkP3dXml(filename);
return 1;
}
if (arguments.read("--strip-text",filename))
{
p3d::XmlPatcher patcher;
// patcher.stripP3dXml(filename, osg::notify(osg::NOTICE));
osg::ref_ptr<osgDB::XmlNode> newNode = patcher.simplifyP3dXml(filename);
if (newNode.valid())
{
newNode->write(std::cout);
}
return 1;
}
std::string lhs_filename, rhs_filename;
if (arguments.read("--merge",lhs_filename, rhs_filename))
{
p3d::XmlPatcher patcher;
osg::ref_ptr<osgDB::XmlNode> newNode = patcher.mergeP3dXml(lhs_filename, rhs_filename);
if (newNode.valid())
{
newNode->write(std::cout);
}
return 1;
}
// construct the viewer.
osgViewer::Viewer viewer(arguments);
// set clear colour to black by default.
viewer.getCamera()->setClearColor(clearColor);
if (!configurationFile.empty())
{
viewer.readConfiguration(configurationFile);
doSetViewer = false;
}
const char* p3dDevice = getenv("P3D_DEVICE");
if (p3dDevice)
{
osgDB::StringList devices;
osgDB::split(p3dDevice, devices);
for(osgDB::StringList::iterator i = devices.begin(); i != devices.end(); ++i)
{
addDeviceTo(viewer, *i);
}
}
std::string device;
while (arguments.read("--device", device))
{
addDeviceTo(viewer, device);
}
if (arguments.read("--http-control"))
{
std::string server_address = "localhost";
std::string server_port = "8080";
std::string document_root = "htdocs";
while (arguments.read("--http-server-address", server_address)) {}
while (arguments.read("--http-server-port", server_port)) {}
while (arguments.read("--http-document-root", document_root)) {}
osg::ref_ptr<osgDB::Options> device_options = new osgDB::Options("documentRegisteredHandlers");
osg::ref_ptr<osgGA::Device> rest_http_device = osgDB::readFile<osgGA::Device>(server_address+":"+server_port+"/"+document_root+".resthttp", device_options.get());
if (rest_http_device.valid())
{
viewer.addDevice(rest_http_device.get());
}
}
// set up stereo masks
viewer.getCamera()->setCullMask(0xffffffff);
viewer.getCamera()->setCullMaskLeft(0x00000001);
viewer.getCamera()->setCullMaskRight(0x00000002);
// set up the camera manipulators.
{
osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;
keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );
std::string pathfile;
char keyForAnimationPath = '5';
while (arguments.read("-p",pathfile))
{
osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
if (apm || !apm->valid())
{
unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
keyswitchManipulator->selectMatrixManipulator(num);
++keyForAnimationPath;
}
}
viewer.setCameraManipulator( keyswitchManipulator.get() );
}
// add the state manipulator
osg::ref_ptr<osgGA::StateSetManipulator> ssManipulator = new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet());
ssManipulator->setKeyEventToggleTexturing('e');
viewer.addEventHandler( ssManipulator.get() );
// add the state manipulator
viewer.addEventHandler( new osgViewer::StatsHandler() );
viewer.addEventHandler( new osgViewer::WindowSizeHandler() );
// neeed to address.
// viewer.getScene()->getUpdateVisitor()->setTraversalMode(osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN);
const char* p3dCursor = getenv("P3D_CURSOR");
std::string cursorFileName( p3dCursor ? p3dCursor : "");
while (arguments.read("--cursor",cursorFileName)) {}
while (arguments.read("--set-viewer")) { doSetViewer = true; }
while (arguments.read("--no-set-viewer")) { doSetViewer = false; }
// cluster related entries.
int socketNumber=8100;
while (arguments.read("-n",socketNumber)) {}
float camera_fov=-1.0f;
while (arguments.read("-f",camera_fov)) {}
float camera_offset=45.0f;
while (arguments.read("-o",camera_offset)) {}
std::string exportName;
while (arguments.read("--print",exportName)) {}
while (arguments.read("--html",exportName)) {}
// read any time delay argument.
float timeDelayBetweenSlides = 1.0f;
while (arguments.read("-d",timeDelayBetweenSlides)) {}
bool autoSteppingActive = false;
while (arguments.read("-a")) autoSteppingActive = true;
bool loopPresentation = false;
while (arguments.read("--loop")) loopPresentation = true;
{
// set update hte default traversal mode settings for update visitor
// default to osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN.
osg::NodeVisitor::TraversalMode updateTraversalMode = osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN; // viewer.getUpdateVisitor()->getTraversalMode();
const char* p3dUpdateStr = getenv("P3D_UPDATE");
if (p3dUpdateStr)
{
std::string updateStr(p3dUpdateStr);
if (updateStr=="active" || updateStr=="Active" || updateStr=="ACTIVE") updateTraversalMode = osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN;
else if (updateStr=="all" || updateStr=="All" || updateStr=="ALL") updateTraversalMode = osg::NodeVisitor::TRAVERSE_ALL_CHILDREN;
}
while(arguments.read("--update-active")) updateTraversalMode = osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN;
while(arguments.read("--update-all")) updateTraversalMode = osg::NodeVisitor::TRAVERSE_ALL_CHILDREN;
viewer.getUpdateVisitor()->setTraversalMode(updateTraversalMode);
}
// register the slide event handler - which moves the presentation from slide to slide, layer to layer.
osg::ref_ptr<osgPresentation::SlideEventHandler> seh = new osgPresentation::SlideEventHandler(&viewer);
viewer.addEventHandler(seh.get());
seh->setAutoSteppingActive(autoSteppingActive);
seh->setTimeDelayBetweenSlides(timeDelayBetweenSlides);
seh->setLoopPresentation(loopPresentation);
double targetFrameRate = 80.0;
while (arguments.read("--targetFrameRate",targetFrameRate)) {}
// set the time delay
float timeDelayOnNewSlideWithMovies = 0.4f;
while (arguments.read("--timeDelayOnNewSlideWithMovies",timeDelayOnNewSlideWithMovies)) {}
seh->setTimeDelayOnNewSlideWithMovies(timeDelayOnNewSlideWithMovies);
// set up optimizer options
unsigned int optimizer_options = osgUtil::Optimizer::DEFAULT_OPTIMIZATIONS;
bool relase_and_compile = false;
while (arguments.read("--release-and-compile"))
{
relase_and_compile = true;
}
seh->setReleaseAndCompileOnEachNewSlide(relase_and_compile);
if (relase_and_compile)
{
// make sure that imagery stays around after being applied to textures.
viewer.getDatabasePager()->setUnrefImageDataAfterApplyPolicy(true,false);
optimizer_options &= ~osgUtil::Optimizer::OPTIMIZE_TEXTURE_SETTINGS;
}
//
// osgDB::Registry::instance()->getOrCreateDatabasePager()->setUnrefImageDataAfterApplyPolicy(true,false);
// optimizer_options &= ~osgUtil::Optimizer::OPTIMIZE_TEXTURE_SETTINGS;
// osg::Texture::getTextureObjectManager()->setExpiryDelay(0.0f);
// osgDB::Registry::instance()->getOrCreateDatabasePager()->setExpiryDelay(1.0f);
// register the handler for modifying the point size
osg::ref_ptr<PointsEventHandler> peh = new PointsEventHandler;
viewer.addEventHandler(peh.get());
// add the screen capture handler
std::string screenCaptureFilename = "screen_shot.jpg";
while(arguments.read("--screenshot", screenCaptureFilename)) {}
osg::ref_ptr<osgViewer::ScreenCaptureHandler::WriteToFile> writeFile = new osgViewer::ScreenCaptureHandler::WriteToFile(
osgDB::getNameLessExtension(screenCaptureFilename),
osgDB::getFileExtension(screenCaptureFilename) );
osg::ref_ptr<osgViewer::ScreenCaptureHandler> screenCaptureHandler = new osgViewer::ScreenCaptureHandler(writeFile.get());
screenCaptureHandler->setKeyEventTakeScreenShot('m');//osgGA::GUIEventAdapter::KEY_Print);
screenCaptureHandler->setKeyEventToggleContinuousCapture('M');
viewer.addEventHandler(screenCaptureHandler.get());
// osg::DisplaySettings::instance()->setSplitStereoAutoAjustAspectRatio(false);
float width = osg::DisplaySettings::instance()->getScreenWidth();
float height = osg::DisplaySettings::instance()->getScreenHeight();
float distance = osg::DisplaySettings::instance()->getScreenDistance();
while (arguments.read("-s", width, height, distance))
{
osg::DisplaySettings::instance()->setScreenDistance(distance);
osg::DisplaySettings::instance()->setScreenHeight(height);
osg::DisplaySettings::instance()->setScreenWidth(width);
}
std::string outputFileName;
while(arguments.read("--output",outputFileName)) {}
// get details on keyboard and mouse bindings used by the viewer.
viewer.getUsage(*arguments.getApplicationUsage());
// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
arguments.getApplicationUsage()->write(osg::notify(osg::NOTICE));
return 1;
}
P3DApplicationType P3DApplicationType = VIEWER;
str = getenv("PRESENT3D_TYPE");
if (str)
{
if (strcmp(str,"viewer")==0) P3DApplicationType = VIEWER;
else if (strcmp(str,"master")==0) P3DApplicationType = MASTER;
else if (strcmp(str,"slave")==0) P3DApplicationType = SLAVE;
}
while (arguments.read("--viewer")) { P3DApplicationType = VIEWER; }
while (arguments.read("--master")) { P3DApplicationType = MASTER; }
while (arguments.read("--slave")) { P3DApplicationType = SLAVE; }
while (arguments.read("--version"))
{
std::string appTypeName = "invalid";
switch(P3DApplicationType)
{
case(VIEWER): appTypeName = "viewer"; break;
case(MASTER): appTypeName = "master"; break;
case(SLAVE): appTypeName = "slave"; break;
}
osg::notify(osg::NOTICE)<<std::endl;
osg::notify(osg::NOTICE)<<"Present3D "<<appTypeName<<" version : "<<s_version<<std::endl;
osg::notify(osg::NOTICE)<<std::endl;
return 0;
}
// any option left unread are converted into errors to write out later.
//arguments.reportRemainingOptionsAsUnrecognized();
// report any errors if they have ocured when parsing the program aguments.
if (arguments.errors())
{
arguments.writeErrorMessages(osg::notify(osg::INFO));
return 1;
}
// read files name from arguments.
p3d::FileNameList xmlFiles, normalFiles;
if (!p3d::getFileNames(arguments, xmlFiles, normalFiles))
{
osg::notify(osg::NOTICE)<<std::endl;
osg::notify(osg::NOTICE)<<"No file specified, please specify and file to load."<<std::endl;
osg::notify(osg::NOTICE)<<std::endl;
return 1;
}
bool viewerInitialized = false;
if (!xmlFiles.empty())
{
osg::ref_ptr<osg::Node> holdingModel = p3d::readHoldingSlide(xmlFiles.front());
if (holdingModel.valid())
{
viewer.setSceneData(holdingModel.get());
seh->selectSlide(0);
if (!viewerInitialized)
{
// pass the global stateset to the point event handler so that it can
// alter the point size of all points in the scene.
peh->setStateSet(viewer.getCamera()->getOrCreateStateSet());
// create the windows and run the threads.
viewer.realize();
if (doSetViewer) setViewer(viewer, width, height, distance);
viewerInitialized = true;
}
seh->home();
// render a frame
viewer.frame();
}
}
osg::Timer timer;
osg::Timer_t start_tick = timer.tick();
osg::ref_ptr<osgDB::ReaderWriter::Options> cacheAllOption = new osgDB::ReaderWriter::Options;
cacheAllOption->setObjectCacheHint(osgDB::ReaderWriter::Options::CACHE_ALL);
osgDB::Registry::instance()->setOptions(cacheAllOption.get());
// read the scene from the list of file specified commandline args.
osg::ref_ptr<osg::Node> loadedModel = p3d::readShowFiles(arguments,cacheAllOption.get()); // osgDB::readNodeFiles(arguments, cacheAllOption.get());
osgDB::Registry::instance()->setOptions( 0 );
// if no model has been successfully loaded report failure.
if (!loadedModel)
{
osg::notify(osg::INFO) << arguments.getApplicationName() <<": No data loaded" << std::endl;
return 1;
}
osg::Timer_t end_tick = timer.tick();
osg::notify(osg::INFO) << "Time to load = "<<timer.delta_s(start_tick,end_tick)<<std::endl;
if (loadedModel->getNumDescriptions()>0)
{
for(unsigned int i=0; i<loadedModel->getNumDescriptions(); ++i)
{
const std::string& desc = loadedModel->getDescription(i);
if (desc=="loop")
{
osg::notify(osg::NOTICE)<<"Enabling looping"<<std::endl;
seh->setLoopPresentation(true);
}
else if (desc=="auto")
{
osg::notify(osg::NOTICE)<<"Enabling auto run"<<std::endl;
seh->setAutoSteppingActive(true);
}
}
}
processLoadedModel(loadedModel, optimizer_options, cursorFileName);
// set the scene to render
viewer.setSceneData(loadedModel.get());
if (!viewerInitialized)
{
// pass the global stateset to the point event handler so that it can
// alter the point size of all points in the scene.
peh->setStateSet(viewer.getCamera()->getOrCreateStateSet());
// create the windows and run the threads.
viewer.realize();
if (doSetViewer) setViewer(viewer, width, height, distance);
viewerInitialized = true;
}
// pass the model to the slide event handler so it knows which to manipulate.
seh->set(loadedModel.get());
seh->selectSlide(0);
seh->home();
if (!outputFileName.empty())
{
osgDB::writeNodeFile(*loadedModel,outputFileName);
return 0;
}
if (!cursorFileName.empty())
{
// have to add a frame in here to avoid problems with X11 threading issue on switching off the cursor
// not yet sure why it makes a difference, but it at least fixes the crash that would otherwise occur
// under X11.
viewer.frame();
// switch off the cursor
osgViewer::Viewer::Windows windows;
viewer.getWindows(windows);
for(osgViewer::Viewer::Windows::iterator itr = windows.begin();
itr != windows.end();
++itr)
{
(*itr)->useCursor(false);
}
}
osg::Timer_t startOfFrameTick = osg::Timer::instance()->tick();
double targetFrameTime = 1.0/targetFrameRate;
if (exportName.empty())
{
// objects for managing the broadcasting and recieving of camera packets.
CameraPacket cp;
Broadcaster bc;
Receiver rc;
bc.setPort(static_cast<short int>(socketNumber));
rc.setPort(static_cast<short int>(socketNumber));
bool masterKilled = false;
DataConverter scratchPad(1024);
while( !viewer.done() && !masterKilled)
{
// wait for all cull and draw threads to complete.
viewer.advance();
osg::Timer_t currentTick = osg::Timer::instance()->tick();
double deltaTime = osg::Timer::instance()->delta_s(startOfFrameTick, currentTick);
if (deltaTime<targetFrameTime)
{
OpenThreads::Thread::microSleep(static_cast<unsigned int>((targetFrameTime-deltaTime)*1000000.0));
}
startOfFrameTick = osg::Timer::instance()->tick();
#if 0
if (kmcb)
{
double time = kmcb->getTime();
viewer.getFrameStamp()->setReferenceTime(time);
}
#endif
#ifdef USE_SDL
sdlIntegration.update(viewer);
#endif
if (P3DApplicationType==MASTER)
{
// take camera zero as the guide.
osg::Matrix modelview(viewer.getCamera()->getViewMatrix());
cp.setPacket(modelview,viewer.getFrameStamp());
// cp.readEventQueue(viewer);
scratchPad.reset();
scratchPad.write(cp);
scratchPad.reset();
scratchPad.read(cp);
bc.setBuffer(scratchPad.startPtr(), scratchPad.numBytes());
std::cout << "bc.sync()"<<scratchPad.numBytes()<<std::endl;
bc.sync();
}
else if (P3DApplicationType==SLAVE)
{
rc.setBuffer(scratchPad.startPtr(), scratchPad.numBytes());
rc.sync();
scratchPad.reset();
scratchPad.read(cp);
// cp.writeEventQueue(viewer);
if (cp.getMasterKilled())
{
std::cout << "Received master killed."<<std::endl;
// break out of while (!done) loop since we've now want to shut down.
masterKilled = true;
}
}
// update the scene by traversing it with the the update visitor which will
// call all node update callbacks and animations.
viewer.eventTraversal();
if (seh->getRequestReload())
{
OSG_INFO<<"Reload requested"<<std::endl;
seh->setRequestReload(false);
int previous_ActiveSlide = seh->getActiveSlide();
int previous_ActiveLayer = seh->getActiveLayer();
// reset time so any event key generate
loadedModel = p3d::readShowFiles(arguments,cacheAllOption.get());
processLoadedModel(loadedModel, optimizer_options, cursorFileName);
if (!loadedModel)
{
return 0;
}
viewer.setSceneData(loadedModel.get());
seh->set(loadedModel.get());
seh->selectSlide(previous_ActiveSlide, previous_ActiveLayer);
continue;
}
// update the scene by traversing it with the the update visitor which will
// call all node update callbacks and animations.
viewer.updateTraversal();
if (P3DApplicationType==SLAVE)
{
osg::Matrix modelview;
cp.getModelView(modelview,camera_offset);
viewer.getCamera()->setViewMatrix(modelview);
}
// fire off the cull and draw traversals of the scene.
if(!masterKilled)
viewer.renderingTraversals();
}
}
else
{
ExportHTML::write(seh.get(), viewer, exportName);
}
return 0;
}
void BBoxDeco::render(RenderContext* renderContext)
{
AABox bbox = renderContext->scene->getBoundingBox();
if (bbox.isValid()) {
Vertex center = bbox.getCenter();
bbox += center + (bbox.vmin - center)*expand;
bbox += center + (bbox.vmax - center)*expand;
// Sphere bsphere(bbox);
glPushAttrib(GL_ENABLE_BIT);
int i,j;
// vertex array:
Vertex4 boxv[8] = {
Vertex4( bbox.vmin.x, bbox.vmin.y, bbox.vmin.z ),
Vertex4( bbox.vmax.x, bbox.vmin.y, bbox.vmin.z ),
Vertex4( bbox.vmin.x, bbox.vmax.y, bbox.vmin.z ),
Vertex4( bbox.vmax.x, bbox.vmax.y, bbox.vmin.z ),
Vertex4( bbox.vmin.x, bbox.vmin.y, bbox.vmax.z ),
Vertex4( bbox.vmax.x, bbox.vmin.y, bbox.vmax.z ),
Vertex4( bbox.vmin.x, bbox.vmax.y, bbox.vmax.z ),
Vertex4( bbox.vmax.x, bbox.vmax.y, bbox.vmax.z )
};
Vertex4 eyev[8];
// transform vertices: used for edge distance criterion and text justification
Matrix4x4 modelview(renderContext->modelview);
for(i=0;i<8;i++)
eyev[i] = modelview * boxv[i];
// setup material
material.beginUse(renderContext);
if (material.line_antialias || material.isTransparent()) {
// SETUP BLENDING
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// ENABLE BLENDING
glEnable(GL_BLEND);
}
// edge adjacent matrix
int adjacent[8][8] = { { 0 } };
// draw back faces
// construct adjacent matrix
glBegin(GL_QUADS);
for(i=0;i<6;i++) {
const Vertex4 q = modelview * side[i].normal;
const Vertex4 view(0.0f,0.0f,1.0f,0.0f);
float cos_a = view * q;
const bool front = (cos_a >= 0.0f) ? true : false;
if (!front) {
// draw back face
glNormal3f(side[i].normal.x, side[i].normal.y, side[i].normal.z);
for(j=0;j<4;j++) {
// modify adjacent matrix
int from = side[i].vidx[j];
int to = side[i].vidx[(j+1)%4];
adjacent[from][to] = 1;
// feed vertex
Vertex4& v = boxv[ side[i].vidx[j] ];
glVertex3f(v.x, v.y, v.z);
}
}
}
glEnd();
// setup mark length
Vertex marklen = getMarkLength(bbox);
// draw axis and tickmarks
// find contours
glDisable(GL_LIGHTING);
material.useColor(1);
for(i=0;i<3;i++) {
Vertex4 v;
AxisInfo* axis;
Edge* axisedge;
int nedges;
float* valueptr;
float low, high;
switch(i)
{
case 0:
axis = &xaxis;
axisedge = xaxisedge;
nedges = 4;
valueptr = &v.x;
low = bbox.vmin.x;
high = bbox.vmax.x;
break;
case 1:
axis = &yaxis;
axisedge = yaxisedge;
nedges = 8;
valueptr = &v.y;
low = bbox.vmin.y;
high = bbox.vmax.y;
break;
case 2:
default:
axis = &zaxis;
axisedge = zaxisedge;
nedges = 4;
valueptr = &v.z;
low = bbox.vmin.z;
high = bbox.vmax.z;
break;
}
if (axis->mode == AXIS_NONE)
continue;
// search z-nearest contours
float d = FLT_MAX;
Edge* edge = NULL;
for(j=0;j<nedges;j++) {
int from = axisedge[j].from;
int to = axisedge[j].to;
if ((adjacent[from][to] == 1) && (adjacent[to][from] == 0)) {
// found contour
float dtmp = -(eyev[from].z + eyev[to].z)/2.0f;
if (dtmp < d) {
// found near contour
d = dtmp;
edge = &axisedge[j];
}
}
}
if (edge) {
v = boxv[edge->from];
switch (axis->mode) {
case AXIS_CUSTOM:
{
// draw axis and tickmarks
StringArrayIterator iter(&axis->textArray);
for (iter.first(), j=0; (j<axis->nticks) && (!iter.isDone());j++, iter.next()) {
float value = axis->ticks[j];
// clip marks
if ((value >= low) && (value <= high)) {
String string = iter.getCurrent();
*valueptr = value;
axis->draw(renderContext, v, edge->dir, modelview, marklen, string);
}
}
}
break;
case AXIS_LENGTH:
{
float delta = (axis->len>1) ? (high-low)/((axis->len)-1) : 0;
for(int k=0;k<axis->len;k++)
{
float value = low + delta * (float)k;
*valueptr = value;
char text[32];
sprintf(text, "%.4g", value);
String string(strlen(text),text);
axis->draw(renderContext, v, edge->dir, modelview, marklen, string);
}
}
break;
case AXIS_UNIT:
{
float value = ( (float) ( (int) ( ( low+(axis->unit-1) ) / (axis->unit) ) ) ) * (axis->unit);
while(value < high) {
*valueptr = value;
char text[32];
sprintf(text, "%.4g", value);
String s (strlen(text),text);
axis->draw(renderContext, v, edge->dir, modelview, marklen, s );
value += axis->unit;
}
}
break;
}
}
}
material.endUse(renderContext);
glPopAttrib();
}
}
int main( int argc, char **argv )
{
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);
// set up the usage document, in case we need to print out how to use this program.
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrates how to approach implementation of clustering.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
arguments.getApplicationUsage()->addCommandLineOption("-m","Set viewer to MASTER mode, sending view via packets.");
arguments.getApplicationUsage()->addCommandLineOption("-s","Set viewer to SLAVE mode, receiving view via packets.");
arguments.getApplicationUsage()->addCommandLineOption("-n <int>","Socket number to transmit packets");
arguments.getApplicationUsage()->addCommandLineOption("-f <float>","Field of view of camera");
arguments.getApplicationUsage()->addCommandLineOption("-o <float>","Offset angle of camera");
// construct the viewer.
osgViewer::Viewer viewer;
// read up the osgcluster specific arguments.
ViewerMode viewerMode = STAND_ALONE;
while (arguments.read("-m")) viewerMode = MASTER;
while (arguments.read("-s")) viewerMode = SLAVE;
int socketNumber=8100;
while (arguments.read("-n",socketNumber)) ;
float camera_fov=-1.0f;
while (arguments.read("-f",camera_fov))
{
}
float camera_offset=45.0f;
while (arguments.read("-o",camera_offset)) ;
// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
arguments.getApplicationUsage()->write(std::cout);
return 1;
}
// any option left unread are converted into errors to write out later.
arguments.reportRemainingOptionsAsUnrecognized();
// report any errors if they have occured when parsing the program aguments.
if (arguments.errors())
{
arguments.writeErrorMessages(std::cout);
return 1;
}
if (arguments.argc()<=1)
{
arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
return 1;
}
// load model.
osg::ref_ptr<osg::Node> rootnode = osgDB::readNodeFiles(arguments);
// set the scene to render
viewer.setSceneData(rootnode.get());
if (camera_fov>0.0f)
{
double fovy, aspectRatio, zNear, zFar;
viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar);
double original_fov = atan(tan(osg::DegreesToRadians(fovy)*0.5)*aspectRatio)*2.0;
std::cout << "setting lens perspective : original "<<original_fov<<" "<<fovy<<std::endl;
fovy = atan(tan(osg::DegreesToRadians(camera_fov)*0.5)/aspectRatio)*2.0;
viewer.getCamera()->setProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar);
viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar);
original_fov = atan(tan(osg::DegreesToRadians(fovy)*0.5)*aspectRatio)*2.0;
std::cout << "setting lens perspective : new "<<original_fov<<" "<<fovy<<std::endl;
}
viewer.setCameraManipulator(new osgGA::TrackballManipulator());
// add the stats handler
viewer.addEventHandler(new osgViewer::StatsHandler);
// add the state manipulator
viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
// create the windows and run the threads.
viewer.realize();
CameraPacket *cp = new CameraPacket;
// objects for managing the broadcasting and recieving of camera packets.
Broadcaster bc;
Receiver rc;
bc.setPort(static_cast<short int>(socketNumber));
rc.setPort(static_cast<short int>(socketNumber));
bool masterKilled = false;
DataConverter scratchPad(1024);
while( !viewer.done() && !masterKilled )
{
osg::Timer_t startTick = osg::Timer::instance()->tick();
viewer.advance();
// special handling for working as a cluster.
switch (viewerMode)
{
case(MASTER):
{
// take camera zero as the guide.
osg::Matrix modelview(viewer.getCamera()->getViewMatrix());
cp->setPacket(modelview,viewer.getFrameStamp());
cp->readEventQueue(viewer);
scratchPad.reset();
scratchPad.write(*cp);
scratchPad.reset();
scratchPad.read(*cp);
bc.setBuffer(scratchPad._startPtr, scratchPad._numBytes);
std::cout << "bc.sync()"<<scratchPad._numBytes<<std::endl;
bc.sync();
}
break;
case(SLAVE):
{
rc.setBuffer(scratchPad._startPtr, scratchPad._numBytes);
rc.sync();
scratchPad.reset();
scratchPad.read(*cp);
cp->writeEventQueue(viewer);
if (cp->getMasterKilled())
{
std::cout << "Received master killed."<<std::endl;
// break out of while (!done) loop since we've now want to shut down.
masterKilled = true;
}
}
break;
default:
// no need to anything here, just a normal interactive viewer.
break;
}
osg::Timer_t endTick = osg::Timer::instance()->tick();
osg::notify(osg::INFO)<<"Time to do cluster sync "<<osg::Timer::instance()->delta_m(startTick,endTick)<<std::endl;
// update the scene by traversing it with the update visitor which will
// call all node update callbacks and animations.
viewer.eventTraversal();
viewer.updateTraversal();
if (viewerMode==SLAVE)
{
osg::Matrix modelview;
cp->getModelView(modelview,camera_offset);
viewer.getCamera()->setViewMatrix(modelview);
}
// fire off the cull and draw traversals of the scene.
if(!masterKilled)
viewer.renderingTraversals();
}
// if we are master clean up by telling all slaves that we're going down.
if (viewerMode==MASTER)
{
// need to broadcast my death.
cp->setPacket(osg::Matrix::identity(),viewer.getFrameStamp());
cp->setMasterKilled(true);
scratchPad.reset();
scratchPad.write(*cp);
bc.setBuffer(scratchPad._startPtr, scratchPad._numBytes);
bc.sync();
std::cout << "Broadcasting death."<<std::endl;
}
return 0;
}
void LLViewerCamera::setPerspective(BOOL for_selection,
S32 x, S32 y_from_bot, S32 width, S32 height,
BOOL limit_select_distance,
F32 z_near, F32 z_far)
{
F32 fov_y, aspect;
fov_y = RAD_TO_DEG * getView();
BOOL z_default_near, z_default_far = FALSE;
if (z_far <= 0)
{
z_default_far = TRUE;
z_far = getFar();
}
if (z_near <= 0)
{
z_default_near = TRUE;
z_near = getNear();
}
aspect = getAspect();
// Load camera view matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glh::matrix4f proj_mat;
if (for_selection)
{
// make a tiny little viewport
// anything drawn into this viewport will be "selected"
GLint viewport[4];
viewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
viewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;
viewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth();
viewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight();
proj_mat = gl_pick_matrix(x+width/2.f, y_from_bot+height/2.f, (GLfloat) width, (GLfloat) height, viewport);
if (limit_select_distance)
{
// ...select distance from control
z_far = gSavedSettings.getF32("MaxSelectDistance");
}
else
{
z_far = gAgent.mDrawDistance;
}
}
else
{
// Only override the far clip if it's not passed in explicitly.
if (z_default_far)
{
z_far = MAX_FAR_CLIP;
}
glViewport(x, y_from_bot, width, height);
gGLViewport[0] = x;
gGLViewport[1] = y_from_bot;
gGLViewport[2] = width;
gGLViewport[3] = height;
}
if (mZoomFactor > 1.f)
{
float offset = mZoomFactor - 1.f;
int pos_y = mZoomSubregion / llceil(mZoomFactor);
int pos_x = mZoomSubregion - (pos_y*llceil(mZoomFactor));
glh::matrix4f translate;
translate.set_translate(glh::vec3f(offset - (F32)pos_x * 2.f, offset - (F32)pos_y * 2.f, 0.f));
glh::matrix4f scale;
scale.set_scale(glh::vec3f(mZoomFactor, mZoomFactor, 1.f));
proj_mat = scale*proj_mat;
proj_mat = translate*proj_mat;
}
calcProjection(z_far); // Update the projection matrix cache
proj_mat *= gl_perspective(fov_y,aspect,z_near,z_far);
glLoadMatrixf(proj_mat.m);
for (U32 i = 0; i < 16; i++)
{
gGLProjection[i] = proj_mat.m[i];
}
glMatrixMode( GL_MODELVIEW );
glh::matrix4f modelview((GLfloat*) OGL_TO_CFR_ROTATION);
GLfloat ogl_matrix[16];
getOpenGLTransform(ogl_matrix);
modelview *= glh::matrix4f(ogl_matrix);
glLoadMatrixf(modelview.m);
if (for_selection && (width > 1 || height > 1))
{
// NB: as of this writing, i believe the code below is broken (doesn't take into account the world view, assumes entire window)
// however, it is also unused (the GL matricies are used for selection, (see LLCamera::sphereInFrustum())) and so i'm not
// comfortable hacking on it.
calculateFrustumPlanesFromWindow((F32)(x - width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
(F32)(y_from_bot - height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f,
(F32)(x + width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
(F32)(y_from_bot + height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f);
}
// if not picking and not doing a snapshot, cache various GL matrices
if (!for_selection && mZoomFactor == 1.f)
{
// Save GL matrices for access elsewhere in code, especially project_world_to_screen
//glGetDoublev(GL_MODELVIEW_MATRIX, gGLModelView);
for (U32 i = 0; i < 16; i++)
{
gGLModelView[i] = modelview.m[i];
}
}
updateFrustumPlanes(*this);
/*if (gSavedSettings.getBOOL("CameraOffset"))
{
glMatrixMode(GL_PROJECTION);
glTranslatef(0,0,-50);
glRotatef(20.0,1,0,0);
glMatrixMode(GL_MODELVIEW);
}*/
}
void BaseRenderer::post_visit(Object& object) {
modelview().pop();
}
void Text3D::drawImplementation(osg::RenderInfo& renderInfo) const
{
osg::State & state = *renderInfo.getState();
unsigned int contextID = state.getContextID();
// ** save the previous modelview matrix
osg::ref_ptr<osg::RefMatrix> previous(new osg::RefMatrix(state.getModelViewMatrix()));
// ** get the modelview for this context
osg::ref_ptr<osg::RefMatrix> modelview(new osg::RefMatrix(_autoTransformCache[contextID]._matrix));
// ** mult previous by the modelview for this context
modelview->postMult(*previous.get());
// ** apply this new modelview matrix
state.applyModelViewMatrix(modelview.get());
osg::GLBeginEndAdapter& gl = (state.getGLBeginEndAdapter());
if (_drawMode & BOUNDINGBOX)
{
if (_textBB.valid())
{
osg::Vec3 c000(osg::Vec3(_textBB.xMin(),_textBB.yMin(),_textBB.zMax()));
osg::Vec3 c100(osg::Vec3(_textBB.xMax(),_textBB.yMin(),_textBB.zMax()));
osg::Vec3 c110(osg::Vec3(_textBB.xMax(),_textBB.yMax(),_textBB.zMax()));
osg::Vec3 c010(osg::Vec3(_textBB.xMin(),_textBB.yMax(),_textBB.zMax()));
osg::Vec3 c001(osg::Vec3(_textBB.xMin(),_textBB.yMin(),_textBB.zMin()));
osg::Vec3 c101(osg::Vec3(_textBB.xMax(),_textBB.yMin(),_textBB.zMin()));
osg::Vec3 c111(osg::Vec3(_textBB.xMax(),_textBB.yMax(),_textBB.zMin()));
osg::Vec3 c011(osg::Vec3(_textBB.xMin(),_textBB.yMax(),_textBB.zMin()));
gl.Begin(GL_LINE_LOOP);
gl.Vertex3fv(c000.ptr());
gl.Vertex3fv(c100.ptr());
gl.Vertex3fv(c110.ptr());
gl.Vertex3fv(c010.ptr());
gl.End();
gl.Begin(GL_LINE_LOOP);
gl.Vertex3fv(c001.ptr());
gl.Vertex3fv(c011.ptr());
gl.Vertex3fv(c111.ptr());
gl.Vertex3fv(c101.ptr());
gl.End();
gl.Begin(GL_LINES);
gl.Vertex3fv(c000.ptr());
gl.Vertex3fv(c001.ptr());
gl.Vertex3fv(c100.ptr());
gl.Vertex3fv(c101.ptr());
gl.Vertex3fv(c110.ptr());
gl.Vertex3fv(c111.ptr());
gl.Vertex3fv(c010.ptr());
gl.Vertex3fv(c011.ptr());
gl.End();
}
}
if (_drawMode & ALIGNMENT)
{
float cursorsize = _characterHeight*0.5f;
osg::Vec3 hl(osg::Vec3(_offset.x()-cursorsize,_offset.y(),_offset.z()));
osg::Vec3 hr(osg::Vec3(_offset.x()+cursorsize,_offset.y(),_offset.z()));
osg::Vec3 vt(osg::Vec3(_offset.x(),_offset.y()-cursorsize,_offset.z()));
osg::Vec3 vb(osg::Vec3(_offset.x(),_offset.y()+cursorsize,_offset.z()));
gl.Begin(GL_LINES);
gl.Vertex3fv(hl.ptr());
gl.Vertex3fv(hr.ptr());
gl.Vertex3fv(vt.ptr());
gl.Vertex3fv(vb.ptr());
gl.End();
}
if (_drawMode & TEXT)
{
renderInfo.getState()->disableAllVertexArrays();
#if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) && !defined(OSG_GL3_AVAILABLE)
glPushAttrib(GL_TRANSFORM_BIT);
glEnable(GL_RESCALE_NORMAL);
#endif
switch(_renderMode)
{
case PER_FACE: renderPerFace(*renderInfo.getState()); break;
case PER_GLYPH:
default: renderPerGlyph(*renderInfo.getState()); break;
}
#if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) && !defined(OSG_GL3_AVAILABLE)
glPopAttrib();
#endif
}
// restore the previous modelview matrix
state.applyModelViewMatrix(previous.get());
}
