[C++] TritEngine - Silnik Graficzny z wykorzystaniem matematyki niższej ( czyli jak ominąć macierze )

void model::rotatez()
{
    for( trit * t = mesh; t != NULL; t = t->next )
    {
        len1 = sqrt( pow( cx - t->v1x, 2 ) + pow( cy - t->v1y, 2 ) + pow( cz - t->v1z, 2 ) );
        len2 = sqrt( pow( cx - t->v2x, 2 ) + pow( cy - t->v2y, 2 ) + pow( cz - t->v2z, 2 ) );
        len3 = sqrt( pow( cx - t->v3x, 2 ) + pow( cy - t->v3y, 2 ) + pow( cz - t->v3z, 2 ) );
       
        // ROTATE Z ( adding vector of movement z )
        // get the current angle 0-360
        deg1z =( atan2( cy - t->v1y, cx - t->v1x ) + M_PI ) * toDegrees;
        deg2z =( atan2( cy - t->v2y, cx - t->v2x ) + M_PI ) * toDegrees;
        deg3z =( atan2( cy - t->v3y, cx - t->v3x ) + M_PI ) * toDegrees;
       
        if( testindex++ < 360 * 2 )
        {
            cout << deg1z << ", " << deg2z << ", " << deg3z << endl;
        }
        // get the sum angles (after rotate)
        fullAnglez1 =( deg1z + anglez ) * toRads;
        fullAnglez2 =( deg2z + anglez ) * toRads;
        fullAnglez3 =( deg3z + anglez ) * toRads;
       
        // get the vectors of movement rotate
        t->rz1x = t->v1x -( cx + len1 * sin( fullAnglez1 ) );
        t->rz1y = t->v1y -( cy + len1 * cos( fullAnglez1 ) );
        t->rz1z = 0;
       
        t->rz2x = t->v2x -( cx + len2 * sin( fullAnglez2 ) );
        t->rz2y = t->v2y -( cy + len2 * cos( fullAnglez2 ) );
        t->rz2z = 0;
       
        t->rz3x = t->v3x -( cx + len3 * sin( fullAnglez3 ) );
        t->rz3y = t->v3y -( cy + len3 * cos( fullAnglez3 ) );
        t->rz3z = 0;
    }
}
[ cpp ]

[ cpp ]
void model::rotateSum()
{
    for( trit * t = mesh; t != NULL; t = t->next )
    {
        t->r1x = t->v1x + t->rz1x; // + t->ry1x + t->rx1x;
        t->r1y = t->v1y + t->rz1y; // + t->ry1y + t->rx1y;
        t->r1z = t->v1z + t->rz1z; // + t->ry1z + t->rx1z;
       
        t->r2x = t->v2x + t->rz2x; // + t->ry2x + t->rx2x;
        t->r2y = t->v2y + t->rz2y; // + t->ry2y + t->rx2y;
        t->r2z = t->v2z + t->rz2z; // + t->ry2z + t->rx2z;
       
        t->r3x = t->v3x + t->rz3x; // + t->ry3x + t->rx3x;
        t->r3y = t->v3y + t->rz3y; // + t->ry3y + t->rx3y;
        t->r3z = t->v3z + t->rz3z; // + t->ry3z + t->rx3z;
    }
}

#include "model3D.hpp"

float dist( float cx, float cy, float cz, trit * t )
{
    return sqrt(
    pow( cx - t->rx, 2 ) +
    pow(( cy + 500 ) - t->ry, 2 ) +
    pow(( cz - 1000 ) - t->rz, 2 )
    );
}

trit::trit( float v1x, float v1y, float v1z, float v2x, float v2y, float v2z, float v3x, float v3y, float v3z, float r = 128, float g = 128, float b = 128, float a = 256 )
{
    this->v1x = v1x; this->v1y = v1y; this->v1z = v1z;
    this->v2x = v2x; this->v2y = v2y; this->v2z = v2z;
    this->v3x = v3x; this->v3y = v3y; this->v3z = v3z;
   
    this->r = r; this->g = g; this->b = b; this->a = a;
   
    calcCenterOfTriangle();
   
    next = NULL;
}

trit::trit( trit * t )
{
    this->v1x = t->v1x; this->v1y = t->v1y; this->v1z = t->v1z;
    this->v2x = t->v2x; this->v2y = t->v2y; this->v2z = t->v2z;
    this->v3x = t->v3x; this->v3y = t->v3y; this->v3z = t->v3z;
   
    this->r = t->r; this->g = t->g; this->b = t->b; this->a = t->a;
   
    calcCenterOfTriangle();
   
    next = NULL;
}

