FGFS-4.1/OpenSceneGraph
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed files.... synching witn 0.8.42

Browse Source
This commit is contained in:
Don BURNS
2001-09-19 21:51:06 +00:00
parent bc739f47a9
commit 77494207fb
37 changed files with 0 additions and 6019 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/osg/DCS.cpp
View File

@@ -1,112 +0,0 @@
#include "osg/DCS"
#include "osg/Registry"
#include "osg/Input"
#include "osg/Output"
using namespace osg;
RegisterObjectProxy<DCS> g_DCSProxy;
DCS::DCS()
{
_mat = new Matrix(
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0 );
_mat->ref();
}
DCS::DCS(const Matrix& mat )
{
_mat = new Matrix(mat);
_mat->ref();
}
DCS::~DCS()
{
_mat->unref();
}
void DCS::setMatrix(const Matrix& mat )
{
*_mat = mat;
dirtyBound();
}
void DCS::preTranslate( float tx, float ty, float tz )
{
_mat->preTrans( tx, ty, tz );
dirtyBound();
}
void DCS::preRotate( float deg, float x, float y, float z )
{
_mat->preRot( deg, x, y, z );
dirtyBound();
}
bool DCS::readLocalData(Input& fr)
{
bool iteratorAdvanced = false;
if (Matrix* tmpMatrix = static_cast<Matrix*>(Matrix::instance()->readClone(fr)))
{
if (_mat) _mat->unref();
_mat = tmpMatrix;
_mat->ref();
iteratorAdvanced = true;
}
if (Group::readLocalData(fr)) iteratorAdvanced = true;
return iteratorAdvanced;
}
bool DCS::writeLocalData(Output& fw)
{
if (_mat) _mat->write(fw);
return Group::writeLocalData(fw);
}
bool DCS::computeBound( void )
{
if (!Group::computeBound()) return false;
Vec3 xdash = _bsphere._center;
xdash.x() += _bsphere._radius;
xdash = xdash*(*_mat);
Vec3 ydash = _bsphere._center;
ydash.y() += _bsphere._radius;
ydash = ydash*(*_mat);
Vec3 zdash = _bsphere._center;
zdash.y() += _bsphere._radius;
zdash = zdash*(*_mat);
_bsphere._center = _bsphere._center*(*_mat);
xdash -= _bsphere._center;
float len_xdash = xdash.length();
ydash -= _bsphere._center;
float len_ydash = ydash.length();
zdash -= _bsphere._center;
float len_zdash = zdash.length();
_bsphere._radius = len_xdash;
if (_bsphere._radius<len_ydash) _bsphere._radius = len_ydash;
if (_bsphere._radius<len_zdash) _bsphere._radius = len_zdash;
return true;
}

66
src/osg/DynamicLibrary.cpp
View File

@@ -1,66 +0,0 @@
#ifdef WIN32
#include <Io.h>
#include <Windows.h>
#include <Winbase.h>
#else
#include <unistd.h>
#include <dlfcn.h>
#endif
#ifndef OSG_USE_IO_DOT_H
#include <iostream>
using namespace std;
#endif
#include "osg/DynamicLibrary"
#include "osg/OSG"
#include "osg/Notify"
using namespace osg;
DynamicLibrary::DynamicLibrary(const std::string& name,HANDLE handle)
{
_name = name;
_handle = handle;
}
DynamicLibrary::~DynamicLibrary()
{
if (_handle)
{
#ifdef WIN32
FreeLibrary((HMODULE)_handle);
#else
dlclose(_handle);
#endif
}
}
DynamicLibrary* DynamicLibrary::loadLibrary(const std::string& libraryName)
{
char* fullLibraryName = osg::findDSO( libraryName.c_str() );
if (fullLibraryName==NULL) return NULL;
#ifdef WIN32
HANDLE handle = LoadLibrary( fullLibraryName );
if (handle) return new DynamicLibrary(libraryName,handle);
notify(WARN) << "DynamicLibrary::failed loading "<<fullLibraryName<<endl;
#else
HANDLE handle = dlopen( fullLibraryName, RTLD_LAZY );
if (handle) return new DynamicLibrary(libraryName,handle);
notify(WARN) << "DynamicLibrary::failed loading "<<fullLibraryName<<endl;
notify(WARN) << "DynamicLibrary::error "<<dlerror()<<endl;
#endif
return NULL;
}
DynamicLibrary::PROC_ADDRESS DynamicLibrary::getProcAddress(const std::string& procName)
{
if (_handle==NULL) return NULL;
#ifdef WIN32
return GetProcAddress( (HMODULE)_handle, procName.c_str() );
#else
return dlsym( _handle, procName.c_str() );
#endif
}

45
src/osg/ExtensionSupported.cpp
View File

@@ -1,45 +0,0 @@
#include "osg/GL"
#include "osg/ExtensionSupported"
#include <stdlib.h>
#include <string.h>
// copied form glut_ext.c
// to be rewritten... Robert Osfield, November 2000.
bool osg::ExtensionSupported(const char *extension)
{
static const GLubyte *extensions = NULL;
const GLubyte *start;
GLubyte *where, *terminator;
/* Extension names should not have spaces. */
where = (GLubyte *) strchr(extension, ' ');
if (where || *extension == '\0')
return 0;
if (!extensions) {
extensions = glGetString(GL_EXTENSIONS);
}
/* It takes a bit of care to be fool-proof about parsing the
OpenGL extensions string. Don't be fooled by sub-strings,
etc. */
start = extensions;
for (;;) {
/* If your application crashes in the strstr routine below,
you are probably calling glutExtensionSupported without
having a current window. Calling glGetString without
a current OpenGL context has unpredictable results.
Please fix your program. */
where = (GLubyte *) strstr((const char *) start, extension);
if (!where)
break;
terminator = where + strlen(extension);
if (where == start || *(where - 1) == ' ') {
if (*terminator == ' ' || *terminator == '\0') {
return true;
}
}
start = terminator;
}
return false;
}

422
src/osg/Field.cpp
View File

@@ -1,422 +0,0 @@
#include "osg/Field"
using namespace osg;
Field::Field()
{
_init();
}
Field::Field(const Field& ic)
{
_copy(ic);
}
Field::~Field()
{
_free();
}
Field& Field::operator = (const Field& ic)
{
if (this==&ic) return *this;
_free();
_copy(ic);
return *this;
}
void Field::_free()
{
// free all data
if (_fieldCache) delete [] _fieldCache;
_init();
}
void Field::_init()
{
_fieldCacheCapacity = 256;
_fieldCacheSize = 0;
_fieldCache = NULL;
_fieldType = UNINTIALISED;
_withinQuotes = false;
_noNestedBrackets = 0;
}
void Field::_copy(const Field& ic)
{
// copy string cache.
if (ic._fieldCache)
{
_fieldCacheCapacity = ic._fieldCacheCapacity;
_fieldCacheSize = ic._fieldCacheSize;
_fieldCache = new char [_fieldCacheCapacity];
strncpy(_fieldCache,ic._fieldCache,_fieldCacheCapacity);
}
else
{
_fieldCacheCapacity = 0;
_fieldCacheSize = 0;
_fieldCache = NULL;
}
_fieldType = ic._fieldType;
_withinQuotes = ic._withinQuotes;
_noNestedBrackets = ic._noNestedBrackets;
}
void Field::setWithinQuotes(bool withinQuotes)
{
_withinQuotes=withinQuotes;
_fieldType = UNINTIALISED;
}
bool Field::getWithinQuotes()
{
return _withinQuotes;
}
void Field::setNoNestedBrackets(int no)
{
_noNestedBrackets=no;
}
int Field::getNoNestedBrackets()
{
return _noNestedBrackets;
}
const char* Field::getStr() const
{
if (_fieldCacheSize!=0) return _fieldCache;
else return NULL;
}
char* Field::takeStr()
{
char* field = _fieldCache;
_fieldCache = NULL;
_fieldCacheSize = 0;
_fieldType = UNINTIALISED;
_withinQuotes = false;
return field;
}
void Field::reset()
{
_fieldCacheSize = 0;
if (_fieldCache)
{
_fieldCache[_fieldCacheSize] = 0;
}
_withinQuotes = false;
_noNestedBrackets = 0;
}
void Field::addChar(char c)
{
if (_fieldCache==NULL)
{
if (_fieldCacheCapacity<MIN_CACHE_SIZE) _fieldCacheCapacity=MIN_CACHE_SIZE;
_fieldCache = new char[_fieldCacheCapacity];
_fieldCacheSize = 0;
}
else if (_fieldCacheSize>=_fieldCacheCapacity-1)
{
if (_fieldCacheCapacity<MIN_CACHE_SIZE) _fieldCacheCapacity=MIN_CACHE_SIZE;
while (_fieldCacheSize>=_fieldCacheCapacity-1) _fieldCacheCapacity *= 2;
char* tmp_str = _fieldCache;
_fieldCache = new char[_fieldCacheCapacity];
strncpy(_fieldCache,tmp_str,_fieldCacheSize);
delete [] tmp_str;
}
_fieldCache[_fieldCacheSize++] = c;
_fieldCache[_fieldCacheSize] = 0;
_fieldType = UNINTIALISED;
}
Field::FieldType Field::getFieldType() const
{
if (_fieldType==UNINTIALISED && _fieldCache)
{
_fieldType = calculateFieldType(_fieldCache,_withinQuotes);
}
return _fieldType;
}
bool Field::isValid() const
{
if (_fieldCacheSize>0 && !_withinQuotes) return true;
else return false;
}
bool Field::isOpenBracket() const
{
if (_fieldCacheSize==1) return _fieldCache[0]=='{';
else return false;
}
bool Field::isCloseBracket() const
{
if (_fieldCacheSize==1) return _fieldCache[0]=='}';
else return false;
}
bool Field::isWord() const
{
getFieldType();
return (_fieldType==WORD);
}
bool Field::matchWord(const char* str) const
{
getFieldType();
return _fieldType==WORD && strcmp(_fieldCache,str)==0;
}
bool Field::matchWord(const char* str,int noCharacters) const
{
getFieldType();
return _fieldType==WORD && strncmp(_fieldCache,str,noCharacters)==0;
}
bool Field::isString() const
{
return getNoCharacters()!=0;
}
bool Field::matchString(const char* str) const
{
return strcmp(_fieldCache,str)==0;
}
bool Field::matchString(const char* str,int noCharacters) const
{
return strncmp(_fieldCache,str,noCharacters)==0;
}
bool Field::isQuotedString() const
{
return _withinQuotes;
}
bool Field::isInt() const
{
getFieldType();
return _fieldType==INTEGER;
}
bool Field::matchInt(int i) const
{
getFieldType();
if (_fieldType==INTEGER)
{
return atoi(_fieldCache)==i;
}
else
{
return false;
}
}
bool Field::getInt(int& i) const
{
getFieldType();
if (_fieldType==INTEGER)
{
i = atoi(_fieldCache);
return true;
}
else
{
return false;
}
}
bool Field::isFloat() const
{
getFieldType();
return _fieldType==REAL || _fieldType==INTEGER;
}
bool Field::matchFloat(float f) const
{
getFieldType();
if (_fieldType==REAL || _fieldType==INTEGER)
{
return (float)atof(_fieldCache)==f;
}
else
{
return false;
}
}
bool Field::getFloat(float& f) const
{
getFieldType();
if (_fieldType==REAL || _fieldType==INTEGER)
{
f = (float)atof(_fieldCache);
return true;
}
else
{
return false;
}
}
bool Field::isDouble() const
{
getFieldType();
return _fieldType==REAL || _fieldType==INTEGER;
}
bool Field::matchDouble(double d) const
{
getFieldType();
if (_fieldType==REAL || _fieldType==INTEGER)
{
return atof(_fieldCache)==d;
}
else
{
return false;
}
}
bool Field::getDouble(double& d) const
{
getFieldType();
if (_fieldType==REAL || _fieldType==INTEGER)
{
d = atof(_fieldCache);
return true;
}
else
{
return false;
}
}
Field::FieldType Field::calculateFieldType(const char* str,bool withinQuotes)
{
if (str==NULL) return BLANK;
if (*str==0) return BLANK;
if (withinQuotes) return STRING;
bool hadPlusMinus = false;
bool hadDecimalPlace = false;
bool hadExponent = false;
bool couldBeInt = true;
bool couldBeFloat = true;
int noZeroToNine = 0;
const char* ptr = str;
while (*ptr!=0 && couldBeFloat)
{
if (*ptr=='+' || *ptr=='-')
{
if (hadPlusMinus)
{
couldBeInt = false;
couldBeFloat = false;
} else hadPlusMinus = true;
}
else if (*ptr>='0' && *ptr<='9')
{
noZeroToNine++;
}
else if (*ptr=='.')
{
if (hadDecimalPlace)
{
couldBeInt = false;
couldBeFloat = false;
}
else
{
hadDecimalPlace = true;
couldBeInt = false;
}
}
else if (*ptr=='e' || *ptr=='E')
{
if (hadExponent || noZeroToNine==0)
{
couldBeInt = false;
couldBeFloat = false;
}
else
{
hadExponent = true;
couldBeInt = false;
hadDecimalPlace = false;
hadPlusMinus = false;
noZeroToNine=0;
}
}
else
{
couldBeInt = false;
couldBeFloat = false;
}
++ptr;
}
if (couldBeInt && noZeroToNine>0) return INTEGER;
if (couldBeFloat && noZeroToNine>0) return REAL;
if (str[0]=='{') return OPEN_BRACKET;
if (str[0]=='}') return CLOSE_BRACKET;
return WORD;
}

269
src/osg/FieldReader.cpp
View File

