src/mesa/drivers/dri/nouveau/nv30_state.c

   1 /**************************************************************************
   2
   3 Copyright 2006 Nouveau
   4 All Rights Reserved.
   5
   6 Permission is hereby granted, free of charge, to any person obtaining a
   7 copy of this software and associated documentation files (the "Software"),
   8 to deal in the Software without restriction, including without limitation
   9 on the rights to use, copy, modify, merge, publish, distribute, sub
  10 license, and/or sell copies of the Software, and to permit persons to whom
  11 the Software is furnished to do so, subject to the following conditions:
  12
  13 The above copyright notice and this permission notice (including the next
  14 paragraph) shall be included in all copies or substantial portions of the
  15 Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  20 ERIC ANHOLT OR SILICON INTEGRATED SYSTEMS CORP BE LIABLE FOR ANY CLAIM,
  21 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  22 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  23 USE OR OTHER DEALINGS IN THE SOFTWARE.
  24
  25 **************************************************************************/
  26
  27 #include "nouveau_context.h"
  28 #include "nouveau_object.h"
  29 #include "nouveau_fifo.h"
  30 #include "nouveau_reg.h"
  31
  32 #include "tnl/t_pipeline.h"
  33
  34 #include "mtypes.h"
  35 #include "colormac.h"
  36
  37 static void nv30AlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
  38 {
  39         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
  40         GLubyte ubRef;
  41         CLAMPED_FLOAT_TO_UBYTE(ubRef, ref);
  42
  43         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_ALPHA_FUNC_FUNC, 2);
  44         OUT_RING(func);     /* NV30_TCL_PRIMITIVE_3D_ALPHA_FUNC_FUNC */
  45         OUT_RING(ubRef);    /* NV30_TCL_PRIMITIVE_3D_ALPHA_FUNC_REF  */
  46 }
  47
  48 static void nv30BlendColor(GLcontext *ctx, const GLfloat color[4])
  49 {
  50         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
  51         GLubyte cf[4];
  52
  53         CLAMPED_FLOAT_TO_UBYTE(cf[0], color[0]);
  54         CLAMPED_FLOAT_TO_UBYTE(cf[1], color[1]);
  55         CLAMPED_FLOAT_TO_UBYTE(cf[2], color[2]);
  56         CLAMPED_FLOAT_TO_UBYTE(cf[3], color[3]);
  57
  58         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_COLOR, 1);
  59         OUT_RING(PACK_COLOR_8888(cf[3], cf[1], cf[2], cf[0]));
  60 }
  61
  62 static void nv30BlendEquationSeparate(GLcontext *ctx, GLenum modeRGB, GLenum modeA)
  63 {
  64         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
  65         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_EQUATION, 1);
  66         OUT_RING((modeA<<16) | modeRGB);
  67 }
  68
  69
  70 static void nv30BlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, GLenum dfactorRGB,
  71                 GLenum sfactorA, GLenum dfactorA)
  72 {
  73         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
  74         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_SRC, 2);
  75         OUT_RING((sfactorA<<16) | sfactorRGB);
  76         OUT_RING((dfactorA<<16) | dfactorRGB);
  77 }
  78
  79 static void nv30ClearColor(GLcontext *ctx, const GLfloat color[4])
  80 {
  81         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
  82         GLubyte c[4];
  83         UNCLAMPED_FLOAT_TO_RGBA_CHAN(c,color);
  84         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CLEAR_VALUE_ARGB, 1);
  85         OUT_RING(PACK_COLOR_8888(c[3],c[0],c[1],c[2]));
  86 }
  87
  88 static void nv30ClearDepth(GLcontext *ctx, GLclampd d)
  89 {
  90         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
  91         nmesa->clear_value=((nmesa->clear_value&0x000000FF)|(((uint32_t)(d*0xFFFFFF))<<8));
  92         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CLEAR_VALUE_DEPTH, 1);
  93         OUT_RING(nmesa->clear_value);
  94 }
  95
  96 /* we're don't support indexed buffers
  97    void (*ClearIndex)(GLcontext *ctx, GLuint index)
  98  */
  99
 100 static void nv30ClearStencil(GLcontext *ctx, GLint s)
 101 {
 102         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 103         nmesa->clear_value=((nmesa->clear_value&0xFFFFFF00)|(s&0x000000FF));
 104         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CLEAR_VALUE_DEPTH, 1);
 105         OUT_RING(nmesa->clear_value);
 106 }
 107
 108 static void nv30ClipPlane(GLcontext *ctx, GLenum plane, const GLfloat *equation)
 109 {
 110         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 111         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CLIP_PLANE_A(plane), 4);
 112         OUT_RINGf(equation[0]);
 113         OUT_RINGf(equation[1]);
 114         OUT_RINGf(equation[2]);
 115         OUT_RINGf(equation[3]);
 116 }
 117
 118 static void nv30ColorMask(GLcontext *ctx, GLboolean rmask, GLboolean gmask,
 119                 GLboolean bmask, GLboolean amask )
 120 {
 121         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 122         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_COLOR_MASK, 1);
 123         OUT_RING(((amask && 0x01) << 24) | ((rmask && 0x01) << 16) | ((gmask && 0x01)<< 8) | ((bmask && 0x01) << 0));
 124 }
 125
 126 static void nv30ColorMaterial(GLcontext *ctx, GLenum face, GLenum mode)
 127 {
 128         // TODO I need love
 129 }
 130
 131 static void nv30CullFace(GLcontext *ctx, GLenum mode)
 132 {
 133         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 134         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CULL_FACE, 1);
 135         OUT_RING(mode);
 136 }
 137
 138 static void nv30FrontFace(GLcontext *ctx, GLenum mode)
 139 {
 140         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 141         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FRONT_FACE, 1);
 142         OUT_RING(mode);
 143 }
 144
 145 static void nv30DepthFunc(GLcontext *ctx, GLenum func)
 146 {
 147         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 148         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_DEPTH_FUNC, 1);
 149         OUT_RING(func);
 150 }
 151
 152 static void nv30DepthMask(GLcontext *ctx, GLboolean flag)
 153 {
 154         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 155         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_DEPTH_WRITE_ENABLE, 1);
 156         OUT_RING(flag);
 157 }
 158
 159 static void nv30DepthRange(GLcontext *ctx, GLclampd nearval, GLclampd farval)
 160 {
 161         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 162         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_DEPTH_RANGE_NEAR, 2);
 163         OUT_RINGf(nearval);
 164         OUT_RINGf(farval);
 165 }
 166
 167 /** Specify the current buffer for writing */
 168 //void (*DrawBuffer)( GLcontext *ctx, GLenum buffer );
 169 /** Specify the buffers for writing for fragment programs*/
 170 //void (*DrawBuffers)( GLcontext *ctx, GLsizei n, const GLenum *buffers );
 171
 172 static void nv30Enable(GLcontext *ctx, GLenum cap, GLboolean state)
 173 {
 174         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 175         switch(cap)
 176         {
 177                 case GL_ALPHA_TEST:
 178                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_ALPHA_FUNC_ENABLE, 1);
 179                         OUT_RING(state);
 180                         break;
 181 //              case GL_AUTO_NORMAL:
 182                 case GL_BLEND:
 183                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 1);
 184                         OUT_RING(state);
 185                         break;
 186                 case GL_CLIP_PLANE0:
 187                 case GL_CLIP_PLANE1:
 188                 case GL_CLIP_PLANE2:
 189                 case GL_CLIP_PLANE3:
 190                 case GL_CLIP_PLANE4:
 191                 case GL_CLIP_PLANE5:
 192                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CLIP_PLANE_ENABLE(cap-GL_CLIP_PLANE0), 1);
 193                         OUT_RING(state);
 194                         break;
 195                 case GL_COLOR_LOGIC_OP:
 196                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_COLOR_LOGIC_OP_ENABLE, 1);
 197                         OUT_RING(state);
 198                         break;
 199 //              case GL_COLOR_MATERIAL:
 200 //              case GL_COLOR_SUM_EXT:
 201 //              case GL_COLOR_TABLE:
 202 //              case GL_CONVOLUTION_1D:
 203 //              case GL_CONVOLUTION_2D:
 204                 case GL_CULL_FACE:
 205                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CULL_FACE_ENABLE, 1);
 206                         OUT_RING(state);
 207                         break;
 208                 case GL_DEPTH_TEST:
 209                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_DEPTH_TEST_ENABLE, 1);
 210                         OUT_RING(state);
 211                         break;
 212                 case GL_DITHER:
 213                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_DITHER_ENABLE, 1);
 214                         OUT_RING(state);
 215                         break;
 216                 case GL_FOG:
 217                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_ENABLE, 1);
 218                         OUT_RING(state);
 219                         break;
 220 //              case GL_HISTOGRAM:
 221 //              case GL_INDEX_LOGIC_OP:
 222                 case GL_LIGHT0:
 223                 case GL_LIGHT1:
 224                 case GL_LIGHT2:
 225                 case GL_LIGHT3:
 226                 case GL_LIGHT4:
 227                 case GL_LIGHT5:
 228                 case GL_LIGHT6:
 229                 case GL_LIGHT7:
 230                         {
 231                         uint32_t mask=0x11<<(2*(cap-GL_LIGHT0));
 232                         nmesa->enabled_lights=((nmesa->enabled_lights&mask)|(mask*state));
 233                         if (nmesa->lighting_enabled)
 234                         {
 235                                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_ENABLED_LIGHTS, 1);
 236                                 OUT_RING(nmesa->enabled_lights);
 237                         }
 238                         break;
 239                         }
 240                 case GL_LIGHTING:
 241                         nmesa->lighting_enabled=state;
 242                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_ENABLED_LIGHTS, 1);
 243                         if (nmesa->lighting_enabled)
 244                                 OUT_RING(nmesa->enabled_lights);
 245                         else
 246                                 OUT_RING(0x0);
 247                         break;
 248 //              case GL_LINE_SMOOTH:
 249 //              case GL_LINE_STIPPLE:
 250 //              case GL_MAP1_COLOR_4:
 251 //              case GL_MAP1_INDEX:
 252 //              case GL_MAP1_NORMAL:
 253 //              case GL_MAP1_TEXTURE_COORD_1:
 254 //              case GL_MAP1_TEXTURE_COORD_2:
 255 //              case GL_MAP1_TEXTURE_COORD_3:
 256 //              case GL_MAP1_TEXTURE_COORD_4:
 257 //              case GL_MAP1_VERTEX_3:
 258 //              case GL_MAP1_VERTEX_4:
 259 //              case GL_MAP2_COLOR_4:
 260 //              case GL_MAP2_INDEX:
 261 //              case GL_MAP2_NORMAL:
 262 //              case GL_MAP2_TEXTURE_COORD_1:
 263 //              case GL_MAP2_TEXTURE_COORD_2:
 264 //              case GL_MAP2_TEXTURE_COORD_3:
 265 //              case GL_MAP2_TEXTURE_COORD_4:
 266 //              case GL_MAP2_VERTEX_3:
 267 //              case GL_MAP2_VERTEX_4:
 268 //              case GL_MINMAX:
 269                 case GL_NORMALIZE:
 270                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_NORMALIZE_ENABLE, 1);
 271                         OUT_RING(state);
 272                         break;
 273 //              case GL_POINT_SMOOTH:
 274                 case GL_POLYGON_OFFSET_POINT:
 275                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_OFFSET_POINT_ENABLE, 1);
 276                         OUT_RING(state);
 277                         break;
 278                 case GL_POLYGON_OFFSET_LINE:
 279                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_OFFSET_LINE_ENABLE, 1);
 280                         OUT_RING(state);
 281                         break;
 282                 case GL_POLYGON_OFFSET_FILL:
 283                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_OFFSET_FILL_ENABLE, 1);
 284                         OUT_RING(state);
 285                         break;
 286                 case GL_POLYGON_SMOOTH:
 287                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_SMOOTH_ENABLE, 1);
 288                         OUT_RING(state);
 289                         break;
 290                 case GL_POLYGON_STIPPLE:
 291                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_STIPPLE_ENABLE, 1);
 292                         OUT_RING(state);
 293                         break;
 294 //              case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 295 //              case GL_POST_CONVOLUTION_COLOR_TABLE:
 296 //              case GL_RESCALE_NORMAL:
 297 //              case GL_SCISSOR_TEST:
 298 //              case GL_SEPARABLE_2D:
 299                 case GL_STENCIL_TEST:
 300                         // TODO BACK and FRONT ?
 301                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_BACK_ENABLE, 1);
 302                         OUT_RING(state);
 303                         break;
 304 //              case GL_TEXTURE_GEN_Q:
 305 //              case GL_TEXTURE_GEN_R:
 306 //              case GL_TEXTURE_GEN_S:
 307 //              case GL_TEXTURE_GEN_T:
 308 //              case GL_TEXTURE_1D:
 309 //              case GL_TEXTURE_2D:
 310 //              case GL_TEXTURE_3D:
 311         }
 312 }
 313
 314 static void nv30Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *params)
 315 {
 316     nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 317     switch(pname)
 318     {
 319         case GL_FOG_MODE:
 320             BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_MODE, 1);
 321             //OUT_RING (params);
 322             break;
 323             /* TODO: unsure about the rest.*/
 324         default:
 325             break;
 326     }
 327
 328 }
 329
 330 static void nv30Hint(GLcontext *ctx, GLenum target, GLenum mode)
 331 {
 332         // TODO I need love (fog and line_smooth hints)
 333 }
 334
 335 // void (*IndexMask)(GLcontext *ctx, GLuint mask);
 336
 337 static void nv30Lightfv(GLcontext *ctx, GLenum light, GLenum pname, const GLfloat *params )
 338 {
 339         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 340         /* not sure where the fourth param value goes...*/
 341         switch(pname)
 342         {
 343                 case GL_AMBIENT:
 344                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_A(light), 3);
 345                         OUT_RINGf(params[0]);
 346                         OUT_RINGf(params[1]);
 347                         OUT_RINGf(params[2]);
 348                         break;
 349                 case GL_DIFFUSE:
 350                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_A(light), 3);
 351                         OUT_RINGf(params[0]);
 352                         OUT_RINGf(params[1]);
 353                         OUT_RINGf(params[2]);
 354                         break;
 355                 case GL_SPECULAR:
 356                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_A(light), 3);
 357                         OUT_RINGf(params[0]);
 358                         OUT_RINGf(params[1]);
 359                         OUT_RINGf(params[2]);
 360                         break;
 361                 case GL_SPOT_DIRECTION:
 362                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_SPOT_DIR_X(light), 3);
 363                         OUT_RINGf(params[0]);
 364                         OUT_RINGf(params[1]);
 365                         OUT_RINGf(params[2]);
 366                         break;
 367                 case GL_POSITION:
 368                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_POSITION_X(light), 3);
 369                         OUT_RINGf(params[0]);
 370                         OUT_RINGf(params[1]);
 371                         OUT_RINGf(params[2]);
 372                         break;
 373                 case GL_SPOT_EXPONENT:
 374                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_SPOT_EXPONENT(light), 1);
 375                         OUT_RINGf(*params);
 376                         break;
 377                 case GL_SPOT_CUTOFF:
 378                         /* you can't factor these */
 379                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_SPOT_CUTOFF_A(light), 1);
 380                         OUT_RINGf(params[0]);
 381                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_SPOT_CUTOFF_B(light), 1);
 382                         OUT_RINGf(params[1]);
 383                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_SPOT_CUTOFF_C(light), 1);
 384                         OUT_RINGf(params[2]);
 385                         break;
 386                 case GL_CONSTANT_ATTENUATION:
 387                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_CONSTANT_ATTENUATION(light), 1);
 388                         OUT_RINGf(*params);
 389                         break;
 390                 case GL_LINEAR_ATTENUATION:
 391                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_LINEAR_ATTENUATION(light), 1);
 392                         OUT_RINGf(*params);
 393                         break;
 394                 case GL_QUADRATIC_ATTENUATION:
 395                         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LIGHT_QUADRATIC_ATTENUATION(light), 1);
 396                         OUT_RINGf(*params);
 397                         break;
 398                 default:
 399                         break;
 400         }
 401 }
 402
 403 /** Set the lighting model parameters */
 404 static void (*LightModelfv)(GLcontext *ctx, GLenum pname, const GLfloat *params);
 405
 406
 407 static void nv30LineStipple(GLcontext *ctx, GLint factor, GLushort pattern )
 408 {
 409         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 410         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LINE_STIPPLE_PATTERN, 1);
 411         OUT_RING((pattern << 16) | factor);
 412 }
 413
 414 static void nv30LineWidth(GLcontext *ctx, GLfloat width)
 415 {
 416         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 417         GLubyte ubWidth;
 418
 419         CLAMPED_FLOAT_TO_UBYTE(ubWidth, width);
 420
 421         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_LINE_WIDTH_SMOOTH, 1);
 422         OUT_RING(ubWidth);
 423 }
 424
 425 static void nv30LogicOpcode(GLcontext *ctx, GLenum opcode)
 426 {
 427         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 428         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_COLOR_LOGIC_OP_OP, 1);
 429         OUT_RING(opcode);
 430 }
 431
 432 static void nv30PointParameterfv(GLcontext *ctx, GLenum pname, const GLfloat *params)
 433 {
 434         /*TODO: not sure what goes here. */
 435         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 436
 437 }
 438
 439 /** Specify the diameter of rasterized points */
 440 static void nv30PointSize(GLcontext *ctx, GLfloat size)
 441 {
 442         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 443         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POINT_SIZE, 1);
 444         OUT_RINGf(size);
 445 }
 446
 447 /** Select a polygon rasterization mode */
 448 static void nv30PolygonMode(GLcontext *ctx, GLenum face, GLenum mode)
 449 {
 450         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 451
 452         if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
 453                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_MODE_FRONT, 1);
 454                 OUT_RING(mode);
 455         }
 456         if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
 457                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_POLYGON_MODE_BACK, 1);
 458                 OUT_RING(mode);
 459         }
 460 }
 461
 462 /** Set the scale and units used to calculate depth values */
 463 void (*PolygonOffset)(GLcontext *ctx, GLfloat factor, GLfloat units);
 464 /** Set the polygon stippling pattern */
 465 void (*PolygonStipple)(GLcontext *ctx, const GLubyte *mask );
 466 /* Specifies the current buffer for reading */
 467 void (*ReadBuffer)( GLcontext *ctx, GLenum buffer );
 468 /** Set rasterization mode */
 469 void (*RenderMode)(GLcontext *ctx, GLenum mode );
 470 /** Define the scissor box */
 471 void (*Scissor)(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
 472 /** Select flat or smooth shading */
 473 void nv30ShadeModel(GLcontext *ctx, GLenum mode)
 474 {
 475         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 476
 477         BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_SHADE_MODEL, 1);
 478         OUT_RING(mode);
 479 }
 480
 481 /** OpenGL 2.0 two-sided StencilFunc */
 482 static void nv30StencilFuncSeparate(GLcontext *ctx, GLenum face, GLenum func,
 483                 GLint ref, GLuint mask)
 484 {
 485         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 486
 487         if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
 488                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_FRONT_FUNC_FUNC, 3);
 489                 OUT_RING(func);
 490                 OUT_RING(ref);
 491                 OUT_RING(mask);
 492         }
 493         if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
 494                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_BACK_FUNC_FUNC, 3);
 495                 OUT_RING(func);
 496                 OUT_RING(ref);
 497                 OUT_RING(mask);
 498         }
 499 }
 500
 501 /** OpenGL 2.0 two-sided StencilMask */
 502 static void nv30StencilMaskSeparate(GLcontext *ctx, GLenum face, GLuint mask)
 503 {
 504         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 505
 506         if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
 507                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_FRONT_MASK, 1);
 508                 OUT_RING(mask);
 509         }
 510         if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
 511                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_BACK_MASK, 1);
 512                 OUT_RING(mask);
 513         }
 514 }
 515
 516 /** OpenGL 2.0 two-sided StencilOp */
 517 static void nv30StencilOpSeparate(GLcontext *ctx, GLenum face, GLenum fail,
 518                 GLenum zfail, GLenum zpass)
 519 {
 520         nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 521
 522         if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
 523                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_FRONT_OP_FAIL, 3);
 524                 OUT_RING(fail);
 525                 OUT_RING(zfail);
 526                 OUT_RING(zpass);
 527         }
 528         if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
 529                 BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_STENCIL_BACK_OP_FAIL, 3);
 530                 OUT_RING(fail);
 531                 OUT_RING(zfail);
 532                 OUT_RING(zpass);
 533         }
 534 }
 535
 536 /** Control the generation of texture coordinates */
 537 void (*TexGen)(GLcontext *ctx, GLenum coord, GLenum pname,
 538                 const GLfloat *params);
 539 /** Set texture environment parameters */
 540 void (*TexEnv)(GLcontext *ctx, GLenum target, GLenum pname,
 541                 const GLfloat *param);
 542 /** Set texture parameters */
 543 void (*TexParameter)(GLcontext *ctx, GLenum target,
 544                 struct gl_texture_object *texObj,
 545                 GLenum pname, const GLfloat *params);
 546 void (*TextureMatrix)(GLcontext *ctx, GLuint unit, const GLmatrix *mat);
 547
 548 /** Set the viewport */
 549 static void nv30Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
 550 {
 551     /* TODO: Where do the VIEWPORT_XFRM_* regs come in? */
 552     nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 553     BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_VIEWPORT_DIMS_0, 2);
 554     OUT_RING((w << 16) | x);
 555     OUT_RING((h << 16) | y);
 556 }
 557
 558 void nv30InitStateFuncs(struct dd_function_table *func)
 559 {
 560         func->AlphaFunc                 = nv30AlphaFunc;
 561         func->BlendColor                = nv30BlendColor;
 562         func->BlendEquationSeparate     = nv30BlendEquationSeparate;
 563         func->BlendFuncSeparate         = nv30BlendFuncSeparate;
 564         func->ClearColor                = nv30ClearColor;
 565         func->ClearDepth                = nv30ClearDepth;
 566         func->ClearStencil              = nv30ClearStencil;
 567         func->ClipPlane                 = nv30ClipPlane;
 568         func->ColorMask                 = nv30ColorMask;
 569         func->ColorMaterial             = nv30ColorMaterial;
 570         func->CullFace                  = nv30CullFace;
 571         func->FrontFace                 = nv30FrontFace;
 572         func->DepthFunc                 = nv30DepthFunc;
 573         func->DepthMask                 = nv30DepthMask;
 574         func->DepthRange                = nv30DepthRange;
 575         func->Enable                    = nv30Enable;
 576         func->Fogfv                     = nv30Fogfv;
 577         func->Hint                      = nv30Hint;
 578         func->Lightfv                   = nv30Lightfv;
 579 /*      func->LightModelfv              = nv30LightModelfv; */
 580         func->LineStipple               = nv30LineStipple;
 581         func->LineWidth                 = nv30LineWidth;
 582         func->LogicOpcode               = nv30LogicOpcode;
 583         func->PointParameterfv          = nv30PointParameterfv;
 584         func->PointSize                 = nv30PointSize;
 585         func->PolygonMode               = nv30PolygonMode;
 586 #if 0
 587         func->PolygonOffset             = nv30PolygonOffset;
 588         func->PolygonStipple            = nv30PolygonStipple;
 589         func->ReadBuffer                = nv30ReadBuffer;
 590         func->RenderMode                = nv30RenderMode;
 591         func->Scissor                   = nv30Scissor;
 592 #endif
 593         func->ShadeModel                = nv30ShadeModel;
 594         func->StencilFuncSeparate       = nv30StencilFuncSeparate;
 595         func->StencilMaskSeparate       = nv30StencilMaskSeparate;
 596         func->StencilOpSeparate         = nv30StencilOpSeparate;
 597 #if 0
 598         func->TexGen                    = nv30TexGen;
 599         func->TexParameter              = nv30TexParameter;
 600         func->TextureMatrix             = nv30TextureMatrix;
 601 #endif
 602         func->Viewport                  = nv30Viewport;
 603 }
 604