/*! Print supported suffixes to osgLog. */
void TextFileType::print(void)
{
std::vector<std::string>::iterator sI;
osgLog() << getName();
if (_suffixList.empty())
{
osgLog() << "NONE";
}
else
{
for (sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
{
osgLog().stream(OSG::LOG_DEBUG) << sI->c_str() << " ";
}
}
osgLog() << std::endl;
}
//! used to initialize member variables - called by every constructor
void DVRVolume::commonConstructor( void )
{
drawStyleListValid = false;
shadingInitialized = false;
if(osgLog().getLogLevel() == LOG_DEBUG)
{
FDEBUG(("DVRVolume::commonConstructor: \n"));
dump();
}
}
// 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();
gwin->setId(winid);
gwin->init();
// set log level to lowest unless specified otherwise by env variable
osgLog().setLogLevel((LogLevel) 0);
// create the scene or load it from a .osg-file
if (argc == 1)
scene = makeVolume("00_data64x64x64.dat");
else
{
scene = SceneFileHandler::the().read(argv[1]);
if (scene == NullFC)
{
SLOG << "Could not read file " << argv[1] << std::endl;
exit(-1);
}
}
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow (gwin );
mgr->setRoot (scene);
mgr->setHighlight(scene);
// show the whole scene
mgr->showAll();
Pnt3f from = mgr->getNavigator()->getFrom();
from[2] = 3 * from[2];
mgr->getNavigator()->setFrom(from);
// GLUT main loop
glutMainLoop();
return 0;
}
void Log::setHeaderElem(UInt32 elemMask, bool force)
{
Char8 *env;
if((force == false ) &&
(this == osgLogP ) &&
(env = getenv(OSG_NAMESPACE_PREFIX"_LOG_HEADER")) )
{
osgLog() << "Log::setHeaderElem: overriden by envvar OSG_LOG_HEADER '"
<< env << "'." << endLog;
elemMask = atoi(env);
}
_headerElem = elemMask;
}
//! conveniance function for finding a specific attachment in the volume kit
AttachmentPtr DVRVolume::findParameter(const FieldContainerType &type,
UInt16 binding)
{
DVRAppearancePtr app = getAppearance();
if(osgLog().getLogLevel() == LOG_DEBUG)
{
FDEBUG(("DVRVolume::findParameter: \n"));
type.dump();
}
if(app != NullFC)
return app->findAttachment(type, binding);
SWARNING << "DVRVolume::findParameter - NO such parameter " << std::endl;
return NullFC;
}
void Log::setLogFile(const Char8 *fileName, bool force)
{
const Char8 *name;
#ifdef OSG_STREAM_HAS_ISOPEN
if(_fileStream.is_open())
#else
if(_fileStream.rdbuf()->is_open())
#endif
{
_fileStream.close();
}
if((force == false ) &&
(this == osgLogP ) &&
(name = getenv(OSG_NAMESPACE_PREFIX"_LOG_FILE")))
{
osgLog() << "Log::setLogFile: overriden by envvar OSG_LOG_FILE '"
<< name << "'." << std::endl;
}
else
{
name = fileName;
}
if(name && *name)
{
_fileStream.open(name, std::ios::out);
#ifdef OSG_STREAM_HAS_ISOPEN
if(_fileStream.is_open())
#else
if(_fileStream.rdbuf()->is_open())
#endif
{
_logType = LOG_FILE;
connect();
}
}
}
bool osgDoInit(OSG::Int32,
OSG::Char8 **,
OSG::UInt16 major,
OSG::UInt16 minor,
OSG::UInt16 release,
bool debug,
bool dll,
bool mt)
{
CompileConfig prog(major,
minor,
release,
debug,
dll,
mt);
CompileConfig lib (OSG_MAJOR_VERSION,
OSG_MINOR_VERSION,
OSG_RELEASE_VERSION,
OSG_INIT_DEBUG,
OSG_INIT_DLL,
OSG_INIT_MT);
if(lib.compare(prog))
{
exit(1);
}
#ifdef WIN32
// Very crude way to safeguard on low level cast, have to find a better
// way later.
OSG_ASSERT(sizeof(UInt32) == sizeof(long));
#endif
bool returnValue = true;
if(GlobalSystemState != Startup)
{
FFATAL(("osgInit: System was already initialized; repeated calls are "
"NOT allowed.\n"));
returnValue = false;
}
if(returnValue == false)
return returnValue;
returnValue = SharedObjectHandler::the()->initialize();
if(osgPreloadSharedObject != NULL)
{
for(UInt32 i = 0; i < osgPreloadSharedObject->size(); ++i)
{
SharedObjectHandler::the()->getOSGSharedObject(
(*osgPreloadSharedObject)[i].c_str());
}
}
#ifdef WIN32
std::string pathSep(";");
#else
std::string pathSep(":");
#endif
char *szEnvLibs = getenv("OSG_LOAD_LIBS");
if(szEnvLibs != NULL)
{
std::string tmpString(szEnvLibs);
string_token_iterator libIt(tmpString, pathSep.c_str());
string_token_iterator libEnd;
while(libIt != libEnd)
{
SharedObjectHandler::the()->getOSGSharedObject(
(*libIt).c_str());
++libIt;
}
}
const char *szEnvPlugins = getenv("OSG_PLUGIN_PATH");
const char *szEnvPluginPattern = getenv("OSG_PLUGIN_PATTERN");
//SharedObjectHandler::the()->dump();
if(szEnvPlugins != NULL)
{
if(szEnvPluginPattern == NULL)
{
szEnvPluginPattern = PluginPattern;
}
fprintf(stderr, "Get Plugins %s from %s\n",
szEnvPluginPattern,
szEnvPlugins);
std::vector<Char8 *> *pPlugins =
Directory::getEntries(szEnvPlugins, szEnvPluginPattern);
if(pPlugins != NULL)
{
std::string szPluginName;
for(UInt32 i = 0; i < pPlugins->size(); ++i)
{
if((*pPlugins)[i][0] == '.')
{
if((*pPlugins)[i][1] == '\0')
{
continue;
}
else if((*pPlugins)[i][1] == '.' &&
(*pPlugins)[i][2] == '\0')
{
continue;
}
}
szPluginName.assign(szEnvPlugins);
szPluginName += '/';
szPluginName += (*pPlugins)[i];
fprintf(stderr, "plugin : %s\n", szPluginName.c_str());
SharedObjectHandler::the()->getSharedObject(
szPluginName.c_str());
}
}
delete pPlugins;
}
if(osgLibraryVersions != NULL)
{
FNOTICE(("osgInit: Main Version : %s\n", OSG_VERSION_STRING));
for(LibVersionMap::const_iterator LibMapItor(osgLibraryVersions->begin());
LibMapItor != osgLibraryVersions->end();
++LibMapItor)
{
FNOTICE(("osgInit: %-30s: %-10s Rev: %s\n",
LibMapItor->first.c_str(),
LibMapItor->second.first.c_str(),
LibMapItor->second.second.c_str()));
}
}
//SharedObjectHandler::the()->dump();
if(returnValue == false)
return returnValue;
// without it floats could be written as "1,456" ...
setlocale(LC_NUMERIC, "English");
if(osgPreMPInitFunctions != NULL)
{
for(UInt32 i = 0; i < osgPreMPInitFunctions->size(); i++)
{
returnValue &= (*osgPreMPInitFunctions)[i]();
if(returnValue == false)
break;
}
osgPreMPInitFunctions->clear();
}
if(returnValue == false)
return returnValue;
returnValue &= ThreadManager::initialize();
if(returnValue == false)
return returnValue;
if(osgPreFactoryInitFunctions != NULL)
{
for(UInt32 i = 0; i < osgPreFactoryInitFunctions->size(); i++)
{
returnValue &= (*osgPreFactoryInitFunctions)[i]();
if(returnValue == false)
break;
}
osgPreFactoryInitFunctions->clear();
}
if(returnValue == false)
return returnValue;
returnValue &= FactoryController::the()->initialize();
if(returnValue == false)
return returnValue;
if(osgPostFactoryInitFunctions != NULL)
{
for(UInt32 i = 0; i < osgPostFactoryInitFunctions->size(); i++)
{
returnValue &= (*osgPostFactoryInitFunctions)[i]();
if(returnValue == false)
break;
}
osgPostFactoryInitFunctions->clear();
}
GlobalSystemState = Running;
osgLog().setLogLevel(OSG_DEFAULT_LOG_LEVEL);
return returnValue;
}
int main (int argc, char **argv)
{
// GLUT init
osgInit(argc, argv);
osgLog().setLogLevel ( OSG::LOG_DEBUG );
FieldContainerPtr pProto = Geometry::getClassType().getPrototype();
GeometryPtr pGeoProto = GeometryPtr::dcast(pProto);
if(pGeoProto != NullFC)
{
pGeoProto->setDlistCache(true);
}
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
UInt32 id = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutReshapeFunc(resize);
glutDisplayFunc(display);
// glutMouseFunc(mouse);
// glutMotionFunc(motion);
glutIdleFunc(display);
// create a material (need that to test textures)
ChunkMaterialPtr mat;
beginEditCP(mat);
mat = ChunkMaterial::create();
MaterialChunkPtr mc = MaterialChunk::create();
beginEditCP(mc);
mc->setDiffuse( Color4f( 1,.8,.8,1 ) );
mc->setAmbient( Color4f( 0.1,0.1,0.1,1 ) );
mc->setSpecular( Color4f( 1,1,1,1 ) );
mc->setShininess( 20 );
mc->setBackMaterial(true);
mc->setBackColorMaterial(GL_DIFFUSE);
mc->setBackDiffuse( Color4f( 1,0,0,1 ) );
mc->setBackAmbient( Color4f( 0.1,0.1,0.1,1 ) );
mc->setBackSpecular( Color4f( 0,1,0,1 ) );
mc->setBackShininess( 10 );
mc->setLit(true);
endEditCP(mc);
mat->addChunk(mc);
// Texture chunk
UChar8 imgdata[] =
{ 255,0,0,128, 0,255,0,128, 0,0,255,255, 255,255,255,255 };
ImagePtr pImage = Image::create();
pImage->set( Image::OSG_RGBA_PF, 2, 2, 1, 1, 1, 0, imgdata );
if ( argc > 1 )
pImage->read( argv[1] );
TextureChunkPtr xchunk;
xchunk = TextureChunk::create();
xchunk->setImage( pImage );
xchunk->setMinFilter( GL_NEAREST );
xchunk->setMagFilter( GL_NEAREST );
xchunk->setWrapS( GL_REPEAT );
xchunk->setWrapT( GL_REPEAT );
xchunk->setEnvMode( GL_MODULATE );
mat->addChunk( xchunk );
endEditCP(mat);
objects[0] = makePolygon(ccwSquare,
sizeof(ccwSquare)/sizeof(double[3]));
objects[1] = makePolygon(ccwSquare,
sizeof(ccwSquare)/sizeof(double[3]));
objects[2] = makePolygon(star,
sizeof(star)/sizeof(double[3]));
objects[3] = makePolygon(star,
sizeof(star)/sizeof(double[3]));
objects[4] = makePolygon(cwSquare,
sizeof(cwSquare)/sizeof(double[3]));
objects[5] = makePolygon(cwSquare,
sizeof(cwSquare)/sizeof(double[3]));
objects[6] = makePolygon(doubleEight,
sizeof(doubleEight)/sizeof(double[3]));
objects[7] = makePolygon(doubleEight,
sizeof(doubleEight)/sizeof(double[3]));
//tesselate every second object
for(int i = 1; i < nobjects; i+=2) {
GeometryPtr::dcast(objects[i]->getCore())->setMaterial( mat );
std::cerr << "Polygon Node: " << std::hex << objects[i] << std::endl;
// try to create convex primitives
OSG::GeometryPtr pGeo = GeometryPtr::dcast(objects[i]->getCore());
std::cerr << "Tesselating polygon : "
<< i
<< std::endl;
createConvexPrimitives(pGeo);
}
// normal material
SimpleMaterialPtr nmat;
nmat = SimpleMaterial::create();
beginEditCP(nmat);
nmat->setEmission( Color3f( 0,1,0 ) );
endEditCP(nmat);
for ( UInt16 i = 0; i < nobjects; i++ )
{
normalobjects[i] = calcVertexNormalsGeo(
GeometryPtr::dcast(objects[i]->getCore()), .5);
GeometryPtr::dcast(normalobjects[i]->getCore())->setMaterial(nmat);
}
//
// The action
win = GLUTWindow::create();
win->setId(id);
win->init();
glEnable( GL_LIGHT0 );
float p[4]={0,0,1,0};
glLightfv(GL_LIGHT0, GL_POSITION, p);
float c[4]={1,1,1,1};
glLightfv(GL_LIGHT0, GL_DIFFUSE, c);
glLightfv(GL_LIGHT0, GL_SPECULAR, c);
glPointSize( 3 );
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glClearColor( .3, .3, .8, 1 );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 60, 1, 0.1, 10 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( 3, 3, 3, 0, 0, 0, 0, 0, 1 );
dact = DrawAction::create();
dact->setWindow(get_pointer(win));
dact->setFrustumCulling( false );
glutMainLoop();
return 0;
}
/*! Set method for attribute logLevel, checks the env vars
OSG_LOG_LEVEL_STARTUP and OSG_LOG_LEVEL and uses their value, unless
\a force is true.
\param[in] logLevel The level for log messages to be emitted.
\param[in] force If true, ignore env variables and set level to \a logLevel.
*/
void Log::setLogLevel(LogLevel logLevel, bool force)
{
static const Char8 *levelnames[] =
{
"log",
"fatal",
"warning",
"notice",
"debug_gv",
"info",
"debug",
NULL
};
static LogLevel levels [] =
{
LOG_LOG,
LOG_FATAL,
LOG_WARNING,
LOG_NOTICE,
LOG_DEBUG_GV,
LOG_INFO,
LOG_DEBUG
};
static Int32 levelCount = sizeof(levels) / sizeof(LogLevel);
Char8 *el;
Int32 ll;
Int32 i;
// unless forced, envvars override the argument
if(!force && (this == osgLogP))
{
// startup allows different log level
if(GlobalSystemState == Startup)
{
if((el = getenv(OSG_NAMESPACE_PREFIX"_LOG_LEVEL_STARTUP")) != 0)
{
// OSG_LOG_LEVEL_STARTUP has highest precedence
osgLog() << "OSGLog::setLogLevel: overridden by envvar "
<< "OSG_LOG_LEVEL_STARTUP '" << el << "'."
<< std::endl;
}
else if((el = getenv(OSG_NAMESPACE_PREFIX"_LOG_LEVEL")) != 0)
{
// fallback to OSG_LOG_LEVEL
osgLog() << "OSGLog::setLogLevel: overridden by envvar "
<< "OSG_LOG_LEVEL '" << el << "'."
<< std::endl;
}
}
else
{
if((el = getenv(OSG_NAMESPACE_PREFIX"_LOG_LEVEL")) != 0)
{
osgLog() << "OSGLog::setLogLevel: overridden by envvar "
<< "OSG_LOG_LEVEL '" << el << "'."
<< std::endl;
}
}
// if an envvar was set, interpret its value
if(el != 0)
{
if(sscanf(el, "%d", &ll) != 1)
{
// interpret the value as name of a level
for(i = 0; levelnames[i]; ++i)
{
if(!osgStringCaseCmp(el, levelnames[i]))
{
logLevel = levels[i];
break;
}
}
if(!levelnames[i])
{
logLevel = LOG_DEBUG;
osgLog() << "OSGLog::setLogLevel: Could not interpret "
<< "envvar, setting to LOG_DEBUG."
<< std::endl;
}
}
else
{
// interpret value as numerical level
if(ll < 0)
{
ll = 0;
}
else if(ll >= levelCount)
{
ll = levelCount - 1;
}
logLevel = levels[ll];
}
}
}
// if force is true this is the unmodified argument, otherwise envvars
// might have changed the value of logLevel
_logLevel = logLevel;
connect();
}
void Log::setLogType(LogType logType, bool force)
{
static const Char8 *typenames[] =
{
"none",
"-",
"stdout",
"stderr",
"file",
"buffer",
NULL
};
static LogType types [] =
{
LOG_NONE,
LOG_STDOUT,
LOG_STDOUT,
LOG_STDERR,
LOG_FILE,
LOG_BUFFER
};
static Int32 typeCount = sizeof(types) / sizeof(LogType);
Char8 *et;
Int32 lt;
Int32 i;
if((force == false ) &&
(this == osgLogP ) &&
(et = getenv(OSG_NAMESPACE_PREFIX"_LOG_TYPE")) )
{
osgLog() << "Log::setLogType: overriden by envvar OSG_LOG_TYPE '"
<< et << "'." << std::endl;
if(sscanf(et, "%d", <) != 1)
{
for(i = 0; typenames[i]; i++)
{
if(!osgStringCaseCmp(et, typenames[i]))
{
_logType = types[i];
break;
}
}
if(! typenames[i])
{
_logType = LOG_STDERR;
osgLog() << "Log::setLogType: couldn't interpret envvar, "
<< "set to LOG_STDERR!"
<< std::endl;
}
}
else
{
if(lt < 0)
{
lt = 0;
}
else
{
if(lt >= typeCount)
lt = typeCount - 1;
}
_logType = types[lt];
}
}
else
{
_logType = logType;
}
connect();
}
