build dumpmine.c for editor
[btb/d2x.git] / texmap / tmapflat.c
1 /* $Id: tmapflat.c,v 1.6 2004-08-28 23:17:46 schaffner Exp $ */
2 /*
3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
12 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
13 */
14
15 /*
16  *
17  * Flat shader derived from texture mapper (a little slow)
18  *
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <conf.h>
23 #endif
24
25 #include "fix.h"
26 #include "vecmat.h"
27 #include "gr.h"
28 #include "grdef.h"
29 #include "texmap.h"
30 #include "texmapl.h"
31 #include "scanline.h"
32
33 //#include "tmapext.h"
34
35 #ifndef OGL
36
37 void (*scanline_func)(int,fix,fix);
38
39 // -------------------------------------------------------------------------------------
40 //      Texture map current scanline.
41 //      Uses globals Du_dx and Dv_dx to incrementally compute u,v coordinates
42 // -------------------------------------------------------------------------------------
43 void tmap_scanline_flat(int y, fix xleft, fix xright)
44 {
45         if (xright < xleft)
46                 return;
47
48         // setup to call assembler scanline renderer
49
50         fx_y = y;
51         fx_xleft = f2i(xleft);
52         fx_xright = f2i(xright);
53
54         if ( Gr_scanline_darkening_level >= GR_FADE_LEVELS )
55                 cur_tmap_scanline_flat();
56         else    {
57                 tmap_flat_shade_value = Gr_scanline_darkening_level;
58                 cur_tmap_scanline_shaded();
59         }       
60 }
61
62
63 //--unused-- void tmap_scanline_shaded(int y, fix xleft, fix xright)
64 //--unused-- {
65 //--unused--    fix     dx;
66 //--unused-- 
67 //--unused--    dx = xright - xleft;
68 //--unused-- 
69 //--unused--    // setup to call assembler scanline renderer
70 //--unused-- 
71 //--unused--    fx_y = y << 16;
72 //--unused--    fx_xleft = xleft;
73 //--unused--    fx_xright = xright;
74 //--unused-- 
75 //--unused--    asm_tmap_scanline_shaded();
76 //--unused-- }
77
78
79 // -------------------------------------------------------------------------------------
80 //      Render a texture map.
81 // Linear in outer loop, linear in inner loop.
82 // -------------------------------------------------------------------------------------
83 void texture_map_flat(g3ds_tmap *t, int color)
84 {
85         int     vlt,vrt,vlb,vrb;        // vertex left top, vertex right top, vertex left bottom, vertex right bottom
86         int     topy,boty,y, dy;
87         fix     dx_dy_left,dx_dy_right;
88         int     max_y_vertex;
89         fix     xleft,xright;
90         fix     recip_dy;
91         g3ds_vertex *v3d;
92
93         v3d = t->verts;
94
95         tmap_flat_color = color;
96
97         // Determine top and bottom y coords.
98         compute_y_bounds(t,&vlt,&vlb,&vrt,&vrb,&max_y_vertex);
99
100         // Set top and bottom (of entire texture map) y coordinates.
101         topy = f2i(v3d[vlt].y2d);
102         boty = f2i(v3d[max_y_vertex].y2d);
103
104         // Set amount to change x coordinate for each advance to next scanline.
105         dy = f2i(t->verts[vlb].y2d) - f2i(t->verts[vlt].y2d);
106         if (dy < FIX_RECIP_TABLE_SIZE)
107                 recip_dy = fix_recip[dy];
108         else
109                 recip_dy = F1_0/dy;
110
111         dx_dy_left = compute_dx_dy(t,vlt,vlb, recip_dy);
112
113         dy = f2i(t->verts[vrb].y2d) - f2i(t->verts[vrt].y2d);
114         if (dy < FIX_RECIP_TABLE_SIZE)
115                 recip_dy = fix_recip[dy];
116         else
117                 recip_dy = F1_0/dy;
118
119         dx_dy_right = compute_dx_dy(t,vrt,vrb, recip_dy);
120
121         // Set initial values for x, u, v
122         xleft = v3d[vlt].x2d;
123         xright = v3d[vrt].x2d;
124
125         // scan all rows in texture map from top through first break.
126         // @mk: Should we render the scanline for y==boty?  This violates Matt's spec.
127
128         for (y = topy; y < boty; y++) {
129
130                 // See if we have reached the end of the current left edge, and if so, set
131                 // new values for dx_dy and x,u,v
132                 if (y == f2i(v3d[vlb].y2d)) {
133                         // Handle problem of double points.  Search until y coord is different.  Cannot get
134                         // hung in an infinite loop because we know there is a vertex with a lower y coordinate
135                         // because in the for loop, we don't scan all spanlines.
136                         while (y == f2i(v3d[vlb].y2d)) {
137                                 vlt = vlb;
138                                 vlb = prevmod(vlb,t->nv);
139                         }
140                         dy = f2i(t->verts[vlb].y2d) - f2i(t->verts[vlt].y2d);
141                         if (dy < FIX_RECIP_TABLE_SIZE)
142                                 recip_dy = fix_recip[dy];
143                         else
144                                 recip_dy = F1_0/dy;
145
146                         dx_dy_left = compute_dx_dy(t,vlt,vlb, recip_dy);
147
148                         xleft = v3d[vlt].x2d;
149                 }
150
151                 // See if we have reached the end of the current left edge, and if so, set
152                 // new values for dx_dy and x.  Not necessary to set new values for u,v.
153                 if (y == f2i(v3d[vrb].y2d)) {
154                         while (y == f2i(v3d[vrb].y2d)) {
155                                 vrt = vrb;
156                                 vrb = succmod(vrb,t->nv);
157                         }
158
159                         dy = f2i(t->verts[vrb].y2d) - f2i(t->verts[vrt].y2d);
160                         if (dy < FIX_RECIP_TABLE_SIZE)
161                                 recip_dy = fix_recip[dy];
162                         else
163                                 recip_dy = F1_0/dy;
164
165                         dx_dy_right = compute_dx_dy(t,vrt,vrb, recip_dy);
166
167                         xright = v3d[vrt].x2d;
168
169                 }
170
171                 //tmap_scanline_flat(y, xleft, xright);
172                 (*scanline_func)(y, xleft, xright);
173
174                 xleft += dx_dy_left;
175                 xright += dx_dy_right;
176
177         }
178         //tmap_scanline_flat(y, xleft, xright);
179         (*scanline_func)(y, xleft, xright);
180 }
181
182
183 //      -----------------------------------------------------------------------------------------
184 //      This is the gr_upoly-like interface to the texture mapper which uses texture-mapper compatible
185 //      (ie, avoids cracking) edge/delta computation.
186 void gr_upoly_tmap(int nverts, int *vert )
187 {
188         gr_upoly_tmap_ylr(nverts, vert, tmap_scanline_flat);
189 }
190
191 #include "3d.h"
192 #include "error.h"
193
194 typedef struct pnt2d {
195         fix x,y;
196 } pnt2d;
197
198 #ifdef __WATCOMC__
199 #pragma off (unreferenced)              //bp not referenced
200 #endif
201
202 //this takes the same partms as draw_tmap, but draws a flat-shaded polygon
203 void draw_tmap_flat(grs_bitmap *bp,int nverts,g3s_point **vertbuf)
204 {
205         pnt2d   points[MAX_TMAP_VERTS];
206         int     i;
207         fix     average_light;
208         int     color;
209
210         Assert(nverts < MAX_TMAP_VERTS);
211
212         average_light = vertbuf[0]->p3_l;
213         for (i=1; i<nverts; i++)
214                 average_light += vertbuf[i]->p3_l;
215
216         if (nverts == 4)
217                 average_light = f2i(average_light * NUM_LIGHTING_LEVELS/4);
218         else
219                 average_light = f2i(average_light * NUM_LIGHTING_LEVELS/nverts);
220
221         if (average_light < 0)
222                 average_light = 0;
223         else if (average_light > NUM_LIGHTING_LEVELS-1)
224                 average_light = NUM_LIGHTING_LEVELS-1;
225
226         color = gr_fade_table[average_light*256 + bp->avg_color];
227         gr_setcolor(color);
228
229         for (i=0;i<nverts;i++) {
230                 points[i].x = vertbuf[i]->p3_sx;
231                 points[i].y = vertbuf[i]->p3_sy;
232         }
233
234         gr_upoly_tmap(nverts,(int *) points);
235
236 }
237 #ifdef __WATCOMC__
238 #pragma on (unreferenced)
239 #endif
240
241 //      -----------------------------------------------------------------------------------------
242 //This is like gr_upoly_tmap() but instead of drawing, it calls the specified
243 //function with ylr values
244 void gr_upoly_tmap_ylr(int nverts, int *vert, void (*ylr_func)(int,fix,fix) )
245 {
246         g3ds_tmap       my_tmap;
247         int                     i;
248
249         //--now called from g3_start_frame-- init_interface_vars_to_assembler();
250
251         my_tmap.nv = nverts;
252
253         for (i=0; i<nverts; i++) {
254                 my_tmap.verts[i].x2d = *vert++;
255                 my_tmap.verts[i].y2d = *vert++;
256         }
257
258         scanline_func = ylr_func;
259
260         texture_map_flat(&my_tmap, COLOR);
261 }
262
263 #endif //!OGL