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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
EngBcub.cpp
资源名称：RayTracing Code.rar　[点击查看]
上传用户：lhwx1029
上传日期：2013-03-07
资源大小：1173k
文件大小：20k
源码类别：

3D图形编程

开发平台：

Visual C++

EngBcub.cpp：源码内容
  1. /** 3DGPL *************************************************
  2.  * ()                                                     *
  3.  * Functions for bicubic patches.                         *
  4.  *                                                        *
  5.  * Ifdefs:                                                *
  6.  *  _CI_                     Colour/Intensity model;      *
  7.  *  _RGB_                    RGB model;                   *
  8.  *  _Z_BUFFER_               Depth array;                 *
  9.  *  _PAINTER_                Back to front rendering.     *
  10.  *                                                        *
  11.  * Defines:                                               *
  12.  *  M_init_bicubic           Allocate structure elements; *
  13.  *  M_shade_bicubic          Compute shading intensities; *
  14.  *  M_render_bicubic         Rendering as set of polygons;*
  15.  *  M_init_bicubic_object    Every patch in the object;   *
  16.  *  M_shade_bicubic_object   Shade the patches;           *
  17.  *  M_render_bicubic_object  Rendering as set of patches. *
  18.  *                                                        *
  19.  * Internals:                                             *
  20.  *  MI_render_square         Single square of the patch;  *
  21.  *  MI_find_bezier_points    Finding points on the curve; *
  22.  *  MI_find_bezier_tangents  Finding the tengents.        *
  23.  *                                                        *
  24.  * (c) 1995-98 Sergei Savchenko, (savs@cs.mcgill.ca)      *
  25. **********************************************************/
  27. #include "Graphics.h"           /* 2-D rendering */
  28. #include "Trans.h"                 /* 3-D transformations */
  29. #include "Clipper.h"             /* 2-D/3-D clipping */
  30. #include "Engine.h"               /* 3-D engine */
  31. #include <stdlib.h>                         /* NULL */
  33. #if defined(_CI_)
  34. int M_square_v[20]=                         /* static data for a square */
  35. {
  36.  2,0,0,0,
  37.  3,0,0,0,
  38.  1,0,0,0,
  39.  0,0,0,0,
  40.  2,0,0,0
  41. };
  42. struct M_polygon M_square={M_QUAD_XY,0,
  43.                            0,
  44.                            0,NULL,4,M_square_v,NULL
  45.                           };
  46. #endif
  47. #if defined(_RGB_)
  48. int M_square_v[30]=                         /* static data for a square */
  49. {
  50.  2,0,0,0,0,0,
  51.  3,0,0,0,0,0,
  52.  1,0,0,0,0,0,
  53.  0,0,0,0,0,0,
  54.  2,0,0,0,0,0
  55. };
  56. struct M_polygon M_square={M_QUAD_XY,0,
  57.                            0,0,0,
  58.                            0,NULL,4,M_square_v,NULL
  59.                           };
  60. #endif
  62. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  63.  * INTERNAL: Rendering a single square of tesselated     *
  64.  * --------- bicubic.                                    *
  65. * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  67. void MI_render_square(int no1,int no2,int* vertices,int *intensities,
  68.                       int *textures
  69.                      )
  70. {
  71.  int tmp_vert[T_LNG_VECTOR*4];              /* X Y Z */
  72.  int tmp_colr[CL_LNG_COLOUR*4];             /* intensity or R G B */
  73.  int tmp_texture[8];                        /* Tx Ty */
  75.  HW_copy_int(vertices+no1*T_LNG_VECTOR,tmp_vert,T_LNG_VECTOR*2);
  76.  HW_copy_int(vertices+no2*T_LNG_VECTOR,tmp_vert+T_LNG_VECTOR*2,T_LNG_VECTOR*2);
  77.                                             /* getting rid of fractions */
  78.  tmp_vert[0]>>=M_PB; tmp_vert[1]>>=M_PB; tmp_vert[2]>>=M_PB;
  79.  tmp_vert[4]>>=M_PB; tmp_vert[5]>>=M_PB; tmp_vert[6]>>=M_PB;
  80.  tmp_vert[8]>>=M_PB; tmp_vert[9]>>=M_PB; tmp_vert[10]>>=M_PB;
  81.  tmp_vert[12]>>=M_PB; tmp_vert[13]>>=M_PB; tmp_vert[14]>>=M_PB;
  83.  if(intensities!=NULL)
  84.  {
  85.   HW_copy_int(intensities+no1*CL_LNG_COLOUR,tmp_colr,CL_LNG_COLOUR*2);
  86.   HW_copy_int(intensities+no2*CL_LNG_COLOUR,tmp_colr+CL_LNG_COLOUR*2,CL_LNG_COLOUR*2);
  87.   HW_copy_int(textures+no1*2,tmp_texture,4);
  88.   HW_copy_int(textures+no2*2,tmp_texture+4,4);
  89.  }
  91. #if defined(_CI_)
  92.  M_square.m_intensity=tmp_colr[0];
  93. #endif
  94. #if defined(_RGB_)
  95.  M_square.m_red=tmp_colr[0];
  96.  M_square.m_green=tmp_colr[1];
  97.  M_square.m_blue=tmp_colr[2];
  98. #endif
  100.  M_render_polygon(&M_square,tmp_vert,tmp_colr,tmp_texture);
  101. }
  103. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  104.  * INTERNAL: Filling an array with the coordinates of    *
  105.  * --------- points on the Bezier curve cpecified        *
  106.  *           through its controls b1,...,b4.             *
  107.  *                                                       *
  108.  * RECURSIVE: Calls itself twice.                        *
  109.  * ----------                                            *
  110. * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  112. void MI_evaluate_bezier_points(int *b1,int *b2,int *b3,int *b4,
  113.                               int *points,int dimension,int length,int top,
  114.                               int rendering
  115.                              )
  116. {
  117.  int b12[T_LNG_VECTOR],b23[T_LNG_VECTOR],b34[T_LNG_VECTOR];
  118.  int b123[T_LNG_VECTOR],b234[T_LNG_VECTOR],*b1234;
  120.  if(top)                                    /* during top level call */
  121.  {
  122.   if(rendering)
  123.   {                                         /* increasing precision */
  124.    b1[0]<<=M_PB; b1[1]<<=M_PB; b1[2]<<=M_PB;/* by adding fractional bits */
  125.    b2[0]<<=M_PB; b2[1]<<=M_PB; b2[2]<<=M_PB;
  126.    b3[0]<<=M_PB; b3[1]<<=M_PB; b3[2]<<=M_PB;
  127.    b4[0]<<=M_PB; b4[1]<<=M_PB; b4[2]<<=M_PB;
  128.   }
  129.   HW_copy_int(b1,points,3);                 /* setting border values */
  130.   HW_copy_int(b4,points+(length-1)*dimension,3);
  131.  }
  133.  if(length>2)
  134.  {
  135.   b1234=points+(length/2)*dimension;
  137.   b12[0]=(b1[0]+b2[0])/2; b12[1]=(b1[1]+b2[1])/2; b12[2]=(b1[2]+b2[2])/2;
  138.   b23[0]=(b2[0]+b3[0])/2; b23[1]=(b2[1]+b3[1])/2; b23[2]=(b2[2]+b3[2])/2;
  139.   b34[0]=(b3[0]+b4[0])/2; b34[1]=(b3[1]+b4[1])/2; b34[2]=(b3[2]+b4[2])/2;
  141.   b123[0]=(b12[0]+b23[0])/2; b123[1]=(b12[1]+b23[1])/2; b123[2]=(b12[2]+b23[2])/2;
  142.   b234[0]=(b23[0]+b34[0])/2; b234[1]=(b23[1]+b34[1])/2; b234[2]=(b23[2]+b34[2])/2;
  144.   b1234[0]=(b123[0]+b234[0])/2;
  145.   b1234[1]=(b123[1]+b234[1])/2;
  146.   b1234[2]=(b123[2]+b234[2])/2;
  148.   MI_evaluate_bezier_points(b1,b12,b123,b1234,points,dimension,length/2+1,0,rendering);
  149.   MI_evaluate_bezier_points(b1234,b234,b34,b4,b1234,dimension,length/2+1,0,rendering);
  150.  }
  151. }
  153. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  154.  * INTERNAL: Filling an array with the tangents of the   *
  155.  * --------- Bezier curve cpecified through its          *
  156.  *           controls b1,...,b4.                         *
  157.  *                                                       *
  158.  * RECURSIVE: Calls itself twice.                        *
  159.  * ----------                                            *
  160. * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  162. void MI_evaluate_bezier_tangents(int *b1,int *b2,int *b3,int *b4,
  163.                                  int *tangents,int dimension,int length,int top
  164.                                 )
  165. {
  166.  int b12[T_LNG_VECTOR],b23[T_LNG_VECTOR],b34[T_LNG_VECTOR];
  167.  int b123[T_LNG_VECTOR],b234[T_LNG_VECTOR],b1234[T_LNG_VECTOR],*mid;
  169.  if(top)                                    /* during top level call */
  170.  {
  171.   T_vector(b1,b2,tangents,3);               /* setting border values */
  172.   T_vector(b3,b4,tangents+(length-1)*dimension,3);
  173.  }
  175.  if(length>2)
  176.  {
  177.   mid=tangents+(length/2)*dimension;
  179.   b12[0]=(b1[0]+b2[0])/2; b12[1]=(b1[1]+b2[1])/2; b12[2]=(b1[2]+b2[2])/2;
  180.   b23[0]=(b2[0]+b3[0])/2; b23[1]=(b2[1]+b3[1])/2; b23[2]=(b2[2]+b3[2])/2;
  181.   b34[0]=(b3[0]+b4[0])/2; b34[1]=(b3[1]+b4[1])/2; b34[2]=(b3[2]+b4[2])/2;
  183.   b123[0]=(b12[0]+b23[0])/2; b123[1]=(b12[1]+b23[1])/2; b123[2]=(b12[2]+b23[2])/2;
  184.   b234[0]=(b23[0]+b34[0])/2; b234[1]=(b23[1]+b34[1])/2; b234[2]=(b23[2]+b34[2])/2;
  186.   T_vector(b123,b234,mid,3);
  188.   b1234[0]=(b123[0]+b234[0])/2;
  189.   b1234[1]=(b123[1]+b234[1])/2;
  190.   b1234[2]=(b123[2]+b234[2])/2;
  192.   MI_evaluate_bezier_tangents(b1,b12,b123,b1234,tangents,dimension,length/2+1,0);
  193.   MI_evaluate_bezier_tangents(b1234,b234,b34,b4,mid,dimension,length/2+1,0);
  194.  }
  195. }
  197. /**********************************************************
  198.  * Allocating the intensity table based on the foreseen   *
  199.  * number of polygons into which the patch will be        *
  200.  * tesselated.                                            *
  201. **********************************************************/
  203. void M_init_bicubic(struct M_bicubic *bicubic)
  204. {
  205.  int tangents1[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  206.  int tangents2[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  207.  int tmpb1[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  208.  int tmpb2[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  209.  int tmpb3[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  210.  int tmpb4[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  211.  int *c=bicubic->m_controls;
  212.  int i,size=(1<<bicubic->m_log_render_size)+1;
  214.  if(size>=M_MAX_RENDER_SIZE)
  215.   HW_error("(Engine) Can't subdivide a bicubic this much.n");
  217.  bicubic->m_normals=(int*)malloc(sizeof(int)*T_LNG_VECTOR*size*size);
  218.  bicubic->m_intensities=(int*)malloc(sizeof(int)*CL_LNG_COLOUR*size*size);
  219.  if((bicubic->m_normals==NULL)||(bicubic->m_intensities==NULL))
  220.   HW_error("(Engine) Not enough memory.n");
  222.  MI_evaluate_bezier_points(c,c+T_LNG_VECTOR,c+T_LNG_VECTOR*2,
  223.                            c+T_LNG_VECTOR*3,tmpb1,T_LNG_VECTOR,size,1,0
  224.                           );
  225.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*4,c+T_LNG_VECTOR*5,c+T_LNG_VECTOR*6,
  226.                            c+T_LNG_VECTOR*7,tmpb2,T_LNG_VECTOR,size,1,0
  227.                           );
  228.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*8,c+T_LNG_VECTOR*9,c+T_LNG_VECTOR*10,
  229.                            c+T_LNG_VECTOR*11,tmpb3,T_LNG_VECTOR,size,1,0
  230.                           );
  231.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*12,c+T_LNG_VECTOR*13,c+T_LNG_VECTOR*14,
  232.                            c+T_LNG_VECTOR*15,tmpb4,T_LNG_VECTOR,size,1,0
  233.                           );
  235.  for(i=0;i<size;i++)
  236.   MI_evaluate_bezier_tangents(tmpb1+i*T_LNG_VECTOR,tmpb2+i*T_LNG_VECTOR,
  237.                               tmpb3+i*T_LNG_VECTOR,tmpb4+i*T_LNG_VECTOR,
  238.                               tangents1+i*T_LNG_VECTOR,T_LNG_VECTOR*size,size,1
  239.                              );
  241.  MI_evaluate_bezier_points(c,c+T_LNG_VECTOR*4,c+T_LNG_VECTOR*8,
  242.                            c+T_LNG_VECTOR*12,tmpb1,T_LNG_VECTOR,size,1,0
  243.                           );
  244.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*1,c+T_LNG_VECTOR*5,c+T_LNG_VECTOR*9,
  245.                            c+T_LNG_VECTOR*13,tmpb2,T_LNG_VECTOR,size,1,0
  246.                           );
  247.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*2,c+T_LNG_VECTOR*6,c+T_LNG_VECTOR*10,
  248.                            c+T_LNG_VECTOR*14,tmpb3,T_LNG_VECTOR,size,1,0
  249.                           );
  250.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*3,c+T_LNG_VECTOR*7,c+T_LNG_VECTOR*11,
  251.                            c+T_LNG_VECTOR*15,tmpb4,T_LNG_VECTOR,size,1,0
  252.                           );
  254.  for(i=0;i<size;i++)
  255.   MI_evaluate_bezier_tangents(tmpb1+i*T_LNG_VECTOR,tmpb2+i*T_LNG_VECTOR,
  256.                               tmpb3+i*T_LNG_VECTOR,tmpb4+i*T_LNG_VECTOR,
  257.                               tangents2+i*size*T_LNG_VECTOR,T_LNG_VECTOR,size,1
  258.                              );
  260.  for(i=0;i<size*size;i++)
  261.   T_normal_vectors(tangents1+i*T_LNG_VECTOR,tangents2+i*T_LNG_VECTOR,
  262.                   bicubic->m_normals+i*T_LNG_VECTOR
  263.                  );
  264. }
  266. /**********************************************************
  267.  * Using precomputed normals to shade the bicubic         *
  268. **********************************************************/
  270. void M_shade_bicubic(struct M_bicubic *bicubic,
  271.                      int x,int y,int z,
  272.                      int alp,int bet,int gam,
  273.                      int no_lights,struct M_light **lights
  274.                     )
  275. {
  276.  int c[16*T_LNG_VECTOR];
  277.  int points[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  278.  int normals[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  279.  int tmpb1[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  280.  int tmpb2[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  281.  int tmpb3[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  282.  int tmpb4[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  283.  int *intensity,*position,*normal;
  284.  int i,size=(1<<bicubic->m_log_render_size)+1;
  286.  if(size>M_MAX_RENDER_SIZE)
  287.   HW_error("(Engine) Can't subdivide a bicubic this much.n");
  289.  T_set_self_rotation(alp,bet,gam);          /* shading happens in world space */
  290.  T_self_rotation(bicubic->m_normals,normals,size*size);
  291.  T_self_rotation(bicubic->m_controls,c,16);
  292.  T_translation(c,c,16,x,y,z);
  294.  MI_evaluate_bezier_points(c,c+T_LNG_VECTOR*4,c+T_LNG_VECTOR*8,
  295.                            c+T_LNG_VECTOR*12,tmpb1,T_LNG_VECTOR,size,1,0
  296.                           );
  297.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*1,c+T_LNG_VECTOR*5,c+T_LNG_VECTOR*9,
  298.                            c+T_LNG_VECTOR*13,tmpb2,T_LNG_VECTOR,size,1,0
  299.                           );
  300.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*2,c+T_LNG_VECTOR*6,c+T_LNG_VECTOR*10,
  301.                            c+T_LNG_VECTOR*14,tmpb3,T_LNG_VECTOR,size,1,0
  302.                           );
  303.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*3,c+T_LNG_VECTOR*7,c+T_LNG_VECTOR*11,
  304.                            c+T_LNG_VECTOR*15,tmpb4,T_LNG_VECTOR,size,1,0
  305.                           );
  307.  for(i=0;i<size;i++)
  308.   MI_evaluate_bezier_points(tmpb1+i*T_LNG_VECTOR,tmpb2+i*T_LNG_VECTOR,
  309.                             tmpb3+i*T_LNG_VECTOR,tmpb4+i*T_LNG_VECTOR,
  310.                             points+i*size*T_LNG_VECTOR,T_LNG_VECTOR,size,1,0
  311.                            );
  313.  intensity=bicubic->m_intensities;
  314.  position=points;
  315.  normal=normals;
  316.  for(i=0;i<size*size;i++)
  317.  {
  318.   M_shade_vertex(intensity,position,normal,
  319.                  no_lights,lights
  320.                 );
  321.   intensity+=CL_LNG_COLOUR;
  322.   position+=T_LNG_VECTOR;
  323.   normal+=T_LNG_VECTOR;
  324.  }
  325. }
  327. /**********************************************************
  328.  * Rendering a bicubic by tesselating it into polygons.   *
  329. **********************************************************/
  331. void M_render_bicubic(struct M_bicubic *bicubic,
  332.                       int x,int y,int z,
  333.                       int alp,int bet,int gam
  334.                      )
  335. {
  336.  int c[16*T_LNG_VECTOR];
  337.  int points[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  338.  int textures[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE*2];
  339.  int numbers[M_MAX_RENDER_SIZE*M_MAX_RENDER_SIZE];
  340.  int tmpb1[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  341.  int tmpb2[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  342.  int tmpb3[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  343.  int tmpb4[M_MAX_RENDER_SIZE*T_LNG_VECTOR];
  344.  int *texture,incr,cur_x,cur_y,max;
  345.  int i,j,size=(1<<bicubic->m_log_render_size)+1;
  347.  if(size>M_MAX_RENDER_SIZE)
  348.   HW_error("(Engine) Can't subdivide a bicubic this much.n");
  350.  T_set_self_rotation(alp,bet,gam);          /* the transformations */
  351.  T_cancatinate_self_world(x+M_camera_x,y+M_camera_y,z+M_camera_z);
  352.  T_cancatinated_rotation(bicubic->m_controls,c,16);
  354.  incr=bicubic->m_log_texture_space_size-bicubic->m_log_render_size;
  356.  if(incr<=0) HW_error("(Engine) Too small a texture to fit onto a bicubic.n");
  358.  M_square.m_colour=bicubic->m_colour;
  359.  M_square.m_log_texture_space_size=incr;
  360.  M_square.m_texture=bicubic->m_texture;     /* transfer info to a square */
  362.  incr=1<<incr;
  363.  max=1<<bicubic->m_log_texture_space_size;
  364.  texture=textures;
  365.  for(i=0,cur_y=max;i<size;i++,cur_y-=incr)  /* building a set of texture */
  366.  {                                          /* coordinates */
  367.   for(j=0,cur_x=0;j<size;j++,cur_x+=incr)
  368.   {
  369.    *texture++=cur_x;
  370.    *texture++=cur_y;
  371.   }
  372.  }
  374.  MI_evaluate_bezier_points(c,c+T_LNG_VECTOR*4,c+T_LNG_VECTOR*8,
  375.                            c+T_LNG_VECTOR*12,tmpb1,T_LNG_VECTOR,size,1,1
  376.                           );
  377.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*1,c+T_LNG_VECTOR*5,c+T_LNG_VECTOR*9,
  378.                            c+T_LNG_VECTOR*13,tmpb2,T_LNG_VECTOR,size,1,1
  379.                           );
  380.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*2,c+T_LNG_VECTOR*6,c+T_LNG_VECTOR*10,
  381.                            c+T_LNG_VECTOR*14,tmpb3,T_LNG_VECTOR,size,1,1
  382.                           );
  383.  MI_evaluate_bezier_points(c+T_LNG_VECTOR*3,c+T_LNG_VECTOR*7,c+T_LNG_VECTOR*11,
  384.                            c+T_LNG_VECTOR*15,tmpb4,T_LNG_VECTOR,size,1,1
  385.                           );
  387.  for(i=0;i<size;i++)                        /* tesselating the bicubic */
  388.   MI_evaluate_bezier_points(tmpb1+i*T_LNG_VECTOR,tmpb2+i*T_LNG_VECTOR,
  389.                             tmpb3+i*T_LNG_VECTOR,tmpb4+i*T_LNG_VECTOR,
  390.                             points+i*size*T_LNG_VECTOR,T_LNG_VECTOR,size,1,0
  391.                           );                /* beware 0 at the end - */
  392.                                             /* precision increased just once */
  393.  for(i=0;i<size*size;i++) numbers[i]=i;     /* prepare for sorting */
  395. #if defined(_PAINTER_)
  396.  M_sort_elements(points+2,T_LNG_VECTOR,numbers,size*size);
  397. #endif
  399.  for(i=0;i<size*size;i++)                   /* rendering back to front */
  400.   if((numbers[i]%size!=size-1)&&(numbers[i]/size!=size-1))
  401.    MI_render_square(numbers[i],numbers[i]+size,points,bicubic->m_intensities,textures);
  402. }
  404. /**********************************************************
  405.  * Initializing all patches in the object, computing      *
  406.  * approximate centres of the patches.                    *
  407. **********************************************************/
  409. void M_init_bicubic_object(struct M_bicubic_object *object)
  410. {
  411.  int i,j;
  413.  object->m_centres=(int*)malloc(sizeof(int)*T_LNG_VECTOR*object->m_no_patches);
  414.  if(object->m_centres==NULL)
  415.   HW_error("(Engine) Not enough memory.n");
  417.  for(i=0;i<object->m_no_patches;i++)
  418.  {
  419.   M_init_bicubic(object->m_patches[i]);
  421.   object->m_centres[i*T_LNG_VECTOR]=0;
  422.   object->m_centres[i*T_LNG_VECTOR+1]=0;
  423.   object->m_centres[i*T_LNG_VECTOR+2]=0;
  424.   for(j=0;j<16;j++)
  425.   {
  426.    object->m_centres[i*T_LNG_VECTOR]+=object->m_patches[i]->m_controls[j*T_LNG_VECTOR];
  427.    object->m_centres[i*T_LNG_VECTOR+1]+=object->m_patches[i]->m_controls[j*T_LNG_VECTOR+1];
  428.    object->m_centres[i*T_LNG_VECTOR+2]+=object->m_patches[i]->m_controls[j*T_LNG_VECTOR+2];
  429.   }
  430.   object->m_centres[i*T_LNG_VECTOR]/=16;
  431.   object->m_centres[i*T_LNG_VECTOR+1]/=16;
  432.   object->m_centres[i*T_LNG_VECTOR+2]/=16;
  433.  }
  434. }
  436. /**********************************************************
  437.  * Shading all patches in the object.                     *
  438. **********************************************************/
  440. void M_shade_bicubic_object(struct M_bicubic_object *object,
  441.                             int x,int y,int z,
  442.                             int alp,int bet,int gam,
  443.                             int no_lights,struct M_light **lights
  444.                            )
  445. {
  446.  int i;
  448.  for(i=0;i<object->m_no_patches;i++)
  449.   M_shade_bicubic(object->m_patches[i],x,y,z,alp,bet,gam,no_lights,lights);
  450. }
  452. /**********************************************************
  453.  * Rendering all patches. In the case of _PAINTER_        *
  454.  * performing sorting of the patches centres first and    *
  455.  * rendering in the back to front order.                  *
  456. **********************************************************/
  458. void M_render_bicubic_object(struct M_bicubic_object *object,
  459.                              int x,int y,int z,
  460.                              int alp,int bet,int gam
  461.                             )
  462. {
  463.  int i;
  464. #if defined(_PAINTER_)
  465.  int centres[M_MAX_PATCHES*T_LNG_VECTOR];
  466. #endif
  467.  int numbers[M_MAX_PATCHES];
  468.  int oldtmap=M_force_linear_tmapping;
  469.  M_force_linear_tmapping=1;                 /* polygons will be small enough */
  471.  if(object->m_no_patches>M_MAX_PATCHES)
  472.   HW_error("(Engine) Too many bicubic patches per object.n");
  474.  for(i=0;i<object->m_no_patches;i++) numbers[i]=i;
  476. #if defined(_PAINTER_)                      /* probably there are few patches */
  477.  T_set_self_rotation(alp,bet,gam);          /* don't cancatinate transforms */
  478.  T_self_rotation(object->m_centres,centres,object->m_no_patches);
  479.  T_world_rotation(centres,centres,object->m_no_patches);
  480.  M_sort_elements(centres+2,T_LNG_VECTOR,numbers,object->m_no_patches);
  481. #endif
  483.  for(i=0;i<object->m_no_patches;i++)
  484.   M_render_bicubic(object->m_patches[numbers[i]],x,y,z,alp,bet,gam);
  486.  M_force_linear_tmapping=oldtmap;
  487. }
  489. /**********************************************************/