#include <math.h>

#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 240
float screenMidW = (float)SCREEN_WIDTH / 2.0f;
float screenMidH = (float)SCREEN_HEIGHT / 2.0f;

float rotSineIdx = 0.0f, rotSineVal = 0.0f;

typedef struct
{
    float x, y, z;
} VECTOR;

VECTOR newp[8], oldp[8];
VECTOR cube[8] =
{
    { -1.0f, -1.0f, -1.0f }, /* 1 top left */
    {  1.0f, -1.0f, -1.0f }, /* 1 top right */
    { -1.0f,  1.0f, -1.0f }, /* 1 bottom left */
    {  1.0f,  1.0f, -1.0f }, /* 1 bottom right */
    { -1.0f, -1.0f,  1.0f }, /* 2 top left */
    {  1.0f, -1.0f,  1.0f }, /* 2 top right */
    { -1.0f,  1.0f,  1.0f }, /* 2 bottom left */
    {  1.0f,  1.0f,  1.0f }  /* 2 bottom right */
};

__forceinline void lineTo(unsigned int *pixbuf, float x1, float x2, float y1, float y2);

void drawCube(unsigned int *backbuf)
{
    /* update sinus/cosinus index */
    rotSineVal = rotSineIdx * 3.141592654f / 180.0f;

    rotSineIdx += 1.0f;
    if (rotSineIdx >= 360.0f)
    {
        rotSineIdx -= 360.0f;
    }

    {
        int i;
        for (i = 0; i < 8; i++)
        {
            /* backup points */
            oldp[i].x = cube[i].x;
            oldp[i].y = cube[i].y;
            oldp[i].z = cube[i].z;

            /* rotate points */
            {
                float newCos = cosf(rotSineVal);
                float newSin = sinf(rotSineVal);

                newp[i].x = ((oldp[i].x * newCos) - (oldp[i].y * newSin));
                newp[i].y = ((oldp[i].x * newSin) + (oldp[i].y * newCos));
                newp[i].z = oldp[i].z;

                oldp[i].y = newp[i].y;
                oldp[i].z = newp[i].z;

                newp[i].y = ((oldp[i].y * newCos) - (oldp[i].z * newSin));
                newp[i].z = ((oldp[i].y * newSin) + (oldp[i].z * newCos));
                oldp[i].x = newp[i].x;

                oldp[i].z = newp[i].z;

                newp[i].z = ((oldp[i].z * newCos) - (oldp[i].x * newSin));
                newp[i].x = ((oldp[i].z * newSin) + (oldp[i].x * newCos));
            }

            /* project x/y points */
            {
                float dist = 10.0f;
                float FOV = 384.0f;

                newp[i].x = (newp[i].x / (newp[i].z + dist)) * FOV + screenMidW;
                newp[i].y = (newp[i].y / (newp[i].z + dist)) * FOV + screenMidH;
            }
        }
    }

    /* render lines between new x/y positions */
    lineTo(backbuf, newp[0].x, newp[1].x, newp[0].y, newp[1].y);
    lineTo(backbuf, newp[0].x, newp[2].x, newp[0].y, newp[2].y);
    lineTo(backbuf, newp[1].x, newp[3].x, newp[1].y, newp[3].y);
    lineTo(backbuf, newp[2].x, newp[3].x, newp[2].y, newp[3].y);
    lineTo(backbuf, newp[0].x, newp[4].x, newp[0].y, newp[4].y);
    lineTo(backbuf, newp[1].x, newp[5].x, newp[1].y, newp[5].y);
    lineTo(backbuf, newp[2].x, newp[6].x, newp[2].y, newp[6].y);
    lineTo(backbuf, newp[3].x, newp[7].x, newp[3].y, newp[7].y);
    lineTo(backbuf, newp[4].x, newp[5].x, newp[4].y, newp[5].y);
    lineTo(backbuf, newp[4].x, newp[6].x, newp[4].y, newp[6].y);
    lineTo(backbuf, newp[5].x, newp[7].x, newp[5].y, newp[7].y);
    lineTo(backbuf, newp[6].x, newp[7].x, newp[6].y, newp[7].y);
}

/* Bresenham's line algorithm */
__forceinline void lineTo(unsigned int *pixbuf, float x1, float x2, float y1, float y2)
{
    int delta_x, ix, delta_y, iy;

    int nx1 = (int)x1;
    int nx2 = (int)x2;
    int ny1 = (int)y1;
    int ny2 = (int)y2;

    #define ABS(a) (((a) < 0) ? -(a) : (a))

    delta_x = (nx2 - nx1);
    ix = (delta_x > 0) - (delta_x < 0);
    delta_x = ABS(delta_x) * 2;

    delta_y = (ny2 - ny1);
    iy = ((delta_y > 0) - (delta_y < 0));
    delta_y = ABS(delta_y) * 2;

    pixbuf[ny1 * SCREEN_WIDTH + nx1] = 0x00FFFFFF;

    if (delta_x >= delta_y)
    {
        int error = delta_y - (delta_x / 2);

        while (nx1 != nx2)
        {
            if (error >= 0)
            {
                if (error || (ix > 0))
                {
                    ny1 += iy;
                    error -= delta_x;
                }
            }

            nx1 += ix;
            error += delta_y;

            pixbuf[ny1 * SCREEN_WIDTH + nx1] = 0x00FFFFFF;
        }
    }
    else
    {
        int error = delta_x - (delta_y / 2);

        while (ny1 != ny2)
        {
            if (error >= 0)
            {
                if (error || (iy > 0))
                {
                    nx1 += ix;
                    error -= delta_y;
                }
            }

            ny1 += iy;
            error += delta_x;

            pixbuf[ny1 * SCREEN_WIDTH + nx1] = 0x00FFFFFF;
        }
    }
}