Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
 
FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen  RegistrierenRegistrieren
ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin
Zur Begleitseite des Forums / Chat / Impressum
Aktueller Forenpartner:

C/CPP nach FB?!

 
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Computer-Forum
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Eternal_pain



Anmeldungsdatum: 08.08.2006
Beiträge: 1783
Wohnort: BW/KA

BeitragVerfasst am: 24.09.2011, 02:07    Titel: C/CPP nach FB?! Antworten mit Zitat

Vorwort:
Bisher hab ich eigentlich immer externe LIB's weitmöglichst vermieden
und verbrachte bisher schon sehr viel Zeit in vergangenen Projekten
damit Funktionen zu schreiben, File Formate und Algorhythmen zu lesen uvm.
was ich mir durch das einfache einbinden einer bereits vorhandenden LIB
eigentlich hätte ersparen können...

Lange rede, gar kein Sinn...
Es gibt für alle möglichen bereiche eine menge bereits bewährter Libs und Engines,
meistens jedoch in und/oder für C/CPP geschrieben...

in meinem Fall möchte ich nun gerne aus der FBGFX ausbrechen und mal in einen anderen
Bereich 'probieren' wo allerdings schon die ersten Probleme auftreten.

Ich lasse mal einige Gründe und Fragen aussen vor und komme gleich zum Kern meines Problems.
Ich möchte Irrlicht benutzen aber nicht auf Gewohnheit, Konfort und angesammelte Erfahrung mit
FreeBASIC verzichten.
(zwar gibt es für Irrlicht einen Wrapper für FreeBASIC, dennoch wiederstrebt es mir eine DLL
zu benutzen um eine DLL anzusprechen... auch wenn dieses schon seine Gründe haben mag auf die
ich hier nicht weiter eingehen möchte)

Aber ob es nun Irrlicht oder irgendeine andere LIB ist spielt hier eigentlich keine Rolle

Ich habe eine SDK und damit die wichtigsten Elemente der LIB
ich habe die DLL und die linker (.a/.lib) und alle notwendingen Header/Include Dateien
welche (und wer hätte es gedacht, hier ist das Problem grinsen) in C/CPP sind.

nun bestehen diese zwar hauptsächlich nur aus Deklarationen, welche teilweise aber doch recht komplex sind

Als bestes Beispiel habe ich hier einmal eine dieser Dateien und komme anschliessend zu den Fragen:
ich habe die kommentare bereits alle FB konform abgeändert für eine bessere übersicht des genzen

vector3d.bi
Code:

'' Copyright (C) 2002-2010 Nikolaus Gebhardt
'' This file is part of the "Irrlicht Engine".
'' For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __IRR_POINT_3D_H_INCLUDED__
#define __IRR_POINT_3D_H_INCLUDED__

#include "irrMath.h"

