void SoXipGetCameraProperties::GLRender(SoGLRenderAction* action)
{
/*
SbMatrix mMV = SoModelMatrixElement::get(action->getState()) * SoViewingMatrixElement::get(action->getState());
SbMatrix mv = mMV.transpose();
mv = mv.inverse();
SbVec3f cc(0.0,0.0,0.0);
SbVec3f wc;
mv.multMatrixVec(cc, wc);
*/
SbViewVolume vv = SoViewVolumeElement::get( action->getState() );
mCamPos = vv.getSightPoint(0.0);
if (mCamPos != camPos.getValue())
camPos.setValue( mCamPos );
mCamDir = vv.getSightPoint(1.0) - vv.getSightPoint(0.0);
if (mCamDir != camDir.getValue() )
camDir.setValue( mCamDir );
SbViewportRegion vpr = SoViewportRegionElement::get( action->getState() );
SbVec2s orig = vpr.getViewportOriginPixels();
SbVec2s wh = vpr.getViewportSizePixels();
SbVec4f vp = SbVec4f( (float)orig[0], (float)orig[1], (float)wh[0], (float)wh[1] );
mViewport = vp;
if (mViewport != viewport.getValue())
viewport.setValue( mViewport );
}
void MyExaminerViewer::actualRedraw()
{
// Must set up the OpenGL viewport manually, as upon resize
// operations, Coin won't set it up until the SoGLRenderAction is
// applied again. And since we need to do glClear() before applying
// the action..
const SbViewportRegion vp = this->getViewportRegion();
SbVec2s origin = vp.getViewportOriginPixels();
SbVec2s size = vp.getViewportSizePixels();
glViewport(origin[0], origin[1], size[0], size[1]);
const SbColor col = this->getBackgroundColor();
glClearColor(col[0], col[1], col[2], 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Render our scenegraph with the image.
SoGLRenderAction * glra = this->getGLRenderAction();
glra->apply(this->bckgroundroot);
// Render normal scenegraph.
SoQtExaminerViewer::actualRedraw();
// Increase arrow angle with 1/1000 every frame.
// arrowrotation->angle = arrowrotation->angle.getValue() + (0.001 / M_PI * 180);
// Render overlay front scenegraph.
glClear(GL_DEPTH_BUFFER_BIT);
glra->apply(this->foregroundroot);
}
void
SoXipMarkerSet::GLRender( SoGLRenderAction* action )
{
if (mCoord && mFaceSet && mScale && mTranslation && mRotation)
{
float pointSize = SoPointSizeElement::get(action->getState());
SbViewportRegion vp = SoViewportRegionElement::get(action->getState());
SbViewVolume vVol = SoViewVolumeElement::get(action->getState());
// world to pixel scale
float scaleFactorY = pointSize * vVol.getHeight() / (float) vp.getViewportSizePixels()[1];
float scaleFactorX = pointSize * vVol.getWidth() / (float) vp.getViewportSizePixels()[0];
mScale->scaleFactor.setValue(0.5f * scaleFactorX, 0.5f * scaleFactorY, 1);
// world to screen rotation
SbMatrix affine, proj;
vVol.getMatrices(affine, proj);
SbVec3f t, s;
SbRotation rot, so;
affine.inverse().getTransform(t, rot, s, so);
mRotation->rotation.setValue(rot);
// number of coordinates
const SoCoordinateElement *ce = (const SoCoordinateElement *) SoCoordinateElement::getInstance(action->getState());
int numPts = 0;
if (ce)
{
numPts = ce->getNum();
}
SbXipMarkerShapes::getVertices(marker.getValue(), mCoord->point);
SbXipMarkerShapes::getNumVertices(marker.getValue(), mFaceSet->numVertices);
for (int i = 0; i < numPts; i++)
{
mTranslation->translation.setValue(ce->get3(i));
action->getState()->push();
action->traverse(mTranslation);
action->traverse(mRotation);
action->traverse(mScale);
action->traverse(mCoord);
action->traverse(mFaceSet);
action->getState()->pop();
}
}
}
void SoViewportRegion::setViewportRegion(const SbViewportRegion vp)
{
SbVec2s winSize;
viewport.setViewport(vp.getViewportOrigin(), vp.getViewportSize());
viewport.setWindowSize (vp.getWindowSize());
viewport.setViewportPixels(vp.getViewportOriginPixels(),
vp.getViewportSizePixels());
}
void Polyline::paintGL()
{
if (!working)
return;
if (_cNodeVector.empty())
return;
const SbViewportRegion vp = viewer->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, size[0], size[1], 0, 0, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(line);
glColor4f(rgb_r, rgb_g, rgb_b, rgb_a);
if (closed && !stippled) {
glBegin(GL_LINE_LOOP);
for (std::vector<QPoint>::iterator it = _cNodeVector.begin(); it != _cNodeVector.end(); ++it) {
glVertex2i(it->x(), it->y());
}
glEnd();
}
else {
glBegin(GL_LINES);
QPoint start = _cNodeVector.front();
for (std::vector<QPoint>::iterator it = _cNodeVector.begin(); it != _cNodeVector.end(); ++it) {
glVertex2i(start.x(), start.y());
start = *it;
glVertex2i(it->x(), it->y());
}
glEnd();
if (closed && stippled) {
glEnable(GL_LINE_STIPPLE);
glLineStipple(2, 0x3F3F);
glBegin(GL_LINES);
glVertex2i(_cNodeVector.back().x(), _cNodeVector.back().y());
glVertex2i(_cNodeVector.front().x(), _cNodeVector.front().y());
glEnd();
glDisable(GL_LINE_STIPPLE);
}
}
glDisable(GL_BLEND);
}
void getScreenPixelVectors(SoGLRenderAction *action, const SbVec3f position, SbVec3f &xPixelVec, SbVec3f &yPixelVec)
{
// To compute correct offset in world space we project width of text onto a plane parallel
// to the near plane of the camera that goes through the current translation of the model matrix.
SoState *state = action->getState();
SbPlaneProjector planeProj(FALSE);
SbViewVolume viewVolume = SoViewVolumeElement::get(state);
SbViewportRegion viewport = SoViewportRegionElement::get(state);
planeProj.setViewVolume(viewVolume);
planeProj.setPlane(SbPlane(viewVolume.getPlane(0.f).getNormal(), position));
float pixelWidth = 1.f / (float) viewport.getViewportSizePixels()[0];
float pixelHeight = 1.f / (float) viewport.getViewportSizePixels()[1];
SbVec3f p1 = planeProj.project(SbVec2f(0, 0));
SbVec3f p2 = planeProj.project(SbVec2f(pixelWidth, 0));
xPixelVec = (p2 - p1);
p2 = planeProj.project(SbVec2f(0, pixelHeight));
yPixelVec = (p2 - p1);
}
void paintGL()
{
const SbViewportRegion vp = view->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, size[0], 0, size[1], -1, 1);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4d(0.0,0.0,1.0,0.0f);
glRasterPos2d(0,0);
//http://wiki.delphigl.com/index.php/Multisampling
//glDrawPixels(img.width(),img.height(),GL_RGBA,GL_UNSIGNED_BYTE,img.bits());
/*
fbo->bind();
GLuint* buf = new GLuint[size[0]*size[1]];
glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_UNSIGNED_BYTE, buf);
fbo->release();
glDrawPixels(size[0],size[1],GL_RGBA,GL_UNSIGNED_BYTE,buf);
delete [] buf;
*/
/*
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, fbo->texture());
glBegin(GL_QUADS);
glTexCoord2f(0.0,0.0);
glVertex2f(-1.0,-1.0);
glTexCoord2f(0.0,1.0);
glVertex2f(-1.0,1.0);
glTexCoord2f(1.0,1.0);
glVertex2f(1.0,1.0);
glTexCoord2f(1.0,0.0);
glVertex2f(1.0,-1.0);
glEnd();
glDisable(GL_TEXTURE_2D);
*/
glPopAttrib();
glPopMatrix();
}
void paintGL()
{
const SbViewportRegion vp = view->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
//glDisable(GL_LIGHTING);
//glViewport(0, 0, size[0], size[1]);
//glMatrixMode(GL_PROJECTION);
//glLoadIdentity();
//glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();
//glDisable(GL_DEPTH_TEST);
//glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glOrtho(0, size[0], size[1], 0, 0, 100);
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(4.0);
glColor4f(1.0f, 1.0f, 1.0f, 0.2f);
glRecti(rubberBandCorner1.x(), rubberBandCorner1.y(),
rubberBandCorner2.x(), rubberBandCorner2.y());
glColor4f(1.0, 1.0, 0.0, 0.5);
glLineStipple(3, 0xAAAA);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINE_LOOP);
glVertex2i(rubberBandCorner1.x(), rubberBandCorner1.y());
glVertex2i(rubberBandCorner2.x(), rubberBandCorner1.y());
glVertex2i(rubberBandCorner2.x(), rubberBandCorner2.y());
glVertex2i(rubberBandCorner1.x(), rubberBandCorner2.y());
glEnd();
glLineWidth(1.0);
glDisable(GL_LINE_STIPPLE);
glDisable(GL_BLEND);
//glEnable(GL_LIGHTING);
//glEnable(GL_DEPTH_TEST);
}
/*!
Update our SoGLRenderAction's viewport settings.
This will change \e both the information about window dimensions and
the actual viewport size and origin.
\sa setWindowSize()
*/
void
SoSceneManager::setViewportRegion(const SbViewportRegion & newregion)
{
#if COIN_DEBUG && 0 // debug
const SbVec2s & ws = newregion.getWindowSize();
const SbVec2s & vpop = newregion.getViewportOriginPixels();
const SbVec2s & vpsp = newregion.getViewportSizePixels();
SoDebugError::postInfo("SoSceneManager::setViewportRegion",
"windowsize=(%d, %d) "
"viewportorigin=(%d, %d) "
"viewportsize=(%d, %d) ",
ws[0], ws[1],
vpop[0], vpop[1],
vpsp[0], vpsp[1]);
#endif // debug
PRIVATE(this)->rendermanager->setViewportRegion(newregion);
PRIVATE(this)->eventmanager->setViewportRegion(newregion);
}
Teapots(Gui::View3DInventorViewer* v) :view(v)
{
const SbViewportRegion vp = view->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
rubberBandIsShown = false;
// makeCurrent();
fbObject = new QGLFramebufferObject(size[0],size[1],
QGLFramebufferObject::Depth);
//initializeGL();
resizeGL(size[0],size[1]);
rubberBandIsShown = true;
rubberBandCorner1.setX(200);
rubberBandCorner1.setY(200);
rubberBandCorner2.setX(800);
rubberBandCorner2.setY(600);
view->getSoRenderManager()->scheduleRedraw();
}
void Rubberband::paintGL()
{
if (!working)
return;
const SbViewportRegion vp = viewer->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, size[0], size[1], 0, 0, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(4.0);
glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
glRecti(x_old, y_old, x_new, y_new);
glLineWidth(4.0);
glColor4f(rgb_r, rgb_g, rgb_b, rgb_a);
if (stipple) {
glLineStipple(3, 0xAAAA);
glEnable(GL_LINE_STIPPLE);
}
glBegin(GL_LINE_LOOP);
glVertex2i(x_old, y_old);
glVertex2i(x_old, y_new);
glVertex2i(x_new, y_new);
glVertex2i(x_new, y_old);
glEnd();
glLineWidth(1.0);
if (stipple)
glDisable(GL_LINE_STIPPLE);
glDisable(GL_BLEND);
}
void GLFlagWindow::paintGL()
{
// draw lines for the flags
if (_flagLayout) {
// it can happen that the GL widget gets replaced internally (SoQt only, not with quarter) which
// causes to destroy the FlagLayout instance
int ct = _flagLayout->count();
const SbViewportRegion vp = _viewer->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
float aspectratio = float(size[0])/float(size[1]);
SbViewVolume vv = _viewer->getSoRenderManager()->getCamera()->getViewVolume(aspectratio);
for (int i=0; i<ct;i++) {
Flag* flag = qobject_cast<Flag*>(_flagLayout->itemAt(i)->widget());
if (flag) {
SbVec3f pt = flag->getOrigin();
vv.projectToScreen(pt, pt);
int tox = (int)(pt[0] * size[0]);
int toy = (int)((1.0f-pt[1]) * size[1]);
flag->drawLine(_viewer, tox, toy);
}
}
}
}
virtual void apply(SoNode* node)
{
if (!headlightRot) {
SoSearchAction sa;
sa.setNode(viewer->getHeadlight());
sa.apply(viewer->getSceneRoot());
SoFullPath* fullPath = (SoFullPath*) sa.getPath();
if (fullPath) {
SoGroup *group = (SoGroup*) fullPath->getNodeFromTail(1);
headlightRot = (SoRotation*) group->getChild(0);
if (!headlightRot->isOfType(SoRotation::getClassTypeId()))
headlightRot = 0;
}
}
const SbViewportRegion vpr = getViewportRegion();
const SbVec2s & size = vpr.getViewportSizePixels();
const int width = size[0];
const int height = size[1];
const int vpsize = width / 2;
SoCamera * camera = viewer->getCamera();
const SbVec3f position = camera->position.getValue();
const SbRotation orientation = camera->orientation.getValue();
const float nearplane = camera->nearDistance.getValue();
const float farplane = camera->farDistance.getValue();
camera->enableNotify(false);
// Front View
rotateCamera(SbRotation(SbVec3f(0,0,1), M_PI));
SbViewportRegion vp;
vp.setViewportPixels(SbVec2s(0, height-width/2), SbVec2s(width, width/2) );
setViewportRegion(vp);
SoGLRenderAction::apply(node);
// Left View
SbRotation r1(SbVec3f(0,0,1), -M_PI/2);
rotateCamera(r1*SbRotation(SbVec3f(0,1,0), -M_PI/2));
vp.setViewportPixels(SbVec2s(0, height-width), SbVec2s(width/2, width) );
setViewportRegion(vp);
SoGLRenderAction::apply(node);
// Right View
rotateCamera(SbRotation(SbVec3f(0,1,0), -M_PI));
vp.setViewportPixels(SbVec2s(width/2, height-width), SbVec2s(width/2, width) );
setViewportRegion(vp);
SoGLRenderAction::apply(node);
setViewportRegion(vpr);
camera->position = position;
camera->orientation = orientation;
camera->enableNotify(true);
// Restore original viewport region
setViewportRegion(vpr);
}
void
SmTextureText2::renderString(const SmTextureFontBundle & bundle,
const SbString * s,
const int numstring,
const SbVec3f & pos,
const SbViewVolume & vv,
const SbViewportRegion & vp,
const SbMatrix & projmatrix,
const SbMatrix & modelmatrix,
const SbMatrix & invmodelmatrix,
const float rotation)
{
// get distance from pos to camera plane
SbVec3f tmp;
modelmatrix.multVecMatrix(pos, tmp);
float dist = -vv.getPlane(0.0f).getDistance(tmp);
if (dist <= vv.getNearDist()) return;
if (dist > (vv.getNearDist() + vv.getDepth())) return;
float maxr = this->maxRange.getValue();
if (maxr > 0.0f && dist > maxr) return;
int i;
SbVec2s vpsize = vp.getViewportSizePixels();
SbVec3f screenpoint;
projmatrix.multVecMatrix(pos, screenpoint);
int xmin = 0;
int ymax = bundle.getAscent();
int ymin = ymax - numstring * (bundle.height() + bundle.getLeading());
ymin += bundle.getLeading();
short h = ymax - ymin;
short halfh = h / 2;
switch (this->verticalJustification.getValue()) {
case SmTextureText2::BOTTOM:
break;
case SmTextureText2::TOP:
ymin -= bundle.getAscent();
ymax -= bundle.getAscent();
break;
case SmTextureText2::VCENTER:
ymin -= halfh;
ymax -= halfh;
break;
default:
assert(0 && "unknown alignment");
break;
}
SbList <int> widthlist;
for (i = 0; i < numstring; i++) {
widthlist.append(bundle.stringWidth(s[i]));
}
for (i = 0; i < numstring; i++) {
int len = s[i].getLength();
if (len == 0) continue;
SbVec2s sp;
if (!get_screenpoint_pixels(screenpoint, vpsize, sp)) continue;
SbVec2s n0 = SbVec2s(sp[0] + xmin,
sp[1] + ymax - (i+1)*bundle.height());
short w = static_cast<short>(widthlist[i]);
short halfw = w / 2;
switch (this->justification.getValue()) {
case SmTextureText2::LEFT:
break;
case SmTextureText2::RIGHT:
n0[0] -= w;
break;
case SmTextureText2::CENTER:
n0[0] -= halfw;
break;
default:
assert(0 && "unknown alignment");
break;
}
if (rotation != 0) {
float x = static_cast<float>(sp[0]);
float y = static_cast<float>(sp[1]);
glPushMatrix();
glTranslatef(x, y, 0);
glRotatef(rotation * static_cast<float>(180 / M_PI), 0, 0, 1);
glTranslatef(-x, -y, 0);
}
bundle.begin();
bundle.renderString(s[i], SbVec3f(n0[0], n0[1], screenpoint[2]));
bundle.end();
if (rotation != 0) glPopMatrix();
}
}
void SoXipViewportBorder::GLRender(SoGLRenderAction * action)
{
SbViewportRegion viewportRegion = SoViewportRegionElement::get( action->getState() );
SbVec2s s = viewportRegion.getViewportSizePixels();
double oldLineWidth = 1.0;
glGetDoublev(GL_LINE_WIDTH, &oldLineWidth);
glPushAttrib(GL_TRANSFORM_BIT | GL_ENABLE_BIT | GL_LINE_BIT | GL_CURRENT_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
#if 0
// disable clip planes
int maxClipPlanes;
glGetIntegerv(GL_MAX_CLIP_PLANES, &maxClipPlanes);
maxClipPlanes = std::min(maxClipPlanes, 16);
for (int i = 0; i < maxClipPlanes; i++)
{
glDisable(GL_CLIP_PLANE0 + i);
}
#endif
unsigned short pattern;
float lineWidth;
SbColor color;
if (SoXipActiveViewportElement::get(action->getState()))
{
pattern = activeLinePattern.getValue();
lineWidth = activeLineWidth.getValue();
color = activeColor.getValue();
}
else
{
pattern = inactiveLinePattern.getValue();
lineWidth = inactiveLineWidth.getValue();
color = inactiveColor.getValue();
}
if (lineWidth <= 0) return;
glColor3f(color[0], color[1], color[2]);
glLineStipple(1, pattern);
glEnable(GL_LINE_STIPPLE);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glOrtho(0, s[0], 0, s[1], -1, 1);
// cast to int to avoid compiler warnings
int iLineWidth = static_cast<int>(lineWidth);
int iLineWidth05 = static_cast<int>(lineWidth+0.5f);
if (pattern == 0xffff)
{
// draw solid blocks
// Note that on some graphics card GL_LINE_LOOP does not look good for thicker lines
// (first/last corner not filled). This is why we use GL_QUADS instead.
glBegin(GL_QUADS);
glVertex2i(0, 0);
glVertex2i(iLineWidth, 0);
glVertex2i(iLineWidth, s[1]);
glVertex2i(0, s[1]);
glVertex2i(0, 0);
glVertex2i(s[0], 0);
glVertex2i(s[0], iLineWidth);
glVertex2i(0, iLineWidth);
glVertex2i(s[0] - iLineWidth, 0);
glVertex2i(s[0], 0);
glVertex2i(s[0], s[1]);
glVertex2i(s[0] - iLineWidth, s[1]);
glVertex2i(0, s[1] - iLineWidth);
glVertex2i(s[0], s[1] - iLineWidth);
glVertex2i(s[0], s[1]);
glVertex2i(0, s[1]);
glEnd();
}
else
{
// draw stippled line
glLineWidth(lineWidth);
lineWidth /= 2.f;
glBegin(GL_LINES);
glVertex2i(iLineWidth, 0 + iLineWidth);
glVertex2i(s[0] - iLineWidth + 1, 0 + iLineWidth);
glVertex2i(iLineWidth, s[1] - iLineWidth);
glVertex2i(s[0] - iLineWidth + 1, s[1] - iLineWidth);
glVertex2i(s[0] - iLineWidth05, s[1] - iLineWidth);
glVertex2i(s[0] - iLineWidth05, iLineWidth);
glVertex2i(iLineWidth05, s[1] - iLineWidth);
glVertex2i(iLineWidth05, iLineWidth);
glEnd();
}
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glLineWidth(oldLineWidth);
glPopAttrib();
}
void SoXipCPUMprRender::GLRender(SoGLRenderAction * action)
{
SoState *state = action->getState();
SbViewportRegion vpRegion = SoViewportRegionElement::get(state);
SbVec2s vpSize = vpRegion.getViewportSizePixels();
// Don't do anything if 0 size
if (!vpSize[0] || !vpSize[1])
return;
// Bind texture to available texture stage
if (!mMPRTexId)
glGenTextures(1, &mMPRTexId);
int texUnit = SoXipMultiTextureElement::getFreeUnit(state);
SoXipMultiTextureElement::setUnit(state, texUnit);
SoXipMultiTextureElement::bindTexture(state, GL_TEXTURE_2D, mMPRTexId);
// Check the size against min/max
SbVec2s minmax = minMaxSize.getValue();
int which = (vpSize[0] > vpSize[1]) ? 0 : 1;
float ratio = (float) vpSize[which] / (float) vpSize[1 - which];
// If smallest dim is < min
if (vpSize[1 - which] < minmax[0])
{
// Clamp to min and change biggest dim according to aspect ratio
vpSize[1 - which] = minmax[0];
vpSize[which] = (short) (ratio * vpSize[1 - which]);
}
// If biggest dim is > max
if (vpSize[which] > minmax[1])
{
// Clamp to max and change smallest dim according to aspect ratio
vpSize[which] = minmax[1];
vpSize[1 - which] = (short) (vpSize[which] / ratio);
}
// Ready the buffers
readyBuffers(state);
if (vpSize[0] == 0 || vpSize[1] == 0)
return;
// Check if mpr texture must be resized
if (mMPRSize != vpSize)
{
resizeBuffers(vpSize);
mUpdateFlag |= UPDATE_MPRCACHE;
}
// Exit if unsupported image type
if (mTexInternalFormat == 0 ||
mTexType == 0)
return;
// Check if orientation has changed
SbVec3f corners[4];
SbViewVolume viewVolume = SoViewVolumeElement::get(state);
float dist = viewVolume.getNearDist() + viewVolume.getDepth() * 0.5f;
corners[0] = viewVolume.getPlanePoint(dist, SbVec2f(0, 1));
corners[1] = viewVolume.getPlanePoint(dist, SbVec2f(1, 1));
corners[2] = viewVolume.getPlanePoint(dist, SbVec2f(1, 0));
corners[3] = viewVolume.getPlanePoint(dist, SbVec2f(0, 0));
if (corners[0] != mCorners[0] ||
corners[1] != mCorners[1] ||
corners[2] != mCorners[2] ||
corners[3] != mCorners[3])
{
mCorners[0] = corners[0];
mCorners[1] = corners[1];
mCorners[2] = corners[2];
mCorners[3] = corners[3];
mUpdateFlag |= UPDATE_MPRCACHE;
}
//
if (mUpdateFlag & UPDATE_MPRCACHE)
{
// Compute new cache table and mpr
switch (mVolDataType)
{
case SbXipImage::UNSIGNED_BYTE:
mLutBuf ? computeMPRCacheLUT(this, (unsigned char*)mVolBuf, state) : computeMPRCache(this, (unsigned char*)mVolBuf, state);
break;
case SbXipImage::BYTE:
mLutBuf ? computeMPRCacheLUT(this, (char*)mVolBuf, state) : computeMPRCache(this, (char*)mVolBuf, state);
break;
case SbXipImage::UNSIGNED_SHORT:
mLutBuf ? computeMPRCacheLUT(this, (unsigned short*)mVolBuf, state) : computeMPRCache(this, (unsigned short*)mVolBuf, state);
break;
case SbXipImage::SHORT:
mLutBuf ? computeMPRCacheLUT(this, (short*)mVolBuf, state) : computeMPRCache(this, (short*)mVolBuf, state);
break;
case SbXipImage::UNSIGNED_INT:
mLutBuf ? computeMPRCacheLUT(this, (unsigned int*)mVolBuf, state) : computeMPRCache(this, (unsigned int*)mVolBuf, state);
break;
case SbXipImage::INT:
mLutBuf ? computeMPRCacheLUT(this, (int*)mVolBuf, state) : computeMPRCache(this, (int*)mVolBuf, state);
break;
case SbXipImage::FLOAT:
mLutBuf ? computeMPRCacheLUT(this, (float*)mVolBuf, state) : computeMPRCache(this, (float*)mVolBuf, state);
break;
case SbXipImage::DOUBLE:
mLutBuf ? computeMPRCacheLUT(this, (double*)mVolBuf, state) : computeMPRCache(this, (double*)mVolBuf, state);
break;
default:
// will never come here cause we already checked for it in resize
break;
}
// Update mpr texture
updateTexture();
}
else if (mUpdateFlag & UPDATE_MPR)
{
// Compute new mpr
switch (mVolDataType)
{
case SbXipImage::UNSIGNED_BYTE:
mLutBuf ? computeMPRLUT(this, (unsigned char*)mVolBuf) : computeMPR(this, (unsigned char*)mVolBuf);
break;
case SbXipImage::BYTE:
mLutBuf ? computeMPRLUT(this, (char*)mVolBuf) : computeMPR(this, (char*)mVolBuf);
break;
case SbXipImage::UNSIGNED_SHORT:
mLutBuf ? computeMPRLUT(this, (unsigned short*)mVolBuf) : computeMPR(this, (unsigned short*)mVolBuf);
break;
case SbXipImage::SHORT:
mLutBuf ? computeMPRLUT(this, (short*)mVolBuf) : computeMPR(this, (short*)mVolBuf);
break;
case SbXipImage::UNSIGNED_INT:
mLutBuf ? computeMPRLUT(this, (unsigned int*)mVolBuf) : computeMPR(this, (unsigned int*)mVolBuf);
break;
case SbXipImage::INT:
mLutBuf ? computeMPRLUT(this, (int*)mVolBuf) : computeMPR(this, (int*)mVolBuf);
break;
case SbXipImage::FLOAT:
mLutBuf ? computeMPRLUT(this, (float*)mVolBuf) : computeMPR(this, (float*)mVolBuf);
break;
case SbXipImage::DOUBLE:
mLutBuf ? computeMPRLUT(this, (double*)mVolBuf) : computeMPR(this, (double*)mVolBuf);
break;
default:
// will never come here cause we already checked for it in resize
break;
}
// Update mpr texture
updateTexture();
}
// Render mpr to a quad
renderMPR(texUnit);
// Reset update flag
mUpdateFlag = 0;
}
void paintGL()
{
const SbViewportRegion vp = view->getSoRenderManager()->getViewportRegion();
SbVec2s size = vp.getViewportSizePixels();
glDisable(GL_LIGHTING);
glViewport(0, 0, size[0], size[1]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, fbObject->texture());
glColor3f(1.0, 1.0, 1.0);
GLfloat s = size[0] / GLfloat(fbObject->size().width());
GLfloat t = size[1] / GLfloat(fbObject->size().height());
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0);
glVertex2f(-1.0, -1.0);
glTexCoord2f(s, 0.0);
glVertex2f(1.0, -1.0);
glTexCoord2f(s, t);
glVertex2f(1.0, 1.0);
glTexCoord2f(0.0, t);
glVertex2f(-1.0, 1.0);
glEnd();
if (rubberBandIsShown) {
glMatrixMode(GL_PROJECTION);
glOrtho(0, size[0], size[1], 0, 0, 100);
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(4.0);
glColor4f(1.0f, 1.0f, 1.0f, 0.2f);
glRecti(rubberBandCorner1.x(), rubberBandCorner1.y(),
rubberBandCorner2.x(), rubberBandCorner2.y());
glColor4f(1.0, 1.0, 0.0, 0.5);
glLineStipple(3, 0xAAAA);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINE_LOOP);
glVertex2i(rubberBandCorner1.x(), rubberBandCorner1.y());
glVertex2i(rubberBandCorner2.x(), rubberBandCorner1.y());
glVertex2i(rubberBandCorner2.x(), rubberBandCorner2.y());
glVertex2i(rubberBandCorner1.x(), rubberBandCorner2.y());
glEnd();
glLineWidth(1.0);
glDisable(GL_LINE_STIPPLE);
glDisable(GL_BLEND);
}
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
}
