3d.c

/*=========================================================================

GFX - a small graphics library 

Copyright (C) 2004  Rafael de Oliveira Jannone

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Contact the author:
        by e-mail : rafael AT jannone DOT org
        homepage  : http://jannone.org/gfxlib
        ICQ UIN   : 10115284

See the License at http://www.gnu.org/copyleft/lesser.txt

=========================================================================*/

// 3D.H : 3D graphics and vectors functions

/* === WARNING ==

        This is a work-in-progress, meaning that most of this code is unstable
        and it's subject to future changes.  Also, most of it is very hackish,
        not properly cleaned up nor tested.

   === WARNING == */

#include <stdlib.h>
#include <math.h>
#include "line.h"
#include "3d.h"

int *tcos, *tsin;

void create_lookup_tables() {
        double M_PI = 8.0 * atan(1.0);

        int c;
        double a;

        tcos = newa(int, 256);
        tsin = newa(int, 256);

        for (c = 0; c < 256; c++) {
                a = M_PI * c / 128;
                tcos[c] = (int)(cos(a) * 64);
                tsin[c] = (int)(sin(a) * 64);
        }
}

void destroy_lookup_tables() {
        free(tcos);
        free(tsin);
}

mesh_t* mesh_new(int pcount, int tcount) {
        mesh_t* r = new(mesh_t);
        r->pcount = pcount;
        r->tcount = tcount;
        r->points = newa(vector_t, pcount);
        r->triangles = newa(triangle_t, tcount);
        return r;
}

void mesh_delete(mesh_t* mesh) {
        free(mesh->points);
        free(mesh->triangles);
        free(mesh);
}

void vector_cross_product (vector_t* v1, vector_t* v2, vector_t* r) {
        int x, y, z;
        x = mulfx(v1->y, v2->z) - mulfx(v1->z, v2->y);
        y = mulfx(v1->z, v2->x) - mulfx(v1->x, v2->z);
        z = mulfx(v1->x, v2->y) - mulfx(v1->y, v2->x);
        r->x = x; r->y = y; r->z = z;
}

int vector_cross_product_z (vector_t* v1, vector_t* v2) {
        return mulfx(v1->x, v2->y) - mulfx(v1->y, v2->x);
}

int vector_dot_product (vector_t* v1, vector_t* v2) {
        return mulfx(v1->x, v2->x) + mulfx(v1->y, v2->y) + mulfx(v1->z, v2->z);
}

int vector_length_squared (vector_t *v) {
        return sqrfx(v->x) + sqrfx(v->y) + sqrfx(v->z);
}

int vector_length(vector_t *v) {
        return sqrtfx(vector_length_squared(v));
}

void vector_normalize(vector_t *p, vector_t *r) {
        int d = vector_length(p);
        if (d != 0) {
                r->x = divfx(p->x, d);
                r->y = divfx(p->y, d);
                r->z = divfx(p->z, d);
        }
}

void vector_scalar(vector_t *v, int s, vector_t* r) {
        r->x = mulfx(v->x, s);
        r->y = mulfx(v->y, s);
        r->z = mulfx(v->z, s);
}

void vector_add(vector_t *v1, vector_t *v2, vector_t *r) {
        r->x = v1->x + v2->x;
        r->y = v1->y + v2->y;
        r->z = v1->z + v2->z;
}

void vector_subtract (vector_t *v1, vector_t *v2, vector_t *r) {
        r->x = v1->x - v2->x;
        r->y = v1->y - v2->y;
        r->z = v1->z - v2->z;
}

int vector_distance (vector_t *v1, vector_t *v2) {
        vector_t r;
        vector_subtract(v1, v2, &r);
        return vector_length(&r);
}

void vector_rotate(vector_t* p, u_char angle_x, u_char angle_y, u_char angle_z, vector_t* r) {
        int x, y, z;
        int ca, sa;

        // z
        ca = tcos[angle_z]; sa = tsin[angle_z];
        x = p->x; y = p->y; z = p->z;
        r->x = (mulfx(ca, x) - mulfx(sa, y));
        r->y = (mulfx(sa, x) + mulfx(ca, y));
        r->z = z;

        // y
        ca = tcos[angle_y]; sa = tsin[angle_y];
        x = r->x; y = r->y; z = r->z;
        r->x = (mulfx(ca, x) - mulfx(sa, z));
        r->z = (mulfx(sa, x) + mulfx(ca, z));

        // x
        ca = tcos[angle_x]; sa = tsin[angle_x];
        x = r->x; y = r->y; z = r->z;
        r->y = (mulfx(ca, y) - mulfx(sa, z));
        r->z = (mulfx(sa, y) + mulfx(ca, z));
}

