home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / vtxfmt_tmp.h < prev    next >
C/C++ Source or Header  |  2002-10-29  |  12KB  |  473 lines
  1. /* $Id: vtxfmt_tmp.h,v 1.11 2002/10/29 20:28:56 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  4.1
  6.  *
  7.  * Copyright (C) 1999-2002  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.  * Authors:
  27.  *    Gareth Hughes
  28.  */
  29.  
  30. #ifndef PRE_LOOPBACK
  31. #define PRE_LOOPBACK( FUNC )
  32. #endif
  33.  
  34. static void TAG(ArrayElement)( GLint i )
  35. {
  36.    PRE_LOOPBACK( ArrayElement );
  37.    _glapi_Dispatch->ArrayElement( i );
  38. }
  39.  
  40. static void TAG(Color3f)( GLfloat r, GLfloat g, GLfloat b )
  41. {
  42.    PRE_LOOPBACK( Color3f );
  43.    _glapi_Dispatch->Color3f( r, g, b );
  44. }
  45.  
  46. static void TAG(Color3fv)( const GLfloat *v )
  47. {
  48.    PRE_LOOPBACK( Color3fv );
  49.    _glapi_Dispatch->Color3fv( v );
  50. }
  51.  
  52. static void TAG(Color3ub)( GLubyte r, GLubyte g, GLubyte b )
  53. {
  54.    PRE_LOOPBACK( Color3ub );
  55.    _glapi_Dispatch->Color3ub( r, g, b );
  56. }
  57.  
  58. static void TAG(Color3ubv)( const GLubyte *v )
  59. {
  60.    PRE_LOOPBACK( Color3ubv );
  61.    _glapi_Dispatch->Color3ubv( v );
  62. }
  63.  
  64. static void TAG(Color4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
  65. {
  66.    PRE_LOOPBACK( Color4f );
  67.    _glapi_Dispatch->Color4f( r, g, b, a );
  68. }
  69.  
  70. static void TAG(Color4fv)( const GLfloat *v )
  71. {
  72.    PRE_LOOPBACK( Color4fv );
  73.    _glapi_Dispatch->Color4fv( v );
  74. }
  75.  
  76. static void TAG(Color4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
  77. {
  78.    PRE_LOOPBACK( Color4ub );
  79.    _glapi_Dispatch->Color4ub( r, g, b, a );
  80. }
  81.  
  82. static void TAG(Color4ubv)( const GLubyte *v )
  83. {
  84.    PRE_LOOPBACK( Color4ubv );
  85.    _glapi_Dispatch->Color4ubv( v );
  86. }
  87.  
  88. static void TAG(EdgeFlag)( GLboolean e )
  89. {
  90.    PRE_LOOPBACK( EdgeFlag );
  91.    _glapi_Dispatch->EdgeFlag( e );
  92. }
  93.  
  94. static void TAG(EdgeFlagv)( const GLboolean *v )
  95. {
  96.    PRE_LOOPBACK( EdgeFlagv );
  97.    _glapi_Dispatch->EdgeFlagv( v );
  98. }
  99.  
  100. static void TAG(EvalCoord1f)( GLfloat s )
  101. {
  102.    PRE_LOOPBACK( EvalCoord1f );
  103.    _glapi_Dispatch->EvalCoord1f( s );
  104. }
  105.  
  106. static void TAG(EvalCoord1fv)( const GLfloat *v )
  107. {
  108.    PRE_LOOPBACK( EvalCoord1fv );
  109.    _glapi_Dispatch->EvalCoord1fv( v );
  110. }
  111.  
  112. static void TAG(EvalCoord2f)( GLfloat s, GLfloat t )
  113. {
  114.    PRE_LOOPBACK( EvalCoord2f );
  115.    _glapi_Dispatch->EvalCoord2f( s, t );
  116. }
  117.  
  118. static void TAG(EvalCoord2fv)( const GLfloat *v )
  119. {
  120.    PRE_LOOPBACK( EvalCoord2fv );
  121.    _glapi_Dispatch->EvalCoord2fv( v );
  122. }
  123.  
  124. static void TAG(EvalPoint1)( GLint i )
  125. {
  126.    PRE_LOOPBACK( EvalPoint1 );
  127.    _glapi_Dispatch->EvalPoint1( i );
  128. }
  129.  
  130. static void TAG(EvalPoint2)( GLint i, GLint j )
  131. {
  132.    PRE_LOOPBACK( EvalPoint2 );
  133.    _glapi_Dispatch->EvalPoint2( i, j );
  134. }
  135.  
  136. static void TAG(FogCoordfEXT)( GLfloat f )
  137. {
  138.    PRE_LOOPBACK( FogCoordfEXT );
  139.    _glapi_Dispatch->FogCoordfEXT( f );
  140. }
  141.  
  142. static void TAG(FogCoordfvEXT)( const GLfloat *v )
  143. {
  144.    PRE_LOOPBACK( FogCoordfvEXT );
  145.    _glapi_Dispatch->FogCoordfvEXT( v );
  146. }
  147.  
  148. static void TAG(Indexi)( GLint i )
  149. {
  150.    PRE_LOOPBACK( Indexi );
  151.    _glapi_Dispatch->Indexi( i );
  152. }
  153.  
  154. static void TAG(Indexiv)( const GLint *v )
  155. {
  156.    PRE_LOOPBACK( Indexiv );
  157.    _glapi_Dispatch->Indexiv( v );
  158. }
  159.  
  160. static void TAG(Materialfv)( GLenum face, GLenum pname, const GLfloat *v )
  161. {
  162.    PRE_LOOPBACK( Materialfv );
  163.    _glapi_Dispatch->Materialfv( face, pname, v );
  164. }
  165.  
  166. static void TAG(MultiTexCoord1fARB)( GLenum target, GLfloat a )
  167. {
  168.    PRE_LOOPBACK( MultiTexCoord1fARB );
  169.    _glapi_Dispatch->MultiTexCoord1fARB( target, a );
  170. }
  171.  
  172. static void TAG(MultiTexCoord1fvARB)( GLenum target, const GLfloat *tc )
  173. {
  174.    PRE_LOOPBACK( MultiTexCoord1fvARB );
  175.    _glapi_Dispatch->MultiTexCoord1fvARB( target, tc );
  176. }
  177.  
  178. static void TAG(MultiTexCoord2fARB)( GLenum target, GLfloat s, GLfloat t )
  179. {
  180.    PRE_LOOPBACK( MultiTexCoord2fARB );
  181.    _glapi_Dispatch->MultiTexCoord2fARB( target, s, t );
  182. }
  183.  
  184. static void TAG(MultiTexCoord2fvARB)( GLenum target, const GLfloat *tc )
  185. {
  186.    PRE_LOOPBACK( MultiTexCoord2fvARB );
  187.    _glapi_Dispatch->MultiTexCoord2fvARB( target, tc );
  188. }
  189.  
  190. static void TAG(MultiTexCoord3fARB)( GLenum target, GLfloat s,
  191.                      GLfloat t, GLfloat r )
  192. {
  193.    PRE_LOOPBACK( MultiTexCoord3fARB );
  194.    _glapi_Dispatch->MultiTexCoord3fARB( target, s, t, r );
  195. }
  196.  
  197. static void TAG(MultiTexCoord3fvARB)( GLenum target, const GLfloat *tc )
  198. {
  199.    PRE_LOOPBACK( MultiTexCoord3fvARB );
  200.    _glapi_Dispatch->MultiTexCoord3fvARB( target, tc );
  201. }
  202.  
  203. static void TAG(MultiTexCoord4fARB)( GLenum target, GLfloat s,
  204.                      GLfloat t, GLfloat r, GLfloat q )
  205. {
  206.    PRE_LOOPBACK( MultiTexCoord4fARB );
  207.    _glapi_Dispatch->MultiTexCoord4fARB( target, s, t, r, q );
  208. }
  209.  
  210. static void TAG(MultiTexCoord4fvARB)( GLenum target, const GLfloat *tc )
  211. {
  212.    PRE_LOOPBACK( MultiTexCoord4fvARB );
  213.    _glapi_Dispatch->MultiTexCoord4fvARB( target, tc );
  214. }
  215.  
  216. static void TAG(Normal3f)( GLfloat x, GLfloat y, GLfloat z )
  217. {
  218.    PRE_LOOPBACK( Normal3f );
  219.    _glapi_Dispatch->Normal3f( x, y, z );
  220. }
  221.  
  222. static void TAG(Normal3fv)( const GLfloat *v )
  223. {
  224.    PRE_LOOPBACK( Normal3fv );
  225.    _glapi_Dispatch->Normal3fv( v );
  226. }
  227.  
  228. static void TAG(SecondaryColor3fEXT)( GLfloat r, GLfloat g, GLfloat b )
  229. {
  230.    PRE_LOOPBACK( SecondaryColor3fEXT );
  231.    _glapi_Dispatch->SecondaryColor3fEXT( r, g, b );
  232. }
  233.  
  234. static void TAG(SecondaryColor3fvEXT)( const GLfloat *v )
  235. {
  236.    PRE_LOOPBACK( SecondaryColor3fvEXT );
  237.    _glapi_Dispatch->SecondaryColor3fvEXT( v );
  238. }
  239.  
  240. static void TAG(SecondaryColor3ubEXT)( GLubyte r, GLubyte g, GLubyte b )
  241. {
  242.    PRE_LOOPBACK( SecondaryColor3ubEXT );
  243.    _glapi_Dispatch->SecondaryColor3ubEXT( r, g, b );
  244. }
  245.  
  246. static void TAG(SecondaryColor3ubvEXT)( const GLubyte *v )
  247. {
  248.    PRE_LOOPBACK( SecondaryColor3ubvEXT );
  249.    _glapi_Dispatch->SecondaryColor3ubvEXT( v );
  250. }
  251.  
  252. static void TAG(TexCoord1f)( GLfloat s )
  253. {
  254.    PRE_LOOPBACK( TexCoord1f );
  255.    _glapi_Dispatch->TexCoord1f( s );
  256. }
  257.  
  258. static void TAG(TexCoord1fv)( const GLfloat *tc )
  259. {
  260.    PRE_LOOPBACK( TexCoord1fv );
  261.    _glapi_Dispatch->TexCoord1fv( tc );
  262. }
  263.  
  264. static void TAG(TexCoord2f)( GLfloat s, GLfloat t )
  265. {
  266.    PRE_LOOPBACK( TexCoord2f );
  267.    _glapi_Dispatch->TexCoord2f( s, t );
  268. }
  269.  
  270. static void TAG(TexCoord2fv)( const GLfloat *tc )
  271. {
  272.    PRE_LOOPBACK( TexCoord2fv );
  273.    _glapi_Dispatch->TexCoord2fv( tc );
  274. }
  275.  
  276. static void TAG(TexCoord3f)( GLfloat s, GLfloat t, GLfloat r )
  277. {
  278.    PRE_LOOPBACK( TexCoord3f );
  279.    _glapi_Dispatch->TexCoord3f( s, t, r );
  280. }
  281.  
  282. static void TAG(TexCoord3fv)( const GLfloat *tc )
  283. {
  284.    PRE_LOOPBACK( TexCoord3fv );
  285.    _glapi_Dispatch->TexCoord3fv( tc );
  286. }
  287.  
  288. static void TAG(TexCoord4f)( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
  289. {
  290.    PRE_LOOPBACK( TexCoord4f );
  291.    _glapi_Dispatch->TexCoord4f( s, t, r, q );
  292. }
  293.  
  294. static void TAG(TexCoord4fv)( const GLfloat *tc )
  295. {
  296.    PRE_LOOPBACK( TexCoord4fv );
  297.    _glapi_Dispatch->TexCoord4fv( tc );
  298. }
  299.  
  300. static void TAG(Vertex2f)( GLfloat x, GLfloat y )
  301. {
  302.    PRE_LOOPBACK( Vertex2f );
  303.    _glapi_Dispatch->Vertex2f( x, y );
  304. }
  305.  
  306. static void TAG(Vertex2fv)( const GLfloat *v )
  307. {
  308.    PRE_LOOPBACK( Vertex2fv );
  309.    _glapi_Dispatch->Vertex2fv( v );
  310. }
  311.  
  312. static void TAG(Vertex3f)( GLfloat x, GLfloat y, GLfloat z )
  313. {
  314.    PRE_LOOPBACK( Vertex3f );
  315.    _glapi_Dispatch->Vertex3f( x, y, z );
  316. }
  317.  
  318. static void TAG(Vertex3fv)( const GLfloat *v )
  319. {
  320.    PRE_LOOPBACK( Vertex3fv );
  321.    _glapi_Dispatch->Vertex3fv( v );
  322. }
  323.  
  324. static void TAG(Vertex4f)( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  325. {
  326.    PRE_LOOPBACK( Vertex4f );
  327.    _glapi_Dispatch->Vertex4f( x, y, z, w );
  328. }
  329.  
  330. static void TAG(Vertex4fv)( const GLfloat *v )
  331. {
  332.    PRE_LOOPBACK( Vertex4fv );
  333.    _glapi_Dispatch->Vertex4fv( v );
  334. }
  335.  
  336. static void TAG(CallList)( GLuint i )
  337. {
  338.    PRE_LOOPBACK( CallList );
  339.    _glapi_Dispatch->CallList( i );
  340. }
  341.  
  342. static void TAG(Begin)( GLenum mode )
  343. {
  344.    PRE_LOOPBACK( Begin );
  345.    _glapi_Dispatch->Begin( mode );
  346. }
  347.  
  348. static void TAG(End)( void )
  349. {
  350.    PRE_LOOPBACK( End );
  351.    _glapi_Dispatch->End();
  352. }
  353.  
  354. static void TAG(Rectf)( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
  355. {
  356.    PRE_LOOPBACK( Rectf );
  357.    _glapi_Dispatch->Rectf( x1, y1, x2, y2 );
  358. }
  359.  
  360. static void TAG(DrawArrays)( GLenum mode, GLint start, GLsizei count )
  361. {
  362.    PRE_LOOPBACK( DrawArrays );
  363.    _glapi_Dispatch->DrawArrays( mode, start, count );
  364. }
  365.  
  366. static void TAG(DrawElements)( GLenum mode, GLsizei count, GLenum type,
  367.                    const void *indices )
  368. {
  369.    PRE_LOOPBACK( DrawElements );
  370.    _glapi_Dispatch->DrawElements( mode, count, type, indices );
  371. }
  372.  
  373. static void TAG(DrawRangeElements)( GLenum mode, GLuint start,
  374.                     GLuint end, GLsizei count,
  375.                     GLenum type, const void *indices )
  376. {
  377.    PRE_LOOPBACK( DrawRangeElements );
  378.    _glapi_Dispatch->DrawRangeElements( mode, start, end, count, type, indices );
  379. }
  380.  
  381. static void TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
  382. {
  383.    PRE_LOOPBACK( EvalMesh1 );
  384.    _glapi_Dispatch->EvalMesh1( mode, i1, i2 );
  385. }
  386.  
  387. static void TAG(EvalMesh2)( GLenum mode, GLint i1, GLint i2,
  388.                 GLint j1, GLint j2 )
  389. {
  390.    PRE_LOOPBACK( EvalMesh2 );
  391.    _glapi_Dispatch->EvalMesh2( mode, i1, i2, j1, j2 );
  392. }
  393.  
  394. static void TAG(VertexAttrib4fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  395. {
  396.    PRE_LOOPBACK( VertexAttrib4fNV );
  397.    _glapi_Dispatch->VertexAttrib4fNV( index, x, y, z, w );
  398. }
  399.  
  400. static void TAG(VertexAttrib4fvNV)( GLuint index, const GLfloat *v )
  401. {
  402.    PRE_LOOPBACK( VertexAttrib4fNV );
  403.    _glapi_Dispatch->VertexAttrib4fvNV( index, v );
  404. }
  405.  
  406.  
  407. static GLvertexformat TAG(vtxfmt) = {
  408.    TAG(ArrayElement),
  409.    TAG(Color3f),
  410.    TAG(Color3fv),
  411.    TAG(Color3ub),
  412.    TAG(Color3ubv),
  413.    TAG(Color4f),
  414.    TAG(Color4fv),
  415.    TAG(Color4ub),
  416.    TAG(Color4ubv),
  417.    TAG(EdgeFlag),
  418.    TAG(EdgeFlagv),
  419.    TAG(EvalCoord1f),
  420.    TAG(EvalCoord1fv),
  421.    TAG(EvalCoord2f),
  422.    TAG(EvalCoord2fv),
  423.    TAG(EvalPoint1),
  424.    TAG(EvalPoint2),
  425.    TAG(FogCoordfEXT),
  426.    TAG(FogCoordfvEXT),
  427.    TAG(Indexi),
  428.    TAG(Indexiv),
  429.    TAG(Materialfv),
  430.    TAG(MultiTexCoord1fARB),
  431.    TAG(MultiTexCoord1fvARB),
  432.    TAG(MultiTexCoord2fARB),
  433.    TAG(MultiTexCoord2fvARB),
  434.    TAG(MultiTexCoord3fARB),
  435.    TAG(MultiTexCoord3fvARB),
  436.    TAG(MultiTexCoord4fARB),
  437.    TAG(MultiTexCoord4fvARB),
  438.    TAG(Normal3f),
  439.    TAG(Normal3fv),
  440.    TAG(SecondaryColor3fEXT),
  441.    TAG(SecondaryColor3fvEXT),
  442.    TAG(SecondaryColor3ubEXT),
  443.    TAG(SecondaryColor3ubvEXT),
  444.    TAG(TexCoord1f),
  445.    TAG(TexCoord1fv),
  446.    TAG(TexCoord2f),
  447.    TAG(TexCoord2fv),
  448.    TAG(TexCoord3f),
  449.    TAG(TexCoord3fv),
  450.    TAG(TexCoord4f),
  451.    TAG(TexCoord4fv),
  452.    TAG(Vertex2f),
  453.    TAG(Vertex2fv),
  454.    TAG(Vertex3f),
  455.    TAG(Vertex3fv),
  456.    TAG(Vertex4f),
  457.    TAG(Vertex4fv),
  458.    TAG(CallList),
  459.    TAG(Begin),
  460.    TAG(End),
  461.    TAG(VertexAttrib4fNV),
  462.    TAG(VertexAttrib4fvNV),
  463.    TAG(Rectf),
  464.    TAG(DrawArrays),
  465.    TAG(DrawElements),
  466.    TAG(DrawRangeElements),
  467.    TAG(EvalMesh1),
  468.    TAG(EvalMesh2)
  469. };
  470.  
  471. #undef TAG
  472. #undef PRE_LOOPBACK
  473.