void Channel::frameDraw( const eq::uint128_t& frameID )
{
if( stopRendering( ))
return;
_initJitter();
if( _isDone( ))
return;
Window* window = static_cast< Window* >( getWindow( ));
VertexBufferState& state = window->getState();
const Model* oldModel = _model;
const Model* model = _getModel();
if( oldModel != model )
state.setFrustumCulling( false ); // create all display lists/VBOs
if( model )
_updateNearFar( model->getBoundingSphere( ));
eq::Channel::frameDraw( frameID ); // Setup OpenGL state
glLightfv( GL_LIGHT0, GL_POSITION, lightPosition );
glLightfv( GL_LIGHT0, GL_AMBIENT, lightAmbient );
glLightfv( GL_LIGHT0, GL_DIFFUSE, lightDiffuse );
glLightfv( GL_LIGHT0, GL_SPECULAR, lightSpecular );
glMaterialfv( GL_FRONT, GL_AMBIENT, materialAmbient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, materialDiffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, materialSpecular );
glMateriali( GL_FRONT, GL_SHININESS, materialShininess );
const FrameData& frameData = _getFrameData();
glPolygonMode( GL_FRONT_AND_BACK,
frameData.useWireframe() ? GL_LINE : GL_FILL );
const eq::Vector3f& position = frameData.getCameraPosition();
glMultMatrixf( frameData.getCameraRotation().array );
glTranslatef( position.x(), position.y(), position.z() );
glMultMatrixf( frameData.getModelRotation().array );
if( frameData.getColorMode() == COLOR_DEMO )
{
const eq::Vector3ub color = getUniqueColor();
glColor3ub( color.r(), color.g(), color.b() );
}
else
glColor3f( .75f, .75f, .75f );
if( model )
_drawModel( model );
else
{
glNormal3f( 0.f, -1.f, 0.f );
glBegin( GL_TRIANGLE_STRIP );
glVertex3f( .25f, 0.f, .25f );
glVertex3f( -.25f, 0.f, .25f );
glVertex3f( .25f, 0.f, -.25f );
glVertex3f( -.25f, 0.f, -.25f );
glEnd();
}
state.setFrustumCulling( true );
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
accum.stepsDone = LB_MAX( accum.stepsDone,
getSubPixel().size * getPeriod( ));
accum.transfer = true;
}
bool Channel::useOrtho() const
{
const FrameData& frameData = _getFrameData();
return frameData.useOrtho();
}
void Channel::_drawHelp()
{
const FrameData& frameData = _getFrameData();
std::string message = frameData.getMessage();
if( !frameData.showHelp() && message.empty( ))
return;
applyBuffer();
applyViewport();
setupAssemblyState();
glDisable( GL_LIGHTING );
glDisable( GL_DEPTH_TEST );
glColor3f( 1.f, 1.f, 1.f );
if( frameData.showHelp( ))
{
const eq::Window::Font* font = getWindow()->getSmallFont();
std::string help = EVolve::getHelp();
float y = 340.f;
for( size_t pos = help.find( '\n' ); pos != std::string::npos;
pos = help.find( '\n' ))
{
glRasterPos3f( 10.f, y, 0.99f );
font->draw( help.substr( 0, pos ));
help = help.substr( pos + 1 );
y -= 16.f;
}
// last line
glRasterPos3f( 10.f, y, 0.99f );
font->draw( help );
}
if( !message.empty( ))
{
const eq::Window::Font* font = getWindow()->getMediumFont();
const eq::Viewport& vp = getViewport();
const eq::PixelViewport& pvp = getPixelViewport();
const float width = pvp.w / vp.w;
const float xOffset = vp.x * width;
const float height = pvp.h / vp.h;
const float yOffset = vp.y * height;
const float yMiddle = 0.5f * height;
float y = yMiddle - yOffset;
for( size_t pos = message.find( '\n' ); pos != std::string::npos;
pos = message.find( '\n' ))
{
glRasterPos3f( 10.f - xOffset, y, 0.99f );
font->draw( message.substr( 0, pos ));
message = message.substr( pos + 1 );
y -= 22.f;
}
// last line
glRasterPos3f( 10.f - xOffset, y, 0.99f );
font->draw( message );
}
EQ_GL_CALL( resetAssemblyState( ));
}
void Channel::_drawHelp()
{
const FrameData& frameData = _getFrameData();
std::string message = frameData.getMessage();
if( !frameData.showHelp() && message.empty( ))
return;
applyOverlayState();
if( frameData.showHelp( ))
{
const eq::util::BitmapFont* font = getWindow()->getSmallFont();
std::string help = EVolve::getHelp();
float y = 340.f;
for( size_t pos = help.find( '\n' ); pos != std::string::npos;
pos = help.find( '\n' ))
{
glRasterPos3f( 10.f, y, 0.99f );
font->draw( help.substr( 0, pos ));
help = help.substr( pos + 1 );
y -= 16.f;
}
// last line
glRasterPos3f( 10.f, y, 0.99f );
font->draw( help );
}
if( !message.empty( ))
{
const eq::util::BitmapFont* font = getWindow()->getMediumFont();
const eq::Viewport& vp = getViewport();
const eq::PixelViewport& pvp = getPixelViewport();
const float width = pvp.w / vp.w;
const float xOffset = vp.x * width;
const float height = pvp.h / vp.h;
const float yOffset = vp.y * height;
const float yMiddle = 0.5f * height;
float y = yMiddle - yOffset;
for( size_t pos = message.find( '\n' ); pos != std::string::npos;
pos = message.find( '\n' ))
{
glRasterPos3f( 10.f - xOffset, y, 0.99f );
font->draw( message.substr( 0, pos ));
message = message.substr( pos + 1 );
y -= 22.f;
}
// last line
glRasterPos3f( 10.f - xOffset, y, 0.99f );
font->draw( message );
}
resetOverlayState();
}
MRESULT EXPENTRY stlrTitleBarProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) {
PSTLRFRAME p;
/* -------------------------------------------------------------------
window creation :
store the handle of the owner window, the initial titlebar size,
convert the title substituting \r\n with 1 space, update the titlebar
font
------------------------------------------------------------------- */
if (msg == WM_CREATE) {
// if this is a global exception window, if the window ID is not
// FID_TITLEBAR or if the owner window is not a frame, go to the
// default system titlebar procedure
if (!pd.ppib
|| (((PCREATESTRUCT)mp2)->id != FID_TITLEBAR)
|| !_isFrameWindow(((PCREATESTRUCT)mp2)->hwndOwner))
goto defaultTitlebarProcedure;
// get the frame data
p = (PSTLRFRAME)WinQueryWindowPtr(((PCREATESTRUCT)mp2)->hwndOwner,
g.cd.frame.cbData);
// /*-*/ dbgPrintf5("*** pd.ppib:%08x, id: %04x, isOwnerFrame: %d, p: %08x\n",
// pd.ppib, ((PCREATESTRUCT)mp2)->id,
// _isFrameWindow(((PCREATESTRUCT)mp2)->hwndOwner), p);
// if the frame window is a win32frame initialize the frame data now
if (!p
|| ((p == FL_WIN32FRAME)
&& (NULL
== (p = _initWin32Frame(((PCREATESTRUCT)mp2)->hwndOwner)))))
goto defaultTitlebarProcedure;
// memorizza handle frame window
WinSetWindowPtr(hwnd, g.cd.tbar.cbData, p);
p->hTBar = hwnd;
if (((PCREATESTRUCT)mp2)->pszText)
p->cchTxt = psznconvcpy(p->achTxt, ((PCREATESTRUCT)mp2)->pszText, 260);
p->wrclTitle.x = ((PCREATESTRUCT)mp2)->x;
p->wrclTitle.y = ((PCREATESTRUCT)mp2)->y;
p->wrclTitle.cx = ((PCREATESTRUCT)mp2)->cx;
p->wrclTitle.cy = ((PCREATESTRUCT)mp2)->cy;
// cambia font secondo preferenze
if (o.tb.on && !(o.gen.disabled || pd.we.tbar))
_setPPFont(hwnd, o.tb.achFont);
/* -------------------------------------------------------------------
hiliting/unhiliting of the titlebar :
store the handle of the owner window, the initial titlebar size,
convert the title substituting \r\n with 1 space, update the titlebar
font
------------------------------------------------------------------- */
} else if (msg == TBM_SETHILITE) {
if (_getFrameData(hwnd, p)) {
p->is.tbhilited = (BOOL)mp1;
if (!o.gen.disabled && o.tb.on && !pd.we.tbar) {
if (o.tb.ovrPP
|| (p->is.tbhilited && !p->is.tbactpp)
|| !(p->is.tbhilited || p->is.tbictpp)) {
if (WinIsWindowShowing(hwnd)) {
p->hps = WinGetPS(hwnd);
DrawTitlebar(p);
WinReleasePS(p->hps);
} /* endif */
return (MRESULT)TRUE;
// Š solo apparentemente ridondante, in realt… Š necessario quando
// non Š ovrPP ed Š presente solo PP att. o inatt.
} else if (!(p->is.tbactpp && p->is.tbictpp)) {
repaintWindow(hwnd);
} /* endif */
} /* endif */
} /* endif */
/* -------------------------------------------------------------------
titlebar font/color changed
- if the font changed repaint the window
- if any color changed reset the presparm presence flag
------------------------------------------------------------------- */
} else if (msg == WM_PRESPARAMCHANGED) {
if (!pd.we.tbar && _getFrameData(hwnd, p)) {
ULONG ul;
switch ((LONG)mp1) {
case PP_FONTNAMESIZE:
p->cyfont = 0;
if (o.gen.disabled) break;
if (WinIsWindowShowing(hwnd)) repaintWindow(hwnd);
return (MRESULT)FALSE;
case PP_ACTIVETEXTBGNDCOLOR:
case PP_ACTIVETEXTBGNDCOLORINDEX:
case PP_ACTIVECOLOR:
case PP_ACTIVECOLORINDEX:
p->is.tbactpp = _getPPColor(hwnd, (ULONG)mp1, &ul) != 0;
break;
case PP_INACTIVETEXTBGNDCOLOR:
case PP_INACTIVETEXTBGNDCOLORINDEX:
case PP_INACTIVECOLOR:
case PP_INACTIVECOLORINDEX:
p->is.tbictpp = _getPPColor(hwnd, (ULONG)mp1, &ul) != 0;
break;
} /* endswitch */
} /* endif */
/* -------------------------------------------------------------------
the titlebar text changed. If this is a Win-OS/2 window set the
window words to 0 so that the enhancements are skipped, otherwise
store the new text.
------------------------------------------------------------------- */
} else if (msg == WM_SETWINDOWPARAMS) {
if (!pd.we.tbar && _getFrameData(hwnd, p)) {
// unsubclass winOS2 windows titlebars
if (p->is.winos2) {
_resetDefaultProc(hwnd);
// WinSetWindowULong(hwnd, g.cd.tbar.cbData, 0);
} else {
if ((PWNDPARAMS)mp1 &&
(((PWNDPARAMS)mp1)->fsStatus & WPM_TEXT) &&
((PWNDPARAMS)mp1)->pszText) {
p->cchTxt = psznconvcpy(p->achTxt, ((PWNDPARAMS)mp1)->pszText, 260);
p->cyfont = 0;
} /* endif */
} /* endif */
} /* endif */
/* -------------------------------------------------------------------
titlebar size/position changed : store new size and position
------------------------------------------------------------------- */
} else if (msg == WM_WINDOWPOSCHANGED) {
if ((((PSWP)mp1)->fl & (SWP_SIZE | SWP_MOVE))
&& _getFrameData(hwnd, p)) {
p->wrclTitle.x = ((PSWP)mp1)->x;
p->wrclTitle.y = ((PSWP)mp1)->y;
p->wrclTitle.cx = ((PSWP)mp1)->cx;
p->wrclTitle.cy = ((PSWP)mp1)->cy;
} /* endif */
// **************************************************************************
// these messages are processed only if Styler/2 is not disabled:
} else if (!o.gen.disabled) {
/* -------------------------------------------------------------------
check if this is the roll-the-window mouse event :
------------------------------------------------------------------- */
if ((msg == o.roll.moumsg) && (SHORT2FROMMP(mp2) == o.roll.moukbd)) {
if (!pd.we.wroll
&& o.roll.mou
&& _getFrameData(hwnd, p)
&& !p->is.win32
&& (o.roll.on || p->is.RLon)) {
toggleRollCmd(p->hwnd, p);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
check if this is the hide-titlebar mouse event :
------------------------------------------------------------------- */
} else if ((msg == o.tbh.moumsg) && (SHORT2FROMMP(mp2) == o.tbh.moukbd)) {
if (!pd.we.tbarhide
&& o.tbh.mou
&& _getFrameData(hwnd, p)
&& !p->is.win32
// opzione titlehide attiva e non dialogo o disattivazione titlehide
&& ((o.tbh.on && !(p->is.dialog && o.tbh.noDlg)) || p->is.titleHide)) {
toggleTitleBarHidingCmd(p->hwnd, p);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
check if this is the change-Zorder mouse event :
------------------------------------------------------------------- */
} else if ((msg == o.sizpos.ZordMoumsg)
&& (SHORT2FROMMP(mp2) == o.sizpos.ZordMoukbd)) {
if (!pd.we.sizemove
&& o.sizpos.Zmove
&& _getFrameData(hwnd, p)) {
_stlrMsgPost(p->hwnd, STLR_ZORDACTIV, SW2_SFMOVETOBOTTOM);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
check if this is the snap-to-screen-edge mouse event :
------------------------------------------------------------------- */
} else if ((msg == o.sizpos.snapMoumsg)
&& (SHORT2FROMMP(mp2) == o.sizpos.snapMoukbd)) {
if (!pd.we.sizemove
&& o.sizpos.snap
&& _getFrameData(hwnd, p)) {
// get the rectangle of the window and of its parent
RECTL r, rParent;
WinQueryWindowRect(p->hwnd, &r);
WinQueryWindowRect(_winParent(p->hwnd), &rParent);
// click on the left side of the titlebar
if (MOUSEX(mp1) < (p->wrclTitle.cx / 3)) {
r.xLeft = -p->ptBrd.x;
// click on the right side of the titlebar
} else if (MOUSEX(mp1) > (p->wrclTitle.cx * 2 / 3)) {
r.xLeft = rParent.xRight - r.xRight + p->ptBrd.x;
// click on the (horizontal) middle of the titlebar
} else {
r.xLeft = (rParent.xRight - r.xRight) / 2;
} /* endif */
// click on the bottom of the titlebar
if (MOUSEY(mp1) < (g.sys.cyTbar / 3)) {
r.yBottom = -p->ptBrd.y;
// click on the top of the titlebar
} else if (MOUSEY(mp1) > (g.sys.cyTbar * 2 / 3)) {
r.yBottom = rParent.yTop - r.yTop + p->ptBrd.y;
// click on the (vertical) middle of the titlebar
} else {
r.yBottom = (rParent.yTop - r.yTop) / 2;
} /* endif */
WinSetWindowPos(p->hwnd, 0, r.xLeft, r.yBottom, 0, 0,
SWP_MOVE | SWP_NOADJUST);
} /* endif */
/* -------------------------------------------------------------------
enhanced window painting
------------------------------------------------------------------- */
} else if (msg == WM_PAINT) {
if (!pd.we.tbar
&& o.tb.on
&& _getFrameData(hwnd, p)
&& (o.tb.ovrPP || (p->is.tbhilited && !p->is.tbactpp)
|| !(p->is.tbhilited || p->is.tbictpp))) {
p->hps = WinBeginPaint(hwnd, NULLHANDLE, NULL);
DrawTitlebar(p);
WinEndPaint(p->hps);
return (MRESULT)FALSE;
} /* endif */
/* -------------------------------------------------------------------
override the default window tracking :
------------------------------------------------------------------- */
} else if ((msg == WM_BUTTON1DOWN) || (msg == WM_BUTTON2DOWN)) {
if (_getFrameData(hwnd, p)) {
// override window motion by titlebar drag :
// store the current mouse position (mp1)
// the window motion will start only when the mouse will move
g.tbdrag.mpPos = mp1;
// if the window is not already moving store which mouse button
// has to be released to stop the titlebar drag
if (!g.tbdrag.hwnd) g.tbdrag.msg = ++msg;
// store the handle of the titlebar (mouse motion events are not
// processed when this is NULLHANDLE)
g.tbdrag.hwnd = hwnd;
// cattura i msg successivi del mouse
WinSetCapture(HWND_DESKTOP, hwnd);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
terminate window motion through titlebar drag events :
------------------------------------------------------------------- */
} else if ((msg == WM_BUTTON1UP) || (msg == WM_BUTTON2UP)) {
if ((g.tbdrag.hwnd == hwnd)
&& (g.tbdrag.msg == msg)
&& _getFrameData(hwnd, p)) {
HWND hwndParent;
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
g.tbdrag.msg = 0;
g.tbdrag.hwnd = NULLHANDLE;
// if the Ctrl key is not pressed and the window is not yet active
// end the window is a size-move feature exception or the event
// is not related to the Z-order motion feature or the snap-to-
// parent-edge feature activate the window bringing it to the top
if (!(SHORT2FROMMP(mp2) & KC_CTRL)
&& (g.hwnd.active != p->hwnd)
&& (pd.we.sizemove
|| (!(o.sizpos.Zmove
&& (msg == (o.sizpos.ZordMoumsg - 0x3a1))
&& (SHORT2FROMMP(mp2) == o.sizpos.ZordMoukbd))
&& (!(o.sizpos.snap
&& (msg == (o.sizpos.snapMoumsg - 0x3a1))
&& (SHORT2FROMMP(mp2) == o.sizpos.snapMoukbd))))))
WinSetWindowPos(p->hwnd, HWND_TOP, 0, 0, 0, 0,
SWP_ACTIVATE | SWP_ZORDER);
} /* endif */
/* -------------------------------------------------------------------
open the system menu on the titlebar :
------------------------------------------------------------------- */
} else if (msg == WM_CONTEXTMENU) {
if (!pd.we.tbar
&& o.tb.menu
&& _getFrameData(hwnd, p)) {
// if this is the titlebar of a WPS folder simulate a context
// menu event on the client window
if (p->is.folder) {
p->hClient = WinWindowFromID(p->hwnd, FID_CLIENT);
WinPostMsg(p->hClient, WM_CONTEXTMENU,
(MPARAM)0x7fff7fff, MPVOID);
// otherwise get the handle of the system menu and bring it to
// the top via WinPopupMenu()
} else if (p->hSMenu) {
POINTL ptl;
WinQueryPointerPos(g.hwnd.desktop, &ptl);
g.cd.menu.pfnwp(p->hSMenu, MM_QUERYITEM,
(MPARAM)SC_SYSMENU, MPFROMP(&p->mi));
g.hwnd.sysMenu = p->mi.hwndSubMenu;
WinPopupMenu(g.hwnd.desktop, p->hSMenu, g.hwnd.sysMenu,
ptl.x, ptl.y, 0, PU_HCONSTRAIN | PU_VCONSTRAIN |
PU_NONE | PU_KEYBOARD | PU_MOUSEBUTTON1);
} /* endif */
} /* endif */
return (MRESULT)TRUE;
/* -------------------------------------------------------------------
trap WM_MOUSEMOVE to implement various features :
- do not move maximized windows
------------------------------------------------------------------- */
} else if (msg == WM_MOUSEMOVE) {
// if mouse button 1 or 2 were pressed and then the mouse position
// changed
if ((g.tbdrag.hwnd == hwnd)
&& (g.tbdrag.mpPos != mp1)
&& _getFrameData(hwnd, p)) {
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
g.tbdrag.hwnd = NULLHANDLE;
g.tbdrag.msg = 0;
// if this is a maximized window and the don't-move-max-window
// feature is set ignore the event
if (o.maxwin.nomove
&& p->is.max
&& !(pd.we.maxwin || p->is.shield || p->is.ovrdnomovemax))
return (MRESULT)TRUE;
WinSendMsg(p->hwnd, WM_TRACKFRAME, (MPARAM)TF_MOVE, g.tbdrag.mpPos);
// ???????????????????????????????
// this is needed because the next WM_BUTTONxUP is captured by
// the WM_TRACKFRAME processing
// if (!(SHORT2FROMMP(mp2) & KC_CTRL))
// WinSetWindowPos(p->hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
return (MRESULT)TRUE;
} else if (g.is.onctrl != OCTLTBAR) {
g.is.onctrl = OCTLTBAR;
// ??????????????? this should be redundant
// _resetHideMouTimer();
} /* endif */
} /* endif */
// -------------------------------------------------------------------
} /* endif */
defaultTitlebarProcedure:
return g.cd.tbar.pfnwp(hwnd, msg, mp1, mp2);
}
void Channel::_drawHelp()
{
const FrameData& frameData = _getFrameData();
std::string message = frameData.getMessage();
if( !frameData.showHelp() && message.empty( ))
return;
applyBuffer();
applyViewport();
setupAssemblyState();
glLogicOp( GL_XOR );
glEnable( GL_COLOR_LOGIC_OP );
glDisable( GL_LIGHTING );
glDisable( GL_DEPTH_TEST );
glColor3f( 1.f, 1.f, 1.f );
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Viewport& vp = getViewport();
const float height = pvp.h / vp.h;
if( !message.empty( ))
{
const eq::Window::Font* font = getWindow()->getMediumFont();
const float width = pvp.w / vp.w;
const float xOffset = vp.x * width;
const float yOffset = vp.y * height;
const float yPos = 0.618f * height;
float y = yPos - yOffset;
for( size_t pos = message.find( '\n' ); pos != std::string::npos;
pos = message.find( '\n' ))
{
glRasterPos3f( 10.f - xOffset, y, 0.99f );
font->draw( message.substr( 0, pos ));
message = message.substr( pos + 1 );
y -= 22.f;
}
// last line
glRasterPos3f( 10.f - xOffset, y, 0.99f );
font->draw( message );
}
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
applyScreenFrustum();
glMatrixMode( GL_MODELVIEW );
if( frameData.showHelp( ))
{
const eq::Window::Font* font = getWindow()->getSmallFont();
std::string help = EqPly::getHelp();
float y = height - 16.f;
for( size_t pos = help.find( '\n' ); pos != std::string::npos;
pos = help.find( '\n' ))
{
glRasterPos3f( 10.f, y, 0.99f );
font->draw( help.substr( 0, pos ));
help = help.substr( pos + 1 );
y -= 16.f;
}
// last line
glRasterPos3f( 10.f, y, 0.99f );
font->draw( help );
}
resetAssemblyState();
}
void Channel::_drawModel( const Model* scene )
{
Window* window = static_cast< Window* >( getWindow( ));
VertexBufferState& state = window->getState();
const FrameData& frameData = _getFrameData();
if( frameData.getColorMode() == COLOR_MODEL && scene->hasColors( ))
state.setColors( true );
else
state.setColors( false );
state.setChannel( this );
// Compute cull matrix
const eq::Matrix4f& rotation = frameData.getCameraRotation();
const eq::Matrix4f& modelRotation = frameData.getModelRotation();
eq::Matrix4f position = eq::Matrix4f::IDENTITY;
position.set_translation( frameData.getCameraPosition());
const eq::Frustumf& frustum = getFrustum();
const eq::Matrix4f projection = useOrtho() ? frustum.compute_ortho_matrix():
frustum.compute_matrix();
const eq::Matrix4f& view = getHeadTransform();
const eq::Matrix4f model = rotation * position * modelRotation;
state.setProjectionModelViewMatrix( projection * view * model );
state.setRange( &getRange().start);
const eq::Pipe* pipe = getPipe();
const GLuint program = state.getProgram( pipe );
if( program != VertexBufferState::INVALID )
glUseProgram( program );
scene->cullDraw( state );
state.setChannel( 0 );
if( program != VertexBufferState::INVALID )
glUseProgram( 0 );
const InitData& initData =
static_cast<Config*>( getConfig( ))->getInitData();
if( !initData.useROI( ))
{
declareRegion( getPixelViewport( ));
return;
}
#ifndef NDEBUG // region border
const eq::PixelViewport& pvp = getPixelViewport();
const eq::PixelViewport& region = getRegion();
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.f, pvp.w, 0.f, pvp.h, -1.f, 1.f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
const eq::View* currentView = getView();
if( currentView && frameData.getCurrentViewID() == currentView->getID( ))
glColor3f( 0.f, 0.f, 0.f );
else
glColor3f( 1.f, 1.f, 1.f );
glNormal3f( 0.f, 0.f, 1.f );
const eq::Vector4f rect( float( region.x ) + .5f, float( region.y ) + .5f,
float( region.getXEnd( )) - .5f,
float( region.getYEnd( )) - .5f );
glBegin( GL_LINE_LOOP ); {
glVertex3f( rect[0], rect[1], -.99f );
glVertex3f( rect[2], rect[1], -.99f );
glVertex3f( rect[2], rect[3], -.99f );
glVertex3f( rect[0], rect[3], -.99f );
} glEnd();
#endif
}
void Channel::frameViewFinish( const eq::uint128_t& frameID )
{
if( stopRendering( ))
return;
applyBuffer();
const FrameData& frameData = _getFrameData();
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
if( accum.buffer )
{
const eq::PixelViewport& pvp = getPixelViewport();
const bool isResized = accum.buffer->resize( pvp.w, pvp.h );
if( isResized )
{
const View* view = static_cast< const View* >( getView( ));
accum.buffer->clear();
accum.step = view->getIdleSteps();
accum.stepsDone = 0;
}
else if( frameData.isIdle( ))
{
setupAssemblyState();
if( !_isDone() && accum.transfer )
accum.buffer->accum();
accum.buffer->display();
resetAssemblyState();
}
}
applyViewport();
_drawOverlay();
_drawHelp();
if( frameData.useStatistics())
drawStatistics();
ConfigEvent event;
event.data.originator = getID();
event.data.type = ConfigEvent::IDLE_AA_LEFT;
if( frameData.isIdle( ))
{
event.steps = 0;
for( size_t i = 0; i < eq::NUM_EYES; ++i )
event.steps = LB_MAX( event.steps, _accum[i].step );
}
else
{
const View* view = static_cast< const View* >( getView( ));
event.steps = view ? view->getIdleSteps() : 0;
}
// if _jitterStep == 0 and no user redraw event happened, the app will exit
// FSAA idle mode and block on the next redraw event.
eq::Config* config = getConfig();
config->sendEvent( event );
}
