Initial revision
This commit is contained in:
curt
@@ -0,0 +1,11 @@
|
||||
noinst_LIBRARIES = libBucket.a
|
||||
|
||||
libBucket_a_SOURCES = newbucket.cxx newbucket.hxx
|
||||
|
||||
bin_PROGRAMS = testbucket
|
||||
|
||||
testbucket_SOURCES = testbucket.cxx
|
||||
|
||||
testbucket_LDADD = $(top_builddir)/Lib/Bucket/libBucket.a
|
||||
|
||||
INCLUDES += -I$(top_builddir)
|
||||
@@ -0,0 +1,166 @@
|
||||
/**************************************************************************
|
||||
* newbucket.hxx -- new bucket routines for better world modeling
|
||||
*
|
||||
* Written by Curtis L. Olson, started February 1999.
|
||||
*
|
||||
* Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* $Id$
|
||||
* (Log is kept at end of this file)
|
||||
**************************************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
|
||||
#include "newbucket.hxx"
|
||||
|
||||
|
||||
// Build the path name for this bucket
|
||||
string FGBucket::gen_base_path() const {
|
||||
// long int index;
|
||||
int top_lon, top_lat, main_lon, main_lat;
|
||||
char hem, pole;
|
||||
char path[256];
|
||||
|
||||
// index = gen_index();
|
||||
|
||||
path[0] = '\0';
|
||||
|
||||
top_lon = lon / 10;
|
||||
main_lon = lon;
|
||||
if ( (lon < 0) && (top_lon * 10 != lon) ) {
|
||||
top_lon -= 1;
|
||||
}
|
||||
top_lon *= 10;
|
||||
if ( top_lon >= 0 ) {
|
||||
hem = 'e';
|
||||
} else {
|
||||
hem = 'w';
|
||||
top_lon *= -1;
|
||||
}
|
||||
if ( main_lon < 0 ) {
|
||||
main_lon *= -1;
|
||||
}
|
||||
|
||||
top_lat = lat / 10;
|
||||
main_lat = lat;
|
||||
if ( (lat < 0) && (top_lat * 10 != lat) ) {
|
||||
top_lat -= 1;
|
||||
}
|
||||
top_lat *= 10;
|
||||
if ( top_lat >= 0 ) {
|
||||
pole = 'n';
|
||||
} else {
|
||||
pole = 's';
|
||||
top_lat *= -1;
|
||||
}
|
||||
if ( main_lat < 0 ) {
|
||||
main_lat *= -1;
|
||||
}
|
||||
|
||||
sprintf(path, "%c%03d%c%02d/%c%03d%c%02d",
|
||||
hem, top_lon, pole, top_lat,
|
||||
hem, main_lon, pole, main_lat);
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
|
||||
// find the bucket which is offset by the specified tile units in the
|
||||
// X & Y direction. We need the current lon and lat to resolve
|
||||
// ambiguities when going from a wider tile to a narrower one above or
|
||||
// below. This assumes that we are feeding in
|
||||
FGBucket fgBucketOffset( double dlon, double dlat, int dx, int dy ) {
|
||||
FGBucket result( dlon, dlat );
|
||||
double clat = result.get_center_lat() + dy * FG_BUCKET_SPAN;
|
||||
|
||||
// walk dy units in the lat direction
|
||||
result.set_bucket( dlon, clat );
|
||||
|
||||
// find the lon span for the new latitude
|
||||
double span = bucket_span( clat );
|
||||
|
||||
// walk dx units in the lon direction
|
||||
result.set_bucket( dlon + dx * span, clat );
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
// calculate the offset between two buckets
|
||||
void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
|
||||
|
||||
// Latitude difference
|
||||
double c1_lat = b1.get_center_lat();
|
||||
double c2_lat = b2.get_center_lat();
|
||||
double diff_lat = c2_lat - c1_lat;
|
||||
|
||||
#ifdef HAVE_RINT
|
||||
*dy = (int)rint( diff_lat / FG_BUCKET_SPAN );
|
||||
#else
|
||||
if ( diff_lat > 0 ) {
|
||||
*dy = (int)( diff_lat / FG_BUCKET_SPAN + 0.5 );
|
||||
} else {
|
||||
*dy = (int)( diff_lat / FG_BUCKET_SPAN - 0.5 );
|
||||
}
|
||||
#endif
|
||||
|
||||
// longitude difference
|
||||
double c1_lon = b1.get_center_lon();
|
||||
double c2_lon = b2.get_center_lon();
|
||||
double diff_lon = c2_lon - c1_lon;
|
||||
double span;
|
||||
if ( bucket_span(c1_lat) <= bucket_span(c2_lat) ) {
|
||||
span = bucket_span(c1_lat);
|
||||
} else {
|
||||
span = bucket_span(c2_lat);
|
||||
}
|
||||
|
||||
#ifdef HAVE_RINT
|
||||
*dx = (int)rint( diff_lon / span );
|
||||
#else
|
||||
if ( diff_lon > 0 ) {
|
||||
*dx = (int)( diff_lon / span + 0.5 );
|
||||
} else {
|
||||
*dx = (int)( diff_lon / span - 0.5 );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:34 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.4 1999/03/27 05:34:05 curt
|
||||
// Elimitated some const warnings from the compiler.
|
||||
//
|
||||
// Revision 1.3 1999/02/26 22:07:54 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.2 1999/02/11 01:09:33 curt
|
||||
// Added a routine to calculate the offset in bucket units between two buckets.
|
||||
//
|
||||
// Revision 1.1 1999/02/08 23:52:16 curt
|
||||
// Added a new "newbucket.[ch]xx" FGBucket class to replace the old
|
||||
// fgBUCKET struct and C routines. This FGBucket class adjusts the tile
|
||||
// width towards the poles to ensure the tiles are at least 8 miles wide.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,363 @@
|
||||
/**************************************************************************
|
||||
* newbucket.hxx -- new bucket routines for better world modeling
|
||||
*
|
||||
* Written by Curtis L. Olson, started February 1999.
|
||||
*
|
||||
* Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* $Id$
|
||||
* (Log is kept at end of this file)
|
||||
**************************************************************************/
|
||||
|
||||
|
||||
#ifndef _NEWBUCKET_HXX
|
||||
#define _NEWBUCKET_HXX
|
||||
|
||||
#include <Include/compiler.h>
|
||||
|
||||
#include STL_STRING
|
||||
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
# include <cstdio> // sprintf()
|
||||
# include <iostream>
|
||||
#else
|
||||
# include <stdio.h> // sprintf()
|
||||
# include <iostream.h>
|
||||
#endif
|
||||
|
||||
FG_USING_STD(string);
|
||||
FG_USING_STD(ostream);
|
||||
|
||||
#include <Include/fg_constants.h>
|
||||
|
||||
|
||||
#define FG_BUCKET_SPAN 0.125 // 1/8 of a degree
|
||||
#define FG_HALF_BUCKET_SPAN 0.0625 // 1/2 of 1/8 of a degree = 1/16 = 0.0625
|
||||
|
||||
class FGBucket;
|
||||
ostream& operator<< ( ostream&, const FGBucket& );
|
||||
bool operator== ( const FGBucket&, const FGBucket& );
|
||||
|
||||
class FGBucket {
|
||||
|
||||
private:
|
||||
double cx, cy; // centerpoint (lon, lat) in degrees of bucket
|
||||
int lon; // longitude index (-180 to 179)
|
||||
int lat; // latitude index (-90 to 89)
|
||||
int x; // x subdivision (0 to 7)
|
||||
int y; // y subdivision (0 to 7)
|
||||
|
||||
public:
|
||||
|
||||
// default constructor
|
||||
FGBucket();
|
||||
|
||||
// create a bucket which would contain the specified lon/lat
|
||||
FGBucket(const double lon, const double lat);
|
||||
|
||||
// create a bucket based on "long int" index
|
||||
FGBucket(const long int bindex);
|
||||
|
||||
// create an impossible bucket if false
|
||||
FGBucket(const bool is_good);
|
||||
|
||||
~FGBucket();
|
||||
|
||||
// Set the bucket params for the specified lat and lon
|
||||
void set_bucket( double dlon, double dlat );
|
||||
|
||||
// Generate the unique scenery tile index for this bucket
|
||||
long int gen_index();
|
||||
string gen_index_str() const;
|
||||
|
||||
// Build the path name for this bucket
|
||||
string gen_base_path() const;
|
||||
|
||||
// return the center lon of a tile
|
||||
double get_center_lon() const;
|
||||
|
||||
// return width of the tile
|
||||
double get_width() const;
|
||||
|
||||
// return the center lat of a tile
|
||||
double get_center_lat() const;
|
||||
|
||||
// return height of the tile
|
||||
double get_height() const;
|
||||
|
||||
// Informational methods
|
||||
inline int get_lon() const { return lon; }
|
||||
inline int get_lat() const { return lat; }
|
||||
inline int get_x() const { return x; }
|
||||
inline int get_y() const { return y; }
|
||||
|
||||
// friends
|
||||
friend ostream& operator<< ( ostream&, const FGBucket& );
|
||||
friend bool operator== ( const FGBucket&, const FGBucket& );
|
||||
};
|
||||
|
||||
|
||||
// return the horizontal tile span factor based on latitude
|
||||
inline double bucket_span( double l ) {
|
||||
if ( l >= 89.0 ) {
|
||||
return 0.0;
|
||||
} else if ( l >= 88.0 ) {
|
||||
return 8.0;
|
||||
} else if ( l >= 86.0 ) {
|
||||
return 4.0;
|
||||
} else if ( l >= 83.0 ) {
|
||||
return 2.0;
|
||||
} else if ( l >= 76.0 ) {
|
||||
return 1.0;
|
||||
} else if ( l >= 62.0 ) {
|
||||
return 0.5;
|
||||
} else if ( l >= 22.0 ) {
|
||||
return 0.25;
|
||||
} else if ( l >= -22.0 ) {
|
||||
return 0.125;
|
||||
} else if ( l >= -62.0 ) {
|
||||
return 0.25;
|
||||
} else if ( l >= -76.0 ) {
|
||||
return 0.5;
|
||||
} else if ( l >= -83.0 ) {
|
||||
return 1.0;
|
||||
} else if ( l >= -86.0 ) {
|
||||
return 2.0;
|
||||
} else if ( l >= -88.0 ) {
|
||||
return 4.0;
|
||||
} else if ( l >= -89.0 ) {
|
||||
return 8.0;
|
||||
} else {
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Set the bucket params for the specified lat and lon
|
||||
inline void FGBucket::set_bucket( double dlon, double dlat ) {
|
||||
//
|
||||
// latitude first
|
||||
//
|
||||
double span = bucket_span( dlat );
|
||||
double diff = dlon - (double)(int)dlon;
|
||||
|
||||
// cout << "diff = " << diff << " span = " << span << endl;
|
||||
|
||||
if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
|
||||
lon = (int)dlon;
|
||||
} else {
|
||||
lon = (int)dlon - 1;
|
||||
}
|
||||
|
||||
// find subdivision or super lon if needed
|
||||
if ( span < FG_EPSILON ) {
|
||||
// polar cap
|
||||
lon = 0;
|
||||
x = 0;
|
||||
} else if ( span <= 1.0 ) {
|
||||
x = (int)((dlon - lon) / span);
|
||||
} else {
|
||||
if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
|
||||
lon = (int)( (int)(lon / span) * span);
|
||||
} else {
|
||||
// cout << " lon = " << lon
|
||||
// << " tmp = " << (int)((lon-1) / span) << endl;
|
||||
lon = (int)( (int)((lon + 1) / span) * span - span);
|
||||
if ( lon < -180 ) {
|
||||
lon = -180;
|
||||
}
|
||||
}
|
||||
x = 0;
|
||||
}
|
||||
|
||||
//
|
||||
// then latitude
|
||||
//
|
||||
diff = dlat - (double)(int)dlat;
|
||||
|
||||
if ( (dlat >= 0) || (fabs(diff) < FG_EPSILON) ) {
|
||||
lat = (int)dlat;
|
||||
} else {
|
||||
lat = (int)dlat - 1;
|
||||
}
|
||||
y = (int)((dlat - lat) * 8);
|
||||
}
|
||||
|
||||
|
||||
// default constructor
|
||||
inline FGBucket::FGBucket() {}
|
||||
|
||||
|
||||
// constructor for specified location
|
||||
inline FGBucket::FGBucket(const double dlon, const double dlat) {
|
||||
set_bucket(dlon, dlat);
|
||||
}
|
||||
|
||||
// create an impossible bucket if false
|
||||
inline FGBucket::FGBucket(const bool is_good) {
|
||||
set_bucket(0.0, 0.0);
|
||||
if ( !is_good ) {
|
||||
lon = -1000;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Parse a unique scenery tile index and find the lon, lat, x, and y
|
||||
inline FGBucket::FGBucket(const long int bindex) {
|
||||
long int index = bindex;
|
||||
|
||||
lon = index >> 14;
|
||||
index -= lon << 14;
|
||||
lon -= 180;
|
||||
|
||||
lat = index >> 6;
|
||||
index -= lat << 6;
|
||||
lat -= 90;
|
||||
|
||||
y = index >> 3;
|
||||
index -= y << 3;
|
||||
|
||||
x = index;
|
||||
}
|
||||
|
||||
|
||||
// default destructor
|
||||
inline FGBucket::~FGBucket() {}
|
||||
|
||||
|
||||
// Generate the unique scenery tile index for this bucket
|
||||
//
|
||||
// The index is constructed as follows:
|
||||
//
|
||||
// 9 bits - to represent 360 degrees of longitude (-180 to 179)
|
||||
// 8 bits - to represent 180 degrees of latitude (-90 to 89)
|
||||
//
|
||||
// Each 1 degree by 1 degree tile is further broken down into an 8x8
|
||||
// grid. So we also need:
|
||||
//
|
||||
// 3 bits - to represent x (0 to 7)
|
||||
// 3 bits - to represent y (0 to 7)
|
||||
|
||||
inline long int FGBucket::gen_index() {
|
||||
return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
|
||||
}
|
||||
|
||||
inline string FGBucket::gen_index_str() const {
|
||||
char tmp[20];
|
||||
sprintf(tmp, "%ld",
|
||||
(((long)lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x);
|
||||
return (string)tmp;
|
||||
}
|
||||
|
||||
|
||||
// return the center lon of a tile
|
||||
inline double FGBucket::get_center_lon() const {
|
||||
double span = bucket_span( lat + y / 8.0 + FG_HALF_BUCKET_SPAN );
|
||||
|
||||
if ( span >= 1.0 ) {
|
||||
return lon + span / 2.0;
|
||||
} else {
|
||||
return lon + x * span + span / 2.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// return width of the tile
|
||||
inline double FGBucket::get_width() const {
|
||||
return bucket_span( get_center_lat() );
|
||||
}
|
||||
|
||||
|
||||
// return the center lat of a tile
|
||||
inline double FGBucket::get_center_lat() const {
|
||||
return lat + y / 8.0 + FG_HALF_BUCKET_SPAN;
|
||||
}
|
||||
|
||||
|
||||
// return height of the tile
|
||||
inline double FGBucket::get_height() const {
|
||||
return FG_BUCKET_SPAN;
|
||||
}
|
||||
|
||||
|
||||
// offset a bucket struct by the specified tile units in the X & Y
|
||||
// direction
|
||||
FGBucket fgBucketOffset( double dlon, double dlat, int x, int y );
|
||||
|
||||
|
||||
// calculate the offset between two buckets
|
||||
void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy );
|
||||
|
||||
|
||||
/*
|
||||
// Given a lat/lon, fill in the local tile index array
|
||||
void fgBucketGenIdxArray(fgBUCKET *p1, fgBUCKET *tiles, int width, int height);
|
||||
*/
|
||||
|
||||
|
||||
inline ostream&
|
||||
operator<< ( ostream& out, const FGBucket& b )
|
||||
{
|
||||
return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator== ( const FGBucket& b1, const FGBucket& b2 )
|
||||
{
|
||||
return ( b1.lon == b2.lon &&
|
||||
b1.lat == b2.lat &&
|
||||
b1.x == b2.x &&
|
||||
b1.y == b2.y );
|
||||
}
|
||||
|
||||
|
||||
#endif // _NEWBUCKET_HXX
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:34 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.8 1999/03/27 05:34:06 curt
|
||||
// Elimitated some const warnings from the compiler.
|
||||
//
|
||||
// Revision 1.7 1999/03/25 19:01:51 curt
|
||||
// Jettisoned old bucketutils.[ch] for newbucket.[ch]xx
|
||||
//
|
||||
// Revision 1.6 1999/03/15 17:58:41 curt
|
||||
// MSVC++ portability tweaks contributed by Bernie Bright.
|
||||
// Added using std::ostream declaration.
|
||||
// Added forward declarations to work around a MSVC bug.
|
||||
//
|
||||
// Revision 1.5 1999/03/12 22:51:18 curt
|
||||
// Added some informational methods.
|
||||
//
|
||||
// Revision 1.4 1999/03/02 01:01:43 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.3 1999/02/26 22:07:55 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.2 1999/02/11 01:09:34 curt
|
||||
// Added a routine to calculate the offset in bucket units between two buckets.
|
||||
//
|
||||
// Revision 1.1 1999/02/08 23:52:16 curt
|
||||
// Added a new "newbucket.[ch]xx" FGBucket class to replace the old
|
||||
// fgBUCKET struct and C routines. This FGBucket class adjusts the tile
|
||||
// width towards the poles to ensure the tiles are at least 8 miles wide.
|
||||
//
|
||||
@@ -0,0 +1,32 @@
|
||||
// test new bucket routines
|
||||
|
||||
#include "newbucket.cxx"
|
||||
|
||||
main() {
|
||||
double lat = 21.9625;
|
||||
double lon = -110.0 + 0.0625;
|
||||
|
||||
/*
|
||||
while ( lon < 180 ) {
|
||||
FGBucket b1( lon, lat );
|
||||
long int index = b1.gen_index();
|
||||
FGBucket b2( index );
|
||||
|
||||
cout << lon << "," << lat << " ";
|
||||
cout << b2 << " " << b2.get_center_lon() << ","
|
||||
<< b2.get_center_lat() << endl;
|
||||
|
||||
lon += 0.125;
|
||||
}
|
||||
*/
|
||||
|
||||
FGBucket b1;
|
||||
|
||||
for ( int j = 2; j >= -2; j-- ) {
|
||||
for ( int i = -2; i < 3; i++ ) {
|
||||
b1 = fgBucketOffset(lon, lat, i, j);
|
||||
cout << "(" << i << "," << j << ")" << b1 << "\t";
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
EXTRA_DIST = logtest.cxx
|
||||
|
||||
noinst_LIBRARIES = libDebug.a
|
||||
|
||||
libDebug_a_SOURCES = \
|
||||
debug_types.h \
|
||||
logstream.cxx logstream.hxx
|
||||
|
||||
# fg_debug.c fg_debug.h \
|
||||
|
||||
INCLUDES += -I$(top_builddir)
|
||||
@@ -0,0 +1,37 @@
|
||||
// NB: To add a dbg_class, add it here, and add it to the structure in
|
||||
// fg_debug.c
|
||||
|
||||
typedef enum {
|
||||
FG_NONE = 0x00000000,
|
||||
|
||||
FG_TERRAIN = 0x00000001,
|
||||
FG_ASTRO = 0x00000002,
|
||||
FG_FLIGHT = 0x00000004,
|
||||
FG_INPUT = 0x00000008,
|
||||
FG_GL = 0x00000010,
|
||||
FG_VIEW = 0x00000020,
|
||||
FG_COCKPIT = 0x00000040,
|
||||
FG_GENERAL = 0x00000080,
|
||||
FG_MATH = 0x00000100,
|
||||
FG_EVENT = 0x00000200,
|
||||
FG_AIRCRAFT = 0x00000400,
|
||||
FG_AUTOPILOT = 0x00000800,
|
||||
FG_SERIAL = 0x00001000,
|
||||
FG_CLIPPER = 0x00002000,
|
||||
FG_UNDEFD = 0x00004000, // For range checking
|
||||
|
||||
FG_ALL = 0xFFFFFFFF
|
||||
} fgDebugClass;
|
||||
|
||||
|
||||
// NB: To add a priority, add it here.
|
||||
typedef enum {
|
||||
FG_BULK, // For frequent messages
|
||||
FG_DEBUG, // Less frequent debug type messages
|
||||
FG_INFO, // Informatory messages
|
||||
FG_WARN, // Possible impending problem
|
||||
FG_ALERT // Very possible impending problem
|
||||
// FG_EXIT, // Problem (no core)
|
||||
// FG_ABORT // Abandon ship (core)
|
||||
} fgDebugPriority;
|
||||
|
||||
@@ -0,0 +1,313 @@
|
||||
/* -*- Mode: C++ -*-
|
||||
*
|
||||
* fg_debug.c -- Flight Gear debug utility functions
|
||||
*
|
||||
* Written by Paul Bleisch, started January 1998.
|
||||
*
|
||||
* Copyright (C) 1998 Paul Bleisch, pbleisch@acm.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* $Id$
|
||||
* (Log is kept at end of this file)
|
||||
**************************************************************************/
|
||||
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <Include/cmdargs.h> // Line to command line arguments
|
||||
|
||||
#include "fg_debug.h"
|
||||
|
||||
|
||||
static int fg_DebugSem = 1;
|
||||
fgDebugClass fg_DebugClass = FG_NONE; // Need visibility for
|
||||
fgDebugPriority fg_DebugPriority = FG_INFO; // command line processing.
|
||||
static fgDebugCallback fg_DebugCallback = NULL;
|
||||
|
||||
FILE *fg_DebugOutput = NULL; // Visibility needed for command line processor.
|
||||
// This can be set to a FILE from the command
|
||||
// line. If not, it will be set to stderr.
|
||||
|
||||
/* TODO: Actually make this thing thread safe */
|
||||
#ifdef USETHREADS
|
||||
#define FG_GRABDEBUGSEM while( --fg_DebugSem < 0 ) { fg_DebugSem++; }
|
||||
#define FG_RELEASEDEBUGSEM fg_DebugSem++;
|
||||
#else
|
||||
#define FG_GRABDEBUGSEM
|
||||
#define FG_RELEASEDEBUGSEM
|
||||
#endif
|
||||
|
||||
/* Used for convienence initialization from env variables.
|
||||
*/
|
||||
static struct {
|
||||
char *str;
|
||||
fgDebugClass dbg_class;
|
||||
} fg_DebugClasses[] = {
|
||||
{ "FG_NONE", 0x00000000 },
|
||||
{ "FG_TERRAIN", 0x00000001 },
|
||||
{ "FG_ASTRO", 0x00000002 },
|
||||
{ "FG_FLIGHT", 0x00000004 },
|
||||
{ "FG_INPUT", 0x00000008 },
|
||||
{ "FG_GL", 0x00000010 },
|
||||
{ "FG_VIEW", 0x00000020 },
|
||||
{ "FG_COCKPIT", 0x00000040 },
|
||||
{ "FG_GENERAL", 0x00000080 },
|
||||
{ "FG_MATH", 0x00000100 },
|
||||
{ "FG_EVENT", 0x00000200 },
|
||||
{ "FG_AIRCRAFT", 0x00000400 },
|
||||
{ "FG_AUTOPILOT", 0x00000800 },
|
||||
|
||||
/* Do not edit below here, last entry should be null */
|
||||
{ "FG_ALL", 0xFFFFFFFF },
|
||||
{ NULL, 0 }
|
||||
};
|
||||
|
||||
static fgDebugClass fgDebugStrToClass( char *str );
|
||||
|
||||
|
||||
/* fgInitDebug =============================================================*/
|
||||
void fgInitDebug( void ) {
|
||||
char *pszClass, *pszPrio, *pszFile;
|
||||
|
||||
// Support for log file/alt debug output via command line, environment or
|
||||
// reasonable default.
|
||||
|
||||
/*
|
||||
if( strlen( logArgbuf ) > 3) { // First check for command line option
|
||||
// Assumed that we will append.
|
||||
fg_DebugOutput = fopen(logArgbuf, "a+" );
|
||||
}
|
||||
*/
|
||||
|
||||
if( !fg_DebugOutput ) { // If not set on command line, environment?
|
||||
pszFile = getenv( "FG_DEBUGFILE" );
|
||||
if( pszFile ) { // There is such an environmental variable.
|
||||
fg_DebugOutput = fopen( pszFile, "a+" );
|
||||
}
|
||||
}
|
||||
|
||||
if( !fg_DebugOutput ) { // If neither command line nor environment
|
||||
fg_DebugOutput = stderr; // then we use the fallback position
|
||||
}
|
||||
|
||||
FG_GRABDEBUGSEM;
|
||||
fg_DebugSem = fg_DebugSem; /* shut up GCC */
|
||||
|
||||
// Test command line option overridge of debug priority. If the value
|
||||
// is in range (properly optioned) the we will override both defaults
|
||||
// and the environmental value.
|
||||
|
||||
/*
|
||||
if ((priorityArgValue >= FG_BULK) && (priorityArgValue <= FG_ABORT)) {
|
||||
fg_DebugPriority = priorityArgValue;
|
||||
} else { // Either not set or out of range. We will not warn the user.
|
||||
*/
|
||||
pszPrio = getenv( "FG_DEBUGPRIORITY" );
|
||||
if( pszPrio ) {
|
||||
fg_DebugPriority = atoi( pszPrio );
|
||||
fprintf( stderr,
|
||||
"fg_debug.c: Environment overrides default debug priority (%d)\n",
|
||||
fg_DebugPriority );
|
||||
}
|
||||
/* } */
|
||||
|
||||
|
||||
/*
|
||||
if ((debugArgValue >= FG_ALL) && (debugArgValue < FG_UNDEFD)) {
|
||||
fg_DebugPriority = priorityArgValue;
|
||||
} else { // Either not set or out of range. We will not warn the user.
|
||||
*/
|
||||
pszClass = getenv( "FG_DEBUGCLASS" );
|
||||
if( pszClass ) {
|
||||
fg_DebugClass = fgDebugStrToClass( pszClass );
|
||||
fprintf( stderr,
|
||||
"fg_debug.c: Environment overrides default debug class (0x%08X)\n",
|
||||
fg_DebugClass );
|
||||
}
|
||||
/* } */
|
||||
|
||||
FG_RELEASEDEBUGSEM;
|
||||
}
|
||||
|
||||
/* fgDebugStrToClass ======================================================*/
|
||||
fgDebugClass fgDebugStrToClass( char *str ) {
|
||||
char *hex = "0123456789ABCDEF";
|
||||
char *hexl = "0123456789abcdef";
|
||||
char *pt, *p, *ph, ps = 1;
|
||||
unsigned int val = 0, i;
|
||||
|
||||
if( str == NULL ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Check for 0xXXXXXX notation */
|
||||
p = strstr( str, "0x");
|
||||
if( p ) {
|
||||
p++; p++;
|
||||
while (*p) {
|
||||
ph = strchr(hex,*p);
|
||||
if ( ph ) {
|
||||
val <<= 4;
|
||||
val += ph-hex;
|
||||
p++;
|
||||
} else {
|
||||
ph = strchr(hexl,*p);
|
||||
if ( ph ) {
|
||||
val <<= 4;
|
||||
val += ph-hex;
|
||||
p++;
|
||||
} else {
|
||||
// fprintf( stderr, "Error in hex string '%s'\n", str );
|
||||
return FG_NONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Must be in string format */
|
||||
p = str;
|
||||
ps = 1;
|
||||
while( ps ) {
|
||||
while( *p && (*p==' ' || *p=='\t') ) p++; /* remove whitespace */
|
||||
pt = p; /* mark token */
|
||||
while( *p && (*p!='|') ) p++; /* find OR or EOS */
|
||||
ps = *p; /* save value at p so we can attempt to be bounds safe */
|
||||
*p++ = 0; /* terminate token */
|
||||
/* determine value for token */
|
||||
i=0;
|
||||
while( fg_DebugClasses[i].str &&
|
||||
strncmp( fg_DebugClasses[i].str, pt,
|
||||
strlen(fg_DebugClasses[i].str)) ) i++;
|
||||
if( fg_DebugClasses[i].str == NULL ) {
|
||||
fprintf( stderr,
|
||||
"fg_debug.c: Could not find message class '%s'\n",
|
||||
pt );
|
||||
} else {
|
||||
val |= fg_DebugClasses[i].dbg_class;
|
||||
}
|
||||
}
|
||||
}
|
||||
return (fgDebugClass)val;
|
||||
}
|
||||
|
||||
|
||||
/* fgSetDebugOutput =======================================================*/
|
||||
void fgSetDebugOutput( FILE *out ) {
|
||||
FG_GRABDEBUGSEM;
|
||||
fflush( fg_DebugOutput );
|
||||
fg_DebugOutput = out;
|
||||
FG_RELEASEDEBUGSEM;
|
||||
}
|
||||
|
||||
|
||||
/* fgSetDebugLevels =======================================================*/
|
||||
void fgSetDebugLevels( fgDebugClass dbg_class, fgDebugPriority prio ) {
|
||||
FG_GRABDEBUGSEM;
|
||||
fg_DebugClass = dbg_class;
|
||||
fg_DebugPriority = prio;
|
||||
FG_RELEASEDEBUGSEM;
|
||||
}
|
||||
|
||||
|
||||
/* fgRegisterDebugCallback ================================================*/
|
||||
fgDebugCallback fgRegisterDebugCallback( fgDebugCallback callback ) {
|
||||
fgDebugCallback old;
|
||||
FG_GRABDEBUGSEM;
|
||||
old = fg_DebugCallback;
|
||||
fg_DebugCallback = callback;
|
||||
FG_RELEASEDEBUGSEM;
|
||||
return old;
|
||||
}
|
||||
|
||||
|
||||
/* fgPrintf ===============================================================*/
|
||||
int fgPrintf( fgDebugClass dbg_class, fgDebugPriority prio, char *fmt, ... ) {
|
||||
char szOut[1024+1];
|
||||
va_list ap;
|
||||
int ret = 0;
|
||||
|
||||
// If no action to take, then don't bother with the semaphore
|
||||
// activity Slight speed benefit.
|
||||
|
||||
// printf("dbg_class = %d fg_DebugClass = %d\n", dbg_class, fg_DebugClass);
|
||||
// printf("prio = %d fg_DebugPriority = %d\n", prio, fg_DebugPriority);
|
||||
|
||||
if( !(dbg_class & fg_DebugClass) ) {
|
||||
// Failed to match a specific debug class
|
||||
if ( prio < fg_DebugPriority ) {
|
||||
// priority is less than requested
|
||||
|
||||
// "ret" is zero anyway. But we might think about changing
|
||||
// it upon some error condition?
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
FG_GRABDEBUGSEM;
|
||||
|
||||
/* ret = vsprintf( szOut, fmt, (&fmt+1)); (but it didn't work, thus ... */
|
||||
va_start (ap, fmt);
|
||||
ret = vsprintf( szOut, fmt, ap);
|
||||
va_end (ap);
|
||||
|
||||
if( fg_DebugCallback!=NULL && fg_DebugCallback(dbg_class, prio, szOut) ) {
|
||||
FG_RELEASEDEBUGSEM;
|
||||
return ret;
|
||||
} else {
|
||||
fprintf( fg_DebugOutput, szOut );
|
||||
FG_RELEASEDEBUGSEM;
|
||||
if( prio == FG_EXIT ) {
|
||||
exit(0);
|
||||
} else if( prio == FG_ABORT ) {
|
||||
abort();
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* $Log$
|
||||
/* Revision 1.1 1999/04/05 21:32:33 curt
|
||||
/* Initial revision
|
||||
/*
|
||||
* Revision 1.4 1998/06/01 17:49:44 curt
|
||||
* Rewrote a slightly ambiguous code fragment (contributed by Charlie Hotchkiss)
|
||||
*
|
||||
* Revision 1.3 1998/05/07 23:03:54 curt
|
||||
* Added an entry for AUTOPILOT.
|
||||
*
|
||||
* Revision 1.2 1998/04/21 17:03:45 curt
|
||||
* Prepairing for C++ integration.
|
||||
*
|
||||
* Revision 1.1 1998/04/18 03:52:04 curt
|
||||
* Moved to Lib directory and created a libDebug.
|
||||
*
|
||||
* Revision 1.10 1998/03/14 00:31:21 curt
|
||||
* Beginning initial terrain texturing experiments.
|
||||
*
|
||||
* Revision 1.9 1998/03/09 22:44:58 curt
|
||||
* Modified so that you can specify FG_DEBUGCLASS ***or*** FG_DEBUG_PRIORITY
|
||||
*
|
||||
* Revision 1.8 1998/03/09 22:11:00 curt
|
||||
* Processed through the format-o-matic.
|
||||
*
|
||||
* Revision 1.7 1998/02/16 13:39:43 curt
|
||||
* Miscellaneous weekend tweaks. Fixed? a cache problem that caused whole
|
||||
* tiles to occasionally be missing.
|
||||
*
|
||||
*/
|
||||
@@ -0,0 +1,156 @@
|
||||
/* -*- Mode: C++ -*-
|
||||
*
|
||||
* fg_debug.h -- Flight Gear debug utility functions
|
||||
*
|
||||
* Written by Paul Bleisch, started January 1998.
|
||||
*
|
||||
* Copyright (C) 1998 Paul Bleisch, pbleisch@acm.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
* (Log is kept at end of this file)
|
||||
**************************************************************************/
|
||||
|
||||
#error "use logstream"
|
||||
|
||||
#ifndef _FG_DEBUG_H
|
||||
#define _FG_DEBUG_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/* NB: To add a dbg_class, add it here, and add it to the structure in
|
||||
fg_debug.c */
|
||||
typedef enum {
|
||||
FG_NONE = 0x00000000,
|
||||
|
||||
FG_TERRAIN = 0x00000001,
|
||||
FG_ASTRO = 0x00000002,
|
||||
FG_FLIGHT = 0x00000004,
|
||||
FG_INPUT = 0x00000008,
|
||||
FG_GL = 0x00000010,
|
||||
FG_VIEW = 0x00000020,
|
||||
FG_COCKPIT = 0x00000040,
|
||||
FG_GENERAL = 0x00000080,
|
||||
FG_MATH = 0x00000100,
|
||||
FG_EVENT = 0x00000200,
|
||||
FG_AIRCRAFT = 0x00000400,
|
||||
FG_AUTOPILOT = 0x00000800,
|
||||
FG_UNDEFD = 0x00001000, // For range checking
|
||||
|
||||
FG_ALL = 0xFFFFFFFF
|
||||
} fgDebugClass;
|
||||
|
||||
/* NB: To add a priority, add it here. */
|
||||
typedef enum {
|
||||
FG_BULK, /* For frequent messages */
|
||||
FG_DEBUG, /* Less frequent debug type messages */
|
||||
FG_INFO, /* Informatory messages */
|
||||
FG_WARN, /* Possible impending problem */
|
||||
FG_ALERT, /* Very possible impending problem */
|
||||
FG_EXIT, /* Problem (no core) */
|
||||
FG_ABORT /* Abandon ship (core) */
|
||||
} fgDebugPriority;
|
||||
|
||||
|
||||
/* Initialize the debuggin stuff. */
|
||||
void fgInitDebug( void );
|
||||
|
||||
|
||||
/* fgPrintf
|
||||
|
||||
Expects:
|
||||
class fgDebugClass mask for this message.
|
||||
prio fgDebugPriority of this message.
|
||||
fmt printf like string format
|
||||
... var args for fmt
|
||||
|
||||
Returns:
|
||||
number of items in fmt handled.
|
||||
|
||||
This function works like the standard C library function printf() with
|
||||
the addition of message classes and priorities (see fgDebugClasses
|
||||
and fgDebugPriorities). These additions allow us to classify messages
|
||||
and disable sets of messages at runtime. Only messages with a prio
|
||||
greater than or equal to fg_DebugPriority and in the current debug class
|
||||
(fg_DebugClass) are printed.
|
||||
*/
|
||||
int fgPrintf( fgDebugClass dbg_class, fgDebugPriority prio, char *fmt, ... );
|
||||
|
||||
|
||||
/* fgSetDebugLevels()
|
||||
|
||||
Expects:
|
||||
dbg_class Bitmask representing classes to display.
|
||||
prio Minimum priority of messages to display.
|
||||
*/
|
||||
void fgSetDebugLevels( fgDebugClass dbg_class, fgDebugPriority prio );
|
||||
|
||||
/* fgSetDebugOutput()
|
||||
|
||||
Expects:
|
||||
file A FILE* to a stream to send messages to.
|
||||
|
||||
It is assumed the file stream is open and writable. The system
|
||||
defaults to stderr. The current stream is flushed but not
|
||||
closed.
|
||||
*/
|
||||
void fgSetDebugOutput( FILE *out );
|
||||
|
||||
|
||||
/* fgRegisterDebugCallback
|
||||
|
||||
Expects:
|
||||
callback A function that takes parameters as defined by the
|
||||
fgDebugCallback type.
|
||||
|
||||
Returns:
|
||||
a pointer to the previously registered callback (if any)
|
||||
|
||||
Install a user defined debug log callback. This callback is called w
|
||||
whenever fgPrintf is called. The parameters passed to the callback are
|
||||
defined above by fgDebugCallback. outstr is the string that is to be
|
||||
printed. If callback returns nonzero, it is assumed that the message
|
||||
was handled fully by the callback and **fgPrintf need do no further
|
||||
processing of the message.** Only one callback may be installed at a
|
||||
time.
|
||||
*/
|
||||
|
||||
//typedef int (*fgDebugCallback)(fgDebugClass, fgDebugPriority, char *outstr);
|
||||
//fgDebugCallback fgRegisterDebugCallback( fgDebugCallback callback );
|
||||
|
||||
typedef int (*fgDebugCallback)( int DebugClass, int DebugPriority, char *outstr);
|
||||
fgDebugCallback fgRegisterDebugCallback( fgDebugCallback callback );
|
||||
|
||||
|
||||
// Leave these alone. Access intended for fg_debug and command line processing.
|
||||
//
|
||||
extern fgDebugClass fg_DebugClass;
|
||||
extern fgDebugPriority fg_DebugPriority;
|
||||
|
||||
extern FILE * fg_DebugOutput;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* _FG_DEBUG_H */
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
// Stream based logging mechanism.
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#include "logstream.hxx"
|
||||
|
||||
bool logbuf::logging_enabled = true;
|
||||
fgDebugClass logbuf::logClass = FG_NONE;
|
||||
fgDebugPriority logbuf::logPriority = FG_INFO;
|
||||
streambuf* logbuf::sbuf = NULL;
|
||||
|
||||
logbuf::logbuf()
|
||||
{
|
||||
// if ( sbuf == NULL )
|
||||
// sbuf = cerr.rdbuf();
|
||||
}
|
||||
|
||||
logbuf::~logbuf()
|
||||
{
|
||||
if ( sbuf )
|
||||
sync();
|
||||
}
|
||||
|
||||
void
|
||||
logbuf::set_sb( streambuf* sb )
|
||||
{
|
||||
if ( sbuf )
|
||||
sync();
|
||||
|
||||
sbuf = sb;
|
||||
}
|
||||
|
||||
void
|
||||
logbuf::set_log_level( fgDebugClass c, fgDebugPriority p )
|
||||
{
|
||||
logClass = c;
|
||||
logPriority = p;
|
||||
}
|
||||
|
||||
void
|
||||
logstream::setLogLevels( fgDebugClass c, fgDebugPriority p )
|
||||
{
|
||||
logbuf::set_log_level( c, p );
|
||||
}
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.2 1999/01/19 20:53:34 curt
|
||||
// Portability updates by Bernie Bright.
|
||||
//
|
||||
// Revision 1.1 1998/11/06 21:20:41 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,231 @@
|
||||
// Stream based logging mechanism.
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#ifndef _LOGSTREAM_H
|
||||
#define _LOGSTREAM_H
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
|
||||
#include <Include/compiler.h>
|
||||
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
# include <streambuf>
|
||||
# include <iostream>
|
||||
#else
|
||||
# include <iostream.h>
|
||||
# include "Include/fg_traits.hxx"
|
||||
#endif
|
||||
|
||||
#include "debug_types.h"
|
||||
|
||||
#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
|
||||
FG_USING_STD(streambuf);
|
||||
FG_USING_STD(ostream);
|
||||
FG_USING_STD(cerr);
|
||||
FG_USING_STD(endl);
|
||||
#endif
|
||||
|
||||
//
|
||||
// TODO:
|
||||
//
|
||||
// 1. Change output destination. Done.
|
||||
// 2. Make logbuf thread safe.
|
||||
// 3. Read environment for default debugClass and debugPriority.
|
||||
//
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// logbuf is an output-only streambuf with the ability to disable sets of
|
||||
// messages at runtime. Only messages with priority >= logbuf::logPriority
|
||||
// and debugClass == logbuf::logClass are output.
|
||||
//
|
||||
class logbuf : public streambuf
|
||||
{
|
||||
public:
|
||||
|
||||
#ifndef FG_HAVE_STD_INCLUDES
|
||||
typedef char_traits<char> traits_type;
|
||||
typedef char_traits<char>::int_type int_type;
|
||||
typedef char_traits<char>::pos_type pos_type;
|
||||
typedef char_traits<char>::off_type off_type;
|
||||
#endif
|
||||
// logbuf( streambuf* sb ) : sbuf(sb) {}
|
||||
logbuf();
|
||||
~logbuf();
|
||||
|
||||
// Is logging enabled?
|
||||
bool enabled() { return logging_enabled; }
|
||||
|
||||
// Set the logging level of subsequent messages.
|
||||
void set_log_state( fgDebugClass c, fgDebugPriority p );
|
||||
|
||||
// Set the global logging level.
|
||||
static void set_log_level( fgDebugClass c, fgDebugPriority p );
|
||||
|
||||
//
|
||||
void set_sb( streambuf* sb );
|
||||
|
||||
protected:
|
||||
|
||||
inline virtual int sync();
|
||||
int_type overflow( int ch );
|
||||
// int xsputn( const char* s, istreamsize n );
|
||||
|
||||
private:
|
||||
|
||||
// The streambuf used for actual output. Defaults to cerr.rdbuf().
|
||||
static streambuf* sbuf;
|
||||
|
||||
static bool logging_enabled;
|
||||
static fgDebugClass logClass;
|
||||
static fgDebugPriority logPriority;
|
||||
|
||||
private:
|
||||
|
||||
// Not defined.
|
||||
logbuf( const logbuf& );
|
||||
void operator= ( const logbuf& );
|
||||
};
|
||||
|
||||
inline int
|
||||
logbuf::sync()
|
||||
{
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
return sbuf->pubsync();
|
||||
#else
|
||||
return sbuf->sync();
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void
|
||||
logbuf::set_log_state( fgDebugClass c, fgDebugPriority p )
|
||||
{
|
||||
logging_enabled = ((c & logClass) != 0 && p >= logPriority);
|
||||
}
|
||||
|
||||
inline logbuf::int_type
|
||||
logbuf::overflow( int c )
|
||||
{
|
||||
return logging_enabled ? sbuf->sputc(c) : (EOF == 0 ? 1: 0);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// logstream manipulator for setting the log level of a message.
|
||||
//
|
||||
struct loglevel
|
||||
{
|
||||
loglevel( fgDebugClass c, fgDebugPriority p )
|
||||
: logClass(c), logPriority(p) {}
|
||||
|
||||
fgDebugClass logClass;
|
||||
fgDebugPriority logPriority;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// A helper class that ensures a streambuf and ostream are constructed and
|
||||
// destroyed in the correct order. The streambuf must be created before the
|
||||
// ostream but bases are constructed before members. Thus, making this class
|
||||
// a private base of logstream, declared to the left of ostream, we ensure the
|
||||
// correct order of construction and destruction.
|
||||
//
|
||||
struct logstream_base
|
||||
{
|
||||
// logstream_base( streambuf* sb ) : lbuf(sb) {}
|
||||
logstream_base() {}
|
||||
|
||||
logbuf lbuf;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
//
|
||||
//
|
||||
class logstream : private logstream_base, public ostream
|
||||
{
|
||||
public:
|
||||
// The default is to send messages to cerr.
|
||||
logstream( ostream& out )
|
||||
// : logstream_base(out.rdbuf()),
|
||||
: logstream_base(),
|
||||
ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
|
||||
|
||||
void set_output( ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
|
||||
|
||||
// Set the global log class and priority level.
|
||||
void setLogLevels( fgDebugClass c, fgDebugPriority p );
|
||||
|
||||
// Output operator to capture the debug level and priority of a message.
|
||||
inline ostream& operator<< ( const loglevel& l );
|
||||
};
|
||||
|
||||
inline ostream&
|
||||
logstream::operator<< ( const loglevel& l )
|
||||
{
|
||||
lbuf.set_log_state( l.logClass, l.logPriority );
|
||||
return *this;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Return the one and only logstream instance.
|
||||
// We use a function instead of a global object so we are assured that cerr
|
||||
// has been initialised.
|
||||
//
|
||||
inline logstream&
|
||||
fglog()
|
||||
{
|
||||
static logstream logstrm( cerr );
|
||||
return logstrm;
|
||||
}
|
||||
|
||||
#ifdef FG_NDEBUG
|
||||
# define FG_LOG(C,P,M)
|
||||
#else
|
||||
# define FG_LOG(C,P,M) fglog() << loglevel(C,P) << M << endl
|
||||
#endif
|
||||
|
||||
#endif // _LOGSTREAM_H
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.4 1999/03/02 01:01:47 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.3 1999/01/19 20:53:35 curt
|
||||
// Portability updates by Bernie Bright.
|
||||
//
|
||||
// Revision 1.2 1998/11/07 19:07:02 curt
|
||||
// Enable release builds using the --without-logging option to the configure
|
||||
// script. Also a couple log message cleanups, plus some C to C++ comment
|
||||
// conversion.
|
||||
//
|
||||
// Revision 1.1 1998/11/06 21:20:42 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <string>
|
||||
#include "Debug/logstream.hxx"
|
||||
|
||||
int
|
||||
main( int argc, char* argv[] )
|
||||
{
|
||||
fglog().setLogLevels( FG_ALL, FG_INFO );
|
||||
|
||||
FG_LOG( FG_TERRAIN, FG_BULK, "terrain::bulk" ); // shouldnt appear
|
||||
FG_LOG( FG_TERRAIN, FG_DEBUG, "terrain::debug" ); // shouldnt appear
|
||||
FG_LOG( FG_TERRAIN, FG_INFO, "terrain::info" );
|
||||
FG_LOG( FG_TERRAIN, FG_WARN, "terrain::warn" );
|
||||
FG_LOG( FG_TERRAIN, FG_ALERT, "terrain::alert" );
|
||||
|
||||
int i = 12345;
|
||||
long l = 54321L;
|
||||
double d = 3.14159;
|
||||
string s = "Hello world!";
|
||||
|
||||
FG_LOG( FG_EVENT, FG_INFO, "event::info "
|
||||
<< "i=" << i
|
||||
<< ", l=" << l
|
||||
<< ", d=" << d
|
||||
<< ", d*l=" << d*l
|
||||
<< ", s=\"" << s << "\"" );
|
||||
|
||||
// This shouldn't appear in log output:
|
||||
FG_LOG( FG_EVENT, FG_DEBUG, "event::debug "
|
||||
<< "- this should be seen - "
|
||||
<< "d=" << d
|
||||
<< ", s=\"" << s << "\"" );
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
/* #include "HEADERS.h" */
|
||||
/* Copyright 1988, Brown Computer Graphics Group. All Rights Reserved. */
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
* This file contains routines that perform geometry-related operations
|
||||
* on matrices.
|
||||
* -------------------------------------------------------------------------*/
|
||||
|
||||
#include <Math/mat3defs.h>
|
||||
|
||||
/* -------------------------- Static Routines ---------------------------- */
|
||||
|
||||
/* ------------------------- Internal Routines --------------------------- */
|
||||
|
||||
/* -------------------------- Public Routines ---------------------------- */
|
||||
|
||||
/*
|
||||
* This takes a matrix used to transform points, and returns a corresponding
|
||||
* matrix that can be used to transform direction vectors (between points).
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3direction_matrix(register double (*result_mat)[4], register double (*mat)[4])
|
||||
{
|
||||
register int i;
|
||||
|
||||
MAT3copy(result_mat, mat);
|
||||
|
||||
for (i = 0; i < 4; i++) result_mat[i][3] = result_mat[3][i] = 0.0;
|
||||
|
||||
result_mat[3][3] = 1.0;
|
||||
}
|
||||
|
||||
/*
|
||||
* This takes a matrix used to transform points, and returns a corresponding
|
||||
* matrix that can be used to transform vectors that must remain perpendicular
|
||||
* to planes defined by the points. It is useful when you are transforming
|
||||
* some object that has both points and normals in its definition, and you
|
||||
* only have the transformation matrix for the points. This routine returns
|
||||
* FALSE if the normal matrix is uncomputable. Otherwise, it returns TRUE.
|
||||
*
|
||||
* Spike sez: "This is the adjoint for the non-homogeneous part of the
|
||||
* transformation."
|
||||
*/
|
||||
|
||||
int
|
||||
MAT3normal_matrix(register double (*result_mat)[4], register double (*mat)[4])
|
||||
{
|
||||
register int ret;
|
||||
MAT3mat tmp_mat;
|
||||
|
||||
MAT3direction_matrix(result_mat, mat);
|
||||
|
||||
if ( (ret = MAT3invert(tmp_mat, tmp_mat)) ) {
|
||||
MAT3transpose(result_mat, tmp_mat);
|
||||
}
|
||||
|
||||
return(ret);
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets the given matrix to be a scale matrix for the given vector of
|
||||
* scale values.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3scale(double (*result_mat)[4], double *scale)
|
||||
{
|
||||
MAT3identity(result_mat);
|
||||
|
||||
result_mat[0][0] = scale[0];
|
||||
result_mat[1][1] = scale[1];
|
||||
result_mat[2][2] = scale[2];
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets up a matrix for a rotation about an axis given by the line from
|
||||
* (0,0,0) to axis, through an angle (in radians).
|
||||
* Looking along the axis toward the origin, the rotation is counter-clockwise.
|
||||
*/
|
||||
|
||||
#define SELECT .7071 /* selection constant (roughly .5*sqrt(2) */
|
||||
|
||||
void
|
||||
MAT3rotate(double (*result_mat)[4], double *axis, double angle_in_radians)
|
||||
{
|
||||
MAT3vec naxis, /* Axis of rotation, normalized */
|
||||
base2, /* 2nd unit basis vec, perp to axis */
|
||||
base3; /* 3rd unit basis vec, perp to axis & base2 */
|
||||
double dot;
|
||||
MAT3mat base_mat, /* Change-of-basis matrix */
|
||||
base_mat_trans; /* Inverse of c-o-b matrix */
|
||||
register int i;
|
||||
|
||||
/* Step 1: extend { axis } to a basis for 3-space: { axis, base2, base3 }
|
||||
* which is orthonormal (all three have unit length, and all three are
|
||||
* mutually orthogonal). Also should be oriented, i.e. axis cross base2 =
|
||||
* base3, rather than -base3.
|
||||
*
|
||||
* Method: Find a vector linearly independent from axis. For this we
|
||||
* either use the y-axis, or, if that is too close to axis, the
|
||||
* z-axis. 'Too close' means that the dot product is too near to 1.
|
||||
*/
|
||||
|
||||
MAT3_COPY_VEC(naxis, axis);
|
||||
MAT3_NORMALIZE_VEC(naxis, dot);
|
||||
|
||||
if (dot == 0.0) {
|
||||
/* ERR_ERROR(MAT3_errid, ERR_SEVERE,
|
||||
(ERR_S, "Zero-length axis vector given to MAT3rotate")); */
|
||||
return;
|
||||
}
|
||||
|
||||
MAT3perp_vec(base2, naxis, TRUE);
|
||||
MAT3cross_product(base3, naxis, base2);
|
||||
|
||||
/* Set up the change-of-basis matrix, and its inverse */
|
||||
MAT3identity(base_mat);
|
||||
MAT3identity(base_mat_trans);
|
||||
MAT3identity(result_mat);
|
||||
|
||||
for (i = 0; i < 3; i++){
|
||||
base_mat_trans[i][0] = base_mat[0][i] = naxis[i];
|
||||
base_mat_trans[i][1] = base_mat[1][i] = base2[i];
|
||||
base_mat_trans[i][2] = base_mat[2][i] = base3[i];
|
||||
}
|
||||
|
||||
/* If T(u) = uR, where R is base_mat, then T(x-axis) = naxis,
|
||||
* T(y-axis) = base2, and T(z-axis) = base3. The inverse of base_mat is
|
||||
* its transpose. OK?
|
||||
*/
|
||||
|
||||
result_mat[1][1] = result_mat[2][2] = cos(angle_in_radians);
|
||||
result_mat[2][1] = -(result_mat[1][2] = sin(angle_in_radians));
|
||||
|
||||
MAT3mult(result_mat, base_mat_trans, result_mat);
|
||||
MAT3mult(result_mat, result_mat, base_mat);
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets the given matrix to be a translation matrix for the given vector of
|
||||
* translation values.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3translate(double (*result_mat)[4], double *trans)
|
||||
{
|
||||
MAT3identity(result_mat);
|
||||
|
||||
result_mat[3][0] = trans[0];
|
||||
result_mat[3][1] = trans[1];
|
||||
result_mat[3][2] = trans[2];
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets the given matrix to be a shear matrix for the given x and y shear
|
||||
* values.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3shear(double (*result_mat)[4], double xshear, double yshear)
|
||||
{
|
||||
MAT3identity(result_mat);
|
||||
|
||||
result_mat[2][0] = xshear;
|
||||
result_mat[2][1] = yshear;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,311 @@
|
||||
/* Copyright 1988, Brown Computer Graphics Group. All Rights Reserved. */
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
* This file contains routines that operate solely on matrices.
|
||||
* -------------------------------------------------------------------------*/
|
||||
|
||||
#include <Math/mat3defs.h>
|
||||
|
||||
/* -------------------------- Static Routines ---------------------------- */
|
||||
|
||||
#define SMALL 1e-20 /* Small enough to be considered zero */
|
||||
|
||||
/*
|
||||
* Shuffles rows in inverse of 3x3. See comment in MAT3_inv3_second_col().
|
||||
*/
|
||||
|
||||
static void
|
||||
MAT3_inv3_swap( register double inv[3][3], int row0, int row1, int row2)
|
||||
{
|
||||
register int i, tempi;
|
||||
double temp;
|
||||
|
||||
#define SWAP_ROWS(a, b) \
|
||||
for (i = 0; i < 3; i++) SWAP(inv[a][i], inv[b][i], temp); \
|
||||
SWAP(a, b, tempi)
|
||||
|
||||
if (row0 != 0){
|
||||
if (row1 == 0) {
|
||||
SWAP_ROWS(row0, row1);
|
||||
}
|
||||
else {
|
||||
SWAP_ROWS(row0, row2);
|
||||
}
|
||||
}
|
||||
|
||||
if (row1 != 1) {
|
||||
SWAP_ROWS(row1, row2);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Does Gaussian elimination on second column.
|
||||
*/
|
||||
|
||||
static int
|
||||
MAT3_inv3_second_col (register double source[3][3], register double inv[3][3], int row0)
|
||||
{
|
||||
register int row1, row2, i1, i2, i;
|
||||
double temp;
|
||||
double a, b;
|
||||
|
||||
/* Find which row to use */
|
||||
if (row0 == 0) i1 = 1, i2 = 2;
|
||||
else if (row0 == 1) i1 = 0, i2 = 2;
|
||||
else i1 = 0, i2 = 1;
|
||||
|
||||
/* Find which is larger in abs. val.:the entry in [i1][1] or [i2][1] */
|
||||
/* and use that value for pivoting. */
|
||||
|
||||
a = source[i1][1]; if (a < 0) a = -a;
|
||||
b = source[i2][1]; if (b < 0) b = -b;
|
||||
if (a > b) row1 = i1;
|
||||
else row1 = i2;
|
||||
row2 = (row1 == i1 ? i2 : i1);
|
||||
|
||||
/* Scale row1 in source */
|
||||
if ((source[row1][1] < SMALL) && (source[row1][1] > -SMALL)) return(FALSE);
|
||||
temp = 1.0 / source[row1][1];
|
||||
source[row1][1] = 1.0;
|
||||
source[row1][2] *= temp; /* source[row1][0] is zero already */
|
||||
|
||||
/* Scale row1 in inv */
|
||||
inv[row1][row1] = temp; /* it used to be a 1.0 */
|
||||
inv[row1][row0] *= temp;
|
||||
|
||||
/* Clear column one, source, and make corresponding changes in inv */
|
||||
|
||||
for (i = 0; i < 3; i++) if (i != row1) { /* for i = all rows but row1 */
|
||||
temp = -source[i][1];
|
||||
source[i][1] = 0.0;
|
||||
source[i][2] += temp * source[row1][2];
|
||||
|
||||
inv[i][row1] = temp * inv[row1][row1];
|
||||
inv[i][row0] += temp * inv[row1][row0];
|
||||
}
|
||||
|
||||
/* Scale row2 in source */
|
||||
if ((source[row2][2] < SMALL) && (source[row2][2] > -SMALL)) return(FALSE);
|
||||
temp = 1.0 / source[row2][2];
|
||||
source[row2][2] = 1.0; /* source[row2][*] is zero already */
|
||||
|
||||
/* Scale row2 in inv */
|
||||
inv[row2][row2] = temp; /* it used to be a 1.0 */
|
||||
inv[row2][row0] *= temp;
|
||||
inv[row2][row1] *= temp;
|
||||
|
||||
/* Clear column one, source, and make corresponding changes in inv */
|
||||
for (i = 0; i < 3; i++) if (i != row2) { /* for i = all rows but row2 */
|
||||
temp = -source[i][2];
|
||||
source[i][2] = 0.0;
|
||||
inv[i][row0] += temp * inv[row2][row0];
|
||||
inv[i][row1] += temp * inv[row2][row1];
|
||||
inv[i][row2] += temp * inv[row2][row2];
|
||||
}
|
||||
|
||||
/*
|
||||
* Now all is done except that the inverse needs to have its rows shuffled.
|
||||
* row0 needs to be moved to inv[0][*], row1 to inv[1][*], etc.
|
||||
*
|
||||
* We *didn't* do the swapping before the elimination so that we could more
|
||||
* easily keep track of what ops are needed to be done in the inverse.
|
||||
*/
|
||||
MAT3_inv3_swap(inv, row0, row1, row2);
|
||||
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Fast inversion routine for 3 x 3 matrices. - Written by jfh.
|
||||
*
|
||||
* This takes 30 multiplies/divides, as opposed to 39 for Cramer's Rule.
|
||||
* The algorithm consists of performing fast gaussian elimination, by never
|
||||
* doing any operations where the result is guaranteed to be zero, or where
|
||||
* one operand is guaranteed to be zero. This is done at the cost of clarity,
|
||||
* alas.
|
||||
*
|
||||
* Returns 1 if the inverse was successful, 0 if it failed.
|
||||
*/
|
||||
|
||||
static int
|
||||
MAT3_invert3 (register double source[3][3], register double inv[3][3])
|
||||
{
|
||||
register int i, row0;
|
||||
double temp;
|
||||
double a, b, c;
|
||||
|
||||
inv[0][0] = inv[1][1] = inv[2][2] = 1.0;
|
||||
inv[0][1] = inv[0][2] = inv[1][0] = inv[1][2] = inv[2][0] = inv[2][1] = 0.0;
|
||||
|
||||
/* attempt to find the largest entry in first column to use as pivot */
|
||||
a = source[0][0]; if (a < 0) a = -a;
|
||||
b = source[1][0]; if (b < 0) b = -b;
|
||||
c = source[2][0]; if (c < 0) c = -c;
|
||||
|
||||
if (a > b) {
|
||||
if (a > c) row0 = 0;
|
||||
else row0 = 2;
|
||||
}
|
||||
else {
|
||||
if (b > c) row0 = 1;
|
||||
else row0 = 2;
|
||||
}
|
||||
|
||||
/* Scale row0 of source */
|
||||
if ((source[row0][0] < SMALL) && (source[row0][0] > -SMALL)) return(FALSE);
|
||||
temp = 1.0 / source[row0][0];
|
||||
source[row0][0] = 1.0;
|
||||
source[row0][1] *= temp;
|
||||
source[row0][2] *= temp;
|
||||
|
||||
/* Scale row0 of inverse */
|
||||
inv[row0][row0] = temp; /* other entries are zero -- no effort */
|
||||
|
||||
/* Clear column zero of source, and make corresponding changes in inverse */
|
||||
|
||||
for (i = 0; i < 3; i++) if (i != row0) { /* for i = all rows but row0 */
|
||||
temp = -source[i][0];
|
||||
source[i][0] = 0.0;
|
||||
source[i][1] += temp * source[row0][1];
|
||||
source[i][2] += temp * source[row0][2];
|
||||
inv[i][row0] = temp * inv[row0][row0];
|
||||
}
|
||||
|
||||
/*
|
||||
* We've now done gaussian elimination so that the source and
|
||||
* inverse look like this:
|
||||
*
|
||||
* 1 * * * 0 0
|
||||
* 0 * * * 1 0
|
||||
* 0 * * * 0 1
|
||||
*
|
||||
* We now proceed to do elimination on the second column.
|
||||
*/
|
||||
if (! MAT3_inv3_second_col(source, inv, row0)) return(FALSE);
|
||||
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Finds a new pivot for a non-simple 4x4. See comments in MAT3invert().
|
||||
*/
|
||||
|
||||
static int
|
||||
MAT3_inv4_pivot (register MAT3mat src, MAT3vec r, double *s, int *swap)
|
||||
{
|
||||
register int i, j;
|
||||
double temp, max;
|
||||
|
||||
*swap = -1;
|
||||
|
||||
if (MAT3_IS_ZERO(src[3][3])) {
|
||||
|
||||
/* Look for a different pivot element: one with largest abs value */
|
||||
max = 0.0;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (src[i][3] > max) max = src[*swap = i][3];
|
||||
else if (src[i][3] < -max) max = -src[*swap = i][3];
|
||||
}
|
||||
|
||||
/* No pivot element available ! */
|
||||
if (*swap < 0) return(FALSE);
|
||||
|
||||
else for (j = 0; j < 4; j++) SWAP(src[*swap][j], src[3][j], temp);
|
||||
}
|
||||
|
||||
MAT3_SET_VEC (r, -src[0][3], -src[1][3], -src[2][3]);
|
||||
|
||||
*s = 1.0 / src[3][3];
|
||||
|
||||
src[0][3] = src[1][3] = src[2][3] = 0.0;
|
||||
src[3][3] = 1.0;
|
||||
|
||||
MAT3_SCALE_VEC(src[3], src[3], *s);
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
src[0][i] += r[0] * src[3][i];
|
||||
src[1][i] += r[1] * src[3][i];
|
||||
src[2][i] += r[2] * src[3][i];
|
||||
}
|
||||
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* ------------------------- Internal Routines --------------------------- */
|
||||
|
||||
/* -------------------------- Public Routines ---------------------------- */
|
||||
|
||||
/*
|
||||
* This returns the inverse of the given matrix. The result matrix
|
||||
* may be the same as the one to invert.
|
||||
*
|
||||
* Fast inversion routine for 4 x 4 matrices, written by jfh.
|
||||
*
|
||||
* Returns 1 if the inverse was successful, 0 if it failed.
|
||||
*
|
||||
* This routine has been specially tweaked to notice the following:
|
||||
* If the matrix has the form
|
||||
* * * * 0
|
||||
* * * * 0
|
||||
* * * * 0
|
||||
* * * * 1
|
||||
*
|
||||
* (as do many matrices in graphics), then we compute the inverse of
|
||||
* the upper left 3x3 matrix and use this to find the general inverse.
|
||||
*
|
||||
* In the event that the right column is not 0-0-0-1, we do gaussian
|
||||
* elimination to make it so, then use the 3x3 inverse, and then do
|
||||
* our gaussian elimination.
|
||||
*/
|
||||
|
||||
int
|
||||
MAT3invert(double (*result_mat)[4], double (*mat)[4])
|
||||
{
|
||||
MAT3mat src, inv;
|
||||
register int i, j, simple;
|
||||
double m[3][3], inv3[3][3], s, temp;
|
||||
MAT3vec r, t;
|
||||
int swap;
|
||||
|
||||
MAT3copy(src, mat);
|
||||
MAT3identity(inv);
|
||||
|
||||
/* If last column is not (0,0,0,1), use special code */
|
||||
simple = (mat[0][3] == 0.0 && mat[1][3] == 0.0 &&
|
||||
mat[2][3] == 0.0 && mat[3][3] == 1.0);
|
||||
|
||||
if (! simple && ! MAT3_inv4_pivot(src, r, &s, &swap)) return(FALSE);
|
||||
|
||||
MAT3_COPY_VEC(t, src[3]); /* Translation vector */
|
||||
|
||||
/* Copy upper-left 3x3 matrix */
|
||||
for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) m[i][j] = src[i][j];
|
||||
|
||||
if (! MAT3_invert3(m, inv3)) return(FALSE);
|
||||
|
||||
for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) inv[i][j] = inv3[i][j];
|
||||
|
||||
for (i = 0; i < 3; i++) for (j = 0; j < 3; j++)
|
||||
inv[3][i] -= t[j] * inv3[j][i];
|
||||
|
||||
if (! simple) {
|
||||
|
||||
/* We still have to undo our gaussian elimination from earlier on */
|
||||
/* add r0 * first col to last col */
|
||||
/* add r1 * 2nd col to last col */
|
||||
/* add r2 * 3rd col to last col */
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
inv[i][3] += r[0] * inv[i][0] + r[1] * inv[i][1] + r[2] * inv[i][2];
|
||||
inv[i][3] *= s;
|
||||
}
|
||||
|
||||
if (swap >= 0)
|
||||
for (i = 0; i < 4; i++) SWAP(inv[i][swap], inv[i][3], temp);
|
||||
}
|
||||
|
||||
MAT3copy(result_mat, inv);
|
||||
|
||||
return(TRUE);
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
/* #include "HEADERS.h" */
|
||||
/* Copyright 1988, Brown Computer Graphics Group. All Rights Reserved. */
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
* This file contains routines that operate solely on matrices.
|
||||
* -------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
# ifndef HAVE_STL_SGI_PORT
|
||||
# include <memory.h> /* required for memset() and memcpy() */
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <Math/mat3defs.h>
|
||||
|
||||
MAT3mat identityMatrix = {
|
||||
{ 1.0, 0.0, 0.0, 0.0 },
|
||||
{ 0.0, 1.0, 0.0, 0.0 },
|
||||
{ 0.0, 0.0, 1.0, 0.0 },
|
||||
{ 0.0, 0.0, 0.0, 1.0 }
|
||||
};
|
||||
|
||||
/* #include "macros.h" */
|
||||
|
||||
/* -------------------------- Static Routines ---------------------------- */
|
||||
|
||||
/* ------------------------- Internal Routines --------------------------- */
|
||||
|
||||
/* -------------------------- Public Routines ---------------------------- */
|
||||
|
||||
|
||||
#if !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/*
|
||||
* This multiplies two matrices, producing a third, which may the same as
|
||||
* either of the first two.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3mult (double (*result_mat)[4], register double (*mat1)[4], register double (*mat2)[4])
|
||||
{
|
||||
register int i, j;
|
||||
MAT3mat tmp_mat;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
for (j = 0; j < 4; j++)
|
||||
tmp_mat[i][j] = (mat1[i][0] * mat2[0][j] +
|
||||
mat1[i][1] * mat2[1][j] +
|
||||
mat1[i][2] * mat2[2][j] +
|
||||
mat1[i][3] * mat2[3][j]);
|
||||
MAT3copy (result_mat, tmp_mat);
|
||||
}
|
||||
#endif // !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/*
|
||||
* This returns the transpose of a matrix. The result matrix may be
|
||||
* the same as the one to transpose.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3transpose (double (*result_mat)[4], register double (*mat)[4])
|
||||
{
|
||||
register int i, j;
|
||||
MAT3mat tmp_mat;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
for (j = 0; j < 4; j++)
|
||||
tmp_mat[i][j] = mat[j][i];
|
||||
|
||||
MAT3copy (result_mat, tmp_mat);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* This prints the given matrix to the given file pointer.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3print(double (*mat)[4], FILE *fp)
|
||||
{
|
||||
MAT3print_formatted(mat, fp, CNULL, CNULL, CNULL, CNULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* This prints the given matrix to the given file pointer.
|
||||
* use the format string to pass to fprintf. head and tail
|
||||
* are printed at the beginning and end of each line.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3print_formatted(double (*mat)[4], FILE *fp, char *title, char *head, char *format, char *tail)
|
||||
{
|
||||
register int i, j;
|
||||
|
||||
/* This is to allow this to be called easily from a debugger */
|
||||
if (fp == NULL) fp = stderr;
|
||||
|
||||
if (title == NULL) title = "MAT3 matrix:\n";
|
||||
if (head == NULL) head = " ";
|
||||
if (format == NULL) format = "%#8.4lf ";
|
||||
if (tail == NULL) tail = "\n";
|
||||
|
||||
(void) fprintf(fp, title);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
(void) fprintf(fp, head);
|
||||
for (j = 0; j < 4; j++) (void) fprintf(fp, format, mat[i][j]);
|
||||
(void) fprintf(fp, tail);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
/* Copyright 1988, Brown Computer Graphics Group. All Rights Reserved. */
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
* This file contains routines that operate on matrices and vectors, or
|
||||
* vectors and vectors.
|
||||
* -------------------------------------------------------------------------*/
|
||||
|
||||
/* #include "sphigslocal.h" */
|
||||
|
||||
/* -------------------------- Static Routines ---------------------------- */
|
||||
|
||||
/* ------------------------- Internal Routines --------------------------- */
|
||||
|
||||
/* -------------------------- Public Routines ---------------------------- */
|
||||
|
||||
/*
|
||||
* Multiplies a vector by a matrix, setting the result vector.
|
||||
* It assumes all homogeneous coordinates are 1.
|
||||
* The two vectors involved may be the same.
|
||||
*/
|
||||
|
||||
#include <Math/mat3.h>
|
||||
|
||||
#ifndef TRUE
|
||||
# define TRUE 1
|
||||
#endif
|
||||
|
||||
#ifndef FALSE
|
||||
# define FALSE 0
|
||||
#endif
|
||||
|
||||
#if !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
void
|
||||
MAT3mult_vec(double *result_vec, register double *vec, register double (*mat)[4])
|
||||
{
|
||||
MAT3vec tempvec;
|
||||
register double *temp = tempvec;
|
||||
|
||||
temp[0] = vec[0] * mat[0][0] + vec[1] * mat[1][0] +
|
||||
vec[2] * mat[2][0] + mat[3][0];
|
||||
temp[1] = vec[0] * mat[0][1] + vec[1] * mat[1][1] +
|
||||
vec[2] * mat[2][1] + mat[3][1];
|
||||
temp[2] = vec[0] * mat[0][2] + vec[1] * mat[1][2] +
|
||||
vec[2] * mat[2][2] + mat[3][2];
|
||||
|
||||
MAT3_COPY_VEC(result_vec, temp);
|
||||
}
|
||||
#endif // !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/*
|
||||
* Multiplies a vector of size 4 by a matrix, setting the result vector.
|
||||
* The fourth element of the vector is the homogeneous coordinate, which
|
||||
* may or may not be 1. If the "normalize" parameter is TRUE, then the
|
||||
* result vector will be normalized so that the homogeneous coordinate is 1.
|
||||
* The two vectors involved may be the same.
|
||||
* This returns zero if the vector was to be normalized, but couldn't be.
|
||||
*/
|
||||
|
||||
int
|
||||
MAT3mult_hvec(double *result_vec, register double *vec, register double (*mat)[4], int normalize)
|
||||
{
|
||||
MAT3hvec tempvec;
|
||||
double norm_fac;
|
||||
register double *temp = tempvec;
|
||||
register int ret = TRUE;
|
||||
|
||||
temp[0] = vec[0] * mat[0][0] + vec[1] * mat[1][0] +
|
||||
vec[2] * mat[2][0] + vec[3] * mat[3][0];
|
||||
temp[1] = vec[0] * mat[0][1] + vec[1] * mat[1][1] +
|
||||
vec[2] * mat[2][1] + vec[3] * mat[3][1];
|
||||
temp[2] = vec[0] * mat[0][2] + vec[1] * mat[1][2] +
|
||||
vec[2] * mat[2][2] + vec[3] * mat[3][2];
|
||||
temp[3] = vec[0] * mat[0][3] + vec[1] * mat[1][3] +
|
||||
vec[2] * mat[2][3] + vec[3] * mat[3][3];
|
||||
|
||||
/* Normalize if asked for, possible, and necessary */
|
||||
if (normalize) {
|
||||
if (MAT3_IS_ZERO(temp[3])) {
|
||||
#ifndef THINK_C
|
||||
fprintf (stderr,
|
||||
"Can't normalize vector: homogeneous coordinate is 0");
|
||||
#endif
|
||||
ret = FALSE;
|
||||
}
|
||||
else {
|
||||
norm_fac = 1.0 / temp[3];
|
||||
MAT3_SCALE_VEC(result_vec, temp, norm_fac);
|
||||
result_vec[3] = 1.0;
|
||||
}
|
||||
}
|
||||
else MAT3_COPY_HVEC(result_vec, temp);
|
||||
|
||||
return(ret);
|
||||
}
|
||||
|
||||
#if !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/*
|
||||
* Sets the first vector to be the cross-product of the last two vectors.
|
||||
*/
|
||||
|
||||
void
|
||||
MAT3cross_product(double *result_vec, register double *vec1, register double *vec2)
|
||||
{
|
||||
MAT3vec tempvec;
|
||||
register double *temp = tempvec;
|
||||
|
||||
temp[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
|
||||
temp[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
|
||||
temp[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
|
||||
|
||||
MAT3_COPY_VEC(result_vec, temp);
|
||||
}
|
||||
#endif // !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/*
|
||||
* Finds a vector perpendicular to vec and stores it in result_vec.
|
||||
* Method: take any vector (we use <0,1,0>) and subtract the
|
||||
* portion of it pointing in the vec direction. This doesn't
|
||||
* work if vec IS <0,1,0> or is very near it. So if this is
|
||||
* the case, use <0,0,1> instead.
|
||||
* If "is_unit" is TRUE, the given vector is assumed to be unit length.
|
||||
*/
|
||||
|
||||
#define SELECT .7071 /* selection constant (roughly .5*sqrt(2) */
|
||||
|
||||
void
|
||||
MAT3perp_vec(double *result_vec, double *vec, int is_unit)
|
||||
{
|
||||
MAT3vec norm;
|
||||
double dot;
|
||||
|
||||
MAT3_SET_VEC(result_vec, 0.0, 1.0, 0.0);
|
||||
|
||||
MAT3_COPY_VEC(norm, vec);
|
||||
|
||||
if (! is_unit) MAT3_NORMALIZE_VEC(norm, dot);
|
||||
|
||||
/* See if vector is too close to <0,1,0>. If so, use <0,0,1> */
|
||||
if ((dot = MAT3_DOT_PRODUCT(norm, result_vec)) > SELECT || dot < -SELECT) {
|
||||
result_vec[1] = 0.0;
|
||||
result_vec[2] = 1.0;
|
||||
dot = MAT3_DOT_PRODUCT(norm, result_vec);
|
||||
}
|
||||
|
||||
/* Subtract off non-perpendicular part */
|
||||
result_vec[0] -= dot * norm[0];
|
||||
result_vec[1] -= dot * norm[1];
|
||||
result_vec[2] -= dot * norm[2];
|
||||
|
||||
/* Make result unit length */
|
||||
MAT3_NORMALIZE_VEC(result_vec, dot);
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
noinst_LIBRARIES = libMath.a
|
||||
|
||||
libMath_a_SOURCES = \
|
||||
MAT3geom.c \
|
||||
MAT3inv.c \
|
||||
MAT3mat.c \
|
||||
MAT3vec.c \
|
||||
fg_geodesy.cxx fg_geodesy.hxx \
|
||||
fg_random.c fg_random.h \
|
||||
interpolater.cxx interpolater.hxx \
|
||||
leastsqs.cxx leastsqs.hxx \
|
||||
mat3.h mat3defs.h mat3err.h \
|
||||
point3d.hxx \
|
||||
polar3d.cxx polar3d.hxx \
|
||||
vector.cxx vector.hxx
|
||||
|
||||
INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib -I$(top_builddir)/Simulator
|
||||
@@ -0,0 +1,307 @@
|
||||
// fg_geodesy.cxx -- routines to convert between geodetic and geocentric
|
||||
// coordinate systems.
|
||||
//
|
||||
// Copied and adapted directly from LaRCsim/ls_geodesy.c
|
||||
//
|
||||
// See below for the complete original LaRCsim comments.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#include "Include/compiler.h"
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
# include <cmath>
|
||||
# include <cerrno>
|
||||
#else
|
||||
# include <math.h>
|
||||
# include <errno.h>
|
||||
#endif
|
||||
|
||||
#include <Include/fg_constants.h>
|
||||
#include <Math/fg_geodesy.hxx>
|
||||
#include <Math/point3d.hxx>
|
||||
|
||||
#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
|
||||
FG_USING_STD(cout);
|
||||
#endif
|
||||
|
||||
// ONE_SECOND is pi/180/60/60, or about 100 feet at earths' equator
|
||||
#define ONE_SECOND 4.848136811E-6
|
||||
|
||||
|
||||
// fgGeocToGeod(lat_geoc, radius, *lat_geod, *alt, *sea_level_r)
|
||||
// INPUTS:
|
||||
// lat_geoc Geocentric latitude, radians, + = North
|
||||
// radius C.G. radius to earth center (meters)
|
||||
//
|
||||
// OUTPUTS:
|
||||
// lat_geod Geodetic latitude, radians, + = North
|
||||
// alt C.G. altitude above mean sea level (meters)
|
||||
// sea_level_r radius from earth center to sea level at
|
||||
// local vertical (surface normal) of C.G. (meters)
|
||||
|
||||
|
||||
void fgGeocToGeod( double lat_geoc, double radius, double
|
||||
*lat_geod, double *alt, double *sea_level_r )
|
||||
{
|
||||
double t_lat, x_alpha, mu_alpha, delt_mu, r_alpha, l_point, rho_alpha;
|
||||
double sin_mu_a, denom,delt_lambda, lambda_sl, sin_lambda_sl;
|
||||
|
||||
if( ( (FG_PI_2 - lat_geoc) < ONE_SECOND ) // near North pole
|
||||
|| ( (FG_PI_2 + lat_geoc) < ONE_SECOND ) ) // near South pole
|
||||
{
|
||||
*lat_geod = lat_geoc;
|
||||
*sea_level_r = EQUATORIAL_RADIUS_M*E;
|
||||
*alt = radius - *sea_level_r;
|
||||
} else {
|
||||
t_lat = tan(lat_geoc);
|
||||
x_alpha = E*EQUATORIAL_RADIUS_M/sqrt(t_lat*t_lat + E*E);
|
||||
double tmp = RESQ_M - x_alpha * x_alpha;
|
||||
if ( tmp < 0.0 ) { tmp = 0.0; }
|
||||
mu_alpha = atan2(sqrt(tmp),E*x_alpha);
|
||||
if (lat_geoc < 0) mu_alpha = - mu_alpha;
|
||||
sin_mu_a = sin(mu_alpha);
|
||||
delt_lambda = mu_alpha - lat_geoc;
|
||||
r_alpha = x_alpha/cos(lat_geoc);
|
||||
l_point = radius - r_alpha;
|
||||
*alt = l_point*cos(delt_lambda);
|
||||
|
||||
// check for domain error
|
||||
if ( errno == EDOM ) {
|
||||
cout << "Domain ERROR in fgGeocToGeod!!!!\n";
|
||||
*alt = 0.0;
|
||||
}
|
||||
|
||||
denom = sqrt(1-EPS*EPS*sin_mu_a*sin_mu_a);
|
||||
rho_alpha = EQUATORIAL_RADIUS_M*(1-EPS)/
|
||||
(denom*denom*denom);
|
||||
delt_mu = atan2(l_point*sin(delt_lambda),rho_alpha + *alt);
|
||||
*lat_geod = mu_alpha - delt_mu;
|
||||
lambda_sl = atan( E*E * tan(*lat_geod) ); // SL geoc. latitude
|
||||
sin_lambda_sl = sin( lambda_sl );
|
||||
*sea_level_r =
|
||||
sqrt(RESQ_M / (1 + ((1/(E*E))-1)*sin_lambda_sl*sin_lambda_sl));
|
||||
|
||||
// check for domain error
|
||||
if ( errno == EDOM ) {
|
||||
cout << "Domain ERROR in fgGeocToGeod!!!!\n";
|
||||
*sea_level_r = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// fgGeodToGeoc( lat_geod, alt, *sl_radius, *lat_geoc )
|
||||
// INPUTS:
|
||||
// lat_geod Geodetic latitude, radians, + = North
|
||||
// alt C.G. altitude above mean sea level (meters)
|
||||
//
|
||||
// OUTPUTS:
|
||||
// sl_radius SEA LEVEL radius to earth center (meters)
|
||||
// (add Altitude to get true distance from earth center.
|
||||
// lat_geoc Geocentric latitude, radians, + = North
|
||||
//
|
||||
|
||||
|
||||
void fgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
|
||||
double *lat_geoc )
|
||||
{
|
||||
double lambda_sl, sin_lambda_sl, cos_lambda_sl, sin_mu, cos_mu, px, py;
|
||||
|
||||
lambda_sl = atan( E*E * tan(lat_geod) ); // sea level geocentric latitude
|
||||
sin_lambda_sl = sin( lambda_sl );
|
||||
cos_lambda_sl = cos( lambda_sl );
|
||||
sin_mu = sin(lat_geod); // Geodetic (map makers') latitude
|
||||
cos_mu = cos(lat_geod);
|
||||
*sl_radius =
|
||||
sqrt(RESQ_M / (1 + ((1/(E*E))-1)*sin_lambda_sl*sin_lambda_sl));
|
||||
py = *sl_radius*sin_lambda_sl + alt*sin_mu;
|
||||
px = *sl_radius*cos_lambda_sl + alt*cos_mu;
|
||||
*lat_geoc = atan2( py, px );
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
|
||||
TITLE: ls_geodesy
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
FUNCTION: Converts geocentric coordinates to geodetic positions
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
MODULE STATUS: developmental
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
GENEALOGY: Written as part of LaRCSim project by E. B. Jackson
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
DESIGNED BY: E. B. Jackson
|
||||
|
||||
CODED BY: E. B. Jackson
|
||||
|
||||
MAINTAINED BY: E. B. Jackson
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
MODIFICATION HISTORY:
|
||||
|
||||
DATE PURPOSE BY
|
||||
|
||||
930208 Modified to avoid singularity near polar region. EBJ
|
||||
930602 Moved backwards calcs here from ls_step. EBJ
|
||||
931214 Changed erroneous Latitude and Altitude variables to
|
||||
*lat_geod and *alt in routine ls_geoc_to_geod. EBJ
|
||||
940111 Changed header files from old ls_eom.h style to ls_types,
|
||||
and ls_constants. Also replaced old DATA type with new
|
||||
SCALAR type. EBJ
|
||||
|
||||
CURRENT RCS HEADER:
|
||||
|
||||
$Header$
|
||||
$Log$
|
||||
Revision 1.1 1999/04/05 21:32:33 curt
|
||||
Initial revision
|
||||
|
||||
Revision 1.6 1999/03/02 01:01:49 curt
|
||||
Tweaks for compiling with native SGI compilers.
|
||||
|
||||
Revision 1.5 1999/01/27 04:46:14 curt
|
||||
Portability tweaks by Bernie Bright.
|
||||
|
||||
Revision 1.4 1998/11/20 01:00:36 curt
|
||||
Patch in fgGeoc2Geod() to avoid a floating explosion.
|
||||
point3d.hxx include math.h for FreeBSD
|
||||
|
||||
Revision 1.3 1998/11/11 00:18:36 curt
|
||||
Check for domain error in fgGeoctoGeod()
|
||||
|
||||
Revision 1.2 1998/10/16 23:36:36 curt
|
||||
c++-ifying.
|
||||
|
||||
Revision 1.1 1998/10/16 19:30:40 curt
|
||||
Renamed .c -> .h so we can start adding c++ supporting routines.
|
||||
|
||||
Revision 1.6 1998/07/08 14:40:07 curt
|
||||
polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
meters.
|
||||
|
||||
Revision 1.5 1998/04/25 22:06:23 curt
|
||||
Edited cvs log messages in source files ... bad bad bad!
|
||||
|
||||
Revision 1.4 1998/01/27 00:47:59 curt
|
||||
Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
|
||||
system and commandline/config file processing code.
|
||||
|
||||
Revision 1.3 1998/01/19 19:27:12 curt
|
||||
Merged in make system changes from Bob Kuehne <rpk@sgi.com>
|
||||
This should simplify things tremendously.
|
||||
|
||||
Revision 1.2 1997/12/15 23:54:54 curt
|
||||
Add xgl wrappers for debugging.
|
||||
Generate terrain normals on the fly.
|
||||
|
||||
Revision 1.1 1997/07/31 23:13:14 curt
|
||||
Initial revision.
|
||||
|
||||
Revision 1.1 1997/05/29 00:09:56 curt
|
||||
Initial Flight Gear revision.
|
||||
|
||||
* Revision 1.5 1994/01/11 18:47:05 bjax
|
||||
* Changed include files to use types and constants, not ls_eom.h
|
||||
* Also changed DATA type to SCALAR type.
|
||||
*
|
||||
* Revision 1.4 1993/12/14 21:06:47 bjax
|
||||
* Removed global variable references Altitude and Latitude. EBJ
|
||||
*
|
||||
* Revision 1.3 1993/06/02 15:03:40 bjax
|
||||
* Made new subroutine for calculating geodetic to geocentric; changed name
|
||||
* of forward conversion routine from ls_geodesy to ls_geoc_to_geod.
|
||||
*
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
REFERENCES:
|
||||
|
||||
[ 1] Stevens, Brian L.; and Lewis, Frank L.: "Aircraft
|
||||
Control and Simulation", Wiley and Sons, 1992.
|
||||
ISBN 0-471-61397-5
|
||||
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
CALLED BY: ls_aux
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
CALLS TO:
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
INPUTS:
|
||||
lat_geoc Geocentric latitude, radians, + = North
|
||||
radius C.G. radius to earth center, ft
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
OUTPUTS:
|
||||
lat_geod Geodetic latitude, radians, + = North
|
||||
alt C.G. altitude above mean sea level, ft
|
||||
sea_level_r radius from earth center to sea level at
|
||||
local vertical (surface normal) of C.G.
|
||||
|
||||
--------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.6 1999/03/02 01:01:49 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.5 1999/01/27 04:46:14 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.4 1998/11/20 01:00:36 curt
|
||||
// Patch in fgGeoc2Geod() to avoid a floating explosion.
|
||||
// point3d.hxx include math.h for FreeBSD
|
||||
//
|
||||
// Revision 1.3 1998/11/11 00:18:36 curt
|
||||
// Check for domain error in fgGeoctoGeod()
|
||||
//
|
||||
// Revision 1.2 1998/10/16 23:36:36 curt
|
||||
// c++-ifying.
|
||||
//
|
||||
// Revision 1.1 1998/10/16 19:30:40 curt
|
||||
// Renamed .c -> .h so we can start adding c++ supporting routines.
|
||||
//
|
||||
// Revision 1.6 1998/07/08 14:40:07 curt
|
||||
// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
// Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
// meters.
|
||||
//
|
||||
// Revision 1.5 1998/04/25 22:06:23 curt
|
||||
// Edited cvs log messages in source files ... bad bad bad!
|
||||
//
|
||||
// Revision 1.4 1998/01/27 00:47:59 curt
|
||||
// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
|
||||
// system and commandline/config file processing code.
|
||||
//
|
||||
// Revision 1.3 1998/01/19 19:27:12 curt
|
||||
// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
|
||||
// This should simplify things tremendously.
|
||||
//
|
||||
// Revision 1.2 1997/12/15 23:54:54 curt
|
||||
// Add xgl wrappers for debugging.
|
||||
// Generate terrain normals on the fly.
|
||||
//
|
||||
// Revision 1.1 1997/07/31 23:13:14 curt
|
||||
// Initial revision.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
// fg_geodesy.hxx -- routines to convert between geodetic and geocentric
|
||||
// coordinate systems.
|
||||
//
|
||||
// Copied and adapted directly from LaRCsim/ls_geodesy.c
|
||||
//
|
||||
// See below for the complete original LaRCsim comments.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _FG_GEODESY_HXX
|
||||
#define _FG_GEODESY_HXX
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
|
||||
#include <Math/point3d.hxx>
|
||||
#include <Math/polar3d.hxx>
|
||||
|
||||
|
||||
// fgGeocToGeod(lat_geoc, radius, *lat_geod, *alt, *sea_level_r)
|
||||
// INPUTS:
|
||||
// lat_geoc Geocentric latitude, radians, + = North
|
||||
// radius C.G. radius to earth center (meters)
|
||||
//
|
||||
// OUTPUTS:
|
||||
// lat_geod Geodetic latitude, radians, + = North
|
||||
// alt C.G. altitude above mean sea level (meters)
|
||||
// sea_level_r radius from earth center to sea level at
|
||||
// local vertical (surface normal) of C.G. (meters)
|
||||
|
||||
void fgGeocToGeod( double lat_geoc, double radius, double
|
||||
*lat_geod, double *alt, double *sea_level_r );
|
||||
|
||||
|
||||
// fgGeodToGeoc( lat_geod, alt, *sl_radius, *lat_geoc )
|
||||
// INPUTS:
|
||||
// lat_geod Geodetic latitude, radians, + = North
|
||||
// alt C.G. altitude above mean sea level (meters)
|
||||
//
|
||||
// OUTPUTS:
|
||||
// sl_radius SEA LEVEL radius to earth center (meters)
|
||||
// (add Altitude to get true distance from earth center.
|
||||
// lat_geoc Geocentric latitude, radians, + = North
|
||||
//
|
||||
|
||||
void fgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
|
||||
double *lat_geoc );
|
||||
|
||||
|
||||
// convert a geodetic point lon(radians), lat(radians), elev(meter) to
|
||||
// a cartesian point
|
||||
|
||||
inline Point3D fgGeodToCart(const Point3D& geod) {
|
||||
double gc_lon, gc_lat, sl_radius;
|
||||
|
||||
// printf("A geodetic point is (%.2f, %.2f, %.2f)\n",
|
||||
// geod[0], geod[1], geod[2]);
|
||||
|
||||
gc_lon = geod.lon();
|
||||
fgGeodToGeoc(geod.lat(), geod.radius(), &sl_radius, &gc_lat);
|
||||
|
||||
// printf("A geocentric point is (%.2f, %.2f, %.2f)\n", gc_lon,
|
||||
// gc_lat, sl_radius+geod[2]);
|
||||
|
||||
Point3D pp = Point3D( gc_lon, gc_lat, sl_radius + geod.radius());
|
||||
return fgPolarToCart3d(pp);
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
|
||||
TITLE: ls_geodesy
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
FUNCTION: Converts geocentric coordinates to geodetic positions
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
MODULE STATUS: developmental
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
GENEALOGY: Written as part of LaRCSim project by E. B. Jackson
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
DESIGNED BY: E. B. Jackson
|
||||
|
||||
CODED BY: E. B. Jackson
|
||||
|
||||
MAINTAINED BY: E. B. Jackson
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
MODIFICATION HISTORY:
|
||||
|
||||
DATE PURPOSE BY
|
||||
|
||||
930208 Modified to avoid singularity near polar region. EBJ
|
||||
930602 Moved backwards calcs here from ls_step. EBJ
|
||||
931214 Changed erroneous Latitude and Altitude variables to
|
||||
*lat_geod and *alt in routine ls_geoc_to_geod. EBJ
|
||||
940111 Changed header files from old ls_eom.h style to ls_types,
|
||||
and ls_constants. Also replaced old DATA type with new
|
||||
SCALAR type. EBJ
|
||||
|
||||
CURRENT RCS HEADER:
|
||||
|
||||
$Header$
|
||||
$Log$
|
||||
Revision 1.1 1999/04/05 21:32:33 curt
|
||||
Initial revision
|
||||
|
||||
Revision 1.4 1999/01/27 04:46:15 curt
|
||||
Portability tweaks by Bernie Bright.
|
||||
|
||||
Revision 1.3 1998/10/18 01:17:11 curt
|
||||
Point3D tweaks.
|
||||
|
||||
Revision 1.2 1998/10/16 23:36:37 curt
|
||||
c++-ifying.
|
||||
|
||||
Revision 1.1 1998/10/16 19:30:42 curt
|
||||
Renamed .c -> .h so we can start adding c++ supporting routines.
|
||||
|
||||
Revision 1.4 1998/07/08 14:40:08 curt
|
||||
polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
meters.
|
||||
|
||||
Revision 1.3 1998/04/21 17:03:48 curt
|
||||
Prepairing for C++ integration.
|
||||
|
||||
Revision 1.2 1998/01/22 02:59:38 curt
|
||||
Changed #ifdef FILE_H to #ifdef _FILE_H
|
||||
|
||||
Revision 1.1 1997/07/31 23:13:14 curt
|
||||
Initial revision.
|
||||
|
||||
Revision 1.1 1997/05/29 00:09:56 curt
|
||||
Initial Flight Gear revision.
|
||||
|
||||
* Revision 1.5 1994/01/11 18:47:05 bjax
|
||||
* Changed include files to use types and constants, not ls_eom.h
|
||||
* Also changed DATA type to SCALAR type.
|
||||
*
|
||||
* Revision 1.4 1993/12/14 21:06:47 bjax
|
||||
* Removed global variable references Altitude and Latitude. EBJ
|
||||
*
|
||||
* Revision 1.3 1993/06/02 15:03:40 bjax
|
||||
* Made new subroutine for calculating geodetic to geocentric; changed name
|
||||
* of forward conversion routine from ls_geodesy to ls_geoc_to_geod.
|
||||
*
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
REFERENCES:
|
||||
|
||||
[ 1] Stevens, Brian L.; and Lewis, Frank L.: "Aircraft
|
||||
Control and Simulation", Wiley and Sons, 1992.
|
||||
ISBN 0-471-61397-5
|
||||
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
CALLED BY: ls_aux
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
CALLS TO:
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
INPUTS:
|
||||
lat_geoc Geocentric latitude, radians, + = North
|
||||
radius C.G. radius to earth center, ft
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
OUTPUTS:
|
||||
lat_geod Geodetic latitude, radians, + = North
|
||||
alt C.G. altitude above mean sea level, ft
|
||||
sea_level_r radius from earth center to sea level at
|
||||
local vertical (surface normal) of C.G.
|
||||
|
||||
--------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
#endif // _FG_GEODESY_HXX
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.4 1999/01/27 04:46:15 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.3 1998/10/18 01:17:11 curt
|
||||
// Point3D tweaks.
|
||||
//
|
||||
// Revision 1.2 1998/10/16 23:36:37 curt
|
||||
// c++-ifying.
|
||||
//
|
||||
// Revision 1.1 1998/10/16 19:30:42 curt
|
||||
// Renamed .c -> .h so we can start adding c++ supporting routines.
|
||||
//
|
||||
// Revision 1.4 1998/07/08 14:40:08 curt
|
||||
// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
// Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
// meters.
|
||||
//
|
||||
// Revision 1.3 1998/04/21 17:03:48 curt
|
||||
// Prepairing for C++ integration.
|
||||
//
|
||||
// Revision 1.2 1998/01/22 02:59:38 curt
|
||||
// Changed #ifdef FILE_H to #ifdef _FILE_H
|
||||
//
|
||||
// Revision 1.1 1997/07/31 23:13:14 curt
|
||||
// Initial revision.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
// fg_random.c -- routines to handle random number generation
|
||||
//
|
||||
// Written by Curtis Olson, started July 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h> // for random(), srandom()
|
||||
#include <time.h> // for time() to seed srandom()
|
||||
|
||||
#include "fg_random.h"
|
||||
|
||||
#ifndef HAVE_RAND
|
||||
# ifdef sgi
|
||||
# undef RAND_MAX
|
||||
# define RAND_MAX 2147483647
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef __SUNPRO_CC
|
||||
extern "C" {
|
||||
long int random(void);
|
||||
void srandom(unsigned int seed);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// Seed the random number generater with time() so we don't see the
|
||||
// same sequence every time
|
||||
void fg_srandom(void) {
|
||||
// fgPrintf( FG_MATH, FG_INFO, "Seeding random number generater\n");
|
||||
|
||||
#ifdef HAVE_RAND
|
||||
srand(time(NULL));
|
||||
#else
|
||||
srandom(time(NULL));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// return a random number between [0.0, 1.0)
|
||||
double fg_random(void) {
|
||||
#ifdef HAVE_RAND
|
||||
return(rand() / (double)RAND_MAX);
|
||||
#else
|
||||
return(random() / (double)RAND_MAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.10 1998/11/07 19:07:03 curt
|
||||
// Enable release builds using the --without-logging option to the configure
|
||||
// script. Also a couple log message cleanups, plus some C to C++ comment
|
||||
// conversion.
|
||||
//
|
||||
// Revision 1.9 1998/11/06 21:17:26 curt
|
||||
// Converted to new logstream debugging facility. This allows release
|
||||
// builds with no messages at all (and no performance impact) by using
|
||||
// the -DFG_NDEBUG flag.
|
||||
//
|
||||
// Revision 1.8 1998/04/25 22:06:23 curt
|
||||
// Edited cvs log messages in source files ... bad bad bad!
|
||||
//
|
||||
// Revision 1.7 1998/04/24 00:43:13 curt
|
||||
// Wrapped "#include <config.h>" in "#ifdef HAVE_CONFIG_H"
|
||||
//
|
||||
// Revision 1.6 1998/04/18 03:53:42 curt
|
||||
// Miscellaneous Tweaks.
|
||||
//
|
||||
// Revision 1.5 1998/04/03 22:10:29 curt
|
||||
// Converting to Gnu autoconf system.
|
||||
//
|
||||
// Revision 1.4 1998/02/03 23:20:28 curt
|
||||
// Lots of little tweaks to fix various consistency problems discovered by
|
||||
// Solaris' CC. Fixed a bug in fg_debug.c with how the fgPrintf() wrapper
|
||||
// passed arguments along to the real printf(). Also incorporated HUD changes
|
||||
// by Michele America.
|
||||
//
|
||||
// Revision 1.3 1998/01/27 00:47:59 curt
|
||||
// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
|
||||
// system and commandline/config file processing code.
|
||||
//
|
||||
// Revision 1.2 1997/12/30 20:47:48 curt
|
||||
// Integrated new event manager with subsystem initializations.
|
||||
//
|
||||
// Revision 1.1 1997/07/30 16:04:09 curt
|
||||
// Moved random routines from Utils/ to Math/
|
||||
//
|
||||
// Revision 1.1 1997/07/19 22:31:57 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,73 @@
|
||||
// fg_random.h -- routines to handle random number generation
|
||||
//
|
||||
// Written by Curtis Olson, started July 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _FG_RANDOM_H
|
||||
#define _FG_RANDOM_H
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
// Seed the random number generater with time() so we don't see the
|
||||
// same sequence every time
|
||||
void fg_srandom(void);
|
||||
|
||||
// return a random number between [0.0, 1.0)
|
||||
double fg_random(void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif // _FG_RANDOM_H
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.4 1998/11/07 19:07:04 curt
|
||||
// Enable release builds using the --without-logging option to the configure
|
||||
// script. Also a couple log message cleanups, plus some C to C++ comment
|
||||
// conversion.
|
||||
//
|
||||
// Revision 1.3 1998/04/21 17:03:48 curt
|
||||
// Prepairing for C++ integration.
|
||||
//
|
||||
// Revision 1.2 1998/01/22 02:59:38 curt
|
||||
// Changed #ifdef FILE_H to #ifdef _FILE_H
|
||||
//
|
||||
// Revision 1.1 1997/07/30 16:04:09 curt
|
||||
// Moved random routines from Utils/ to Math/
|
||||
//
|
||||
// Revision 1.2 1997/07/23 21:52:28 curt
|
||||
// Put comments around the text after an #endif for increased portability.
|
||||
//
|
||||
// Revision 1.1 1997/07/19 22:31:57 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,30 @@
|
||||
#include <Include/fg_constants.h>
|
||||
#include <Math/fg_geodesy.h>
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
void
|
||||
main( void )
|
||||
{
|
||||
double Lon, Alt, sl_radius;
|
||||
double geodetic_Lat;
|
||||
double geocentric_Lat;
|
||||
|
||||
Lon = -87.75 * DEG_TO_RAD;
|
||||
geodetic_Lat = 41.83 * DEG_TO_RAD;
|
||||
Alt = 1.5; /* km */
|
||||
|
||||
printf("Geodetic position = (%.8f, %.8f, %.8f)\n", Lon, geodetic_Lat, Alt);
|
||||
|
||||
fgGeodToGeoc( geodetic_Lat, Alt, &sl_radius, &geocentric_Lat );
|
||||
|
||||
printf("Geocentric position = (%.8f, %.8f, %.8f)\n", Lon, geocentric_Lat,
|
||||
sl_radius + Alt);
|
||||
printf("new sl_radius = %.8f\n", sl_radius);
|
||||
|
||||
fgGeocToGeod( geocentric_Lat, sl_radius + Alt, &geodetic_Lat,
|
||||
&Alt, &sl_radius );
|
||||
|
||||
printf("Geodetic position = (%.8f, %.8f, %.8f)\n", Lon, geodetic_Lat, Alt);
|
||||
printf("new sl_radius = %.8f\n", sl_radius);
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
//
|
||||
// interpolater.cxx -- routines to handle linear interpolation from a table of
|
||||
// x,y The table must be sorted by "x" in ascending order
|
||||
//
|
||||
// Written by Curtis Olson, started April 1998.
|
||||
//
|
||||
// Copyright (C) 1998 Curtis L. Olson - curt@me.umn.edu
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#include <Include/compiler.h>
|
||||
|
||||
#include STL_STRING
|
||||
|
||||
#include <Debug/logstream.hxx>
|
||||
#include <Include/fg_zlib.h>
|
||||
#include <Misc/fgstream.hxx>
|
||||
|
||||
#include "interpolater.hxx"
|
||||
|
||||
|
||||
// Constructor -- loads the interpolation table from the specified
|
||||
// file
|
||||
fgINTERPTABLE::fgINTERPTABLE( const string& file ) {
|
||||
FG_LOG( FG_MATH, FG_INFO, "Initializing Interpolator for " << file );
|
||||
|
||||
fg_gzifstream in( file );
|
||||
if ( !in ) {
|
||||
FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << file );
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
size = 0;
|
||||
in >> skipcomment;
|
||||
while ( ! in.eof() ){
|
||||
if ( size < MAX_TABLE_SIZE ) {
|
||||
in >> table[size][0] >> table[size][1];
|
||||
size++;
|
||||
} else {
|
||||
FG_LOG( FG_MATH, FG_ALERT,
|
||||
"fgInterpolateInit(): Exceed max table size = "
|
||||
<< MAX_TABLE_SIZE );
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Given an x value, linearly interpolate the y value from the table
|
||||
double fgINTERPTABLE::interpolate(double x) {
|
||||
int i;
|
||||
double y;
|
||||
|
||||
i = 0;
|
||||
|
||||
while ( (x > table[i][0]) && (i < size) ) {
|
||||
i++;
|
||||
}
|
||||
|
||||
// printf ("i = %d ", i);
|
||||
|
||||
if ( (i == 0) && (x < table[0][0]) ) {
|
||||
FG_LOG( FG_MATH, FG_ALERT,
|
||||
"fgInterpolateInit(): lookup error, x to small = " << x );
|
||||
return(0.0);
|
||||
}
|
||||
|
||||
if ( x > table[i][0] ) {
|
||||
FG_LOG( FG_MATH, FG_ALERT,
|
||||
"fgInterpolateInit(): lookup error, x to big = " << x );
|
||||
return(0.0);
|
||||
}
|
||||
|
||||
// y = y1 + (y0 - y1)(x - x1) / (x0 - x1)
|
||||
y = table[i][1] +
|
||||
( (table[i-1][1] - table[i][1]) *
|
||||
(x - table[i][0]) ) /
|
||||
(table[i-1][0] - table[i][0]);
|
||||
|
||||
return(y);
|
||||
}
|
||||
|
||||
|
||||
// Destructor
|
||||
fgINTERPTABLE::~fgINTERPTABLE( void ) {
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.7 1999/02/26 22:08:03 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.6 1999/01/27 04:46:16 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.5 1998/11/06 21:17:27 curt
|
||||
// Converted to new logstream debugging facility. This allows release
|
||||
// builds with no messages at all (and no performance impact) by using
|
||||
// the -DFG_NDEBUG flag.
|
||||
//
|
||||
// Revision 1.4 1998/05/13 18:24:25 curt
|
||||
// Wrapped zlib calls so zlib can be optionally disabled.
|
||||
//
|
||||
// Revision 1.3 1998/04/25 15:05:01 curt
|
||||
// Changed "r" to "rb" in gzopen() options. This fixes bad behavior in win32.
|
||||
//
|
||||
// Revision 1.2 1998/04/22 13:18:10 curt
|
||||
// C++ - ified comments. Make file open errors fatal.
|
||||
//
|
||||
// Revision 1.1 1998/04/21 19:14:23 curt
|
||||
// Modified Files:
|
||||
// Makefile.am Makefile.in
|
||||
// Added Files:
|
||||
// interpolater.cxx interpolater.hxx
|
||||
//
|
||||
@@ -0,0 +1,90 @@
|
||||
//
|
||||
// interpolater.hxx -- routines to handle linear interpolation from a table of
|
||||
// x,y The table must be sorted by "x" in ascending order
|
||||
//
|
||||
// Written by Curtis Olson, started April 1998.
|
||||
//
|
||||
// Copyright (C) 1998 Curtis L. Olson - curt@me.umn.edu
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _INTERPOLATER_H
|
||||
#define _INTERPOLATER_H
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
#include "Include/compiler.h"
|
||||
|
||||
#include STL_STRING
|
||||
FG_USING_STD(string);
|
||||
|
||||
#define MAX_TABLE_SIZE 32
|
||||
|
||||
|
||||
class fgINTERPTABLE {
|
||||
int size;
|
||||
double table[MAX_TABLE_SIZE][2];
|
||||
|
||||
public:
|
||||
|
||||
// Constructor -- loads the interpolation table from the specified
|
||||
// file
|
||||
fgINTERPTABLE( const string& file );
|
||||
|
||||
// Given an x value, linearly interpolate the y value from the table
|
||||
double interpolate(double x);
|
||||
|
||||
// Destructor
|
||||
~fgINTERPTABLE( void );
|
||||
};
|
||||
|
||||
|
||||
#endif // _INTERPOLATER_H
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.6 1999/03/02 01:01:50 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.5 1999/02/26 22:08:05 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.4 1999/01/27 04:46:17 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.3 1998/11/06 21:17:28 curt
|
||||
// Converted to new logstream debugging facility. This allows release
|
||||
// builds with no messages at all (and no performance impact) by using
|
||||
// the -DFG_NDEBUG flag.
|
||||
//
|
||||
// Revision 1.2 1998/04/22 13:18:10 curt
|
||||
// C++ - ified comments. Make file open errors fatal.
|
||||
//
|
||||
// Revision 1.1 1998/04/21 19:14:23 curt
|
||||
// Modified Files:
|
||||
// Makefile.am Makefile.in
|
||||
// Added Files:
|
||||
// interpolater.cxx interpolater.hxx
|
||||
//
|
||||
@@ -0,0 +1,23 @@
|
||||
#include <stdio.h>
|
||||
#include <Debug/fg_debug.h>
|
||||
|
||||
#include "interpolater.hxx"
|
||||
|
||||
main() {
|
||||
fgINTERPTABLE test("test.table");
|
||||
|
||||
fgInitDebug();
|
||||
|
||||
printf("-1.0 = %.2f\n", test.interpolate(-1.0));
|
||||
printf("0.0 = %.2f\n", test.interpolate(0.0));
|
||||
printf("2.9 = %.2f\n", test.interpolate(2.9));
|
||||
printf("3.0 = %.2f\n", test.interpolate(3.0));
|
||||
printf("3.5 = %.2f\n", test.interpolate(3.5));
|
||||
printf("4.0 = %.2f\n", test.interpolate(4.0));
|
||||
printf("4.5 = %.2f\n", test.interpolate(4.5));
|
||||
printf("5.2 = %.2f\n", test.interpolate(5.2));
|
||||
printf("8.0 = %.2f\n", test.interpolate(8.0));
|
||||
printf("8.5 = %.2f\n", test.interpolate(8.5));
|
||||
printf("9.0 = %.2f\n", test.interpolate(9.0));
|
||||
printf("10.0 = %.2f\n", test.interpolate(10.0));
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
// leastsqs.c -- Implements a simple linear least squares best fit routine
|
||||
//
|
||||
// Written by Curtis Olson, started September 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
//
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "leastsqs.hxx"
|
||||
|
||||
|
||||
/*
|
||||
Least squares fit:
|
||||
|
||||
y = b0 + b1x
|
||||
|
||||
n*sum(xi*yi) - (sum(xi)*sum(yi))
|
||||
b1 = --------------------------------
|
||||
n*sum(xi^2) - (sum(xi))^2
|
||||
|
||||
|
||||
b0 = sum(yi)/n - b1*(sum(xi)/n)
|
||||
*/
|
||||
|
||||
double sum_xi, sum_yi, sum_xi_2, sum_xi_yi;
|
||||
int sum_n;
|
||||
|
||||
void least_squares(double *x, double *y, int n, double *m, double *b) {
|
||||
int i;
|
||||
|
||||
sum_xi = sum_yi = sum_xi_2 = sum_xi_yi = 0.0;
|
||||
sum_n = n;
|
||||
|
||||
for ( i = 0; i < n; i++ ) {
|
||||
sum_xi += x[i];
|
||||
sum_yi += y[i];
|
||||
sum_xi_2 += x[i] * x[i];
|
||||
sum_xi_yi += x[i] * y[i];
|
||||
}
|
||||
|
||||
/* printf("sum(xi)=%.2f sum(yi)=%.2f sum(xi^2)=%.2f sum(xi*yi)=%.2f\n",
|
||||
sum_xi, sum_yi, sum_xi_2, sum_xi_yi); */
|
||||
|
||||
*m = ( (double)sum_n * sum_xi_yi - sum_xi * sum_yi ) /
|
||||
( (double)sum_n * sum_xi_2 - sum_xi * sum_xi );
|
||||
*b = (sum_yi / (double)sum_n) - (*m) * (sum_xi / (double)sum_n);
|
||||
|
||||
/* printf("slope = %.2f intercept = %.2f\n", *m, *b); */
|
||||
}
|
||||
|
||||
|
||||
/* incrimentally update existing values with a new data point */
|
||||
void least_squares_update(double x, double y, double *m, double *b) {
|
||||
++sum_n;
|
||||
|
||||
sum_xi += x;
|
||||
sum_yi += y;
|
||||
sum_xi_2 += x * x;
|
||||
sum_xi_yi += x * y;
|
||||
|
||||
/* printf("sum(xi)=%.2f sum(yi)=%.2f sum(xi^2)=%.2f sum(xi*yi)=%.2f\n",
|
||||
sum_xi, sum_yi, sum_xi_2, sum_xi_yi); */
|
||||
|
||||
*m = ( (double)sum_n * sum_xi_yi - sum_xi * sum_yi ) /
|
||||
( (double)sum_n * sum_xi_2 - sum_xi * sum_xi );
|
||||
*b = (sum_yi / (double)sum_n) - (*m) * (sum_xi / (double)sum_n);
|
||||
|
||||
/* printf("slope = %.2f intercept = %.2f\n", *m, *b); */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
return the least squares error:
|
||||
|
||||
(y[i] - y_hat[i])^2
|
||||
-------------------
|
||||
n
|
||||
*/
|
||||
double least_squares_error(double *x, double *y, int n, double m, double b) {
|
||||
int i;
|
||||
double error, sum;
|
||||
|
||||
sum = 0.0;
|
||||
|
||||
for ( i = 0; i < n; i++ ) {
|
||||
error = y[i] - (m * x[i] + b);
|
||||
sum += error * error;
|
||||
// printf("%.2f %.2f\n", error, sum);
|
||||
}
|
||||
|
||||
return ( sum / (double)n );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
return the maximum least squares error:
|
||||
|
||||
(y[i] - y_hat[i])^2
|
||||
*/
|
||||
double least_squares_max_error(double *x, double *y, int n, double m, double b){
|
||||
int i;
|
||||
double error, max_error;
|
||||
|
||||
max_error = 0.0;
|
||||
|
||||
for ( i = 0; i < n; i++ ) {
|
||||
error = y[i] - (m * x[i] + b);
|
||||
error = error * error;
|
||||
if ( error > max_error ) {
|
||||
max_error = error;
|
||||
}
|
||||
}
|
||||
|
||||
return ( max_error );
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.1 1999/03/13 17:34:45 curt
|
||||
// Moved to math subdirectory.
|
||||
//
|
||||
// Revision 1.2 1998/04/21 17:03:41 curt
|
||||
// Prepairing for C++ integration.
|
||||
//
|
||||
// Revision 1.1 1998/04/08 22:57:24 curt
|
||||
// Adopted Gnu automake/autoconf system.
|
||||
//
|
||||
// Revision 1.1 1998/03/19 02:54:47 curt
|
||||
// Reorganized into a class lib called fgDEM.
|
||||
//
|
||||
// Revision 1.1 1997/10/13 17:02:35 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,93 @@
|
||||
// leastsqs.h -- Implements a simple linear least squares best fit routine
|
||||
//
|
||||
// Written by Curtis Olson, started September 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
///
|
||||
|
||||
|
||||
#ifndef _LEASTSQS_H
|
||||
#define _LEASTSQS_H
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
Least squares fit:
|
||||
|
||||
y = b0 + b1x
|
||||
|
||||
n*sum(xi*yi) - (sum(xi)*sum(yi))
|
||||
b1 = --------------------------------
|
||||
n*sum(xi^2) - (sum(xi))^2
|
||||
|
||||
|
||||
b0 = sum(yi)/n - b1*(sum(xi)/n)
|
||||
*/
|
||||
|
||||
void least_squares(double *x, double *y, int n, double *m, double *b);
|
||||
|
||||
/* incrimentally update existing values with a new data point */
|
||||
void least_squares_update(double x, double y, double *m, double *b);
|
||||
|
||||
|
||||
/*
|
||||
return the least squares error:
|
||||
|
||||
(y[i] - y_hat[i])^2
|
||||
-------------------
|
||||
n
|
||||
*/
|
||||
double least_squares_error(double *x, double *y, int n, double m, double b);
|
||||
|
||||
|
||||
/*
|
||||
return the maximum least squares error:
|
||||
|
||||
(y[i] - y_hat[i])^2
|
||||
*/
|
||||
double least_squares_max_error(double *x, double *y, int n, double m, double b);
|
||||
|
||||
|
||||
#endif // _LEASTSQS_H
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.1 1999/03/13 17:34:45 curt
|
||||
// Moved to math subdirectory.
|
||||
//
|
||||
// Revision 1.2 1998/04/21 17:03:42 curt
|
||||
// Prepairing for C++ integration.
|
||||
//
|
||||
// Revision 1.1 1998/04/08 22:57:25 curt
|
||||
// Adopted Gnu automake/autoconf system.
|
||||
//
|
||||
// Revision 1.1 1998/03/19 02:54:48 curt
|
||||
// Reorganized into a class lib called fgDEM.
|
||||
//
|
||||
// Revision 1.1 1997/10/13 17:02:35 curt
|
||||
// Initial revision.
|
||||
//
|
||||
+208
@@ -0,0 +1,208 @@
|
||||
/* Copyright 1988, Brown Computer Graphics Group. All Rights Reserved. */
|
||||
|
||||
/* -------------------------------------------------------------------------
|
||||
Public MAT3 include file
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifndef MAT3_HAS_BEEN_INCLUDED
|
||||
#define MAT3_HAS_BEEN_INCLUDED
|
||||
|
||||
/* ----------------------------- Constants ------------------------------ */
|
||||
|
||||
/*
|
||||
* Make sure the math library .h file is included, in case it wasn't.
|
||||
*/
|
||||
|
||||
#ifndef HUGE
|
||||
#include <math.h>
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
|
||||
#include <string.h>
|
||||
#include "Include/fg_memory.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#define MAT3_DET0 -1 /* Indicates singular mat */
|
||||
#define MAT3_EPSILON 1e-12 /* Close enough to zero */
|
||||
|
||||
#ifdef M_PI
|
||||
# define MAT3_PI M_PI
|
||||
#else
|
||||
# define MAT3_PI 3.14159265358979323846
|
||||
#endif
|
||||
|
||||
#define USE_XTRA_MAT3_INLINES
|
||||
|
||||
/* ------------------------------ Types --------------------------------- */
|
||||
|
||||
typedef double MAT3mat[4][4]; /* 4x4 matrix */
|
||||
typedef double MAT3vec[3]; /* Vector */
|
||||
typedef double MAT3hvec[4]; /* Vector with homogeneous coord */
|
||||
|
||||
/* ------------------------------ Macros -------------------------------- */
|
||||
|
||||
extern MAT3mat identityMatrix;
|
||||
|
||||
/* Tests if a number is within EPSILON of zero */
|
||||
#define MAT3_IS_ZERO(N) ((N) < MAT3_EPSILON && (N) > -MAT3_EPSILON)
|
||||
|
||||
/* Sets a vector to the three given values */
|
||||
#define MAT3_SET_VEC(V,X,Y,Z) ((V)[0]=(X), (V)[1]=(Y), (V)[2]=(Z))
|
||||
|
||||
/* Tests a vector for all components close to zero */
|
||||
#define MAT3_IS_ZERO_VEC(V) (MAT3_IS_ZERO((V)[0]) && \
|
||||
MAT3_IS_ZERO((V)[1]) && \
|
||||
MAT3_IS_ZERO((V)[2]))
|
||||
|
||||
/* Dot product of two vectors */
|
||||
#define MAT3_DOT_PRODUCT(V1,V2) \
|
||||
((V1)[0]*(V2)[0] + (V1)[1]*(V2)[1] + (V1)[2]*(V2)[2])
|
||||
|
||||
/* Copy one vector to other */
|
||||
#define MAT3_COPY_VEC(TO,FROM) ((TO)[0] = (FROM)[0], \
|
||||
(TO)[1] = (FROM)[1], \
|
||||
(TO)[2] = (FROM)[2])
|
||||
|
||||
/* Normalize vector to unit length, using TEMP as temporary variable.
|
||||
* TEMP will be zero if vector has zero length */
|
||||
#define MAT3_NORMALIZE_VEC(V,TEMP) \
|
||||
if ((TEMP = sqrt(MAT3_DOT_PRODUCT(V,V))) > MAT3_EPSILON) { \
|
||||
TEMP = 1.0 / TEMP; \
|
||||
MAT3_SCALE_VEC(V,V,TEMP); \
|
||||
} else TEMP = 0.0
|
||||
|
||||
/* Scale vector by given factor, storing result vector in RESULT_V */
|
||||
#define MAT3_SCALE_VEC(RESULT_V,V,SCALE) \
|
||||
MAT3_SET_VEC(RESULT_V, (V)[0]*(SCALE), (V)[1]*(SCALE), (V)[2]*(SCALE))
|
||||
|
||||
/* Adds vectors V1 and V2, storing result in RESULT_V */
|
||||
#define MAT3_ADD_VEC(RESULT_V,V1,V2) \
|
||||
MAT3_SET_VEC(RESULT_V, (V1)[0]+(V2)[0], (V1)[1]+(V2)[1], \
|
||||
(V1)[2]+(V2)[2])
|
||||
|
||||
/* Subtracts vector V2 from V1, storing result in RESULT_V */
|
||||
#define MAT3_SUB_VEC(RESULT_V,V1,V2) \
|
||||
MAT3_SET_VEC(RESULT_V, (V1)[0]-(V2)[0], (V1)[1]-(V2)[1], \
|
||||
(V1)[2]-(V2)[2])
|
||||
|
||||
/* Multiplies vectors V1 and V2, storing result in RESULT_V */
|
||||
#define MAT3_MULT_VEC(RESULT_V,V1,V2) \
|
||||
MAT3_SET_VEC(RESULT_V, (V1)[0]*(V2)[0], (V1)[1]*(V2)[1], \
|
||||
(V1)[2]*(V2)[2])
|
||||
|
||||
/* Sets RESULT_V to the linear combination of V1 and V2, scaled by
|
||||
* SCALE1 and SCALE2, respectively */
|
||||
#define MAT3_LINEAR_COMB(RESULT_V,SCALE1,V1,SCALE2,V2) \
|
||||
MAT3_SET_VEC(RESULT_V, (SCALE1)*(V1)[0] + (SCALE2)*(V2)[0], \
|
||||
(SCALE1)*(V1)[1] + (SCALE2)*(V2)[1], \
|
||||
(SCALE1)*(V1)[2] + (SCALE2)*(V2)[2])
|
||||
|
||||
/* Several of the vector macros are useful for homogeneous-coord vectors */
|
||||
#define MAT3_SET_HVEC(V,X,Y,Z,W) ((V)[0]=(X), (V)[1]=(Y), \
|
||||
(V)[2]=(Z), (V)[3]=(W))
|
||||
|
||||
#define MAT3_COPY_HVEC(TO,FROM) ((TO)[0] = (FROM)[0], \
|
||||
(TO)[1] = (FROM)[1], \
|
||||
(TO)[2] = (FROM)[2], \
|
||||
(TO)[3] = (FROM)[3])
|
||||
|
||||
#define MAT3_SCALE_HVEC(RESULT_V,V,SCALE) \
|
||||
MAT3_SET_HVEC(RESULT_V, (V)[0]*(SCALE), (V)[1]*(SCALE), \
|
||||
(V)[2]*(SCALE), (V)[3]*(SCALE))
|
||||
|
||||
#define MAT3_ADD_HVEC(RESULT_V,V1,V2) \
|
||||
MAT3_SET_HVEC(RESULT_V, (V1)[0]+(V2)[0], (V1)[1]+(V2)[1], \
|
||||
(V1)[2]+(V2)[2], (V1)[3]+(V2)[3])
|
||||
|
||||
#define MAT3_SUB_HVEC(RESULT_V,V1,V2) \
|
||||
MAT3_SET_HVEC(RESULT_V, (V1)[0]-(V2)[0], (V1)[1]-(V2)[1], \
|
||||
(V1)[2]-(V2)[2], (V1)[3]-(V2)[3])
|
||||
|
||||
#define MAT3_MULT_HVEC(RESULT_V,V1,V2) \
|
||||
MAT3_SET_HVEC(RESULT_V, (V1)[0]*(V2)[0], (V1)[1]*(V2)[1], \
|
||||
(V1)[2]*(V2)[2], (V1)[3]*(V2)[3])
|
||||
|
||||
/* ------------------------------ Entries ------------------------------- */
|
||||
|
||||
|
||||
#define MAT3identity(mat) fgmemcpy( mat, identityMatrix, sizeof(MAT3mat) )
|
||||
#define MAT3zero(mat) fgmemzero( mat, sizeof(MAT3mat) )
|
||||
#define MAT3copy(to, from) fgmemcpy( to, from, sizeof(MAT3mat) )
|
||||
|
||||
#if defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
# define MAT3mult_vec( result_vec, vec, mat) { \
|
||||
MAT3vec tempvec; \
|
||||
tempvec[0]=vec[0]*mat[0][0]+vec[1]*mat[1][0]+vec[2]*mat[2][0]+mat[3][0]; \
|
||||
tempvec[1]=vec[0]*mat[0][1]+vec[1]*mat[1][1]+vec[2]*mat[2][1]+mat[3][1]; \
|
||||
tempvec[2]=vec[0]*mat[0][2]+vec[1]*mat[1][2]+vec[2]*mat[2][2]+mat[3][2]; \
|
||||
result_vec[0] = tempvec[0]; \
|
||||
result_vec[1] = tempvec[1]; \
|
||||
result_vec[2] = tempvec[2]; \
|
||||
}
|
||||
|
||||
# define MAT3cross_product(result_vec, vec1, vec2) { \
|
||||
MAT3vec tempvec; \
|
||||
tempvec[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1]; \
|
||||
tempvec[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2]; \
|
||||
tempvec[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0]; \
|
||||
result_vec[0] = tempvec[0]; \
|
||||
result_vec[1] = tempvec[1]; \
|
||||
result_vec[2] = tempvec[2]; \
|
||||
}
|
||||
|
||||
# define MAT3mult( result_mat, mat1, mat2) { \
|
||||
register int i, j; \
|
||||
MAT3mat tmp_mat; \
|
||||
for (i = 0; i < 4; i++) \
|
||||
for (j = 0; j < 4; j++) \
|
||||
tmp_mat[i][j] = (mat1[i][0] * mat2[0][j] + \
|
||||
mat1[i][1] * mat2[1][j] + \
|
||||
mat1[i][2] * mat2[2][j] + \
|
||||
mat1[i][3] * mat2[3][j]); \
|
||||
fgmemcpy(result_mat, tmp_mat, sizeof(MAT3mat)); \
|
||||
}
|
||||
|
||||
#else // !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/* In MAT3mat.c */
|
||||
void MAT3mult(MAT3mat result, MAT3mat, MAT3mat);
|
||||
void MAT3mult_vec(MAT3vec result_vec, MAT3vec vec, MAT3mat mat);
|
||||
void MAT3cross_product(MAT3vec result,MAT3vec,MAT3vec);
|
||||
|
||||
#endif // defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
/* In MAT3geom.c */
|
||||
void MAT3direction_matrix (MAT3mat result_mat, MAT3mat mat);
|
||||
int MAT3normal_matrix (MAT3mat result_mat, MAT3mat mat);
|
||||
void MAT3rotate (MAT3mat result_mat, MAT3vec axis, double angle_in_radians);
|
||||
void MAT3translate (MAT3mat result_mat, MAT3vec trans);
|
||||
void MAT3scale (MAT3mat result_mat, MAT3vec scale);
|
||||
void MAT3shear(MAT3mat result_mat, double xshear, double yshear);
|
||||
|
||||
void MAT3transpose (MAT3mat result, MAT3mat);
|
||||
int MAT3invert (MAT3mat result, MAT3mat);
|
||||
void MAT3print (MAT3mat, FILE *fp);
|
||||
void MAT3print_formatted (MAT3mat, FILE *fp,
|
||||
char *title, char *head, char *format, char *tail);
|
||||
int MAT3equal( void );
|
||||
double MAT3trace( void );
|
||||
int MAT3power( void );
|
||||
int MAT3column_reduce( void );
|
||||
int MAT3kernel_basis( void );
|
||||
|
||||
/* In MAT3vec.c */
|
||||
int MAT3mult_hvec (MAT3hvec result_vec, MAT3hvec vec, MAT3mat mat, int normalize);
|
||||
void MAT3perp_vec(MAT3vec result_vec, MAT3vec vec, int is_unit);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* MAT3_HAS_BEEN_INCLUDED */
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
/* Copyright 1988, Brown Computer Graphics Group. All Rights Reserved. */
|
||||
|
||||
|
||||
#ifndef _MAT3DEFS_H
|
||||
#define _MAT3DEFS_H
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
/* #include <Math/mat3err.h> */
|
||||
#include <Math/mat3.h>
|
||||
|
||||
/* ----------------------------- Constants ------------------------------ */
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
#define CNULL ((char *) NULL)
|
||||
|
||||
/* ------------------------------ Macros -------------------------------- */
|
||||
|
||||
#define ALLOCN(P,T,N,M) \
|
||||
if ((P = (T *) malloc((unsigned) (N) * sizeof(T))) == NULL) \
|
||||
ERR_ERROR(MAT3_errid, ERR_FATAL, (ERR_ALLOC1, M)); \
|
||||
else
|
||||
|
||||
#define FREE(P) free((char *) (P))
|
||||
|
||||
#define ABS(A) ((A) > 0 ? (A) : -(A))
|
||||
#define MIN(A,B) ((A) < (B) ? (A) : (B))
|
||||
#define MAX(A,B) ((A) > (B) ? (A) : (B))
|
||||
|
||||
#define SWAP(A,B,T) (T = A, A = B, B = T)
|
||||
|
||||
/* Is N within EPS of zero ? */
|
||||
#define IS_ZERO(N,EPS) ((N) < EPS && (N) > -EPS)
|
||||
|
||||
/* Macros for lu routines */
|
||||
#define LU_PERMUTE(p,i,j) { int LU_T; LU_T = p[i]; p[i] = p[j]; p[j] = LU_T; }
|
||||
|
||||
/* ------------------------- Internal Entries ---------------------------- */
|
||||
|
||||
/* ------------------------- Global Variables ---------------------------- */
|
||||
|
||||
/* extern ERRid *MAT3_errid; */
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* _MAT3DEFS_H */
|
||||
@@ -0,0 +1,41 @@
|
||||
#ifndef _MAT3ERR_H
|
||||
#define _MAT3ERR_H
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#include "sph_errtypes.h"
|
||||
|
||||
#ifdef THINK_C
|
||||
/* We hide this from gnu's compiler, which doesn't understand it. */
|
||||
void SPH__error (int errtype, ...);
|
||||
#endif
|
||||
|
||||
|
||||
#define ERR_ERROR(A,B,C) \
|
||||
if (1) {char cstr[256]; sprintf C; SPH__error(ERR_MAT3_PACKAGE, cstr); } else
|
||||
|
||||
|
||||
#define ERR_S cstr,"%s\n"
|
||||
#define ERR_SI cstr,"%s: %d\n"
|
||||
#define ERR_SS cstr,"%s: %s\n"
|
||||
|
||||
#define ERR_SEVERE 0
|
||||
#define ERR_FATAL 0
|
||||
|
||||
#define ERR_ALLOC1 0
|
||||
|
||||
typedef int ERRid;
|
||||
|
||||
#define ERRregister_package(S) 100
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* _MAT3ERR_H */
|
||||
@@ -0,0 +1,374 @@
|
||||
// point3d.hxx -- a 3d point class.
|
||||
//
|
||||
// Adapted from algebra3 by Jean-Francois Doue, started October 1998.
|
||||
//
|
||||
// Copyright (C) 1998 Curtis L. Olson - curt@me.umn.edu
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _POINT3D_HXX
|
||||
#define _POINT3D_HXX
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
#include "Include/compiler.h"
|
||||
|
||||
#ifdef FG_MATH_EXCEPTION_CLASH
|
||||
# define exception c_exception
|
||||
#endif
|
||||
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
# include <iostream>
|
||||
# include <cassert>
|
||||
# include <cmath>
|
||||
#else
|
||||
# include <iostream.h>
|
||||
# include <assert.h>
|
||||
# include <math.h>
|
||||
#endif
|
||||
|
||||
#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
|
||||
FG_USING_STD(ostream);
|
||||
FG_USING_STD(istream);
|
||||
#endif
|
||||
|
||||
// -rp- assert.h is buggy under MWCWP3, as multiple #include undef assert !
|
||||
#ifdef __MWERKS__
|
||||
# define assert(x)
|
||||
#endif
|
||||
|
||||
const double fgPoint3_Epsilon = 0.0000001;
|
||||
|
||||
enum {PX, PY, PZ}; // axes
|
||||
|
||||
// Kludge for msvc++ 6.0 - requires forward decls of friend functions.
|
||||
class Point3D;
|
||||
istream& operator>> ( istream&, Point3D& );
|
||||
ostream& operator<< ( ostream&, const Point3D& );
|
||||
Point3D operator- (const Point3D& p); // -p1
|
||||
bool operator== (const Point3D& a, const Point3D& b); // p1 == p2?
|
||||
|
||||
|
||||
///////////////////////////
|
||||
//
|
||||
// 3D Point
|
||||
//
|
||||
///////////////////////////
|
||||
|
||||
class Point3D {
|
||||
|
||||
protected:
|
||||
|
||||
double n[3];
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
Point3D();
|
||||
Point3D(const double x, const double y, const double z);
|
||||
explicit Point3D(const double d);
|
||||
Point3D(const Point3D &p);
|
||||
|
||||
// Assignment operators
|
||||
|
||||
Point3D& operator = ( const Point3D& p ); // assignment of a Point3D
|
||||
Point3D& operator += ( const Point3D& p ); // incrementation by a Point3D
|
||||
Point3D& operator -= ( const Point3D& p ); // decrementation by a Point3D
|
||||
Point3D& operator *= ( const double d ); // multiplication by a constant
|
||||
Point3D& operator /= ( const double d ); // division by a constant
|
||||
|
||||
void setx(const double x);
|
||||
void sety(const double y);
|
||||
void setz(const double z);
|
||||
|
||||
// Queries
|
||||
|
||||
double& operator [] ( int i); // indexing
|
||||
double operator[] (int i) const; // read-only indexing
|
||||
|
||||
double x() const; // cartesian x
|
||||
double y() const; // cartesian y
|
||||
double z() const; // cartesian z
|
||||
|
||||
double lon() const; // polar longitude
|
||||
double lat() const; // polar latitude
|
||||
double radius() const; // polar radius
|
||||
double elev() const; // geodetic elevation (if specifying a surface point)
|
||||
|
||||
// friends
|
||||
friend Point3D operator - (const Point3D& p); // -p1
|
||||
friend bool operator == (const Point3D& a, const Point3D& b); // p1 == p2?
|
||||
friend istream& operator>> ( istream&, Point3D& );
|
||||
friend ostream& operator<< ( ostream&, const Point3D& );
|
||||
|
||||
// Special functions
|
||||
double distance3D(const Point3D& a) const; // distance between
|
||||
double distance3Dsquared(const Point3D& a) const; // distance between ^ 2
|
||||
};
|
||||
|
||||
|
||||
// input from stream
|
||||
inline istream&
|
||||
operator >> ( istream& in, Point3D& p)
|
||||
{
|
||||
char c;
|
||||
|
||||
in >> p.n[PX];
|
||||
|
||||
// read past optional comma
|
||||
while ( in.get(c) ) {
|
||||
if ( (c != ' ') && (c != ',') ) {
|
||||
// push back on the stream
|
||||
in.putback(c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
in >> p.n[PY];
|
||||
|
||||
// read past optional comma
|
||||
while ( in.get(c) ) {
|
||||
if ( (c != ' ') && (c != ',') ) {
|
||||
// push back on the stream
|
||||
in.putback(c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
in >> p.n[PZ];
|
||||
|
||||
return in;
|
||||
}
|
||||
|
||||
inline ostream&
|
||||
operator<< ( ostream& out, const Point3D& p )
|
||||
{
|
||||
return out << p.n[PX] << ", " << p.n[PY] << ", " << p.n[PZ];
|
||||
}
|
||||
|
||||
///////////////////////////
|
||||
//
|
||||
// Point3D Member functions
|
||||
//
|
||||
///////////////////////////
|
||||
|
||||
// CONSTRUCTORS
|
||||
|
||||
inline Point3D::Point3D() {}
|
||||
|
||||
inline Point3D::Point3D(const double x, const double y, const double z)
|
||||
{
|
||||
n[PX] = x; n[PY] = y; n[PZ] = z;
|
||||
}
|
||||
|
||||
inline Point3D::Point3D(const double d)
|
||||
{
|
||||
n[PX] = n[PY] = n[PZ] = d;
|
||||
}
|
||||
|
||||
inline Point3D::Point3D(const Point3D& p)
|
||||
{
|
||||
n[PX] = p.n[PX]; n[PY] = p.n[PY]; n[PZ] = p.n[PZ];
|
||||
}
|
||||
|
||||
// ASSIGNMENT OPERATORS
|
||||
|
||||
inline Point3D& Point3D::operator = (const Point3D& p)
|
||||
{
|
||||
n[PX] = p.n[PX]; n[PY] = p.n[PY]; n[PZ] = p.n[PZ]; return *this;
|
||||
}
|
||||
|
||||
inline Point3D& Point3D::operator += ( const Point3D& p )
|
||||
{
|
||||
n[PX] += p.n[PX]; n[PY] += p.n[PY]; n[PZ] += p.n[PZ]; return *this;
|
||||
}
|
||||
|
||||
inline Point3D& Point3D::operator -= ( const Point3D& p )
|
||||
{
|
||||
n[PX] -= p.n[PX]; n[PY] -= p.n[PY]; n[PZ] -= p.n[PZ]; return *this;
|
||||
}
|
||||
|
||||
inline Point3D& Point3D::operator *= ( const double d )
|
||||
{
|
||||
n[PX] *= d; n[PY] *= d; n[PZ] *= d; return *this;
|
||||
}
|
||||
|
||||
inline Point3D& Point3D::operator /= ( const double d )
|
||||
{
|
||||
double d_inv = 1./d; n[PX] *= d_inv; n[PY] *= d_inv; n[PZ] *= d_inv;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline void Point3D::setx(const double x) {
|
||||
n[PX] = x;
|
||||
}
|
||||
|
||||
inline void Point3D::sety(const double y) {
|
||||
n[PY] = y;
|
||||
}
|
||||
|
||||
inline void Point3D::setz(const double z) {
|
||||
n[PZ] = z;
|
||||
}
|
||||
|
||||
// QUERIES
|
||||
|
||||
inline double& Point3D::operator [] ( int i)
|
||||
{
|
||||
assert(! (i < PX || i > PZ));
|
||||
return n[i];
|
||||
}
|
||||
|
||||
inline double Point3D::operator [] ( int i) const {
|
||||
assert(! (i < PX || i > PZ));
|
||||
return n[i];
|
||||
}
|
||||
|
||||
|
||||
inline double Point3D::x() const { return n[PX]; }
|
||||
|
||||
inline double Point3D::y() const { return n[PY]; }
|
||||
|
||||
inline double Point3D::z() const { return n[PZ]; }
|
||||
|
||||
inline double Point3D::lon() const { return n[PX]; }
|
||||
|
||||
inline double Point3D::lat() const { return n[PY]; }
|
||||
|
||||
inline double Point3D::radius() const { return n[PZ]; }
|
||||
|
||||
inline double Point3D::elev() const { return n[PZ]; }
|
||||
|
||||
|
||||
// FRIENDS
|
||||
|
||||
inline Point3D operator - (const Point3D& a)
|
||||
{
|
||||
return Point3D(-a.n[PX],-a.n[PY],-a.n[PZ]);
|
||||
}
|
||||
|
||||
inline Point3D operator + (const Point3D& a, const Point3D& b)
|
||||
{
|
||||
return Point3D(a) += b;
|
||||
}
|
||||
|
||||
inline Point3D operator - (const Point3D& a, const Point3D& b)
|
||||
{
|
||||
return Point3D(a) -= b;
|
||||
}
|
||||
|
||||
inline Point3D operator * (const Point3D& a, const double d)
|
||||
{
|
||||
return Point3D(a) *= d;
|
||||
}
|
||||
|
||||
inline Point3D operator * (const double d, const Point3D& a)
|
||||
{
|
||||
return a*d;
|
||||
}
|
||||
|
||||
inline Point3D operator / (const Point3D& a, const double d)
|
||||
{
|
||||
return Point3D(a) *= (1.0 / d );
|
||||
}
|
||||
|
||||
inline bool operator == (const Point3D& a, const Point3D& b)
|
||||
{
|
||||
return
|
||||
(a.n[PX] - b.n[PX]) < fgPoint3_Epsilon &&
|
||||
(a.n[PY] - b.n[PY]) < fgPoint3_Epsilon &&
|
||||
(a.n[PZ] - b.n[PZ]) < fgPoint3_Epsilon;
|
||||
}
|
||||
|
||||
inline bool operator != (const Point3D& a, const Point3D& b)
|
||||
{
|
||||
return !(a == b);
|
||||
}
|
||||
|
||||
// Special functions
|
||||
|
||||
inline double
|
||||
Point3D::distance3D(const Point3D& a ) const
|
||||
{
|
||||
double x, y, z;
|
||||
|
||||
x = n[PX] - a.n[PX];
|
||||
y = n[PY] - a.n[PY];
|
||||
z = n[PZ] - a.n[PZ];
|
||||
|
||||
return sqrt(x*x + y*y + z*z);
|
||||
}
|
||||
|
||||
|
||||
inline double
|
||||
Point3D::distance3Dsquared(const Point3D& a ) const
|
||||
{
|
||||
double x, y, z;
|
||||
|
||||
x = n[PX] - a.n[PX];
|
||||
y = n[PY] - a.n[PY];
|
||||
z = n[PZ] - a.n[PZ];
|
||||
|
||||
return(x*x + y*y + z*z);
|
||||
}
|
||||
|
||||
|
||||
#endif // _POINT3D_HXX
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.10 1999/03/02 01:01:52 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.9 1999/02/01 21:08:28 curt
|
||||
// Optimizations from Norman Vine.
|
||||
//
|
||||
// Revision 1.8 1999/01/27 04:46:18 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.7 1999/01/19 20:56:58 curt
|
||||
// MacOS portability changes contributed by "Robert Puyol" <puyol@abvent.fr>
|
||||
//
|
||||
// Revision 1.6 1998/11/23 21:46:37 curt
|
||||
// Borland portability tweaks.
|
||||
//
|
||||
// Revision 1.5 1998/11/20 01:00:38 curt
|
||||
// Patch in fgGeoc2Geod() to avoid a floating explosion.
|
||||
// point3d.hxx include math.h for FreeBSD
|
||||
//
|
||||
// Revision 1.4 1998/11/11 00:18:38 curt
|
||||
// Check for domain error in fgGeoctoGeod()
|
||||
//
|
||||
// Revision 1.3 1998/10/20 18:21:49 curt
|
||||
// Tweaks from Bernie Bright.
|
||||
//
|
||||
// Revision 1.2 1998/10/18 01:17:12 curt
|
||||
// Point3D tweaks.
|
||||
//
|
||||
// Revision 1.1 1998/10/16 00:50:29 curt
|
||||
// Added point3d.hxx to replace cheezy fgPoint3d struct.
|
||||
//
|
||||
//
|
||||
@@ -0,0 +1,113 @@
|
||||
// polar.cxx -- routines to deal with polar math and transformations
|
||||
//
|
||||
// Written by Curtis Olson, started June 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <Include/fg_constants.h>
|
||||
|
||||
#include "polar3d.hxx"
|
||||
|
||||
|
||||
// Find the Altitude above the Ellipsoid (WGS84) given the Earth
|
||||
// Centered Cartesian coordinate vector Distances are specified in
|
||||
// meters.
|
||||
double fgGeodAltFromCart(const Point3D& cp)
|
||||
{
|
||||
double t_lat, x_alpha, mu_alpha;
|
||||
double lat_geoc, radius;
|
||||
double result;
|
||||
|
||||
lat_geoc = FG_PI_2 - atan2( sqrt(cp.x()*cp.x() + cp.y()*cp.y()), cp.z() );
|
||||
radius = sqrt( cp.x()*cp.x() + cp.y()*cp.y() + cp.z()*cp.z() );
|
||||
|
||||
if( ( (FG_PI_2 - lat_geoc) < ONE_SECOND ) // near North pole
|
||||
|| ( (FG_PI_2 + lat_geoc) < ONE_SECOND ) ) // near South pole
|
||||
{
|
||||
result = radius - EQUATORIAL_RADIUS_M*E;
|
||||
} else {
|
||||
t_lat = tan(lat_geoc);
|
||||
x_alpha = E*EQUATORIAL_RADIUS_M/sqrt(t_lat*t_lat + E*E);
|
||||
mu_alpha = atan2(sqrt(RESQ_M - x_alpha*x_alpha),E*x_alpha);
|
||||
if (lat_geoc < 0) {
|
||||
mu_alpha = - mu_alpha;
|
||||
}
|
||||
result = (radius - x_alpha/cos(lat_geoc))*cos(mu_alpha - lat_geoc);
|
||||
}
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.6 1999/01/27 04:46:19 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.5 1998/10/18 01:17:13 curt
|
||||
// Point3D tweaks.
|
||||
//
|
||||
// Revision 1.4 1998/10/16 19:30:09 curt
|
||||
// C++-ified the comments.
|
||||
//
|
||||
// Revision 1.3 1998/10/16 00:50:29 curt
|
||||
// Added point3d.hxx to replace cheezy fgPoint3d struct.
|
||||
//
|
||||
// Revision 1.2 1998/08/24 20:04:11 curt
|
||||
// Various "inline" code optimizations contributed by Norman Vine.
|
||||
//
|
||||
// Revision 1.1 1998/07/08 14:40:08 curt
|
||||
// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
// Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
// meters.
|
||||
//
|
||||
// Revision 1.2 1998/05/03 00:45:49 curt
|
||||
// Commented out a debugging printf.
|
||||
//
|
||||
// Revision 1.1 1998/05/02 01:50:11 curt
|
||||
// polar.[ch] renamed to polar3d.[ch]
|
||||
//
|
||||
// Revision 1.6 1998/04/25 22:06:23 curt
|
||||
// Edited cvs log messages in source files ... bad bad bad!
|
||||
//
|
||||
// Revision 1.5 1998/01/27 00:48:00 curt
|
||||
// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
|
||||
// system and commandline/config file processing code.
|
||||
//
|
||||
// Revision 1.4 1998/01/19 19:27:12 curt
|
||||
// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
|
||||
// This should simplify things tremendously.
|
||||
//
|
||||
// Revision 1.3 1997/12/15 23:54:54 curt
|
||||
// Add xgl wrappers for debugging.
|
||||
// Generate terrain normals on the fly.
|
||||
//
|
||||
// Revision 1.2 1997/07/31 22:52:27 curt
|
||||
// Working on redoing internal coordinate systems & scenery transformations.
|
||||
//
|
||||
// Revision 1.1 1997/07/07 21:02:36 curt
|
||||
// Initial revision.
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
// polar.hxx -- routines to deal with polar math and transformations
|
||||
//
|
||||
// Written by Curtis Olson, started June 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _POLAR_HXX
|
||||
#define _POLAR_HXX
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
|
||||
#include <Include/fg_constants.h>
|
||||
#include <Math/point3d.hxx>
|
||||
|
||||
|
||||
// Find the Altitude above the Ellipsoid (WGS84) given the Earth
|
||||
// Centered Cartesian coordinate vector Distances are specified in
|
||||
// meters.
|
||||
double fgGeodAltFromCart(const Point3D& cp);
|
||||
|
||||
|
||||
// Convert a polar coordinate to a cartesian coordinate. Lon and Lat
|
||||
// must be specified in radians. The FG convention is for distances
|
||||
// to be specified in meters
|
||||
inline Point3D fgPolarToCart3d(const Point3D& p) {
|
||||
double tmp = cos( p.lat() ) * p.radius();
|
||||
|
||||
return Point3D( cos( p.lon() ) * tmp,
|
||||
sin( p.lon() ) * tmp,
|
||||
sin( p.lat() ) * p.radius() );
|
||||
}
|
||||
|
||||
|
||||
// Convert a cartesian coordinate to polar coordinates (lon/lat
|
||||
// specified in radians. Distances are specified in meters.
|
||||
inline Point3D fgCartToPolar3d(const Point3D& cp) {
|
||||
return Point3D( atan2( cp.y(), cp.x() ),
|
||||
FG_PI_2 -
|
||||
atan2( sqrt(cp.x()*cp.x() + cp.y()*cp.y()), cp.z() ),
|
||||
sqrt(cp.x()*cp.x() + cp.y()*cp.y() + cp.z()*cp.z()) );
|
||||
}
|
||||
|
||||
|
||||
#endif // _POLAR_HXX
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.5 1999/01/27 04:46:20 curt
|
||||
// Portability tweaks by Bernie Bright.
|
||||
//
|
||||
// Revision 1.4 1998/10/16 19:30:07 curt
|
||||
// C++-ified the comments.
|
||||
//
|
||||
// Revision 1.3 1998/10/16 00:50:30 curt
|
||||
// Added point3d.hxx to replace cheezy fgPoint3d struct.
|
||||
//
|
||||
// Revision 1.2 1998/08/24 20:04:12 curt
|
||||
// Various "inline" code optimizations contributed by Norman Vine.
|
||||
//
|
||||
// Revision 1.1 1998/07/08 14:40:09 curt
|
||||
// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
// Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
// meters.
|
||||
//
|
||||
// Revision 1.1 1998/05/02 01:50:11 curt
|
||||
// polar.[ch] renamed to polar3d.[ch]
|
||||
//
|
||||
// Revision 1.9 1998/04/25 22:06:23 curt
|
||||
// Edited cvs log messages in source files ... bad bad bad!
|
||||
//
|
||||
// Revision 1.8 1998/04/21 17:03:50 curt
|
||||
// Prepairing for C++ integration.
|
||||
//
|
||||
// Revision 1.7 1998/01/27 00:48:00 curt
|
||||
// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
|
||||
// system and commandline/config file processing code.
|
||||
//
|
||||
// Revision 1.6 1998/01/22 02:59:39 curt
|
||||
// Changed #ifdef FILE_H to #ifdef _FILE_H
|
||||
//
|
||||
// Revision 1.5 1998/01/19 19:27:13 curt
|
||||
// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
|
||||
// This should simplify things tremendously.
|
||||
//
|
||||
// Revision 1.4 1997/12/15 23:54:55 curt
|
||||
// Add xgl wrappers for debugging.
|
||||
// Generate terrain normals on the fly.
|
||||
//
|
||||
// Revision 1.3 1997/07/31 22:52:28 curt
|
||||
// Working on redoing internal coordinate systems & scenery transformations.
|
||||
//
|
||||
// Revision 1.2 1997/07/23 21:52:21 curt
|
||||
// Put comments around the text after an #endif for increased portability.
|
||||
//
|
||||
// Revision 1.1 1997/07/07 21:02:37 curt
|
||||
// Initial revision.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,165 @@
|
||||
// vector.cxx -- additional vector routines
|
||||
//
|
||||
// Written by Curtis Olson, started December 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
// #include <Include/fg_types.h>
|
||||
|
||||
#include "vector.hxx"
|
||||
|
||||
#include "mat3.h"
|
||||
|
||||
|
||||
#if !defined( USE_XTRA_MAT3_INLINES )
|
||||
// Map a vector onto the plane specified by normal
|
||||
void map_vec_onto_cur_surface_plane(MAT3vec normal, MAT3vec v0, MAT3vec vec,
|
||||
MAT3vec result)
|
||||
{
|
||||
MAT3vec u1, v, tmp;
|
||||
|
||||
// calculate a vector "u1" representing the shortest distance from
|
||||
// the plane specified by normal and v0 to a point specified by
|
||||
// "vec". "u1" represents both the direction and magnitude of
|
||||
// this desired distance.
|
||||
|
||||
// u1 = ( (normal <dot> vec) / (normal <dot> normal) ) * normal
|
||||
|
||||
MAT3_SCALE_VEC( u1,
|
||||
normal,
|
||||
( MAT3_DOT_PRODUCT(normal, vec) /
|
||||
MAT3_DOT_PRODUCT(normal, normal)
|
||||
)
|
||||
);
|
||||
|
||||
// printf(" vec = %.2f, %.2f, %.2f\n", vec[0], vec[1], vec[2]);
|
||||
// printf(" v0 = %.2f, %.2f, %.2f\n", v0[0], v0[1], v0[2]);
|
||||
// printf(" u1 = %.2f, %.2f, %.2f\n", u1[0], u1[1], u1[2]);
|
||||
|
||||
// calculate the vector "v" which is the vector "vec" mapped onto
|
||||
// the plane specified by "normal" and "v0".
|
||||
|
||||
// v = v0 + vec - u1
|
||||
|
||||
MAT3_ADD_VEC(tmp, v0, vec);
|
||||
MAT3_SUB_VEC(v, tmp, u1);
|
||||
// printf(" v = %.2f, %.2f, %.2f\n", v[0], v[1], v[2]);
|
||||
|
||||
// Calculate the vector "result" which is "v" - "v0" which is a
|
||||
// directional vector pointing from v0 towards v
|
||||
|
||||
// result = v - v0
|
||||
|
||||
MAT3_SUB_VEC(result, v, v0);
|
||||
// printf(" result = %.2f, %.2f, %.2f\n",
|
||||
// result[0], result[1], result[2]);
|
||||
}
|
||||
#endif // !defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
|
||||
// Given a point p, and a line through p0 with direction vector d,
|
||||
// find the shortest distance from the point to the line
|
||||
double fgPointLine(MAT3vec p, MAT3vec p0, MAT3vec d) {
|
||||
MAT3vec u, u1, v;
|
||||
double ud, dd, tmp;
|
||||
|
||||
// u = p - p0
|
||||
MAT3_SUB_VEC(u, p, p0);
|
||||
|
||||
// calculate the projection, u1, of u along d.
|
||||
// u1 = ( dot_prod(u, d) / dot_prod(d, d) ) * d;
|
||||
ud = MAT3_DOT_PRODUCT(u, d);
|
||||
dd = MAT3_DOT_PRODUCT(d, d);
|
||||
tmp = ud / dd;
|
||||
|
||||
MAT3_SCALE_VEC(u1, d, tmp);;
|
||||
|
||||
// v = u - u1 = vector from closest point on line, p1, to the
|
||||
// original point, p.
|
||||
MAT3_SUB_VEC(v, u, u1);
|
||||
|
||||
return sqrt(MAT3_DOT_PRODUCT(v, v));
|
||||
}
|
||||
|
||||
|
||||
// Given a point p, and a line through p0 with direction vector d,
|
||||
// find the shortest distance (squared) from the point to the line
|
||||
double fgPointLineSquared(MAT3vec p, MAT3vec p0, MAT3vec d) {
|
||||
MAT3vec u, u1, v;
|
||||
double ud, dd, tmp;
|
||||
|
||||
// u = p - p0
|
||||
MAT3_SUB_VEC(u, p, p0);
|
||||
|
||||
// calculate the projection, u1, of u along d.
|
||||
// u1 = ( dot_prod(u, d) / dot_prod(d, d) ) * d;
|
||||
ud = MAT3_DOT_PRODUCT(u, d);
|
||||
dd = MAT3_DOT_PRODUCT(d, d);
|
||||
tmp = ud / dd;
|
||||
|
||||
MAT3_SCALE_VEC(u1, d, tmp);;
|
||||
|
||||
// v = u - u1 = vector from closest point on line, p1, to the
|
||||
// original point, p.
|
||||
MAT3_SUB_VEC(v, u, u1);
|
||||
|
||||
return ( MAT3_DOT_PRODUCT(v, v) );
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.6 1999/03/25 19:02:28 curt
|
||||
// Minor optimization tweaks.
|
||||
//
|
||||
// Revision 1.5 1998/10/16 23:36:38 curt
|
||||
// c++-ifying.
|
||||
//
|
||||
// Revision 1.4 1998/10/16 00:50:31 curt
|
||||
// Added point3d.hxx to replace cheezy fgPoint3d struct.
|
||||
//
|
||||
// Revision 1.3 1998/08/24 20:04:12 curt
|
||||
// Various "inline" code optimizations contributed by Norman Vine.
|
||||
//
|
||||
// Revision 1.2 1998/07/24 21:34:38 curt
|
||||
// fgPointLine() rewritten into fgPointLineSquared() ... this ultimately saves
|
||||
// us from doing a sqrt().
|
||||
//
|
||||
// Revision 1.1 1998/07/08 14:40:10 curt
|
||||
// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
// Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
// meters.
|
||||
//
|
||||
// Revision 1.3 1998/05/07 23:04:28 curt
|
||||
// Added a blank formating line!
|
||||
//
|
||||
// Revision 1.2 1998/01/19 19:27:13 curt
|
||||
// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
|
||||
// This should simplify things tremendously.
|
||||
//
|
||||
// Revision 1.1 1997/12/22 04:13:17 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,97 @@
|
||||
// vector.hxx -- additional vector routines
|
||||
//
|
||||
// Written by Curtis Olson, started December 1997.
|
||||
//
|
||||
// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _VECTOR_HXX
|
||||
#define _VECTOR_HXX
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
|
||||
#include "mat3.h"
|
||||
|
||||
|
||||
// Map a vector onto the plane specified by normal
|
||||
#if defined( USE_XTRA_MAT3_INLINES )
|
||||
# define map_vec_onto_cur_surface_plane(normal, v0, vec, result) { \
|
||||
double scale = ((normal[0]*vec[0]+normal[1]*vec[1]+normal[2]*vec[2]) / \
|
||||
(normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2])); \
|
||||
result[0] = vec[0]-normal[0]*scale; \
|
||||
result[1] = vec[1]-normal[1]*scale; \
|
||||
result[2] = vec[2]-normal[2]*scale; \
|
||||
}
|
||||
#else
|
||||
void map_vec_onto_cur_surface_plane(MAT3vec normal, MAT3vec v0, MAT3vec vec,
|
||||
MAT3vec result);
|
||||
#endif //defined( USE_XTRA_MAT3_INLINES )
|
||||
|
||||
|
||||
// Given a point p, and a line through p0 with direction vector d,
|
||||
// find the shortest distance from the point to the line
|
||||
double fgPointLine(MAT3vec p, MAT3vec p0, MAT3vec d);
|
||||
|
||||
|
||||
// Given a point p, and a line through p0 with direction vector d,
|
||||
// find the shortest distance (squared) from the point to the line
|
||||
double fgPointLineSquared(MAT3vec p, MAT3vec p0, MAT3vec d);
|
||||
|
||||
|
||||
#endif // _VECTOR_HXX
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.4 1998/10/16 23:36:39 curt
|
||||
// c++-ifying.
|
||||
//
|
||||
// Revision 1.3 1998/08/24 20:04:13 curt
|
||||
// Various "inline" code optimizations contributed by Norman Vine.
|
||||
//
|
||||
// Revision 1.2 1998/07/24 21:34:38 curt
|
||||
// fgPointLine() rewritten into fgPointLineSquared() ... this ultimately saves
|
||||
// us from doing a sqrt().
|
||||
//
|
||||
// Revision 1.1 1998/07/08 14:40:10 curt
|
||||
// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
|
||||
// Updated fg_geodesy comments to reflect that routines expect and produce
|
||||
// meters.
|
||||
//
|
||||
// Revision 1.4 1998/04/21 17:03:51 curt
|
||||
// Prepairing for C++ integration.
|
||||
//
|
||||
// Revision 1.3 1998/01/22 02:59:39 curt
|
||||
// Changed #ifdef FILE_H to #ifdef _FILE_H
|
||||
//
|
||||
// Revision 1.2 1998/01/19 19:27:14 curt
|
||||
// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
|
||||
// This should simplify things tremendously.
|
||||
//
|
||||
// Revision 1.1 1997/12/22 04:13:18 curt
|
||||
// Initial revision.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
The following files were unashamedly borrowed from other projects:
|
||||
|
||||
zfstream.hxx
|
||||
zfstream.cxx
|
||||
zlib/contrib/iostream
|
||||
|
||||
stopwatch.hxx was (blitz/time.h)
|
||||
blitz
|
||||
|
||||
Some modifications have been made to fit in with the FlightGear scheme of things.
|
||||
|
||||
As far as I'm aware they are all covered by GNU's licensing agreements.
|
||||
|
||||
Many thanks to their respective authors.
|
||||
|
||||
Bernie Bright (bbright@c031.aone.net.au)
|
||||
@@ -0,0 +1,11 @@
|
||||
## Process this file with automake to produce Makefile.in
|
||||
|
||||
noinst_LIBRARIES = libMisc.a
|
||||
|
||||
libMisc_a_SOURCES = \
|
||||
fgstream.cxx fgstream.hxx \
|
||||
stopwatch.hxx \
|
||||
strutils.cxx strutils.hxx \
|
||||
zfstream.cxx zfstream.hxx
|
||||
|
||||
INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib
|
||||
@@ -0,0 +1,154 @@
|
||||
// zlib input file stream wrapper.
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#include <ctype.h> // isspace()
|
||||
#include <Misc/fgstream.hxx>
|
||||
|
||||
fg_gzifstream::fg_gzifstream()
|
||||
: istream(&gzbuf)
|
||||
{
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Open a possibly gzipped file for reading.
|
||||
//
|
||||
fg_gzifstream::fg_gzifstream( const string& name, ios_openmode io_mode )
|
||||
: istream(&gzbuf)
|
||||
{
|
||||
this->open( name, io_mode );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Attach a stream to an already opened file descriptor.
|
||||
//
|
||||
fg_gzifstream::fg_gzifstream( int fd, ios_openmode io_mode )
|
||||
: istream(&gzbuf)
|
||||
{
|
||||
gzbuf.attach( fd, io_mode );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Open a possibly gzipped file for reading.
|
||||
// If the initial open fails and the filename has a ".gz" extension then
|
||||
// remove the extension and try again.
|
||||
// If the initial open fails and the filename doesn't have a ".gz" extension
|
||||
// then append ".gz" and try again.
|
||||
//
|
||||
void
|
||||
fg_gzifstream::open( const string& name, ios_openmode io_mode )
|
||||
{
|
||||
gzbuf.open( name.c_str(), io_mode );
|
||||
if ( ! gzbuf.is_open() )
|
||||
{
|
||||
string s = name;
|
||||
if ( s.substr( s.length() - 3, 3 ) == ".gz" )
|
||||
{
|
||||
// remove ".gz" suffix
|
||||
s.replace( s.length() - 3, 3, "" );
|
||||
// s.erase( s.length() - 3, 3 );
|
||||
}
|
||||
else
|
||||
{
|
||||
// Append ".gz" suffix
|
||||
s += ".gz";
|
||||
}
|
||||
|
||||
// Try again.
|
||||
gzbuf.open( s.c_str(), io_mode );
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
fg_gzifstream::attach( int fd, ios_openmode io_mode )
|
||||
{
|
||||
gzbuf.attach( fd, io_mode );
|
||||
}
|
||||
|
||||
//
|
||||
// Manipulators
|
||||
//
|
||||
|
||||
istream&
|
||||
skipeol( istream& in )
|
||||
{
|
||||
char c = 0;
|
||||
// skip to end of line.
|
||||
while ( in.get(c) && (c != '\n' && c != '\r') )
|
||||
;
|
||||
|
||||
// \r\n ?
|
||||
return in;
|
||||
}
|
||||
|
||||
istream&
|
||||
skipws( istream& in )
|
||||
{
|
||||
char c;
|
||||
while ( in.get(c) )
|
||||
{
|
||||
if ( ! isspace( c ) )
|
||||
{
|
||||
// put pack the non-space character
|
||||
in.putback(c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return in;
|
||||
}
|
||||
|
||||
istream&
|
||||
skipcomment( istream& in )
|
||||
{
|
||||
while ( in )
|
||||
{
|
||||
// skip whitespace
|
||||
in >> skipws;
|
||||
|
||||
char c;
|
||||
if ( in.get( c ) && c != '#' )
|
||||
{
|
||||
// not a comment
|
||||
in.putback(c);
|
||||
break;
|
||||
}
|
||||
in >> skipeol;
|
||||
}
|
||||
return in;
|
||||
}
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.3 1998/11/06 14:05:12 curt
|
||||
// More portability improvements by Bernie Bright.
|
||||
//
|
||||
// Revision 1.2 1998/09/24 15:22:17 curt
|
||||
// Additional enhancements.
|
||||
//
|
||||
// Revision 1.1 1998/09/01 19:06:29 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,132 @@
|
||||
// zlib input file stream wrapper.
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#ifndef _FGSTREAM_HXX
|
||||
#define _FGSTREAM_HXX
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "Include/config.h"
|
||||
#endif
|
||||
|
||||
#include <Include/compiler.h>
|
||||
|
||||
#if defined( FG_HAVE_STD_INCLUDES )
|
||||
# include <istream>
|
||||
#elif defined ( FG_HAVE_NATIVE_SGI_COMPILERS )
|
||||
# include <CC/stream.h>
|
||||
#else
|
||||
# include <istream.h>
|
||||
#endif
|
||||
|
||||
#include STL_STRING
|
||||
|
||||
#include "zfstream.hxx"
|
||||
|
||||
FG_USING_STD(string);
|
||||
|
||||
#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
|
||||
FG_USING_STD(istream);
|
||||
#endif
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Envelope class for gzifstream.
|
||||
//
|
||||
class fg_gzifstream : private gzifstream_base, public istream
|
||||
{
|
||||
public:
|
||||
//
|
||||
fg_gzifstream();
|
||||
|
||||
// Attempt to open a file with and without ".gz" extension.
|
||||
fg_gzifstream( const string& name,
|
||||
ios_openmode io_mode = ios_in | ios_binary );
|
||||
|
||||
//
|
||||
fg_gzifstream( int fd, ios_openmode io_mode = ios_in|ios_binary );
|
||||
|
||||
// Attempt to open a file with and without ".gz" extension.
|
||||
void open( const string& name,
|
||||
ios_openmode io_mode = ios_in|ios_binary );
|
||||
|
||||
void attach( int fd, ios_openmode io_mode = ios_in|ios_binary );
|
||||
|
||||
void close() { gzbuf.close(); }
|
||||
|
||||
bool is_open() { return gzbuf.is_open(); }
|
||||
|
||||
private:
|
||||
// Not defined!
|
||||
fg_gzifstream( const fg_gzifstream& );
|
||||
void operator= ( const fg_gzifstream& );
|
||||
};
|
||||
|
||||
// istream manipulator that skips to end of line.
|
||||
istream& skipeol( istream& in );
|
||||
|
||||
// istream manipulator that skips over white space.
|
||||
istream& skipws( istream& in );
|
||||
|
||||
// istream manipulator that skips comments and white space.
|
||||
// A comment starts with '#'.
|
||||
istream& skipcomment( istream& in );
|
||||
|
||||
|
||||
#endif /* _FGSTREAM_HXX */
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.9 1999/03/27 14:04:25 curt
|
||||
// Added is_open() so we can check if the open() succeeded.
|
||||
//
|
||||
// Revision 1.8 1999/03/02 01:01:55 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.7 1999/02/26 22:08:08 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.6 1999/01/19 20:41:46 curt
|
||||
// Portability updates contributed by Bernie Bright.
|
||||
//
|
||||
// Revision 1.5 1998/11/06 14:05:13 curt
|
||||
// More portability improvements by Bernie Bright.
|
||||
//
|
||||
// Revision 1.4 1998/10/16 00:50:56 curt
|
||||
// Remove leading _ from a couple defines.
|
||||
//
|
||||
// Revision 1.3 1998/10/13 00:10:06 curt
|
||||
// More portability changes to help with windoze compilation problems.
|
||||
//
|
||||
// Revision 1.2 1998/09/24 15:22:18 curt
|
||||
// Additional enhancements.
|
||||
//
|
||||
// Revision 1.1 1998/09/01 19:06:29 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,144 @@
|
||||
/***************************************************************************
|
||||
* stopwatch.hxx Timer class, for use in benchmarking
|
||||
*
|
||||
* Based on blitz/Timer.h
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 1997,1998 Todd Veldhuizen <tveldhui@seurat.uwaterloo.ca>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* Suggestions: blitz-suggest@cybervision.com
|
||||
* Bugs: blitz-bugs@cybervision.com
|
||||
*
|
||||
* For more information, please see the Blitz++ Home Page:
|
||||
* http://seurat.uwaterloo.ca/blitz/
|
||||
*
|
||||
***************************************************************************
|
||||
* $Log$
|
||||
* Revision 1.1 1999/04/05 21:32:33 curt
|
||||
* Initial revision
|
||||
*
|
||||
* Revision 1.3 1998/11/20 01:01:03 curt
|
||||
* FreeBSD support.
|
||||
*
|
||||
* Revision 1.2 1998/11/02 18:28:31 curt
|
||||
* Additional win32 support.
|
||||
*
|
||||
* Revision 1.1 1998/09/01 19:06:30 curt
|
||||
* Initial revision.
|
||||
*
|
||||
* Revision 1.4 1998/03/14 00:04:47 tveldhui
|
||||
* 0.2-alpha-05
|
||||
*
|
||||
* Revision 1.3 1997/07/16 14:51:20 tveldhui
|
||||
* Update: Alpha release 0.2 (Arrays)
|
||||
*
|
||||
* Revision 1.2 1997/01/24 14:42:00 tveldhui
|
||||
* Periodic RCS update
|
||||
*
|
||||
*/
|
||||
|
||||
// This class is not portable to non System V platforms.
|
||||
// It will need to be rewritten for Windows, NT, Mac.
|
||||
// NEEDS_WORK
|
||||
|
||||
#ifndef _STOPWATCH_HXX
|
||||
#define _STOPWATCH_HXX
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#if defined(__linux__) && ! defined(HAVE_GETRUSAGE)
|
||||
# define HAVE_GETRUSAGE
|
||||
#endif
|
||||
|
||||
#if defined( WIN32 ) && defined( HAVE_GETRUSAGE )
|
||||
# undef HAVE_GETRUSAGE
|
||||
#endif // WIN32
|
||||
|
||||
#if defined( HAVE_GETRUSAGE )
|
||||
# if defined( __FreeBSD__ )
|
||||
# include <sys/types.h>
|
||||
# endif
|
||||
# include <sys/time.h>
|
||||
# include <sys/resource.h>
|
||||
# include <unistd.h>
|
||||
#elif defined( WIN32 )
|
||||
# include <windows.h>
|
||||
#else
|
||||
# include <time.h>
|
||||
#endif
|
||||
|
||||
class StopWatch {
|
||||
|
||||
public:
|
||||
StopWatch()
|
||||
{
|
||||
// state_ = uninitialized;
|
||||
}
|
||||
|
||||
void start()
|
||||
{
|
||||
// state_ = running;
|
||||
t1_ = systemTime();
|
||||
}
|
||||
|
||||
void stop()
|
||||
{
|
||||
t2_ = systemTime();
|
||||
// BZPRECONDITION(state_ == running);
|
||||
// state_ = stopped;
|
||||
}
|
||||
|
||||
double elapsedSeconds()
|
||||
{
|
||||
// BZPRECONDITION(state_ == stopped);
|
||||
return t2_ - t1_;
|
||||
}
|
||||
|
||||
private:
|
||||
StopWatch(StopWatch&) { }
|
||||
void operator=(StopWatch&) { }
|
||||
|
||||
double systemTime()
|
||||
{
|
||||
#if defined( HAVE_GETRUSAGE )
|
||||
getrusage(RUSAGE_SELF, &resourceUsage_);
|
||||
double seconds = resourceUsage_.ru_utime.tv_sec
|
||||
+ resourceUsage_.ru_stime.tv_sec;
|
||||
double micros = resourceUsage_.ru_utime.tv_usec
|
||||
+ resourceUsage_.ru_stime.tv_usec;
|
||||
return seconds + micros/1.0e6;
|
||||
#elif defined( WIN32 )
|
||||
return double(GetTickCount()) * double(1e-3);
|
||||
#else
|
||||
return clock() / (double) CLOCKS_PER_SEC;
|
||||
#endif
|
||||
}
|
||||
|
||||
// enum { uninitialized, running, stopped } state_;
|
||||
|
||||
#if defined( HAVE_GETRUSAGE )
|
||||
struct rusage resourceUsage_;
|
||||
#endif
|
||||
|
||||
double t1_, t2_;
|
||||
};
|
||||
|
||||
#endif // _STOPWATCH_HXX
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
// String utilities.
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "strutils.hxx"
|
||||
|
||||
const string whitespace = " \n\r\t";
|
||||
|
||||
//
|
||||
string
|
||||
trimleft( const string& s, const string& trimmings )
|
||||
{
|
||||
string result;
|
||||
string::size_type pos = s.find_first_not_of( trimmings );
|
||||
if ( pos != string::npos )
|
||||
{
|
||||
result.assign( s.substr( pos ) );
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//
|
||||
string
|
||||
trimright( const string& s, const string& trimmings )
|
||||
{
|
||||
string result;
|
||||
|
||||
string::size_type pos = s.find_last_not_of( trimmings );
|
||||
if ( pos == string::npos )
|
||||
{
|
||||
// Not found, return the original string.
|
||||
result = s;
|
||||
}
|
||||
else
|
||||
{
|
||||
result.assign( s.substr( 0, pos+1 ) );
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//
|
||||
string
|
||||
trim( const string& s, const string& trimmings )
|
||||
{
|
||||
return trimright( trimleft( s, trimmings ), trimmings );
|
||||
}
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.2 1998/10/18 01:17:15 curt
|
||||
// Point3D tweaks.
|
||||
//
|
||||
// Revision 1.1 1998/09/01 19:06:30 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,87 @@
|
||||
// String utilities.
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#ifndef STRUTILS_H
|
||||
#define STRUTILS_H
|
||||
|
||||
#include <Include/compiler.h>
|
||||
#include STL_STRING
|
||||
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
# include <cstdlib>
|
||||
#else
|
||||
# include <stdlib.h>
|
||||
#endif
|
||||
|
||||
FG_USING_STD(string);
|
||||
|
||||
// Default characters to remove.
|
||||
extern const string whitespace;
|
||||
|
||||
// Returns a string with trailing characters removed.
|
||||
string trimleft( const string& s, const string& trimmings = whitespace );
|
||||
|
||||
// Returns a string with leading characters removed.
|
||||
string trimright( const string& s, const string& trimmings = whitespace );
|
||||
|
||||
// Returns a string with leading and trailing characters removed.
|
||||
string trim( const string& s, const string& trimmings = whitespace );
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
inline double
|
||||
atof( const string& str )
|
||||
{
|
||||
return ::atof( str.c_str() );
|
||||
}
|
||||
|
||||
inline int
|
||||
atoi( const string& str )
|
||||
{
|
||||
return ::atoi( str.c_str() );
|
||||
}
|
||||
|
||||
#endif // STRUTILS_H
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.6 1999/03/02 01:01:56 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.5 1999/02/26 22:08:09 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.4 1999/01/19 20:41:47 curt
|
||||
// Portability updates contributed by Bernie Bright.
|
||||
//
|
||||
// Revision 1.3 1998/10/16 00:50:57 curt
|
||||
// Remove leading _ from a couple defines.
|
||||
//
|
||||
// Revision 1.2 1998/10/13 00:10:07 curt
|
||||
// More portability changes to help with windoze compilation problems.
|
||||
//
|
||||
// Revision 1.1 1998/09/01 19:06:31 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,320 @@
|
||||
// A C++ I/O streams interface to the zlib gz* functions
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#include <memory.h>
|
||||
#include "zfstream.hxx"
|
||||
|
||||
//
|
||||
// Construct a gzfilebuf object.
|
||||
// Allocate memory for 'get' buffer and zero all buffer pointers.
|
||||
//
|
||||
gzfilebuf::gzfilebuf()
|
||||
: streambuf(),
|
||||
file(NULL),
|
||||
mode(0),
|
||||
own_file_descriptor(false),
|
||||
ibuf_size(0),
|
||||
ibuffer(0)
|
||||
{
|
||||
// try {
|
||||
ibuf_size = page_size / sizeof(char);
|
||||
ibuffer = new char [ibuf_size];
|
||||
// } catch (...) {
|
||||
// delete [] ibuffer;
|
||||
// }
|
||||
|
||||
// Null get and set pointers.
|
||||
this->setg(0,0,0);
|
||||
this->setp(0,0);
|
||||
}
|
||||
|
||||
gzfilebuf::~gzfilebuf()
|
||||
{
|
||||
sync();
|
||||
if ( own_file_descriptor )
|
||||
this->close();
|
||||
delete [] ibuffer;
|
||||
}
|
||||
|
||||
void
|
||||
gzfilebuf::cvt_iomode( char* p, ios_openmode io_mode )
|
||||
{
|
||||
// memset( char_mode, '\0', 10 );
|
||||
// char* p = char_mode;
|
||||
|
||||
if ( io_mode & ios_in )
|
||||
{
|
||||
mode = ios_in;
|
||||
*p++ = 'r';
|
||||
}
|
||||
else if ( io_mode & ios_app )
|
||||
{
|
||||
mode = ios_app;
|
||||
*p++ = 'a';
|
||||
}
|
||||
else
|
||||
{
|
||||
mode = ios_out;
|
||||
*p++ = 'w';
|
||||
}
|
||||
|
||||
if ( io_mode & ios_binary )
|
||||
{
|
||||
mode |= ios_binary;
|
||||
*p++ = 'b';
|
||||
}
|
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios_out | ios_app) )
|
||||
{
|
||||
*p++ = '9';
|
||||
}
|
||||
|
||||
*p = '\0';
|
||||
}
|
||||
|
||||
gzfilebuf*
|
||||
gzfilebuf::open( const char *name, ios_openmode io_mode )
|
||||
{
|
||||
if ( is_open() )
|
||||
return NULL;
|
||||
|
||||
char char_mode[10];
|
||||
cvt_iomode( char_mode, io_mode );
|
||||
if ( (file = gzopen(name, char_mode)) == NULL )
|
||||
return NULL;
|
||||
|
||||
own_file_descriptor = true;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
gzfilebuf*
|
||||
gzfilebuf::attach( int file_descriptor, ios_openmode io_mode )
|
||||
{
|
||||
if ( is_open() )
|
||||
return NULL;
|
||||
|
||||
char char_mode[10];
|
||||
cvt_iomode( char_mode, io_mode );
|
||||
if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
|
||||
return NULL;
|
||||
|
||||
own_file_descriptor = false;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
gzfilebuf*
|
||||
gzfilebuf::close()
|
||||
{
|
||||
if ( is_open() )
|
||||
{
|
||||
sync();
|
||||
gzclose( file );
|
||||
file = NULL;
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
// int
|
||||
// gzfilebuf::setcompressionlevel( int comp_level )
|
||||
// {
|
||||
// return gzsetparams(file, comp_level, -2);
|
||||
// }
|
||||
|
||||
// int
|
||||
// gzfilebuf::setcompressionstrategy( int comp_strategy )
|
||||
// {
|
||||
// return gzsetparams(file, -2, comp_strategy);
|
||||
// }
|
||||
|
||||
|
||||
streampos
|
||||
gzfilebuf::seekoff( streamoff, ios_seekdir, int )
|
||||
{
|
||||
return streampos(EOF);
|
||||
}
|
||||
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::overflow( int_type )
|
||||
{
|
||||
#if 0
|
||||
if ( !is_open() || !(mode & ios::out) )
|
||||
return EOF;
|
||||
|
||||
if ( !base() )
|
||||
{
|
||||
if ( allocate() == EOF )
|
||||
return EOF;
|
||||
setg(0,0,0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (in_avail())
|
||||
{
|
||||
return EOF;
|
||||
}
|
||||
|
||||
if (out_waiting())
|
||||
{
|
||||
if (flushbuf() == EOF)
|
||||
return EOF;
|
||||
}
|
||||
}
|
||||
|
||||
int bl = blen();
|
||||
setp( base(), base() + bl);
|
||||
|
||||
if ( c != EOF )
|
||||
{
|
||||
*pptr() = c;
|
||||
pbump(1);
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
gzfilebuf::sync()
|
||||
{
|
||||
if ( !is_open() )
|
||||
return EOF;
|
||||
|
||||
if ( pptr() != 0 && pptr() > pbase() )
|
||||
return flushbuf();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::flushbuf()
|
||||
{
|
||||
char* q = pbase();
|
||||
int n = pptr() - q;
|
||||
|
||||
if ( gzwrite( file, q, n) < n )
|
||||
return traits_type::eof();
|
||||
|
||||
setp(0,0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::underflow()
|
||||
{
|
||||
// cerr << "gzfilebuf::underflow(): gptr()=" << (void*)gptr() << endl;
|
||||
// Error if the file not open for reading.
|
||||
if ( !is_open() || !(mode & ios_in) )
|
||||
return traits_type::eof();
|
||||
|
||||
// If the input buffer is empty then try to fill it.
|
||||
if ( gptr() != 0 && gptr() < egptr() )
|
||||
{
|
||||
return int_type(*gptr());
|
||||
}
|
||||
else
|
||||
{
|
||||
return fillbuf() == EOF ? traits_type::eof() : int_type(*gptr());
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Load the input buffer from the underlying gz file.
|
||||
// Returns number of characters read, or EOF.
|
||||
//
|
||||
int
|
||||
gzfilebuf::fillbuf()
|
||||
{
|
||||
int t = gzread( file, ibuffer, ibuf_size );
|
||||
if ( t <= 0)
|
||||
{
|
||||
// disable get area
|
||||
setg(0,0,0);
|
||||
return EOF;
|
||||
}
|
||||
|
||||
// Set the input (get) pointers
|
||||
setg( ibuffer, ibuffer, ibuffer+t );
|
||||
|
||||
// cerr << "gzfilebuf::fillbuf():"
|
||||
// << " t=" << t
|
||||
// << ", ibuffer=" << (void*)ibuffer
|
||||
// << ", ibuffer+t=" << (void*)(ibuffer+t) << endl;
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
#if 0
|
||||
gzifstream::gzifstream()
|
||||
: istream(&buffer), buffer()
|
||||
{
|
||||
clear( ios_badbit );
|
||||
}
|
||||
|
||||
gzifstream::gzifstream( const char *name, ios_openmode io_mode )
|
||||
: istream(&buffer), buffer()
|
||||
{
|
||||
this->open( name, io_mode );
|
||||
}
|
||||
|
||||
gzifstream::gzifstream( int fd, ios_openmode io_mode )
|
||||
: istream(&buffer), buffer()
|
||||
{
|
||||
buffer.attach( fd, io_mode );
|
||||
}
|
||||
|
||||
gzifstream::~gzifstream()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
gzifstream::open( const char *name, ios_openmode io_mode )
|
||||
{
|
||||
if ( !buffer.open( name, io_mode ) )
|
||||
clear( ios_failbit | ios_badbit );
|
||||
else
|
||||
clear();
|
||||
}
|
||||
|
||||
void
|
||||
gzifstream::close()
|
||||
{
|
||||
if ( !buffer.close() )
|
||||
clear( ios_failbit | ios_badbit );
|
||||
}
|
||||
#endif
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.3 1999/01/19 20:41:48 curt
|
||||
// Portability updates contributed by Bernie Bright.
|
||||
//
|
||||
// Revision 1.2 1998/11/06 14:05:14 curt
|
||||
// More portability improvements by Bernie Bright.
|
||||
//
|
||||
@@ -0,0 +1,180 @@
|
||||
// A C++ I/O streams interface to the zlib gz* functions
|
||||
//
|
||||
// Written by Bernie Bright, 1998
|
||||
// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
//
|
||||
// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
#ifndef _zfstream_hxx
|
||||
#define _zfstream_hxx
|
||||
|
||||
#include "zlib/zlib.h"
|
||||
#include "Include/compiler.h"
|
||||
|
||||
#ifdef FG_HAVE_STD_INCLUDES
|
||||
|
||||
# include <streambuf>
|
||||
# include <istream>
|
||||
|
||||
# define ios_openmode ios_base::openmode
|
||||
# define ios_in ios_base::in
|
||||
# define ios_out ios_base::out
|
||||
# define ios_app ios_base::app
|
||||
# define ios_binary ios_base::binary
|
||||
|
||||
# define ios_seekdir ios_base::seekdir
|
||||
|
||||
# define ios_badbit ios_base::badbit
|
||||
# define ios_failbit ios_base::failbit
|
||||
|
||||
FG_USING_STD(streambuf);
|
||||
FG_USING_STD(ios_base);
|
||||
FG_USING_STD(streampos);
|
||||
FG_USING_STD(streamoff);
|
||||
|
||||
#else
|
||||
|
||||
# ifdef FG_HAVE_STREAMBUF
|
||||
# include <streambuf.h>
|
||||
# include <istream.h>
|
||||
# else
|
||||
# include <iostream.h>
|
||||
# endif
|
||||
|
||||
//# define ios_openmode ios::open_mode
|
||||
# define ios_openmode int
|
||||
# define ios_in ios::in
|
||||
# define ios_out ios::out
|
||||
# define ios_app ios::app
|
||||
|
||||
#if defined(__GNUC__) && __GNUC_MINOR__ < 8
|
||||
# define ios_binary ios::bin
|
||||
#elif defined( FG_HAVE_NATIVE_SGI_COMPILERS )
|
||||
# define ios_binary 0
|
||||
#else
|
||||
# define ios_binary ios::binary
|
||||
#endif
|
||||
|
||||
# define ios_seekdir ios::seek_dir
|
||||
|
||||
# define ios_badbit ios::badbit
|
||||
# define ios_failbit ios::failbit
|
||||
|
||||
# include "Include/fg_traits.hxx"
|
||||
|
||||
#endif // FG_HAVE_STD_INCLUDES
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
//
|
||||
//
|
||||
class gzfilebuf : public streambuf
|
||||
{
|
||||
public:
|
||||
|
||||
#ifndef FG_HAVE_STD_INCLUDES
|
||||
typedef char_traits<char> traits_type;
|
||||
typedef char_traits<char>::int_type int_type;
|
||||
typedef char_traits<char>::pos_type pos_type;
|
||||
typedef char_traits<char>::off_type off_type;
|
||||
#endif
|
||||
|
||||
gzfilebuf();
|
||||
virtual ~gzfilebuf();
|
||||
|
||||
gzfilebuf* open( const char* name, ios_openmode io_mode );
|
||||
gzfilebuf* attach( int file_descriptor, ios_openmode io_mode );
|
||||
gzfilebuf* close();
|
||||
|
||||
// int setcompressionlevel( int comp_level );
|
||||
// int setcompressionstrategy( int comp_strategy );
|
||||
bool is_open() const { return (file != NULL); }
|
||||
virtual streampos seekoff( streamoff off, ios_seekdir way, int which );
|
||||
virtual int sync();
|
||||
|
||||
protected:
|
||||
|
||||
virtual int_type underflow();
|
||||
virtual int_type overflow( int_type c = traits_type::eof() );
|
||||
|
||||
private:
|
||||
|
||||
int_type flushbuf();
|
||||
int fillbuf();
|
||||
|
||||
// Convert io_mode to "rwab" string.
|
||||
void cvt_iomode( char* mode_str, ios_openmode io_mode );
|
||||
|
||||
private:
|
||||
|
||||
gzFile file;
|
||||
ios_openmode mode;
|
||||
bool own_file_descriptor;
|
||||
|
||||
// Get (input) buffer.
|
||||
int ibuf_size;
|
||||
char* ibuffer;
|
||||
|
||||
enum { page_size = 4096 };
|
||||
|
||||
private:
|
||||
// Not defined
|
||||
gzfilebuf( const gzfilebuf& );
|
||||
void operator= ( const gzfilebuf& );
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
//
|
||||
//
|
||||
struct gzifstream_base
|
||||
{
|
||||
gzifstream_base() {}
|
||||
|
||||
gzfilebuf gzbuf;
|
||||
};
|
||||
|
||||
#endif // _zfstream_hxx
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:33 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.9 1999/03/08 22:00:12 curt
|
||||
// Tweak for native SGI compilers.
|
||||
//
|
||||
// Revision 1.8 1999/02/26 22:08:10 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.7 1999/01/19 20:41:49 curt
|
||||
// Portability updates contributed by Bernie Bright.
|
||||
//
|
||||
// Revision 1.6 1998/12/07 21:10:26 curt
|
||||
// Portability improvements.
|
||||
//
|
||||
// Revision 1.5 1998/11/06 21:17:29 curt
|
||||
// Converted to new logstream debugging facility. This allows release
|
||||
// builds with no messages at all (and no performance impact) by using
|
||||
// the -DFG_NDEBUG flag.
|
||||
//
|
||||
// Revision 1.4 1998/11/06 14:05:16 curt
|
||||
// More portability improvements by Bernie Bright.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
bin_PROGRAMS = testserial
|
||||
|
||||
noinst_LIBRARIES = libSerial.a
|
||||
|
||||
libSerial_a_SOURCES = serial.cxx serial.hxx
|
||||
|
||||
testserial_SOURCES = testserial.cxx
|
||||
|
||||
testserial_LDADD = \
|
||||
$(top_builddir)/Lib/Serial/libSerial.a \
|
||||
$(top_builddir)/Lib/Debug/libDebug.a
|
||||
|
||||
INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib
|
||||
@@ -0,0 +1,384 @@
|
||||
// serial.cxx -- Unix serial I/O support
|
||||
//
|
||||
// Written by Curtis Olson, started November 1998.
|
||||
//
|
||||
// Copyright (C) 1998 Curtis L. Olson - curt@flightgear.org
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "Include/compiler.h"
|
||||
#ifdef FG_HAVE_STD_INCLUDE
|
||||
# include <cerrno>
|
||||
#else
|
||||
# include <errno.h>
|
||||
#endif
|
||||
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
// maybe include something???
|
||||
#else
|
||||
# include <termios.h>
|
||||
# include <sys/types.h>
|
||||
# include <sys/stat.h>
|
||||
# include <fcntl.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <Debug/logstream.hxx>
|
||||
|
||||
#include "serial.hxx"
|
||||
|
||||
|
||||
fgSERIAL::fgSERIAL()
|
||||
: dev_open(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
fgSERIAL::fgSERIAL(const string& device, int baud) {
|
||||
open_port(device);
|
||||
|
||||
if ( dev_open ) {
|
||||
set_baud(baud);
|
||||
}
|
||||
}
|
||||
|
||||
fgSERIAL::~fgSERIAL() {
|
||||
// closing the port here screws us up because if we would even so
|
||||
// much as make a copy of an fgSERIAL object and then delete it,
|
||||
// the file descriptor gets closed. Doh!!!
|
||||
}
|
||||
|
||||
bool fgSERIAL::open_port(const string& device) {
|
||||
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
|
||||
fd = CreateFile( device.c_str(),
|
||||
GENERIC_READ | GENERIC_WRITE,
|
||||
0, // dwShareMode
|
||||
NULL, // lpSecurityAttributes
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAG_OVERLAPPED,
|
||||
NULL );
|
||||
if ( fd == INVALID_HANDLE_VALUE )
|
||||
{
|
||||
LPVOID lpMsgBuf;
|
||||
FormatMessage(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||
NULL,
|
||||
GetLastError(),
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
||||
(LPTSTR) &lpMsgBuf,
|
||||
0,
|
||||
NULL );
|
||||
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Error opening serial device \""
|
||||
<< device << "\" " << (const char*) lpMsgBuf );
|
||||
LocalFree( lpMsgBuf );
|
||||
return false;
|
||||
}
|
||||
|
||||
dev_open = true;
|
||||
return true;
|
||||
|
||||
#else
|
||||
|
||||
struct termios config;
|
||||
|
||||
fd = open(device.c_str(), O_RDWR | O_NONBLOCK);
|
||||
cout << "Serial fd created = " << fd << endl;
|
||||
|
||||
if ( fd == -1 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Cannot open " << device
|
||||
<< " for serial I/O" );
|
||||
return false;
|
||||
} else {
|
||||
dev_open = true;
|
||||
}
|
||||
|
||||
// set required port parameters
|
||||
if ( tcgetattr( fd, &config ) != 0 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Unable to poll port settings" );
|
||||
return false;
|
||||
}
|
||||
|
||||
// cfmakeraw( &config );
|
||||
|
||||
// cout << "config.c_iflag = " << config.c_iflag << endl;
|
||||
|
||||
// software flow control on
|
||||
config.c_iflag |= IXON;
|
||||
// config.c_iflag |= IXOFF;
|
||||
|
||||
// config.c_cflag |= CLOCAL;
|
||||
|
||||
#if ! defined( sgi )
|
||||
// disable hardware flow control
|
||||
config.c_cflag &= ~(CRTSCTS);
|
||||
#endif
|
||||
|
||||
// cout << "config.c_iflag = " << config.c_iflag << endl;
|
||||
|
||||
if ( tcsetattr( fd, TCSANOW, &config ) != 0 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Unable to update port settings" );
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
bool fgSERIAL::close_port() {
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
CloseHandle( fd );
|
||||
#else
|
||||
close(fd);
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool fgSERIAL::set_baud(int baud) {
|
||||
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
|
||||
return true;
|
||||
|
||||
#else
|
||||
|
||||
struct termios config;
|
||||
speed_t speed = B9600;
|
||||
|
||||
if ( tcgetattr( fd, &config ) != 0 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Unable to poll port settings" );
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( baud == 300 ) {
|
||||
speed = B300;
|
||||
} else if ( baud == 1200 ) {
|
||||
speed = B1200;
|
||||
} else if ( baud == 2400 ) {
|
||||
speed = B2400;
|
||||
} else if ( baud == 4800 ) {
|
||||
speed = B4800;
|
||||
} else if ( baud == 9600 ) {
|
||||
speed = B9600;
|
||||
} else if ( baud == 19200 ) {
|
||||
speed = B19200;
|
||||
} else if ( baud == 38400 ) {
|
||||
speed = B38400;
|
||||
} else if ( baud == 57600 ) {
|
||||
speed = B57600;
|
||||
} else if ( baud == 115200 ) {
|
||||
speed = B115200;
|
||||
#if defined( linux ) || defined( __FreeBSD__ )
|
||||
} else if ( baud == 230400 ) {
|
||||
speed = B230400;
|
||||
#endif
|
||||
} else {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Unsupported baud rate " << baud );
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( cfsetispeed( &config, speed ) != 0 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Problem setting input baud rate" );
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( cfsetospeed( &config, speed ) != 0 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Problem setting output baud rate" );
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( tcsetattr( fd, TCSANOW, &config ) != 0 ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Unable to update port settings" );
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
string fgSERIAL::read_port() {
|
||||
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
|
||||
string result = "";
|
||||
return result;
|
||||
|
||||
#else
|
||||
|
||||
const int max_count = 1024;
|
||||
char buffer[max_count+1];
|
||||
int count;
|
||||
string result;
|
||||
|
||||
count = read(fd, buffer, max_count);
|
||||
// cout << "read " << count << " bytes" << endl;
|
||||
|
||||
if ( count < 0 ) {
|
||||
// error condition
|
||||
if ( errno != EAGAIN ) {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT,
|
||||
"Serial I/O on read, error number = " << errno );
|
||||
}
|
||||
|
||||
return "";
|
||||
} else {
|
||||
buffer[count] = '\0';
|
||||
result = buffer;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
int fgSERIAL::write_port(const string& value) {
|
||||
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
|
||||
LPCVOID lpBuffer = value.c_str();
|
||||
DWORD nNumberOfBytesToWrite = value.length();
|
||||
DWORD lpNumberOfBytesWritten;
|
||||
OVERLAPPED lpOverlapped;
|
||||
|
||||
if ( WriteFile( fd,
|
||||
lpBuffer,
|
||||
nNumberOfBytesToWrite,
|
||||
&lpNumberOfBytesWritten,
|
||||
&lpOverlapped ) == 0 )
|
||||
{
|
||||
LPVOID lpMsgBuf;
|
||||
FormatMessage(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||
NULL,
|
||||
GetLastError(),
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
||||
(LPTSTR) &lpMsgBuf,
|
||||
0,
|
||||
NULL );
|
||||
|
||||
FG_LOG( FG_SERIAL, FG_ALERT, "Serial I/O write error: "
|
||||
<< (const char*) lpMsgBuf );
|
||||
LocalFree( lpMsgBuf );
|
||||
return int(lpNumberOfBytesWritten);
|
||||
}
|
||||
|
||||
return int(lpNumberOfBytesWritten);
|
||||
|
||||
#else
|
||||
|
||||
static bool error = false;
|
||||
int count;
|
||||
|
||||
if ( error ) {
|
||||
// attempt some sort of error recovery
|
||||
count = write(fd, "\n", 1);
|
||||
if ( count == 1 ) {
|
||||
// cout << "Serial error recover successful!\n";
|
||||
error = false;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
count = write(fd, value.c_str(), value.length());
|
||||
// cout << "write '" << value << "' " << count << " bytes" << endl;
|
||||
|
||||
if ( (int)count == (int)value.length() ) {
|
||||
error = false;
|
||||
} else {
|
||||
error = true;
|
||||
if ( errno == EAGAIN ) {
|
||||
// ok ... in our context we don't really care if we can't
|
||||
// write a string, we'll just get it the next time around
|
||||
} else {
|
||||
FG_LOG( FG_SERIAL, FG_ALERT,
|
||||
"Serial I/O on write, error number = " << errno );
|
||||
}
|
||||
}
|
||||
|
||||
return count;
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:34 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.9 1999/02/02 20:13:23 curt
|
||||
// MSVC++ portability changes by Bernie Bright:
|
||||
//
|
||||
// Lib/Serial/serial.[ch]xx: Initial Windows support - incomplete.
|
||||
// Simulator/Astro/stars.cxx: typo? included <stdio> instead of <cstdio>
|
||||
// Simulator/Cockpit/hud.cxx: Added Standard headers
|
||||
// Simulator/Cockpit/panel.cxx: Redefinition of default parameter
|
||||
// Simulator/Flight/flight.cxx: Replaced cout with FG_LOG. Deleted <stdio.h>
|
||||
// Simulator/Main/fg_init.cxx:
|
||||
// Simulator/Main/GLUTmain.cxx:
|
||||
// Simulator/Main/options.hxx: Shuffled <fg_serial.hxx> dependency
|
||||
// Simulator/Objects/material.hxx:
|
||||
// Simulator/Time/timestamp.hxx: VC++ friend kludge
|
||||
// Simulator/Scenery/tile.[ch]xx: Fixed using std::X declarations
|
||||
// Simulator/Main/views.hxx: Added a constant
|
||||
//
|
||||
// Revision 1.8 1999/01/20 13:42:21 curt
|
||||
// Tweaked FDM interface.
|
||||
// Testing check sum support for NMEA serial output.
|
||||
//
|
||||
// Revision 1.7 1998/12/04 01:24:35 curt
|
||||
// Tweak for SGI portability.
|
||||
//
|
||||
// Revision 1.6 1998/11/30 17:15:29 curt
|
||||
// Having the class destructor close the fd was a bad idea ... especially if you
|
||||
// ever make a copy of the instance and then subsequently destroy either.
|
||||
// close_port() is now a separate member function.
|
||||
//
|
||||
// Revision 1.5 1998/11/25 01:33:23 curt
|
||||
// Remove call to cfmakeraw()
|
||||
//
|
||||
// Revision 1.4 1998/11/23 21:47:00 curt
|
||||
// Cygnus tools compatibility tweaks.
|
||||
//
|
||||
// Revision 1.3 1998/11/19 13:52:54 curt
|
||||
// port configuration tweaks & experiments.
|
||||
//
|
||||
// Revision 1.2 1998/11/19 03:35:43 curt
|
||||
// Updates ...
|
||||
//
|
||||
// Revision 1.1 1998/11/16 13:53:02 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,115 @@
|
||||
// serial.hxx -- Unix serial I/O support
|
||||
//
|
||||
// Written by Curtis Olson, started November 1998.
|
||||
//
|
||||
// Copyright (C) 1998 Curtis L. Olson - curt@flightgear.org
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
//
|
||||
// $Id$
|
||||
// (Log is kept at end of this file)
|
||||
|
||||
|
||||
#ifndef _SERIAL_HXX
|
||||
#define _SERIAL_HXX
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
#include <Include/compiler.h>
|
||||
#include STL_STRING
|
||||
FG_USING_STD(string);
|
||||
|
||||
// if someone know how to do this all with C++ streams let me know
|
||||
// #include <stdio.h>
|
||||
|
||||
|
||||
class fgSERIAL
|
||||
{
|
||||
#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
|
||||
typedef HANDLE fd_type;
|
||||
#else
|
||||
typedef int fd_type;
|
||||
#endif
|
||||
|
||||
private:
|
||||
|
||||
fd_type fd;
|
||||
bool dev_open;
|
||||
|
||||
public:
|
||||
|
||||
fgSERIAL();
|
||||
fgSERIAL(const string& device, int baud);
|
||||
|
||||
~fgSERIAL();
|
||||
|
||||
bool open_port(const string& device);
|
||||
bool close_port();
|
||||
bool set_baud(int baud);
|
||||
string read_port();
|
||||
int write_port(const string& value);
|
||||
|
||||
inline bool is_enabled() { return dev_open; }
|
||||
};
|
||||
|
||||
|
||||
#endif // _SERIAL_HXX
|
||||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.1 1999/04/05 21:32:34 curt
|
||||
// Initial revision
|
||||
//
|
||||
// Revision 1.5 1999/03/02 01:01:58 curt
|
||||
// Tweaks for compiling with native SGI compilers.
|
||||
//
|
||||
// Revision 1.4 1999/02/26 22:08:13 curt
|
||||
// Added initial support for native SGI compilers.
|
||||
//
|
||||
// Revision 1.3 1999/02/02 20:13:24 curt
|
||||
// MSVC++ portability changes by Bernie Bright:
|
||||
//
|
||||
// Lib/Serial/serial.[ch]xx: Initial Windows support - incomplete.
|
||||
// Simulator/Astro/stars.cxx: typo? included <stdio> instead of <cstdio>
|
||||
// Simulator/Cockpit/hud.cxx: Added Standard headers
|
||||
// Simulator/Cockpit/panel.cxx: Redefinition of default parameter
|
||||
// Simulator/Flight/flight.cxx: Replaced cout with FG_LOG. Deleted <stdio.h>
|
||||
// Simulator/Main/fg_init.cxx:
|
||||
// Simulator/Main/GLUTmain.cxx:
|
||||
// Simulator/Main/options.hxx: Shuffled <fg_serial.hxx> dependency
|
||||
// Simulator/Objects/material.hxx:
|
||||
// Simulator/Time/timestamp.hxx: VC++ friend kludge
|
||||
// Simulator/Scenery/tile.[ch]xx: Fixed using std::X declarations
|
||||
// Simulator/Main/views.hxx: Added a constant
|
||||
//
|
||||
// Revision 1.2 1998/11/30 17:15:30 curt
|
||||
// Having the class destructor close the fd was a bad idea ... especially if you
|
||||
// ever make a copy of the instance and then subsequently destroy either.
|
||||
// close_port() is now a separate member function.
|
||||
//
|
||||
// Revision 1.1 1998/11/16 13:53:02 curt
|
||||
// Initial revision.
|
||||
//
|
||||
@@ -0,0 +1,30 @@
|
||||
#include <string>
|
||||
|
||||
#include <Debug/logstream.hxx>
|
||||
|
||||
#include "serial.hxx"
|
||||
|
||||
main () {
|
||||
fgSERIAL port;
|
||||
string value;
|
||||
bool result;
|
||||
|
||||
fglog().setLogLevels( FG_ALL, FG_INFO );
|
||||
|
||||
cout << "start of main" << endl;
|
||||
|
||||
result = port.open_port("/dev/ttyS1");
|
||||
cout << "opened port, result = " << result << endl;
|
||||
|
||||
result = port.set_baud(4800);
|
||||
cout << "set baud, result = " << result << endl;
|
||||
|
||||
port.write_port("ATDT 626-9800\n");
|
||||
|
||||
while ( true ) {
|
||||
value = port.read_port();
|
||||
if ( value.length() ) {
|
||||
cout << "-> " << value << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
lib_LIBRARIES = libXGL.a
|
||||
|
||||
libXGL_a_SOURCES = xgl.c xgl.h xglUtils.c
|
||||
|
||||
INCLUDES += -I$(top_builddir) -I$(top_builddir)/Simulator
|
||||
+3034
File diff suppressed because it is too large
Load Diff
+837
@@ -0,0 +1,837 @@
|
||||
#ifndef _XGL_H
|
||||
#define _XGL_H
|
||||
|
||||
|
||||
#ifdef HAVE_WINDOWS_H
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glu.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/* xgl Utilities */
|
||||
|
||||
extern FILE *xglTraceFd ;
|
||||
|
||||
int xglTraceIsEnabled ( char *gl_function_name ) ;
|
||||
int xglExecuteIsEnabled ( char *gl_function_name ) ;
|
||||
char *xglExpandGLenum ( GLenum x ) ;
|
||||
|
||||
GLdouble *xglBuild1dv ( GLdouble v ) ;
|
||||
GLfloat *xglBuild1fv ( GLfloat v ) ;
|
||||
GLbyte *xglBuild1bv ( GLbyte v ) ;
|
||||
GLint *xglBuild1iv ( GLint v ) ;
|
||||
GLshort *xglBuild1sv ( GLshort v ) ;
|
||||
GLubyte *xglBuild1ubv ( GLubyte v ) ;
|
||||
GLuint *xglBuild1uiv ( GLuint v ) ;
|
||||
GLushort *xglBuild1usv ( GLushort v ) ;
|
||||
|
||||
GLdouble *xglBuild2dv ( GLdouble v0, GLdouble v1 ) ;
|
||||
GLfloat *xglBuild2fv ( GLfloat v0, GLfloat v1 ) ;
|
||||
GLbyte *xglBuild2bv ( GLbyte v0, GLbyte v1 ) ;
|
||||
GLint *xglBuild2iv ( GLint v0, GLint v1 ) ;
|
||||
GLshort *xglBuild2sv ( GLshort v0, GLshort v1 ) ;
|
||||
GLubyte *xglBuild2ubv ( GLubyte v0, GLubyte v1 ) ;
|
||||
GLuint *xglBuild2uiv ( GLuint v0, GLuint v1 ) ;
|
||||
GLushort *xglBuild2usv ( GLushort v0, GLushort v1 ) ;
|
||||
|
||||
GLdouble *xglBuild3dv ( GLdouble v0, GLdouble v1, GLdouble v2 ) ;
|
||||
GLfloat *xglBuild3fv ( GLfloat v0, GLfloat v1, GLfloat v2 ) ;
|
||||
GLbyte *xglBuild3bv ( GLbyte v0, GLbyte v1, GLbyte v2 ) ;
|
||||
GLint *xglBuild3iv ( GLint v0, GLint v1, GLint v2 ) ;
|
||||
GLshort *xglBuild3sv ( GLshort v0, GLshort v1, GLshort v2 ) ;
|
||||
GLubyte *xglBuild3ubv ( GLubyte v0, GLubyte v1, GLubyte v2 ) ;
|
||||
GLuint *xglBuild3uiv ( GLuint v0, GLuint v1, GLuint v2 ) ;
|
||||
GLushort *xglBuild3usv ( GLushort v0, GLushort v1, GLushort v2 ) ;
|
||||
|
||||
GLdouble *xglBuild4dv ( GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) ;
|
||||
GLfloat *xglBuild4fv ( GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) ;
|
||||
GLbyte *xglBuild4bv ( GLbyte v0, GLbyte v1, GLbyte v2, GLbyte v3 ) ;
|
||||
GLint *xglBuild4iv ( GLint v0, GLint v1, GLint v2, GLint v3 ) ;
|
||||
GLshort *xglBuild4sv ( GLshort v0, GLshort v1, GLshort v2, GLshort v3 ) ;
|
||||
GLubyte *xglBuild4ubv ( GLubyte v0, GLubyte v1, GLubyte v2, GLubyte v3 ) ;
|
||||
GLuint *xglBuild4uiv ( GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) ;
|
||||
GLushort *xglBuild4usv ( GLushort v0, GLushort v1, GLushort v2, GLushort v3 ) ;
|
||||
|
||||
GLfloat *xglBuildMatrixf ( GLfloat m0 , GLfloat m1 , GLfloat m2 , GLfloat m3 ,
|
||||
GLfloat m4 , GLfloat m5 , GLfloat m6 , GLfloat m7 ,
|
||||
GLfloat m8 , GLfloat m9 , GLfloat m10, GLfloat m11,
|
||||
GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15 ) ;
|
||||
|
||||
GLdouble *xglBuildMatrixd ( GLdouble m0 , GLdouble m1 , GLdouble m2 , GLdouble m3 ,
|
||||
GLdouble m4 , GLdouble m5 , GLdouble m6 , GLdouble m7 ,
|
||||
GLdouble m8 , GLdouble m9 , GLdouble m10, GLdouble m11,
|
||||
GLdouble m12, GLdouble m13, GLdouble m14, GLdouble m15 ) ;
|
||||
|
||||
/*
|
||||
Conditionally compile all 'xgl' calls into standard 'gl' calls...
|
||||
|
||||
OR
|
||||
|
||||
Declare all possible 'xgl' calls as 'extern'.
|
||||
*/
|
||||
|
||||
#ifndef XGL_TRACE
|
||||
|
||||
#define xglAccum glAccum
|
||||
#define xglAlphaFunc glAlphaFunc
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglArrayElementEXT glArrayElementEXT
|
||||
#endif
|
||||
#define xglBegin glBegin
|
||||
#define xglBitmap glBitmap
|
||||
#ifdef GL_EXT_blend_color
|
||||
#define xglBlendColorEXT glBlendColorEXT
|
||||
#endif
|
||||
#ifdef GL_EXT_blend_minmax
|
||||
#define xglBlendEquationEXT glBlendEquationEXT
|
||||
#endif
|
||||
#define xglBlendFunc glBlendFunc
|
||||
#define xglCallList glCallList
|
||||
#define xglCallLists glCallLists
|
||||
#define xglClear glClear
|
||||
#define xglClearAccum glClearAccum
|
||||
#define xglClearColor glClearColor
|
||||
#define xglClearDepth glClearDepth
|
||||
#define xglClearIndex glClearIndex
|
||||
#define xglClearStencil glClearStencil
|
||||
#define xglClipPlane glClipPlane
|
||||
#define xglColor3b glColor3b
|
||||
#define xglColor3bv glColor3bv
|
||||
#define xglColor3d glColor3d
|
||||
#define xglColor3dv glColor3dv
|
||||
#define xglColor3f glColor3f
|
||||
#define xglColor3fv glColor3fv
|
||||
#define xglColor3i glColor3i
|
||||
#define xglColor3iv glColor3iv
|
||||
#define xglColor3s glColor3s
|
||||
#define xglColor3sv glColor3sv
|
||||
#define xglColor3ub glColor3ub
|
||||
#define xglColor3ubv glColor3ubv
|
||||
#define xglColor3ui glColor3ui
|
||||
#define xglColor3uiv glColor3uiv
|
||||
#define xglColor3us glColor3us
|
||||
#define xglColor3usv glColor3usv
|
||||
#define xglColor4b glColor4b
|
||||
#define xglColor4bv glColor4bv
|
||||
#define xglColor4d glColor4d
|
||||
#define xglColor4dv glColor4dv
|
||||
#define xglColor4f glColor4f
|
||||
#define xglColor4fv glColor4fv
|
||||
#define xglColor4i glColor4i
|
||||
#define xglColor4iv glColor4iv
|
||||
#define xglColor4s glColor4s
|
||||
#define xglColor4sv glColor4sv
|
||||
#define xglColor4ub glColor4ub
|
||||
#define xglColor4ubv glColor4ubv
|
||||
#define xglColor4ui glColor4ui
|
||||
#define xglColor4uiv glColor4uiv
|
||||
#define xglColor4us glColor4us
|
||||
#define xglColor4usv glColor4usv
|
||||
#define xglColorMask glColorMask
|
||||
#define xglColorMaterial glColorMaterial
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglColorPointerEXT glColorPointerEXT
|
||||
#endif
|
||||
#define xglCopyPixels glCopyPixels
|
||||
#define xglCullFace glCullFace
|
||||
#define xglDeleteLists glDeleteLists
|
||||
#define xglDepthFunc glDepthFunc
|
||||
#define xglDepthMask glDepthMask
|
||||
#define xglDepthRange glDepthRange
|
||||
#define xglDisable glDisable
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglDrawArraysEXT glDrawArraysEXT
|
||||
#endif
|
||||
#define xglDrawBuffer glDrawBuffer
|
||||
#define xglDrawPixels glDrawPixels
|
||||
#define xglEdgeFlag glEdgeFlag
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglEdgeFlagPointerEXT glEdgeFlagPointerEXT
|
||||
#endif
|
||||
#define xglEdgeFlagv glEdgeFlagv
|
||||
#define xglEnable glEnable
|
||||
#define xglEnd glEnd
|
||||
#define xglEndList glEndList
|
||||
#define xglEvalCoord1d glEvalCoord1d
|
||||
#define xglEvalCoord1dv glEvalCoord1dv
|
||||
#define xglEvalCoord1f glEvalCoord1f
|
||||
#define xglEvalCoord1fv glEvalCoord1fv
|
||||
#define xglEvalCoord2d glEvalCoord2d
|
||||
#define xglEvalCoord2dv glEvalCoord2dv
|
||||
#define xglEvalCoord2f glEvalCoord2f
|
||||
#define xglEvalCoord2fv glEvalCoord2fv
|
||||
#define xglEvalMesh1 glEvalMesh1
|
||||
#define xglEvalMesh2 glEvalMesh2
|
||||
#define xglEvalPoint1 glEvalPoint1
|
||||
#define xglEvalPoint2 glEvalPoint2
|
||||
#define xglFeedbackBuffer glFeedbackBuffer
|
||||
#define xglFinish glFinish
|
||||
#define xglFlush glFlush
|
||||
#define xglFogf glFogf
|
||||
#define xglFogfv glFogfv
|
||||
#define xglFogi glFogi
|
||||
#define xglFogiv glFogiv
|
||||
#define xglFrontFace glFrontFace
|
||||
#define xglFrustum glFrustum
|
||||
#define xglGenLists glGenLists
|
||||
#define xglGetBooleanv glGetBooleanv
|
||||
#define xglGetClipPlane glGetClipPlane
|
||||
#define xglGetDoublev glGetDoublev
|
||||
#define xglGetError glGetError
|
||||
#define xglGetFloatv glGetFloatv
|
||||
#define xglGetIntegerv glGetIntegerv
|
||||
#define xglGetLightfv glGetLightfv
|
||||
#define xglGetLightiv glGetLightiv
|
||||
#define xglGetMapdv glGetMapdv
|
||||
#define xglGetMapfv glGetMapfv
|
||||
#define xglGetMapiv glGetMapiv
|
||||
#define xglGetMaterialfv glGetMaterialfv
|
||||
#define xglGetMaterialiv glGetMaterialiv
|
||||
#define xglGetPixelMapfv glGetPixelMapfv
|
||||
#define xglGetPixelMapuiv glGetPixelMapuiv
|
||||
#define xglGetPixelMapusv glGetPixelMapusv
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglGetPointervEXT glGetPointervEXT
|
||||
#endif
|
||||
#define xglGetPolygonStipple glGetPolygonStipple
|
||||
#define xglGetString glGetString
|
||||
#define xglGetTexEnvfv glGetTexEnvfv
|
||||
#define xglGetTexEnviv glGetTexEnviv
|
||||
#define xglGetTexGendv glGetTexGendv
|
||||
#define xglGetTexGenfv glGetTexGenfv
|
||||
#define xglGetTexGeniv glGetTexGeniv
|
||||
#define xglGetTexImage glGetTexImage
|
||||
#define xglGetTexLevelParameterfv glGetTexLevelParameterfv
|
||||
#define xglGetTexLevelParameteriv glGetTexLevelParameteriv
|
||||
#define xglGetTexParameterfv glGetTexParameterfv
|
||||
#define xglGetTexParameteriv glGetTexParameteriv
|
||||
#define xglHint glHint
|
||||
#define xglIndexMask glIndexMask
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglIndexPointerEXT glIndexPointerEXT
|
||||
#endif
|
||||
#define xglIndexd glIndexd
|
||||
#define xglIndexdv glIndexdv
|
||||
#define xglIndexf glIndexf
|
||||
#define xglIndexfv glIndexfv
|
||||
#define xglIndexi glIndexi
|
||||
#define xglIndexiv glIndexiv
|
||||
#define xglIndexs glIndexs
|
||||
#define xglIndexsv glIndexsv
|
||||
#define xglInitNames glInitNames
|
||||
#define xglIsEnabled glIsEnabled
|
||||
#define xglIsList glIsList
|
||||
#define xglLightModelf glLightModelf
|
||||
#define xglLightModelfv glLightModelfv
|
||||
#define xglLightModeli glLightModeli
|
||||
#define xglLightModeliv glLightModeliv
|
||||
#define xglLightf glLightf
|
||||
#define xglLightfv glLightfv
|
||||
#define xglLighti glLighti
|
||||
#define xglLightiv glLightiv
|
||||
#define xglLineStipple glLineStipple
|
||||
#define xglLineWidth glLineWidth
|
||||
#define xglListBase glListBase
|
||||
#define xglLoadIdentity glLoadIdentity
|
||||
#define xglLoadMatrixd glLoadMatrixd
|
||||
#define xglLoadMatrixf glLoadMatrixf
|
||||
#define xglLoadName glLoadName
|
||||
#define xglLogicOp glLogicOp
|
||||
#define xglMap1d glMap1d
|
||||
#define xglMap1f glMap1f
|
||||
#define xglMap2d glMap2d
|
||||
#define xglMap2f glMap2f
|
||||
#define xglMapGrid1d glMapGrid1d
|
||||
#define xglMapGrid1f glMapGrid1f
|
||||
#define xglMapGrid2d glMapGrid2d
|
||||
#define xglMapGrid2f glMapGrid2f
|
||||
#define xglMaterialf glMaterialf
|
||||
#define xglMaterialfv glMaterialfv
|
||||
#define xglMateriali glMateriali
|
||||
#define xglMaterialiv glMaterialiv
|
||||
#define xglMatrixMode glMatrixMode
|
||||
#define xglMultMatrixd glMultMatrixd
|
||||
#define xglMultMatrixf glMultMatrixf
|
||||
#define xglNewList glNewList
|
||||
#define xglNormal3b glNormal3b
|
||||
#define xglNormal3bv glNormal3bv
|
||||
#define xglNormal3d glNormal3d
|
||||
#define xglNormal3dv glNormal3dv
|
||||
#define xglNormal3f glNormal3f
|
||||
#ifdef DEBUGGING_NORMALS
|
||||
#define xglNormal3fv(f) {\
|
||||
float ff = (f)[0]*(f)[0]+(f)[1]*(f)[1]+(f)[2]*(f)[2];\
|
||||
if ( ff < 0.9 || ff > 1.1 )\
|
||||
{\
|
||||
fprintf(stderr,"glNormal3fv Overflow: %f, %f, %f -> %f [%s,%s,%s]\n",\
|
||||
(f)[0],(f)[1],(f)[2],ff,str1,str2,str3);\
|
||||
normal_bombed = 1 ;\
|
||||
}\
|
||||
glNormal3fv(f);\
|
||||
}
|
||||
#else
|
||||
#define xglNormal3fv glNormal3fv
|
||||
#endif
|
||||
#define xglNormal3i glNormal3i
|
||||
#define xglNormal3iv glNormal3iv
|
||||
#define xglNormal3s glNormal3s
|
||||
#define xglNormal3sv glNormal3sv
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglNormalPointerEXT glNormalPointerEXT
|
||||
#endif
|
||||
#define xglOrtho glOrtho
|
||||
#define xglPassThrough glPassThrough
|
||||
#define xglPixelMapfv glPixelMapfv
|
||||
#define xglPixelMapuiv glPixelMapuiv
|
||||
#define xglPixelMapusv glPixelMapusv
|
||||
#define xglPixelStoref glPixelStoref
|
||||
#define xglPixelStorei glPixelStorei
|
||||
#define xglPixelTransferf glPixelTransferf
|
||||
#define xglPixelTransferi glPixelTransferi
|
||||
#define xglPixelZoom glPixelZoom
|
||||
#define xglPointSize glPointSize
|
||||
#define xglPolygonMode glPolygonMode
|
||||
#ifdef GL_EXT_polygon_offset
|
||||
#define xglPolygonOffsetEXT glPolygonOffsetEXT
|
||||
#endif
|
||||
#define xglPolygonOffset glPolygonOffset
|
||||
#define xglPolygonStipple glPolygonStipple
|
||||
#define xglPopAttrib glPopAttrib
|
||||
#define xglPopMatrix glPopMatrix
|
||||
#define xglPopName glPopName
|
||||
#define xglPushAttrib glPushAttrib
|
||||
#define xglPushMatrix glPushMatrix
|
||||
#define xglPushName glPushName
|
||||
#define xglRasterPos2d glRasterPos2d
|
||||
#define xglRasterPos2dv glRasterPos2dv
|
||||
#define xglRasterPos2f glRasterPos2f
|
||||
#define xglRasterPos2fv glRasterPos2fv
|
||||
#define xglRasterPos2i glRasterPos2i
|
||||
#define xglRasterPos2iv glRasterPos2iv
|
||||
#define xglRasterPos2s glRasterPos2s
|
||||
#define xglRasterPos2sv glRasterPos2sv
|
||||
#define xglRasterPos3d glRasterPos3d
|
||||
#define xglRasterPos3dv glRasterPos3dv
|
||||
#define xglRasterPos3f glRasterPos3f
|
||||
#define xglRasterPos3fv glRasterPos3fv
|
||||
#define xglRasterPos3i glRasterPos3i
|
||||
#define xglRasterPos3iv glRasterPos3iv
|
||||
#define xglRasterPos3s glRasterPos3s
|
||||
#define xglRasterPos3sv glRasterPos3sv
|
||||
#define xglRasterPos4d glRasterPos4d
|
||||
#define xglRasterPos4dv glRasterPos4dv
|
||||
#define xglRasterPos4f glRasterPos4f
|
||||
#define xglRasterPos4fv glRasterPos4fv
|
||||
#define xglRasterPos4i glRasterPos4i
|
||||
#define xglRasterPos4iv glRasterPos4iv
|
||||
#define xglRasterPos4s glRasterPos4s
|
||||
#define xglRasterPos4sv glRasterPos4sv
|
||||
#define xglReadBuffer glReadBuffer
|
||||
#define xglReadPixels glReadPixels
|
||||
#define xglRectd glRectd
|
||||
#define xglRectdv glRectdv
|
||||
#define xglRectf glRectf
|
||||
#define xglRectfv glRectfv
|
||||
#define xglRecti glRecti
|
||||
#define xglRectiv glRectiv
|
||||
#define xglRects glRects
|
||||
#define xglRectsv glRectsv
|
||||
#define xglRenderMode glRenderMode
|
||||
#define xglRotated glRotated
|
||||
#define xglRotatef glRotatef
|
||||
#define xglScaled glScaled
|
||||
#define xglScalef glScalef
|
||||
#define xglScissor glScissor
|
||||
#define xglSelectBuffer glSelectBuffer
|
||||
#define xglShadeModel glShadeModel
|
||||
#define xglStencilFunc glStencilFunc
|
||||
#define xglStencilMask glStencilMask
|
||||
#define xglStencilOp glStencilOp
|
||||
#define xglTexCoord1d glTexCoord1d
|
||||
#define xglTexCoord1dv glTexCoord1dv
|
||||
#define xglTexCoord1f glTexCoord1f
|
||||
#define xglTexCoord1fv glTexCoord1fv
|
||||
#define xglTexCoord1i glTexCoord1i
|
||||
#define xglTexCoord1iv glTexCoord1iv
|
||||
#define xglTexCoord1s glTexCoord1s
|
||||
#define xglTexCoord1sv glTexCoord1sv
|
||||
#define xglTexCoord2d glTexCoord2d
|
||||
#define xglTexCoord2dv glTexCoord2dv
|
||||
#define xglTexCoord2f glTexCoord2f
|
||||
#define xglTexCoord2fv glTexCoord2fv
|
||||
#define xglTexCoord2i glTexCoord2i
|
||||
#define xglTexCoord2iv glTexCoord2iv
|
||||
#define xglTexCoord2s glTexCoord2s
|
||||
#define xglTexCoord2sv glTexCoord2sv
|
||||
#define xglTexCoord3d glTexCoord3d
|
||||
#define xglTexCoord3dv glTexCoord3dv
|
||||
#define xglTexCoord3f glTexCoord3f
|
||||
#define xglTexCoord3fv glTexCoord3fv
|
||||
#define xglTexCoord3i glTexCoord3i
|
||||
#define xglTexCoord3iv glTexCoord3iv
|
||||
#define xglTexCoord3s glTexCoord3s
|
||||
#define xglTexCoord3sv glTexCoord3sv
|
||||
#define xglTexCoord4d glTexCoord4d
|
||||
#define xglTexCoord4dv glTexCoord4dv
|
||||
#define xglTexCoord4f glTexCoord4f
|
||||
#define xglTexCoord4fv glTexCoord4fv
|
||||
#define xglTexCoord4i glTexCoord4i
|
||||
#define xglTexCoord4iv glTexCoord4iv
|
||||
#define xglTexCoord4s glTexCoord4s
|
||||
#define xglTexCoord4sv glTexCoord4sv
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglTexCoordPointerEXT glTexCoordPointerEXT
|
||||
#endif
|
||||
#define xglTexEnvf glTexEnvf
|
||||
#define xglTexEnvfv glTexEnvfv
|
||||
#define xglTexEnvi glTexEnvi
|
||||
#define xglTexEnviv glTexEnviv
|
||||
#define xglTexGend glTexGend
|
||||
#define xglTexGendv glTexGendv
|
||||
#define xglTexGenf glTexGenf
|
||||
#define xglTexGenfv glTexGenfv
|
||||
#define xglTexGeni glTexGeni
|
||||
#define xglTexGeniv glTexGeniv
|
||||
#define xglTexImage1D glTexImage1D
|
||||
#define xglTexImage2D glTexImage2D
|
||||
#define xglTexParameterf glTexParameterf
|
||||
#define xglTexParameterfv glTexParameterfv
|
||||
#define xglTexParameteri glTexParameteri
|
||||
#define xglTexParameteriv glTexParameteriv
|
||||
#define xglTranslated glTranslated
|
||||
#define xglTranslatef glTranslatef
|
||||
#define xglVertex2d glVertex2d
|
||||
#define xglVertex2dv glVertex2dv
|
||||
#define xglVertex2f glVertex2f
|
||||
#define xglVertex2fv glVertex2fv
|
||||
#define xglVertex2i glVertex2i
|
||||
#define xglVertex2iv glVertex2iv
|
||||
#define xglVertex2s glVertex2s
|
||||
#define xglVertex2sv glVertex2sv
|
||||
#define xglVertex3d glVertex3d
|
||||
#define xglVertex3dv glVertex3dv
|
||||
#define xglVertex3f glVertex3f
|
||||
#define xglVertex3fv glVertex3fv
|
||||
#define xglVertex3i glVertex3i
|
||||
#define xglVertex3iv glVertex3iv
|
||||
#define xglVertex3s glVertex3s
|
||||
#define xglVertex3sv glVertex3sv
|
||||
#define xglVertex4d glVertex4d
|
||||
#define xglVertex4dv glVertex4dv
|
||||
#define xglVertex4f glVertex4f
|
||||
#define xglVertex4fv glVertex4fv
|
||||
#define xglVertex4i glVertex4i
|
||||
#define xglVertex4iv glVertex4iv
|
||||
#define xglVertex4s glVertex4s
|
||||
#define xglVertex4sv glVertex4sv
|
||||
#ifdef GL_EXT_vertex_array
|
||||
#define xglVertexPointerEXT glVertexPointerEXT
|
||||
#endif
|
||||
#define xglViewport glViewport
|
||||
|
||||
#ifdef GL_VERSION_1_1
|
||||
#define xglAreTexturesResident glAreTexturesResident
|
||||
#define xglIsTexture glIsTexture
|
||||
#define xglBindTexture glBindTexture
|
||||
#define xglDeleteTextures glDeleteTextures
|
||||
#define xglGenTextures glGenTextures
|
||||
#define xglPrioritizeTextures glPrioritizeTextures
|
||||
#endif
|
||||
|
||||
#ifdef GL_EXT_texture_object
|
||||
#define xglAreTexturesResidentEXT glAreTexturesResidentEXT
|
||||
#define xglIsTextureEXT glIsTextureEXT
|
||||
#define xglBindTextureEXT glBindTextureEXT
|
||||
#define xglDeleteTexturesEXT glDeleteTexturesEXT
|
||||
#define xglGenTexturesEXT glGenTexturesEXT
|
||||
#define xglPrioritizeTexturesEXT glPrioritizeTexturesEXT
|
||||
#endif
|
||||
|
||||
#define xglutAddMenuEntry glutAddMenuEntry
|
||||
#define xglutAttachMenu glutAttachMenu
|
||||
#define xglutCreateMenu glutCreateMenu
|
||||
#define xglutCreateWindow glutCreateWindow
|
||||
#define xglutDisplayFunc glutDisplayFunc
|
||||
#define xglutIdleFunc glutIdleFunc
|
||||
#define xglutInit glutInit
|
||||
#define xglutInitDisplayMode glutInitDisplayMode
|
||||
#define xglutInitWindowPosition glutInitWindowPosition
|
||||
#define xglutInitWindowSize glutInitWindowSize
|
||||
#define xglutKeyboardFunc glutKeyboardFunc
|
||||
#define xglutMainLoopUpdate glutMainLoopUpdate
|
||||
#define xglutPostRedisplay glutPostRedisplay
|
||||
#define xglutPreMainLoop glutPreMainLoop
|
||||
#define xglutReshapeFunc glutReshapeFunc
|
||||
#define xglutSwapBuffers glutSwapBuffers
|
||||
|
||||
#else
|
||||
|
||||
GLboolean xglIsEnabled ( GLenum cap ) ;
|
||||
GLboolean xglIsList ( GLuint list ) ;
|
||||
GLenum xglGetError () ;
|
||||
GLint xglRenderMode ( GLenum mode ) ;
|
||||
GLuint xglGenLists ( GLsizei range ) ;
|
||||
const GLubyte *xglGetString ( GLenum name ) ;
|
||||
|
||||
void xglAccum ( GLenum op, GLfloat value ) ;
|
||||
void xglAlphaFunc ( GLenum func, GLclampf ref ) ;
|
||||
void xglArrayElementEXT ( GLint i ) ;
|
||||
void xglBegin ( GLenum mode ) ;
|
||||
void xglBitmap ( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte *bitmap ) ;
|
||||
void xglBlendColorEXT ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) ;
|
||||
void xglBlendEquationEXT( GLenum mode ) ;
|
||||
void xglBlendFunc ( GLenum sfactor, GLenum dfactor ) ;
|
||||
void xglCallList ( GLuint list ) ;
|
||||
void xglCallLists ( GLsizei n, GLenum type, GLvoid *lists ) ;
|
||||
void xglClear ( GLbitfield mask ) ;
|
||||
void xglClearAccum ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) ;
|
||||
void xglClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) ;
|
||||
void xglClearDepth ( GLclampd depth ) ;
|
||||
void xglClearIndex ( GLfloat c ) ;
|
||||
void xglClearStencil ( GLint s ) ;
|
||||
void xglClipPlane ( GLenum plane, GLdouble *equation ) ;
|
||||
void xglColor3b ( GLbyte red, GLbyte green, GLbyte blue ) ;
|
||||
void xglColor3bv ( GLbyte *v ) ;
|
||||
void xglColor3d ( GLdouble red, GLdouble green, GLdouble blue ) ;
|
||||
void xglColor3dv ( GLdouble *v ) ;
|
||||
void xglColor3f ( GLfloat red, GLfloat green, GLfloat blue ) ;
|
||||
void xglColor3fv ( GLfloat *v ) ;
|
||||
void xglColor3i ( GLint red, GLint green, GLint blue ) ;
|
||||
void xglColor3iv ( GLint *v ) ;
|
||||
void xglColor3s ( GLshort red, GLshort green, GLshort blue ) ;
|
||||
void xglColor3sv ( GLshort *v ) ;
|
||||
void xglColor3ub ( GLubyte red, GLubyte green, GLubyte blue ) ;
|
||||
void xglColor3ubv ( GLubyte *v ) ;
|
||||
void xglColor3ui ( GLuint red, GLuint green, GLuint blue ) ;
|
||||
void xglColor3uiv ( GLuint *v ) ;
|
||||
void xglColor3us ( GLushort red, GLushort green, GLushort blue ) ;
|
||||
void xglColor3usv ( GLushort *v ) ;
|
||||
void xglColor4b ( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) ;
|
||||
void xglColor4bv ( GLbyte *v ) ;
|
||||
void xglColor4d ( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) ;
|
||||
void xglColor4dv ( GLdouble *v ) ;
|
||||
void xglColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) ;
|
||||
void xglColor4fv ( GLfloat *v ) ;
|
||||
void xglColor4i ( GLint red, GLint green, GLint blue, GLint alpha ) ;
|
||||
void xglColor4iv ( GLint *v ) ;
|
||||
void xglColor4s ( GLshort red, GLshort green, GLshort blue, GLshort alpha ) ;
|
||||
void xglColor4sv ( GLshort *v ) ;
|
||||
void xglColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) ;
|
||||
void xglColor4ubv ( GLubyte *v ) ;
|
||||
void xglColor4ui ( GLuint red, GLuint green, GLuint blue, GLuint alpha ) ;
|
||||
void xglColor4uiv ( GLuint *v ) ;
|
||||
void xglColor4us ( GLushort red, GLushort green, GLushort blue, GLushort alpha ) ;
|
||||
void xglColor4usv ( GLushort *v ) ;
|
||||
void xglColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) ;
|
||||
void xglColorMaterial ( GLenum face, GLenum mode ) ;
|
||||
void xglColorPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
|
||||
void xglCopyPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) ;
|
||||
void xglCullFace ( GLenum mode ) ;
|
||||
void xglDeleteLists ( GLuint list, GLsizei range ) ;
|
||||
void xglDepthFunc ( GLenum func ) ;
|
||||
void xglDepthMask ( GLboolean flag ) ;
|
||||
void xglDepthRange ( GLclampd near_val, GLclampd far_val ) ;
|
||||
void xglDisable ( GLenum cap ) ;
|
||||
void xglDrawArraysEXT ( GLenum mode, GLint first, GLsizei count ) ;
|
||||
void xglDrawBuffer ( GLenum mode ) ;
|
||||
void xglDrawPixels ( GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) ;
|
||||
void xglEdgeFlag ( GLboolean flag ) ;
|
||||
void xglEdgeFlagPointerEXT( GLsizei stride, GLsizei count, GLboolean *ptr ) ;
|
||||
void xglEdgeFlagv ( GLboolean *flag ) ;
|
||||
void xglEnable ( GLenum cap ) ;
|
||||
void xglEnd () ;
|
||||
void xglEndList () ;
|
||||
void xglEvalCoord1d ( GLdouble u ) ;
|
||||
void xglEvalCoord1dv ( GLdouble *u ) ;
|
||||
void xglEvalCoord1f ( GLfloat u ) ;
|
||||
void xglEvalCoord1fv ( GLfloat *u ) ;
|
||||
void xglEvalCoord2d ( GLdouble u, GLdouble v ) ;
|
||||
void xglEvalCoord2dv ( GLdouble *u ) ;
|
||||
void xglEvalCoord2f ( GLfloat u, GLfloat v ) ;
|
||||
void xglEvalCoord2fv ( GLfloat *u ) ;
|
||||
void xglEvalMesh1 ( GLenum mode, GLint i1, GLint i2 ) ;
|
||||
void xglEvalMesh2 ( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) ;
|
||||
void xglEvalPoint1 ( GLint i ) ;
|
||||
void xglEvalPoint2 ( GLint i, GLint j ) ;
|
||||
void xglFeedbackBuffer ( GLsizei size, GLenum type, GLfloat *buffer ) ;
|
||||
void xglFinish () ;
|
||||
void xglFlush () ;
|
||||
void xglFogf ( GLenum pname, GLfloat param ) ;
|
||||
void xglFogfv ( GLenum pname, GLfloat *params ) ;
|
||||
void xglFogi ( GLenum pname, GLint param ) ;
|
||||
void xglFogiv ( GLenum pname, GLint *params ) ;
|
||||
void xglFrontFace ( GLenum mode ) ;
|
||||
void xglFrustum ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) ;
|
||||
void xglGetBooleanv ( GLenum pname, GLboolean *params ) ;
|
||||
void xglGetClipPlane ( GLenum plane, GLdouble *equation ) ;
|
||||
void xglGetDoublev ( GLenum pname, GLdouble *params ) ;
|
||||
void xglGetFloatv ( GLenum pname, GLfloat *params ) ;
|
||||
void xglGetIntegerv ( GLenum pname, GLint *params ) ;
|
||||
void xglGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) ;
|
||||
void xglGetLightiv ( GLenum light, GLenum pname, GLint *params ) ;
|
||||
void xglGetMapdv ( GLenum target, GLenum query, GLdouble *v ) ;
|
||||
void xglGetMapfv ( GLenum target, GLenum query, GLfloat *v ) ;
|
||||
void xglGetMapiv ( GLenum target, GLenum query, GLint *v ) ;
|
||||
void xglGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) ;
|
||||
void xglGetMaterialiv ( GLenum face, GLenum pname, GLint *params ) ;
|
||||
void xglGetPixelMapfv ( GLenum map, GLfloat *values ) ;
|
||||
void xglGetPixelMapuiv ( GLenum map, GLuint *values ) ;
|
||||
void xglGetPixelMapusv ( GLenum map, GLushort *values ) ;
|
||||
void xglGetPointervEXT ( GLenum pname, void **params ) ;
|
||||
void xglGetPolygonStipple( GLubyte *mask ) ;
|
||||
void xglGetTexEnvfv ( GLenum target, GLenum pname, GLfloat *params ) ;
|
||||
void xglGetTexEnviv ( GLenum target, GLenum pname, GLint *params ) ;
|
||||
void xglGetTexGendv ( GLenum coord, GLenum pname, GLdouble *params ) ;
|
||||
void xglGetTexGenfv ( GLenum coord, GLenum pname, GLfloat *params ) ;
|
||||
void xglGetTexGeniv ( GLenum coord, GLenum pname, GLint *params ) ;
|
||||
void xglGetTexImage ( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ) ;
|
||||
void xglGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) ;
|
||||
void xglGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) ;
|
||||
void xglGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params) ;
|
||||
void xglGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) ;
|
||||
void xglHint ( GLenum target, GLenum mode ) ;
|
||||
void xglIndexMask ( GLuint mask ) ;
|
||||
void xglIndexPointerEXT ( GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
|
||||
void xglIndexd ( GLdouble c ) ;
|
||||
void xglIndexdv ( GLdouble *c ) ;
|
||||
void xglIndexf ( GLfloat c ) ;
|
||||
void xglIndexfv ( GLfloat *c ) ;
|
||||
void xglIndexi ( GLint c ) ;
|
||||
void xglIndexiv ( GLint *c ) ;
|
||||
void xglIndexs ( GLshort c ) ;
|
||||
void xglIndexsv ( GLshort *c ) ;
|
||||
void xglInitNames () ;
|
||||
void xglLightModelf ( GLenum pname, GLfloat param ) ;
|
||||
void xglLightModelfv ( GLenum pname, GLfloat *params ) ;
|
||||
void xglLightModeli ( GLenum pname, GLint param ) ;
|
||||
void xglLightModeliv ( GLenum pname, GLint *params ) ;
|
||||
void xglLightf ( GLenum light, GLenum pname, GLfloat param ) ;
|
||||
void xglLightfv ( GLenum light, GLenum pname, GLfloat *params ) ;
|
||||
void xglLighti ( GLenum light, GLenum pname, GLint param ) ;
|
||||
void xglLightiv ( GLenum light, GLenum pname, GLint *params ) ;
|
||||
void xglLineStipple ( GLint factor, GLushort pattern ) ;
|
||||
void xglLineWidth ( GLfloat width ) ;
|
||||
void xglListBase ( GLuint base ) ;
|
||||
void xglLoadIdentity () ;
|
||||
void xglLoadMatrixd ( GLdouble *m ) ;
|
||||
void xglLoadMatrixf ( GLfloat *m ) ;
|
||||
void xglLoadName ( GLuint name ) ;
|
||||
void xglLogicOp ( GLenum opcode ) ;
|
||||
void xglMap1d ( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble *points ) ;
|
||||
void xglMap1f ( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat *points ) ;
|
||||
void xglMap2d ( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble *points ) ;
|
||||
void xglMap2f ( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat *points ) ;
|
||||
void xglMapGrid1d ( GLint un, GLdouble u1, GLdouble u2 ) ;
|
||||
void xglMapGrid1f ( GLint un, GLfloat u1, GLfloat u2 ) ;
|
||||
void xglMapGrid2d ( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) ;
|
||||
void xglMapGrid2f ( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) ;
|
||||
void xglMaterialf ( GLenum face, GLenum pname, GLfloat param ) ;
|
||||
void xglMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) ;
|
||||
void xglMateriali ( GLenum face, GLenum pname, GLint param ) ;
|
||||
void xglMaterialiv ( GLenum face, GLenum pname, GLint *params ) ;
|
||||
void xglMatrixMode ( GLenum mode ) ;
|
||||
void xglMultMatrixd ( GLdouble *m ) ;
|
||||
void xglMultMatrixf ( GLfloat *m ) ;
|
||||
void xglNewList ( GLuint list, GLenum mode ) ;
|
||||
void xglNormal3b ( GLbyte nx, GLbyte ny, GLbyte nz ) ;
|
||||
void xglNormal3bv ( GLbyte *v ) ;
|
||||
void xglNormal3d ( GLdouble nx, GLdouble ny, GLdouble nz ) ;
|
||||
void xglNormal3dv ( GLdouble *v ) ;
|
||||
void xglNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) ;
|
||||
void xglNormal3fv ( GLfloat *v ) ;
|
||||
void xglNormal3i ( GLint nx, GLint ny, GLint nz ) ;
|
||||
void xglNormal3iv ( GLint *v ) ;
|
||||
void xglNormal3s ( GLshort nx, GLshort ny, GLshort nz ) ;
|
||||
void xglNormal3sv ( GLshort *v ) ;
|
||||
void xglNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
|
||||
void xglOrtho ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) ;
|
||||
void xglPassThrough ( GLfloat token ) ;
|
||||
void xglPixelMapfv ( GLenum map, GLint mapsize, GLfloat *values ) ;
|
||||
void xglPixelMapuiv ( GLenum map, GLint mapsize, GLuint *values ) ;
|
||||
void xglPixelMapusv ( GLenum map, GLint mapsize, GLushort *values ) ;
|
||||
void xglPixelStoref ( GLenum pname, GLfloat param ) ;
|
||||
void xglPixelStorei ( GLenum pname, GLint param ) ;
|
||||
void xglPixelTransferf ( GLenum pname, GLfloat param ) ;
|
||||
void xglPixelTransferi ( GLenum pname, GLint param ) ;
|
||||
void xglPixelZoom ( GLfloat xfactor, GLfloat yfactor ) ;
|
||||
void xglPointSize ( GLfloat size ) ;
|
||||
void xglPolygonMode ( GLenum face, GLenum mode ) ;
|
||||
void xglPolygonOffsetEXT( GLfloat factor, GLfloat bias ) ;
|
||||
void xglPolygonOffset ( GLfloat factor, GLfloat bias ) ;
|
||||
void xglPolygonStipple ( GLubyte *mask ) ;
|
||||
void xglPopAttrib () ;
|
||||
void xglPopMatrix () ;
|
||||
void xglPopName () ;
|
||||
void xglPushAttrib ( GLbitfield mask ) ;
|
||||
void xglPushMatrix () ;
|
||||
void xglPushName ( GLuint name ) ;
|
||||
void xglRasterPos2d ( GLdouble x, GLdouble y ) ;
|
||||
void xglRasterPos2dv ( GLdouble *v ) ;
|
||||
void xglRasterPos2f ( GLfloat x, GLfloat y ) ;
|
||||
void xglRasterPos2fv ( GLfloat *v ) ;
|
||||
void xglRasterPos2i ( GLint x, GLint y ) ;
|
||||
void xglRasterPos2iv ( GLint *v ) ;
|
||||
void xglRasterPos2s ( GLshort x, GLshort y ) ;
|
||||
void xglRasterPos2sv ( GLshort *v ) ;
|
||||
void xglRasterPos3d ( GLdouble x, GLdouble y, GLdouble z ) ;
|
||||
void xglRasterPos3dv ( GLdouble *v ) ;
|
||||
void xglRasterPos3f ( GLfloat x, GLfloat y, GLfloat z ) ;
|
||||
void xglRasterPos3fv ( GLfloat *v ) ;
|
||||
void xglRasterPos3i ( GLint x, GLint y, GLint z ) ;
|
||||
void xglRasterPos3iv ( GLint *v ) ;
|
||||
void xglRasterPos3s ( GLshort x, GLshort y, GLshort z ) ;
|
||||
void xglRasterPos3sv ( GLshort *v ) ;
|
||||
void xglRasterPos4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) ;
|
||||
void xglRasterPos4dv ( GLdouble *v ) ;
|
||||
void xglRasterPos4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ;
|
||||
void xglRasterPos4fv ( GLfloat *v ) ;
|
||||
void xglRasterPos4i ( GLint x, GLint y, GLint z, GLint w ) ;
|
||||
void xglRasterPos4iv ( GLint *v ) ;
|
||||
void xglRasterPos4s ( GLshort x, GLshort y, GLshort z, GLshort w ) ;
|
||||
void xglRasterPos4sv ( GLshort *v ) ;
|
||||
void xglReadBuffer ( GLenum mode ) ;
|
||||
void xglReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) ;
|
||||
void xglRectd ( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) ;
|
||||
void xglRectdv ( GLdouble *v1, GLdouble *v2 ) ;
|
||||
void xglRectf ( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) ;
|
||||
void xglRectfv ( GLfloat *v1, GLfloat *v2 ) ;
|
||||
void xglRecti ( GLint x1, GLint y1, GLint x2, GLint y2 ) ;
|
||||
void xglRectiv ( GLint *v1, GLint *v2 ) ;
|
||||
void xglRects ( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) ;
|
||||
void xglRectsv ( GLshort *v1, GLshort *v2 ) ;
|
||||
void xglRotated ( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) ;
|
||||
void xglRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) ;
|
||||
void xglScaled ( GLdouble x, GLdouble y, GLdouble z ) ;
|
||||
void xglScalef ( GLfloat x, GLfloat y, GLfloat z ) ;
|
||||
void xglScissor ( GLint x, GLint y, GLsizei width, GLsizei height) ;
|
||||
void xglSelectBuffer ( GLsizei size, GLuint *buffer ) ;
|
||||
void xglShadeModel ( GLenum mode ) ;
|
||||
void xglStencilFunc ( GLenum func, GLint ref, GLuint mask ) ;
|
||||
void xglStencilMask ( GLuint mask ) ;
|
||||
void xglStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) ;
|
||||
void xglTexCoord1d ( GLdouble s ) ;
|
||||
void xglTexCoord1dv ( GLdouble *v ) ;
|
||||
void xglTexCoord1f ( GLfloat s ) ;
|
||||
void xglTexCoord1fv ( GLfloat *v ) ;
|
||||
void xglTexCoord1i ( GLint s ) ;
|
||||
void xglTexCoord1iv ( GLint *v ) ;
|
||||
void xglTexCoord1s ( GLshort s ) ;
|
||||
void xglTexCoord1sv ( GLshort *v ) ;
|
||||
void xglTexCoord2d ( GLdouble s, GLdouble t ) ;
|
||||
void xglTexCoord2dv ( GLdouble *v ) ;
|
||||
void xglTexCoord2f ( GLfloat s, GLfloat t ) ;
|
||||
void xglTexCoord2fv ( GLfloat *v ) ;
|
||||
void xglTexCoord2i ( GLint s, GLint t ) ;
|
||||
void xglTexCoord2iv ( GLint *v ) ;
|
||||
void xglTexCoord2s ( GLshort s, GLshort t ) ;
|
||||
void xglTexCoord2sv ( GLshort *v ) ;
|
||||
void xglTexCoord3d ( GLdouble s, GLdouble t, GLdouble r ) ;
|
||||
void xglTexCoord3dv ( GLdouble *v ) ;
|
||||
void xglTexCoord3f ( GLfloat s, GLfloat t, GLfloat r ) ;
|
||||
void xglTexCoord3fv ( GLfloat *v ) ;
|
||||
void xglTexCoord3i ( GLint s, GLint t, GLint r ) ;
|
||||
void xglTexCoord3iv ( GLint *v ) ;
|
||||
void xglTexCoord3s ( GLshort s, GLshort t, GLshort r ) ;
|
||||
void xglTexCoord3sv ( GLshort *v ) ;
|
||||
void xglTexCoord4d ( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) ;
|
||||
void xglTexCoord4dv ( GLdouble *v ) ;
|
||||
void xglTexCoord4f ( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) ;
|
||||
void xglTexCoord4fv ( GLfloat *v ) ;
|
||||
void xglTexCoord4i ( GLint s, GLint t, GLint r, GLint q ) ;
|
||||
void xglTexCoord4iv ( GLint *v ) ;
|
||||
void xglTexCoord4s ( GLshort s, GLshort t, GLshort r, GLshort q ) ;
|
||||
void xglTexCoord4sv ( GLshort *v ) ;
|
||||
void xglTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
|
||||
void xglTexEnvf ( GLenum target, GLenum pname, GLfloat param ) ;
|
||||
void xglTexEnvfv ( GLenum target, GLenum pname, GLfloat *params ) ;
|
||||
void xglTexEnvi ( GLenum target, GLenum pname, GLint param ) ;
|
||||
void xglTexEnviv ( GLenum target, GLenum pname, GLint *params ) ;
|
||||
void xglTexGend ( GLenum coord, GLenum pname, GLdouble param ) ;
|
||||
void xglTexGendv ( GLenum coord, GLenum pname, GLdouble *params ) ;
|
||||
void xglTexGenf ( GLenum coord, GLenum pname, GLfloat param ) ;
|
||||
void xglTexGenfv ( GLenum coord, GLenum pname, GLfloat *params ) ;
|
||||
void xglTexGeni ( GLenum coord, GLenum pname, GLint param ) ;
|
||||
void xglTexGeniv ( GLenum coord, GLenum pname, GLint *params ) ;
|
||||
void xglTexImage1D ( GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid *pixels ) ;
|
||||
void xglTexImage2D ( GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels ) ;
|
||||
void xglTexParameterf ( GLenum target, GLenum pname, GLfloat param ) ;
|
||||
void xglTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) ;
|
||||
void xglTexParameteri ( GLenum target, GLenum pname, GLint param ) ;
|
||||
void xglTexParameteriv ( GLenum target, GLenum pname, GLint *params ) ;
|
||||
void xglTranslated ( GLdouble x, GLdouble y, GLdouble z ) ;
|
||||
void xglTranslatef ( GLfloat x, GLfloat y, GLfloat z ) ;
|
||||
void xglVertex2d ( GLdouble x, GLdouble y ) ;
|
||||
void xglVertex2dv ( GLdouble *v ) ;
|
||||
void xglVertex2f ( GLfloat x, GLfloat y ) ;
|
||||
void xglVertex2fv ( GLfloat *v ) ;
|
||||
void xglVertex2i ( GLint x, GLint y ) ;
|
||||
void xglVertex2iv ( GLint *v ) ;
|
||||
void xglVertex2s ( GLshort x, GLshort y ) ;
|
||||
void xglVertex2sv ( GLshort *v ) ;
|
||||
void xglVertex3d ( GLdouble x, GLdouble y, GLdouble z ) ;
|
||||
void xglVertex3dv ( GLdouble *v ) ;
|
||||
void xglVertex3f ( GLfloat x, GLfloat y, GLfloat z ) ;
|
||||
void xglVertex3fv ( GLfloat *v ) ;
|
||||
void xglVertex3i ( GLint x, GLint y, GLint z ) ;
|
||||
void xglVertex3iv ( GLint *v ) ;
|
||||
void xglVertex3s ( GLshort x, GLshort y, GLshort z ) ;
|
||||
void xglVertex3sv ( GLshort *v ) ;
|
||||
void xglVertex4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) ;
|
||||
void xglVertex4dv ( GLdouble *v ) ;
|
||||
void xglVertex4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ;
|
||||
void xglVertex4fv ( GLfloat *v ) ;
|
||||
void xglVertex4i ( GLint x, GLint y, GLint z, GLint w ) ;
|
||||
void xglVertex4iv ( GLint *v ) ;
|
||||
void xglVertex4s ( GLshort x, GLshort y, GLshort z, GLshort w ) ;
|
||||
void xglVertex4sv ( GLshort *v ) ;
|
||||
void xglVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
|
||||
void xglViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) ;
|
||||
|
||||
void xglutAddMenuEntry ( char *label, int value ) ;
|
||||
void xglutAttachMenu ( int button ) ;
|
||||
int xglutCreateMenu ( void (*)(int) ) ;
|
||||
int xglutCreateWindow ( char *title ) ;
|
||||
void xglutDisplayFunc ( void (*)(void) ) ;
|
||||
void xglutIdleFunc ( void (*)(void) ) ;
|
||||
void xglutInit ( int *argcp, char **argv ) ;
|
||||
void xglutInitDisplayMode ( unsigned int mode ) ;
|
||||
void xglutInitWindowPosition ( int x, int y ) ;
|
||||
void xglutInitWindowSize ( int width, int height ) ;
|
||||
void xglutKeyboardFunc ( void (*)(unsigned char key, int x, int y) ) ;
|
||||
void xglutMainLoopUpdate () ;
|
||||
void xglutPostRedisplay () ;
|
||||
void xglutPreMainLoop () ;
|
||||
void xglutReshapeFunc ( void (*)(int width, int height) ) ;
|
||||
void xglutSwapBuffers () ;
|
||||
|
||||
GLboolean xglAreTexturesResident( GLsizei n, GLuint *textures, GLboolean *residences ) ;
|
||||
GLboolean xglIsTexture ( GLuint texture ) ;
|
||||
void xglBindTexture ( GLenum target, GLuint texture ) ;
|
||||
void xglDeleteTextures ( GLsizei n, GLuint *textures ) ;
|
||||
void xglGenTextures ( GLsizei n, GLuint *textures ) ;
|
||||
void xglPrioritizeTextures ( GLsizei n, GLuint *textures, GLclampf *priorities ) ;
|
||||
|
||||
GLboolean xglAreTexturesResidentEXT ( GLsizei n, GLuint *textures, GLboolean *residences ) ;
|
||||
GLboolean xglIsTextureEXT ( GLuint texture ) ;
|
||||
void xglBindTextureEXT ( GLenum target, GLuint texture ) ;
|
||||
void xglDeleteTexturesEXT ( GLsizei n, GLuint *textures ) ;
|
||||
void xglGenTexturesEXT ( GLsizei n, GLuint *textures ) ;
|
||||
void xglPrioritizeTexturesEXT ( GLsizei n, GLuint *textures, GLclampf *priorities ) ;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* _XGL_H */
|
||||
@@ -0,0 +1,687 @@
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#if !defined( __CYGWIN__ ) && !defined( __CYGWIN32__ )
|
||||
# if !defined( HAVE_STL_SGI_PORT ) && !defined( __MWERKS__ )
|
||||
// Avoid malloc with STLport and MSL
|
||||
# include <malloc.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_UNISTD_H
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
|
||||
|
||||
#include "xgl.h"
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
int xglTraceOn = TRUE ;
|
||||
|
||||
#ifndef WIN32
|
||||
FILE *xglTraceFd = stdout ;
|
||||
#else /* WIN32 */
|
||||
/* Bail for now, we just want it to compile I guess */
|
||||
FILE *xglTraceFd = NULL;
|
||||
#endif /* WIN32 */
|
||||
|
||||
struct GLenumLookup
|
||||
{
|
||||
GLenum val ;
|
||||
char *name ;
|
||||
} ;
|
||||
|
||||
static struct GLenumLookup glenum_string [] =
|
||||
{
|
||||
/*
|
||||
Due to ambiguity - these are not in the table...
|
||||
|
||||
GL_NONE = , GL_ZERO = GL_FALSE = GL_POINTS = 0
|
||||
GL_ONE = , GL_TRUE = GL_LINES = 1
|
||||
*/
|
||||
{ GL_2D ,"GL_2D" },
|
||||
{ GL_2_BYTES ,"GL_2_BYTES" },
|
||||
{ GL_3D ,"GL_3D" },
|
||||
{ GL_3D_COLOR ,"GL_3D_COLOR" },
|
||||
{ GL_3D_COLOR_TEXTURE ,"GL_3D_COLOR_TEXTURE" },
|
||||
{ GL_3_BYTES ,"GL_3_BYTES" },
|
||||
{ GL_4D_COLOR_TEXTURE ,"GL_4D_COLOR_TEXTURE" },
|
||||
{ GL_4_BYTES ,"GL_4_BYTES" },
|
||||
{ GL_ACCUM ,"GL_ACCUM" },
|
||||
{ GL_ACCUM_ALPHA_BITS ,"GL_ACCUM_ALPHA_BITS" },
|
||||
{ GL_ACCUM_BLUE_BITS ,"GL_ACCUM_BLUE_BITS" },
|
||||
{ GL_ACCUM_CLEAR_VALUE ,"GL_ACCUM_CLEAR_VALUE" },
|
||||
{ GL_ACCUM_GREEN_BITS ,"GL_ACCUM_GREEN_BITS" },
|
||||
{ GL_ACCUM_RED_BITS ,"GL_ACCUM_RED_BITS" },
|
||||
{ GL_ADD ,"GL_ADD" },
|
||||
{ GL_ALPHA ,"GL_ALPHA" },
|
||||
{ GL_ALPHA_BIAS ,"GL_ALPHA_BIAS" },
|
||||
{ GL_ALPHA_BITS ,"GL_ALPHA_BITS" },
|
||||
{ GL_ALPHA_SCALE ,"GL_ALPHA_SCALE" },
|
||||
{ GL_ALPHA_TEST ,"GL_ALPHA_TEST" },
|
||||
{ GL_ALPHA_TEST_FUNC ,"GL_ALPHA_TEST_FUNC" },
|
||||
{ GL_ALPHA_TEST_REF ,"GL_ALPHA_TEST_REF" },
|
||||
{ GL_ALWAYS ,"GL_ALWAYS" },
|
||||
{ GL_AMBIENT ,"GL_AMBIENT" },
|
||||
{ GL_AMBIENT_AND_DIFFUSE ,"GL_AMBIENT_AND_DIFFUSE" },
|
||||
{ GL_AND ,"GL_AND" },
|
||||
{ GL_AND_INVERTED ,"GL_AND_INVERTED" },
|
||||
{ GL_AND_REVERSE ,"GL_AND_REVERSE" },
|
||||
{ GL_ATTRIB_STACK_DEPTH ,"GL_ATTRIB_STACK_DEPTH" },
|
||||
{ GL_AUTO_NORMAL ,"GL_AUTO_NORMAL" },
|
||||
{ GL_AUX0 ,"GL_AUX0" },
|
||||
{ GL_AUX1 ,"GL_AUX1" },
|
||||
{ GL_AUX2 ,"GL_AUX2" },
|
||||
{ GL_AUX3 ,"GL_AUX3" },
|
||||
{ GL_AUX_BUFFERS ,"GL_AUX_BUFFERS" },
|
||||
{ GL_BACK ,"GL_BACK" },
|
||||
{ GL_BACK_LEFT ,"GL_BACK_LEFT" },
|
||||
{ GL_BACK_RIGHT ,"GL_BACK_RIGHT" },
|
||||
{ GL_BITMAP ,"GL_BITMAP" },
|
||||
{ GL_BITMAP_TOKEN ,"GL_BITMAP_TOKEN" },
|
||||
{ GL_BLEND ,"GL_BLEND" },
|
||||
{ GL_BLEND_DST ,"GL_BLEND_DST" },
|
||||
#ifdef GL_BLEND_COLOR_EXT
|
||||
{ GL_BLEND_COLOR_EXT ,"GL_BLEND_COLOR_EXT" },
|
||||
#endif
|
||||
#ifdef GL_BLEND_EQUATION_EXT
|
||||
{ GL_BLEND_EQUATION_EXT ,"GL_BLEND_EQUATION_EXT" },
|
||||
#endif
|
||||
{ GL_BLEND_SRC ,"GL_BLEND_SRC" },
|
||||
{ GL_BLUE ,"GL_BLUE" },
|
||||
{ GL_BLUE_BIAS ,"GL_BLUE_BIAS" },
|
||||
{ GL_BLUE_BITS ,"GL_BLUE_BITS" },
|
||||
{ GL_BLUE_SCALE ,"GL_BLUE_SCALE" },
|
||||
{ GL_BYTE ,"GL_BYTE" },
|
||||
{ GL_CCW ,"GL_CCW" },
|
||||
{ GL_CLAMP ,"GL_CLAMP" },
|
||||
{ GL_CLEAR ,"GL_CLEAR" },
|
||||
{ GL_CLIP_PLANE0 ,"GL_CLIP_PLANE0" },
|
||||
{ GL_CLIP_PLANE1 ,"GL_CLIP_PLANE1" },
|
||||
{ GL_CLIP_PLANE2 ,"GL_CLIP_PLANE2" },
|
||||
{ GL_CLIP_PLANE3 ,"GL_CLIP_PLANE3" },
|
||||
{ GL_CLIP_PLANE4 ,"GL_CLIP_PLANE4" },
|
||||
{ GL_CLIP_PLANE5 ,"GL_CLIP_PLANE5" },
|
||||
{ GL_COEFF ,"GL_COEFF" },
|
||||
{ GL_COLOR ,"GL_COLOR" },
|
||||
#ifdef GL_COLOR_ARRAY_EXT
|
||||
{ GL_COLOR_ARRAY_COUNT_EXT ,"GL_COLOR_ARRAY_COUNT_EXT" },
|
||||
{ GL_COLOR_ARRAY_EXT ,"GL_COLOR_ARRAY_EXT" },
|
||||
{ GL_COLOR_ARRAY_POINTER_EXT ,"GL_COLOR_ARRAY_POINTER_EXT" },
|
||||
{ GL_COLOR_ARRAY_SIZE_EXT ,"GL_COLOR_ARRAY_SIZE_EXT" },
|
||||
{ GL_COLOR_ARRAY_STRIDE_EXT ,"GL_COLOR_ARRAY_STRIDE_EXT" },
|
||||
{ GL_COLOR_ARRAY_TYPE_EXT ,"GL_COLOR_ARRAY_TYPE_EXT" },
|
||||
#endif
|
||||
{ GL_COLOR_CLEAR_VALUE ,"GL_COLOR_CLEAR_VALUE" },
|
||||
{ GL_COLOR_INDEX ,"GL_COLOR_INDEX" },
|
||||
{ GL_COLOR_INDEXES ,"GL_COLOR_INDEXES" },
|
||||
{ GL_COLOR_MATERIAL ,"GL_COLOR_MATERIAL" },
|
||||
{ GL_COLOR_MATERIAL_FACE ,"GL_COLOR_MATERIAL_FACE" },
|
||||
{ GL_COLOR_MATERIAL_PARAMETER ,"GL_COLOR_MATERIAL_PARAMETER" },
|
||||
{ GL_COLOR_WRITEMASK ,"GL_COLOR_WRITEMASK" },
|
||||
{ GL_COMPILE ,"GL_COMPILE" },
|
||||
{ GL_COMPILE_AND_EXECUTE ,"GL_COMPILE_AND_EXECUTE" },
|
||||
#ifdef GL_CONSTANT_ALPHA_EXT
|
||||
{ GL_CONSTANT_ALPHA_EXT ,"GL_CONSTANT_ALPHA_EXT" },
|
||||
#endif
|
||||
{ GL_CONSTANT_ATTENUATION ,"GL_CONSTANT_ATTENUATION" },
|
||||
#ifdef GL_CONSTANT_COLOR_EXT
|
||||
{ GL_CONSTANT_COLOR_EXT ,"GL_CONSTANT_COLOR_EXT" },
|
||||
#endif
|
||||
{ GL_COPY ,"GL_COPY" },
|
||||
{ GL_COPY_INVERTED ,"GL_COPY_INVERTED" },
|
||||
{ GL_COPY_PIXEL_TOKEN ,"GL_COPY_PIXEL_TOKEN" },
|
||||
{ GL_CULL_FACE ,"GL_CULL_FACE" },
|
||||
{ GL_CULL_FACE_MODE ,"GL_CULL_FACE_MODE" },
|
||||
{ GL_CURRENT_COLOR ,"GL_CURRENT_COLOR" },
|
||||
{ GL_CURRENT_INDEX ,"GL_CURRENT_INDEX" },
|
||||
{ GL_CURRENT_NORMAL ,"GL_CURRENT_NORMAL" },
|
||||
{ GL_CURRENT_RASTER_COLOR ,"GL_CURRENT_RASTER_COLOR" },
|
||||
{ GL_CURRENT_RASTER_DISTANCE ,"GL_CURRENT_RASTER_DISTANCE" },
|
||||
{ GL_CURRENT_RASTER_INDEX ,"GL_CURRENT_RASTER_INDEX" },
|
||||
{ GL_CURRENT_RASTER_POSITION ,"GL_CURRENT_RASTER_POSITION" },
|
||||
{ GL_CURRENT_RASTER_POSITION_VALID,"GL_CURRENT_RASTER_POSITION_VALID" },
|
||||
{ GL_CURRENT_RASTER_TEXTURE_COORDS,"GL_CURRENT_RASTER_TEXTURE_COORDS" },
|
||||
{ GL_CURRENT_TEXTURE_COORDS ,"GL_CURRENT_TEXTURE_COORDS" },
|
||||
{ GL_CW ,"GL_CW" },
|
||||
{ GL_DECAL ,"GL_DECAL" },
|
||||
{ GL_DECR ,"GL_DECR" },
|
||||
{ GL_DEPTH ,"GL_DEPTH" },
|
||||
{ GL_DEPTH_BIAS ,"GL_DEPTH_BIAS" },
|
||||
{ GL_DEPTH_BITS ,"GL_DEPTH_BITS" },
|
||||
{ GL_DEPTH_CLEAR_VALUE ,"GL_DEPTH_CLEAR_VALUE" },
|
||||
{ GL_DEPTH_COMPONENT ,"GL_DEPTH_COMPONENT" },
|
||||
{ GL_DEPTH_FUNC ,"GL_DEPTH_FUNC" },
|
||||
{ GL_DEPTH_RANGE ,"GL_DEPTH_RANGE" },
|
||||
{ GL_DEPTH_SCALE ,"GL_DEPTH_SCALE" },
|
||||
{ GL_DEPTH_TEST ,"GL_DEPTH_TEST" },
|
||||
{ GL_DEPTH_WRITEMASK ,"GL_DEPTH_WRITEMASK" },
|
||||
{ GL_DIFFUSE ,"GL_DIFFUSE" },
|
||||
{ GL_DITHER ,"GL_DITHER" },
|
||||
{ GL_DOMAIN ,"GL_DOMAIN" },
|
||||
{ GL_DONT_CARE ,"GL_DONT_CARE" },
|
||||
{ GL_DOUBLEBUFFER ,"GL_DOUBLEBUFFER" },
|
||||
#ifdef GL_DOUBLE_EXT
|
||||
{ GL_DOUBLE_EXT ,"GL_DOUBLE_EXT" },
|
||||
#endif
|
||||
{ GL_DRAW_BUFFER ,"GL_DRAW_BUFFER" },
|
||||
{ GL_DRAW_PIXEL_TOKEN ,"GL_DRAW_PIXEL_TOKEN" },
|
||||
{ GL_DST_ALPHA ,"GL_DST_ALPHA" },
|
||||
{ GL_DST_COLOR ,"GL_DST_COLOR" },
|
||||
{ GL_EDGE_FLAG ,"GL_EDGE_FLAG" },
|
||||
#ifdef GL_EDGE_FLAG_ARRAY_EXT
|
||||
{ GL_EDGE_FLAG_ARRAY_COUNT_EXT,"GL_EDGE_FLAG_ARRAY_COUNT_EXT" },
|
||||
{ GL_EDGE_FLAG_ARRAY_EXT ,"GL_EDGE_FLAG_ARRAY_EXT" },
|
||||
{ GL_EDGE_FLAG_ARRAY_POINTER_EXT,"GL_EDGE_FLAG_ARRAY_POINTER_EXT" },
|
||||
{ GL_EDGE_FLAG_ARRAY_STRIDE_EXT,"GL_EDGE_FLAG_ARRAY_STRIDE_EXT" },
|
||||
#endif
|
||||
{ GL_EMISSION ,"GL_EMISSION" },
|
||||
{ GL_EQUAL ,"GL_EQUAL" },
|
||||
{ GL_EQUIV ,"GL_EQUIV" },
|
||||
{ GL_EXP ,"GL_EXP" },
|
||||
{ GL_EXP2 ,"GL_EXP2" },
|
||||
{ GL_EXTENSIONS ,"GL_EXTENSIONS" },
|
||||
{ GL_EYE_LINEAR ,"GL_EYE_LINEAR" },
|
||||
{ GL_EYE_PLANE ,"GL_EYE_PLANE" },
|
||||
{ GL_FASTEST ,"GL_FASTEST" },
|
||||
{ GL_FEEDBACK ,"GL_FEEDBACK" },
|
||||
{ GL_FILL ,"GL_FILL" },
|
||||
{ GL_FLAT ,"GL_FLAT" },
|
||||
{ GL_FLOAT ,"GL_FLOAT" },
|
||||
{ GL_FOG ,"GL_FOG" },
|
||||
{ GL_FOG_COLOR ,"GL_FOG_COLOR" },
|
||||
{ GL_FOG_DENSITY ,"GL_FOG_DENSITY" },
|
||||
{ GL_FOG_END ,"GL_FOG_END" },
|
||||
{ GL_FOG_HINT ,"GL_FOG_HINT" },
|
||||
{ GL_FOG_INDEX ,"GL_FOG_INDEX" },
|
||||
{ GL_FOG_MODE ,"GL_FOG_MODE" },
|
||||
{ GL_FOG_START ,"GL_FOG_START" },
|
||||
{ GL_FRONT ,"GL_FRONT" },
|
||||
{ GL_FRONT_AND_BACK ,"GL_FRONT_AND_BACK" },
|
||||
{ GL_FRONT_FACE ,"GL_FRONT_FACE" },
|
||||
{ GL_FRONT_LEFT ,"GL_FRONT_LEFT" },
|
||||
{ GL_FRONT_RIGHT ,"GL_FRONT_RIGHT" },
|
||||
#ifdef GL_FUNC_ADD_EXT
|
||||
{ GL_FUNC_ADD_EXT ,"GL_FUNC_ADD_EXT" },
|
||||
{ GL_FUNC_REVERSE_SUBTRACT_EXT,"GL_FUNC_REVERSE_SUBTRACT_EXT" },
|
||||
{ GL_FUNC_SUBTRACT_EXT ,"GL_FUNC_SUBTRACT_EXT" },
|
||||
#endif
|
||||
{ GL_GEQUAL ,"GL_GEQUAL" },
|
||||
{ GL_GREATER ,"GL_GREATER" },
|
||||
{ GL_GREEN ,"GL_GREEN" },
|
||||
{ GL_GREEN_BIAS ,"GL_GREEN_BIAS" },
|
||||
{ GL_GREEN_BITS ,"GL_GREEN_BITS" },
|
||||
{ GL_GREEN_SCALE ,"GL_GREEN_SCALE" },
|
||||
{ GL_INCR ,"GL_INCR" },
|
||||
#ifdef GL_INDEX_ARRAY_EXT
|
||||
{ GL_INDEX_ARRAY_COUNT_EXT ,"GL_INDEX_ARRAY_COUNT_EXT" },
|
||||
{ GL_INDEX_ARRAY_EXT ,"GL_INDEX_ARRAY_EXT" },
|
||||
{ GL_INDEX_ARRAY_POINTER_EXT ,"GL_INDEX_ARRAY_POINTER_EXT" },
|
||||
{ GL_INDEX_ARRAY_STRIDE_EXT ,"GL_INDEX_ARRAY_STRIDE_EXT" },
|
||||
{ GL_INDEX_ARRAY_TYPE_EXT ,"GL_INDEX_ARRAY_TYPE_EXT" },
|
||||
#endif
|
||||
{ GL_INDEX_BITS ,"GL_INDEX_BITS" },
|
||||
{ GL_INDEX_CLEAR_VALUE ,"GL_INDEX_CLEAR_VALUE" },
|
||||
{ GL_INDEX_MODE ,"GL_INDEX_MODE" },
|
||||
{ GL_INDEX_OFFSET ,"GL_INDEX_OFFSET" },
|
||||
{ GL_INDEX_SHIFT ,"GL_INDEX_SHIFT" },
|
||||
{ GL_INDEX_WRITEMASK ,"GL_INDEX_WRITEMASK" },
|
||||
{ GL_INT ,"GL_INT" },
|
||||
{ GL_INVALID_ENUM ,"GL_INVALID_ENUM" },
|
||||
{ GL_INVALID_OPERATION ,"GL_INVALID_OPERATION" },
|
||||
{ GL_INVALID_VALUE ,"GL_INVALID_VALUE" },
|
||||
{ GL_INVERT ,"GL_INVERT" },
|
||||
{ GL_KEEP ,"GL_KEEP" },
|
||||
{ GL_LEFT ,"GL_LEFT" },
|
||||
{ GL_LEQUAL ,"GL_LEQUAL" },
|
||||
{ GL_LESS ,"GL_LESS" },
|
||||
{ GL_LIGHT0 ,"GL_LIGHT0" },
|
||||
{ GL_LIGHT1 ,"GL_LIGHT1" },
|
||||
{ GL_LIGHT2 ,"GL_LIGHT2" },
|
||||
{ GL_LIGHT3 ,"GL_LIGHT3" },
|
||||
{ GL_LIGHT4 ,"GL_LIGHT4" },
|
||||
{ GL_LIGHT5 ,"GL_LIGHT5" },
|
||||
{ GL_LIGHT6 ,"GL_LIGHT6" },
|
||||
{ GL_LIGHT7 ,"GL_LIGHT7" },
|
||||
{ GL_LIGHTING ,"GL_LIGHTING" },
|
||||
{ GL_LIGHT_MODEL_AMBIENT ,"GL_LIGHT_MODEL_AMBIENT" },
|
||||
{ GL_LIGHT_MODEL_LOCAL_VIEWER ,"GL_LIGHT_MODEL_LOCAL_VIEWER" },
|
||||
{ GL_LIGHT_MODEL_TWO_SIDE ,"GL_LIGHT_MODEL_TWO_SIDE" },
|
||||
{ GL_LINE ,"GL_LINE" },
|
||||
{ GL_LINEAR ,"GL_LINEAR" },
|
||||
{ GL_LINEAR_ATTENUATION ,"GL_LINEAR_ATTENUATION" },
|
||||
{ GL_LINEAR_MIPMAP_LINEAR ,"GL_LINEAR_MIPMAP_LINEAR" },
|
||||
{ GL_LINEAR_MIPMAP_NEAREST ,"GL_LINEAR_MIPMAP_NEAREST" },
|
||||
{ GL_LINE_LOOP ,"GL_LINE_LOOP" },
|
||||
{ GL_LINE_RESET_TOKEN ,"GL_LINE_RESET_TOKEN" },
|
||||
{ GL_LINE_SMOOTH ,"GL_LINE_SMOOTH" },
|
||||
{ GL_LINE_SMOOTH_HINT ,"GL_LINE_SMOOTH_HINT" },
|
||||
{ GL_LINE_STIPPLE ,"GL_LINE_STIPPLE" },
|
||||
{ GL_LINE_STIPPLE_PATTERN ,"GL_LINE_STIPPLE_PATTERN" },
|
||||
{ GL_LINE_STIPPLE_REPEAT ,"GL_LINE_STIPPLE_REPEAT" },
|
||||
{ GL_LINE_STRIP ,"GL_LINE_STRIP" },
|
||||
{ GL_LINE_TOKEN ,"GL_LINE_TOKEN" },
|
||||
{ GL_LINE_WIDTH ,"GL_LINE_WIDTH" },
|
||||
{ GL_LINE_WIDTH_GRANULARITY ,"GL_LINE_WIDTH_GRANULARITY" },
|
||||
{ GL_LINE_WIDTH_RANGE ,"GL_LINE_WIDTH_RANGE" },
|
||||
{ GL_LIST_BASE ,"GL_LIST_BASE" },
|
||||
{ GL_LIST_INDEX ,"GL_LIST_INDEX" },
|
||||
{ GL_LIST_MODE ,"GL_LIST_MODE" },
|
||||
{ GL_LOAD ,"GL_LOAD" },
|
||||
{ GL_LOGIC_OP ,"GL_LOGIC_OP" },
|
||||
{ GL_LOGIC_OP_MODE ,"GL_LOGIC_OP_MODE" },
|
||||
{ GL_LUMINANCE ,"GL_LUMINANCE" },
|
||||
{ GL_LUMINANCE_ALPHA ,"GL_LUMINANCE_ALPHA" },
|
||||
{ GL_MAP1_COLOR_4 ,"GL_MAP1_COLOR_4" },
|
||||
{ GL_MAP1_GRID_DOMAIN ,"GL_MAP1_GRID_DOMAIN" },
|
||||
{ GL_MAP1_GRID_SEGMENTS ,"GL_MAP1_GRID_SEGMENTS" },
|
||||
{ GL_MAP1_INDEX ,"GL_MAP1_INDEX" },
|
||||
{ GL_MAP1_NORMAL ,"GL_MAP1_NORMAL" },
|
||||
{ GL_MAP1_TEXTURE_COORD_1 ,"GL_MAP1_TEXTURE_COORD_1" },
|
||||
{ GL_MAP1_TEXTURE_COORD_2 ,"GL_MAP1_TEXTURE_COORD_2" },
|
||||
{ GL_MAP1_TEXTURE_COORD_3 ,"GL_MAP1_TEXTURE_COORD_3" },
|
||||
{ GL_MAP1_TEXTURE_COORD_4 ,"GL_MAP1_TEXTURE_COORD_4" },
|
||||
{ GL_MAP1_VERTEX_3 ,"GL_MAP1_VERTEX_3" },
|
||||
{ GL_MAP1_VERTEX_4 ,"GL_MAP1_VERTEX_4" },
|
||||
{ GL_MAP2_COLOR_4 ,"GL_MAP2_COLOR_4" },
|
||||
{ GL_MAP2_GRID_DOMAIN ,"GL_MAP2_GRID_DOMAIN" },
|
||||
{ GL_MAP2_GRID_SEGMENTS ,"GL_MAP2_GRID_SEGMENTS" },
|
||||
{ GL_MAP2_INDEX ,"GL_MAP2_INDEX" },
|
||||
{ GL_MAP2_NORMAL ,"GL_MAP2_NORMAL" },
|
||||
{ GL_MAP2_TEXTURE_COORD_1 ,"GL_MAP2_TEXTURE_COORD_1" },
|
||||
{ GL_MAP2_TEXTURE_COORD_2 ,"GL_MAP2_TEXTURE_COORD_2" },
|
||||
{ GL_MAP2_TEXTURE_COORD_3 ,"GL_MAP2_TEXTURE_COORD_3" },
|
||||
{ GL_MAP2_TEXTURE_COORD_4 ,"GL_MAP2_TEXTURE_COORD_4" },
|
||||
{ GL_MAP2_VERTEX_3 ,"GL_MAP2_VERTEX_3" },
|
||||
{ GL_MAP2_VERTEX_4 ,"GL_MAP2_VERTEX_4" },
|
||||
{ GL_MAP_COLOR ,"GL_MAP_COLOR" },
|
||||
{ GL_MAP_STENCIL ,"GL_MAP_STENCIL" },
|
||||
{ GL_MATRIX_MODE ,"GL_MATRIX_MODE" },
|
||||
{ GL_MAX_ATTRIB_STACK_DEPTH ,"GL_MAX_ATTRIB_STACK_DEPTH" },
|
||||
{ GL_MAX_CLIP_PLANES ,"GL_MAX_CLIP_PLANES" },
|
||||
{ GL_MAX_EVAL_ORDER ,"GL_MAX_EVAL_ORDER" },
|
||||
#ifdef GL_MAX_EXT
|
||||
{ GL_MAX_EXT ,"GL_MAX_EXT" },
|
||||
#endif
|
||||
{ GL_MAX_LIGHTS ,"GL_MAX_LIGHTS" },
|
||||
{ GL_MAX_LIST_NESTING ,"GL_MAX_LIST_NESTING" },
|
||||
{ GL_MAX_MODELVIEW_STACK_DEPTH,"GL_MAX_MODELVIEW_STACK_DEPTH" },
|
||||
{ GL_MAX_NAME_STACK_DEPTH ,"GL_MAX_NAME_STACK_DEPTH" },
|
||||
{ GL_MAX_PIXEL_MAP_TABLE ,"GL_MAX_PIXEL_MAP_TABLE" },
|
||||
{ GL_MAX_PROJECTION_STACK_DEPTH,"GL_MAX_PROJECTION_STACK_DEPTH" },
|
||||
{ GL_MAX_TEXTURE_SIZE ,"GL_MAX_TEXTURE_SIZE" },
|
||||
{ GL_MAX_TEXTURE_STACK_DEPTH ,"GL_MAX_TEXTURE_STACK_DEPTH" },
|
||||
{ GL_MAX_VIEWPORT_DIMS ,"GL_MAX_VIEWPORT_DIMS" },
|
||||
#ifdef GL_MIN_EXT
|
||||
{ GL_MIN_EXT ,"GL_MIN_EXT" },
|
||||
#endif
|
||||
{ GL_MODELVIEW ,"GL_MODELVIEW" },
|
||||
{ GL_MODELVIEW_MATRIX ,"GL_MODELVIEW_MATRIX" },
|
||||
{ GL_MODELVIEW_STACK_DEPTH ,"GL_MODELVIEW_STACK_DEPTH" },
|
||||
{ GL_MODULATE ,"GL_MODULATE" },
|
||||
{ GL_MULT ,"GL_MULT" },
|
||||
{ GL_NAME_STACK_DEPTH ,"GL_NAME_STACK_DEPTH" },
|
||||
{ GL_NAND ,"GL_NAND" },
|
||||
{ GL_NEAREST ,"GL_NEAREST" },
|
||||
{ GL_NEAREST_MIPMAP_LINEAR ,"GL_NEAREST_MIPMAP_LINEAR" },
|
||||
{ GL_NEAREST_MIPMAP_NEAREST ,"GL_NEAREST_MIPMAP_NEAREST" },
|
||||
{ GL_NEVER ,"GL_NEVER" },
|
||||
{ GL_NICEST ,"GL_NICEST" },
|
||||
{ GL_NOOP ,"GL_NOOP" },
|
||||
{ GL_NOR ,"GL_NOR" },
|
||||
{ GL_NORMALIZE ,"GL_NORMALIZE" },
|
||||
#ifdef GL_NORMAL_ARRAY_EXT
|
||||
{ GL_NORMAL_ARRAY_COUNT_EXT ,"GL_NORMAL_ARRAY_COUNT_EXT" },
|
||||
{ GL_NORMAL_ARRAY_EXT ,"GL_NORMAL_ARRAY_EXT" },
|
||||
{ GL_NORMAL_ARRAY_POINTER_EXT ,"GL_NORMAL_ARRAY_POINTER_EXT" },
|
||||
{ GL_NORMAL_ARRAY_STRIDE_EXT ,"GL_NORMAL_ARRAY_STRIDE_EXT" },
|
||||
{ GL_NORMAL_ARRAY_TYPE_EXT ,"GL_NORMAL_ARRAY_TYPE_EXT" },
|
||||
#endif
|
||||
{ GL_NOTEQUAL ,"GL_NOTEQUAL" },
|
||||
{ GL_OBJECT_LINEAR ,"GL_OBJECT_LINEAR" },
|
||||
{ GL_OBJECT_PLANE ,"GL_OBJECT_PLANE" },
|
||||
#ifdef GL_ONE_MINUS_CONSTANT_ALPHA_EXT
|
||||
{ GL_ONE_MINUS_CONSTANT_ALPHA_EXT,"GL_ONE_MINUS_CONSTANT_ALPHA_EXT" },
|
||||
{ GL_ONE_MINUS_CONSTANT_COLOR_EXT,"GL_ONE_MINUS_CONSTANT_COLOR_EXT" },
|
||||
#endif
|
||||
{ GL_ONE_MINUS_DST_ALPHA ,"GL_ONE_MINUS_DST_ALPHA" },
|
||||
{ GL_ONE_MINUS_DST_COLOR ,"GL_ONE_MINUS_DST_COLOR" },
|
||||
{ GL_ONE_MINUS_SRC_ALPHA ,"GL_ONE_MINUS_SRC_ALPHA" },
|
||||
{ GL_ONE_MINUS_SRC_COLOR ,"GL_ONE_MINUS_SRC_COLOR" },
|
||||
{ GL_OR ,"GL_OR" },
|
||||
{ GL_ORDER ,"GL_ORDER" },
|
||||
{ GL_OR_INVERTED ,"GL_OR_INVERTED" },
|
||||
{ GL_OR_REVERSE ,"GL_OR_REVERSE" },
|
||||
{ GL_OUT_OF_MEMORY ,"GL_OUT_OF_MEMORY" },
|
||||
{ GL_PACK_ALIGNMENT ,"GL_PACK_ALIGNMENT" },
|
||||
{ GL_PACK_LSB_FIRST ,"GL_PACK_LSB_FIRST" },
|
||||
{ GL_PACK_ROW_LENGTH ,"GL_PACK_ROW_LENGTH" },
|
||||
{ GL_PACK_SKIP_PIXELS ,"GL_PACK_SKIP_PIXELS" },
|
||||
{ GL_PACK_SKIP_ROWS ,"GL_PACK_SKIP_ROWS" },
|
||||
{ GL_PACK_SWAP_BYTES ,"GL_PACK_SWAP_BYTES" },
|
||||
{ GL_PASS_THROUGH_TOKEN ,"GL_PASS_THROUGH_TOKEN" },
|
||||
{ GL_PERSPECTIVE_CORRECTION_HINT,"GL_PERSPECTIVE_CORRECTION_HINT" },
|
||||
{ GL_PIXEL_MAP_A_TO_A ,"GL_PIXEL_MAP_A_TO_A" },
|
||||
{ GL_PIXEL_MAP_A_TO_A_SIZE ,"GL_PIXEL_MAP_A_TO_A_SIZE" },
|
||||
{ GL_PIXEL_MAP_B_TO_B ,"GL_PIXEL_MAP_B_TO_B" },
|
||||
{ GL_PIXEL_MAP_B_TO_B_SIZE ,"GL_PIXEL_MAP_B_TO_B_SIZE" },
|
||||
{ GL_PIXEL_MAP_G_TO_G ,"GL_PIXEL_MAP_G_TO_G" },
|
||||
{ GL_PIXEL_MAP_G_TO_G_SIZE ,"GL_PIXEL_MAP_G_TO_G_SIZE" },
|
||||
{ GL_PIXEL_MAP_I_TO_A ,"GL_PIXEL_MAP_I_TO_A" },
|
||||
{ GL_PIXEL_MAP_I_TO_A_SIZE ,"GL_PIXEL_MAP_I_TO_A_SIZE" },
|
||||
{ GL_PIXEL_MAP_I_TO_B ,"GL_PIXEL_MAP_I_TO_B" },
|
||||
{ GL_PIXEL_MAP_I_TO_B_SIZE ,"GL_PIXEL_MAP_I_TO_B_SIZE" },
|
||||
{ GL_PIXEL_MAP_I_TO_G ,"GL_PIXEL_MAP_I_TO_G" },
|
||||
{ GL_PIXEL_MAP_I_TO_G_SIZE ,"GL_PIXEL_MAP_I_TO_G_SIZE" },
|
||||
{ GL_PIXEL_MAP_I_TO_I ,"GL_PIXEL_MAP_I_TO_I" },
|
||||
{ GL_PIXEL_MAP_I_TO_I_SIZE ,"GL_PIXEL_MAP_I_TO_I_SIZE" },
|
||||
{ GL_PIXEL_MAP_I_TO_R ,"GL_PIXEL_MAP_I_TO_R" },
|
||||
{ GL_PIXEL_MAP_I_TO_R_SIZE ,"GL_PIXEL_MAP_I_TO_R_SIZE" },
|
||||
{ GL_PIXEL_MAP_R_TO_R ,"GL_PIXEL_MAP_R_TO_R" },
|
||||
{ GL_PIXEL_MAP_R_TO_R_SIZE ,"GL_PIXEL_MAP_R_TO_R_SIZE" },
|
||||
{ GL_PIXEL_MAP_S_TO_S ,"GL_PIXEL_MAP_S_TO_S" },
|
||||
{ GL_PIXEL_MAP_S_TO_S_SIZE ,"GL_PIXEL_MAP_S_TO_S_SIZE" },
|
||||
{ GL_POINT ,"GL_POINT" },
|
||||
{ GL_POINT_SIZE ,"GL_POINT_SIZE" },
|
||||
{ GL_POINT_SIZE_GRANULARITY ,"GL_POINT_SIZE_GRANULARITY" },
|
||||
{ GL_POINT_SIZE_RANGE ,"GL_POINT_SIZE_RANGE" },
|
||||
{ GL_POINT_SMOOTH ,"GL_POINT_SMOOTH" },
|
||||
{ GL_POINT_SMOOTH_HINT ,"GL_POINT_SMOOTH_HINT" },
|
||||
{ GL_POINT_TOKEN ,"GL_POINT_TOKEN" },
|
||||
{ GL_POLYGON ,"GL_POLYGON" },
|
||||
{ GL_POLYGON_MODE ,"GL_POLYGON_MODE" },
|
||||
{ GL_POLYGON_SMOOTH ,"GL_POLYGON_SMOOTH" },
|
||||
{ GL_POLYGON_SMOOTH_HINT ,"GL_POLYGON_SMOOTH_HINT" },
|
||||
{ GL_POLYGON_STIPPLE ,"GL_POLYGON_STIPPLE" },
|
||||
#ifdef GL_POLYGON_OFFSET_EXT
|
||||
{ GL_POLYGON_OFFSET_BIAS_EXT ,"GL_POLYGON_OFFSET_BIAS_EXT" },
|
||||
{ GL_POLYGON_OFFSET_EXT ,"GL_POLYGON_OFFSET_EXT" },
|
||||
{ GL_POLYGON_OFFSET_FACTOR_EXT,"GL_POLYGON_OFFSET_FACTOR_EXT" },
|
||||
#endif
|
||||
{ GL_POLYGON_TOKEN ,"GL_POLYGON_TOKEN" },
|
||||
{ GL_POSITION ,"GL_POSITION" },
|
||||
{ GL_PROJECTION ,"GL_PROJECTION" },
|
||||
{ GL_PROJECTION_MATRIX ,"GL_PROJECTION_MATRIX" },
|
||||
{ GL_PROJECTION_STACK_DEPTH ,"GL_PROJECTION_STACK_DEPTH" },
|
||||
{ GL_Q ,"GL_Q" },
|
||||
{ GL_QUADRATIC_ATTENUATION ,"GL_QUADRATIC_ATTENUATION" },
|
||||
{ GL_QUADS ,"GL_QUADS" },
|
||||
{ GL_QUAD_STRIP ,"GL_QUAD_STRIP" },
|
||||
{ GL_R ,"GL_R" },
|
||||
{ GL_READ_BUFFER ,"GL_READ_BUFFER" },
|
||||
{ GL_RED ,"GL_RED" },
|
||||
{ GL_RED_BIAS ,"GL_RED_BIAS" },
|
||||
{ GL_RED_BITS ,"GL_RED_BITS" },
|
||||
{ GL_RED_SCALE ,"GL_RED_SCALE" },
|
||||
{ GL_RENDER ,"GL_RENDER" },
|
||||
{ GL_RENDERER ,"GL_RENDERER" },
|
||||
{ GL_RENDER_MODE ,"GL_RENDER_MODE" },
|
||||
{ GL_REPEAT ,"GL_REPEAT" },
|
||||
{ GL_REPLACE ,"GL_REPLACE" },
|
||||
#ifdef GL_REPLACE_EXT
|
||||
{ GL_REPLACE_EXT ,"GL_REPLACE_EXT" },
|
||||
#endif
|
||||
{ GL_RETURN ,"GL_RETURN" },
|
||||
{ GL_RGB ,"GL_RGB" },
|
||||
{ GL_RGBA ,"GL_RGBA" },
|
||||
{ GL_RGBA_MODE ,"GL_RGBA_MODE" },
|
||||
{ GL_RIGHT ,"GL_RIGHT" },
|
||||
{ GL_S ,"GL_S" },
|
||||
{ GL_SCISSOR_BOX ,"GL_SCISSOR_BOX" },
|
||||
{ GL_SCISSOR_TEST ,"GL_SCISSOR_TEST" },
|
||||
{ GL_SELECT ,"GL_SELECT" },
|
||||
{ GL_SET ,"GL_SET" },
|
||||
{ GL_SHADE_MODEL ,"GL_SHADE_MODEL" },
|
||||
{ GL_SHININESS ,"GL_SHININESS" },
|
||||
{ GL_SHORT ,"GL_SHORT" },
|
||||
{ GL_SMOOTH ,"GL_SMOOTH" },
|
||||
{ GL_SPECULAR ,"GL_SPECULAR" },
|
||||
{ GL_SPHERE_MAP ,"GL_SPHERE_MAP" },
|
||||
{ GL_SPOT_CUTOFF ,"GL_SPOT_CUTOFF" },
|
||||
{ GL_SPOT_DIRECTION ,"GL_SPOT_DIRECTION" },
|
||||
{ GL_SPOT_EXPONENT ,"GL_SPOT_EXPONENT" },
|
||||
{ GL_SRC_ALPHA ,"GL_SRC_ALPHA" },
|
||||
{ GL_SRC_ALPHA_SATURATE ,"GL_SRC_ALPHA_SATURATE" },
|
||||
{ GL_SRC_COLOR ,"GL_SRC_COLOR" },
|
||||
{ GL_STACK_OVERFLOW ,"GL_STACK_OVERFLOW" },
|
||||
{ GL_STACK_UNDERFLOW ,"GL_STACK_UNDERFLOW" },
|
||||
{ GL_STENCIL ,"GL_STENCIL" },
|
||||
{ GL_STENCIL_BITS ,"GL_STENCIL_BITS" },
|
||||
{ GL_STENCIL_CLEAR_VALUE ,"GL_STENCIL_CLEAR_VALUE" },
|
||||
{ GL_STENCIL_FAIL ,"GL_STENCIL_FAIL" },
|
||||
{ GL_STENCIL_FUNC ,"GL_STENCIL_FUNC" },
|
||||
{ GL_STENCIL_INDEX ,"GL_STENCIL_INDEX" },
|
||||
{ GL_STENCIL_PASS_DEPTH_FAIL ,"GL_STENCIL_PASS_DEPTH_FAIL" },
|
||||
{ GL_STENCIL_PASS_DEPTH_PASS ,"GL_STENCIL_PASS_DEPTH_PASS" },
|
||||
{ GL_STENCIL_REF ,"GL_STENCIL_REF" },
|
||||
{ GL_STENCIL_TEST ,"GL_STENCIL_TEST" },
|
||||
{ GL_STENCIL_VALUE_MASK ,"GL_STENCIL_VALUE_MASK" },
|
||||
{ GL_STENCIL_WRITEMASK ,"GL_STENCIL_WRITEMASK" },
|
||||
{ GL_STEREO ,"GL_STEREO" },
|
||||
{ GL_SUBPIXEL_BITS ,"GL_SUBPIXEL_BITS" },
|
||||
{ GL_T ,"GL_T" },
|
||||
{ GL_TEXTURE ,"GL_TEXTURE" },
|
||||
{ GL_TEXTURE_1D ,"GL_TEXTURE_1D" },
|
||||
{ GL_TEXTURE_2D ,"GL_TEXTURE_2D" },
|
||||
{ GL_TEXTURE_BORDER ,"GL_TEXTURE_BORDER" },
|
||||
{ GL_TEXTURE_BORDER_COLOR ,"GL_TEXTURE_BORDER_COLOR" },
|
||||
{ GL_TEXTURE_COMPONENTS ,"GL_TEXTURE_COMPONENTS" },
|
||||
#ifdef GL_TEXTURE_COORD_ARRAY_EXT
|
||||
{ GL_TEXTURE_COORD_ARRAY_COUNT_EXT,"GL_TEXTURE_COORD_ARRAY_COUNT_EXT" },
|
||||
{ GL_TEXTURE_COORD_ARRAY_EXT ,"GL_TEXTURE_COORD_ARRAY_EXT" },
|
||||
{ GL_TEXTURE_COORD_ARRAY_POINTER_EXT,"GL_TEXTURE_COORD_ARRAY_POINTER_EXT" },
|
||||
{ GL_TEXTURE_COORD_ARRAY_SIZE_EXT,"GL_TEXTURE_COORD_ARRAY_SIZE_EXT" },
|
||||
{ GL_TEXTURE_COORD_ARRAY_STRIDE_EXT,"GL_TEXTURE_COORD_ARRAY_STRIDE_EXT" },
|
||||
{ GL_TEXTURE_COORD_ARRAY_TYPE_EXT,"GL_TEXTURE_COORD_ARRAY_TYPE_EXT" },
|
||||
#endif
|
||||
{ GL_TEXTURE_ENV ,"GL_TEXTURE_ENV" },
|
||||
{ GL_TEXTURE_ENV_COLOR ,"GL_TEXTURE_ENV_COLOR" },
|
||||
{ GL_TEXTURE_ENV_MODE ,"GL_TEXTURE_ENV_MODE" },
|
||||
{ GL_TEXTURE_GEN_MODE ,"GL_TEXTURE_GEN_MODE" },
|
||||
{ GL_TEXTURE_GEN_Q ,"GL_TEXTURE_GEN_Q" },
|
||||
{ GL_TEXTURE_GEN_R ,"GL_TEXTURE_GEN_R" },
|
||||
{ GL_TEXTURE_GEN_S ,"GL_TEXTURE_GEN_S" },
|
||||
{ GL_TEXTURE_GEN_T ,"GL_TEXTURE_GEN_T" },
|
||||
{ GL_TEXTURE_HEIGHT ,"GL_TEXTURE_HEIGHT" },
|
||||
{ GL_TEXTURE_MAG_FILTER ,"GL_TEXTURE_MAG_FILTER" },
|
||||
{ GL_TEXTURE_MATRIX ,"GL_TEXTURE_MATRIX" },
|
||||
{ GL_TEXTURE_MIN_FILTER ,"GL_TEXTURE_MIN_FILTER" },
|
||||
{ GL_TEXTURE_STACK_DEPTH ,"GL_TEXTURE_STACK_DEPTH" },
|
||||
{ GL_TEXTURE_WIDTH ,"GL_TEXTURE_WIDTH" },
|
||||
{ GL_TEXTURE_WRAP_S ,"GL_TEXTURE_WRAP_S" },
|
||||
{ GL_TEXTURE_WRAP_T ,"GL_TEXTURE_WRAP_T" },
|
||||
{ GL_TRIANGLES ,"GL_TRIANGLES" },
|
||||
{ GL_TRIANGLE_FAN ,"GL_TRIANGLE_FAN" },
|
||||
{ GL_TRIANGLE_STRIP ,"GL_TRIANGLE_STRIP" },
|
||||
{ GL_UNPACK_ALIGNMENT ,"GL_UNPACK_ALIGNMENT" },
|
||||
{ GL_UNPACK_LSB_FIRST ,"GL_UNPACK_LSB_FIRST" },
|
||||
{ GL_UNPACK_ROW_LENGTH ,"GL_UNPACK_ROW_LENGTH" },
|
||||
{ GL_UNPACK_SKIP_PIXELS ,"GL_UNPACK_SKIP_PIXELS" },
|
||||
{ GL_UNPACK_SKIP_ROWS ,"GL_UNPACK_SKIP_ROWS" },
|
||||
{ GL_UNPACK_SWAP_BYTES ,"GL_UNPACK_SWAP_BYTES" },
|
||||
{ GL_UNSIGNED_BYTE ,"GL_UNSIGNED_BYTE" },
|
||||
{ GL_UNSIGNED_INT ,"GL_UNSIGNED_INT" },
|
||||
{ GL_UNSIGNED_SHORT ,"GL_UNSIGNED_SHORT" },
|
||||
{ GL_VENDOR ,"GL_VENDOR" },
|
||||
{ GL_VERSION ,"GL_VERSION" },
|
||||
#ifdef GL_VERTEX_ARRAY_EXT
|
||||
{ GL_VERTEX_ARRAY_COUNT_EXT ,"GL_VERTEX_ARRAY_COUNT_EXT" },
|
||||
{ GL_VERTEX_ARRAY_EXT ,"GL_VERTEX_ARRAY_EXT" },
|
||||
{ GL_VERTEX_ARRAY_POINTER_EXT ,"GL_VERTEX_ARRAY_POINTER_EXT" },
|
||||
{ GL_VERTEX_ARRAY_SIZE_EXT ,"GL_VERTEX_ARRAY_SIZE_EXT" },
|
||||
{ GL_VERTEX_ARRAY_STRIDE_EXT ,"GL_VERTEX_ARRAY_STRIDE_EXT" },
|
||||
{ GL_VERTEX_ARRAY_TYPE_EXT ,"GL_VERTEX_ARRAY_TYPE_EXT" },
|
||||
#endif
|
||||
{ GL_VIEWPORT ,"GL_VIEWPORT" },
|
||||
{ GL_XOR ,"GL_XOR" },
|
||||
{ GL_ZOOM_X ,"GL_ZOOM_X" },
|
||||
{ GL_ZOOM_Y ,"GL_ZOOM_Y" },
|
||||
|
||||
/* Magic end-marker - do not remove! */
|
||||
{ GL_ZERO, NULL }
|
||||
} ;
|
||||
|
||||
|
||||
int xglTraceIsEnabled ( char *gl_function_name )
|
||||
{
|
||||
static int frameno = 0 ;
|
||||
static int countdown = 0 ;
|
||||
|
||||
if ( strcmp ( gl_function_name, "glutSwapBuffers" ) == 0 )
|
||||
{
|
||||
if ( countdown == 0 )
|
||||
{
|
||||
char s [ 100 ] ;
|
||||
|
||||
fprintf ( stderr, "\nContinue Tracing after frame %d [Yes,No,Countdown,eXit] ?", ++frameno ) ;
|
||||
gets ( s ) ;
|
||||
|
||||
if ( s[0] == 'x' )
|
||||
exit ( 1 ) ;
|
||||
|
||||
xglTraceOn = ( s[0] != 'n' && s[0] != 'c' ) ;
|
||||
|
||||
if ( s[0] == 'c' )
|
||||
{
|
||||
fprintf ( stderr, "\nHow many frames should I wait until I ask again?" ) ;
|
||||
gets ( s ) ;
|
||||
countdown = atoi(s) ;
|
||||
}
|
||||
|
||||
fprintf ( xglTraceFd, "/* Frame %d - tracing %s */\n", frameno, xglTraceOn ? "ON" : "OFF" ) ;
|
||||
}
|
||||
else
|
||||
countdown-- ;
|
||||
}
|
||||
|
||||
return xglTraceOn ;
|
||||
}
|
||||
|
||||
|
||||
int xglExecuteIsEnabled ( char *gl_function_name )
|
||||
{
|
||||
return TRUE ;
|
||||
}
|
||||
|
||||
char *xglExpandGLenum ( GLenum x )
|
||||
{
|
||||
static GLenum last_val = GL_NONE ;
|
||||
static char *last_str = NULL ;
|
||||
char *error_message;
|
||||
int i;
|
||||
|
||||
/* Due to ambiguity - these are output as numbers...
|
||||
|
||||
GL_NONE = , GL_ZERO = GL_FALSE = GL_POINTS = 0
|
||||
GL_ONE = , GL_TRUE = GL_LINES = 1
|
||||
*/
|
||||
|
||||
if ( (int) x == 0 ) return "(GLenum) 0" ;
|
||||
if ( (int) x == 1 ) return "(GLenum) 1" ;
|
||||
|
||||
if ( last_val == x ) return last_str ;
|
||||
|
||||
for ( i = 0 ; glenum_string [i].name != NULL ; i++ )
|
||||
if ( glenum_string [i].val == x )
|
||||
return glenum_string [i].name ;
|
||||
|
||||
/*
|
||||
WARNING - this will leak memory - but it is an error condition,
|
||||
so I suppose it's acceptable.
|
||||
You can't declare the 'error_message' string as a
|
||||
static - or else double errors will go mis-reported.
|
||||
*/
|
||||
|
||||
error_message = (char *)malloc( 100 * sizeof(char) ) ;
|
||||
|
||||
sprintf ( error_message, "(GLenum) 0x%04x /* Illegal? */", (int) x ) ;
|
||||
|
||||
return error_message ;
|
||||
}
|
||||
|
||||
static GLbyte b1 [ 1 ], b2 [ 2 ], b3 [ 3 ], b4 [ 4 ] ;
|
||||
static GLdouble d1 [ 1 ], d2 [ 2 ], d3 [ 3 ], d4 [ 4 ] ;
|
||||
static GLfloat f1 [ 1 ], f2 [ 2 ], f3 [ 3 ], f4 [ 4 ] ;
|
||||
static GLint i1 [ 1 ], i2 [ 2 ], i3 [ 3 ], i4 [ 4 ] ;
|
||||
static GLshort s1 [ 1 ], s2 [ 2 ], s3 [ 3 ], s4 [ 4 ] ;
|
||||
static GLubyte ub1 [ 1 ], ub2 [ 2 ], ub3 [ 3 ], ub4 [ 4 ] ;
|
||||
static GLuint ui1 [ 1 ], ui2 [ 2 ], ui3 [ 3 ], ui4 [ 4 ] ;
|
||||
static GLushort us1 [ 1 ], us2 [ 2 ], us3 [ 3 ], us4 [ 4 ] ;
|
||||
|
||||
static GLdouble md [ 16 ] ;
|
||||
static GLfloat mf [ 16 ] ;
|
||||
|
||||
GLdouble *xglBuild1dv ( GLdouble v ) { d1[0] = v ; return d1 ; }
|
||||
GLfloat *xglBuild1fv ( GLfloat v ) { f1[0] = v ; return f1 ; }
|
||||
GLbyte *xglBuild1bv ( GLbyte v ) { b1[0] = v ; return b1 ; }
|
||||
GLint *xglBuild1iv ( GLint v ) { i1[0] = v ; return i1 ; }
|
||||
GLshort *xglBuild1sv ( GLshort v ) { s1[0] = v ; return s1 ; }
|
||||
GLubyte *xglBuild1ubv ( GLubyte v ) { ub1[0] = v ; return ub1 ; }
|
||||
GLuint *xglBuild1uiv ( GLuint v ) { ui1[0] = v ; return ui1 ; }
|
||||
GLushort *xglBuild1usv ( GLushort v ) { us1[0] = v ; return us1 ; }
|
||||
|
||||
GLdouble *xglBuild2dv ( GLdouble v0, GLdouble v1 ) { d2[0] = v0 ; d2[1] = v1 ; return d2 ; }
|
||||
GLfloat *xglBuild2fv ( GLfloat v0, GLfloat v1 ) { f2[0] = v0 ; f2[1] = v1 ; return f2 ; }
|
||||
GLbyte *xglBuild2bv ( GLbyte v0, GLbyte v1 ) { b2[0] = v0 ; b2[1] = v1 ; return b2 ; }
|
||||
GLint *xglBuild2iv ( GLint v0, GLint v1 ) { i2[0] = v0 ; i2[1] = v1 ; return i2 ; }
|
||||
GLshort *xglBuild2sv ( GLshort v0, GLshort v1 ) { s2[0] = v0 ; s2[1] = v1 ; return s2 ; }
|
||||
GLubyte *xglBuild2ubv ( GLubyte v0, GLubyte v1 ) { ub2[0] = v0 ; ub2[1] = v1 ; return ub2 ; }
|
||||
GLuint *xglBuild2uiv ( GLuint v0, GLuint v1 ) { ui2[0] = v0 ; ui2[1] = v1 ; return ui2 ; }
|
||||
GLushort *xglBuild2usv ( GLushort v0, GLushort v1 ) { us2[0] = v0 ; us2[1] = v1 ; return us2 ; }
|
||||
|
||||
GLdouble *xglBuild3dv ( GLdouble v0, GLdouble v1, GLdouble v2 ) { d3[0] = v0 ; d3[1] = v1 ; d3[2] = v2 ; return d3 ; }
|
||||
GLfloat *xglBuild3fv ( GLfloat v0, GLfloat v1, GLfloat v2 ) { f3[0] = v0 ; f3[1] = v1 ; f3[2] = v2 ; return f3 ; }
|
||||
GLbyte *xglBuild3bv ( GLbyte v0, GLbyte v1, GLbyte v2 ) { b3[0] = v0 ; b3[1] = v1 ; b3[2] = v2 ; return b3 ; }
|
||||
GLint *xglBuild3iv ( GLint v0, GLint v1, GLint v2 ) { i3[0] = v0 ; i3[1] = v1 ; i3[2] = v2 ; return i3 ; }
|
||||
GLshort *xglBuild3sv ( GLshort v0, GLshort v1, GLshort v2 ) { s3[0] = v0 ; s3[1] = v1 ; s3[2] = v2 ; return s3 ; }
|
||||
GLubyte *xglBuild3ubv ( GLubyte v0, GLubyte v1, GLubyte v2 ) { ub3[0] = v0 ; ub3[1] = v1 ; ub3[2] = v2 ; return ub3 ; }
|
||||
GLuint *xglBuild3uiv ( GLuint v0, GLuint v1, GLuint v2 ) { ui3[0] = v0 ; ui3[1] = v1 ; ui3[2] = v2 ; return ui3 ; }
|
||||
GLushort *xglBuild3usv ( GLushort v0, GLushort v1, GLushort v2 ) { us3[0] = v0 ; us3[1] = v1 ; us3[2] = v2 ; return us3 ; }
|
||||
|
||||
|
||||
GLdouble *xglBuild4dv ( GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) { d4[0] = v0 ; d4[1] = v1 ; d4[2] = v2 ; d4[3] = v3 ; return d4 ; }
|
||||
GLfloat *xglBuild4fv ( GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { f4[0] = v0 ; f4[1] = v1 ; f4[2] = v2 ; f4[3] = v3 ; return f4 ; }
|
||||
GLbyte *xglBuild4bv ( GLbyte v0, GLbyte v1, GLbyte v2, GLbyte v3 ) { b4[0] = v0 ; b4[1] = v1 ; b4[2] = v2 ; b4[3] = v3 ; return b4 ; }
|
||||
GLint *xglBuild4iv ( GLint v0, GLint v1, GLint v2, GLint v3 ) { i4[0] = v0 ; i4[1] = v1 ; i4[2] = v2 ; i4[3] = v3 ; return i4 ; }
|
||||
GLshort *xglBuild4sv ( GLshort v0, GLshort v1, GLshort v2, GLshort v3 ) { s4[0] = v0 ; s4[1] = v1 ; s4[2] = v2 ; s4[3] = v3 ; return s4 ; }
|
||||
GLubyte *xglBuild4ubv ( GLubyte v0, GLubyte v1, GLubyte v2, GLubyte v3 ) { ub4[0] = v0 ; ub4[1] = v1 ; ub4[2] = v2 ; ub4[3] = v3 ; return ub4 ; }
|
||||
GLuint *xglBuild4uiv ( GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { ui4[0] = v0 ; ui4[1] = v1 ; ui4[2] = v2 ; ui4[3] = v3 ; return ui4 ; }
|
||||
GLushort *xglBuild4usv ( GLushort v0, GLushort v1, GLushort v2, GLushort v3 ) { us4[0] = v0 ; us4[1] = v1 ; us4[2] = v2 ; us4[3] = v3 ; return us4 ; }
|
||||
|
||||
GLdouble *xglBuildMatrixd ( GLdouble m0 , GLdouble m1 , GLdouble m2 , GLdouble m3 ,
|
||||
GLdouble m4 , GLdouble m5 , GLdouble m6 , GLdouble m7 ,
|
||||
GLdouble m8 , GLdouble m9 , GLdouble m10, GLdouble m11,
|
||||
GLdouble m12, GLdouble m13, GLdouble m14, GLdouble m15 )
|
||||
{
|
||||
md[ 0] = m0 ; md[ 1] = m1 ; md[ 2] = m2 ; md[ 3] = m3 ;
|
||||
md[ 4] = m4 ; md[ 5] = m5 ; md[ 6] = m6 ; md[ 7] = m7 ;
|
||||
md[ 8] = m8 ; md[ 9] = m9 ; md[10] = m10 ; md[11] = m11 ;
|
||||
md[12] = m12 ; md[13] = m13 ; md[14] = m14 ; md[15] = m15 ;
|
||||
|
||||
return md ;
|
||||
}
|
||||
|
||||
|
||||
GLfloat *xglBuildMatrixf ( GLfloat m0 , GLfloat m1 , GLfloat m2 , GLfloat m3 ,
|
||||
GLfloat m4 , GLfloat m5 , GLfloat m6 , GLfloat m7 ,
|
||||
GLfloat m8 , GLfloat m9 , GLfloat m10, GLfloat m11,
|
||||
GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15 )
|
||||
{
|
||||
mf[ 0] = m0 ; mf[ 1] = m1 ; mf[ 2] = m2 ; mf[ 3] = m3 ;
|
||||
mf[ 4] = m4 ; mf[ 5] = m5 ; mf[ 6] = m6 ; mf[ 7] = m7 ;
|
||||
mf[ 8] = m8 ; mf[ 9] = m9 ; mf[10] = m10 ; mf[11] = m11 ;
|
||||
mf[12] = m12 ; mf[13] = m13 ; mf[14] = m14 ; mf[15] = m15 ;
|
||||
|
||||
return mf ;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user