---

gtcmesh.h

Go to the documentation of this file.

/*
    Sebastien Loisel's Toolchest
    Copyright (C) 1998 Sebastien Loisel

    $Header: /home/gtc/public_html/gtc-cvs/toolchest/include/gtcmesh.h,v 1.11 2000/06/25 05:11:52 loisel Exp $
    */

/* Meshes! */

#ifndef Z_BASEMESH_H
#define Z_BASEMESH_H

#include <gtcutils.h>

/* gtcSimpleMesh: a 3d graphical mesh.
   This holds all the information that GTC needs to draw a textured mesh
   with vertex normals and all that. A special feature is also the vertex
   weights. The crucial API function is gtc_put_simple_mesh. If you fill in the
   various fields properly, you won't need any function but
   gtc_put_mesh() (and
   some OpenGL setup code). Here is a description of all the entries of the
   struct and what gtc_put_mesh does with it.

   name: This field isn't used by gtc_put_mesh but is useful to have around for
   some of the mesh loading facilities (more specifically, the .asc and .ase
   import functions).

   v: vertices, an array of gtcReal[3] -- each vertex is given an x, y and z
   coordinate.

   n: normals, an array of gtcReal[3] -- each vertex is given a normal, and
   this is the (x,y,z) coordinates of a given vertex's normal. If this pointer
   is zero, normals aren't sent to OpenGL.

   t: texture coordinates, an array of gtcReal[3] -- each vertex is given
   some texture coordinates. If the pointer is zero, texture coordinates are
   not sent to OpenGL.

   w: weights: an array of gtcReal[numw]. This is for skeleton animations.
   In a skeleton animation, each bone is represented by an affine transform.
   Each vertex is affected by one or more bones. If there are n bones, there
   are n affine transforms, A[0] through A[n-1], that can affect a vertex v.
   The net affine transform affecting vertex v[k] is given by the formula
   A = w[k][0]*A[0] + w[k][1]*A[1] + ... + w[k][n-1]*A[n-1].
   That is, with the above A, the transformed vertex v will be Av.

   f: face index. The k_th triangle of the mesh is (f[k][0],f[k][1],f[k][2]),
   these three integers tell you which vertices to use to form that triangle.
   To use backface culling, try to orient these properly.

   numf: number of faces.

   numv: number of vertices.

   numw: number of weights. If zero, there's one affine transform and the
   weight is one for all vertices. This is the fast path (if the hardware
   supports it, this has a shot at being hardware accelerated and transformed
   by the hardware geometry engine). If there are weights, unless some
   geometry accelerated card manufacturer puts in an extension for this
   precise purpose, the vertices have to be transformed in software.

   texid: a texture id. If zero, unused, otherwise, this is the OpenGL texture
   id to use for the mesh. Note there's only one texture per gtcSimpleMesh.

   Note. If a vertex is transformed by a 3x3 matrix A then its normal needs
   to be transformed by (A^-1)' (' is transpose). Sadly, there's a matrix
   inverse in that computation. If every vertex is transformed through the
   same matrix, that's ok. If every vertex is transformed through a different
   matrix (as is the case when weights are used), that would involve one
   matrix inversion per vertex, which is expensive. An approximation is used.
*/

typedef struct
{
  char *name;
  gtcReal (*v)[3];
  gtcReal (*n)[3];
  gtcReal (*t)[2];
  gtcReal *w;
  int (*f)[3];
  int numf,
    numv,
    numw,
    texid;
} gtcSimpleMesh;

/* gtc_put_simple_mesh_wremap: puts the mesh to the screen. The matrices
   are sent by pointer, that is, A[0] is a pointer to the first matrix,
   A[1] a pointer to the second, etc... If m->numw=1, you only need to
   send a single matrix. An[k] needs to point to a matrix whose linear part is
   equal to (A[k]^-1)' where the apostrophe denotes the matrix transpose. This
   functions will never use hardware geometry transform -- the vertices and
   normals are transformed in software. Don't use this function if m->numw=0.
*/

void gtc_put_mesh(int f[][3], gtcReal v[][3], gtcReal n[][3], int texid,
                  gtcReal t[][2], int numf);
void gtc_put_simple_mesh_wremap(gtcSimpleMesh *m, gtcReal (*A[])[4][4],
                                gtcReal (*An[])[4][4]);
void gtc_put_simple_mesh(gtcSimpleMesh *m, gtcReal A[][4][4]);
typedef gtcReal (*I_dont_know_all_I_need_to_know)[4][4];
I_dont_know_all_I_need_to_know gtc_prep_An(int numw, gtcReal A[][4][4]);
void gtc_put_simple_mesh_easy(gtcSimpleMesh *m, gtcReal A[4][4]);

void gtc_normalize_mesh(gtcReal v[][3], int numv);
void gtc_normalize_simple_mesh(gtcSimpleMesh *m);