void object_apply_transformations(object_t* obj, vector_t* pbuffer, int x, int y) {
        mesh_t* mesh = obj->mesh;
        vector_t* m = mesh->points;
        int c = mesh->pcount;
        while (c--) {
                vector_rotate(m, obj->rot_x, obj->rot_y, obj->rot_z, pbuffer);
                pbuffer->z += obj->trans_z;
                pbuffer->z /= 128;
                pbuffer->x = ((pbuffer->x + obj->trans_x) / pbuffer->z) + x;
                pbuffer->y = ((pbuffer->y + obj->trans_y) / pbuffer->z) + y;
                ++pbuffer;
                ++m;
        }
}

void object_render_wireframe(surface_t* s, object_t* obj, vector_t* pbuffer) {
        int c, diff;
        vector_t *i, *j, *k, q1, q2;
        mesh_t* mesh = obj->mesh;
        vector_t* m = mesh->points;
        triangle_t* t = mesh->triangles;

        object_apply_transformations(obj, pbuffer, 128, 96); // FIXME: must use surface center

        m = mesh->points;
        diff = (char*)pbuffer - (char*)m;
        for (c = 0; c < mesh->tcount; c++) {
                i = (vector_t*)((char*)t->vertexes[0] + diff);
                j = (vector_t*)((char*)t->vertexes[1] + diff);
                k = (vector_t*)((char*)t->vertexes[2] + diff);

                vector_subtract(j, i, &q1);
                vector_subtract(k, i, &q2);
                if (vector_cross_product_z(&q1, &q2) > 0) {
                        surface_line(s, i->x, i->y, j->x, j->y);
                        surface_line(s, j->x, j->y, k->x, k->y);
                        surface_line(s, k->x, k->y, i->x, i->y);
                }
                t++;
        }       
}

void object_render_flatshading(surface_t* s, object_t* obj, vector_t* pbuffer, int* low, int* high, vector_t* light) {
        int c, diff;
        int l, top, bottom;
        vector_t *i, *j, *k, q1, q2, N;
        mesh_t* mesh = obj->mesh;
        vector_t* m = mesh->points;
        triangle_t* t = mesh->triangles;
        int li;

        object_apply_transformations(obj, pbuffer, 128, 96); // FIXME: must use surface center

        m = mesh->points;
        diff = (char*)pbuffer - (char*)m;
        for (c = 0; c < mesh->tcount; c++) {
                i = (vector_t*)((char*)t->vertexes[0] + diff);
                j = (vector_t*)((char*)t->vertexes[1] + diff);
                k = (vector_t*)((char*)t->vertexes[2] + diff);

                vector_subtract(j, i, &q1);
                vector_subtract(k, i, &q2);
                vector_cross_product(&q1, &q2, &N);

                if (N.z > 0) {
                        vector_normalize(&N, &N);
                        li = vector_dot_product(&N, light) * 5;
                        li = f2i(li);
                        li = (li < 0) ? 0 : ((li > 4) ? 4 : li);

                        // FIXME: can optimize memset's by covering only "top" to "bottom" lines
                        // in this case we should require clean buffers to start with.
                        // and we should clean them after rendering.
                        memset(low, MODE2_HEIGHT << 1, 64);     // FIXME: must use surface height
                        memset(high, MODE2_HEIGHT << 1, 0);     // FIXME: must use surface height

                        // calculate polygon
                        calculate_side(i->x, i->y, j->x, j->y, low, high);
                        calculate_side(j->x, j->y, k->x, k->y, low, high);
                        calculate_side(k->x, k->y, i->x, i->y, low, high);

                        top = (i->y < j->y) ? ((i->y < k->y) ? i->y : k->y) : ((j->y < k->y) ? j->y : k->y);
                        bottom = (i->y > j->y) ? ((i->y > k->y) ? i->y : k->y) : ((j->y > k->y) ? j->y : k->y);

                        for (l = top; l <= bottom; l++) {
                                surface_hline(s, low[l], l, high[l], DITHER(li, l));
                        }
                }
                t++;
        }       
}

---