@@ -1,269 +0,0 @@
#include "osg/FieldReader"
#include "osg/Field"
using namespace osg;
FieldReader::FieldReader()
{
_init();
}
FieldReader::FieldReader(const FieldReader& ic)
{
_copy(ic);
}
FieldReader::~FieldReader()
{
_free();
}
FieldReader& FieldReader::operator = (const FieldReader& ic)
{
if (this==&ic) return *this;
_free();
_copy(ic);
return *this;
}
void FieldReader::_free()
{
// free all data
_init();
}
void FieldReader::_init()
{
_fin = NULL;
_eof = true;
_noNestedBrackets = 0;
int i;
for(i=0;i<256;++i) _delimatorEatLookUp[i]=false;
_delimatorEatLookUp[' '] = true;
_delimatorEatLookUp['\t'] = true;
_delimatorEatLookUp['\n'] = true;
_delimatorEatLookUp['\r'] = true;
for(i=0;i<256;++i) _delimatorKeepLookUp[i]=false;
_delimatorKeepLookUp['{'] = true;
_delimatorKeepLookUp['}'] = true;
_delimatorKeepLookUp['"'] = true;
_delimatorKeepLookUp['\''] = true;
}
void FieldReader::_copy(const FieldReader& ic)
{
_fin = ic._fin;
_eof = ic._eof;
_noNestedBrackets = ic._noNestedBrackets;
int i;
for(i=0;i<256;++i) _delimatorEatLookUp[i]=ic._delimatorEatLookUp[i];
for(i=0;i<256;++i) _delimatorKeepLookUp[i]=ic._delimatorKeepLookUp[i];
}
void FieldReader::attach(istream* input)
{
_fin = input;
if (_fin)
{
_eof = _fin->eof()!=0;
}
else
{
_eof = true;
}
}
void FieldReader::detach()
{
_fin = NULL;
_eof = true;
}
bool FieldReader::eof() const
{
return _eof;
}
bool FieldReader::findStartOfNextField()
{
int ch = 0;
while (true)
{
ch = _fin->peek();
if (ch==EOF)
{
_eof = true;
return false;
}
else if (_delimatorEatLookUp[ch])
{
_fin->ignore(1);
}
else
{
return true;
}
}
}
bool FieldReader::readField(Field& fieldPtr)
{
return _readField(&fieldPtr);
}
void FieldReader::ignoreField()
{
_readField(NULL);
}
bool FieldReader::_readField(Field* fieldPtr)
{
if (fieldPtr) fieldPtr->reset();
if (!eof() && findStartOfNextField())
{
int ch = _fin->peek();
if (ch==EOF)
{
_eof = true;
if (fieldPtr) fieldPtr->setNoNestedBrackets(getNoNestedBrackets());
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
else if (ch=='"')
{
if (fieldPtr)
{
fieldPtr->setWithinQuotes(true);
fieldPtr->setNoNestedBrackets(getNoNestedBrackets());
}
_fin->ignore(1);
char c;
while (true)
{
ch = _fin->peek();
if (ch==EOF)
{
_eof = true;
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
c = ch;
if (ch=='"')
{
_fin->ignore(1);
//return fieldPtr && fieldPtr->getNoCharacters()!=0;
return fieldPtr!=NULL;
}
else
{
_fin->get(c);
if (fieldPtr) fieldPtr->addChar(c);
}
}
}
else if (ch=='\'')
{
if (fieldPtr)
{
fieldPtr->setWithinQuotes(true);
fieldPtr->setNoNestedBrackets(getNoNestedBrackets());
}
_fin->ignore(1);
char c;
while (true)
{
ch = _fin->peek();
if (ch==EOF)
{
_eof = true;
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
c = ch;
if (ch=='\'')
{
_fin->ignore(1);
//return fieldPtr && fieldPtr->getNoCharacters()!=0;
return fieldPtr!=NULL;
}
else
{
_fin->get(c);
if (fieldPtr) fieldPtr->addChar(c);
}
}
}
else if (_delimatorKeepLookUp[ch])
{
char c;
_fin->get(c);
if (fieldPtr) fieldPtr->addChar(c);
if (c=='{') ++_noNestedBrackets;
else if (c=='}') --_noNestedBrackets;
if (fieldPtr) fieldPtr->setNoNestedBrackets(getNoNestedBrackets());
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
else
{
if (fieldPtr) fieldPtr->setNoNestedBrackets(getNoNestedBrackets());
char c;
while (true)
{
ch = _fin->peek();
if (ch==EOF)
{
_eof = true;
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
c = ch;
if (_delimatorEatLookUp[c])
{
_fin->ignore(1);
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
if (_delimatorKeepLookUp[c])
{
return fieldPtr && fieldPtr->getNoCharacters()!=0;
}
else
{
_fin->get(c);
if (fieldPtr) fieldPtr->addChar(c);
}
}
}
}
else
{
return false;
}
}
int FieldReader::getNoNestedBrackets() const
{
return _noNestedBrackets;
}

361
src/osg/FieldReaderIterator.cpp
View File

@@ -1,361 +0,0 @@
#include "osg/FieldReaderIterator"
using namespace osg;
FieldReaderIterator::FieldReaderIterator()
{
_init();
}
FieldReaderIterator::FieldReaderIterator(const FieldReaderIterator& ic)
{
_copy(ic);
}
FieldReaderIterator::~FieldReaderIterator()
{
_free();
}
FieldReaderIterator& FieldReaderIterator::operator = (const FieldReaderIterator& ic)
{
if (this==&ic) return *this;
_free();
_copy(ic);
return *this;
}
void FieldReaderIterator::_free()
{
// free all data
if (_previousField)
{
delete _previousField;
}
if (_fieldQueue)
{
for(int i=0;i<_fieldQueueCapacity;++i)
{
if (_fieldQueue[i]) delete _fieldQueue[i];
_fieldQueue[i] = NULL;
}
delete [] _fieldQueue;
}
_init();
}
void FieldReaderIterator::_init()
{
_previousField = NULL;
_fieldQueue = NULL;
_fieldQueueSize = 0;
_fieldQueueCapacity = 0;
}
void FieldReaderIterator::_copy(const FieldReaderIterator& ic)
{
_reader = ic._reader;
if (ic._previousField)
{
_previousField = new Field(*ic._previousField);
}
if (ic._fieldQueue && ic._fieldQueueCapacity>0)
{
_fieldQueue = new Field* [ic._fieldQueueCapacity];
for(int i=0;i<ic._fieldQueueCapacity;++i)
{
if (ic._fieldQueue[i])
{
_fieldQueue[i] = new Field(*ic._fieldQueue[i]);
}
else
{
_fieldQueue[i] = NULL;
}
}
_fieldQueueSize = ic._fieldQueueSize;
_fieldQueueCapacity = ic._fieldQueueCapacity;
}
else
{
_fieldQueue = NULL;
_fieldQueueSize = 0;
_fieldQueueCapacity = 0;
}
}
void FieldReaderIterator::attach(istream* input)
{
_reader.attach(input);
}
void FieldReaderIterator::detach()
{
_reader.detach();
}
bool FieldReaderIterator::eof() const
{
return _fieldQueueSize==0 && _reader.eof();
}
void FieldReaderIterator::insert(int pos,Field* field)
{
if (field==NULL) return;
if (pos<0) pos=0;
if (pos>_fieldQueueSize) pos=_fieldQueueSize;
int i;
if (_fieldQueueSize>=_fieldQueueCapacity) // need to reallocate the stack
{
int newCapacity = _fieldQueueCapacity*2;
if (newCapacity<MINIMUM_FIELD_READER_QUEUE_SIZE) newCapacity = MINIMUM_FIELD_READER_QUEUE_SIZE;
while(_fieldQueueSize>=newCapacity) newCapacity*=2;
Field** newFieldStack = new Field* [newCapacity];
for(i=0;i<_fieldQueueCapacity;++i)
{
newFieldStack[i] = _fieldQueue[i];
}
for(;i<newCapacity;++i)
{
newFieldStack[i] = NULL;
}
_fieldQueue = newFieldStack;
_fieldQueueCapacity = newCapacity;
}
for(i=_fieldQueueSize-1;i>=pos;++i)
{
_fieldQueue[i+1]=_fieldQueue[i];
}
_fieldQueue[pos] = field;
++_fieldQueueSize;
}
void FieldReaderIterator::insert(int pos,const char* str)
{
if (str)
{
Field* field = new Field;
while(*str!=0)
{
field->addChar(*str);
++str;
}
insert(pos,field);
}
}
Field& FieldReaderIterator::operator [] (int pos)
{
return field(pos);
}
Field& FieldReaderIterator::field (int pos)
{
if (pos<0)
{
_blank.setNoNestedBrackets(_reader.getNoNestedBrackets());
return _blank;
} // can directly access field
else if (pos<_fieldQueueSize)
{
return *_fieldQueue[pos];
} // need to read the new fields.
else
{
if (pos>=_fieldQueueCapacity) // need to reallocate the stack
{
int newCapacity = _fieldQueueCapacity*2;
if (newCapacity<MINIMUM_FIELD_READER_QUEUE_SIZE) newCapacity = MINIMUM_FIELD_READER_QUEUE_SIZE;
while(_fieldQueueSize>=newCapacity) newCapacity*=2;
Field** newFieldStack = new Field* [newCapacity];
int i;
for(i=0;i<_fieldQueueCapacity;++i)
{
newFieldStack[i] = _fieldQueue[i];
}
for(;i<newCapacity;++i)
{
newFieldStack[i] = NULL;
}
_fieldQueue = newFieldStack;
_fieldQueueCapacity = newCapacity;
}
while(!_reader.eof() && pos>=_fieldQueueSize)
{
if (_fieldQueue[_fieldQueueSize]==NULL) _fieldQueue[_fieldQueueSize] = new Field;
if (_reader.readField(*_fieldQueue[_fieldQueueSize]))
{
++_fieldQueueSize;
}
}
if (pos<_fieldQueueSize)
{
return *_fieldQueue[pos];
}
else
{
_blank.setNoNestedBrackets(_reader.getNoNestedBrackets());
return _blank;
}
}
}
FieldReaderIterator& FieldReaderIterator::operator ++ ()
{
return (*this)+=1;
}
FieldReaderIterator& FieldReaderIterator::operator += (int no)
{
if (no>_fieldQueueSize)
{
while (!_reader.eof() && no>_fieldQueueSize)
{
_reader.ignoreField();
--no;
}
_fieldQueueSize=0;
}
else if (no>0)
{
Field** tmpFields = new Field* [no];
int i;
for(i=0;i<no;++i)
{
tmpFields[i] = _fieldQueue[i];
}
for(i=no;i<_fieldQueueSize;++i)
{
_fieldQueue[i-no] = _fieldQueue[i];
}
_fieldQueueSize -= no;
for(i=0;i<no;++i)
{
_fieldQueue[_fieldQueueSize+i] = tmpFields[i];
}
delete [] tmpFields;
}
return *this;
}
// increments the itetor of the next simple field or
// whole block if the current field[0] is an open bracket
void FieldReaderIterator::advanceOverCurrentFieldOrBlock()
{
if (field(0).isOpenBracket()) advanceToEndOfCurrentBlock();
else ++(*this);
}
void FieldReaderIterator::advanceToEndOfCurrentBlock()
{
int entry = field(0).getNoNestedBrackets();
while(!eof() && field(0).getNoNestedBrackets()>=entry)
{
++(*this);
}
}
void FieldReaderIterator::advanceToEndOfBlock(int noNestedBrackets)
{
while(!eof() && field(0).getNoNestedBrackets()>=noNestedBrackets)
{
++(*this);
}
}
bool FieldReaderIterator::matchSequence(const char* str)
{
if (str==NULL) return false;
if (*str==0) return false;
int fieldCount = 0;
const char* end = str;
while((*end)!=0 && (*end)==' ') ++end;
const char* start = end;
while((*start)!=0)
{
if (*end!=' ' && *end!=0)
{
++end;
}
else
{
if (start!=end)
{
if (end-start>1 && *start=='%')
{
const char type = *(start+1);
switch(type)
{
case('i') : // expecting an integer
{
if (!field(fieldCount).isInt()) return false;
break;
}
case('f') : // expecting an floating point number
{
if (!field(fieldCount).isFloat()) return false;
break;
}
case('s') : // expecting an quoted string
{
if (!field(fieldCount).isQuotedString()) return false;
break;
}
default : // expecting an word
{
if (!field(fieldCount).isWord()) return false;
break;
}
}
}
else
{
if (*start=='{')
{
if (!field(fieldCount).isOpenBracket()) return false;
}
else if (*start=='}')
{
if (!field(fieldCount).isCloseBracket()) return false;
}
else
{
if (!field(fieldCount).matchWord(start,end-start)) return false;
}
}
fieldCount++;
}
while((*end)==' ') ++end;
start = end;
}
}
return true;
}

50
src/osg/FileNameUtils.cpp
View File

@@ -1,50 +0,0 @@
#include "osg/FileNameUtils"
std::string osg::getFilePath(const std::string& fileName)
{
std::string::size_type slash = fileName.find_last_of('/');
if (slash==std::string::npos) return std::string("");
return std::string(fileName.begin(),fileName.begin()+slash+1);
}
std::string osg::getSimpleFileName(const std::string& fileName)
{
std::string::size_type slash = fileName.find_last_of('/');
if (slash==std::string::npos) return fileName;
return std::string(fileName.begin()+slash+1,fileName.end());
}
std::string osg::getFileExtension(const std::string& fileName)
{
std::string::size_type dot = fileName.find_last_of('.');
if (dot==std::string::npos) return std::string("");
return std::string(fileName.begin()+dot+1,fileName.end());
}
std::string osg::getLowerCaseFileExtension(const std::string& filename)
{
std::string ext = osg::getFileExtension(filename);
for(std::string::iterator itr=ext.begin();
itr!=ext.end();
++itr)
{
*itr = (char)tolower(*itr);
}
return ext;
}
std::string osg::getStrippedName(const std::string& fileName)
{
std::string::size_type slash = fileName.find_last_of('/');
std::string::size_type dot = fileName.find_last_of('.');
if (slash==std::string::npos) {
if (dot==std::string::npos) return fileName;
else return std::string(fileName.begin(),fileName.begin()+dot);
}
else
{
if (dot==std::string::npos) return std::string(fileName.begin()+slash+1,fileName.end());
else return std::string(fileName.begin()+slash+1,fileName.begin()+dot);
}
}

850
src/osg/GeoState.cpp
View File

@@ -1,850 +0,0 @@
#include <stdio.h>
#include "osg/GeoState"
#include "osg/Input"
#include "osg/Output"
#include "osg/Notify"
using namespace osg;
GeoState::GeoState()
{
_transparencing = INHERIT;
_face_culling = INHERIT;
_lighting = INHERIT;
_texturing = INHERIT;
_fogging = INHERIT;
_texgening = INHERIT;
_antialiasing = INHERIT;
_colortable = INHERIT;
_pointSmoothing = INHERIT;
_polygonOffsetting = INHERIT;
_alphaTesting = INHERIT;
_transparency = 0L;
_cullFace = 0L;
_texture = 0L;
_fog = 0L;
_texgen = 0L;
_material = 0L;
_texenv = 0L;
_texmat = 0L;
_point = 0L;
_polygonOffset = 0L;
_alphaFunc = 0L;
}
GeoState::~GeoState()
{
// note, all attached state attributes will be automatically
// unreferenced by ref_ptr<> and therefore there is now need to
// delete the memory manually.
}
GeoState* GeoState::instance()
{
static ref_ptr<GeoState> s_geostate(new GeoState);
return s_geostate.get();
}
void GeoState::setGlobalDefaults()
{
_transparencing = OFF;
_face_culling = ON;
_lighting = OFF;
_texturing = OFF;
_fogging = OFF;
_texgening = OFF;
_antialiasing = OFF;
_colortable = OFF;
_pointSmoothing = OFF;
_polygonOffsetting = OFF;
_alphaTesting = OFF;
_transparency = new Transparency;
_cullFace = new CullFace;
_texture = 0L;
_fog = 0L;
_texgen = 0L;
_material = new Material;
_material->setColorMode(Material::AMBIENT_AND_DIFFUSE);
_texenv = 0L;
_texmat = 0L;
_point = 0L;
_polygonOffset = 0L;
_alphaFunc = new AlphaFunc;
}
void GeoState::setAllToInherit()
{
_transparencing = INHERIT;
_face_culling = INHERIT;
_lighting = INHERIT;
_texturing = INHERIT;
_fogging = INHERIT;
_texgening = INHERIT;
_antialiasing = INHERIT;
_colortable = INHERIT;
_pointSmoothing = INHERIT;
_polygonOffsetting = INHERIT;
_alphaTesting = INHERIT;
_transparency = 0L;
_cullFace = 0L;
_texture = 0L;
_fog = 0L;
_texgen = 0L;
_material = 0L;
_texenv = 0L;
_texmat = 0L;
_point = 0L;
_polygonOffset = 0L;
_alphaFunc = 0L;
}
bool GeoState::readLocalData(Input& fr)
{
bool iteratorAdvanced = false;
AttributeMode mode;
if (fr[0].matchWord("transparency") && matchModeStr(fr[1].getStr(),mode))
{
_transparencing = mode;
fr+=2;
iteratorAdvanced = true;
}
if (Transparency* transTmp = static_cast<Transparency*>(Transparency::instance()->readClone(fr)))
{
_transparency = transTmp;
iteratorAdvanced = true;
}
if (fr[0].matchWord("antialiasing") && matchModeStr(fr[1].getStr(),mode))
{
_antialiasing = mode;
fr+=2;
iteratorAdvanced = true;
}
if (fr[0].matchWord("face_culling") && matchModeStr(fr[1].getStr(),mode))
{
_face_culling = mode;
fr+=2;
iteratorAdvanced = true;
}
if (CullFace* cullTmp = static_cast<CullFace*>(CullFace::instance()->readClone(fr)))
{
_cullFace = cullTmp;
iteratorAdvanced = true;
}
if (fr[0].matchWord("lighting") && matchModeStr(fr[1].getStr(),mode))
{
_lighting = mode;
fr+=2;
iteratorAdvanced = true;
}
if (fr[0].matchWord("texturing") && matchModeStr(fr[1].getStr(),mode))
{
_texturing = mode;
fr+=2;
iteratorAdvanced = true;
}
if (Texture* textTmp = static_cast<Texture*>(Texture::instance()->readClone(fr)))
{
_texture = textTmp;
iteratorAdvanced = true;
}
if (fr[0].matchWord("fogging") && matchModeStr(fr[1].getStr(),mode))
{
_fogging = mode;
fr+=2;
iteratorAdvanced = true;
}
if (Fog* fogTmp = static_cast<Fog*>(Fog::instance()->readClone(fr)))
{
_fog = fogTmp;
iteratorAdvanced = true;
}
if (fr[0].matchWord("colortable") && matchModeStr(fr[1].getStr(),mode))
{
_colortable = mode;
fr+=2;
iteratorAdvanced = true;
}
if (fr[0].matchWord("texgening") && matchModeStr(fr[1].getStr(),mode))
{
_texgening = mode;
fr+=2;
iteratorAdvanced = true;
}
if (TexGen* tmpTexgen = static_cast<TexGen*>(TexGen::instance()->readClone(fr)))
{
_texgen = tmpTexgen;
iteratorAdvanced = true;
}
if (fr[0].matchWord("point_smoothing") && matchModeStr(fr[1].getStr(),mode))
{
_pointSmoothing = mode;
fr+=2;
iteratorAdvanced = true;
}
if (Point* tmpPoint = static_cast<Point*>(Point::instance()->readClone(fr)))
{
_point = tmpPoint;
iteratorAdvanced = true;
}
if (fr[0].matchWord("polygon_offset") && matchModeStr(fr[1].getStr(),mode))
{
_polygonOffsetting = mode;
fr+=2;
iteratorAdvanced = true;
}
if (PolygonOffset* tmpPolygonOffset = static_cast<PolygonOffset*>(PolygonOffset::instance()->readClone(fr)))
{
_polygonOffset = tmpPolygonOffset;
iteratorAdvanced = true;
}
if (fr[0].matchWord("alpha_test") && matchModeStr(fr[1].getStr(),mode))
{
_alphaTesting = mode;
fr+=2;
iteratorAdvanced = true;
}
if (AlphaFunc* tmpAlphaFunc = static_cast<AlphaFunc*>(AlphaFunc::instance()->readClone(fr)))
{
_alphaFunc = tmpAlphaFunc;
iteratorAdvanced = true;
}
if (Material* tmpMaterial = static_cast<Material*>(Material::instance()->readClone(fr)))
{
_material = tmpMaterial;
iteratorAdvanced = true;
}
/*
* Decided that texmatting does not make sense. If a Texture matrix
* is present, just apply it. No need for a mode. Don.
*
if (fr[0].matchWord("texmating") && matchModeStr(fr[1].getStr(),mode)) {
_texmating = mode;
fr+=2;
iteratorAdvanced = true;
}
*/
return iteratorAdvanced;
}
bool GeoState::writeLocalData(Output& fw)
{
fw.indent() << "transparency " << getModeStr(_transparencing) << endl;
if (_transparency.valid()) _transparency->write(fw);
fw.indent() << "antialiasing " << getModeStr(_antialiasing) << endl;
fw.indent() << "face_culling " << getModeStr(_face_culling) << endl;
if (_cullFace.valid()) _cullFace->write(fw);
fw.indent() << "lighting " << getModeStr(_lighting) << endl;
fw.indent() << "texturing " << getModeStr(_texturing) << endl;
if (_texture.valid()) _texture->write(fw);
fw.indent() << "fogging " << getModeStr(_fogging) << endl;
if (_fog.valid()) _fog->write(fw);
fw.indent() << "colortable " << getModeStr(_colortable) << endl;
fw.indent() << "texgening " << getModeStr(_texgening) << endl;
if (_texgen.valid()) _texgen->write(fw);
if (_texenv.valid()) _texenv->write(fw);
fw.indent() << "point_smoothing " << getModeStr(_pointSmoothing) << endl;
if (_point.valid()) _point->write(fw);
fw.indent() << "polygon_offset " << getModeStr(_polygonOffsetting) << endl;
if (_polygonOffset.valid()) _polygonOffset->write(fw);
fw.indent() << "alpha_test " << getModeStr(_alphaTesting) << endl;
if (_alphaFunc.valid()) _alphaFunc->write(fw);
if (_material.valid()) _material->write(fw);
/*
fw.indent() << "texmating " << getModeStr(_texmating) << endl;
*/
return true;
}
bool GeoState::matchModeStr(const char* str,AttributeMode& mode)
{
if (strcmp(str,"INHERIT")==0) mode = INHERIT;
else if (strcmp(str,"ON")==0) mode = ON;
else if (strcmp(str,"OFF")==0) mode = OFF;
else if (strcmp(str,"OVERRIDE_ON")==0) mode = OVERRIDE_ON;
else if (strcmp(str,"OVERRIDE_OFF")==0) mode = OVERRIDE_OFF;
else return false;
return true;
}
const char* GeoState::getModeStr(AttributeMode mode)
{
switch(mode)
{
case(INHERIT): return "INHERIT";
case(ON): return "ON";
case(OFF): return "OFF";
case(OVERRIDE_ON): return "OVERRIDE_ON";
case(OVERRIDE_OFF): return "OVERRIDE_OFF";
}
return "";
}
void GeoState::setMode( AttributeType type, AttributeMode mode )
{
switch( type )
{
case ANTIALIAS : _antialiasing = mode; break;
case FACE_CULL: _face_culling = mode; break;
case FOG : _fogging = mode; break;
case LIGHTING: _lighting = mode; break;
case POINT : _pointSmoothing = mode; break;
case POLYGON_OFFSET : _polygonOffsetting = mode; break;
case TEXGEN : _texgening = mode; break;
case TEXTURE : _texturing = mode; break;
case TRANSPARENCY: _transparencing = mode; break;
case ALPHAFUNC: _alphaTesting = mode; break;
default : notify(WARN) << "GeoState::setMode("<<(int)type<<","<<(int)mode<<") not handled."<<endl;
}
}
GeoState::AttributeMode GeoState::getMode( AttributeType type) const
{
switch( type )
{
case ANTIALIAS : return _antialiasing;
case FACE_CULL: return _face_culling;
case FOG : return _fogging;
case LIGHTING: return _lighting;
case POINT : return _pointSmoothing;
case POLYGON_OFFSET : return _polygonOffsetting;
case TEXTURE : return _texturing;
case TEXGEN : return _texgening;
case TRANSPARENCY: return _transparencing;
case ALPHAFUNC: return _alphaTesting;
default : notify(WARN) << "GeoState::getMode("<<(int)type<<") not handled."<<endl;
}
return INHERIT;
}
void GeoState::setAttribute( AttributeType type, Object *attribute )
{
switch( type )
{
case FACE_CULL : _cullFace = dynamic_cast<CullFace*>(attribute); break;
case FOG : _fog = dynamic_cast<Fog*>(attribute); break;
case LIGHTING: break; /*_light = (Light *)attribute;*/
case MATERIAL: _material = dynamic_cast<Material*>(attribute); break;
case POINT : _point = dynamic_cast<Point*>(attribute); break;
case POLYGON_OFFSET: _polygonOffset = dynamic_cast<PolygonOffset*>(attribute); break;
case TEXENV : _texenv = dynamic_cast<TexEnv*>(attribute); break;
case TEXGEN : _texgen = dynamic_cast<TexGen*>(attribute); break;
case TEXMAT : _texmat = dynamic_cast<TexMat*>(attribute); break;
case TEXTURE : _texture = dynamic_cast<Texture*>(attribute); break;
case TRANSPARENCY: _transparency = dynamic_cast<Transparency*>(attribute); break;
case ALPHAFUNC: _alphaFunc = dynamic_cast<AlphaFunc*>(attribute); break;
default : notify(WARN) << "GeoState::setAttribute("<<(int)type<<","<<attribute<<") not handled."<<endl;
}
}
Object* GeoState::getAttribute( AttributeType type) const
{
switch( type )
{
case FOG : return _fog.get();
case LIGHTING: return NULL; /*_light*/
case MATERIAL: return _material.get();
case POINT : return _point.get();
case POLYGON_OFFSET: return _polygonOffset.get();
case TEXENV : return _texenv.get();
case TEXGEN : return _texgen.get();
case TEXMAT : return _texmat.get();
case TEXTURE : return _texture.get();
case TRANSPARENCY: return _transparency.get();
case ALPHAFUNC: return _alphaFunc.get();
default : notify(WARN) << "GeoState::getAttribute("<<(int)type<<") not handled."<<endl;
}
return NULL;
}
void GeoState::apply()
{
switch(_transparencing)
{
case(ON):
case(OVERRIDE_ON):
Transparency::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Transparency::disable();
break;
case(INHERIT):
break;
}
switch(_face_culling)
{
case(ON):
case(OVERRIDE_ON):
CullFace::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
CullFace::disable();
break;
case(INHERIT):
break;
}
switch(_lighting)
{
case(ON):
case(OVERRIDE_ON):
Lighting::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Lighting::disable();
break;
case(INHERIT):
break;
}
switch(_texturing)
{
case(ON):
case(OVERRIDE_ON):
Texture::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Texture::disable();
break;
case(INHERIT):
break;
}
switch(_texgening)
{
case(ON):
case(OVERRIDE_ON):
TexGen::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
TexGen::disable();
break;
case(INHERIT):
break;
}
switch(_fogging)
{
case(ON):
case(OVERRIDE_ON):
Fog::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Fog::disable();
break;
case(INHERIT):
break;
}
switch(_pointSmoothing)
{
case(ON):
case(OVERRIDE_ON):
Point::enableSmooth();
break;
case(OFF):
case(OVERRIDE_OFF):
Point::disableSmooth();
break;
case(INHERIT):
break;
}
switch(_polygonOffsetting)
{
case(ON):
case(OVERRIDE_ON):
PolygonOffset::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
PolygonOffset::disable();
break;
case(INHERIT):
break;
}
switch(_alphaTesting)
{
case(ON):
case(OVERRIDE_ON):
AlphaFunc::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
AlphaFunc::disable();
break;
case(INHERIT):
break;
}
if( _transparency.valid())
_transparency->apply();
if( _cullFace.valid())
_cullFace->apply();
if( _texenv.valid())
_texenv->apply();
if( _texgen.valid())
_texgen->apply();
if( _texture.valid())
_texture->apply();
if( _material.valid())
_material->apply();
if( _fog.valid())
_fog->apply();
if( _texmat.valid())
_texmat->apply();
if( _point.valid())
_point->apply();
if( _polygonOffset.valid())
_polygonOffset->apply();
if( _alphaFunc.valid())
_alphaFunc->apply();
}
void GeoState::apply(GeoState* global,GeoState* prev)
{
if (global==NULL || prev==NULL)
{
apply();
return;
}
switch(GeoState::combineMode(global->_transparencing,prev->_transparencing,_transparencing))
{
case(ON):
case(OVERRIDE_ON):
Transparency::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Transparency::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_face_culling,prev->_face_culling,_face_culling))
{
case(ON):
case(OVERRIDE_ON):
CullFace::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
CullFace::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_lighting,prev->_lighting,_lighting))
{
case(ON):
case(OVERRIDE_ON):
Lighting::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Lighting::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_texturing,prev->_texturing,_texturing))
{
case(ON):
case(OVERRIDE_ON):
Texture::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Texture::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_texgening,prev->_texgening,_texgening))
{
case(ON):
case(OVERRIDE_ON):
TexGen::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
TexGen::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_fogging,prev->_fogging,_fogging))
{
case(ON):
case(OVERRIDE_ON):
Fog::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
Fog::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_pointSmoothing,prev->_pointSmoothing,_pointSmoothing))
{
case(ON):
case(OVERRIDE_ON):
Point::enableSmooth();
break;
case(OFF):
case(OVERRIDE_OFF):
Point::disableSmooth();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_polygonOffsetting,prev->_polygonOffsetting,_polygonOffsetting))
{
case(ON):
case(OVERRIDE_ON):
PolygonOffset::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
PolygonOffset::disable();
break;
case(INHERIT):
break;
}
switch(GeoState::combineMode(global->_alphaTesting,prev->_alphaTesting,_alphaTesting))
{
case(ON):
case(OVERRIDE_ON):
AlphaFunc::enable();
break;
case(OFF):
case(OVERRIDE_OFF):
AlphaFunc::disable();
break;
case(INHERIT):
break;
}
if (prev->_transparency!=_transparency)
{
osg::Transparency* new_transparency;
if (_transparency.valid()) new_transparency = _transparency.get();
else new_transparency = global->_transparency.get();
if (new_transparency) new_transparency->apply();
}
if (prev->_cullFace!=_cullFace)
{
osg::CullFace* new_cullFace;
if (_cullFace.valid()) new_cullFace = _cullFace.get();
else new_cullFace = global->_cullFace.get();
if (new_cullFace) new_cullFace->apply();
}
if (prev->_texenv!=_texenv)
{
osg::TexEnv* new_texenv;
if (_texenv.valid()) new_texenv = _texenv.get();
else new_texenv = global->_texenv.get();
if (new_texenv) new_texenv->apply();
}
if (prev->_texgen!=_texgen)
{
osg::TexGen* new_texgen;
if (_texgen.valid()) new_texgen = _texgen.get();
else new_texgen = global->_texgen.get();
if (new_texgen) new_texgen->apply();
}
if (prev->_texture!=_texture)
{
osg::Texture* new_texture;
if (_texture.valid()) new_texture = _texture.get();
else new_texture = global->_texture.get();
if (new_texture) new_texture->apply();
}
if (prev->_material!=_material)
{
osg::Material* new_material;
if (_material.valid()) new_material = _material.get();
else new_material = global->_material.get();
if (new_material) new_material->apply();
}
if (prev->_fog!=_fog)
{
osg::Fog* new_fog;
if (_fog.valid()) new_fog = _fog.get();
else new_fog = global->_fog.get();
if (new_fog) new_fog->apply();
}
if (prev->_texmat!=_texmat)
{
osg::TexMat* new_texmat;
if (_texmat.valid()) new_texmat = _texmat.get();
else new_texmat = global->_texmat.get();
if (new_texmat) new_texmat->apply();
}
if (prev->_point!=_point)
{
osg::Point* new_point;
if (_point.valid()) new_point = _point.get();
else new_point = global->_point.get();
if (new_point) new_point->apply();
}
if (prev->_polygonOffset!=_polygonOffset)
{
osg::PolygonOffset* new_polygonOffset;
if (_polygonOffset.valid()) new_polygonOffset = _polygonOffset.get();
else new_polygonOffset = global->_polygonOffset.get();
if (new_polygonOffset) new_polygonOffset->apply();
}
if (prev->_alphaFunc!=_alphaFunc)
{
osg::AlphaFunc* new_AlphaFunc;
if (_alphaFunc.valid()) new_AlphaFunc = _alphaFunc.get();
else new_AlphaFunc = global->_alphaFunc.get();
if (new_AlphaFunc) new_AlphaFunc->apply();
}
}
bool GeoState::check()
{
return true;
}
/*
#if 0 // [ NOTES on how apply should work
Each Scene must have a global initial GeoState, current GeoState, and current request state. The current definition of GeoState
should really become an GeoState. The global initial State can have modes set to
SG_ON,
SG_OFF,
and may be or'ed with
SG_OVERRIDE.
All attributes are set to the default. Defaults can be set at start up by querying hardware
and determining best parameters (for example, do we have hardware texture mapping?, if so enable texture and create a texture environment).
The current GeoState and the request GeoState begin as a copy of the initial state. The request state is subsequently changed by each GeoState,
during traversal. It is the current state that will actually issue the GL commands at apply time.
Attributes for the GeoStates may be
SG_ON -explicitely
SG_OFF -explicitely
SG_INHERIT
and may be or'ed with
SG_PERSIST
During traversal, each GeoState's attribute set to INHERIT does nothing. Each attribute set to ON or OFF sets the subsequent request state
to the same before drawing and unsets it after. If the attribute is or'ed with SG_PERSIST, then the mode is not unset after drawing.
Just before drawing the request state is compared to the current state. If an attribute or mode has changed, it is changed in the current
state then applied. Only at this application will the actual GL calls be issued.
For exammple, if two subsequent geosets have lighting on the sequence will be as follows
geostate 1 sets lighting on in request state
at draw:
if current state has lighting off it is changed to on and applied.
geostate1 unsets lighting in request state.
geosate2 resets lighting to on in request state
at draw:
current state has lighting set to on from previous draw therefore nothing changes
geostate2
Addendum 10/22 - Use this method for traversal. Currently we shall do dumb apply().
Upon implementation of a CULL traversal, which creates a DRAW display list, then we
shall implement the "smart" state change described above.
#endif // ]
*/

