2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics to
4 develop this 3D driver.
6 Permission is hereby granted, free of charge, to any person obtaining
7 a copy of this software and associated documentation files (the
8 "Software"), to deal in the Software without restriction, including
9 without limitation the rights to use, copy, modify, merge, publish,
10 distribute, sublicense, and/or sell copies of the Software, and to
11 permit persons to whom the Software is furnished to do so, subject to
12 the following conditions:
14 The above copyright notice and this permission notice (including the
15 next paragraph) shall be included in all copies or substantial
16 portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **********************************************************************/
29 * Keith Whitwell <keithw@vmware.com>
33 * @file brw_sampler_state.c
35 * This file contains code for emitting SAMPLER_STATE structures, which
36 * specifies filter modes, wrap modes, border color, and so on.
39 #include "brw_context.h"
40 #include "brw_state.h"
41 #include "brw_defines.h"
42 #include "intel_batchbuffer.h"
43 #include "intel_mipmap_tree.h"
45 #include "main/macros.h"
46 #include "main/samplerobj.h"
49 * Emit a 3DSTATE_SAMPLER_STATE_POINTERS_{VS,HS,GS,DS,PS} packet.
52 gen7_emit_sampler_state_pointers_xs(struct brw_context
*brw
,
53 struct brw_stage_state
*stage_state
)
55 static const uint16_t packet_headers
[] = {
56 [MESA_SHADER_VERTEX
] = _3DSTATE_SAMPLER_STATE_POINTERS_VS
,
57 [MESA_SHADER_GEOMETRY
] = _3DSTATE_SAMPLER_STATE_POINTERS_GS
,
58 [MESA_SHADER_FRAGMENT
] = _3DSTATE_SAMPLER_STATE_POINTERS_PS
,
61 /* Ivybridge requires a workaround flush before VS packets. */
62 if (brw
->gen
== 7 && !brw
->is_haswell
&& !brw
->is_baytrail
&&
63 stage_state
->stage
== MESA_SHADER_VERTEX
) {
64 gen7_emit_vs_workaround_flush(brw
);
68 OUT_BATCH(packet_headers
[stage_state
->stage
] << 16 | (2 - 2));
69 OUT_BATCH(stage_state
->sampler_offset
);
74 * Emit a SAMPLER_STATE structure, given all the fields.
77 brw_emit_sampler_state(struct brw_context
*brw
,
79 uint32_t batch_offset_for_sampler_state
,
83 unsigned max_anisotropy
,
84 unsigned address_rounding
,
92 unsigned shadow_function
,
93 bool non_normalized_coordinates
,
94 uint32_t border_color_offset
)
96 ss
[0] = BRW_SAMPLER_LOD_PRECLAMP_ENABLE
|
97 SET_FIELD(base_level
, BRW_SAMPLER_BASE_MIPLEVEL
) |
98 SET_FIELD(mip_filter
, BRW_SAMPLER_MIP_FILTER
) |
99 SET_FIELD(mag_filter
, BRW_SAMPLER_MAG_FILTER
) |
100 SET_FIELD(min_filter
, BRW_SAMPLER_MIN_FILTER
);
102 ss
[2] = border_color_offset
;
104 ss
[2] += brw
->batch
.bo
->offset64
; /* reloc */
105 drm_intel_bo_emit_reloc(brw
->batch
.bo
,
106 batch_offset_for_sampler_state
+ 8,
107 brw
->batch
.bo
, border_color_offset
,
108 I915_GEM_DOMAIN_SAMPLER
, 0);
111 ss
[3] = SET_FIELD(max_anisotropy
, BRW_SAMPLER_MAX_ANISOTROPY
) |
112 SET_FIELD(address_rounding
, BRW_SAMPLER_ADDRESS_ROUNDING
);
115 ss
[0] |= SET_FIELD(lod_bias
& 0x1fff, GEN7_SAMPLER_LOD_BIAS
);
117 if (min_filter
== BRW_MAPFILTER_ANISOTROPIC
)
118 ss
[0] |= GEN7_SAMPLER_EWA_ANISOTROPIC_ALGORITHM
;
120 ss
[1] = SET_FIELD(min_lod
, GEN7_SAMPLER_MIN_LOD
) |
121 SET_FIELD(max_lod
, GEN7_SAMPLER_MAX_LOD
) |
122 SET_FIELD(shadow_function
, GEN7_SAMPLER_SHADOW_FUNCTION
);
124 ss
[3] |= SET_FIELD(wrap_s
, BRW_SAMPLER_TCX_WRAP_MODE
) |
125 SET_FIELD(wrap_t
, BRW_SAMPLER_TCY_WRAP_MODE
) |
126 SET_FIELD(wrap_r
, BRW_SAMPLER_TCZ_WRAP_MODE
);
128 if (non_normalized_coordinates
)
129 ss
[3] |= GEN7_SAMPLER_NON_NORMALIZED_COORDINATES
;
131 ss
[0] |= SET_FIELD(lod_bias
& 0x7ff, GEN4_SAMPLER_LOD_BIAS
) |
132 SET_FIELD(shadow_function
, GEN4_SAMPLER_SHADOW_FUNCTION
);
134 if (brw
->gen
== 6 && min_filter
!= mag_filter
)
135 ss
[0] |= GEN6_SAMPLER_MIN_MAG_NOT_EQUAL
;
137 ss
[1] = SET_FIELD(min_lod
, GEN4_SAMPLER_MIN_LOD
) |
138 SET_FIELD(max_lod
, GEN4_SAMPLER_MAX_LOD
) |
139 SET_FIELD(wrap_s
, BRW_SAMPLER_TCX_WRAP_MODE
) |
140 SET_FIELD(wrap_t
, BRW_SAMPLER_TCY_WRAP_MODE
) |
141 SET_FIELD(wrap_r
, BRW_SAMPLER_TCZ_WRAP_MODE
);
143 if (brw
->gen
>= 6 && non_normalized_coordinates
)
144 ss
[3] |= GEN6_SAMPLER_NON_NORMALIZED_COORDINATES
;
149 translate_wrap_mode(struct brw_context
*brw
, GLenum wrap
, bool using_nearest
)
153 return BRW_TEXCOORDMODE_WRAP
;
155 /* GL_CLAMP is the weird mode where coordinates are clamped to
156 * [0.0, 1.0], so linear filtering of coordinates outside of
157 * [0.0, 1.0] give you half edge texel value and half border
160 * Gen8+ supports this natively.
163 return GEN8_TEXCOORDMODE_HALF_BORDER
;
165 /* On Gen4-7.5, we clamp the coordinates in the fragment shader
166 * and set clamp_border here, which gets the result desired.
167 * We just use clamp(_to_edge) for nearest, because for nearest
168 * clamping to 1.0 gives border color instead of the desired
172 return BRW_TEXCOORDMODE_CLAMP
;
174 return BRW_TEXCOORDMODE_CLAMP_BORDER
;
175 case GL_CLAMP_TO_EDGE
:
176 return BRW_TEXCOORDMODE_CLAMP
;
177 case GL_CLAMP_TO_BORDER
:
178 return BRW_TEXCOORDMODE_CLAMP_BORDER
;
179 case GL_MIRRORED_REPEAT
:
180 return BRW_TEXCOORDMODE_MIRROR
;
181 case GL_MIRROR_CLAMP_TO_EDGE
:
182 return BRW_TEXCOORDMODE_MIRROR_ONCE
;
184 return BRW_TEXCOORDMODE_WRAP
;
189 * Return true if the given wrap mode requires the border color to exist.
192 wrap_mode_needs_border_color(unsigned wrap_mode
)
194 return wrap_mode
== BRW_TEXCOORDMODE_CLAMP_BORDER
||
195 wrap_mode
== GEN8_TEXCOORDMODE_HALF_BORDER
;
199 * Upload SAMPLER_BORDER_COLOR_STATE.
202 upload_default_color(struct brw_context
*brw
,
203 const struct gl_sampler_object
*sampler
,
205 uint32_t *sdc_offset
)
207 struct gl_context
*ctx
= &brw
->ctx
;
208 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
209 struct gl_texture_object
*texObj
= texUnit
->_Current
;
210 struct gl_texture_image
*firstImage
= texObj
->Image
[0][texObj
->BaseLevel
];
211 union gl_color_union color
;
213 switch (firstImage
->_BaseFormat
) {
214 case GL_DEPTH_COMPONENT
:
215 /* GL specs that border color for depth textures is taken from the
216 * R channel, while the hardware uses A. Spam R into all the
217 * channels for safety.
219 color
.ui
[0] = sampler
->BorderColor
.ui
[0];
220 color
.ui
[1] = sampler
->BorderColor
.ui
[0];
221 color
.ui
[2] = sampler
->BorderColor
.ui
[0];
222 color
.ui
[3] = sampler
->BorderColor
.ui
[0];
228 color
.ui
[3] = sampler
->BorderColor
.ui
[3];
231 color
.ui
[0] = sampler
->BorderColor
.ui
[0];
232 color
.ui
[1] = sampler
->BorderColor
.ui
[0];
233 color
.ui
[2] = sampler
->BorderColor
.ui
[0];
234 color
.ui
[3] = sampler
->BorderColor
.ui
[0];
237 color
.ui
[0] = sampler
->BorderColor
.ui
[0];
238 color
.ui
[1] = sampler
->BorderColor
.ui
[0];
239 color
.ui
[2] = sampler
->BorderColor
.ui
[0];
240 color
.ui
[3] = float_as_int(1.0);
242 case GL_LUMINANCE_ALPHA
:
243 color
.ui
[0] = sampler
->BorderColor
.ui
[0];
244 color
.ui
[1] = sampler
->BorderColor
.ui
[0];
245 color
.ui
[2] = sampler
->BorderColor
.ui
[0];
246 color
.ui
[3] = sampler
->BorderColor
.ui
[3];
249 color
.ui
[0] = sampler
->BorderColor
.ui
[0];
250 color
.ui
[1] = sampler
->BorderColor
.ui
[1];
251 color
.ui
[2] = sampler
->BorderColor
.ui
[2];
252 color
.ui
[3] = sampler
->BorderColor
.ui
[3];
256 /* In some cases we use an RGBA surface format for GL RGB textures,
257 * where we've initialized the A channel to 1.0. We also have to set
258 * the border color alpha to 1.0 in that case.
260 if (firstImage
->_BaseFormat
== GL_RGB
)
261 color
.ui
[3] = float_as_int(1.0);
264 /* On Broadwell, the border color is represented as four 32-bit floats,
265 * integers, or unsigned values, interpreted according to the surface
266 * format. This matches the sampler->BorderColor union exactly; just
269 uint32_t *sdc
= brw_state_batch(brw
, AUB_TRACE_SAMPLER_DEFAULT_COLOR
,
270 4 * 4, 64, sdc_offset
);
271 memcpy(sdc
, color
.ui
, 4 * 4);
272 } else if (brw
->is_haswell
&& texObj
->_IsIntegerFormat
) {
273 /* Haswell's integer border color support is completely insane:
274 * SAMPLER_BORDER_COLOR_STATE is 20 DWords. The first four are
275 * for float colors. The next 12 DWords are MBZ and only exist to
276 * pad it out to a 64 byte cacheline boundary. DWords 16-19 then
277 * contain integer colors; these are only used if SURFACE_STATE
278 * has the "Integer Surface Format" bit set. Even then, the
279 * arrangement of the RGBA data devolves into madness.
281 uint32_t *sdc
= brw_state_batch(brw
, AUB_TRACE_SAMPLER_DEFAULT_COLOR
,
282 20 * 4, 512, sdc_offset
);
283 memset(sdc
, 0, 20 * 4);
286 mesa_format format
= firstImage
->TexFormat
;
287 int bits_per_channel
= _mesa_get_format_bits(format
, GL_RED_BITS
);
289 /* From the Haswell PRM, "Command Reference: Structures", Page 36:
290 * "If any color channel is missing from the surface format,
291 * corresponding border color should be programmed as zero and if
292 * alpha channel is missing, corresponding Alpha border color should
293 * be programmed as 1."
295 unsigned c
[4] = { 0, 0, 0, 1 };
296 for (int i
= 0; i
< 4; i
++) {
297 if (_mesa_format_has_color_component(format
, i
))
301 switch (bits_per_channel
) {
303 /* Copy RGBA in order. */
304 for (int i
= 0; i
< 4; i
++)
305 ((uint8_t *) sdc
)[i
] = c
[i
];
308 /* R10G10B10A2_UINT is treated like a 16-bit format. */
310 ((uint16_t *) sdc
)[0] = c
[0]; /* R -> DWord 0, bits 15:0 */
311 ((uint16_t *) sdc
)[1] = c
[1]; /* G -> DWord 0, bits 31:16 */
312 /* DWord 1 is Reserved/MBZ! */
313 ((uint16_t *) sdc
)[4] = c
[2]; /* B -> DWord 2, bits 15:0 */
314 ((uint16_t *) sdc
)[5] = c
[3]; /* A -> DWord 3, bits 31:16 */
317 if (firstImage
->_BaseFormat
== GL_RG
) {
318 /* Careful inspection of the tables reveals that for RG32 formats,
319 * the green channel needs to go where blue normally belongs.
325 /* Copy RGBA in order. */
326 for (int i
= 0; i
< 4; i
++)
331 assert(!"Invalid number of bits per channel in integer format.");
334 } else if (brw
->gen
== 5 || brw
->gen
== 6) {
335 struct gen5_sampler_default_color
*sdc
;
337 sdc
= brw_state_batch(brw
, AUB_TRACE_SAMPLER_DEFAULT_COLOR
,
338 sizeof(*sdc
), 32, sdc_offset
);
340 memset(sdc
, 0, sizeof(*sdc
));
342 UNCLAMPED_FLOAT_TO_UBYTE(sdc
->ub
[0], color
.f
[0]);
343 UNCLAMPED_FLOAT_TO_UBYTE(sdc
->ub
[1], color
.f
[1]);
344 UNCLAMPED_FLOAT_TO_UBYTE(sdc
->ub
[2], color
.f
[2]);
345 UNCLAMPED_FLOAT_TO_UBYTE(sdc
->ub
[3], color
.f
[3]);
347 UNCLAMPED_FLOAT_TO_USHORT(sdc
->us
[0], color
.f
[0]);
348 UNCLAMPED_FLOAT_TO_USHORT(sdc
->us
[1], color
.f
[1]);
349 UNCLAMPED_FLOAT_TO_USHORT(sdc
->us
[2], color
.f
[2]);
350 UNCLAMPED_FLOAT_TO_USHORT(sdc
->us
[3], color
.f
[3]);
352 UNCLAMPED_FLOAT_TO_SHORT(sdc
->s
[0], color
.f
[0]);
353 UNCLAMPED_FLOAT_TO_SHORT(sdc
->s
[1], color
.f
[1]);
354 UNCLAMPED_FLOAT_TO_SHORT(sdc
->s
[2], color
.f
[2]);
355 UNCLAMPED_FLOAT_TO_SHORT(sdc
->s
[3], color
.f
[3]);
357 sdc
->hf
[0] = _mesa_float_to_half(color
.f
[0]);
358 sdc
->hf
[1] = _mesa_float_to_half(color
.f
[1]);
359 sdc
->hf
[2] = _mesa_float_to_half(color
.f
[2]);
360 sdc
->hf
[3] = _mesa_float_to_half(color
.f
[3]);
362 sdc
->b
[0] = sdc
->s
[0] >> 8;
363 sdc
->b
[1] = sdc
->s
[1] >> 8;
364 sdc
->b
[2] = sdc
->s
[2] >> 8;
365 sdc
->b
[3] = sdc
->s
[3] >> 8;
367 sdc
->f
[0] = color
.f
[0];
368 sdc
->f
[1] = color
.f
[1];
369 sdc
->f
[2] = color
.f
[2];
370 sdc
->f
[3] = color
.f
[3];
372 float *sdc
= brw_state_batch(brw
, AUB_TRACE_SAMPLER_DEFAULT_COLOR
,
373 4 * 4, 32, sdc_offset
);
374 memcpy(sdc
, color
.f
, 4 * 4);
379 * Sets the sampler state for a single unit based off of the sampler key
383 brw_update_sampler_state(struct brw_context
*brw
,
385 uint32_t *sampler_state
,
386 uint32_t batch_offset_for_sampler_state
)
388 struct gl_context
*ctx
= &brw
->ctx
;
389 const struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
390 const struct gl_texture_object
*texObj
= texUnit
->_Current
;
391 const struct gl_sampler_object
*sampler
= _mesa_get_samplerobj(ctx
, unit
);
393 /* These don't use samplers at all. */
394 if (texObj
->Target
== GL_TEXTURE_BUFFER
)
397 unsigned min_filter
, mag_filter
, mip_filter
;
399 /* Select min and mip filters. */
400 switch (sampler
->MinFilter
) {
402 min_filter
= BRW_MAPFILTER_NEAREST
;
403 mip_filter
= BRW_MIPFILTER_NONE
;
406 min_filter
= BRW_MAPFILTER_LINEAR
;
407 mip_filter
= BRW_MIPFILTER_NONE
;
409 case GL_NEAREST_MIPMAP_NEAREST
:
410 min_filter
= BRW_MAPFILTER_NEAREST
;
411 mip_filter
= BRW_MIPFILTER_NEAREST
;
413 case GL_LINEAR_MIPMAP_NEAREST
:
414 min_filter
= BRW_MAPFILTER_LINEAR
;
415 mip_filter
= BRW_MIPFILTER_NEAREST
;
417 case GL_NEAREST_MIPMAP_LINEAR
:
418 min_filter
= BRW_MAPFILTER_NEAREST
;
419 mip_filter
= BRW_MIPFILTER_LINEAR
;
421 case GL_LINEAR_MIPMAP_LINEAR
:
422 min_filter
= BRW_MAPFILTER_LINEAR
;
423 mip_filter
= BRW_MIPFILTER_LINEAR
;
426 unreachable("not reached");
429 /* Select mag filter. */
430 if (sampler
->MagFilter
== GL_LINEAR
)
431 mag_filter
= BRW_MAPFILTER_LINEAR
;
433 mag_filter
= BRW_MAPFILTER_NEAREST
;
435 /* Enable anisotropic filtering if desired. */
436 unsigned max_anisotropy
= BRW_ANISORATIO_2
;
437 if (sampler
->MaxAnisotropy
> 1.0) {
438 min_filter
= BRW_MAPFILTER_ANISOTROPIC
;
439 mag_filter
= BRW_MAPFILTER_ANISOTROPIC
;
441 if (sampler
->MaxAnisotropy
> 2.0) {
443 MIN2((sampler
->MaxAnisotropy
- 2) / 2, BRW_ANISORATIO_16
);
447 /* Set address rounding bits if not using nearest filtering. */
448 unsigned address_rounding
= 0;
449 if (min_filter
!= BRW_MAPFILTER_NEAREST
) {
450 address_rounding
|= BRW_ADDRESS_ROUNDING_ENABLE_U_MIN
|
451 BRW_ADDRESS_ROUNDING_ENABLE_V_MIN
|
452 BRW_ADDRESS_ROUNDING_ENABLE_R_MIN
;
454 if (mag_filter
!= BRW_MAPFILTER_NEAREST
) {
455 address_rounding
|= BRW_ADDRESS_ROUNDING_ENABLE_U_MAG
|
456 BRW_ADDRESS_ROUNDING_ENABLE_V_MAG
|
457 BRW_ADDRESS_ROUNDING_ENABLE_R_MAG
;
460 bool either_nearest
=
461 sampler
->MinFilter
== GL_NEAREST
|| sampler
->MagFilter
== GL_NEAREST
;
462 unsigned wrap_s
= translate_wrap_mode(brw
, sampler
->WrapS
, either_nearest
);
463 unsigned wrap_t
= translate_wrap_mode(brw
, sampler
->WrapT
, either_nearest
);
464 unsigned wrap_r
= translate_wrap_mode(brw
, sampler
->WrapR
, either_nearest
);
466 if (texObj
->Target
== GL_TEXTURE_CUBE_MAP
||
467 texObj
->Target
== GL_TEXTURE_CUBE_MAP_ARRAY
) {
468 /* Cube maps must use the same wrap mode for all three coordinate
469 * dimensions. Prior to Haswell, only CUBE and CLAMP are valid.
471 if ((ctx
->Texture
.CubeMapSeamless
|| sampler
->CubeMapSeamless
) &&
472 (sampler
->MinFilter
!= GL_NEAREST
||
473 sampler
->MagFilter
!= GL_NEAREST
)) {
474 wrap_s
= BRW_TEXCOORDMODE_CUBE
;
475 wrap_t
= BRW_TEXCOORDMODE_CUBE
;
476 wrap_r
= BRW_TEXCOORDMODE_CUBE
;
478 wrap_s
= BRW_TEXCOORDMODE_CLAMP
;
479 wrap_t
= BRW_TEXCOORDMODE_CLAMP
;
480 wrap_r
= BRW_TEXCOORDMODE_CLAMP
;
482 } else if (texObj
->Target
== GL_TEXTURE_1D
) {
483 /* There's a bug in 1D texture sampling - it actually pays
484 * attention to the wrap_t value, though it should not.
485 * Override the wrap_t value here to GL_REPEAT to keep
486 * any nonexistent border pixels from floating in.
488 wrap_t
= BRW_TEXCOORDMODE_WRAP
;
491 /* Set shadow function. */
492 unsigned shadow_function
= 0;
493 if (sampler
->CompareMode
== GL_COMPARE_R_TO_TEXTURE_ARB
) {
495 intel_translate_shadow_compare_func(sampler
->CompareFunc
);
498 const int lod_bits
= brw
->gen
>= 7 ? 8 : 6;
499 const unsigned min_lod
= U_FIXED(CLAMP(sampler
->MinLod
, 0, 13), lod_bits
);
500 const unsigned max_lod
= U_FIXED(CLAMP(sampler
->MaxLod
, 0, 13), lod_bits
);
502 S_FIXED(CLAMP(texUnit
->LodBias
+ sampler
->LodBias
, -16, 15), lod_bits
);
503 const unsigned base_level
= U_FIXED(0, 1);
505 /* Upload the border color if necessary. If not, just point it at
506 * offset 0 (the start of the batch) - the color should be ignored,
507 * but that address won't fault in case something reads it anyway.
509 uint32_t border_color_offset
= 0;
510 if (wrap_mode_needs_border_color(wrap_s
) ||
511 wrap_mode_needs_border_color(wrap_t
) ||
512 wrap_mode_needs_border_color(wrap_r
)) {
513 upload_default_color(brw
, sampler
, unit
, &border_color_offset
);
516 const bool non_normalized_coords
= texObj
->Target
== GL_TEXTURE_RECTANGLE
;
518 brw_emit_sampler_state(brw
,
520 batch_offset_for_sampler_state
,
521 min_filter
, mag_filter
, mip_filter
,
524 wrap_s
, wrap_t
, wrap_r
,
525 min_lod
, max_lod
, lod_bias
, base_level
,
527 non_normalized_coords
,
528 border_color_offset
);
533 brw_upload_sampler_state_table(struct brw_context
*brw
,
534 struct gl_program
*prog
,
535 struct brw_stage_state
*stage_state
)
537 struct gl_context
*ctx
= &brw
->ctx
;
538 uint32_t sampler_count
= stage_state
->sampler_count
;
540 GLbitfield SamplersUsed
= prog
->SamplersUsed
;
542 if (sampler_count
== 0)
545 /* SAMPLER_STATE is 4 DWords on all platforms. */
546 const int dwords
= 4;
547 const int size_in_bytes
= dwords
* sizeof(uint32_t);
549 uint32_t *sampler_state
= brw_state_batch(brw
, AUB_TRACE_SAMPLER_STATE
,
550 sampler_count
* size_in_bytes
,
551 32, &stage_state
->sampler_offset
);
552 memset(sampler_state
, 0, sampler_count
* size_in_bytes
);
554 uint32_t batch_offset_for_sampler_state
= stage_state
->sampler_offset
;
556 for (unsigned s
= 0; s
< sampler_count
; s
++) {
557 if (SamplersUsed
& (1 << s
)) {
558 const unsigned unit
= prog
->SamplerUnits
[s
];
559 if (ctx
->Texture
.Unit
[unit
]._Current
) {
560 brw_update_sampler_state(brw
, unit
, sampler_state
,
561 batch_offset_for_sampler_state
);
565 sampler_state
+= dwords
;
566 batch_offset_for_sampler_state
+= size_in_bytes
;
570 /* Emit a 3DSTATE_SAMPLER_STATE_POINTERS_XS packet. */
571 gen7_emit_sampler_state_pointers_xs(brw
, stage_state
);
573 /* Flag that the sampler state table pointer has changed; later atoms
576 brw
->state
.dirty
.brw
|= BRW_NEW_SAMPLER_STATE_TABLE
;
581 brw_upload_fs_samplers(struct brw_context
*brw
)
583 /* BRW_NEW_FRAGMENT_PROGRAM */
584 struct gl_program
*fs
= (struct gl_program
*) brw
->fragment_program
;
585 brw_upload_sampler_state_table(brw
, fs
, &brw
->wm
.base
);
588 const struct brw_tracked_state brw_fs_samplers
= {
590 .mesa
= _NEW_TEXTURE
,
591 .brw
= BRW_NEW_BATCH
|
592 BRW_NEW_FRAGMENT_PROGRAM
,
594 .emit
= brw_upload_fs_samplers
,
598 brw_upload_vs_samplers(struct brw_context
*brw
)
600 /* BRW_NEW_VERTEX_PROGRAM */
601 struct gl_program
*vs
= (struct gl_program
*) brw
->vertex_program
;
602 brw_upload_sampler_state_table(brw
, vs
, &brw
->vs
.base
);
606 const struct brw_tracked_state brw_vs_samplers
= {
608 .mesa
= _NEW_TEXTURE
,
609 .brw
= BRW_NEW_BATCH
|
610 BRW_NEW_VERTEX_PROGRAM
,
612 .emit
= brw_upload_vs_samplers
,
617 brw_upload_gs_samplers(struct brw_context
*brw
)
619 /* BRW_NEW_GEOMETRY_PROGRAM */
620 struct gl_program
*gs
= (struct gl_program
*) brw
->geometry_program
;
624 brw_upload_sampler_state_table(brw
, gs
, &brw
->gs
.base
);
628 const struct brw_tracked_state brw_gs_samplers
= {
630 .mesa
= _NEW_TEXTURE
,
631 .brw
= BRW_NEW_BATCH
|
632 BRW_NEW_GEOMETRY_PROGRAM
,
634 .emit
= brw_upload_gs_samplers
,