gtcSimpleMesh *gtc_simple_mesh_new(char *name, int numf, int numv);
gtcSimpleMesh *gtc_simple_mesh_tex_new(char *name, int numf, int numv);
gtcSimpleMesh *gtc_simple_mesh_w_new(char *name, int numf, int numv, int numw);
gtcSimpleMesh *gtc_simple_mesh_wtex_new(char *name, int numf,
                                        int numv, int numw);
void gtc_simple_texcoord(gtcSimpleMesh *m);
void gtc_simple_mesh_free(gtcSimpleMesh *m);

/* Basic vector functionality here */
gtcReal gtc_dot(gtcReal a[], gtcReal b[], int n); /* dot product */
void gtc_cross(gtcReal a[3], gtcReal b[3], gtcReal r[3]); /* cross product */
void gtc_add(gtcReal a[], gtcReal b[], gtcReal r[], int n); /* vector addition */
void gtc_sub(gtcReal a[], gtcReal b[], gtcReal r[], int n); /* difference */
gtcReal gtc_norm(gtcReal a[], int n); /* norm */
void gtc_addscale(gtcReal s, gtcReal a[], gtcReal r[], int n);
/* add and scale: r+=s*a; */
void gtc_zero(gtcReal z[], int n); /* zeroes the vector */
void gtc_copy(gtcReal a[], gtcReal r[], int n); /* copies the vector */

/* Setting normals */
void gtc_cum_face(int f[3], gtcReal v[][3], gtcReal n[][3]);
/* Adds a face's normal (properly scaled) to its vertices */
void gtc_set_normals(int f[][3], gtcReal v[][3], gtcReal n[][3],
                     int numf, int numv); /* Set all vertex normals. */

void gtc_make_face(int f[], int a, int b, int c);
/* This one takes four vertices and spits back a mesh of the tetrahedron
   of these four vertices. */
void gtc_tetrahedron(gtcReal v[4][3], int f[4][3]);

void gtc_simple_GL_setup(void);
/* Before calling putmesh, you should set up GL so that it understands what
   you're saying. This function does exactly that, for a simple example
   with some lights. */

/* gtc_GL_setup: I know I'm against wrappers but this one was very useful
   so I made it anyway. You tell it if you want the various options
   (GL_NORMALIZE, GL_SMOOTH, GL_LIGHTING, GL_CULL) by passing a 1 (for yes)
   or a zero (for no) in the appropriate parameter. near, far are the near
   and far clipping planes. fov is the (vertical) field of vision in degrees,
   the horizontal field of vision is computed from the vertical one, the
   width of the viewport and assuming that the aspect ratio is 1:1. if
   clear==1 then it will also call glClear. */
void gtc_GL_setup(int normalize, int smooth, int lighting, int cull, int clear,
                  gtcReal near, gtcReal far, gtcReal fov, gtcReal w_div_h);
/* gtc_GL_setupall: calls gtc_GL_setup with all options and reasonable near,
   far, fov. */
void gtc_GL_setupall(gtcReal w_div_h);

#if 0
int gtctricollide(gtcvec u1, gtcvec u2, gtcvec u3,
                  gtcvec v1, gtcvec v2, gtcvec v3);
#endif

/* Mesh transform */
void gtc_apply(gtcReal A[4][4], gtcReal v[3], gtcReal r[3]);
/* transform a single vector */
void gtc_xform_pos(gtcReal A[4][4], gtcReal v[][3], gtcReal r[][3], int numv);
void gtc_combine(gtcReal a[4][4], gtcReal b[4][4], gtcReal r[4][4]);
/* affine group multiplication */
void gtc_rot(gtcReal x, gtcReal y, gtcReal z, gtcReal theta, gtcReal R[4][4]);
/* generates a rotation about (x,y,z) by theta (in radians). */
void gtc_redress(gtcReal r[4][4]);
void gtc_xlat(gtcReal x, gtcReal y, gtcReal z, gtcReal T[4][4]);
/* makes a translation */
void gtc_ident(gtcReal I[4][4]); /* returns the identity */
void gtcaffinecopy(gtcReal A[4][4], gtcReal R[4][4]); /* copies */
gtcReal gtc_determinant_3(gtcReal A[4][4]);
/* Computes the determinant of the 3x3 linear transform */
void gtc_invert(gtcReal A[4][4], gtcReal R[4][4]); /* inverses */
int gtc_check_ortho(gtcReal A[4][4], gtcReal epsilon);
/* Checks if the linear part of A is orthogonal. Tolerance epsilon. */
int gtc_check_rot(gtcReal A[4][4], gtcReal epsilon);
/* Checks if the linear part of A is a rotation
   (=orthogonal of determinant 1). */

char *gtc_first_tok(char *s);
char *gtc_next_tok(char *s);

/* Quaternions. Quaternions can be used to represent rotations. If
   a matrix is not a rotation then do not try to convert it to a
   quaternion, you'll get garbage. To check if a matrix is a rotation,
   use gtc_check_rot above. */

void gtc_quaternion_to_matrix(gtcReal Q[4], gtcReal M[4][4]);
void gtc_matrix_to_quaternion(gtcReal M[4][4], gtcReal Q[4]);

gtcSimpleMesh *gtc_stars(void);

#endif
 

---