Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. /*
  3.  * Mesa 3-D graphics library
  4.  * Version:  3.5
  5.  *
  6.  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  7.  *
  8.  * Permission is hereby granted, free of charge, to any person obtaining a
  9.  * copy of this software and associated documentation files (the "Software"),
  10.  * to deal in the Software without restriction, including without limitation
  11.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12.  * and/or sell copies of the Software, and to permit persons to whom the
  13.  * Software is furnished to do so, subject to the following conditions:
  14.  *
  15.  * The above copyright notice and this permission notice shall be included
  16.  * in all copies or substantial portions of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24.  *
  25.  * Authors:
  26.  *    Gareth Hughes <gareth@valinux.com>
  27.  */
  28.  
  29. /* Template for immediate mode color functions.
  30.  *
  31.  * FIXME: Floating-point color versions of these...
  32.  */
  33.  
  34.  
  35. static void TAG(Color3f)( GLfloat r, GLfloat g, GLfloat b )
  36. {
  37.    GET_CURRENT;
  38. #ifdef COLOR_IS_FLOAT
  39.    CURRENT_COLOR( RCOMP ) = CLAMP(r, 0.0f, 1.0f);
  40.    CURRENT_COLOR( GCOMP ) = CLAMP(g, 0.0f, 1.0f);
  41.    CURRENT_COLOR( BCOMP ) = CLAMP(b, 0.0f, 1.0f);
  42.    CURRENT_COLOR( ACOMP ) = 1.0f;
  43. #else
  44.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), r );
  45.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), g );
  46.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), b );
  47.    CURRENT_COLOR( ACOMP ) = 255;
  48. #endif
  49. }
  50.  
  51. static void TAG(Color3fv)( const GLfloat *v )
  52. {
  53.    GET_CURRENT;
  54. #ifdef COLOR_IS_FLOAT
  55.    CURRENT_COLOR( RCOMP ) = CLAMP(v[0], 0.0f, 1.0f);
  56.    CURRENT_COLOR( GCOMP ) = CLAMP(v[1], 0.0f, 1.0f);
  57.    CURRENT_COLOR( BCOMP ) = CLAMP(v[2], 0.0f, 1.0f);
  58.    CURRENT_COLOR( ACOMP ) = 1.0f;
  59. #else
  60.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), v[0] );
  61.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), v[1] );
  62.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), v[2] );
  63.    CURRENT_COLOR( ACOMP ) = 255;
  64. #endif
  65. }
  66.  
  67. static void TAG(Color3ub)( GLubyte r, GLubyte g, GLubyte b )
  68. {
  69.    GET_CURRENT;
  70. #ifdef COLOR_IS_FLOAT
  71.    CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( r );
  72.    CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( g );
  73.    CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( b );
  74.    CURRENT_COLOR( ACOMP ) = 1.0f;
  75. #else
  76.    CURRENT_COLOR( RCOMP ) = r;
  77.    CURRENT_COLOR( GCOMP ) = g;
  78.    CURRENT_COLOR( BCOMP ) = b;
  79.    CURRENT_COLOR( ACOMP ) = 255;
  80. #endif
  81. }
  82.  
  83. static void TAG(Color3ubv)( const GLubyte *v )
  84. {
  85.    GET_CURRENT;
  86. #ifdef COLOR_IS_FLOAT
  87.    CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( v[0] );
  88.    CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( v[1] );
  89.    CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( v[2] );
  90.    CURRENT_COLOR( ACOMP ) = 1.0f;
  91. #else
  92.    CURRENT_COLOR( RCOMP ) = v[0];
  93.    CURRENT_COLOR( GCOMP ) = v[1];
  94.    CURRENT_COLOR( BCOMP ) = v[2];
  95.    CURRENT_COLOR( ACOMP ) = 255;
  96. #endif
  97. }
  98.  
  99. static void TAG(Color4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
  100. {
  101.    GET_CURRENT;
  102. #ifdef COLOR_IS_FLOAT
  103.    CURRENT_COLOR( RCOMP ) = CLAMP(r, 0.0f, 1.0f);
  104.    CURRENT_COLOR( GCOMP ) = CLAMP(g, 0.0f, 1.0f);
  105.    CURRENT_COLOR( BCOMP ) = CLAMP(b, 0.0f, 1.0f);
  106.    CURRENT_COLOR( ACOMP ) = CLAMP(a, 0.0f, 1.0f);
  107. #else
  108.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), r );
  109.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), g );
  110.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), b );
  111.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( ACOMP ), a );
  112. #endif
  113. }
  114.  
  115. static void TAG(Color4fv)( const GLfloat *v )
  116. {
  117.    GET_CURRENT;
  118. #ifdef COLOR_IS_FLOAT
  119.    CURRENT_COLOR( RCOMP ) = CLAMP(v[0], 0.0f, 1.0f);
  120.    CURRENT_COLOR( GCOMP ) = CLAMP(v[1], 0.0f, 1.0f);
  121.    CURRENT_COLOR( BCOMP ) = CLAMP(v[2], 0.0f, 1.0f);
  122.    CURRENT_COLOR( ACOMP ) = CLAMP(v[3], 0.0f, 1.0f);
  123. #else
  124.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), v[0] );
  125.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), v[1] );
  126.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), v[2] );
  127.    UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( ACOMP ), v[3] );
  128. #endif
  129. }
  130.  
  131. static void TAG(Color4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
  132. {
  133.    GET_CURRENT;
  134. #ifdef COLOR_IS_FLOAT
  135.    CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( r );
  136.    CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( g );
  137.    CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( b );
  138.    CURRENT_COLOR( ACOMP ) = UBYTE_TO_FLOAT( a );
  139. #else
  140.    CURRENT_COLOR( RCOMP ) = r;
  141.    CURRENT_COLOR( GCOMP ) = g;
  142.    CURRENT_COLOR( BCOMP ) = b;
  143.    CURRENT_COLOR( ACOMP ) = a;
  144. #endif
  145. }
  146.  
  147. static void TAG(Color4ubv)( const GLubyte *v )
  148. {
  149.    GET_CURRENT;
  150. #ifdef COLOR_IS_FLOAT
  151.    CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( v[0] );
  152.    CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( v[1] );
  153.    CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( v[2] );
  154.    CURRENT_COLOR( ACOMP ) = UBYTE_TO_FLOAT( v[3] );
  155. #else
  156.    CURRENT_COLOR( RCOMP ) = v[0];
  157.    CURRENT_COLOR( GCOMP ) = v[1];
  158.    CURRENT_COLOR( BCOMP ) = v[2];
  159.    CURRENT_COLOR( ACOMP ) = v[3];
  160. #endif
  161. }
  162.  
  163.  
  164. static void TAG(ColorMaterial3f)( GLfloat r, GLfloat g, GLfloat b )
  165. {
  166.    GET_CURRENT_CONTEXT(ctx);
  167.    GLfloat *color = ctx->Current.Color;
  168.  
  169.    color[0] = r;
  170.    color[1] = g;
  171.    color[2] = b;
  172.    color[3] = 1.0;
  173.  
  174.    _mesa_update_color_material( ctx, color );
  175.    RECALC_BASE_COLOR( ctx );
  176. }
  177.  
  178. static void TAG(ColorMaterial3fv)( const GLfloat *v )
  179. {
  180.    GET_CURRENT_CONTEXT(ctx);
  181.    GLfloat *color = ctx->Current.Color;
  182.  
  183.    color[0] = v[0];
  184.    color[1] = v[1];
  185.    color[2] = v[2];
  186.    color[3] = 1.0;
  187.  
  188.    _mesa_update_color_material( ctx, color );
  189.    RECALC_BASE_COLOR( ctx );
  190. }
  191.  
  192. static void TAG(ColorMaterial3ub)( GLubyte r, GLubyte g, GLubyte b )
  193. {
  194.    GET_CURRENT_CONTEXT(ctx);
  195.    GLfloat *color = ctx->Current.Color;
  196.  
  197.    color[0] = UBYTE_TO_FLOAT( r );
  198.    color[1] = UBYTE_TO_FLOAT( g );
  199.    color[2] = UBYTE_TO_FLOAT( b );
  200.    color[3] = 1.0;
  201.  
  202.    _mesa_update_color_material( ctx, color );
  203.    RECALC_BASE_COLOR( ctx );
  204. }
  205.  
  206. static void TAG(ColorMaterial3ubv)( const GLubyte *v )
  207. {
  208.    GET_CURRENT_CONTEXT(ctx);
  209.    GLfloat *color = ctx->Current.Color;
  210.  
  211.    color[0] = UBYTE_TO_FLOAT( v[0] );
  212.    color[1] = UBYTE_TO_FLOAT( v[1] );
  213.    color[2] = UBYTE_TO_FLOAT( v[2] );
  214.    color[3] = 1.0;
  215.  
  216.    _mesa_update_color_material( ctx, color );
  217.    RECALC_BASE_COLOR( ctx );
  218. }
  219.  
  220. static void TAG(ColorMaterial4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
  221. {
  222.    GET_CURRENT_CONTEXT(ctx);
  223.    GLfloat *color = ctx->Current.Color;
  224.  
  225.    color[0] = r;
  226.    color[1] = g;
  227.    color[2] = b;
  228.    color[3] = a;
  229.  
  230.    _mesa_update_color_material( ctx, color );
  231.    RECALC_BASE_COLOR( ctx );
  232. }
  233.  
  234. static void TAG(ColorMaterial4fv)( const GLfloat *v )
  235. {
  236.    GET_CURRENT_CONTEXT(ctx);
  237.    GLfloat *color = ctx->Current.Color;
  238.  
  239.    color[0] = v[0];
  240.    color[1] = v[1];
  241.    color[2] = v[2];
  242.    color[3] = v[3];
  243.  
  244.    _mesa_update_color_material( ctx, color );
  245.    RECALC_BASE_COLOR( ctx );
  246. }
  247.  
  248. static void TAG(ColorMaterial4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
  249. {
  250.    GET_CURRENT_CONTEXT(ctx);
  251.    GLfloat *color = ctx->Current.Color;
  252.  
  253.    color[0] = UBYTE_TO_FLOAT( r );
  254.    color[1] = UBYTE_TO_FLOAT( g );
  255.    color[2] = UBYTE_TO_FLOAT( b );
  256.    color[3] = UBYTE_TO_FLOAT( a );
  257.  
  258.    _mesa_update_color_material( ctx, color );
  259.    RECALC_BASE_COLOR( ctx );
  260. }
  261.  
  262. static void TAG(ColorMaterial4ubv)( const GLubyte *v )
  263. {
  264.    GET_CURRENT_CONTEXT(ctx);
  265.    GLfloat *color = ctx->Current.Color;
  266.  
  267.    color[0] = UBYTE_TO_FLOAT( v[0] );
  268.    color[1] = UBYTE_TO_FLOAT( v[1] );
  269.    color[2] = UBYTE_TO_FLOAT( v[2] );
  270.    color[3] = UBYTE_TO_FLOAT( v[3] );
  271.  
  272.    _mesa_update_color_material( ctx, color );
  273.    RECALC_BASE_COLOR( ctx );
  274. }
  275.  
  276.  
  277.  
  278.  
  279.  
  280. /* =============================================================
  281.  * Color chooser functions:
  282.  */
  283.  
  284. static void TAG(choose_Color3f)( GLfloat r, GLfloat g, GLfloat b )
  285. {
  286.    GET_CURRENT_CONTEXT(ctx);
  287.  
  288.    if ( ctx->Light.Enabled ) {
  289.       if ( ctx->Light.ColorMaterialEnabled ) {
  290.          SET_Color3f(ctx->Exec, TAG(ColorMaterial3f));
  291.       } else {
  292.          SET_Color3f(ctx->Exec, _mesa_noop_Color3f);
  293.       }
  294.    } else {
  295.       SET_Color3f(ctx->Exec, TAG(Color3f));
  296.    }
  297.    glColor3f( r, g, b );
  298. }
  299.  
  300. static void TAG(choose_Color3fv)( const GLfloat *v )
  301. {
  302.    GET_CURRENT_CONTEXT(ctx);
  303.  
  304.    if ( ctx->Light.Enabled ) {
  305.       if ( ctx->Light.ColorMaterialEnabled ) {
  306.          SET_Color3fv(ctx->Exec, TAG(ColorMaterial3fv));
  307.       } else {
  308.          SET_Color3fv(ctx->Exec, _mesa_noop_Color3fv);
  309.       }
  310.    } else {
  311.       SET_Color3fv(ctx->Exec, TAG(Color3fv));
  312.    }
  313.    glColor3fv( v );
  314. }
  315.  
  316. static void TAG(choose_Color3ub)( GLubyte r, GLubyte g, GLubyte b )
  317. {
  318.    GET_CURRENT_CONTEXT(ctx);
  319.  
  320.    if ( ctx->Light.Enabled ) {
  321.       if ( ctx->Light.ColorMaterialEnabled ) {
  322.          SET_Color3ub(ctx->Exec, TAG(ColorMaterial3ub));
  323.       } else {
  324.          SET_Color3ub(ctx->Exec, _mesa_noop_Color3ub);
  325.       }
  326.    } else {
  327.       SET_Color3ub(ctx->Exec, TAG(Color3ub));
  328.    }
  329.    glColor3ub( r, g, b );
  330. }
  331.  
  332. static void TAG(choose_Color3ubv)( const GLubyte *v )
  333. {
  334.    GET_CURRENT_CONTEXT(ctx);
  335.  
  336.    if ( ctx->Light.Enabled ) {
  337.       if ( ctx->Light.ColorMaterialEnabled ) {
  338.          SET_Color3ubv(ctx->Exec, TAG(ColorMaterial3ubv));
  339.       } else {
  340.          SET_Color3ubv(ctx->Exec, _mesa_noop_Color3ubv);
  341.       }
  342.    } else {
  343.       SET_Color3ubv(ctx->Exec, TAG(Color3ubv));
  344.    }
  345.    glColor3ubv( v );
  346. }
  347.  
  348. static void TAG(choose_Color4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
  349. {
  350.    GET_CURRENT_CONTEXT(ctx);
  351.  
  352.    if ( ctx->Light.Enabled ) {
  353.       if ( ctx->Light.ColorMaterialEnabled ) {
  354.          SET_Color4f(ctx->Exec, TAG(ColorMaterial4f));
  355.       } else {
  356.          SET_Color4f(ctx->Exec, _mesa_noop_Color4f);
  357.       }
  358.    } else {
  359.       SET_Color4f(ctx->Exec, TAG(Color4f));
  360.    }
  361.    glColor4f( r, g, b, a );
  362. }
  363.  
  364. static void TAG(choose_Color4fv)( const GLfloat *v )
  365. {
  366.    GET_CURRENT_CONTEXT(ctx);
  367.  
  368.    if ( ctx->Light.Enabled ) {
  369.       if ( ctx->Light.ColorMaterialEnabled ) {
  370.          SET_Color4fv(ctx->Exec, TAG(ColorMaterial4fv));
  371.       } else {
  372.          SET_Color4fv(ctx->Exec, _mesa_noop_Color4fv);
  373.       }
  374.    } else {
  375.       SET_Color4fv(ctx->Exec, TAG(Color4fv));
  376.    }
  377.    glColor4fv( v );
  378. }
  379.  
  380. static void TAG(choose_Color4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
  381. {
  382.    GET_CURRENT_CONTEXT(ctx);
  383.  
  384.    if ( ctx->Light.Enabled ) {
  385.       if ( ctx->Light.ColorMaterialEnabled ) {
  386.          SET_Color4ub(ctx->Exec, TAG(ColorMaterial4ub));
  387.       } else {
  388.          SET_Color4ub(ctx->Exec, _mesa_noop_Color4ub);
  389.       }
  390.    } else {
  391.       SET_Color4ub(ctx->Exec, TAG(Color4ub));
  392.    }
  393.    glColor4ub( r, g, b, a );
  394. }
  395.  
  396. static void TAG(choose_Color4ubv)( const GLubyte *v )
  397. {
  398.    GET_CURRENT_CONTEXT(ctx);
  399.  
  400.    if ( ctx->Light.Enabled ) {
  401.       if ( ctx->Light.ColorMaterialEnabled ) {
  402.          SET_Color4ubv(ctx->Exec, TAG(ColorMaterial4ubv));
  403.       } else {
  404.          SET_Color4ubv(ctx->Exec, _mesa_noop_Color4ubv);
  405.       }
  406.    } else {
  407.       SET_Color4ubv(ctx->Exec, TAG(Color4ubv));
  408.    }
  409.    glColor4ubv( v );
  410. }
  411.  
  412.  
  413.  
  414. #undef GET_CURRENT
  415. #undef CURRENT_COLOR
  416. #undef CURRENT_SPECULAR
  417. #undef COLOR_IS_FLOAT
  418. #undef RECALC_BASE_COLOR
  419. #undef TAG
  420.