Fehler behoben

DX12PixelShader.h

@@ -92,10 +92,10 @@ ret
 
 const BYTE DX12PixelShaderBytes[] =
 {
-     68,  88,  66,  67,  13,  29, 
-     88,  39,   8, 241, 156, 214, 
-    171,  72, 142, 140, 103, 136, 
-    131, 224,   1,   0,   0,   0, 
+     68,  88,  66,  67,  49,  41, 
+    207,  98, 201, 181,   2,  86, 
+    254, 110, 180,  23, 127,   2, 
+    129, 138,   1,   0,   0,   0, 
     184,  91,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
      36,   2,   0,   0, 188,   2, 
@@ -763,11 +763,11 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0, 148,  46, 
-     49,   1, 113, 112, 171,  92, 
-      1,   0,   0,   0, 243, 251, 
-    139,  67, 225,  65, 221,  72, 
-    137, 122,  55, 133, 103, 113, 
-     68, 209,   0,   0,   0,   0, 
+     49,   1, 246, 194, 176,  92, 
+      1,   0,   0,   0, 225,  75, 
+     84, 198, 211,  78, 149,  66, 
+    162,  62, 136,  56, 183,   0, 
+     40,  32,   0,   0,   0,   0, 
       0,   0,   0,   0,   1,   0, 
       0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1788,7 +1788,7 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  27, 226, 
      48,   1, 128,   0,   0,   0, 
-     24, 215,  50,  98,  36, 238, 
+     32, 111,  88, 130,  80, 241, 
     212,   1,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3427,7 +3427,7 @@ const BYTE DX12PixelShaderBytes[] =
       2,   0,   9,   0, 220,   4, 
       0,   0,   0,   0,   0,   0, 
     156,   1,   0,   0,   1,   0, 
-      0,   0,  64, 122, 129,   3, 
+      0,   0,  96, 121, 146,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0, 109,  97, 105, 110, 
       0, 110, 111, 110, 101,   0, 
@@ -3494,10 +3494,10 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0, 148,  46,  49,   1, 
-    113, 112, 171,  92,   1,   0, 
-      0,   0, 243, 251, 139,  67, 
-    225,  65, 221,  72, 137, 122, 
-     55, 133, 103, 113,  68, 209, 
+    246, 194, 176,  92,   1,   0, 
+      0,   0, 225,  75,  84, 198, 
+    211,  78, 149,  66, 162,  62, 
+    136,  56, 183,   0,  40,  32, 
     137,   0,   0,   0,  47,  76, 
     105, 110, 107,  73, 110, 102, 
     111,   0,  47, 110,  97, 109, 

DX12VertexShader.h

@@ -129,10 +129,10 @@ ret
 
 const BYTE DX12VertexShaderBytes[] =
 {
-     68,  88,  66,  67, 155, 183, 
-    187,  94, 251, 255, 190, 203, 
-    217, 216, 170, 211,  12, 141, 
-    226,  27,   1,   0,   0,   0, 
+     68,  88,  66,  67,   8, 152, 
+    110, 229,  23,  54,  59, 238, 
+    177,  79, 105,  85,  56, 233, 
+    179, 195,   1,   0,   0,   0, 
     108,  78,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
     124,   2,   0,   0,  16,   3, 
@@ -915,11 +915,11 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    148,  46,  49,   1, 113, 112, 
-    171,  92,   1,   0,   0,   0, 
-     97, 164,  63,  33,  48,  11, 
-     72,  79, 160, 116, 254,  49, 
-     34, 234,  47,  36,   0,   0, 
+    148,  46,  49,   1, 247, 194, 
+    176,  92,   1,   0,   0,   0, 
+    158,   6, 144, 237, 203,  63, 
+    114,  73, 163, 205,  90, 235, 
+    127, 218, 240, 121,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       1,   0,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1095,7 +1095,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0, 103, 159,   1,   0, 
     179, 120,   1,   0, 238,  97, 
       2,   0,  90,  28,   0,   0, 
-     30, 255,   1,   0,  53, 174, 
+    251,  52,   0,   0,  53, 174, 
       3,   0, 206,  21,   0,   0, 
     193, 205,   3,   0, 207, 193, 
       1,   0,  62,   3,   3,   0, 
@@ -1684,8 +1684,8 @@ const BYTE DX12VertexShaderBytes[] =
     111, 110,  59,  13,  10, 125, 
      59,  13,  10,  13,  10,  47, 
      27, 226,  48,   1, 128,   0, 
-      0,   0, 120, 232, 107,  98, 
-     36, 238, 212,   1,   1,   0, 
+      0,   0,  48,  43, 167, 130, 
+     80, 241, 212,   1,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2200,7 +2200,7 @@ const BYTE DX12VertexShaderBytes[] =
      12,  16,   0,   0,   1,   0, 
       1,   0,  14,   0,  23,  21, 
      13,  16,   0,   0,  36,   2, 
-      0, 106,   0,   0, 242, 241, 
+      0,   3,   0,   0, 242, 241, 
      10,   0,  24,  21,  14,  16, 
       0,   0,   1,   0,   0,   2, 
      18,   0,  22,  21,  10,  16, 
@@ -3153,7 +3153,7 @@ const BYTE DX12VertexShaderBytes[] =
       9,   0, 132,   5,   0,   0, 
       0,   0,   0,   0, 236,   2, 
       0,   0,   1,   0,   0,   0, 
-     32, 124, 209,   3,   0,   0, 
+    112, 123, 145,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
     109,  97, 105, 110,   0, 110, 
     111, 110, 101,   0,   0,   0, 
@@ -3219,11 +3219,11 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    148,  46,  49,   1, 113, 112, 
-    171,  92,   1,   0,   0,   0, 
-     97, 164,  63,  33,  48,  11, 
-     72,  79, 160, 116, 254,  49, 
-     34, 234,  47,  36, 138,   0, 
+    148,  46,  49,   1, 247, 194, 
+    176,  92,   1,   0,   0,   0, 
+    158,   6, 144, 237, 203,  63, 
+    114,  73, 163, 205,  90, 235, 
+    127, 218, 240, 121, 138,   0, 
       0,   0,  47,  76, 105, 110, 
     107,  73, 110, 102, 111,   0, 
      47, 110,  97, 109, 101, 115, 

DX9GraphicsApi.cpp

@@ -144,9 +144,9 @@ void DirectX9::renderKamera( Kam3D * zKamera )
     Mat4< float > inv = zKamera->getViewMatrix().getInverse();
     Welt3D *welt = zKamera->zWelt();
     ZeitMesser zm = ZeitMesser();
+    zm.messungStart();
     for( int x = 0; x < zKamera->zViewPort()->width; x++ )
     {
-        zm.messungStart();
         for( int y = 0; y < zKamera->zViewPort()->height; y++ )
         {
             Vec3< float > wPoint = Vec3< float >( x / ( 0.5f * zKamera->zViewPort()->width ) - 1, y / ( 0.5f * zKamera->zViewPort()->height ) - 1, 0.1f );
@@ -160,9 +160,9 @@ void DirectX9::renderKamera( Kam3D * zKamera )
             Vec3< float > wDir = wPoint2 - wPoint;
             uiBild->setPixelDP( x + (int)zKamera->zViewPort()->x, y + (int)zKamera->zViewPort()->y, welt->traceRay( wPoint, wDir ) );
         }
-        zm.messungEnde();
-        //std::cout << zm.getSekunden() << "\n";
     }
+    zm.messungEnde();
+    std::cout << zm.getSekunden() << "\n";
 }
 
 void DirectX9::presentFrame()

Model3D.cpp

@@ -718,14 +718,19 @@ Model3DData *Model3D::zModelData()
 //  maxSqDist: Die maximale quadratische distanz die erlaubt ist
 //  pId: die Id des Polygons, zu dem der Schnittpunkt gehört
 //  return: den quadratischen Abstand des Schnittpunktes zum Ursprung des Strahls oder -1, wenn kein schnittpunkt existiert 
-float Model3D::traceRay( Vec3< float > point, Vec3< float > dir, float maxSqDist, int &pId ) const
+float Model3D::traceRay( Vec3< float > & p, Vec3< float > & d, float maxSqDist, int &pId ) const
 {
     if( !model )
         return -1;
-    Mat4< float > m = Mat4< float >::rotationZ( -angle.z ) * Mat4< float >::rotationX( -angle.x ) * Mat4< float >::rotationY( -angle.y );
-    dir = m * dir;
-    m = Mat4< float >::translation( -pos ) * m;
-    point = m * point;
+    Vec3< float > dir = d;
+    dir.rotateY( -angle.y );
+    dir.rotateX( -angle.x );
+    dir.rotateZ( -angle.z );
+    Vec3< float > point = p;
+    point.rotateY( -angle.y );
+    point.rotateX( -angle.x );
+    point.rotateZ( -angle.z );
+    point -= pos;
     float nearest = ( -dir.x * point.x - dir.y * point.y - dir.z * point.z ) / ( dir.x * dir.x + dir.y * dir.y + dir.z * dir.z );
     float dist = ( point + dir * nearest ).getLengthSq();
     if( dist > ( radius * size ) * ( radius * size ) || ( dir * nearest ).getLength() - radius * size > sqrt( maxSqDist ) || ( nearest < 0 && ( dir * nearest ).getLengthSq() > radius * size * radius * size ) ) // es gibt kein schnittpunkt
@@ -752,12 +757,9 @@ float Model3D::traceRay( Vec3< float > point, Vec3< float > dir, float maxSqDist
                     {
                         nearest = ( a * normal - point * normal ) / ( dir * normal );
                         Vec3< float > hit = point + dir * nearest;
-                        if( abs( ( b - a ).angle( hit - a ) ) <= abs( ( b - a ).angle( c - a ) ) &&
-                            abs( ( c - a ).angle( hit - a ) ) <= abs( ( b - a ).angle( c - a ) ) &&
-                            abs( ( a - b ).angle( hit - b ) ) <= abs( ( a - b ).angle( c - b ) ) &&
-                            abs( ( c - b ).angle( hit - b ) ) <= abs( ( a - b ).angle( c - b ) ) &&
-                            abs( ( a - c ).angle( hit - c ) ) <= abs( ( a - c ).angle( b - c ) ) &&
-                            abs( ( b - c ).angle( hit - c ) ) <= abs( ( a - c ).angle( b - c ) ) )
+                        if( ( b - a ).angle( hit - a ) <= ( b - a ).angle( c - a ) &&
+                            ( c - a ).angle( hit - a ) <= ( b - a ).angle( c - a ) &&
+                            ( a - b ).angle( hit - b ) <= ( a - b ).angle( c - b ) )
                         {
                             maxSqDist = ( hit - point ).getLengthSq();
                             pId = index;
@@ -777,12 +779,17 @@ float Model3D::traceRay( Vec3< float > point, Vec3< float > dir, float maxSqDist
 //  dir: die Richtung des Strahls in Weltkoordinaten
 //  zWelt: die Welt, aus der der Strahl kommt
 //  return: die Farbe des Schnittpunktes 
-int Model3D::traceRay( Vec3< float > point, Vec3< float > dir, int pId, Welt3D * zWelt ) const
-{
-    Mat4< float > m = Mat4< float >::rotationZ( -angle.z ) * Mat4< float >::rotationX( -angle.x ) * Mat4< float >::rotationY( -angle.y );
-    dir = m * dir;
-    m = Mat4< float >::translation( -pos ) * m;
-    point = m * point;
+int Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, int pId, Welt3D * zWelt ) const
+{
+    Vec3< float > dir = d;
+    dir.rotateY( -angle.y );
+    dir.rotateX( -angle.x );
+    dir.rotateZ( -angle.z );
+    Vec3< float > point = p;
+    point.rotateY( -angle.y );
+    point.rotateX( -angle.x );
+    point.rotateZ( -angle.z );
+    point -= pos;
     int index = 0;
     for( auto p = model->getPolygons(); p; p++, index++ )
     {
@@ -792,9 +799,9 @@ int Model3D::traceRay( Vec3< float > point, Vec3< float > dir, int pId, Welt3D *
             {
                 if( pId == 0 )
                 {
-                    Vec3< float > a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
-                    Vec3< float > b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
-                    Vec3< float > c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
+                    const Vec3< float > &a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
+                    const Vec3< float > &b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
+                    const Vec3< float > &c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
                     Vertex at = model->zVertexBuffer()[ p->indexList[ j ] ].tPos;
                     Vertex bt = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].tPos;
                     Vertex ct = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].tPos;

Model3D.h

@@ -307,13 +307,13 @@ namespace Framework
         //  maxSqDist: Die maximale quadratische distanz die erlaubt ist
         //  pId: die Id des Polygons, zu dem der Schnittpunkt gehört
         //  return: den quadratischen Abstand des Schnittpunktes zum Ursprung des Strahls oder -1, wenn kein schnittpunkt existiert 
-        __declspec( dllexport ) virtual float traceRay( Vec3< float > point, Vec3< float > dir, float maxSqDist, int &pId ) const;
+        __declspec( dllexport ) virtual float traceRay( Vec3< float > &point, Vec3< float > &dir, float maxSqDist, int &pId ) const;
         // berechnet die Farbe des Schnittpunktes deines Strahls
         //  point: der startpunkt des Strahls in Weltkoordinaten
         //  dir: die Richtung des Strahls in Weltkoordinaten
         //  zWelt: die Welt, aus der der Strahl kommt
         //  return: die Farbe des Schnittpunktes 
-        __declspec( dllexport ) virtual int traceRay( Vec3< float > point, Vec3< float > dir, int pId, Welt3D *zWelt ) const;
+        __declspec( dllexport ) virtual int traceRay( Vec3< float > &point, Vec3< float > &dir, int pId, Welt3D *zWelt ) const;
         // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
         __declspec( dllexport ) int getDatenId() const;
         // Git den Factor an, mit dem das umgebungslicht (textur farbe) multipliziert wird

UIPixelShader.h

@@ -262,10 +262,10 @@ ret
 
 const BYTE UIPixelShader[] =
 {
-     68,  88,  66,  67,  95, 102, 
-      4,  30, 228, 127,  75,  23, 
-    135, 195, 243, 172,  49, 187, 
-     80,  93,   1,   0,   0,   0, 
+     68,  88,  66,  67,  61, 177, 
+    100,  74, 122,  82,  87,   8, 
+    129, 184, 151, 223,  46, 239, 
+     13, 126,   1,   0,   0,   0, 
     136, 104,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
     124,   5,   0,   0,  12,   6, 
@@ -1480,10 +1480,10 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0, 148,  46,  49,   1, 
-    114, 112, 171,  92,   1,   0, 
-      0,   0,  28,  51, 164, 118, 
-    130,   0, 174,  73, 134,  59, 
-    188, 168, 219, 236, 249, 204, 
+    247, 194, 176,  92,   1,   0, 
+      0,   0, 163,  66,  84, 152, 
+     21, 183, 120,  76, 156, 156, 
+     20,  50,   0, 150,  33, 124, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   1,   0,   0,   0, 
       1,   0,   0,   0,   0,   0, 
@@ -2419,8 +2419,8 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      27, 226,  48,   1, 128,   0, 
-      0,   0, 189,  35, 145,  98, 
-     36, 238, 212,   1,   1,   0, 
+      0,   0,  91, 250, 208, 130, 
+     80, 241, 212,   1,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -4400,7 +4400,7 @@ const BYTE UIPixelShader[] =
       9,   0, 160,   7,   0,   0, 
       0,   0,   0,   0, 244,   9, 
       0,   0,   1,   0,   0,   0, 
-    160, 123, 223,   3,   0,   0, 
+     64, 123, 255,   2,   0,   0, 
       0,   0,   0,   0,   0,   0, 
      84, 101, 120, 116, 117, 114, 
     101,  80, 105, 120, 101, 108, 
@@ -4466,11 +4466,11 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    148,  46,  49,   1, 114, 112, 
-    171,  92,   1,   0,   0,   0, 
-     28,  51, 164, 118, 130,   0, 
-    174,  73, 134,  59, 188, 168, 
-    219, 236, 249, 204, 137,   0, 
+    148,  46,  49,   1, 247, 194, 
+    176,  92,   1,   0,   0,   0, 
+    163,  66,  84, 152,  21, 183, 
+    120,  76, 156, 156,  20,  50, 
+      0, 150,  33, 124, 137,   0, 
       0,   0,  47,  76, 105, 110, 
     107,  73, 110, 102, 111,   0, 
      47, 110,  97, 109, 101, 115, 

UIVertexShader.h

@@ -119,10 +119,10 @@ ret
 
 const BYTE UIVertexShader[] =
 {
-     68,  88,  66,  67,  54, 141, 
-    250, 161, 107,  66, 121, 119, 
-    195, 141,  46,  86, 102,  25, 
-     96, 115,   1,   0,   0,   0, 
+     68,  88,  66,  67,  16, 163, 
+     41, 145,  90, 139,  98,  60, 
+    182, 120, 193,  41, 194,  76, 
+    250, 231,   1,   0,   0,   0, 
     168,  77,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
      20,   2,   0,   0, 168,   2, 
@@ -873,10 +873,10 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0, 148,  46,  49,   1, 
-    114, 112, 171,  92,   1,   0, 
-      0,   0, 232, 249, 102, 161, 
-    153, 102,  18,  71, 165, 183, 
-    224, 178, 162, 160, 124,  39, 
+    247, 194, 176,  92,   1,   0, 
+      0,   0,  47, 249, 217,  16, 
+     68, 198, 138,  67, 170,  32, 
+    199, 178, 105, 231, 110, 243, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   1,   0,   0,   0, 
       1,   0,   0,   0,   0,   0, 
@@ -1556,8 +1556,8 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      27, 226,  48,   1, 128,   0, 
-      0,   0, 140,  84, 215,  98, 
-     36, 238, 212,   1,   1,   0, 
+      0,   0,  66,  17,  26, 131, 
+     80, 241, 212,   1,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2939,8 +2939,8 @@ const BYTE UIVertexShader[] =
       0,   0,   2,   0,   9,   0, 
      80,   5,   0,   0,   0,   0, 
       0,   0, 236,   2,   0,   0, 
-      1,   0,   0,   0, 208, 121, 
-    143,   3,   0,   0,   0,   0, 
+      1,   0,   0,   0,  96, 121, 
+     89,   3,   0,   0,   0,   0, 
       0,   0,   0,   0,  84, 101, 
     120, 116, 117, 114, 101,  86, 
     101, 114, 116, 101, 120,  83, 
@@ -3006,11 +3006,11 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0, 148,  46, 
-     49,   1, 114, 112, 171,  92, 
-      1,   0,   0,   0, 232, 249, 
-    102, 161, 153, 102,  18,  71, 
-    165, 183, 224, 178, 162, 160, 
-    124,  39, 138,   0,   0,   0, 
+     49,   1, 247, 194, 176,  92, 
+      1,   0,   0,   0,  47, 249, 
+    217,  16,  68, 198, 138,  67, 
+    170,  32, 199, 178, 105, 231, 
+    110, 243, 138,   0,   0,   0, 
      47,  76, 105, 110, 107,  73, 
     110, 102, 111,   0,  47, 110, 
      97, 109, 101, 115,   0,  47, 

Vec3.h

@@ -179,6 +179,36 @@ namespace Framework
         {
             return Vec3( y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x );
         }
+
+        inline void rotateY( float radian )
+        {
+            const float cosTheta = lowPrecisionCos( radian );
+            const float sinTheta = lowPrecisionSin( radian );
+            float x = cosTheta * this->x + sinTheta * this->z;
+            float z = -sinTheta * this->x + cosTheta * this->z;
+            this->x = (T)x;
+            this->z = (T)z;
+        }
+
+        inline void rotateX( float radian )
+        {
+            const float cosTheta = lowPrecisionCos( radian );
+            const float sinTheta = lowPrecisionSin( radian );
+            float y = cosTheta * this->y + -sinTheta * this->z;
+            float z = sinTheta * this->y + cosTheta * this->z;
+            this->y = (T)y;
+            this->z = (T)z;
+        }
+
+        inline void rotateZ( float radian )
+        {
+            const float cosTheta = lowPrecisionCos( radian );
+            const float sinTheta = lowPrecisionSin( radian );
+            float x = cosTheta * this->x + -sinTheta * this->y;
+            float y = sinTheta * this->x + cosTheta * this->y;
+            this->x = (T)x;
+            this->z = (T)z;
+        }
     };
 }
 

Welt3D.cpp

@@ -130,7 +130,7 @@ bool Welt3D::tick( double tickval )
 //  point: Der ursprung des Strahls,
 //  dir: Die Richtung des Strahls
 //  return: Die Farbe des Strahls
-int Welt3D::traceRay( Vec3< float > point, Vec3< float > dir )
+int Welt3D::traceRay( Vec3< float > &point, Vec3< float > &dir )
 {
     float min = INFINITY;
     int minId = -1;

Welt3D.h

@@ -46,7 +46,7 @@ namespace Framework
         //  point: Der ursprung des Strahls,
         //  dir: Die Richtung des Strahls
         //  return: Die Farbe des Strahls
-        __declspec( dllexport ) virtual int traceRay( Vec3< float > point, Vec3< float > dir );
+        __declspec( dllexport ) virtual int traceRay( Vec3< float > &point, Vec3< float > &dir );
         // Gibt einen Iterator zurück, mit dem alle Members aufgezählt werden können
         __declspec( dllexport ) Iterator< Model3D * > getMembers();
         // Erhöht den Reference Counting Zähler.

main.h

@@ -37,12 +37,6 @@ namespace Framework
     // Überschreibe diese Funktion. Sie wird vom Framework automatisch beim Start des Programmes aufgerufen
     //  p: Die Parameter, die dem Programm beim Start vom Betriebssystem übergeben wurden
     int KSGStart Start( Startparam p );
-    // Initialisiert das Framework
-    // Wird in der (WinMain) des Frameworks automatisch aufgerufen
-    __declspec( dllexport ) void initFramework();
-    // Gibt den duch (initFramework) benutzten Arbeitsspeicher wieder frei
-    // Wird in der (WinMain) des Frameworks automatisch aufgerufen
-    __declspec( dllexport ) void releaseFramework();
 }
 
 typedef BOOL( __stdcall *MINIDUMPWRITEDUMP )( HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType, CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam );