i915_state.c 24.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/**************************************************************************
 * 
 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * 
 **************************************************************************/

/* Authors:  Keith Whitwell <keith@tungstengraphics.com>
 */
30

31

32
#include "draw/draw_context.h"
Zack Rusin's avatar
Zack Rusin committed
33
#include "pipe/internal/p_winsys_screen.h"
34
#include "pipe/p_inlines.h"
35 36
#include "util/u_math.h"
#include "util/u_memory.h"
37
#include "tgsi/tgsi_parse.h"
38 39

#include "i915_context.h"
40
#include "i915_reg.h"
41
#include "i915_state.h"
42
#include "i915_state_inlines.h"
43
#include "i915_fpc.h"
44

Zack Rusin's avatar
Zack Rusin committed
45 46 47
/* The i915 (and related graphics cores) do not support GL_CLAMP.  The
 * Intel drivers for "other operating systems" implement GL_CLAMP as
 * GL_CLAMP_TO_EDGE, so the same is done here.
48
 */
Zack Rusin's avatar
Zack Rusin committed
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
static unsigned
translate_wrap_mode(unsigned wrap)
{
   switch (wrap) {
   case PIPE_TEX_WRAP_REPEAT:
      return TEXCOORDMODE_WRAP;
   case PIPE_TEX_WRAP_CLAMP:
      return TEXCOORDMODE_CLAMP_EDGE;   /* not quite correct */
   case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
      return TEXCOORDMODE_CLAMP_EDGE;
   case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
      return TEXCOORDMODE_CLAMP_BORDER;
//   case PIPE_TEX_WRAP_MIRRORED_REPEAT:
//      return TEXCOORDMODE_MIRROR;
   default:
      return TEXCOORDMODE_WRAP;
   }
}

static unsigned translate_img_filter( unsigned filter )
{
   switch (filter) {
   case PIPE_TEX_FILTER_NEAREST:
      return FILTER_NEAREST;
   case PIPE_TEX_FILTER_LINEAR:
      return FILTER_LINEAR;
75 76
   case PIPE_TEX_FILTER_ANISO:
      return FILTER_ANISOTROPIC;
Zack Rusin's avatar
Zack Rusin committed
77 78 79 80 81 82 83 84 85 86 87 88 89
   default:
      assert(0);
      return FILTER_NEAREST;
   }
}

static unsigned translate_mip_filter( unsigned filter )
{
   switch (filter) {
   case PIPE_TEX_MIPFILTER_NONE:
      return MIPFILTER_NONE;
   case PIPE_TEX_MIPFILTER_NEAREST:
      return MIPFILTER_NEAREST;
90
   case PIPE_TEX_MIPFILTER_LINEAR:
Zack Rusin's avatar
Zack Rusin committed
91 92 93 94 95 96 97 98 99 100
      return MIPFILTER_LINEAR;
   default:
      assert(0);
      return MIPFILTER_NONE;
   }
}


/* None of this state is actually used for anything yet.
 */
101
static void *
102 103 104
i915_create_blend_state(struct pipe_context *pipe,
                        const struct pipe_blend_state *blend)
{
Michal's avatar
Michal committed
105
   struct i915_blend_state *cso_data = CALLOC_STRUCT( i915_blend_state );
106

107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
   {
      unsigned eqRGB  = blend->rgb_func;
      unsigned srcRGB = blend->rgb_src_factor;
      unsigned dstRGB = blend->rgb_dst_factor;

      unsigned eqA    = blend->alpha_func;
      unsigned srcA   = blend->alpha_src_factor;
      unsigned dstA   = blend->alpha_dst_factor;

      /* Special handling for MIN/MAX filter modes handled at
       * state_tracker level.
       */

      if (srcA != srcRGB ||
	  dstA != dstRGB ||
	  eqA != eqRGB) {

	 cso_data->iab = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD |
                          IAB_MODIFY_ENABLE |
                          IAB_ENABLE |
                          IAB_MODIFY_FUNC |
                          IAB_MODIFY_SRC_FACTOR |
                          IAB_MODIFY_DST_FACTOR |
                          SRC_ABLND_FACT(i915_translate_blend_factor(srcA)) |
                          DST_ABLND_FACT(i915_translate_blend_factor(dstA)) |
                          (i915_translate_blend_func(eqA) << IAB_FUNC_SHIFT));
      }
      else {
	 cso_data->iab = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD |
                          IAB_MODIFY_ENABLE |
                          0);
      }
   }

   cso_data->modes4 |= (_3DSTATE_MODES_4_CMD |
                        ENABLE_LOGIC_OP_FUNC |
                        LOGIC_OP_FUNC(i915_translate_logic_op(blend->logicop_func)));

   if (blend->logicop_enable)
      cso_data->LIS5 |= S5_LOGICOP_ENABLE;

   if (blend->dither)
      cso_data->LIS5 |= S5_COLOR_DITHER_ENABLE;

   if ((blend->colormask & PIPE_MASK_R) == 0)
      cso_data->LIS5 |= S5_WRITEDISABLE_RED;

   if ((blend->colormask & PIPE_MASK_G) == 0)
      cso_data->LIS5 |= S5_WRITEDISABLE_GREEN;

   if ((blend->colormask & PIPE_MASK_B) == 0)
      cso_data->LIS5 |= S5_WRITEDISABLE_BLUE;

   if ((blend->colormask & PIPE_MASK_A) == 0)
      cso_data->LIS5 |= S5_WRITEDISABLE_ALPHA;

   if (blend->blend_enable) {
      unsigned funcRGB = blend->rgb_func;
      unsigned srcRGB  = blend->rgb_src_factor;
      unsigned dstRGB  = blend->rgb_dst_factor;

      cso_data->LIS6 |= (S6_CBUF_BLEND_ENABLE |
                         SRC_BLND_FACT(i915_translate_blend_factor(srcRGB)) |
                         DST_BLND_FACT(i915_translate_blend_factor(dstRGB)) |
                         (i915_translate_blend_func(funcRGB) << S6_CBUF_BLEND_FUNC_SHIFT));
   }

   return cso_data;
175 176
}

177 178
static void i915_bind_blend_state(struct pipe_context *pipe,
                                  void *blend)
179 180
{
   struct i915_context *i915 = i915_context(pipe);
181
   draw_flush(i915->draw);
182

183
   i915->blend = (struct i915_blend_state*)blend;
184 185 186 187 188

   i915->dirty |= I915_NEW_BLEND;
}


189
static void i915_delete_blend_state(struct pipe_context *pipe, void *blend)
190
{
Michal's avatar
Michal committed
191
   FREE(blend);
192 193
}

194 195 196 197
static void i915_set_blend_color( struct pipe_context *pipe,
			     const struct pipe_blend_color *blend_color )
{
   struct i915_context *i915 = i915_context(pipe);
198
   draw_flush(i915->draw);
199 200 201 202 203 204

   i915->blend_color = *blend_color;

   i915->dirty |= I915_NEW_BLEND;
}