Namespace irr
'{
Namespace core
'{

   '!' 3d vector template class with lots of operators and methods.
   ''  The vector3d class is used in Irrlicht for three main purposes:
   ''   1) As a direction vector (most of the methods assume this).
   ''   2) As a position in 3d space (which is synonymous with a direction vector from the origin to this position).
   ''   3) To hold three Euler rotations, where X is pitch, Y is yaw and Z is roll.
   
   template <class T>
   class vector3d
   {
   public:
      '!' Default constructor (null vector).
      vector3d() : X(0), Y(0), Z(0) {}
      '!' Constructor with three different values
      vector3d(T nx, T ny, T nz) : X(nx), Y(ny), Z(nz) {}
      '!' Constructor with the same value for all elements
      explicit vector3d(T n) : X(n), Y(n), Z(n) {}
      '!' Copy constructor
      vector3d(const vector3d<T>& other) : X(other.X), Y(other.Y), Z(other.Z) {}

      '' operators

      vector3d<T> operator-() const { return vector3d<T>(-X, -Y, -Z); }

      vector3d<T>& operator=(const vector3d<T>& other) { X = other.X; Y = other.Y; Z = other.Z; return *this; }

      vector3d<T> operator+(const vector3d<T>& other) const { return vector3d<T>(X + other.X, Y + other.Y, Z + other.Z); }
      vector3d<T>& operator+=(const vector3d<T>& other) { X+=other.X; Y+=other.Y; Z+=other.Z; return *this; }
      vector3d<T> operator+(const T val) const { return vector3d<T>(X + val, Y + val, Z + val); }
      vector3d<T>& operator+=(const T val) { X+=val; Y+=val; Z+=val; return *this; }

      vector3d<T> operator-(const vector3d<T>& other) const { return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z); }
      vector3d<T>& operator-=(const vector3d<T>& other) { X-=other.X; Y-=other.Y; Z-=other.Z; return *this; }
      vector3d<T> operator-(const T val) const { return vector3d<T>(X - val, Y - val, Z - val); }
      vector3d<T>& operator-=(const T val) { X-=val; Y-=val; Z-=val; return *this; }

      vector3d<T> operator*(const vector3d<T>& other) const { return vector3d<T>(X * other.X, Y * other.Y, Z * other.Z); }
      vector3d<T>& operator*=(const vector3d<T>& other) { X*=other.X; Y*=other.Y; Z*=other.Z; return *this; }
      vector3d<T> operator*(const T v) const { return vector3d<T>(X * v, Y * v, Z * v); }
      vector3d<T>& operator*=(const T v) { X*=v; Y*=v; Z*=v; return *this; }

      vector3d<T> operator/(const vector3d<T>& other) const { return vector3d<T>(X / other.X, Y / other.Y, Z / other.Z); }
      vector3d<T>& operator/=(const vector3d<T>& other) { X/=other.X; Y/=other.Y; Z/=other.Z; return *this; }
      vector3d<T> operator/(const T v) const { T i=(T)1.0/v; return vector3d<T>(X * i, Y * i, Z * i); }
      vector3d<T>& operator/=(const T v) { T i=(T)1.0/v; X*=i; Y*=i; Z*=i; return *this; }

      '!' sort in order X, Y, Z. Equality with rounding tolerance.
      
        bool operator<=(const vector3d<T>&other) const
      {
         return    (X<other.X || core::equals(X, other.X)) ||
               (core::equals(X, other.X) && (Y<other.Y || core::equals(Y, other.Y))) ||
               (core::equals(X, other.X) && core::equals(Y, other.Y) && (Z<other.Z || core::equals(Z, other.Z)));
      }

      '!' sort in order X, Y, Z. Equality with rounding tolerance.
      
        bool operator>=(const vector3d<T>&other) const
      {
         return    (X>other.X || core::equals(X, other.X)) ||
               (core::equals(X, other.X) && (Y>other.Y || core::equals(Y, other.Y))) ||
               (core::equals(X, other.X) && core::equals(Y, other.Y) && (Z>other.Z || core::equals(Z, other.Z)));
      }

      '!' sort in order X, Y, Z. Difference must be above rounding tolerance.
      
        bool operator<(const vector3d<T>&other) const
      {
         return    (X<other.X && !core::equals(X, other.X)) ||
               (core::equals(X, other.X) && Y<other.Y && !core::equals(Y, other.Y)) ||
               (core::equals(X, other.X) && core::equals(Y, other.Y) && Z<other.Z && !core::equals(Z, other.Z));
      }

      '!' sort in order X, Y, Z. Difference must be above rounding tolerance.
      
        bool operator>(const vector3d<T>&other) const
      {
         return    (X>other.X && !core::equals(X, other.X)) ||
               (core::equals(X, other.X) && Y>other.Y && !core::equals(Y, other.Y)) ||
               (core::equals(X, other.X) && core::equals(Y, other.Y) && Z>other.Z && !core::equals(Z, other.Z));
      }

      '!' use weak float compare
      
        bool operator==(const vector3d<T>& other) const
      {
         return this->equals(other);
      }

      bool operator!=(const vector3d<T>& other) const
      {
         return !this->equals(other);
      }

      '' functions

      '!' returns if this vector equals the other one, taking floating point rounding errors into account
      
        bool equals(const vector3d<T>& other, const T tolerance = (T)ROUNDING_ERROR_f32 ) const
      {
         return core::equals(X, other.X, tolerance) &&
            core::equals(Y, other.Y, tolerance) &&
            core::equals(Z, other.Z, tolerance);
      }

      vector3d<T>& set(const T nx, const T ny, const T nz) {X=nx; Y=ny; Z=nz; return *this;}
      vector3d<T>& set(const vector3d<T>& p) {X=p.X; Y=p.Y; Z=p.Z;return *this;}

      '!' Get length of the vector.
      
        T getLength() const { return core::squareroot( X*X + Y*Y + Z*Z ); }

      '!' Get squared length of the vector.
      ''  This is useful because it is much faster than getLength().
      ''  return Squared length of the vector.
       
      T getLengthSQ() const { return X*X + Y*Y + Z*Z; }

      '!' Get the dot product with another vector.
      
        T dotProduct(const vector3d<T>& other) const
      {
         return X*other.X + Y*other.Y + Z*other.Z;
      }

      '!' Get distance from another point.
      ''  Here, the vector is interpreted as point in 3 dimensional space.
       
      T getDistanceFrom(const vector3d<T>& other) const
      {
         return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z).getLength();
      }

      '!' Returns squared distance from another point.
      ''  Here, the vector is interpreted as point in 3 dimensional space.
       
      T getDistanceFromSQ(const vector3d<T>& other) const
      {
         return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z).getLengthSQ();
      }

      '!' Calculates the cross product with another vector.
      ''  param p Vector to multiply with.
      ''  return Crossproduct of this vector with p.
       
      vector3d<T> crossProduct(const vector3d<T>& p) const
      {
         return vector3d<T>(Y * p.Z - Z * p.Y, Z * p.X - X * p.Z, X * p.Y - Y * p.X);
      }

      '!' Returns if this vector interpreted as a point is on a line between two other points.
      ''  It is assumed that the point is on the line.
      ''  param begin Beginning vector to compare between.
      ''  param end Ending vector to compare between.
      ''  return True if this vector is between begin and end, false if not.
       
      bool isBetweenPoints(const vector3d<T>& begin, const vector3d<T>& end) const
      {
         const T f = (end - begin).getLengthSQ();
         return getDistanceFromSQ(begin) <= f &&
            getDistanceFromSQ(end) <= f;
      }

      '!' Normalizes the vector.
      ''  In case of the 0 vector the result is still 0, otherwise
      ''  the length of the vector will be 1.
      ''  return Reference to this vector after normalization.
       
      vector3d<T>& normalize()
      {
         f64 length = X*X + Y*Y + Z*Z;
         if (core::equals(length, 0.0)) // this check isn't an optimization but prevents getting NAN in the sqrt.
            return *this;
         length = core::reciprocal_squareroot(length);

         X = (T)(X * length);
         Y = (T)(Y * length);
         Z = (T)(Z * length);
         return *this;
      }

      '!' Sets the length of the vector to a new value
      
        vector3d<T>& setLength(T newlength)
      {
         normalize();
         return (*this *= newlength);
      }

      '!' Inverts the vector.
      
        vector3d<T>& invert()
      {
         X *= -1;
         Y *= -1;
         Z *= -1;
         return *this;
      }

      '!' Rotates the vector by a specified number of degrees around the Y axis and the specified center.
      ''  param degrees Number of degrees to rotate around the Y axis.
      ''  param center The center of the rotation.
      
        void rotateXZBy(f64 degrees, const vector3d<T>& center=vector3d<T>())
      {
         degrees *= DEGTORAD64;
         f64 cs = cos(degrees);
         f64 sn = sin(degrees);
         X -= center.X;
         Z -= center.Z;
         set((T)(X*cs - Z*sn), Y, (T)(X*sn + Z*cs));
         X += center.X;
         Z += center.Z;
      }

      '!' Rotates the vector by a specified number of degrees around the Z axis and the specified center.
      ''  param degrees: Number of degrees to rotate around the Z axis.
      ''  param center: The center of the rotation.
       
      void rotateXYBy(f64 degrees, const vector3d<T>& center=vector3d<T>())
      {
         degrees *= DEGTORAD64;
         f64 cs = cos(degrees);
         f64 sn = sin(degrees);
         X -= center.X;
         Y -= center.Y;
         set((T)(X*cs - Y*sn), (T)(X*sn + Y*cs), Z);
         X += center.X;
         Y += center.Y;
      }

      '!' Rotates the vector by a specified number of degrees around the X axis and the specified center.
      ''  param degrees: Number of degrees to rotate around the X axis.
      ''  param center: The center of the rotation.
       
      void rotateYZBy(f64 degrees, const vector3d<T>& center=vector3d<T>())
      {
         degrees *= DEGTORAD64;
         f64 cs = cos(degrees);
         f64 sn = sin(degrees);
         Z -= center.Z;
         Y -= center.Y;
         set(X, (T)(Y*cs - Z*sn), (T)(Y*sn + Z*cs));
         Z += center.Z;
         Y += center.Y;
      }

      '!' Creates an interpolated vector between this vector and another vector.
      ''  param other The other vector to interpolate with.
      ''  param d Interpolation value between 0.0f (all the other vector) and 1.0f (all this vector).
      ''  Note that this is the opposite direction of interpolation to getInterpolated_quadratic()
      ''  return An interpolated vector.  This vector is not modified.
       
      vector3d<T> getInterpolated(const vector3d<T>& other, f64 d) const
      {
         const f64 inv = 1.0 - d;
         return vector3d<T>((T)(other.X*inv + X*d), (T)(other.Y*inv + Y*d), (T)(other.Z*inv + Z*d));
      }

      '!' Creates a quadratically interpolated vector between this and two other vectors.
      ''  param v2 Second vector to interpolate with.
      ''  param v3 Third vector to interpolate with (maximum at 1.0f)
      ''  param d Interpolation value between 0.0f (all this vector) and 1.0f (all the 3rd vector).
      ''  Note that this is the opposite direction of interpolation to getInterpolated() and interpolate()
      ''  return An interpolated vector. This vector is not modified.
       
      vector3d<T> getInterpolated_quadratic(const vector3d<T>& v2, const vector3d<T>& v3, f64 d) const
      {
         // this*(1-d)*(1-d) + 2 * v2 * (1-d) + v3 * d * d;
         const f64 inv = (T) 1.0 - d;
         const f64 mul0 = inv * inv;
         const f64 mul1 = (T) 2.0 * d * inv;
         const f64 mul2 = d * d;

         return vector3d<T> ((T)(X * mul0 + v2.X * mul1 + v3.X * mul2),
               (T)(Y * mul0 + v2.Y * mul1 + v3.Y * mul2),
               (T)(Z * mul0 + v2.Z * mul1 + v3.Z * mul2));
      }

      '!' Sets this vector to the linearly interpolated vector between a and b.
      ''  param a first vector to interpolate with, maximum at 1.0f
      ''  param b second vector to interpolate with, maximum at 0.0f
      ''  param d Interpolation value between 0.0f (all vector b) and 1.0f (all vector a)
      ''  Note that this is the opposite direction of interpolation to getInterpolated_quadratic()

      vector3d<T>& interpolate(const vector3d<T>& a, const vector3d<T>& b, f64 d)
      {
         X = (T)((f64)b.X + ( ( a.X - b.X ) * d ));
         Y = (T)((f64)b.Y + ( ( a.Y - b.Y ) * d ));
         Z = (T)((f64)b.Z + ( ( a.Z - b.Z ) * d ));
         return *this;
      }


      '!' Get the rotations that would make a (0,0,1) direction vector point in the same direction as this direction vector.
      ''  Thanks to Arras on the Irrlicht forums for this method.  This utility method is very useful for
      ''  orienting scene nodes towards specific targets.  For example, if this vector represents the difference
      ''  between two scene nodes, then applying the result of getHorizontalAngle() to one scene node will point
      ''  it at the other one.
      ''
        ''  Example code:
      ''  'Where target and seeker are of type ISceneNode*
      ''  const vector3df toTarget(target->getAbsolutePosition() - seeker->getAbsolutePosition());
      ''  const vector3df requiredRotation = toTarget.getHorizontalAngle();
      ''  seeker->setRotation(requiredRotation);

      ''  'return A rotation vector containing the X (pitch) and Y (raw) rotations (in degrees) that when applied to a
      ''  '+Z (e.g. 0, 0, 1) direction vector would make it point in the same direction as this vector. The Z (roll) rotation
      ''  'is always 0, since two Euler rotations are sufficient to point in any given direction.
      
        vector3d<T> getHorizontalAngle() const
      {
         vector3d<T> angle;

         const f64 tmp = (atan2((f64)X, (f64)Z) * RADTODEG64);
         angle.Y = (T)tmp;

         if (angle.Y < 0)
            angle.Y += 360;
         if (angle.Y >= 360)
            angle.Y -= 360;

         const f64 z1 = core::squareroot(X*X + Z*Z);

         angle.X = (T)(atan2((f64)z1, (f64)Y) * RADTODEG64 - 90.0);

         if (angle.X < 0)
            angle.X += 360;
         if (angle.X >= 360)
            angle.X -= 360;

         return angle;
      }

      '!' Get the spherical coordinate angles
      ''  This returns Euler degrees for the point represented by
      ''  this vector.  The calculation assumes the pole at (0,1,0) and
      ''  returns the angles in X and Y.

      vector3d<T> getSphericalCoordinateAngles()
      {
         vector3d<T> angle;
         const f64 length = X*X + Y*Y + Z*Z;

         if (length)
         {
            if (X!=0)
            {
               angle.Y = (T)(atan2((f64)Z,(f64)X) * RADTODEG64);
            }
            else if (Z<0)
               angle.Y=180;

            angle.X = (T)(acos(Y * core::reciprocal_squareroot(length)) * RADTODEG64);
         }
         return angle;
      }

      '!' Builds a direction vector from (this) rotation vector.
      '' This vector is assumed to be a rotation vector composed of 3 Euler angle rotations, in degrees.
      '' The implementation performs the same calculations as using a matrix to do the rotation.
      ''
        '' param[in] forwards  The direction representing "forwards" which will be rotated by this vector.
      '' If you do not provide a direction, then the +Z axis (0, 0, 1) will be assumed to be forwards.
      '' return A direction vector calculated by rotating the forwards direction by the 3 Euler angles
      '' (in degrees) represented by this vector.
       
      vector3d<T> rotationToDirection(const vector3d<T> & forwards = vector3d<T>(0, 0, 1)) const
      {
         const f64 cr = cos( core::DEGTORAD64 * X );
         const f64 sr = sin( core::DEGTORAD64 * X );
         const f64 cp = cos( core::DEGTORAD64 * Y );
         const f64 sp = sin( core::DEGTORAD64 * Y );
         const f64 cy = cos( core::DEGTORAD64 * Z );
         const f64 sy = sin( core::DEGTORAD64 * Z );

         const f64 srsp = sr*sp;
         const f64 crsp = cr*sp;

         const f64 pseudoMatrix[] = {
            ( cp*cy ), ( cp*sy ), ( -sp ),
            ( srsp*cy-cr*sy ), ( srsp*sy+cr*cy ), ( sr*cp ),
            ( crsp*cy+sr*sy ), ( crsp*sy-sr*cy ), ( cr*cp )};

         return vector3d<T>(
            (T)(forwards.X * pseudoMatrix[0] +
               forwards.Y * pseudoMatrix[3] +
               forwards.Z * pseudoMatrix[6]),
            (T)(forwards.X * pseudoMatrix[1] +
               forwards.Y * pseudoMatrix[4] +
               forwards.Z * pseudoMatrix[7]),
            (T)(forwards.X * pseudoMatrix[2] +
               forwards.Y * pseudoMatrix[5] +
               forwards.Z * pseudoMatrix[8]));
      }

      '!' Fills an array of 4 values with the vector data (usually floats).
      '' Useful for setting in shader constants for example. The fourth value
      '' will always be 0.
      
        void getAs4Values(T* array) const
      {
         array[0] = X;
         array[1] = Y;
         array[2] = Z;
         array[3] = 0;
      }

      '!' X coordinate of the vector
      T X;

      '!' Y coordinate of the vector
      T Y;

      '!' Z coordinate of the vector
      T Z;
   };

   '!' partial specialization for integer vectors
   '' Implementor note: inline keyword needed due to template specialization for s32. Otherwise put specialization into a .cpp
   
    template <>
   inline vector3d<s32> vector3d<s32>::operator /(s32 val) const {return core::vector3d<s32>(X/val,Y/val,Z/val);}
   template <>
   inline vector3d<s32>& vector3d<s32>::operator /=(s32 val) {X/=val;Y/=val;Z/=val; return *this;}

   '!' Typedef for a f32 3d vector.
   typedef vector3d<f32> vector3df;

   '!' Typedef for an integer 3d vector.
   typedef vector3d<s32> vector3di;

   '!' Function multiplying a scalar and a vector component-wise.
   template<class S, class T>
   vector3d<T> operator*(const S scalar, const vector3d<T>& vector) { return vector*scalar; }

