[brlcad-commits] SF.net SVN: brlcad:[42096] brlcad/trunk/src/adrt
Open Source Solid Modeling CAD
Brought to you by:
brlcad
Menu
▾
▴
[brlcad-commits] SF.net SVN: brlcad:[42096] brlcad/trunk/src/adrt
|
From: <eri...@us...> - 2011-01-11 22:37:36
|
Revision: 42096
http://brlcad.svn.sourceforge.net/brlcad/?rev=42096&view=rev
Author: erikgreenwald
Date: 2011-01-11 22:37:27 +0000 (Tue, 11 Jan 2011)
Log Message:
-----------
major migration to use significantly more vmath types/macros
Modified Paths:
--------------
brlcad/trunk/src/adrt/adrt_struct.h
brlcad/trunk/src/adrt/librender/camera.c
brlcad/trunk/src/adrt/librender/camera.h
brlcad/trunk/src/adrt/librender/component.c
brlcad/trunk/src/adrt/librender/cut.c
brlcad/trunk/src/adrt/librender/flos.c
brlcad/trunk/src/adrt/librender/grid.c
brlcad/trunk/src/adrt/librender/hit.c
brlcad/trunk/src/adrt/librender/normal.c
brlcad/trunk/src/adrt/librender/path.c
brlcad/trunk/src/adrt/librender/phong.c
brlcad/trunk/src/adrt/librender/render_util.c
brlcad/trunk/src/adrt/librender/render_util.h
brlcad/trunk/src/adrt/librender/spall.c
brlcad/trunk/src/adrt/librender/surfel.c
brlcad/trunk/src/adrt/librender/texture.h
brlcad/trunk/src/adrt/librender/texture_blend.c
brlcad/trunk/src/adrt/librender/texture_bump.c
brlcad/trunk/src/adrt/librender/texture_camo.c
brlcad/trunk/src/adrt/librender/texture_checker.c
brlcad/trunk/src/adrt/librender/texture_clouds.c
brlcad/trunk/src/adrt/librender/texture_gradient.c
brlcad/trunk/src/adrt/librender/texture_image.c
brlcad/trunk/src/adrt/librender/texture_internal.h
brlcad/trunk/src/adrt/librender/texture_mix.c
brlcad/trunk/src/adrt/librender/texture_perlin.c
brlcad/trunk/src/adrt/libtie/tie.c
brlcad/trunk/src/adrt/libtie/tie.h
brlcad/trunk/src/adrt/libtie/tie_kdtree.c
brlcad/trunk/src/adrt/libtie/tie_kdtree0.c
Modified: brlcad/trunk/src/adrt/adrt_struct.h
===================================================================
--- brlcad/trunk/src/adrt/adrt_struct.h 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/adrt_struct.h 2011-01-11 22:37:27 UTC (rev 42096)
@@ -44,10 +44,10 @@
/* Attributes */
typedef struct adrt_mesh_attributes_s {
TIE_3 color; /* base color of the material */
- tfloat density; /* density of the material, x-ray/vulnerability stuff */
- tfloat gloss; /* smoothness of the surface, ability to reflect */
- tfloat emission; /* emission, power of light source */
- tfloat ior; /* index of refraction */
+ fastf_t density; /* density of the material, x-ray/vulnerability stuff */
+ fastf_t gloss; /* smoothness of the surface, ability to reflect */
+ fastf_t emission; /* emission, power of light source */
+ fastf_t ior; /* index of refraction */
} adrt_mesh_attributes_t;
@@ -57,9 +57,9 @@
int flags;
int matid;
char name[256];
- TIE_3 min, max;
- tfloat matrix[16];
- tfloat matinv[16];
+ vect_t min, max;
+ fastf_t matrix[16];
+ fastf_t matinv[16];
adrt_mesh_attributes_t *attributes;
struct texture_s *texture;
} adrt_mesh_t;
Modified: brlcad/trunk/src/adrt/librender/camera.c
===================================================================
--- brlcad/trunk/src/adrt/librender/camera.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/camera.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -105,176 +105,176 @@
static void
render_camera_prep_ortho(render_camera_t *camera)
{
- TIE_3 look, up, side, temp;
+ vect_t look, up, side, temp;
tfloat angle, s, c;
/* Generate standard up vector */
- up.v[0] = 0;
- up.v[1] = 0;
- up.v[2] = 1;
+ up[0] = 0;
+ up[1] = 0;
+ up[2] = 1;
- /* Generate unitized look vector */
- VSUB2(look.v, camera->focus.v, camera->pos.v);
- VUNITIZE(look.v);
+ /* Generate unitized lookector */
+ VSUB2(look, camera->focus, camera->pos);
+ VUNITIZE(look);
- /* Make unitized up vector perpendicular to look vector */
- temp = look;
- angle = VDOT( up.v, temp.v);
- VSCALE(temp.v, temp.v, angle);
- VSUB2(up.v, up.v, temp.v);
- VUNITIZE(up.v);
+ /* Make unitized up vector perpendicular to lookector */
+ VMOVE(temp, look);
+ angle = VDOT( up, temp);
+ VSCALE(temp, temp, angle);
+ VSUB2(up, up, temp);
+ VUNITIZE(up);
/* Generate a temporary side vector */
- VCROSS(side.v, up.v, look.v);
+ VCROSS(side, up, look);
/* Apply tilt to up vector - negate angle to make positive angles clockwise */
s = sin(-camera->tilt * DEG2RAD);
c = cos(-camera->tilt * DEG2RAD);
- VSCALE(up.v, up.v, c);
- VSCALE(side.v, side.v, s);
- VADD2(up.v, up.v, side.v);
+ VSCALE(up, up, c);
+ VSCALE(side, side, s);
+ VADD2(up, up, side);
/* Create final side vector */
- VCROSS(side.v, up.v, look.v);
+ VCROSS(side, up, look);
/* look direction */
- camera->view_list[0].top_l = look;
+ VMOVE(camera->view_list[0].top_l, look);
/* gridsize is milimeters along the horizontal axis to display */
/* left (side) */
- VSCALE(temp.v, side.v, (camera->aspect * camera->gridsize * 0.5));
- VADD2(camera->view_list[0].pos.v, camera->pos.v, temp.v);
+ VSCALE(temp, side, (camera->aspect * camera->gridsize * 0.5));
+ VADD2(camera->view_list[0].pos, camera->pos, temp);
/* and (up) */
- VSCALE(temp.v, up.v, (camera->gridsize * 0.5));
- VADD2(camera->view_list[0].pos.v, camera->view_list[0].pos.v, temp.v);
+ VSCALE(temp, up, (camera->gridsize * 0.5));
+ VADD2(camera->view_list[0].pos, camera->view_list[0].pos, temp);
/* compute step vectors for camera position */
/* X */
- VSCALE(camera->view_list[0].step_x.v, side.v, (-camera->gridsize * camera->aspect / (tfloat)camera->w));
+ VSCALE(camera->view_list[0].step_x, side, (-camera->gridsize * camera->aspect / (tfloat)camera->w));
/* Y */
- VSCALE(camera->view_list[0].step_y.v, up.v, (-camera->gridsize / (tfloat)camera->h));
+ VSCALE(camera->view_list[0].step_y, up, (-camera->gridsize / (tfloat)camera->h));
}
static void
render_camera_prep_persp(render_camera_t *camera)
{
- TIE_3 look, up, side, temp, topl, topr, botl;
+ vect_t look, up, side, temp, topl, topr, botl;
tfloat angle, s, c;
- /* Generate unitized look vector */
- VSUB2(look.v, camera->focus.v, camera->pos.v);
- VUNITIZE(look.v);
+ /* Generate unitized lookector */
+ VSUB2(look, camera->focus, camera->pos);
+ VUNITIZE(look);
/* Generate standard up vector */
- up.v[0] = 0;
- up.v[1] = 0;
- up.v[2] = 1;
+ up[0] = 0;
+ up[1] = 0;
+ up[2] = 1;
- /* Make unitized up vector perpendicular to look vector */
- temp = look;
- angle = VDOT( up.v, temp.v);
- VSCALE(temp.v, temp.v, angle);
- VSUB2(up.v, up.v, temp.v);
- VUNITIZE(up.v);
+ /* Make unitized up vector perpendicular to lookector */
+ VMOVE(temp, look);
+ angle = VDOT(up, temp);
+ VSCALE(temp, temp, angle);
+ VSUB2(up, up, temp);
+ VUNITIZE(up);
/* Generate a temporary side vector */
- VCROSS(side.v, up.v, look.v);
+ VCROSS(side, up, look);
/* Apply tilt to up vector - negate angle to make positive angles clockwise */
s = sin(-camera->tilt * DEG2RAD);
c = cos(-camera->tilt * DEG2RAD);
- VSCALE(up.v, up.v, c);
- VSCALE(side.v, side.v, s);
- VADD2(up.v, up.v, side.v);
+ VSCALE(up, up, c);
+ VSCALE(side, side, s);
+ VADD2(up, up, side);
/* Create final side vector */
- VCROSS(side.v, up.v, look.v);
+ VCROSS(side, up, look);
/* Compute sine and cosine terms for field of view */
s = sin(camera->fov*DEG2RAD);
c = cos(camera->fov*DEG2RAD);
/* Up, Look, and Side vectors are complete, generate Top Left reference vector */
- topl.v[0] = s*up.v[0] + camera->aspect*s*side.v[0] + c*look.v[0];
- topl.v[1] = s*up.v[1] + camera->aspect*s*side.v[1] + c*look.v[1];
- topl.v[2] = s*up.v[2] + camera->aspect*s*side.v[2] + c*look.v[2];
+ topl[0] = s*up[0] + camera->aspect*s*side[0] + c*look[0];
+ topl[1] = s*up[1] + camera->aspect*s*side[1] + c*look[1];
+ topl[2] = s*up[2] + camera->aspect*s*side[2] + c*look[2];
- topr.v[0] = s*up.v[0] - camera->aspect*s*side.v[0] + c*look.v[0];
- topr.v[1] = s*up.v[1] - camera->aspect*s*side.v[1] + c*look.v[1];
- topr.v[2] = s*up.v[2] - camera->aspect*s*side.v[2] + c*look.v[2];
+ topr[0] = s*up[0] - camera->aspect*s*side[0] + c*look[0];
+ topr[1] = s*up[1] - camera->aspect*s*side[1] + c*look[1];
+ topr[2] = s*up[2] - camera->aspect*s*side[2] + c*look[2];
- botl.v[0] = -s*up.v[0] + camera->aspect*s*side.v[0] + c*look.v[0];
- botl.v[1] = -s*up.v[1] + camera->aspect*s*side.v[1] + c*look.v[1];
- botl.v[2] = -s*up.v[2] + camera->aspect*s*side.v[2] + c*look.v[2];
+ botl[0] = -s*up[0] + camera->aspect*s*side[0] + c*look[0];
+ botl[1] = -s*up[1] + camera->aspect*s*side[1] + c*look[1];
+ botl[2] = -s*up[2] + camera->aspect*s*side[2] + c*look[2];
- VUNITIZE(topl.v);
- VUNITIZE(botl.v);
- VUNITIZE(topr.v);
+ VUNITIZE(topl);
+ VUNITIZE(botl);
+ VUNITIZE(topr);
/* Store Camera Position */
- camera->view_list[0].pos = camera->pos;
+ VMOVE(camera->view_list[0].pos, camera->pos);
/* Store the top left vector */
- camera->view_list[0].top_l = topl;
+ VMOVE(camera->view_list[0].top_l, topl);
/* Generate stepx and stepy vectors for sampling each pixel */
- VSUB2(camera->view_list[0].step_x.v, topr.v, topl.v);
- VSUB2(camera->view_list[0].step_y.v, botl.v, topl.v);
+ VSUB2(camera->view_list[0].step_x, topr, topl);
+ VSUB2(camera->view_list[0].step_y, botl, topl);
/* Divide stepx and stepy by the number of pixels */
- VSCALE(camera->view_list[0].step_x.v, camera->view_list[0].step_x.v, 1.0 / camera->w);
- VSCALE(camera->view_list[0].step_y.v, camera->view_list[0].step_y.v, 1.0 / camera->h);
+ VSCALE(camera->view_list[0].step_x, camera->view_list[0].step_x, 1.0 / camera->w);
+ VSCALE(camera->view_list[0].step_y, camera->view_list[0].step_y, 1.0 / camera->h);
return;
}
static void
render_camera_prep_persp_dof(render_camera_t *camera)
{
- TIE_3 look, up, side, dof_look, dof_up, dof_side, dof_topl, dof_topr, dof_botl, temp, step_x, step_y, topl, topr, botl;
+ vect_t look, up, side, dof_look, dof_up, dof_side, dof_topl, dof_topr, dof_botl, temp, step_x, step_y, topl, topr, botl;
tfloat angle, mag, sfov, cfov, sdof, cdof;
uint32_t i, n;
- /* Generate unitized look vector */
- VSUB2(dof_look.v, camera->focus.v, camera->pos.v);
- VUNITIZE(dof_look.v);
+ /* Generate unitized lookector */
+ VSUB2(dof_look, camera->focus, camera->pos);
+ VUNITIZE(dof_look);
/* Generate standard up vector */
- dof_up.v[0] = 0;
- dof_up.v[1] = 0;
- dof_up.v[2] = 1;
+ dof_up[0] = 0;
+ dof_up[1] = 0;
+ dof_up[2] = 1;
- /* Make unitized up vector perpendicular to look vector */
- temp = dof_look;
- angle = VDOT( dof_up.v, temp.v);
- VSCALE(temp.v, temp.v, angle);
- VSUB2(dof_up.v, dof_up.v, temp.v);
- VUNITIZE(dof_up.v);
+ /* Make unitized up vector perpendicular to lookector */
+ VMOVE(temp, dof_look);
+ angle = VDOT( dof_up, temp);
+ VSCALE(temp, temp, angle);
+ VSUB2(dof_up, dof_up, temp);
+ VUNITIZE(dof_up);
/* Generate a temporary side vector */
- VCROSS(dof_side.v, dof_up.v, dof_look.v);
+ VCROSS(dof_side, dof_up, dof_look);
/* Apply tilt to up vector - negate angle to make positive angles clockwise */
sdof = sin(-camera->tilt * DEG2RAD);
cdof = cos(-camera->tilt * DEG2RAD);
- VSCALE(dof_up.v, dof_up.v, cdof);
- VSCALE(dof_side.v, dof_side.v, sdof);
- VADD2(dof_up.v, dof_up.v, dof_side.v);
+ VSCALE(dof_up, dof_up, cdof);
+ VSCALE(dof_side, dof_side, sdof);
+ VADD2(dof_up, dof_up, dof_side);
/* Create final side vector */
- VCROSS(dof_side.v, dof_up.v, dof_look.v);
+ VCROSS(dof_side, dof_up, dof_look);
/*
* Generage a camera position, top left vector, and step vectors for each DOF sample
*/
- /* Obtain magnitude of reverse look vector */
- VSUB2(dof_look.v, camera->pos.v, camera->focus.v);
- mag = MAGNITUDE(dof_look.v);
- VUNITIZE(dof_look.v);
+ /* Obtain magnitude of reverse lookector */
+ VSUB2(dof_look, camera->pos, camera->focus);
+ mag = MAGNITUDE(dof_look);
+ VUNITIZE(dof_look);
/* Compute sine and cosine terms for field of view */
@@ -283,66 +283,66 @@
/* Up, Look, and Side vectors are complete, generate Top Left reference vector */
- dof_topl.v[0] = sdof*dof_up.v[0] + sdof*dof_side.v[0] + cdof*dof_look.v[0];
- dof_topl.v[1] = sdof*dof_up.v[1] + sdof*dof_side.v[1] + cdof*dof_look.v[1];
- dof_topl.v[2] = sdof*dof_up.v[2] + sdof*dof_side.v[2] + cdof*dof_look.v[2];
+ dof_topl[0] = sdof*dof_up[0] + sdof*dof_side[0] + cdof*dof_look[0];
+ dof_topl[1] = sdof*dof_up[1] + sdof*dof_side[1] + cdof*dof_look[1];
+ dof_topl[2] = sdof*dof_up[2] + sdof*dof_side[2] + cdof*dof_look[2];
- dof_topr.v[0] = sdof*dof_up.v[0] - sdof*dof_side.v[0] + cdof*dof_look.v[0];
- dof_topr.v[1] = sdof*dof_up.v[1] - sdof*dof_side.v[1] + cdof*dof_look.v[1];
- dof_topr.v[2] = sdof*dof_up.v[2] - sdof*dof_side.v[2] + cdof*dof_look.v[2];
+ dof_topr[0] = sdof*dof_up[0] - sdof*dof_side[0] + cdof*dof_look[0];
+ dof_topr[1] = sdof*dof_up[1] - sdof*dof_side[1] + cdof*dof_look[1];
+ dof_topr[2] = sdof*dof_up[2] - sdof*dof_side[2] + cdof*dof_look[2];
- dof_botl.v[0] = -sdof*dof_up.v[0] + sdof*dof_side.v[0] + cdof*dof_look.v[0];
- dof_botl.v[1] = -sdof*dof_up.v[1] + sdof*dof_side.v[1] + cdof*dof_look.v[1];
- dof_botl.v[2] = -sdof*dof_up.v[2] + sdof*dof_side.v[2] + cdof*dof_look.v[2];
+ dof_botl[0] = -sdof*dof_up[0] + sdof*dof_side[0] + cdof*dof_look[0];
+ dof_botl[1] = -sdof*dof_up[1] + sdof*dof_side[1] + cdof*dof_look[1];
+ dof_botl[2] = -sdof*dof_up[2] + sdof*dof_side[2] + cdof*dof_look[2];
- VUNITIZE(dof_topl.v);
- VUNITIZE(dof_botl.v);
- VUNITIZE(dof_topr.v);
+ VUNITIZE(dof_topl);
+ VUNITIZE(dof_botl);
+ VUNITIZE(dof_topr);
- VSUB2(step_x.v, dof_topr.v, dof_topl.v);
- VSUB2(step_y.v, dof_botl.v, dof_topl.v);
+ VSUB2(step_x, dof_topr, dof_topl);
+ VSUB2(step_y, dof_botl, dof_topl);
for (i = 0; i < RENDER_CAMERA_DOF_SAMPLES; i++)
{
for (n = 0; n < RENDER_CAMERA_DOF_SAMPLES; n++)
{
/* Generate virtual camera position for this depth of field sample */
- VSCALE(temp.v, step_x.v, ((tfloat)i/(tfloat)(RENDER_CAMERA_DOF_SAMPLES-1)));
- VADD2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, dof_topl.v, temp.v);
- VSCALE(temp.v, step_y.v, ((tfloat)n/(tfloat)(RENDER_CAMERA_DOF_SAMPLES-1)));
- VADD2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, temp.v);
- VUNITIZE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v);
- VSCALE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, mag);
- VADD2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v, camera->focus.v);
+ VSCALE(temp, step_x, ((tfloat)i/(tfloat)(RENDER_CAMERA_DOF_SAMPLES-1)));
+ VADD2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, dof_topl, temp);
+ VSCALE(temp, step_y, ((tfloat)n/(tfloat)(RENDER_CAMERA_DOF_SAMPLES-1)));
+ VADD2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, temp);
+ VUNITIZE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos);
+ VSCALE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, mag);
+ VADD2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos, camera->focus);
- /* Generate unitized look vector */
- VSUB2(look.v, camera->focus.v, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos.v);
- VUNITIZE(look.v);
+ /* Generate unitized lookector */
+ VSUB2(look, camera->focus, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].pos);
+ VUNITIZE(look);
/* Generate standard up vector */
- up.v[0] = 0;
- up.v[1] = 0;
- up.v[2] = 1;
+ up[0] = 0;
+ up[1] = 0;
+ up[2] = 1;
- /* Make unitized up vector perpendicular to look vector */
- temp = look;
- angle = VDOT( up.v, temp.v);
- VSCALE(temp.v, temp.v, angle);
- VSUB2(up.v, up.v, temp.v);
- VUNITIZE(up.v);
+ /* Make unitized up vector perpendicular to lookector */
+ VMOVE(temp, look);
+ angle = VDOT( up, temp);
+ VSCALE(temp, temp, angle);
+ VSUB2(up, up, temp);
+ VUNITIZE(up);
/* Generate a temporary side vector */
- VCROSS(side.v, up.v, look.v);
+ VCROSS(side, up, look);
/* Apply tilt to up vector - negate angle to make positive angles clockwise */
sfov = sin(-camera->tilt * DEG2RAD);
cfov = cos(-camera->tilt * DEG2RAD);
- VSCALE(up.v, up.v, cfov);
- VSCALE(side.v, side.v, sfov);
- VADD2(up.v, up.v, side.v);
+ VSCALE(up, up, cfov);
+ VSCALE(side, side, sfov);
+ VADD2(up, up, side);
/* Create final side vector */
- VCROSS(side.v, up.v, look.v);
+ VCROSS(side, up, look);
/* Compute sine and cosine terms for field of view */
sfov = sin(camera->fov*DEG2RAD);
@@ -350,32 +350,32 @@
/* Up, Look, and Side vectors are complete, generate Top Left reference vector */
- topl.v[0] = sfov*up.v[0] + camera->aspect*sfov*side.v[0] + cfov*look.v[0];
- topl.v[1] = sfov*up.v[1] + camera->aspect*sfov*side.v[1] + cfov*look.v[1];
- topl.v[2] = sfov*up.v[2] + camera->aspect*sfov*side.v[2] + cfov*look.v[2];
+ topl[0] = sfov*up[0] + camera->aspect*sfov*side[0] + cfov*look[0];
+ topl[1] = sfov*up[1] + camera->aspect*sfov*side[1] + cfov*look[1];
+ topl[2] = sfov*up[2] + camera->aspect*sfov*side[2] + cfov*look[2];
- topr.v[0] = sfov*up.v[0] - camera->aspect*sfov*side.v[0] + cfov*look.v[0];
- topr.v[1] = sfov*up.v[1] - camera->aspect*sfov*side.v[1] + cfov*look.v[1];
- topr.v[2] = sfov*up.v[2] - camera->aspect*sfov*side.v[2] + cfov*look.v[2];
+ topr[0] = sfov*up[0] - camera->aspect*sfov*side[0] + cfov*look[0];
+ topr[1] = sfov*up[1] - camera->aspect*sfov*side[1] + cfov*look[1];
+ topr[2] = sfov*up[2] - camera->aspect*sfov*side[2] + cfov*look[2];
- botl.v[0] = -sfov*up.v[0] + camera->aspect*sfov*side.v[0] + cfov*look.v[0];
- botl.v[1] = -sfov*up.v[1] + camera->aspect*sfov*side.v[1] + cfov*look.v[1];
- botl.v[2] = -sfov*up.v[2] + camera->aspect*sfov*side.v[2] + cfov*look.v[2];
+ botl[0] = -sfov*up[0] + camera->aspect*sfov*side[0] + cfov*look[0];
+ botl[1] = -sfov*up[1] + camera->aspect*sfov*side[1] + cfov*look[1];
+ botl[2] = -sfov*up[2] + camera->aspect*sfov*side[2] + cfov*look[2];
- VUNITIZE(topl.v);
- VUNITIZE(botl.v);
- VUNITIZE(topr.v);
+ VUNITIZE(topl);
+ VUNITIZE(botl);
+ VUNITIZE(topr);
/* Store the top left vector */
- camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].top_l = topl;
+ VMOVE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].top_l, topl);
/* Generate stepx and stepy vectors for sampling each pixel */
- VSUB2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_x.v, topr.v, topl.v);
- VSUB2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_y.v, botl.v, topl.v);
+ VSUB2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_x, topr, topl);
+ VSUB2(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_y, botl, topl);
/* Divide stepx and stepy by the number of pixels */
- VSCALE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_x.v, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_x.v, 1.0 / camera->w);
- VSCALE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_y.v, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_y.v, 1.0 / camera->h);
+ VSCALE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_x, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_x, 1.0 / camera->w);
+ VSCALE(camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_y, camera->view_list[i*RENDER_CAMERA_DOF_SAMPLES+n].step_y, 1.0 / camera->h);
}
}
}
@@ -412,11 +412,11 @@
{
render_camera_thread_data_t *td;
int d, n, res_ind, scanline, v_scanline;
- TIE_3 pixel, accum, v1, v2;
+ vect_t pixel, accum, v1, v2;
struct tie_ray_s ray;
tfloat view_inv;
- VSETALL(v1.v, 0);
+ VSETALL(v1, 0);
td = (render_camera_thread_data_t *)ptr;
view_inv = 1.0 / td->camera->view_num;
@@ -459,8 +459,8 @@
/* optimization if there is no depth of field being applied */
if (td->camera->view_num == 1)
{
- VSCALE(v1.v, td->camera->view_list[0].step_y.v, v_scanline);
- VADD2(v1.v, v1.v, td->camera->view_list[0].top_l.v);
+ VSCALE(v1, td->camera->view_list[0].step_y, v_scanline);
+ VADD2(v1, v1, td->camera->view_list[0].top_l);
}
@@ -470,55 +470,55 @@
/* depth of view samples */
if (td->camera->view_num > 1)
{
- VSET(accum.v, 0, 0, 0);
+ VSET(accum, 0, 0, 0);
for (d = 0; d < td->camera->view_num; d++)
{
- VSCALE(ray.dir.v, td->camera->view_list[d].step_y.v, v_scanline);
- VADD2(ray.dir.v, ray.dir.v, td->camera->view_list[d].top_l.v);
- VSCALE(v1.v, td->camera->view_list[d].step_x.v, n);
- VADD2(ray.dir.v, ray.dir.v, v1.v);
+ VSCALE(ray.dir, td->camera->view_list[d].step_y, v_scanline);
+ VADD2(ray.dir, ray.dir, td->camera->view_list[d].top_l);
+ VSCALE(v1, td->camera->view_list[d].step_x, n);
+ VADD2(ray.dir, ray.dir, v1);
- VSET(pixel.v, (tfloat)RENDER_CAMERA_BGR, (tfloat)RENDER_CAMERA_BGG, (tfloat)RENDER_CAMERA_BGB);
+ VSET(pixel, (tfloat)RENDER_CAMERA_BGR, (tfloat)RENDER_CAMERA_BGG, (tfloat)RENDER_CAMERA_BGB);
- ray.pos = td->camera->view_list[d].pos;
+ VMOVE(ray.pos, td->camera->view_list[d].pos);
ray.depth = 0;
- VUNITIZE(ray.dir.v);
+ VUNITIZE(ray.dir);
/* Compute pixel value using this ray */
td->camera->render.work(&td->camera->render, td->tie, &ray, &pixel);
- VADD2(accum.v, accum.v, pixel.v);
+ VADD2(accum, accum, pixel);
}
/* Find Mean value of all views */
- VSCALE(pixel.v, accum.v, view_inv);
+ VSCALE(pixel, accum, view_inv);
}
else
{
if (td->camera->type == RENDER_CAMERA_PERSPECTIVE)
{
- VSCALE(v2.v, td->camera->view_list[0].step_x.v, n);
- VADD2(ray.dir.v, v1.v, v2.v);
+ VSCALE(v2, td->camera->view_list[0].step_x, n);
+ VADD2(ray.dir, v1, v2);
- VSET(pixel.v, (tfloat)RENDER_CAMERA_BGR, (tfloat)RENDER_CAMERA_BGG, (tfloat)RENDER_CAMERA_BGB);
+ VSET(pixel, (tfloat)RENDER_CAMERA_BGR, (tfloat)RENDER_CAMERA_BGG, (tfloat)RENDER_CAMERA_BGB);
- ray.pos = td->camera->view_list[0].pos;
+ VMOVE(ray.pos, td->camera->view_list[0].pos);
ray.depth = 0;
- VUNITIZE(ray.dir.v);
+ VUNITIZE(ray.dir);
/* Compute pixel value using this ray */
td->camera->render.work(&td->camera->render, td->tie, &ray, &pixel);
} else {
- ray.pos = td->camera->view_list[0].pos;
- ray.dir = td->camera->view_list[0].top_l;
+ VMOVE(ray.pos, td->camera->view_list[0].pos);
+ VMOVE(ray.dir, td->camera->view_list[0].top_l);
- VSCALE(v1.v, td->camera->view_list[0].step_x.v, n);
- VSCALE(v2.v, td->camera->view_list[0].step_y.v, v_scanline);
- VADD2(ray.pos.v, ray.pos.v, v1.v);
- VADD2(ray.pos.v, ray.pos.v, v2.v);
+ VSCALE(v1, td->camera->view_list[0].step_x, n);
+ VSCALE(v2, td->camera->view_list[0].step_y, v_scanline);
+ VADD2(ray.pos, ray.pos, v1);
+ VADD2(ray.pos, ray.pos, v2);
- VSET(pixel.v, (tfloat)RENDER_CAMERA_BGR, (tfloat)RENDER_CAMERA_BGG, (tfloat)RENDER_CAMERA_BGB);
+ VSET(pixel, (tfloat)RENDER_CAMERA_BGR, (tfloat)RENDER_CAMERA_BGG, (tfloat)RENDER_CAMERA_BGB);
ray.depth = 0;
/* Compute pixel value using this ray */
@@ -529,12 +529,12 @@
if (td->tile->format == RENDER_CAMERA_BIT_DEPTH_24)
{
- if (pixel.v[0] > 1) pixel.v[0] = 1;
- if (pixel.v[1] > 1) pixel.v[1] = 1;
- if (pixel.v[2] > 1) pixel.v[2] = 1;
- ((char *)(td->res_buf))[res_ind+0] = (unsigned char)(255 * pixel.v[0]);
- ((char *)(td->res_buf))[res_ind+1] = (unsigned char)(255 * pixel.v[1]);
- ((char *)(td->res_buf))[res_ind+2] = (unsigned char)(255 * pixel.v[2]);
+ if (pixel[0] > 1) pixel[0] = 1;
+ if (pixel[1] > 1) pixel[1] = 1;
+ if (pixel[2] > 1) pixel[2] = 1;
+ ((char *)(td->res_buf))[res_ind+0] = (unsigned char)(255 * pixel[0]);
+ ((char *)(td->res_buf))[res_ind+1] = (unsigned char)(255 * pixel[1]);
+ ((char *)(td->res_buf))[res_ind+2] = (unsigned char)(255 * pixel[2]);
res_ind += 3;
}
else if (td->tile->format == RENDER_CAMERA_BIT_DEPTH_128)
@@ -543,9 +543,9 @@
alpha = 1.0;
- ((tfloat *)(td->res_buf))[res_ind + 0] = pixel.v[0];
- ((tfloat *)(td->res_buf))[res_ind + 1] = pixel.v[1];
- ((tfloat *)(td->res_buf))[res_ind + 2] = pixel.v[2];
+ ((tfloat *)(td->res_buf))[res_ind + 0] = pixel[0];
+ ((tfloat *)(td->res_buf))[res_ind + 1] = pixel[1];
+ ((tfloat *)(td->res_buf))[res_ind + 2] = pixel[2];
((tfloat *)(td->res_buf))[res_ind + 3] = alpha;
res_ind += 4;
Modified: brlcad/trunk/src/adrt/librender/camera.h
===================================================================
--- brlcad/trunk/src/adrt/librender/camera.h 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/camera.h 2011-01-11 22:37:27 UTC (rev 42096)
@@ -41,18 +41,18 @@
typedef struct render_camera_view_s
{
- TIE_3 step_x;
- TIE_3 step_y;
- TIE_3 pos;
- TIE_3 top_l;
+ vect_t step_x;
+ vect_t step_y;
+ vect_t pos;
+ vect_t top_l;
} render_camera_view_t;
typedef struct render_camera_s
{
uint8_t type;
- TIE_3 pos;
- TIE_3 focus;
+ point_t pos;
+ vect_t focus;
fastf_t tilt;
fastf_t fov;
fastf_t gridsize;
Modified: brlcad/trunk/src/adrt/librender/component.c
===================================================================
--- brlcad/trunk/src/adrt/librender/component.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/component.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -50,16 +50,16 @@
if ((mesh = (adrt_mesh_t *)tie_work(tie, ray, &id, component_hit, NULL))) {
/* Flip normal to face ray origin (via dot product check) */
- if (ray->dir.v[0] * id.norm.v[0] + ray->dir.v[1] * id.norm.v[1] + ray->dir.v[2] * id.norm.v[2] > 0)
- VSCALE(id.norm.v, id.norm.v, -1.0);
+ if (ray->dir[0] * id.norm[0] + ray->dir[1] * id.norm[1] + ray->dir[2] * id.norm[2] > 0)
+ VSCALE(id.norm, id.norm, -1.0);
/* shade solid */
pixel->v[0] = mesh->flags & ADRT_MESH_HIT ? 0.8 : 0.2;
pixel->v[1] = (tfloat)0.2;
pixel->v[2] = mesh->flags & ADRT_MESH_SELECT ? 0.8 : 0.2;
- VSUB2(vec.v, ray->pos.v, id.pos.v);
+ VSUB2(vec.v, ray->pos, id.pos);
VUNITIZE(vec.v);
- VSCALE((*pixel).v, (*pixel).v, VDOT(vec.v, id.norm.v) * 0.8);
+ VSCALE((*pixel).v, (*pixel).v, VDOT(vec.v, id.norm) * 0.8);
} else if (ray->depth) {
pixel->v[0] += (tfloat)0.2;
pixel->v[1] += (tfloat)0.2;
Modified: brlcad/trunk/src/adrt/librender/cut.c
===================================================================
--- brlcad/trunk/src/adrt/librender/cut.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/cut.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -40,8 +40,8 @@
void render_cut(struct tie_s *tie, struct tie_ray_s *ray, TIE_3 *pixel);
typedef struct render_cut_s {
- TIE_3 ray_pos;
- TIE_3 ray_dir;
+ point_t ray_pos;
+ vect_t ray_dir;
tfloat plane[4];
struct tie_s tie;
} render_cut_t;
@@ -112,7 +112,7 @@
* I don't think this needs to be done for every pixel?
* Flip plane normal to face us.
*/
- t = ray->pos.v[0]*rd->plane[0] + ray->pos.v[1]*rd->plane[1] + ray->pos.v[2]*rd->plane[2] + rd->plane[3];
+ t = ray->pos[0]*rd->plane[0] + ray->pos[1]*rd->plane[1] + ray->pos[2]*rd->plane[2] + rd->plane[3];
hit.mod = t < 0 ? 1 : -1;
@@ -123,16 +123,16 @@
* Ray = O + td
* t = -(Pn \xB7 R0 + D) / (Pn \xB7 Rd)
*/
- t = (rd->plane[0]*ray->pos.v[0] + rd->plane[1]*ray->pos.v[1] + rd->plane[2]*ray->pos.v[2] + rd->plane[3]) /
- (rd->plane[0]*ray->dir.v[0] + rd->plane[1]*ray->dir.v[1] + rd->plane[2]*ray->dir.v[2]);
+ t = (rd->plane[0]*ray->pos[0] + rd->plane[1]*ray->pos[1] + rd->plane[2]*ray->pos[2] + rd->plane[3]) /
+ (rd->plane[0]*ray->dir[0] + rd->plane[1]*ray->dir[1] + rd->plane[2]*ray->dir[2]);
/* Ray never intersects plane */
if (t > 0)
return;
- ray->pos.v[0] += -t * ray->dir.v[0];
- ray->pos.v[1] += -t * ray->dir.v[1];
- ray->pos.v[2] += -t * ray->dir.v[2];
+ ray->pos[0] += -t * ray->dir[0];
+ ray->pos[1] += -t * ray->dir[1];
+ ray->pos[2] += -t * ray->dir[2];
HMOVE(hit.plane, rd->plane);
/* Render Geometry */
@@ -145,7 +145,7 @@
*/
/* flipped normal */
- dot = fabs(VDOT( ray->dir.v, hit.id.norm.v));
+ dot = fabs(VDOT( ray->dir, hit.id.norm));
if (hit.mesh->flags & (ADRT_MESH_SELECT|ADRT_MESH_HIT)) {
VSET(color.v, hit.mesh->flags & ADRT_MESH_HIT ? (tfloat)0.9 : (tfloat)0.2, (tfloat)0.2, hit.mesh->flags & ADRT_MESH_SELECT ? (tfloat)0.9 : (tfloat)0.2);
@@ -171,7 +171,7 @@
TIE_3 vec;
fastf_t angle;
/* shade solid */
- VSUB2(vec.v, ray->pos.v, hit.id.pos.v);
+ VSUB2(vec.v, ray->pos, hit.id.pos);
VUNITIZE(vec.v);
angle = vec.v[0]*hit.mod*-hit.plane[0] + vec.v[1]*-hit.mod*hit.plane[1] + vec.v[2]*-hit.mod*hit.plane[2];
VSCALE((*pixel).v, color.v, (angle*0.90));
@@ -188,8 +188,8 @@
{
int i;
render_cut_t *d;
- static TIE_3 list[6];
- TIE_3 **tlist, up, ray_pos, ray_dir;
+ static point_t list[6];
+ point_t **tlist, up, ray_pos, ray_dir;
fastf_t shot_len = 100, shot_width = .02;
struct tie_id_s id;
struct tie_ray_s ray;
@@ -199,15 +199,15 @@
return -1;
sscanf(buf, "#(%f %f %f) #(%f %f %f)",
- ray_pos.v, ray_pos.v+1, ray_pos.v+2,
- ray_dir.v, ray_dir.v+1, ray_dir.v+2);
- VUNITIZE(ray_dir.v);
+ ray_pos, ray_pos+1, ray_pos+2,
+ ray_dir, ray_dir+1, ray_dir+2);
+ VUNITIZE(ray_dir);
shot_width = 0.01 * render->tie->radius;
{
vect_t v;
- VSUB2(v, ray_pos.v, render->tie->mid);
+ VSUB2(v, ray_pos, render->tie->mid);
shot_len = 2.0 * render->tie->radius + MAGNITUDE(v) - render->tie->radius;;
}
@@ -215,8 +215,8 @@
* fire through the entire geometry, marking each intersected mesh with
* ADRT_MESH_HIT
*/
- VMOVE(ray.pos.v, ray_pos.v);
- VMOVE(ray.dir.v, ray_dir.v);
+ VMOVE(ray.pos, ray_pos);
+ VMOVE(ray.dir, ray_dir);
ray.depth = 0;
tie_work(render->tie, &ray, &id, render_cut_hit_cutline, &step);
@@ -233,33 +233,33 @@
}
d = (render_cut_t *)render->data;
- d->ray_pos = ray_pos;
- d->ray_dir = ray_dir;
+ VMOVE(d->ray_pos, ray_pos);
+ VMOVE(d->ray_dir, ray_dir);
/* Calculate the normal to be used for the plane */
- VSET(up.v, 0, 0, 1);
- VCROSS(d->plane, ray_dir.v, up.v);
+ VSET(up, 0, 0, 1);
+ VCROSS(d->plane, ray_dir, up);
VUNITIZE(d->plane);
/* Construct the plane */
- d->plane[3] = -VDOT( d->plane, ray_pos.v); /* up is really new ray_pos */
+ d->plane[3] = -VDOT( d->plane, ray_pos); /* up is really new ray_pos */
/* generate the shtuff for the blue line */
tie_init(&d->tie, 2, TIE_KDTREE_FAST);
/* Triangle 1 */
- VSET(list[0].v, ray_pos.v[0], ray_pos.v[1], ray_pos.v[2] - shot_width);
- VSET(list[1].v, ray_pos.v[0] + shot_len*ray_dir.v[0], ray_pos.v[1] + shot_len*ray_dir.v[1], ray_pos.v[2] + shot_len*ray_dir.v[2] - shot_width);
- VSET(list[2].v, ray_pos.v[0] + shot_len*ray_dir.v[0], ray_pos.v[1] + shot_len*ray_dir.v[1], ray_pos.v[2] + shot_len*ray_dir.v[2] + shot_width);
+ VSET(list[0], ray_pos[0], ray_pos[1], ray_pos[2] - shot_width);
+ VSET(list[1], ray_pos[0] + shot_len*ray_dir[0], ray_pos[1] + shot_len*ray_dir[1], ray_pos[2] + shot_len*ray_dir[2] - shot_width);
+ VSET(list[2], ray_pos[0] + shot_len*ray_dir[0], ray_pos[1] + shot_len*ray_dir[1], ray_pos[2] + shot_len*ray_dir[2] + shot_width);
/* Triangle 2 */
- VMOVE(list[3].v, ray_pos.v);
- list[3].v[2] -= shot_width;
+ VMOVE(list[3], ray_pos);
+ list[3][2] -= shot_width;
- VSET(list[4].v, ray_pos.v[0] + shot_len*ray_dir.v[0], ray_pos.v[1] + shot_len*ray_dir.v[1], ray_pos.v[2] + shot_len*ray_dir.v[2] + shot_width);
+ VSET(list[4], ray_pos[0] + shot_len*ray_dir[0], ray_pos[1] + shot_len*ray_dir[1], ray_pos[2] + shot_len*ray_dir[2] + shot_width);
- VMOVE(list[5].v, ray_pos.v);
- list[5].v[2] += shot_width;
+ VMOVE(list[5], ray_pos);
+ list[5][2] += shot_width;
for(i=0;i<6;i++)
tlist[i] = &list[i];
Modified: brlcad/trunk/src/adrt/librender/flos.c
===================================================================
--- brlcad/trunk/src/adrt/librender/flos.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/flos.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -33,7 +33,7 @@
#include "bu.h"
typedef struct render_flos_s {
- TIE_3 frag_pos;
+ point_t frag_pos;
} render_flos_t;
@@ -55,19 +55,19 @@
return;
}
- VSUB2(vec.v, ray->pos.v, id.pos.v);
+ VSUB2(vec.v, ray->pos, id.pos);
VUNITIZE(vec.v);
- angle = VDOT( vec.v, id.norm.v);
+ angle = VDOT( vec.v, id.norm);
/* Determine if direct line of sight to fragment */
- ray->pos = rd->frag_pos;
- VSUB2(ray->dir.v, id.pos.v, rd->frag_pos.v);
- VUNITIZE(ray->dir.v);
+ VMOVE(ray->pos, rd->frag_pos);
+ VSUB2(ray->dir, id.pos, rd->frag_pos);
+ VUNITIZE(ray->dir);
if (tie_work(tie, ray, &tid, render_hit, NULL)) {
- if (fabs (id.pos.v[0] - tid.pos.v[0]) < TIE_PREC &&
- fabs (id.pos.v[1] - tid.pos.v[1]) < TIE_PREC &&
- fabs (id.pos.v[2] - tid.pos.v[2]) < TIE_PREC)
+ if (fabs (id.pos[0] - tid.pos[0]) < TIE_PREC &&
+ fabs (id.pos[1] - tid.pos[1]) < TIE_PREC &&
+ fabs (id.pos[2] - tid.pos[2]) < TIE_PREC)
{
VSET((*pixel).v, 1.0, 0.0, 0.0);
}
@@ -88,7 +88,7 @@
render->free = render_flos_free;
render->data = (render_flos_t *)bu_malloc(sizeof(render_flos_t), "render_flos_init");
d = (render_flos_t *)render->data;
- sscanf(frag_pos, "#(%f %f %f)", &d->frag_pos.v[0], &d->frag_pos.v[1], &d->frag_pos.v[2]);
+ sscanf(frag_pos, "#(%f %f %f)", &d->frag_pos[0], &d->frag_pos[1], &d->frag_pos[2]);
return 0;
}
Modified: brlcad/trunk/src/adrt/librender/grid.c
===================================================================
--- brlcad/trunk/src/adrt/librender/grid.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/grid.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -44,7 +44,7 @@
if ((m = (adrt_mesh_t *)tie_work(tie, ray, &id, render_hit, NULL))) {
/* if X or Y lie in the grid paint it white else make it gray */
- if (fabs(GRID*id.pos.v[0] - (int)(GRID*id.pos.v[0])) < 0.2*LINE || fabs(GRID*id.pos.v[1] - (int)(GRID*id.pos.v[1])) < 0.2*LINE) {
+ if (fabs(GRID*id.pos[0] - (int)(GRID*id.pos[0])) < 0.2*LINE || fabs(GRID*id.pos[1] - (int)(GRID*id.pos[1])) < 0.2*LINE) {
pixel->v[0] = (tfloat)0.9;
pixel->v[1] = (tfloat)0.9;
pixel->v[2] = (tfloat)0.9;
@@ -57,9 +57,9 @@
return;
}
- VSUB2(vec.v, ray->pos.v, id.pos.v);
+ VSUB2(vec.v, ray->pos, id.pos);
VUNITIZE(vec.v);
- angle = VDOT( vec.v, id.norm.v);
+ angle = VDOT( vec.v, id.norm);
VSCALE((*pixel).v, (*pixel).v, (angle*0.9));
pixel->v[0] += (tfloat)0.1;
Modified: brlcad/trunk/src/adrt/librender/hit.c
===================================================================
--- brlcad/trunk/src/adrt/librender/hit.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/hit.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -26,8 +26,8 @@
void* render_hit(struct tie_ray_s *ray, struct tie_id_s *id, struct tie_tri_s *tri, void *ptr) {
/* Flip normal to face ray origin (via dot product check) */
- if (ray->dir.v[0] * id->norm.v[0] + ray->dir.v[1] * id->norm.v[1] + ray->dir.v[2] * id->norm.v[2] > 0)
- VSCALE(id->norm.v, id->norm.v, -1.0);
+ if (ray->dir[0] * id->norm[0] + ray->dir[1] * id->norm[1] + ray->dir[2] * id->norm[2] > 0)
+ VSCALE(id->norm, id->norm, -1.0);
return (adrt_mesh_t *)(tri->ptr);
}
Modified: brlcad/trunk/src/adrt/librender/normal.c
===================================================================
--- brlcad/trunk/src/adrt/librender/normal.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/normal.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -40,7 +40,7 @@
float one[3] = { 1, 1, 1 };
if (tie_work(tie, ray, &id, normal_hit, NULL))
- VADD2SCALE(pixel->v, id.norm.v, one, 0.5);
+ VADD2SCALE(pixel->v, id.norm, one, 0.5);
return;
}
Modified: brlcad/trunk/src/adrt/librender/path.c
===================================================================
--- brlcad/trunk/src/adrt/librender/path.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/path.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -43,11 +43,11 @@
/* _a is reflected ray, _b is incident ray, _c is normal */
#define MATH_VEC_REFLECT(_a, _b, _c) { \
- tfloat _d; \
- _d = VDOT( _b.v, _c.v); \
- VSCALE(_a.v, _c.v, 2.0*_d); \
- VSUB2(_a.v, _b.v, _a.v); \
- VUNITIZE(_a.v); }
+ fastf_t _d; \
+ _d = VDOT( _b, _c); \
+ VSCALE(_a, _c, 2.0*_d); \
+ VSUB2(_a, _b, _a); \
+ VUNITIZE(_a); }
void
@@ -62,17 +62,17 @@
{
struct tie_ray_s new_ray;
struct tie_id_s new_id;
- TIE_3 new_pix, accum, T, ref, bax, bay;
+ vect_t new_pix, accum, T, ref, bax, bay;
adrt_mesh_t *new_mesh;
tfloat sin_theta, cos_theta, sin_phi, cos_phi;
int i, n, propogate;
render_path_t *rd;
- VSETALL(new_pix.v, 0);
+ VSETALL(new_pix, 0);
rd = (render_path_t *)render->data;
- accum.v[0] = accum.v[1] = accum.v[2] = 0;
+ accum[0] = accum[1] = accum[2] = 0;
for (i = 0; i < rd->samples; i++) {
/* Prime variables */
@@ -87,47 +87,47 @@
/* Deal with refractive-fu */
} else if (new_mesh->attributes->emission > 0.0) {
/* Emitting Light Source */
- T = new_mesh->attributes->color;
- VSCALE(T.v, T.v, new_mesh->attributes->emission);
+ VMOVE(T, new_mesh->attributes->color.v);
+ VSCALE(T, T, new_mesh->attributes->emission);
propogate = 0;
} else {
/* Diffuse */
if (new_mesh->texture) {
new_mesh->texture->work(new_mesh->texture, new_mesh, &new_ray, &new_id, &T);
} else {
- T = new_mesh->attributes->color;
+ VMOVE(T, new_mesh->attributes->color.v);
}
}
if (new_ray.depth) {
- VELMUL(new_pix.v, new_pix.v, T.v);
+ VELMUL(new_pix, new_pix, T);
} else {
- new_pix = T;
+ VMOVE(new_pix, T);
}
new_ray.depth++;
MATH_VEC_REFLECT(ref, new_ray.dir, new_id.norm);
- new_ray.pos.v[0] = new_id.pos.v[0] + new_id.norm.v[0]*TIE_PREC;
- new_ray.pos.v[1] = new_id.pos.v[1] + new_id.norm.v[1]*TIE_PREC;
- new_ray.pos.v[2] = new_id.pos.v[2] + new_id.norm.v[2]*TIE_PREC;
+ new_ray.pos[0] = new_id.pos[0] + new_id.norm[0]*TIE_PREC;
+ new_ray.pos[1] = new_id.pos[1] + new_id.norm[1]*TIE_PREC;
+ new_ray.pos[2] = new_id.pos[2] + new_id.norm[2]*TIE_PREC;
- T.v[0] = new_id.norm.v[0] - new_mesh->attributes->gloss*ref.v[0];
- T.v[1] = new_id.norm.v[1] - new_mesh->attributes->gloss*ref.v[1];
- T.v[2] = new_id.norm.v[2] - new_mesh->attributes->gloss*ref.v[2];
- VUNITIZE(T.v);
+ T[0] = new_id.norm[0] - new_mesh->attributes->gloss*ref[0];
+ T[1] = new_id.norm[1] - new_mesh->attributes->gloss*ref[1];
+ T[2] = new_id.norm[2] - new_mesh->attributes->gloss*ref[2];
+ VUNITIZE(T);
/* Form Basis X */
- bax.v[0] = T.v[0] || T.v[1] ? -T.v[1] : 1.0;
- bax.v[1] = T.v[0];
- bax.v[2] = 0;
- VUNITIZE(bax.v);
+ bax[0] = T[0] || T[1] ? -T[1] : 1.0;
+ bax[1] = T[0];
+ bax[2] = 0;
+ VUNITIZE(bax);
/* Form Basis Y, Simplified Cross Product of two unit vectors is a unit vector */
- bay.v[0] = -T.v[2]*bax.v[1];
- bay.v[1] = T.v[2]*bax.v[0];
- bay.v[2] = T.v[0]*bax.v[1] - T.v[1]*bax.v[0];
+ bay[0] = -T[2]*bax[1];
+ bay[1] = T[2]*bax[0];
+ bay[2] = T[0]*bax[1] - T[1]*bax[0];
cos_theta = bn_randmt();
sin_theta = sqrt(cos_theta);
@@ -138,24 +138,24 @@
cos_phi = cos(cos_phi);
for (n = 0; n < 3; n++) {
- T.v[n] = sin_theta*cos_phi*bax.v[n] + sin_theta*sin_phi*bay.v[n] + cos_theta*T.v[n];
+ T[n] = sin_theta*cos_phi*bax[n] + sin_theta*sin_phi*bay[n] + cos_theta*T[n];
/* Weigh reflected vector back in */
- new_ray.dir.v[n] = (1.0 - new_mesh->attributes->gloss)*T.v[n] + new_mesh->attributes->gloss * ref.v[n];
+ new_ray.dir[n] = (1.0 - new_mesh->attributes->gloss)*T[n] + new_mesh->attributes->gloss * ref[n];
}
- VUNITIZE(new_ray.dir.v);
+ VUNITIZE(new_ray.dir);
} else {
- new_pix.v[0] = 0;
- new_pix.v[1] = 0;
- new_pix.v[2] = 0;
+ new_pix[0] = 0;
+ new_pix[1] = 0;
+ new_pix[2] = 0;
propogate = 0;
}
}
- VADD2(accum.v, accum.v, new_pix.v);
+ VADD2(accum, accum, new_pix);
}
- VSCALE((*pixel).v, accum.v, rd->inv_samples);
+ VSCALE((*pixel).v, accum, rd->inv_samples);
}
int
Modified: brlcad/trunk/src/adrt/librender/phong.c
===================================================================
--- brlcad/trunk/src/adrt/librender/phong.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/phong.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -47,9 +47,9 @@
if (mesh->texture)
mesh->texture->work(mesh->texture, mesh, ray, &id, pixel);
- VSUB2(vec.v, ray->pos.v, id.pos.v);
+ VSUB2(vec.v, ray->pos, id.pos);
VUNITIZE(vec.v);
- VSCALE((*pixel).v, (*pixel).v, VDOT( vec.v, id.norm.v));
+ VSCALE((*pixel).v, (*pixel).v, VDOT( vec.v, id.norm));
}
return;
}
Modified: brlcad/trunk/src/adrt/librender/render_util.c
===================================================================
--- brlcad/trunk/src/adrt/librender/render_util.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/render_util.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -39,14 +39,14 @@
typedef struct render_shotline_s {
render_segment_t *seglist;
- TIE_3 in_hit;
+ point_t in_hit;
uint32_t segnum;
uint32_t segind;
} render_shotline_t;
/* Generate vector list for a spall cone given a reference angle */
-void render_util_spall_vec(TIE_3 dir, tfloat angle, int vec_num, TIE_3 *vec_list) {
+void render_util_spall_vec(vect_t dir, fastf_t angle, int vec_num, vect_t *vec_list) {
#if 0
TIE_3 vec;
tfloat radius, t;
@@ -111,9 +111,9 @@
/* In-hit */
if (shotline->segnum == 0) {
- shotline->in_hit = ray->dir;
- VSCALE(shotline->in_hit.v, shotline->in_hit.v, id->dist);
- VADD2(shotline->in_hit.v, shotline->in_hit.v, ray->pos.v);
+ VMOVE(shotline->in_hit, ray->dir);
+ VSCALE(shotline->in_hit, shotline->in_hit, id->dist);
+ VADD2(shotline->in_hit, shotline->in_hit, ray->pos);
}
/* Increment */
Modified: brlcad/trunk/src/adrt/librender/render_util.h
===================================================================
--- brlcad/trunk/src/adrt/librender/render_util.h 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/render_util.h 2011-01-11 22:37:27 UTC (rev 42096)
@@ -26,7 +26,7 @@
#include "render_internal.h"
-BU_EXPORT BU_EXTERN(void render_util_spall_vec, (TIE_3 dir, tfloat angle, int vec_num, TIE_3 *vec_list));
+BU_EXPORT BU_EXTERN(void render_util_spall_vec, (vect_t dir, fastf_t angle, int vec_num, vect_t *vec_list));
BU_EXPORT BU_EXTERN(void render_util_shotline_list, (struct tie_s *tie, struct tie_ray_s *ray, void **data, int *dlen));
BU_EXPORT BU_EXTERN(void render_util_spall_list, (struct tie_s *tie, struct tie_ray_s *ray, tfloat angle, void **data, int *dlen));
Modified: brlcad/trunk/src/adrt/librender/spall.c
===================================================================
--- brlcad/trunk/src/adrt/librender/spall.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/spall.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -35,23 +35,23 @@
#define TESSELATION 32
#define SPALL_LEN 20
-typedef struct render_spall_s {
- TIE_3 ray_pos;
- TIE_3 ray_dir;
- tfloat plane[4];
- tfloat angle;
+struct render_spall_s {
+ point_t ray_pos;
+ vect_t ray_dir;
+ fastf_t plane[4];
+ fastf_t angle;
struct tie_s tie;
-} render_spall_t;
+};
void* render_spall_hit(struct tie_ray_s *ray, struct tie_id_s *id, struct tie_tri_s *tri, void *ptr);
void render_plane(struct tie_s *tie, struct tie_ray_s *ray, TIE_3 *pixel);
-typedef struct render_spall_hit_s {
+struct render_spall_hit_s {
struct tie_id_s id;
adrt_mesh_t *mesh;
- tfloat plane[4];
- tfloat mod;
-} render_spall_hit_t;
+ fastf_t plane[4];
+ fastf_t mod;
+};
@@ -72,7 +72,7 @@
void *
render_spall_hit(struct tie_ray_s *ray, struct tie_id_s *id, struct tie_tri_s *tri, void *ptr)
{
- render_spall_hit_t *hit = (render_spall_hit_t *)ptr;
+ struct render_spall_hit_s *hit = (struct render_spall_hit_s *)ptr;
hit->id = *id;
hit->mesh = (adrt_mesh_t *)(tri->ptr);
@@ -83,14 +83,14 @@
void
render_spall_work(render_t *render, struct tie_s *tie, struct tie_ray_s *ray, TIE_3 *pixel)
{
- render_spall_t *rd;
- render_spall_hit_t hit;
- TIE_3 color;
+ struct render_spall_s *rd;
+ struct render_spall_hit_s hit;
+ vect_t color;
struct tie_id_s id;
tfloat t, dot;
- rd = (render_spall_t *)render->data;
+ rd = (struct render_spall_s *)render->data;
/* Draw spall Cone */
if (tie_work(&rd->tie, ray, &id, render_arrow_hit, NULL)) {
@@ -103,7 +103,7 @@
* I don't think this needs to be done for every pixel?
* Flip plane normal to face us.
*/
- t = ray->pos.v[0]*rd->plane[0] + ray->pos.v[1]*rd->plane[1] + ray->pos.v[2]*rd->plane[2] + rd->plane[3];
+ t = ray->pos[0]*rd->plane[0] + ray->pos[1]*rd->plane[1] + ray->pos[2]*rd->plane[2] + rd->plane[3];
hit.mod = t < 0 ? 1 : -1;
@@ -116,16 +116,16 @@
*
*/
- t = (rd->plane[0]*ray->pos.v[0] + rd->plane[1]*ray->pos.v[1] + rd->plane[2]*ray->pos.v[2] + rd->plane[3]) /
- (rd->plane[0]*ray->dir.v[0] + rd->plane[1]*ray->dir.v[1] + rd->plane[2]*ray->dir.v[2]);
+ t = (rd->plane[0]*ray->pos[0] + rd->plane[1]*ray->pos[1] + rd->plane[2]*ray->pos[2] + rd->plane[3]) /
+ (rd->plane[0]*ray->dir[0] + rd->plane[1]*ray->dir[1] + rd->plane[2]*ray->dir[2]);
/* Ray never intersects plane */
if (t > 0)
return;
- ray->pos.v[0] += -t * ray->dir.v[0];
- ray->pos.v[1] += -t * ray->dir.v[1];
- ray->pos.v[2] += -t * ray->dir.v[2];
+ ray->pos[0] += -t * ray->dir[0];
+ ray->pos[1] += -t * ray->dir[1];
+ ray->pos[2] += -t * ray->dir[2];
hit.plane[0] = rd->plane[0];
hit.plane[1] = rd->plane[1];
@@ -142,34 +142,34 @@
* If the point after the splitting plane is an inhit, then just shade as usual.
*/
- dot = VDOT( ray->dir.v, hit.id.norm.v);
+ dot = VDOT( ray->dir, hit.id.norm);
/* flip normal */
dot = fabs(dot);
if (hit.mesh->flags == 1) {
- VSET(color.v, (tfloat)0.9, (tfloat)0.2, (tfloat)0.2);
+ VSET(color, 0.9, 0.2, 0.2);
} else {
/* Mix actual color with white 4:1, shade 50% darker */
- VSET(color.v, (tfloat)1.0, (tfloat)1.0, (tfloat)1.0);
- VSCALE(color.v, color.v, (tfloat)3.0);
- VADD2(color.v, color.v, hit.mesh->attributes->color.v);
- VSCALE(color.v, color.v, (tfloat)0.125);
+ VSET(color, 1.0, 1.0, 1.0);
+ VSCALE(color, color, 3.0);
+ VADD2(color, color, hit.mesh->attributes->color.v);
+ VSCALE(color, color, 0.125);
}
#if 0
if (dot < 0) {
#endif
/* Shade using inhit */
- VSCALE(color.v, color.v, (dot*0.50));
- VADD2((*pixel).v, (*pixel).v, color.v);
+ VSCALE(color, color, (dot*0.50));
+ VADD2((*pixel).v, (*pixel).v, color);
#if 0
} else {
/* shade solid */
- VSUB2(vec.v, ray->pos.v, hit.id.pos.v);
- VUNITIZE(vec.v);
- angle = vec.v[0]*hit.mod*-hit.plane[0] + vec.v[1]*-hit.mod*hit.plane[1] + vec.v[2]*-hit.mod*hit.plane[2];
- VSCALE((*pixel).v, color.v, (angle*0.50));
+ VSUB2(vec, ray->pos, hit.id.pos);
+ VUNITIZE(vec);
+ angle = vec[0]*hit.mod*-hit.plane[0] + vec[1]*-hit.mod*hit.plane[1] + vec[2]*-hit.mod*hit.plane[2];
+ VSCALE((*pixel), color, (angle*0.50));
}
#endif
@@ -181,8 +181,8 @@
int
render_spall_init(render_t *render, const char *buf)
{
- render_spall_t *d;
- TIE_3 *tri_list, *vec_list, normal, up, ray_pos, ray_dir;
+ struct render_spall_s *d;
+ vect_t *tri_list, *vec_list, normal, up, ray_pos, ray_dir;
tfloat plane[4], angle;
int i;
@@ -193,35 +193,35 @@
render->free = render_spall_free;
sscanf(buf, "(%g %g %g) (%g %g %g) %g",
- &ray_pos.v[0], &ray_pos.v[1], &ray_pos.v[2],
- &ray_dir.v[0], &ray_dir.v[1], &ray_dir.v[2],
+ &ray_pos[0], &ray_pos[1], &ray_pos[2],
+ &ray_dir[0], &ray_dir[1], &ray_dir[2],
&angle);
- render->data = (render_spall_t *)bu_malloc(sizeof(render_spall_t), "render_spall_init");
+ render->data = (struct render_spall_s *)bu_malloc(sizeof(struct render_spall_s), "render_spall_init");
if (!render->data) {
perror("render->data");
exit(1);
}
- d = (render_spall_t *)render->data;
+ d = (struct render_spall_s *)render->data;
- d->ray_pos = ray_pos;
- d->ray_dir = ray_dir;
+ VMOVE(d->ray_pos, ray_pos);
+ VMOVE(d->ray_dir, ray_dir);
tie_init(&d->tie, TESSELATION, TIE_KDTREE_FAST);
/* Calculate the normal to be used for the plane */
- up.v[0] = 0;
- up.v[1] = 0;
- up.v[2] = 1;
+ up[0] = 0;
+ up[1] = 0;
+ up[2] = 1;
- VCROSS(normal.v, ray_dir.v, up.v);
- VUNITIZE(normal.v);
+ VCROSS(normal, ray_dir, up);
+ VUNITIZE(normal);
/* Construct the plane */
- d->plane[0] = normal.v[0];
- d->plane[1] = normal.v[1];
- d->plane[2] = normal.v[2];
- plane[3] = VDOT( normal.v, ray_pos.v); /* up is really new ray_pos */
+ d->plane[0] = normal[0];
+ d->plane[1] = normal[1];
+ d->plane[2] = normal[2];
+ plane[3] = VDOT( normal, ray_pos); /* up is really new ray_pos */
d->plane[3] = -plane[3];
/******************/
@@ -234,17 +234,17 @@
/* triangles to approximate */
for (i = 0; i < TESSELATION; i++) {
- tri_list[3*i+0] = ray_pos;
+ VMOVE(tri_list[3*i+0], ray_pos);
- VSCALE(tri_list[3*i+1].v, vec_list[i].v, SPALL_LEN);
- VADD2(tri_list[3*i+1].v, tri_list[3*i+1].v, ray_pos.v);
+ VSCALE(tri_list[3*i+1], vec_list[i], SPALL_LEN);
+ VADD2(tri_list[3*i+1], tri_list[3*i+1], ray_pos);
if (i == TESSELATION - 1) {
- VSCALE(tri_list[3*i+2].v, vec_list[0].v, SPALL_LEN);
- VADD2(tri_list[3*i+2].v, tri_list[3*i+2].v, ray_pos.v);
+ VSCALE(tri_list[3*i+2], vec_list[0], SPALL_LEN);
+ VADD2(tri_list[3*i+2], tri_list[3*i+2], ray_pos);
} else {
- VSCALE(tri_list[3*i+2].v, vec_list[i+1].v, SPALL_LEN);
- VADD2(tri_list[3*i+2].v, tri_list[3*i+2].v, ray_pos.v);
+ VSCALE(tri_list[3*i+2], vec_list[i+1], SPALL_LEN);
+ VADD2(tri_list[3*i+2], tri_list[3*i+2], ray_pos);
}
}
Modified: brlcad/trunk/src/adrt/librender/surfel.c
===================================================================
--- brlcad/trunk/src/adrt/librender/surfel.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/surfel.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -32,9 +32,9 @@
#include "adrt_struct.h"
typedef struct render_surfel_pt_s {
- TIE_3 pos;
+ point_t pos;
tfloat radius;
- TIE_3 color;
+ vect_t color;
} render_surfel_pt_t;
typedef struct render_surfel_s {
@@ -67,12 +67,12 @@
if ((mesh = (adrt_mesh_t *)tie_work(tie, ray, &id, render_hit, NULL))) {
for (i = 0; i < d->num; i++) {
- dist_sq = (d->list[i].pos.v[0]-id.pos.v[0]) * (d->list[i].pos.v[0]-id.pos.v[0]) +
- (d->list[i].pos.v[1]-id.pos.v[1]) * (d->list[i].pos.v[1]-id.pos.v[1]) +
- (d->list[i].pos.v[2]-id.pos.v[2]) * (d->list[i].pos.v[2]-id.pos.v[2]);
+ dist_sq = (d->list[i].pos[0]-id.pos[0]) * (d->list[i].pos[0]-id.pos[0]) +
+ (d->list[i].pos[1]-id.pos[1]) * (d->list[i].pos[1]-id.pos[1]) +
+ (d->list[i].pos[2]-id.pos[2]) * (d->list[i].pos[2]-id.pos[2]);
if (dist_sq < d->list[i].radius*d->list[i].radius) {
- *pixel = d->list[i].color;
+ VMOVE((*pixel).v, d->list[i].color);
break;
}
}
Modified: brlcad/trunk/src/adrt/librender/texture.h
===================================================================
--- brlcad/trunk/src/adrt/librender/texture.h 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/texture.h 2011-01-11 22:37:27 UTC (rev 42096)
@@ -42,45 +42,45 @@
struct texture_perlin_s {
int *PV;
- TIE_3 *RV;
+ vect_t *RV;
};
BU_EXPORT BU_EXTERN(void texture_perlin_init, (struct texture_perlin_s *P));
BU_EXPORT BU_EXTERN(void texture_perlin_free, (struct texture_perlin_s *P));
-BU_EXPORT BU_EXTERN(tfloat texture_perlin_noise3, (struct texture_perlin_s *P, TIE_3 V, tfloat Size, int Depth));
+BU_EXPORT BU_EXTERN(fastf_t texture_perlin_noise3, (struct texture_perlin_s *P, vect_t V, fastf_t Size, int Depth));
struct texture_blend_s {
- TIE_3 color1;
- TIE_3 color2;
+ vect_t color1;
+ vect_t color2;
};
-BU_EXPORT BU_EXTERN(void texture_blend_init, (struct texture_s *texture, TIE_3 color1, TIE_3 color2));
+BU_EXPORT BU_EXTERN(void texture_blend_init, (struct texture_s *texture, vect_t color1, vect_t color2));
BU_EXPORT BU_EXTERN(void texture_blend_free, (struct texture_s *texture));
BU_EXPORT BU_EXTERN(void texture_blend_work, (__TEXTURE_WORK_PROTOTYPE__));
struct texture_bump_s {
- TIE_3 coef;
+ vect_t coef;
};
-BU_EXPORT BU_EXTERN(void texture_bump_init, (struct texture_s *texture, TIE_3 rgb));
+BU_EXPORT BU_EXTERN(void texture_bump_init, (struct texture_s *texture, vect_t rgb));
BU_EXPORT BU_EXTERN(void texture_bump_free, (struct texture_s *texture));
BU_EXPORT BU_EXTERN(void texture_bump_work, (__TEXTURE_WORK_PROTOTYPE__));
struct texture_camo_s {
- tfloat size;
+ fastf_t size;
int octaves;
int absolute;
- TIE_3 color1;
- TIE_3 color2;
- TIE_3 color3;
+ vect_t color1;
+ vect_t color2;
+ vect_t color3;
struct texture_perlin_s perlin;
};
-BU_EXPORT BU_EXTERN(void texture_camo_init, (struct texture_s *texture, tfloat size, int octaves, int absolute, TIE_3 color1, TIE_3 color2, TIE_3 color3));
+BU_EXPORT BU_EXTERN(void texture_camo_init, (struct texture_s *texture, fastf_t size, int octaves, int absolute, vect_t color1, vect_t color2, vect_t color3));
BU_EXPORT BU_EXTERN(void texture_camo_free, (struct texture_s *texture));
BU_EXPORT BU_EXTERN(void texture_camo_work, (__TEXTURE_WORK_PROTOTYPE__));
@@ -95,15 +95,15 @@
struct texture_clouds_s {
- tfloat size;
+ fastf_t size;
int octaves;
int absolute;
- TIE_3 scale;
- TIE_3 translate;
+ vect_t scale;
+ vect_t translate;
struct texture_perlin_s perlin;
};
-BU_EXPORT BU_EXTERN(void texture_cloudts_inis, (struct texture_s *texture, tfloat size, int octaves, int absolute, TIE_3 scale, TIE_3 translate));
+BU_EXPORT BU_EXTERN(void texture_cloudts_inis, (struct texture_s *texture, fastf_t size, int octaves, int absolute, vect_t scale, vect_t translate));
BU_EXPORT BU_EXTERN(void texture_clouds_free, (struct texture_s *texture));
BU_EXPORT BU_EXTERN(void texture_clouds_work, (__TEXTURE_WORK_PROTOTYPE__));
@@ -130,11 +130,11 @@
struct texture_mix_s {
struct texture_s *texture1;
struct texture_s *texture2;
- tfloat coef;
+ fastf_t coef;
};
-BU_EXPORT BU_EXTERN(void texture_mix_init, (struct texture_s *texture, struct texture_s *texture1, struct texture_s *texture2, tfloat coef));
+BU_EXPORT BU_EXTERN(void texture_mix_init, (struct texture_s *texture, struct texture_s *texture1, struct texture_s *texture2, fastf_t coef));
BU_EXPORT BU_EXTERN(void texture_mix_free, (struct texture_s *texture));
BU_EXPORT BU_EXTERN(void texture_mix_work, (__TEXTURE_WORK_PROTOTYPE__));
Modified: brlcad/trunk/src/adrt/librender/texture_blend.c
===================================================================
--- brlcad/trunk/src/adrt/librender/texture_blend.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/texture_blend.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -29,7 +29,7 @@
#include "bu.h"
-void texture_blend_inis(struct texture_s *texture, TIE_3 color1, TIE_3 color2) {
+void texture_blend_init(struct texture_s *texture, vect_t color1, vect_t color2) {
struct texture_blend_s *sd;
texture->data = bu_malloc(sizeof(struct texture_blend_s), "texture data");
@@ -37,8 +37,8 @@
texture->work = (struct texture_work_s *)texture_blend_work;
sd = (struct texture_blend_s *)texture->data;
- sd->color1 = color1;
- sd->color2 = color2;
+ VMOVE(sd->color1, color1);
+ VMOVE(sd->color2, color2);
}
@@ -49,14 +49,14 @@
void texture_blend_work(__TEXTURE_WORK_PROTOTYPE__) {
struct texture_blend_s *sd;
- tfloat coef;
+ fastf_t coef;
sd = (struct texture_blend_s *)texture->data;
- coef = pixel->v[0];
- pixel->v[0] = (1.0 - coef)*sd->color1.v[0] + coef*sd->color2.v[0];
- pixel->v[1] = (1.0 - coef)*sd->color1.v[1] + coef*sd->color2.v[1];
- pixel->v[2] = (1.0 - coef)*sd->color1.v[2] + coef*sd->color2.v[2];
+ coef = *pixel[0];
+ *pixel[0] = (1.0 - coef)*sd->color1[0] + coef*sd->color2[0];
+ *pixel[1] = (1.0 - coef)*sd->color1[1] + coef*sd->color2[1];
+ *pixel[2] = (1.0 - coef)*sd->color1[2] + coef*sd->color2[2];
}
/*
Modified: brlcad/trunk/src/adrt/librender/texture_bump.c
===================================================================
--- brlcad/trunk/src/adrt/librender/texture_bump.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/texture_bump.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -29,7 +29,7 @@
#include "bu.h"
-void texture_bump_init(struct texture_s *texture, TIE_3 coef) {
+void texture_bump_init(struct texture_s *texture, vect_t coef) {
struct texture_bump_s *sd;
texture->data = bu_malloc(sizeof(struct texture_bump_s), "texture data");
@@ -37,7 +37,7 @@
texture->work = (struct texture_work_s *)texture_bump_work;
sd = (struct texture_bump_s *)texture->data;
- sd->coef = coef;
+ VMOVE(sd->coef, coef);
}
@@ -48,22 +48,22 @@
void texture_bump_work(__TEXTURE_WORK_PROTOTYPE__) {
struct texture_bump_s *sd;
- TIE_3 n;
+ vect_t n;
tfloat d;
sd = (struct texture_bump_s *)texture->data;
- n.v[0] = id->norm.v[0] + sd->coef.v[0]*(2*pixel->v[0]-1.0);
- n.v[1] = id->norm.v[1] + sd->coef.v[1]*(2*pixel->v[1]-1.0);
- n.v[2] = id->norm.v[2] + sd->coef.v[2]*(2*pixel->v[2]-1.0);
- VUNITIZE(n.v);
+ n[0] = id->norm[0] + sd->coef[0]*(2* *pixel[0]-1.0);
+ n[1] = id->norm[1] + sd->coef[1]*(2* *pixel[1]-1.0);
+ n[2] = id->norm[2] + sd->coef[2]*(2* *pixel[2]-1.0);
+ VUNITIZE(n);
- d = VDOT( n.v, id->norm.v);
+ d = VDOT( n, id->norm);
if (d < 0)
- VSCALE(n.v, n.v, -1.0);
- id->norm = n;
+ VSCALE(n, n, -1.0);
+ VMOVE(id->norm, n);
}
/*
Modified: brlcad/trunk/src/adrt/librender/texture_camo.c
===================================================================
--- brlcad/trunk/src/adrt/librender/texture_camo.c 2011-01-11 22:32:24 UTC (rev 42095)
+++ brlcad/trunk/src/adrt/librender/texture_camo.c 2011-01-11 22:37:27 UTC (rev 42096)
@@ -30,7 +30,7 @@
#include "bu.h"
-void texture_camo_init(struct texture_s *texture, tfloat size, int octaves, int absolute, TIE_3 color1, TIE_3 color2, TIE_3 color3) {
+void texture_camo_init(struct texture_s *texture, fastf_t size, int octaves, int absolute, vect_t color1, vect_t color2, vect_t color3) {
struct texture_camo_s *sd;
texture->data = bu_malloc(sizeof(struct texture_c...
[truncated message content] |