205
static void *
206 207 208
i915_create_sampler_state(struct pipe_context *pipe,
                          const struct pipe_sampler_state *sampler)
{
Michal's avatar
Michal committed
209
   struct i915_sampler_state *cso = CALLOC_STRUCT( i915_sampler_state );
Zack Rusin's avatar
Zack Rusin committed
210 211 212 213 214 215
   const unsigned ws = sampler->wrap_s;
   const unsigned wt = sampler->wrap_t;
   const unsigned wr = sampler->wrap_r;
   unsigned minFilt, magFilt;
   unsigned mipFilt;

Michal's avatar
Michal committed
216 217
   cso->templ = sampler;

Zack Rusin's avatar
Zack Rusin committed
218
   mipFilt = translate_mip_filter(sampler->min_mip_filter);
219 220 221 222 223
   minFilt = translate_img_filter( sampler->min_img_filter );
   magFilt = translate_img_filter( sampler->mag_img_filter );
   
   if (sampler->max_anisotropy > 2.0) {
      cso->state[0] |= SS2_MAX_ANISO_4;
Zack Rusin's avatar
Zack Rusin committed
224 225 226
   }

   {
Michal's avatar
Michal committed
227
      int b = (int) (sampler->lod_bias * 16.0);
Zack Rusin's avatar
Zack Rusin committed
228 229 230 231 232 233 234 235 236
      b = CLAMP(b, -256, 255);
      cso->state[0] |= ((b << SS2_LOD_BIAS_SHIFT) & SS2_LOD_BIAS_MASK);
   }

   /* Shadow:
    */
   if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) 
   {
      cso->state[0] |= (SS2_SHADOW_ENABLE |
237
                        i915_translate_compare_func(sampler->compare_func));
Zack Rusin's avatar
Zack Rusin committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251

      minFilt = FILTER_4X4_FLAT;
      magFilt = FILTER_4X4_FLAT;
   }

   cso->state[0] |= ((minFilt << SS2_MIN_FILTER_SHIFT) |
                     (mipFilt << SS2_MIP_FILTER_SHIFT) |
                     (magFilt << SS2_MAG_FILTER_SHIFT));

   cso->state[1] |=
      ((translate_wrap_mode(ws) << SS3_TCX_ADDR_MODE_SHIFT) |
       (translate_wrap_mode(wt) << SS3_TCY_ADDR_MODE_SHIFT) |
       (translate_wrap_mode(wr) << SS3_TCZ_ADDR_MODE_SHIFT));

252 253 254
   if (sampler->normalized_coords)
      cso->state[1] |= SS3_NORMALIZED_COORDS;

255 256
   {
      int minlod = (int) (16.0 * sampler->min_lod);
257
      int maxlod = (int) (16.0 * sampler->max_lod);
258
      minlod = CLAMP(minlod, 0, 16 * 11);
259 260 261 262 263 264 265
      maxlod = CLAMP(maxlod, 0, 16 * 11);

      if (minlod > maxlod)
	 maxlod = minlod;

      cso->minlod = minlod;
      cso->maxlod = maxlod;
266 267
   }

Zack Rusin's avatar
Zack Rusin committed
268 269 270 271 272 273 274 275
   {
      ubyte r = float_to_ubyte(sampler->border_color[0]);
      ubyte g = float_to_ubyte(sampler->border_color[1]);
      ubyte b = float_to_ubyte(sampler->border_color[2]);
      ubyte a = float_to_ubyte(sampler->border_color[3]);
      cso->state[2] = I915PACKCOLOR8888(r, g, b, a);
   }
   return cso;
276 277
}

278 279
static void i915_bind_sampler_states(struct pipe_context *pipe,
                                     unsigned num, void **sampler)
280 281
{
   struct i915_context *i915 = i915_context(pipe);
282
   unsigned i;
283

284 285 286 287 288 289 290
   assert(num <= PIPE_MAX_SAMPLERS);

   /* Check for no-op */
   if (num == i915->num_samplers &&
       !memcmp(i915->sampler, sampler, num * sizeof(void *)))
      return;

291 292
   draw_flush(i915->draw);

293 294 295 296
   for (i = 0; i < num; ++i)
      i915->sampler[i] = sampler[i];
   for (i = num; i < PIPE_MAX_SAMPLERS; ++i)
      i915->sampler[i] = NULL;
297 298

   i915->num_samplers = num;
299 300 301 302 303

   i915->dirty |= I915_NEW_SAMPLER;
}

static void i915_delete_sampler_state(struct pipe_context *pipe,
304
                                      void *sampler)
305
{
Michal's avatar
Michal committed
306
   FREE(sampler);
307 308
}

309 310 311 312 313

/** XXX move someday?  Or consolidate all these simple state setters
 * into one file.
 */

314
static void *
315
i915_create_depth_stencil_state(struct pipe_context *pipe,
316
				const struct pipe_depth_stencil_alpha_state *depth_stencil)
317
{
Michal's avatar
Michal committed
318
   struct i915_depth_stencil_state *cso = CALLOC_STRUCT( i915_depth_stencil_state );
319 320

   {
321 322
      int testmask = depth_stencil->stencil[0].valuemask & 0xff;
      int writemask = depth_stencil->stencil[0].writemask & 0xff;
323 324 325 326 327 328 329 330

      cso->stencil_modes4 |= (_3DSTATE_MODES_4_CMD |
                              ENABLE_STENCIL_TEST_MASK |
                              STENCIL_TEST_MASK(testmask) |
                              ENABLE_STENCIL_WRITE_MASK |
                              STENCIL_WRITE_MASK(writemask));
   }

331 332 333 334 335 336
   if (depth_stencil->stencil[0].enabled) {
      int test = i915_translate_compare_func(depth_stencil->stencil[0].func);
      int fop  = i915_translate_stencil_op(depth_stencil->stencil[0].fail_op);
      int dfop = i915_translate_stencil_op(depth_stencil->stencil[0].zfail_op);
      int dpop = i915_translate_stencil_op(depth_stencil->stencil[0].zpass_op);
      int ref  = depth_stencil->stencil[0].ref_value & 0xff;
337 338 339 340 341 342 343 344 345 346

      cso->stencil_LIS5 |= (S5_STENCIL_TEST_ENABLE |
                            S5_STENCIL_WRITE_ENABLE |
                            (ref  << S5_STENCIL_REF_SHIFT) |
                            (test << S5_STENCIL_TEST_FUNC_SHIFT) |
                            (fop  << S5_STENCIL_FAIL_SHIFT) |
                            (dfop << S5_STENCIL_PASS_Z_FAIL_SHIFT) |
                            (dpop << S5_STENCIL_PASS_Z_PASS_SHIFT));
   }

347 348 349 350 351 352
   if (depth_stencil->stencil[1].enabled) {
      int test  = i915_translate_compare_func(depth_stencil->stencil[1].func);
      int fop   = i915_translate_stencil_op(depth_stencil->stencil[1].fail_op);
      int dfop  = i915_translate_stencil_op(depth_stencil->stencil[1].zfail_op);
      int dpop  = i915_translate_stencil_op(depth_stencil->stencil[1].zpass_op);
      int ref   = depth_stencil->stencil[1].ref_value & 0xff;
353 354
      int tmask = depth_stencil->stencil[1].valuemask & 0xff;
      int wmask = depth_stencil->stencil[1].writemask & 0xff;
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394

      cso->bfo[0] = (_3DSTATE_BACKFACE_STENCIL_OPS |
                     BFO_ENABLE_STENCIL_FUNCS |
                     BFO_ENABLE_STENCIL_TWO_SIDE |
                     BFO_ENABLE_STENCIL_REF |
                     BFO_STENCIL_TWO_SIDE |
                     (ref  << BFO_STENCIL_REF_SHIFT) |
                     (test << BFO_STENCIL_TEST_SHIFT) |
                     (fop  << BFO_STENCIL_FAIL_SHIFT) |
                     (dfop << BFO_STENCIL_PASS_Z_FAIL_SHIFT) |
                     (dpop << BFO_STENCIL_PASS_Z_PASS_SHIFT));

      cso->bfo[1] = (_3DSTATE_BACKFACE_STENCIL_MASKS |
                     BFM_ENABLE_STENCIL_TEST_MASK |
                     BFM_ENABLE_STENCIL_WRITE_MASK |
                     (tmask << BFM_STENCIL_TEST_MASK_SHIFT) |
                     (wmask << BFM_STENCIL_WRITE_MASK_SHIFT));
   }
   else {
      /* This actually disables two-side stencil: The bit set is a
       * modify-enable bit to indicate we are changing the two-side
       * setting.  Then there is a symbolic zero to show that we are
       * setting the flag to zero/off.
       */
      cso->bfo[0] = (_3DSTATE_BACKFACE_STENCIL_OPS |
                     BFO_ENABLE_STENCIL_TWO_SIDE |
                     0);
      cso->bfo[1] = 0;
   }

   if (depth_stencil->depth.enabled) {
      int func = i915_translate_compare_func(depth_stencil->depth.func);

      cso->depth_LIS6 |= (S6_DEPTH_TEST_ENABLE |
                          (func << S6_DEPTH_TEST_FUNC_SHIFT));

      if (depth_stencil->depth.writemask)
	 cso->depth_LIS6 |= S6_DEPTH_WRITE_ENABLE;
   }

395 396
   if (depth_stencil->alpha.enabled) {
      int test = i915_translate_compare_func(depth_stencil->alpha.func);
397
      ubyte refByte = float_to_ubyte(depth_stencil->alpha.ref_value);
398 399 400 401 402 403

      cso->depth_LIS6 |= (S6_ALPHA_TEST_ENABLE |
			  (test << S6_ALPHA_TEST_FUNC_SHIFT) |
			  (((unsigned) refByte) << S6_ALPHA_REF_SHIFT));
   }

404
   return cso;
405 406
}