End Namespace '} // end namespace core
End NameSpace '} // end namespace irr

#endif


soweit ich das sehe und denke ist das eigentlich nur eine UDT (eine ziemlich grosse happy)
aber schon am anfang, was wie wo warum ist ein Template, warum class und nicht struct
(ist es das gleiche?) ist vector3d<T> ein array?Pointer? (die eckigen klammern verwirren mich happy)
ausserdem sind hier mehrere constructors deklariert... ???

Ich hab mich zwar schon ein wenig umgesehen und eine zwar hilfreiche seite finden können,
aber bei derart komplexen deklarationen ist das auch keine wirkliche hilfe...

http://www.activevb.de/rubriken/kolumne/kol_4/cpptovbtypen.html

Kennt noch wer ein paar gute seiten wie man solche deklarationen FB konform umschreibt?
bzw ist hier jemand in der lage ein paar meiner Fragen zum umschreiben zu beantworten
und evtl. hilfestellung geben kann/könnte?
_________________
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen MSN Messenger
nemored



Anmeldungsdatum: 22.02.2007
Beiträge: 4594
Wohnort: ~/

BeitragVerfasst am: 24.09.2011, 07:17    Titel: Antworten mit Zitat

Zu den Templates und den Spitzklammern kann dir Wikipedia weiterhelfen:
http://de.wikipedia.org/wiki/Template_%28Programmierung%29