69
src/osg/Input.cpp
View File

@@ -1,69 +0,0 @@
#include "osg/Input"
#include "osg/Registry"
#include "osg/Object"
#ifdef __sgi
using std::string;
#endif
using namespace osg;
// Will extend to handle #DEF and use
// functionality similar to Inventor,
// and add the ability to handle #include
// from within the OSG file format.
Input::Input()
{
}
Input::~Input()
{
}
Object* Input::getObjectForUniqueID(const std::string& uniqueID)
{
UniqueIDToObjectMapping::iterator fitr = _uniqueIDToObjectMap.find(uniqueID);
if (fitr != _uniqueIDToObjectMap.end()) return (*fitr).second;
else return NULL;
}
void Input::regisiterUniqueIDForObject(const std::string& uniqueID,Object* obj)
{
_uniqueIDToObjectMap[uniqueID] = obj;
}
Object* Input::readObject()
{
return Registry::instance()->readObject(*this);
}
Object* Input::readObject(const string& fileName)
{
return Registry::instance()->readObject(fileName);
}
Image* Input::readImage()
{
return Registry::instance()->readImage(*this);
}
Image* Input::readImage(const string& fileName)
{
return Registry::instance()->readImage(fileName);
}
Node* Input::readNode()
{
return Registry::instance()->readNode(*this);
}
Node* Input::readNode(const string& fileName)
{
return Registry::instance()->readNode(fileName);
}

228
src/osg/OSG.cpp
View File

@@ -1,228 +0,0 @@
#ifndef WIN32
#include <unistd.h>
#include <dlfcn.h>
#else
#include <Io.h>
#include <Windows.h>
#include <Winbase.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include "osg/Notify"
#include "osg/OSG"
#include "osg/Node"
#include "osg/Geode"
#include "osg/Group"
#include "osg/Input"
#include "osg/Output"
#include "osg/Registry"
using namespace osg;
#ifdef WIN32
char *PathDelimitor = ";";
static const char *s_default_file_path = ".;D:/OpenSceneGraph/Data;D:/OpenSceneGraph/Data/Images;D:/OpenSceneGraph/lib";
//static char *s_filePath = (char *)s_default_file_path;
static char *s_filePath = ".;";
#else
char *PathDelimitor = ":";
static const char *s_default_file_path = ".:";
#ifdef __sgi
static const char *s_default_dso_path = "/usr/lib32/osgPlugins/";
#else
static const char *s_default_dso_path = "/usr/lib/osgPlugins/";
#endif
static char *s_filePath = ".:";
//static char *s_filePath = s_default_file_path;
#endif
#include <vector>
#include <algorithm>
using std::vector;
using std::find_if;
void osg::Init( void )
{
char *ptr;
if( (ptr = getenv( "OSGFILEPATH" )) )
{
notify(DEBUG) << "osg::Init("<<ptr<<")"<<endl;
SetFilePath( ptr );
}
else
{
notify(DEBUG) << "osg::Init(NULL)"<<endl;
}
}
void osg::SetFilePath( const char *_path )
{
notify(DEBUG) << "In osg::SetFilePath("<<s_filePath<<")"<<endl;
if( s_filePath != s_default_file_path )
delete s_filePath;
s_filePath = strdup( _path );
notify(DEBUG) << "Out osg::SetFilePath("<<s_filePath<<")"<<endl;
}
static char *FindFileInPath( const char *_file, const char * filePath )
{
char pathbuff[1024];
char *tptr, *tmppath;
char *path = 0L;
notify(DEBUG) << "FindFileInPath() : trying " << _file << " ...\n";
#ifdef WIN32
if( _access( _file, 4 ) == 0 ) return (char *)_file;
#else
if( access( _file, F_OK ) == 0 ) return (char *)_file;
#endif
tptr = strdup( filePath );
tmppath = strtok( tptr, PathDelimitor );
do
{
sprintf( pathbuff, "%s/%s", tmppath, _file );
notify(DEBUG) << "FindFileInPath() : trying " << pathbuff << " ...\n";
#ifdef WIN32
if( _access( pathbuff, 4 ) == 0 ) break;
#else
if( access( pathbuff, F_OK ) == 0 ) break;
#endif
} while( (tmppath = strtok( 0, PathDelimitor )) );
if( tmppath != (char *)0L )
path = strdup( pathbuff );
::free(tptr);
notify( DEBUG ) << "FindFileInPath() : returning " << path << "\n";
return path;
}
char *osg::FindFile( const char *file )
{
return FindFileInPath( file, s_filePath );
}
/*
Order of precedence for
./
OSG_LD_LIBRARY_PATH
s_default_dso_path
LD_LIBRARY*_PATH
*/
char *osg::findDSO( const char *name )
{
char path[1024];
char *ptr;
strcpy( path, "./" );
if((ptr = getenv( "OSG_LD_LIBRARY_PATH" )))
{
strcat( path, PathDelimitor );
strcat( path, ptr );
}
strcat( path, PathDelimitor );
strcat( path, s_default_dso_path );
#ifdef __sgi // [
// bloody mess see rld(1) man page
# if (_MIPS_SIM == _MIPS_SIM_ABI32) // [
if( (ptr = getenv( "LD_LIBRARY_PATH" )))
{
strcat( path, PathDelimitor );
strcat( path, ptr );
}
# elif (_MIPS_SIM == _MIPS_SIM_NABI32) // ][
if( !(ptr = getenv( "LD_LIBRARYN32_PATH" )))
ptr = getenv( "LD_LIBRARY_PATH" );
if( ptr )
{
strcat( path, PathDelimitor );
strcat( path, ptr );
}
# elif (_MIPS_SIM == _MIPS_SIM_ABI64) // ][
if( !(ptr = getenv( "LD_LIBRARYN32_PATH" )))
ptr = getenv( "LD_LIBRARY_PATH" );
if( ptr )
{
strcat( path, PathDelimitor );
strcat( path, ptr );
}
# endif // ]
#else // ][
# ifdef WIN32 // [
if ((ptr = getenv( "PATH" )))
{
notify(DEBUG) << "PATH = "<<ptr<<endl;
strcat( path, PathDelimitor );
strcat( path, ptr );
}
# else // ][
if( (ptr = getenv( "LD_LIBRARY_PATH" )))
{
strcat( path, PathDelimitor );
strcat( path, ptr );
}
#endif // ]
#endif // ]
#ifndef WIN32
// #ifdef __sgi
// strcat( path, PathDelimitor );
// strcat( path, "/usr/lib32/osgPlugins" );
// #else
// strcat( path, PathDelimitor );
// strcat( path, "/usr/lib/osgPlugins" );
// #endif
#endif
strcat( path ,PathDelimitor );
strcat( path, s_filePath );
char* fileFound = NULL;
fileFound = FindFileInPath( name , path );
if (fileFound) return fileFound;
// now try prepending the filename with "osgPlugins/"
char* prependosgPlugins = new char[strlen(name)+12];
strcpy(prependosgPlugins,"osgPlugins/");
strcat(prependosgPlugins,name);
fileFound = FindFileInPath( prependosgPlugins , path );
delete prependosgPlugins;
return fileFound;
}

75
src/osg/Output.cpp
View File

@@ -1,75 +0,0 @@
#include <stdio.h>
#include "osg/Output"
#include "osg/Object"
using namespace osg;
Output::Output()
{
_init();
}
Output::~Output()
{
_free();
}
void Output::_init()
{
_indent = 0;
_indentStep = 2;
_numIndicesPerLine = 10;
}
void Output::_free()
{
// should I be calling ofstream's free as well???
}
Output& Output::indent()
{
for(int i=0;i<_indent;++i) *this<<' ';
return *this;
}
void Output::moveIn()
{
_indent += _indentStep;
}
void Output::moveOut()
{
_indent -= _indentStep;
if (_indent<0) _indent=0;
}
bool Output::getUniqueIDForObject(Object* obj,std::string& uniqueID)
{
UniqueIDToLabelMapping::iterator fitr = _objectToUniqueIDMap.find(obj);
if (fitr != _objectToUniqueIDMap.end())
{
uniqueID = (*fitr).second;
return true;
}
else return false;
}
bool Output::createUniqueIDForObject(Object* obj,std::string& uniqueID)
{
char str[256];
sprintf(str,"%s_%i",obj->className(),_objectToUniqueIDMap.size());
uniqueID = str;
return true;
}
bool Output::registerUniqueIDForObject(Object* obj,std::string& uniqueID)
{
_objectToUniqueIDMap[obj] = uniqueID;
return true;
}

101
src/osg/ReaderWriterOSG.cpp
View File