trit::~trit()
{
   
}

void trit::calcCenterOfTriangle()
{
    cx =( v1x + v2x + v3x ) / 3.0f;
    cy =( v1y + v2y + v3y ) / 3.0f;
    cz =( v1z + v2z + v3z ) / 3.0f;
}

void trit::calcCenterOfRotatedTriangle()
{
    rx =( r1x + r2x + r3x ) / 3.0f;
    ry =( r1y + r2y + r3y ) / 3.0f;
    rz =( r1z + r2z + r3z ) / 3.0f;
}

void trit::render()
{
    renderTritColor(
    r1x, r1y,
    r2x, r2y,
    r3x, r3y,
    r, g, b, a
    );
}

void trit::render_3to2D()
{
    renderTritColor(
    v1x + v1z / 2.f, v1y + v1z / 2.f,
    v2x + v2z / 2.f, v2y + v2z / 2.f,
    v3x + v3z / 2.f, v3y + v3z / 2.f,
    r, g, b, a
    );
}

model3D::model3D()
{
    mesh = NULL;
    cz = cy = cx = 0.0f;
    angley = 0.0f;
    next = NULL;
}

model3D::~model3D()
{
   
}

void model3D::setCenter( float cx, float cy, float cz )
{
    this->cx = cx;
    this->cy = cy;
    this->cz = cz;
}

void model3D::addTrit( trit * t )
{
    if( mesh != NULL )
         t->next = mesh;
   
    mesh = t;
}

void model3D::addTritsFromModel( model3D * m )
{
    trit * t;
   
    for( trit * t2 = m->mesh; t2 != NULL; t2 = t2->next )
    {
        t = new trit( t2 );
        addTrit( t );
    }
   
}

void model3D::rotateY()
{
    for( trit * t = mesh; t != NULL; t = t->next )
    {
        deg1y = atan2( cz - t->v1z, cx - t->v1x ) * toDegrees;
        deg2y = atan2( cz - t->v2z, cx - t->v2x ) * toDegrees;
        deg3y = atan2( cz - t->v3z, cx - t->v3x ) * toDegrees;
       
        fullAngley1 =( deg1y + angley ) * toRads;
        fullAngley2 =( deg2y + angley ) * toRads;
        fullAngley3 =( deg3y + angley ) * toRads;
       
        len1 = sqrt( pow( cx - t->v1x, 2 ) + pow( cz - t->v1z, 2 ) );
        len2 = sqrt( pow( cx - t->v2x, 2 ) + pow( cz - t->v2z, 2 ) );
        len3 = sqrt( pow( cx - t->v3x, 2 ) + pow( cz - t->v3z, 2 ) );
       
        t->r1x = t->v1x - len1 * cos( fullAngley1 );
        t->r1y = t->v1y;
        t->r1z = t->v1z + len1 * sin( fullAngley1 );
       
        t->r2x = t->v2x - len2 * cos( fullAngley2 );
        t->r2y = t->v2y;
        t->r2z = t->v2z + len2 * sin( fullAngley2 );
       
        t->r3x = t->v3x - len3 * cos( fullAngley3 );
        t->r3y = t->v3y;
        t->r3z = t->v3z + len3 * sin( fullAngley3 );
       
    }
}

void model3D::sortTrits()
{
    for( trit * t = mesh; t != NULL; t = t->next )
         t->calcCenterOfRotatedTriangle();
   
   
    if( mesh != NULL && mesh->next != NULL )
    {
        trit * newMesh = mesh;
        trit * current = mesh->next;
        newMesh->next = NULL;
       
        while( current != NULL )
        {
            trit * next = current->next;
           
            if( dist( cx, cy, cz, current ) > dist( cx, cy, cz, newMesh ) )
            {
                current->next = newMesh;
                newMesh = current;
            } else
            {
                trit * search = newMesh;
                while( search->next != NULL &&
                dist( cx, cy, cz, search->next ) > dist( cx, cy, cz, current ) )
                     search = search->next;
               
                current->next = search->next;
                search->next = current;
            };
           
            current = next;
        }
       
        mesh = newMesh;
    }
}

void model3D::render()
{
    for( trit * t = mesh; t != NULL; t = t->next )
         t->render(); // trit(xy, xy, xy, rgba) po r ( rotated )
   
}

void model3D::render_3to2D()
{
    for( trit * t = mesh; t != NULL; t = t->next )
         t->render_3to2D();
   
}