o Updated Metrowerks files for MacOS. They aren't 100% there yet,
but getting there.
o First cut of osgcluster demo. Very simple beginings. Alas
I only one PC here so I can't test it in its current guise.
o New support for NodeCallbacks, via AppCallback attached to
osg::Node's, and a default osgUtil::AppVisitor which calls them on
each frame.
o Support for traversal masks in osg::NodeVisitor, osg::Node
which allows nodes to be switched on or off via a bit mask.
o Suppport for traversal number (frame number) and reference time
into osg::NodeVisitor to handle syncronization of app and cull
traversals. This also assist clustering as traversal number
master to slaves.
This commit is contained in:
Don BURNS
0
src/Demos/osgcluster/Makedepend
Normal file
0
src/Demos/osgcluster/Makedepend
Normal file
25
src/Demos/osgcluster/Makefile
Normal file
25
src/Demos/osgcluster/Makefile
Normal file
@@ -0,0 +1,25 @@
|
||||
#!smake
|
||||
include ../../../Make/makedefs
|
||||
|
||||
C++FILES = \
|
||||
broadcaster.cpp\
|
||||
receiver.cpp\
|
||||
osgcluster.cpp
|
||||
|
||||
C++FLAGS += -g
|
||||
|
||||
TARGET = ../../../bin/osgcluster
|
||||
|
||||
TARGET_BIN_FILES = osgcluster
|
||||
|
||||
#note, use this library list when using the Performer osgPlugin.
|
||||
#LIBS = ${PFLIBS} -losgGLUT -losgUtil -losgDB -losg $(GLUTLIB) -lGLU -lGL -lm -lXmu -lX11 -lXi
|
||||
|
||||
#note, standard library list.
|
||||
LIBS = -losgGLUT -losgUtil -losgDB -losg $(GLUTLIB) -lGLU -lGL -lm -lXmu -lX11 -lXi
|
||||
|
||||
C++FLAGS += -I../../../include
|
||||
LDFLAGS += -L../../../lib
|
||||
|
||||
include ../../../Make/makerules
|
||||
|
||||
67
src/Demos/osgcluster/README
Normal file
67
src/Demos/osgcluster/README
Normal file
@@ -0,0 +1,67 @@
|
||||
osgcluster demonstates basic clustering of machines across a local area
|
||||
network using UDP packets to send camera position updates from a master viewer
|
||||
to slave viewers.
|
||||
|
||||
Note, the broadcaster and reciever classes have currently been implement
|
||||
for Linux/IRIX, hence osgcluster will only work on these systems. It should
|
||||
also work with little extra work on other Unix based OS's. Support for
|
||||
WinSocket needs to be added to allow support for Windows. Anybody know
|
||||
WinSocket enough to tackle this? If so let us know.
|
||||
|
||||
-
|
||||
|
||||
On the master machine run:
|
||||
|
||||
osgcluster -m -f 30 mymodel.osg
|
||||
|
||||
|
||||
On the slave machines run:
|
||||
|
||||
for left channel:
|
||||
|
||||
osgcluster -s -f 30 -o 30 mymodel.osg
|
||||
|
||||
for right channel:
|
||||
|
||||
osgcluster -s -f 30 -o 30 mymodel.osg
|
||||
|
||||
The options are :
|
||||
|
||||
-m set to viewer to master so that it broadcasts its camera postion.
|
||||
-s set to viewer to slave so that it recivers its camera postion.
|
||||
-n set the socket number to communicate over, defaults to 8100.
|
||||
-o set offset the slave camera from the master position by specified
|
||||
number of degress. positive offset turns camera towards right.
|
||||
-f set the horizontal field of view of the camera.
|
||||
|
||||
Sepetember 2001.
|
||||
Robert Osfield.
|
||||
|
||||
|
||||
|
||||
Note: Using sgv with Peformer (for IRIX and Linux users only)
|
||||
=============================================================
|
||||
|
||||
If you find problems with loading .pfb files its likely that its due to undefined
|
||||
symbols. This isn't a problem with the OSG implementation, but alas the only
|
||||
current solution is to directly link you app with the Performer libraries. The
|
||||
Makefile contains two library list. In Makefile you'll see something like :
|
||||
|
||||
#note, use this library list when using the Performer osgPlugin.
|
||||
#LIBS = ${PFLIBS} -losgGLUT -losgDB -losg -lGLU -lGL -lm -lXmu -lX11 -lXi
|
||||
|
||||
#note, standard library list.
|
||||
LIBS = -losgGLUT -losgDB -losg -lGLU -lGL -lm -lXmu -lX11 -lXi
|
||||
|
||||
Simple comment in the LIBS line with PFLIBS and comment out the standard LIBS,
|
||||
then :
|
||||
|
||||
make clean
|
||||
make
|
||||
|
||||
Hopefully the Performer distribution will eventually work as a dynamic plugin
|
||||
but until that day we're stuck with this 'hack'...
|
||||
|
||||
|
||||
Robert Osfield,
|
||||
March 20001.
|
||||
125
src/Demos/osgcluster/broadcaster.cpp
Normal file
125
src/Demos/osgcluster/broadcaster.cpp
Normal file
@@ -0,0 +1,125 @@
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netdb.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <sys/time.h>
|
||||
#include <net/if.h>
|
||||
#include <netdb.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef __linux
|
||||
#include <linux/sockios.h>
|
||||
#else
|
||||
#include <net/soioctl.h>
|
||||
#endif
|
||||
|
||||
#include "broadcaster.h"
|
||||
|
||||
#define _VERBOSE 1
|
||||
|
||||
Broadcaster::Broadcaster( void )
|
||||
{
|
||||
_port = 0;
|
||||
_initialized = false;
|
||||
_buffer = 0L;
|
||||
_address = 0;
|
||||
}
|
||||
|
||||
Broadcaster::~Broadcaster( void )
|
||||
{
|
||||
close( _so );
|
||||
}
|
||||
|
||||
bool Broadcaster::init( void )
|
||||
{
|
||||
if( _port == 0 )
|
||||
{
|
||||
fprintf( stderr, "Broadcaster::init() - port not defined\n" );
|
||||
return false;
|
||||
}
|
||||
|
||||
if( (_so = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
|
||||
{
|
||||
perror( "socket" );
|
||||
return false;
|
||||
}
|
||||
int on = 1;
|
||||
setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
|
||||
|
||||
saddr.sin_family = AF_INET;
|
||||
saddr.sin_port = htons( _port );
|
||||
if( _address == 0 )
|
||||
{
|
||||
struct ifreq ifr;
|
||||
setsockopt( _so, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
|
||||
#ifdef __linux
|
||||
strcpy( ifr.ifr_name, "eth0" );
|
||||
#else
|
||||
strcpy( ifr.ifr_name, "ef0" );
|
||||
#endif
|
||||
if( (ioctl( _so, SIOCGIFBRDADDR, &ifr)) < 0 )
|
||||
{
|
||||
perror( "Broadcaster::init() Cannot get Broadcast Address" );
|
||||
return false;
|
||||
}
|
||||
saddr.sin_addr.s_addr = (
|
||||
((sockaddr_in *)&ifr.ifr_broadaddr)->sin_addr.s_addr);
|
||||
}
|
||||
else
|
||||
{
|
||||
saddr.sin_addr.s_addr = _address;
|
||||
}
|
||||
#ifdef _VERBOSE
|
||||
unsigned char *ptr = (unsigned char *)&saddr.sin_addr.s_addr;
|
||||
printf( "Broadcast address : %u.%u.%u.%u\n", ptr[0], ptr[1], ptr[2], ptr[3] );
|
||||
#endif
|
||||
|
||||
_initialized = true;
|
||||
return _initialized;
|
||||
}
|
||||
|
||||
void Broadcaster::setHost( const char *hostname )
|
||||
{
|
||||
struct hostent *h;
|
||||
if( (h = gethostbyname( hostname )) == 0L )
|
||||
{
|
||||
fprintf( stderr, "Broadcaster::setHost() - Cannot resolv an address for \"%s\".\n", hostname );
|
||||
_address = 0;
|
||||
}
|
||||
else
|
||||
_address = *(( unsigned long *)h->h_addr);
|
||||
}
|
||||
|
||||
void Broadcaster::setPort( const short port )
|
||||
{
|
||||
_port = port;
|
||||
}
|
||||
|
||||
void Broadcaster::setBuffer( void *buffer, const unsigned int size )
|
||||
{
|
||||
_buffer = buffer;
|
||||
_buffer_size = size;
|
||||
}
|
||||
|
||||
void Broadcaster::sync( void )
|
||||
{
|
||||
_initialized || init();
|
||||
|
||||
if( _buffer == 0L )
|
||||
{
|
||||
fprintf( stderr, "Broadcaster::sync() - No buffer\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int size = sizeof( struct sockaddr_in );
|
||||
sendto( _so, (const void *)_buffer, _buffer_size,
|
||||
0, (struct sockaddr *)&saddr, size );
|
||||
|
||||
}
|
||||
|
||||
45
src/Demos/osgcluster/broadcaster.h
Normal file
45
src/Demos/osgcluster/broadcaster.h
Normal file
@@ -0,0 +1,45 @@
|
||||
#ifndef __BROADCASTER_H
|
||||
#define __BROADCASTER_H
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
// Broadcaster.h
|
||||
//
|
||||
// Class definition for broadcasting a buffer to a LAN
|
||||
//
|
||||
|
||||
#include <netinet/in.h>
|
||||
|
||||
class Broadcaster
|
||||
{
|
||||
public :
|
||||
|
||||
Broadcaster( void );
|
||||
~Broadcaster( void );
|
||||
|
||||
// Set the broadcast port
|
||||
void setPort( const short port );
|
||||
|
||||
// Set the buffer to be broadcast
|
||||
void setBuffer( void *buffer, const unsigned int buffer_size );
|
||||
|
||||
// Set a recipient host. If this is used, the Broadcaster
|
||||
// no longer broadcasts, but rather directs UDP packets at
|
||||
// host.
|
||||
void setHost( const char *hostname );
|
||||
|
||||
// Sync broadcasts the buffer
|
||||
void sync( void );
|
||||
|
||||
private :
|
||||
bool init( void );
|
||||
|
||||
private :
|
||||
int _so;
|
||||
bool _initialized;
|
||||
short _port;
|
||||
void *_buffer;
|
||||
unsigned int _buffer_size;
|
||||
struct sockaddr_in saddr;
|
||||
unsigned long _address;
|
||||
};
|
||||
#endif
|
||||
350
src/Demos/osgcluster/osgcluster.cpp
Normal file
350
src/Demos/osgcluster/osgcluster.cpp
Normal file
@@ -0,0 +1,350 @@
|
||||
#ifdef USE_MEM_CHECK
|
||||
#include <mcheck.h>
|
||||
#endif
|
||||
|
||||
#include <osg/Group>
|
||||
#include <osg/Notify>
|
||||
|
||||
#include <osgDB/Registry>
|
||||
#include <osgDB/ReadFile>
|
||||
|
||||
#include <osgUtil/TrackballManipulator>
|
||||
#include <osgUtil/FlightManipulator>
|
||||
#include <osgUtil/DriveManipulator>
|
||||
|
||||
#include <GL/glut.h>
|
||||
#include <osgGLUT/Viewer>
|
||||
|
||||
#include <osg/Quat>
|
||||
|
||||
#include "receiver.h"
|
||||
#include "broadcaster.h"
|
||||
|
||||
|
||||
class CameraPacket {
|
||||
public:
|
||||
|
||||
CameraPacket():_masterKilled(false) {}
|
||||
|
||||
void setPacket(const osg::Camera& camera,int tnum, double rtime)
|
||||
{
|
||||
_eye = camera.getEyePoint();
|
||||
_center = camera.getCenterPoint();
|
||||
_up = camera.getUpVector();
|
||||
_traversalNumber = tnum;
|
||||
_referenceTime = rtime;
|
||||
}
|
||||
|
||||
void getCamera(osg::Camera& camera,float angle_offset=0.0f)
|
||||
{
|
||||
|
||||
osg::Vec3 lv = _center-_eye;
|
||||
osg::Matrix matrix;
|
||||
matrix.makeIdent();
|
||||
matrix.makeRot(angle_offset,_up.x(),_up.y(),_up.z());
|
||||
lv = lv*matrix;
|
||||
|
||||
camera.setLookAt(_eye,_eye+lv,_up);
|
||||
|
||||
}
|
||||
|
||||
void getSceneViewUpdate(osgUtil::SceneView& sv)
|
||||
{
|
||||
sv.setTraversalNumber(_traversalNumber);
|
||||
sv.setReferenceTime(_referenceTime);
|
||||
}
|
||||
|
||||
void setMasterKilled(const bool flag) { _masterKilled = flag; }
|
||||
const bool getMasterKilled() const { return _masterKilled; }
|
||||
|
||||
bool _masterKilled;
|
||||
osg::Vec3 _eye;
|
||||
osg::Vec3 _center;
|
||||
osg::Vec3 _up;
|
||||
bool _attachMatrix;
|
||||
osg::Matrix _matrix;
|
||||
|
||||
int _traversalNumber;
|
||||
double _referenceTime;
|
||||
|
||||
};
|
||||
|
||||
|
||||
class MySceneView : public osgUtil::SceneView {
|
||||
|
||||
public:
|
||||
|
||||
enum ViewerMode
|
||||
{
|
||||
STAND_ALONE,
|
||||
SLAVE,
|
||||
MASTER
|
||||
};
|
||||
|
||||
MySceneView(ViewerMode viewerMode,int socketNumber,float camera_fov, float camera_offset):
|
||||
_viewerMode(viewerMode),_socketNumber(socketNumber),
|
||||
_camera_fov(camera_fov), _camera_offset(camera_offset)
|
||||
{
|
||||
setDefaults();
|
||||
getCamera()->setAdjustAspectRatioMode(osg::Camera::ADJUST_VERTICAL);
|
||||
getCamera()->setFOV(camera_fov,camera_fov*(600.0f/800.0f),1.0f,1000.0f);
|
||||
|
||||
_bc.setPort(socketNumber);
|
||||
_rc.setPort(socketNumber);
|
||||
};
|
||||
|
||||
~MySceneView()
|
||||
{
|
||||
if (_viewerMode==MASTER)
|
||||
{
|
||||
// need to broadcast my death.
|
||||
CameraPacket cp;
|
||||
cp.setPacket(*getCamera(),getTraversalNumber(),getReferenceTime());
|
||||
cp.setMasterKilled(true);
|
||||
|
||||
_bc.setBuffer(&cp, sizeof( CameraPacket ));
|
||||
_bc.sync();
|
||||
|
||||
cout << "broadcasting death"<<endl;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// override the basic SceneView::app traversal.
|
||||
virtual void app()
|
||||
{
|
||||
osgUtil::SceneView::app();
|
||||
switch (_viewerMode)
|
||||
{
|
||||
case(MASTER):
|
||||
{
|
||||
CameraPacket cp;
|
||||
cp.setPacket(*getCamera(),getTraversalNumber(),getReferenceTime());
|
||||
|
||||
_bc.setBuffer(&cp, sizeof( CameraPacket ));
|
||||
_bc.sync();
|
||||
|
||||
}
|
||||
break;
|
||||
case(SLAVE):
|
||||
{
|
||||
CameraPacket cp;
|
||||
|
||||
_rc.setBuffer(&cp, sizeof( CameraPacket ));
|
||||
_rc.sync();
|
||||
|
||||
cp.getCamera(*getCamera(),_camera_offset);
|
||||
cp.getSceneViewUpdate(*this);
|
||||
|
||||
if (cp.getMasterKilled())
|
||||
{
|
||||
cout << "recieved master killed"<<endl;
|
||||
_viewerMode = STAND_ALONE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
// no need to anything here, just a normal interactive viewer.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
ViewerMode _viewerMode;
|
||||
int _socketNumber;
|
||||
float _camera_fov;
|
||||
float _camera_offset;
|
||||
|
||||
|
||||
Broadcaster _bc;
|
||||
Receiver _rc;
|
||||
|
||||
|
||||
};
|
||||
|
||||
/*
|
||||
* Function to read several files (typically one) as specified on the command
|
||||
* line, and return them in an osg::Node
|
||||
*/
|
||||
osg::Node* getNodeFromFiles(int argc,char **argv,
|
||||
MySceneView::ViewerMode& viewerMode, int& socketNumber,
|
||||
float& camera_fov, float& camera_offset)
|
||||
{
|
||||
osg::Node *rootnode = new osg::Node;
|
||||
|
||||
int i;
|
||||
|
||||
typedef std::vector<osg::Node*> NodeList;
|
||||
NodeList nodeList;
|
||||
for( i = 1; i < argc; i++ )
|
||||
{
|
||||
|
||||
if (argv[i][0]=='-')
|
||||
{
|
||||
switch(argv[i][1])
|
||||
{
|
||||
|
||||
case('m'):
|
||||
viewerMode = MySceneView::MASTER;
|
||||
break;
|
||||
case('s'):
|
||||
viewerMode = MySceneView::SLAVE;
|
||||
break;
|
||||
case('n'):
|
||||
++i;
|
||||
if (i<argc)
|
||||
{
|
||||
socketNumber = atoi(argv[i]);
|
||||
}
|
||||
break;
|
||||
case('f'):
|
||||
++i;
|
||||
if (i<argc)
|
||||
{
|
||||
camera_fov = atoi(argv[i]);
|
||||
}
|
||||
break;
|
||||
case('o'):
|
||||
++i;
|
||||
if (i<argc)
|
||||
{
|
||||
camera_offset = atoi(argv[i]);
|
||||
}
|
||||
break;
|
||||
|
||||
case('l'):
|
||||
++i;
|
||||
if (i<argc)
|
||||
{
|
||||
osgDB::Registry::instance()->loadLibrary(argv[i]);
|
||||
}
|
||||
break;
|
||||
case('e'):
|
||||
++i;
|
||||
if (i<argc)
|
||||
{
|
||||
std::string libName = osgDB::Registry::instance()->createLibraryNameForExt(argv[i]);
|
||||
osgDB::Registry::instance()->loadLibrary(libName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else
|
||||
{
|
||||
osg::Node *node = osgDB::readNodeFile( argv[i] );
|
||||
|
||||
if( node != (osg::Node *)0L )
|
||||
{
|
||||
if (node->getName().empty()) node->setName( argv[i] );
|
||||
nodeList.push_back(node);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (nodeList.size()==0)
|
||||
{
|
||||
osg::notify(osg::WARN) << "No data loaded."<<endl;
|
||||
exit(0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
if (master) osg::notify(osg::NOTICE)<<"set to MASTER, broadcasting on socketNumber "<<socketNumber<<endl;
|
||||
else osg::notify(osg::NOTICE)<<"set to SLAVE, reciving on socketNumber "<<socketNumber<<endl;
|
||||
|
||||
*/
|
||||
|
||||
|
||||
if (nodeList.size()==1)
|
||||
{
|
||||
rootnode = nodeList.front();
|
||||
}
|
||||
else // size >1
|
||||
{
|
||||
osg::Group* group = new osg::Group();
|
||||
for(NodeList::iterator itr=nodeList.begin();
|
||||
itr!=nodeList.end();
|
||||
++itr)
|
||||
{
|
||||
group->addChild(*itr);
|
||||
}
|
||||
|
||||
rootnode = group;
|
||||
}
|
||||
|
||||
return rootnode;
|
||||
}
|
||||
|
||||
|
||||
int main( int argc, char **argv )
|
||||
{
|
||||
|
||||
#ifdef USE_MEM_CHECK
|
||||
mtrace();
|
||||
#endif
|
||||
|
||||
// initialize the GLUT
|
||||
glutInit( &argc, argv );
|
||||
|
||||
if (argc<2)
|
||||
{
|
||||
osg::notify(osg::NOTICE)<<"usage:"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" osgcluster [options] infile1 [infile2 ...]"<<endl;
|
||||
osg::notify(osg::NOTICE)<<endl;
|
||||
osg::notify(osg::NOTICE)<<"options:"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -m - set this viewer to be master"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -s - set this viewer to be a slave"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -o - offset the slave camera from the master position"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" by specified number of degress. A positive offset "<<endl;
|
||||
osg::notify(osg::NOTICE)<<" turns camera towards right."<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -f - set the horizontal field of view of the camera."<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -n SocketNumber - set the socket number, defaults to 8100."<<endl;
|
||||
osg::notify(osg::NOTICE)<<" to broadcast on if a master"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" to reciever on if a slave"<<endl;
|
||||
osg::notify(osg::NOTICE)<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -l libraryName - load plugin of name libraryName"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" i.e. -l osgdb_pfb"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" Useful for loading reader/writers which can load"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" other file formats in addition to its extension."<<endl;
|
||||
osg::notify(osg::NOTICE)<<" -e extensionName - load reader/wrter plugin for file extension"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" i.e. -e pfb"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" Useful short hand for specifying full library name as"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" done with -l above, as it automatically expands to the"<<endl;
|
||||
osg::notify(osg::NOTICE)<<" full library name appropriate for each platform."<<endl;
|
||||
osg::notify(osg::NOTICE)<<endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
osg::Timer timer;
|
||||
osg::Timer_t before_load = timer.tick();
|
||||
|
||||
MySceneView::ViewerMode viewerMode = MySceneView::STAND_ALONE;
|
||||
int socketNumber=8100;
|
||||
float camera_fov=45.0f;
|
||||
float camera_offset=45.0f;
|
||||
|
||||
osg::Node* rootnode = getNodeFromFiles( argc, argv, viewerMode, socketNumber,camera_fov,camera_offset);
|
||||
|
||||
osg::Timer_t after_load = timer.tick();
|
||||
cout << "Time for load = "<<timer.delta_s(before_load,after_load)<<" seconds"<<endl;
|
||||
|
||||
osg::ref_ptr<MySceneView> mySceneView = new MySceneView(viewerMode,socketNumber,camera_fov,camera_offset);
|
||||
|
||||
mySceneView->setSceneData(rootnode);
|
||||
|
||||
// initialize the viewer.
|
||||
osgGLUT::Viewer viewer;
|
||||
viewer.addViewport( mySceneView.get() );
|
||||
|
||||
// register trackball, flight and drive.
|
||||
viewer.registerCameraManipulator(new osgUtil::TrackballManipulator);
|
||||
viewer.registerCameraManipulator(new osgUtil::FlightManipulator);
|
||||
viewer.registerCameraManipulator(new osgUtil::DriveManipulator);
|
||||
|
||||
viewer.open();
|
||||
viewer.run();
|
||||
|
||||
return 0;
|
||||
}
|
||||
104
src/Demos/osgcluster/receiver.cpp
Normal file
104
src/Demos/osgcluster/receiver.cpp
Normal file
@@ -0,0 +1,104 @@
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netdb.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
|
||||
#include "receiver.h"
|
||||
|
||||
Receiver::Receiver( void )
|
||||
{
|
||||
_port = 0;
|
||||
_initialized = false;
|
||||
_buffer = 0L;
|
||||
}
|
||||
|
||||
Receiver::~Receiver( void )
|
||||
{
|
||||
close( _so );
|
||||
}
|
||||
|
||||
bool Receiver::init( void )
|
||||
{
|
||||
if( _port == 0 )
|
||||
{
|
||||
fprintf( stderr, "Receiver::init() - port not defined\n" );
|
||||
return false;
|
||||
}
|
||||
|
||||
if( (_so = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
|
||||
{
|
||||
perror( "socket" );
|
||||
return false;
|
||||
}
|
||||
int on = 1;
|
||||
setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
|
||||
|
||||
struct sockaddr_in saddr;
|
||||
saddr.sin_family = AF_INET;
|
||||
saddr.sin_port = htons( _port );
|
||||
saddr.sin_addr.s_addr = 0;
|
||||
|
||||
if( bind( _so, (struct sockaddr *)&saddr, sizeof( saddr )) < 0 )
|
||||
{
|
||||
perror( "bind" );
|
||||
return false;
|
||||
}
|
||||
|
||||
_initialized = true;
|
||||
return _initialized;
|
||||
}
|
||||
|
||||
|
||||
void Receiver::setPort( const short port )
|
||||
{
|
||||
_port = port;
|
||||
}
|
||||
|
||||
void Receiver::setBuffer( void *buffer, const unsigned int size )
|
||||
{
|
||||
_buffer = buffer;
|
||||
_buffer_size = size;
|
||||
}
|
||||
|
||||
void Receiver::sync( void )
|
||||
{
|
||||
_initialized || init();
|
||||
|
||||
if( _buffer == 0L )
|
||||
{
|
||||
fprintf( stderr, "Receiver::sync() - No buffer\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef __linux
|
||||
socklen_t
|
||||
#else
|
||||
int
|
||||
#endif
|
||||
size = sizeof( struct sockaddr_in );
|
||||
|
||||
fd_set fdset;
|
||||
FD_ZERO( &fdset );
|
||||
FD_SET( _so, &fdset );
|
||||
|
||||
struct timeval tv;
|
||||
tv.tv_sec = 0;
|
||||
tv.tv_usec = 0;
|
||||
|
||||
recvfrom( _so, (caddr_t)_buffer, _buffer_size, 0, 0, &size );
|
||||
while( select( _so+1, &fdset, 0L, 0L, &tv ) )
|
||||
{
|
||||
if( FD_ISSET( _so, &fdset ) )
|
||||
{
|
||||
recvfrom( _so, (caddr_t)_buffer, _buffer_size, 0, 0, &size );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
39
src/Demos/osgcluster/receiver.h
Normal file
39
src/Demos/osgcluster/receiver.h
Normal file
@@ -0,0 +1,39 @@
|
||||
#ifndef __RECEIVER_H
|
||||
#define __RECEIVER_H
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
// Receiver.h
|
||||
//
|
||||
// Class definition for the recipient of a broadcasted message
|
||||
//
|
||||
|
||||
|
||||
class Receiver
|
||||
{
|
||||
public :
|
||||
|
||||
Receiver();
|
||||
~Receiver();
|
||||
|
||||
// setBuffer defines the buffer into which the broadcasted
|
||||
// message will be received.
|
||||
void setBuffer( void *buffer, const unsigned int size );
|
||||
|
||||
// Define what port to listen and bind to
|
||||
void setPort( const short port );
|
||||
|
||||
// Sync does a blocking wait to recieve next message
|
||||
void sync( void );
|
||||
|
||||
private :
|
||||
bool init( void );
|
||||
|
||||
private :
|
||||
int _so;
|
||||
bool _initialized;
|
||||
short _port;
|
||||
void *_buffer;
|
||||
unsigned int _buffer_size;
|
||||
};
|
||||
#endif
|
||||
558
src/osg/Matrix.cpp.new
Normal file
558
src/osg/Matrix.cpp.new
Normal file
@@ -0,0 +1,558 @@
|
||||
|
||||
#include <osg/Matrix>
|
||||
#include <osg/Quat>
|
||||
#include <osg/Notify>
|
||||
|
||||
#include <cstdlib> //memcpy
|
||||
#include <cmath> //acos
|
||||
|
||||
using namespace osg;
|
||||
|
||||
#define WARN_DEPRECATED
|
||||
|
||||
Matrix::Matrix() : Object(), fully_realized(false) {}
|
||||
|
||||
Matrix::Matrix( const Matrix& other ) : Object() {
|
||||
set( (float const * const) other._mat );
|
||||
}
|
||||
|
||||
Matrix::Matrix( float const * const def ) {
|
||||
set( def );
|
||||
}
|
||||
|
||||
Matrix::Matrix(
|
||||
float a00, float a01, float a02, float a03,
|
||||
float a10, float a11, float a12, float a13,
|
||||
float a20, float a21, float a22, float a23,
|
||||
float a30, float a31, float a32, float a33)
|
||||
{
|
||||
_mat[0][0] = a00;
|
||||
_mat[0][1] = a01;
|
||||
_mat[0][2] = a02;
|
||||
_mat[0][3] = a03;
|
||||
|
||||
_mat[1][0] = a10;
|
||||
_mat[1][1] = a11;
|
||||
_mat[1][2] = a12;
|
||||
_mat[1][3] = a13;
|
||||
|
||||
_mat[2][0] = a20;
|
||||
_mat[2][1] = a21;
|
||||
_mat[2][2] = a22;
|
||||
_mat[2][3] = a23;
|
||||
|
||||
_mat[3][0] = a30;
|
||||
_mat[3][1] = a31;
|
||||
_mat[3][2] = a32;
|
||||
_mat[3][3] = a33;
|
||||
}
|
||||
|
||||
Matrix& Matrix::operator = (const Matrix& other ) {
|
||||
if( &other == this ) return *this;
|
||||
set((const float*)other._mat);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void Matrix::set( float const * const def ) {
|
||||
memcpy( _mat, def, sizeof(_mat) );
|
||||
fully_realized = true;
|
||||
}
|
||||
|
||||
void Matrix::set(
|
||||
float a00, float a01, float a02, float a03,
|
||||
float a10, float a11, float a12, float a13,
|
||||
float a20, float a21, float a22, float a23,
|
||||
float a30, float a31, float a32, float a33)
|
||||
{
|
||||
_mat[0][0] = a00;
|
||||
_mat[0][1] = a01;
|
||||
_mat[0][2] = a02;
|
||||
_mat[0][3] = a03;
|
||||
|
||||
_mat[1][0] = a10;
|
||||
_mat[1][1] = a11;
|
||||
_mat[1][2] = a12;
|
||||
_mat[1][3] = a13;
|
||||
|
||||
_mat[2][0] = a20;
|
||||
_mat[2][1] = a21;
|
||||
_mat[2][2] = a22;
|
||||
_mat[2][3] = a23;
|
||||
|
||||
_mat[3][0] = a30;
|
||||
_mat[3][1] = a31;
|
||||
_mat[3][2] = a32;
|
||||
_mat[3][3] = a33;
|
||||
}
|
||||
|
||||
#define SET_ROW(row, v1, v2, v3, v4 ) \
|
||||
_mat[0][(row)] = (v1); \
|
||||
_mat[1][(row)] = (v2); \
|
||||
_mat[2][(row)] = (v3); \
|
||||
_mat[3][(row)] = (v4);
|
||||
|
||||
|
||||
void Matrix::makeIdent() {
|
||||
SET_ROW(0, 1, 0, 0, 0 )
|
||||
SET_ROW(1, 0, 1, 0, 0 )
|
||||
SET_ROW(2, 0, 0, 1, 0 )
|
||||
SET_ROW(3, 0, 0, 0, 1 )
|
||||
|
||||
fully_realized = true;
|
||||
}
|
||||
|
||||
void Matrix::makeScale( const Vec3& v ) {
|
||||
makeScale(v[0], v[1], v[2] );
|
||||
}
|
||||
|
||||
void Matrix::makeScale( float x, float y, float z ) {
|
||||
SET_ROW(0, x, 0, 0, 0 )
|
||||
SET_ROW(1, 0, y, 0, 0 )
|
||||
SET_ROW(2, 0, 0, z, 0 )
|
||||
SET_ROW(3, 0, 0, 0, 1 )
|
||||
|
||||
fully_realized = true;
|
||||
}
|
||||
|
||||
void Matrix::makeTrans( const Vec3& v ) {
|
||||
makeTrans( v[0], v[1], v[2] );
|
||||
}
|
||||
|
||||
void Matrix::makeTrans( float x, float y, float z ) {
|
||||
SET_ROW(0, 1, 0, 0, x )
|
||||
SET_ROW(1, 0, 1, 0, y )
|
||||
SET_ROW(2, 0, 0, 1, z )
|
||||
SET_ROW(3, 0, 0, 0, 1 )
|
||||
|
||||
fully_realized = true;
|
||||
}
|
||||
|
||||
void Matrix::makeRot( const Vec3& from, const Vec3& to ) {
|
||||
double d = from * to; // dot product == cos( angle between from & to )
|
||||
if( d < 0.9999 ) {
|
||||
double angle = acos(d);
|
||||
Vec3 axis = to ^ from; //we know ((to) x (from)) is perpendicular to both
|
||||
makeRot( angle, axis );
|
||||
}
|
||||
else
|
||||
makeIdent();
|
||||
}
|
||||
|
||||
void Matrix::makeRot( float angle, const Vec3& axis ) {
|
||||
makeRot( angle, axis.x(), axis.y(), axis.z() );
|
||||
}
|
||||
|
||||
void Matrix::makeRot( float angle, float x, float y, float z ) {
|
||||
float d = sqrt( x*x + y*y + z*z );
|
||||
if( d == 0 )
|
||||
return;
|
||||
|
||||
float sin_half = sin( angle/2 );
|
||||
float cos_half = cos( angle/2 );
|
||||
|
||||
Quat q( sin_half * (x/d),
|
||||
sin_half * (y/d),
|
||||
sin_half * (z/d),
|
||||
cos_half );
|
||||
makeRot( q );
|
||||
}
|
||||
|
||||
void Matrix::makeRot( const Quat& q ) {
|
||||
// taken from Shoemake/ACM SIGGRAPH 89
|
||||
Vec4 v = q.asVec4();
|
||||
|
||||
double xs = 2 * v.x(); //assume q is already normalized? assert?
|
||||
double ys = 2 * v.y(); // if not, xs = 2 * v.x() / d, ys = 2 * v.y() / d
|
||||
double zs = 2 * v.z(); // and zs = 2 * v.z() /d where d = v.length2()
|
||||
|
||||
double xx = xs * v.x();
|
||||
double xy = ys * v.x();
|
||||
double xz = zs * v.x();
|
||||
double yy = ys * v.y();
|
||||
double yz = zs * v.y();
|
||||
double zz = zs * v.z();
|
||||
double wx = xs * v.w();
|
||||
double wy = ys * v.w();
|
||||
double wz = zs * v.w();
|
||||
|
||||
SET_ROW(0, 1.0-(yy+zz), xy - wz, xz + wz, 0.0 )
|
||||
SET_ROW(1, xy + wz, 1.0-(xx+zz),yz - wx, 0.0 )
|
||||
SET_ROW(2, xz - wy, yz + wx, 1.0-(xx+yy),0.0 )
|
||||
SET_ROW(3, 0.0, 0.0, 0.0, 1.0 )
|
||||
|
||||
fully_realized = true;
|
||||
}
|
||||
|
||||
void Matrix::makeRot( float yaw, float pitch, float roll) {
|
||||
// lifted straight from SOLID library v1.01 Quaternion.h
|
||||
// available from http://www.win.tue.nl/~gino/solid/
|
||||
// and also distributed under the LGPL
|
||||
float cosYaw = cos(yaw / 2);
|
||||
float sinYaw = sin(yaw / 2);
|
||||
float cosPitch = cos(pitch / 2);
|
||||
float sinPitch = sin(pitch / 2);
|
||||
float cosRoll = cos(roll / 2);
|
||||
float sinRoll = sin(roll / 2);
|
||||
Quat q(sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,
|
||||
cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,
|
||||
cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,
|
||||
cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);
|
||||
makeRot( q );
|
||||
}
|
||||
|
||||
#define INNER_PRODUCT(a,b,c,r) \
|
||||
((a)._mat[0][r] * (b)._mat[c][0]) \
|
||||
+((a)._mat[1][r] * (b)._mat[c][1]) \
|
||||
+((a)._mat[2][r] * (b)._mat[c][2]) \
|
||||
+((a)._mat[3][r] * (b)._mat[c][3])
|
||||
|
||||
void Matrix::mult( const Matrix& lhs, const Matrix& rhs ) {
|
||||
// PRECONDITION: We assume neither &lhs nor &rhs == this
|
||||
// if it did, use preMult or postMult instead
|
||||
_mat[0][0] = INNER_PRODUCT(lhs, rhs, 0, 0);
|
||||
_mat[0][1] = INNER_PRODUCT(lhs, rhs, 0, 1);
|
||||
_mat[0][2] = INNER_PRODUCT(lhs, rhs, 0, 2);
|
||||
_mat[0][3] = INNER_PRODUCT(lhs, rhs, 0, 3);
|
||||
_mat[1][0] = INNER_PRODUCT(lhs, rhs, 1, 0);
|
||||
_mat[1][1] = INNER_PRODUCT(lhs, rhs, 1, 1);
|
||||
_mat[1][2] = INNER_PRODUCT(lhs, rhs, 1, 2);
|
||||
_mat[1][3] = INNER_PRODUCT(lhs, rhs, 1, 3);
|
||||
_mat[2][0] = INNER_PRODUCT(lhs, rhs, 2, 0);
|
||||
_mat[2][1] = INNER_PRODUCT(lhs, rhs, 2, 1);
|
||||
_mat[2][2] = INNER_PRODUCT(lhs, rhs, 2, 2);
|
||||
_mat[2][3] = INNER_PRODUCT(lhs, rhs, 2, 3);
|
||||
_mat[3][0] = INNER_PRODUCT(lhs, rhs, 3, 0);
|
||||
_mat[3][1] = INNER_PRODUCT(lhs, rhs, 3, 1);
|
||||
_mat[3][2] = INNER_PRODUCT(lhs, rhs, 3, 2);
|
||||
_mat[3][3] = INNER_PRODUCT(lhs, rhs, 3, 3);
|
||||
fully_realized = true;
|
||||
}
|
||||
|
||||
void Matrix::preMult( const Matrix& other ) {
|
||||
float t1,t2,t3,t4;
|
||||
if( !fully_realized ) {
|
||||
//act as if this were an identity Matrix
|
||||
set((const float*)other._mat);
|
||||
return;
|
||||
}
|
||||
for(int col=0; col<4; ++col) {
|
||||
t1 = INNER_PRODUCT( other, *this, col, 0 );
|
||||
t2 = INNER_PRODUCT( other, *this, col, 1 );
|
||||
t3 = INNER_PRODUCT( other, *this, col, 2 );
|
||||
t4 = INNER_PRODUCT( other, *this, col, 3 );
|
||||
_mat[col][0] = t1;
|
||||
_mat[col][1] = t2;
|
||||
_mat[col][2] = t3;
|
||||
_mat[col][3] = t4;
|
||||
}
|
||||
}
|
||||
|
||||
void Matrix::postMult( const Matrix& other ) {
|
||||
float t[4];
|
||||
if( !fully_realized ) {
|
||||
//act as if this were an identity Matrix
|
||||
set((const float*)other._mat);
|
||||
return;
|
||||
}
|
||||
for(int row=0; row<4; ++row) {
|
||||
t[0] = INNER_PRODUCT( *this, other, 0, row );
|
||||
t[1] = INNER_PRODUCT( *this, other, 1, row );
|
||||
t[2] = INNER_PRODUCT( *this, other, 2, row );
|
||||
t[3] = INNER_PRODUCT( *this, other, 3, row );
|
||||
SET_ROW(row, t[0], t[1], t[2], t[3] )
|
||||
}
|
||||
}
|
||||
|
||||
#undef SET_ROW
|
||||
#undef INNER_PRODUCT
|
||||
|
||||
bool Matrix::invert( const Matrix& _m ) {
|
||||
|
||||
if (&_m==this)
|
||||
{
|
||||
Matrix tm(_m);
|
||||
return invert(tm);
|
||||
}
|
||||
if ( _m._mat[0][3] == 0.0
|
||||
&& _m._mat[1][3] == 0.0
|
||||
&& _m._mat[2][3] == 0.0
|
||||
&& _m._mat[3][3] == 1.0 )
|
||||
{
|
||||
return invertAffine( _m );
|
||||
}
|
||||
|
||||
// code lifted from VR Juggler.
|
||||
// not cleanly added, but seems to work. RO.
|
||||
const float* a = reinterpret_cast<const float*>(_m._mat);
|
||||
float* b = reinterpret_cast<float*>(_mat);
|
||||
|
||||
int n = 4;
|
||||
int i, j, k;
|
||||
int r[ 4], c[ 4], row[ 4], col[ 4];
|
||||
float m[ 4][ 4*2], pivot, max_m, tmp_m, fac;
|
||||
|
||||
/* Initialization */
|
||||
for ( i = 0; i < n; i ++ )
|
||||
{
|
||||
r[ i] = c[ i] = 0;
|
||||
row[ i] = col[ i] = 0;
|
||||
}
|
||||
|
||||
/* Set working matrix */
|
||||
for ( i = 0; i < n; i++ )
|
||||
{
|
||||
for ( j = 0; j < n; j++ )
|
||||
{
|
||||
m[ i][ j] = a[ i * n + j];
|
||||
m[ i][ j + n] = ( i == j ) ? 1.0 : 0.0 ;
|
||||
}
|
||||
}
|
||||
|
||||
/* Begin of loop */
|
||||
for ( k = 0; k < n; k++ )
|
||||
{
|
||||
/* Choosing the pivot */
|
||||
for ( i = 0, max_m = 0; i < n; i++ )
|
||||
{
|
||||
if ( row[ i] ) continue;
|
||||
for ( j = 0; j < n; j++ )
|
||||
{
|
||||
if ( col[ j] ) continue;
|
||||
tmp_m = fabs( m[ i][j]);
|
||||
if ( tmp_m > max_m)
|
||||
{
|
||||
max_m = tmp_m;
|
||||
r[ k] = i;
|
||||
c[ k] = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
row[ r[k] ] = col[ c[k] ] = 1;
|
||||
pivot = m[ r[ k] ][ c[ k] ];
|
||||
|
||||
if ( fabs( pivot) <= 1e-20)
|
||||
{
|
||||
notify(WARN) << "*** pivot = %f in mat_inv. ***\n";
|
||||
//exit( 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Normalization */
|
||||
for ( j = 0; j < 2*n; j++ )
|
||||
{
|
||||
if ( j == c[ k] )
|
||||
m[ r[ k]][ j] = 1.0;
|
||||
else
|
||||
m[ r[ k]][ j] /=pivot;
|
||||
}
|
||||
|
||||
/* Reduction */
|
||||
for ( i = 0; i < n; i++ )
|
||||
{
|
||||
if ( i == r[ k] )
|
||||
continue;
|
||||
|
||||
for ( j=0, fac = m[ i][ c[k]];j < 2*n; j++ )
|
||||
{
|
||||
if ( j == c[ k] )
|
||||
m[ i][ j] =0.0;
|
||||
else
|
||||
m[ i][ j] -=fac * m[ r[k]][ j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Assign invers to a matrix */
|
||||
for ( i = 0; i < n; i++ )
|
||||
for ( j = 0; j < n; j++ )
|
||||
row[ i] = ( c[ j] == i ) ? r[j] : row[ i];
|
||||
|
||||
for ( i = 0; i < n; i++ )
|
||||
for ( j = 0; j < n; j++ )
|
||||
b[ i * n + j] = m[ row[ i]][j + n];
|
||||
|
||||
return true; // It worked
|
||||
}
|
||||
|
||||
const double PRECISION_LIMIT = 1.0e-15;
|
||||
|
||||
bool Matrix::invertAffine( const Matrix& _m ) {
|
||||
// adapted from Graphics Gems II.
|
||||
//
|
||||
// This method treats the matrix as a block matrix and calculates
|
||||
// the inverse of one submatrix, improving performance over something
|
||||
// that inverts any non-singular matrix:
|
||||
// -1
|
||||
// -1 [ A 0 ] -1 [ A 0 ]
|
||||
// M = [ ] = [ -1 ]
|
||||
// [ C 1 ] [-CA 1 ]
|
||||
//
|
||||
// returns true if _m is nonsingular, and (*this) contains its inverse
|
||||
// otherwise returns false. (*this unchanged)
|
||||
|
||||
// assert (this.isAffine()) ?
|
||||
double det_1, pos, neg, temp;
|
||||
|
||||
pos = neg = 0.0;
|
||||
|
||||
#define ACCUMULATE \
|
||||
{ \
|
||||
if(temp < 0.0) pos += temp; \
|
||||
else neg += temp; \
|
||||
}
|
||||
|
||||
temp = _m._mat[0][0] * _m._mat[1][1] * _m._mat[2][2]; ACCUMULATE;
|
||||
temp = _m._mat[0][1] * _m._mat[1][2] * _m._mat[2][0]; ACCUMULATE;
|
||||
temp = _m._mat[0][2] * _m._mat[1][0] * _m._mat[2][1]; ACCUMULATE;
|
||||
|
||||
temp = - _m._mat[0][2] * _m._mat[1][1] * _m._mat[2][0]; ACCUMULATE;
|
||||
temp = - _m._mat[0][1] * _m._mat[1][0] * _m._mat[2][2]; ACCUMULATE;
|
||||
temp = - _m._mat[0][0] * _m._mat[1][2] * _m._mat[2][1]; ACCUMULATE;
|
||||
|
||||
det_1 = pos + neg;
|
||||
|
||||
if( (det_1 == 0.0) || (abs(det_1/(pos-neg)) < PRECISION_LIMIT )) {
|
||||
// _m has no inverse
|
||||
notify(WARN) << "Matrix::invert(): Matrix has no inverse." << endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
// inverse is adj(A)/det(A)
|
||||
det_1 = 1.0 / det_1;
|
||||
|
||||
_mat[0][0] = (_m._mat[1][1] * _m._mat[2][2] - _m._mat[1][2] * _m._mat[2][1]) * det_1;
|
||||
_mat[1][0] = (_m._mat[1][0] * _m._mat[2][2] - _m._mat[1][2] * _m._mat[2][0]) * det_1;
|
||||
_mat[2][0] = (_m._mat[1][0] * _m._mat[2][1] - _m._mat[1][1] * _m._mat[2][0]) * det_1;
|
||||
_mat[0][1] = (_m._mat[0][1] * _m._mat[2][2] - _m._mat[0][2] * _m._mat[2][1]) * det_1;
|
||||
_mat[1][1] = (_m._mat[0][0] * _m._mat[2][2] - _m._mat[0][2] * _m._mat[2][0]) * det_1;
|
||||
_mat[2][1] = (_m._mat[0][0] * _m._mat[2][1] - _m._mat[0][1] * _m._mat[2][0]) * det_1;
|
||||
_mat[0][2] = (_m._mat[0][1] * _m._mat[1][2] - _m._mat[0][2] * _m._mat[1][1]) * det_1;
|
||||
_mat[1][2] = (_m._mat[0][0] * _m._mat[1][2] - _m._mat[0][2] * _m._mat[1][0]) * det_1;
|
||||
_mat[2][2] = (_m._mat[0][0] * _m._mat[1][1] - _m._mat[0][1] * _m._mat[1][0]) * det_1;
|
||||
|
||||
// calculate -C * inv(A)
|
||||
_mat[3][0] = -(_m._mat[3][0] * _mat[0][0] + _m._mat[3][1] * _mat[1][0] + _m._mat[3][2] * _mat[2][0] );
|
||||
_mat[3][1] = -(_m._mat[3][0] * _mat[0][1] + _m._mat[3][1] * _mat[1][1] + _m._mat[3][2] * _mat[2][1] );
|
||||
_mat[3][2] = -(_m._mat[3][0] * _mat[0][2] + _m._mat[3][1] * _mat[1][2] + _m._mat[3][2] * _mat[2][2] );
|
||||
|
||||
_mat[0][3] = 0.0;
|
||||
_mat[1][3] = 0.0;
|
||||
_mat[2][3] = 0.0;
|
||||
_mat[3][3] = 1.0;
|
||||
|
||||
fully_realized = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
//static utility methods
|
||||
Matrix Matrix::scale(float sx, float sy, float sz) {
|
||||
Matrix m;
|
||||
m.makeScale(sx,sy,sz);
|
||||
return m;
|
||||
}
|
||||
Matrix Matrix::scale(const Vec3& v ) {
|
||||
return scale(v.x(), v.y(), v.z() );
|
||||
}
|
||||
Matrix Matrix::trans(float tx, float ty, float tz) {
|
||||
Matrix m;
|
||||
m.makeTrans(tx,ty,tz);
|
||||
return m;
|
||||
}
|
||||
Matrix Matrix::trans(const Vec3& v ) {
|
||||
return trans(v.x(), v.y(), v.z() );
|
||||
}
|
||||
Matrix Matrix::rotate( const Quat& q ) {
|
||||
Matrix m;
|
||||
m.makeRot( q );
|
||||
return m;
|
||||
}
|
||||
Matrix Matrix::rotate(float angle, float x, float y, float z ) {
|
||||
Matrix m;
|
||||
m.makeRot(angle,x,y,z);
|
||||
return m;
|
||||
}
|
||||
Matrix Matrix::rotate(const Vec3& from, const Vec3& to ) {
|
||||
Matrix m;
|
||||
m.makeRot(from,to);
|
||||
return m;
|
||||
}
|
||||
|
||||
//Deprecated methods
|
||||
void Matrix::copy( const Matrix& other) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::copy is deprecated. Use = instead.";
|
||||
#endif
|
||||
(*this) = other;
|
||||
}
|
||||
void Matrix::preScale( float sx, float sy, float sz, const Matrix& m ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::preScale is deprecated. Use result = (Matrix::scale * m) instead.";
|
||||
(*this) = ( scale(sx,sy,sz) * m );
|
||||
#endif
|
||||
}
|
||||
void Matrix::postScale( const Matrix& m, float sx, float sy, float sz ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::postScale is deprecated. Use result = (m * Matrix::scale()) instead.";
|
||||
(*this) = ( m * scale(sx,sy,sz) );
|
||||
#endif
|
||||
}
|
||||
void Matrix::preScale( float sx, float sy, float sz ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::preScale is deprecated. Use M.preMult( Matrix::scale ) instead.";
|
||||
preMult( scale(sx,sy,sz) );
|
||||
#endif
|
||||
}
|
||||
void Matrix::postScale( float sx, float sy, float sz ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::postScale is deprecated. Use M.postMult( Matrix::scale ) instead.";
|
||||
postMult( scale(sx,sy,sz) );
|
||||
#endif
|
||||
}
|
||||
void Matrix::preTrans( float tx, float ty, float tz, const Matrix& m ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::preTrans is deprecated. Use result = Matrix::trans * m instead.";
|
||||
(*this) = trans(tx,ty,tz) * m;
|
||||
#endif
|
||||
}
|
||||
void Matrix::postTrans( const Matrix& m, float tx, float ty, float tz ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::postTrans is deprecated. Use result = m * Matrix::trans instead.";
|
||||
(*this) = m * trans(tx,ty,tz);
|
||||
#endif
|
||||
}
|
||||
void Matrix::preTrans( float sx, float sy, float sz ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::preTrans is deprecated. Use result = Matrix::trans * m instead.";
|
||||
preMult( trans(sx,sy,sz) );
|
||||
#endif
|
||||
}
|
||||
void Matrix::postTrans( float sx, float sy, float sz ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::postTrans is deprecated. Use result = m * Matrix::trans instead.";
|
||||
postMult( trans(sx,sy,sz) );
|
||||
#endif
|
||||
}
|
||||
void Matrix::preRot( float deg, float x, float y, float z, const Matrix& m ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::preRot is deprecated. Use result = Matrix::rot * m instead.";
|
||||
(*this) = rotate(deg,x,y,z) * m;
|
||||
#endif
|
||||
}
|
||||
void Matrix::postRot( const Matrix& m, float deg, float x, float y, float z ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::postRot is deprecated. Use result = m * Matrix::rotate instead.";
|
||||
(*this) = m * rotate(deg,x,y,z);
|
||||
#endif
|
||||
}
|
||||
void Matrix::preRot( float deg, float x, float y, float z ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::preRot is deprecated. Use m.preMult( Matrix::rotate ) instead.";
|
||||
preMult( rotate(deg,x,y,z) );
|
||||
#endif
|
||||
}
|
||||
void Matrix::postRot( float deg, float x, float y, float z ) {
|
||||
#ifdef WARN_DEPRECATED
|
||||
notify(NOTICE) << "Matrix::postRot is deprecated. Use m.postMult( Matrix::rotate ) instead.";
|
||||
postMult( rotate(deg,x,y,z) );
|
||||
#endif
|
||||
}
|
||||
568
src/osg/Matrix.cpp.old
Normal file
568
src/osg/Matrix.cpp.old
Normal file
@@ -0,0 +1,568 @@
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <osg/Types>
|
||||
#include <osg/Matrix>
|
||||
#include <osg/Notify>
|
||||
#include <osg/ref_ptr>
|
||||
|
||||
#define square(x) ((x)*(x))
|
||||
#define DEG2RAD(x) ((x)*M_PI/180.0)
|
||||
#define RAD2DEG(x) ((x)*180.0/M_PI)
|
||||
|
||||
using namespace osg;
|
||||
|
||||
typedef struct quaternion_
|
||||
{
|
||||
double x ;
|
||||
double y ;
|
||||
double z ;
|
||||
double w ;
|
||||
} quaternion ;
|
||||
|
||||
/* C = a(row).b(row) */
|
||||
|
||||
#define matrix_inner_product( a, b, row, col, C ) \
|
||||
{ \
|
||||
(C)[row][col] = (a)[row][0] * (b)[0][col] + \
|
||||
(a)[row][1] * (b)[1][col] + \
|
||||
(a)[row][2] * (b)[2][col] + \
|
||||
(a)[row][3] * (b)[3][col]; \
|
||||
}
|
||||
|
||||
/* C = a.b */
|
||||
|
||||
#define matrix_mult( a, b, C ) \
|
||||
{ \
|
||||
matrix_inner_product( a, b, 0, 0, C ); \
|
||||
matrix_inner_product( a, b, 0, 1, C ); \
|
||||
matrix_inner_product( a, b, 0, 2, C ); \
|
||||
matrix_inner_product( a, b, 0, 3, C ); \
|
||||
matrix_inner_product( a, b, 1, 0, C ); \
|
||||
matrix_inner_product( a, b, 1, 1, C ); \
|
||||
matrix_inner_product( a, b, 1, 2, C ); \
|
||||
matrix_inner_product( a, b, 1, 3, C ); \
|
||||
matrix_inner_product( a, b, 2, 0, C ); \
|
||||
matrix_inner_product( a, b, 2, 1, C ); \
|
||||
matrix_inner_product( a, b, 2, 2, C ); \
|
||||
matrix_inner_product( a, b, 2, 3, C ); \
|
||||
matrix_inner_product( a, b, 3, 0, C ); \
|
||||
matrix_inner_product( a, b, 3, 1, C ); \
|
||||
matrix_inner_product( a, b, 3, 2, C ); \
|
||||
matrix_inner_product( a, b, 3, 3, C ); \
|
||||
}
|
||||
|
||||
static void quaternion_matrix( quaternion *q, double mat[4][4] )
|
||||
{
|
||||
/* copied from Shoemake/ACM SIGGRAPH 89 */
|
||||
double xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz ;
|
||||
|
||||
xs = q->x + q->x;
|
||||
ys = q->y + q->y;
|
||||
zs = q->z + q->z;
|
||||
|
||||
wx = q->w * xs ; wy = q->w * ys ; wz = q->w * zs ;
|
||||
xx = q->x * xs ; xy = q->x * ys ; xz = q->x * zs ;
|
||||
yy = q->y * ys ; yz = q->y * zs ; zz = q->z * zs ;
|
||||
|
||||
mat[0][0] = 1.0 - ( yy + zz ) ;
|
||||
mat[0][1] = xy - wz ;
|
||||
mat[0][2] = xz + wy ;
|
||||
mat[1][0] = xy + wz ;
|
||||
mat[1][1] = 1.0 - ( xx + zz ) ;
|
||||
mat[1][2] = yz - wx ;
|
||||
mat[2][0] = xz - wy ;
|
||||
mat[2][1] = yz + wx ;
|
||||
mat[2][2] = 1.0 - ( xx + yy ) ;
|
||||
|
||||
mat[0][3] = 0.0;
|
||||
mat[1][3] = 0.0;
|
||||
mat[2][3] = 0.0;
|
||||
|
||||
mat[3][0] = 0.0;
|
||||
mat[3][1] = 0.0;
|
||||
mat[3][2] = 0.0;
|
||||
mat[3][3] = 1.0;
|
||||
}
|
||||
|
||||
|
||||
Matrix::Matrix()
|
||||
{
|
||||
makeIdent();
|
||||
}
|
||||
|
||||
|
||||
Matrix::Matrix(const Matrix& matrix) : Object()
|
||||
{
|
||||
memcpy(_mat,matrix._mat,sizeof(_mat));
|
||||
}
|
||||
|
||||
|
||||
Matrix& Matrix::operator = (const Matrix& matrix)
|
||||
{
|
||||
if (&matrix==this) return *this;
|
||||
memcpy(_mat,matrix._mat,sizeof(_mat));
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
Matrix::Matrix(
|
||||
float a00, float a01, float a02, float a03,
|
||||
float a10, float a11, float a12, float a13,
|
||||
float a20, float a21, float a22, float a23,
|
||||
float a30, float a31, float a32, float a33)
|
||||
{
|
||||
_mat[0][0] = a00;
|
||||
_mat[0][1] = a01;
|
||||
_mat[0][2] = a02;
|
||||
_mat[0][3] = a03;
|
||||
|
||||
_mat[1][0] = a10;
|
||||
_mat[1][1] = a11;
|
||||
_mat[1][2] = a12;
|
||||
_mat[1][3] = a13;
|
||||
|
||||
_mat[2][0] = a20;
|
||||
_mat[2][1] = a21;
|
||||
_mat[2][2] = a22;
|
||||
_mat[2][3] = a23;
|
||||
|
||||
_mat[3][0] = a30;
|
||||
_mat[3][1] = a31;
|
||||
_mat[3][2] = a32;
|
||||
_mat[3][3] = a33;
|
||||
}
|
||||
|
||||
|
||||
Matrix::~Matrix()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void Matrix::makeIdent()
|
||||
{
|
||||
_mat[0][0] = 1.0f;
|
||||
_mat[0][1] = 0.0f;
|
||||
_mat[0][2] = 0.0f;
|
||||
_mat[0][3] = 0.0f;
|
||||
|
||||
_mat[1][0] = 0.0f;
|
||||
_mat[1][1] = 1.0f;
|
||||
_mat[1][2] = 0.0f;
|
||||
_mat[1][3] = 0.0f;
|
||||
|
||||
_mat[2][0] = 0.0f;
|
||||
_mat[2][1] = 0.0f;
|
||||
_mat[2][2] = 1.0f;
|
||||
_mat[2][3] = 0.0f;
|
||||
|
||||
_mat[3][0] = 0.0f;
|
||||
_mat[3][1] = 0.0f;
|
||||
_mat[3][2] = 0.0f;
|
||||
_mat[3][3] = 1.0f;
|
||||
}
|
||||
|
||||
void Matrix::set(const float* m)
|
||||
{
|
||||
_mat[0][0] = m[0];
|
||||
_mat[0][1] = m[1];
|
||||
_mat[0][2] = m[2];
|
||||
_mat[0][3] = m[3];
|
||||
|
||||
_mat[1][0] = m[4];
|
||||
_mat[1][1] = m[5];
|
||||
_mat[1][2] = m[6];
|
||||
_mat[1][3] = m[7];
|
||||
|
||||
_mat[2][0] = m[8];
|
||||
_mat[2][1] = m[9];
|
||||
_mat[2][2] = m[10];
|
||||
_mat[2][3] = m[11];
|
||||
|
||||
_mat[3][0] = m[12];
|
||||
_mat[3][1] = m[13];
|
||||
_mat[3][2] = m[14];
|
||||
_mat[3][3] = m[15];
|
||||
}
|
||||
|
||||
|
||||
void Matrix::set(
|
||||
float a00, float a01, float a02, float a03,
|
||||
float a10, float a11, float a12, float a13,
|
||||
float a20, float a21, float a22, float a23,
|
||||
float a30, float a31, float a32, float a33)
|
||||
{
|
||||
_mat[0][0] = a00;
|
||||
_mat[0][1] = a01;
|
||||
_mat[0][2] = a02;
|
||||
_mat[0][3] = a03;
|
||||
|
||||
_mat[1][0] = a10;
|
||||
_mat[1][1] = a11;
|
||||
_mat[1][2] = a12;
|
||||
_mat[1][3] = a13;
|
||||
|
||||
_mat[2][0] = a20;
|
||||
_mat[2][1] = a21;
|
||||
_mat[2][2] = a22;
|
||||
_mat[2][3] = a23;
|
||||
|
||||
_mat[3][0] = a30;
|
||||
_mat[3][1] = a31;
|
||||
_mat[3][2] = a32;
|
||||
_mat[3][3] = a33;
|
||||
}
|
||||
|
||||
void Matrix::copy(const Matrix& matrix)
|
||||
{
|
||||
memcpy(_mat,matrix._mat,sizeof(_mat));
|
||||
}
|
||||
|
||||
|
||||
void Matrix::makeScale(float sx, float sy, float sz)
|
||||
{
|
||||
makeIdent();
|
||||
_mat[0][0] = sx;
|
||||
_mat[1][1] = sy;
|
||||
_mat[2][2] = sz;
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preScale( float sx, float sy, float sz, const Matrix& m )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeScale(sx, sy, sz);
|
||||
mult(transMat,m);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postScale( const Matrix& m, float sx, float sy, float sz )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeScale(sx, sy, sz);
|
||||
mult(m,transMat);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preScale( float sx, float sy, float sz )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeScale(sx, sy, sz);
|
||||
preMult(transMat);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postScale( float sx, float sy, float sz )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeScale(sx, sy, sz);
|
||||
postMult(transMat);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::makeTrans( float tx, float ty, float tz )
|
||||
{
|
||||
makeIdent();
|
||||
_mat[3][0] = tx;
|
||||
_mat[3][1] = ty;
|
||||
_mat[3][2] = tz;
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preTrans( float tx, float ty, float tz, const Matrix& m )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeTrans(tx, ty, tz);
|
||||
mult(transMat,m);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postTrans( const Matrix& m, float tx, float ty, float tz )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeTrans(tx, ty, tz);
|
||||
mult(m,transMat);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preTrans( float tx, float ty, float tz )
|
||||
{
|
||||
_mat[3][0] = (tx * _mat[0][0]) + (ty * _mat[1][0]) + (tz * _mat[2][0]) + _mat[3][0];
|
||||
_mat[3][1] = (tx * _mat[0][1]) + (ty * _mat[1][1]) + (tz * _mat[2][1]) + _mat[3][1];
|
||||
_mat[3][2] = (tx * _mat[0][2]) + (ty * _mat[1][2]) + (tz * _mat[2][2]) + _mat[3][2];
|
||||
_mat[3][3] = (tx * _mat[0][3]) + (ty * _mat[1][3]) + (tz * _mat[2][3]) + _mat[3][3];
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postTrans( float tx, float ty, float tz )
|
||||
{
|
||||
Matrix transMat;
|
||||
transMat.makeTrans(tx, ty, tz);
|
||||
postMult(transMat);
|
||||
}
|
||||
|
||||
void Matrix::makeRot( const Vec3& old_vec, const Vec3& new_vec )
|
||||
{
|
||||
/* dot product == cos(angle old_vec<>new_vec). */
|
||||
double d = new_vec * old_vec;
|
||||
if ( d < 0.9999 )
|
||||
{
|
||||
double angle = acos( d );
|
||||
Vec3 rot_axis = new_vec ^ old_vec;
|
||||
makeRot( RAD2DEG(angle),
|
||||
rot_axis.x(), rot_axis.y(), rot_axis.z() );
|
||||
}
|
||||
else
|
||||
makeIdent();
|
||||
}
|
||||
|
||||
void Matrix::makeRot( float deg, float x, float y, float z )
|
||||
{
|
||||
double __mat[4][4];
|
||||
quaternion q;
|
||||
float d = sqrtf( square(x) + square(y) + square(z) );
|
||||
|
||||
if( d == 0 )
|
||||
return;
|
||||
|
||||
float sin_HalfAngle = sinf( DEG2RAD(deg/2) );
|
||||
float cos_HalfAngle = cosf( DEG2RAD(deg/2) );
|
||||
|
||||
q.x = sin_HalfAngle * (x/d);
|
||||
q.y = sin_HalfAngle * (y/d);
|
||||
q.z = sin_HalfAngle * (z/d);
|
||||
q.w = cos_HalfAngle;
|
||||
|
||||
quaternion_matrix( &q, __mat );
|
||||
|
||||
for(int i=0;i<4;++i)
|
||||
{
|
||||
for(int j=0;j<4;++j)
|
||||
{
|
||||
_mat[i][j]=__mat[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preRot( float deg, float x, float y, float z, const Matrix& m )
|
||||
{
|
||||
Matrix rotMat;
|
||||
rotMat.makeRot( deg, x, y, z );
|
||||
mult(rotMat,m);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postRot( const Matrix& m, float deg, float x, float y, float z )
|
||||
{
|
||||
Matrix rotMat;
|
||||
rotMat.makeRot( deg, x, y, z );
|
||||
mult(m,rotMat);
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preRot( float deg, float x, float y, float z )
|
||||
{
|
||||
quaternion q;
|
||||
double __mat[4][4];
|
||||
float res_mat[4][4];
|
||||
|
||||
float d = sqrtf( square(x) + square(y) + square(z) );
|
||||
|
||||
if( d == 0 )
|
||||
return;
|
||||
|
||||
float sin_HalfAngle = sinf( DEG2RAD(deg/2) );
|
||||
float cos_HalfAngle = cosf( DEG2RAD(deg/2) );
|
||||
|
||||
q.x = sin_HalfAngle * (x/d);
|
||||
q.y = sin_HalfAngle * (y/d);
|
||||
q.z = sin_HalfAngle * (z/d);
|
||||
q.w = cos_HalfAngle;
|
||||
|
||||
quaternion_matrix( &q, __mat );
|
||||
matrix_mult( __mat, _mat, res_mat );
|
||||
memcpy( _mat, res_mat, sizeof( _mat ) );
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postRot( float deg, float x, float y, float z )
|
||||
{
|
||||
quaternion q;
|
||||
double __mat[4][4];
|
||||
float res_mat[4][4];
|
||||
|
||||
float d = sqrtf( square(x) + square(y) + square(z) );
|
||||
|
||||
if( d == 0 )
|
||||
return;
|
||||
|
||||
float sin_HalfAngle = sinf( DEG2RAD(deg/2) );
|
||||
float cos_HalfAngle = cosf( DEG2RAD(deg/2) );
|
||||
|
||||
q.x = sin_HalfAngle * (x/d);
|
||||
q.y = sin_HalfAngle * (y/d);
|
||||
q.z = sin_HalfAngle * (z/d);
|
||||
q.w = cos_HalfAngle;
|
||||
|
||||
quaternion_matrix( &q, __mat );
|
||||
matrix_mult( _mat, __mat , res_mat );
|
||||
memcpy( _mat, res_mat, sizeof( _mat ) );
|
||||
}
|
||||
|
||||
|
||||
void Matrix::setTrans( float tx, float ty, float tz )
|
||||
{
|
||||
_mat[3][0] = tx;
|
||||
_mat[3][1] = ty;
|
||||
_mat[3][2] = tz;
|
||||
}
|
||||
|
||||
|
||||
void Matrix::setTrans( const Vec3& v )
|
||||
{
|
||||
_mat[3][0] = v[0];
|
||||
_mat[3][1] = v[1];
|
||||
_mat[3][2] = v[2];
|
||||
}
|
||||
|
||||
|
||||
void Matrix::preMult(const Matrix& m)
|
||||
{
|
||||
Matrix tm;
|
||||
matrix_mult( m._mat, _mat, tm._mat );
|
||||
*this = tm;
|
||||
}
|
||||
|
||||
|
||||
void Matrix::postMult(const Matrix& m)
|
||||
{
|
||||
Matrix tm;
|
||||
matrix_mult( _mat, m._mat, tm._mat );
|
||||
*this = tm;
|
||||
}
|
||||
|
||||
|
||||
void Matrix::mult(const Matrix& lhs,const Matrix& rhs)
|
||||
{
|
||||
if (&lhs==this || &rhs==this)
|
||||
{
|
||||
osg::Matrix tm;
|
||||
matrix_mult( lhs._mat, rhs._mat, tm._mat );
|
||||
*this = tm;
|
||||
}
|
||||
else
|
||||
{
|
||||
matrix_mult( lhs._mat, rhs._mat, _mat );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Matrix Matrix::operator * (const Matrix& m) const
|
||||
{
|
||||
Matrix tm;
|
||||
matrix_mult( _mat,m._mat, tm._mat );
|
||||
return tm;
|
||||
}
|
||||
|
||||
|
||||
bool Matrix::invert(const Matrix& invm)
|
||||
{
|
||||
if (&invm==this) {
|
||||
Matrix tm(invm);
|
||||
return invert(tm);
|
||||
}
|
||||
|
||||
// code lifted from VR Juggler.
|
||||
// not cleanly added, but seems to work. RO.
|
||||
|
||||
const float* a = reinterpret_cast<const float*>(invm._mat);
|
||||
float* b = reinterpret_cast<float*>(_mat);
|
||||
|
||||
int n = 4;
|
||||
int i, j, k;
|
||||
int r[ 4], c[ 4], row[ 4], col[ 4];
|
||||
float m[ 4][ 4*2], pivot, max_m, tmp_m, fac;
|
||||
|
||||
/* Initialization */
|
||||
for ( i = 0; i < n; i ++ )
|
||||
{
|
||||
r[ i] = c[ i] = 0;
|
||||
row[ i] = col[ i] = 0;
|
||||
}
|
||||
|
||||
/* Set working matrix */
|
||||
for ( i = 0; i < n; i++ )
|
||||
{
|
||||
for ( j = 0; j < n; j++ )
|
||||
{
|
||||
m[ i][ j] = a[ i * n + j];
|
||||
m[ i][ j + n] = ( i == j ) ? 1.0 : 0.0 ;
|
||||
}
|
||||
}
|
||||
|
||||
/* Begin of loop */
|
||||
for ( k = 0; k < n; k++ )
|
||||
{
|
||||
/* Choosing the pivot */
|
||||
for ( i = 0, max_m = 0; i < n; i++ )
|
||||
{
|
||||
if ( row[ i] ) continue;
|
||||
for ( j = 0; j < n; j++ )
|
||||
{
|
||||
if ( col[ j] ) continue;
|
||||
tmp_m = fabs( m[ i][j]);
|
||||
if ( tmp_m > max_m)
|
||||
{
|
||||
max_m = tmp_m;
|
||||
r[ k] = i;
|
||||
c[ k] = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
row[ r[k] ] = col[ c[k] ] = 1;
|
||||
pivot = m[ r[ k] ][ c[ k] ];
|
||||
|
||||
if ( fabs( pivot) <= 1e-20)
|
||||
{
|
||||
notify(WARN) << "*** pivot = %f in mat_inv. ***\n";
|
||||
//exit( 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Normalization */
|
||||
for ( j = 0; j < 2*n; j++ )
|
||||
{
|
||||
if ( j == c[ k] )
|
||||
m[ r[ k]][ j] = 1.0;
|
||||
else
|
||||
m[ r[ k]][ j] /=pivot;
|
||||
}
|
||||
|
||||
/* Reduction */
|
||||
for ( i = 0; i < n; i++ )
|
||||
{
|
||||
if ( i == r[ k] )
|
||||
continue;
|
||||
|
||||
for ( j=0, fac = m[ i][ c[k]];j < 2*n; j++ )
|
||||
{
|
||||
if ( j == c[ k] )
|
||||
m[ i][ j] =0.0;
|
||||
else
|
||||
m[ i][ j] -=fac * m[ r[k]][ j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Assign invers to a matrix */
|
||||
for ( i = 0; i < n; i++ )
|
||||
for ( j = 0; j < n; j++ )
|
||||
row[ i] = ( c[ j] == i ) ? r[j] : row[ i];
|
||||
|
||||
for ( i = 0; i < n; i++ )
|
||||
for ( j = 0; j < n; j++ )
|
||||
b[ i * n + j] = m[ row[ i]][j + n];
|
||||
|
||||
return true; // It worked
|
||||
}
|
||||
22
src/osg/Viewport.cpp
Normal file
22
src/osg/Viewport.cpp
Normal file
@@ -0,0 +1,22 @@
|
||||
#include <osg/Viewport>
|
||||
|
||||
using namespace osg;
|
||||
|
||||
Viewport::Viewport()
|
||||
{
|
||||
_x = 0;
|
||||
_y = 0;
|
||||
_width = 800;
|
||||
_height = 600;
|
||||
}
|
||||
|
||||
|
||||
Viewport::~Viewport()
|
||||
{
|
||||
}
|
||||
|
||||
void Viewport::apply(State&) const
|
||||
{
|
||||
glViewport(_x,_y,_width,_height);
|
||||
}
|
||||
|
||||
18
src/osgUtil/AppVisitor.cpp
Normal file
18
src/osgUtil/AppVisitor.cpp
Normal file
@@ -0,0 +1,18 @@
|
||||
#include <osgUtil/AppVisitor>
|
||||
|
||||
using namespace osg;
|
||||
using namespace osgUtil;
|
||||
|
||||
AppVisitor::AppVisitor():NodeVisitor(TRAVERSE_ACTIVE_CHILDREN)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
AppVisitor::~AppVisitor()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void AppVisitor::reset()
|
||||
{
|
||||
}
|
||||
Reference in New Issue
Block a user