@@ -1,101 +0,0 @@
#include "osg/Registry"
#include "osg/Object"
#include "osg/Image"
#include "osg/Node"
#include "osg/Group"
#include "osg/Input"
#include "osg/Output"
#ifdef __sgi
using std::string;
#endif
using namespace osg;
class DefaultReaderWriter : public ReaderWriter
{
public:
virtual const char* className() { return "Default OSG Reader/Writer"; }
virtual bool acceptsExtension(const string& extension) { return extension=="osg" || extension=="OSG"; }
virtual Object* readObject(const string& fileName) { return readNode(fileName); }
virtual Node* readNode(const string& fileName)
{
ifstream fin(fileName.c_str());
if (fin)
{
Input fr;
fr.attach(&fin);
Group* group = new Group;
group->setName("import group");
// load all nodes in file, placing them in a group.
while(!fr.eof())
{
Node *node = fr.readNode();
if (node) group->addChild(node);
else fr.advanceOverCurrentFieldOrBlock();
}
if (group->getNumChildren()>1)
{
return group;
}
else if (group->getNumChildren()==1)
{
// only one node loaded so just return that one node,
// and delete the redundent group. Note, the
// child must be referenced before defrencing
// the group so to avoid delete its children.
Node* node = group->getChild(0);
node->ref();
group->unref();
return node;
} // group->getNumChildren()==0
else
{
return 0L;
}
}
else
{
return 0L;
}
}
virtual bool writeObject(Object& obj,const string& fileName)
{
Output fout;
fout.open(fileName.c_str());
if (fout)
{
obj.write(fout);
fout.close();
return true;
}
return false;
}
virtual bool writeNode(Node& node,const string& fileName)
{
Output fout;
fout.open(fileName.c_str());
if (fout)
{
node.write(fout);
fout.close();
return true;
}
return false;
}
};
// now register with Registry to instantiate the above
// reader/writer.
RegisterReaderWriterProxy<DefaultReaderWriter> g_defaultReaderWriterProxy;

380
src/osg/ReaderWriterRGB.cpp
View File

@@ -1,380 +0,0 @@
#include "osg/Image"
#include "osg/Input"
#include "osg/Output"
#include "osg/Notify"
#include "osg/FileNameUtils"
#include "osg/Registry"
#include <osg/Geode>
#include <osg/GeoSet>
#include <osg/GeoState>
#include <osg/Texture>
#include "osg/GL"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef SEEK_SET
# define SEEK_SET 0
#endif
using namespace osg;
typedef struct _rawImageRec
{
unsigned short imagic;
unsigned short type;
unsigned short dim;
unsigned short sizeX, sizeY, sizeZ;
unsigned long min, max;
unsigned long wasteBytes;
char name[80];
unsigned long colorMap;
FILE *file;
unsigned char *tmp, *tmpR, *tmpG, *tmpB, *tmpA;
unsigned long rleEnd;
GLuint *rowStart;
GLint *rowSize;
} rawImageRec;
static void ConvertShort(unsigned short *array, long length)
{
unsigned long b1, b2;
unsigned char *ptr;
ptr = (unsigned char *)array;
while (length--)
{
b1 = *ptr++;
b2 = *ptr++;
*array++ = (unsigned short) ((b1 << 8) | (b2));
}
}
static void ConvertLong(GLuint *array, long length)
{
unsigned long b1, b2, b3, b4;
unsigned char *ptr;
ptr = (unsigned char *)array;
while (length--)
{
b1 = *ptr++;
b2 = *ptr++;
b3 = *ptr++;
b4 = *ptr++;
*array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
}
}
static rawImageRec *RawImageOpen(const char *fileName)
{
union
{
int testWord;
char testByte[4];
} endianTest;
rawImageRec *raw;
GLenum swapFlag;
int x;
endianTest.testWord = 1;
if (endianTest.testByte[0] == 1)
{
swapFlag = GL_TRUE;
}
else
{
swapFlag = GL_FALSE;
}
raw = (rawImageRec *)malloc(sizeof(rawImageRec));
if (raw == NULL)
{
notify(WARN)<< "Out of memory!"<<endl;
return NULL;
}
if ((raw->file = fopen(fileName, "rb")) == NULL)
{
perror(fileName);
return NULL;
}
fread(raw, 1, 12, raw->file);
if (swapFlag)
{
ConvertShort(&raw->imagic, 6);
}
raw->tmp = raw->tmpR = raw->tmpG = raw->tmpB = raw->tmpA = 0L;
raw->tmp = (unsigned char *)malloc(raw->sizeX*256);
if (raw->tmp == NULL )
{
notify(FATAL)<< "Out of memory!"<<endl;
return NULL;
}
if( raw->sizeZ >= 1 )
{
if( (raw->tmpR = (unsigned char *)malloc(raw->sizeX)) == NULL )
{
notify(FATAL)<< "Out of memory!"<<endl;
free( raw->tmp );
return NULL;
}
}
if( raw->sizeZ >= 2 )
{
if( (raw->tmpG = (unsigned char *)malloc(raw->sizeX)) == NULL )
{
notify(FATAL)<< "Out of memory!"<<endl;
free( raw->tmp );
free( raw->tmpR );
return NULL;
}
}
if( raw->sizeZ >= 3 )
{
if( (raw->tmpB = (unsigned char *)malloc(raw->sizeX)) == NULL )
{
notify(FATAL)<< "Out of memory!"<<endl;
free( raw->tmp );
free( raw->tmpR );
free( raw->tmpG );
return NULL;
}
}
if (raw->sizeZ >= 4)
{
if( (raw->tmpA = (unsigned char *)malloc(raw->sizeX)) == NULL )
{
notify(FATAL)<< "Out of memory!"<<endl;
free( raw->tmp );
free( raw->tmpR );
free( raw->tmpG );
free( raw->tmpB );
return NULL;
}
}
if ((raw->type & 0xFF00) == 0x0100)
{
x = raw->sizeY * raw->sizeZ * sizeof(GLuint);
raw->rowStart = (GLuint *)malloc(x);
raw->rowSize = (GLint *)malloc(x);
if (raw->rowStart == NULL || raw->rowSize == NULL)
{
notify(FATAL)<< "Out of memory!"<<endl;
return NULL;
}
raw->rleEnd = 512 + (2 * x);
fseek(raw->file, 512, SEEK_SET);
fread(raw->rowStart, 1, x, raw->file);
fread(raw->rowSize, 1, x, raw->file);
if (swapFlag)
{
ConvertLong(raw->rowStart, (long) (x/sizeof(GLuint)));
ConvertLong((GLuint *)raw->rowSize, (long) (x/sizeof(GLint)));
}
}
return raw;
}
static void RawImageClose(rawImageRec *raw)
{
fclose(raw->file);
free(raw->tmp);
if( raw->tmpR )
free(raw->tmpR);
if( raw->tmpG )
free(raw->tmpG);
if( raw->tmpB )
free(raw->tmpB);
if( raw->tmpA )
free(raw->tmpA);
free(raw);
}
static void RawImageGetRow(rawImageRec *raw, unsigned char *buf, int y, int z)
{
unsigned char *iPtr, *oPtr, pixel;
int count, done = 0;
if ((raw->type & 0xFF00) == 0x0100)
{
fseek(raw->file, (long) raw->rowStart[y+z*raw->sizeY], SEEK_SET);
fread(raw->tmp, 1, (unsigned int)raw->rowSize[y+z*raw->sizeY],
raw->file);
iPtr = raw->tmp;
oPtr = buf;
while (!done)
{
pixel = *iPtr++;
count = (int)(pixel & 0x7F);
if (!count)
{
done = 1;
return;
}
if (pixel & 0x80)
{
while (count--)
{
*oPtr++ = *iPtr++;
}
}
else
{
pixel = *iPtr++;
while (count--)
{
*oPtr++ = pixel;
}
}
}
}
else
{
fseek(raw->file, 512+(y*raw->sizeX)+(z*raw->sizeX*raw->sizeY),
SEEK_SET);
fread(buf, 1, raw->sizeX, raw->file);
}
}
static void RawImageGetData(rawImageRec *raw, unsigned char **data )
{
unsigned char *ptr;
int i, j;
// // round the width to a factor 4
// int width = (int)(floorf((float)raw->sizeX/4.0f)*4.0f);
// if (width!=raw->sizeX) width += 4;
*data = (unsigned char *)malloc(2 * (raw->sizeX+1)*(raw->sizeY+1)*4);
// *data = (unsigned char *)malloc(2 * (width+1)*(raw->sizeY+1)*4);
ptr = *data;
for (i = 0; i < (int)(raw->sizeY); i++)
{
if( raw->sizeZ >= 1 )
RawImageGetRow(raw, raw->tmpR, i, 0);
if( raw->sizeZ >= 2 )
RawImageGetRow(raw, raw->tmpG, i, 1);
if( raw->sizeZ >= 3 )
RawImageGetRow(raw, raw->tmpB, i, 2);
if( raw->sizeZ >= 4 )
RawImageGetRow(raw, raw->tmpA, i, 3);
for (j = 0; j < (int)(raw->sizeX); j++)
{
if( raw->sizeZ >= 1 )
*ptr++ = *(raw->tmpR + j);
if( raw->sizeZ >= 2 )
*ptr++ = *(raw->tmpG + j);
if( raw->sizeZ >= 3 )
*ptr++ = *(raw->tmpB + j);
if( raw->sizeZ >= 4 )
*ptr++ = *(raw->tmpA + j);
}
// // pad the image width with blanks to bring it up to the rounded width.
// for(;j<width;++j) *ptr++ = 0;
}
}
class ReaderWriterRGB : public ReaderWriter
{
public:
virtual const char* className() { return "Default RGB Image Reader/Writer"; }
virtual bool acceptsExtension(const std::string& extension)
{
return extension=="rgb" || extension=="rgba" ||
extension=="int" || extension=="inta" ||
extension=="bw";
}
virtual Node* readNode(const std::string& fileName)
{
Image* image = readImage(fileName);
if (image)
{
Geode* geode = createGeodeForImage(image);
if (geode==NULL) image->unref();
return geode;
}
else
{
return NULL;
}
}
virtual Image* readImage(const std::string& fileName)
{
std::string ext = getLowerCaseFileExtension(fileName);
if (!acceptsExtension(ext)) return NULL;
rawImageRec *raw;
if( (raw = RawImageOpen(fileName.c_str())) == NULL )
{
notify(FATAL)<< "Unable to open \""<<fileName<<"\""<<endl;
return NULL;
}
int s = raw->sizeX;
int t = raw->sizeY;
int r = 1;
#if 0
int internalFormat = raw->sizeZ == 3 ? GL_RGB5 :
raw->sizeZ == 4 ? GL_RGB5_A1 : GL_RGB;
#else
int internalFormat = raw->sizeZ;
#endif
unsigned int pixelFormat =
raw->sizeZ == 1 ? GL_LUMINANCE :
raw->sizeZ == 2 ? GL_LUMINANCE_ALPHA :
raw->sizeZ == 3 ? GL_RGB :
raw->sizeZ == 4 ? GL_RGBA : (GLenum)-1;
unsigned int dataType = GL_UNSIGNED_BYTE;
unsigned char *data;
RawImageGetData(raw, &data);
RawImageClose(raw);
Image* image = new Image();
image->setFileName(fileName.c_str());
image->setImage(s,t,r,
internalFormat,
pixelFormat,
dataType,
data);
notify(INFO) << "image read ok "<<s<<" "<<t<<endl;
return image;
}
virtual bool writeImage(Image& ,const std::string& )
{
return false;
}
};
// now register with Registry to instantiate the above
// reader/writer.
RegisterReaderWriterProxy<ReaderWriterRGB> g_readerWriter_RGB_Proxy;

543
src/osg/Registry.cpp
View File

