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.
23 // John's new stuff below here....
26 int scale_initial_pixel_count;
29 int scale_final_pixel_count;
30 int scale_ydelta_minus_1;
32 ubyte * scale_source_ptr;
33 ubyte * scale_dest_ptr;
36 ubyte scale_rle_data[640];
38 void scale_up_bitmap(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 );
39 void scale_up_bitmap_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 );
40 void rls_stretch_scanline_setup( int XDelta, int YDelta );
41 void rls_stretch_scanline(void);
44 void decode_row( grs_bitmap * bmp, int y )
46 int i, offset=4+bmp->bm_h;
49 offset += bmp->bm_data[4+i];
50 gr_rle_decode( &bmp->bm_data[offset], scale_rle_data );
53 void scale_up_bitmap(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
58 dv = (v1-v0) / (y1-y0);
60 rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
61 if ( scale_ydelta_minus_1 < 1 ) return;
65 for (y=y0; y<=y1; y++ ) {
66 scale_source_ptr = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)+f2i(u0)];
67 scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
68 rls_stretch_scanline();
76 void scale_up_bitmap_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
81 dv = (v1-v0) / (y1-y0);
83 rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
84 if ( scale_ydelta_minus_1 < 1 ) return;
88 for (y=y0; y<=y1; y++ ) {
89 if ( f2i(v) != last_row ) {
91 decode_row( source_bmp, last_row );
93 scale_source_ptr = &scale_rle_data[f2i(u0)];
94 scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
95 rls_stretch_scanline();
100 void rls_stretch_scanline_setup( int XDelta, int YDelta )
102 scale_ydelta_minus_1 = YDelta - 1;
105 /* Minimum # of pixels in a run in this line */
106 scale_whole_step = XDelta / YDelta;
108 /* Error term adjust each time Y steps by 1; used to tell when one
109 extra pixel should be drawn as part of a run, to account for
110 fractional steps along the X axis per 1-pixel steps along Y */
111 scale_adj_up = (XDelta % YDelta) * 2;
113 /* Error term adjust when the error term turns over, used to factor
114 out the X step made at that time */
115 scale_adj_down = YDelta * 2;
117 /* Initial error term; reflects an initial step of 0.5 along the Y
119 scale_error_term = (XDelta % YDelta) - (YDelta * 2);
121 /* The initial and last runs are partial, because Y advances only 0.5
122 for these runs, rather than 1. Divide one full run, plus the
123 initial pixel, between the initial and last runs */
124 scale_initial_pixel_count = (scale_whole_step / 2) + 1;
125 scale_final_pixel_count = scale_initial_pixel_count;
127 /* If the basic run length is even and there's no fractional
128 advance, we have one pixel that could go to either the initial
129 or last partial run, which we'll arbitrarily allocate to the
131 if ((scale_adj_up == 0) && ((scale_whole_step & 0x01) == 0))
133 scale_initial_pixel_count--;
135 /* If there're an odd number of pixels per run, we have 1 pixel that can't
136 be allocated to either the initial or last partial run, so we'll add 0.5
137 to error term so this pixel will be handled by the normal full-run loop */
138 if ((scale_whole_step & 0x01) != 0)
140 scale_error_term += YDelta;
145 void rls_stretch_scanline()
148 int i, j, len, ErrorTerm, x;
150 // Setup initial variables
151 ErrorTerm = scale_error_term;
153 // Draw the first, partial run of pixels
155 c = *scale_source_ptr++;
156 if ( c != TRANSPARENCY_COLOR ) {
157 for (i=0; i<scale_initial_pixel_count; i++ )
158 *scale_dest_ptr++ = c;
160 scale_dest_ptr += scale_initial_pixel_count;
163 // Draw all full runs
165 for (j=0; j<scale_ydelta_minus_1; j++) {
166 len = scale_whole_step; // run is at least this long
168 // Advance the error term and add an extra pixel if the error term so indicates
169 if ((ErrorTerm += scale_adj_up) > 0) {
171 ErrorTerm -= scale_adj_down; // reset the error term
174 // Draw this run o' pixels
175 c = *scale_source_ptr++;
176 if ( c != TRANSPARENCY_COLOR ) {
179 while ((size_t)(scale_dest_ptr) & 0x3) { *scale_dest_ptr++ = c; len--; };
181 x = (c << 24) | (c << 16) | (c << 8) | c;
182 while (len > 4) { *((int *)scale_dest_ptr) = x; scale_dest_ptr += 4; len -= 4; };
184 while (len > 0) { *scale_dest_ptr++ = c; len--; };
186 for (i=0; i<len; i++ )
187 *scale_dest_ptr++ = c;
190 scale_dest_ptr += len;
194 // Draw the final run of pixels
195 c = *scale_source_ptr++;
196 if ( c != TRANSPARENCY_COLOR ) {
197 for (i=0; i<scale_final_pixel_count; i++ )
198 *scale_dest_ptr++ = c;
200 scale_dest_ptr += scale_final_pixel_count;
206 void scale_bitmap_c(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
210 ubyte * sbits, * dbits;
212 du = (u1-u0) / (x1-x0);
213 dv = (v1-v0) / (y1-y0);
217 for (y=y0; y<=y1; y++ ) {
218 sbits = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)];
219 dbits = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
222 for (x=x0; x<=x1; x++ ) {
223 *dbits++ = sbits[ u >> 16 ];
229 void scale_row_asm_transparent( ubyte * sbits, ubyte * dbits, int width, fix u, fix du )
235 for (i=0; i<width; i++ ) {
236 c = sbits[ u >> 16 ];
237 if ( c!=TRANSPARENCY_COLOR)
245 ubyte *dbits_end = &dbits[width-1];
252 next_u_int = f2i(u)+1;
253 c = sbits[ next_u_int ];
254 next_u = i2f(next_u_int);
255 if ( c != TRANSPARENCY_COLOR ) goto NonTransparent;
260 if ( dbits > dbits_end ) return;
263 next_u_int = f2i(u)+1;
264 c = sbits[ next_u_int ];
265 next_u = i2f(next_u_int);
266 if ( c != TRANSPARENCY_COLOR ) goto NonTransparent;
274 if ( dbits > dbits_end ) return;
277 next_u_int = f2i(u)+1;
278 c = sbits[ next_u_int ];
279 next_u = i2f(next_u_int);
280 if ( c == TRANSPARENCY_COLOR ) goto Transparent;
288 for ( i=0; i<width; i++ ) {
291 if ( c != TRANSPARENCY_COLOR )
300 void scale_bitmap_c_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
305 du = (u1-u0) / (x1-x0);
306 dv = (v1-v0) / (y1-y0);
310 for (y=y0; y<=y1; y++ ) {
311 if ( f2i(v) != last_row ) {
313 decode_row( source_bmp, last_row );
315 scale_row_asm_transparent( scale_rle_data, &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0], x1-x0+1, u0, du );
320 #define FIND_SCALED_NUM(x,x0,x1,y0,y1) (fixmuldiv((x)-(x0),(y1)-(y0),(x1)-(x0))+(y0))
322 // Scales bitmap, bp, into vertbuf[0] to vertbuf[1]
323 void scale_bitmap(grs_bitmap *bp, grs_point *vertbuf ,int orientation)
325 grs_bitmap * dbp = &grd_curcanv->cv_bitmap;
328 fix clipped_x0, clipped_y0, clipped_x1, clipped_y1;
329 fix clipped_u0, clipped_v0, clipped_u1, clipped_v1;
330 fix xmin, xmax, ymin, ymax;
331 int dx0, dy0, dx1, dy1;
333 // Set initial variables....
335 x0 = vertbuf[0].x; y0 = vertbuf[0].y;
336 x1 = vertbuf[2].x; y1 = vertbuf[2].y;
339 xmax = i2f(dbp->bm_w)-fl2f(.5); ymax = i2f(dbp->bm_h)-fl2f(.5);
341 u0 = i2f(0); v0 = i2f(0);
342 u1 = i2f(bp->bm_w-1); v1 = i2f(bp->bm_h-1);
344 // Check for obviously offscreen bitmaps...
345 if ( (y1<=y0) || (x1<=x0) ) return;
346 if ( (x1<0 ) || (x0>=xmax) ) return;
347 if ( (y1<0 ) || (y0>=ymax) ) return;
349 clipped_u0 = u0; clipped_v0 = v0;
350 clipped_u1 = u1; clipped_v1 = v1;
352 clipped_x0 = x0; clipped_y0 = y0;
353 clipped_x1 = x1; clipped_y1 = y1;
355 // Clip the left, moving u0 right as necessary
357 clipped_u0 = FIND_SCALED_NUM(xmin,x0,x1,u0,u1);
361 // Clip the right, moving u1 left as necessary
363 clipped_u1 = FIND_SCALED_NUM(xmax,x0,x1,u0,u1);
367 // Clip the top, moving v0 down as necessary
369 clipped_v0 = FIND_SCALED_NUM(ymin,y0,y1,v0,v1);
373 // Clip the bottom, moving v1 up as necessary
375 clipped_v1 = FIND_SCALED_NUM(ymax,y0,y1,v0,v1);
379 dx0 = f2i(clipped_x0); dx1 = f2i(clipped_x1);
380 dy0 = f2i(clipped_y0); dy1 = f2i(clipped_y1);
382 if (dx1<=dx0) return;
383 if (dy1<=dy0) return;
387 // Assert( dx1<dbp->bm_w );
388 // Assert( dy1<dbp->bm_h );
389 // Assert( f2i(u0)<=f2i(u1) );
390 // Assert( f2i(v0)<=f2i(v1) );
391 // Assert( f2i(u0)>=0 );
392 // Assert( f2i(v0)>=0 );
393 // Assert( u1<i2f(bp->bm_w) );
394 // Assert( v1<i2f(bp->bm_h) );
395 //mprintf( 0, "(%.2f,%.2f) to (%.2f,%.2f) using (%.2f,%.2f) to (%.2f,%.2f)\n", f2fl(clipped_x0), f2fl(clipped_y0), f2fl(clipped_x1), f2fl(clipped_y1), f2fl(clipped_u0), f2fl(clipped_v0), f2fl(clipped_u1), f2fl(clipped_v1) );
397 dtemp = f2i(clipped_u1)-f2i(clipped_u0);
400 if ( bp->bm_flags & BM_FLAG_RLE )
401 scale_bitmap_c_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
403 scale_bitmap_c(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
405 if ( bp->bm_flags & BM_FLAG_RLE ) {
406 if ( (dtemp < (f2i(clipped_x1)-f2i(clipped_x0))) && (dtemp>0) )
407 scale_up_bitmap_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
409 scale_bitmap_c_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
411 if ( (dtemp < (f2i(clipped_x1)-f2i(clipped_x0))) && (dtemp>0) )
412 scale_up_bitmap(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
414 scale_bitmap_c(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );