path: root/math3d.c

#include <GL/glew.h>
#include <stdio.h>
#include <stdlib.h>
#include "math3d.h"

void m3dFindNormal(M3DVector3f result, const M3DVector3f point1, 
                   const M3DVector3f point2, const M3DVector3f point3)
{
    M3DVector3f v1, v2;

    /* calculate two vectors from the three points, assumes 
     * counter clockwise winding
     */
    v1[0] = point1[0] - point2[0];
    v1[1] = point1[1] - point2[1];
    v1[2] = point1[2] - point2[2];

    v2[0] = point2[0] - point3[0];
    v2[1] = point2[1] - point3[1];
    v2[2] = point2[2] - point3[2];

    /* take the cross product of the two vectors to get the normal vector */
    m3dCrossProduct(result, v1, v2);
}

void m3dLoadIdentity44(M3DMatrix44f m) /* 4x4 float */
{
    /* don't be fooled, this is still column major */
    static M3DMatrix44f identity = { 1.0f, 0.0f, 0.0f, 0.0f,
                                     0.0f, 1.0f, 0.0f, 0.0f,
                                     0.0f, 0.0f, 1.0f, 0.0f,
                                     0.0f, 0.0f, 0.0f, 1.0f };

    memcpy(m, identity, sizeof(M3DMatrix44f));
}

/* creates a 4x4 rotation matrix, takes radians not degrees */
void m3dRotationMatrix44(M3DMatrix44f m, float angle, float x, float y, float z)
{
    float mag, s, c;
    float xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;

    s = (float) (sin(angle));
    c = (float) (cos(angle));

    mag = (float) (sqrt(x*x + y*y + z*z));

    /* identity matrix */
    if (mag == 0.0f)
    {
        m3dLoadIdentity44(m);
        return;
    }

    /* rotation matrix is normalized */
    x /= mag;
    y /= mag;
    z /= mag;

    #define M(row,col) m[col*4+row]

    xx = x * x;
    yy = y * y;
    zz = z * z;
    xy = x * y;
    yz = y * z;
    zx = z * x;

    xs = x * s;
    ys = y * s;
    zs = z * s;
    one_c = 1.0f - c;

    M(0,0) = (one_c * xx) + c;
    M(0,1) = (one_c * xy) - zs;
    M(0,2) = (one_c * zx) + ys;
    M(0,3) = 0.0f;

    M(1,0) = (one_c * xy) + zs;
    M(1,1) = (one_c * yy) + c;
    M(1,2) = (one_c * yz) - xs;
    M(1,3) = 0.0f;

    M(2,0) = (one_c * zx) - ys;
    M(2,1) = (one_c * yz) + xs;
    M(2,2) = (one_c * zz) + c;
    M(2,3) = 0.0f;

    M(3,0) = 0.0f;
    M(3,1) = 0.0f;
    M(3,2) = 0.0f;
    M(3,3) = 1.0f;

    #undef M
}

void m3dMatrixMultiply44(M3DMatrix44f product, const M3DMatrix44f a, 
                         const M3DMatrix44f b)
{
    #define A(row,col)  a[(col<<2)+row]
    #define B(row,col)  b[(col<<2)+row]
    #define P(row,col)  product[(col<<2)+row]

    int i;
    for (i = 0; i < 4; i++)
    {
        float ai0 = A(i, 0), ai1 = A(i, 1), ai2 = A(i, 2), ai3 = A(i, 3);
        P(i, 0) = ai0 * B(0, 0) + ai1 * B(1, 0) + ai2 * B(2, 0) + ai3 * B(3, 0);
        P(i, 1) = ai0 * B(0, 1) + ai1 * B(1, 1) + ai2 * B(2, 1) + ai3 * B(3, 1);
        P(i, 2) = ai0 * B(0, 2) + ai1 * B(1, 2) + ai2 * B(2, 2) + ai3 * B(3, 2);
        P(i, 3) = ai0 * B(0, 3) + ai1 * B(1, 3) + ai2 * B(2, 3) + ai3 * B(3, 3);
    }
    
    #undef A
    #undef B
    #undef P
}

GLint gltWriteTGA(const char *szFileName)
{
    FILE *pFile;              /* file pointer */
    TGAHEADER tgaHeader;      /* tga file header */
    unsigned long lImageSize; /* size in bytes of image */
    GLbyte *pBits = NULL;     /* pointer to bits */
    GLint iViewport[4];       /* viewport in pixels */
    GLenum lastBuffer;        /* storage for the current read buffer setting */

    /* get the viewport dimensions */
    glGetIntegerv(GL_VIEWPORT, iViewport);

    /* how big is the image going to be (targas are tightly packed) */
    lImageSize = iViewport[2] * 3 * iViewport[3];

    /* allocate block, if this doesn't work, go home */
    pBits = (GLbyte *) malloc(lImageSize);
    if (pBits == NULL)
    {
        perror("malloc");
        return 0;
    }

    /* read bits from color buffer */
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
    glPixelStorei(GL_PACK_SKIP_ROWS, 0);
    glPixelStorei(GL_PACK_SKIP_PIXELS, 0);

    /* get the current read buffer setting and save it, switch to
     * the front buffer and do the read operation, finally, restore
     * the read buffer state
     */
    glGetIntegerv(GL_READ_BUFFER, (GLint *) &lastBuffer);
    glReadBuffer(GL_FRONT);
    glReadPixels(0, 0, iViewport[2], iViewport[3], GL_BGR_EXT,
    GL_UNSIGNED_BYTE, pBits);
    glReadBuffer(lastBuffer);

    /* initialize the targa header */
    tgaHeader.identsize = 0;
    tgaHeader.colorMapType = 0;
    tgaHeader.imageType = 2;
    tgaHeader.colorMapStart = 0;
    tgaHeader.colorMapLength = 0;
    tgaHeader.colorMapBits = 0;
    tgaHeader.xstart = 0;
    tgaHeader.ystart = 0;
    tgaHeader.width = iViewport[2];
    tgaHeader.height = iViewport[3];
    tgaHeader.bits = 24;
    tgaHeader.descriptor = 0;

    /* attempt to open the file */
    pFile = fopen(szFileName, "wb");
    if (pFile == NULL)
    {
        perror("fopen");
        free(pBits); /* free buffer and return error */
        return 0;
    }
    
    /* write the header */
    fwrite(&tgaHeader, sizeof(TGAHEADER), 1, pFile);

    /* write the image data */
    fwrite(pBits, lImageSize, 1, pFile);

    /* free temporary buffer and close the file */
    free(pBits);
    fclose(pFile);

    return 1;
}

GLbyte *gltLoadTGA(const char *szFileName, GLint *iWidth, GLint *iHeight, 
                   GLint *iComponents, GLenum *eFormat)
{
    FILE *pFile;              /* file pointer */
    TGAHEADER tgaHeader;      /* TGA file header */
    unsigned long lImageSize; /* size in bytes of image */
    short sDepth;             /* pixel depth; */
    GLbyte *pBits = NULL;     /* pointer to bits */

    /* default/failed values */
    *iWidth = 0;
    *iHeight = 0;
    *eFormat = GL_BGR_EXT;
    *iComponents = GL_RGB8;

    /* attempt to open the file */
    pFile = fopen(szFileName, "rb");
    if (pFile == NULL)
    {
        perror("fopen");
        return 0;
    }

    /* read in header (binary) */
    fread(&tgaHeader, 18 /* sizeof(TGAHEADER) */, 1, pFile);

    /* get width, height, and depth of texture */
    *iWidth = tgaHeader.width;
    *iHeight = tgaHeader.height;
    sDepth = tgaHeader.bits / 8;

    /* put some validity checks here, very simply, i only understand
     * or care about 8, 24, or 32 bit targas
     */
    if (tgaHeader.bits != 8 && tgaHeader.bits != 24 && tgaHeader.bits != 32)
        return NULL;

    /* calculate size of image buffer */
    lImageSize = tgaHeader.width * tgaHeader.height * sDepth;

    /* allocate memory and check for success */
    pBits = (GLbyte *) malloc(lImageSize * sizeof(GLbyte));
    if (pBits == NULL)
    {
        perror("malloc");
        return NULL;
    }

    /* read in the bits */
    /* check for read error, this should catch rle or other  */
    /* weird formats that i don't want to recognize */
    if (fread(pBits, lImageSize, 1, pFile) != 1)
    {
        perror("fread");
        free(pBits);
        return NULL;
    }
    
    /* set opengl format expected */
    switch (sDepth)
    {
        case 3: /* most likely case */
            *eFormat = GL_BGR_EXT;
            *iComponents = GL_RGB8;
            break;
        case 4:
            *eFormat = GL_BGRA_EXT;
            *iComponents = GL_RGBA8;
            break;
        case 1:
            *eFormat = GL_LUMINANCE;
            *iComponents = GL_LUMINANCE8;
            break;
    }

    /* done with file */
    fclose(pFile);

    /* return pointer to image data */
    return pBits;
}