407
static void i915_bind_depth_stencil_state(struct pipe_context *pipe,
408
                                          void *depth_stencil)
409 410
{
   struct i915_context *i915 = i915_context(pipe);
411
   draw_flush(i915->draw);
412

413
   i915->depth_stencil = (const struct i915_depth_stencil_state *)depth_stencil;
414

415
   i915->dirty |= I915_NEW_DEPTH_STENCIL;
416 417
}

418
static void i915_delete_depth_stencil_state(struct pipe_context *pipe,
419
                                            void *depth_stencil)
420
{
Michal's avatar
Michal committed
421
   FREE(depth_stencil);
422 423
}

Zack Rusin's avatar
Zack Rusin committed
424

425 426 427 428
static void i915_set_scissor_state( struct pipe_context *pipe,
                                 const struct pipe_scissor_state *scissor )
{
   struct i915_context *i915 = i915_context(pipe);
429
   draw_flush(i915->draw);
430 431 432 433 434 435 436 437 438 439 440

   memcpy( &i915->scissor, scissor, sizeof(*scissor) );
   i915->dirty |= I915_NEW_SCISSOR;
}


static void i915_set_polygon_stipple( struct pipe_context *pipe,
                                   const struct pipe_poly_stipple *stipple )
{
}

441

442 443 444 445

static void *
i915_create_fs_state(struct pipe_context *pipe,
                     const struct pipe_shader_state *templ)
446
{
447 448 449 450 451
   struct i915_context *i915 = i915_context(pipe);
   struct i915_fragment_shader *ifs = CALLOC_STRUCT(i915_fragment_shader);
   if (!ifs)
      return NULL;

452
   ifs->state.tokens = tgsi_dup_tokens(templ->tokens);
453

454 455
   tgsi_scan_shader(templ->tokens, &ifs->info);

456 457 458 459
   /* The shader's compiled to i915 instructions here */
   i915_translate_fragment_program(i915, ifs);

   return ifs;
460
}
461

462 463
static void
i915_bind_fs_state(struct pipe_context *pipe, void *shader)
464 465
{
   struct i915_context *i915 = i915_context(pipe);
466
   draw_flush(i915->draw);
467

468
   i915->fs = (struct i915_fragment_shader*) shader;
469 470 471 472

   i915->dirty |= I915_NEW_FS;
}

473 474
static
void i915_delete_fs_state(struct pipe_context *pipe, void *shader)
475
{
476 477 478 479 480 481
   struct i915_fragment_shader *ifs = (struct i915_fragment_shader *) shader;

   if (ifs->program)
      FREE(ifs->program);
   ifs->program_len = 0;

José Fonseca's avatar
José Fonseca committed
482
   FREE((struct tgsi_token *)ifs->state.tokens);
483

484
   FREE(ifs);
485
}
Brian's avatar
Brian committed
486

487

488 489 490
static void *
i915_create_vs_state(struct pipe_context *pipe,
                     const struct pipe_shader_state *templ)
491
{
492 493 494
   struct i915_context *i915 = i915_context(pipe);

   /* just pass-through to draw module */
495
   return draw_create_vertex_shader(i915->draw, templ);
496 497
}

