| /*************************************************************************/ |
| /* */ |
| /* Copyright (c) 1994 Stanford University */ |
| /* */ |
| /* All rights reserved. */ |
| /* */ |
| /* Permission is given to use, copy, and modify this software for any */ |
| /* non-commercial purpose as long as this copyright notice is not */ |
| /* removed. All other uses, including redistribution in whole or in */ |
| /* part, are forbidden without prior written permission. */ |
| /* */ |
| /* This software is provided with absolutely no warranty and no */ |
| /* support. */ |
| /* */ |
| /*************************************************************************/ |
| |
| /************************************************************************ |
| * * |
| * global.h: global variables common to entire program * |
| * * |
| ************************************************************************/ |
| |
| extern int ROTATE_STEPS; |
| |
| extern long image_section[NI]; |
| extern long voxel_section[NM]; |
| |
| extern PIXEL *image,*image_block,*mask_image_block; |
| extern long num_nodes,frame; |
| extern long block_xlen,block_ylen,num_blocks,num_xblocks,num_yblocks; |
| extern struct GlobalMemory *Global; |
| extern PIXEL *shd_address; |
| extern BOOLEAN *sbit_address; |
| extern long shd_length; |
| |
| /* Option globals */ |
| extern BOOLEAN adaptive; /* YES for adaptive ray tracing, NO if not */ |
| /* Shading parameters of reflective surface: */ |
| extern float density_opacity[MAX_DENSITY+1]; |
| /* opacity as function of density */ |
| extern float magnitude_opacity[MAX_MAGNITUDE+1]; |
| /* opacity as function of magnitude */ |
| extern long density_epsilon; /* minimum (density*map_divisor) */ |
| /* (>= MIN_DENSITY) */ |
| extern long magnitude_epsilon; /* minimum (magnitude*grd_divisor)**2 */ |
| /* (> MIN_MAGNITUDE) */ |
| extern PIXEL background; /* color of background */ |
| extern float light[NM]; /* normalized vector from object to light */ |
| extern float ambient_color; /* color of ambient reflection */ |
| extern float diffuse_color; /* color of diffuse reflection */ |
| extern float specular_color; /* color of specular reflection */ |
| extern float specular_exponent; /* exponent of specular reflection */ |
| extern float depth_hither; /* percentage of full intensity at hither */ |
| extern float depth_yon; /* percentage of full intensity at yon */ |
| extern float depth_exponent; /* exponent of falloff from hither to yon */ |
| extern float opacity_epsilon; /* minimum opacity */ |
| /* (usually >= MIN_OPACITY, */ |
| /* < MIN_OPACITY during shading shades */ |
| /* all voxels for generation of mipmap) */ |
| extern float opacity_cutoff; /* cutoff opacity */ |
| /* (<= MAX_OPACITY) */ |
| extern long highest_sampling_boxlen; |
| /* highest boxlen for adaptive sampling */ |
| /* (>= 1) */ |
| extern long lowest_volume_boxlen;/* lowest boxlen for volume data */ |
| /* (>= 1) */ |
| extern long volume_color_difference; |
| /* minimum color diff for volume data */ |
| /* (>= MIN_PIXEL) */ |
| extern float angle[NM]; /* initial viewing angle */ |
| extern long pyr_highest_level; /* highest level of pyramid to look at */ |
| /* (<= MAX_PYRLEVEL) */ |
| extern long pyr_lowest_level; /* lowest level of pyramid to look at */ |
| /* (>= 0) */ |
| |
| /* Pre_View Globals */ |
| extern long frust_len; /* Size of clipping frustum */ |
| /* (mins will be 0 in this program, */ |
| /* {x,y}len will be <= IK{X,Y}SIZE) */ |
| extern float depth_cueing[MAX_OUTLEN]; |
| /* Pre-computed table of depth cueing */ |
| extern long image_zlen; /* number of samples along viewing ray */ |
| extern float in_max[NM]; /* Pre-computed clipping aids */ |
| extern long opc_xlen,opc_xylen; |
| extern long norm_xlen,norm_xylen; |
| |
| extern VOXEL *vox_address; |
| extern long vox_len[NM]; |
| extern long vox_length; |
| extern long vox_xlen,vox_xylen; |
| |
| |
| /* View Globals */ |
| extern float transformation_matrix[4][4]; |
| /* current transformation matrix */ |
| extern float out_invvertex[2][2][2][NM]; |
| /* Image and object space centers */ |
| /* of outer voxels in output map */ |
| extern float uout_invvertex[2][2][2][NM]; |
| /* Image and object space vertices */ |
| /* of output map unit voxel */ |
| |
| /* Render Globals */ |
| extern float obslight[NM]; /* observer transformed light vector */ |
| extern float obshighlight[NM]; /* observer transformed highlight vector */ |
| extern float invjacobian[NM][NM]; |
| /* Jacobian matrix showing object space */ |
| /* d{x,y,z} per image space d{x,y,z} */ |
| /* [0][0] is dx(object)/dx(image) */ |
| /* [0][2] is dz(object)/dx(image) */ |
| /* [2][0] is dx(object)/dz(image) */ |
| extern float invinvjacobian[NM][NM]; |
| /* [i][j] = 1.0 / invjacobian[i][j] */ |
| |
| |
| /* Density map globals */ |
| extern short map_len[NM]; /* Size of this density map */ |
| extern int map_length; /* Total number of densities in map */ |
| /* (= product of lens) */ |
| extern DENSITY *map_address; /* Pointer to map */ |
| |
| /* Normal and gradient magnitude map globals */ |
| extern short norm_len[NM]; /* Size of this normal map */ |
| extern int norm_length; /* Total number of normals in map */ |
| /* (= NM * product of lens) */ |
| extern NORMAL *norm_address; /* Pointer to normal map */ |
| extern float nmag_epsilon; |
| |
| /* Opacity map globals */ |
| extern short opc_len[NM]; /* Size of this opacity map */ |
| extern int opc_length; /* Total number of opacities in map */ |
| /* (= product of lens) */ |
| extern OPACITY *opc_address; /* Pointer to opacity map */ |
| |
| /* Octree globals */ |
| extern short pyr_levels; /* Number of levels in this pyramid */ |
| extern short pyr_len[MAX_PYRLEVEL+1][NM]; |
| /* Number of voxels on each level */ |
| extern short pyr_voxlen[MAX_PYRLEVEL+1][NM]; |
| /* Size of voxels on each level */ |
| extern int pyr_length[MAX_PYRLEVEL+1]; |
| /* Total number of bytes on this level */ |
| /* (= (long)((product of lens+7)/8)) */ |
| extern BYTE *pyr_address[MAX_PYRLEVEL+1]; |
| /* Pointer to binary pyramid */ |
| /* (only pyr_levels sets of lens, lengths, */ |
| /* and 3-D arrays are written to file) */ |
| extern long pyr_offset1; /* Bit offset of desired bit within pyramid */ |
| extern long pyr_offset2; /* Bit offset of bit within byte */ |
| extern BYTE *pyr_address2; /* Pointer to byte containing bit */ |
| |
| /* Image globals */ |
| extern long image_len[NI]; /* Size of image */ |
| extern int image_length; /* Total number of pixels in map */ |
| extern PIXEL *image_address; /* Pointer to image */ |
| extern long mask_image_len[NI]; /* Size of mask image for adaptive ray trace */ |
| extern long mask_image_length; /* Total number of pixels in mask image */ |
| extern MPIXEL *mask_image_address; |
| /* Pointer to image */ |
| |
| /* adaptive.c */ |
| void Ray_Trace(long my_node); |
| void Ray_Trace_Adaptively(long my_node); |
| void Ray_Trace_Adaptive_Box(long outx, long outy, long boxlen); |
| void Ray_Trace_Non_Adaptively(long my_node); |
| void Ray_Trace_Fast_Non_Adaptively(long my_node); |
| void Interpolate_Recursively(long my_node); |
| void Interpolate_Recursive_Box(long outx, long outy, long boxlen); |
| |
| /* file.c */ |
| int Create_File(char filename[]); |
| int Open_File(char filename[]); |
| void Write_Bytes(int fd, unsigned char array[], long length); |
| void Write_Shorts(int fd, unsigned char array[], long length); |
| void Write_Longs(int fd, unsigned char array[], long length); |
| void Read_Bytes(int fd, unsigned char array[], long length); |
| void Read_Shorts(int fd, unsigned char array[], long length); |
| void Read_Longs(int fd, unsigned char array[], long length); |
| void Close_File(int fd); |
| |
| /* main.c */ |
| void mclock(long stoptime, long starttime, long *exectime); |
| void Frame(void); |
| void Render_Loop(void); |
| void Error(char string[], .../*char *arg1, char *arg2, char *arg3, char *arg4, char *arg5, char *arg6, char *arg7, char *arg8*/); |
| void Allocate_Image(PIXEL **address, long length); |
| void Allocate_MImage(MPIXEL **address, long length); |
| void Lallocate_Image(PIXEL **address, long length); |
| void Store_Image(char filename[]); |
| void Allocate_Shading_Table(PIXEL **address1, long length); |
| void Init_Decomposition(void); |
| long WriteGrayscaleTIFF(char *filename, long width, long height, long scanbytes, unsigned char *data); |
| |
| /* map.c */ |
| void Load_Map(char filename[]); |
| void Allocate_Map(DENSITY **address, long length); |
| void Deallocate_Map(DENSITY **address); |
| |
| /* normal.c */ |
| void Compute_Normal(void); |
| void Allocate_Normal(NORMAL **address, long length); |
| void Normal_Compute(void); |
| void Load_Normal(char filename[]); |
| void Store_Normal(char filename[]); |
| void Deallocate_Normal(NORMAL **address); |
| |
| /* octree.c */ |
| void Compute_Octree(void); |
| void Compute_Base(void); |
| void Or_Neighbors_In_Base(void); |
| void Allocate_Pyramid_Level(BYTE **address, long length); |
| void Compute_Pyramid_Level(long level); |
| void Load_Octree(char filename[]); |
| void Store_Octree(char filename[]); |
| |
| /* opacity.c */ |
| void Compute_Opacity(void); |
| void Allocate_Opacity(OPACITY **address, long length); |
| void Opacity_Compute(void); |
| void Load_Opacity(char filename[]); |
| void Store_Opacity(char filename[]); |
| void Deallocate_Opacity(OPACITY **address); |
| |
| /* option.c */ |
| void Init_Options(void); |
| void Init_Opacity(void); |
| void Init_Lighting(void); |
| void Init_Parallelization(void); |
| |
| /* raytrace.c */ |
| void Trace_Ray(double foutx, double fouty, PIXEL *pixel_address); |
| void Pre_Shade(long my_node); |
| |
| /* render.c */ |
| void Render(long my_node); |
| void Observer_Transform_Light_Vector(void); |
| void Compute_Observer_Transformed_Highlight_Vector(void); |
| |
| /* view.c */ |
| void Compute_Pre_View(void); |
| void Select_View(double delta_angle, long axis); |
| void Compute_Input_Dimensions(void); |
| void Compute_Input_Unit_Vector(void); |
| void Load_Transformation_Matrix(float matrix[4][4]); |
| void Transform_Point(double xold, double yold, double zold, float *xnew, float *ynew, float *znew); |
| void Inverse_Concatenate_Translation(float matrix[4][4], double xoffset, double yoffset, double zoffset); |
| void Inverse_Concatenate_Scaling(float matrix[4][4], double xscale, double yscale, double zscale); |
| void Inverse_Concatenate_Rotation(float matrix[4][4], long axis, double angle); |
| void Load_Identity_Matrix(float matrix[4][4]); |
| void Load_Translation_Matrix(float matrix[4][4], double xoffset, double yoffset, double zoffset); |
| void Load_Scaling_Matrix(float matrix[4][4], double xscale, double yscale, double zscale); |
| void Load_Rotation_Matrix(float matrix[4][4], long axis, double angle); |
| void Concatenate_Transform(float composite_matrix[][4], float transformation_matrix[][4]); |
| void Inverse_Concatenate_Transform(float composite_matrix[][4], float transformation_matrix[][4]); |
| void Multiply_Matrices(float input_matrix1[][4], float input_matrix2[][4], float output_matrix[][4]); |
| void Copy_Matrix(float input_matrix[][4], float output_matrix[][4]); |