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

From Geoff Michel, updated geo plugin to support latest rev of Geo Modeller's file format.

Browse Source
This commit is contained in:
Robert Osfield
2003-09-14 22:49:47 +00:00
parent 81fbb26d62
commit e6cd07f857
8 changed files with 1131 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
NEWS.txt
View File

@@ -1,7 +1,7 @@
OSG News (most significant items from ChangeLog)
================================================
12th September 2003 - OpenSceneGraph-0.9.6
14th September 2003 - OpenSceneGraph-0.9.6
>>> osgFX Special Effects nodekit, support for double Matrix traversals,
>>> improved build support, thread safety and robustness.

9
VisualStudio/VisualStudio.dsw
View File

@@ -1742,6 +1742,15 @@ Package=<4>
Begin Project Dependency
Project_Dep_Name Core osgDB
End Project Dependency
Begin Project Dependency
Project_Dep_Name Core osgUtil
End Project Dependency
Begin Project Dependency
Project_Dep_Name Core osgSim
End Project Dependency
Begin Project Dependency
Project_Dep_Name Core osgText
End Project Dependency
}}}
###############################################################################

13
VisualStudio/examples/slideshow3D/slideshow3D.dsp
View File

@@ -189,6 +189,12 @@ SOURCE=..\..\..\examples\slideshow3D\DefaultPresentation.cpp
SOURCE=..\..\..\examples\slideshow3D\SlideEventHandler.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\examples\slideshow3D\PointsEventHandler.cpp
# End Source File
# Begin Source File
@@ -229,6 +235,13 @@ SOURCE=..\..\..\examples\slideshow3D\SlideShowConstructor.cpp
SOURCE=..\..\..\examples\slideshow3D\SlideEventHandler.h
# End Source File
# Begin Source File
SOURCE=..\..\..\examples\slideshow3D\PointsEventHandler.h
# End Source File
# Begin Source File

348
src/osgPlugins/geo/ReaderWriterGEO.cpp
View File

