//3DS platform in Pascal
//
// Copyright (c) 2013, 2015, 2017 Kenneth Dwayne Lee Bsc.
// all rights reserved
//
// If the Box didn't have a bow; twats that never felt or what it is to sexlive, for whom & why ... prude reasons?
//!! poster sized is optional, Pix sideways of before & after on the doors of any & all Christ's churches !!


{$ifdef 3dsintf}
  {*
   * @file enums.h
   * @brief GPU enumeration values.
    }
    
  {/ Creates a texture magnification filter parameter from a @ref GPU_TEXTURE_FILTER_PARAM }
  
  //function GPU_TEXTURE_MAG_FILTER(v : longint) : longint;  

  {/ Creates a texture minification filter parameter from a @ref GPU_TEXTURE_FILTER_PARAM }
  
  //function GPU_TEXTURE_MIN_FILTER(v : longint) : longint;  

  {/ Creates a texture mipmap filter parameter from a @ref GPU_TEXTURE_FILTER_PARAM }
  
  function GPU_TEXTURE_MIP_FILTER(v : longint) : longint;  

  {/ Creates a texture wrap S parameter from a @ref GPU_TEXTURE_WRAP_PARAM }
  
  //function GPU_TEXTURE_WRAP_S(v : longint) : longint;  

  {/ Creates a texture wrap T parameter from a @ref GPU_TEXTURE_WRAP_PARAM }
  
 // function GPU_TEXTURE_WRAP_T(v : longint) : longint;  

  {/ Creates a texture mode parameter from a @ref GPU_TEXTURE_MODE_PARAM }
  
  function GPU_TEXTURE_MODE(v : longint) : longint;  

  {/ Texture parameter indicating ETC1 texture. }
  { was #define dname def_expr }
  function GPU_TEXTURE_ETC1_PARAM : longint;

  {/ Texture parameter indicating shadow texture. }
  function GPU_TEXTURE_SHADOW_PARAM : longint;

  {/ Creates a combiner buffer write configuration. }
  
  function GPU_TEV_BUFFER_WRITE_CONFIG(stage0,stage1,stage2,stage3 : longint) : longint;  

  {/ Texture filters. }
  {/< Nearest-neighbor interpolation. }
  {/< Linear interpolation. }

  type

     GPU_TEXTURE_FILTER_PARAM =  Longint;
     Const
       GPU_NEAREST = $0;
       GPU_LINEAR = $1;
//;

  type

     GPU_TEXTURE_WRAP_PARAM =  Longint;
     Const
       GPU_CLAMP_TO_EDGE = $0;
       GPU_CLAMP_TO_BORDER = $1;
       GPU_REPEAT = $2;
       GPU_MIRRORED_REPEAT = $3;
//;

  type

     GPU_TEXTURE_MODE_PARAM =  Longint;
     Const
       GPU_TEX_2D = $0;
       GPU_TEX_CUBE_MAP = $1;
       GPU_TEX_SHADOW_2D = $2;
       GPU_TEX_PROJECTION = $3;
       GPU_TEX_SHADOW_CUBE = $4;
       GPU_TEX_DISABLED = $5;
//;


//  type
//     GPU_TEXUNIT =  Longint;
//     Const
//       GPU_TEXUNIT0 = $1;
//       GPU_TEXUNIT1 = $2;
//       GPU_TEXUNIT2 = $4;
//;

  {/ Supported texture formats. }
  {/< 8-bit Red + 8-bit Green + 8-bit Blue + 8-bit Alpha }
  {/< 8-bit Red + 8-bit Green + 8-bit Blue }
  {/< 5-bit Red + 5-bit Green + 5-bit Blue + 1-bit Alpha }
  {/< 5-bit Red + 6-bit Green + 5-bit Blue }
  {/< 4-bit Red + 4-bit Green + 4-bit Blue + 4-bit Alpha }
  {/< 8-bit Luminance + 8-bit Alpha }
  {/< 8-bit Hi + 8-bit Lo }
  {/< 8-bit Luminance }
  {/< 8-bit Alpha }
  {/< 4-bit Luminance + 4-bit Alpha }
  {/< 4-bit Luminance }
  {/< 4-bit Alpha }
  {/< ETC1 texture compression }
  {/< ETC1 texture compression + 4-bit Alpha }

  type

     GPU_TEXCOLOR =  Longint;
     Const
       GPU_RGBA8 = $0;
       GPU_RGB8 = $1;
       GPU_RGBA5551 = $2;
       GPU_RGB565 = $3;
       GPU_RGBA4 = $4;
       GPU_LA8 = $5;
       GPU_HILO8 = $6;
       GPU_L8 = $7;
       GPU_A8 = $8;
       GPU_LA4 = $9;
       GPU_L4 = $A;
       GPU_A4 = $B;
       GPU_ETC1 = $C;
       GPU_ETC1A4 = $D;

  type

     GPU_PROCTEX_CLAMP =  Longint;
     Const
       GPU_PT_CLAMP_TO_ZERO = 0;
       GPU_PT_CLAMP_TO_EDGE = 1;
       GPU_PT_REPEAT = 2;
       GPU_PT_MIRRORED_REPEAT = 3;
       GPU_PT_PULSE = 4;

  type

     GPU_PROCTEX_MAPFUNC =  Longint;
     Const
       GPU_PT_U = 0;
       GPU_PT_U2 = 1;
       GPU_PT_V = 2;
       GPU_PT_V2 = 3;
       GPU_PT_ADD = 4;
       GPU_PT_ADD2 = 5;
       GPU_PT_SQRT2 = 6;
       GPU_PT_MIN = 7;
       GPU_PT_MAX = 8;
       GPU_PT_RMAX = 9;
       
  {/ Procedural texture shift values. }
  {/< No shift. }
  {/< Odd shift. }
  {/< Even shift. }

  type

     GPU_PROCTEX_SHIFT =  Longint;
     Const
       GPU_PT_NONE = 0;
       GPU_PT_ODD = 1;
       GPU_PT_EVEN = 2;

  type

     GPU_PROCTEX_FILTER =  Longint;
     Const
       GPU_PT_NEAREST = 0;
       GPU_PT_LINEAR = 1;
       GPU_PT_NEAREST_MIP_NEAREST = 2;
       GPU_PT_LINEAR_MIP_NEAREST = 3;
       GPU_PT_NEAREST_MIP_LINEAR = 4;
       GPU_PT_LINEAR_MIP_LINEAR = 5;

  type

     GPU_PROCTEX_LUTID =  Longint;
     Const
       GPU_LUT_NOISE = 0;
       GPU_LUT_RGBMAP = 1;
       GPU_LUT_ALPHAMAP = 2;
       GPU_LUT_COLOR = 3;
       GPU_LUT_COLORDIF = 4;
  
  {/ Supported color buffer formats. }
  {/< 8-bit Red + 8-bit Green + 8-bit Blue + 8-bit Alpha }
  {/< 8-bit Red + 8-bit Green + 8-bit Blue }
  {/< 5-bit Red + 5-bit Green + 5-bit Blue + 1-bit Alpha }
  {/< 5-bit Red + 6-bit Green + 5-bit Blue }
  {/< 4-bit Red + 4-bit Green + 4-bit Blue + 4-bit Alpha }

  type

     GPU_COLORBUF =  Longint;
     Const
       GPU_RB_RGBA8 = 0;
       GPU_RB_RGB8 = 1;
       GPU_RB_RGBA5551 = 2;
       GPU_RB_RGB565 = 3;
       GPU_RB_RGBA4 = 4;
       
  {/ Supported depth buffer formats. }
  {/< 16-bit Depth }
  {/< 24-bit Depth }
  {/< 24-bit Depth + 8-bit Stencil }

  type

     GPU_DEPTHBUF =  Longint;
     Const
       GPU_RB_DEPTH16 = 0;
       GPU_RB_DEPTH24 = 2;
       GPU_RB_DEPTH24_STENCIL8 = 3;

  type

     GPU_TESTFUNC =  Longint;
     Const
       GPU_NEVER = 0;
       GPU_ALWAYS = 1;
       GPU_EQUAL = 2;
       GPU_NOTEQUAL = 3;
       GPU_LESS = 4;
       GPU_LEQUAL = 5;
       GPU_GREATER = 6;
       GPU_GEQUAL = 7;

  type

     GPU_EARLYDEPTHFUNC =  Longint;
     Const
       GPU_EARLYDEPTH_GEQUAL = 0;
       GPU_EARLYDEPTH_GREATER = 1;
       GPU_EARLYDEPTH_LEQUAL = 2;
       GPU_EARLYDEPTH_LESS = 3;

  {/ Scissor test modes. }
  {/< Disable. }
  {/< Exclude pixels inside the scissor box. }
  { 2 is the same as 0 }
  {/< Exclude pixels outside of the scissor box. }

  type

     GPU_SCISSORMODE =  Longint;
     Const
       GPU_SCISSOR_DISABLE = 0;
       GPU_SCISSOR_INVERT = 1;
       GPU_SCISSOR_NORMAL = 3;
 
  type

     GPU_STENCILOP =  Longint;
     Const
       GPU_STENCIL_KEEP = 0;
       GPU_STENCIL_ZERO = 1;
       GPU_STENCIL_REPLACE = 2;
       GPU_STENCIL_INCR = 3;
       GPU_STENCIL_DECR = 4;
       GPU_STENCIL_INVERT = 5;
       GPU_STENCIL_INCR_WRAP = 6;
       GPU_STENCIL_DECR_WRAP = 7;

  type

     GPU_WRITEMASK =  Longint;
     Const
       GPU_WRITE_RED = $01;
       GPU_WRITE_GREEN = $02;
       GPU_WRITE_BLUE = $04;
       GPU_WRITE_ALPHA = $08;
       GPU_WRITE_DEPTH = $10;
       GPU_WRITE_COLOR = $0F;
       GPU_WRITE_ALL = $1F;
       
  {/ Blend modes. }
  {/< Add colors. }
  {/< Subtract colors. }
  {/< Reverse-subtract colors. }
  {/< Use the minimum color. }
  {/< Use the maximum color. }

  type

     GPU_BLENDEQUATION =  Longint;
     Const
       GPU_BLEND_ADD = 0;
       GPU_BLEND_SUBTRACT = 1;
       GPU_BLEND_REVERSE_SUBTRACT = 2;
       GPU_BLEND_MIN = 3;
       GPU_BLEND_MAX = 4;

  type
     GPU_BLENDFACTOR =  Longint;
     Const
       GPU_ZERO = 0;
       GPU_ONE = 1;
       GPU_SRC_COLOR = 2;
       GPU_ONE_MINUS_SRC_COLOR = 3;
       GPU_DST_COLOR = 4;
       GPU_ONE_MINUS_DST_COLOR = 5;
       GPU_SRC_ALPHA = 6;
       GPU_ONE_MINUS_SRC_ALPHA = 7;
       GPU_DST_ALPHA = 8;
       GPU_ONE_MINUS_DST_ALPHA = 9;
       GPU_CONSTANT_COLOR = 10;
       GPU_ONE_MINUS_CONSTANT_COLOR = 11;
       GPU_CONSTANT_ALPHA = 12;
       GPU_ONE_MINUS_CONSTANT_ALPHA = 13;
       GPU_SRC_ALPHA_SATURATE = 14;

  type
     GPU_LOGICOP =  Longint;
     Const
       GPU_LOGICOP_CLEAR = 0;
       GPU_LOGICOP_AND = 1;
       GPU_LOGICOP_AND_REVERSE = 2;
       GPU_LOGICOP_COPY = 3;
       GPU_LOGICOP_SET = 4;
       GPU_LOGICOP_COPY_INVERTED = 5;
       GPU_LOGICOP_NOOP = 6;
       GPU_LOGICOP_INVERT = 7;
       GPU_LOGICOP_NAND = 8;
       GPU_LOGICOP_OR = 9;
       GPU_LOGICOP_NOR = 10;
       GPU_LOGICOP_XOR = 11;
       GPU_LOGICOP_EQUIV = 12;
       GPU_LOGICOP_AND_INVERTED = 13;
       GPU_LOGICOP_OR_REVERSE = 14;
       GPU_LOGICOP_OR_INVERTED = 15;

  type

     GPU_FRAGOPMODE =  Longint;
     Const
       GPU_FRAGOPMODE_GL = 0;
       GPU_FRAGOPMODE_GAS_ACC = 1;
       GPU_FRAGOPMODE_SHADOW = 3;

  type

     GPU_FORMATS =  Longint;
     Const
       GPU_BYTE = 0;
       GPU_UNSIGNED_BYTE = 1;
       GPU_SHORT = 2;
       GPU_FLOAT = 3;
  type

     GPU_CULLMODE =  Longint;
     Const
       GPU_CULL_NONE = 0;
       GPU_CULL_FRONT_CCW = 1;
       GPU_CULL_BACK_CCW = 2;
  {/ Creates a VBO attribute parameter from its index, size, and format. }
  
  function GPU_ATTRIBFMT(i,n,f : longint) : longint;  

  type

     GPU_TEVSRC =  Longint;
     Const
       GPU_PRIMARY_COLOR = $00;
       GPU_FRAGMENT_PRIMARY_COLOR = $01;
       GPU_FRAGMENT_SECONDARY_COLOR = $02;
       GPU_TEXTURE0 = $03;
       GPU_TEXTURE1 = $04;
       GPU_TEXTURE2 = $05;
       GPU_TEXTURE3 = $06;
       GPU_PREVIOUS_BUFFER = $0D;
       GPU_CONSTANT = $0E;
       GPU_PREVIOUS = $0F;

  {/ Texture RGB combiner operands. }
  {/< Source color. }
  {/< Source color - 1. }
  {/< Source alpha. }
  {/< Source alpha - 1. }
  {/< Source red. }
  {/< Source red - 1. }
  {/< Unknown. }
  {/< Unknown. }
  {/< Source green. }
  {/< Source green - 1. }
  {/< Unknown. }
  {/< Unknown. }
  {/< Source blue. }
  {/< Source blue - 1. }
  {/< Unknown. }
  {/< Unknown. }

  type

     GPU_TEVOP_RGB =  Longint;
     Const
       GPU_TEVOP_RGB_SRC_COLOR = $00;
       GPU_TEVOP_RGB_ONE_MINUS_SRC_COLOR = $01;
       GPU_TEVOP_RGB_SRC_ALPHA = $02;
       GPU_TEVOP_RGB_ONE_MINUS_SRC_ALPHA = $03;
       GPU_TEVOP_RGB_SRC_R = $04;
       GPU_TEVOP_RGB_ONE_MINUS_SRC_R = $05;
       GPU_TEVOP_RGB_0x06 = $06;
       GPU_TEVOP_RGB_0x07 = $07;
       GPU_TEVOP_RGB_SRC_G = $08;
       GPU_TEVOP_RGB_ONE_MINUS_SRC_G = $09;
       GPU_TEVOP_RGB_0x0A = $0A;
       GPU_TEVOP_RGB_0x0B = $0B;
       GPU_TEVOP_RGB_SRC_B = $0C;
       GPU_TEVOP_RGB_ONE_MINUS_SRC_B = $0D;
       GPU_TEVOP_RGB_0x0E = $0E;
       GPU_TEVOP_RGB_0x0F = $0F;

  {/ Texture Alpha combiner operands. }
  {/< Source alpha. }
  {/< Source alpha - 1. }
  {/< Source red. }
  {/< Source red - 1. }
  {/< Source green. }
  {/< Source green - 1. }
  {/< Source blue. }
  {/< Source blue - 1. }

  type

     GPU_TEVOP_A =  Longint;
     Const
       GPU_TEVOP_A_SRC_ALPHA = $00;
       GPU_TEVOP_A_ONE_MINUS_SRC_ALPHA = $01;
       GPU_TEVOP_A_SRC_R = $02;
       GPU_TEVOP_A_ONE_MINUS_SRC_R = $03;
       GPU_TEVOP_A_SRC_G = $04;
       GPU_TEVOP_A_ONE_MINUS_SRC_G = $05;
       GPU_TEVOP_A_SRC_B = $06;
       GPU_TEVOP_A_ONE_MINUS_SRC_B = $07;

  {/ Texture combiner functions. }
  {/< Replace. }
  {/< Modulate. }
  {/< Add. }
  {/< Signed add. }
  {/< Interpolate. }
  {/< Subtract. }
  {/< Dot3. RGB only. }
  {/< Multiply then add. }
  {/< Add then multiply. }

  type

     GPU_COMBINEFUNC =  Longint;
     Const
       GPU_REPLACE = $00;
       GPU_MODULATE = $01;
       GPU_ADD = $02;
       GPU_ADD_SIGNED = $03;
       GPU_INTERPOLATE = $04;
       GPU_SUBTRACT = $05;
       GPU_DOT3_RGB = $06;
       GPU_MULTIPLY_ADD = $08;
       GPU_ADD_MULTIPLY = $09;

  {/ Texture scale factors. }
  {/< 1x }
  {/< 2x }
  {/< 4x }

  type

     GPU_TEVSCALE =  Longint;
     Const
       GPU_TEVSCALE_1 = $0;
       GPU_TEVSCALE_2 = $1;
       GPU_TEVSCALE_4 = $2;

  {/ Creates a texture combiner source parameter from three sources. }
  
  function GPU_TEVSOURCES(a,b,c : longint) : longint;  

  {/ Creates a texture combiner operand parameter from three operands. }
  
  function GPU_TEVOPERANDS(a,b,c : longint) : longint;  

  {/ Creates a light environment layer configuration parameter. }
  
  function GPU_LIGHT_ENV_LAYER_CONFIG(n : longint) : longint;  

  {/ Light shadow disable bits in GPUREG_LIGHT_CONFIG1. }
  
  function GPU_LC1_SHADOWBIT(n : longint) : longint;  

  {/ Light spot disable bits in GPUREG_LIGHT_CONFIG1. }
  
  function GPU_LC1_SPOTBIT(n : longint) : longint;  

  {/ LUT disable bits in GPUREG_LIGHT_CONFIG1. }
  
  function GPU_LC1_LUTBIT(n : longint) : longint;  

  {/ Light distance attenuation disable bits in GPUREG_LIGHT_CONFIG1. }
  
  function GPU_LC1_ATTNBIT(n : longint) : longint;  

  {/ Creates a light permutation parameter. }
  
  function GPU_LIGHTPERM(i,n : longint) : longint;  

  {/ Creates a light LUT input parameter. }
  
  function GPU_LIGHTLUTINPUT(i,n : longint) : longint;  

  {/ Creates a light LUT index parameter. }
  
  function GPU_LIGHTLUTIDX(c,i,o : longint) : longint;  

  {/ Creates a light color parameter from red, green, and blue components. }
  
  function GPU_LIGHTCOLOR(r,g,b : longint) : longint;  

  type

     GPU_FRESNELSEL =  Longint;
     Const
       GPU_NO_FRESNEL = 0;
       GPU_PRI_ALPHA_FRESNEL = 1;
       GPU_SEC_ALPHA_FRESNEL = 2;
       GPU_PRI_SEC_ALPHA_FRESNEL = 3;

  type

     GPU_BUMPMODE =  Longint;
     Const
       GPU_BUMP_NOT_USED = 0;
       GPU_BUMP_AS_BUMP = 1;
       GPU_BUMP_AS_TANG = 2;

  type

     GPU_LIGHTLUTID =  Longint;
     Const
       GPU_LUT_D0 = 0;
       GPU_LUT_D1 = 1;
       GPU_LUT_SP = 2;
       GPU_LUT_FR = 3;
       GPU_LUT_RB = 4;
       GPU_LUT_RG = 5;
       GPU_LUT_RR = 6;
       GPU_LUT_DA = 7;

 // type
//   GPU_LIGHTLUTINPUT =  Longint; // --> line 712

     Const
       GPU_LUTINPUT_NH = 0;
       GPU_LUTINPUT_VH = 1;
       GPU_LUTINPUT_NV = 2;
       GPU_LUTINPUT_LN = 3;
       GPU_LUTINPUT_SP = 4;
       GPU_LUTINPUT_CP = 5;
       
  type

     GPU_LIGHTLUTSCALER =  Longint;
     Const
       GPU_LUTSCALER_1x = 0;
       GPU_LUTSCALER_2x = 1;
       GPU_LUTSCALER_4x = 2;
       GPU_LUTSCALER_8x = 3;
       GPU_LUTSCALER_0_25x = 6;
       GPU_LUTSCALER_0_5x = 7;

  type

     GPU_LIGHTLUTSELECT =  Longint;
     Const
       GPU_LUTSELECT_COMMON = 0;
       GPU_LUTSELECT_SP = 1;
       GPU_LUTSELECT_DA = 2;

  {/ Supported primitives. }
  {/< Triangles. }
  {/< Triangle strip. }
  {/< Triangle fan. }
  {/< Geometry shader primitive. }

  type

     GPU_Primitive_t =  Longint;
     Const
       GPU_TRIANGLES = $0000;
       GPU_TRIANGLE_STRIP = $0100;
       GPU_TRIANGLE_FAN = $0200;
       GPU_GEOMETRY_PRIM = $0300;

  type

     GPU_SHADER_TYPE =  Longint;
     Const
       GPU_VERTEX_SHADER = $0;
       GPU_GEOMETRY_SHADER = $1;

{$endif 3dsintf}

{$ifdef 3dsimpl}  

  
  function GPU_TEXTURE_MAG_FILTER(v : longint) : longint;
    begin
       GPU_TEXTURE_MAG_FILTER:=(v and $1) shl 1;
    end;

  
  function GPU_TEXTURE_MIN_FILTER(v : longint) : longint;
    begin
       GPU_TEXTURE_MIN_FILTER:=(v and $1) shl 2;
    end;

  
  function GPU_TEXTURE_MIP_FILTER(v : longint) : longint;
    begin
       GPU_TEXTURE_MIP_FILTER:=(v and $1) shl 24;
    end;

  
  function GPU_TEXTURE_WRAP_S(v : longint) : longint;
    begin
       GPU_TEXTURE_WRAP_S:=(v and $3) shl 12;
    end;

  
  function GPU_TEXTURE_WRAP_T(v : longint) : longint;
    begin
       GPU_TEXTURE_WRAP_T:=(v and $3) shl 8;
    end;

  
  function GPU_TEXTURE_MODE(v : longint) : longint;
    begin
       GPU_TEXTURE_MODE:=(v and $7) shl 28;
    end;

  function GPU_TEXTURE_ETC1_PARAM : longint;
      begin
         GPU_TEXTURE_ETC1_PARAM:=(1 shl 5);
      end;

  function GPU_TEXTURE_SHADOW_PARAM : longint;
      begin
         GPU_TEXTURE_SHADOW_PARAM:=(1 shl 20);
      end;

  
  function GPU_TEV_BUFFER_WRITE_CONFIG(stage0,stage1,stage2,stage3 : longint) : longint;
    begin
       GPU_TEV_BUFFER_WRITE_CONFIG:=((stage0 or (stage1 shl 1)) or (stage2 shl 2)) or (stage3 shl 3);
    end;

  
  function GPU_ATTRIBFMT(i,n,f : longint) : longint;
    begin
     //  GPU_ATTRIBFMT:=(((n(-(1))) shl 2) or (f(@(3)))) shl (i*4);
       GPU_ATTRIBFMT:=((n-1) shl 2) or (f and 3) shl (i*4);
    end;

  
  function GPU_TEVSOURCES(a,b,c : longint) : longint;
    begin
       GPU_TEVSOURCES:=(a or (b shl 4)) or (c shl 8);
    end;

  
  function GPU_TEVOPERANDS(a,b,c : longint) : longint;
    begin
       GPU_TEVOPERANDS:=(a or (b shl 4)) or (c shl 8);
    end;

  
  function GPU_LIGHT_ENV_LAYER_CONFIG(n : longint) : longint;
    begin
       GPU_LIGHT_ENV_LAYER_CONFIG:= n+7;
    end;

  
  function GPU_LC1_SHADOWBIT(n : longint) : longint;
    begin
       GPU_LC1_SHADOWBIT:=(1 shl n);
    end;


  function GPU_LC1_SPOTBIT(n : longint) : longint;
    begin
       GPU_LC1_SPOTBIT:=(1 shl n+8);
    end;

  
  function GPU_LC1_LUTBIT(n : longint) : longint;
    begin
       GPU_LC1_LUTBIT:=(1 shl n+16);
    end;

  
  function GPU_LC1_ATTNBIT(n : longint) : longint;
    begin
       GPU_LC1_ATTNBIT:=(1 shl n+24);
    end;

  
  function GPU_LIGHTPERM(i,n : longint) : longint;
    begin
       GPU_LIGHTPERM:=n shl i;
    end;

  
  function GPU_LIGHTLUTINPUT(i,n : longint) : longint;
    begin
       GPU_LIGHTLUTINPUT:= n shl (i*4);
    end;

  
  function GPU_LIGHTLUTIDX(c,i,o : longint) : longint;
    begin
       GPU_LIGHTLUTIDX:=(o or (i shl 8)) or (c shl 11);
    end;

  
  function GPU_LIGHTCOLOR(r,g,b : longint) : longint;
    begin
       GPU_LIGHTCOLOR:=((b and $FF) or ((g shl 10) and $FF) or ((r shl 20) and $FF));
    end;

{$endif 3dsimpl}