Ansonsten muss ich im Großen und Ganzen passen; da erzähle ich lieber nichts als (höchstwahrscheinlich) das falsche. happy
_________________
Deine Chance beträgt 1:1000. Also musst du folgendes tun: Vergiss die 1000 und konzentriere dich auf die 1.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
E-P-S



Anmeldungsdatum: 16.09.2004
Beiträge: 500
Wohnort: Neuruppin

BeitragVerfasst am: 24.09.2011, 08:08    Titel: Antworten mit Zitat

Hi, ich versuch mal mit meinem geballten halbwissen ein wenig zu helfen (ich hoffe das ich nicht nur Stuss erzähle).

Vor langer Zeit hab ich an einem ähnlichen Problem gesessen als ich die API von trueSpace nach FB portiert hab. Automatisiert kam da ebenfalls nur Unsinn raus - also per Hand - und da stiess ich auf ähnlich "komische" Strukturen, Types, Operatoren etc.

Die exakten Terminies sind mir nicht bekannt, und war mir damals wie heute auch nicht wichtig. Ich wollte nur das es funktioniert - und das tut es bei mir.

Los gehts. Die Vermutung das es sich um ein (großes) UDT handelt kann ich bestätigen.

Im Prinzip sind hier Funktionen, Operatoren usw. beschrieben die 4 Grundsätzliche Struktur Typen behandeln.

Der Grundtyp - Construktor - ist als vector3d() definiert. Er hat 3 Parameter: X,Y,Z die immer 0 sind. Man kann also einfach vector3d() angeben anstatt sozusagen vector3d(0,0,0) zu schreiben.

Code:
public:
      '!' Default constructor (null vector).
      vector3d() : X(0), Y(0), Z(0) {}


Der zweite heißt ebenfalls vector3d, hat aber 3 verschiedene Werte als Parameter: X,Y,Z.

Code:
'!' Constructor with three different values
      vector3d(T nx, T ny, T nz) : X(nx), Y(ny), Z(nz) {}


Nummer 3 ist vector3d() mit nur einem Parameter die X,Y,Z entsprechen wenn diese 3 gleich sind. Also z.B. vector3d(2,2,2)
Code:
'!' Constructor with the same value for all elements
      explicit vector3d(T n) : X(n), Y(n), Z(n) {}


Der vierte im Bunde ist ein Copy Construktor der, so wie ich das verstehe, den eigentlichen vector als Kopie enthält - kapier ich ehrlich gesagt auch nicht ganz.

So, für jede dieser "Variationen" ein und derselben Struktur gibt es nun zunächst mal Operatoren die es erlauben + - = < > usw. durchzuführen.

So wie man in FB "A + B" rechnen kann, legt man hier die Operationen für den neuen Variablentyp vector3d fest.

Picken wir uns mal den ersten raus:
Code:
'' operators
      vector3d<T> operator-() const { return vector3d<T>(-X, -Y, -Z); }


Hier wird der Operator MINUS festgelegt, welcher besagt das aus X,Y und Z jeweils -X, -Y und -Z zu machen sind. Auf unser A+B Beispiel angewand ist dies also da brauchbar wo man im Code später einfach einen negativen Vektor benötigt, so wie man manchmal C = A * -B benötigt.

Kommen wir zum <T>

Da wir ja nicht nur eine Variante an Parametern für vector3d haben, sondern wie oben erklärt mehrere, steht das <T> sozusagen als platzhalter für eine der 3 möglichen Varianten, oder anders gesagt es steht als Platzhalter für die Construktoren.

Nach all den Construktoren und Operatoren folgen dann noch verschiedene Funktionen die man mit dem vector so anstellen kann...

Das wichtigste ist natürlich: Wie sieht das ganz korrekt in FB aus...

Nun die schlechte Nachricht: Ich hab keine Ahnung - jedenfalls nicht konkret. Ich könnte das jetzt auch nicht AdHook übersetzen so das es läuft - sorry. Ich hoffe aber das ich trotzdem etwas helfen konnte.
_________________
Man kann sich öfter als zweimal im Leben halb tot lachen.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
MOD
Fleißiger Referenzredakteur


Anmeldungsdatum: 10.09.2007
Beiträge: 1003

BeitragVerfasst am: 24.09.2011, 11:08    Titel: Antworten mit Zitat

Nun, das wird so nicht gehen. Irrlicht ist eine C++-Lib, wie man am Code gut erkennen kann und C++ ist (noch) nicht mit FB kompatibel, so wie es bei C ist. Darum braucht man für sowas auch einen Wrapper.

Das <T> ist ein Platzhalter für den Datentyp und die ganze Klasse damit ein Template. Das <T> wird dann einfach bei der Deklaration mit dem Typen ersetzt, den man möchte. Sowas gibt es in FB nicht, lösbar nur mit Makros ober Überladung für sämtliche Typen. Für die Lib nutzt das aber nichts.

Was die Überladung der Operatoren angeht, da haben wir im Portal ein Tutorial.

Aber wie gesagt, das wird mit allerhöchster Wahrscheinlichkeit nicht laufen. Nimm den Wrapper (der umhüllt die C++-Eigenschaften in einfache C-Funktionen, die mit FB kompatibel sind).
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Eternal_pain



Anmeldungsdatum: 08.08.2006
Beiträge: 1783
Wohnort: BW/KA

BeitragVerfasst am: 24.09.2011, 21:04    Titel: Antworten mit Zitat

nemored hat Folgendes geschrieben:

Zu den Templates und den Spitzklammern kann dir Wikipedia weiterhelfen:
http://de.wikipedia.org/wiki/Template_%28Programmierung%29

Ansonsten muss ich im Großen und Ganzen passen; da erzähle ich lieber nichts als (höchstwahrscheinlich) das falsche. happy
...

Eine grosse Hilfe war die Erklärung leider nicht, im gegenteil hat mich das Template nur sehr verwirrt grinsen
Überladung, Vererbung usw... das ganze entwickelt sich zu einem Studium happy



E-P-S hat Folgendes geschrieben:

Hi, ich versuch mal mit meinem geballten halbwissen ein wenig zu helfen (ich hoffe das ich nicht nur Stuss erzähle).

Vor langer Zeit hab ich an einem ähnlichen Problem gesessen als ich die API von trueSpace nach FB portiert hab. Automatisiert kam da ebenfalls nur Unsinn raus - also per Hand - und da stiess ich auf ähnlich "komische" Strukturen, Types, Operatoren etc.

Die exakten Terminies sind mir nicht bekannt, und war mir damals wie heute auch nicht wichtig. Ich wollte nur das es funktioniert - und das tut es bei mir.
...

Im grunde bestätigt das gröstenteils meine Annahme, allerdings ist mir hier noch vieles unklar:
vector3d ist das eigentliche UDT? mit den Records X,Y und Z? aber welchen Typs?
diese Constructor überladungen... im groben müsste es so aussehen wenn nicht alles falsch ist?!

grobes (experimentelles) Beispiel:
Code:

Type vector3d
   X as Single
   Y as Single
   Z as Single
   '!' Default constructor (null vector).
   Declare Constructor
   '!' Constructor with three different values
   Declare Constructor(nX as Single, nY as Single, nZ as Single)
   '!' Constructor with the same value for all elements
   Declare Constructor(n as Single)

   'operators
   Declare   Operator - (n as vector3d) as vector3d
End Type


FBC hat Folgendes geschrieben:
E:\FreeBASIC\FBIDETEMP.bas(13) error 142: Operator cannot be a member function (TODO), before '(' in 'Declare Operator - (n as vector3d) as vector3d'





MOD hat Folgendes geschrieben:

Nun, das wird so nicht gehen. Irrlicht ist eine C++-Lib, wie man am Code gut erkennen kann und C++ ist (noch) nicht mit FB kompatibel, so wie es bei C ist. Darum braucht man für sowas auch einen Wrapper.

Das <T> ist ein Platzhalter für den Datentyp und die ganze Klasse damit ein Template. Das <T> wird dann einfach bei der Deklaration mit dem Typen ersetzt, den man möchte. Sowas gibt es in FB nicht, lösbar nur mit Makros ober Überladung für sämtliche Typen. Für die Lib nutzt das aber nichts.
...


Das ganze scheint mir wirklich mehr als kompliziert zu werden und klingt auch nicht sehr zuversichtlich,
obwohl ich meine das es so gehen 'könnte' oder eigentlich sogar sollte, sofern die deklarationen FB typisch angepasst werden...
Zum experimentieren ist Irrlicht jetzt aber nicht gerade 'klein' es sind immerhin 177 Header die es dann
zu übersetzen gäbe...
Wäre es sicher das es dann laufen würde, wäre ich (hoffentlich mit etwas hilfe) ja bereit die Zeit und Arbeit
darin zu investieren, um Irrlicht nativ in FreeBASIC einzubinden...
_________________
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen MSN Messenger
nemored



Anmeldungsdatum: 22.02.2007
Beiträge: 4594
Wohnort: ~/

BeitragVerfasst am: 24.09.2011, 21:11    Titel: Antworten mit Zitat

Code:
vector3d ist das eigentliche UDT? mit den Records X,Y und Z? aber welchen Typs?

So wie ich das sehe, vom Typ T. Darum geht es ja gerade bei Templates, dass sie für mehrere Typen einsetzbar sind.
_________________
Deine Chance beträgt 1:1000. Also musst du folgendes tun: Vergiss die 1000 und konzentriere dich auf die 1.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Eternal_pain



Anmeldungsdatum: 08.08.2006
Beiträge: 1783
Wohnort: BW/KA

BeitragVerfasst am: 24.09.2011, 23:43    Titel: Antworten mit Zitat

hmm.. ok, das kann man so wohl nicht wirklich in FB umsetzen,
jedoch lässt sich mit Metabefehlen da evtl noch was machen?!

Theoretisch könnte man das Template aber doch eigentlich ignorieren und
T einfach einen Variablentyp geben?!

Hab das ganze bis hier mal probiert... sollte soweit ja gehen, jedoch
wie man an den vielen ausgeklammerten declarationen erkennt, gibts hier noch einige probleme bei der umsetzung der Operator?!
so weit wie ich nu bin, ging das umsetzen noch halbwegs...
ab da aber wirds kompliziert...


Code:
Type bool as long
Type T as Double

Type vector3d
   X as T
   Y as T
   Z as T
   '!' Default constructor (null vector).
   Declare Constructor
   '!' Constructor with three different values
   Declare Constructor(nX as T, nY as T, nZ as T)
   '!' Constructor with the same value for all elements
   Declare Constructor(n as T)
    '!' Copy constructor
    Declare Constructor(other as vector3d)
   
    '   operators

'?  'vector3d<T> operator-() const { return vector3d<T>(-X, -Y, -Z); }
'?  'Declare Operator -()

'!  'Operator cannot be a member function (TODO)
'!  'Declare Operator = (other as vector3d)
   
    Declare Operator += (other as vector3d)       

'?  'vector3d<T> operator+(const T val) const { return vector3d<T>(X + val, Y + val, Z + val); }
'?  'Declare Operator + (val as T)

'?  'vector3d<T>& operator+=(const T val) { X+=val; Y+=val; Z+=val; return *this; }
'?  'Declare Operator += (val as T)

'?  'vector3d<T> operator-(const vector3d<T>& other) const { return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z); }
'?  'Declare Operator - (other as vector3d)

    Declare Operator -= (other as vector3d)

'?  'vector3d<T> operator-(const T val) const { return vector3d<T>(X - val, Y - val, Z - val); }     
'?  'Declare Operator - (val as T)

'?  'vector3d<T>& operator-=(const T val) { X-=val; Y-=val; Z-=val; return *this; }
'?  'Declare Operator -= (val as T)

'?  'vector3d<T> operator*(const vector3d<T>& other) const { return vector3d<T>(X * other.X, Y * other.Y, Z * other.Z); }
'?  'Declare Operator * (other as vector3d)
     
    Declare Operator *= (other as vector3d)
   
'?  'vector3d<T> operator*(const T v) const { return vector3d<T>(X * v, Y * v, Z * v); }
'?  'Declare Operator * (v as T)

    Declare Operator *= (v as T)

'?  'vector3d<T> operator/(const vector3d<T>& other) const { return vector3d<T>(X / other.X, Y / other.Y, Z / other.Z); }
'?  'Declare Operator / (other as vector3d)

    Declare Operator /= (other as vector3d)
   
'?  'vector3d<T> operator/(const T v) const { T i=(T)1.0/v; return vector3d<T>(X * i, Y * i, Z * i); }     
'?  'Declare Operator / (v as T)

    'vector3d<T>& operator/=(const T v) { T i=(T)1.0/v; X*=i; Y*=i; Z*=i; return *this; }
    Declare Operator /= (v as T) '??

    '!' sort in order X, Y, Z. Equality with rounding tolerance.
       
'!  'Operator cannot be a member function (TODO)
'!  'bool operator<=(const vector3d<T>&other) const
'!  Declare Operator <= (other as vector3d) as bool
   
'...
 '...
  '...   
End Type

'!  'Operator cannot be a member function (TODO)
'Operator.vecor3d.<= (other as vector3d) as bool
'      {
'         return    (X<other.X || core::equals(X, other.X)) ||
'               (core::equals(X, other.X) && (Y<other.Y || core::equals(Y, other.Y))) ||
'               (core::equals(X, other.X) && core::equals(Y, other.Y) && (Z<other.Z || core::equals(Z, other.Z)));
'      }     
'End Operator

Operator.vector3d./= (v as T)
    Dim i as T '??
    i=1.0/v    '??
   
    this.X*=i
    this.Y*=i
    this.Z*=i
End Operator

'Operator.vector3d./ (v as T)
'?  'vector3d<T> operator/(const T v) const { T i=(T)1.0/v; return vector3d<T>(X * i, Y * i, Z * i); }     
'End Operator

Operator.vector3d./= (other as vector3d)
    this.X/=other.X
    this.Y/=other.Y
    this.Z/=other.Z
End Operator

'Operator.vector3d./ (other as vector3d)
'?  'vector3d<T> operator/(const vector3d<T>& other) const { return vector3d<T>(X / other.X, Y / other.Y, Z / other.Z); }
'End Operator

Operator.vector3d.*= (v as T)
    this.X*=v
    this.Y*=v
    this.Z*=v
End Operator

'Operator.vector3d.* (v as T)
'?  'vector3d<T> operator*(const T v) const { return vector3d<T>(X * v, Y * v, Z * v); }
'End Operator

Operator.vector3d.*= (other as vector3d)
    this.X*=other.X
    this.Y*=other.Y
    this.Z*=other.Z
End Operator
   
'Operator.vector3d.* (other as vector3d)
'?  'vector3d<T> operator*(const vector3d<T>& other) const { return vector3d<T>(X * other.X, Y * other.Y, Z * other.Z); }
'End vector3d

'Operator.vector3d.-= (val as T)
'?  'vector3d<T>& operator-=(const T val) { X-=val; Y-=val; Z-=val; return *this; }
'End Operator

'Operator.vector3d.- (val as T)
'?  vector3d<T> operator-(const T val) const { return vector3d<T>(X - val, Y - val, Z - val); }     
'End Operator

Operator.vector3d.-= (other as vector3d)
    this.X-=other.X
    this.Y-=other.Y
    this.Z-=other.Z
End Operator

'Operator.vector3d.- (other as vector3d)
'?  'vector3d<T> operator-(const vector3d<T>& other) const { return vector3d<T>(X - other.X, Y - other.Y, Z - other.Z); }     
'End Operator

'Operator.vector3d.+=(val as T)
'?  'vector3d<T>& operator+=(const T val) { X+=val; Y+=val; Z+=val; return *this; }
'End Operator

'Operator.vector3d.+ (val as T)
'?  'vector3d<T> operator+(const T val) const { return vector3d<T>(X + val, Y + val, Z + val); }
'End Operator

Operator.vector3d.+= (other as vector3d)
    this.X+=other.X
    this.Y+=other.Y
    this.Z+=other.Z
End Operator
   
'!  'Operator cannot be a member function (TODO)
'Operator.vector3d.= (other as vector3d)
'    this.X=other.X
'    this.Y=other.Y
'    this.Z=other.Z
'End Operator

'Operator.vector3d.-()
'?  'vector3d<T> operator-() const { return vector3d<T>(-X, -Y, -Z); }
'End Operator

Constructor.vector3d
    This.X = 0
    This.Y = 0
    This.Z = 0
end Constructor

Constructor.vector3d(n as T)
    This.X = n
    This.Y = n
    This.Z = n
end Constructor

Constructor.vector3d(nX as T, nY as T, nZ as T)
    This.X = nX
    This.Y = nY
    This.Z = nZ
end Constructor

Constructor.vector3d(other as vector3D)
    This.X=other.X
    This.Y=other.Y
    This.Z=other.Z
