// redraw the window
void display(void)
{
WindowPtr win = mgr->getWindow();
//mgr->redraw();
win->activate();
win->frameInit();
//RenderAction *rAct = (RenderAction*)mgr->getAction();
if (multipass)
{
RenderAction *rAct = RenderAction::create();
fbo_vp->setParent(win);
rAct->setWindow(get_pointer(win));
fbo_vp->render(rAct);
fbo_vp->setParent(NullFC);
delete rAct;
//multipass = false;
}
win->getPort(0)->render(dynamic_cast<RenderAction *>(mgr->getAction()));
//win->renderAllViewports(rAct);
win->swap();
win->frameExit();
win->deactivate();
}
void setCamera(CameraPtr c)
{
_camera = c;
ViewportPtr vp = _win->getPort(0);
beginEditCP(vp);
vp->setCamera(_camera);
endEditCP(vp);
}
virtual void initialize(void)
{
// Check necessary stuff
if(_win == NullFC)
{
FWARNING(("SceneManager::initialize: window not set, "
"ignoring!\n"));
return;
}
// the rendering action
_ownAction = RenderAction::create();
_action = _ownAction;
// the camera and light beacon
NodePtr cartN = Node::create();
_cart = Transform::create();
beginEditCP(cartN);
cartN->setCore(_cart);
endEditCP(cartN);
// the headlight
_internalRoot = Node::create();
_headlight = DirectionalLight::create();
addRefCP(_internalRoot);
beginEditCP(_internalRoot);
_internalRoot->setCore(_headlight);
_internalRoot->addChild(cartN);
endEditCP(_internalRoot);
beginEditCP(_headlight);
_headlight->setAmbient (.3, .3, .3, 1);
_headlight->setDiffuse ( 1, 1, 1, 1);
_headlight->setSpecular ( 1, 1, 1, 1);
_headlight->setDirection( 0, 0, 1);
_headlight->setBeacon (cartN);
endEditCP(_headlight);
// the camera
_camera = PerspectiveCamera::create();
addRefCP(_camera);
beginEditCP(PerspectiveCameraPtr::dcast(_camera));
PerspectiveCameraPtr::dcast(_camera)->setBeacon(cartN);
PerspectiveCameraPtr::dcast(_camera)->setFov (deg2rad(60.f));
PerspectiveCameraPtr::dcast(_camera)->setNear (0.1f);
PerspectiveCameraPtr::dcast(_camera)->setFar (10000.f);
endEditCP(PerspectiveCameraPtr::dcast(_camera));
// need a viewport?
if(_win->getPort().size() == 0)
{
SolidBackgroundPtr bg = SolidBackground::create();
beginEditCP(bg);
bg->setColor(Color3f(0, 0, 0));
endEditCP(bg);
ViewportPtr vp = Viewport::create();
beginEditCP(vp);
vp->setCamera (_camera);
vp->setRoot (_internalRoot);
vp->setSize (0,0, 1,1);
vp->setBackground (bg);
endEditCP(vp);
beginEditCP(_win);
_win->addPort(vp);
endEditCP(_win);
}
}
void MultiDisplayWindow::serverRender(WindowPtr serverWindow,
UInt32 id,
DrawActionBase *action )
{
TileCameraDecoratorPtr deco;
ViewportPtr serverPort;
ViewportPtr clientPort;
StereoBufferViewportPtr clientStereoPort;
UInt32 sv,cv;
Int32 l,r,t,b;
Int32 cleft,cright,ctop,cbottom;
// sync, otherwise viewports will be out of date
if(!getHServers())
{
setHServers(getServers().size());
}
if(!getVServers())
{
setVServers(1);
}
UInt32 row =id/getHServers();
UInt32 column=id%getHServers();
// calculate width and height from local width and height
UInt32 width = serverWindow->getWidth() ;
UInt32 height = serverWindow->getHeight();
if(getWidth()==0)
{
setWidth( width*getHServers() );
}
if(getHeight()==0)
{
setHeight( height*getVServers() );
}
Int32 left = column * width - column * getXOverlap();
Int32 bottom = row * height - row * getYOverlap();
Int32 right = left + width - 1;
Int32 top = bottom + height - 1;
Real64 scaleCWidth =
((width - getXOverlap()) * (getHServers() - 1) + width) /
(float)getWidth();
Real64 scaleCHeight =
((height - getYOverlap())* (getVServers() - 1) + height)/
(float)getHeight();
bool isVirtualPort = false;
// duplicate viewports
for(cv = 0, sv = 0; cv < getPort().size(); ++cv)
{
clientPort = getPort()[cv];
#if 0
isVirtualPort = clientPort->getType().isDerivedFrom(FBOViewport::getClassType());
if(isVirtualPort)
{
// TODO -- seems wrong to render this on all servers, though rendering
// then transmitting the texture doesn't seem like a good idea either.
if(serverWindow->getPort().size() <= sv)
{
serverPort = ViewportPtr::dcast(clientPort->shallowCopy());
beginEditCP(serverWindow);
serverWindow->addPort(serverPort);
endEditCP(serverWindow);
}
else
{
serverPort = serverWindow->getPort()[sv];
if(serverWindow->getPort()[sv]->getType() !=
clientPort->getType())
{
// there is a viewport with the wrong type
subRefCP(serverWindow->getPort()[sv]);
serverPort = ViewportPtr::dcast(clientPort->shallowCopy());
beginEditCP(serverWindow);
{
serverWindow->getPort()[sv] = serverPort;
}
endEditCP(serverWindow);
}
}
// update changed viewport fields
updateViewport(serverPort,clientPort);
}
else
#endif
{
clientStereoPort =
dynamic_cast<StereoBufferViewportPtr>(clientPort);
cleft = (Int32)(clientPort->getPixelLeft() * scaleCWidth) ;
cbottom = (Int32)(clientPort->getPixelBottom() * scaleCHeight) ;
cright = (Int32)((clientPort->getPixelRight()+1) * scaleCWidth) -1;
ctop = (Int32)((clientPort->getPixelTop()+1) * scaleCHeight)-1;
if(cright < left ||
cleft > right ||
ctop < bottom ||
cbottom > top )
{
// invisible on this server screen
continue;
}
// calculate overlapping viewport
l = osgMax(cleft ,left ) - left;
b = osgMax(cbottom,bottom) - bottom;
r = osgMin(cright ,right ) - left;
t = osgMin(ctop ,top ) - bottom;
if(serverWindow->getPort().size() <= sv)
{
serverPort =
dynamic_cast<ViewportPtr>(clientPort->shallowCopy());
deco = TileCameraDecorator::create();
serverWindow->addPort(serverPort);
serverPort->setCamera(deco);
}
else
{
serverPort = serverWindow->getPort()[sv];
deco = dynamic_cast<TileCameraDecoratorPtr>(
serverPort->getCamera());
if(serverWindow->getPort()[sv]->getType() !=
clientPort->getType())
{
// there is a viewport with the wrong type
serverPort =
dynamic_cast<ViewportPtr>(clientPort->shallowCopy());
serverWindow->replacePort(sv,
serverPort);//[sv] = serverPort;
serverPort->setCamera(deco);
}
else
{
deco = dynamic_cast<TileCameraDecoratorPtr>(
serverPort->getCamera());
}
}
// update changed viewport fields
updateViewport(serverPort,clientPort);
// set viewport size
serverPort->setSize(Real32(l),Real32(b),Real32(r),Real32(t));
// use pixel even if pixel = 1
if(serverPort->getLeft() == 1.0)
serverPort->setLeft(1.0001);
if(serverPort->getRight() == 1.0)
serverPort->setRight(1.0001);
if(serverPort->getTop() == 1.0)
serverPort->setTop(1.0001);
if(serverPort->getBottom() == 1.0)
serverPort->setBottom(1.0001);
// calculate tile parameters
deco->setFullWidth ( cright-cleft );
deco->setFullHeight( ctop-cbottom );
deco->setSize( ( l+left-cleft ) / (float)( cright-cleft ),
( b+bottom-cbottom ) / (float)( ctop-cbottom ),
( r+left-cleft ) / (float)( cright-cleft ),
( t+bottom-cbottom ) / (float)( ctop-cbottom ) );
deco->setDecoratee( clientPort->getCamera() );
}
sv++;
}
// remove unused ports
while(serverWindow->getPort().size()>sv)
{
serverWindow->subPort(sv);
}
Inherited::serverRender(serverWindow,id,action);
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG CGFX Shader");
// the connection between GLUT and OpenSG
_gwin = GLUTWindow::create();
_gwin->setId(winid);
_gwin->setSize( 800, 800 );
_gwin->init();
// init callbacks
glutSetWindow(winid);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
const char *effectFile = "BumpGlossedShiny.fx";
if(argc > 1)
{
effectFile = argv[1];
}
_cgfxmat = CGFXMaterial::create();
beginEditCP(_cgfxmat);
_cgfxmat->setEffectFile(effectFile);
// this multipass technique leads to a render bug, I have no idea what's wrong :-(
//_cgfxmat->setTechnique(1);
endEditCP(_cgfxmat);
ChunkMaterialPtr mat2 = ChunkMaterial::create();
MaterialChunkPtr matc = MaterialChunk::create();
beginEditCP(matc);
matc->setDiffuse(Color4f(1, 0, 0, 1));
endEditCP(matc);
beginEditCP(mat2);
mat2->addChunk(matc);
//mat2->addChunk(texc);
endEditCP(mat2);
// create root node
_scene = Node::create();
GeometryPtr geo1 = makeLatLongSphereGeo(50, 50, 1.0f);
OSG::calcVertexTangents(geo1, 0, Geometry::TexCoords1FieldId, Geometry::TexCoords2FieldId);
beginEditCP( geo1, Geometry::MaterialFieldMask);
geo1->setMaterial(_cgfxmat);
endEditCP(geo1, Geometry::MaterialFieldMask);
NodePtr sphere1 = Node::create();
beginEditCP(sphere1, Node::CoreFieldMask);
sphere1->setCore(geo1);
endEditCP(sphere1, Node::CoreFieldMask);
TransformPtr trans1 = Transform::create();
beginEditCP(trans1);
trans1->getMatrix().setTranslate(-2 , 0, 0);
endEditCP(trans1);
NodePtr transn1 = Node::create();
beginEditCP(transn1);
transn1->setCore(trans1);
transn1->addChild(sphere1);
beginEditCP(transn1);
//
GeometryPtr geo2 = makeLatLongSphereGeo(50, 50, 1.0f);
beginEditCP( geo2, Geometry::MaterialFieldMask);
geo2->setMaterial(mat2);
endEditCP(geo2, Geometry::MaterialFieldMask);
NodePtr sphere2 = Node::create();
beginEditCP(sphere2, Node::CoreFieldMask);
sphere2->setCore(geo2);
endEditCP(sphere2, Node::CoreFieldMask);
TransformPtr trans2 = Transform::create();
beginEditCP(trans2);
trans2->getMatrix().setTranslate(2 , 0, 0);
endEditCP(trans2);
NodePtr transn2 = Node::create();
beginEditCP(transn2);
transn2->setCore(trans2);
transn2->addChild(sphere2);
beginEditCP(transn2);
beginEditCP(_scene);
_scene->setCore(Group::create());
_scene->addChild(transn1);
_scene->addChild(transn2);
endEditCP(_scene);
// create the SimpleSceneManager
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(_gwin);
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// create a gradient background.
GradientBackgroundPtr gback = GradientBackground::create();
beginEditCP(gback, GradientBackground::LineFieldMask);
gback->clearLines();
gback->addLine(Color3f(0.7, 0.7, 0.8), 0);
gback->addLine(Color3f(0.0, 0.1, 0.3), 1);
endEditCP(gback, GradientBackground::LineFieldMask);
WindowPtr win = _mgr->getWindow();
beginEditCP(win);
for(int i=0;i<win->getPort().size();++i)
{
ViewportPtr vp = win->getPort()[i];
beginEditCP(vp);
vp->setBackground(gback);
endEditCP(vp);
}
endEditCP(win);
// GLUT main loop
glutMainLoop();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin = GLUTWindow::create();
beginEditCP(gwin);
gwin->setId(winid);
gwin->setSize( 800, 800 );
gwin->init();
endEditCP(gwin);
// create root node
_scene = makeCoredNode<Group>();
GeometryPtr geo = makeBoxGeo(0.5, 0.5, 0.5, 1, 1, 1);
// share the chunk
CGChunkPtr cg = CGChunk::create();
beginEditCP(cg);
cg->setVertexProfile(CG_PROFILE_ARBVP1);
cg->setVertexProgram(_vp_program);
cg->setFragmentProfile(CG_PROFILE_ARBFP1);
cg->setFragmentProgram(_fp_program);
endEditCP(cg);
Int32 size = 4;
// start color
Vec3f sc(0.0, 0.0, 0.0);
// end color
Vec3f ec(1.0, 1.0, 1.0);
Real32 sr = (ec[0] - sc[0]) / Real32((size*2));
Real32 sg = (ec[1] - sc[1]) / Real32((size*2));
Real32 sb = (ec[2] - sc[2]) / Real32((size*2));
Vec3f color(sc);
Int32 x = - size;
Int32 y = - size;
Int32 z = - size;
UInt32 iterations = size*2 * size*2 * size*2;
printf("Creating %u cubes ...\n", iterations);
for(UInt32 i=0;i<iterations;++i)
{
ChunkMaterialPtr cmat = ChunkMaterial::create();
// ok use one CGChunk and n CGParameterChunks
CGParameterChunkPtr cgparameter = CGParameterChunk::create();
beginEditCP(cgparameter);
cgparameter->setCGChunk(cg);
cgparameter->setUniformParameter("SurfaceColor", color);
endEditCP(cgparameter);
_cgparameter = cgparameter;
beginEditCP(cmat);
cmat->addChunk(cg);
cmat->addChunk(cgparameter);
endEditCP(cmat);
TransformPtr trans;
NodePtr trans_node = makeCoredNode<Transform>(&trans);
beginEditCP(trans);
trans->getMatrix().setTranslate(Real32(x), Real32(y), Real32(z));
endEditCP(trans);
MaterialGroupPtr mg;
NodePtr mg_node = makeCoredNode<MaterialGroup>(&mg);
beginEditCP(mg, MaterialGroup::MaterialFieldMask);
mg->setMaterial(cmat);
endEditCP(mg, MaterialGroup::MaterialFieldMask);
NodePtr geonode = Node::create();
beginEditCP(geonode, Node::CoreFieldMask);
geonode->setCore(geo);
endEditCP(geonode, Node::CoreFieldMask);
beginEditCP(mg_node);
mg_node->addChild(geonode);
endEditCP(mg_node);
beginEditCP(trans_node);
trans_node->addChild(mg_node);
endEditCP(trans_node);
// add to scene
beginEditCP(_scene);
_scene->addChild(trans_node);
endEditCP(_scene);
// ----
++x;
color[0] += sr;
if(x == size)
{
x = - size;
++y;
color[0] = sc[0];
color[1] += sg;
if(y == size)
{
y = - size;
++z;
color[1] = sc[1];
color[2] += sb;
}
}
}
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// create a gradient background.
GradientBackgroundPtr gback = GradientBackground::create();
beginEditCP(gback, GradientBackground::LineFieldMask);
gback->clearLines();
gback->addLine(Color3f(0.7, 0.7, 0.8), 0);
gback->addLine(Color3f(0.0, 0.1, 0.3), 1);
endEditCP(gback, GradientBackground::LineFieldMask);
WindowPtr win = _mgr->getWindow();
beginEditCP(win);
for(int i=0;i<win->getPort().size();++i)
{
ViewportPtr vp = win->getPort()[i];
beginEditCP(vp);
vp->setBackground(gback);
endEditCP(vp);
}
endEditCP(win);
// GLUT main loop
glutMainLoop();
return 0;
}
