move win32 window creation code from arch_init_start to arch_init to fix weirdness...
[btb/d2x.git] / texmap / tmap_lin.asm
1 ; $Id: tmap_lin.asm,v 1.2 2003-02-18 20:15:48 btb Exp $
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.
12 ;
13 ;
14 ; Linearly interpolating texture mapper inner loop
15 ;
16 ; Old Log:
17 ; Revision 1.3  1995/02/20  18:22:57  john
18 ; Put all the externs in the assembly modules into tmap_inc.asm.
19 ; Also, moved all the C versions of the inner loops into a new module,
20 ; scanline.c.
21 ;
22 ; Revision 1.2  1995/02/20  17:09:10  john
23 ; Added code so that you can build the tmapper with no assembly!
24 ;
25 ; Revision 1.1  1994/11/30  12:24:04  mike
26 ; Initial revision
27 ;
28 ; Revision 1.6  1994/11/12  16:39:40  mike
29 ; jae to ja.
30 ;
31 ; Revision 1.5  1994/02/10  21:24:43  matt
32 ; Got rid of debug_on set
33 ;
34 ; Revision 1.4  1994/01/31  15:39:53  mike
35 ; Write additional inner loop for transparency.
36 ;
37 ; Revision 1.3  1994/01/26  11:50:04  john
38 ; Added transparency to linear unlighted texture mapper.
39 ;
40 ; Revision 1.2  1993/11/22  10:24:36  mike
41 ; *** empty log message ***
42 ;
43 ; Revision 1.1  1993/09/08  17:29:50  mike
44 ; Initial revision
45 ;
46 ;
47 ;
48
49 [BITS 32]
50
51 global  _asm_tmap_scanline_lin
52 global  asm_tmap_scanline_lin
53
54 [SECTION .data]
55
56 %include        "tmap_inc.asm"
57
58 _loop_count     dd      0
59
60 [SECTION .text]
61
62 ; --------------------------------------------------------------------------------------------------
63 ; Enter:
64 ;       _xleft  fixed point left x coordinate
65 ;       _xright fixed point right x coordinate
66 ;       _y      fixed point y coordinate
67 ;       _pixptr address of source pixel map
68 ;       _u      fixed point initial u coordinate
69 ;       _v      fixed point initial v coordinate
70 ;       _du_dx  fixed point du/dx
71 ;       _dv_dx  fixed point dv/dx
72
73 ;   for (x = (int) xleft; x <= (int) xright; x++) {
74 ;      _setcolor(read_pixel_from_tmap(srcb,((int) (u/z)) & 63,((int) (v/z)) & 63));
75 ;      _setpixel(x,y);
76 ;
77 ;      u += du_dx;
78 ;      v += dv_dx;
79 ;      z += dz_dx;
80 ;   }
81
82         align   4
83 _asm_tmap_scanline_lin:
84 asm_tmap_scanline_lin:
85         pusha
86
87 ; Setup for loop:       _loop_count  iterations = (int) xright - (int) xleft
88 ;       esi     source pixel pointer = pixptr
89 ;       edi     initial row pointer = y*320+x
90
91 ; set esi = pointer to start of texture map data
92         mov     esi,[_pixptr]
93
94 ; set edi = address of first pixel to modify
95         mov     edi,[_fx_y]
96         cmp     edi,[_window_bottom]
97         ja      near _none_to_do
98
99         imul    edi,[_bytes_per_row]
100         mov     eax,[_fx_xleft]
101         test    eax, eax
102         jns     eax_ok
103         sub     eax,eax
104 eax_ok:
105         add     edi,eax
106         add     edi,[_write_buffer]
107
108 ; set _loop_count = # of iterations
109         mov     eax,[_fx_xright]
110         cmp     eax,[_window_right]
111         jb      eax_ok1
112         mov     eax,[_window_right]
113 eax_ok1:        cmp     eax,[_window_left]
114         ja      eax_ok2
115         mov     eax,[_window_left]
116 eax_ok2:
117
118         mov     ebx,[_fx_xleft]
119         sub     eax,ebx
120         js      near _none_to_do
121         cmp     eax,[_window_width]
122         jbe     _ok_to_do
123         mov     eax,[_window_width]
124 _ok_to_do:
125         mov     [_loop_count],eax
126
127 ;       edi     destination pixel pointer
128
129
130         mov     ebx,[_fx_u]
131         mov     ecx,[_fx_du_dx]
132         mov     edx,[_fx_dv_dx]
133         mov     ebp,[_fx_v]
134
135         shl     ebx,10
136         shl     ebp,10
137         shl     edx,10
138         shl     ecx,10
139
140 ; eax   work
141 ; ebx   u
142 ; ecx   du_dx
143 ; edx   dv_dx
144 ; ebp   v
145 ; esi   read address
146 ; edi   write address
147
148         test    dword [_Transparency_on],-1
149         jne     near transparent_texture
150
151 %define _size   (_end1 - _start1)/num_iters
152         mov     eax,num_iters-1
153         sub     eax,[_loop_count]
154         jns     j_eax_ok1
155         inc     eax     ; sort of a hack, but we can get -1 here and want to be graceful
156         jns     j_eax_ok1       ; if we jump, we had -1, which is kind of ok, if not, we int 3
157         int     3       ; oops, going to jump behind _start1, very bad...
158         sub     eax,eax ; ok to continue
159 j_eax_ok1:      imul    eax,eax,_size
160         add     eax,_start1
161         jmp     eax
162
163         align   4
164 _start1:
165
166 ; "OPTIMIZATIONS" maybe not worth making
167 ;    Getting rid of the esi from the mov al,[esi+eax] instruction.
168 ;       This would require moving into eax at the top of the loop, rather than doing the sub eax,eax.
169 ;       You would have to align your bitmaps so that the two shlds would create the proper base address.
170 ;       In other words, your bitmap data would have to begin at 4096x (for 64x64 bitmaps).
171 ;       I did timings without converting the sub to a mov eax,esi and setting esi to the proper value.
172 ;       There was a speedup of about 1% to 1.5% without converting the sub to a mov.
173 ;    Getting rid of the edi by doing a mov nnnn[edi],al instead of mov [edi],al.
174 ;       The problem with this is you would have a dword offset for nnnn.  My timings indicate it is slower.  (I think.)
175 ;    Combining u,v and du,dv into single longwords.
176 ;       The problem with this is you then must do a 16 bit operation to extract them, and you don't have enough
177 ;       instructions to separate a destination operand from being used by the next instruction.  It shaves out one
178 ;       register instruction (an add reg,reg), but adds a 16 bit operation, and the setup is more complicated.
179 ; usage:
180 ;       eax     work
181 ;       ebx     u coordinate
182 ;       ecx     delta u
183 ;       edx     delta v
184 ;       ebp     v coordinate
185 ;       esi     pointer to source bitmap
186 ;       edi     write address
187 %rep num_iters
188         mov     eax,ebp ; clear for 
189         add     ebp,edx ; update v coordinate
190         shr     eax,26  ; shift in v coordinate
191         shld    eax,ebx,6       ; shift in u coordinate while shifting up v coordinate
192         add     ebx,ecx ; update u coordinate
193         mov     al,[esi+eax]    ; get pixel from source bitmap
194         mov     [edi],al
195         inc     edi             ; XPARENT ADDED BY JOHN
196
197 ; inner loop if bitmaps are 256x256
198 ; your register usage is bogus, and you must clear ecx
199 ; fix your setup
200 ; this is only about 10% faster in the inner loop
201 ; this method would adapt to writing two pixels at a time better than
202 ; the 64x64 method because you wouldn't run out of registers
203 ; Note that this method assumes that both dv_dx and du_dx are in edx.
204 ; edx = vi|vf|ui|uf
205 ; where each field is 8 bits, vi = integer v coordinate, vf = fractional v coordinate, etc.
206 ;** add ebx,edx
207 ;** mov cl,bh
208 ;** shld cx,bx,8
209 ;** mov al,[esi+ecx]
210 ;** mov [edi],al
211 ;** inc edi
212 %endrep
213
214 _end1:
215
216 _none_to_do:    popa
217
218         ret
219
220 ; ----------------------------------------------------------------------------------------
221 ; if texture map has transparency, use this code.
222 transparent_texture:
223         test    dword [_loop_count],-1
224         je      _t_none_to_do
225 loop_transparent:
226         mov     eax,ebp ; clear for 
227         add     ebp,edx ; update v coordinate
228         shr     eax,26  ; shift in v coordinate
229         shld    eax,ebx,6       ; shift in u coordinate while shifting up v coordinate
230         add     ebx,ecx ; update u coordinate
231         mov     al,[esi+eax]    ; get pixel from source bitmap
232         cmp     al,255
233         je      transp
234         mov     [edi],al
235 transp: inc     edi             ; XPARENT ADDED BY JOHN
236
237         dec     dword [_loop_count]
238         jne     loop_transparent
239
240 _t_none_to_do:  popa
241         ret
242
243
244 ; This is the inner loop to write two pixels at a time
245 ; This is about 2.5% faster overall (on Mike's 66 MHz 80486 DX2, VLB)
246 ; You must write code to even align edi and do half as many iterations, and write
247 ; the beginning and ending extra pixels, if necessary.
248 ;       sub     eax,eax ; clear for 
249 ;       shld    eax,ebp,6       ; shift in v coordinate
250 ;       add     ebp,_fx_dv_dx   ; update v coordinate
251 ;       shld    eax,ebx,6       ; shift in u coordinate while shifting up v coordinate
252 ;       add     ebx,ecx ; update u coordinate
253 ;       mov     dl,[esi+eax]    ; get pixel from source bitmap
254 ;
255 ;       sub     eax,eax ; clear for 
256 ;       shld    eax,ebp,6       ; shift in v coordinate
257 ;       add     ebp,_fx_dv_dx   ; update v coordinate
258 ;       shld    eax,ebx,6       ; shift in u coordinate while shifting up v coordinate
259 ;       add     ebx,ecx ; update u coordinate
260 ;       mov     dh,[esi+eax]    ; get pixel from source bitmap
261 ;
262 ;       mov     [edi],dx
263 ;       add     edi,2
264