end Constructor
   



EDIT:

Bei diesen Teil hier:
Code:

        bool operator<=(const vector3d<T>&other) const
      {
         return    (X<other.X || core::equals(X, other.X)) ||
               (core::equals(X, other.X) && (Y<other.Y || core::equals(Y, other.Y))) ||
               (core::equals(X, other.X) && core::equals(Y, other.Y) && (Z<other.Z || core::equals(Z, other.Z)));
      }


find ich besonders den Teil verwirrend
Code:
core::

den ich einfach 'ignoriert' habe

umgesetzt habe ich es erst einmal so,
allerdings soll dieser Operator soweit und wenn
ich das richtig verstehe nur True oder False
zurückgeben, beim testen kommen allerdings
recht abstrakte Werte heraus:
Code:

Operator.vecor3d.<= (other as vector3d) as bool
    return _
    (this.X<other.X or (this.X EQV other.X)) or _
    ((this.X EQV other.X) and (this.Y<other.Y or (this.Y EQV other.Y))) or _
    ((this.X EQV other.Y) and (this.Y EQV other.Y) and (this.Z<other.Z or (this.Z EQV other.Z)))
End Operator

_________________
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen MSN Messenger
Jojo
alter Rang


Anmeldungsdatum: 12.02.2005
Beiträge: 9736
Wohnort: Neben der Festplatte

BeitragVerfasst am: 25.09.2011, 01:28    Titel: Antworten mit Zitat

core:: ist entweder ein namespace oder der bezeichner nach core:: ist ein statisches element einer klasse namens core. core::equals ist vermutlich ein byteweiser vergleich zweier objekte, ich vermute mal dass EQV in FB nicht dasselbe tut. in FB wäre entweder normale gleichheit oder memcmp zu verwenden.

Zitat:
Theoretisch könnte man das Template aber doch eigentlich ignorieren und
T einfach einen Variablentyp geben?!

Wenn du die vektor-klasse für jeden datentyp neu implementieren willst... ja. Spätestens hier solltest du merken wie toll templates sind. Zunge rausstrecken
_________________
» Die Mathematik wurde geschaffen, um Probleme zu lösen, die es nicht gäbe, wenn die Mathematik nicht erschaffen worden wäre.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Eternal_pain



Anmeldungsdatum: 08.08.2006
Beiträge: 1783
Wohnort: BW/KA

BeitragVerfasst am: 25.09.2011, 01:51    Titel: Antworten mit Zitat

zum thema equals hab ich das beispiel gefunden,
aber verstehen tu ich es eigentlich nicht...
beide variablen enthalten den selben text,
daher wundere ich mich eben darüber warum
in diesem beispiel mit equal true ergibt und mit == false

Code:

String strA;  // erstes Objekt
String strB;  // zweites Objekt

strA   = new String( "Der Gingham Hund" );
strB   = new String( "Der Gingham Hund" );

if ( strA.equals( strB  )  )
  System.out.println( "Dies WIRD ausgegeben.");

if ( strA == strB )
  System.out.println( "Dies wird NICHT ausgegeben.");


irgendwie vergleicht er da wohl den speicherplatz/bereich??

aber in dem beispiel oben ergibt das mit dem speicher keinen sinn für mich,
tendiere daher zu einem normalen 'ist gleich'...

core ist wirklich ein namespace, verstehe nur nicht warum dieser hier explizit
angegeben und eingesetzt ist...

hm.. das mit den templates erscheint praktisch aber erschliesst es sich mir
noch nicht ganz... im prinzip wäre es damit getan würde man T als datentyp
'any' deklarieren, nur geht das leider nicht... weiss aber auch nicht wie
sich sowas anders lösen lässt?!
_________________
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen MSN Messenger
nemored



Anmeldungsdatum: 22.02.2007
Beiträge: 4594
Wohnort: ~/

BeitragVerfasst am: 25.09.2011, 08:40    Titel: Antworten mit Zitat

ANY ist nicht so ganz dasselbe - das würde bedeuten, dass in vector3d(x, y, z) jede Variable jeden beliebigen Datentyp annehmen kann; hier müssen aber x, y und z immer vom gleichen Datentyp sein. Es geht also nicht x AS INTEGER, y AS DOUBLE, z AS myOwnUdt oder so etwas.
_________________
Deine Chance beträgt 1:1000. Also musst du folgendes tun: Vergiss die 1000 und konzentriere dich auf die 1.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
MOD
Fleißiger Referenzredakteur


Anmeldungsdatum: 10.09.2007
Beiträge: 1003

BeitragVerfasst am: 25.09.2011, 10:49    Titel: Antworten mit Zitat

Mein letzter Post wurde wohl nicht ordentlich gelesen, oder zumindest nicht die verlinkte Seite. Dort wird nämlich erklärt, warum das mit den Operatoren nicht läuft.

Zu der Makroumsetzung von Templates. Es ist möglich, aber nicht halb so schön wie in C++. Ein Beispielcode:
Code:
#Macro vectorDummy(T)
   #Ifndef vector##T
      Type vector##T
         As T X, Y, Z
      End Type
   #EndIf
#EndMacro


vectorDummy(Integer)
Dim As vectorInteger meinVector1
meinVector1.X = 5

vectorDummy(String)
Dim As vectorString meinVector2
meinVector2.X = "Hallo"

Print meinVector1.X
Print meinVector2.X

Sleep
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Jojo
alter Rang


Anmeldungsdatum: 12.02.2005
Beiträge: 9736
Wohnort: Neben der Festplatte

BeitragVerfasst am: 25.09.2011, 15:23    Titel: Antworten mit Zitat

Eternal_pain hat Folgendes geschrieben:
zum thema equals hab ich das beispiel gefunden,
aber verstehen tu ich es eigentlich nicht...
beide variablen enthalten den selben text,
daher wundere ich mich eben darüber warum
in diesem beispiel mit equal true ergibt und mit == false


"Gleichheit" kann man beliebig definieren, d.h. core::equals könnte etwas ganz anderes tun als die für Integer/Float-Variablen bekannte gleichheit - Beispielsweise könnte das Vorzeichen ignoriert werden, irgendwelche Vektoren könnten normalisiert werden, was auch immer.
_________________
» Die Mathematik wurde geschaffen, um Probleme zu lösen, die es nicht gäbe, wenn die Mathematik nicht erschaffen worden wäre.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Lutz Ifer
Grillmeister


Anmeldungsdatum: 23.09.2005
Beiträge: 555

BeitragVerfasst am: 25.09.2011, 15:55    Titel: Antworten mit Zitat

@Eternal_pain:

