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

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

游戏

开发平台：

Visual C++

t3dlib7.cpp：源码内容
  2.     Write_Error("nSurface Desc = 0x%.4x, num_verts = %d, vert_indices [%d, %d, %d]", 
  3.                                                          poly_surface_desc, 
  4.                                                          poly_num_verts, 
  5.                                                          obj->plist[poly].vert[0],
  6.                                                          obj->plist[poly].vert[1],
  7.                                                          obj->plist[poly].vert[2]);
  9.     // now we that we have the vertex list and we have entered the polygon
  10.     // vertex index data into the polygon itself, now let's analyze the surface
  11.     // descriptor and set the fields for the polygon based on the description
  13.     // extract out each field of data from the surface descriptor
  14.     // first let's get the single/double sided stuff out of the way
  15.     if ((poly_surface_desc & PLX_2SIDED_FLAG))
  16.        {
  17.        SET_BIT(obj->plist[poly].attr, POLY4DV2_ATTR_2SIDED);
  18.        Write_Error("n2 sided.");
  19.        } // end if
  20.     else
  21.        {
  22.        // one sided
  23.        Write_Error("n1 sided.");
  24.        } // end else
  26.     // now let's set the color type and color
  27.     if ((poly_surface_desc & PLX_COLOR_MODE_RGB_FLAG)) 
  28.        {
  29.        // this is an RGB 4.4.4 surface
  30.        SET_BIT(obj->plist[poly].attr,POLY4DV2_ATTR_RGB16);
  31.  
  32.        // now extract color and copy into polygon color
  33.        // field in proper 16-bit format 
  34.        // 0x0RGB is the format, 4 bits per pixel 
  35.        int red   = ((poly_surface_desc & 0x0f00) >> 8);
  36.        int green = ((poly_surface_desc & 0x00f0) >> 4);
  37.        int blue  = (poly_surface_desc & 0x000f);
  39.        // although the data is always in 4.4.4 format, the graphics card
  40.        // is either 5.5.5 or 5.6.5, but our virtual color system translates
  41.        // 8.8.8 into 5.5.5 or 5.6.5 for us, but we have to first scale all
  42.        // these 4.4.4 values into 8.8.8
  43.        obj->plist[poly].color = RGB16Bit(red*16, green*16, blue*16);
  44.        Write_Error("nRGB color = [%d, %d, %d]", red, green, blue);
  45.        } // end if
  46.     else
  47.        {
  48.        // this is an 8-bit color indexed surface
  49.        SET_BIT(obj->plist[poly].attr,POLY4DV2_ATTR_8BITCOLOR);
  51.        // and simple extract the last 8 bits and that's the color index
  52.        obj->plist[poly].color = (poly_surface_desc & 0x00ff);
  53.        
  54.        Write_Error("n8-bit color index = %d", obj->plist[poly].color);
  56.        } // end else
  58.    // handle shading mode
  59.    int shade_mode = (poly_surface_desc & PLX_SHADE_MODE_MASK);
  61.    // set polygon shading mode
  62.    switch(shade_mode)
  63.          {
  64.          case PLX_SHADE_MODE_PURE_FLAG: {
  65.          SET_BIT(obj->plist[poly].attr, POLY4DV2_ATTR_SHADE_MODE_PURE);
  66.          Write_Error("nShade mode = pure");
  67.          } break;
  69.          case PLX_SHADE_MODE_FLAT_FLAG: {
  70.          SET_BIT(obj->plist[poly].attr, POLY4DV2_ATTR_SHADE_MODE_FLAT);
  71.          Write_Error("nShade mode = flat");
  73.          } break;
  75.          case PLX_SHADE_MODE_GOURAUD_FLAG: {
  76.          SET_BIT(obj->plist[poly].attr, POLY4DV2_ATTR_SHADE_MODE_GOURAUD);
  77.          
  78.          // the vertices from this polygon all need normals, set that in the flags attribute
  79.          SET_BIT(obj->vlist_local[ obj->plist[poly].vert[0] ].attr, VERTEX4DTV1_ATTR_NORMAL); 
  80.          SET_BIT(obj->vlist_local[ obj->plist[poly].vert[1] ].attr, VERTEX4DTV1_ATTR_NORMAL); 
  81.          SET_BIT(obj->vlist_local[ obj->plist[poly].vert[2] ].attr, VERTEX4DTV1_ATTR_NORMAL); 
  83.          Write_Error("nShade mode = gouraud");
  84.          } break;
  86.          case PLX_SHADE_MODE_PHONG_FLAG: {
  87.          SET_BIT(obj->plist[poly].attr, POLY4DV2_ATTR_SHADE_MODE_PHONG);
  89.          // the vertices from this polygon all need normals, set that in the flags attribute
  90.          SET_BIT(obj->vlist_local[ obj->plist[poly].vert[0] ].attr, VERTEX4DTV1_ATTR_NORMAL); 
  91.          SET_BIT(obj->vlist_local[ obj->plist[poly].vert[1] ].attr, VERTEX4DTV1_ATTR_NORMAL); 
  92.          SET_BIT(obj->vlist_local[ obj->plist[poly].vert[2] ].attr, VERTEX4DTV1_ATTR_NORMAL); 
  94.          Write_Error("nShade mode = phong");
  95.          } break;
  97.          default: break;
  98.          } // end switch
  100.     // set the material mode to ver. 1.0 emulation
  101.     SET_BIT(obj->plist[poly].attr, POLY4DV2_ATTR_DISABLE_MATERIAL);
  103.     // finally set the polygon to active
  104.     obj->plist[poly].state = POLY4DV2_STATE_ACTIVE;    
  107.     // point polygon vertex list to object's vertex list
  108.     // note that this is redundant since the polylist is contained
  109.     // within the object in this case and its up to the user to select
  110.     // whether the local or transformed vertex list is used when building up
  111.     // polygon geometry, might be a better idea to set to NULL in the context
  112.     // of polygons that are part of an object
  113.     obj->plist[poly].vlist = obj->vlist_local; 
  115.     // set texture coordinate list, this is needed
  116.     obj->plist[poly].tlist = obj->tlist;
  119.     } // end for poly
  121. // compute the polygon normal lengths
  122. Compute_OBJECT4DV2_Poly_Normals(obj);
  124. // compute vertex normals for any gouraud shaded polys
  125. Compute_OBJECT4DV2_Vertex_Normals(obj);
  127. // close the file
  128. fclose(fp);
  130. // return success
  131. return(1);
  133. } // end Load_OBJECT4DV2_PLG
  136. ////////////////////////////////////////////////////////////////
  138. void Reset_RENDERLIST4DV2(RENDERLIST4DV2_PTR rend_list)
  139. {
  140. // this function intializes and resets the sent render list and
  141. // redies it for polygons/faces to be inserted into it
  142. // note that the render list in this version is composed
  143. // of an array FACE4DV1 pointer objects, you call this
  144. // function each frame
  146. // since we are tracking the number of polys in the
  147. // list via num_polys we can set it to 0
  148. // but later we will want a more robust scheme if
  149. // we generalize the linked list more and disconnect
  150. // it from the polygon pointer list
  151. rend_list->num_polys = 0; // that was hard!
  153. }  // end Reset_RENDERLIST4DV2
  155. ////////////////////////////////////////////////////////////////
  157. void Draw_RENDERLIST4DV2_Wire16(RENDERLIST4DV2_PTR rend_list, 
  158.                                 UCHAR *video_buffer, int lpitch)
  159. {
  160. // this function "executes" the render list or in other words
  161. // draws all the faces in the list in wire frame 16bit mode
  162. // note there is no need to sort wire frame polygons
  164. // at this point, all we have is a list of polygons and it's time
  165. // to draw them
  166. for (int poly=0; poly < rend_list->num_polys; poly++)
  167.     {
  168.     // render this polygon if and only if it's not clipped, not culled,
  169.     // active, and visible, note however the concecpt of "backface" is 
  170.     // irrelevant in a wire frame engine though
  171.     if (!(rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_ACTIVE) ||
  172.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_CLIPPED ) ||
  173.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_BACKFACE) )
  174.        continue; // move onto next poly
  176.     // draw the triangle edge one, note that clipping was already set up
  177.     // by 2D initialization, so line clipper will clip all polys out
  178.     // of the 2D screen/window boundary
  179.     Draw_Clip_Line16(rend_list->poly_ptrs[poly]->tvlist[0].x, 
  180.                      rend_list->poly_ptrs[poly]->tvlist[0].y,
  181.                      rend_list->poly_ptrs[poly]->tvlist[1].x, 
  182.                      rend_list->poly_ptrs[poly]->tvlist[1].y,
  183.                      rend_list->poly_ptrs[poly]->lit_color[0],
  184.                      video_buffer, lpitch);
  186.     Draw_Clip_Line16(rend_list->poly_ptrs[poly]->tvlist[1].x, 
  187.                      rend_list->poly_ptrs[poly]->tvlist[1].y,
  188.                      rend_list->poly_ptrs[poly]->tvlist[2].x, 
  189.                      rend_list->poly_ptrs[poly]->tvlist[2].y,
  190.                      rend_list->poly_ptrs[poly]->lit_color[0],
  191.                      video_buffer, lpitch);
  193.     Draw_Clip_Line16(rend_list->poly_ptrs[poly]->tvlist[2].x, 
  194.                      rend_list->poly_ptrs[poly]->tvlist[2].y,
  195.                      rend_list->poly_ptrs[poly]->tvlist[0].x, 
  196.                      rend_list->poly_ptrs[poly]->tvlist[0].y,
  197.                      rend_list->poly_ptrs[poly]->lit_color[0],
  198.                      video_buffer, lpitch);
  200. // track rendering stats
  201. #ifdef DEBUG_ON
  202. debug_polys_rendered_per_frame++;
  203. #endif
  204.     } // end for poly
  206. } // end Draw_RENDERLIST4DV2_Wire16
  208. /////////////////////////////////////////////////////////////
  210. void Draw_RENDERLIST4DV2_Wire(RENDERLIST4DV2_PTR rend_list, 
  211.                               UCHAR *video_buffer, int lpitch)
  212. {
  213. // this function "executes" the render list or in other words
  214. // draws all the faces in the list in wire frame 8bit mode
  215. // note there is no need to sort wire frame polygons
  217. // at this point, all we have is a list of polygons and it's time
  218. // to draw them
  219. for (int poly=0; poly < rend_list->num_polys; poly++)
  220.     {
  221.     // render this polygon if and only if it's not clipped, not culled,
  222.     // active, and visible, note however the concecpt of "backface" is 
  223.     // irrelevant in a wire frame engine though
  224.     if (!(rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_ACTIVE) ||
  225.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_CLIPPED ) ||
  226.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_BACKFACE) )
  227.        continue; // move onto next poly
  229.     // draw the triangle edge one, note that clipping was already set up
  230.     // by 2D initialization, so line clipper will clip all polys out
  231.     // of the 2D screen/window boundary
  232.     Draw_Clip_Line(rend_list->poly_ptrs[poly]->tvlist[0].x, 
  233.                    rend_list->poly_ptrs[poly]->tvlist[0].y,
  234.                    rend_list->poly_ptrs[poly]->tvlist[1].x, 
  235.                    rend_list->poly_ptrs[poly]->tvlist[1].y,
  236.                    rend_list->poly_ptrs[poly]->lit_color[0],
  237.                    video_buffer, lpitch);
  239.     Draw_Clip_Line(rend_list->poly_ptrs[poly]->tvlist[1].x, 
  240.                    rend_list->poly_ptrs[poly]->tvlist[1].y,
  241.                    rend_list->poly_ptrs[poly]->tvlist[2].x, 
  242.                    rend_list->poly_ptrs[poly]->tvlist[2].y,
  243.                    rend_list->poly_ptrs[poly]->lit_color[0],
  244.                    video_buffer, lpitch);
  246.     Draw_Clip_Line(rend_list->poly_ptrs[poly]->tvlist[2].x, 
  247.                    rend_list->poly_ptrs[poly]->tvlist[2].y,
  248.                    rend_list->poly_ptrs[poly]->tvlist[0].x, 
  249.                    rend_list->poly_ptrs[poly]->tvlist[0].y,
  250.                    rend_list->poly_ptrs[poly]->lit_color[0],
  251.                    video_buffer, lpitch);
  252. // track rendering stats
  253. #ifdef DEBUG_ON
  254. debug_polys_rendered_per_frame++;
  255. #endif
  257.     } // end for poly
  259. } // end Draw_RENDERLIST4DV2_Wire
  261. ///////////////////////////////////////////////////////////////
  263. void Draw_RENDERLIST4DV2_Solid16(RENDERLIST4DV2_PTR rend_list, 
  264.                               UCHAR *video_buffer, 
  265.   int lpitch)
  266. {
  267. // 16-bit version
  268. // this function "executes" the render list or in other words
  269. // draws all the faces in the list, the function will call the 
  270. // proper rasterizer based on the lighting model of the polygons
  273. POLYF4DV2 face; // temp face used to render polygon
  275. // at this point, all we have is a list of polygons and it's time
  276. // to draw them
  277. for (int poly=0; poly < rend_list->num_polys; poly++)
  278.     {
  279.     // render this polygon if and only if it's not clipped, not culled,
  280.     // active, and visible, note however the concecpt of "backface" is 
  281.     // irrelevant in a wire frame engine though
  282.     if (!(rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_ACTIVE) ||
  283.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_CLIPPED ) ||
  284.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_BACKFACE) )
  285.        continue; // move onto next poly
  287.     // need to test for textured first, since a textured poly can either
  288.     // be emissive, or flat shaded, hence we need to call different
  289.     // rasterizers    
  290.     if (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_TEXTURE)
  291.        {
  293.        // set the vertices
  294.        face.tvlist[0].x = (int)rend_list->poly_ptrs[poly]->tvlist[0].x;
  295.        face.tvlist[0].y = (int)rend_list->poly_ptrs[poly]->tvlist[0].y;
  296.        face.tvlist[0].u0 = (int)rend_list->poly_ptrs[poly]->tvlist[0].u0;
  297.        face.tvlist[0].v0 = (int)rend_list->poly_ptrs[poly]->tvlist[0].v0;
  299.        face.tvlist[1].x = (int)rend_list->poly_ptrs[poly]->tvlist[1].x;
  300.        face.tvlist[1].y = (int)rend_list->poly_ptrs[poly]->tvlist[1].y;
  301.        face.tvlist[1].u0 = (int)rend_list->poly_ptrs[poly]->tvlist[1].u0;
  302.        face.tvlist[1].v0 = (int)rend_list->poly_ptrs[poly]->tvlist[1].v0;
  304.        face.tvlist[2].x = (int)rend_list->poly_ptrs[poly]->tvlist[2].x;
  305.        face.tvlist[2].y = (int)rend_list->poly_ptrs[poly]->tvlist[2].y;
  306.        face.tvlist[2].u0 = (int)rend_list->poly_ptrs[poly]->tvlist[2].u0;
  307.        face.tvlist[2].v0 = (int)rend_list->poly_ptrs[poly]->tvlist[2].v0;
  308.     
  310.        // assign the texture
  311.        face.texture = rend_list->poly_ptrs[poly]->texture;
  312.        
  313.        // is this a plain emissive texture?
  314.        if (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_CONSTANT)
  315.           {
  316.           // draw the textured triangle as emissive
  317.           Draw_Textured_Triangle16(&face, video_buffer, lpitch);
  318.           } // end if
  319.        else
  320.           {
  321.           // draw as flat shaded
  322.           face.lit_color[0] = rend_list->poly_ptrs[poly]->lit_color[0];
  323.           Draw_Textured_TriangleFS16(&face, video_buffer, lpitch);
  324.           } // end else
  326.        } // end if      
  327.     else
  328.     if ((rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_FLAT) || 
  329.         (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_CONSTANT) )
  330.        {
  331.        // draw the triangle with basic flat rasterizer
  332.        Draw_Triangle_2D2_16(rend_list->poly_ptrs[poly]->tvlist[0].x, rend_list->poly_ptrs[poly]->tvlist[0].y,
  333.                  rend_list->poly_ptrs[poly]->tvlist[1].x, rend_list->poly_ptrs[poly]->tvlist[1].y,
  334.              rend_list->poly_ptrs[poly]->tvlist[2].x, rend_list->poly_ptrs[poly]->tvlist[2].y,
  335.                  rend_list->poly_ptrs[poly]->lit_color[0], video_buffer, lpitch);
  337.        } // end if
  338.     else
  339.     if (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_GOURAUD)
  340.        {
  341.         // {andre take advantage of the data structures later..}
  342.         // set the vertices
  343.         face.tvlist[0].x  = (int)rend_list->poly_ptrs[poly]->tvlist[0].x;
  344.         face.tvlist[0].y  = (int)rend_list->poly_ptrs[poly]->tvlist[0].y;
  345.         face.lit_color[0] = rend_list->poly_ptrs[poly]->lit_color[0];
  347.         face.tvlist[1].x  = (int)rend_list->poly_ptrs[poly]->tvlist[1].x;
  348.         face.tvlist[1].y  = (int)rend_list->poly_ptrs[poly]->tvlist[1].y;
  349.         face.lit_color[1] = rend_list->poly_ptrs[poly]->lit_color[1];
  351.         face.tvlist[2].x  = (int)rend_list->poly_ptrs[poly]->tvlist[2].x;
  352.         face.tvlist[2].y  = (int)rend_list->poly_ptrs[poly]->tvlist[2].y;
  353.         face.lit_color[2] = rend_list->poly_ptrs[poly]->lit_color[2];
  355.     // draw the gouraud shaded triangle
  356.         Draw_Gouraud_Triangle16(&face, video_buffer, lpitch);
  357.        } // end if gouraud
  359.     } // end for poly
  361. } // end Draw_RENDERLIST4DV2_Solid16
  363. ///////////////////////////////////////////////////////////////
  365. void Draw_RENDERLIST4DV2_Solid(RENDERLIST4DV2_PTR rend_list, 
  366.                               UCHAR *video_buffer, 
  367.   int lpitch)
  368. {
  369. // 8-bit version
  370. // this function "executes" the render list or in other words
  371. // draws all the faces in the list, the function will call the 
  372. // proper rasterizer based on the lighting model of the polygons
  374. POLYF4DV2 face; // temp face used to render polygon
  376. // at this point, all we have is a list of polygons and it's time
  377. // to draw them
  378. for (int poly=0; poly < rend_list->num_polys; poly++)
  379.     {
  380.     // render this polygon if and only if it's not clipped, not culled,
  381.     // active, and visible, note however the concecpt of "backface" is 
  382.     // irrelevant in a wire frame engine though
  383.     if (!(rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_ACTIVE) ||
  384.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_CLIPPED ) ||
  385.          (rend_list->poly_ptrs[poly]->state & POLY4DV2_STATE_BACKFACE) )
  386.        continue; // move onto next poly
  388.     // need to test for textured first, since a textured poly can either
  389.     // be emissive, or flat shaded, hence we need to call different
  390.     // rasterizers    
  391.     if (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_TEXTURE)
  392.        {
  394.        // set the vertices
  395.        face.tvlist[0].x = (int)rend_list->poly_ptrs[poly]->tvlist[0].x;
  396.        face.tvlist[0].y = (int)rend_list->poly_ptrs[poly]->tvlist[0].y;
  397.        face.tvlist[0].u0 = (int)rend_list->poly_ptrs[poly]->tvlist[0].u0;
  398.        face.tvlist[0].v0 = (int)rend_list->poly_ptrs[poly]->tvlist[0].v0;
  400.        face.tvlist[1].x = (int)rend_list->poly_ptrs[poly]->tvlist[1].x;
  401.        face.tvlist[1].y = (int)rend_list->poly_ptrs[poly]->tvlist[1].y;
  402.        face.tvlist[1].u0 = (int)rend_list->poly_ptrs[poly]->tvlist[1].u0;
  403.        face.tvlist[1].v0 = (int)rend_list->poly_ptrs[poly]->tvlist[1].v0;
  405.        face.tvlist[2].x = (int)rend_list->poly_ptrs[poly]->tvlist[2].x;
  406.        face.tvlist[2].y = (int)rend_list->poly_ptrs[poly]->tvlist[2].y;
  407.        face.tvlist[2].u0 = (int)rend_list->poly_ptrs[poly]->tvlist[2].u0;
  408.        face.tvlist[2].v0 = (int)rend_list->poly_ptrs[poly]->tvlist[2].v0;
  409.     
  411.        // assign the texture
  412.        face.texture = rend_list->poly_ptrs[poly]->texture;
  413.        
  414.        // is this a plain emissive texture?
  415.        if (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_CONSTANT)
  416.           {
  417.           // draw the textured triangle as emissive
  418.           Draw_Textured_Triangle(&face, video_buffer, lpitch);
  419.           } // end if
  420.        else
  421.           {
  422.           // draw as flat shaded
  423.           face.lit_color[0] = rend_list->poly_ptrs[poly]->lit_color[0];
  424.           Draw_Textured_TriangleFS(&face, video_buffer, lpitch);
  425.           } // end else
  427.        } // end if      
  428.     else
  429.     if ((rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_FLAT) || 
  430.         (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_CONSTANT) )
  431.        {
  432.        // draw the triangle with basic flat rasterizer
  433.        Draw_Triangle_2D2(rend_list->poly_ptrs[poly]->tvlist[0].x, rend_list->poly_ptrs[poly]->tvlist[0].y,
  434.                  rend_list->poly_ptrs[poly]->tvlist[1].x, rend_list->poly_ptrs[poly]->tvlist[1].y,
  435.              rend_list->poly_ptrs[poly]->tvlist[2].x, rend_list->poly_ptrs[poly]->tvlist[2].y,
  436.                  rend_list->poly_ptrs[poly]->lit_color[0], video_buffer, lpitch);
  438.        } // end if
  439.     else
  440.     if (rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_GOURAUD)
  441.        {
  442.         // {andre take advantage of the data structures later..}
  443.         // set the vertices
  444.         face.tvlist[0].x  = (int)rend_list->poly_ptrs[poly]->tvlist[0].x;
  445.         face.tvlist[0].y  = (int)rend_list->poly_ptrs[poly]->tvlist[0].y;
  446.         face.lit_color[0] = rend_list->poly_ptrs[poly]->lit_color[0];
  448.         face.tvlist[1].x  = (int)rend_list->poly_ptrs[poly]->tvlist[1].x;
  449.         face.tvlist[1].y  = (int)rend_list->poly_ptrs[poly]->tvlist[1].y;
  450.         face.lit_color[1] = rend_list->poly_ptrs[poly]->lit_color[1];
  452.         face.tvlist[2].x  = (int)rend_list->poly_ptrs[poly]->tvlist[2].x;
  453.         face.tvlist[2].y  = (int)rend_list->poly_ptrs[poly]->tvlist[2].y;
  454.         face.lit_color[2] = rend_list->poly_ptrs[poly]->lit_color[2];
  456.     // draw the gouraud shaded triangle
  457.         Draw_Gouraud_Triangle(&face, video_buffer, lpitch);
  458.        } // end if gouraud
  460.     } // end for poly
  462. } // end Draw_RENDERLIST4DV2_Solid
  464. /////////////////////////////////////////////////////////////////
  466. void Draw_OBJECT4DV2_Solid(OBJECT4DV2_PTR obj, 
  467.                             UCHAR *video_buffer, int lpitch)
  468.                      
  469. {
  470. // this function renders an object to the screen  in
  471. // 8 bit mode, it has no regard at all about hidden surface removal, 
  472. // etc. the function only exists as an easy way to render an object 
  473. // without converting it into polygons, the function assumes all 
  474. // coordinates are screen coordinates, but will perform 2D clipping
  476. POLYF4DV2 face; // temp face used to render polygon
  478. // at this point, all we have is a list of polygons and it's time
  479. // to draw them
  480. for (int poly=0; poly < obj->num_polys; poly++)
  481.     {
  482.     // render this polygon if and only if it's not clipped, not culled,
  483.     // active, and visible, note however the concecpt of "backface" is 
  484.     // irrelevant in a wire frame engine though
  485.     if (!(obj->plist[poly].state & POLY4DV2_STATE_ACTIVE) ||
  486.          (obj->plist[poly].state & POLY4DV2_STATE_CLIPPED ) ||
  487.          (obj->plist[poly].state & POLY4DV2_STATE_BACKFACE) )
  488.        continue; // move onto next poly
  490.     // extract vertex indices into master list, rember the polygons are 
  491.     // NOT self contained, but based on the vertex list stored in the object
  492.     // itself
  493.     int vindex_0 = obj->plist[poly].vert[0];
  494.     int vindex_1 = obj->plist[poly].vert[1];
  495.     int vindex_2 = obj->plist[poly].vert[2];
  498.      // need to test for textured first, since a textured poly can either
  499.     // be emissive, or flat shaded, hence we need to call different
  500.     // rasterizers    
  501.     if (obj->plist[poly].attr  & POLY4DV2_ATTR_SHADE_MODE_TEXTURE)
  502.        {
  504.        // set the vertices
  505.        face.tvlist[0].x = (int)obj->vlist_trans[ vindex_0].x;
  506.        face.tvlist[0].y = (int)obj->vlist_trans[ vindex_0].y;
  507.        face.tvlist[0].u0 = (int)obj->vlist_trans[ vindex_0].u0;
  508.        face.tvlist[0].v0 = (int)obj->vlist_trans[ vindex_0].v0;
  510.        face.tvlist[1].x = (int)obj->vlist_trans[ vindex_1].x;
  511.        face.tvlist[1].y = (int)obj->vlist_trans[ vindex_1].y;
  512.        face.tvlist[1].u0 = (int)obj->vlist_trans[ vindex_1].u0;
  513.        face.tvlist[1].v0 = (int)obj->vlist_trans[ vindex_1].v0;
  515.        face.tvlist[2].x = (int)obj->vlist_trans[ vindex_2].x;
  516.        face.tvlist[2].y = (int)obj->vlist_trans[ vindex_2].y;
  517.        face.tvlist[2].u0 = (int)obj->vlist_trans[ vindex_2].u0;
  518.        face.tvlist[2].v0 = (int)obj->vlist_trans[ vindex_2].v0;
  519.     
  520.        // assign the texture
  521.        face.texture = obj->plist[poly].texture;
  522.        
  523.        // is this a plain emissive texture?
  524.        if (obj->plist[poly].attr & POLY4DV2_ATTR_SHADE_MODE_CONSTANT)
  525.           {
  526.           // draw the textured triangle as emissive
  527.           Draw_Textured_Triangle(&face, video_buffer, lpitch);
  528.           } // end if
  529.        else
  530.           {
  531.           // draw as flat shaded
  532.           face.lit_color[0] = obj->plist[poly].lit_color[0];
  533.           Draw_Textured_TriangleFS(&face, video_buffer, lpitch);
  534.           } // end else
  536.        } // end if      
  537.     else
  538.     if ((obj->plist[poly].attr  & POLY4DV2_ATTR_SHADE_MODE_FLAT) || 
  539.         (obj->plist[poly].attr  & POLY4DV2_ATTR_SHADE_MODE_CONSTANT) )
  540.        {
  541.        // draw the triangle with basic flat rasterizer
  542.        Draw_Triangle_2D2(obj->vlist_trans[ vindex_0].x, obj->vlist_trans[ vindex_0].y,
  543.                  obj->vlist_trans[ vindex_1].x, obj->vlist_trans[ vindex_1].y,
  544.              obj->vlist_trans[ vindex_2].x, obj->vlist_trans[ vindex_2].y,
  545.                  obj->plist[poly].lit_color[0], video_buffer, lpitch);
  547.        } // end if
  548.     else
  549.     if (obj->plist[poly].attr & POLY4DV2_ATTR_SHADE_MODE_GOURAUD)
  550.        {
  551.         // {andre take advantage of the data structures later..}
  552.         // set the vertices
  553.         face.tvlist[0].x  = (int)obj->vlist_trans[ vindex_0].x;
  554.         face.tvlist[0].y  = (int)obj->vlist_trans[ vindex_0].y;
  555.         face.lit_color[0] = obj->plist[poly].lit_color[0];
  557.         face.tvlist[1].x  = (int)obj->vlist_trans[ vindex_1].x;
  558.         face.tvlist[1].y  = (int)obj->vlist_trans[ vindex_1].y;
  559.         face.lit_color[1] = obj->plist[poly].lit_color[1];
  561.         face.tvlist[2].x  = (int)obj->vlist_trans[ vindex_2].x;
  562.         face.tvlist[2].y  = (int)obj->vlist_trans[ vindex_2].y;
  563.         face.lit_color[2] = obj->plist[poly].lit_color[2];
  564.     
  565.        // draw the gouraud shaded triangle
  566.        Draw_Gouraud_Triangle(&face, video_buffer, lpitch);
  567.        } // end if gouraud
  569.     } // end for poly
  571. } // end Draw_OBJECT4DV2_Solid
  573. ///////////////////////////////////////////////////////////////
  575. void Draw_OBJECT4DV2_Solid16(OBJECT4DV2_PTR obj, 
  576.                             UCHAR *video_buffer, int lpitch)
  577.                      
  578. {
  579. // this function renders an object to the screen  in
  580. // 16 bit mode, it has no regard at all about hidden surface removal, 
  581. // etc. the function only exists as an easy way to render an object 
  582. // without converting it into polygons, the function assumes all 
  583. // coordinates are screen coordinates, but will perform 2D clipping
  585. POLYF4DV2 face; // temp face used to render polygon
  587. // at this point, all we have is a list of polygons and it's time
  588. // to draw them
  589. for (int poly=0; poly < obj->num_polys; poly++)
  590.     {
  591.     // render this polygon if and only if it's not clipped, not culled,
  592.     // active, and visible, note however the concecpt of "backface" is 
  593.     // irrelevant in a wire frame engine though
  594.     if (!(obj->plist[poly].state & POLY4DV2_STATE_ACTIVE) ||
  595.          (obj->plist[poly].state & POLY4DV2_STATE_CLIPPED ) ||
  596.          (obj->plist[poly].state & POLY4DV2_STATE_BACKFACE) )
  597.        continue; // move onto next poly
  599.     // extract vertex indices into master list, rember the polygons are 
  600.     // NOT self contained, but based on the vertex list stored in the object
  601.     // itself
  602.     int vindex_0 = obj->plist[poly].vert[0];
  603.     int vindex_1 = obj->plist[poly].vert[1];
  604.     int vindex_2 = obj->plist[poly].vert[2];
  607.  // need to test for textured first, since a textured poly can either
  608.     // be emissive, or flat shaded, hence we need to call different
  609.     // rasterizers    
  610.     if (obj->plist[poly].attr  & POLY4DV2_ATTR_SHADE_MODE_TEXTURE)
  611.        {
  613.        // set the vertices
  614.        face.tvlist[0].x = (int)obj->vlist_trans[ vindex_0].x;
  615.        face.tvlist[0].y = (int)obj->vlist_trans[ vindex_0].y;
  616.        face.tvlist[0].u0 = (int)obj->vlist_trans[ vindex_0].u0;
  617.        face.tvlist[0].v0 = (int)obj->vlist_trans[ vindex_0].v0;
  619.        face.tvlist[1].x = (int)obj->vlist_trans[ vindex_1].x;
  620.        face.tvlist[1].y = (int)obj->vlist_trans[ vindex_1].y;
  621.        face.tvlist[1].u0 = (int)obj->vlist_trans[ vindex_1].u0;
  622.        face.tvlist[1].v0 = (int)obj->vlist_trans[ vindex_1].v0;
  624.        face.tvlist[2].x = (int)obj->vlist_trans[ vindex_2].x;
  625.        face.tvlist[2].y = (int)obj->vlist_trans[ vindex_2].y;
  626.        face.tvlist[2].u0 = (int)obj->vlist_trans[ vindex_2].u0;
  627.        face.tvlist[2].v0 = (int)obj->vlist_trans[ vindex_2].v0;
  628.     
  630.        // assign the texture
  631.        face.texture = obj->plist[poly].texture;
  632.        
  633.        // is this a plain emissive texture?
  634.        if (obj->plist[poly].attr & POLY4DV2_ATTR_SHADE_MODE_CONSTANT)
  635.           {
  636.           // draw the textured triangle as emissive
  637.           Draw_Textured_Triangle16(&face, video_buffer, lpitch);
  638.           } // end if
  639.        else
  640.           {
  641.           // draw as flat shaded
  642.           face.lit_color[0] = obj->plist[poly].lit_color[0];
  643.           Draw_Textured_TriangleFS16(&face, video_buffer, lpitch);
  644.           } // end else
  646.        } // end if      
  647.     else
  648.     if ((obj->plist[poly].attr  & POLY4DV2_ATTR_SHADE_MODE_FLAT) || 
  649.         (obj->plist[poly].attr  & POLY4DV2_ATTR_SHADE_MODE_CONSTANT) )
  650.        {
  651.        // draw the triangle with basic flat rasterizer
  652.        Draw_Triangle_2D2_16(obj->vlist_trans[ vindex_0].x, obj->vlist_trans[ vindex_0].y,
  653.                  obj->vlist_trans[ vindex_1].x, obj->vlist_trans[ vindex_1].y,
  654.              obj->vlist_trans[ vindex_2].x, obj->vlist_trans[ vindex_2].y,
  655.                  obj->plist[poly].lit_color[0], video_buffer, lpitch);
  657.        } // end if
  658.     else
  659.     if (obj->plist[poly].attr & POLY4DV2_ATTR_SHADE_MODE_GOURAUD)
  660.        {
  661.         // {andre take advantage of the data structures later..}
  662.         // set the vertices
  663.         face.tvlist[0].x  = (int)obj->vlist_trans[ vindex_0].x;
  664.         face.tvlist[0].y  = (int)obj->vlist_trans[ vindex_0].y;
  665.         face.lit_color[0] = obj->plist[poly].lit_color[0];
  667.         face.tvlist[1].x  = (int)obj->vlist_trans[ vindex_1].x;
  668.         face.tvlist[1].y  = (int)obj->vlist_trans[ vindex_1].y;
  669.         face.lit_color[1] = obj->plist[poly].lit_color[1];
  671.         face.tvlist[2].x  = (int)obj->vlist_trans[ vindex_2].x;
  672.         face.tvlist[2].y  = (int)obj->vlist_trans[ vindex_2].y;
  673.         face.lit_color[2] = obj->plist[poly].lit_color[2];
  674.     
  675.        // draw the gouraud shaded triangle
  676.        Draw_Gouraud_Triangle16(&face, video_buffer, lpitch);
  677.        } // end if gouraud
  679.     } // end for poly
  681. } // end Draw_OBJECT4DV2_Solid16
  683. /////////////////////////////////////////////////////////////
  685. void Draw_Textured_Triangle(POLYF4DV2_PTR face,   // ptr to face
  686.                             UCHAR *dest_buffer,   // pointer to video buffer
  687.                             int mem_pitch)        // bytes per line, 320, 640 etc.
  688. {
  689. // this function draws a textured triangle in 8-bit mode
  691. int v0=0,
  692.     v1=1,
  693. v2=2,
  694. temp=0,
  695. tri_type = TRI_TYPE_NONE,
  696. irestart = INTERP_LHS;
  698. int dx,dy,dyl,dyr,          // general deltas
  699.     u,v,
  700.     du,dv,
  701.     xi,yi,                  // the current interpolated x,y
  702. ui,vi,              // the current interpolated u,v
  703. index_x,index_y,    // looping vars
  704. x,y,                // hold general x,y
  705. xstart,
  706. xend,
  707. ystart,
  708. yrestart,
  709. yend,
  710. xl,                 
  711. dxdyl,              
  712. xr,
  713. dxdyr,             
  714. dudyl,    
  715. ul,
  716. dvdyl,   
  717. vl,
  718. dudyr,
  719. ur,
  720. dvdyr,
  721. vr;
  723. int x0,y0,tu0,tv0,    // cached vertices
  724. x1,y1,tu1,tv1,
  725. x2,y2,tu2,tv2;
  727. UCHAR *screen_ptr  = NULL,
  728.   *screen_line = NULL,
  729.   *textmap     = NULL;
  731. #ifdef DEBUG_ON
  732. // track rendering stats
  733.     debug_polys_rendered_per_frame++;
  734. #endif
  736. // extract texture map
  737. textmap = face->texture->buffer;
  739. // extract base 2 of texture width
  740. int texture_shift2 = logbase2ofx[face->texture->width];
  742. // first trivial clipping rejection tests 
  743. if (((face->tvlist[0].y < min_clip_y)  && 
  744.  (face->tvlist[1].y < min_clip_y)  &&
  745.  (face->tvlist[2].y < min_clip_y)) ||
  747. ((face->tvlist[0].y > max_clip_y)  && 
  748.  (face->tvlist[1].y > max_clip_y)  &&
  749.  (face->tvlist[2].y > max_clip_y)) ||
  751. ((face->tvlist[0].x < min_clip_x)  && 
  752.  (face->tvlist[1].x < min_clip_x)  &&
  753.  (face->tvlist[2].x < min_clip_x)) ||
  755. ((face->tvlist[0].x > max_clip_x)  && 
  756.  (face->tvlist[1].x > max_clip_x)  &&
  757.  (face->tvlist[2].x > max_clip_x)))
  758.    return;
  760. // degenerate triangle
  761. if ( ((face->tvlist[0].x==face->tvlist[1].x) && (face->tvlist[1].x==face->tvlist[2].x)) ||
  762.  ((face->tvlist[0].y==face->tvlist[1].y) && (face->tvlist[1].y==face->tvlist[2].y)))
  763.    return;
  765. // sort vertices
  766. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  767. {SWAP(v0,v1,temp);} 
  769. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  770. {SWAP(v0,v2,temp);}
  772. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  773. {SWAP(v1,v2,temp);}
  775. // now test for trivial flat sided cases
  776. if (face->tvlist[v0].y==face->tvlist[v1].y)
  777. { 
  778. // set triangle type
  779. tri_type = TRI_TYPE_FLAT_TOP;
  781. // sort vertices left to right
  782. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  783. {SWAP(v0,v1,temp);}
  785. } // end if
  786. else
  787. // now test for trivial flat sided cases
  788. if (face->tvlist[v1].y==face->tvlist[v2].y)
  789. { 
  790. // set triangle type
  791. tri_type = TRI_TYPE_FLAT_BOTTOM;
  793. // sort vertices left to right
  794. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  795. {SWAP(v1,v2,temp);}
  797. } // end if
  798. else
  799. {
  800. // must be a general triangle
  801. tri_type = TRI_TYPE_GENERAL;
  803. } // end else
  805. // extract vertices for processing, now that we have order
  806. x0  = (int)(face->tvlist[v0].x+0.5);
  807. y0  = (int)(face->tvlist[v0].y+0.5);
  808. tu0 = (int)(face->tvlist[v0].u0);
  809. tv0 = (int)(face->tvlist[v0].v0);
  811. x1  = (int)(face->tvlist[v1].x+0.5);
  812. y1  = (int)(face->tvlist[v1].y+0.5);
  813. tu1 = (int)(face->tvlist[v1].u0);
  814. tv1 = (int)(face->tvlist[v1].v0);
  816. x2  = (int)(face->tvlist[v2].x+0.5);
  817. y2  = (int)(face->tvlist[v2].y+0.5);
  818. tu2 = (int)(face->tvlist[v2].u0);
  819. tv2 = (int)(face->tvlist[v2].v0);
  821. // set interpolation restart value
  822. yrestart = y1;
  824. // what kind of triangle
  825. if (tri_type & TRI_TYPE_FLAT_MASK)
  826. {
  828. if (tri_type == TRI_TYPE_FLAT_TOP)
  829. {
  830. // compute all deltas
  831. dy = (y2 - y0);
  833. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  834. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  835. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  837. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  838. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  839. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  841. // test for y clipping
  842. if (y0 < min_clip_y)
  843. {
  844. // compute overclip
  845. dy = (min_clip_y - y0);
  847. // computer new LHS starting values
  848. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  849. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  850. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  852. // compute new RHS starting values
  853. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  854. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  855. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  857. // compute new starting y
  858. ystart = min_clip_y;
  860. } // end if
  861. else
  862. {
  863. // no clipping
  865. // set starting values
  866. xl = (x0 << FIXP16_SHIFT);
  867. xr = (x1 << FIXP16_SHIFT);
  869. ul = (tu0 << FIXP16_SHIFT);
  870. vl = (tv0 << FIXP16_SHIFT);
  872. ur = (tu1 << FIXP16_SHIFT);
  873. vr = (tv1 << FIXP16_SHIFT);
  875. // set starting y
  876. ystart = y0;
  878. } // end else
  880. } // end if flat top
  881. else
  882. {
  883. // must be flat bottom
  885. // compute all deltas
  886. dy = (y1 - y0);
  888. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  889. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  890. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  892. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  893. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  894. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  896. // test for y clipping
  897. if (y0 < min_clip_y)
  898. {
  899. // compute overclip
  900. dy = (min_clip_y - y0);
  902. // computer new LHS starting values
  903. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  904. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  905. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  907. // compute new RHS starting values
  908. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  909. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  910. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  912. // compute new starting y
  913. ystart = min_clip_y;
  915. } // end if
  916. else
  917. {
  918. // no clipping
  920. // set starting values
  921. xl = (x0 << FIXP16_SHIFT);
  922. xr = (x0 << FIXP16_SHIFT);
  924. ul = (tu0 << FIXP16_SHIFT);
  925. vl = (tv0 << FIXP16_SHIFT);
  927. ur = (tu0 << FIXP16_SHIFT);
  928. vr = (tv0 << FIXP16_SHIFT);
  930. // set starting y
  931. ystart = y0;
  933. } // end else
  935. } // end else flat bottom
  937. // test for bottom clip, always
  938. if ((yend = y2) > max_clip_y)
  939. yend = max_clip_y;
  941.     // test for horizontal clipping
  942. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  943. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  944. (x2 < min_clip_x) || (x2 > max_clip_x))
  945. {
  946.     // clip version
  948. // point screen ptr to starting line
  949. screen_ptr = dest_buffer + (ystart * mem_pitch);
  951. for (yi = ystart; yi<=yend; yi++)
  952. {
  953. // compute span endpoints
  954. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  955. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  957. // compute starting points for u,v interpolants
  958. ui = ul + FIXP16_ROUND_UP;
  959. vi = vl + FIXP16_ROUND_UP;
  961. // compute u,v interpolants
  962. if ((dx = (xend - xstart))>0)
  963. {
  964. du = (ur - ul)/dx;
  965. dv = (vr - vl)/dx;
  966. } // end if
  967. else
  968. {
  969. du = (ur - ul);
  970. dv = (vr - vl);
  971. } // end else
  973. ///////////////////////////////////////////////////////////////////////
  975. // test for x clipping, LHS
  976. if (xstart < min_clip_x)
  977. {
  978. // compute x overlap
  979. dx = min_clip_x - xstart;
  981. // slide interpolants over
  982. ui+=dx*du;
  983. vi+=dx*dv;
  985. // reset vars
  986. xstart = min_clip_x;
  988. } // end if
  990. // test for x clipping RHS
  991. if (xend > max_clip_x)
  992. xend = max_clip_x;
  994. ///////////////////////////////////////////////////////////////////////
  996. // draw span
  997. for (xi=xstart; xi<=xend; xi++)
  998. {
  999. // write textel
  1000.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1002. // interpolate u,v
  1003. ui+=du;
  1004. vi+=dv;
  1005. } // end for xi
  1007. // interpolate u,v,x along right and left edge
  1008. xl+=dxdyl;
  1009. ul+=dudyl;
  1010. vl+=dvdyl;
  1012. xr+=dxdyr;
  1013. ur+=dudyr;
  1014. vr+=dvdyr;
  1015.  
  1016. // advance screen ptr
  1017. screen_ptr+=mem_pitch;
  1019. } // end for y
  1021. } // end if clip
  1022. else
  1023. {
  1024. // non-clip version
  1026. // point screen ptr to starting line
  1027. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1029. for (yi = ystart; yi<=yend; yi++)
  1030. {
  1031. // compute span endpoints
  1032. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1033. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1035. // compute starting points for u,v interpolants
  1036. ui = ul + FIXP16_ROUND_UP;
  1037. vi = vl + FIXP16_ROUND_UP;
  1039. // compute u,v interpolants
  1040. if ((dx = (xend - xstart))>0)
  1041. {
  1042. du = (ur - ul)/dx;
  1043. dv = (vr - vl)/dx;
  1044. } // end if
  1045. else
  1046. {
  1047. du = (ur - ul);
  1048. dv = (vr - vl);
  1049. } // end else
  1051. // draw span
  1052. for (xi=xstart; xi<=xend; xi++)
  1053. {
  1054. // write textel
  1055.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1057. // interpolate u,v
  1058. ui+=du;
  1059. vi+=dv;
  1060. } // end for xi
  1062. // interpolate u,v,x along right and left edge
  1063. xl+=dxdyl;
  1064. ul+=dudyl;
  1065. vl+=dvdyl;
  1067. xr+=dxdyr;
  1068. ur+=dudyr;
  1069. vr+=dvdyr;
  1071. // advance screen ptr
  1072. screen_ptr+=mem_pitch;
  1074. } // end for y
  1076. } // end if non-clipped
  1078. } // end if
  1079. else
  1080. if (tri_type==TRI_TYPE_GENERAL)
  1081. {
  1083. // first test for bottom clip, always
  1084. if ((yend = y2) > max_clip_y)
  1085. yend = max_clip_y;
  1087. // pre-test y clipping status
  1088. if (y1 < min_clip_y)
  1089. {
  1090. // compute all deltas
  1091. // LHS
  1092. dyl = (y2 - y1);
  1094. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  1095. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1096. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  1098. // RHS
  1099. dyr = (y2 - y0);
  1101. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  1102. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1103. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1105. // compute overclip
  1106. dyr = (min_clip_y - y0);
  1107. dyl = (min_clip_y - y1);
  1109. // computer new LHS starting values
  1110. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  1111. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  1112. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  1114. // compute new RHS starting values
  1115. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  1116. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  1117. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  1119. // compute new starting y
  1120. ystart = min_clip_y;
  1122. // test if we need swap to keep rendering left to right
  1123. if (dxdyr > dxdyl)
  1124. {
  1125. SWAP(dxdyl,dxdyr,temp);
  1126. SWAP(dudyl,dudyr,temp);
  1127. SWAP(dvdyl,dvdyr,temp);
  1128. SWAP(xl,xr,temp);
  1129. SWAP(ul,ur,temp);
  1130. SWAP(vl,vr,temp);
  1131. SWAP(x1,x2,temp);
  1132. SWAP(y1,y2,temp);
  1133. SWAP(tu1,tu2,temp);
  1134. SWAP(tv1,tv2,temp);
  1136. // set interpolation restart
  1137. irestart = INTERP_RHS;
  1139. } // end if
  1141. } // end if
  1142. else
  1143. if (y0 < min_clip_y)
  1144. {
  1145. // compute all deltas
  1146. // LHS
  1147. dyl = (y1 - y0);
  1149. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  1150. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  1151. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  1153. // RHS
  1154. dyr = (y2 - y0);
  1156. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  1157. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1158. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1160. // compute overclip
  1161. dy = (min_clip_y - y0);
  1163. // computer new LHS starting values
  1164. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1165. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1166. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1168. // compute new RHS starting values
  1169. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  1170. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  1171. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  1173. // compute new starting y
  1174. ystart = min_clip_y;
  1176. // test if we need swap to keep rendering left to right
  1177. if (dxdyr < dxdyl)
  1178. {
  1179. SWAP(dxdyl,dxdyr,temp);
  1180. SWAP(dudyl,dudyr,temp);
  1181. SWAP(dvdyl,dvdyr,temp);
  1182. SWAP(xl,xr,temp);
  1183. SWAP(ul,ur,temp);
  1184. SWAP(vl,vr,temp);
  1185. SWAP(x1,x2,temp);
  1186. SWAP(y1,y2,temp);
  1187. SWAP(tu1,tu2,temp);
  1188. SWAP(tv1,tv2,temp);
  1190. // set interpolation restart
  1191. irestart = INTERP_RHS;
  1193. } // end if
  1195. } // end if
  1196. else
  1197. {
  1198. // no initial y clipping
  1200. // compute all deltas
  1201. // LHS
  1202. dyl = (y1 - y0);
  1204. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  1205. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  1206. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  1208. // RHS
  1209. dyr = (y2 - y0);
  1211. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  1212. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1213. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1215. // no clipping y
  1217. // set starting values
  1218. xl = (x0 << FIXP16_SHIFT);
  1219. xr = (x0 << FIXP16_SHIFT);
  1221. ul = (tu0 << FIXP16_SHIFT);
  1222. vl = (tv0 << FIXP16_SHIFT);
  1224. ur = (tu0 << FIXP16_SHIFT);
  1225. vr = (tv0 << FIXP16_SHIFT);
  1227. // set starting y
  1228. ystart = y0;
  1230. // test if we need swap to keep rendering left to right
  1231. if (dxdyr < dxdyl)
  1232. {
  1233. SWAP(dxdyl,dxdyr,temp);
  1234. SWAP(dudyl,dudyr,temp);
  1235. SWAP(dvdyl,dvdyr,temp);
  1236. SWAP(xl,xr,temp);
  1237. SWAP(ul,ur,temp);
  1238. SWAP(vl,vr,temp);
  1239. SWAP(x1,x2,temp);
  1240. SWAP(y1,y2,temp);
  1241. SWAP(tu1,tu2,temp);
  1242. SWAP(tv1,tv2,temp);
  1244. // set interpolation restart
  1245. irestart = INTERP_RHS;
  1247. } // end if
  1249. } // end else
  1252.     // test for horizontal clipping
  1253. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  1254. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  1255. (x2 < min_clip_x) || (x2 > max_clip_x))
  1256. {
  1257.     // clip version
  1258. // x clipping
  1260. // point screen ptr to starting line
  1261. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1263. for (yi = ystart; yi<=yend; yi++)
  1264. {
  1265. // compute span endpoints
  1266. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1267. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1269. // compute starting points for u,v interpolants
  1270. ui = ul + FIXP16_ROUND_UP;
  1271. vi = vl + FIXP16_ROUND_UP;
  1273. // compute u,v interpolants
  1274. if ((dx = (xend - xstart))>0)
  1275. {
  1276. du = (ur - ul)/dx;
  1277. dv = (vr - vl)/dx;
  1278. } // end if
  1279. else
  1280. {
  1281. du = (ur - ul);
  1282. dv = (vr - vl);
  1283. } // end else
  1285. ///////////////////////////////////////////////////////////////////////
  1287. // test for x clipping, LHS
  1288. if (xstart < min_clip_x)
  1289. {
  1290. // compute x overlap
  1291. dx = min_clip_x - xstart;
  1293. // slide interpolants over
  1294. ui+=dx*du;
  1295. vi+=dx*dv;
  1297. // set x to left clip edge
  1298. xstart = min_clip_x;
  1300. } // end if
  1302. // test for x clipping RHS
  1303. if (xend > max_clip_x)
  1304. xend = max_clip_x;
  1306. ///////////////////////////////////////////////////////////////////////
  1308. // draw span
  1309. for (xi=xstart; xi<=xend; xi++)
  1310. {
  1311. // write textel
  1312.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1314. // interpolate u,v
  1315. ui+=du;
  1316. vi+=dv;
  1317. } // end for xi
  1319. // interpolate u,v,x along right and left edge
  1320. xl+=dxdyl;
  1321. ul+=dudyl;
  1322. vl+=dvdyl;
  1324. xr+=dxdyr;
  1325. ur+=dudyr;
  1326. vr+=dvdyr;
  1328. // advance screen ptr
  1329. screen_ptr+=mem_pitch;
  1331. // test for yi hitting second region, if so change interpolant
  1332. if (yi==yrestart)
  1333. {
  1335. // test interpolation side change flag
  1337. if (irestart == INTERP_LHS)
  1338. {
  1339. // LHS
  1340. dyl = (y2 - y1);
  1342. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  1343. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1344. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  1346. // set starting values
  1347. xl = (x1  << FIXP16_SHIFT);
  1348. ul = (tu1 << FIXP16_SHIFT);
  1349. vl = (tv1 << FIXP16_SHIFT);
  1351. // interpolate down on LHS to even up
  1352. xl+=dxdyl;
  1353. ul+=dudyl;
  1354. vl+=dvdyl;
  1355. } // end if
  1356. else
  1357. {
  1358. // RHS
  1359. dyr = (y1 - y2);
  1361. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  1362. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  1363. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  1365. // set starting values
  1366. xr = (x2  << FIXP16_SHIFT);
  1367. ur = (tu2 << FIXP16_SHIFT);
  1368. vr = (tv2 << FIXP16_SHIFT);
  1370. // interpolate down on RHS to even up
  1371. xr+=dxdyr;
  1372. ur+=dudyr;
  1373. vr+=dvdyr;
  1375. } // end else
  1378. } // end if
  1380. } // end for y
  1382. } // end if
  1383. else
  1384. {
  1385. // no x clipping
  1386. // point screen ptr to starting line
  1387. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1389. for (yi = ystart; yi<=yend; yi++)
  1390. {
  1391. // compute span endpoints
  1392. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1393. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1395. // compute starting points for u,v interpolants
  1396. ui = ul + FIXP16_ROUND_UP;
  1397. vi = vl + FIXP16_ROUND_UP;
  1399. // compute u,v interpolants
  1400. if ((dx = (xend - xstart))>0)
  1402. {
  1403. du = (ur - ul)/dx;
  1404. dv = (vr - vl)/dx;
  1405. } // end if
  1406. else
  1407. {
  1408. du = (ur - ul);
  1409. dv = (vr - vl);
  1410. } // end else
  1412. // draw span
  1413. for (xi=xstart; xi<=xend; xi++)
  1414. {
  1415. // write textel
  1416.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1418. // interpolate u,v
  1419. ui+=du;
  1420. vi+=dv;
  1421. } // end for xi
  1423. // interpolate u,v,x along right and left edge
  1424. xl+=dxdyl;
  1425. ul+=dudyl;
  1426. vl+=dvdyl;
  1428. xr+=dxdyr;
  1429. ur+=dudyr;
  1430. vr+=dvdyr;
  1432. // advance screen ptr
  1433. screen_ptr+=mem_pitch;
  1435. // test for yi hitting second region, if so change interpolant
  1436. if (yi==yrestart)
  1437. {
  1438. // test interpolation side change flag
  1440. if (irestart == INTERP_LHS)
  1441. {
  1442. // LHS
  1443. dyl = (y2 - y1);
  1445. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  1446. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1447. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  1449. // set starting values
  1450. xl = (x1  << FIXP16_SHIFT);
  1451. ul = (tu1 << FIXP16_SHIFT);
  1452. vl = (tv1 << FIXP16_SHIFT);
  1454. // interpolate down on LHS to even up
  1455. xl+=dxdyl;
  1456. ul+=dudyl;
  1457. vl+=dvdyl;
  1458. } // end if
  1459. else
  1460. {
  1461. // RHS
  1462. dyr = (y1 - y2);
  1464. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  1465. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  1466. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  1468. // set starting values
  1469. xr = (x2  << FIXP16_SHIFT);
  1470. ur = (tu2 << FIXP16_SHIFT);
  1471. vr = (tv2 << FIXP16_SHIFT);
  1473. // interpolate down on RHS to even up
  1474. xr+=dxdyr;
  1475. ur+=dudyr;
  1476. vr+=dvdyr;
  1478. } // end else
  1480. } // end if
  1482. } // end for y
  1484. } // end else
  1486. } // end if
  1488. } // end Draw_Textured_Triangle
  1490. //////////////////////////////////////////////////////////////////////
  1492. void Draw_Textured_TriangleFS(POLYF4DV2_PTR face,   // ptr to face
  1493.                             UCHAR *dest_buffer,   // pointer to video buffer
  1494.                             int mem_pitch)        // bytes per line, 320, 640 etc.
  1495. {
  1496. // this function draws a textured triangle in 8-bit mode
  1498. int v0=0,
  1499.     v1=1,
  1500. v2=2,
  1501. temp=0,
  1502. tri_type = TRI_TYPE_NONE,
  1503. irestart = INTERP_LHS;
  1505. int dx,dy,dyl,dyr,          // general deltas
  1506.     u,v,
  1507.     du,dv,
  1508.     xi,yi,                  // the current interpolated x,y
  1509. ui,vi,              // the current interpolated u,v
  1510. index_x,index_y,    // looping vars
  1511. x,y,                // hold general x,y
  1512. xstart,
  1513. xend,
  1514. ystart,
  1515. yrestart,
  1516. yend,
  1517. xl,                 
  1518. dxdyl,              
  1519. xr,
  1520. dxdyr,             
  1521. dudyl,    
  1522. ul,
  1523. dvdyl,   
  1524. vl,
  1525. dudyr,
  1526. ur,
  1527. dvdyr,
  1528. vr;
  1530. int x0,y0,tu0,tv0,    // cached vertices
  1531. x1,y1,tu1,tv1,
  1532. x2,y2,tu2,tv2;
  1534. int r_base, g_base, b_base, base_rgb444, textel; // used for color modulation algorithm to light texture
  1536. UCHAR *screen_ptr    = NULL,
  1537.   *screen_line   = NULL,
  1538.   *textmap       = NULL,
  1539.       *lightrow444_8 = NULL;
  1541. #ifdef DEBUG_ON
  1542. // track rendering stats
  1543.     debug_polys_rendered_per_frame++;
  1544. #endif
  1546. // extract texture map
  1547. textmap = face->texture->buffer;
  1549. // extract base 2 of texture width
  1550. int texture_shift2 = logbase2ofx[face->texture->width];
  1552. // first trivial clipping rejection tests 
  1553. if (((face->tvlist[0].y < min_clip_y)  && 
  1554.  (face->tvlist[1].y < min_clip_y)  &&
  1555.  (face->tvlist[2].y < min_clip_y)) ||
  1557. ((face->tvlist[0].y > max_clip_y)  && 
  1558.  (face->tvlist[1].y > max_clip_y)  &&
  1559.  (face->tvlist[2].y > max_clip_y)) ||
  1561. ((face->tvlist[0].x < min_clip_x)  && 
  1562.  (face->tvlist[1].x < min_clip_x)  &&
  1563.  (face->tvlist[2].x < min_clip_x)) ||
  1565. ((face->tvlist[0].x > max_clip_x)  && 
  1566.  (face->tvlist[1].x > max_clip_x)  &&
  1567.  (face->tvlist[2].x > max_clip_x)))
  1568.    return;
  1570. // degenerate triangle
  1571. if ( ((face->tvlist[0].x==face->tvlist[1].x) && (face->tvlist[1].x==face->tvlist[2].x)) ||
  1572.  ((face->tvlist[0].y==face->tvlist[1].y) && (face->tvlist[1].y==face->tvlist[2].y)))
  1573.    return;
  1575. // sort vertices
  1576. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  1577. {SWAP(v0,v1,temp);} 
  1579. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  1580. {SWAP(v0,v2,temp);}
  1582. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  1583. {SWAP(v1,v2,temp);}
  1585. // now test for trivial flat sided cases
  1586. if (face->tvlist[v0].y==face->tvlist[v1].y)
  1587. { 
  1588. // set triangle type
  1589. tri_type = TRI_TYPE_FLAT_TOP;
  1591. // sort vertices left to right
  1592. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  1593. {SWAP(v0,v1,temp);}
  1595. } // end if
  1596. else
  1597. // now test for trivial flat sided cases
  1598. if (face->tvlist[v1].y==face->tvlist[v2].y)
  1599. { 
  1600. // set triangle type
  1601. tri_type = TRI_TYPE_FLAT_BOTTOM;
  1603. // sort vertices left to right
  1604. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  1605. {SWAP(v1,v2,temp);}
  1607. } // end if
  1608. else
  1609. {
  1610. // must be a general triangle
  1611. tri_type = TRI_TYPE_GENERAL;
  1613. } // end else
  1615. // extract base color of lit poly, so we can modulate texture a bit
  1616. // for lighting
  1617. r_base = palette[face->lit_color[0]].peRed;
  1618. g_base = palette[face->lit_color[0]].peGreen;
  1619. b_base = palette[face->lit_color[0]].peBlue;
  1621. // build 4.4.4 intensity for color modulation
  1622. base_rgb444 = ( (b_base >> 4) + ((g_base >> 4) << 4) + ((r_base >> 4) << 8) );
  1624. // now find row in light table we will need for the r,g,b values on this polygon
  1625. lightrow444_8 = rgblightlookup[base_rgb444];
  1627. // extract vertices for processing, now that we have order
  1628. x0  = (int)(face->tvlist[v0].x+0.5);
  1629. y0  = (int)(face->tvlist[v0].y+0.5);
  1630. tu0 = (int)(face->tvlist[v0].u0);
  1631. tv0 = (int)(face->tvlist[v0].v0);
  1633. x1  = (int)(face->tvlist[v1].x+0.5);
  1634. y1  = (int)(face->tvlist[v1].y+0.5);
  1635. tu1 = (int)(face->tvlist[v1].u0);
  1636. tv1 = (int)(face->tvlist[v1].v0);
  1638. x2  = (int)(face->tvlist[v2].x+0.5);
  1639. y2  = (int)(face->tvlist[v2].y+0.5);
  1640. tu2 = (int)(face->tvlist[v2].u0);
  1641. tv2 = (int)(face->tvlist[v2].v0);
  1643. // set interpolation restart value
  1644. yrestart = y1;
  1646. // what kind of triangle
  1647. if (tri_type & TRI_TYPE_FLAT_MASK)
  1648. {
  1650. if (tri_type == TRI_TYPE_FLAT_TOP)
  1651. {
  1652. // compute all deltas
  1653. dy = (y2 - y0);
  1655. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  1656. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  1657. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  1659. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  1660. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  1661. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  1663. // test for y clipping
  1664. if (y0 < min_clip_y)
  1665. {
  1666. // compute overclip
  1667. dy = (min_clip_y - y0);
  1669. // computer new LHS starting values
  1670. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1671. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1672. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1674. // compute new RHS starting values
  1675. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  1676. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  1677. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  1679. // compute new starting y
  1680. ystart = min_clip_y;
  1682. } // end if
  1683. else
  1684. {
  1685. // no clipping
  1687. // set starting values
  1688. xl = (x0 << FIXP16_SHIFT);
  1689. xr = (x1 << FIXP16_SHIFT);
  1691. ul = (tu0 << FIXP16_SHIFT);
  1692. vl = (tv0 << FIXP16_SHIFT);
  1694. ur = (tu1 << FIXP16_SHIFT);
  1695. vr = (tv1 << FIXP16_SHIFT);
  1697. // set starting y
  1698. ystart = y0;
  1700. } // end else
  1702. } // end if flat top
  1703. else
  1704. {
  1705. // must be flat bottom
  1707. // compute all deltas
  1708. dy = (y1 - y0);
  1710. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  1711. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  1712. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  1714. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  1715. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  1716. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  1718. // test for y clipping
  1719. if (y0 < min_clip_y)
  1720. {
  1721. // compute overclip
  1722. dy = (min_clip_y - y0);
  1724. // computer new LHS starting values
  1725. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1726. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1727. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1729. // compute new RHS starting values
  1730. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  1731. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  1732. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  1734. // compute new starting y
  1735. ystart = min_clip_y;
  1737. } // end if
  1738. else
  1739. {
  1740. // no clipping
  1742. // set starting values
  1743. xl = (x0 << FIXP16_SHIFT);
  1744. xr = (x0 << FIXP16_SHIFT);
  1746. ul = (tu0 << FIXP16_SHIFT);
  1747. vl = (tv0 << FIXP16_SHIFT);
  1749. ur = (tu0 << FIXP16_SHIFT);
  1750. vr = (tv0 << FIXP16_SHIFT);
  1752. // set starting y
  1753. ystart = y0;
  1755. } // end else
  1757. } // end else flat bottom
  1759. // test for bottom clip, always
  1760. if ((yend = y2) > max_clip_y)
  1761. yend = max_clip_y;
  1763.     // test for horizontal clipping
  1764. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  1765. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  1766. (x2 < min_clip_x) || (x2 > max_clip_x))
  1767. {
  1768.     // clip version
  1770. // point screen ptr to starting line
  1771. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1773. for (yi = ystart; yi<=yend; yi++)
  1774. {
  1775. // compute span endpoints
  1776. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1777. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1779. // compute starting points for u,v interpolants
  1780. ui = ul + FIXP16_ROUND_UP;
  1781. vi = vl + FIXP16_ROUND_UP;
  1783. // compute u,v interpolants
  1784. if ((dx = (xend - xstart))>0)
  1785. {
  1786. du = (ur - ul)/dx;
  1787. dv = (vr - vl)/dx;
  1788. } // end if
  1789. else
  1790. {
  1791. du = (ur - ul);
  1792. dv = (vr - vl);
  1793. } // end else
  1795. ///////////////////////////////////////////////////////////////////////
  1797. // test for x clipping, LHS
  1798. if (xstart < min_clip_x)
  1799. {
  1800. // compute x overlap
  1801. dx = min_clip_x - xstart;
  1803. // slide interpolants over
  1804. ui+=dx*du;
  1805. vi+=dx*dv;
  1807. // reset vars
  1808. xstart = min_clip_x;
  1810. } // end if
  1812. // test for x clipping RHS
  1813. if (xend > max_clip_x)
  1814. xend = max_clip_x;
  1816. ///////////////////////////////////////////////////////////////////////
  1818. // draw span
  1819. for (xi=xstart; xi<=xend; xi++)
  1820. {
  1821. // write textel
  1822.             // get textel
  1823.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1824.             // modulate with base color via light table and write textel
  1825.             screen_ptr[xi] = lightrow444_8[textel];
  1827. // interpolate u,v
  1828. ui+=du;
  1829. vi+=dv;
  1830. } // end for xi
  1832. // interpolate u,v,x along right and left edge
  1833. xl+=dxdyl;
  1834. ul+=dudyl;
  1835. vl+=dvdyl;
  1837. xr+=dxdyr;
  1838. ur+=dudyr;
  1839. vr+=dvdyr;
  1840.  
  1841. // advance screen ptr
  1842. screen_ptr+=mem_pitch;
  1844. } // end for y
  1846. } // end if clip
  1847. else
  1848. {
  1849. // non-clip version
  1851. // point screen ptr to starting line
  1852. screen_ptr = dest_buffer + (ystart * mem_pitch);
  1854. for (yi = ystart; yi<=yend; yi++)
  1855. {
  1856. // compute span endpoints
  1857. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1858. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  1860. // compute starting points for u,v interpolants
  1861. ui = ul + FIXP16_ROUND_UP;
  1862. vi = vl + FIXP16_ROUND_UP;
  1864. // compute u,v interpolants
  1865. if ((dx = (xend - xstart))>0)
  1866. {
  1867. du = (ur - ul)/dx;
  1868. dv = (vr - vl)/dx;
  1869. } // end if
  1870. else
  1871. {
  1872. du = (ur - ul);
  1873. dv = (vr - vl);
  1874. } // end else
  1876. // draw span
  1877. for (xi=xstart; xi<=xend; xi++)
  1878. {
  1879. // write textel
  1880. // get textel
  1881.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  1882.             // modulate with base color via light table and write textel
  1883.             screen_ptr[xi] = lightrow444_8[textel];
  1885. // interpolate u,v
  1886. ui+=du;
  1887. vi+=dv;
  1888. } // end for xi
  1890. // interpolate u,v,x along right and left edge
  1891. xl+=dxdyl;
  1892. ul+=dudyl;
  1893. vl+=dvdyl;
  1895. xr+=dxdyr;
  1896. ur+=dudyr;
  1897. vr+=dvdyr;
  1899. // advance screen ptr
  1900. screen_ptr+=mem_pitch;
  1902. } // end for y
  1904. } // end if non-clipped
  1906. } // end if
  1907. else
  1908. if (tri_type==TRI_TYPE_GENERAL)
  1909. {
  1911. // first test for bottom clip, always
  1912. if ((yend = y2) > max_clip_y)
  1913. yend = max_clip_y;
  1915. // pre-test y clipping status
  1916. if (y1 < min_clip_y)
  1917. {
  1918. // compute all deltas
  1919. // LHS
  1920. dyl = (y2 - y1);
  1922. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  1923. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  1924. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  1926. // RHS
  1927. dyr = (y2 - y0);
  1929. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  1930. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1931. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1933. // compute overclip
  1934. dyr = (min_clip_y - y0);
  1935. dyl = (min_clip_y - y1);
  1937. // computer new LHS starting values
  1938. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  1939. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  1940. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  1942. // compute new RHS starting values
  1943. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  1944. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  1945. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  1947. // compute new starting y
  1948. ystart = min_clip_y;
  1950. // test if we need swap to keep rendering left to right
  1951. if (dxdyr > dxdyl)
  1952. {
  1953. SWAP(dxdyl,dxdyr,temp);
  1954. SWAP(dudyl,dudyr,temp);
  1955. SWAP(dvdyl,dvdyr,temp);
  1956. SWAP(xl,xr,temp);
  1957. SWAP(ul,ur,temp);
  1958. SWAP(vl,vr,temp);
  1959. SWAP(x1,x2,temp);
  1960. SWAP(y1,y2,temp);
  1961. SWAP(tu1,tu2,temp);
  1962. SWAP(tv1,tv2,temp);
  1964. // set interpolation restart
  1965. irestart = INTERP_RHS;
  1967. } // end if
  1969. } // end if
  1970. else
  1971. if (y0 < min_clip_y)
  1972. {
  1973. // compute all deltas
  1974. // LHS
  1975. dyl = (y1 - y0);
  1977. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  1978. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  1979. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  1981. // RHS
  1982. dyr = (y2 - y0);
  1984. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  1985. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  1986. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  1988. // compute overclip
  1989. dy = (min_clip_y - y0);
  1991. // computer new LHS starting values
  1992. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  1993. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  1994. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  1996. // compute new RHS starting values
  1997. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  1998. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  1999. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  2001. // compute new starting y
  2002. ystart = min_clip_y;
  2004. // test if we need swap to keep rendering left to right
  2005. if (dxdyr < dxdyl)
  2006. {
  2007. SWAP(dxdyl,dxdyr,temp);
  2008. SWAP(dudyl,dudyr,temp);
  2009. SWAP(dvdyl,dvdyr,temp);
  2010. SWAP(xl,xr,temp);
  2011. SWAP(ul,ur,temp);
  2012. SWAP(vl,vr,temp);
  2013. SWAP(x1,x2,temp);
  2014. SWAP(y1,y2,temp);
  2015. SWAP(tu1,tu2,temp);
  2016. SWAP(tv1,tv2,temp);
  2018. // set interpolation restart
  2019. irestart = INTERP_RHS;
  2021. } // end if
  2023. } // end if
  2024. else
  2025. {
  2026. // no initial y clipping
  2028. // compute all deltas
  2029. // LHS
  2030. dyl = (y1 - y0);
  2032. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  2033. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  2034. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  2036. // RHS
  2037. dyr = (y2 - y0);
  2039. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  2040. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2041. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2043. // no clipping y
  2045. // set starting values
  2046. xl = (x0 << FIXP16_SHIFT);
  2047. xr = (x0 << FIXP16_SHIFT);
  2049. ul = (tu0 << FIXP16_SHIFT);
  2050. vl = (tv0 << FIXP16_SHIFT);
  2052. ur = (tu0 << FIXP16_SHIFT);
  2053. vr = (tv0 << FIXP16_SHIFT);
  2055. // set starting y
  2056. ystart = y0;
  2058. // test if we need swap to keep rendering left to right
  2059. if (dxdyr < dxdyl)
  2060. {
  2061. SWAP(dxdyl,dxdyr,temp);
  2062. SWAP(dudyl,dudyr,temp);
  2063. SWAP(dvdyl,dvdyr,temp);
  2064. SWAP(xl,xr,temp);
  2065. SWAP(ul,ur,temp);
  2066. SWAP(vl,vr,temp);
  2067. SWAP(x1,x2,temp);
  2068. SWAP(y1,y2,temp);
  2069. SWAP(tu1,tu2,temp);
  2070. SWAP(tv1,tv2,temp);
  2072. // set interpolation restart
  2073. irestart = INTERP_RHS;
  2075. } // end if
  2077. } // end else
  2079.     // test for horizontal clipping
  2080. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  2081. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  2082. (x2 < min_clip_x) || (x2 > max_clip_x))
  2083. {
  2084.     // clip version
  2085. // x clipping
  2087. // point screen ptr to starting line
  2088. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2090. for (yi = ystart; yi<=yend; yi++)
  2091. {
  2092. // compute span endpoints
  2093. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2094. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2096. // compute starting points for u,v interpolants
  2097. ui = ul + FIXP16_ROUND_UP;
  2098. vi = vl + FIXP16_ROUND_UP;
  2100. // compute u,v interpolants
  2101. if ((dx = (xend - xstart))>0)
  2102. {
  2103. du = (ur - ul)/dx;
  2104. dv = (vr - vl)/dx;
  2105. } // end if
  2106. else
  2107. {
  2108. du = (ur - ul);
  2109. dv = (vr - vl);
  2110. } // end else
  2112. ///////////////////////////////////////////////////////////////////////
  2114. // test for x clipping, LHS
  2115. if (xstart < min_clip_x)
  2116. {
  2117. // compute x overlap
  2118. dx = min_clip_x - xstart;
  2120. // slide interpolants over
  2121. ui+=dx*du;
  2122. vi+=dx*dv;
  2124. // set x to left clip edge
  2125. xstart = min_clip_x;
  2127. } // end if
  2129. // test for x clipping RHS
  2130. if (xend > max_clip_x)
  2131. xend = max_clip_x;
  2133. ///////////////////////////////////////////////////////////////////////
  2135. // draw span
  2136. for (xi=xstart; xi<=xend; xi++)
  2137. {
  2138. // write textel
  2139.             // get textel
  2140.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2141.             // modulate with base color via light table and write textel
  2142.             screen_ptr[xi] = lightrow444_8[textel];
  2144. // interpolate u,v
  2145. ui+=du;
  2146. vi+=dv;
  2147. } // end for xi
  2149. // interpolate u,v,x along right and left edge
  2150. xl+=dxdyl;
  2151. ul+=dudyl;
  2152. vl+=dvdyl;
  2154. xr+=dxdyr;
  2155. ur+=dudyr;
  2156. vr+=dvdyr;
  2158. // advance screen ptr
  2159. screen_ptr+=mem_pitch;
  2161. // test for yi hitting second region, if so change interpolant
  2162. if (yi==yrestart)
  2163. {
  2165. // test interpolation side change flag
  2167. if (irestart == INTERP_LHS)
  2168. {
  2169. // LHS
  2170. dyl = (y2 - y1);
  2172. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  2173. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2174. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  2176. // set starting values
  2177. xl = (x1  << FIXP16_SHIFT);
  2178. ul = (tu1 << FIXP16_SHIFT);
  2179. vl = (tv1 << FIXP16_SHIFT);
  2181. // interpolate down on LHS to even up
  2182. xl+=dxdyl;
  2183. ul+=dudyl;
  2184. vl+=dvdyl;
  2185. } // end if
  2186. else
  2187. {
  2188. // RHS
  2189. dyr = (y1 - y2);
  2191. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  2192. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  2193. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  2195. // set starting values
  2196. xr = (x2  << FIXP16_SHIFT);
  2197. ur = (tu2 << FIXP16_SHIFT);
  2198. vr = (tv2 << FIXP16_SHIFT);
  2200. // interpolate down on RHS to even up
  2201. xr+=dxdyr;
  2202. ur+=dudyr;
  2203. vr+=dvdyr;
  2205. } // end else
  2208. } // end if
  2210. } // end for y
  2212. } // end if
  2213. else
  2214. {
  2215. // no x clipping
  2216. // point screen ptr to starting line
  2217. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2219. for (yi = ystart; yi<=yend; yi++)
  2220. {
  2221. // compute span endpoints
  2222. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2223. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2225. // compute starting points for u,v interpolants
  2226. ui = ul + FIXP16_ROUND_UP;
  2227. vi = vl + FIXP16_ROUND_UP;
  2229. // compute u,v interpolants
  2230. if ((dx = (xend - xstart))>0)
  2232. {
  2233. du = (ur - ul)/dx;
  2234. dv = (vr - vl)/dx;
  2235. } // end if
  2236. else
  2237. {
  2238. du = (ur - ul);
  2239. dv = (vr - vl);
  2240. } // end else
  2242. // draw span
  2243. for (xi=xstart; xi<=xend; xi++)
  2244. {
  2245. // write textel
  2246.             // get textel
  2247.             textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2248.             // modulate with base color via light table and write textel
  2249.             screen_ptr[xi] = lightrow444_8[textel];
  2251. // interpolate u,v
  2252. ui+=du;
  2253. vi+=dv;
  2254. } // end for xi
  2256. // interpolate u,v,x along right and left edge
  2257. xl+=dxdyl;
  2258. ul+=dudyl;
  2259. vl+=dvdyl;
  2261. xr+=dxdyr;
  2262. ur+=dudyr;
  2263. vr+=dvdyr;
  2265. // advance screen ptr
  2266. screen_ptr+=mem_pitch;
  2268. // test for yi hitting second region, if so change interpolant
  2269. if (yi==yrestart)
  2270. {
  2271. // test interpolation side change flag
  2273. if (irestart == INTERP_LHS)
  2274. {
  2275. // LHS
  2276. dyl = (y2 - y1);
  2278. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  2279. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2280. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  2282. // set starting values
  2283. xl = (x1  << FIXP16_SHIFT);
  2284. ul = (tu1 << FIXP16_SHIFT);
  2285. vl = (tv1 << FIXP16_SHIFT);
  2287. // interpolate down on LHS to even up
  2288. xl+=dxdyl;
  2289. ul+=dudyl;
  2290. vl+=dvdyl;
  2291. } // end if
  2292. else
  2293. {
  2294. // RHS
  2295. dyr = (y1 - y2);
  2297. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  2298. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  2299. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  2301. // set starting values
  2302. xr = (x2  << FIXP16_SHIFT);
  2303. ur = (tu2 << FIXP16_SHIFT);
  2304. vr = (tv2 << FIXP16_SHIFT);
  2306. // interpolate down on RHS to even up
  2307. xr+=dxdyr;
  2308. ur+=dudyr;
  2309. vr+=dvdyr;
  2311. } // end else
  2313. } // end if
  2315. } // end for y
  2317. } // end else
  2319. } // end if
  2321. } // end Draw_Textured_TriangleFS
  2323. /////////////////////////////////////////////////////////////
  2325. void Draw_Textured_Triangle16(POLYF4DV2_PTR face,   // ptr to face
  2326.                               UCHAR *_dest_buffer,   // pointer to video buffer
  2327.                               int mem_pitch)        // bytes per line, 320, 640 etc.
  2328. {
  2329. // this function draws a textured triangle in 16-bit mode
  2331. int v0=0,
  2332.     v1=1,
  2333. v2=2,
  2334. temp=0,
  2335. tri_type = TRI_TYPE_NONE,
  2336. irestart = INTERP_LHS;
  2338. int dx,dy,dyl,dyr,      // general deltas
  2339.     u,v,
  2340.     du,dv,
  2341.     xi,yi,              // the current interpolated x,y
  2342. ui,vi,              // the current interpolated u,v
  2343. index_x,index_y,    // looping vars
  2344. x,y,                // hold general x,y
  2345. xstart,
  2346. xend,
  2347. ystart,
  2348. yrestart,
  2349. yend,
  2350. xl,                 
  2351. dxdyl,              
  2352. xr,
  2353. dxdyr,             
  2354. dudyl,    
  2355. ul,
  2356. dvdyl,   
  2357. vl,
  2358. dudyr,
  2359. ur,
  2360. dvdyr,
  2361. vr;
  2363. int x0,y0,tu0,tv0,    // cached vertices
  2364. x1,y1,tu1,tv1,
  2365. x2,y2,tu2,tv2;
  2367. USHORT *screen_ptr  = NULL,
  2368.    *screen_line = NULL,
  2369.    *textmap     = NULL,
  2370.        *dest_buffer = (USHORT *)_dest_buffer;
  2372. #ifdef DEBUG_ON
  2373. // track rendering stats
  2374.     debug_polys_rendered_per_frame++;
  2375. #endif
  2377. // extract texture map
  2378. textmap = (USHORT *)face->texture->buffer;
  2380. // extract base 2 of texture width
  2381. int texture_shift2 = logbase2ofx[face->texture->width];
  2383. // adjust memory pitch to words, divide by 2
  2384. mem_pitch >>=1;
  2386. // first trivial clipping rejection tests 
  2387. if (((face->tvlist[0].y < min_clip_y)  && 
  2388.  (face->tvlist[1].y < min_clip_y)  &&
  2389.  (face->tvlist[2].y < min_clip_y)) ||
  2391. ((face->tvlist[0].y > max_clip_y)  && 
  2392.  (face->tvlist[1].y > max_clip_y)  &&
  2393.  (face->tvlist[2].y > max_clip_y)) ||
  2395. ((face->tvlist[0].x < min_clip_x)  && 
  2396.  (face->tvlist[1].x < min_clip_x)  &&
  2397.  (face->tvlist[2].x < min_clip_x)) ||
  2399. ((face->tvlist[0].x > max_clip_x)  && 
  2400.  (face->tvlist[1].x > max_clip_x)  &&
  2401.  (face->tvlist[2].x > max_clip_x)))
  2402.    return;
  2404. // degenerate triangle
  2405. if ( ((face->tvlist[0].x==face->tvlist[1].x) && (face->tvlist[1].x==face->tvlist[2].x)) ||
  2406.  ((face->tvlist[0].y==face->tvlist[1].y) && (face->tvlist[1].y==face->tvlist[2].y)))
  2407.    return;
  2409. // sort vertices
  2410. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  2411. {SWAP(v0,v1,temp);} 
  2413. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  2414. {SWAP(v0,v2,temp);}
  2416. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  2417. {SWAP(v1,v2,temp);}
  2419. // now test for trivial flat sided cases
  2420. if (face->tvlist[v0].y==face->tvlist[v1].y)
  2421. { 
  2422. // set triangle type
  2423. tri_type = TRI_TYPE_FLAT_TOP;
  2425. // sort vertices left to right
  2426. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  2427. {SWAP(v0,v1,temp);}
  2429. } // end if
  2430. else
  2431. // now test for trivial flat sided cases
  2432. if (face->tvlist[v1].y==face->tvlist[v2].y)
  2433. { 
  2434. // set triangle type
  2435. tri_type = TRI_TYPE_FLAT_BOTTOM;
  2437. // sort vertices left to right
  2438. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  2439. {SWAP(v1,v2,temp);}
  2441. } // end if
  2442. else
  2443. {
  2444. // must be a general triangle
  2445. tri_type = TRI_TYPE_GENERAL;
  2447. } // end else
  2449. // extract vertices for processing, now that we have order
  2450. x0  = (int)(face->tvlist[v0].x+0.5);
  2451. y0  = (int)(face->tvlist[v0].y+0.5);
  2452. tu0 = (int)(face->tvlist[v0].u0);
  2453. tv0 = (int)(face->tvlist[v0].v0);
  2455. x1  = (int)(face->tvlist[v1].x+0.5);
  2456. y1  = (int)(face->tvlist[v1].y+0.5);
  2457. tu1 = (int)(face->tvlist[v1].u0);
  2458. tv1 = (int)(face->tvlist[v1].v0);
  2460. x2  = (int)(face->tvlist[v2].x+0.5);
  2461. y2  = (int)(face->tvlist[v2].y+0.5);
  2462. tu2 = (int)(face->tvlist[v2].u0);
  2463. tv2 = (int)(face->tvlist[v2].v0);
  2465. // set interpolation restart value
  2466. yrestart = y1;
  2468. // what kind of triangle
  2469. if (tri_type & TRI_TYPE_FLAT_MASK)
  2470. {
  2472. if (tri_type == TRI_TYPE_FLAT_TOP)
  2473. {
  2474. // compute all deltas
  2475. dy = (y2 - y0);
  2477. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  2478. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  2479. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  2481. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  2482. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  2483. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  2485. // test for y clipping
  2486. if (y0 < min_clip_y)
  2487. {
  2488. // compute overclip
  2489. dy = (min_clip_y - y0);
  2491. // computer new LHS starting values
  2492. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  2493. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  2494. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  2496. // compute new RHS starting values
  2497. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  2498. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  2499. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  2501. // compute new starting y
  2502. ystart = min_clip_y;
  2504. } // end if
  2505. else
  2506. {
  2507. // no clipping
  2509. // set starting values
  2510. xl = (x0 << FIXP16_SHIFT);
  2511. xr = (x1 << FIXP16_SHIFT);
  2513. ul = (tu0 << FIXP16_SHIFT);
  2514. vl = (tv0 << FIXP16_SHIFT);
  2516. ur = (tu1 << FIXP16_SHIFT);
  2517. vr = (tv1 << FIXP16_SHIFT);
  2519. // set starting y
  2520. ystart = y0;
  2522. } // end else
  2524. } // end if flat top
  2525. else
  2526. {
  2527. // must be flat bottom
  2529. // compute all deltas
  2530. dy = (y1 - y0);
  2532. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  2533. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  2534. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  2536. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  2537. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  2538. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  2540. // test for y clipping
  2541. if (y0 < min_clip_y)
  2542. {
  2543. // compute overclip
  2544. dy = (min_clip_y - y0);
  2546. // computer new LHS starting values
  2547. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  2548. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  2549. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  2551. // compute new RHS starting values
  2552. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  2553. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  2554. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  2556. // compute new starting y
  2557. ystart = min_clip_y;
  2559. } // end if
  2560. else
  2561. {
  2562. // no clipping
  2564. // set starting values
  2565. xl = (x0 << FIXP16_SHIFT);
  2566. xr = (x0 << FIXP16_SHIFT);
  2568. ul = (tu0 << FIXP16_SHIFT);
  2569. vl = (tv0 << FIXP16_SHIFT);
  2571. ur = (tu0 << FIXP16_SHIFT);
  2572. vr = (tv0 << FIXP16_SHIFT);
  2574. // set starting y
  2575. ystart = y0;
  2577. } // end else
  2579. } // end else flat bottom
  2581. // test for bottom clip, always
  2582. if ((yend = y2) > max_clip_y)
  2583. yend = max_clip_y;
  2585.     // test for horizontal clipping
  2586. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  2587. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  2588. (x2 < min_clip_x) || (x2 > max_clip_x))
  2589. {
  2590.     // clip version
  2592. // point screen ptr to starting line
  2593. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2595. for (yi = ystart; yi<=yend; yi++)
  2596. {
  2597. // compute span endpoints
  2598. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2599. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2601. // compute starting points for u,v interpolants
  2602. ui = ul + FIXP16_ROUND_UP;
  2603. vi = vl + FIXP16_ROUND_UP;
  2605. // compute u,v interpolants
  2606. if ((dx = (xend - xstart))>0)
  2607. {
  2608. du = (ur - ul)/dx;
  2609. dv = (vr - vl)/dx;
  2610. } // end if
  2611. else
  2612. {
  2613. du = (ur - ul);
  2614. dv = (vr - vl);
  2615. } // end else
  2617. ///////////////////////////////////////////////////////////////////////
  2619. // test for x clipping, LHS
  2620. if (xstart < min_clip_x)
  2621. {
  2622. // compute x overlap
  2623. dx = min_clip_x - xstart;
  2625. // slide interpolants over
  2626. ui+=dx*du;
  2627. vi+=dx*dv;
  2629. // reset vars
  2630. xstart = min_clip_x;
  2632. } // end if
  2634. // test for x clipping RHS
  2635. if (xend > max_clip_x)
  2636. xend = max_clip_x;
  2638. ///////////////////////////////////////////////////////////////////////
  2640. // draw span
  2641. for (xi=xstart; xi<=xend; xi++)
  2642. {
  2643. // write textel
  2644.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2646. // interpolate u,v
  2647. ui+=du;
  2648. vi+=dv;
  2649. } // end for xi
  2651. // interpolate u,v,x along right and left edge
  2652. xl+=dxdyl;
  2653. ul+=dudyl;
  2654. vl+=dvdyl;
  2656. xr+=dxdyr;
  2657. ur+=dudyr;
  2658. vr+=dvdyr;
  2659.  
  2660. // advance screen ptr
  2661. screen_ptr+=mem_pitch;
  2663. } // end for y
  2665. } // end if clip
  2666. else
  2667. {
  2668. // non-clip version
  2670. // point screen ptr to starting line
  2671. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2673. for (yi = ystart; yi<=yend; yi++)
  2674. {
  2675. // compute span endpoints
  2676. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2677. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2679. // compute starting points for u,v interpolants
  2680. ui = ul + FIXP16_ROUND_UP;
  2681. vi = vl + FIXP16_ROUND_UP;
  2683. // compute u,v interpolants
  2684. if ((dx = (xend - xstart))>0)
  2685. {
  2686. du = (ur - ul)/dx;
  2687. dv = (vr - vl)/dx;
  2688. } // end if
  2689. else
  2690. {
  2691. du = (ur - ul);
  2692. dv = (vr - vl);
  2693. } // end else
  2695. // draw span
  2696. for (xi=xstart; xi<=xend; xi++)
  2697. {
  2698. // write textel
  2699.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) +  ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2701. // interpolate u,v
  2702. ui+=du;
  2703. vi+=dv;
  2704. } // end for xi
  2706. // interpolate u,v,x along right and left edge
  2707. xl+=dxdyl;
  2708. ul+=dudyl;
  2709. vl+=dvdyl;
  2711. xr+=dxdyr;
  2712. ur+=dudyr;
  2713. vr+=dvdyr;
  2715. // advance screen ptr
  2716. screen_ptr+=mem_pitch;
  2718. } // end for y
  2720. } // end if non-clipped
  2722. } // end if
  2723. else
  2724. if (tri_type==TRI_TYPE_GENERAL)
  2725. {
  2727. // first test for bottom clip, always
  2728. if ((yend = y2) > max_clip_y)
  2729. yend = max_clip_y;
  2731. // pre-test y clipping status
  2732. if (y1 < min_clip_y)
  2733. {
  2734. // compute all deltas
  2735. // LHS
  2736. dyl = (y2 - y1);
  2738. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  2739. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2740. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  2742. // RHS
  2743. dyr = (y2 - y0);
  2745. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  2746. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2747. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2749. // compute overclip
  2750. dyr = (min_clip_y - y0);
  2751. dyl = (min_clip_y - y1);
  2753. // computer new LHS starting values
  2754. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  2755. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  2756. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  2758. // compute new RHS starting values
  2759. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  2760. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  2761. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  2763. // compute new starting y
  2764. ystart = min_clip_y;
  2766. // test if we need swap to keep rendering left to right
  2767. if (dxdyr > dxdyl)
  2768. {
  2769. SWAP(dxdyl,dxdyr,temp);
  2770. SWAP(dudyl,dudyr,temp);
  2771. SWAP(dvdyl,dvdyr,temp);
  2772. SWAP(xl,xr,temp);
  2773. SWAP(ul,ur,temp);
  2774. SWAP(vl,vr,temp);
  2775. SWAP(x1,x2,temp);
  2776. SWAP(y1,y2,temp);
  2777. SWAP(tu1,tu2,temp);
  2778. SWAP(tv1,tv2,temp);
  2780. // set interpolation restart
  2781. irestart = INTERP_RHS;
  2783. } // end if
  2785. } // end if
  2786. else
  2787. if (y0 < min_clip_y)
  2788. {
  2789. // compute all deltas
  2790. // LHS
  2791. dyl = (y1 - y0);
  2793. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  2794. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  2795. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  2797. // RHS
  2798. dyr = (y2 - y0);
  2800. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  2801. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2802. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2804. // compute overclip
  2805. dy = (min_clip_y - y0);
  2807. // computer new LHS starting values
  2808. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  2809. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  2810. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  2812. // compute new RHS starting values
  2813. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  2814. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  2815. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  2817. // compute new starting y
  2818. ystart = min_clip_y;
  2820. // test if we need swap to keep rendering left to right
  2821. if (dxdyr < dxdyl)
  2822. {
  2823. SWAP(dxdyl,dxdyr,temp);
  2824. SWAP(dudyl,dudyr,temp);
  2825. SWAP(dvdyl,dvdyr,temp);
  2826. SWAP(xl,xr,temp);
  2827. SWAP(ul,ur,temp);
  2828. SWAP(vl,vr,temp);
  2829. SWAP(x1,x2,temp);
  2830. SWAP(y1,y2,temp);
  2831. SWAP(tu1,tu2,temp);
  2832. SWAP(tv1,tv2,temp);
  2834. // set interpolation restart
  2835. irestart = INTERP_RHS;
  2837. } // end if
  2839. } // end if
  2840. else
  2841. {
  2842. // no initial y clipping
  2844. // compute all deltas
  2845. // LHS
  2846. dyl = (y1 - y0);
  2848. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  2849. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  2850. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  2852. // RHS
  2853. dyr = (y2 - y0);
  2855. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  2856. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  2857. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  2859. // no clipping y
  2861. // set starting values
  2862. xl = (x0 << FIXP16_SHIFT);
  2863. xr = (x0 << FIXP16_SHIFT);
  2865. ul = (tu0 << FIXP16_SHIFT);
  2866. vl = (tv0 << FIXP16_SHIFT);
  2868. ur = (tu0 << FIXP16_SHIFT);
  2869. vr = (tv0 << FIXP16_SHIFT);
  2871. // set starting y
  2872. ystart = y0;
  2874. // test if we need swap to keep rendering left to right
  2875. if (dxdyr < dxdyl)
  2876. {
  2877. SWAP(dxdyl,dxdyr,temp);
  2878. SWAP(dudyl,dudyr,temp);
  2879. SWAP(dvdyl,dvdyr,temp);
  2880. SWAP(xl,xr,temp);
  2881. SWAP(ul,ur,temp);
  2882. SWAP(vl,vr,temp);
  2883. SWAP(x1,x2,temp);
  2884. SWAP(y1,y2,temp);
  2885. SWAP(tu1,tu2,temp);
  2886. SWAP(tv1,tv2,temp);
  2888. // set interpolation restart
  2889. irestart = INTERP_RHS;
  2891. } // end if
  2893. } // end else
  2896.     // test for horizontal clipping
  2897. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  2898. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  2899. (x2 < min_clip_x) || (x2 > max_clip_x))
  2900. {
  2901.     // clip version
  2902. // x clipping
  2904. // point screen ptr to starting line
  2905. screen_ptr = dest_buffer + (ystart * mem_pitch);
  2907. for (yi = ystart; yi<=yend; yi++)
  2908. {
  2909. // compute span endpoints
  2910. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2911. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  2913. // compute starting points for u,v interpolants
  2914. ui = ul + FIXP16_ROUND_UP;
  2915. vi = vl + FIXP16_ROUND_UP;
  2917. // compute u,v interpolants
  2918. if ((dx = (xend - xstart))>0)
  2919. {
  2920. du = (ur - ul)/dx;
  2921. dv = (vr - vl)/dx;
  2922. } // end if
  2923. else
  2924. {
  2925. du = (ur - ul);
  2926. dv = (vr - vl);
  2927. } // end else
  2929. ///////////////////////////////////////////////////////////////////////
  2931. // test for x clipping, LHS
  2932. if (xstart < min_clip_x)
  2933. {
  2934. // compute x overlap
  2935. dx = min_clip_x - xstart;
  2937. // slide interpolants over
  2938. ui+=dx*du;
  2939. vi+=dx*dv;
  2941. // set x to left clip edge
  2942. xstart = min_clip_x;
  2944. } // end if
  2946. // test for x clipping RHS
  2947. if (xend > max_clip_x)
  2948. xend = max_clip_x;
  2950. ///////////////////////////////////////////////////////////////////////
  2952. // draw span
  2953. for (xi=xstart; xi<=xend; xi++)
  2954. {
  2955. // write textel
  2956.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  2958. // interpolate u,v
  2959. ui+=du;
  2960. vi+=dv;
  2961. } // end for xi
  2963. // interpolate u,v,x along right and left edge
  2964. xl+=dxdyl;
  2965. ul+=dudyl;
  2966. vl+=dvdyl;
  2968. xr+=dxdyr;
  2969. ur+=dudyr;
  2970. vr+=dvdyr;
  2972. // advance screen ptr
  2973. screen_ptr+=mem_pitch;
  2975. // test for yi hitting second region, if so change interpolant
  2976. if (yi==yrestart)
  2977. {
  2979. // test interpolation side change flag
  2981. if (irestart == INTERP_LHS)
  2982. {
  2983. // LHS
  2984. dyl = (y2 - y1);
  2986. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  2987. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  2988. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  2990. // set starting values
  2991. xl = (x1  << FIXP16_SHIFT);
  2992. ul = (tu1 << FIXP16_SHIFT);
  2993. vl = (tv1 << FIXP16_SHIFT);
  2995. // interpolate down on LHS to even up
  2996. xl+=dxdyl;
  2997. ul+=dudyl;
  2998. vl+=dvdyl;
  2999. } // end if
  3000. else
  3001. {
  3002. // RHS
  3003. dyr = (y1 - y2);
  3005. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  3006. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  3007. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  3009. // set starting values
  3010. xr = (x2  << FIXP16_SHIFT);
  3011. ur = (tu2 << FIXP16_SHIFT);
  3012. vr = (tv2 << FIXP16_SHIFT);
  3014. // interpolate down on RHS to even up
  3015. xr+=dxdyr;
  3016. ur+=dudyr;
  3017. vr+=dvdyr;
  3019. } // end else
  3022. } // end if
  3024. } // end for y
  3026. } // end if
  3027. else
  3028. {
  3029. // no x clipping
  3030. // point screen ptr to starting line
  3031. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3033. for (yi = ystart; yi<=yend; yi++)
  3034. {
  3035. // compute span endpoints
  3036. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3037. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3039. // compute starting points for u,v interpolants
  3040. ui = ul + FIXP16_ROUND_UP;
  3041. vi = vl + FIXP16_ROUND_UP;
  3043. // compute u,v interpolants
  3044. if ((dx = (xend - xstart))>0)
  3046. {
  3047. du = (ur - ul)/dx;
  3048. dv = (vr - vl)/dx;
  3049. } // end if
  3050. else
  3051. {
  3052. du = (ur - ul);
  3053. dv = (vr - vl);
  3054. } // end else
  3056. // draw span
  3057. for (xi=xstart; xi<=xend; xi++)
  3058. {
  3059. // write textel
  3060.             screen_ptr[xi] = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3062. // interpolate u,v
  3063. ui+=du;
  3064. vi+=dv;
  3065. } // end for xi
  3067. // interpolate u,v,x along right and left edge
  3068. xl+=dxdyl;
  3069. ul+=dudyl;
  3070. vl+=dvdyl;
  3072. xr+=dxdyr;
  3073. ur+=dudyr;
  3074. vr+=dvdyr;
  3076. // advance screen ptr
  3077. screen_ptr+=mem_pitch;
  3079. // test for yi hitting second region, if so change interpolant
  3080. if (yi==yrestart)
  3081. {
  3082. // test interpolation side change flag
  3084. if (irestart == INTERP_LHS)
  3085. {
  3086. // LHS
  3087. dyl = (y2 - y1);
  3089. dxdyl = ((x2 - x1)   << FIXP16_SHIFT)/dyl;
  3090. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  3091. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;   
  3093. // set starting values
  3094. xl = (x1  << FIXP16_SHIFT);
  3095. ul = (tu1 << FIXP16_SHIFT);
  3096. vl = (tv1 << FIXP16_SHIFT);
  3098. // interpolate down on LHS to even up
  3099. xl+=dxdyl;
  3100. ul+=dudyl;
  3101. vl+=dvdyl;
  3102. } // end if
  3103. else
  3104. {
  3105. // RHS
  3106. dyr = (y1 - y2);
  3108. dxdyr = ((x1 - x2)   << FIXP16_SHIFT)/dyr;
  3109. dudyr = ((tu1 - tu2) << FIXP16_SHIFT)/dyr;  
  3110. dvdyr = ((tv1 - tv2) << FIXP16_SHIFT)/dyr;   
  3112. // set starting values
  3113. xr = (x2  << FIXP16_SHIFT);
  3114. ur = (tu2 << FIXP16_SHIFT);
  3115. vr = (tv2 << FIXP16_SHIFT);
  3117. // interpolate down on RHS to even up
  3118. xr+=dxdyr;
  3119. ur+=dudyr;
  3120. vr+=dvdyr;
  3122. } // end else
  3124. } // end if
  3126. } // end for y
  3128.    } // end else
  3130. } // end if
  3132. } // end Draw_Textured_Triangle16
  3134. ///////////////////////////////////////////////////////////////////////////////
  3136. void Draw_Textured_TriangleFS16(POLYF4DV2_PTR face,   // ptr to face
  3137.                               UCHAR *_dest_buffer,   // pointer to video buffer
  3138.                               int mem_pitch)        // bytes per line, 320, 640 etc.
  3139. {
  3140. // this function draws a textured triangle in 16-bit mode with flat shading
  3142. int v0=0,
  3143.     v1=1,
  3144. v2=2,
  3145. temp=0,
  3146. tri_type = TRI_TYPE_NONE,
  3147. irestart = INTERP_LHS;
  3149. int dx,dy,dyl,dyr,      // general deltas
  3150.     u,v,
  3151.     du,dv,
  3152.     xi,yi,              // the current interpolated x,y
  3153. ui,vi,              // the current interpolated u,v
  3154. index_x,index_y,    // looping vars
  3155. x,y,                // hold general x,y
  3156. xstart,
  3157. xend,
  3158. ystart,
  3159. yrestart,
  3160. yend,
  3161. xl,                 
  3162. dxdyl,              
  3163. xr,
  3164. dxdyr,             
  3165. dudyl,    
  3166. ul,
  3167. dvdyl,   
  3168. vl,
  3169. dudyr,
  3170. ur,
  3171. dvdyr,
  3172. vr;
  3174. USHORT r_base, g_base, b_base,
  3175.        r_textel, g_textel, b_textel, textel;
  3177. int x0,y0,tu0,tv0,    // cached vertices
  3178. x1,y1,tu1,tv1,
  3179. x2,y2,tu2,tv2;
  3181. USHORT *screen_ptr  = NULL,
  3182.    *screen_line = NULL,
  3183.    *textmap     = NULL,
  3184.        *dest_buffer = (USHORT *)_dest_buffer;
  3186. #ifdef DEBUG_ON
  3187. // track rendering stats
  3188.     debug_polys_rendered_per_frame++;
  3189. #endif
  3191. // extract texture map
  3192. textmap = (USHORT *)face->texture->buffer;
  3194. // extract base 2 of texture width
  3195. int texture_shift2 = logbase2ofx[face->texture->width];
  3197. // adjust memory pitch to words, divide by 2
  3198. mem_pitch >>=1;
  3200. // first trivial clipping rejection tests 
  3201. if (((face->tvlist[0].y < min_clip_y)  && 
  3202.  (face->tvlist[1].y < min_clip_y)  &&
  3203.  (face->tvlist[2].y < min_clip_y)) ||
  3205. ((face->tvlist[0].y > max_clip_y)  && 
  3206.  (face->tvlist[1].y > max_clip_y)  &&
  3207.  (face->tvlist[2].y > max_clip_y)) ||
  3209. ((face->tvlist[0].x < min_clip_x)  && 
  3210.  (face->tvlist[1].x < min_clip_x)  &&
  3211.  (face->tvlist[2].x < min_clip_x)) ||
  3213. ((face->tvlist[0].x > max_clip_x)  && 
  3214.  (face->tvlist[1].x > max_clip_x)  &&
  3215.  (face->tvlist[2].x > max_clip_x)))
  3216.    return;
  3218. // degenerate triangle
  3219. if ( ((face->tvlist[0].x==face->tvlist[1].x) && (face->tvlist[1].x==face->tvlist[2].x)) ||
  3220.  ((face->tvlist[0].y==face->tvlist[1].y) && (face->tvlist[1].y==face->tvlist[2].y)))
  3221.    return;
  3223. // sort vertices
  3224. if (face->tvlist[v1].y < face->tvlist[v0].y) 
  3225. {SWAP(v0,v1,temp);} 
  3227. if (face->tvlist[v2].y < face->tvlist[v0].y) 
  3228. {SWAP(v0,v2,temp);}
  3230. if (face->tvlist[v2].y < face->tvlist[v1].y) 
  3231. {SWAP(v1,v2,temp);}
  3233. // now test for trivial flat sided cases
  3234. if (face->tvlist[v0].y==face->tvlist[v1].y)
  3235. { 
  3236. // set triangle type
  3237. tri_type = TRI_TYPE_FLAT_TOP;
  3239. // sort vertices left to right
  3240. if (face->tvlist[v1].x < face->tvlist[v0].x) 
  3241. {SWAP(v0,v1,temp);}
  3243. } // end if
  3244. else
  3245. // now test for trivial flat sided cases
  3246. if (face->tvlist[v1].y==face->tvlist[v2].y)
  3247. { 
  3248. // set triangle type
  3249. tri_type = TRI_TYPE_FLAT_BOTTOM;
  3251. // sort vertices left to right
  3252. if (face->tvlist[v2].x < face->tvlist[v1].x) 
  3253. {SWAP(v1,v2,temp);}
  3255. } // end if
  3256. else
  3257. {
  3258. // must be a general triangle
  3259. tri_type = TRI_TYPE_GENERAL;
  3261. } // end else
  3263. // extract base color of lit poly, so we can modulate texture a bit
  3264. // for lighting
  3265. _RGB565FROM16BIT(face->lit_color[0], &r_base, &g_base, &b_base);
  3267. // extract vertices for processing, now that we have order
  3268. x0  = (int)(face->tvlist[v0].x+0.5);
  3269. y0  = (int)(face->tvlist[v0].y+0.5);
  3270. tu0 = (int)(face->tvlist[v0].u0);
  3271. tv0 = (int)(face->tvlist[v0].v0);
  3273. x1  = (int)(face->tvlist[v1].x+0.5);
  3274. y1  = (int)(face->tvlist[v1].y+0.5);
  3275. tu1 = (int)(face->tvlist[v1].u0);
  3276. tv1 = (int)(face->tvlist[v1].v0);
  3278. x2  = (int)(face->tvlist[v2].x+0.5);
  3279. y2  = (int)(face->tvlist[v2].y+0.5);
  3280. tu2 = (int)(face->tvlist[v2].u0);
  3281. tv2 = (int)(face->tvlist[v2].v0);
  3283. // set interpolation restart value
  3284. yrestart = y1;
  3286. // what kind of triangle
  3287. if (tri_type & TRI_TYPE_FLAT_MASK)
  3288. {
  3290. if (tri_type == TRI_TYPE_FLAT_TOP)
  3291. {
  3292. // compute all deltas
  3293. dy = (y2 - y0);
  3295. dxdyl = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  3296. dudyl = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  3297. dvdyl = ((tv2 - tv0) << FIXP16_SHIFT)/dy;    
  3299. dxdyr = ((x2 - x1)   << FIXP16_SHIFT)/dy;
  3300. dudyr = ((tu2 - tu1) << FIXP16_SHIFT)/dy;  
  3301. dvdyr = ((tv2 - tv1) << FIXP16_SHIFT)/dy;   
  3303. // test for y clipping
  3304. if (y0 < min_clip_y)
  3305. {
  3306. // compute overclip
  3307. dy = (min_clip_y - y0);
  3309. // computer new LHS starting values
  3310. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  3311. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  3312. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  3314. // compute new RHS starting values
  3315. xr = dxdyr*dy + (x1  << FIXP16_SHIFT);
  3316. ur = dudyr*dy + (tu1 << FIXP16_SHIFT);
  3317. vr = dvdyr*dy + (tv1 << FIXP16_SHIFT);
  3319. // compute new starting y
  3320. ystart = min_clip_y;
  3322. } // end if
  3323. else
  3324. {
  3325. // no clipping
  3327. // set starting values
  3328. xl = (x0 << FIXP16_SHIFT);
  3329. xr = (x1 << FIXP16_SHIFT);
  3331. ul = (tu0 << FIXP16_SHIFT);
  3332. vl = (tv0 << FIXP16_SHIFT);
  3334. ur = (tu1 << FIXP16_SHIFT);
  3335. vr = (tv1 << FIXP16_SHIFT);
  3337. // set starting y
  3338. ystart = y0;
  3340. } // end else
  3342. } // end if flat top
  3343. else
  3344. {
  3345. // must be flat bottom
  3347. // compute all deltas
  3348. dy = (y1 - y0);
  3350. dxdyl = ((x1 - x0)   << FIXP16_SHIFT)/dy;
  3351. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dy;  
  3352. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dy;    
  3354. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dy;
  3355. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dy;  
  3356. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dy;   
  3358. // test for y clipping
  3359. if (y0 < min_clip_y)
  3360. {
  3361. // compute overclip
  3362. dy = (min_clip_y - y0);
  3364. // computer new LHS starting values
  3365. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  3366. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  3367. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  3369. // compute new RHS starting values
  3370. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  3371. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  3372. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  3374. // compute new starting y
  3375. ystart = min_clip_y;
  3377. } // end if
  3378. else
  3379. {
  3380. // no clipping
  3382. // set starting values
  3383. xl = (x0 << FIXP16_SHIFT);
  3384. xr = (x0 << FIXP16_SHIFT);
  3386. ul = (tu0 << FIXP16_SHIFT);
  3387. vl = (tv0 << FIXP16_SHIFT);
  3389. ur = (tu0 << FIXP16_SHIFT);
  3390. vr = (tv0 << FIXP16_SHIFT);
  3392. // set starting y
  3393. ystart = y0;
  3395. } // end else
  3397. } // end else flat bottom
  3399. // test for bottom clip, always
  3400. if ((yend = y2) > max_clip_y)
  3401. yend = max_clip_y;
  3403.     // test for horizontal clipping
  3404. if ((x0 < min_clip_x) || (x0 > max_clip_x) ||
  3405. (x1 < min_clip_x) || (x1 > max_clip_x) ||
  3406. (x2 < min_clip_x) || (x2 > max_clip_x))
  3407. {
  3408.     // clip version
  3410. // point screen ptr to starting line
  3411. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3413. for (yi = ystart; yi<=yend; yi++)
  3414. {
  3415. // compute span endpoints
  3416. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3417. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3419. // compute starting points for u,v interpolants
  3420. ui = ul + FIXP16_ROUND_UP;
  3421. vi = vl + FIXP16_ROUND_UP;
  3423. // compute u,v interpolants
  3424. if ((dx = (xend - xstart))>0)
  3425. {
  3426. du = (ur - ul)/dx;
  3427. dv = (vr - vl)/dx;
  3428. } // end if
  3429. else
  3430. {
  3431. du = (ur - ul);
  3432. dv = (vr - vl);
  3433. } // end else
  3435. ///////////////////////////////////////////////////////////////////////
  3437. // test for x clipping, LHS
  3438. if (xstart < min_clip_x)
  3439. {
  3440. // compute x overlap
  3441. dx = min_clip_x - xstart;
  3443. // slide interpolants over
  3444. ui+=dx*du;
  3445. vi+=dx*dv;
  3447. // reset vars
  3448. xstart = min_clip_x;
  3450. } // end if
  3452. // test for x clipping RHS
  3453. if (xend > max_clip_x)
  3454. xend = max_clip_x;
  3456. ///////////////////////////////////////////////////////////////////////
  3458. // draw span
  3459. for (xi=xstart; xi<=xend; xi++)
  3460. {
  3461. // write textel
  3462.     // get textel first
  3463.   textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3465.             // extract rgb components
  3466.             r_textel  = ((textel >> 11)       ); 
  3467.             g_textel  = ((textel >> 5)  & 0x3f); 
  3468.             b_textel =   (textel        & 0x1f);
  3470.             // modulate textel with lit background color
  3471.             r_textel*=r_base; 
  3472.             g_textel*=g_base;
  3473.             b_textel*=b_base;
  3475.             // finally write pixel, note that we did the math such that the results are r*32, g*64, b*32
  3476.             // hence we need to divide the results by 32,64,32 respetively, BUT since we need to shift
  3477.             // the results to fit into the destination 5.6.5 word, we can take advantage of the shifts
  3478.             // and they all cancel out for the most part, but we will need logical anding, we will do
  3479.             // it later when we optimize more...
  3480.             screen_ptr[xi] = ((b_textel >> 5) + ((g_textel >> 6) << 5) + ((r_textel >> 5) << 11));
  3482. // interpolate u,v
  3483. ui+=du;
  3484. vi+=dv;
  3485. } // end for xi
  3487. // interpolate u,v,x along right and left edge
  3488. xl+=dxdyl;
  3489. ul+=dudyl;
  3490. vl+=dvdyl;
  3492. xr+=dxdyr;
  3493. ur+=dudyr;
  3494. vr+=dvdyr;
  3495.  
  3496. // advance screen ptr
  3497. screen_ptr+=mem_pitch;
  3499. } // end for y
  3501. } // end if clip
  3502. else
  3503. {
  3504. // non-clip version
  3506. // point screen ptr to starting line
  3507. screen_ptr = dest_buffer + (ystart * mem_pitch);
  3509. for (yi = ystart; yi<=yend; yi++)
  3510. {
  3511. // compute span endpoints
  3512. xstart = ((xl + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3513. xend   = ((xr + FIXP16_ROUND_UP) >> FIXP16_SHIFT);
  3515. // compute starting points for u,v interpolants
  3516. ui = ul + FIXP16_ROUND_UP;
  3517. vi = vl + FIXP16_ROUND_UP;
  3519. // compute u,v interpolants
  3520. if ((dx = (xend - xstart))>0)
  3521. {
  3522. du = (ur - ul)/dx;
  3523. dv = (vr - vl)/dx;
  3524. } // end if
  3525. else
  3526. {
  3527. du = (ur - ul);
  3528. dv = (vr - vl);
  3529. } // end else
  3531. // draw span
  3532. for (xi=xstart; xi<=xend; xi++)
  3533. {
  3534. // write textel
  3535.     // get textel first
  3536.   textel = textmap[(ui >> FIXP16_SHIFT) + ((vi >> FIXP16_SHIFT) << texture_shift2)];
  3538.             // extract rgb components
  3539.             r_textel  = ((textel >> 11)       ); 
  3540.             g_textel  = ((textel >> 5)  & 0x3f); 
  3541.             b_textel =   (textel        & 0x1f);
  3543.             // modulate textel with lit background color
  3544.             r_textel*=r_base; 
  3545.             g_textel*=g_base;
  3546.             b_textel*=b_base;
  3548.             // finally write pixel, note that we did the math such that the results are r*32, g*64, b*32
  3549.             // hence we need to divide the results by 32,64,32 respetively, BUT since we need to shift
  3550.             // the results to fit into the destination 5.6.5 word, we can take advantage of the shifts
  3551.             // and they all cancel out for the most part, but we will need logical anding, we will do
  3552.             // it later when we optimize more...
  3553.             screen_ptr[xi] = ((b_textel >> 5) + ((g_textel >> 6) << 5) + ((r_textel >> 5) << 11));
  3555. // interpolate u,v
  3556. ui+=du;
  3557. vi+=dv;
  3558. } // end for xi
  3560. // interpolate u,v,x along right and left edge
  3561. xl+=dxdyl;
  3562. ul+=dudyl;
  3563. vl+=dvdyl;
  3565. xr+=dxdyr;
  3566. ur+=dudyr;
  3567. vr+=dvdyr;
  3569. // advance screen ptr
  3570. screen_ptr+=mem_pitch;
  3572. } // end for y
  3574. } // end if non-clipped
  3576. } // end if
  3577. else
  3578. if (tri_type==TRI_TYPE_GENERAL)
  3579. {
  3581. // first test for bottom clip, always
  3582. if ((yend = y2) > max_clip_y)
  3583. yend = max_clip_y;
  3585. // pre-test y clipping status
  3586. if (y1 < min_clip_y)
  3587. {
  3588. // compute all deltas
  3589. // LHS
  3590. dyl = (y2 - y1);
  3592. dxdyl = ((x2  - x1)  << FIXP16_SHIFT)/dyl;
  3593. dudyl = ((tu2 - tu1) << FIXP16_SHIFT)/dyl;  
  3594. dvdyl = ((tv2 - tv1) << FIXP16_SHIFT)/dyl;    
  3596. // RHS
  3597. dyr = (y2 - y0);
  3599. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  3600. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  3601. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  3603. // compute overclip
  3604. dyr = (min_clip_y - y0);
  3605. dyl = (min_clip_y - y1);
  3607. // computer new LHS starting values
  3608. xl = dxdyl*dyl + (x1  << FIXP16_SHIFT);
  3609. ul = dudyl*dyl + (tu1 << FIXP16_SHIFT);
  3610. vl = dvdyl*dyl + (tv1 << FIXP16_SHIFT);
  3612. // compute new RHS starting values
  3613. xr = dxdyr*dyr + (x0  << FIXP16_SHIFT);
  3614. ur = dudyr*dyr + (tu0 << FIXP16_SHIFT);
  3615. vr = dvdyr*dyr + (tv0 << FIXP16_SHIFT);
  3617. // compute new starting y
  3618. ystart = min_clip_y;
  3620. // test if we need swap to keep rendering left to right
  3621. if (dxdyr > dxdyl)
  3622. {
  3623. SWAP(dxdyl,dxdyr,temp);
  3624. SWAP(dudyl,dudyr,temp);
  3625. SWAP(dvdyl,dvdyr,temp);
  3626. SWAP(xl,xr,temp);
  3627. SWAP(ul,ur,temp);
  3628. SWAP(vl,vr,temp);
  3629. SWAP(x1,x2,temp);
  3630. SWAP(y1,y2,temp);
  3631. SWAP(tu1,tu2,temp);
  3632. SWAP(tv1,tv2,temp);
  3634. // set interpolation restart
  3635. irestart = INTERP_RHS;
  3637. } // end if
  3639. } // end if
  3640. else
  3641. if (y0 < min_clip_y)
  3642. {
  3643. // compute all deltas
  3644. // LHS
  3645. dyl = (y1 - y0);
  3647. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  3648. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  3649. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  3651. // RHS
  3652. dyr = (y2 - y0);
  3654. dxdyr = ((x2  - x0)  << FIXP16_SHIFT)/dyr;
  3655. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  3656. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  3658. // compute overclip
  3659. dy = (min_clip_y - y0);
  3661. // computer new LHS starting values
  3662. xl = dxdyl*dy + (x0  << FIXP16_SHIFT);
  3663. ul = dudyl*dy + (tu0 << FIXP16_SHIFT);
  3664. vl = dvdyl*dy + (tv0 << FIXP16_SHIFT);
  3666. // compute new RHS starting values
  3667. xr = dxdyr*dy + (x0  << FIXP16_SHIFT);
  3668. ur = dudyr*dy + (tu0 << FIXP16_SHIFT);
  3669. vr = dvdyr*dy + (tv0 << FIXP16_SHIFT);
  3671. // compute new starting y
  3672. ystart = min_clip_y;
  3674. // test if we need swap to keep rendering left to right
  3675. if (dxdyr < dxdyl)
  3676. {
  3677. SWAP(dxdyl,dxdyr,temp);
  3678. SWAP(dudyl,dudyr,temp);
  3679. SWAP(dvdyl,dvdyr,temp);
  3680. SWAP(xl,xr,temp);
  3681. SWAP(ul,ur,temp);
  3682. SWAP(vl,vr,temp);
  3683. SWAP(x1,x2,temp);
  3684. SWAP(y1,y2,temp);
  3685. SWAP(tu1,tu2,temp);
  3686. SWAP(tv1,tv2,temp);
  3688. // set interpolation restart
  3689. irestart = INTERP_RHS;
  3691. } // end if
  3693. } // end if
  3694. else
  3695. {
  3696. // no initial y clipping
  3698. // compute all deltas
  3699. // LHS
  3700. dyl = (y1 - y0);
  3702. dxdyl = ((x1  - x0)  << FIXP16_SHIFT)/dyl;
  3703. dudyl = ((tu1 - tu0) << FIXP16_SHIFT)/dyl;  
  3704. dvdyl = ((tv1 - tv0) << FIXP16_SHIFT)/dyl;    
  3706. // RHS
  3707. dyr = (y2 - y0);
  3709. dxdyr = ((x2 - x0)   << FIXP16_SHIFT)/dyr;
  3710. dudyr = ((tu2 - tu0) << FIXP16_SHIFT)/dyr;  
  3711. dvdyr = ((tv2 - tv0) << FIXP16_SHIFT)/dyr;   
  3713. // no clipping y
  3715. // set starting values
  3716. xl = (x0 << FIXP16_SHIFT);
  3717. xr = (x0 << FIXP16_SHIFT);
  3719. ul = (tu0 << FIXP16_SHIFT);
  3720. vl = (tv0 << FIXP16_SHIFT);
  3722. ur = (tu0 << FIXP16_SHIFT);
  3723. vr = (tv0 << FIXP16_SHIFT);