From 2be63aa0fb7936c7c344a7468ec928c735099ca0 Mon Sep 17 00:00:00 2001 From: curt Date: Sat, 4 Jul 1998 00:52:22 +0000 Subject: [PATCH] Add my own version of gluLookAt() (which is nearly identical to the Mesa/glu version.) But, by calculating the Model View matrix our selves we can save this matrix without having to read it back in from the video card. This hopefully allows us to save a few cpu cycles when rendering out the fragments because we can just use glLoadMatrixd() with the precalculated matrix for each tile rather than doing a push(), translate(), pop() for every fragment. Panel status defaults to off for now until it gets a bit more developed. Extract OpenGL driver info on initialization. --- Main/GLUTmain.cxx | 21 ++++++++--- Main/fg_init.cxx | 17 +++++++++ Main/options.cxx | 15 +++++++- Main/views.cxx | 92 +++++++++++++++++++++++++++++++++++++++++++++++ Main/views.hxx | 24 +++++++++++++ 5 files changed, 164 insertions(+), 5 deletions(-) diff --git a/Main/GLUTmain.cxx b/Main/GLUTmain.cxx index 1d5dbce5f..fb4db8a0b 100644 --- a/Main/GLUTmain.cxx +++ b/Main/GLUTmain.cxx @@ -192,28 +192,28 @@ static void fgUpdateViewParams( void ) { xglLoadIdentity(); // set up our view volume (default) - gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, + fg_gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, v->view_pos.x + v->view_forward[0], v->view_pos.y + v->view_forward[1], v->view_pos.z + v->view_forward[2], v->view_up[0], v->view_up[1], v->view_up[2]); // look almost straight up (testing and eclipse watching) - /* gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, + /* fg_gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, v->view_pos.x + v->view_up[0] + .001, v->view_pos.y + v->view_up[1] + .001, v->view_pos.z + v->view_up[2] + .001, v->view_up[0], v->view_up[1], v->view_up[2]); */ // lock view horizontally towards sun (testing) - /* gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, + /* fg_gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, v->view_pos.x + v->surface_to_sun[0], v->view_pos.y + v->surface_to_sun[1], v->view_pos.z + v->surface_to_sun[2], v->view_up[0], v->view_up[1], v->view_up[2]); */ // lock view horizontally towards south (testing) - /* gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, + /* fg_gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z, v->view_pos.x + v->surface_south[0], v->view_pos.y + v->surface_south[1], v->view_pos.z + v->surface_south[2], @@ -745,6 +745,19 @@ int main( int argc, char **argv ) { // $Log$ +// Revision 1.29 1998/07/04 00:52:22 curt +// Add my own version of gluLookAt() (which is nearly identical to the +// Mesa/glu version.) But, by calculating the Model View matrix our selves +// we can save this matrix without having to read it back in from the video +// card. This hopefully allows us to save a few cpu cycles when rendering +// out the fragments because we can just use glLoadMatrixd() with the +// precalculated matrix for each tile rather than doing a push(), translate(), +// pop() for every fragment. +// +// Panel status defaults to off for now until it gets a bit more developed. +// +// Extract OpenGL driver info on initialization. +// // Revision 1.28 1998/06/27 16:54:32 curt // Replaced "extern displayInstruments" with a entry in fgOPTIONS. // Don't change the view port when displaying the panel. diff --git a/Main/fg_init.cxx b/Main/fg_init.cxx index dd0890bd8..89ebfabbb 100644 --- a/Main/fg_init.cxx +++ b/Main/fg_init.cxx @@ -180,6 +180,10 @@ int fgInitGeneral( void ) { fgPrintf( FG_GENERAL, FG_INFO, "General Initialization\n" ); fgPrintf( FG_GENERAL, FG_INFO, "======= ==============\n" ); + g->glVendor = glGetString ( GL_VENDOR ); + g->glRenderer = glGetString ( GL_RENDERER ); + g->glVersion = glGetString ( GL_VERSION ); + if ( !strlen(o->fg_root) ) { // No root path set? Then assume, we will exit if this is // wrong when looking for support files. @@ -383,6 +387,19 @@ int fgInitSubsystems( void ) { // $Log$ +// Revision 1.22 1998/07/04 00:52:25 curt +// Add my own version of gluLookAt() (which is nearly identical to the +// Mesa/glu version.) But, by calculating the Model View matrix our selves +// we can save this matrix without having to read it back in from the video +// card. This hopefully allows us to save a few cpu cycles when rendering +// out the fragments because we can just use glLoadMatrixd() with the +// precalculated matrix for each tile rather than doing a push(), translate(), +// pop() for every fragment. +// +// Panel status defaults to off for now until it gets a bit more developed. +// +// Extract OpenGL driver info on initialization. +// // Revision 1.21 1998/06/27 16:54:33 curt // Replaced "extern displayInstruments" with a entry in fgOPTIONS. // Don't change the view port when displaying the panel. diff --git a/Main/options.cxx b/Main/options.cxx index 5efd62e1e..25c48a65f 100644 --- a/Main/options.cxx +++ b/Main/options.cxx @@ -69,7 +69,7 @@ fgOPTIONS::fgOPTIONS( void ) { // Features hud_status = 1; - panel_status = 1; + panel_status = 0; // Rendering options fog = 2; // nicest @@ -434,6 +434,19 @@ fgOPTIONS::~fgOPTIONS( void ) { // $Log$ +// Revision 1.14 1998/07/04 00:52:26 curt +// Add my own version of gluLookAt() (which is nearly identical to the +// Mesa/glu version.) But, by calculating the Model View matrix our selves +// we can save this matrix without having to read it back in from the video +// card. This hopefully allows us to save a few cpu cycles when rendering +// out the fragments because we can just use glLoadMatrixd() with the +// precalculated matrix for each tile rather than doing a push(), translate(), +// pop() for every fragment. +// +// Panel status defaults to off for now until it gets a bit more developed. +// +// Extract OpenGL driver info on initialization. +// // Revision 1.13 1998/06/27 16:54:34 curt // Replaced "extern displayInstruments" with a entry in fgOPTIONS. // Don't change the view port when displaying the panel. diff --git a/Main/views.cxx b/Main/views.cxx index 5ab8e9425..e1a77662b 100644 --- a/Main/views.cxx +++ b/Main/views.cxx @@ -375,7 +375,99 @@ fgVIEW::~fgVIEW( void ) { } +// Basically, this is a modified version of the Mesa gluLookAt() +// function that's been modified slightly so we can capture the result +// before sending it off to OpenGL land. +void fg_gluLookAt( GLdouble eyex, GLdouble eyey, GLdouble eyez, + GLdouble centerx, GLdouble centery, GLdouble centerz, + GLdouble upx, GLdouble upy, GLdouble upz ) +{ + GLdouble *m; + GLdouble x[3], y[3], z[3]; + GLdouble mag; + + m = current_view.MODEL_VIEW; + + /* Make rotation matrix */ + + /* Z vector */ + z[0] = eyex - centerx; + z[1] = eyey - centery; + z[2] = eyez - centerz; + mag = sqrt( z[0]*z[0] + z[1]*z[1] + z[2]*z[2] ); + if (mag) { /* mpichler, 19950515 */ + z[0] /= mag; + z[1] /= mag; + z[2] /= mag; + } + + /* Y vector */ + y[0] = upx; + y[1] = upy; + y[2] = upz; + + /* X vector = Y cross Z */ + x[0] = y[1]*z[2] - y[2]*z[1]; + x[1] = -y[0]*z[2] + y[2]*z[0]; + x[2] = y[0]*z[1] - y[1]*z[0]; + + /* Recompute Y = Z cross X */ + y[0] = z[1]*x[2] - z[2]*x[1]; + y[1] = -z[0]*x[2] + z[2]*x[0]; + y[2] = z[0]*x[1] - z[1]*x[0]; + + /* mpichler, 19950515 */ + /* cross product gives area of parallelogram, which is < 1.0 for + * non-perpendicular unit-length vectors; so normalize x, y here + */ + + mag = sqrt( x[0]*x[0] + x[1]*x[1] + x[2]*x[2] ); + if (mag) { + x[0] /= mag; + x[1] /= mag; + x[2] /= mag; + } + + mag = sqrt( y[0]*y[0] + y[1]*y[1] + y[2]*y[2] ); + if (mag) { + y[0] /= mag; + y[1] /= mag; + y[2] /= mag; + } + +#define M(row,col) m[col*4+row] + M(0,0) = x[0]; M(0,1) = x[1]; M(0,2) = x[2]; M(0,3) = 0.0; + M(1,0) = y[0]; M(1,1) = y[1]; M(1,2) = y[2]; M(1,3) = 0.0; + M(2,0) = z[0]; M(2,1) = z[1]; M(2,2) = z[2]; M(2,3) = 0.0; + M(3,0) = 0.0; M(3,1) = 0.0; M(3,2) = 0.0; M(3,3) = 1.0; +#undef M + + // Translate Eye to Origin + // replaces: glTranslated( -eyex, -eyey, -eyez ); + m[12] = m[0] * -eyex + m[4] * -eyey + m[8] * -eyez + m[12]; + m[13] = m[1] * -eyex + m[5] * -eyey + m[9] * -eyez + m[13]; + m[14] = m[2] * -eyex + m[6] * -eyey + m[10] * -eyez + m[14]; + m[15] = m[3] * -eyex + m[7] * -eyey + m[11] * -eyez + m[15]; + + // xglMultMatrixd( m ); + xglLoadMatrixd( m ); +} + + // $Log$ +// Revision 1.13 1998/07/04 00:52:27 curt +// Add my own version of gluLookAt() (which is nearly identical to the +// Mesa/glu version.) But, by calculating the Model View matrix our selves +// we can save this matrix without having to read it back in from the video +// card. This hopefully allows us to save a few cpu cycles when rendering +// out the fragments because we can just use glLoadMatrixd() with the +// precalculated matrix for each tile rather than doing a push(), translate(), +// pop() for every fragment. +// +// Panel status defaults to off for now until it gets a bit more developed. +// +// Extract OpenGL driver info on initialization. +// // Revision 1.12 1998/06/03 00:47:15 curt // Updated to compile in audio support if OSS available. // Updated for new version of Steve's audio library. diff --git a/Main/views.hxx b/Main/views.hxx index c4b335878..47c052afc 100644 --- a/Main/views.hxx +++ b/Main/views.hxx @@ -135,6 +135,9 @@ public: // coordinates to eye coordinates MAT3mat WORLD_TO_EYE; + // Current model view matrix; + GLdouble MODEL_VIEW[16]; + // Constructor fgVIEW( void ); @@ -158,10 +161,31 @@ public: extern fgVIEW current_view; +// Basically, this is a modified version of the Mesa gluLookAt() +// function that's been modified slightly so we can capture the result +// before sending it off to OpenGL land. +void fg_gluLookAt( GLdouble eyex, GLdouble eyey, GLdouble eyez, + GLdouble centerx, GLdouble centery, GLdouble centerz, + GLdouble upx, GLdouble upy, GLdouble upz ); + + #endif // _VIEWS_HXX // $Log$ +// Revision 1.9 1998/07/04 00:52:27 curt +// Add my own version of gluLookAt() (which is nearly identical to the +// Mesa/glu version.) But, by calculating the Model View matrix our selves +// we can save this matrix without having to read it back in from the video +// card. This hopefully allows us to save a few cpu cycles when rendering +// out the fragments because we can just use glLoadMatrixd() with the +// precalculated matrix for each tile rather than doing a push(), translate(), +// pop() for every fragment. +// +// Panel status defaults to off for now until it gets a bit more developed. +// +// Extract OpenGL driver info on initialization. +// // Revision 1.8 1998/05/27 02:24:06 curt // View optimizations by Norman Vine. //