In Java gilt:
"=" prüft auf Identität => das selbe Objekt wird von zwei Variablen referenziert.
"equals" auf Gleicheit => zwei Objekte enthalten die gleichen Daten.
_________________
Wahnsinn ist nur die Antwort einer gesunden Psyche auf eine kranke Gesellschaft.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
dreael
Administrator


Anmeldungsdatum: 10.09.2004
Beiträge: 2507
Wohnort: Hofen SH (Schweiz)

BeitragVerfasst am: 25.09.2011, 18:27    Titel: Antworten mit Zitat

Das hier gezeigte C++-Beispiel wendet halt viele Sparchkonzepte an, welche FreeBasic überhaupt nicht in dieser Form kennt. Templates machen typischerweise in Sortierroutinen Sinn, damit Du nicht für Integer, Strings usw. eigene Versionen erstellen musst, sondern hier ist der Datentyp gegenüber der Sortierklasse abstrakt; kann dann jeden beliebigen Typ sein, als Programmierer der Sortierklasse schreibst Du lediglich vor, dass z.B. ein "<"-Operator vorhanden sein muss, welcher a<b und b<c => a<c für jedes beliebige a,b,c erfüllt.
_________________
Teste die PC-Sicherheit mit www.sec-check.net
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
Jojo
alter Rang


Anmeldungsdatum: 12.02.2005
Beiträge: 9736
Wohnort: Neben der Festplatte

BeitragVerfasst am: 25.09.2011, 21:10    Titel: Antworten mit Zitat

dreael hat Folgendes geschrieben:
Templates machen typischerweise in Sortierroutinen Sinn

Ergänzen wir das mal am besten auf Algorithmen im Allgemeinen, und zudem noch (wie in diesem Beispiel) Containerklassen.
_________________
» Die Mathematik wurde geschaffen, um Probleme zu lösen, die es nicht gäbe, wenn die Mathematik nicht erschaffen worden wäre.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Eternal_pain



Anmeldungsdatum: 08.08.2006
Beiträge: 1783
Wohnort: BW/KA

BeitragVerfasst am: 25.09.2011, 23:30    Titel: Antworten mit Zitat

Jetzt verstehe ich endlich den Sinn und zweck eines Templates grinsen
So etwas hätte ich mir in FB bei früheren Projekten zB mit BubbleSort auch gewünscht, da dieser je nach zu sortierenden Datentyp immer wieder neu angepasst werden muss, wenn ich pointer, strings oder einfache integer arrays sortieren wollte...

Somit erkenne ich jetzt auch besser das eigentliche Problem dahinter.

@MOD gelesen habe ich es schon das tutorial, jedenfalls teilweise,
ich bin der Sache nur Langsam angegangen da ich ehrlich gesagt noch nie mit operatoren gearbeitet habe und diese für mich eigentlich neuland sind.
Verstanden habe ich mehr oder weniger schon das in FB einige nicht so
eingesetzt werden können wie in diesem Beispiel, allerdings aber auch noch nicht genau warum... werd mich bei gelegenheit aber eingehender damit beschaeftigen, scheint mir doch recht nützlich zu sein.

hmm.. ich denke, aufgrund mangelder erfahrung und verstaendnis für C und CPP und vorallem der in dem Beispiel auftretenden 'Besonderheiten'
müsste man wohl sagen das es nahezu unmöglich ist den bzw solche Header in FB zu übersetzen?
Jedenfalls denke ich das ich an dieser stelle erst einmal 'aufgebe'
(wäre es nur dieser eine Header würde ich evtl noch nach lösungen suchen, aber bei 177 die teilweise ähnlich aufgebaut sind, wäre mir das eindeutig zuviel arbeit nur zum 'Testen')

Immerhin habe ich dadurch wieder das eine oder andere neue sowohl für FB als und mit C/CPP gelernt...

Mal sehen was es mir nutzt zwinkern

Notfalls bleibt mir immernoch der existierende Wrapper (auch wenn es mir immernoch wiederstrebt eine DLL für eine DLL zu nutzen grinsen)

Irrlicht fand ich deswegen toll da es relativ leicht zu benutzen ist,
OpenGL sowie DirectX als auch einen eigenen Sofware Renderer
ansprechen kann was mich in sachen flexibilität sehr angesprochen hat.

Wie dem auch sei, ich habe erst einmal angefangen mich durch die OpenGL Tutorials zu lesen (Stormy's OGL 2D Tut, NeHe (Deutsche übersetzungen) und Eastler_dart's Einführung auf FBP)

Was mich allerdings jetzt schon verstört ist das es im prinzip keine 'Kamera' gibt und man Die Welt/Objekte alle drehen und verschieben muss...
_________________
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen MSN Messenger
28398



Anmeldungsdatum: 25.04.2008
Beiträge: 1917

BeitragVerfasst am: 26.09.2011, 20:36    Titel: Antworten mit Zitat

Eternal_pain hat Folgendes geschrieben:
hmm.. ich denke, aufgrund mangelder erfahrung und verstaendnis für C und CPP und vorallem der in dem Beispiel auftretenden 'Besonderheiten'
müsste man wohl sagen das es nahezu unmöglich ist den bzw solche Header in FB zu übersetzen?
Es ist gar nicht übersetzbar. Deswegen brauch man ja auch den Wrapper, der in C++ die C++ Objekte auf C Funktionen abbildet, die dann von Freebasic aus benutzt werden können.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
MOD
Fleißiger Referenzredakteur


Anmeldungsdatum: 10.09.2007
Beiträge: 1003

BeitragVerfasst am: 26.09.2011, 21:22    Titel: Antworten mit Zitat

Es scheint möglich zu sein, einige C++-Features in FB zu nutzen. Stueber hat mal Teile von Qt zum Laufen gebracht - ohne Wrapper. Allerdings sah das nicht besonders schön aus. Solange FB das nicht von Haus aus liefert, sollte man Wrapper bevorzugen.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
28398



Anmeldungsdatum: 25.04.2008
Beiträge: 1917

BeitragVerfasst am: 27.09.2011, 16:06    Titel: Antworten mit Zitat

MOD hat Folgendes geschrieben:
Es scheint möglich zu sein, einige C++-Features in FB zu nutzen. Stueber hat mal Teile von Qt zum Laufen gebracht - ohne Wrapper. Allerdings sah das nicht besonders schön aus. Solange FB das nicht von Haus aus liefert, sollte man Wrapper bevorzugen.

Klaro kann man sich quasi einen ABI-Wrapper zurechtbasteln. Das ist aber weder schön, noch portabel. Und überhaupt nicht aufwendig zwinkern
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Computer-Forum Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.

 Impressum :: Datenschutz