498
static void i915_bind_vs_state(struct pipe_context *pipe, void *shader)
499
{
500 501 502
   struct i915_context *i915 = i915_context(pipe);

   /* just pass-through to draw module */
503
   draw_bind_vertex_shader(i915->draw, (struct draw_vertex_shader *) shader);
504 505

   i915->dirty |= I915_NEW_VS;
506 507 508 509 510 511 512
}

static void i915_delete_vs_state(struct pipe_context *pipe, void *shader)
{
   struct i915_context *i915 = i915_context(pipe);

   /* just pass-through to draw module */
513
   draw_delete_vertex_shader(i915->draw, (struct draw_vertex_shader *) shader);
514
}
Brian's avatar
Brian committed
515

Brian's avatar
Brian committed
516 517 518 519 520 521
static void i915_set_constant_buffer(struct pipe_context *pipe,
                                     uint shader, uint index,
                                     const struct pipe_constant_buffer *buf)
{
   struct i915_context *i915 = i915_context(pipe);
   struct pipe_winsys *ws = pipe->winsys;
522
   draw_flush(i915->draw);
Brian's avatar
Brian committed
523 524 525 526 527 528 529 530 531 532 533 534 535

   assert(shader < PIPE_SHADER_TYPES);
   assert(index == 0);

   /* Make a copy of shader constants.
    * During fragment program translation we may add additional
    * constants to the array.
    *
    * We want to consider the situation where some user constants
    * (ex: a material color) may change frequently but the shader program
    * stays the same.  In that case we should only be updating the first
    * N constants, leaving any extras from shader translation alone.
    */
Brian's avatar
Brian committed
536
   if (buf) {
Brian's avatar
Brian committed
537
      void *mapped;
538
      if (buf->buffer && buf->buffer->size &&
Zack Rusin's avatar
Zack Rusin committed
539
          (mapped = ws->buffer_map(ws, buf->buffer,
540
                                    PIPE_BUFFER_USAGE_CPU_READ))) {
541
         memcpy(i915->current.constants[shader], mapped, buf->buffer->size);
Zack Rusin's avatar
Zack Rusin committed
542
         ws->buffer_unmap(ws, buf->buffer);
Brian's avatar
Brian committed
543
         i915->current.num_user_constants[shader]
544
            = buf->buffer->size / (4 * sizeof(float));
Brian's avatar
Brian committed
545 546 547 548 549 550 551 552 553 554
      }
      else {
         i915->current.num_user_constants[shader] = 0;
      }
   }

   i915->dirty |= I915_NEW_CONSTANTS;
}


555 556 557
static void i915_set_sampler_textures(struct pipe_context *pipe,
                                      unsigned num,
                                      struct pipe_texture **texture)
558 559
{
   struct i915_context *i915 = i915_context(pipe);
560 561 562 563 564 565 566 567 568
   uint i;

   assert(num <= PIPE_MAX_SAMPLERS);

   /* Check for no-op */
   if (num == i915->num_textures &&
       !memcmp(i915->texture, texture, num * sizeof(struct pipe_texture *)))
      return;

569 570 571
   /* Fixes wrong texture in texobj with VBUF */
   draw_flush(i915->draw);

572 573 574 575 576 577 578
   for (i = 0; i < num; i++)
      pipe_texture_reference((struct pipe_texture **) &i915->texture[i],
                             texture[i]);

   for (i = num; i < i915->num_textures; i++)
      pipe_texture_reference((struct pipe_texture **) &i915->texture[i],
                             NULL);
579

580
   i915->num_textures = num;
581 582 583 584 585 586 587

   i915->dirty |= I915_NEW_TEXTURE;
}



static void i915_set_framebuffer_state(struct pipe_context *pipe,
588
				       const struct pipe_framebuffer_state *fb)
589 590
{
   struct i915_context *i915 = i915_context(pipe);
591
   draw_flush(i915->draw);
592 593 594 595 596 597 598 599 600 601 602 603

   i915->framebuffer = *fb; /* struct copy */

   i915->dirty |= I915_NEW_FRAMEBUFFER;
}



