293 lines
11 KiB
C++
293 lines
11 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
|
|
*
|
|
* This library is open source and may be redistributed and/or modified under
|
|
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
|
* (at your option) any later version. The full license is in LICENSE file
|
|
* included with this distribution, and on the openscenegraph.org website.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* OpenSceneGraph Public License for more details.
|
|
*/
|
|
|
|
#include <osgViewer/config/PanoramicSphericalDisplay>
|
|
#include <osgViewer/Renderer>
|
|
#include <osgViewer/View>
|
|
#include <osgViewer/GraphicsWindow>
|
|
|
|
#include <osg/io_utils>
|
|
|
|
#include <osg/TextureRectangle>
|
|
#include <osg/Texture2D>
|
|
#include <osg/TexMat>
|
|
#include <osg/Stencil>
|
|
#include <osg/PolygonStipple>
|
|
#include <osg/ValueObject>
|
|
|
|
using namespace osgViewer;
|
|
|
|
osg::Geometry* PanoramicSphericalDisplay::createParoramicSphericalDisplayDistortionMesh(const osg::Vec3& origin, const osg::Vec3& widthVector, const osg::Vec3& heightVector, double sphere_radius, double collar_radius, osg::Image* intensityMap, const osg::Matrix& projectorMatrix) const
|
|
{
|
|
osg::Vec3d center(0.0,0.0,0.0);
|
|
osg::Vec3d eye(0.0,0.0,0.0);
|
|
|
|
double distance = sqrt(sphere_radius*sphere_radius - collar_radius*collar_radius);
|
|
bool flip = false;
|
|
bool texcoord_flip = false;
|
|
|
|
osg::Vec3d projector = eye - osg::Vec3d(0.0,0.0, distance);
|
|
|
|
|
|
OSG_INFO<<"createParoramicSphericalDisplayDistortionMesh : Projector position = "<<projector<<std::endl;
|
|
OSG_INFO<<"createParoramicSphericalDisplayDistortionMesh : distance = "<<distance<<std::endl;
|
|
|
|
// create the quad to visualize.
|
|
osg::Geometry* geometry = new osg::Geometry();
|
|
|
|
geometry->setSupportsDisplayList(false);
|
|
|
|
osg::Vec3 xAxis(widthVector);
|
|
float width = widthVector.length();
|
|
xAxis /= width;
|
|
|
|
osg::Vec3 yAxis(heightVector);
|
|
float height = heightVector.length();
|
|
yAxis /= height;
|
|
|
|
int noSteps = 160;
|
|
|
|
osg::Vec3Array* vertices = new osg::Vec3Array;
|
|
osg::Vec2Array* texcoords0 = new osg::Vec2Array;
|
|
osg::Vec2Array* texcoords1 = intensityMap==0 ? new osg::Vec2Array : 0;
|
|
osg::Vec4Array* colors = new osg::Vec4Array;
|
|
|
|
osg::Vec3 top = origin + yAxis*height;
|
|
|
|
osg::Vec3 screenCenter = origin + widthVector*0.5f + heightVector*0.5f;
|
|
float screenRadius = heightVector.length() * 0.5f;
|
|
|
|
geometry->getOrCreateStateSet()->setMode(GL_CULL_FACE, osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED);
|
|
|
|
for(int i=0;i<noSteps;++i)
|
|
{
|
|
for(int j=0;j<noSteps;++j)
|
|
{
|
|
osg::Vec2 texcoord(double(i)/double(noSteps-1), double(j)/double(noSteps-1));
|
|
double theta = texcoord.x() * 2.0 * osg::PI;
|
|
double phi = (1.0-texcoord.y()) * osg::PI;
|
|
|
|
if (texcoord_flip) texcoord.y() = 1.0f - texcoord.y();
|
|
|
|
osg::Vec3 pos(sin(phi)*sin(theta), sin(phi)*cos(theta), cos(phi));
|
|
pos = pos*projectorMatrix;
|
|
|
|
double alpha = atan2(pos.x(), pos.y());
|
|
if (alpha<0.0) alpha += 2.0*osg::PI;
|
|
|
|
double beta = atan2(sqrt(pos.x()*pos.x() + pos.y()*pos.y()), pos.z());
|
|
if (beta<0.0) beta += 2.0*osg::PI;
|
|
|
|
double gamma = atan2(sqrt(double(pos.x()*pos.x() + pos.y()*pos.y())), double(pos.z()+distance));
|
|
if (gamma<0.0) gamma += 2.0*osg::PI;
|
|
|
|
|
|
osg::Vec3 v = screenCenter + osg::Vec3(sin(alpha)*gamma*2.0/osg::PI, -cos(alpha)*gamma*2.0/osg::PI, 0.0f)*screenRadius;
|
|
|
|
if (flip)
|
|
vertices->push_back(osg::Vec3(v.x(), top.y()-(v.y()-origin.y()),v.z()));
|
|
else
|
|
vertices->push_back(v);
|
|
|
|
texcoords0->push_back( texcoord );
|
|
|
|
osg::Vec2 texcoord1(alpha/(2.0*osg::PI), 1.0f - beta/osg::PI);
|
|
if (intensityMap)
|
|
{
|
|
colors->push_back(intensityMap->getColor(texcoord1));
|
|
}
|
|
else
|
|
{
|
|
colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
|
|
if (texcoords1) texcoords1->push_back( texcoord1 );
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
// pass the created vertex array to the points geometry object.
|
|
geometry->setVertexArray(vertices);
|
|
|
|
geometry->setColorArray(colors, osg::Array::BIND_PER_VERTEX);
|
|
|
|
geometry->setTexCoordArray(0,texcoords0);
|
|
if (texcoords1) geometry->setTexCoordArray(1,texcoords1);
|
|
|
|
osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(osg::PrimitiveSet::TRIANGLES);
|
|
geometry->addPrimitiveSet(elements);
|
|
|
|
for(int i=0;i<noSteps-1;++i)
|
|
{
|
|
for(int j=0;j<noSteps-1;++j)
|
|
{
|
|
int i1 = j+(i+1)*noSteps;
|
|
int i2 = j+(i)*noSteps;
|
|
int i3 = j+1+(i)*noSteps;
|
|
int i4 = j+1+(i+1)*noSteps;
|
|
|
|
osg::Vec3& v1 = (*vertices)[i1];
|
|
osg::Vec3& v2 = (*vertices)[i2];
|
|
osg::Vec3& v3 = (*vertices)[i3];
|
|
osg::Vec3& v4 = (*vertices)[i4];
|
|
|
|
if ((v1-screenCenter).length()>screenRadius) continue;
|
|
if ((v2-screenCenter).length()>screenRadius) continue;
|
|
if ((v3-screenCenter).length()>screenRadius) continue;
|
|
if ((v4-screenCenter).length()>screenRadius) continue;
|
|
|
|
elements->push_back(i1);
|
|
elements->push_back(i2);
|
|
elements->push_back(i3);
|
|
|
|
elements->push_back(i1);
|
|
elements->push_back(i3);
|
|
elements->push_back(i4);
|
|
}
|
|
}
|
|
|
|
return geometry;
|
|
}
|
|
|
|
void PanoramicSphericalDisplay::configure(osgViewer::View& view) const
|
|
{
|
|
OSG_INFO<<"PanoramicSphericalDisplay::configure(rad="<<_radius<<", cllr="<<_collar<<", sn="<<_screenNum<<", im="<<_intensityMap<<")"<<std::endl;
|
|
|
|
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
|
|
if (!wsi)
|
|
{
|
|
OSG_NOTICE<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
|
|
return;
|
|
}
|
|
|
|
osg::GraphicsContext::ScreenIdentifier si;
|
|
si.readDISPLAY();
|
|
|
|
// displayNum has not been set so reset it to 0.
|
|
if (si.displayNum<0) si.displayNum = 0;
|
|
|
|
si.screenNum = _screenNum;
|
|
|
|
unsigned int width, height;
|
|
wsi->getScreenResolution(si, width, height);
|
|
|
|
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
|
|
traits->hostName = si.hostName;
|
|
traits->displayNum = si.displayNum;
|
|
traits->screenNum = si.screenNum;
|
|
traits->x = 0;
|
|
traits->y = 0;
|
|
traits->width = width;
|
|
traits->height = height;
|
|
traits->windowDecoration = false;
|
|
traits->doubleBuffer = true;
|
|
traits->sharedContext = 0;
|
|
|
|
|
|
bool applyIntensityMapAsColours = true;
|
|
|
|
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
|
|
if (!gc)
|
|
{
|
|
OSG_NOTICE<<"GraphicsWindow has not been created successfully."<<std::endl;
|
|
return;
|
|
}
|
|
|
|
int tex_width = width;
|
|
int tex_height = height;
|
|
|
|
int camera_width = tex_width;
|
|
int camera_height = tex_height;
|
|
|
|
osg::TextureRectangle* texture = new osg::TextureRectangle;
|
|
|
|
texture->setTextureSize(tex_width, tex_height);
|
|
texture->setInternalFormat(GL_RGB);
|
|
texture->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
|
|
texture->setFilter(osg::Texture::MAG_FILTER,osg::Texture::LINEAR);
|
|
texture->setWrap(osg::Texture::WRAP_S,osg::Texture::CLAMP_TO_EDGE);
|
|
texture->setWrap(osg::Texture::WRAP_T,osg::Texture::CLAMP_TO_EDGE);
|
|
|
|
// front face
|
|
{
|
|
#if 0
|
|
osg::Camera::RenderTargetImplementation renderTargetImplementation = osg::Camera::SEPERATE_WINDOW;
|
|
GLenum buffer = GL_FRONT;
|
|
#else
|
|
osg::Camera::RenderTargetImplementation renderTargetImplementation = osg::Camera::FRAME_BUFFER_OBJECT;
|
|
GLenum buffer = GL_FRONT;
|
|
#endif
|
|
|
|
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
|
|
camera->setName("Front face camera");
|
|
camera->setGraphicsContext(gc.get());
|
|
camera->setViewport(new osg::Viewport(0,0,camera_width, camera_height));
|
|
camera->setDrawBuffer(buffer);
|
|
camera->setReadBuffer(buffer);
|
|
camera->setAllowEventFocus(false);
|
|
// tell the camera to use OpenGL frame buffer object where supported.
|
|
camera->setRenderTargetImplementation(renderTargetImplementation);
|
|
|
|
// attach the texture and use it as the color buffer.
|
|
camera->attach(osg::Camera::COLOR_BUFFER, texture);
|
|
|
|
view.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd());
|
|
}
|
|
|
|
// distortion correction set up.
|
|
{
|
|
osg::Geode* geode = new osg::Geode();
|
|
geode->addDrawable(createParoramicSphericalDisplayDistortionMesh(osg::Vec3(0.0f,0.0f,0.0f), osg::Vec3(width,0.0f,0.0f), osg::Vec3(0.0f,height,0.0f), _radius, _collar, applyIntensityMapAsColours ? _intensityMap.get() : 0, _projectorMatrix));
|
|
|
|
// new we need to add the texture to the mesh, we do so by creating a
|
|
// StateSet to contain the Texture StateAttribute.
|
|
osg::StateSet* stateset = geode->getOrCreateStateSet();
|
|
stateset->setTextureAttributeAndModes(0, texture,osg::StateAttribute::ON);
|
|
stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
|
|
|
|
osg::TexMat* texmat = new osg::TexMat;
|
|
texmat->setScaleByTextureRectangleSize(true);
|
|
stateset->setTextureAttributeAndModes(0, texmat, osg::StateAttribute::ON);
|
|
|
|
if (!applyIntensityMapAsColours && _intensityMap.valid())
|
|
{
|
|
stateset->setTextureAttributeAndModes(1, new osg::Texture2D(_intensityMap.get()), osg::StateAttribute::ON);
|
|
}
|
|
|
|
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
|
|
camera->setGraphicsContext(gc.get());
|
|
camera->setClearMask(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );
|
|
camera->setClearColor( osg::Vec4(0.0,0.0,0.0,1.0) );
|
|
camera->setViewport(new osg::Viewport(0, 0, width, height));
|
|
|
|
GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;
|
|
camera->setDrawBuffer(buffer);
|
|
camera->setReadBuffer(buffer);
|
|
camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
|
|
camera->setAllowEventFocus(false);
|
|
camera->setInheritanceMask(camera->getInheritanceMask() & ~osg::CullSettings::CLEAR_COLOR & ~osg::CullSettings::COMPUTE_NEAR_FAR_MODE);
|
|
//camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
|
|
|
|
camera->setProjectionMatrixAsOrtho2D(0,width,0,height);
|
|
camera->setViewMatrix(osg::Matrix::identity());
|
|
|
|
// add subgraph to render
|
|
camera->addChild(geode);
|
|
|
|
camera->setName("DistortionCorrectionCamera");
|
|
|
|
view.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd(), false);
|
|
}
|
|
}
|