--- /dev/null
+// controls.cxx -- defines a standard interface to all flight sim controls
+//
+// Written by Curtis Olson, started May 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 "controls.hxx"
+
+
+FGControls controls;
+
+
+// Constructor
+FGControls::FGControls() :
+ aileron( 0.0 ),
+ elevator( 0.0 ),
+ elevator_trim( 1.969572E-03 ),
+ rudder( 0.0 )
+{
+ for ( int engine = 0; engine < MAX_ENGINES; engine++ ) {
+ throttle[engine] = 0.0;
+ }
+
+ for ( int wheel = 0; wheel < MAX_WHEELS; wheel++ ) {
+ brake[wheel] = 0.0;
+ }
+}
+
+
+// Destructor
+FGControls::~FGControls() {
+}
+
+
+// $Log$
+// Revision 1.1 1999/02/13 01:12:03 curt
+// Initial Revision.
+//
+// Revision 1.1 1999/02/09 04:51:32 jon
+// Initial revision
+//
+// Revision 1.3 1998/12/05 16:13:12 curt
+// Renamed class fgCONTROLS to class FGControls.
+//
+// Revision 1.2 1998/10/25 14:08:41 curt
+// Turned "struct fgCONTROLS" into a class, with inlined accessor functions.
+//
+// Revision 1.1 1998/10/18 01:51:05 curt
+// c++-ifying ...
+//
+// Revision 1.8 1998/09/29 02:01:31 curt
+// Added a brake.
+//
+// Revision 1.7 1998/02/07 15:29:36 curt
+// Incorporated HUD changes and struct/typedef changes from Charlie Hotchkiss
+// <chotchkiss@namg.us.anritsu.com>
+//
+// Revision 1.6 1998/01/19 19:27:02 curt
+// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+// This should simplify things tremendously.
+//
+// Revision 1.5 1998/01/19 18:40:22 curt
+// Tons of little changes to clean up the code and to remove fatal errors
+// when building with the c++ compiler.
+//
+// Revision 1.4 1997/12/10 22:37:41 curt
+// Prepended "fg" on the name of all global structures that didn't have it yet.
+// i.e. "struct WEATHER {}" became "struct fgWEATHER {}"
+//
+// Revision 1.3 1997/08/27 03:30:01 curt
+// Changed naming scheme of basic shared structures.
+//
+// Revision 1.2 1997/06/21 17:12:48 curt
+// Capitalized subdirectory names.
+//
+// Revision 1.1 1997/05/31 19:24:04 curt
+// Initial revision.
+//
+
--- /dev/null
+// controls.hxx -- defines a standard interface to all flight sim controls
+//
+// Written by Curtis Olson, started May 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 _CONTROLS_HXX
+#define _CONTROLS_HXX
+
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+
+// Define a structure containing the control parameters
+
+class FGControls {
+
+public:
+
+ static const int ALL_ENGINES = -1;
+ static const int MAX_ENGINES = 10;
+
+ static const int ALL_WHEELS = -1;
+ static const int MAX_WHEELS = 3;
+
+private:
+
+ double aileron;
+ double elevator;
+ double elevator_trim;
+ double rudder;
+ double throttle[MAX_ENGINES];
+ double brake[MAX_WHEELS];
+
+public:
+
+ FGControls();
+ ~FGControls();
+
+ // Query functions
+ inline double get_aileron() const { return aileron; }
+ inline double get_elevator() const { return elevator; }
+ inline double get_elevator_trim() const { return elevator_trim; }
+ inline double get_rudder() const { return rudder; }
+ inline double get_throttle(int engine) const { return throttle[engine]; }
+ inline double get_brake(int wheel) const { return brake[wheel]; }
+
+ // Update functions
+ inline void set_aileron( double pos ) {
+ aileron = pos;
+ if ( aileron < -1.0 ) aileron = -1.0;
+ if ( aileron > 1.0 ) aileron = 1.0;
+ }
+ inline void move_aileron( double amt ) {
+ aileron += amt;
+ if ( aileron < -1.0 ) aileron = -1.0;
+ if ( aileron > 1.0 ) aileron = 1.0;
+ }
+ inline void set_elevator( double pos ) {
+ elevator = pos;
+ if ( elevator < -1.0 ) elevator = -1.0;
+ if ( elevator > 1.0 ) elevator = 1.0;
+ }
+ inline void move_elevator( double amt ) {
+ elevator += amt;
+ if ( elevator < -1.0 ) elevator = -1.0;
+ if ( elevator > 1.0 ) elevator = 1.0;
+ }
+ inline void set_elevator_trim( double pos ) {
+ elevator_trim = pos;
+ if ( elevator_trim < -1.0 ) elevator_trim = -1.0;
+ if ( elevator_trim > 1.0 ) elevator_trim = 1.0;
+ }
+ inline void move_elevator_trim( double amt ) {
+ elevator_trim += amt;
+ if ( elevator_trim < -1.0 ) elevator_trim = -1.0;
+ if ( elevator_trim > 1.0 ) elevator_trim = 1.0;
+ }
+ inline void set_rudder( double pos ) {
+ rudder = pos;
+ if ( rudder < -1.0 ) rudder = -1.0;
+ if ( rudder > 1.0 ) rudder = 1.0;
+ }
+ inline void move_rudder( double amt ) {
+ rudder += amt;
+ if ( rudder < -1.0 ) rudder = -1.0;
+ if ( rudder > 1.0 ) rudder = 1.0;
+ }
+ inline void set_throttle( int engine, double pos ) {
+ if ( engine == ALL_ENGINES ) {
+ for ( int i = 0; i < MAX_ENGINES; i++ ) {
+ throttle[i] = pos;
+ if ( throttle[i] < 0.0 ) throttle[i] = 0.0;
+ if ( throttle[i] > 1.0 ) throttle[i] = 1.0;
+ }
+ } else {
+ if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
+ throttle[engine] = pos;
+ if ( throttle[engine] < 0.0 ) throttle[engine] = 0.0;
+ if ( throttle[engine] > 1.0 ) throttle[engine] = 1.0;
+ }
+ }
+ }
+ inline void move_throttle( int engine, double amt ) {
+ if ( engine == ALL_ENGINES ) {
+ for ( int i = 0; i < MAX_ENGINES; i++ ) {
+ throttle[i] += amt;
+ if ( throttle[i] < 0.0 ) throttle[i] = 0.0;
+ if ( throttle[i] > 1.0 ) throttle[i] = 1.0;
+ }
+ } else {
+ if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
+ throttle[engine] += amt;
+ if ( throttle[engine] < 0.0 ) throttle[engine] = 0.0;
+ if ( throttle[engine] > 1.0 ) throttle[engine] = 1.0;
+ }
+ }
+ }
+ inline void set_brake( int wheel, double pos ) {
+ if ( wheel == ALL_WHEELS ) {
+ for ( int i = 0; i < MAX_WHEELS; i++ ) {
+ brake[i] = pos;
+ if ( brake[i] < 0.0 ) brake[i] = 0.0;
+ if ( brake[i] > 1.0 ) brake[i] = 1.0;
+ }
+ } else {
+ if ( (wheel >= 0) && (wheel < MAX_WHEELS) ) {
+ brake[wheel] = pos;
+ if ( brake[wheel] < 0.0 ) brake[wheel] = 0.0;
+ if ( brake[wheel] > 1.0 ) brake[wheel] = 1.0;
+ }
+ }
+ }
+ inline void move_brake( int wheel, double amt ) {
+ if ( wheel == ALL_WHEELS ) {
+ for ( int i = 0; i < MAX_WHEELS; i++ ) {
+ brake[i] += amt;
+ if ( brake[i] < 0.0 ) brake[i] = 0.0;
+ if ( brake[i] > 1.0 ) brake[i] = 1.0;
+ }
+ } else {
+ if ( (wheel >= 0) && (wheel < MAX_WHEELS) ) {
+ brake[wheel] += amt;
+ if ( brake[wheel] < 0.0 ) brake[wheel] = 0.0;
+ if ( brake[wheel] > 1.0 ) brake[wheel] = 1.0;
+ }
+ }
+ }
+};
+
+
+extern FGControls controls;
+
+
+#endif // _CONTROLS_HXX
+
+
+// $Log$
+// Revision 1.1 1999/02/13 01:12:03 curt
+// Initial Revision.
+//
+// Revision 1.3 1998/12/05 16:13:13 curt
+// Renamed class fgCONTROLS to class FGControls.
+//
+// Revision 1.2 1998/10/25 14:08:42 curt
+// Turned "struct fgCONTROLS" into a class, with inlined accessor functions.
+//
+// Revision 1.1 1998/10/18 01:51:07 curt
+// c++-ifying ...
+//
+// Revision 1.17 1998/09/29 14:57:00 curt
+// c++-ified some comments.
+//
+// Revision 1.16 1998/09/29 02:01:32 curt
+// Added a brake.
+//
+// Revision 1.15 1998/04/25 22:06:27 curt
+// Edited cvs log messages in source files ... bad bad bad!
+//
+// Revision 1.14 1998/04/22 13:26:19 curt
+// C++ - ifing the code a bit.
+//
+// Revision 1.13 1998/04/21 17:02:35 curt
+// Prepairing for C++ integration.
+//
+// Revision 1.12 1998/02/09 22:56:48 curt
+// Removed "depend" files from cvs control. Other minor make tweaks.
+//
+// Revision 1.11 1998/02/07 15:29:36 curt
+// Incorporated HUD changes and struct/typedef changes from Charlie Hotchkiss
+// <chotchkiss@namg.us.anritsu.com>
+//
+// Revision 1.10 1998/01/27 00:47:52 curt
+// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
+// system and commandline/config file processing code.
+//
+// Revision 1.9 1998/01/22 02:59:31 curt
+// Changed #ifdef FILE_H to #ifdef _FILE_H
+//
+// Revision 1.8 1998/01/19 18:40:22 curt
+// Tons of little changes to clean up the code and to remove fatal errors
+// when building with the c++ compiler.
+//
+// Revision 1.7 1997/12/15 23:54:36 curt
+// Add xgl wrappers for debugging.
+// Generate terrain normals on the fly.
+//
+// Revision 1.6 1997/12/10 22:37:41 curt
+// Prepended "fg" on the name of all global structures that didn't have it yet.
+// i.e. "struct WEATHER {}" became "struct fgWEATHER {}"
+//
+// Revision 1.5 1997/08/27 03:30:02 curt
+// Changed naming scheme of basic shared structures.
+//
+// Revision 1.4 1997/07/23 21:52:18 curt
+// Put comments around the text after an #endif for increased portability.
+//
+// Revision 1.3 1997/05/31 19:16:27 curt
+// Elevator trim added.
+//
+// Revision 1.2 1997/05/23 15:40:33 curt
+// Added GNU copyright headers.
+//
+// Revision 1.1 1997/05/16 15:59:48 curt
+// Initial revision.
+//
--- /dev/null
+/*******************************************************************************
+
+ Header: FGDefs.h
+ Author: Jon S. Berndt
+ Date started: 02/01/99
+
+ ------------- Copyright (C) 1999 Jon S. Berndt (jsb@hal-pc.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., 59 Temple
+ Place - Suite 330, Boston, MA 02111-1307, USA.
+
+ Further information about the GNU General Public License can also be found on
+ the world wide web at http://www.gnu.org.
+
+HISTORY
+--------------------------------------------------------------------------------
+02/01/99 JSB Created
+
+********************************************************************************
+SENTRY
+*******************************************************************************/
+
+#ifndef FGDEFS_H
+#define FGDEFS_H
+
+#define MAX_ENGINES 10
+#define MAX_TANKS 30
+#define GRAVITY 32.174
+#define EARTHRAD 20898908.00 // feet
+#define OMEGAEARTH 7.2685E-3 // rad/sec
+#define EARTHRADSQRD 437882827922500.0
+#define ONESECOND 4.848136811E-6
+#define ECCENT 0.996647186
+#define ECCENTSQRD 0.99330561
+#define INVECCENTSQRD 1.0067395
+#define INVECCENTSQRDM1 0.0067395
+#define EPS 0.081819221
+
+
+/******************************************************************************/
+#endif
--- /dev/null
+/*******************************************************************************
+
+Module: FGMatrix.cpp
+Author: Tony Peden [formatted here by JSB]
+Date started: ??
+Purpose: FGMatrix class
+Called by: Various
+
+FUNCTIONAL DESCRIPTION
+--------------------------------------------------------------------------------
+
+
+ARGUMENTS
+--------------------------------------------------------------------------------
+
+
+HISTORY
+--------------------------------------------------------------------------------
+??/??/?? TP Created
+
+********************************************************************************
+INCLUDES
+*******************************************************************************/
+
+#include <stdlib.h>
+#include "FGMatrix.h"
+#include <iostream.h>
+#include <iomanip.h>
+#include <fstream.h>
+
+/*******************************************************************************
+DEFINES
+*******************************************************************************/
+
+#pragma warn -use
+
+/*******************************************************************************
+CONSTANTS
+*******************************************************************************/
+
+
+/*******************************************************************************
+TYPEDEFS
+*******************************************************************************/
+
+
+/*******************************************************************************
+GLOBALS
+*******************************************************************************/
+
+
+/*******************************************************************************
+************************************ CODE **************************************
+*******************************************************************************/
+
+double** alloc(int rows,int cols)
+{
+ double **A;
+
+ A = new double *[rows+1];
+ if (!A) return NULL;
+
+ for (int i=0;i<=rows;i++){
+ A[i]=new double[cols+1];
+ if (!A[i]) return NULL;
+ }
+ return A;
+}
+
+
+void dealloc(double **A, int rows, int cols)
+{
+ for(int i=0;i<=rows;i++){
+ delete[] A[i];
+ }
+
+ delete[] A;
+}
+
+
+FGMatrix::FGMatrix(unsigned rows, unsigned cols)
+{
+ this->rows=rows;
+ this->cols=cols;
+ keep=false;
+ data=alloc(rows,cols);
+}
+
+
+FGMatrix::FGMatrix(const FGMatrix& A)
+{
+ data=NULL;
+ *this=A;
+}
+
+
+FGMatrix::~FGMatrix(void)
+{
+ if (keep == false) {
+ dealloc(data,rows,cols);
+ rows=cols=0;
+ }
+}
+
+
+FGMatrix& FGMatrix::operator=(const FGMatrix& A)
+{
+ if (&A != this) {
+ if (data != NULL) dealloc(data,rows,cols);
+
+ width = A.width;
+ prec = A.prec;
+ delim = A.delim;
+ origin = A.origin;
+ rows = A.rows;
+ cols = A.cols;
+ keep = false;
+
+ if (A.keep == true) {
+ data = A.data;
+ } else {
+ data = alloc(rows,cols);
+ for (int i=0; i<=rows; i++) {
+ for (int j=0; j<=cols; j++) {
+ data[i][j] = A.data[i][j];
+ }
+ }
+ }
+ }
+ return *this;
+}
+
+
+double& FGMatrix::operator()(unsigned row, unsigned col)
+{
+ return data[row][col];
+}
+
+
+unsigned FGMatrix::Rows(void) const
+{
+ return rows;
+}
+
+
+unsigned FGMatrix::Cols(void) const
+{
+ return cols;
+}
+
+
+void FGMatrix::SetOParams(char delim,int width,int prec,int origin)
+{
+ FGMatrix::delim=delim;
+ FGMatrix::width=width;
+ FGMatrix::prec=prec;
+ FGMatrix::origin=origin;
+}
+
+
+void FGMatrix::InitMatrix(double value)
+{
+ if (data) {
+ for (int i=0;i<=rows;i++) {
+ for (int j=0;j<=cols;j++) {
+ operator()(i,j) = value;
+ }
+ }
+ }
+}
+
+
+void FGMatrix::InitMatrix(void)
+{
+ this->InitMatrix(0);
+}
+
+
+FGMatrix operator-(FGMatrix& A, FGMatrix& B)
+{
+ if ((A.Rows() != B.Rows()) || (A.Cols() != B.Cols())) {
+ cout << endl << "FGMatrix::operator-" << endl << '\t';
+ cout << "Subtraction not defined for matrices of different sizes";
+ cout << endl;
+ exit(1);
+ }
+
+ FGMatrix Diff(A.Rows(),A.Cols());
+ Diff.keep=true;
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ Diff(i,j)=A(i,j)-B(i,j);
+ }
+ }
+ return Diff;
+}
+
+
+void operator-=(FGMatrix &A,FGMatrix &B)
+{
+ if ((A.Rows() != B.Rows()) || (A.Cols() != B.Cols())) {
+ cout << endl << "FGMatrix::operator-" << endl << '\t';
+ cout << "Subtraction not defined for matrices of different sizes";
+ cout << endl;
+ exit(1);
+ }
+
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ A(i,j)-=B(i,j);
+ }
+ }
+}
+
+
+FGMatrix operator+(FGMatrix& A, FGMatrix& B)
+{
+ if ((A.Rows() != B.Rows()) || (A.Cols() != B.Cols())) {
+ cout << endl << "FGMatrix::operator+" << endl << '\t';
+ cout << "Addition not defined for matrices of different sizes";
+ cout << endl;
+ exit(1);
+ }
+
+ FGMatrix Sum(A.Rows(),A.Cols());
+ Sum.keep = true;
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ Sum(i,j)=A(i,j)+B(i,j);
+ }
+ }
+ return Sum;
+}
+
+
+void operator+=(FGMatrix &A,FGMatrix &B)
+{
+ if ((A.Rows() != B.Rows()) || (A.Cols() != B.Cols())) {
+ cout << endl << "FGMatrix::operator+" << endl << '\t';
+ cout << "Addition not defined for matrices of different sizes";
+ cout << endl;
+ exit(1);
+ }
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ A(i,j)+=B(i,j);
+ }
+ }
+}
+
+
+FGMatrix operator*(double scalar,FGMatrix &A)
+{
+ FGMatrix Product(A.Rows(),A.Cols());
+ Product.keep = true;
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ Product(i,j) = scalar*A(i,j);
+ }
+ }
+ return Product;
+}
+
+
+void operator*=(FGMatrix &A,double scalar)
+{
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ A(i,j)*=scalar;
+ }
+ }
+}
+
+
+FGMatrix operator*(FGMatrix &Left, FGMatrix &Right)
+{
+ if (Left.Cols() != Right.Rows()) {
+ cout << endl << "FGMatrix::operator*" << endl << '\t';
+ cout << "The number of rows in the right matrix must match the number";
+ cout << endl << '\t' << "of columns in the left." << endl;
+ cout << '\t' << "Multiplication not defined." << endl;
+ exit(1);
+ }
+
+ FGMatrix Product(Left.Rows(),Right.Cols());
+ Product.keep = true;
+ for (int i=1;i<=Left.Rows();i++) {
+ for (int j=1;j<=Right.Cols();j++) {
+ Product(i,j) = 0;
+ for (int k=1;k<=Left.Cols();k++) {
+ Product(i,j)+=Left(i,k)*Right(k,j);
+ }
+ }
+ }
+ return Product;
+}
+
+
+void operator*=(FGMatrix &Left,FGMatrix &Right)
+{
+ if (Left.Cols() != Right.Rows()) {
+ cout << endl << "FGMatrix::operator*" << endl << '\t';
+ cout << "The number of rows in the right matrix must match the number";
+ cout << endl << '\t' << "of columns in the left." << endl;
+ cout << '\t' << "Multiplication not defined." << endl;
+ exit(1);
+ }
+
+ double **prod;
+
+ prod=alloc(Left.Rows(),Right.Cols());
+ for (int i=1;i<=Left.Rows();i++) {
+ for (int j=1;j<=Right.Cols();j++) {
+ prod[i][j] = 0;
+ for (int k=1;k<=Left.Cols();k++) {
+ prod[i][j]+=Left(i,k)*Right(k,j);
+ }
+ }
+ }
+ dealloc(Left.data,Left.Rows(),Left.Cols());
+ Left.data=prod;
+ Left.cols=Right.cols;
+}
+
+
+FGMatrix operator/(FGMatrix& A, double scalar)
+{
+ FGMatrix Quot(A.Rows(),A.Cols());
+ A.keep = true;
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ Quot(i,j)=A(i,j)/scalar;
+ }
+ }
+ return Quot;
+}
+
+
+void operator/=(FGMatrix &A,double scalar)
+{
+ for (int i=1;i<=A.Rows();i++) {
+ for (int j=1;j<=A.Cols();j++) {
+ A(i,j)/=scalar;
+ }
+ }
+}
+
+
+void FGMatrix::T(void)
+{
+ if (rows==cols)
+ TransposeSquare();
+ else
+ TransposeNonSquare();
+}
+
+
+void FGMatrix::TransposeSquare(void)
+{
+ for (int i=1;i<=rows;i++) {
+ for (int j=i+1;j<=cols;j++) {
+ double tmp=data[i][j];
+ data[i][j]=data[j][i];
+ data[j][i]=tmp;
+ }
+ }
+}
+
+
+void FGMatrix::TransposeNonSquare(void)
+{
+ double **tran;
+
+ tran=alloc(rows,cols);
+ for (int i=1;i<=rows;i++) {
+ for (int j=1;j<=cols;j++) {
+ tran[j][i]=data[i][j];
+ }
+ }
+ dealloc(data,rows,cols);
+
+ data=tran;
+ unsigned m=rows;
+ rows=cols;
+ cols=m;
+}
+
+
+FGColumnVector::FGColumnVector(void):FGMatrix(3,1) { }
+FGColumnVector::FGColumnVector(int m):FGMatrix(m,1) { }
+FGColumnVector::FGColumnVector(FGColumnVector& b):FGMatrix(b) { }
+FGColumnVector::~FGColumnVector() { }
+double& FGColumnVector::operator()(int m)
+{
+ return FGMatrix::operator()(m,1);
+}
+
--- /dev/null
+/*******************************************************************************
+
+Header: FGMatrix.h
+Author: Tony Peden [formatted here by Jon Berndt]
+Date started: Unknown
+
+HISTORY
+--------------------------------------------------------------------------------
+??/??/?? TP Created
+
+/*******************************************************************************
+SENTRY
+*******************************************************************************/
+
+#ifndef FGMATRIX_H
+#define FGMATRIX_H
+
+/*******************************************************************************
+INCLUDES
+*******************************************************************************/
+
+#include <stdlib.h>
+#include <iostream.h>
+#include <fstream.h>
+
+/*******************************************************************************
+DEFINES
+*******************************************************************************/
+
+
+/*******************************************************************************
+CONSTANTS
+*******************************************************************************/
+
+
+/*******************************************************************************
+TYPEDEFS
+*******************************************************************************/
+
+
+/*******************************************************************************
+GLOBALS
+*******************************************************************************/
+
+class FGMatrix
+{
+private:
+ double **data;
+ unsigned rows,cols;
+ bool keep;
+ char delim;
+ int width,prec,origin;
+ void TransposeSquare(void);
+ void TransposeNonSquare(void);
+
+public:
+ FGMatrix(unsigned rows, unsigned cols);
+ FGMatrix(const FGMatrix& A);
+ ~FGMatrix(void);
+
+ FGMatrix& FGMatrix::operator=(const FGMatrix& A);
+ double& FGMatrix::operator()(unsigned row, unsigned col);
+
+ unsigned FGMatrix::Rows(void) const;
+ unsigned FGMatrix::Cols(void) const;
+
+ void FGMatrix::T(void);
+ void InitMatrix(void);
+ void InitMatrix(double value);
+
+ friend FGMatrix operator-(FGMatrix& A, FGMatrix& B);
+ friend FGMatrix operator+(FGMatrix& A, FGMatrix& B);
+ friend FGMatrix operator*(double scalar,FGMatrix& A);
+ friend FGMatrix operator*(FGMatrix& Left, FGMatrix& Right);
+ friend FGMatrix operator/(FGMatrix& A, double scalar);
+
+ friend void operator-=(FGMatrix &A,FGMatrix &B);
+ friend void operator+=(FGMatrix &A,FGMatrix &B);
+ friend void operator*=(FGMatrix &A,FGMatrix &B);
+ friend void operator*=(FGMatrix &A,double scalar);
+ friend void operator/=(FGMatrix &A,double scalar);
+
+ void SetOParams(char delim,int width,int prec, int origin=0);
+};
+
+class FGColumnVector : public FGMatrix
+{
+public:
+ FGColumnVector(void);
+ FGColumnVector(int m);
+ FGColumnVector(FGColumnVector& b);
+ ~FGColumnVector();
+
+ double& operator()(int m);
+};
+
+/******************************************************************************/
+#endif
#include <math.h>
+#include <string>
+
#include "FGState.h"
#include "FGFDMExec.h"
#include "FGAtmosphere.h"
}
-bool FGState::Reset(char* fname)
+bool FGState::Reset(const string& path, const string& fname)
{
- char resetDef[256];
+ string resetDef;
float U, V, W;
float phi, tht, psi;
float alpha, beta, gamma;
float Q0, Q1, Q2, Q3;
float T[4][4];
- sprintf(resetDef, "/h/curt/projects/FlightGear/Simulator/FDM/JSBsim/aircraft/%s/%s", FDMExec->GetAircraft()->GetAircraftName(), fname);
+ resetDef = path;
+ resetDef += "/";
+ resetDef += FDMExec->GetAircraft()->GetAircraftName();
+ resetDef += "/" + fname;
- ifstream resetfile(resetDef);
+ ifstream resetfile( resetDef.c_str() );
if (resetfile) {
resetfile >> U;
#include <stdio.h>
#include <fstream.h>
+#include <string>
#include "FGDefs.h"
/*******************************************************************************
FGState(FGFDMExec*);
~FGState(void);
- bool Reset(char*);
+ bool FGState::Reset(const string& path, const string& fname);
bool StoreData(char*);
bool DumpData(char*);
bool DisplayData(void);
projects / flightgear.git / commitdiff