2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
11 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
20 static char rcsid[] = "$Id: draw.c,v 1.1.1.1 2001-01-19 03:29:58 bradleyb Exp $";
34 void (*tmap_drawer_ptr)(grs_bitmap *bm,int nv,g3s_point **vertlist) = draw_tmap;
35 void (*flat_drawer_ptr)(int nv,int *vertlist) = gr_upoly_tmap;
36 int (*line_drawer_ptr)(fix x0,fix y0,fix x1,fix y1) = gr_line;
38 //specifies 2d drawing routines to use instead of defaults. Passing
39 //NULL for either or both restores defaults
40 void g3_set_special_render(void (*tmap_drawer)(),void (*flat_drawer)(),int (*line_drawer)(fix, fix, fix, fix))
42 tmap_drawer_ptr = (tmap_drawer)?tmap_drawer:draw_tmap;
43 flat_drawer_ptr = (flat_drawer)?flat_drawer:gr_upoly_tmap;
44 line_drawer_ptr = (line_drawer)?line_drawer:gr_line;
47 //deal with a clipped line
48 bool must_clip_line(g3s_point *p0,g3s_point *p1,ubyte codes_or)
52 if ((p0->p3_flags&PF_TEMP_POINT) || (p1->p3_flags&PF_TEMP_POINT))
54 ret = 0; //line has already been clipped, so give up
58 clip_line(&p0,&p1,codes_or);
60 ret = g3_draw_line(p0,p1);
65 if (p0->p3_flags & PF_TEMP_POINT)
68 if (p1->p3_flags & PF_TEMP_POINT)
74 //draws a line. takes two points. returns true if drew
75 bool g3_draw_line(g3s_point *p0,g3s_point *p1)
79 if (p0->p3_codes & p1->p3_codes)
82 codes_or = p0->p3_codes | p1->p3_codes;
84 if (codes_or & CC_BEHIND)
85 return must_clip_line(p0,p1,codes_or);
87 if (!(p0->p3_flags&PF_PROJECTED))
90 if (p0->p3_flags&PF_OVERFLOW)
91 return must_clip_line(p0,p1,codes_or);
94 if (!(p1->p3_flags&PF_PROJECTED))
97 if (p1->p3_flags&PF_OVERFLOW)
98 return must_clip_line(p0,p1,codes_or);
100 return (bool) (*line_drawer_ptr)(p0->p3_sx,p0->p3_sy,p1->p3_sx,p1->p3_sy);
104 //returns true if a plane is facing the viewer. takes the unrotated surface
105 //normal of the plane, and a point on it. The normal need not be normalized
106 bool g3_check_normal_facing(vms_vector *v,vms_vector *norm)
110 vm_vec_sub(&tempv,&View_position,v);
112 return (vm_vec_dot(&tempv,norm) > 0);
115 bool do_facing_check(vms_vector *norm,g3s_point **vertlist,vms_vector *p)
117 if (norm) { //have normal
119 Assert(norm->x || norm->y || norm->z);
121 return g3_check_normal_facing(p,norm);
123 else { //normal not specified, so must compute
127 //get three points (rotated) and compute normal
129 vm_vec_perp(&tempv,&vertlist[0]->p3_vec,&vertlist[1]->p3_vec,&vertlist[2]->p3_vec);
131 return (vm_vec_dot(&tempv,&vertlist[1]->p3_vec) < 0);
135 //like g3_draw_poly(), but checks to see if facing. If surface normal is
136 //NULL, this routine must compute it, which will be slow. It is better to
137 //pre-compute the normal, and pass it to this function. When the normal
138 //is passed, this function works like g3_check_normal_facing() plus
140 //returns -1 if not facing, 1 if off screen, 0 if drew
141 bool g3_check_and_draw_poly(int nv,g3s_point **pointlist,vms_vector *norm,vms_vector *pnt)
143 if (do_facing_check(norm,pointlist,pnt))
144 return g3_draw_poly(nv,pointlist);
149 bool g3_check_and_draw_tmap(int nv,g3s_point **pointlist,g3s_uvl *uvl_list,grs_bitmap *bm,vms_vector *norm,vms_vector *pnt)
151 if (do_facing_check(norm,pointlist,pnt))
152 return g3_draw_tmap(nv,pointlist,uvl_list,bm);
157 //deal with face that must be clipped
158 bool must_clip_flat_face(int nv,g3s_codes cc)
164 bufptr = clip_polygon(Vbuf0,Vbuf1,&nv,&cc);
166 if (nv>0 && !(cc.or&CC_BEHIND) && !cc.and) {
169 g3s_point *p = bufptr[i];
171 if (!(p->p3_flags&PF_PROJECTED))
174 if (p->p3_flags&PF_OVERFLOW) {
179 Vertex_list[i*2] = p->p3_sx;
180 Vertex_list[i*2+1] = p->p3_sy;
183 (*flat_drawer_ptr)(nv,(int *)Vertex_list);
193 if (Vbuf1[i]->p3_flags & PF_TEMP_POINT)
194 free_temp_point(Vbuf1[i]);
196 // Assert(free_point_num==0);
201 #if (!(defined(D1XD3D) || defined(OGL)))
202 //draw a flat-shaded face.
203 //returns 1 if off screen, 0 if drew
204 bool g3_draw_poly(int nv,g3s_point **pointlist)
210 cc.or = 0; cc.and = 0xff;
216 bufptr[i] = pointlist[i];
218 cc.and &= bufptr[i]->p3_codes;
219 cc.or |= bufptr[i]->p3_codes;
223 return 1; //all points off screen
226 return must_clip_flat_face(nv,cc);
228 //now make list of 2d coords (& check for overflow)
231 g3s_point *p = bufptr[i];
233 if (!(p->p3_flags&PF_PROJECTED))
236 if (p->p3_flags&PF_OVERFLOW)
237 return must_clip_flat_face(nv,cc);
239 Vertex_list[i*2] = p->p3_sx;
240 Vertex_list[i*2+1] = p->p3_sy;
243 (*flat_drawer_ptr)(nv,(int *)Vertex_list);
245 return 0; //say it drew
248 bool must_clip_tmap_face(int nv,g3s_codes cc,grs_bitmap *bm);
250 //draw a texture-mapped face.
251 //returns 1 if off screen, 0 if drew
252 bool g3_draw_tmap(int nv,g3s_point **pointlist,g3s_uvl *uvl_list,grs_bitmap *bm)
258 cc.or = 0; cc.and = 0xff;
265 p = bufptr[i] = pointlist[i];
267 cc.and &= p->p3_codes;
268 cc.or |= p->p3_codes;
270 p->p3_u = uvl_list[i].u;
271 p->p3_v = uvl_list[i].v;
272 p->p3_l = uvl_list[i].l;
274 p->p3_flags |= PF_UVS + PF_LS;
279 return 1; //all points off screen
282 return must_clip_tmap_face(nv,cc,bm);
284 //now make list of 2d coords (& check for overflow)
287 g3s_point *p = bufptr[i];
289 if (!(p->p3_flags&PF_PROJECTED))
292 if (p->p3_flags&PF_OVERFLOW) {
293 Int3(); //should not overflow after clip
298 (*tmap_drawer_ptr)(bm,nv,bufptr);
300 return 0; //say it drew
304 bool must_clip_tmap_face(int nv,g3s_codes cc,grs_bitmap *bm)
309 bufptr = clip_polygon(Vbuf0,Vbuf1,&nv,&cc);
311 if (nv && !(cc.or&CC_BEHIND) && !cc.and) {
314 g3s_point *p = bufptr[i];
316 if (!(p->p3_flags&PF_PROJECTED))
319 if (p->p3_flags&PF_OVERFLOW) {
320 Int3(); //should not overflow after clip
325 (*tmap_drawer_ptr)(bm,nv,bufptr);
332 if (bufptr[i]->p3_flags & PF_TEMP_POINT)
333 free_temp_point(bufptr[i]);
335 // Assert(free_point_num==0);
342 int checkmuldiv(fix *r,fix a,fix b,fix c);
346 //draw a sortof sphere - i.e., the 2d radius is proportional to the 3d
347 //radius, but not to the distance from the eye
348 int g3_draw_sphere(g3s_point *pnt,fix rad)
350 if (! (pnt->p3_codes & CC_BEHIND)) {
352 if (! (pnt->p3_flags & PF_PROJECTED))
353 g3_project_point(pnt);
355 if (! (pnt->p3_codes & PF_OVERFLOW)) {
358 r2 = fixmul(rad,Matrix_scale.x);
360 if (checkmuldiv(&t,r2,Canv_w2,pnt->p3_z))
361 return gr_disk(pnt->p3_sx,pnt->p3_sy,t);
365 return gr_disk(pnt->p3_sx, pnt->p3_sy, fl2f(((f2fl(r2) * fCanv_w2) / f2fl(pnt->p3_z))));