@@ -1,543 +0,0 @@
#include "osg/Registry"
#include "osg/Notify"
#include "osg/Object"
#include "osg/Image"
#include "osg/Node"
#include "osg/Group"
#include "osg/Input"
#include "osg/Output"
#include "osg/FileNameUtils"
#include <stdio.h>
#include <algorithm>
#include <set>
using namespace osg;
Object* osg::loadObjectFile(const char *name)
{
return Registry::instance()->readObject(name);
}
Image* osg::loadImageFile(const char *name)
{
return Registry::instance()->readImage(name);
}
Node* osg::loadNodeFile(const char *name)
{
return Registry::instance()->readNode(name);
}
bool osg::saveObjectFile(Object& object,const char *name)
{
return Registry::instance()->writeObject(object,name);
}
bool osg::saveImageFile(Image& image,const char *name)
{
return Registry::instance()->writeImage(image,name);
}
bool osg::saveNodeFile(Node& node,const char *name)
{
return Registry::instance()->writeNode(node,name);
}
// definition of the Registry
Registry::Registry()
{
notify(INFO) << "Constructing osg::Registry"<<endl;
_openingLibrary = false;
osg::Init();
}
Registry::~Registry()
{
// Don't write to notify() in here. Destruction order is indeterminate
// (I think) and the notify stream may have been destroyed before this
// is called.
// note, do not need to unregister attached prototype and reader/writers
// as they will be automatically unreferenced by the std::vector
// destructor & ref_ptr combination.
}
Registry* Registry::instance()
{
static Registry s_nodeFactory;
return &s_nodeFactory;
}
void Registry::addPrototype(Object* obj)
{
if (obj==0L) return;
// works under win32, good old C :-)
if (_openingLibrary) notify(INFO) << "Opening Library : ";
notify(INFO) << "osg::Registry::addPrototype("<<obj->className()<<")"<<endl;
int newPos = _nodeProtoList.size();
_protoList.push_back(obj);
if (dynamic_cast<Node*>(obj))
{
_nodeProtoList.push_back(newPos);
}
if (dynamic_cast<Image*>(obj))
{
_imageProtoList.push_back(newPos);
}
}
void Registry::removePrototype(Object* obj)
{
if (obj==0L) return;
notify(INFO) << "osg::Registry::removePrototype()"<<endl;
PrototypeList::iterator pitr = std::find(_protoList.begin(),_protoList.end(),obj);
if (pitr!=_protoList.end())
{
_protoList.erase(pitr);
// note need to handle the node and image lists,
// to be implemented...
}
}
void Registry::addReaderWriter(ReaderWriter* rw)
{
if (rw==0L) return;
if (_openingLibrary) notify(INFO) << "Opening Library : "<<endl;
notify(INFO) << "osg::Registry::addReaderWriter("<<rw->className()<<")"<<endl;
_rwList.push_back(rw);
}
void Registry::removeReaderWriter(ReaderWriter* rw)
{
if (rw==0L) return;
notify(INFO) << "osg::Registry::removeReaderWriter();"<<endl;
ReaderWriterList::iterator rwitr = std::find(_rwList.begin(),_rwList.end(),rw);
if (rwitr!=_rwList.end())
{
_rwList.erase(rwitr);
}
}
std::string Registry::createLibraryNameForFile(const std::string& fileName)
{
std::string ext = getLowerCaseFileExtension(fileName);
return createLibraryNameForExt(ext);
}
std::string Registry::createLibraryNameForExt(const std::string& ext)
{
#ifdef WIN32
# ifdef _DEBUG
return "osgdb_"+ext+"d.dll";
# else
return "osgdb_"+ext+".dll";
# endif
#else
return "osgdb_"+ext+".so";
#endif
}
bool Registry::loadLibrary(const std::string& fileName)
{
DynamicLibrary* dl = getLibrary(fileName);
if (dl) return false;
_openingLibrary=true;
dl = DynamicLibrary::loadLibrary(fileName);
_openingLibrary=false;
if (dl)
{
dl->ref();
_dlList.push_back(dl);
return true;
}
return false;
}
bool Registry::closeLibrary(const std::string& fileName)
{
DynamicLibraryList::iterator ditr = getLibraryItr(fileName);
if (ditr!=_dlList.end())
{
(*ditr)->unref();
_dlList.erase(ditr);
return true;
}
return false;
}
Registry::DynamicLibraryList::iterator Registry::getLibraryItr(const std::string& fileName)
{
DynamicLibraryList::iterator ditr = _dlList.begin();
for(;ditr!=_dlList.end();++ditr)
{
if ((*ditr)->getName()==fileName) return ditr;
}
return _dlList.end();
}
DynamicLibrary* Registry::getLibrary(const std::string& fileName)
{
DynamicLibraryList::iterator ditr = getLibraryItr(fileName);
if (ditr!=_dlList.end()) return ditr->get();
else return NULL;
}
Object* Registry::readObject(Input& fr)
{
if (fr[0].matchWord("Use"))
{
if (fr[1].isString()) {
Object* obj = fr.getObjectForUniqueID(fr[1].getStr());
if (obj) fr+=2;
return obj;
}
else return NULL;
}
for(unsigned int i=0;i<_protoList.size();++i)
{
Object* obj = _protoList[i]->readClone(fr);
if (obj) return obj;
}
return 0L;
}
Object* Registry::readObject(const std::string& fileName)
{
char *file = FindFile( fileName.c_str() );
if (file==NULL) return NULL;
// record the existing reader writer.
std::set<ReaderWriter*> rwOriginal;
// first attempt to load the file from existing ReaderWriter's
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
rwOriginal.insert(itr->get());
Object* obj = (*itr)->readObject(file);
if (obj) return obj;
}
// now look for a plug-in to load the file.
std::string libraryName = createLibraryNameForFile(fileName);
if (Registry::instance()->loadLibrary(libraryName))
{
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
if (rwOriginal.find(itr->get())==rwOriginal.end())
{
Object* obj = (*itr)->readObject(file);
if (obj) return obj;
}
}
}
else
{
notify(NOTICE)<<"Warning: Could not find plugin to read file with extension ."
<<getLowerCaseFileExtension(fileName)<<endl;
}
notify(NOTICE)<<"Warning: Unable to read file "<<fileName<<endl;
return NULL;
}
bool Registry::writeObject(Object& obj,const std::string& fileName)
{
// record the existing reader writer.
std::set<ReaderWriter*> rwOriginal;
// first attempt to load the file from existing ReaderWriter's
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
rwOriginal.insert(itr->get());
if ((*itr)->writeObject(obj,fileName)) return true;
}
// now look for a plug-in to save the file.
std::string libraryName = createLibraryNameForFile(fileName);
if (loadLibrary(libraryName))
{
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
if (rwOriginal.find(itr->get())==rwOriginal.end())
{
if ((*itr)->writeObject(obj,fileName)) return true;
}
}
}
else
{
notify(NOTICE)<<"Warning: Could not find plugin to write file with extension ."
<<getLowerCaseFileExtension(fileName)<<endl;
}
notify(NOTICE)<<"Warning: Unable to write file "<<fileName<<endl;
return false;
}
Image* Registry::readImage(Input& fr)
{
if (fr[0].matchWord("Use"))
{
if (fr[1].isString()) {
Image* image = dynamic_cast<Image*>(fr.getObjectForUniqueID(fr[1].getStr()));
if (image) fr+=2;
return image;
}
else return NULL;
}
for(std::vector<int>::iterator itr=_imageProtoList.begin();
itr!=_imageProtoList.end();
++itr)
{
int i=*itr;
Object* obj = _protoList[i]->readClone(fr);
if (obj)
{
Image* image = static_cast<Image*>(obj);
return image;
}
}
return 0L;
}
Image* Registry::readImage(const std::string& fileName)
{
char *file = FindFile( fileName.c_str() );
if (file==NULL) return NULL;
// record the existing reader writer.
std::set<ReaderWriter*> rwOriginal;
// first attempt to load the file from existing ReaderWriter's
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
rwOriginal.insert(itr->get());
Image* image = (*itr)->readImage(file);
if (image) return image;
}
// now look for a plug-in to load the file.
std::string libraryName = createLibraryNameForFile(fileName);
if (loadLibrary(libraryName))
{
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
if (rwOriginal.find(itr->get())==rwOriginal.end())
{
Image* image = (*itr)->readImage(file);
if (image) return image;
}
}
}
else
{
notify(NOTICE)<<"Warning: Could not find plugin to read file with extension ."
<<getLowerCaseFileExtension(fileName)<<endl;
}
notify(NOTICE)<<"Warning: Unable to read file "<<fileName<<endl;
return NULL;
}
bool Registry::writeImage(Image& image,const std::string& fileName)
{
// record the existing reader writer.
std::set<ReaderWriter*> rwOriginal;
// first attempt to load the file from existing ReaderWriter's
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
rwOriginal.insert(itr->get());
if ((*itr)->writeImage(image,fileName)) return true;
}
// now look for a plug-in to save the file.
std::string libraryName = createLibraryNameForFile(fileName);
if (loadLibrary(libraryName))
{
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
if (rwOriginal.find(itr->get())==rwOriginal.end())
{
if ((*itr)->writeImage(image,fileName)) return true;
}
}
}
else
{
notify(NOTICE)<<"Warning: Could not find plugin to write file with extension ."
<<getLowerCaseFileExtension(fileName)<<endl;
}
notify(NOTICE)<<"Warning: Unable to write file "<<fileName<<endl;
return false;
}
Node* Registry::readNode(Input& fr)
{
if (fr[0].matchWord("Use"))
{
if (fr[1].isString()) {
Node* node = dynamic_cast<Node*>(fr.getObjectForUniqueID(fr[1].getStr()));
if (node) fr+=2;
return node;
}
else return NULL;
}
std::vector<int>::iterator itr=_nodeProtoList.begin();
for(;itr!=_nodeProtoList.end();++itr)
{
int i=*itr;
Object* obj = _protoList[i]->readClone(fr);
if (obj)
{
Node* node = static_cast<Node*>(obj);
return node;
}
}
return 0L;
}
Node* Registry::readNode(const std::string& fileName)
{
char *file = FindFile( fileName.c_str() );
if (file==NULL) return NULL;
// record the existing reader writer.
std::set<ReaderWriter*> rwOriginal;
// first attempt to load the file from existing ReaderWriter's
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
rwOriginal.insert(itr->get());
Node* node = (*itr)->readNode(file);
if (node) return node;
}
// now look for a plug-in to load the file.
std::string libraryName = createLibraryNameForFile(fileName);
notify(INFO) << "Now checking for plug-in "<<libraryName<<endl;
if (loadLibrary(libraryName))
{
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
if (rwOriginal.find(itr->get())==rwOriginal.end())
{
Node* node = (*itr)->readNode(file);
if (node) return node;
}
}
}
else
{
notify(NOTICE)<<"Warning: Could not find plugin to read file with extension ."
<<getLowerCaseFileExtension(fileName)<<endl;
}
notify(NOTICE)<<"Warning: Unable to read file "<<fileName<<endl;
return NULL;
}
bool Registry::writeNode(Node& node,const std::string& fileName)
{
// record the existing reader writer.
std::set<ReaderWriter*> rwOriginal;
// first attempt to load the file from existing ReaderWriter's
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
rwOriginal.insert(itr->get());
if ((*itr)->writeNode(node,fileName)) return true;
}
// now look for a plug-in to save the file.
std::string libraryName = createLibraryNameForFile(fileName);
if (Registry::instance()->loadLibrary(libraryName))
{
for(ReaderWriterList::iterator itr=_rwList.begin();
itr!=_rwList.end();
++itr)
{
if (rwOriginal.find(itr->get())==rwOriginal.end())
{
if ((*itr)->writeNode(node,fileName)) return true;
}
}
}
else
{
notify(NOTICE)<<"Warning: Could not find plugin to write file with extension ."
<<getLowerCaseFileExtension(fileName)<<endl;
}
notify(NOTICE)<<"Warning: Unable to write file "<<fileName<<endl;
return false;
}

69
src/osg/Scene.cpp
View File

@@ -1,69 +0,0 @@
#include "osg/Scene"
#include "osg/Registry"
#include "osg/Input"
#include "osg/Output"
using namespace osg;
RegisterObjectProxy<Scene> g_SceneProxy;
Scene::Scene()
{
_gstate = NULL;
}
Scene::~Scene()
{
if (_gstate) _gstate->unref();
}
void Scene::setGState(osg::GeoState* gstate)
{
if (gstate==_gstate) return;
if (_gstate) _gstate->unref();
_gstate = gstate;
if (_gstate) _gstate->ref();
}
bool Scene::readLocalData(Input& fr)
{
bool iteratorAdvanced = false;
if (fr[0].matchWord("Use"))
{
if (fr[1].isString()) {
GeoState* geostate = dynamic_cast<GeoState*>(fr.getObjectForUniqueID(fr[1].getStr()));
if (geostate) {
fr+=2;
_gstate = geostate;
_gstate->ref();
iteratorAdvanced = true;
}
}
}
if (GeoState* readState = static_cast<GeoState*>(GeoState::instance()->readClone(fr)))
{
_gstate = readState;
_gstate->ref();
iteratorAdvanced = true;
}
if (Group::readLocalData(fr)) iteratorAdvanced = true;
return iteratorAdvanced;
}
bool Scene::writeLocalData(Output& fw)
{
if (_gstate)
{
_gstate->write(fw);
}
Group::writeLocalData(fw);
return true;
}

270
src/osg/Seg.cpp
View File

@@ -1,270 +0,0 @@
#include "osg/Seg"
using namespace osg;
bool Seg::intersectAndClip(Vec3& s,Vec3& e,const BoundingBox& bb)
{
// compate s and e against the xMin to xMax range of bb.
if (s.x()<=e.x())
{
// trivial reject of segment wholely outside.
if (e.x()<bb.xMin()) return false;
if (s.x()>bb.xMax()) return false;
if (s.x()<bb.xMin())
{
// clip s to xMin.
s = s+(e-s)*(bb.xMin()-s.x())/(e.x()-s.x());
}
if (e.x()>bb.xMax())
{
// clip e to xMax.
e = s+(e-s)*(bb.xMax()-s.x())/(e.x()-s.x());
}
}
else
{
if (s.x()<bb.xMin()) return false;
if (e.x()>bb.xMax()) return false;
if (e.x()<bb.xMin())
{
// clip s to xMin.
e = s+(e-s)*(bb.xMin()-s.x())/(e.x()-s.x());
}
if (s.x()>bb.xMax())
{
// clip e to xMax.
s = s+(e-s)*(bb.xMax()-s.x())/(e.x()-s.x());
}
}
// compate s and e against the yMin to yMax range of bb.
if (s.y()<=e.y())
{
// trivial reject of segment wholely outside.
if (e.y()<bb.yMin()) return false;
if (s.y()>bb.yMax()) return false;
if (s.y()<bb.yMin())
{
// clip s to yMin.
s = s+(e-s)*(bb.yMin()-s.y())/(e.y()-s.y());
}
if (e.y()>bb.yMax())
{
// clip e to yMax.
e = s+(e-s)*(bb.yMax()-s.y())/(e.y()-s.y());
}
}
else
{
if (s.y()<bb.yMin()) return false;
if (e.y()>bb.yMax()) return false;
if (e.y()<bb.yMin())
{
// clip s to yMin.
e = s+(e-s)*(bb.yMin()-s.y())/(e.y()-s.y());
}
if (s.y()>bb.yMax())
{
// clip e to yMax.
s = s+(e-s)*(bb.yMax()-s.y())/(e.y()-s.y());
}
}
// compate s and e against the zMin to zMax range of bb.
if (s.z()<=e.z())
{
// trivial reject of segment wholely outside.
if (e.z()<bb.zMin()) return false;
if (s.z()>bb.zMax()) return false;
if (s.z()<bb.zMin())
{
// clip s to zMin.
s = s+(e-s)*(bb.zMin()-s.z())/(e.z()-s.z());
}
if (e.z()>bb.zMax())
{
// clip e to zMax.
e = s+(e-s)*(bb.zMax()-s.z())/(e.z()-s.z());
}
}
else
{
if (s.z()<bb.zMin()) return false;
if (e.z()>bb.zMax()) return false;
if (e.z()<bb.zMin())
{
// clip s to zMin.
e = s+(e-s)*(bb.zMin()-s.z())/(e.z()-s.z());
}
if (s.z()>bb.zMax())
{
// clip e to zMax.
s = s+(e-s)*(bb.zMax()-s.z())/(e.z()-s.z());
}
}
return true;
}
bool Seg::intersect(const BoundingBox& bb) const
{
if (!bb.isValid()) return false;
Vec3 s=_s,e=_e;
return intersectAndClip(s,e,bb);
}
bool Seg::intersect(const BoundingBox& bb,float& r1,float& r2) const
{
if (!bb.isValid()) return false;
Vec3 s=_s,e=_e;
return intersectAndClip(s,e,bb);
}
bool Seg::intersect(const BoundingSphere& bs,float& r1,float& r2) const
{
Vec3 sm = _s-bs._center;
float c = sm.length2()-bs._radius*bs._radius;
Vec3 se = _e-_s;
float a = se.length2();
float b = sm*se*2.0f;
float d = b*b-4.0f*a*c;
if (d<0.0f) return false;
d = sqrtf(d);
float div = 1.0f/(2.0f*a);
r1 = (-b-d)*div;
r2 = (-b+d)*div;
if (r1<=0.0f && r2<=0.0f) return false;
if (r1>=1.0f && r2>=1.0f) return false;
return true;
}
bool Seg::intersect(const BoundingSphere& bs) const
{
Vec3 sm = _s-bs._center;
float c = sm.length2()-bs._radius*bs._radius;
if (c<0.0f) return true;
Vec3 se = _e-_s;
float a = se.length2();
float b = (sm*se)*2.0f;
float d = b*b-4.0f*a*c;
if (d<0.0f) return false;
d = sqrtf(d);
float div = 1.0f/(2.0f*a);
float r1 = (-b-d)*div;
float r2 = (-b+d)*div;
if (r1<=0.0f && r2<=0.0f) return false;
if (r1>=1.0f && r2>=1.0f) return false;
return true;
}
bool Seg::intersect(const Vec3& v1,const Vec3& v2,const Vec3& v3,float& r)
{
if (v1==v2 || v2==v3 || v1==v3) return false;
Vec3 vse = _e-_s;
Vec3 v12 = v2-v1;
Vec3 n12 = v12^vse;
float ds12 = (_s-v1)*n12;
float d312 = (v3-v1)*n12;
if (d312>=0.0f)
{
if (ds12<0.0f) return false;
if (ds12>d312) return false;
}
else // d312 < 0
{
if (ds12>0.0f) return false;
if (ds12<d312) return false;
}
Vec3 v23 = v3-v2;
Vec3 n23 = v23^vse;
float ds23 = (_s-v2)*n23;
float d123 = (v1-v2)*n23;
if (d123>=0.0f)
{
if (ds23<0.0f) return false;
if (ds23>d123) return false;
}
else // d123 < 0
{
if (ds23>0.0f) return false;
if (ds23<d123) return false;
}
Vec3 v31 = v1-v3;
Vec3 n31 = v31^vse;
float ds31 = (_s-v3)*n31;
float d231 = (v2-v3)*n31;
if (d231>=0.0f)
{
if (ds31<0.0f) return false;
if (ds31>d231) return false;
}
else // d231 < 0
{
if (ds31>0.0f) return false;
if (ds31<d231) return false;
}
float r3 = ds12/d312;
float r1 = ds23/d123;
float r2 = ds31/d231;
// float rt = r1+r2+r3;
Vec3 in = v1*r1+v2*r2+v3*r3;
float length = vse.length();
vse /= length;
float d = (in-_s)*vse;
if (d<0.0f) return false;
if (d>length) return false;
r = d/length;
return true;
}

