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

   1 /*
   2  * Copyright (C) 2009 Francisco Jerez.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  */
  26
  27 #include "nouveau_driver.h"
  28 #include "nouveau_context.h"
  29 #include "nouveau_texture.h"
  30 #include "nouveau_util.h"
  31
  32 #include "swrast/swrast.h"
  33 #include "tnl/tnl.h"
  34
  35 static void
  36 nouveau_alpha_func(GLcontext *ctx, GLenum func, GLfloat ref)
  37 {
  38         context_dirty(ctx, ALPHA_FUNC);
  39 }
  40
  41 static void
  42 nouveau_blend_color(GLcontext *ctx, const GLfloat color[4])
  43 {
  44         context_dirty(ctx, BLEND_COLOR);
  45 }
  46
  47 static void
  48 nouveau_blend_equation_separate(GLcontext *ctx, GLenum modeRGB, GLenum modeA)
  49 {
  50         context_dirty(ctx, BLEND_EQUATION);
  51 }
  52
  53 static void
  54 nouveau_blend_func_separate(GLcontext *ctx, GLenum sfactorRGB,
  55                             GLenum dfactorRGB, GLenum sfactorA, GLenum dfactorA)
  56 {
  57         context_dirty(ctx, BLEND_FUNC);
  58 }
  59
  60 static void
  61 nouveau_clip_plane(GLcontext *ctx, GLenum plane, const GLfloat *equation)
  62 {
  63         context_dirty_i(ctx, CLIP_PLANE, plane - GL_CLIP_PLANE0);
  64 }
  65
  66 static void
  67 nouveau_color_mask(GLcontext *ctx, GLboolean rmask, GLboolean gmask,
  68                    GLboolean bmask, GLboolean amask)
  69 {
  70         context_dirty(ctx, COLOR_MASK);
  71 }
  72
  73 static void
  74 nouveau_color_material(GLcontext *ctx, GLenum face, GLenum mode)
  75 {
  76         context_dirty(ctx, COLOR_MATERIAL);
  77         context_dirty(ctx, MATERIAL_FRONT_AMBIENT);
  78         context_dirty(ctx, MATERIAL_BACK_AMBIENT);
  79         context_dirty(ctx, MATERIAL_FRONT_DIFFUSE);
  80         context_dirty(ctx, MATERIAL_BACK_DIFFUSE);
  81         context_dirty(ctx, MATERIAL_FRONT_SPECULAR);
  82         context_dirty(ctx, MATERIAL_BACK_SPECULAR);
  83 }
  84
  85 static void
  86 nouveau_cull_face(GLcontext *ctx, GLenum mode)
  87 {
  88         context_dirty(ctx, CULL_FACE);
  89 }
  90
  91 static void
  92 nouveau_front_face(GLcontext *ctx, GLenum mode)
  93 {
  94         context_dirty(ctx, FRONT_FACE);
  95 }
  96
  97 static void
  98 nouveau_depth_func(GLcontext *ctx, GLenum func)
  99 {
 100         context_dirty(ctx, DEPTH);
 101 }
 102
 103 static void
 104 nouveau_depth_mask(GLcontext *ctx, GLboolean flag)
 105 {
 106         context_dirty(ctx, DEPTH);
 107 }
 108
 109 static void
 110 nouveau_depth_range(GLcontext *ctx, GLclampd nearval, GLclampd farval)
 111 {
 112         context_dirty(ctx, VIEWPORT);
 113 }
 114
 115 static void
 116 nouveau_draw_buffer(GLcontext *ctx, GLenum buffer)
 117 {
 118         context_dirty(ctx, FRAMEBUFFER);
 119 }
 120
 121 static void
 122 nouveau_draw_buffers(GLcontext *ctx, GLsizei n, const GLenum *buffers)
 123 {
 124         context_dirty(ctx, FRAMEBUFFER);
 125 }
 126
 127 static void
 128 nouveau_enable(GLcontext *ctx, GLenum cap, GLboolean state)
 129 {
 130         int i;
 131
 132         switch (cap) {
 133         case GL_ALPHA_TEST:
 134                 context_dirty(ctx, ALPHA_FUNC);
 135                 break;
 136         case GL_BLEND:
 137                 context_dirty(ctx, BLEND_EQUATION);
 138                 break;
 139         case GL_COLOR_LOGIC_OP:
 140                 context_dirty(ctx, LOGIC_OPCODE);
 141                 break;
 142         case GL_COLOR_MATERIAL:
 143                 context_dirty(ctx, COLOR_MATERIAL);
 144                 context_dirty(ctx, MATERIAL_FRONT_AMBIENT);
 145                 context_dirty(ctx, MATERIAL_BACK_AMBIENT);
 146                 context_dirty(ctx, MATERIAL_FRONT_DIFFUSE);
 147                 context_dirty(ctx, MATERIAL_BACK_DIFFUSE);
 148                 context_dirty(ctx, MATERIAL_FRONT_SPECULAR);
 149                 context_dirty(ctx, MATERIAL_BACK_SPECULAR);
 150                 break;
 151         case GL_COLOR_SUM_EXT:
 152                 context_dirty(ctx, FRAG);
 153                 context_dirty(ctx, LIGHT_MODEL);
 154                 break;
 155         case GL_CULL_FACE:
 156                 context_dirty(ctx, CULL_FACE);
 157                 break;
 158         case GL_DEPTH_TEST:
 159                 context_dirty(ctx, DEPTH);
 160                 break;
 161         case GL_DITHER:
 162                 context_dirty(ctx, DITHER);
 163                 break;
 164         case GL_FOG:
 165                 context_dirty(ctx, FOG);
 166                 context_dirty(ctx, FRAG);
 167                 context_dirty(ctx, MODELVIEW);
 168                 break;
 169         case GL_LIGHT0:
 170         case GL_LIGHT1:
 171         case GL_LIGHT2:
 172         case GL_LIGHT3:
 173         case GL_LIGHT4:
 174         case GL_LIGHT5:
 175         case GL_LIGHT6:
 176         case GL_LIGHT7:
 177                 context_dirty(ctx, MODELVIEW);
 178                 context_dirty(ctx, LIGHT_ENABLE);
 179                 context_dirty_i(ctx, LIGHT_SOURCE, cap - GL_LIGHT0);
 180                 context_dirty(ctx, MATERIAL_FRONT_AMBIENT);
 181                 context_dirty(ctx, MATERIAL_BACK_AMBIENT);
 182                 context_dirty(ctx, MATERIAL_FRONT_DIFFUSE);
 183                 context_dirty(ctx, MATERIAL_BACK_DIFFUSE);
 184                 context_dirty(ctx, MATERIAL_FRONT_SPECULAR);
 185                 context_dirty(ctx, MATERIAL_BACK_SPECULAR);
 186                 context_dirty(ctx, MATERIAL_FRONT_SHININESS);
 187                 context_dirty(ctx, MATERIAL_BACK_SHININESS);
 188                 break;
 189         case GL_LIGHTING:
 190                 context_dirty(ctx, FRAG);
 191                 context_dirty(ctx, MODELVIEW);
 192                 context_dirty(ctx, LIGHT_MODEL);
 193                 context_dirty(ctx, LIGHT_ENABLE);
 194
 195                 for (i = 0; i < MAX_LIGHTS; i++) {
 196                         if (ctx->Light.Light[i].Enabled)
 197                                 context_dirty_i(ctx, LIGHT_SOURCE, i);
 198                 }
 199
 200                 context_dirty(ctx, MATERIAL_FRONT_AMBIENT);
 201                 context_dirty(ctx, MATERIAL_BACK_AMBIENT);
 202                 context_dirty(ctx, MATERIAL_FRONT_DIFFUSE);
 203                 context_dirty(ctx, MATERIAL_BACK_DIFFUSE);
 204                 context_dirty(ctx, MATERIAL_FRONT_SPECULAR);
 205                 context_dirty(ctx, MATERIAL_BACK_SPECULAR);
 206                 context_dirty(ctx, MATERIAL_FRONT_SHININESS);
 207                 context_dirty(ctx, MATERIAL_BACK_SHININESS);
 208                 break;
 209         case GL_LINE_SMOOTH:
 210                 context_dirty(ctx, LINE_MODE);
 211                 break;
 212         case GL_NORMALIZE:
 213                 context_dirty(ctx, LIGHT_ENABLE);
 214                 break;
 215         case GL_POINT_SMOOTH:
 216                 context_dirty(ctx, POINT_MODE);
 217                 break;
 218         case GL_POLYGON_OFFSET_POINT:
 219         case GL_POLYGON_OFFSET_LINE:
 220         case GL_POLYGON_OFFSET_FILL:
 221                 context_dirty(ctx, POLYGON_OFFSET);
 222                 break;
 223         case GL_POLYGON_SMOOTH:
 224                 context_dirty(ctx, POLYGON_MODE);
 225                 break;
 226         case GL_SCISSOR_TEST:
 227                 context_dirty(ctx, SCISSOR);
 228                 break;
 229         case GL_STENCIL_TEST:
 230                 context_dirty(ctx, STENCIL_FUNC);
 231                 break;
 232         case GL_TEXTURE_1D:
 233         case GL_TEXTURE_2D:
 234         case GL_TEXTURE_3D:
 235                 context_dirty_i(ctx, TEX_ENV, ctx->Texture.CurrentUnit);
 236                 context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 237                 break;
 238         case GL_TEXTURE_GEN_S:
 239         case GL_TEXTURE_GEN_T:
 240         case GL_TEXTURE_GEN_R:
 241         case GL_TEXTURE_GEN_Q:
 242                 context_dirty_i(ctx, TEX_GEN, ctx->Texture.CurrentUnit);
 243                 context_dirty(ctx, MODELVIEW);
 244                 break;
 245         }
 246 }
 247
 248 static void
 249 nouveau_fog(GLcontext *ctx, GLenum pname, const GLfloat *params)
 250 {
 251         context_dirty(ctx, FOG);
 252 }
 253
 254 static void
 255 nouveau_light(GLcontext *ctx, GLenum light, GLenum pname, const GLfloat *params)
 256 {
 257         switch (pname) {
 258         case GL_AMBIENT:
 259                 context_dirty(ctx, MATERIAL_FRONT_AMBIENT);
 260                 context_dirty(ctx, MATERIAL_BACK_AMBIENT);
 261                 break;
 262         case GL_DIFFUSE:
 263                 context_dirty(ctx, MATERIAL_FRONT_DIFFUSE);
 264                 context_dirty(ctx, MATERIAL_BACK_DIFFUSE);
 265                 break;
 266         case GL_SPECULAR:
 267                 context_dirty(ctx, MATERIAL_FRONT_SPECULAR);
 268                 context_dirty(ctx, MATERIAL_BACK_SPECULAR);
 269                 break;
 270         case GL_SPOT_CUTOFF:
 271         case GL_POSITION:
 272                 context_dirty(ctx, MODELVIEW);
 273                 context_dirty(ctx, LIGHT_ENABLE);
 274                 context_dirty_i(ctx, LIGHT_SOURCE, light - GL_LIGHT0);
 275                 break;
 276         default:
 277                 context_dirty_i(ctx, LIGHT_SOURCE, light - GL_LIGHT0);
 278                 break;
 279         }
 280 }
 281
 282 static void
 283 nouveau_light_model(GLcontext *ctx, GLenum pname, const GLfloat *params)
 284 {
 285         context_dirty(ctx, LIGHT_MODEL);
 286         context_dirty(ctx, MODELVIEW);
 287 }
 288
 289 static void
 290 nouveau_line_stipple(GLcontext *ctx, GLint factor, GLushort pattern )
 291 {
 292         context_dirty(ctx, LINE_STIPPLE);
 293 }
 294
 295 static void
 296 nouveau_line_width(GLcontext *ctx, GLfloat width)
 297 {
 298         context_dirty(ctx, LINE_MODE);
 299 }
 300
 301 static void
 302 nouveau_logic_opcode(GLcontext *ctx, GLenum opcode)
 303 {
 304         context_dirty(ctx, LOGIC_OPCODE);
 305 }
 306
 307 static void
 308 nouveau_point_parameter(GLcontext *ctx, GLenum pname, const GLfloat *params)
 309 {
 310         context_dirty(ctx, POINT_PARAMETER);
 311 }
 312
 313 static void
 314 nouveau_point_size(GLcontext *ctx, GLfloat size)
 315 {
 316         context_dirty(ctx, POINT_MODE);
 317 }
 318
 319 static void
 320 nouveau_polygon_mode(GLcontext *ctx, GLenum face, GLenum mode)
 321 {
 322         context_dirty(ctx, POLYGON_MODE);
 323 }
 324
 325 static void
 326 nouveau_polygon_offset(GLcontext *ctx, GLfloat factor, GLfloat units)
 327 {
 328         context_dirty(ctx, POLYGON_OFFSET);
 329 }
 330
 331 static void
 332 nouveau_polygon_stipple(GLcontext *ctx, const GLubyte *mask)
 333 {
 334         context_dirty(ctx, POLYGON_STIPPLE);
 335 }
 336
 337 static void
 338 nouveau_render_mode(GLcontext *ctx, GLenum mode)
 339 {
 340         context_dirty(ctx, RENDER_MODE);
 341 }
 342
 343 static void
 344 nouveau_scissor(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
 345 {
 346         context_dirty(ctx, SCISSOR);
 347 }
 348
 349 static void
 350 nouveau_shade_model(GLcontext *ctx, GLenum mode)
 351 {
 352         context_dirty(ctx, SHADE_MODEL);
 353 }
 354
 355 static void
 356 nouveau_stencil_func_separate(GLcontext *ctx, GLenum face, GLenum func,
 357                               GLint ref, GLuint mask)
 358 {
 359         context_dirty(ctx, STENCIL_FUNC);
 360 }
 361
 362 static void
 363 nouveau_stencil_mask_separate(GLcontext *ctx, GLenum face, GLuint mask)
 364 {
 365         context_dirty(ctx, STENCIL_MASK);
 366 }
 367
 368 static void
 369 nouveau_stencil_op_separate(GLcontext *ctx, GLenum face, GLenum fail,
 370                             GLenum zfail, GLenum zpass)
 371 {
 372         context_dirty(ctx, STENCIL_OP);
 373 }
 374
 375 static void
 376 nouveau_tex_gen(GLcontext *ctx, GLenum coord, GLenum pname,
 377                 const GLfloat *params)
 378 {
 379         switch (pname) {
 380         case GL_TEXTURE_GEN_MODE:
 381                 context_dirty_i(ctx, TEX_GEN, ctx->Texture.CurrentUnit);
 382                 context_dirty(ctx, MODELVIEW);
 383                 break;
 384         default:
 385                 context_dirty_i(ctx, TEX_GEN, ctx->Texture.CurrentUnit);
 386                 break;
 387         }
 388 }
 389
 390 static void
 391 nouveau_tex_env(GLcontext *ctx, GLenum target, GLenum pname,
 392                 const GLfloat *param)
 393 {
 394         switch (target) {
 395         case GL_TEXTURE_FILTER_CONTROL_EXT:
 396                 context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 397                 break;
 398         default:
 399                 context_dirty_i(ctx, TEX_ENV, ctx->Texture.CurrentUnit);
 400                 break;
 401         }
 402 }
 403
 404 static void
 405 nouveau_tex_parameter(GLcontext *ctx, GLenum target,
 406                       struct gl_texture_object *t, GLenum pname,
 407                       const GLfloat *params)
 408 {
 409         switch (pname) {
 410         case GL_TEXTURE_MAG_FILTER:
 411         case GL_TEXTURE_WRAP_S:
 412         case GL_TEXTURE_WRAP_T:
 413         case GL_TEXTURE_WRAP_R:
 414         case GL_TEXTURE_MIN_LOD:
 415         case GL_TEXTURE_MAX_LOD:
 416         case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 417         case GL_TEXTURE_LOD_BIAS:
 418                 context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 419                 break;
 420
 421         case GL_TEXTURE_MIN_FILTER:
 422         case GL_TEXTURE_BASE_LEVEL:
 423         case GL_TEXTURE_MAX_LEVEL:
 424                 nouveau_texture_reallocate(ctx, t);
 425                 context_dirty_i(ctx, TEX_OBJ, ctx->Texture.CurrentUnit);
 426                 break;
 427         }
 428 }
 429
 430 static void
 431 nouveau_viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
 432 {
 433         context_dirty(ctx, VIEWPORT);
 434 }
 435
 436 void
 437 nouveau_emit_nothing(GLcontext *ctx, int emit)
 438 {
 439 }
 440
 441 int
 442 nouveau_next_dirty_state(GLcontext *ctx)
 443 {
 444         struct nouveau_context *nctx = to_nouveau_context(ctx);
 445         int i = BITSET_FFS(nctx->dirty) - 1;
 446
 447         if (i < 0 || i >= context_drv(ctx)->num_emit)
 448                 return -1;
 449
 450         return i;
 451 }
 452
 453 void
 454 nouveau_state_emit(GLcontext *ctx)
 455 {
 456         struct nouveau_context *nctx = to_nouveau_context(ctx);
 457         const struct nouveau_driver *drv = context_drv(ctx);
 458         int i;
 459
 460         while ((i = nouveau_next_dirty_state(ctx)) >= 0) {
 461                 BITSET_CLEAR(nctx->dirty, i);
 462                 drv->emit[i](ctx, i);
 463         }
 464
 465         BITSET_ZERO(nctx->dirty);
 466
 467         nouveau_bo_state_emit(ctx);
 468 }
 469
 470 static void
 471 nouveau_update_state(GLcontext *ctx, GLbitfield new_state)
 472 {
 473         int i;
 474
 475         if (new_state & (_NEW_PROJECTION | _NEW_MODELVIEW))
 476                 context_dirty(ctx, PROJECTION);
 477
 478         if (new_state & _NEW_MODELVIEW)
 479                 context_dirty(ctx, MODELVIEW);
 480
 481         if (new_state & _NEW_TEXTURE_MATRIX) {
 482                 for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
 483                         context_dirty_i(ctx, TEX_MAT, i);
 484         }
 485
 486         if (new_state & _NEW_CURRENT_ATTRIB &&
 487             new_state & _NEW_LIGHT) {
 488                 context_dirty(ctx, MATERIAL_FRONT_AMBIENT);
 489                 context_dirty(ctx, MATERIAL_BACK_AMBIENT);
 490                 context_dirty(ctx, MATERIAL_FRONT_DIFFUSE);
 491                 context_dirty(ctx, MATERIAL_BACK_DIFFUSE);
 492                 context_dirty(ctx, MATERIAL_FRONT_SPECULAR);
 493                 context_dirty(ctx, MATERIAL_BACK_SPECULAR);
 494                 context_dirty(ctx, MATERIAL_FRONT_SHININESS);
 495                 context_dirty(ctx, MATERIAL_BACK_SHININESS);
 496         }
 497
 498         _swrast_InvalidateState(ctx, new_state);
 499         _tnl_InvalidateState(ctx, new_state);
 500
 501         nouveau_state_emit(ctx);
 502 }
 503
 504 void
 505 nouveau_state_init(GLcontext *ctx)
 506 {
 507         struct nouveau_context *nctx = to_nouveau_context(ctx);
 508
 509         ctx->Driver.AlphaFunc = nouveau_alpha_func;
 510         ctx->Driver.BlendColor = nouveau_blend_color;
 511         ctx->Driver.BlendEquationSeparate = nouveau_blend_equation_separate;
 512         ctx->Driver.BlendFuncSeparate = nouveau_blend_func_separate;
 513         ctx->Driver.ClipPlane = nouveau_clip_plane;
 514         ctx->Driver.ColorMask = nouveau_color_mask;
 515         ctx->Driver.ColorMaterial = nouveau_color_material;
 516         ctx->Driver.CullFace = nouveau_cull_face;
 517         ctx->Driver.FrontFace = nouveau_front_face;
 518         ctx->Driver.DepthFunc = nouveau_depth_func;
 519         ctx->Driver.DepthMask = nouveau_depth_mask;
 520         ctx->Driver.DepthRange = nouveau_depth_range;
 521         ctx->Driver.DrawBuffer = nouveau_draw_buffer;
 522         ctx->Driver.DrawBuffers = nouveau_draw_buffers;
 523         ctx->Driver.Enable = nouveau_enable;
 524         ctx->Driver.Fogfv = nouveau_fog;
 525         ctx->Driver.Lightfv = nouveau_light;
 526         ctx->Driver.LightModelfv = nouveau_light_model;
 527         ctx->Driver.LineStipple = nouveau_line_stipple;
 528         ctx->Driver.LineWidth = nouveau_line_width;
 529         ctx->Driver.LogicOpcode = nouveau_logic_opcode;
 530         ctx->Driver.PointParameterfv = nouveau_point_parameter;
 531         ctx->Driver.PointSize = nouveau_point_size;
 532         ctx->Driver.PolygonMode = nouveau_polygon_mode;
 533         ctx->Driver.PolygonOffset = nouveau_polygon_offset;
 534         ctx->Driver.PolygonStipple = nouveau_polygon_stipple;
 535         ctx->Driver.RenderMode = nouveau_render_mode;
 536         ctx->Driver.Scissor = nouveau_scissor;
 537         ctx->Driver.ShadeModel = nouveau_shade_model;
 538         ctx->Driver.StencilFuncSeparate = nouveau_stencil_func_separate;
 539         ctx->Driver.StencilMaskSeparate = nouveau_stencil_mask_separate;
 540         ctx->Driver.StencilOpSeparate = nouveau_stencil_op_separate;
 541         ctx->Driver.TexGen = nouveau_tex_gen;
 542         ctx->Driver.TexEnv = nouveau_tex_env;
 543         ctx->Driver.TexParameter = nouveau_tex_parameter;
 544         ctx->Driver.Viewport = nouveau_viewport;
 545
 546         ctx->Driver.UpdateState = nouveau_update_state;
 547
 548         BITSET_ONES(nctx->dirty);
 549 }