static void i915_set_clip_state( struct pipe_context *pipe,
			     const struct pipe_clip_state *clip )
{
   struct i915_context *i915 = i915_context(pipe);
604
   draw_flush(i915->draw);
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623

   draw_set_clip_state(i915->draw, clip);

   i915->dirty |= I915_NEW_CLIP;
}



/* Called when driver state tracker notices changes to the viewport
 * matrix:
 */
static void i915_set_viewport_state( struct pipe_context *pipe,
				     const struct pipe_viewport_state *viewport )
{
   struct i915_context *i915 = i915_context(pipe);

   i915->viewport = *viewport; /* struct copy */

   /* pass the viewport info to the draw module */
624
   draw_set_viewport_state(i915->draw, &i915->viewport);
625 626 627 628

   i915->dirty |= I915_NEW_VIEWPORT;
}

629

630
static void *
631
i915_create_rasterizer_state(struct pipe_context *pipe,
632
                             const struct pipe_rasterizer_state *rasterizer)
633
{
Michal's avatar
Michal committed
634
   struct i915_rasterizer_state *cso = CALLOC_STRUCT( i915_rasterizer_state );
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685

   cso->templ = rasterizer;
   cso->color_interp = rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR;
   cso->light_twoside = rasterizer->light_twoside;
   cso->ds[0].u = _3DSTATE_DEPTH_OFFSET_SCALE;
   cso->ds[1].f = rasterizer->offset_scale;
   if (rasterizer->poly_stipple_enable) {
      cso->st |= ST1_ENABLE;
   }

   if (rasterizer->scissor)
      cso->sc[0] = _3DSTATE_SCISSOR_ENABLE_CMD | ENABLE_SCISSOR_RECT;
   else
      cso->sc[0] = _3DSTATE_SCISSOR_ENABLE_CMD | DISABLE_SCISSOR_RECT;

   switch (rasterizer->cull_mode) {
   case PIPE_WINDING_NONE:
      cso->LIS4 |= S4_CULLMODE_NONE;
      break;
   case PIPE_WINDING_CW:
      cso->LIS4 |= S4_CULLMODE_CW;
      break;
   case PIPE_WINDING_CCW:
      cso->LIS4 |= S4_CULLMODE_CCW;
      break;
   case PIPE_WINDING_BOTH:
      cso->LIS4 |= S4_CULLMODE_BOTH;
      break;
   }

   {
      int line_width = CLAMP((int)(rasterizer->line_width * 2), 1, 0xf);

      cso->LIS4 |= line_width << S4_LINE_WIDTH_SHIFT;

      if (rasterizer->line_smooth)
	 cso->LIS4 |= S4_LINE_ANTIALIAS_ENABLE;
   }

   {
      int point_size = CLAMP((int) rasterizer->point_size, 1, 0xff);

      cso->LIS4 |= point_size << S4_POINT_WIDTH_SHIFT;
   }

   if (rasterizer->flatshade) {
      cso->LIS4 |= (S4_FLATSHADE_ALPHA |
                    S4_FLATSHADE_COLOR |
                    S4_FLATSHADE_SPECULAR);
   }

Michal's avatar
Michal committed
686
   cso->LIS7 = fui( rasterizer->offset_units );
687 688 689


   return cso;
690 691 692
}

static void i915_bind_rasterizer_state( struct pipe_context *pipe,
693
                                        void *raster )
694 695 696
{
   struct i915_context *i915 = i915_context(pipe);

697
   i915->rasterizer = (struct i915_rasterizer_state *)raster;
698 699

   /* pass-through to draw module */
700 701
   draw_set_rasterizer_state(i915->draw,
                          (i915->rasterizer ? i915->rasterizer->templ : NULL));
702

703
   i915->dirty |= I915_NEW_RASTERIZER;
704 705
}

706
static void i915_delete_rasterizer_state(struct pipe_context *pipe,
707
                                         void *raster)
708
{
709
   FREE(raster);
710
}
711

712 713 714
static void i915_set_vertex_buffers(struct pipe_context *pipe,
                                    unsigned count,
                                    const struct pipe_vertex_buffer *buffers)