8
src/osg/Sequence.cpp
View File

@@ -1,8 +0,0 @@
#include "osg/Sequence"
#include "osg/Registry"
using namespace osg;
RegisterObjectProxy<Sequence> g_SequenceProxy;
// to be written :-)

22
src/osgPlugins/flt/export.h
View File

@@ -1,22 +0,0 @@
#ifndef __FLT_EXPORT_H
#define __FLT_EXPORT_H
#define FLT_DLL
#ifdef WIN32
#pragma warning( disable : 4251 )
#pragma warning( disable : 4275 )
#pragma warning( disable : 4786 )
#endif
#if defined(FLT_DLL) && defined(_MSC_VER)
# ifdef FLT_LIBRARY
# define FLT_EXPORT __declspec(dllexport)
# else
# define FLT_EXPORT __declspec(dllimport)
# endif /* FLT_LIBRARY */
#else
# define FLT_EXPORT
#endif /* FLT_DLL && _MSC_VER */
#endif

94
src/osgPlugins/osgtgz/osgtgz.cpp
View File

@@ -1,94 +0,0 @@
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <osg/OSG>
#include <osg/Geode>
#include <osg/Group>
#include <osg/Registry>
#include <osg/Notify>
#include "osg/FileNameUtils"
using namespace osg;
#ifdef __sgi
static int dirent_select( dirent *dent )
#else
static int dirent_select( const dirent *dent )
#endif
{
if( strlen( dent->d_name) < 4 )
return 0;
return !strncmp( ".osg", &dent->d_name[strlen(dent->d_name)-4], 4 );
}
class sgReaderWriterOSGTGZ : public ReaderWriter {
public:
virtual const char* className() { return "Default OSGTGZ Database Reader/Writer"; }
virtual bool acceptsExtension(const std::string& extension) { return extension=="osgtgz"; }
virtual Node* readNode(const std::string& fileName)
{
std::string ext = getLowerCaseFileExtension(fileName);
if (!acceptsExtension(ext)) return NULL;
osg::notify(osg::INFO)<< "sgReaderWriterOSGTGZ::readNode( "<<fileName.c_str()<<" )\n";
char dirname[128];
char command[1024];
struct dirent **dent;
int ndent;
sprintf( dirname, "/tmp/.osg%06d", getpid());
#ifdef __linux
sprintf( command,
"tar xfCz %s %s",
fileName.c_str(), dirname );
#endif
#ifdef __sgi
sprintf( command,
"cp %s %s; cd %s;"
"gzcat %s | tar xf -",
fileName.c_str(), dirname, dirname,
fileName.c_str() );
#endif
mkdir( dirname, 0700 );
system( command );
ndent = scandir( dirname, &dent, dirent_select, alphasort );
osg::Group *grp = new osg::Group;
osg::SetFilePath( dirname );
for( int i = 0; i < ndent; i++ )
{
osg::Node *node = osg::loadNodeFile( dent[i]->d_name );
grp->addChild( node );
}
sprintf( command, "rm -rf %s", dirname );
system( command );
if( grp->getNumChildren() == 0 )
{
grp->unref();
return NULL;
}
else
return grp;
}
virtual bool writeNode(Node& obj,const std::string& fileName) {
return false;
}
};
// now register with sgRegistry to instantiate the above
// reader/writer.
RegisterReaderWriterProxy<sgReaderWriterOSGTGZ> g_readerWriter_OSGTGZ_Proxy;

799
src/osgUtil/RenderVisitor.cpp
View File

@@ -1,799 +0,0 @@
#include "osgUtil/RenderVisitor"
#include "osg/DCS"
#include "osg/Geode"
#include "osg/LOD"
#include "osg/Billboard"
#include "osg/LightSource"
#include "osg/Notify"
#include <float.h>
#include <algorithm>
#ifndef OSG_USE_IO_DOT_H
#include <iostream>
using namespace std;
#endif
using namespace osg;
using namespace osgUtil;
static bool g_debugging = false;
ViewState::ViewState()
{
_matrix = NULL;
_inverse = NULL;
_ratio = 0.002f;
_viewFrustumCullingActive=true;
_smallFeatureCullingActive=true;
}
ViewState::~ViewState()
{
if (_matrix) _matrix->unref();
if (_inverse) _inverse->unref();
}
bool ViewState::isCulled(const BoundingSphere& sp)
{
if (!sp.isValid()) return true;
Vec3 delta = sp._center-_eyePoint;
if (_smallFeatureCullingActive)
{
if (sp._radius<delta.length()*_ratio)
{
return true;
}
}
if (_viewFrustumCullingActive)
{
if (delta*_frustumTopNormal>sp._radius)
{
return true;
}
if (delta*_frustumBottomNormal>sp._radius)
{
return true;
}
if (delta*_frustumLeftNormal>sp._radius)
{
return true;
}
if (delta*_frustumRightNormal>sp._radius)
{
return true;
}
}
return false;
}
bool ViewState::isCulled(const BoundingBox& bb)
{
if (!bb.isValid()) return true;
if (_viewFrustumCullingActive)
{
unsigned int c;
for(c=0;c<8;++c)
{
if ((bb.corner(c)-_eyePoint)*_frustumLeftNormal<=0.0f) break;
}
// if all corners have been checked, therefore all points are
// and the far side of the left clipping plane and hence should be culled.
if (c==8) return true;
for(c=0;c<8;++c)
{
if ((bb.corner(c)-_eyePoint)*_frustumRightNormal<=0.0f) break;
}
// if all corners have been checked, therefore all points are
// and the far side of the right clipping plane and hence should be culled.
if (c==8) return true;
for(c=0;c<8;++c)
{
if ((bb.corner(c)-_eyePoint)*_frustumTopNormal<=0.0f) break;
}
// if all corners have been checked, therefore all points are
// and the far side of the top clipping plane and hence should be culled.
if (c==8) return true;
for(c=0;c<8;++c)
{
if ((bb.corner(c)-_eyePoint)*_frustumBottomNormal<=0.0f) break;
}
// if all corners have been checked, therefore all points are
// and the far side of the bottom clipping plane and hence should be culled.
if (c==8) return true;
}
return false;
}
RenderVisitor::RenderVisitor()
{
// overide the default node visitor mode.
setTraverseMode(NodeVisitor::TRAVERSE_ACTIVE_CHILDREN);
_globalState=NULL;
_LODBias = 1.0f;
_fovy=60.0f;
_aspect=1.0f;
_znear=1.0f;
_zfar=1000.0f;
_tvs = new ViewState;
_tvs->_eyePoint.set(0.0f,0.0f,1.0f);
_tvs->_centerPoint.set(0.0f,0.0f,0.0f);
_tvs->_lookVector.set(0.0f,0.0f,-1.0f);
_tvs->_upVector.set(0.0f,1.0f,0.0f);
_tvs->ref();
_cvs = _tvs;
_cvs->ref();
_tsm = LOOK_VECTOR_DISTANCE;
_tsm = OBJECT_EYE_POINT_DISTANCE;
_viewFrustumCullingActive=true;
_smallFeatureCullingActive=true;
calculateClippingPlanes();
}
RenderVisitor::~RenderVisitor()
{
reset();
// if a global geostate is attached simply unref it.
if (_globalState)
{
_globalState->unref();
_globalState = NULL;
}
if (_tvs) _tvs->unref();
if (_cvs) _cvs->unref();
}
void RenderVisitor::reset()
{
//
// first unref all referenced objects and then empty the containers.
//
std::for_each(_viewStateStack.begin(),_viewStateStack.end(),UnrefOp<ViewState>());
_viewStateStack.erase(_viewStateStack.begin(),_viewStateStack.end());
if (_cvs!=_tvs)
{
if (_cvs) _cvs->unref();
_cvs = _tvs;
_cvs->ref();
}
for(std::multimap<float,MatrixGeoSet>::iterator titr= _transparentGeoSets.begin();
titr!= _transparentGeoSets.end();
++titr)
{
if ((*titr).second.first) (*titr).second.first->unref();
}
_transparentGeoSets.erase(_transparentGeoSets.begin(),_transparentGeoSets.end());
for(std::multimap<GeoState*,MatrixGeoSet>::iterator oitr= _opaqueGeoSets.begin();
oitr!= _opaqueGeoSets.end();
++oitr)
{
if ((*oitr).second.first) (*oitr).second.first->unref();
}
_opaqueGeoSets.erase(_opaqueGeoSets.begin(),_opaqueGeoSets.end());
_lights.erase(_lights.begin(),_lights.end());
}
void RenderVisitor::setGlobalState(GeoState* global)
{
if (global==_globalState) return;
if (_globalState) _globalState->unref();
_globalState = global;
_globalState->ref();
}
void RenderVisitor::setPerspective(const osg::Camera& camera)
{
_fovy=camera.getFieldOfViewY();
_aspect=camera.getAspectRatio();
_znear=camera.getNearPlane();
_zfar=camera.getFarPlane();
calculateClippingPlanes();
}
void RenderVisitor::setPerspective(float fovy,float aspect,float znear,float zfar)
{
_fovy=fovy;
_aspect=aspect;
_znear=znear;
_zfar=zfar;
calculateClippingPlanes();
}
void RenderVisitor::setLookAt(const Camera& camera)
{
setLookAt(camera.getEyePoint(),camera.getLookPoint(),camera.getUpVector());
}
void RenderVisitor::setLookAt(const Vec3& eye,const Vec3& center,const Vec3& upVector)
{
_tvs->_eyePoint = eye;
_tvs->_centerPoint = center;
_tvs->_lookVector = center-eye;
_tvs->_lookVector.normalize();
_tvs->_upVector = upVector;
calculateClippingPlanes();
}
void RenderVisitor::setLookAt(double eyeX,double eyeY,double eyeZ,
double centerX,double centerY,double centerZ,
double upX,double upY,double upZ)
{
_tvs->_eyePoint[0] = eyeX;
_tvs->_eyePoint[1] = eyeY;
_tvs->_eyePoint[2] = eyeZ;
_tvs->_centerPoint[0] = centerX;
_tvs->_centerPoint[1] = centerY;
_tvs->_centerPoint[2] = centerZ;
_tvs->_lookVector[0] = centerX-eyeX;
_tvs->_lookVector[1] = centerY-eyeY;
_tvs->_lookVector[2] = centerZ-eyeZ;
_tvs->_lookVector.normalize();
_tvs->_upVector[0] = upX;
_tvs->_upVector[1] = upY;
_tvs->_upVector[2] = upZ;
calculateClippingPlanes();
}
void RenderVisitor::setCullingActive(CullingType ct,bool active)
{
switch(ct)
{
case(VIEW_FRUSTUM_CULLING):_viewFrustumCullingActive=active;break;
case(SMALL_FEATURE_CULLING):_smallFeatureCullingActive=active;break;
}
}
bool RenderVisitor::getCullingActive(CullingType ct)
{
switch(ct)
{
case(VIEW_FRUSTUM_CULLING):return _viewFrustumCullingActive;
case(SMALL_FEATURE_CULLING):return _smallFeatureCullingActive;
}
return false;
}
void RenderVisitor::calculateClippingPlanes()
{
float half_fovy = _fovy*0.5f;
float s = sinf(half_fovy*M_PI/180.0f);
float c = cosf(half_fovy*M_PI/180.0f);
Vec3 lv = _tvs->_lookVector;
Vec3 up = _tvs->_upVector;
Vec3 sv = lv ^ up;
sv.normalize();
_tvs->_frustumTopNormal = -lv*s + up*c;
_tvs->_frustumTopNormal.normalize();
_tvs->_frustumBottomNormal = -lv*s - up*c;
_tvs->_frustumBottomNormal.normalize();
_tvs->_frustumLeftNormal = -sv*c - lv*(s*_aspect);
_tvs->_frustumLeftNormal.normalize();
_tvs->_frustumRightNormal = sv*c - lv*(s*_aspect);
_tvs->_frustumRightNormal.normalize();
// notify(INFO) << "_frustumTopNormal = "<<_tvs->_frustumTopNormal[0]<<"\t"<<_tvs->_frustumTopNormal[1]<<"\t"<<_tvs->_frustumTopNormal[2]<<endl;
// notify(INFO) << "_frustumBottomNormal = "<<_tvs->_frustumBottomNormal[0]<<"\t"<<_tvs->_frustumBottomNormal[1]<<"\t"<<_tvs->_frustumBottomNormal[2]<<endl;
// notify(INFO) << "_frustumLeftNormal = "<<_tvs->_frustumLeftNormal[0]<<"\t"<<_tvs->_frustumLeftNormal[1]<<"\t"<<_tvs->_frustumLeftNormal[2]<<endl;
// notify(INFO) << "_frustumRightNormal = "<<_tvs->_frustumRightNormal[0]<<"\t"<<_tvs->_frustumRightNormal[1]<<"\t"<<_tvs->_frustumRightNormal[2]<<endl;
}
void RenderVisitor::pushMatrix(const Matrix& matrix)
{
ViewState* nvs = new ViewState;
nvs->ref();
nvs->_viewFrustumCullingActive=_viewFrustumCullingActive;
nvs->_smallFeatureCullingActive=_smallFeatureCullingActive;
if (_cvs && _cvs->_matrix)
{
nvs->_matrix = new Matrix;
nvs->_matrix->mult(matrix,*(_cvs->_matrix));
}
else
{
nvs->_matrix = new Matrix(matrix);
}
nvs->_matrix->ref();
Matrix* inverse_world = new Matrix;
inverse_world->ref();
inverse_world->invert(*(nvs->_matrix));
nvs->_inverse = inverse_world;
nvs->_eyePoint = _tvs->_eyePoint*(*inverse_world);
nvs->_centerPoint = _tvs->_centerPoint*(*inverse_world);
nvs->_lookVector = nvs->_centerPoint - nvs->_eyePoint;
nvs->_lookVector.normalize();
nvs->_frustumTopNormal = (_tvs->_eyePoint + _tvs->_frustumTopNormal)*(*inverse_world)-nvs->_eyePoint;
nvs->_frustumTopNormal.normalize();
nvs->_frustumBottomNormal = (_tvs->_eyePoint + _tvs->_frustumBottomNormal)*(*inverse_world)-nvs->_eyePoint;
nvs->_frustumBottomNormal.normalize();
nvs->_frustumLeftNormal = (_tvs->_eyePoint + _tvs->_frustumLeftNormal)*(*inverse_world)-nvs->_eyePoint;
nvs->_frustumLeftNormal.normalize();
nvs->_frustumRightNormal = (_tvs->_eyePoint + _tvs->_frustumRightNormal)*(*inverse_world)-nvs->_eyePoint;
nvs->_frustumRightNormal.normalize();
if (_cvs) _cvs->unref();
_cvs = nvs;
if (_cvs) _cvs->ref();
_viewStateStack.push_back(nvs);
}
void RenderVisitor::popMatrix()
{
// pop the top of the view stack and unref it.
ViewState* pvs = _viewStateStack.back();
_viewStateStack.pop_back();
pvs->unref();
// unref previous cvs
if (_cvs) _cvs->unref();
// to new cvs and ref it.
if (_viewStateStack.empty())
{
_cvs = _tvs;
if (_cvs) _cvs->ref();
}
else
{
_cvs = _viewStateStack.back();
if (_cvs) _cvs->ref();
}
}
Matrix* RenderVisitor::getCurrentMatrix()
{
return _cvs->_matrix;
}
Matrix* RenderVisitor::getInverseCurrentMatrix()
{
return _cvs->_inverse;
}
const Vec3& RenderVisitor::getEyeLocal()
{
return _cvs->_eyePoint;
}
const Vec3& RenderVisitor::getCenterLocal()
{
return _cvs->_centerPoint;
}
const Vec3& RenderVisitor::getLookVectorLocal()
{
return _cvs->_lookVector;
}
bool RenderVisitor::isCulled(const BoundingSphere& sp)
{
return _cvs->isCulled(sp);
}
bool RenderVisitor::isCulled(const BoundingBox& bb)
{
return _cvs->isCulled(bb);
}
void RenderVisitor::apply(Node& node)
{
if (isCulled(node.getBound())) return;
traverse(node);
}
void RenderVisitor::apply(Geode& node)
{
if (isCulled(node.getBound())) return;
Matrix* matrix = getCurrentMatrix();
for(int i=0;i<node.getNumGeosets();++i)
{
GeoSet* gset = node.getGeoSet(i);
if (isCulled(gset->getBound())) continue;
GeoState* gstate = gset->getGeoState();
bool isTransparent = gstate && gstate->isTransparent();
if (isTransparent)
{
Vec3 center;
if (matrix)
{
center = (gset->getBound().center())*(*matrix);
}
else
{
center = gset->getBound().center();
}
Vec3 delta_center = center-_tvs->_eyePoint;
if (g_debugging)
{
notify(INFO) << "center ["<<center.x()<<","<<center.y()<<","<<center.z()<<"]"<<endl;
notify(INFO) << "delta_center ["<<delta_center.x()<<","<<delta_center.y()<<","<<delta_center.z()<<"]"<<endl;
notify(INFO) << "_lookVector ["<<_tvs->_lookVector.x()<<","<<_tvs->_lookVector.y()<<","<<_tvs->_lookVector.z()<<"]"<<endl;
}
float depth;
switch(_tsm)
{
case(LOOK_VECTOR_DISTANCE):depth = _tvs->_lookVector*delta_center;break;
case(OBJECT_EYE_POINT_DISTANCE):
default: depth = delta_center.length2();break;
}
if (matrix) matrix->ref();
_transparentGeoSets.insert(
std::pair<float,MatrixGeoSet>(depth,MatrixGeoSet(matrix,gset))
);
}
else
{
if (matrix) matrix->ref();
_opaqueGeoSets.insert(
std::pair<GeoState*,MatrixGeoSet>(gstate,MatrixGeoSet(matrix,gset))
);
}
}
}
void RenderVisitor::apply(Billboard& node)
{
if (isCulled(node.getBound())) return;
Vec3 eye_local = getEyeLocal();
for(int i=0;i<node.getNumGeosets();++i)
{
Vec3 pos;
node.getPos(i,pos);
GeoSet* gset = node.getGeoSet(i);
// need to modify isCulled to handle the billboard offset.
// if (isCulled(gset->getBound())) continue;
Matrix local_mat;
node.calcTransform(eye_local,pos,local_mat);
Matrix* matrix = NULL;
if (_cvs->_matrix)
{
matrix = new Matrix();
matrix->mult(local_mat,*(_cvs->_matrix));
}
else
{
matrix = new Matrix(local_mat);
}
GeoState* gstate = gset->getGeoState();
bool isTransparent = gstate && gstate->isTransparent();
if (isTransparent)
{
Vec3 center;
if (matrix)
{
center = (gset->getBound().center())*(*matrix);
}
else
{
center = gset->getBound().center();
}
Vec3 delta_center = center-_tvs->_eyePoint;
if (g_debugging)
{
notify(INFO) << "center ["<<center.x()<<","<<center.y()<<","<<center.z()<<"]"<<endl;
notify(INFO) << "delta_center ["<<delta_center.x()<<","<<delta_center.y()<<","<<delta_center.z()<<"]"<<endl;
notify(INFO) << "_lookVector ["<<_tvs->_lookVector.x()<<","<<_tvs->_lookVector.y()<<","<<_tvs->_lookVector.z()<<"]"<<endl;
}
float depth;
switch(_tsm)
{
case(LOOK_VECTOR_DISTANCE):depth = _tvs->_lookVector*delta_center;break;
case(OBJECT_EYE_POINT_DISTANCE):
default: depth = delta_center.length2();break;
}
if (matrix) matrix->ref();
_transparentGeoSets.insert(
std::pair<float,MatrixGeoSet>(depth,MatrixGeoSet(matrix,gset))
);
}
else
{
if (matrix) matrix->ref();
_opaqueGeoSets.insert(
std::pair<GeoState*,MatrixGeoSet>(gstate,MatrixGeoSet(matrix,gset))
);
}
}
}
void RenderVisitor::apply(LightSource& node)
{
Matrix* matrix = getCurrentMatrix();
Light* light = node.getLight();
if (light)
{
if (matrix) matrix->ref();
_lights.insert(std::pair<Matrix*,Light*>(matrix,light));
}
}
void RenderVisitor::apply(Group& node)
{
if (isCulled(node.getBound())) return;
traverse(node);
}
void RenderVisitor::apply(DCS& node)
{
if (isCulled(node.getBound())) return;
pushMatrix(*node.getMatrix());
traverse(node);
popMatrix();
}
void RenderVisitor::apply(Switch& node)
{
apply((Group&)node);
}
void RenderVisitor::apply(LOD& node)
{
if (isCulled(node.getBound())) return;
int eval = node.evaluate(getEyeLocal(),_LODBias);
if (eval<0)
{
//notify(INFO) << "culled LOD"<<endl;
return;
}
else
{
//notify(INFO) << "selecting child "<<eval<<endl;
node.getChild(eval)->accept(*this);
}
}
void RenderVisitor::apply(Scene& node)
{
apply((Group&)node);
}
bool RenderVisitor::calcNearFar(double& near_plane,double& far_plane)
{
if (_opaqueGeoSets.empty() && _transparentGeoSets.empty()) return false;
near_plane = FLT_MAX;
far_plane = -FLT_MAX;
Vec3 eyePoint = getEyeLocal();
Vec3 lookVector = getLookVectorLocal();
for(OpaqueList::iterator oitr = _opaqueGeoSets.begin();
oitr != _opaqueGeoSets.end();
++oitr)
{
Matrix* matrix = (oitr->second).first;
GeoSet* gset = (oitr->second).second;
const BoundingBox& bb = gset->getBound();
for(int c=0;c<8;++c)
{
float d;
if (matrix) d = ((bb.corner(c)*(*matrix))-eyePoint)*lookVector;
else d = (bb.corner(c)-eyePoint)*lookVector;
if (d<near_plane) near_plane = d;
if (d>far_plane) far_plane = d;
}
}
for(TransparentList::iterator titr = _transparentGeoSets.begin();
titr != _transparentGeoSets.end();
++titr)
{
Matrix* matrix = (titr->second).first;
GeoSet* gset = (titr->second).second;
const BoundingBox& bb = gset->getBound();
for(int c=0;c<8;++c)
{
float d;
if (matrix) d = ((bb.corner(c)*(*matrix))-eyePoint)*lookVector;
else d = (bb.corner(c)-eyePoint)*lookVector;
if (d<near_plane) near_plane = d;
if (d>far_plane) far_plane = d;
}
}
return true;
}
void RenderVisitor::render()
{
Matrix* prevMatrix = NULL;
Matrix* currMatrix = NULL;
GeoState* currGeoState = NULL;
GeoState* prevGeoState = NULL;
if (g_debugging) notify(INFO) << "start of render"<<endl;
if (_globalState)
{
_globalState->apply();
prevGeoState=_globalState;
}
// apply the lists.
for(LightList::iterator litr=_lights.begin();
litr!=_lights.end();
++litr)
{
currMatrix = litr->first;
if (currMatrix!=prevMatrix)
{
if (prevMatrix) glPopMatrix();
if (currMatrix)
{
glPushMatrix();
glMultMatrixf( (GLfloat *)(currMatrix->_mat) );
}
prevMatrix = currMatrix;
}
(litr->second)->apply();
}
// draw the opaque bin.
for(std::multimap<GeoState*,MatrixGeoSet>::iterator oitr= _opaqueGeoSets.begin();
oitr!= _opaqueGeoSets.end();
++oitr)
{
if (g_debugging)
{
notify(INFO) << " drawing opaque matrix["<<(*oitr).second.first<<"]"
<< " geoset["<<(*oitr).second.second<<"]"
<< " geostate["<<(*oitr).second.second->getGeoState()<<"]"<<endl;
}
currMatrix = (*oitr).second.first;
if (currMatrix!=prevMatrix)
{
if (prevMatrix) glPopMatrix();
if (currMatrix)
{
glPushMatrix();
glMultMatrixf( (GLfloat *)(currMatrix->_mat) );
}
prevMatrix = currMatrix;
}
currGeoState = (*oitr).first;
if (currGeoState!=prevGeoState)
{
if (currGeoState) currGeoState->apply(_globalState,prevGeoState);
prevGeoState = currGeoState;
}
(*oitr).second.second->draw();
}
// glPushAttrib( GL_DEPTH_TEST );
// glDisable( GL_DEPTH_TEST );
// render the transparent geoset in reverse order, so to render the
// deepest transparent objects, relative to the look vector, first.
for(std::multimap<float,MatrixGeoSet>::reverse_iterator titr= _transparentGeoSets.rbegin();
titr!= _transparentGeoSets.rend();
++titr)
{
if (g_debugging)
{
notify(INFO) << " drawing transparent matrix["<<(*titr).second.first<<"]"
<< " geoset["<<(*titr).second.second<<"]"
<< " geostate["<<(*titr).second.second->getGeoState()<<"]"
<< " depth["<<(*titr).first<<"]"<<endl;
}
currMatrix = (*titr).second.first;
if (currMatrix!=prevMatrix)
{
if (prevMatrix) glPopMatrix();
if (currMatrix)
{
glPushMatrix();
glMultMatrixf( (GLfloat *)(currMatrix->_mat) );
}
prevMatrix = currMatrix;
}
currGeoState = (*titr).second.second->getGeoState();
if (currGeoState!=prevGeoState)
{
if (currGeoState) currGeoState->apply(_globalState,prevGeoState);
prevGeoState = currGeoState;
}
(*titr).second.second->draw();
}
// glPopAttrib();
if (currMatrix) glPopMatrix();
if (g_debugging)
{
notify(INFO) << "end of render"<<endl<<endl;
notify(INFO).flush();
}
}