home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / math / m_xform_tmp.h < prev    next >
Text File  |  2001-05-18  |  27KB  |  808 lines
  1. /* $Id: m_xform_tmp.h,v 1.7 2001/05/18 23:58:26 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.5
  6.  *
  7.  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  8.  *
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  *
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * New (3.1) transformation code written by Keith Whitwell.
  29.  */
  30.  
  31.  
  32. /*----------------------------------------------------------------------
  33.  * Begin Keith's new code
  34.  *
  35.  *----------------------------------------------------------------------
  36.  */
  37.  
  38. /* KW: Fixed stride, now measured in bytes as is the OpenGL array stride.
  39.  */
  40.  
  41. /* KW: These are now parameterized to produce two versions, one
  42.  *     which transforms all incoming points, and a second which
  43.  *     takes notice of a cullmask array, and only transforms
  44.  *     unculled vertices.
  45.  */
  46.  
  47. /* KW: 1-vectors can sneak into the texture pipeline via the array
  48.  *     interface.  These functions are here because I want consistant
  49.  *     treatment of the vertex sizes and a lazy strategy for
  50.  *     cleaning unused parts of the vector, and so as not to exclude
  51.  *     them from the vertex array interface.
  52.  *
  53.  *     Under our current analysis of matrices, there is no way that
  54.  *     the product of a matrix and a 1-vector can remain a 1-vector,
  55.  *     with the exception of the identity transform.
  56.  */
  57.  
  58. /* KW: No longer zero-pad outgoing vectors.  Now that external
  59.  *     vectors can get into the pipeline we cannot ever assume
  60.  *     that there is more to a vector than indicated by its
  61.  *     size.
  62.  */
  63.  
  64. /* KW: Now uses clipmask and a flag to allow us to skip both/either
  65.  *     cliped and/or culled vertices.
  66.  */
  67.  
  68. /* GH: Not any more -- it's easier (and faster) to just process the
  69.  *     entire vector.  Clipping and culling are handled further down
  70.  *     the pipe, most often during or after the conversion to some
  71.  *     driver-specific vertex format.
  72.  */
  73.  
  74. static void _XFORMAPI
  75. TAG(transform_points1_general)( GLvector4f *to_vec,
  76.                 const GLfloat m[16],
  77.                 const GLvector4f *from_vec )
  78. {
  79.    const GLuint stride = from_vec->stride;
  80.    GLfloat *from = from_vec->start;
  81.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  82.    GLuint count = from_vec->count;
  83.    const GLfloat m0 = m[0],  m12 = m[12];
  84.    const GLfloat m1 = m[1],  m13 = m[13];
  85.    const GLfloat m2 = m[2],  m14 = m[14];
  86.    const GLfloat m3 = m[3],  m15 = m[15];
  87.    GLuint i;
  88.    STRIDE_LOOP {
  89.       const GLfloat ox = from[0];
  90.       to[i][0] = m0 * ox + m12;
  91.       to[i][1] = m1 * ox + m13;
  92.       to[i][2] = m2 * ox + m14;
  93.       to[i][3] = m3 * ox + m15;
  94.    }
  95.    to_vec->size = 4;
  96.    to_vec->flags |= VEC_SIZE_4;
  97.    to_vec->count = from_vec->count;
  98. }
  99.  
  100. static void _XFORMAPI
  101. TAG(transform_points1_identity)( GLvector4f *to_vec,
  102.                  const GLfloat m[16],
  103.                  const GLvector4f *from_vec )
  104. {
  105.    const GLuint stride = from_vec->stride;
  106.    GLfloat *from = from_vec->start;
  107.    GLuint count = from_vec->count;
  108.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  109.    GLuint i;
  110.    if (to_vec == from_vec) return;
  111.    STRIDE_LOOP {
  112.       to[i][0] = from[0];
  113.    }
  114.    to_vec->size = 1;
  115.    to_vec->flags |= VEC_SIZE_1;
  116.    to_vec->count = from_vec->count;
  117. }
  118.  
  119. static void _XFORMAPI
  120. TAG(transform_points1_2d)( GLvector4f *to_vec,
  121.                const GLfloat m[16],
  122.                const GLvector4f *from_vec )
  123. {
  124.    const GLuint stride = from_vec->stride;
  125.    GLfloat *from = from_vec->start;
  126.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  127.    GLuint count = from_vec->count;
  128.    const GLfloat m0 = m[0], m1 = m[1];
  129.    const GLfloat m12 = m[12], m13 = m[13];
  130.    GLuint i;
  131.    STRIDE_LOOP {
  132.       const GLfloat ox = from[0];
  133.       to[i][0] = m0 * ox + m12;
  134.       to[i][1] = m1 * ox + m13;
  135.    }
  136.    to_vec->size = 2;
  137.    to_vec->flags |= VEC_SIZE_2;
  138.    to_vec->count = from_vec->count;
  139. }
  140.  
  141. static void _XFORMAPI
  142. TAG(transform_points1_2d_no_rot)( GLvector4f *to_vec,
  143.                   const GLfloat m[16],
  144.                   const GLvector4f *from_vec )
  145. {
  146.    const GLuint stride = from_vec->stride;
  147.    GLfloat *from = from_vec->start;
  148.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  149.    GLuint count = from_vec->count;
  150.    const GLfloat m0 = m[0], m12 = m[12], m13 = m[13];
  151.    GLuint i;
  152.    STRIDE_LOOP {
  153.       const GLfloat ox = from[0];
  154.       to[i][0] = m0 * ox + m12;
  155.       to[i][1] =           m13;
  156.    }
  157.    to_vec->size = 2;
  158.    to_vec->flags |= VEC_SIZE_2;
  159.    to_vec->count = from_vec->count;
  160. }
  161.  
  162. static void _XFORMAPI
  163. TAG(transform_points1_3d)( GLvector4f *to_vec,
  164.                const GLfloat m[16],
  165.                const GLvector4f *from_vec )
  166. {
  167.    const GLuint stride = from_vec->stride;
  168.    GLfloat *from = from_vec->start;
  169.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  170.    GLuint count = from_vec->count;
  171.    const GLfloat m0 = m[0], m1 = m[1], m2 = m[2];
  172.    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
  173.    GLuint i;
  174.    STRIDE_LOOP {
  175.       const GLfloat ox = from[0];
  176.       to[i][0] = m0 * ox + m12;
  177.       to[i][1] = m1 * ox + m13;
  178.       to[i][2] = m2 * ox + m14;
  179.    }
  180.    to_vec->size = 3;
  181.    to_vec->flags |= VEC_SIZE_3;
  182.    to_vec->count = from_vec->count;
  183. }
  184.  
  185.  
  186. static void _XFORMAPI
  187. TAG(transform_points1_3d_no_rot)( GLvector4f *to_vec,
  188.                   const GLfloat m[16],
  189.                   const GLvector4f *from_vec )
  190. {
  191.    const GLuint stride = from_vec->stride;
  192.    GLfloat *from = from_vec->start;
  193.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  194.    GLuint count = from_vec->count;
  195.    const GLfloat m0 = m[0];
  196.    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
  197.    GLuint i;
  198.    STRIDE_LOOP {
  199.       const GLfloat ox = from[0];
  200.       to[i][0] = m0 * ox           + m12;
  201.       to[i][1] =                     m13;
  202.       to[i][2] =                     m14;
  203.    }
  204.    to_vec->size = 3;
  205.    to_vec->flags |= VEC_SIZE_3;
  206.    to_vec->count = from_vec->count;
  207. }
  208.  
  209. static void _XFORMAPI
  210. TAG(transform_points1_perspective)( GLvector4f *to_vec,
  211.                     const GLfloat m[16],
  212.                     const GLvector4f *from_vec )
  213. {
  214.    const GLuint stride = from_vec->stride;
  215.    GLfloat *from = from_vec->start;
  216.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  217.    GLuint count = from_vec->count;
  218.    const GLfloat m0 = m[0], m14 = m[14];
  219.    GLuint i;
  220.    STRIDE_LOOP {
  221.       const GLfloat ox = from[0];
  222.       to[i][0] = m0 * ox                ;
  223.       to[i][1] =           0            ;
  224.       to[i][2] =                     m14;
  225.       to[i][3] = 0;
  226.    }
  227.    to_vec->size = 4;
  228.    to_vec->flags |= VEC_SIZE_4;
  229.    to_vec->count = from_vec->count;
  230. }
  231.  
  232.  
  233.  
  234.  
  235. /* 2-vectors, which are a lot more relevant than 1-vectors, are
  236.  * present early in the geometry pipeline and throughout the
  237.  * texture pipeline.
  238.  */
  239. static void _XFORMAPI
  240. TAG(transform_points2_general)( GLvector4f *to_vec,
  241.                 const GLfloat m[16],
  242.                 const GLvector4f *from_vec )
  243. {
  244.    const GLuint stride = from_vec->stride;
  245.    GLfloat *from = from_vec->start;
  246.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  247.    GLuint count = from_vec->count;
  248.    const GLfloat m0 = m[0],  m4 = m[4],  m12 = m[12];
  249.    const GLfloat m1 = m[1],  m5 = m[5],  m13 = m[13];
  250.    const GLfloat m2 = m[2],  m6 = m[6],  m14 = m[14];
  251.    const GLfloat m3 = m[3],  m7 = m[7],  m15 = m[15];
  252.    GLuint i;
  253.    STRIDE_LOOP {
  254.       const GLfloat ox = from[0], oy = from[1];
  255.       to[i][0] = m0 * ox + m4 * oy + m12;
  256.       to[i][1] = m1 * ox + m5 * oy + m13;
  257.       to[i][2] = m2 * ox + m6 * oy + m14;
  258.       to[i][3] = m3 * ox + m7 * oy + m15;
  259.    }
  260.    to_vec->size = 4;
  261.    to_vec->flags |= VEC_SIZE_4;
  262.    to_vec->count = from_vec->count;
  263. }
  264.  
  265. static void _XFORMAPI
  266. TAG(transform_points2_identity)( GLvector4f *to_vec,
  267.                  const GLfloat m[16],
  268.                  const GLvector4f *from_vec )
  269. {
  270.    const GLuint stride = from_vec->stride;
  271.    GLfloat *from = from_vec->start;
  272.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  273.    GLuint count = from_vec->count;
  274.    GLuint i;
  275.    if (to_vec == from_vec) return;
  276.    STRIDE_LOOP {
  277.       to[i][0] = from[0];
  278.       to[i][1] = from[1];
  279.    }
  280.    to_vec->size = 2;
  281.    to_vec->flags |= VEC_SIZE_2;
  282.    to_vec->count = from_vec->count;
  283. }
  284.  
  285. static void _XFORMAPI
  286. TAG(transform_points2_2d)( GLvector4f *to_vec,
  287.                const GLfloat m[16],
  288.                const GLvector4f *from_vec )
  289. {
  290.    const GLuint stride = from_vec->stride;
  291.    GLfloat *from = from_vec->start;
  292.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  293.    GLuint count = from_vec->count;
  294.    const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
  295.    const GLfloat m12 = m[12], m13 = m[13];
  296.    GLuint i;
  297.    STRIDE_LOOP {
  298.       const GLfloat ox = from[0], oy = from[1];
  299.       to[i][0] = m0 * ox + m4 * oy + m12;
  300.       to[i][1] = m1 * ox + m5 * oy + m13;
  301.    }
  302.    to_vec->size = 2;
  303.    to_vec->flags |= VEC_SIZE_2;
  304.    to_vec->count = from_vec->count;
  305. }
  306.  
  307. static void _XFORMAPI
  308. TAG(transform_points2_2d_no_rot)( GLvector4f *to_vec,
  309.                   const GLfloat m[16],
  310.                   const GLvector4f *from_vec )
  311. {
  312.    const GLuint stride = from_vec->stride;
  313.    GLfloat *from = from_vec->start;
  314.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  315.    GLuint count = from_vec->count;
  316.    const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
  317.    GLuint i;
  318.    STRIDE_LOOP {
  319.       const GLfloat ox = from[0], oy = from[1];
  320.       to[i][0] = m0 * ox           + m12;
  321.       to[i][1] =           m5 * oy + m13;
  322.    }
  323.    to_vec->size = 2;
  324.    to_vec->flags |= VEC_SIZE_2;
  325.    to_vec->count = from_vec->count;
  326. }
  327.  
  328. static void _XFORMAPI
  329. TAG(transform_points2_3d)( GLvector4f *to_vec,
  330.                const GLfloat m[16],
  331.                const GLvector4f *from_vec )
  332. {
  333.    const GLuint stride = from_vec->stride;
  334.    GLfloat *from = from_vec->start;
  335.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  336.    GLuint count = from_vec->count;
  337.    const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
  338.    const GLfloat m6 = m[6], m12 = m[12], m13 = m[13], m14 = m[14];
  339.    GLuint i;
  340.    STRIDE_LOOP {
  341.       const GLfloat ox = from[0], oy = from[1];
  342.       to[i][0] = m0 * ox + m4 * oy + m12;
  343.       to[i][1] = m1 * ox + m5 * oy + m13;
  344.       to[i][2] = m2 * ox + m6 * oy + m14;
  345.    }
  346.    to_vec->size = 3;
  347.    to_vec->flags |= VEC_SIZE_3;
  348.    to_vec->count = from_vec->count;
  349. }
  350.  
  351.  
  352. /* I would actually say this was a fairly important function, from
  353.  * a texture transformation point of view.
  354.  */
  355. static void _XFORMAPI
  356. TAG(transform_points2_3d_no_rot)( GLvector4f *to_vec,
  357.                   const GLfloat m[16],
  358.                   const GLvector4f *from_vec )
  359. {
  360.    const GLuint stride = from_vec->stride;
  361.    GLfloat *from = from_vec->start;
  362.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  363.    GLuint count = from_vec->count;
  364.    const GLfloat m0 = m[0], m5 = m[5];
  365.    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
  366.    GLuint i;
  367.    STRIDE_LOOP {
  368.       const GLfloat ox = from[0], oy = from[1];
  369.       to[i][0] = m0 * ox           + m12;
  370.       to[i][1] =           m5 * oy + m13;
  371.       to[i][2] =                     m14;
  372.    }
  373.    if (m14 == 0) {
  374.       to_vec->size = 2;
  375.       to_vec->flags |= VEC_SIZE_2;
  376.    } else {
  377.       to_vec->size = 3;
  378.       to_vec->flags |= VEC_SIZE_3;
  379.    }
  380.    to_vec->count = from_vec->count;
  381. }
  382.  
  383.  
  384. static void _XFORMAPI
  385. TAG(transform_points2_perspective)( GLvector4f *to_vec,
  386.                     const GLfloat m[16],
  387.                     const GLvector4f *from_vec )
  388. {
  389.    const GLuint stride = from_vec->stride;
  390.    GLfloat *from = from_vec->start;
  391.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  392.    GLuint count = from_vec->count;
  393.    const GLfloat m0 = m[0], m5 = m[5], m14 = m[14];
  394.    GLuint i;
  395.    STRIDE_LOOP {
  396.       const GLfloat ox = from[0], oy = from[1];
  397.       to[i][0] = m0 * ox                ;
  398.       to[i][1] =           m5 * oy      ;
  399.       to[i][2] =                     m14;
  400.       to[i][3] = 0;
  401.    }
  402.    to_vec->size = 4;
  403.    to_vec->flags |= VEC_SIZE_4;
  404.    to_vec->count = from_vec->count;
  405. }
  406.  
  407.  
  408.  
  409. static void _XFORMAPI
  410. TAG(transform_points3_general)( GLvector4f *to_vec,
  411.                 const GLfloat m[16],
  412.                 const GLvector4f *from_vec )
  413. {
  414.    const GLuint stride = from_vec->stride;
  415.    GLfloat *from = from_vec->start;
  416.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  417.    GLuint count = from_vec->count;
  418.    const GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8],  m12 = m[12];
  419.    const GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9],  m13 = m[13];
  420.    const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
  421.    const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
  422.    GLuint i;
  423.    STRIDE_LOOP {
  424.       const GLfloat ox = from[0], oy = from[1], oz = from[2];
  425.       to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12;
  426.       to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13;
  427.       to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14;
  428.       to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15;
  429.    }
  430.    to_vec->size = 4;
  431.    to_vec->flags |= VEC_SIZE_4;
  432.    to_vec->count = from_vec->count;
  433. }
  434.  
  435. static void _XFORMAPI
  436. TAG(transform_points3_identity)( GLvector4f *to_vec,
  437.                  const GLfloat m[16],
  438.                  const GLvector4f *from_vec )
  439. {
  440.    const GLuint stride = from_vec->stride;
  441.    GLfloat *from = from_vec->start;
  442.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  443.    GLuint count = from_vec->count;
  444.    GLuint i;
  445.    if (to_vec == from_vec) return;
  446.    STRIDE_LOOP {
  447.       to[i][0] = from[0];
  448.       to[i][1] = from[1];
  449.       to[i][2] = from[2];
  450.    }
  451.    to_vec->size = 3;
  452.    to_vec->flags |= VEC_SIZE_3;
  453.    to_vec->count = from_vec->count;
  454. }
  455.  
  456. static void _XFORMAPI
  457. TAG(transform_points3_2d)( GLvector4f *to_vec,
  458.                const GLfloat m[16],
  459.                const GLvector4f *from_vec )
  460. {
  461.    const GLuint stride = from_vec->stride;
  462.    GLfloat *from = from_vec->start;
  463.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  464.    GLuint count = from_vec->count;
  465.    const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
  466.    const GLfloat m12 = m[12], m13 = m[13];
  467.    GLuint i;
  468.    STRIDE_LOOP {
  469.       const GLfloat ox = from[0], oy = from[1], oz = from[2];
  470.       to[i][0] = m0 * ox + m4 * oy            + m12       ;
  471.       to[i][1] = m1 * ox + m5 * oy            + m13       ;
  472.       to[i][2] =                   +       oz             ;
  473.    }
  474.    to_vec->size = 3;
  475.    to_vec->flags |= VEC_SIZE_3;
  476.    to_vec->count = from_vec->count;
  477. }
  478.  
  479. static void _XFORMAPI
  480. TAG(transform_points3_2d_no_rot)( GLvector4f *to_vec,
  481.                   const GLfloat m[16],
  482.                   const GLvector4f *from_vec )
  483. {
  484.    const GLuint stride = from_vec->stride;
  485.    GLfloat *from = from_vec->start;
  486.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  487.    GLuint count = from_vec->count;
  488.    const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
  489.    GLuint i;
  490.    STRIDE_LOOP {
  491.       const GLfloat ox = from[0], oy = from[1], oz = from[2];
  492.       to[i][0] = m0 * ox                      + m12       ;
  493.       to[i][1] =           m5 * oy            + m13       ;
  494.       to[i][2] =                   +       oz             ;
  495.    }
  496.    to_vec->size = 3;
  497.    to_vec->flags |= VEC_SIZE_3;
  498.    to_vec->count = from_vec->count;
  499. }
  500.  
  501. static void _XFORMAPI
  502. TAG(transform_points3_3d)( GLvector4f *to_vec,
  503.                const GLfloat m[16],
  504.                const GLvector4f *from_vec )
  505. {
  506.    const GLuint stride = from_vec->stride;
  507.    GLfloat *from = from_vec->start;
  508.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  509.    GLuint count = from_vec->count;
  510.    const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
  511.    const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
  512.    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
  513.    GLuint i;
  514.    STRIDE_LOOP {
  515.       const GLfloat ox = from[0], oy = from[1], oz = from[2];
  516.       to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12       ;
  517.       to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13       ;
  518.       to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14       ;
  519.    }
  520.    to_vec->size = 3;
  521.    to_vec->flags |= VEC_SIZE_3;
  522.    to_vec->count = from_vec->count;
  523. }
  524.  
  525. /* previously known as ortho...
  526.  */
  527. static void _XFORMAPI
  528. TAG(transform_points3_3d_no_rot)( GLvector4f *to_vec,
  529.                   const GLfloat m[16],
  530.                   const GLvector4f *from_vec )
  531. {
  532.    const GLuint stride = from_vec->stride;
  533.    GLfloat *from = from_vec->start;
  534.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  535.    GLuint count = from_vec->count;
  536.    const GLfloat m0 = m[0], m5 = m[5];
  537.    const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
  538.    GLuint i;
  539.    STRIDE_LOOP {
  540.       const GLfloat ox = from[0], oy = from[1], oz = from[2];
  541.       to[i][0] = m0 * ox                      + m12       ;
  542.       to[i][1] =           m5 * oy            + m13       ;
  543.       to[i][2] =                     m10 * oz + m14       ;
  544.    }
  545.    to_vec->size = 3;
  546.    to_vec->flags |= VEC_SIZE_3;
  547.    to_vec->count = from_vec->count;
  548. }
  549.  
  550. static void _XFORMAPI
  551. TAG(transform_points3_perspective)( GLvector4f *to_vec,
  552.                     const GLfloat m[16],
  553.                     const GLvector4f *from_vec )
  554. {
  555.    const GLuint stride = from_vec->stride;
  556.    GLfloat *from = from_vec->start;
  557.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  558.    GLuint count = from_vec->count;
  559.    const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
  560.    const GLfloat m10 = m[10], m14 = m[14];
  561.    GLuint i;
  562.    STRIDE_LOOP {
  563.       const GLfloat ox = from[0], oy = from[1], oz = from[2];
  564.       to[i][0] = m0 * ox           + m8  * oz       ;
  565.       to[i][1] =           m5 * oy + m9  * oz       ;
  566.       to[i][2] =                     m10 * oz + m14 ;
  567.       to[i][3] =                          -oz       ;
  568.    }
  569.    to_vec->size = 4;
  570.    to_vec->flags |= VEC_SIZE_4;
  571.    to_vec->count = from_vec->count;
  572. }
  573.  
  574.  
  575.  
  576. static void _XFORMAPI
  577. TAG(transform_points4_general)( GLvector4f *to_vec,
  578.                 const GLfloat m[16],
  579.                 const GLvector4f *from_vec )
  580. {
  581.    const GLuint stride = from_vec->stride;
  582.    GLfloat *from = from_vec->start;
  583.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  584.    GLuint count = from_vec->count;
  585.    const GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8],  m12 = m[12];
  586.    const GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9],  m13 = m[13];
  587.    const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
  588.    const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
  589.    GLuint i;
  590.    STRIDE_LOOP {
  591.       const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
  592.       to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12 * ow;
  593.       to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13 * ow;
  594.       to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
  595.       to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15 * ow;
  596.    }
  597.    to_vec->size = 4;
  598.    to_vec->flags |= VEC_SIZE_4;
  599.    to_vec->count = from_vec->count;
  600. }
  601.  
  602. static void _XFORMAPI
  603. TAG(transform_points4_identity)( GLvector4f *to_vec,
  604.                  const GLfloat m[16],
  605.                  const GLvector4f *from_vec )
  606. {
  607.    const GLuint stride = from_vec->stride;
  608.    GLfloat *from = from_vec->start;
  609.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  610.    GLuint count = from_vec->count;
  611.    GLuint i;
  612.    if (to_vec == from_vec) return;
  613.    STRIDE_LOOP {
  614.       to[i][0] = from[0];
  615.       to[i][1] = from[1];
  616.       to[i][2] = from[2];
  617.       to[i][3] = from[3];
  618.    }
  619.    to_vec->size = 4;
  620.    to_vec->flags |= VEC_SIZE_4;
  621.    to_vec->count = from_vec->count;
  622. }
  623.  
  624. static void _XFORMAPI
  625. TAG(transform_points4_2d)( GLvector4f *to_vec,
  626.                const GLfloat m[16],
  627.                const GLvector4f *from_vec )
  628. {
  629.    const GLuint stride = from_vec->stride;
  630.    GLfloat *from = from_vec->start;
  631.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  632.    GLuint count = from_vec->count;
  633.    const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
  634.    const GLfloat m12 = m[12], m13 = m[13];
  635.    GLuint i;
  636.    STRIDE_LOOP {
  637.       const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
  638.       to[i][0] = m0 * ox + m4 * oy            + m12 * ow;
  639.       to[i][1] = m1 * ox + m5 * oy            + m13 * ow;
  640.       to[i][2] =                   +       oz           ;
  641.       to[i][3] =                                      ow;
  642.    }
  643.    to_vec->size = 4;
  644.    to_vec->flags |= VEC_SIZE_4;
  645.    to_vec->count = from_vec->count;
  646. }
  647.  
  648. static void _XFORMAPI
  649. TAG(transform_points4_2d_no_rot)( GLvector4f *to_vec,
  650.                   const GLfloat m[16],
  651.                   const GLvector4f *from_vec )
  652. {
  653.    const GLuint stride = from_vec->stride;
  654.    GLfloat *from = from_vec->start;
  655.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  656.    GLuint count = from_vec->count;
  657.    const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
  658.    GLuint i;
  659.    STRIDE_LOOP {
  660.       const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
  661.       to[i][0] = m0 * ox                      + m12 * ow;
  662.       to[i][1] =           m5 * oy            + m13 * ow;
  663.       to[i][2] =                   +       oz           ;
  664.       to[i][3] =                                      ow;
  665.    }
  666.    to_vec->size = 4;
  667.    to_vec->flags |= VEC_SIZE_4;
  668.    to_vec->count = from_vec->count;
  669. }
  670.  
  671. static void _XFORMAPI
  672. TAG(transform_points4_3d)( GLvector4f *to_vec,
  673.                const GLfloat m[16],
  674.                const GLvector4f *from_vec )
  675. {
  676.    const GLuint stride = from_vec->stride;
  677.    GLfloat *from = from_vec->start;
  678.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  679.    GLuint count = from_vec->count;
  680.    const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
  681.    const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
  682.    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
  683.    GLuint i;
  684.    STRIDE_LOOP {
  685.       const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
  686.       to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12 * ow;
  687.       to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13 * ow;
  688.       to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
  689.       to[i][3] =                                      ow;
  690.    }
  691.    to_vec->size = 4;
  692.    to_vec->flags |= VEC_SIZE_4;
  693.    to_vec->count = from_vec->count;
  694. }
  695.  
  696. static void _XFORMAPI
  697. TAG(transform_points4_3d_no_rot)( GLvector4f *to_vec,
  698.                   const GLfloat m[16],
  699.                   const GLvector4f *from_vec )
  700. {
  701.    const GLuint stride = from_vec->stride;
  702.    GLfloat *from = from_vec->start;
  703.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  704.    GLuint count = from_vec->count;
  705.    const GLfloat m0 = m[0], m5 = m[5];
  706.    const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
  707.    GLuint i;
  708.    STRIDE_LOOP {
  709.       const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
  710.       to[i][0] = m0 * ox                      + m12 * ow;
  711.       to[i][1] =           m5 * oy            + m13 * ow;
  712.       to[i][2] =                     m10 * oz + m14 * ow;
  713.       to[i][3] =                                      ow;
  714.    }
  715.    to_vec->size = 4;
  716.    to_vec->flags |= VEC_SIZE_4;
  717.    to_vec->count = from_vec->count;
  718. }
  719.  
  720. static void _XFORMAPI
  721. TAG(transform_points4_perspective)( GLvector4f *to_vec,
  722.                     const GLfloat m[16],
  723.                     const GLvector4f *from_vec )
  724. {
  725.    const GLuint stride = from_vec->stride;
  726.    GLfloat *from = from_vec->start;
  727.    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
  728.    GLuint count = from_vec->count;
  729.    const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
  730.    const GLfloat m10 = m[10], m14 = m[14];
  731.    GLuint i;
  732.    STRIDE_LOOP {
  733.       const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
  734.       to[i][0] = m0 * ox           + m8  * oz            ;
  735.       to[i][1] =           m5 * oy + m9  * oz            ;
  736.       to[i][2] =                     m10 * oz + m14 * ow ;
  737.       to[i][3] =                          -oz            ;
  738.    }
  739.    to_vec->size = 4;
  740.    to_vec->flags |= VEC_SIZE_4;
  741.    to_vec->count = from_vec->count;
  742. }
  743.  
  744. static transform_func _XFORMAPI TAG(transform_tab_1)[7];
  745. static transform_func _XFORMAPI TAG(transform_tab_2)[7];
  746. static transform_func _XFORMAPI TAG(transform_tab_3)[7];
  747. static transform_func _XFORMAPI TAG(transform_tab_4)[7];
  748.  
  749. /* Similar functions could be called several times, with more highly
  750.  * optimized routines overwriting the arrays.  This only occurs during
  751.  * startup.
  752.  */
  753. static void _XFORMAPI TAG(init_c_transformations)( void )
  754. {
  755. #define TAG_TAB   _mesa_transform_tab
  756. #define TAG_TAB_1 TAG(transform_tab_1)
  757. #define TAG_TAB_2 TAG(transform_tab_2)
  758. #define TAG_TAB_3 TAG(transform_tab_3)
  759. #define TAG_TAB_4 TAG(transform_tab_4)
  760.  
  761.    TAG_TAB[1] = TAG_TAB_1;
  762.    TAG_TAB[2] = TAG_TAB_2;
  763.    TAG_TAB[3] = TAG_TAB_3;
  764.    TAG_TAB[4] = TAG_TAB_4;
  765.  
  766.    /* 1-D points (ie texcoords) */
  767.    TAG_TAB_1[MATRIX_GENERAL]     = TAG(transform_points1_general);
  768.    TAG_TAB_1[MATRIX_IDENTITY]    = TAG(transform_points1_identity);
  769.    TAG_TAB_1[MATRIX_3D_NO_ROT]   = TAG(transform_points1_3d_no_rot);
  770.    TAG_TAB_1[MATRIX_PERSPECTIVE] = TAG(transform_points1_perspective);
  771.    TAG_TAB_1[MATRIX_2D]          = TAG(transform_points1_2d);
  772.    TAG_TAB_1[MATRIX_2D_NO_ROT]   = TAG(transform_points1_2d_no_rot);
  773.    TAG_TAB_1[MATRIX_3D]          = TAG(transform_points1_3d);
  774.  
  775.    /* 2-D points */
  776.    TAG_TAB_2[MATRIX_GENERAL]     = TAG(transform_points2_general);
  777.    TAG_TAB_2[MATRIX_IDENTITY]    = TAG(transform_points2_identity);
  778.    TAG_TAB_2[MATRIX_3D_NO_ROT]   = TAG(transform_points2_3d_no_rot);
  779.    TAG_TAB_2[MATRIX_PERSPECTIVE] = TAG(transform_points2_perspective);
  780.    TAG_TAB_2[MATRIX_2D]          = TAG(transform_points2_2d);
  781.    TAG_TAB_2[MATRIX_2D_NO_ROT]   = TAG(transform_points2_2d_no_rot);
  782.    TAG_TAB_2[MATRIX_3D]          = TAG(transform_points2_3d);
  783.  
  784.    /* 3-D points */
  785.    TAG_TAB_3[MATRIX_GENERAL]     = TAG(transform_points3_general);
  786.    TAG_TAB_3[MATRIX_IDENTITY]    = TAG(transform_points3_identity);
  787.    TAG_TAB_3[MATRIX_3D_NO_ROT]   = TAG(transform_points3_3d_no_rot);
  788.    TAG_TAB_3[MATRIX_PERSPECTIVE] = TAG(transform_points3_perspective);
  789.    TAG_TAB_3[MATRIX_2D]          = TAG(transform_points3_2d);
  790.    TAG_TAB_3[MATRIX_2D_NO_ROT]   = TAG(transform_points3_2d_no_rot);
  791.    TAG_TAB_3[MATRIX_3D]          = TAG(transform_points3_3d);
  792.  
  793.    /* 4-D points */
  794.    TAG_TAB_4[MATRIX_GENERAL]     = TAG(transform_points4_general);
  795.    TAG_TAB_4[MATRIX_IDENTITY]    = TAG(transform_points4_identity);
  796.    TAG_TAB_4[MATRIX_3D_NO_ROT]   = TAG(transform_points4_3d_no_rot);
  797.    TAG_TAB_4[MATRIX_PERSPECTIVE] = TAG(transform_points4_perspective);
  798.    TAG_TAB_4[MATRIX_2D]          = TAG(transform_points4_2d);
  799.    TAG_TAB_4[MATRIX_2D_NO_ROT]   = TAG(transform_points4_2d_no_rot);
  800.    TAG_TAB_4[MATRIX_3D]          = TAG(transform_points4_3d);
  801.  
  802. #undef TAG_TAB
  803. #undef TAG_TAB_1
  804. #undef TAG_TAB_2
  805. #undef TAG_TAB_3
  806. #undef TAG_TAB_4
  807. }
  808.