Brian's avatar
Brian committed
715 716
{
   struct i915_context *i915 = i915_context(pipe);
717 718 719 720
   /* Because we change state before the draw_set_vertex_buffers call
    * we need a flush here, just to be sure.
    */
   draw_flush(i915->draw);
721 722

   memcpy(i915->vertex_buffer, buffers, count * sizeof(buffers[0]));
723 724
   i915->num_vertex_buffers = count;

Brian's avatar
Brian committed
725
   /* pass-through to draw module */
726
   draw_set_vertex_buffers(i915->draw, count, buffers);
Brian's avatar
Brian committed
727 728
}

729 730 731
static void i915_set_vertex_elements(struct pipe_context *pipe,
                                     unsigned count,
                                     const struct pipe_vertex_element *elements)
Brian's avatar
Brian committed
732 733
{
   struct i915_context *i915 = i915_context(pipe);
734 735 736 737 738
   /* Because we change state before the draw_set_vertex_buffers call
    * we need a flush here, just to be sure.
    */
   draw_flush(i915->draw);

739
   i915->num_vertex_elements = count;
Brian's avatar
Brian committed
740
   /* pass-through to draw module */
741
   draw_set_vertex_elements(i915->draw, count, elements);
Brian's avatar
Brian committed
742 743 744
}


Jakob Bornecrantz's avatar
Jakob Bornecrantz committed
745 746 747 748 749
static void i915_set_edgeflags(struct pipe_context *pipe,
                               const unsigned *bitfield)
{
   /* TODO do something here */
}
Brian's avatar
Brian committed
750

751 752 753
void
i915_init_state_functions( struct i915_context *i915 )
{
Jakob Bornecrantz's avatar
Jakob Bornecrantz committed
754
   i915->pipe.set_edgeflags = i915_set_edgeflags;
755 756 757 758
   i915->pipe.create_blend_state = i915_create_blend_state;
   i915->pipe.bind_blend_state = i915_bind_blend_state;
   i915->pipe.delete_blend_state = i915_delete_blend_state;

759
   i915->pipe.create_sampler_state = i915_create_sampler_state;
760
   i915->pipe.bind_sampler_states = i915_bind_sampler_states;
761 762
   i915->pipe.delete_sampler_state = i915_delete_sampler_state;

763 764 765
   i915->pipe.create_depth_stencil_alpha_state = i915_create_depth_stencil_state;
   i915->pipe.bind_depth_stencil_alpha_state = i915_bind_depth_stencil_state;
   i915->pipe.delete_depth_stencil_alpha_state = i915_delete_depth_stencil_state;
766

767 768 769
   i915->pipe.create_rasterizer_state = i915_create_rasterizer_state;
   i915->pipe.bind_rasterizer_state = i915_bind_rasterizer_state;
   i915->pipe.delete_rasterizer_state = i915_delete_rasterizer_state;
770
   i915->pipe.create_fs_state = i915_create_fs_state;
771
   i915->pipe.bind_fs_state = i915_bind_fs_state;
772 773
   i915->pipe.delete_fs_state = i915_delete_fs_state;
   i915->pipe.create_vs_state = i915_create_vs_state;
774
   i915->pipe.bind_vs_state = i915_bind_vs_state;
775
   i915->pipe.delete_vs_state = i915_delete_vs_state;
776

777 778
   i915->pipe.set_blend_color = i915_set_blend_color;
   i915->pipe.set_clip_state = i915_set_clip_state;
Brian's avatar
Brian committed
779
   i915->pipe.set_constant_buffer = i915_set_constant_buffer;
780
   i915->pipe.set_framebuffer_state = i915_set_framebuffer_state;
Brian's avatar
Brian committed
781

782 783
   i915->pipe.set_polygon_stipple = i915_set_polygon_stipple;
   i915->pipe.set_scissor_state = i915_set_scissor_state;
784
   i915->pipe.set_sampler_textures = i915_set_sampler_textures;
785
   i915->pipe.set_viewport_state = i915_set_viewport_state;
786 787
   i915->pipe.set_vertex_buffers = i915_set_vertex_buffers;
   i915->pipe.set_vertex_elements = i915_set_vertex_elements;
788
}