@@ -16,6 +16,7 @@
#include <osg/Sequence>
#include <osg/Switch>
#include <osg/Geode>
#include <osg/Depth>
#include <osg/LineWidth>
#include <osg/Geometry>
#include <osg/MatrixTransform>
@@ -32,6 +33,7 @@
#include <osgDB/FileNameUtils>
#include <osgDB/Registry>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgDB/Input>
#include <osgDB/Output>
#include <osgUtil/Tesselator>
@@ -175,19 +177,62 @@ public:
}
}
}
bool addFlat( const georecord *gface)
{ // this must only be called with a vertex georecord.
bool isflat=false;
const geoField *gfshade=gface->getField(GEO_DB_POLY_SHADEMODEL); // shaded gouraud, flat...
int shademodel=gfshade ? gfshade->getInt() : -1;
if (shademodel==GEO_POLY_SHADEMODEL_LIT) { // flat shaded - need the index
const geoField *gfd=gface->getField(GEO_DB_POLY_NORMAL);
if (gfd) {
float *normal= (gfd) ? (gfd->getVec3Arr()):NULL;
osg::Vec3 nrm(normal[0], normal[1], normal[2]);
norms->push_back(nrm);
isflat=true;
}
}
return isflat;
}
bool addIndices(georecord *gr, const geoHeaderGeo *ghdr, const float cdef[4], const georecord *gface)
{ // this must only be called with a vertex georecord.
// gr is tha vertex; gface is the face containing the vertex
bool hbeh=false; // true if this vertex has a behaviour
if (gr->getType()==DB_DSK_VERTEX) {
const geoField *gfd=gr->getField(GEO_DB_VRTX_NORMAL);
int nrmindex=gfd ? gfd->getUInt():0;
normindices->push_back(nrmindex);
norms->push_back((*npool)[nrmindex]);
gfd=gr->getField(GEO_DB_VRTX_COORD);
unsigned int idx=gfd ? gfd->getInt():0;
coords->push_back((*cpool)[idx]); //osg::Vec3(cpool[3*idx],cpool[3*idx+1],cpool[3*idx+2]));
coordindices->push_back(txcoords->size());
const geoField *gfshade=gface->getField(GEO_DB_POLY_SHADEMODEL); // shaded gouraud, flat...
int shademodel=gfshade ? gfshade->getInt() : -1;
if (shademodel!=GEO_POLY_SHADEMODEL_LIT && shademodel!=GEO_POLY_SHADEMODEL_FLAT) {
const geoField *gfd=gr->getField(GEO_DB_VRTX_NORMAL);
if (gfd->getType()==DB_UINT) {
unsigned int idx=gfd ? gfd->getUInt():-1;
if (idx>=0) {
normindices->push_back(idx);
norms->push_back((*npool)[idx]);
} else {
osg::notify(osg::WARN) << "No valid vertex index" << std::endl;
}
} else if (gfd->getType()==DB_VEC3F) {
float *p=gfd->getVec3Arr();
osg::Vec3 nrm;
nrm.set(p[0],p[1],p[2]);
norms->push_back(nrm);
}
}
const geoField *gfd=gr->getField(GEO_DB_VRTX_COORD);
osg::Vec3 pos;
if (gfd->getType()==DB_INT) {
unsigned int idx=gfd ? gfd->getInt():-1;
if (idx>=0) {
pos=(*cpool)[idx];
coords->push_back((*cpool)[idx]); //osg::Vec3(cpool[3*idx],cpool[3*idx+1],cpool[3*idx+2]));
coordindices->push_back(coords->size());
} else {
osg::notify(osg::WARN) << "No valid vertex index" << std::endl;
}
} else if (gfd->getType()==DB_VEC3F) {
float *p=gfd->getVec3Arr();
pos.set(p[0],p[1],p[2]);
coords->push_back(pos); //osg::Vec3(cpool[3*idx],cpool[3*idx+1],cpool[3*idx+2]));
}
std::vector< georecord *>bhv=gr->getBehaviour(); // behaviours for vertices, eg tranlate, colour!
if (!bhv.empty()) {
int ncoord=coords->size();
@@ -198,14 +243,14 @@ public:
if ((*rcitr)->getType()==DB_DSK_TRANSLATE_ACTION) {
geoMoveVertexBehaviour *mb=new geoMoveVertexBehaviour;
mb->makeBehave((*rcitr),ghdr);
mb->setpos((*cpool)[idx]);
mb->setpos(pos);
mb->setindx(ncoord-1);
BehList.push_back(mb);
}
if ((*rcitr)->getType()==DB_DSK_ROTATE_ACTION) {
geoMoveVertexBehaviour *mb=new geoMoveVertexBehaviour;
mb->makeBehave((*rcitr),ghdr);
mb->setpos((*cpool)[idx]);
mb->setpos(pos);
mb->setindx(ncoord-1);
BehList.push_back(mb);
}
@@ -231,16 +276,18 @@ public:
}
txindices->push_back(txcoords->size());
float *uvc=NULL;
gfd=gr->getField(GEO_DB_VRTX_UV_SET_1);
gfd=gr->getField(GEO_DB_VRTX_UV_SET_0);
if (gfd) {
uvc=(float *)gfd->getstore(0);
}
if (uvc) { // then there are tx coords
osg::Vec2 uv(uvc[0], uvc[1]);
txcoords->push_back(uv);
} else {
txcoords->push_back(osg::Vec2(0,0));
if (uvc) { // then there are tx coords
osg::Vec2 uv(uvc[0], uvc[1]);
txcoords->push_back(uv);
} else {
txcoords->push_back(osg::Vec2(0,0));
}
} else {
txcoords->push_back(osg::Vec2(0,0));
}
gfd=gr->getField(GEO_DB_VRTX_PACKED_COLOR);
if (gfd) {
@@ -319,8 +366,7 @@ public:
float getlinewidth(void) const { return linewidth;}
void setlineWidth(const int w) { linewidth=w;}
void setGeom(osg::Geometry *nugeom) { geom=nugeom;}
osg::Geometry *getGeom() const { return geom;}
osg::Geometry *getGeom() { return geom;}
osg::Geometry *getGeom() { return geom.get();}
uint getStart(uint nv) { uint ns=nstart; nstart+=nv; return ns; }
bool operator == (const geoInfo *gt) { // compare two geoInfos for same type of geometry
if (gt->texture!=texture) return false;
@@ -336,28 +382,25 @@ private:
int linewidth;
vertexInfo vinf;
uint nstart; // start vertex for a primitive
osg::Geometry *geom; // the geometry created for this vinf and texture
osg::ref_ptr<osg::Geometry> geom; // the geometry created for this vinf and texture
};
class ReaderWriterGEO : public ReaderWriter
class ReaderWriterGEO : public osgDB::ReaderWriter
{
public:
ReaderWriterGEO() { cpalrec=NULL; }
~ReaderWriterGEO() {
}
virtual const char* className() { return "GEO Reader/Writer"; }
virtual bool acceptsExtension(const std::string& extension)
{
return equalCaseInsensitive(extension,"gem") || equalCaseInsensitive(extension,"geo");
return osgDB::equalCaseInsensitive(extension,"gem") || osgDB::equalCaseInsensitive(extension,"geo");
}
virtual ReadResult readObject(const std::string& fileName, const Options* opt) { return readNode(fileName,opt); }
virtual ReadResult readNode(const std::string& fileName, const Options*)
{
std::string ext = getFileExtension(fileName);
std::string ext = osgDB::getFileExtension(fileName);
if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
std::ifstream fin(fileName.c_str(), std::ios::binary | std::ios::in );
@@ -384,12 +427,14 @@ class ReaderWriterGEO : public ReaderWriter
fin.close();
// now sort the records so that any record followed by a PUSh has a child set = next record, etc
std::vector<georecord *> sorted=sort(recs); // tree-list of sorted record pointers
/*#ifdef _DEBUG
#ifdef _DEBUG
osgDB::Output fout("georex.txt"); //, std::ios_base::out );
fout << "Debug file " << fileName << std::endl;
// fout << "Debug raw file " << fileName << std::endl;
// output(fout,recs);
fout << "Debug Sorted file " << fileName << std::endl;
output(fout,sorted);
fout.close();
#endif */
#endif /**/
nodeList=makeosg(sorted); // make a list of osg nodes
recs.clear();
geotxlist.clear();
@@ -399,17 +444,18 @@ class ReaderWriterGEO : public ReaderWriter
matlist.clear();/* */
coord_pool.clear();
normal_pool.clear();
osg::Node * groupnode = NULL;
if (nodeList.empty())
{
return ReadResult("No data loaded from "+fileName);
}
else if (nodeList.size()==1)
{
return nodeList.front();
groupnode = nodeList.front();
}
else
{
Group* group = new Group;
osg::Group *group = new Group;
group->setName("import group");
for(NodeList::iterator itr=nodeList.begin();
itr!=nodeList.end();
@@ -417,8 +463,12 @@ class ReaderWriterGEO : public ReaderWriter
{
group->addChild(*itr);
}
return group;
groupnode=group;
}
#ifdef _DEBUG // output a .osg version
osgDB::writeNodeFile(*groupnode,"geoosg.osg");
#endif /**/
return groupnode;
}
return 0L;
}
@@ -434,6 +484,11 @@ class ReaderWriterGEO : public ReaderWriter
// now parse for push/pops and add to lists
switch ((*itr).getType()) {
case 101: // old header - not appropriate!
curparent= &(*itr);
sorted.push_back(&(*itr));
osg::notify(osg::WARN) << "Old version 2 header block found - possible error!" << std::endl;
break;
case DB_DSK_PUSH:
if (!(curparent->getchildren().empty())) {
curparent= curparent->getLastChild(); // itr-1;
@@ -447,6 +502,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_HEADER: // attach to previous
curparent= &(*itr);
sorted.push_back(&(*itr));
cpalrec=NULL;
break;
case DB_DSK_INTERNAL_VARS: // attach to parent
case DB_DSK_LOCAL_VARS:
@@ -577,7 +633,7 @@ class ReaderWriterGEO : public ReaderWriter
int txidx=ginf.getTexture();
nug=new osg::Geometry;
const vertexInfo *vinf=ginf.getVinf();
nug->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
// nug->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
nug->setVertexArray(vinf->getCoords());
nug->setNormalArray(vinf->getNorms());
StateSet *dstate=new StateSet;
@@ -622,6 +678,7 @@ class ReaderWriterGEO : public ReaderWriter
{ // reclaim the colours
gfd=grec->getField(GEO_DB_POLY_USE_MATERIAL_DIFFUSE); // true: use material...
bool usemat= gfd ? gfd->getBool() : false;
nug->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
if (!usemat) { // get the per vertex colours OR per face colours.
gfd=grec->getField(GEO_DB_POLY_USE_VERTEX_COLORS); // true: use material...
bool usevert=gfd ? gfd->getBool() : false;
@@ -632,11 +689,14 @@ class ReaderWriterGEO : public ReaderWriter
nug->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
}
} else {
osg::Vec4Array *polycols=vinf->getPolcolours();
//if (polycols->size() > 0) {
nug->setColorArray(polycols);
nug->setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE);
//}
if (shademodel==GEO_POLY_SHADEMODEL_LIT_GOURAUD) {
nug->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
} else if (shademodel==GEO_POLY_SHADEMODEL_LIT) {
nug->setNormalBinding(osg::Geometry::BIND_PER_PRIMITIVE);
}
osg::Vec4Array *polycols=vinf->getPolcolours();
nug->setColorArray(polycols);
nug->setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE);
}
}
}
@@ -673,14 +733,11 @@ class ReaderWriterGEO : public ReaderWriter
}
if (gr.size()>0) {
vinf->addFlat(grec); // for flat normal shading
for (std::vector<georecord *>::const_iterator itr=gr.begin();
itr!=gr.end();
++itr) {
//bool hbeh=
vinf->addIndices((*itr), theHeader, defcol, grec);
//if (hbeh) { // then add a behaviour callback to the primitive
// bool hasbehave=true;
//}
vinf->addIndices((*itr), theHeader.get(), defcol, grec);
nv++;
}
}
@@ -708,8 +765,8 @@ class ReaderWriterGEO : public ReaderWriter
//int gFontSize1=2;
osgText::Text *text= new osgText::Text;
text->setFont(ttfPath);
const geoField *gfd=gr->getField(GEO_DB_TEXT_NAME);
//const char *name=gfd ? gfd->getChar() : "a text";
const geoField *gfd=gr->getField(GEO_DB_NODE_NAME);
const char *name=gfd ? gfd->getChar() : "a text";
gfd=gr->getField(GEO_DB_TEXT_STRING);
const char *content=gfd ? gfd->getChar() : " ";
text->setText(std::string(content));
@@ -745,6 +802,7 @@ class ReaderWriterGEO : public ReaderWriter
textState->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
geod->setStateSet( textState );
numt=new osg::MatrixTransform;
numt->setName(name);
gfd=gr->getField(GEO_DB_TEXT_MATRIX);
if (gfd) {
float *fmat=gfd->getMat44Arr();
@@ -767,7 +825,7 @@ class ReaderWriterGEO : public ReaderWriter
geoStrContentBehaviour *cb=new geoStrContentBehaviour;
gfd=(*rcitr)->getField(GEO_DB_STRING_CONTENT_ACTION_INPUT_VAR);
if (gfd) {
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
// ok=false;
@@ -801,7 +859,7 @@ class ReaderWriterGEO : public ReaderWriter
} else { // overall
cb->setVertIndices(0,1); // part of colours array to be modified
}
bool ok=cb->makeBehave((*rcitr), theHeader);
bool ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
@@ -820,7 +878,18 @@ class ReaderWriterGEO : public ReaderWriter
if ((*itr)->getType()==DB_DSK_VERTEX)
{ // light point vertices
const geoField *gfd=(*itr)->getField(GEO_DB_VRTX_COORD);
unsigned int idx=gfd ? gfd->getInt():0;
osg::Vec3 pos;
if (gfd->getType()==DB_INT) {
unsigned int idx=gfd ? gfd->getInt():-1;
if (idx>=0) {
pos=coord_pool[idx];
} else {
osg::notify(osg::WARN) << "No valid vertex index" << std::endl;
}
} else if (gfd->getType()==DB_VEC3F) {
float *p=gfd->getVec3Arr();
pos.set(p[0],p[1],p[2]);
}
gfd=(*itr)->getField(GEO_DB_VRTX_PACKED_COLOR);
if (gfd) {
unsigned char *cls=gfd->getUCh4Arr();
@@ -829,13 +898,13 @@ class ReaderWriterGEO : public ReaderWriter
float blue=cls[2]/255.0f;
//float alpha=1.0f; // cls[3]*frac/255.0f;
osg::Vec4 colour(red,green,blue,1.0f);
lpn->addLightPoint(osgSim::LightPoint(true,coord_pool[idx],colour,1.0f,1.0f,0,0,osgSim::LightPoint::BLENDED));
lpn->addLightPoint(osgSim::LightPoint(true,pos,colour,1.0f,1.0f,0,0,osgSim::LightPoint::BLENDED));
} else { // get colour from palette
gfd=(*itr)->getField(GEO_DB_VRTX_COLOR_INDEX); // use color pool...
int icp= gfd ? gfd->getInt() : 0;
float col[4];
theHeader->getPalette(icp, col);
lpn->addLightPoint(osgSim::LightPoint((coord_pool)[idx], osg::Vec4(col[0],col[1],col[2],1.0f)));
lpn->addLightPoint(osgSim::LightPoint(pos, osg::Vec4(col[0],col[1],col[2],1.0f)));
}
}
}
@@ -856,17 +925,19 @@ class ReaderWriterGEO : public ReaderWriter
}
}
}
void makeAnimatedGeometry(const georecord grec, const int imat,Group *nug) {
int makeAnimatedGeometry(const georecord grec, const int imat,Group *nug) {
// animated polygons - create a matrix & geode & poly & add to group nug
const std::vector<georecord *> gr=grec.getchildren();
int nanimations=0;
bool bothsides=allOneSided(&grec);
for (std::vector<georecord *>::const_iterator itr=gr.begin();
itr!=gr.end();
++itr) {
std::vector< georecord *>bhv=(*itr)->getBehaviour(); // behaviours attached to facets, eg colour!
if ((*itr)->getType()==DB_DSK_POLYGON && !bhv.empty()) { // animated facets go here
nanimations++;
if (hasMotionAction(bhv)) { // make matrix if motion needed.
const geoField *gfd=(*itr)->getField(GEO_DB_POLY_TEX);
const geoField *gfd=(*itr)->getField(GEO_DB_POLY_TEX0);
int txidx= gfd ? gfd->getInt() : -1;
gfd=(*itr)->getField(GEO_DB_POLY_SHADEMODEL); // shaded gouraud, flat...
int shademodel=gfd ? gfd->getInt() : GEO_POLY_SHADEMODEL_LIT_GOURAUD;
@@ -910,7 +981,7 @@ class ReaderWriterGEO : public ReaderWriter
}
}
return;
return nanimations;
}
bool hasColorAction(std::vector< georecord *>bhv) { // true if one of the actions changes colour
bool ok=false;
@@ -952,11 +1023,10 @@ class ReaderWriterGEO : public ReaderWriter
}
geoInfo *getGeometry(const georecord *grec,Geode *nug, std::vector<class geoInfo> *ia,
const unsigned int imat, const int shademodel, const bool bothsides) {
//gfd=(*itr)->getField(GEO_DB_POLY_NORMAL); // polygon normal for whole poly
int igidx=0, igeom=-1;
const geoField *gfd=grec->getField(GEO_DB_POLY_TEX);
const geoField *gfd=grec->getField(GEO_DB_POLY_TEX0);
int txidx= gfd ? gfd->getInt() : -1;
for (std::vector<class geoInfo>::const_iterator itrint=ia->begin();
for (std::vector<class geoInfo>::iterator itrint=ia->begin();
itrint!=ia->end() && igeom<0;
++itrint) { // find a geometry that shares this texture.
// also test for other properties of a unique material:
@@ -983,7 +1053,7 @@ class ReaderWriterGEO : public ReaderWriter
}
return (&((*ia)[igeom]));
}
void makeGeometry(const georecord &grec, const unsigned int imat,Geode *nug)
int makeGeometry(const georecord &grec, const unsigned int imat,Geode *nug)
{ // makegeometry makes a set of Geometrys attached to current parent (Geode nug)
const std::vector<georecord *> gr=grec.getchildren();
// std::vector<osg::Geometry *> geom;
@@ -1062,7 +1132,7 @@ class ReaderWriterGEO : public ReaderWriter
}
}
}
return;
return gr.size();
}
void makeTexts(georecord grec, Group *nug)
{ // makeTexts adds a set of text+transform Geometrys attached to current parent (Group nug)
@@ -1085,20 +1155,24 @@ class ReaderWriterGEO : public ReaderWriter
Group *makeTextGeode(const georecord *gr)
{ // in geo text is defined with a matrix included in the geo.geode (gr is this geo.geode)
// - we need to create this tree to render text
return NULL; // temporary disable april 2003
Group *nug=new Group;
const geoField *gfd=gr->getField(GEO_DB_RENDERGROUP_MAT);
// may be used in future const unsigned int imat=gfd ? gfd->getInt():0;
gfd=gr->getField(GEO_DB_RENDERGROUP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
nug->setName(gfd->getChar());
}
makeTexts((*gr),nug);
if (nug->getNumChildren() <=0) {
nug=NULL;
}
return nug;
}
Group *makeLightPointGeodes(const georecord *gr) {
const geoField *gfd=gr->getField(GEO_DB_RENDERGROUP_MAT);
Group *nug=new Group;
gfd=gr->getField(GEO_DB_RENDERGROUP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
char *name = gfd->getChar();
nug->setName(name);
@@ -1126,13 +1200,13 @@ class ReaderWriterGEO : public ReaderWriter
} else {
nug=new Geode;
} */
gfd=gr->getField(GEO_DB_RENDERGROUP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
char *name = gfd->getChar();
nug->setName(name);
}
makeAnimatedGeometry((*gr),imat,nug);
if (nug->getNumChildren() <=0) {
int nans=makeAnimatedGeometry((*gr),imat,nug);
if (nans <=0) {
nug=NULL;
}
return nug;
@@ -1141,9 +1215,9 @@ class ReaderWriterGEO : public ReaderWriter
{
const geoField *gfd=gr.getField(GEO_DB_RENDERGROUP_MAT);
const unsigned int imat=gfd ? gfd->getInt():0;
gfd=gr.getField(GEO_DB_RENDERGROUP_IS_BILLBOARD);
gfd=gr.getField(GEO_DB_RENDERGROUP_BILLBOARD);
bool isbillb = gfd ? gfd->getBool() : false;
Geode *nug;
osg::Geode *nug;
if (isbillb) {
Billboard *bilb= new Billboard ;
bilb->setAxis(Vec3(0,0,1));
@@ -1152,36 +1226,48 @@ class ReaderWriterGEO : public ReaderWriter
} else {
nug=new Geode;
}
gfd=gr.getField(GEO_DB_RENDERGROUP_NAME);
if (gfd) {
nug->setName(gfd->getChar());
}
makeGeometry(gr,imat,nug);
return nug;
int nchild=makeGeometry(gr,imat,nug);
if (nchild>0) { // complete the geode
gfd=gr.getField(GEO_DB_NODE_NAME);
if (gfd) {
nug->setName(gfd->getChar());
}
return nug;
} else {
return NULL;
}
}
osg::Group *makePage(const georecord *gr)
{
osg::Group *gp=new Group;
const geoField *gfd=gr->getField(GEO_DB_PAGE_NAME);
const geoField *gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
gp->setName(gfd->getChar());
}
return gp;
}
osg::Group *makeGroup(const georecord *gr) { // group or Static transform
osg::Group *gp=NULL;
const geoField *gfd=gr->getField(GEO_DB_GRP_TRANSFORM);
osg::Group *setmatrix(const georecord *gr) { // find one of the type sof matrix supported
const geoField *gfd=gr->getField(GEO_DB_GRP_MATRIX_TRANSFORM);
if (!gfd) gfd=gr->getField(GEO_DB_GRP_TRANSLATE_TRANSFORM);
if (!gfd) gfd=gr->getField(GEO_DB_GRP_ROTATE_TRANSFORM);
if (!gfd) gfd=gr->getField(GEO_DB_GRP_SCALE_TRANSFORM);
if (gfd) {
MatrixTransform *tr=new MatrixTransform;
osg::Matrix mx;
float * m44=gfd->getMat44Arr();
mx.set(m44); // hope uses same convention as OSG else will need to use set(m44[0],m44[1]...)
tr->setMatrix(mx);
gp=tr;
return tr;
} else {
return NULL;
}
}
osg::Group *makeGroup(const georecord *gr) { // group or Static transform
osg::Group *gp=setmatrix(gr);
if (!gp) {
gp=new osg::Group;
}
gfd=gr->getField(GEO_DB_GRP_NAME);
const geoField *gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
gp->setName(gfd->getChar());
}
@@ -1209,7 +1295,7 @@ class ReaderWriterGEO : public ReaderWriter
sw->setSingleChildOn(0);
osg::notify(osg::WARN) << gr << " No mask " << std::endl;
}
gfd=gr->getField(GEO_DB_SWITCH_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
sw->setName(gfd->getChar());
}
@@ -1219,7 +1305,7 @@ class ReaderWriterGEO : public ReaderWriter
osg::Sequence *makeSequence(const georecord *gr)
{
Sequence *sq=new Sequence;
const geoField *gfd=gr->getField(GEO_DB_SEQUENCE_NAME);
const geoField *gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
sq->setName(gfd->getChar());
}
@@ -1233,7 +1319,7 @@ class ReaderWriterGEO : public ReaderWriter
gfd=gr->getField(GEO_DB_LOD_OUT);
float out = gfd ? gfd->getFloat() : 0.0;
gp->setRange(0,out,in);
gfd=gr->getField(GEO_DB_LOD_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
gp->setName(gfd->getChar());
}
@@ -1290,7 +1376,7 @@ class ReaderWriterGEO : public ReaderWriter
// theHeader->setUpdateCallback(theHeader->getInternalVars());
}
if ((*rcitr)->getType()==DB_DSK_FLOAT_VAR) {
if (theHeader) theHeader->addUserVar((**rcitr));
if (theHeader.valid()) theHeader->addUserVar((**rcitr));
}
}
theHeader->setUpdateCallback(new geoHeaderCB);
@@ -1300,7 +1386,7 @@ class ReaderWriterGEO : public ReaderWriter
(*itr)->setMaterial(mt);
matlist.push_back(mt);
}
return theHeader;
return theHeader.get();
}
void makeTexture(const georecord *gr) {
// scans the fields of this record and puts a new texture & environment into 'pool' stor
@@ -1405,7 +1491,7 @@ class ReaderWriterGEO : public ReaderWriter
break;
case DB_DSK_ROTATE_ACTION: {
geoMoveBehaviour *cb= new geoMoveBehaviour;
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
@@ -1413,14 +1499,14 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_SCALE_ACTION: {
geoMoveBehaviour *sb=new geoMoveBehaviour;
ok=sb->makeBehave((*rcitr), theHeader);
ok=sb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(sb);
else delete sb;
}
break;
case DB_DSK_TRANSLATE_ACTION: {
geoMoveBehaviour *cb= new geoMoveBehaviour;
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
@@ -1428,35 +1514,35 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_COMPARE_ACTION: {
geoCompareBehaviour *cb=new geoCompareBehaviour;
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
break;
case DB_DSK_ARITHMETIC_ACTION: {
geoArithBehaviour *cb=new geoArithBehaviour;
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
break;
case DB_DSK_CLAMP_ACTION: {
geoClampBehaviour *cb=new geoClampBehaviour;
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
break;
case DB_DSK_RANGE_ACTION: {
geoRangeBehaviour *cb=new geoRangeBehaviour;
ok=cb->makeBehave((*rcitr), theHeader);
ok=cb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(cb);
else delete cb;
}
break;
case DB_DSK_VISIBILITY_ACTION: {
geoVisibBehaviour *vb = new geoVisibBehaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
@@ -1464,49 +1550,49 @@ class ReaderWriterGEO : public ReaderWriter
// ar3 types
case DB_DSK_TRIG_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
break;
case DB_DSK_INVERSE_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
break;
case DB_DSK_LINEAR_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
break;
case DB_DSK_PERIODIC_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
break;
case DB_DSK_PERIODIC2_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
break;
case DB_DSK_TRUNCATE_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
break;
case DB_DSK_ABS_ACTION: {
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
@@ -1515,7 +1601,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_DCS_ACTION: */
case DB_DSK_DISCRETE_ACTION: {
geoDiscreteBehaviour *db = new geoDiscreteBehaviour;
ok=db->makeBehave((*rcitr), theHeader);
ok=db->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(db);
else delete db;
}
@@ -1527,7 +1613,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_IF_THEN_ELSE_ACTION:
{
geoAr3Behaviour *vb = new geoAr3Behaviour;
ok=vb->makeBehave((*rcitr), theHeader);
ok=vb->makeBehave((*rcitr), theHeader.get());
if (ok) gcb->addBehaviour(vb);
else delete vb;
}
@@ -1550,12 +1636,27 @@ class ReaderWriterGEO : public ReaderWriter
++itr) {
const georecord *gr=*itr;
Group *mtr=makeBehave(gr);
if (gr->getType()== DB_DSK_GEODE) { // geodes can require >1 geometry for example if polygons have different texture indices.
if (gr->getType()== DB_DSK_RENDERGROUP) { // geodes can require >1 geometry for example if polygons have different texture indices.
// and for example if the node has a colour or other fine behaviour
Geode *geode=makeGeode(*gr); // geode of geometrys
Group *animatedGeodes= makeAnimatedGeodes(gr);
Group *lightptGeodes= makeLightPointGeodes(gr);
Group *textgeode=makeTextGeode(gr); // group of matrices & texts
const geoField *gfd=gr->getField(GEO_DB_GRP_ZBUFFER);
if (gfd) {
bool onoff=gfd->getBool();
if (!onoff) { // no z buffer - force to use unsorted renderBin
StateSet *dstate=new StateSet;
osg::Depth* depth = new osg::Depth;
depth->setFunction(osg::Depth::ALWAYS);
dstate->setAttribute(depth);
dstate->setRenderBinDetails(osg::StateSet::OPAQUE_BIN + 3, "UnSortedBin");
if (geode) geode->setStateSet( dstate );
if (animatedGeodes) animatedGeodes->setStateSet( dstate );
if (lightptGeodes) lightptGeodes->setStateSet( dstate );
if (textgeode) textgeode->setStateSet( dstate );
}
}
if (mtr) {
if (geode) mtr->addChild(geode);
@@ -1567,6 +1668,7 @@ class ReaderWriterGEO : public ReaderWriter
} else {
if (!geodeholder && (geode || textgeode)) {
geodeholder=new osg::Group;
geodeholder->setName("geodeHolder");
}
if (geode) geodeholder->addChild(geode);
if (animatedGeodes) geodeholder->addChild(animatedGeodes);
@@ -1577,6 +1679,7 @@ class ReaderWriterGEO : public ReaderWriter
Group *holder=NULL;
const geoField *gfd;
switch (gr->getType()) {
case 101:
case DB_DSK_HEADER:
holder=makeHeader(gr);
(*itr)->setNode(holder);
@@ -1607,7 +1710,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_CUBE:
holder=new Group;
(*itr)->setNode(holder);
gfd=gr->getField(GEO_DB_GRP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
holder->setName(gfd->getChar());
}
@@ -1615,7 +1718,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_SPHERE:
holder=new Group;
(*itr)->setNode(holder);
gfd=gr->getField(GEO_DB_GRP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
holder->setName(gfd->getChar());
}
@@ -1623,7 +1726,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_CONE:
holder=new Group;
(*itr)->setNode(holder);
gfd=gr->getField(GEO_DB_GRP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
holder->setName(gfd->getChar());
}
@@ -1631,7 +1734,7 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_CYLINDER:
holder=new Group;
(*itr)->setNode(holder);
gfd=gr->getField(GEO_DB_GRP_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
holder->setName(gfd->getChar());
}
@@ -1639,11 +1742,11 @@ class ReaderWriterGEO : public ReaderWriter
case DB_DSK_INSTANCE:
{
MatrixTransform *mtr=new MatrixTransform;
gfd=gr->getField(GEO_DB_INSTANCE_NAME);
gfd=gr->getField(GEO_DB_NODE_NAME);
if (gfd) {
mtr->setName(gfd->getChar());
}
gfd=gr->getField(GEO_DB_INSTANCE_TRANSFORM);
gfd=gr->getField(GEO_DB_GRP_MATRIX_TRANSFORM); // was: GEO_DB_INSTANCE_TRANSFORM);
if (gfd) {
float *fmat=gfd->getMat44Arr();
mtr->setMatrix(Matrix(fmat));
@@ -1732,6 +1835,17 @@ class ReaderWriterGEO : public ReaderWriter
}
return nodelist;
}
void output(osgDB::Output &fout,std::vector<georecord> gr)
{ // debugging - print the tree of records
if (gr.size()>0) {
for (std::vector<georecord>::iterator itr=gr.begin();
itr!=gr.end();
++itr) {
fout.indent() << "Node type " << (*itr).getType() << " ";
fout.indent() << (*itr) << std::endl;
}
}
}
void output(osgDB::Output &fout,std::vector<georecord *> gr)
{ // debugging - print the tree of records
fout.moveIn();
@@ -1761,28 +1875,28 @@ class ReaderWriterGEO : public ReaderWriter
}
break;
case DB_DSK_LOD:
gfd=(*itr).getField(GEO_DB_LOD_INSTANCE_DEF);
gfd=(*itr).getField(GEO_DB_INSTANCE_DEF);
if (gfd) {
uint fidnod=gfd->getUInt();
if (fidnod==fid) return &(*itr);
}
break;
case DB_DSK_SEQUENCE:
gfd=(*itr).getField(GEO_DB_SEQUENCE_INSTANCE_DEF);
gfd=(*itr).getField(GEO_DB_INSTANCE_DEF);
if (gfd) {
uint fidnod=gfd->getUInt();
if (fidnod==fid) return &(*itr);
}
break;
case DB_DSK_SWITCH:
gfd=(*itr).getField(GEO_DB_SWITCH_INSTANCE_DEF);
gfd=(*itr).getField(GEO_DB_INSTANCE_DEF);
if (gfd) {
uint fidnod=gfd->getUInt();
if (fidnod==fid) return &(*itr);
}
break;
case DB_DSK_GEODE:
gfd=(*itr).getField(GEO_DB_RENDERGROUP_INSTANCE_DEF);
case DB_DSK_RENDERGROUP:
gfd=(*itr).getField(GEO_DB_INSTANCE_DEF);
if (gfd) {
uint fidnod=gfd->getUInt();
if (fidnod==fid) return &(*itr);
@@ -1797,7 +1911,7 @@ private:
geoRecordList recs; // the records read from file
std::vector<osg::Vec3> coord_pool; // current vertex ooords
std::vector<osg::Vec3> normal_pool; // current pool of normal vectors
geoHeaderGeo *theHeader; // an OSG class - has animation vars etc
osg::ref_ptr<geoHeaderGeo> theHeader; // an OSG class - has animation vars etc
std::vector<georecord *> geotxlist; // list of geo::textures for this model
std::vector<georecord *> geomatlist; // list of geo::materials for this model
std::vector<osg::Texture2D *> txlist; // list of osg::textures for this model
@@ -1947,14 +2061,14 @@ void geoField::readfile(std::ifstream &fin, const uint id) { // is part of a rec
fin.read((char *)&tokid,1);fin.read((char *)&type,1);
fin.read((char *)&nits,sizeof(unsigned short));
// osg::notify(osg::WARN) << "geoField " << (int)tokid << " type " << (int)type << " nit " << (int)nits << std::endl;
if (type == GEO_DB_EXTENDED_FIELD) { // change for true extended type
if (type == DB_EXTENDED_FIELD_STRUCT) { // change for true extended type
fin.read((char *)&tokenId,sizeof(tokenId));fin.read((char *)&TypeId,sizeof(TypeId));
fin.read((char *)&numItems,sizeof(unsigned int));
} else {
tokenId=tokid; TypeId=type;
numItems=nits;
}
if (id== 0 && tokenId == GEO_DB_USER_EXT_VALUE_FIELD && numItems==1) { // Feb 2003 parse extension template records
if (id== 0 && tokenId == GEO_DB_NODE_EXTENDED && numItems==1) { // Feb 2003 parse extension template records
if (TypeId == DB_SHORT ||
TypeId == DB_USHORT) {
short upad;
@@ -1973,8 +2087,8 @@ void geoField::readfile(std::ifstream &fin, const uint id) { // is part of a rec
} else {
if (numItems>0) {
storageRead(fin); // allocate & fill the storage
if (tokenId == GEO_DB_USER_EXT_VALUE_FIELD) {
if (id==DB_DSK_POLYGON || id==DB_DSK_GEODE || id==DB_DSK_GROUP
if (tokenId == GEO_DB_NODE_EXTENDED) {
if (id==DB_DSK_POLYGON || id==DB_DSK_RENDERGROUP || id==DB_DSK_GROUP
|| id==DB_DSK_LOD || id==DB_DSK_MESH || id==DB_DSK_CUBE
|| id==DB_DSK_SPHERE || id==DB_DSK_CONE || id==DB_DSK_CYLINDER
|| id==DB_DSK_TEXTURE || id==DB_DSK_MATERIAL || id==DB_DSK_VIEW) {

993
src/osgPlugins/geo/geoFormat.h
View File

File diff suppressed because it is too large Load Diff

162
src/osgPlugins/geo/geoTypes.h
View File

@@ -45,7 +45,7 @@ COPYRIGHT NOTICE:
#endif
#ifndef ushort
//#define ushort unsigned short
#define ushort unsigned short
#endif
#ifndef ubyte
@@ -65,7 +65,9 @@ const uint GEO_PLUGIN_TYPE_IMAGE_IMPORTER = 4;
const uint GEO_PLUGIN_TYPE_TOOL = 5;
const uint GEO_PLUGIN_TYPE_BEHAVIOR = 6;
const uint GEO_PLUGIN_TYPE_GROUP_NODE_DEF = 7;
const uint GEO_PLUGIN_TYPE_LAST = GEO_PLUGIN_TYPE_GROUP_NODE_DEF;
const uint GEO_PLUGIN_TYPE_SURFACE_NODE_DEF = 8;
const uint GEO_PLUGIN_TYPE_TASK = 9;
const uint GEO_PLUGIN_TYPE_LAST = GEO_PLUGIN_TYPE_TASK;
@@ -104,62 +106,86 @@ const uint GEO_TOOL_TYPE_LAST = GEO_TOOL_TYPE_OPTIMIZE;
*
* GEO_DB_BASE
* GEO_DB_GROUP
* GEO_DB_BILLBOARD
* GEO_DB_SEQUENCE
* GEO_DB_LOD
* GEO_DB_SWITCH
* GEO_DB_RENDERGROUP
* GEO_DB_BASE_GROUP
* GEO_DB_RENDERGROUP
* GEO_DB_MULTI_TEX_SHADER
* GEO_DB_BASE_RENDERGROUP (*)
* GEO_DB_EXTERNAL
* GEO_DB_INSTANCE
* GEO_DB_PAGE
* GEO_DB_TRANSFORM (*)
* GEO_DB_CULL_GROUP
* GEO_DB_Z_OFFSET_GROUP
* GEO_DB_MULTI_SAMPLE_AA_GROUP
* GEO_DB_LINE_AA_GROUP
* GEO_DB_FADE_GROUP
* GEO_DB_TERRAIN
* GEO_DB_BSP
* GEO_DB_GEOMETRY
* GEO_DB_SURFACE
* GEO_DB_COORDINATE_SURFACE
* GEO_DB_POLYGON
* GEO_DB_LIGHTPT
* GEO_DB_MESH (*)
* GEO_DB_PARAMETRIC_SURFACE (*)
* GEO_DB_QUADRIC (*)
* GEO_DB_TEXT
* GEO_DB_POLYGON
* GEO_DB_LIGHTPT
* GEO_DB_MESH
* GEO_DB_BASE_SURFACE (*)
* GEO_DB_TEXT
* GEO_DB_VERTEX
* GEO_DB_HEADER
*
* (*) Not available in Geo Version 1.0
*/
//------------
//
const uint GEO_DB_BASE = 0x00000003;
const uint GEO_DB_GROUP = (0x00000004 | GEO_DB_BASE);
const uint GEO_DB_TERRAIN = (0x00000008 | GEO_DB_GROUP);
//------------
const uint GEO_DB_SEQUENCE = (0x00000010 | GEO_DB_GROUP);
const uint GEO_DB_LOD = (0x00000020 | GEO_DB_GROUP);
const uint GEO_DB_SWITCH = (0x00000040 | GEO_DB_GROUP);
const uint GEO_DB_RENDERGROUP = (0x00000080 | GEO_DB_GROUP);
//------------
const uint GEO_DB_GEOMETRY = (0x00000100 | GEO_DB_BASE);
const uint GEO_DB_SURFACE = (0x00000200 | GEO_DB_GEOMETRY);
const uint GEO_DB_COORDINATE_SURFACE = (0x00000400 | GEO_DB_SURFACE);
const uint GEO_DB_POLYGON = (0x00000800 | GEO_DB_COORDINATE_SURFACE);
const uint GEO_DB_BSP = (0x00000400 | GEO_DB_GROUP);
const uint GEO_DB_POLYGON = (0x00000800 | GEO_DB_SURFACE);
//------------
const uint GEO_DB_MESH = (0x00001000 | GEO_DB_POLYGON);
const uint GEO_DB_PARAMETRIC_SURFACE = (0x00002000 | GEO_DB_SURFACE);
const uint GEO_DB_QUADRIC = (0x00004000 | GEO_DB_PARAMETRIC_SURFACE);
const uint GEO_DB_CULL_GROUP = (0x00002000 | GEO_DB_GROUP);
const uint GEO_DB_MULTI_TEX_SHADER = (0x00004000 | GEO_DB_RENDERGROUP);
const uint GEO_DB_PAGE = (0x00008000 | GEO_DB_GROUP);
const uint GEO_DB_TEXT = (0x00040000 | GEO_DB_SURFACE);
//------------
const uint GEO_DB_Z_OFFSET_GROUP = (0x00010000 | GEO_DB_GROUP);
const uint GEO_DB_MULTI_SAMPLE_AA_GROUP = (0x00020000 | GEO_DB_GROUP);
const uint GEO_DB_TEXT = (0x00040000 | GEO_DB_GEOMETRY);
const uint GEO_DB_VERTEX = (0x00080000 | GEO_DB_GEOMETRY);
//------------
const uint GEO_DB_HEADER = (0x00100000 | GEO_DB_BASE);
const uint GEO_DB_TRANSFORM = (0x00200000 | GEO_DB_GROUP);
const uint GEO_DB_LINE_AA_GROUP = (0x00200000 | GEO_DB_GROUP);
const uint GEO_DB_BASE_GROUP = (0x00400000 | GEO_DB_GROUP);
const uint GEO_DB_BASE_SURFACE = (0x00800000 | GEO_DB_SURFACE);
const uint GEO_DB_EXTERNAL = (0x01000000 | GEO_DB_GROUP);
//------------
const uint GEO_DB_EXTERNAL = (0x01000000 | GEO_DB_GROUP);
const uint GEO_DB_BASE_RENDERGROUP = (0x02000000 | GEO_DB_RENDERGROUP);
const uint GEO_DB_INSTANCE = (0x04000000 | GEO_DB_GROUP);
const uint GEO_DB_LIGHTPT = (0x08000000 | GEO_DB_POLYGON);
//------------
const uint GEO_DB_FADE_GROUP = (0x10000000 | GEO_DB_GROUP);
//
//
//
//------------
// older version types for Compatability & convenience
//
const uint GEO_DB_ALL = GEO_DB_BASE;
const uint GEO_DB_ALL_GROUP_TYPES = GEO_DB_GROUP;
const uint GEO_DB_ALL_GROUP_TYPES = GEO_DB_GROUP;
const uint GEO_DB_ALL_GEOMETRY_TYPES = GEO_DB_GEOMETRY;
const uint GEO_DB_ALL_SURFACE_TYPES = GEO_DB_SURFACE;
const uint GEO_DB_ALL_SHAPE_TYPES = GEO_DB_PARAMETRIC_SURFACE;
const uint GEO_DB_ALL_GEOMETRY_TYPES = GEO_DB_GEOMETRY;
@@ -169,10 +195,10 @@ const uint GEO_DB_ALL_GEOMETRY_TYPES = GEO_DB_GEOMETRY;
const uint GEO_PICK_GROUP = 0x00000001;
const uint GEO_PICK_PRIM = 0x00000002;
const uint GEO_PICK_VERTEX = 0x00000004;
const uint GEO_PICK_EDGE = 0x00000008; // Future
const uint GEO_PICK_GRID = 0x00000010;
const uint GEO_PICK_NON_NODE = 0x00000020; // manipulators, user geometry etc.
const uint GEO_PICK_EXTERNAL = 0x00000040;
const uint GEO_PICK_TEXT = 0x00000080;
@@ -187,6 +213,46 @@ const uint GEO_LEFT_AND_RIGHT_MOUSE = 0x00000008;
const uint GEO_MIDDLE_AND_RIGHT_MOUSE = 0x00000010;
///////////////////////////////////////////////////////////////////
// PROPERTY TYPES
///////////////////////////////////////////////////////////////////
// Identifiers for Geo data types - Used in geoProperty & geoPropertyExtension Classes
const unsigned char GEO_DB_DATATYPE_STRING = 1;
const unsigned char GEO_DB_DATATYPE_SHORT = 2;
const unsigned char GEO_DB_DATATYPE_INT = 3;
const unsigned char GEO_DB_DATATYPE_FLOAT = 4;
const unsigned char GEO_DB_DATATYPE_LONG = 5;
const unsigned char GEO_DB_DATATYPE_DOUBLE = 6;
const unsigned char GEO_DB_DATATYPE_BOOL = 28;
///////////////////////////////////////////////////////////////////
// VARIABLE TYPES
///////////////////////////////////////////////////////////////////
const uint GEO_VAR_TYPE_FLOAT = 1;
const uint GEO_VAR_TYPE_INT = 2;
const uint GEO_VAR_TYPE_LONG = 3;
const uint GEO_VAR_TYPE_DOUBLE = 4;
const uint GEO_VAR_TYPE_BOOL = 5;
const uint GEO_VAR_TYPE_2FV = 6;
const uint GEO_VAR_TYPE_3FV = 7;
const uint GEO_VAR_TYPE_4FV = 8;
const uint GEO_VAR_TYPE_STRING = 9;
const uint GEO_VAR_TYPE_2IV = 10;
const uint GEO_VAR_TYPE_3IV = 11;
const uint GEO_VAR_TYPE_4IV = 12;
///////////////////////////////////////////////////////////////////
// TRANSFORM TYPES
///////////////////////////////////////////////////////////////////
const uint GEO_TRANSFORM_TYPE_TRANSLATE = 1;
const uint GEO_TRANSFORM_TYPE_ROTATE = 2;
const uint GEO_TRANSFORM_TYPE_SCALE = 3;
const uint GEO_TRANSFORM_TYPE_MATRIX = 4;
@@ -225,19 +291,27 @@ const int GEO_DB_UP_AXIS_Z = 3;
*/
const uint GEO_DB_SOLID = 0x00000001;
const uint GEO_DB_WIRE = 0x00000002;
const uint GEO_DB_OUTLINED = 0x00000008;
const uint GEO_DB_OUTLINED = (GEO_DB_SOLID | GEO_DB_WIRE);
const uint GEO_DB_WIRE_ON_MOVE = 0x00000004;
const uint GEO_DB_DETEXTURE_ON_MOVE = 0x00000008;
const uint GEO_DB_SHRINK = 0x00000080;
const uint GEO_DB_ZBUFFER = 0x00000100;
const uint GEO_DB_BACKFACE = 0x00000400;
const uint GEO_DB_SELECTIVE_CULLFACE = 0x00000800;
const uint GEO_DB_DRAW_FACE_NORMALS = 0x00001000;
const uint GEO_DB_DRAW_VERTEX_NORMALS = 0x00002000;
const uint GEO_DB_SELECTIVE_BLENDING = 0x00008000;
const uint GEO_DB_TEXTURE = 0x00010000;
const uint GEO_DB_HIGHLIGHT = 0x00020000;
const uint GEO_DB_PICKING = 0x00040000;
const uint GEO_DB_HIGHLIGHT_DASHED = 0x00080000;
const uint GEO_DB_SELECTIVE_SHADING = 0x00100000;
const uint GEO_DB_ILLUMINATED = 0x01000000;
const uint GEO_DB_NORMAL_PER_PRIM = 0x04000000;
const uint GEO_DB_NORMAL_PER_VERTEX = 0x08000000;
@@ -246,10 +320,24 @@ const uint GEO_DB_COLOR_PER_GEODE = 0x10000000;
const uint GEO_DB_COLOR_PER_PRIM = 0x20000000;
const uint GEO_DB_COLOR_PER_VERTEX = 0x40000000;
const uint GEO_DB_SELECTIVE_ZBUFFER = 0x80000000;
///////////////////////////////////////////////////////////////////////////////
/** constants to identify the different Group types
*/
const uint GEO_GROUP_TYPE_CONTAINER = 1;
const uint GEO_GROUP_TYPE_CULL = 2;
const uint GEO_GROUP_TYPE_Z_OFFSET = 3;
const uint GEO_GROUP_TYPE_MULTI_SAMPLE_AA = 4;
const uint GEO_GROUP_TYPE_LINE_AA = 5;
const uint GEO_GROUP_TYPE_FADE = 6;
const uint GEO_GROUP_TYPE_TERRAIN = 7;
///////////////////////////////////////////////////////////////////////////////
/** Constants to control the switch Node behavior
*
@@ -265,14 +353,16 @@ const uint GEO_SWITCH_TYPE_SELECTIVE = 2;
///////////////////////////////////////////////////////////////////////////////
/** Type Tokens for Node & Tool Gui Widgets */
/** Type Tokens for Node & Tool Gui Widgets
*/
const int GUI_FLOAT = 1;
const int GUI_INT = 2;
const int GUI_STRING = 3;
///////////////////////////////////////////////////////////////////////////////
/** geoWidget Typedef - Used by Node & Tool Gui Widgets */
/** geoWidget Typedef - Used by Node & Tool Gui Widgets
*/
typedef void geoWidget;
@@ -314,6 +404,19 @@ const int GEO_POLY_SPHERICAL_MAP = 2;
///////////////////////////////////////////////////////////////////////////////
// Texture Unit Functions - used in Polys, meshes & multi-tex shaders
//
const int GEO_DB_TEXTURE_UNIT_FUNC_AS_DEFINED = 0;
const int GEO_DB_TEXTURE_UNIT_FUNC_MODULATE = 1;
const int GEO_DB_TEXTURE_UNIT_FUNC_DECAL = 2;
const int GEO_DB_TEXTURE_UNIT_FUNC_BLEND = 3;
const int GEO_DB_TEXTURE_UNIT_FUNC_REPLACE = 4;
const int GEO_DB_TEXTURE_UNIT_FUNC_COMBINE = 5;
///////////////////////////////////////////////////////////////////////////////
// STring type constants
//
@@ -370,8 +473,15 @@ const unsigned GEO_DB_TEX_LINEAR_MIPMAP_LINEAR = 0x00000020;
const unsigned GEO_DB_TEX_MODULATE = 0x00000001;
const unsigned GEO_DB_TEX_DECAL = 0x00000002;
const unsigned GEO_DB_TEX_BLEND = 0x00000004;
const unsigned GEO_DB_TEX_REPLACE = 0x00000008;
///////////////////////////////////////////////////////////////////////////////
// Header Vertex Table Usage
const unsigned GEO_DB_USES_PRIVATE_DATA = 0x00000000;
const unsigned GEO_DB_USES_SHARED_TABLE_DATA = 0x00000001;
const unsigned GEO_DB_USES_UNSHARED_TABLE_DATA = 0x00000002;
#endif //_GEO_TYPES_H_

3
src/osgPlugins/geo/osgGeoAction.h
View File

@@ -4,7 +4,6 @@
#define _GEO_ACTIONS_H_
using namespace osg;
using namespace osgDB;
class georecord; // You don't need to know how I read a geo record,
// but objects of this class are passed to some of the parsing routines.
@@ -37,7 +36,7 @@ public:
virtual void setInVar(const double *indvar) {in=indvar;}
virtual void setOutVar(double *outdvar) {out=outdvar;}
virtual void doaction(osg::Node *)=0; // do math operation eg *out=*in or =f(*in).
virtual bool makeBehave(const georecord* /*grec*/, const geoHeaderGeo* /*theHeader*/) { return true;}; // pure virtual
virtual bool makeBehave(const georecord* , const geoHeaderGeo* ) { return true;}; // pure virtual
protected:
const double *in; // address of input variable
double *out; // address of output

56
src/osgPlugins/geo/osgGeoStructs.h
View File

@@ -132,8 +132,41 @@ public:
break;
}
}
//<<<<<<< osgGeoStructs.h
void set(unsigned short id,unsigned int fid) { // to set values
TypeId=DB_UINT;
tokenId=id;
storeSize=SIZEOF_UINT;
numItems=1;
storage=new unsigned char[SIZEOF_UINT];
memcpy(storage,&fid,SIZEOF_UINT);
}
void set(unsigned short id,float *cen,const int nsize) { // to set values
//set(GEO_DB_ROTATE_ACTION_ORIGIN,ct,3);
if (nsize==3) {
TypeId=DB_VEC3F;
tokenId=id;
storeSize=SIZEOF_VEC3F;
} else if (nsize==2) {
TypeId=DB_VEC2F;
tokenId=id;
storeSize=SIZEOF_VEC2F;
} else if (nsize==4) {
TypeId=DB_VEC4F;
tokenId=id;
storeSize=SIZEOF_VEC4F;
}
numItems=1;
storage=new unsigned char[storeSize];
memcpy(storage,cen,storeSize);
}
void readfile(std::ifstream &fin, const unsigned int id); // is part of a record id
void parseExt(std::ifstream &fin) const; // Feb 2003 parse node extension fields
/*=======
void readfile(std::ifstream &fin, const uint id); // is part of a record id
void parseExt(std::ifstream &fin) const; // Feb 2003 parse node extension fields
//>>>>>>> 1.10 */
void writefile(std::ofstream &fout) { // write binary file
if (numItems<32767 && tokenId<256) {
unsigned char tokid=tokenId, type=TypeId;
@@ -153,7 +186,7 @@ public:
if (TypeId==DB_VEC3F) { // already uncompressed
} else {
float *norms=new float[numItems*SIZEOF_VEC3F]; // uncompressed size
for (uint i=0; i<numItems; i++) {
for (unsigned int i=0; i<numItems; i++) {
switch (TypeId) {
case DB_UINT:
norms[3*i]=storage[4*i+1]/255.0f;
@@ -204,7 +237,7 @@ public:
output.indent() << " Field:token " << (int)gf.tokenId << " datatype " << (int)gf.TypeId
<< " num its " << gf.numItems << " size " << gf.storeSize << std::endl;
if (gf.TypeId==DB_CHAR) output.indent();
for (uint i=0; i<gf.numItems; i++) {
for (unsigned int i=0; i<gf.numItems; i++) {
if (gf.storage==NULL) {
output.indent() << "No storage" << std::endl;
} else {
@@ -214,7 +247,7 @@ public:
char *ch;
float *ft;
int *in;
uint *uin;
unsigned int *uin;
short *sh;
unsigned short *ush;
long *ln;
@@ -353,7 +386,7 @@ public:
}
private:
unsigned short tokenId, TypeId; // these are longer than standard field; are extended field length
uint numItems;
unsigned int numItems;
unsigned char *storage; // data relating
uint storeSize; // size*numItems in storage
};
@@ -364,7 +397,7 @@ public:
georecord() {id=0; parent=NULL; instance=NULL; nod=NULL; }
~georecord() {;}
inline const uint getType(void) const {return id;}
typedef std::vector<osg::MatrixTransform *> instancelist; // list if unused instance matrices
typedef std::vector<osg::ref_ptr<osg::MatrixTransform> > instancelist; // list 0f unused instance matrices
void addInstance(osg::MatrixTransform *mtr) { mtrlist.push_back(mtr);}
inline void setNode(osg::Node *n) {
nod=n;
@@ -372,12 +405,12 @@ public:
for (instancelist::iterator itr=mtrlist.begin();
itr!=mtrlist.end();
++itr) {
(*itr)->addChild(nod);
(*itr).get()->addChild(nod.get());
}
mtrlist.clear();
}
}
inline osg::Node *getNode() const { return nod;}
inline osg::Node *getNode() { return nod.get();}
inline void setparent(georecord *p) { parent=p;}
inline class georecord *getparent() const { return parent;}
inline std::vector<georecord *> getchildren(void) const { return children;}
@@ -481,7 +514,8 @@ public:
// case DB_DSK_BILLBOARD: output << "Billboard" << std::endl; break;
case DB_DSK_SEQUENCE: output << "Sequence" << std::endl; break;
case DB_DSK_LOD: output << "LOD" << std::endl; break;
case DB_DSK_GEODE: output << "Geode" << std::endl; break;
// case DB_DSK_GEODE: output << "Geode" << std::endl; break;
case DB_DSK_RENDERGROUP: output << "Rendergroup Geode" << std::endl; break;
case DB_DSK_POLYGON: output << "Polygon" << std::endl; break;
case DB_DSK_MESH: output << "Mesh" << std::endl; break;
case DB_DSK_CUBE: output << "Cube" << std::endl; break;
@@ -515,6 +549,7 @@ public:
case DB_DSK_ROTATE_ACTION: output << "rotate action" << std::endl; break;
case DB_DSK_TRANSLATE_ACTION: output << "translate action" << std::endl; break;
case DB_DSK_SCALE_ACTION: output << "scale action" << std::endl; break;
case DB_DSK_DCS_ACTION: output << "DCS action" << std::endl; break;
case DB_DSK_ARITHMETIC_ACTION: output << "arithmetic action" << std::endl; break;
case DB_DSK_LOGIC_ACTION: output << "logic action" << std::endl; break;
case DB_DSK_CONDITIONAL_ACTION: output << "conditional action" << std::endl; break;
@@ -597,15 +632,16 @@ public:
}
}
unsigned int getNumFields(void) const { return fields.size();}
void addField(geoField &gf){fields.push_back(gf);}
private:
uint id;
unsigned int id;
std::vector<geoField> fields; // each geo record has a variable number of fields
class georecord *parent; // parent of pushed/popped records
class georecord *instance; // this record is an instance of the pointed to record
std::vector< georecord *> tmap; // texture mapping records of this record
std::vector< georecord *> behaviour; // behaviour & action records of this record
std::vector< georecord *> children; // children of this record
osg::Node *nod; // the node that this record has been converted to (useful for instances)
osg::ref_ptr<osg::Node> nod; // the node that this record has been converted to (useful for instances)
instancelist mtrlist; // list of matrices of instances not yet satisfied
};