Hello,
concerning the skinning-with-cluster problem:
I found out, that some changes to the Ogre skinning mesh take place while
rendering. So the extra rendering for the shadow map triggers the update,
but leaving out the shadow stage will not update the skinning correctly. As
an example I added the following lines in the displayCB method to
character.cpp from the advanced examples:
[...]
OSG::FrameHandler::the()->frame(currT);
//OSG::commitChangesAndClear(); // do not clear
changes now, cluster needs changes, right? (let's pretend that the render
call is done on a clusterwindow)
OSG::Thread::getCurrentChangeList()->commitChanges();
g->mgr->idle ();
g->mgr->redraw();
//OSG::Thread::getCurrentChangeList()->clear(); // not working, because
no commit is done, skinning mesh will not move
OSG::commitChangesAndClear(); // working for
client, but still not working for servers, though
[...]
So, the skeleton joints move correctly (rendermode 1 shows that), but the
skinning is doing some update which is triggered with the rendering. Could
this update be moved to another place?
(I hope the developer of the Ogre-Skinning node is still reading this...)
Cheers,
Volker
> -----Original Message-----
> From: Volker Settgast [mailto:v.settg...@cgv.tugraz.at]
> Sent: Donnerstag, 02. August 2012 08:55
> To: opensg-users@lists.sourceforge.net
> Subject: Re: [Opensg-users] OSG2, Ogre skinning + cluster
>
> >
> > Hello Volker,
> >
> > On 08/01/2012 03:22 PM, Volker Settgast wrote:
> > > I know there are only a few who are working with the Ogre-Character
> > > meshes, but I am stuck:
> > >
> > > I got the skinning animations working fine for non-cluster
applications.
> > > Now I just changed to a setup with distributed rendering and
> > > skinning animation is not working. But - and now the tricky part -
> > > it works if I include a shadow stage and actually activate it with
> > > an arbitrary shadow shader.
> > >
> > > This is true for CPU and GPU skinning. It I deactivate the shadow
> > > (set the shadow mode to NO_SHADOW) the animation is not updated.
> > >
> > > I tried to trace the problem, found out that in the working case the
> > > JointMatricesFieldMask is changed and without the shadow stage this
> > > change is missing.
> > >
> > > Does anyone have a clue what could be the problem here? (besides me
> > > being all confused about the change list changes with the shadow
> > > stage
> > > .)
> >
> > from the symptoms you are describing my first guess would be that the
> > character is frustum culled and that prevents an update of the matrices.
> > Since the shadows render the scene in a way that all of it is inside
> > the frustum you get an update of the matrices by adding a shadow stage.
> > One option that comes to mind to get around this is to keep characters
> > in
> a
> > tree on the side and link them into the main scene via VisitSubTree.
> > The
> on-
> > the-side tree could then be updated by running a action with disabled
> > frustum culling.
> >
> > Cheers,
> > Carsten
> >
>
> Hello Carsten,
>
> to be sure I deactivated frustum culling. It is not the problem.
>
> It seems to be some difference with the skeleton updates with skinning. In
> render mode 1 (just skeleton visible) everything works fine. So I will
compare
> the skeleton-renderer with the skinning-renderer. There has to be a tiny
> difference in the jointmatrix updates.
>
> Cheers,
> Volker
>
>
>
>
----------------------------------------------------------------------------
--
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and threat
> landscape has changed and how IT managers can respond. Discussions will
> include endpoint security, mobile security and the latest in malware
threats.
> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Opensg-users mailing list
> Opensg-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/opensg-users
#ifdef OSG_BUILD_ACTIVE
// Headers
#include <OSGConfig.h>
#include <OSGAnimation.h>
#include <OSGAnimBindAction.h>
#include <OSGAnimKeyFrameTemplate.h>
#include <OSGGlobalsAttachment.h>
#include <OSGGLUT.h>
#include <OSGGLUTWindow.h>
#include <OSGImageFileHandler.h>
#include <OSGMatrixUtility.h>
#include <OSGNameAttachment.h>
#include <OSGSceneFileHandler.h>
#include <OSGShaderProgram.h>
#include <OSGShaderProgramChunk.h>
#include <OSGSimpleGeometry.h>
#include <OSGSimpleSceneManager.h>
#include <OSGSkinnedGeometry.h>
#include <OSGSkyBackground.h>
#include <OSGTextureObjChunk.h>
#include <OpenSG/OSGLog.h>
#else // OSG_BUILD_ACTIVE
#include <OpenSG/OSGConfig.h>
#include <OpenSG/OSGAnimation.h>
#include <OpenSG/OSGAnimBindAction.h>
#include <OpenSG/OSGAnimKeyFrameTemplate.h>
#include <OpenSG/OSGGlobalsAttachment.h>
#include <OpenSG/OSGGLUT.h>
#include <OpenSG/OSGGLUTWindow.h>
#include <OpenSG/OSGImageFileHandler.h>
#include <OpenSG/OSGNameAttachment.h>
#include <OpenSG/OSGMatrixUtility.h>
#include <OpenSG/OSGSceneFileHandler.h>
#include <OpenSG/OSGShaderProgram.h>
#include <OpenSG/OSGShaderProgramChunk.h>
#include <OpenSG/OSGSimpleGeometry.h>
#include <OpenSG/OSGSimpleSceneManager.h>
#include <OpenSG/OSGSkinnedGeometry.h>
#include <OpenSG/OSGSkyBackground.h>
#include <OpenSG/OSGTextureObjChunk.h>
#include <OpenSG/OSGPathHandler.h>
#include <OpenSG/OSGLog.h>
#endif // OSG_BUILD_ACTIVE
#include <boost/array.hpp>
#include <map>
#include <set>
typedef std::set<OSG::SkinnedGeometry *> SkinnedGeoStore;
typedef std::set<OSG::Material *> MaterialStore;
typedef std::map<std::string, OSG::TextureObjChunkRefPtr> TextureMap;
enum AnimIdE
{
AnimIdWalkUB,
AnimIdWalkLB,
AnimIdRunUB,
AnimIdRunLB,
AnimIdIdleUB,
AnimIdIdleLB,
AnimIdMAX
};
enum AnimStateE
{
AnimOff,
AnimFadeIn,
AnimFadeOut,
AnimOn
};
enum CharacterStateE
{
CharIdle,
CharWalk,
CharRun
};
struct GlobalVars
{
OSG::SimpleSceneManagerRefPtr mgr;
OSG::GLUTWindowRefPtr win;
OSG::NodeRefPtr rootN;
OSG::TransformRefPtr xform;
OSG::Real32 angle;
OSG::Real32 angleVel;
CharacterStateE charState;
CharacterStateE prevCharState;
AnimStateE animState[AnimIdMAX];
OSG::AnimationRefPtr anims [AnimIdMAX];
SkinnedGeoStore skinGeos;
MaterialStore materials;
TextureMap texMap;
OSG::SkinnedGeometry::RenderModeE renderMode;
OSG::ShaderProgramChunkRefPtr skinShader;
};
const OSG::Real32 idleAngleVel = 0.f;
const OSG::Real32 walkAngleVel = OSG::TwoPi / 20.f;
const OSG::Real32 runAngleVel = OSG::TwoPi / 10.f;
boost::array<const std::string, AnimIdMAX> animNames = {
{
"UB_walk",
"LB_walk",
"UB_newRun",
"LB_newRun",
"UB_idle",
"LB_idle"
}
};
GlobalVars *g = NULL;
void init (int argc, char *argv[]);
void cleanup(void);
void loadCharacter (void);
void loadTextures (void);
void initAnimations(void);
void loadBackground(void);
void initFloor (void);
void initShader (void);
void enableRenderMode(OSG::SkinnedGeometry::RenderModeE rm);
void reshapeCB (int w, int h);
void displayCB (void);
void mouseCB (int button, int state, int mouseX, int mouseY);
void motionCB (int mouseX, int mouseY);
void keyboardCB(unsigned char k, int mouseX, int mouseY);
void idleCB (void);
int setupGLUT (int *argc, char *argv[]);
// extended path handler (to get the paths back)
class myPathHandlerClass : public OSG::PathHandler
{
public:
typedef std::list<std::string> PathList;
inline PathList& getPathList() { return _pathList;}
};
int main(int argc, char *argv[])
{
// load dlls
OSG::preloadSharedObject("OSGFileIO");
OSG::preloadSharedObject("OSGContribPLY");
OSG::preloadSharedObject("OSGImageFileIO");
myPathHandlerClass myPH;
OSG::SceneFileHandler::the()->setPathHandler(&myPH);
OSG::ImageFileHandler::the()->setPathHandler(&myPH);
OSG::ImageFileHandler::the()->getPathHandler()->push_backWin32Path("opensg/Examples/Advanced/Character");
//OSG::osgLog().setLogType(OSG::LOG_FILE);
//OSG::osgLog().setLogFile("log.txt");
init(argc, argv);
//OSG::osgLog().setLogType(OSG::LOG_STDOUT);
glutMainLoop();
cleanup();
return 0;
}
// ============================================================================
void init(int argc, char *argv[])
{
// enable changelist
OSG::ChangeList::setReadWriteDefault(true);
OSG::osgInit(argc, argv);
g = new GlobalVars;
int glutWinId = setupGLUT(&argc, argv);
g->win = OSG::GLUTWindow::create();
g->win->setGlutId(glutWinId);
g->win->init();
g->mgr = OSG::SimpleSceneManager::create();
g->mgr->setWindow(g->win);
g->rootN = OSG::makeCoredNode<OSG::Group>();
g->mgr->setRoot(g->rootN);
g->mgr->getHeadlight()->setDiffuse (0.7f, 0.7f, 0.5f, 1.f);
g->mgr->getHeadlight()->setAmbient (0.3f, 0.3f, 0.3f, 1.f);
g->mgr->getHeadlight()->setSpecular(0.3f, 0.3f, 0.3f, 1.f);
g->charState = CharIdle;
g->prevCharState = CharIdle;
g->angle = 0.f;
g->angleVel = idleAngleVel;
g->renderMode = OSG::SkinnedGeometry::RMSkinnedCPU;
loadCharacter ();
loadTextures ();
initAnimations();
loadBackground();
initFloor ();
initShader ();
g->mgr->showAll();
}
// ============================================================================
void cleanup(void)
{
if(g == NULL)
return;
g->mgr = NULL;
delete g;
g = NULL;
OSG::osgExit();
}
// ============================================================================
class ObjectCollector
{
public:
void operator()(OSG::Node *root);
private:
OSG::Action::ResultE enterFunc(OSG::Node *node);
};
void
ObjectCollector::operator()(OSG::Node *root)
{
g->skinGeos .clear();
g->materials.clear();
OSG::traverse(root, boost::bind(&ObjectCollector::enterFunc, this, _1));
}
OSG::Action::ResultE
ObjectCollector::enterFunc(OSG::Node *node)
{
OSG::NodeCore *core = node->getCore();
if(core->getType().isDerivedFrom(OSG::SkinnedGeometry::getClassType()))
{
OSG::SkinnedGeometry *skinGeo =
dynamic_cast<OSG::SkinnedGeometry*>(core);
g->skinGeos .insert(skinGeo );
g->materials.insert(skinGeo->getMaterial());
}
return OSG::Action::Continue;
}
// ============================================================================
void loadCharacter(void)
{
OSG::NodeUnrecPtr modelN =
OSG::SceneFileHandler::the()->read("western.male01.mesh", NULL);
ObjectCollector()(modelN);
SkinnedGeoStore::iterator sIt = g->skinGeos.begin();
SkinnedGeoStore::iterator sEnd = g->skinGeos.end ();
for(; sIt != sEnd; ++sIt)
{
(*sIt)->setRenderMode(g->renderMode);
}
g->xform = OSG::Transform::create();
OSG::NodeUnrecPtr xformN = OSG::makeNodeFor(g->xform);
xformN->addChild(modelN);
g->rootN->addChild(xformN);
}
// ============================================================================
void loadTextures(void)
{
MaterialStore::iterator mIt = g->materials.begin();
MaterialStore::iterator mEnd = g->materials.end ();
for(; mIt != mEnd; ++mIt)
{
if(OSG::getName(*mIt) != NULL)
{
FLOG(("mat name '%s'\n", OSG::getName(*mIt)));
std::string matName = OSG::getName(*mIt);
TextureMap::iterator tIt = g->texMap.find(matName);
if(tIt == g->texMap.end())
{
std::string::size_type pos = matName.find("_");
std::string texName = matName.substr(0, pos) +
"_diffuse.tga";
OSG::ImageUnrecPtr texImg =
OSG::ImageFileHandler::the()->read(texName.c_str());
OSG::TextureObjChunkUnrecPtr texObj =
OSG::TextureObjChunk::create();
texObj->setImage(texImg);
g->texMap.insert(TextureMap::value_type(matName, texObj));
tIt = g->texMap.find(matName);
}
OSG_ASSERT(tIt != g->texMap.end());
OSG::ChunkMaterial *chunkMat =
dynamic_cast<OSG::ChunkMaterial*>(*mIt);
if(chunkMat != NULL)
{
FLOG(("adding texture chunk\n"));
chunkMat->addChunk((*tIt).second);
}
}
}
}
// ============================================================================
OSG::Action::ResultE
initAnimationsEnterFunc(OSG::Node *node)
{
OSG::Action::ResultE retVal = OSG::Action::Continue;
OSG::GlobalsAttachment *globals = dynamic_cast<OSG::GlobalsAttachment *>(
node->findAttachment(OSG::GlobalsAttachment::getClassType()));
if(globals == NULL)
return retVal;
OSG::GlobalsAttachment::MFElementsType::const_iterator eIt =
globals->getMFElements()->begin();
OSG::GlobalsAttachment::MFElementsType::const_iterator eEnd =
globals->getMFElements()->end ();
for(; eIt != eEnd; ++eIt)
{
OSG::AnimTemplate *animTmpl = dynamic_cast<OSG::AnimTemplate *>(*eIt);
if(animTmpl == NULL)
continue;
for(OSG::UInt32 i = 0; i < animNames.size(); ++i)
{
if(animNames[i] == animTmpl->getName())
{
FLOG(("instantiating anim %s\n", animNames[i].c_str()));
g->anims [i] = animTmpl->instantiate(node);
g->anims [i]->setWeight(0.f);
g->animState[i] = AnimOff;
}
}
}
return retVal;
}
void initAnimations(void)
{
OSG::traverse(g->rootN, &initAnimationsEnterFunc);
g->animState[AnimIdIdleUB] = AnimFadeIn;
g->animState[AnimIdIdleLB] = AnimFadeIn;
}
// ============================================================================
void updateAnimations(OSG::Time currT, OSG::Time deltaT)
{
for(OSG::UInt32 i = 0; i < AnimIdMAX; ++i)
{
switch(g->animState[i])
{
case AnimOff:
{
if(g->anims[i]->getEnabled() == true)
{
// FLOG(("AnimOff: disabling anim %d %s\n",
// i, g->anims[i]->getName().c_str()));
g->anims[i]->stop ();
g->anims[i]->setEnabled(false);
g->anims[i]->setWeight (0.f);
}
}
break;
case AnimFadeIn:
{
OSG::Real32 oldW = g->anims[i]->getWeight();
OSG::Real32 newW = OSG::osgMin<OSG::Real32>(1.f, oldW + deltaT);
if(oldW < 1.f)
{
// FLOG(("AnimFadeIn: new weight %f - %d %s\n",
// newW, i, g->anims[i]->getName().c_str()));
g->anims[i]->setWeight(newW);
}
if(newW >= 1.f)
{
// FLOG(("AnimFadeIn: new state AnimOn %d %s\n",
// i, g->anims[i]->getName().c_str()));
g->animState[i] = AnimOn;
g->anims [i]->setWeight(1.f);
}
if(g->anims[i]->getEnabled() == false)
{
// FLOG(("AnimFadeIn: enabling anim %d %s\n",
// i, g->anims[i]->getName().c_str()));
g->anims[i]->reset ();
g->anims[i]->setEnabled(true);
g->anims[i]->startLoop
(OSG::FrameHandler::the()->getTimeStamp());
}
}
break;
case AnimFadeOut:
{
OSG::Real32 oldW = g->anims[i]->getWeight();
OSG::Real32 newW = OSG::osgMax<OSG::Real32>(0.f, oldW - deltaT);
if(oldW > 0.f)
{
// FLOG(("AnimFadeOut: new weight %f - %d %s\n",
// newW, i, g->anims[i]->getName().c_str()));
g->anims[i]->setWeight(newW);
}
if(newW <= 0.f)
{
// FLOG(("AnimFadeOut: new state AnimOff %d %s\n",
// i, g->anims[i]->getName().c_str()));
g->animState[i] = AnimOff;
g->anims [i]->setWeight(0.f);
}
}
break;
case AnimOn:
{
if(g->anims[i]->getEnabled() == false)
{
// FLOG(("AnimOn: enabling anim %d %s\n",
// i, g->anims[i]->getName().c_str()));
g->anims[i]->reset ();
g->anims[i]->setEnabled(true);
g->anims[i]->startLoop
(OSG::FrameHandler::the()->getTimeStamp());
g->anims[i]->setWeight (1.f);
}
}
break;
}
}
}
// ============================================================================
OSG::Real32 speedByState(CharacterStateE state)
{
OSG::Real32 retVal = 0.f;
switch(state)
{
case CharIdle:
retVal = idleAngleVel;
break;
case CharWalk:
retVal = walkAngleVel;
break;
case CharRun:
retVal = runAngleVel;
break;
}
return retVal;
}
void updatePosition(OSG::Time deltaT)
{
OSG::Real32 oldVel = speedByState(g->prevCharState);
OSG::Real32 newVel = speedByState(g->charState );
switch(g->charState)
{
case CharIdle:
{
OSG::Real32 w1 = g->anims[AnimIdIdleLB]->getWeight();
OSG::Real32 w0 = 1.f - w1;
g->angleVel = w0 * oldVel + w1 * newVel;
}
break;
case CharWalk:
{
OSG::Real32 w1 = g->anims[AnimIdWalkLB]->getWeight();
OSG::Real32 w0 = 1.f - w1;
g->angleVel = w0 * oldVel + w1 * newVel;
}
break;
case CharRun:
{
OSG::Real32 w1 = g->anims[AnimIdRunLB]->getWeight();
OSG::Real32 w0 = 1.f - w1;
g->angleVel = w0 * oldVel + w1 * newVel;
}
break;
}
g->angle += deltaT * g->angleVel;
OSG::Pnt3f from;
from[0] = 500.f * OSG::osgCos(g->angle);
from[2] = 500.f * OSG::osgSin(g->angle);
OSG::Pnt3f at;
at[0] = from[0] + from[2];
at[2] = from[2] - from[0];
OSG::Vec3f up;
up[1] = 1.f;
OSG::Matrix mat;
OSG::MatrixLookAt(mat, from, at, up);
g->xform->setMatrix(mat);
}
// ============================================================================
void loadBackground(void)
{
OSG::ImageUnrecPtr imgFront =
OSG::ImageFileHandler::the()->read("skyBoxFront.jpg");
OSG::TextureObjChunkUnrecPtr texFront = OSG::TextureObjChunk::create();
texFront->setImage(imgFront);
OSG::ImageUnrecPtr imgBack =
OSG::ImageFileHandler::the()->read("skyBoxBack.jpg");
OSG::TextureObjChunkUnrecPtr texBack = OSG::TextureObjChunk::create();
texBack->setImage(imgBack);
OSG::ImageUnrecPtr imgLeft =
OSG::ImageFileHandler::the()->read("skyBoxLeft.jpg");
OSG::TextureObjChunkUnrecPtr texLeft = OSG::TextureObjChunk::create();
texLeft->setImage(imgLeft);
OSG::ImageUnrecPtr imgRight =
OSG::ImageFileHandler::the()->read("skyBoxRight.jpg");
OSG::TextureObjChunkUnrecPtr texRight = OSG::TextureObjChunk::create();
texRight->setImage(imgRight);
OSG::ImageUnrecPtr imgTop =
OSG::ImageFileHandler::the()->read("skyBoxTop.jpg");
OSG::TextureObjChunkUnrecPtr texTop = OSG::TextureObjChunk::create();
texTop->setImage(imgTop);
OSG::ImageUnrecPtr imgBottom =
OSG::ImageFileHandler::the()->read("skyBoxBottom.jpg");
OSG::TextureObjChunkUnrecPtr texBottom = OSG::TextureObjChunk::create();
texBottom->setImage(imgBottom);
OSG::SkyBackgroundUnrecPtr skyBG = OSG::SkyBackground::create();
skyBG->setFrontTexture (texFront);
skyBG->setBackTexture (texBack );
skyBG->setLeftTexture (texLeft );
skyBG->setRightTexture (texRight);
skyBG->setTopTexture (texTop );
skyBG->setBottomTexture(texBottom);
g->mgr->setBackground(skyBG);
}
// ============================================================================
void initFloor(void)
{
OSG::GeometryUnrecPtr floor = OSG::makePlaneGeo(2000.f, 2000.f, 10, 10);
OSG::NodeUnrecPtr floorN = OSG::makeNodeFor(floor);
OSG::TransformUnrecPtr xform = OSG::Transform::create();
OSG::NodeUnrecPtr xformN = OSG::makeNodeFor(xform);
OSG::ImageUnrecPtr img =
OSG::ImageFileHandler::the()->read("sand1Tile.png");
OSG::TextureObjChunkUnrecPtr tex = OSG::TextureObjChunk::create();
tex->setImage(img);
OSG::ChunkMaterial *chunkMat = dynamic_cast<OSG::ChunkMaterial
*>(floor->getMaterial());
if(chunkMat != NULL)
{
chunkMat->addChunk(tex);
}
OSG::Quaternion quat;
quat.setValueAsAxisDeg(OSG::Vec3f(1.f, 0.f, 0.f), -90.f);
xform->editMatrix().setRotate(quat);
xformN->addChild(floorN);
g->rootN->addChild(xformN);
}
// ============================================================================
void initShader(void)
{
OSG::ShaderProgramUnrecPtr vp = OSG::ShaderProgram::createVertexShader();
vp->readProgram("vertex_skinned.vp.glsl");
OSG::ShaderProgramUnrecPtr fp = OSG::ShaderProgram::createFragmentShader();
fp->readProgram("vertex_skinned.fp.glsl");
fp->addUniformVariable("diffuseMap", 0);
fp->addOSGVariable ("OSGLight0Active");
fp->addOSGVariable ("OSGLight1Active");
fp->addOSGVariable ("OSGLight2Active");
fp->addOSGVariable ("OSGLight3Active");
g->skinShader = OSG::ShaderProgramChunk::create();
g->skinShader->addShader(vp);
g->skinShader->addShader(fp);
}
void enableRenderMode(OSG::SkinnedGeometry::RenderModeE rm)
{
if(g->renderMode == rm)
return;
if(g->renderMode == OSG::SkinnedGeometry::RMSkinnedGPU)
{
// remove shader chunk
MaterialStore::iterator mIt = g->materials.begin();
MaterialStore::iterator mEnd = g->materials.end ();
for(; mIt != mEnd; ++mIt)
{
OSG::ChunkMaterial *chunkMat = dynamic_cast<OSG::ChunkMaterial
*>((*mIt));
if(chunkMat != NULL)
chunkMat->subChunk(g->skinShader);
}
}
if(rm == OSG::SkinnedGeometry::RMSkinnedGPU)
{
// add shader chunk
MaterialStore::iterator mIt = g->materials.begin();
MaterialStore::iterator mEnd = g->materials.end ();
for(; mIt != mEnd; ++mIt)
{
OSG::ChunkMaterial *chunkMat = dynamic_cast<OSG::ChunkMaterial
*>((*mIt));
if(chunkMat != NULL)
chunkMat->addChunk(g->skinShader);
}
}
SkinnedGeoStore::iterator sIt = g->skinGeos.begin();
SkinnedGeoStore::iterator sEnd = g->skinGeos.end ();
for(; sIt != sEnd; ++sIt)
{
(*sIt)->setRenderMode(rm);
}
FLOG(("enable render mode %d\n", rm));
g->renderMode = rm;
}
// ============================================================================
// GLUT callback functions
//
void reshapeCB(int w, int h)
{
g->mgr->resize(w, h);
glutPostRedisplay();
}
void displayCB(void)
{
static OSG::Time prevT = OSG::getSystemTime();
OSG::Time currT = OSG::getSystemTime();
OSG::Time deltaT = currT - prevT;
updateAnimations(currT, deltaT);
updatePosition (deltaT);
OSG::FrameHandler::the()->frame(currT);
//OSG::commitChangesAndClear();
OSG::Thread::getCurrentChangeList()->commitChanges();
//OSG::commitChanges();
g->mgr->idle ();
g->mgr->redraw();
//OSG::Thread::getCurrentChangeList()->clear(); // not working
OSG::commitChangesAndClear(); // working for client
(still not for servers)
prevT = currT;
}
void mouseCB(int button, int state, int mouseX, int mouseY)
{
if(state)
g->mgr->mouseButtonRelease(button, mouseX, mouseY);
else
g->mgr->mouseButtonPress(button, mouseX, mouseY);
glutPostRedisplay();
}
void motionCB(int mouseX, int mouseY)
{
g->mgr->mouseMove(mouseX, mouseY);
glutPostRedisplay();
}
void keyboardCB(unsigned char k, int mouseX, int mouseY)
{
switch(k)
{
case 27:
case 'q':
case 'Q':
cleanup();
OSG::osgExit();
std::exit(0);
break;
case '1':
{
// fade in walk
if(g->animState[AnimIdWalkUB] != AnimOn)
g->animState[AnimIdWalkUB] = AnimFadeIn;
if(g->animState[AnimIdWalkLB] != AnimOn)
g->animState[AnimIdWalkLB] = AnimFadeIn;
// fade out other
if(g->animState[AnimIdRunUB] != AnimOff)
g->animState[AnimIdRunUB] = AnimFadeOut;
if(g->animState[AnimIdRunLB] != AnimOff)
g->animState[AnimIdRunLB] = AnimFadeOut;
if(g->animState[AnimIdIdleUB] != AnimOff)
g->animState[AnimIdIdleUB] = AnimFadeOut;
if(g->animState[AnimIdIdleLB] != AnimOff)
g->animState[AnimIdIdleLB] = AnimFadeOut;
g->prevCharState = g->charState;
g->charState = CharWalk;
}
break;
case '2':
{
// fade in run
if(g->animState[AnimIdRunUB] != AnimOn)
g->animState[AnimIdRunUB] = AnimFadeIn;
if(g->animState[AnimIdRunLB] != AnimOn)
g->animState[AnimIdRunLB] = AnimFadeIn;
// fade out other
if(g->animState[AnimIdWalkUB] != AnimOff)
g->animState[AnimIdWalkUB] = AnimFadeOut;
if(g->animState[AnimIdWalkLB] != AnimOff)
g->animState[AnimIdWalkLB] = AnimFadeOut;
if(g->animState[AnimIdIdleUB] != AnimOff)
g->animState[AnimIdIdleUB] = AnimFadeOut;
if(g->animState[AnimIdIdleLB] != AnimOff)
g->animState[AnimIdIdleLB] = AnimFadeOut;
g->prevCharState = g->charState;
g->charState = CharRun;
}
break;
case '3':
{
// fade in idle
if(g->animState[AnimIdIdleUB] != AnimOn)
g->animState[AnimIdIdleUB] = AnimFadeIn;
if(g->animState[AnimIdIdleLB] != AnimOn)
g->animState[AnimIdIdleLB] = AnimFadeIn;
// fade out other
if(g->animState[AnimIdRunUB] != AnimOff)
g->animState[AnimIdRunUB] = AnimFadeOut;
if(g->animState[AnimIdRunLB] != AnimOff)
g->animState[AnimIdRunLB] = AnimFadeOut;
if(g->animState[AnimIdWalkUB] != AnimOff)
g->animState[AnimIdWalkUB] = AnimFadeOut;
if(g->animState[AnimIdWalkLB] != AnimOff)
g->animState[AnimIdWalkLB] = AnimFadeOut;
g->prevCharState = g->charState;
g->charState = CharIdle;
}
break;
case 'r':
{
OSG::SkinnedGeometry::RenderModeE newRM =
static_cast<OSG::SkinnedGeometry::RenderModeE>((g->renderMode + 1)
% 4);
enableRenderMode(newRM);
}
break;
}
glutPostRedisplay();
}
void idleCB(void)
{
glutPostRedisplay();
}
int setupGLUT (int *argc, char *argv[])
{
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int winId = glutCreateWindow("OpenSG");
glutReshapeFunc(reshapeCB);
glutDisplayFunc(displayCB);
glutIdleFunc(idleCB);
glutMouseFunc(mouseCB);
glutMotionFunc(motionCB);
glutKeyboardFunc(keyboardCB);
return winId;
}
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and
threat landscape has changed and how IT managers can respond. Discussions
will include endpoint security, mobile security and the latest in malware
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Opensg-users mailing list
Opensg-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/opensg-users
