开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
T3DLIB12.CPP
资源名称：Source.rar　[点击查看]
上传用户：husern
上传日期：2018-01-20
资源大小：42486k
文件大小：252k
源码类别：

游戏

开发平台：

Visual C++

T3DLIB12.CPP：源码内容
  1. ui+=du;
  2. vi+=dv;
  3. wi+=dw;
  4. zi+=dz;
  6. si+=ds;
  7. ti+=dt;
  9. } // end for xi
  11. // interpolate u,v,w,x along right and left edge
  12. xl+=dxdyl;
  13. ul+=dudyl;
  14. vl+=dvdyl;
  15. wl+=dwdyl;
  16. zl+=dzdyl;
  18. sl+=dsdyl;
  19. tl+=dtdyl;
  21. xr+=dxdyr;
  22. ur+=dudyr;
  23. vr+=dvdyr;
  24. wr+=dwdyr;
  25. zr+=dzdyr;
  27. sr+=dsdyr;
  28. tr+=dtdyr;
  30. // advance screen ptr
  31. screen_ptr+=mem_pitch;
  33.         // advance zbuffer ptr
  34.         z_ptr+=zpitch;
  36. } // end for y
  38. } // end if non-clipped
  40. } // end if
  41. else
  42. if (tri_type==TRI_TYPE_GENERAL)
  43. {
  45. // first test for bottom clip, always
  46. if ((yend = y2) > max_clip_y)
  47. yend = max_clip_y;
  49. // pre-test y clipping status
  50. if (y1 < min_clip_y)
  51. {
  52. // compute all deltas
  53. // LHS
  54. dyl = (y2 - y1);
  56. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  57. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  58. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  59. dwdyl = ((tw2 - tw1) << FIXP16_SHIFT)/dyl;  
  60. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;  
  62. dsdyl = ((ts2 - ts1) << FIXP16_SHIFT)/dyl;    
  63. dtdyl = ((tt2 - tt1) << FIXP16_SHIFT)/dyl;  
  65. // RHS
  66. dyr = (y2 - y0);
  68. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  69. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  70. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  71. dwdyr = ((tw2 - tw0) << FIXP16_SHIFT)/dyr;   
  72. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  74. dsdyr = ((ts2 - ts0) << FIXP16_SHIFT)/dyr;   
  75. dtdyr = ((tt2 - tt0) << FIXP16_SHIFT)/dyr;  
  77. // compute overclip
  78. dyr = (min_clip_y - y0);
  79. dyl = (min_clip_y - y1);
  81. // computer new LHS starting values
  82. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  84. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  85. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  86. wl = dwdyl*dyl + (tw1 << FIXP16_SHIFT);
  87. zl = dzdyl*dyl + (tz1 << FIXP16_SHIFT);
  89. sl = dsdyl*dyl + (ts1 << FIXP16_SHIFT);
  90. tl = dtdyl*dyl + (tt1 << FIXP16_SHIFT);
  92. // compute new RHS starting values
  93. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  95. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  96. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  97. wr = dwdyr*dyr + (tw0 << FIXP16_SHIFT);
  98. zr = dzdyr*dyr + (tz0 << FIXP16_SHIFT);
  100. sr = dsdyr*dyr + (ts0 << FIXP16_SHIFT);
  101. tr = dtdyr*dyr + (tt0 << FIXP16_SHIFT);
  103. // compute new starting y
  104. ystart = min_clip_y;
  106. // test if we need swap to keep rendering left to right
  107. if (dxdyr > dxdyl)
  108. {
  109. SWAP(dxdyl,dxdyr,temp);
  110. SWAP(dudyl,dudyr,temp);
  111. SWAP(dvdyl,dvdyr,temp);
  112. SWAP(dwdyl,dwdyr,temp);
  113. SWAP(dzdyl,dzdyr,temp);
  115. SWAP(dsdyl,dsdyr,temp);
  116. SWAP(dtdyl,dtdyr,temp);
  118.           SWAP(xl,xr,temp);
  119. SWAP(ul,ur,temp);
  120. SWAP(vl,vr,temp);
  121. SWAP(wl,wr,temp);
  122. SWAP(zl,zr,temp);
  124. SWAP(sl,sr,temp);
  125. SWAP(tl,tr,temp);
  127. SWAP(x1,x2,temp);
  128. SWAP(y1,y2,temp);
  129. SWAP(tu1,tu2,temp);
  130. SWAP(tv1,tv2,temp);
  131. SWAP(tw1,tw2,temp);
  132. SWAP(tz1,tz2,temp);
  134. SWAP(ts1,ts2,temp);
  135. SWAP(tt1,tt2,temp);
  137. // set interpolation restart
  138. irestart = INTERP_RHS;
  140. } // end if
  142. } // end if
  143. else
  144. if (y0 < min_clip_y)
  145. {
  146. // compute all deltas
  147. // LHS
  148. dyl = (y1 - y0);
  150. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  151. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  152. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  153. dwdyl = ((tw1 - tw0) << FIXP16_SHIFT)/dyl; 
  154. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl; 
  156. dsdyl = ((ts1 - ts0) << FIXP16_SHIFT)/dyl;    
  157. dtdyl = ((tt1 - tt0) << FIXP16_SHIFT)/dyl; 
  159. // RHS
  160. dyr = (y2 - y0);
  162. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  163. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  164. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  165. dwdyr = ((tw2 - tw0) << FIXP16_SHIFT)/dyr;   
  166. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  168. dsdyr = ((ts2 - ts0) << FIXP16_SHIFT)/dyr;   
  169. dtdyr = ((tt2 - tt0) << FIXP16_SHIFT)/dyr;   
  171. // compute overclip
  172. dy = (min_clip_y - y0);
  174. // computer new LHS starting values
  175. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  176. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  177. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  178. wl = dwdyl*dy + (tw0 << FIXP16_SHIFT);
  179. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  181. sl = dsdyl*dy + (ts0 << FIXP16_SHIFT);
  182. tl = dtdyl*dy + (tt0 << FIXP16_SHIFT);
  184. // compute new RHS starting values
  185. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  186. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  187. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  188. wr = dwdyr*dy + (tw0 << FIXP16_SHIFT);
  189. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  191. sr = dsdyr*dy + (ts0 << FIXP16_SHIFT);
  192. tr = dtdyr*dy + (tt0 << FIXP16_SHIFT);
  194. // compute new starting y
  195. ystart = min_clip_y;
  197. // test if we need swap to keep rendering left to right
  198. if (dxdyr < dxdyl)
  199. {
  200. SWAP(dxdyl,dxdyr,temp);
  201. SWAP(dudyl,dudyr,temp);
  202. SWAP(dvdyl,dvdyr,temp);
  203. SWAP(dwdyl,dwdyr,temp);
  204. SWAP(dzdyl,dzdyr,temp);
  206. SWAP(dsdyl,dsdyr,temp);
  207. SWAP(dtdyl,dtdyr,temp);
  209. SWAP(xl,xr,temp);
  210. SWAP(ul,ur,temp);
  211. SWAP(vl,vr,temp);
  212. SWAP(wl,wr,temp);
  213. SWAP(zl,zr,temp);
  215. SWAP(sl,sr,temp);
  216. SWAP(tl,tr,temp);
  218. SWAP(x1,x2,temp);
  219. SWAP(y1,y2,temp);
  220. SWAP(tu1,tu2,temp);
  221. SWAP(tv1,tv2,temp);
  222. SWAP(tw1,tw2,temp);
  223. SWAP(tz1,tz2,temp);
  225. SWAP(ts1,ts2,temp);
  226. SWAP(tt1,tt2,temp);
  228. // set interpolation restart
  229. irestart = INTERP_RHS;
  231. } // end if
  233. } // end if
  234. else
  235. {
  236. // no initial y clipping
  238. // compute all deltas
  239. // LHS
  240. dyl = (y1 - y0);
  242. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  243. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  244. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  245. dwdyl = ((tw1 - tw0) << FIXP16_SHIFT)/dyl;   
  246. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;  
  248. dsdyl = ((ts1 - ts0) << FIXP16_SHIFT)/dyl;    
  249. dtdyl = ((tt1 - tt0) << FIXP16_SHIFT)/dyl;   
  251. // RHS
  252. dyr = (y2 - y0);
  254. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  255. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  256. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  257. dwdyr = ((tw2 - tw0) << FIXP16_SHIFT)/dyr;
  258. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;
  260. dsdyr = ((ts2 - ts0) << FIXP16_SHIFT)/dyr;   
  261. dtdyr = ((tt2 - tt0) << FIXP16_SHIFT)/dyr;
  263. // no clipping y
  265. // set starting values
  266. xl = (x0 << FIXP16_SHIFT);
  267. xr = (x0 << FIXP16_SHIFT);
  269. ul = (tu0 << FIXP16_SHIFT);
  270. vl = (tv0 << FIXP16_SHIFT);
  271. wl = (tw0 << FIXP16_SHIFT);
  272. zl = (tz0 << FIXP16_SHIFT);
  274. sl = (ts0 << FIXP16_SHIFT);
  275. tl = (tt0 << FIXP16_SHIFT);
  277. ur = (tu0 << FIXP16_SHIFT);
  278. vr = (tv0 << FIXP16_SHIFT);
  279. wr = (tw0 << FIXP16_SHIFT);
  280. zr = (tz0 << FIXP16_SHIFT);
  282. sr = (ts0 << FIXP16_SHIFT);
  283. tr = (tt0 << FIXP16_SHIFT);
  285. // set starting y
  286. ystart = y0;
  288. // test if we need swap to keep rendering left to right
  289. if (dxdyr < dxdyl)
  290. {
  291. SWAP(dxdyl,dxdyr,temp);
  292. SWAP(dudyl,dudyr,temp);
  293. SWAP(dvdyl,dvdyr,temp);
  294. SWAP(dwdyl,dwdyr,temp);
  295. SWAP(dzdyl,dzdyr,temp);
  297. SWAP(dsdyl,dsdyr,temp);
  298. SWAP(dtdyl,dtdyr,temp);
  301. SWAP(xl,xr,temp);
  302. SWAP(ul,ur,temp);
  303. SWAP(vl,vr,temp);
  304. SWAP(wl,wr,temp);
  305. SWAP(zl,zr,temp);
  307. SWAP(sl,sr,temp);
  308. SWAP(tl,tr,temp);
  311. SWAP(x1,x2,temp);
  312. SWAP(y1,y2,temp);
  313. SWAP(tu1,tu2,temp);
  314. SWAP(tv1,tv2,temp);
  315. SWAP(tw1,tw2,temp);
  316. SWAP(tz1,tz2,temp);
  318. SWAP(ts1,ts2,temp);
  319. SWAP(tt1,tt2,temp);
  321. // set interpolation restart
  322. irestart = INTERP_RHS;
  324. } // end if
  326. } // end else
  328.     // test for horizontal clipping
  329. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  330. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  331. (x2 < min_clip_x) || (x2 > max_clip_x))
  332. {
  333.     // clip version
  334. // x clipping
  336. // point screen ptr to starting line
  337. screen_ptr = dest_buffer + (ystart * mem_pitch);
  339.     // point zbuffer to starting line
  340.     z_ptr = zbuffer + (ystart * zpitch);
  342. for (yi = ystart; yi < yend; yi++)
  343. {
  344. // compute span endpoints
  345. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  346. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  348. // compute starting points for u,v,w interpolants
  349. ui = ul + FIXP16_ROUND_UP;
  350. vi = vl + FIXP16_ROUND_UP;
  351. wi = wl + FIXP16_ROUND_UP;
  352. zi = zl + FIXP16_ROUND_UP;
  354. si = sl + FIXP16_ROUND_UP;
  355. ti = tl + FIXP16_ROUND_UP;
  357. // compute u,v interpolants
  358. if ((dx = (xend - xstart))>0)
  359. {
  360. du = (ur - ul)/dx;
  361. dv = (vr - vl)/dx;
  362. dw = (wr - wl)/dx;
  363. dz = (zr - zl)/dx;
  365. ds = (sr - sl)/dx;
  366. dt = (tr - tl)/dx;
  368. } // end if
  369. else
  370. {
  371. du = (ur - ul);
  372. dv = (vr - vl);
  373. dw = (wr - wl);
  374. dz = (zr - zl);
  376. ds = (sr - sl);
  377. dt = (tr - tl);
  379. } // end else
  381. ///////////////////////////////////////////////////////////////////////
  383. // test for x clipping, LHS
  384. if (xstart < min_clip_x)
  385. {
  386. // compute x overlap
  387. dx = min_clip_x - xstart;
  389. // slide interpolants over
  390. ui+=dx*du;
  391. vi+=dx*dv;
  392. wi+=dx*dw;
  393. zi+=dx*dz;
  395. si+=dx*ds;
  396. ti+=dx*dt;
  398. // set x to left clip edge
  399. xstart = min_clip_x;
  401. } // end if
  403. // test for x clipping RHS
  404. if (xend > max_clip_x)
  405. xend = max_clip_x;
  407. ///////////////////////////////////////////////////////////////////////
  409. // draw span
  410. for (xi=xstart; xi < xend; xi++)
  411. {
  412. // write textel assume 5.6.5
  413.             // write thru z buffer always
  414.     // get textel first
  415.   textel = textmap[(si >> FIXP16_SHIFT) + ((ti >> FIXP16_SHIFT) << texture_shift2)];
  417.             if (textel)
  418.             {
  419.            
  420.             // extract rgb components
  421.             r_textel  = ((textel >> 11)       ); 
  422.             g_textel  = ((textel >> 5)  & 0x3f); 
  423.             b_textel =   (textel        & 0x1f);
  425.             // modulate textel with gouraud shading
  426.             r_textel*=ui; 
  427.             g_textel*=vi;
  428.             b_textel*=wi;
  430.             // finally write pixel, note that we did the math such that the results are r*32, g*64, b*32
  431.             // hence we need to divide the results by 32,64,32 respetively, BUT since we need to shift
  432.             // the results to fit into the destination 5.6.5 word, we can take advantage of the shifts
  433.             // and they all cancel out for the most part, but we will need logical anding, we will do
  434.             // it later when we optimize more...
  435.             screen_ptr[xi] = ((b_textel >> (FIXP16_SHIFT+8)) + 
  436.                              ((g_textel >> (FIXP16_SHIFT+8)) << 5) + 
  437.                              ((r_textel >> (FIXP16_SHIFT+8)) << 11));
  439.             // update z-buffer
  440.             z_ptr[xi] = zi;   
  441.             } // end if
  443. // interpolate u,v
  444. ui+=du;
  445. vi+=dv;
  446. wi+=dw;
  447. zi+=dz;
  449. si+=ds;
  450. ti+=dt;
  452. } // end for xi
  454. // interpolate u,v,w,x along right and left edge
  455. xl+=dxdyl;
  456.         ul+=dudyl;
  457. vl+=dvdyl;
  458. wl+=dwdyl;
  459. zl+=dzdyl;
  461. sl+=dsdyl;
  462. tl+=dtdyl;
  464. xr+=dxdyr;
  465.       ur+=dudyr;
  466. vr+=dvdyr;
  467. wr+=dwdyr;
  468. zr+=dzdyr;
  470. sr+=dsdyr;
  471. tr+=dtdyr;
  473. // advance screen ptr
  474. screen_ptr+=mem_pitch;
  476.         // advance zbuffer ptr
  477.         z_ptr+=zpitch;
  479. // test for yi hitting second region, if so change interpolant
  480. if (yi==yrestart)
  481. {
  482.     // test interpolation side change flag
  484. if (irestart == INTERP_LHS)
  485. {
  486. // LHS
  487. dyl = (y2 - y1);
  489. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  490. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  491. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  492. dwdyl = ((tw2 - tw1) << FIXP16_SHIFT)/dyl;  
  493. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;  
  495. dsdyl = ((ts2 - ts1) << FIXP16_SHIFT)/dyl;   
  496. dtdyl = ((tt2 - tt1) << FIXP16_SHIFT)/dyl;  
  499. // set starting values
  500. xl = (x1  << FIXP16_SHIFT);
  501. ul = (tu1 << FIXP16_SHIFT);
  502. vl = (tv1 << FIXP16_SHIFT);
  503. wl = (tw1 << FIXP16_SHIFT);
  504. zl = (tz1 << FIXP16_SHIFT);
  506. sl = (ts1 << FIXP16_SHIFT);
  507. tl = (tt1 << FIXP16_SHIFT);
  509. // interpolate down on LHS to even up
  510. xl+=dxdyl;
  511. ul+=dudyl;
  512. vl+=dvdyl;
  513. wl+=dwdyl;
  514. zl+=dzdyl;
  516. sl+=dsdyl;
  517. tl+=dtdyl;
  519. } // end if
  520. else
  521. {
  522. // RHS
  523. dyr = (y1 - y2);
  525. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  526. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  527. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  528. dwdyr = ((tw1 - tw2) << FIXP16_SHIFT)/dyr;   
  529. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr;   
  531. dsdyr = ((ts1 - ts2) << FIXP16_SHIFT)/dyr;   
  532. dtdyr = ((tt1 - tt2) << FIXP16_SHIFT)/dyr;  
  534. // set starting values
  535. xr = (x2  << FIXP16_SHIFT);
  536. ur = (tu2 << FIXP16_SHIFT);
  537. vr = (tv2 << FIXP16_SHIFT);
  538. wr = (tw2 << FIXP16_SHIFT);
  539. zr = (tz2 << FIXP16_SHIFT);
  541. sr = (ts2 << FIXP16_SHIFT);
  542. tr = (tt2 << FIXP16_SHIFT);
  544. // interpolate down on RHS to even up
  545. xr+=dxdyr;
  546. ur+=dudyr;
  547. vr+=dvdyr;
  548. wr+=dwdyr;
  549. zr+=dzdyr;
  551. sr+=dsdyr;
  552. tr+=dtdyr;
  553. } // end else
  555. } // end if
  557. } // end for y
  559. } // end if
  560. else
  561. {
  562. // no x clipping
  563. // point screen ptr to starting line
  564. screen_ptr = dest_buffer + (ystart * mem_pitch);
  566.     // point zbuffer to starting line
  567.     z_ptr = zbuffer + (ystart * zpitch);
  569. for (yi = ystart; yi < yend; yi++)
  570. {
  571. // compute span endpoints
  572. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  573. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  575. // compute starting points for u,v,w interpolants
  576. ui = ul + FIXP16_ROUND_UP;
  577. vi = vl + FIXP16_ROUND_UP;
  578. wi = wl + FIXP16_ROUND_UP;
  579. zi = zl + FIXP16_ROUND_UP;
  581. si = sl + FIXP16_ROUND_UP;
  582. ti = tl + FIXP16_ROUND_UP;
  584. // compute u,v interpolants
  585. if ((dx = (xend - xstart))>0)
  586. {
  587. du = (ur - ul)/dx;
  588. dv = (vr - vl)/dx;
  589. dw = (wr - wl)/dx;
  590. dz = (zr - zl)/dx;
  592. ds = (sr - sl)/dx;
  593. dt = (tr - tl)/dx;
  595. } // end if
  596. else
  597. {
  598. du = (ur - ul);
  599. dv = (vr - vl);
  600. dw = (wr - wl);
  601. dz = (zr - zl);
  603. ds = (sr - sl);
  604. dt = (tr - tl);
  606. } // end else
  608. // draw span
  609. for (xi=xstart; xi < xend; xi++)
  610. {
  611. // write textel assume 5.6.5
  612.             // write thru z buffer always
  613.     // get textel first
  614.   textel = textmap[(si >> FIXP16_SHIFT) + ((ti >> FIXP16_SHIFT) << texture_shift2)];
  616.             if (textel)
  617.             {
  618.            
  619.             // extract rgb components
  620.             r_textel  = ((textel >> 11)       ); 
  621.             g_textel  = ((textel >> 5)  & 0x3f); 
  622.             b_textel =   (textel        & 0x1f);
  624.             // modulate textel with gouraud shading
  625.             r_textel*=ui; 
  626.             g_textel*=vi;
  627.             b_textel*=wi;
  629.             // finally write pixel, note that we did the math such that the results are r*32, g*64, b*32
  630.             // hence we need to divide the results by 32,64,32 respetively, BUT since we need to shift
  631.             // the results to fit into the destination 5.6.5 word, we can take advantage of the shifts
  632.             // and they all cancel out for the most part, but we will need logical anding, we will do
  633.             // it later when we optimize more...
  634.             screen_ptr[xi] = ((b_textel >> (FIXP16_SHIFT+8)) + 
  635.                              ((g_textel >> (FIXP16_SHIFT+8)) << 5) + 
  636.                              ((r_textel >> (FIXP16_SHIFT+8)) << 11));
  638.             // update z-buffer
  639.             z_ptr[xi] = zi;   
  640.             } // end if
  642. // interpolate u,v
  643. ui+=du;
  644. vi+=dv;
  645. wi+=dw;
  646. zi+=dz;
  648. si+=ds;
  649. ti+=dt;
  650. } // end for xi
  652. // interpolate u,v,w,x along right and left edge
  653. xl+=dxdyl;
  654. ul+=dudyl;
  655. vl+=dvdyl;
  656. wl+=dwdyl;
  657. zl+=dzdyl;
  659. sl+=dsdyl;
  660. tl+=dtdyl;
  662. xr+=dxdyr;
  663. ur+=dudyr;
  664. vr+=dvdyr;
  665. wr+=dwdyr;
  666. zr+=dzdyr;
  668. sr+=dsdyr;
  669. tr+=dtdyr;
  671. // advance screen ptr
  672. screen_ptr+=mem_pitch;
  674.         // advance zbuffer ptr
  675.         z_ptr+=zpitch;
  677. // test for yi hitting second region, if so change interpolant
  678. if (yi==yrestart)
  679. {
  680. // test interpolation side change flag
  682. if (irestart == INTERP_LHS)
  683. {
  684. // LHS
  685. dyl = (y2 - y1);
  687. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  688. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  689. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  690. dwdyl = ((tw2 - tw1) << FIXP16_SHIFT)/dyl;   
  691. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;  
  693. dsdyl = ((ts2 - ts1) << FIXP16_SHIFT)/dyl;   
  694. dtdyl = ((tt2 - tt1) << FIXP16_SHIFT)/dyl;   
  696. // set starting values
  697. xl = (x1  << FIXP16_SHIFT);
  698. ul = (tu1 << FIXP16_SHIFT);
  699. vl = (tv1 << FIXP16_SHIFT);
  700. wl = (tw1 << FIXP16_SHIFT);
  701. zl = (tz1 << FIXP16_SHIFT);
  703. sl = (ts1 << FIXP16_SHIFT);
  704. tl = (tt1 << FIXP16_SHIFT);
  706. // interpolate down on LHS to even up
  707. xl+=dxdyl;
  708. ul+=dudyl;
  709. vl+=dvdyl;
  710. wl+=dwdyl;
  711. zl+=dzdyl;
  713. sl+=dsdyl;
  714. tl+=dtdyl;
  716. } // end if
  717. else
  718. {
  719. // RHS
  720. dyr = (y1 - y2);
  722. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  723. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  724. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  725. dwdyr = ((tw1 - tw2) << FIXP16_SHIFT)/dyr;   
  726. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr;   
  728. dsdyr = ((ts1 - ts2) << FIXP16_SHIFT)/dyr;   
  729. dtdyr = ((tt1 - tt2) << FIXP16_SHIFT)/dyr;   
  731. // set starting values
  732. xr = (x2  << FIXP16_SHIFT);
  733. ur = (tu2 << FIXP16_SHIFT);
  734. vr = (tv2 << FIXP16_SHIFT);
  735. wr = (tw2 << FIXP16_SHIFT);
  736. zr = (tz2 << FIXP16_SHIFT);
  738. sr = (ts2 << FIXP16_SHIFT);
  739. tr = (tt2 << FIXP16_SHIFT);
  741. // interpolate down on RHS to even up
  742. xr+=dxdyr;
  743. ur+=dudyr;
  744. vr+=dvdyr;
  745. wr+=dwdyr;
  746. zr+=dzdyr;
  748. sr+=dsdyr;
  749. tr+=dtdyr;
  751. } // end else
  753. } // end if
  755. } // end for y
  757.    } // end else
  759. } // end if
  761. } // end Draw_Textured_TriangleGSWTZB2_16
  763. ///////////////////////////////////////////////////////////////////////////////////////////////////
  765. void Draw_Textured_Triangle_Alpha16_2(POLYF4DV2_PTR face,   // ptr to face
  766.                                 UCHAR *_dest_buffer,      // pointer to video buffer
  767.                                 int mem_pitch, int alpha) // bytes per line, 320, 640 etc.
  768. {
  769. // this function draws a textured triangle in 16-bit mode
  771. int v0=0,
  772.     v1=1,
  773. v2=2,
  774. temp=0,
  775. tri_type = TRI_TYPE_NONE,
  776. irestart = INTERP_LHS;
  778. int dx,dy,dyl,dyr,      // general deltas
  779.     u,v,
  780.     du,dv,
  781.     xi,yi,              // the current interpolated x,y
  782. ui,vi,              // the current interpolated u,v
  783. index_x,index_y,    // looping vars
  784. x,y,                // hold general x,y
  785. xstart,
  786. xend,
  787. ystart,
  788. yrestart,
  789. yend,
  790. xl,                 
  791. dxdyl,              
  792. xr,
  793. dxdyr,             
  794. dudyl,    
  795. ul,
  796. dvdyl,   
  797. vl,
  798. dudyr,
  799. ur,
  800. dvdyr,
  801. vr;
  803. int x0,y0,tu0,tv0,    // cached vertices
  804. x1,y1,tu1,tv1,
  805. x2,y2,tu2,tv2;
  807. USHORT *screen_ptr  = NULL,
  808.    *screen_line = NULL,
  809.    *textmap     = NULL,
  810.        *dest_buffer = (USHORT *)_dest_buffer,
  811.        textel;
  813. #ifdef DEBUG_ON
  814. // track rendering stats
  815.     debug_polys_rendered_per_frame++;
  816. #endif
  818. // extract texture map
  819. textmap = (USHORT *)face->texture->buffer;
  821. // extract base 2 of texture width
  822. int texture_shift2 = logbase2ofx[face->texture->width];
  824. // adjust memory pitch to words, divide by 2
  825. mem_pitch >>=1;
  827. // apply fill convention to coordinates
  828. face->tvlist[0].x = (int)(face->tvlist[0].x+0.5);
  829. face->tvlist[0].y = (int)(face->tvlist[0].y+0.5);
  831. face->tvlist[1].x = (int)(face->tvlist[1].x+0.5);
  832. face->tvlist[1].y = (int)(face->tvlist[1].y+0.5);
  834. face->tvlist[2].x = (int)(face->tvlist[2].x+0.5);
  835. face->tvlist[2].y = (int)(face->tvlist[2].y+0.5);
  837. // first trivial clipping rejection tests 
  838. if (((face->tvlist[0].y < min_clip_y)  && 
  839.  (face->tvlist[1].y < min_clip_y)  &&
  840.  (face->tvlist[2].y < min_clip_y)) ||
  842. ((face->tvlist[0].y > max_clip_y)  && 
  843.  (face->tvlist[1].y > max_clip_y)  &&
  844.  (face->tvlist[2].y > max_clip_y)) ||
  846. ((face->tvlist[0].x < min_clip_x)  && 
  847.  (face->tvlist[1].x < min_clip_x)  &&
  848.  (face->tvlist[2].x < min_clip_x)) ||
  850. ((face->tvlist[0].x > max_clip_x)  && 
  851.  (face->tvlist[1].x > max_clip_x)  &&
  852.  (face->tvlist[2].x > max_clip_x)))
  853.    return;
  855. // sort vertices
  856. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  857. {SWAP(v0,v1,temp);} 
  859. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  860. {SWAP(v0,v2,temp);}
  862. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  863. {SWAP(v1,v2,temp);}
  865. // now test for trivial flat sided cases
  866. if (FCMP(face->tvlist[v0].y, face->tvlist[v1].y) )
  867. { 
  868. // set triangle type
  869. tri_type = TRI_TYPE_FLAT_TOP;
  871. // sort vertices left to right
  872. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  873. {SWAP(v0,v1,temp);}
  875. } // end if
  876. else
  877. // now test for trivial flat sided cases
  878. if (FCMP(face->tvlist[v1].y, face->tvlist[v2].y) )
  879. { 
  880. // set triangle type
  881. tri_type = TRI_TYPE_FLAT_BOTTOM;
  883. // sort vertices left to right
  884. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  885. {SWAP(v1,v2,temp);}
  887. } // end if
  888. else
  889. {
  890. // must be a general triangle
  891. tri_type = TRI_TYPE_GENERAL;
  893. } // end else
  895. // extract vertices for processing, now that we have order
  896. x0  = (int)(face->tvlist[v0].x+0.0);
  897. y0  = (int)(face->tvlist[v0].y+0.0);
  898. tu0 = (int)(face->tvlist[v0].u0);
  899. tv0 = (int)(face->tvlist[v0].v0);
  901. x1  = (int)(face->tvlist[v1].x+0.0);
  902. y1  = (int)(face->tvlist[v1].y+0.0);
  903. tu1 = (int)(face->tvlist[v1].u0);
  904. tv1 = (int)(face->tvlist[v1].v0);
  906. x2  = (int)(face->tvlist[v2].x+0.0);
  907. y2  = (int)(face->tvlist[v2].y+0.0);
  908. tu2 = (int)(face->tvlist[v2].u0);
  909. tv2 = (int)(face->tvlist[v2].v0);
  912. // degenerate triangle
  913. if ( ((x0 == x1) && (x1 == x2)) || ((y0 ==  y1) && (y1 == y2)))
  914.    return;
  916. // assign both source1 and source2 alpha tables based on polygon alpha level
  917. USHORT *alpha_table_src1 = (USHORT *)&rgb_alpha_table[(NUM_ALPHA_LEVELS-1) - alpha][0];
  918. USHORT *alpha_table_src2 = (USHORT *)&rgb_alpha_table[alpha][0];
  920. // set interpolation restart value
  921. yrestart = y1;
  923. // what kind of triangle
  924. if (tri_type & TRI_TYPE_FLAT_MASK)
  925. {
  927. if (tri_type == TRI_TYPE_FLAT_TOP)
  928. {
  929. // compute all deltas
  930. dy = (y2 - y0);
  932. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  933. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  934. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  936. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  937. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  938. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  940. // test for y clipping
  941. if (y0 < min_clip_y)
  942. {
  943. // compute overclip
  944. dy = (min_clip_y - y0);
  946. // computer new LHS starting values
  947. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  948. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  949. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  951. // compute new RHS starting values
  952. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  953. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  954. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  956. // compute new starting y
  957. ystart = min_clip_y;
  959. } // end if
  960. else
  961. {
  962. // no clipping
  964. // set starting values
  965. xl = (x0 << FIXP16_SHIFT);
  966. xr = (x1 << FIXP16_SHIFT);
  968. ul = (tu0 << FIXP16_SHIFT);
  969. vl = (tv0 << FIXP16_SHIFT);
  971. ur = (tu1 << FIXP16_SHIFT);
  972. vr = (tv1 << FIXP16_SHIFT);
  974. // set starting y
  975. ystart = y0;
  977. } // end else
  979. } // end if flat top
  980. else
  981. {
  982. // must be flat bottom
  984. // compute all deltas
  985. dy = (y1 - y0);
  987. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  988. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  989. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  991. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  992. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  993. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  995. // test for y clipping
  996. if (y0 < min_clip_y)
  997. {
  998. // compute overclip
  999. dy = (min_clip_y - y0);
  1001. // computer new LHS starting values
  1002. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1003. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1004. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1006. // compute new RHS starting values
  1007. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  1008. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  1009. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  1011. // compute new starting y
  1012. ystart = min_clip_y;
  1014. } // end if
  1015. else
  1016. {
  1017. // no clipping
  1019. // set starting values
  1020. xl = (x0 << FIXP16_SHIFT);
  1021. xr = (x0 << FIXP16_SHIFT);
  1023. ul = (tu0 << FIXP16_SHIFT);
  1024. vl = (tv0 << FIXP16_SHIFT);
  1026. ur = (tu0 << FIXP16_SHIFT);
  1027. vr = (tv0 << FIXP16_SHIFT);
  1029. // set starting y
  1030. ystart = y0;
  1032. } // end else
  1034. } // end else flat bottom
  1036. // test for bottom clip, always
  1037. if ((yend = y2) > max_clip_y)
  1038. yend = max_clip_y;
  1040.     // test for horizontal clipping
  1041. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  1042. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  1043. (x2 < min_clip_x) || (x2 > max_clip_x))
  1044. {
  1045.     // clip version
  1047. // point screen ptr to starting line
  1048. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1050. for (yi = ystart; yi < yend; yi++)
  1051. {
  1052. // compute span endpoints
  1053. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1054. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1056. // compute starting points for u,v interpolants
  1057. ui = ul + FIXP16_ROUND_UP;
  1058. vi = vl + FIXP16_ROUND_UP;
  1060. // compute u,v interpolants
  1061. if ((dx = (xend - xstart))>0)
  1062. {
  1063. du = (ur - ul)/dx;
  1064. dv = (vr - vl)/dx;
  1065. } // end if
  1066. else
  1067. {
  1068. du = (ur - ul);
  1069. dv = (vr - vl);
  1070. } // end else
  1072. ///////////////////////////////////////////////////////////////////////
  1074. // test for x clipping, LHS
  1075. if (xstart < min_clip_x)
  1076. {
  1077. // compute x overlap
  1078. dx = min_clip_x - xstart;
  1080. // slide interpolants over
  1081. ui+=dx*du;
  1082. vi+=dx*dv;
  1084. // reset vars
  1085. xstart = min_clip_x;
  1087. } // end if
  1089. // test for x clipping RHS
  1090. if (xend > max_clip_x)
  1091. xend = max_clip_x;
  1093. ///////////////////////////////////////////////////////////////////////
  1095. // draw span
  1096. for (xi=xstart; xi < xend; xi++)
  1097. {
  1098. // write textel
  1099.             // check for transparency
  1100.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1102.             if (textel)
  1103.                {
  1104.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + alpha_table_src2[textel];
  1105.                } // end if
  1108. // interpolate u,v
  1109. ui+=du;
  1110. vi+=dv;
  1111. } // end for xi
  1113. // interpolate u,v,x along right and left edge
  1114. xl+=dxdyl;
  1115. ul+=dudyl;
  1116. vl+=dvdyl;
  1118. xr+=dxdyr;
  1119. ur+=dudyr;
  1120. vr+=dvdyr;
  1121.  
  1122. // advance screen ptr
  1123. screen_ptr+=mem_pitch;
  1125. } // end for y
  1127. } // end if clip
  1128. else
  1129. {
  1130. // non-clip version
  1132. // point screen ptr to starting line
  1133. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1135. for (yi = ystart; yi < yend; yi++)
  1136. {
  1137. // compute span endpoints
  1138. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1139. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1141. // compute starting points for u,v interpolants
  1142. ui = ul + FIXP16_ROUND_UP;
  1143. vi = vl + FIXP16_ROUND_UP;
  1145. // compute u,v interpolants
  1146. if ((dx = (xend - xstart))>0)
  1147. {
  1148. du = (ur - ul)/dx;
  1149. dv = (vr - vl)/dx;
  1150. } // end if
  1151. else
  1152. {
  1153. du = (ur - ul);
  1154. dv = (vr - vl);
  1155. } // end else
  1157. // draw span
  1158. for (xi=xstart; xi < xend; xi++)
  1159. {
  1160. // write textel
  1161.             // check for transparency
  1162.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1164.             if (textel)
  1165.                {
  1166.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + alpha_table_src2[textel];
  1167.                } // end if
  1169. // interpolate u,v
  1170. ui+=du;
  1171. vi+=dv;
  1172. } // end for xi
  1174. // interpolate u,v,x along right and left edge
  1175. xl+=dxdyl;
  1176. ul+=dudyl;
  1177. vl+=dvdyl;
  1179. xr+=dxdyr;
  1180. ur+=dudyr;
  1181. vr+=dvdyr;
  1183. // advance screen ptr
  1184. screen_ptr+=mem_pitch;
  1186. } // end for y
  1188. } // end if non-clipped
  1190. } // end if
  1191. else
  1192. if (tri_type==TRI_TYPE_GENERAL)
  1193. {
  1195. // first test for bottom clip, always
  1196. if ((yend = y2) > max_clip_y)
  1197. yend = max_clip_y;
  1199. // pre-test y clipping status
  1200. if (y1 < min_clip_y)
  1201. {
  1202. // compute all deltas
  1203. // LHS
  1204. dyl = (y2 - y1);
  1206. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  1207. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1208. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  1210. // RHS
  1211. dyr = (y2 - y0);
  1213. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  1214. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1215. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1217. // compute overclip
  1218. dyr = (min_clip_y - y0);
  1219. dyl = (min_clip_y - y1);
  1221. // computer new LHS starting values
  1222. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  1223. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  1224. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  1226. // compute new RHS starting values
  1227. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  1228. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  1229. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  1231. // compute new starting y
  1232. ystart = min_clip_y;
  1234. // test if we need swap to keep rendering left to right
  1235. if (dxdyr > dxdyl)
  1236. {
  1237. SWAP(dxdyl,dxdyr,temp);
  1238. SWAP(dudyl,dudyr,temp);
  1239. SWAP(dvdyl,dvdyr,temp);
  1240. SWAP(xl,xr,temp);
  1241. SWAP(ul,ur,temp);
  1242. SWAP(vl,vr,temp);
  1243. SWAP(x1,x2,temp);
  1244. SWAP(y1,y2,temp);
  1245. SWAP(tu1,tu2,temp);
  1246. SWAP(tv1,tv2,temp);
  1248. // set interpolation restart
  1249. irestart = INTERP_RHS;
  1251. } // end if
  1253. } // end if
  1254. else
  1255. if (y0 < min_clip_y)
  1256. {
  1257. // compute all deltas
  1258. // LHS
  1259. dyl = (y1 - y0);
  1261. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  1262. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  1263. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  1265. // RHS
  1266. dyr = (y2 - y0);
  1268. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  1269. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1270. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1272. // compute overclip
  1273. dy = (min_clip_y - y0);
  1275. // computer new LHS starting values
  1276. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1277. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1278. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1280. // compute new RHS starting values
  1281. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  1282. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  1283. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  1285. // compute new starting y
  1286. ystart = min_clip_y;
  1288. // test if we need swap to keep rendering left to right
  1289. if (dxdyr < dxdyl)
  1290. {
  1291. SWAP(dxdyl,dxdyr,temp);
  1292. SWAP(dudyl,dudyr,temp);
  1293. SWAP(dvdyl,dvdyr,temp);
  1294. SWAP(xl,xr,temp);
  1295. SWAP(ul,ur,temp);
  1296. SWAP(vl,vr,temp);
  1297. SWAP(x1,x2,temp);
  1298. SWAP(y1,y2,temp);
  1299. SWAP(tu1,tu2,temp);
  1300. SWAP(tv1,tv2,temp);
  1302. // set interpolation restart
  1303. irestart = INTERP_RHS;
  1305. } // end if
  1307. } // end if
  1308. else
  1309. {
  1310. // no initial y clipping
  1312. // compute all deltas
  1313. // LHS
  1314. dyl = (y1 - y0);
  1316. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  1317. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  1318. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  1320. // RHS
  1321. dyr = (y2 - y0);
  1323. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  1324. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1325. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1327. // no clipping y
  1329. // set starting values
  1330. xl = (x0 << FIXP16_SHIFT);
  1331. xr = (x0 << FIXP16_SHIFT);
  1333. ul = (tu0 << FIXP16_SHIFT);
  1334. vl = (tv0 << FIXP16_SHIFT);
  1336. ur = (tu0 << FIXP16_SHIFT);
  1337. vr = (tv0 << FIXP16_SHIFT);
  1339. // set starting y
  1340. ystart = y0;
  1342. // test if we need swap to keep rendering left to right
  1343. if (dxdyr < dxdyl)
  1344. {
  1345. SWAP(dxdyl,dxdyr,temp);
  1346. SWAP(dudyl,dudyr,temp);
  1347. SWAP(dvdyl,dvdyr,temp);
  1348. SWAP(xl,xr,temp);
  1349. SWAP(ul,ur,temp);
  1350. SWAP(vl,vr,temp);
  1351. SWAP(x1,x2,temp);
  1352. SWAP(y1,y2,temp);
  1353. SWAP(tu1,tu2,temp);
  1354. SWAP(tv1,tv2,temp);
  1356. // set interpolation restart
  1357. irestart = INTERP_RHS;
  1359. } // end if
  1361. } // end else
  1364.     // test for horizontal clipping
  1365. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  1366. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  1367. (x2 < min_clip_x) || (x2 > max_clip_x))
  1368. {
  1369.     // clip version
  1370. // x clipping
  1372. // point screen ptr to starting line
  1373. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1375. for (yi = ystart; yi < yend; yi++)
  1376. {
  1377. // compute span endpoints
  1378. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1379. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1381. // compute starting points for u,v interpolants
  1382. ui = ul + FIXP16_ROUND_UP;
  1383. vi = vl + FIXP16_ROUND_UP;
  1385. // compute u,v interpolants
  1386. if ((dx = (xend - xstart))>0)
  1387. {
  1388. du = (ur - ul)/dx;
  1389. dv = (vr - vl)/dx;
  1390. } // end if
  1391. else
  1392. {
  1393. du = (ur - ul);
  1394. dv = (vr - vl);
  1395. } // end else
  1397. ///////////////////////////////////////////////////////////////////////
  1399. // test for x clipping, LHS
  1400. if (xstart < min_clip_x)
  1401. {
  1402. // compute x overlap
  1403. dx = min_clip_x - xstart;
  1405. // slide interpolants over
  1406. ui+=dx*du;
  1407. vi+=dx*dv;
  1409. // set x to left clip edge
  1410. xstart = min_clip_x;
  1412. } // end if
  1414. // test for x clipping RHS
  1415. if (xend > max_clip_x)
  1416. xend = max_clip_x;
  1418. ///////////////////////////////////////////////////////////////////////
  1420. // draw span
  1421. for (xi=xstart; xi < xend; xi++)
  1422. {
  1423. // write textel
  1424.             // check for transparency
  1425.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1427.             if (textel)
  1428.                {
  1429.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + alpha_table_src2[textel];
  1430.                } // end if
  1433. // interpolate u,v
  1434. ui+=du;
  1435. vi+=dv;
  1436. } // end for xi
  1438. // interpolate u,v,x along right and left edge
  1439. xl+=dxdyl;
  1440. ul+=dudyl;
  1441. vl+=dvdyl;
  1443. xr+=dxdyr;
  1444. ur+=dudyr;
  1445. vr+=dvdyr;
  1447. // advance screen ptr
  1448. screen_ptr+=mem_pitch;
  1450. // test for yi hitting second region, if so change interpolant
  1451. if (yi==yrestart)
  1452. {
  1454.     // test interpolation side change flag
  1456. if (irestart == INTERP_LHS)
  1457. {
  1458. // LHS
  1459. dyl = (y2 - y1);
  1461. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  1462. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1463. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  1465. // set starting values
  1466. xl = (x1  << FIXP16_SHIFT);
  1467. ul = (tu1 << FIXP16_SHIFT);
  1468. vl = (tv1 << FIXP16_SHIFT);
  1470. // interpolate down on LHS to even up
  1471. xl+=dxdyl;
  1472. ul+=dudyl;
  1473. vl+=dvdyl;
  1474. } // end if
  1475. else
  1476. {
  1477. // RHS
  1478. dyr = (y1 - y2);
  1480. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  1481. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  1482. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  1484. // set starting values
  1485. xr = (x2  << FIXP16_SHIFT);
  1486. ur = (tu2 << FIXP16_SHIFT);
  1487. vr = (tv2 << FIXP16_SHIFT);
  1489. // interpolate down on RHS to even up
  1490. xr+=dxdyr;
  1491. ur+=dudyr;
  1492. vr+=dvdyr;
  1494. } // end else
  1497. } // end if
  1499. } // end for y
  1501. } // end if
  1502. else
  1503. {
  1504. // no x clipping
  1505. // point screen ptr to starting line
  1506. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1508. for (yi = ystart; yi < yend; yi++)
  1509. {
  1510. // compute span endpoints
  1511. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1512. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1514. // compute starting points for u,v interpolants
  1515. ui = ul + FIXP16_ROUND_UP;
  1516. vi = vl + FIXP16_ROUND_UP;
  1518. // compute u,v interpolants
  1519. if ((dx = (xend - xstart))>0)
  1521. {
  1522. du = (ur - ul)/dx;
  1523. dv = (vr - vl)/dx;
  1524. } // end if
  1525. else
  1526. {
  1527. du = (ur - ul);
  1528. dv = (vr - vl);
  1529. } // end else
  1531. // draw span
  1532. for (xi=xstart; xi < xend; xi++)
  1533. {
  1534. // write textel
  1535.             // check for transparency
  1536.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1538.             if (textel)
  1539.                {
  1540.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + alpha_table_src2[textel];
  1541.                } // end if
  1544. // interpolate u,v
  1545. ui+=du;
  1546. vi+=dv;
  1547. } // end for xi
  1549. // interpolate u,v,x along right and left edge
  1550. xl+=dxdyl;
  1551. ul+=dudyl;
  1552. vl+=dvdyl;
  1554. xr+=dxdyr;
  1555. ur+=dudyr;
  1556. vr+=dvdyr;
  1558. // advance screen ptr
  1559. screen_ptr+=mem_pitch;
  1561. // test for yi hitting second region, if so change interpolant
  1562. if (yi==yrestart)
  1563. {
  1564. // test interpolation side change flag
  1566. if (irestart == INTERP_LHS)
  1567. {
  1568. // LHS
  1569. dyl = (y2 - y1);
  1571. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  1572. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1573. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  1575. // set starting values
  1576. xl = (x1  << FIXP16_SHIFT);
  1577. ul = (tu1 << FIXP16_SHIFT);
  1578. vl = (tv1 << FIXP16_SHIFT);
  1580. // interpolate down on LHS to even up
  1581. xl+=dxdyl;
  1582. ul+=dudyl;
  1583. vl+=dvdyl;
  1584. } // end if
  1585. else
  1586. {
  1587. // RHS
  1588. dyr = (y1 - y2);
  1590. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  1591. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  1592. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  1594. // set starting values
  1595. xr = (x2  << FIXP16_SHIFT);
  1596. ur = (tu2 << FIXP16_SHIFT);
  1597. vr = (tv2 << FIXP16_SHIFT);
  1599. // interpolate down on RHS to even up
  1600. xr+=dxdyr;
  1601. ur+=dudyr;
  1602. vr+=dvdyr;
  1604. } // end else
  1606. } // end if
  1608. } // end for y
  1610.    } // end else
  1612. } // end if
  1614. } // end Draw_Textured_Triangle_Alpha16_2
  1616. ///////////////////////////////////////////////////////////////////////////////
  1618. void Draw_Textured_TriangleZB_Alpha16_2(POLYF4DV2_PTR face,  // ptr to face
  1619.                               UCHAR *_dest_buffer,  // pointer to video buffer
  1620.                               int mem_pitch,        // bytes per line, 320, 640 etc.
  1621.                               UCHAR *_zbuffer,       // pointer to z-buffer
  1622.                               int zpitch,          // bytes per line of zbuffer
  1623.                               int alpha)
  1624. {
  1625. // this function draws a textured triangle in 16-bit mode
  1627. int v0=0,
  1628.     v1=1,
  1629. v2=2,
  1630. temp=0,
  1631. tri_type = TRI_TYPE_NONE,
  1632. irestart = INTERP_LHS;
  1634. int dx,dy,dyl,dyr,      // general deltas
  1635.     u,v,z,
  1636.     du,dv,dz,
  1637.     xi,yi,              // the current interpolated x,y
  1638. ui,vi,zi,           // the current interpolated u,v,z
  1639. index_x,index_y,    // looping vars
  1640. x,y,                // hold general x,y
  1641. xstart,
  1642. xend,
  1643. ystart,
  1644. yrestart,
  1645. yend,
  1646. xl,                 
  1647. dxdyl,              
  1648. xr,
  1649. dxdyr,             
  1650. dudyl,    
  1651. ul,
  1652. dvdyl,   
  1653. vl,
  1654. dzdyl,   
  1655. zl,
  1656. dudyr,
  1657. ur,
  1658. dvdyr,
  1659. vr,
  1660. dzdyr,
  1661. zr;
  1663. int x0,y0,tu0,tv0,tz0,    // cached vertices
  1664. x1,y1,tu1,tv1,tz1,
  1665. x2,y2,tu2,tv2,tz2;
  1667. USHORT *screen_ptr  = NULL,
  1668.    *screen_line = NULL,
  1669.    *textmap     = NULL,
  1670.        *dest_buffer = (USHORT *)_dest_buffer,
  1671.         textel; 
  1673. UINT  *z_ptr = NULL,
  1674.       *zbuffer = (UINT *)_zbuffer;
  1676. #ifdef DEBUG_ON
  1677. // track rendering stats
  1678.     debug_polys_rendered_per_frame++;
  1679. #endif
  1681. // extract texture map
  1682. textmap = (USHORT *)face->texture->buffer;
  1684. // extract base 2 of texture width
  1685. int texture_shift2 = logbase2ofx[face->texture->width];
  1687. // adjust memory pitch to words, divide by 2
  1688. mem_pitch >>=1;
  1690. // adjust zbuffer pitch for 32 bit alignment
  1691. zpitch >>= 2;
  1693. // apply fill convention to coordinates
  1694. face->tvlist[0].x = (int)(face->tvlist[0].x+0.5);
  1695. face->tvlist[0].y = (int)(face->tvlist[0].y+0.5);
  1697. face->tvlist[1].x = (int)(face->tvlist[1].x+0.5);
  1698. face->tvlist[1].y = (int)(face->tvlist[1].y+0.5);
  1700. face->tvlist[2].x = (int)(face->tvlist[2].x+0.5);
  1701. face->tvlist[2].y = (int)(face->tvlist[2].y+0.5);
  1703. // first trivial clipping rejection tests 
  1704. if (((face->tvlist[0].y < min_clip_y)  && 
  1705.  (face->tvlist[1].y < min_clip_y)  &&
  1706.  (face->tvlist[2].y < min_clip_y)) ||
  1708. ((face->tvlist[0].y > max_clip_y)  && 
  1709.  (face->tvlist[1].y > max_clip_y)  &&
  1710.  (face->tvlist[2].y > max_clip_y)) ||
  1712. ((face->tvlist[0].x < min_clip_x)  && 
  1713.  (face->tvlist[1].x < min_clip_x)  &&
  1714.  (face->tvlist[2].x < min_clip_x)) ||
  1716. ((face->tvlist[0].x > max_clip_x)  && 
  1717.  (face->tvlist[1].x > max_clip_x)  &&
  1718.  (face->tvlist[2].x > max_clip_x)))
  1719.    return;
  1721. // sort vertices
  1722. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  1723. {SWAP(v0,v1,temp);} 
  1725. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  1726. {SWAP(v0,v2,temp);}
  1728. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  1729. {SWAP(v1,v2,temp);}
  1731. // now test for trivial flat sided cases
  1732. if (FCMP(face->tvlist[v0].y, face->tvlist[v1].y) )
  1733. { 
  1734. // set triangle type
  1735. tri_type = TRI_TYPE_FLAT_TOP;
  1737. // sort vertices left to right
  1738. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  1739. {SWAP(v0,v1,temp);}
  1741. } // end if
  1742. else
  1743. // now test for trivial flat sided cases
  1744. if (FCMP(face->tvlist[v1].y ,face->tvlist[v2].y))
  1745. { 
  1746. // set triangle type
  1747. tri_type = TRI_TYPE_FLAT_BOTTOM;
  1749. // sort vertices left to right
  1750. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  1751. {SWAP(v1,v2,temp);}
  1753. } // end if
  1754. else
  1755. {
  1756. // must be a general triangle
  1757. tri_type = TRI_TYPE_GENERAL;
  1759. } // end else
  1761. // extract vertices for processing, now that we have order
  1762. x0  = (int)(face->tvlist[v0].x+0.0);
  1763. y0  = (int)(face->tvlist[v0].y+0.0);
  1764. tu0 = (int)(face->tvlist[v0].u0);
  1765. tv0 = (int)(face->tvlist[v0].v0);
  1766. tz0 = (int)(face->tvlist[v0].z+0.5);
  1768. x1  = (int)(face->tvlist[v1].x+0.0);
  1769. y1  = (int)(face->tvlist[v1].y+0.0);
  1770. tu1 = (int)(face->tvlist[v1].u0);
  1771. tv1 = (int)(face->tvlist[v1].v0);
  1772. tz1 = (int)(face->tvlist[v1].z+0.5);
  1774. x2  = (int)(face->tvlist[v2].x+0.0);
  1775. y2  = (int)(face->tvlist[v2].y+0.0);
  1776. tu2 = (int)(face->tvlist[v2].u0);
  1777. tv2 = (int)(face->tvlist[v2].v0);
  1778. tz2 = (int)(face->tvlist[v2].z+0.5);
  1781. // degenerate triangle
  1782. if ( ((x0 == x1) && (x1 == x2)) || ((y0 ==  y1) && (y1 == y2)))
  1783.    return;
  1785. // assign both source1 and source2 alpha tables based on polygon alpha level
  1786. USHORT *alpha_table_src1 = (USHORT *)&rgb_alpha_table[(NUM_ALPHA_LEVELS-1) - alpha][0];
  1787. USHORT *alpha_table_src2 = (USHORT *)&rgb_alpha_table[alpha][0];
  1789. // set interpolation restart value
  1790. yrestart = y1;
  1792. // what kind of triangle
  1793. if (tri_type & TRI_TYPE_FLAT_MASK)
  1794. {
  1796. if (tri_type == TRI_TYPE_FLAT_TOP)
  1797. {
  1798. // compute all deltas
  1799. dy = (y2 - y0);
  1801. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  1802. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  1803. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  1804. dzdyl = ((tz2 - tz0) << FIXP16_SHIFT)/dy;    
  1806. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  1807. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  1808. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  1809. dzdyr = ((tz2 - tz1) << FIXP16_SHIFT)/dy;  
  1811. // test for y clipping
  1812. if (y0 < min_clip_y)
  1813. {
  1814. // compute overclip
  1815. dy = (min_clip_y - y0);
  1817. // computer new LHS starting values
  1818. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1819. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1820. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1821. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  1823. // compute new RHS starting values
  1824. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  1825. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  1826. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  1827. zr = dzdyr*dy + (tz1 << FIXP16_SHIFT);
  1829. // compute new starting y
  1830. ystart = min_clip_y;
  1832. } // end if
  1833. else
  1834. {
  1835. // no clipping
  1837. // set starting values
  1838. xl = (x0 << FIXP16_SHIFT);
  1839. xr = (x1 << FIXP16_SHIFT);
  1841. ul = (tu0 << FIXP16_SHIFT);
  1842. vl = (tv0 << FIXP16_SHIFT);
  1843. zl = (tz0 << FIXP16_SHIFT);
  1845. ur = (tu1 << FIXP16_SHIFT);
  1846. vr = (tv1 << FIXP16_SHIFT);
  1847. zr = (tz1 << FIXP16_SHIFT);
  1849. // set starting y
  1850. ystart = y0;
  1852. } // end else
  1854. } // end if flat top
  1855. else
  1856. {
  1857. // must be flat bottom
  1859. // compute all deltas
  1860. dy = (y1 - y0);
  1862. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  1863. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  1864. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  1865. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dy;   
  1867. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  1868. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  1869. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  1870. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dy;   
  1872. // test for y clipping
  1873. if (y0 < min_clip_y)
  1874. {
  1875. // compute overclip
  1876. dy = (min_clip_y - y0);
  1878. // computer new LHS starting values
  1879. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1880. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1881. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1882. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  1884. // compute new RHS starting values
  1885. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  1886. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  1887. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  1888. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  1890. // compute new starting y
  1891. ystart = min_clip_y;
  1893. } // end if
  1894. else
  1895. {
  1896. // no clipping
  1898. // set starting values
  1899. xl = (x0 << FIXP16_SHIFT);
  1900. xr = (x0 << FIXP16_SHIFT);
  1902. ul = (tu0 << FIXP16_SHIFT);
  1903. vl = (tv0 << FIXP16_SHIFT);
  1904. zl = (tz0 << FIXP16_SHIFT);
  1906. ur = (tu0 << FIXP16_SHIFT);
  1907. vr = (tv0 << FIXP16_SHIFT);
  1908. zr = (tz0 << FIXP16_SHIFT);
  1910. // set starting y
  1911. ystart = y0;
  1913. } // end else
  1915. } // end else flat bottom
  1917. // test for bottom clip, always
  1918. if ((yend = y2) > max_clip_y)
  1919. yend = max_clip_y;
  1921.     // test for horizontal clipping
  1922. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  1923. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  1924. (x2 < min_clip_x) || (x2 > max_clip_x))
  1925. {
  1926.     // clip version
  1928. // point screen ptr to starting line
  1929. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1931.     // point zbuffer to starting line
  1932.     z_ptr = zbuffer + (ystart * zpitch);
  1934. for (yi = ystart; yi < yend; yi++)
  1935. {
  1936. // compute span endpoints
  1937. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1938. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1940. // compute starting points for u,v interpolants
  1941. ui = ul + FIXP16_ROUND_UP;
  1942. vi = vl + FIXP16_ROUND_UP;
  1943. zi = zl + FIXP16_ROUND_UP;
  1945. // compute u,v interpolants
  1946. if ((dx = (xend - xstart))>0)
  1947. {
  1948. du = (ur - ul)/dx;
  1949. dv = (vr - vl)/dx;
  1950. dz = (zr - zl)/dx;
  1951. } // end if
  1952. else
  1953. {
  1954. du = (ur - ul);
  1955. dv = (vr - vl);
  1956. dz = (zr - zl);
  1957. } // end else
  1959. ///////////////////////////////////////////////////////////////////////
  1961. // test for x clipping, LHS
  1962. if (xstart < min_clip_x)
  1963. {
  1964. // compute x overlap
  1965. dx = min_clip_x - xstart;
  1967. // slide interpolants over
  1968. ui+=dx*du;
  1969. vi+=dx*dv;
  1970. zi+=dx*dz;
  1972. // reset vars
  1973. xstart = min_clip_x;
  1975. } // end if
  1977. // test for x clipping RHS
  1978. if (xend > max_clip_x)
  1979. xend = max_clip_x;
  1981. ///////////////////////////////////////////////////////////////////////
  1983. // draw span
  1984. for (xi=xstart; xi < xend; xi++)
  1985. {
  1987.             // get textel
  1988.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1990.             if (textel)
  1991.             {
  1992.             // test if z of current pixel is nearer than current z buffer value
  1993.             if (zi < z_ptr[xi])
  1994.                {
  1995.       // write textel
  1996.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  1997.                              alpha_table_src2[textel];
  2000.                // update z-buffer
  2001.                z_ptr[xi] = zi;           
  2002.                } // end if
  2004.             } // end if
  2007. // interpolate u,v,z
  2008. ui+=du;
  2009. vi+=dv;
  2010. zi+=dz;
  2011. } // end for xi
  2013. // interpolate u,v,x along right and left edge
  2014. xl+=dxdyl;
  2015. ul+=dudyl;
  2016. vl+=dvdyl;
  2017. zl+=dzdyl;
  2019. xr+=dxdyr;
  2020. ur+=dudyr;
  2021. vr+=dvdyr;
  2022. zr+=dzdyr;
  2023.  
  2024. // advance screen ptr
  2025. screen_ptr+=mem_pitch;
  2027.         // advance zbuffer ptr
  2028.         z_ptr+=zpitch;
  2030. } // end for y
  2032. } // end if clip
  2033. else
  2034. {
  2035. // non-clip version
  2037. // point screen ptr to starting line
  2038. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2040.     // point zbuffer to starting line
  2041.     z_ptr = zbuffer + (ystart * zpitch);
  2043. for (yi = ystart; yi < yend; yi++)
  2044. {
  2045. // compute span endpoints
  2046. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2047. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2049. // compute starting points for u,v interpolants
  2050. ui = ul + FIXP16_ROUND_UP;
  2051. vi = vl + FIXP16_ROUND_UP;
  2052. zi = zl + FIXP16_ROUND_UP;
  2054. // compute u,v interpolants
  2055. if ((dx = (xend - xstart))>0)
  2056. {
  2057. du = (ur - ul)/dx;
  2058. dv = (vr - vl)/dx;
  2059. dz = (zr - zl)/dx;
  2060. } // end if
  2061. else
  2062. {
  2063. du = (ur - ul);
  2064. dv = (vr - vl);
  2065. dz = (zr - zl);
  2066. } // end else
  2068. // draw span
  2069. for (xi=xstart; xi < xend; xi++)
  2070. {
  2071.                // get textel
  2072.                textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2074.                if (textel)
  2075.                {
  2076.                // test if z of current pixel is nearer than current z buffer value
  2077.                if (zi < z_ptr[xi])
  2078.                   {
  2079.          // write textel
  2080.                   screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  2081.                              alpha_table_src2[textel];
  2084.                   // update z-buffer
  2085.                   z_ptr[xi] = zi;           
  2086.                   } // end if
  2088.                } // end if
  2090. // interpolate u,v,z
  2091. ui+=du;
  2092. vi+=dv;
  2093. zi+=dz;
  2094. } // end for xi
  2096. // interpolate u,v,x along right and left edge
  2097. xl+=dxdyl;
  2098. ul+=dudyl;
  2099. vl+=dvdyl;
  2100. zl+=dzdyl;
  2102. xr+=dxdyr;
  2103. ur+=dudyr;
  2104. vr+=dvdyr;
  2105. zr+=dzdyr;
  2107. // advance screen ptr
  2108. screen_ptr+=mem_pitch;
  2110.         // advance zbuffer ptr
  2111.         z_ptr+=zpitch;
  2113. } // end for y
  2115. } // end if non-clipped
  2117. } // end if
  2118. else
  2119. if (tri_type==TRI_TYPE_GENERAL)
  2120. {
  2122. // first test for bottom clip, always
  2123. if ((yend = y2) > max_clip_y)
  2124. yend = max_clip_y;
  2126. // pre-test y clipping status
  2127. if (y1 < min_clip_y)
  2128. {
  2129. // compute all deltas
  2130. // LHS
  2131. dyl = (y2 - y1);
  2133. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  2134. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2135. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  2136. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;  
  2138. // RHS
  2139. dyr = (y2 - y0);
  2141. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  2142. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2143. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2144. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  2146. // compute overclip
  2147. dyr = (min_clip_y - y0);
  2148. dyl = (min_clip_y - y1);
  2150. // computer new LHS starting values
  2151. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  2152. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  2153. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  2154. zl = dzdyl*dyl + (tz1 << FIXP16_SHIFT);
  2156. // compute new RHS starting values
  2157. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  2158. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  2159. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  2160. zr = dzdyr*dyr + (tz0 << FIXP16_SHIFT);
  2162. // compute new starting y
  2163. ystart = min_clip_y;
  2165. // test if we need swap to keep rendering left to right
  2166. if (dxdyr > dxdyl)
  2167. {
  2168. SWAP(dxdyl,dxdyr,temp);
  2169. SWAP(dudyl,dudyr,temp);
  2170. SWAP(dvdyl,dvdyr,temp);
  2171. SWAP(dzdyl,dzdyr,temp);
  2172. SWAP(xl,xr,temp);
  2173. SWAP(ul,ur,temp);
  2174. SWAP(vl,vr,temp);
  2175. SWAP(zl,zr,temp);
  2176. SWAP(x1,x2,temp);
  2177. SWAP(y1,y2,temp);
  2178. SWAP(tu1,tu2,temp);
  2179. SWAP(tv1,tv2,temp);
  2180. SWAP(tz1,tz2,temp);
  2182. // set interpolation restart
  2183. irestart = INTERP_RHS;
  2185. } // end if
  2187. } // end if
  2188. else
  2189. if (y0 < min_clip_y)
  2190. {
  2191. // compute all deltas
  2192. // LHS
  2193. dyl = (y1 - y0);
  2195. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  2196. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  2197. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  2198. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;  
  2200. // RHS
  2201. dyr = (y2 - y0);
  2203. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  2204. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2205. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2206. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  2208. // compute overclip
  2209. dy = (min_clip_y - y0);
  2211. // computer new LHS starting values
  2212. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  2213. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  2214. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  2215. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  2217. // compute new RHS starting values
  2218. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  2219. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  2220. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  2221. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  2223. // compute new starting y
  2224. ystart = min_clip_y;
  2226. // test if we need swap to keep rendering left to right
  2227. if (dxdyr < dxdyl)
  2228. {
  2229. SWAP(dxdyl,dxdyr,temp);
  2230. SWAP(dudyl,dudyr,temp);
  2231. SWAP(dvdyl,dvdyr,temp);
  2232. SWAP(dzdyl,dzdyr,temp);
  2233. SWAP(xl,xr,temp);
  2234. SWAP(ul,ur,temp);
  2235. SWAP(vl,vr,temp);
  2236. SWAP(zl,zr,temp);
  2237. SWAP(x1,x2,temp);
  2238. SWAP(y1,y2,temp);
  2239. SWAP(tu1,tu2,temp);
  2240. SWAP(tv1,tv2,temp);
  2241. SWAP(tz1,tz2,temp);
  2243. // set interpolation restart
  2244. irestart = INTERP_RHS;
  2246. } // end if
  2248. } // end if
  2249. else
  2250. {
  2251. // no initial y clipping
  2253. // compute all deltas
  2254. // LHS
  2255. dyl = (y1 - y0);
  2257. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  2258. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  2259. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  2260. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;   
  2262. // RHS
  2263. dyr = (y2 - y0);
  2265. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  2266. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2267. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2268. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;  
  2270. // no clipping y
  2272. // set starting values
  2273. xl = (x0 << FIXP16_SHIFT);
  2274. xr = (x0 << FIXP16_SHIFT);
  2276. ul = (tu0 << FIXP16_SHIFT);
  2277. vl = (tv0 << FIXP16_SHIFT);
  2278. zl = (tz0 << FIXP16_SHIFT);
  2280. ur = (tu0 << FIXP16_SHIFT);
  2281. vr = (tv0 << FIXP16_SHIFT);
  2282. zr = (tz0 << FIXP16_SHIFT);
  2284. // set starting y
  2285. ystart = y0;
  2287. // test if we need swap to keep rendering left to right
  2288. if (dxdyr < dxdyl)
  2289. {
  2290. SWAP(dxdyl,dxdyr,temp);
  2291. SWAP(dudyl,dudyr,temp);
  2292. SWAP(dvdyl,dvdyr,temp);
  2293. SWAP(dzdyl,dzdyr,temp);
  2294. SWAP(xl,xr,temp);
  2295. SWAP(ul,ur,temp);
  2296. SWAP(vl,vr,temp);
  2297. SWAP(zl,zr,temp);
  2298. SWAP(x1,x2,temp);
  2299. SWAP(y1,y2,temp);
  2300. SWAP(tu1,tu2,temp);
  2301. SWAP(tv1,tv2,temp);
  2302. SWAP(tz1,tz2,temp);
  2304. // set interpolation restart
  2305. irestart = INTERP_RHS;
  2307. } // end if
  2309. } // end else
  2311.     // test for horizontal clipping
  2312. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  2313. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  2314. (x2 < min_clip_x) || (x2 > max_clip_x))
  2315. {
  2316.     // clip version
  2317. // x clipping
  2319. // point screen ptr to starting line
  2320. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2322.     // point zbuffer to starting line
  2323.     z_ptr = zbuffer + (ystart * zpitch);
  2325. for (yi = ystart; yi < yend; yi++)
  2326. {
  2327. // compute span endpoints
  2328. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2329. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2331. // compute starting points for u,v interpolants
  2332. ui = ul + FIXP16_ROUND_UP;
  2333. vi = vl + FIXP16_ROUND_UP;
  2334. zi = zl + FIXP16_ROUND_UP;
  2336. // compute u,v interpolants
  2337. if ((dx = (xend - xstart))>0)
  2338. {
  2339. du = (ur - ul)/dx;
  2340. dv = (vr - vl)/dx;
  2341. dz = (zr - zl)/dx;
  2342. } // end if
  2343. else
  2344. {
  2345. du = (ur - ul);
  2346. dv = (vr - vl);
  2347. dz = (zr - zl);
  2348. } // end else
  2350. ///////////////////////////////////////////////////////////////////////
  2352. // test for x clipping, LHS
  2353. if (xstart < min_clip_x)
  2354. {
  2355. // compute x overlap
  2356. dx = min_clip_x - xstart;
  2358. // slide interpolants over
  2359. ui+=dx*du;
  2360. vi+=dx*dv;
  2361. zi+=dx*dz;
  2363. // set x to left clip edge
  2364. xstart = min_clip_x;
  2366. } // end if
  2368. // test for x clipping RHS
  2369. if (xend > max_clip_x)
  2370. xend = max_clip_x;
  2372. ///////////////////////////////////////////////////////////////////////
  2374. // draw span
  2375. for (xi=xstart; xi < xend; xi++)
  2376. {
  2377.             // get textel
  2378.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2380.             if (textel)
  2381.             {
  2382.             // test if z of current pixel is nearer than current z buffer value
  2383.             if (zi < z_ptr[xi])
  2384.                {
  2385.       // write textel
  2386.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  2387.                              alpha_table_src2[textel];
  2390.                // update z-buffer
  2391.                z_ptr[xi] = zi;           
  2392.                } // end if
  2394.             } // end if
  2396. // interpolate u,v,z
  2397. ui+=du;
  2398. vi+=dv;
  2399. zi+=dz;
  2400. } // end for xi
  2402. // interpolate u,v,x along right and left edge
  2403. xl+=dxdyl;
  2404. ul+=dudyl;
  2405. vl+=dvdyl;
  2406. zl+=dzdyl;
  2408. xr+=dxdyr;
  2409. ur+=dudyr;
  2410. vr+=dvdyr;
  2411. zr+=dzdyr;
  2413. // advance screen ptr
  2414. screen_ptr+=mem_pitch;
  2416.         // advance zbuffer ptr
  2417.         z_ptr+=zpitch;
  2419. // test for yi hitting second region, if so change interpolant
  2420. if (yi==yrestart)
  2421. {
  2422.     // test interpolation side change flag
  2424. if (irestart == INTERP_LHS)
  2425. {
  2426. // LHS
  2427. dyl = (y2 - y1);
  2429. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  2430. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2431. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  2432. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;   
  2434. // set starting values
  2435. xl = (x1  << FIXP16_SHIFT);
  2436. ul = (tu1 << FIXP16_SHIFT);
  2437. vl = (tv1 << FIXP16_SHIFT);
  2438. zl = (tz1 << FIXP16_SHIFT);
  2440. // interpolate down on LHS to even up
  2441. xl+=dxdyl;
  2442. ul+=dudyl;
  2443. vl+=dvdyl;
  2444. zl+=dzdyl;
  2445. } // end if
  2446. else
  2447. {
  2448. // RHS
  2449. dyr = (y1 - y2);
  2451. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  2452. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  2453. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  2454. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr;  
  2456. // set starting values
  2457. xr = (x2  << FIXP16_SHIFT);
  2458. ur = (tu2 << FIXP16_SHIFT);
  2459. vr = (tv2 << FIXP16_SHIFT);
  2460. zr = (tz2 << FIXP16_SHIFT);
  2462. // interpolate down on RHS to even up
  2463. xr+=dxdyr;
  2464. ur+=dudyr;
  2465. vr+=dvdyr;
  2466. zr+=dzdyr;
  2468. } // end else
  2470. } // end if
  2472. } // end for y
  2474. } // end if
  2475. else
  2476. {
  2477. // no x clipping
  2478. // point screen ptr to starting line
  2479. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2481.     // point zbuffer to starting line
  2482.     z_ptr = zbuffer + (ystart * zpitch);
  2484. for (yi = ystart; yi < yend; yi++)
  2485. {
  2486. // compute span endpoints
  2487. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2488. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2490. // compute starting points for u,v interpolants
  2491. ui = ul + FIXP16_ROUND_UP;
  2492. vi = vl + FIXP16_ROUND_UP;
  2493. zi = zl + FIXP16_ROUND_UP;
  2495. // compute u,v interpolants
  2496. if ((dx = (xend - xstart))>0)
  2497. {
  2498. du = (ur - ul)/dx;
  2499. dv = (vr - vl)/dx;
  2500. dz = (zr - zl)/dx;
  2501. } // end if
  2502. else
  2503. {
  2504. du = (ur - ul);
  2505. dv = (vr - vl);
  2506. dz = (zr - zl);
  2507. } // end else
  2509. // draw span
  2510. for (xi=xstart; xi < xend; xi++)
  2511. {
  2512.             // test if z of current pixel is nearer than current z buffer value
  2513.             // get textel
  2514.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2516.             if (textel)
  2517.             {
  2518.             // test if z of current pixel is nearer than current z buffer value
  2519.             if (zi < z_ptr[xi])
  2520.                {
  2521.       // write textel
  2522.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  2523.                              alpha_table_src2[textel];
  2526.                // update z-buffer
  2527.                z_ptr[xi] = zi;           
  2528.                } // end if
  2530.             } // end if
  2532. // interpolate u,v
  2533. ui+=du;
  2534. vi+=dv;
  2535. zi+=dz;
  2536. } // end for xi
  2538. // interpolate u,v,x along right and left edge
  2539. xl+=dxdyl;
  2540. ul+=dudyl;
  2541. vl+=dvdyl;
  2542. zl+=dzdyl;
  2544. xr+=dxdyr;
  2545. ur+=dudyr;
  2546. vr+=dvdyr;
  2547. zr+=dzdyr;
  2549. // advance screen ptr
  2550. screen_ptr+=mem_pitch;
  2552.         // advance zbuffer ptr
  2553.         z_ptr+=zpitch;
  2555. // test for yi hitting second region, if so change interpolant
  2556. if (yi==yrestart)
  2557. {
  2558. // test interpolation side change flag
  2560. if (irestart == INTERP_LHS)
  2561. {
  2562. // LHS
  2563. dyl = (y2 - y1);
  2565. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  2566. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2567. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  2568. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;   
  2570. // set starting values
  2571. xl = (x1  << FIXP16_SHIFT);
  2572. ul = (tu1 << FIXP16_SHIFT);
  2573. vl = (tv1 << FIXP16_SHIFT);
  2574. zl = (tz1 << FIXP16_SHIFT);
  2576. // interpolate down on LHS to even up
  2577. xl+=dxdyl;
  2578. ul+=dudyl;
  2579. vl+=dvdyl;
  2580. zl+=dzdyl;
  2581. } // end if
  2582. else
  2583. {
  2584. // RHS
  2585. dyr = (y1 - y2);
  2587. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  2588. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  2589. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  2590. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr; 
  2592. // set starting values
  2593. xr = (x2  << FIXP16_SHIFT);
  2594. ur = (tu2 << FIXP16_SHIFT);
  2595. vr = (tv2 << FIXP16_SHIFT);
  2596. zr = (tz2 << FIXP16_SHIFT);
  2598. // interpolate down on RHS to even up
  2599. xr+=dxdyr;
  2600. ur+=dudyr;
  2601. vr+=dvdyr;
  2602. zr+=dzdyr;
  2604. } // end else
  2606. } // end if
  2608. } // end for y
  2610.    } // end else
  2612. } // end if
  2614. } // end Draw_Textured_TriangleZB_Alpha16_2
  2616. ///////////////////////////////////////////////////////////////////////////////
  2618. void Draw_Textured_TriangleWTZB_Alpha16_2(POLYF4DV2_PTR face,  // ptr to face
  2619.                               UCHAR *_dest_buffer,  // pointer to video buffer
  2620.                               int mem_pitch,        // bytes per line, 320, 640 etc.
  2621.                               UCHAR *_zbuffer,       // pointer to z-buffer
  2622.                               int zpitch,          // bytes per line of zbuffer
  2623.                               int alpha)
  2624. {
  2625. // this function draws a textured triangle in 16-bit mode
  2627. int v0=0,
  2628.     v1=1,
  2629. v2=2,
  2630. temp=0,
  2631. tri_type = TRI_TYPE_NONE,
  2632. irestart = INTERP_LHS;
  2634. int dx,dy,dyl,dyr,      // general deltas
  2635.     u,v,z,
  2636.     du,dv,dz,
  2637.     xi,yi,              // the current interpolated x,y
  2638. ui,vi,zi,           // the current interpolated u,v,z
  2639. index_x,index_y,    // looping vars
  2640. x,y,                // hold general x,y
  2641. xstart,
  2642. xend,
  2643. ystart,
  2644. yrestart,
  2645. yend,
  2646. xl,                 
  2647. dxdyl,              
  2648. xr,
  2649. dxdyr,             
  2650. dudyl,    
  2651. ul,
  2652. dvdyl,   
  2653. vl,
  2654. dzdyl,   
  2655. zl,
  2656. dudyr,
  2657. ur,
  2658. dvdyr,
  2659. vr,
  2660. dzdyr,
  2661. zr;
  2663. int x0,y0,tu0,tv0,tz0,    // cached vertices
  2664. x1,y1,tu1,tv1,tz1,
  2665. x2,y2,tu2,tv2,tz2;
  2667. USHORT *screen_ptr  = NULL,
  2668.    *screen_line = NULL,
  2669.    *textmap     = NULL,
  2670.        *dest_buffer = (USHORT *)_dest_buffer,
  2671.         textel; 
  2673. UINT  *z_ptr = NULL,
  2674.       *zbuffer = (UINT *)_zbuffer;
  2676. #ifdef DEBUG_ON
  2677. // track rendering stats
  2678.     debug_polys_rendered_per_frame++;
  2679. #endif
  2681. // extract texture map
  2682. textmap = (USHORT *)face->texture->buffer;
  2684. // extract base 2 of texture width
  2685. int texture_shift2 = logbase2ofx[face->texture->width];
  2687. // adjust memory pitch to words, divide by 2
  2688. mem_pitch >>=1;
  2690. // adjust zbuffer pitch for 32 bit alignment
  2691. zpitch >>= 2;
  2693. // apply fill convention to coordinates
  2694. face->tvlist[0].x = (int)(face->tvlist[0].x+0.5);
  2695. face->tvlist[0].y = (int)(face->tvlist[0].y+0.5);
  2697. face->tvlist[1].x = (int)(face->tvlist[1].x+0.5);
  2698. face->tvlist[1].y = (int)(face->tvlist[1].y+0.5);
  2700. face->tvlist[2].x = (int)(face->tvlist[2].x+0.5);
  2701. face->tvlist[2].y = (int)(face->tvlist[2].y+0.5);
  2703. // first trivial clipping rejection tests 
  2704. if (((face->tvlist[0].y < min_clip_y)  && 
  2705.  (face->tvlist[1].y < min_clip_y)  &&
  2706.  (face->tvlist[2].y < min_clip_y)) ||
  2708. ((face->tvlist[0].y > max_clip_y)  && 
  2709.  (face->tvlist[1].y > max_clip_y)  &&
  2710.  (face->tvlist[2].y > max_clip_y)) ||
  2712. ((face->tvlist[0].x < min_clip_x)  && 
  2713.  (face->tvlist[1].x < min_clip_x)  &&
  2714.  (face->tvlist[2].x < min_clip_x)) ||
  2716. ((face->tvlist[0].x > max_clip_x)  && 
  2717.  (face->tvlist[1].x > max_clip_x)  &&
  2718.  (face->tvlist[2].x > max_clip_x)))
  2719.    return;
  2721. // sort vertices
  2722. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  2723. {SWAP(v0,v1,temp);} 
  2725. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  2726. {SWAP(v0,v2,temp);}
  2728. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  2729. {SWAP(v1,v2,temp);}
  2731. // now test for trivial flat sided cases
  2732. if (FCMP(face->tvlist[v0].y, face->tvlist[v1].y) )
  2733. { 
  2734. // set triangle type
  2735. tri_type = TRI_TYPE_FLAT_TOP;
  2737. // sort vertices left to right
  2738. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  2739. {SWAP(v0,v1,temp);}
  2741. } // end if
  2742. else
  2743. // now test for trivial flat sided cases
  2744. if (FCMP(face->tvlist[v1].y ,face->tvlist[v2].y))
  2745. { 
  2746. // set triangle type
  2747. tri_type = TRI_TYPE_FLAT_BOTTOM;
  2749. // sort vertices left to right
  2750. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  2751. {SWAP(v1,v2,temp);}
  2753. } // end if
  2754. else
  2755. {
  2756. // must be a general triangle
  2757. tri_type = TRI_TYPE_GENERAL;
  2759. } // end else
  2761. // extract vertices for processing, now that we have order
  2762. x0  = (int)(face->tvlist[v0].x+0.0);
  2763. y0  = (int)(face->tvlist[v0].y+0.0);
  2764. tu0 = (int)(face->tvlist[v0].u0);
  2765. tv0 = (int)(face->tvlist[v0].v0);
  2766. tz0 = (int)(face->tvlist[v0].z+0.5);
  2768. x1  = (int)(face->tvlist[v1].x+0.0);
  2769. y1  = (int)(face->tvlist[v1].y+0.0);
  2770. tu1 = (int)(face->tvlist[v1].u0);
  2771. tv1 = (int)(face->tvlist[v1].v0);
  2772. tz1 = (int)(face->tvlist[v1].z+0.5);
  2774. x2  = (int)(face->tvlist[v2].x+0.0);
  2775. y2  = (int)(face->tvlist[v2].y+0.0);
  2776. tu2 = (int)(face->tvlist[v2].u0);
  2777. tv2 = (int)(face->tvlist[v2].v0);
  2778. tz2 = (int)(face->tvlist[v2].z+0.5);
  2781. // degenerate triangle
  2782. if ( ((x0 == x1) && (x1 == x2)) || ((y0 ==  y1) && (y1 == y2)))
  2783.    return;
  2785. // assign both source1 and source2 alpha tables based on polygon alpha level
  2786. USHORT *alpha_table_src1 = (USHORT *)&rgb_alpha_table[(NUM_ALPHA_LEVELS-1) - alpha][0];
  2787. USHORT *alpha_table_src2 = (USHORT *)&rgb_alpha_table[alpha][0];
  2789. // set interpolation restart value
  2790. yrestart = y1;
  2792. // what kind of triangle
  2793. if (tri_type & TRI_TYPE_FLAT_MASK)
  2794. {
  2796. if (tri_type == TRI_TYPE_FLAT_TOP)
  2797. {
  2798. // compute all deltas
  2799. dy = (y2 - y0);
  2801. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  2802. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  2803. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  2804. dzdyl = ((tz2 - tz0) << FIXP16_SHIFT)/dy;    
  2806. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  2807. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  2808. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  2809. dzdyr = ((tz2 - tz1) << FIXP16_SHIFT)/dy;  
  2811. // test for y clipping
  2812. if (y0 < min_clip_y)
  2813. {
  2814. // compute overclip
  2815. dy = (min_clip_y - y0);
  2817. // computer new LHS starting values
  2818. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  2819. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  2820. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  2821. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  2823. // compute new RHS starting values
  2824. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  2825. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  2826. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  2827. zr = dzdyr*dy + (tz1 << FIXP16_SHIFT);
  2829. // compute new starting y
  2830. ystart = min_clip_y;
  2832. } // end if
  2833. else
  2834. {
  2835. // no clipping
  2837. // set starting values
  2838. xl = (x0 << FIXP16_SHIFT);
  2839. xr = (x1 << FIXP16_SHIFT);
  2841. ul = (tu0 << FIXP16_SHIFT);
  2842. vl = (tv0 << FIXP16_SHIFT);
  2843. zl = (tz0 << FIXP16_SHIFT);
  2845. ur = (tu1 << FIXP16_SHIFT);
  2846. vr = (tv1 << FIXP16_SHIFT);
  2847. zr = (tz1 << FIXP16_SHIFT);
  2849. // set starting y
  2850. ystart = y0;
  2852. } // end else
  2854. } // end if flat top
  2855. else
  2856. {
  2857. // must be flat bottom
  2859. // compute all deltas
  2860. dy = (y1 - y0);
  2862. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  2863. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  2864. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  2865. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dy;   
  2867. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  2868. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  2869. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  2870. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dy;   
  2872. // test for y clipping
  2873. if (y0 < min_clip_y)
  2874. {
  2875. // compute overclip
  2876. dy = (min_clip_y - y0);
  2878. // computer new LHS starting values
  2879. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  2880. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  2881. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  2882. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  2884. // compute new RHS starting values
  2885. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  2886. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  2887. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  2888. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  2890. // compute new starting y
  2891. ystart = min_clip_y;
  2893. } // end if
  2894. else
  2895. {
  2896. // no clipping
  2898. // set starting values
  2899. xl = (x0 << FIXP16_SHIFT);
  2900. xr = (x0 << FIXP16_SHIFT);
  2902. ul = (tu0 << FIXP16_SHIFT);
  2903. vl = (tv0 << FIXP16_SHIFT);
  2904. zl = (tz0 << FIXP16_SHIFT);
  2906. ur = (tu0 << FIXP16_SHIFT);
  2907. vr = (tv0 << FIXP16_SHIFT);
  2908. zr = (tz0 << FIXP16_SHIFT);
  2910. // set starting y
  2911. ystart = y0;
  2913. } // end else
  2915. } // end else flat bottom
  2917. // test for bottom clip, always
  2918. if ((yend = y2) > max_clip_y)
  2919. yend = max_clip_y;
  2921.     // test for horizontal clipping
  2922. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  2923. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  2924. (x2 < min_clip_x) || (x2 > max_clip_x))
  2925. {
  2926.     // clip version
  2928. // point screen ptr to starting line
  2929. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2931.     // point zbuffer to starting line
  2932.     z_ptr = zbuffer + (ystart * zpitch);
  2934. for (yi = ystart; yi < yend; yi++)
  2935. {
  2936. // compute span endpoints
  2937. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2938. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2940. // compute starting points for u,v interpolants
  2941. ui = ul + FIXP16_ROUND_UP;
  2942. vi = vl + FIXP16_ROUND_UP;
  2943. zi = zl + FIXP16_ROUND_UP;
  2945. // compute u,v interpolants
  2946. if ((dx = (xend - xstart))>0)
  2947. {
  2948. du = (ur - ul)/dx;
  2949. dv = (vr - vl)/dx;
  2950. dz = (zr - zl)/dx;
  2951. } // end if
  2952. else
  2953. {
  2954. du = (ur - ul);
  2955. dv = (vr - vl);
  2956. dz = (zr - zl);
  2957. } // end else
  2959. ///////////////////////////////////////////////////////////////////////
  2961. // test for x clipping, LHS
  2962. if (xstart < min_clip_x)
  2963. {
  2964. // compute x overlap
  2965. dx = min_clip_x - xstart;
  2967. // slide interpolants over
  2968. ui+=dx*du;
  2969. vi+=dx*dv;
  2970. zi+=dx*dz;
  2972. // reset vars
  2973. xstart = min_clip_x;
  2975. } // end if
  2977. // test for x clipping RHS
  2978. if (xend > max_clip_x)
  2979. xend = max_clip_x;
  2981. ///////////////////////////////////////////////////////////////////////
  2983. // draw span
  2984. for (xi=xstart; xi < xend; xi++)
  2985. {
  2987.             // get textel
  2988.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2990.             if (textel)
  2991.             {
  2992.       // write textel
  2993.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  2994.                              alpha_table_src2[textel];
  2997.                // update z-buffer, write thru
  2998.                z_ptr[xi] = zi;           
  3000.             } // end if
  3003. // interpolate u,v,z
  3004. ui+=du;
  3005. vi+=dv;
  3006. zi+=dz;
  3007. } // end for xi
  3009. // interpolate u,v,x along right and left edge
  3010. xl+=dxdyl;
  3011. ul+=dudyl;
  3012. vl+=dvdyl;
  3013. zl+=dzdyl;
  3015. xr+=dxdyr;
  3016. ur+=dudyr;
  3017. vr+=dvdyr;
  3018. zr+=dzdyr;
  3019.  
  3020. // advance screen ptr
  3021. screen_ptr+=mem_pitch;
  3023.         // advance zbuffer ptr
  3024.         z_ptr+=zpitch;
  3026. } // end for y
  3028. } // end if clip
  3029. else
  3030. {
  3031. // non-clip version
  3033. // point screen ptr to starting line
  3034. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3036.     // point zbuffer to starting line
  3037.     z_ptr = zbuffer + (ystart * zpitch);
  3039. for (yi = ystart; yi < yend; yi++)
  3040. {
  3041. // compute span endpoints
  3042. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3043. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3045. // compute starting points for u,v interpolants
  3046. ui = ul + FIXP16_ROUND_UP;
  3047. vi = vl + FIXP16_ROUND_UP;
  3048. zi = zl + FIXP16_ROUND_UP;
  3050. // compute u,v interpolants
  3051. if ((dx = (xend - xstart))>0)
  3052. {
  3053. du = (ur - ul)/dx;
  3054. dv = (vr - vl)/dx;
  3055. dz = (zr - zl)/dx;
  3056. } // end if
  3057. else
  3058. {
  3059. du = (ur - ul);
  3060. dv = (vr - vl);
  3061. dz = (zr - zl);
  3062. } // end else
  3064. // draw span
  3065. for (xi=xstart; xi < xend; xi++)
  3066. {
  3067.             // test if z of current pixel is nearer than current z buffer value
  3068.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3070.             if (textel)
  3071.             {
  3072.       // write textel
  3073.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  3074.                              alpha_table_src2[textel];
  3077.                // update z-buffer, write thru
  3078.                z_ptr[xi] = zi;           
  3080.             } // end if
  3082. // interpolate u,v,z
  3083. ui+=du;
  3084. vi+=dv;
  3085. zi+=dz;
  3086. } // end for xi
  3088. // interpolate u,v,x along right and left edge
  3089. xl+=dxdyl;
  3090. ul+=dudyl;
  3091. vl+=dvdyl;
  3092. zl+=dzdyl;
  3094. xr+=dxdyr;
  3095. ur+=dudyr;
  3096. vr+=dvdyr;
  3097. zr+=dzdyr;
  3099. // advance screen ptr
  3100. screen_ptr+=mem_pitch;
  3102.         // advance zbuffer ptr
  3103.         z_ptr+=zpitch;
  3105. } // end for y
  3107. } // end if non-clipped
  3109. } // end if
  3110. else
  3111. if (tri_type==TRI_TYPE_GENERAL)
  3112. {
  3114. // first test for bottom clip, always
  3115. if ((yend = y2) > max_clip_y)
  3116. yend = max_clip_y;
  3118. // pre-test y clipping status
  3119. if (y1 < min_clip_y)
  3120. {
  3121. // compute all deltas
  3122. // LHS
  3123. dyl = (y2 - y1);
  3125. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  3126. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  3127. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  3128. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;  
  3130. // RHS
  3131. dyr = (y2 - y0);
  3133. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  3134. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  3135. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  3136. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  3138. // compute overclip
  3139. dyr = (min_clip_y - y0);
  3140. dyl = (min_clip_y - y1);
  3142. // computer new LHS starting values
  3143. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  3144. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  3145. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  3146. zl = dzdyl*dyl + (tz1 << FIXP16_SHIFT);
  3148. // compute new RHS starting values
  3149. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  3150. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  3151. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  3152. zr = dzdyr*dyr + (tz0 << FIXP16_SHIFT);
  3154. // compute new starting y
  3155. ystart = min_clip_y;
  3157. // test if we need swap to keep rendering left to right
  3158. if (dxdyr > dxdyl)
  3159. {
  3160. SWAP(dxdyl,dxdyr,temp);
  3161. SWAP(dudyl,dudyr,temp);
  3162. SWAP(dvdyl,dvdyr,temp);
  3163. SWAP(dzdyl,dzdyr,temp);
  3164. SWAP(xl,xr,temp);
  3165. SWAP(ul,ur,temp);
  3166. SWAP(vl,vr,temp);
  3167. SWAP(zl,zr,temp);
  3168. SWAP(x1,x2,temp);
  3169. SWAP(y1,y2,temp);
  3170. SWAP(tu1,tu2,temp);
  3171. SWAP(tv1,tv2,temp);
  3172. SWAP(tz1,tz2,temp);
  3174. // set interpolation restart
  3175. irestart = INTERP_RHS;
  3177. } // end if
  3179. } // end if
  3180. else
  3181. if (y0 < min_clip_y)
  3182. {
  3183. // compute all deltas
  3184. // LHS
  3185. dyl = (y1 - y0);
  3187. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  3188. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  3189. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  3190. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;  
  3192. // RHS
  3193. dyr = (y2 - y0);
  3195. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  3196. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  3197. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  3198. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  3200. // compute overclip
  3201. dy = (min_clip_y - y0);
  3203. // computer new LHS starting values
  3204. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  3205. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  3206. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  3207. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  3209. // compute new RHS starting values
  3210. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  3211. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  3212. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  3213. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  3215. // compute new starting y
  3216. ystart = min_clip_y;
  3218. // test if we need swap to keep rendering left to right
  3219. if (dxdyr < dxdyl)
  3220. {
  3221. SWAP(dxdyl,dxdyr,temp);
  3222. SWAP(dudyl,dudyr,temp);
  3223. SWAP(dvdyl,dvdyr,temp);
  3224. SWAP(dzdyl,dzdyr,temp);
  3225. SWAP(xl,xr,temp);
  3226. SWAP(ul,ur,temp);
  3227. SWAP(vl,vr,temp);
  3228. SWAP(zl,zr,temp);
  3229. SWAP(x1,x2,temp);
  3230. SWAP(y1,y2,temp);
  3231. SWAP(tu1,tu2,temp);
  3232. SWAP(tv1,tv2,temp);
  3233. SWAP(tz1,tz2,temp);
  3235. // set interpolation restart
  3236. irestart = INTERP_RHS;
  3238. } // end if
  3240. } // end if
  3241. else
  3242. {
  3243. // no initial y clipping
  3245. // compute all deltas
  3246. // LHS
  3247. dyl = (y1 - y0);
  3249. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  3250. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  3251. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  3252. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;   
  3254. // RHS
  3255. dyr = (y2 - y0);
  3257. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  3258. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  3259. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  3260. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;  
  3262. // no clipping y
  3264. // set starting values
  3265. xl = (x0 << FIXP16_SHIFT);
  3266. xr = (x0 << FIXP16_SHIFT);
  3268. ul = (tu0 << FIXP16_SHIFT);
  3269. vl = (tv0 << FIXP16_SHIFT);
  3270. zl = (tz0 << FIXP16_SHIFT);
  3272. ur = (tu0 << FIXP16_SHIFT);
  3273. vr = (tv0 << FIXP16_SHIFT);
  3274. zr = (tz0 << FIXP16_SHIFT);
  3276. // set starting y
  3277. ystart = y0;
  3279. // test if we need swap to keep rendering left to right
  3280. if (dxdyr < dxdyl)
  3281. {
  3282. SWAP(dxdyl,dxdyr,temp);
  3283. SWAP(dudyl,dudyr,temp);
  3284. SWAP(dvdyl,dvdyr,temp);
  3285. SWAP(dzdyl,dzdyr,temp);
  3286. SWAP(xl,xr,temp);
  3287. SWAP(ul,ur,temp);
  3288. SWAP(vl,vr,temp);
  3289. SWAP(zl,zr,temp);
  3290. SWAP(x1,x2,temp);
  3291. SWAP(y1,y2,temp);
  3292. SWAP(tu1,tu2,temp);
  3293. SWAP(tv1,tv2,temp);
  3294. SWAP(tz1,tz2,temp);
  3296. // set interpolation restart
  3297. irestart = INTERP_RHS;
  3299. } // end if
  3301. } // end else
  3303.     // test for horizontal clipping
  3304. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  3305. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  3306. (x2 < min_clip_x) || (x2 > max_clip_x))
  3307. {
  3308.     // clip version
  3309. // x clipping
  3311. // point screen ptr to starting line
  3312. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3314.     // point zbuffer to starting line
  3315.     z_ptr = zbuffer + (ystart * zpitch);
  3317. for (yi = ystart; yi < yend; yi++)
  3318. {
  3319. // compute span endpoints
  3320. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3321. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3323. // compute starting points for u,v interpolants
  3324. ui = ul + FIXP16_ROUND_UP;
  3325. vi = vl + FIXP16_ROUND_UP;
  3326. zi = zl + FIXP16_ROUND_UP;
  3328. // compute u,v interpolants
  3329. if ((dx = (xend - xstart))>0)
  3330. {
  3331. du = (ur - ul)/dx;
  3332. dv = (vr - vl)/dx;
  3333. dz = (zr - zl)/dx;
  3334. } // end if
  3335. else
  3336. {
  3337. du = (ur - ul);
  3338. dv = (vr - vl);
  3339. dz = (zr - zl);
  3340. } // end else
  3342. ///////////////////////////////////////////////////////////////////////
  3344. // test for x clipping, LHS
  3345. if (xstart < min_clip_x)
  3346. {
  3347. // compute x overlap
  3348. dx = min_clip_x - xstart;
  3350. // slide interpolants over
  3351. ui+=dx*du;
  3352. vi+=dx*dv;
  3353. zi+=dx*dz;
  3355. // set x to left clip edge
  3356. xstart = min_clip_x;
  3358. } // end if
  3360. // test for x clipping RHS
  3361. if (xend > max_clip_x)
  3362. xend = max_clip_x;
  3364. ///////////////////////////////////////////////////////////////////////
  3366. // draw span
  3367. for (xi=xstart; xi < xend; xi++)
  3368. {
  3369.             // get textel
  3370.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3372.             if (textel)
  3373.             {
  3374.       // write textel
  3375.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  3376.                              alpha_table_src2[textel];
  3379.                // update z-buffer, write thru
  3380.                z_ptr[xi] = zi;           
  3382.             } // end if
  3384.     
  3385. // interpolate u,v,z
  3386. ui+=du;
  3387. vi+=dv;
  3388. zi+=dz;
  3389. } // end for xi
  3391. // interpolate u,v,x along right and left edge
  3392. xl+=dxdyl;
  3393. ul+=dudyl;
  3394. vl+=dvdyl;
  3395. zl+=dzdyl;
  3397. xr+=dxdyr;
  3398. ur+=dudyr;
  3399. vr+=dvdyr;
  3400. zr+=dzdyr;
  3402. // advance screen ptr
  3403. screen_ptr+=mem_pitch;
  3405.         // advance zbuffer ptr
  3406.         z_ptr+=zpitch;
  3408. // test for yi hitting second region, if so change interpolant
  3409. if (yi==yrestart)
  3410. {
  3411.     // test interpolation side change flag
  3413. if (irestart == INTERP_LHS)
  3414. {
  3415. // LHS
  3416. dyl = (y2 - y1);
  3418. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  3419. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  3420. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  3421. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;   
  3423. // set starting values
  3424. xl = (x1  << FIXP16_SHIFT);
  3425. ul = (tu1 << FIXP16_SHIFT);
  3426. vl = (tv1 << FIXP16_SHIFT);
  3427. zl = (tz1 << FIXP16_SHIFT);
  3429. // interpolate down on LHS to even up
  3430. xl+=dxdyl;
  3431. ul+=dudyl;
  3432. vl+=dvdyl;
  3433. zl+=dzdyl;
  3434. } // end if
  3435. else
  3436. {
  3437. // RHS
  3438. dyr = (y1 - y2);
  3440. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  3441. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  3442. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  3443. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr;  
  3445. // set starting values
  3446. xr = (x2  << FIXP16_SHIFT);
  3447. ur = (tu2 << FIXP16_SHIFT);
  3448. vr = (tv2 << FIXP16_SHIFT);
  3449. zr = (tz2 << FIXP16_SHIFT);
  3451. // interpolate down on RHS to even up
  3452. xr+=dxdyr;
  3453. ur+=dudyr;
  3454. vr+=dvdyr;
  3455. zr+=dzdyr;
  3457. } // end else
  3459. } // end if
  3461. } // end for y
  3463. } // end if
  3464. else
  3465. {
  3466. // no x clipping
  3467. // point screen ptr to starting line
  3468. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3470.     // point zbuffer to starting line
  3471.     z_ptr = zbuffer + (ystart * zpitch);
  3473. for (yi = ystart; yi < yend; yi++)
  3474. {
  3475. // compute span endpoints
  3476. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3477. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3479. // compute starting points for u,v interpolants
  3480. ui = ul + FIXP16_ROUND_UP;
  3481. vi = vl + FIXP16_ROUND_UP;
  3482. zi = zl + FIXP16_ROUND_UP;
  3484. // compute u,v interpolants
  3485. if ((dx = (xend - xstart))>0)
  3486. {
  3487. du = (ur - ul)/dx;
  3488. dv = (vr - vl)/dx;
  3489. dz = (zr - zl)/dx;
  3490. } // end if
  3491. else
  3492. {
  3493. du = (ur - ul);
  3494. dv = (vr - vl);
  3495. dz = (zr - zl);
  3496. } // end else
  3498. // draw span
  3499. for (xi=xstart; xi < xend; xi++)
  3500. {
  3501.             // test if z of current pixel is nearer than current z buffer value
  3502.             // get textel
  3503.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3505.             if (textel)
  3506.             {
  3507.       // write textel
  3508.                screen_ptr[xi] = alpha_table_src1[screen_ptr[xi]] + 
  3509.                              alpha_table_src2[textel];
  3512.                // update z-buffer, write thru
  3513.                z_ptr[xi] = zi;           
  3515.             } // end if
  3517. // interpolate u,v
  3518. ui+=du;
  3519. vi+=dv;
  3520. zi+=dz;
  3521. } // end for xi
  3523. // interpolate u,v,x along right and left edge
  3524. xl+=dxdyl;
  3525. ul+=dudyl;
  3526. vl+=dvdyl;
  3527. zl+=dzdyl;
  3529. xr+=dxdyr;
  3530. ur+=dudyr;
  3531. vr+=dvdyr;
  3532. zr+=dzdyr;
  3534. // advance screen ptr
  3535. screen_ptr+=mem_pitch;
  3537.         // advance zbuffer ptr
  3538.         z_ptr+=zpitch;
  3540. // test for yi hitting second region, if so change interpolant
  3541. if (yi==yrestart)
  3542. {
  3543. // test interpolation side change flag
  3545. if (irestart == INTERP_LHS)
  3546. {
  3547. // LHS
  3548. dyl = (y2 - y1);
  3550. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  3551. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  3552. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  3553. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;   
  3555. // set starting values
  3556. xl = (x1  << FIXP16_SHIFT);
  3557. ul = (tu1 << FIXP16_SHIFT);
  3558. vl = (tv1 << FIXP16_SHIFT);
  3559. zl = (tz1 << FIXP16_SHIFT);
  3561. // interpolate down on LHS to even up
  3562. xl+=dxdyl;
  3563. ul+=dudyl;
  3564. vl+=dvdyl;
  3565. zl+=dzdyl;
  3566. } // end if
  3567. else
  3568. {
  3569. // RHS
  3570. dyr = (y1 - y2);
  3572. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  3573. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  3574. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  3575. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr; 
  3577. // set starting values
  3578. xr = (x2  << FIXP16_SHIFT);
  3579. ur = (tu2 << FIXP16_SHIFT);
  3580. vr = (tv2 << FIXP16_SHIFT);
  3581. zr = (tz2 << FIXP16_SHIFT);
  3583. // interpolate down on RHS to even up
  3584. xr+=dxdyr;
  3585. ur+=dudyr;
  3586. vr+=dvdyr;
  3587. zr+=dzdyr;
  3589. } // end else
  3591. } // end if
  3593. } // end for y
  3595.    } // end else
  3597. } // end if
  3599. } // end Draw_Textured_TriangleWTZB_Alpha16_2
  3601. ///////////////////////////////////////////////////////////////////////////////
  3603. void Draw_Textured_TriangleZB3_16(POLYF4DV2_PTR face,  // ptr to face
  3604.                               UCHAR *_dest_buffer,  // pointer to video buffer
  3605.                               int mem_pitch,        // bytes per line, 320, 640 etc.
  3606.                               UCHAR *_zbuffer,       // pointer to z-buffer
  3607.                               int zpitch)          // bytes per line of zbuffer
  3608. {
  3609. // this function draws a textured triangle in 16-bit mode
  3611. int v0=0,
  3612.     v1=1,
  3613. v2=2,
  3614. temp=0,
  3615. tri_type = TRI_TYPE_NONE,
  3616. irestart = INTERP_LHS;
  3618. int dx,dy,dyl,dyr,      // general deltas
  3619.     u,v,z,
  3620.     du,dv,dz,
  3621.     xi,yi,              // the current interpolated x,y
  3622. ui,vi,zi,           // the current interpolated u,v,z
  3623. index_x,index_y,    // looping vars
  3624. x,y,                // hold general x,y
  3625. xstart,
  3626. xend,
  3627. ystart,
  3628. yrestart,
  3629. yend,
  3630. xl,                 
  3631. dxdyl,              
  3632. xr,
  3633. dxdyr,             
  3634. dudyl,    
  3635. ul,
  3636. dvdyl,   
  3637. vl,
  3638. dzdyl,   
  3639. zl,
  3640. dudyr,
  3641. ur,
  3642. dvdyr,
  3643. vr,
  3644. dzdyr,
  3645. zr;
  3647. int x0,y0,tu0,tv0,tz0,    // cached vertices
  3648. x1,y1,tu1,tv1,tz1,
  3649. x2,y2,tu2,tv2,tz2;
  3651. USHORT *screen_ptr  = NULL,
  3652.    *screen_line = NULL,
  3653.    *textmap     = NULL,
  3654.        *dest_buffer = (USHORT *)_dest_buffer,
  3655.         textel;                       
  3657. UINT  *z_ptr = NULL,
  3658.       *zbuffer = (UINT *)_zbuffer;
  3660. #ifdef DEBUG_ON
  3661. // track rendering stats
  3662.     debug_polys_rendered_per_frame++;
  3663. #endif
  3665. // extract texture map
  3666. textmap = (USHORT *)face->texture->buffer;
  3668. // extract base 2 of texture width
  3669. int texture_shift2 = logbase2ofx[face->texture->width];
  3671. // adjust memory pitch to words, divide by 2
  3672. mem_pitch >>=1;
  3674. // adjust zbuffer pitch for 32 bit alignment
  3675. zpitch >>= 2;
  3677. // apply fill convention to coordinates
  3678. face->tvlist[0].x = (int)(face->tvlist[0].x+0.5);
  3679. face->tvlist[0].y = (int)(face->tvlist[0].y+0.5);
  3681. face->tvlist[1].x = (int)(face->tvlist[1].x+0.5);
  3682. face->tvlist[1].y = (int)(face->tvlist[1].y+0.5);
  3684. face->tvlist[2].x = (int)(face->tvlist[2].x+0.5);
  3685. face->tvlist[2].y = (int)(face->tvlist[2].y+0.5);
  3687. // first trivial clipping rejection tests 
  3688. if (((face->tvlist[0].y < min_clip_y)  && 
  3689.  (face->tvlist[1].y < min_clip_y)  &&
  3690.  (face->tvlist[2].y < min_clip_y)) ||
  3692. ((face->tvlist[0].y > max_clip_y)  && 
  3693.  (face->tvlist[1].y > max_clip_y)  &&
  3694.  (face->tvlist[2].y > max_clip_y)) ||
  3696. ((face->tvlist[0].x < min_clip_x)  && 
  3697.  (face->tvlist[1].x < min_clip_x)  &&
  3698.  (face->tvlist[2].x < min_clip_x)) ||
  3700. ((face->tvlist[0].x > max_clip_x)  && 
  3701.  (face->tvlist[1].x > max_clip_x)  &&
  3702.  (face->tvlist[2].x > max_clip_x)))
  3703.    return;
  3705. // sort vertices
  3706. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  3707. {SWAP(v0,v1,temp);} 
  3709. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  3710. {SWAP(v0,v2,temp);}
  3712. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  3713. {SWAP(v1,v2,temp);}
  3715. // now test for trivial flat sided cases
  3716. if (FCMP(face->tvlist[v0].y, face->tvlist[v1].y) )
  3717. { 
  3718. // set triangle type
  3719. tri_type = TRI_TYPE_FLAT_TOP;
  3721. // sort vertices left to right
  3722. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  3723. {SWAP(v0,v1,temp);}
  3725. } // end if
  3726. else
  3727. // now test for trivial flat sided cases
  3728. if (FCMP(face->tvlist[v1].y ,face->tvlist[v2].y))
  3729. { 
  3730. // set triangle type
  3731. tri_type = TRI_TYPE_FLAT_BOTTOM;
  3733. // sort vertices left to right
  3734. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  3735. {SWAP(v1,v2,temp);}
  3737. } // end if
  3738. else
  3739. {
  3740. // must be a general triangle
  3741. tri_type = TRI_TYPE_GENERAL;
  3743. } // end else
  3745. // extract vertices for processing, now that we have order
  3746. x0  = (int)(face->tvlist[v0].x+0.0);
  3747. y0  = (int)(face->tvlist[v0].y+0.0);
  3748. tu0 = (int)(face->tvlist[v0].u0);
  3749. tv0 = (int)(face->tvlist[v0].v0);
  3750. tz0 = (int)(face->tvlist[v0].z+0.5);
  3752. x1  = (int)(face->tvlist[v1].x+0.0);
  3753. y1  = (int)(face->tvlist[v1].y+0.0);
  3754. tu1 = (int)(face->tvlist[v1].u0);
  3755. tv1 = (int)(face->tvlist[v1].v0);
  3756. tz1 = (int)(face->tvlist[v1].z+0.5);
  3758. x2  = (int)(face->tvlist[v2].x+0.0);
  3759. y2  = (int)(face->tvlist[v2].y+0.0);
  3760. tu2 = (int)(face->tvlist[v2].u0);
  3761. tv2 = (int)(face->tvlist[v2].v0);
  3762. tz2 = (int)(face->tvlist[v2].z+0.5);
  3765. // degenerate triangle
  3766. if ( ((x0 == x1) && (x1 == x2)) || ((y0 ==  y1) && (y1 == y2)))
  3767.    return;
  3769. // set interpolation restart value
  3770. yrestart = y1;
  3772. // what kind of triangle
  3773. if (tri_type & TRI_TYPE_FLAT_MASK)
  3774. {
  3776. if (tri_type == TRI_TYPE_FLAT_TOP)
  3777. {
  3778. // compute all deltas
  3779. dy = (y2 - y0);
  3781. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  3782. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  3783. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  3784. dzdyl = ((tz2 - tz0) << FIXP16_SHIFT)/dy;    
  3786. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  3787. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  3788. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  3789. dzdyr = ((tz2 - tz1) << FIXP16_SHIFT)/dy;  
  3791. // test for y clipping
  3792. if (y0 < min_clip_y)
  3793. {
  3794. // compute overclip
  3795. dy = (min_clip_y - y0);
  3797. // computer new LHS starting values
  3798. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  3799. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  3800. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  3801. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  3803. // compute new RHS starting values
  3804. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  3805. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  3806. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  3807. zr = dzdyr*dy + (tz1 << FIXP16_SHIFT);
  3809. // compute new starting y
  3810. ystart = min_clip_y;
  3812. } // end if
  3813. else
  3814. {
  3815. // no clipping
  3817. // set starting values
  3818. xl = (x0 << FIXP16_SHIFT);
  3819. xr = (x1 << FIXP16_SHIFT);
  3821. ul = (tu0 << FIXP16_SHIFT);
  3822. vl = (tv0 << FIXP16_SHIFT);
  3823. zl = (tz0 << FIXP16_SHIFT);
  3825. ur = (tu1 << FIXP16_SHIFT);
  3826. vr = (tv1 << FIXP16_SHIFT);
  3827. zr = (tz1 << FIXP16_SHIFT);
  3829. // set starting y
  3830. ystart = y0;
  3832. } // end else
  3834. } // end if flat top
  3835. else
  3836. {
  3837. // must be flat bottom
  3839. // compute all deltas
  3840. dy = (y1 - y0);
  3842. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  3843. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  3844. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  3845. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dy;   
  3847. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  3848. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  3849. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  3850. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dy;   
  3852. // test for y clipping
  3853. if (y0 < min_clip_y)
  3854. {
  3855. // compute overclip
  3856. dy = (min_clip_y - y0);
  3858. // computer new LHS starting values
  3859. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  3860. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  3861. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  3862. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  3864. // compute new RHS starting values
  3865. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  3866. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  3867. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  3868. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  3870. // compute new starting y
  3871. ystart = min_clip_y;
  3873. } // end if
  3874. else
  3875. {
  3876. // no clipping
  3878. // set starting values
  3879. xl = (x0 << FIXP16_SHIFT);
  3880. xr = (x0 << FIXP16_SHIFT);
  3882. ul = (tu0 << FIXP16_SHIFT);
  3883. vl = (tv0 << FIXP16_SHIFT);
  3884. zl = (tz0 << FIXP16_SHIFT);
  3886. ur = (tu0 << FIXP16_SHIFT);
  3887. vr = (tv0 << FIXP16_SHIFT);
  3888. zr = (tz0 << FIXP16_SHIFT);
  3890. // set starting y
  3891. ystart = y0;
  3893. } // end else
  3895. } // end else flat bottom
  3897. // test for bottom clip, always
  3898. if ((yend = y2) > max_clip_y)
  3899. yend = max_clip_y;
  3901.     // test for horizontal clipping
  3902. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  3903. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  3904. (x2 < min_clip_x) || (x2 > max_clip_x))
  3905. {
  3906.     // clip version
  3908. // point screen ptr to starting line
  3909. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3911.     // point zbuffer to starting line
  3912.     z_ptr = zbuffer + (ystart * zpitch);
  3914. for (yi = ystart; yi < yend; yi++)
  3915. {
  3916. // compute span endpoints
  3917. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3918. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3920. // compute starting points for u,v interpolants
  3921. ui = ul + FIXP16_ROUND_UP;
  3922. vi = vl + FIXP16_ROUND_UP;
  3923. zi = zl + FIXP16_ROUND_UP;
  3925. // compute u,v interpolants
  3926. if ((dx = (xend - xstart))>0)
  3927. {
  3928. du = (ur - ul)/dx;
  3929. dv = (vr - vl)/dx;
  3930. dz = (zr - zl)/dx;
  3931. } // end if
  3932. else
  3933. {
  3934. du = (ur - ul);
  3935. dv = (vr - vl);
  3936. dz = (zr - zl);
  3937. } // end else
  3939. ///////////////////////////////////////////////////////////////////////
  3941. // test for x clipping, LHS
  3942. if (xstart < min_clip_x)
  3943. {
  3944. // compute x overlap
  3945. dx = min_clip_x - xstart;
  3947. // slide interpolants over
  3948. ui+=dx*du;
  3949. vi+=dx*dv;
  3950. zi+=dx*dz;
  3952. // reset vars
  3953. xstart = min_clip_x;
  3955. } // end if
  3957. // test for x clipping RHS
  3958. if (xend > max_clip_x)
  3959. xend = max_clip_x;
  3961. ///////////////////////////////////////////////////////////////////////
  3963. // draw span
  3964. for (xi=xstart; xi < xend; xi++)
  3965. {
  3966.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3968.             if (textel)
  3969.             {
  3970.             // test if z of current pixel is nearer than current z buffer value
  3971.             if (zi < z_ptr[xi])
  3972.                {
  3973.        // write textel
  3974.                screen_ptr[xi] = textel;
  3976.                // update z-buffer
  3977.                z_ptr[xi] = zi;           
  3978.                } // end if
  3979.              } // end if
  3980.         
  3983. // interpolate u,v,z
  3984. ui+=du;
  3985. vi+=dv;
  3986. zi+=dz;
  3987. } // end for xi
  3989. // interpolate u,v,x along right and left edge
  3990. xl+=dxdyl;
  3991. ul+=dudyl;
  3992. vl+=dvdyl;
  3993. zl+=dzdyl;
  3995. xr+=dxdyr;
  3996. ur+=dudyr;
  3997. vr+=dvdyr;
  3998. zr+=dzdyr;
  3999.  
  4000. // advance screen ptr
  4001. screen_ptr+=mem_pitch;
  4003.         // advance zbuffer ptr
  4004.         z_ptr+=zpitch;
  4006. } // end for y
  4008. } // end if clip
  4009. else
  4010. {
  4011. // non-clip version
  4013. // point screen ptr to starting line
  4014. screen_ptr = dest_buffer + (ystart * mem_pitch);
  4016.     // point zbuffer to starting line
  4017.     z_ptr = zbuffer + (ystart * zpitch);
  4019. for (yi = ystart; yi < yend; yi++)
  4020. {
  4021. // compute span endpoints
  4022. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  4023. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  4025. // compute starting points for u,v interpolants
  4026. ui = ul + FIXP16_ROUND_UP;
  4027. vi = vl + FIXP16_ROUND_UP;
  4028. zi = zl + FIXP16_ROUND_UP;
  4030. // compute u,v interpolants
  4031. if ((dx = (xend - xstart))>0)
  4032. {
  4033. du = (ur - ul)/dx;
  4034. dv = (vr - vl)/dx;
  4035. dz = (zr - zl)/dx;
  4036. } // end if
  4037. else
  4038. {
  4039. du = (ur - ul);
  4040. dv = (vr - vl);
  4041. dz = (zr - zl);
  4042. } // end else
  4044. // draw span
  4045. for (xi=xstart; xi < xend; xi++)
  4046. {
  4047.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  4049.             if (textel)
  4050.             {
  4051.             // test if z of current pixel is nearer than current z buffer value
  4052.             if (zi < z_ptr[xi])
  4053.                {
  4054.        // write textel
  4055.                screen_ptr[xi] = textel;
  4057.                // update z-buffer
  4058.                z_ptr[xi] = zi;           
  4059.                } // end if
  4060.              } // end if
  4062. // interpolate u,v,z
  4063. ui+=du;
  4064. vi+=dv;
  4065. zi+=dz;
  4066. } // end for xi
  4068. // interpolate u,v,x along right and left edge
  4069. xl+=dxdyl;
  4070. ul+=dudyl;
  4071. vl+=dvdyl;
  4072. zl+=dzdyl;
  4074. xr+=dxdyr;
  4075. ur+=dudyr;
  4076. vr+=dvdyr;
  4077. zr+=dzdyr;
  4079. // advance screen ptr
  4080. screen_ptr+=mem_pitch;
  4082.         // advance zbuffer ptr
  4083.         z_ptr+=zpitch;
  4085. } // end for y
  4087. } // end if non-clipped
  4089. } // end if
  4090. else
  4091. if (tri_type==TRI_TYPE_GENERAL)
  4092. {
  4094. // first test for bottom clip, always
  4095. if ((yend = y2) > max_clip_y)
  4096. yend = max_clip_y;
  4098. // pre-test y clipping status
  4099. if (y1 < min_clip_y)
  4100. {
  4101. // compute all deltas
  4102. // LHS
  4103. dyl = (y2 - y1);
  4105. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  4106. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  4107. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  4108. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;  
  4110. // RHS
  4111. dyr = (y2 - y0);
  4113. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  4114. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  4115. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  4116. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  4118. // compute overclip
  4119. dyr = (min_clip_y - y0);
  4120. dyl = (min_clip_y - y1);
  4122. // computer new LHS starting values
  4123. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  4124. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  4125. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  4126. zl = dzdyl*dyl + (tz1 << FIXP16_SHIFT);
  4128. // compute new RHS starting values
  4129. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  4130. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  4131. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  4132. zr = dzdyr*dyr + (tz0 << FIXP16_SHIFT);
  4134. // compute new starting y
  4135. ystart = min_clip_y;
  4137. // test if we need swap to keep rendering left to right
  4138. if (dxdyr > dxdyl)
  4139. {
  4140. SWAP(dxdyl,dxdyr,temp);
  4141. SWAP(dudyl,dudyr,temp);
  4142. SWAP(dvdyl,dvdyr,temp);
  4143. SWAP(dzdyl,dzdyr,temp);
  4144. SWAP(xl,xr,temp);
  4145. SWAP(ul,ur,temp);
  4146. SWAP(vl,vr,temp);
  4147. SWAP(zl,zr,temp);
  4148. SWAP(x1,x2,temp);
  4149. SWAP(y1,y2,temp);
  4150. SWAP(tu1,tu2,temp);
  4151. SWAP(tv1,tv2,temp);
  4152. SWAP(tz1,tz2,temp);
  4154. // set interpolation restart
  4155. irestart = INTERP_RHS;
  4157. } // end if
  4159. } // end if
  4160. else
  4161. if (y0 < min_clip_y)
  4162. {
  4163. // compute all deltas
  4164. // LHS
  4165. dyl = (y1 - y0);
  4167. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  4168. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  4169. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  4170. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;  
  4172. // RHS
  4173. dyr = (y2 - y0);
  4175. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  4176. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  4177. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  4178. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;   
  4180. // compute overclip
  4181. dy = (min_clip_y - y0);
  4183. // computer new LHS starting values
  4184. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  4185. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  4186. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  4187. zl = dzdyl*dy + (tz0 << FIXP16_SHIFT);
  4189. // compute new RHS starting values
  4190. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  4191. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  4192. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  4193. zr = dzdyr*dy + (tz0 << FIXP16_SHIFT);
  4195. // compute new starting y
  4196. ystart = min_clip_y;
  4198. // test if we need swap to keep rendering left to right
  4199. if (dxdyr < dxdyl)
  4200. {
  4201. SWAP(dxdyl,dxdyr,temp);
  4202. SWAP(dudyl,dudyr,temp);
  4203. SWAP(dvdyl,dvdyr,temp);
  4204. SWAP(dzdyl,dzdyr,temp);
  4205. SWAP(xl,xr,temp);
  4206. SWAP(ul,ur,temp);
  4207. SWAP(vl,vr,temp);
  4208. SWAP(zl,zr,temp);
  4209. SWAP(x1,x2,temp);
  4210. SWAP(y1,y2,temp);
  4211. SWAP(tu1,tu2,temp);
  4212. SWAP(tv1,tv2,temp);
  4213. SWAP(tz1,tz2,temp);
  4215. // set interpolation restart
  4216. irestart = INTERP_RHS;
  4218. } // end if
  4220. } // end if
  4221. else
  4222. {
  4223. // no initial y clipping
  4225. // compute all deltas
  4226. // LHS
  4227. dyl = (y1 - y0);
  4229. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  4230. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  4231. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  4232. dzdyl = ((tz1 - tz0) << FIXP16_SHIFT)/dyl;   
  4234. // RHS
  4235. dyr = (y2 - y0);
  4237. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  4238. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  4239. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  4240. dzdyr = ((tz2 - tz0) << FIXP16_SHIFT)/dyr;  
  4242. // no clipping y
  4244. // set starting values
  4245. xl = (x0 << FIXP16_SHIFT);
  4246. xr = (x0 << FIXP16_SHIFT);
  4248. ul = (tu0 << FIXP16_SHIFT);
  4249. vl = (tv0 << FIXP16_SHIFT);
  4250. zl = (tz0 << FIXP16_SHIFT);
  4252. ur = (tu0 << FIXP16_SHIFT);
  4253. vr = (tv0 << FIXP16_SHIFT);
  4254. zr = (tz0 << FIXP16_SHIFT);
  4256. // set starting y
  4257. ystart = y0;
  4259. // test if we need swap to keep rendering left to right
  4260. if (dxdyr < dxdyl)
  4261. {
  4262. SWAP(dxdyl,dxdyr,temp);
  4263. SWAP(dudyl,dudyr,temp);
  4264. SWAP(dvdyl,dvdyr,temp);
  4265. SWAP(dzdyl,dzdyr,temp);
  4266. SWAP(xl,xr,temp);
  4267. SWAP(ul,ur,temp);
  4268. SWAP(vl,vr,temp);
  4269. SWAP(zl,zr,temp);
  4270. SWAP(x1,x2,temp);
  4271. SWAP(y1,y2,temp);
  4272. SWAP(tu1,tu2,temp);
  4273. SWAP(tv1,tv2,temp);
  4274. SWAP(tz1,tz2,temp);
  4276. // set interpolation restart
  4277. irestart = INTERP_RHS;
  4279. } // end if
  4281. } // end else
  4283.     // test for horizontal clipping
  4284. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  4285. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  4286. (x2 < min_clip_x) || (x2 > max_clip_x))
  4287. {
  4288.     // clip version
  4289. // x clipping
  4291. // point screen ptr to starting line
  4292. screen_ptr = dest_buffer + (ystart * mem_pitch);
  4294.     // point zbuffer to starting line
  4295.     z_ptr = zbuffer + (ystart * zpitch);
  4297. for (yi = ystart; yi < yend; yi++)
  4298. {
  4299. // compute span endpoints
  4300. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  4301. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  4303. // compute starting points for u,v interpolants
  4304. ui = ul + FIXP16_ROUND_UP;
  4305. vi = vl + FIXP16_ROUND_UP;
  4306. zi = zl + FIXP16_ROUND_UP;
  4308. // compute u,v interpolants
  4309. if ((dx = (xend - xstart))>0)
  4310. {
  4311. du = (ur - ul)/dx;
  4312. dv = (vr - vl)/dx;
  4313. dz = (zr - zl)/dx;
  4314. } // end if
  4315. else
  4316. {
  4317. du = (ur - ul);
  4318. dv = (vr - vl);
  4319. dz = (zr - zl);
  4320. } // end else
  4322. ///////////////////////////////////////////////////////////////////////
  4324. // test for x clipping, LHS
  4325. if (xstart < min_clip_x)
  4326. {
  4327. // compute x overlap
  4328. dx = min_clip_x - xstart;
  4330. // slide interpolants over
  4331. ui+=dx*du;
  4332. vi+=dx*dv;
  4333. zi+=dx*dz;
  4335. // set x to left clip edge
  4336. xstart = min_clip_x;
  4338. } // end if
  4340. // test for x clipping RHS
  4341. if (xend > max_clip_x)
  4342. xend = max_clip_x;
  4344. ///////////////////////////////////////////////////////////////////////
  4346. // draw span
  4347. for (xi=xstart; xi < xend; xi++)
  4348. {
  4349.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  4351.             if (textel)
  4352.             {
  4353.             // test if z of current pixel is nearer than current z buffer value
  4354.             if (zi < z_ptr[xi])
  4355.                {
  4356.        // write textel
  4357.                screen_ptr[xi] = textel;
  4359.                // update z-buffer
  4360.                z_ptr[xi] = zi;           
  4361.                } // end if
  4362.              } // end if
  4364. // interpolate u,v,z
  4365. ui+=du;
  4366. vi+=dv;
  4367. zi+=dz;
  4368. } // end for xi
  4370. // interpolate u,v,x along right and left edge
  4371. xl+=dxdyl;
  4372. ul+=dudyl;
  4373. vl+=dvdyl;
  4374. zl+=dzdyl;
  4376. xr+=dxdyr;
  4377. ur+=dudyr;
  4378. vr+=dvdyr;
  4379. zr+=dzdyr;
  4381. // advance screen ptr
  4382. screen_ptr+=mem_pitch;
  4384.         // advance zbuffer ptr
  4385.         z_ptr+=zpitch;
  4387. // test for yi hitting second region, if so change interpolant
  4388. if (yi==yrestart)
  4389. {
  4390.     // test interpolation side change flag
  4392. if (irestart == INTERP_LHS)
  4393. {
  4394. // LHS
  4395. dyl = (y2 - y1);
  4397. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  4398. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  4399. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  4400. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;   
  4402. // set starting values
  4403. xl = (x1  << FIXP16_SHIFT);
  4404. ul = (tu1 << FIXP16_SHIFT);
  4405. vl = (tv1 << FIXP16_SHIFT);
  4406. zl = (tz1 << FIXP16_SHIFT);
  4408. // interpolate down on LHS to even up
  4409. xl+=dxdyl;
  4410. ul+=dudyl;
  4411. vl+=dvdyl;
  4412. zl+=dzdyl;
  4413. } // end if
  4414. else
  4415. {
  4416. // RHS
  4417. dyr = (y1 - y2);
  4419. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  4420. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  4421. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  4422. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr;  
  4424. // set starting values
  4425. xr = (x2  << FIXP16_SHIFT);
  4426. ur = (tu2 << FIXP16_SHIFT);
  4427. vr = (tv2 << FIXP16_SHIFT);
  4428. zr = (tz2 << FIXP16_SHIFT);
  4430. // interpolate down on RHS to even up
  4431. xr+=dxdyr;
  4432. ur+=dudyr;
  4433. vr+=dvdyr;
  4434. zr+=dzdyr;
  4436. } // end else
  4438. } // end if
  4440. } // end for y
  4442. } // end if
  4443. else
  4444. {
  4445. // no x clipping
  4446. // point screen ptr to starting line
  4447. screen_ptr = dest_buffer + (ystart * mem_pitch);
  4449.     // point zbuffer to starting line
  4450.     z_ptr = zbuffer + (ystart * zpitch);
  4452. for (yi = ystart; yi < yend; yi++)
  4453. {
  4454. // compute span endpoints
  4455. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  4456. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  4458. // compute starting points for u,v interpolants
  4459. ui = ul + FIXP16_ROUND_UP;
  4460. vi = vl + FIXP16_ROUND_UP;
  4461. zi = zl + FIXP16_ROUND_UP;
  4463. // compute u,v interpolants
  4464. if ((dx = (xend - xstart))>0)
  4465. {
  4466. du = (ur - ul)/dx;
  4467. dv = (vr - vl)/dx;
  4468. dz = (zr - zl)/dx;
  4469. } // end if
  4470. else
  4471. {
  4472. du = (ur - ul);
  4473. dv = (vr - vl);
  4474. dz = (zr - zl);
  4475. } // end else
  4477. // draw span
  4478. for (xi=xstart; xi < xend; xi++)
  4479. {
  4480.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  4482.             if (textel)
  4483.             {
  4484.             // test if z of current pixel is nearer than current z buffer value
  4485.             if (zi < z_ptr[xi])
  4486.                {
  4487.        // write textel
  4488.                screen_ptr[xi] = textel;
  4490.                // update z-buffer
  4491.                z_ptr[xi] = zi;           
  4492.                } // end if
  4493.              } // end if
  4496. // interpolate u,v
  4497. ui+=du;
  4498. vi+=dv;
  4499. zi+=dz;
  4500. } // end for xi
  4502. // interpolate u,v,x along right and left edge
  4503. xl+=dxdyl;
  4504. ul+=dudyl;
  4505. vl+=dvdyl;
  4506. zl+=dzdyl;
  4508. xr+=dxdyr;
  4509. ur+=dudyr;
  4510. vr+=dvdyr;
  4511. zr+=dzdyr;
  4513. // advance screen ptr
  4514. screen_ptr+=mem_pitch;
  4516.         // advance zbuffer ptr
  4517.         z_ptr+=zpitch;
  4519. // test for yi hitting second region, if so change interpolant
  4520. if (yi==yrestart)
  4521. {
  4522. // test interpolation side change flag
  4524. if (irestart == INTERP_LHS)
  4525. {
  4526. // LHS
  4527. dyl = (y2 - y1);
  4529. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  4530. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  4531. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  4532. dzdyl = ((tz2 - tz1) << FIXP16_SHIFT)/dyl;   
  4534. // set starting values
  4535. xl = (x1  << FIXP16_SHIFT);
  4536. ul = (tu1 << FIXP16_SHIFT);
  4537. vl = (tv1 << FIXP16_SHIFT);
  4538. zl = (tz1 << FIXP16_SHIFT);
  4540. // interpolate down on LHS to even up
  4541. xl+=dxdyl;
  4542. ul+=dudyl;
  4543. vl+=dvdyl;
  4544. zl+=dzdyl;
  4545. } // end if
  4546. else
  4547. {
  4548. // RHS
  4549. dyr = (y1 - y2);
  4551. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  4552. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  4553. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  4554. dzdyr = ((tz1 - tz2) << FIXP16_SHIFT)/dyr; 
  4556. // set starting values
  4557. xr = (x2  << FIXP16_SHIFT);
  4558. ur = (tu2 << FIXP16_SHIFT);
  4559. vr = (tv2 << FIXP16_SHIFT);
  4560. zr = (tz2 << FIXP16_SHIFT);
  4562. // interpolate down on RHS to even up
  4563. xr+=dxdyr;
  4564. ur+=dudyr;
  4565. vr+=dvdyr;
  4566. zr+=dzdyr;
  4568. } // end else
  4570. } // end if
  4572. } // end for y
  4574.    } // end else
  4576. } // end if
  4578. } // end Draw_Textured_TriangleZB3_16