Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2010 Red Hat Inc. |
| 3 | * 2010 Jerome Glisse |
| 4 | * |
| 5 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 6 | * copy of this software and associated documentation files (the "Software"), |
| 7 | * to deal in the Software without restriction, including without limitation |
| 8 | * on the rights to use, copy, modify, merge, publish, distribute, sub |
| 9 | * license, and/or sell copies of the Software, and to permit persons to whom |
| 10 | * the Software is furnished to do so, subject to the following conditions: |
| 11 | * |
| 12 | * The above copyright notice and this permission notice (including the next |
| 13 | * paragraph) shall be included in all copies or substantial portions of the |
| 14 | * Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| 20 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| 21 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| 22 | * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 23 | * |
| 24 | * Authors: Dave Airlie <airlied@redhat.com> |
| 25 | * Jerome Glisse <jglisse@redhat.com> |
| 26 | */ |
Henri Verbeet | d7577ae | 2011-04-25 13:28:55 +0200 | [diff] [blame] | 27 | #include "r600_formats.h" |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 28 | #include "r600d.h" |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 29 | |
Marek Olšák | 187d7fb | 2012-08-24 05:57:22 +0200 | [diff] [blame] | 30 | #include "util/u_draw_quad.h" |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 31 | #include "util/u_upload_mgr.h" |
Marek Olšák | 330b6c8 | 2012-03-05 15:17:00 +0100 | [diff] [blame] | 32 | #include "tgsi/tgsi_parse.h" |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 33 | #include <byteswap.h> |
Marek Olšák | 330b6c8 | 2012-03-05 15:17:00 +0100 | [diff] [blame] | 34 | |
Marek Olšák | 187d7fb | 2012-08-24 05:57:22 +0200 | [diff] [blame] | 35 | #define R600_PRIM_RECTANGLE_LIST PIPE_PRIM_MAX |
| 36 | |
Marek Olšák | d8ea646 | 2012-10-05 00:20:27 +0200 | [diff] [blame] | 37 | void r600_init_command_buffer(struct r600_command_buffer *cb, unsigned num_dw) |
Marek Olšák | f126253 | 2012-01-31 10:50:51 +0100 | [diff] [blame] | 38 | { |
Marek Olšák | f126253 | 2012-01-31 10:50:51 +0100 | [diff] [blame] | 39 | cb->buf = CALLOC(1, 4 * num_dw); |
| 40 | cb->max_num_dw = num_dw; |
| 41 | } |
| 42 | |
| 43 | void r600_release_command_buffer(struct r600_command_buffer *cb) |
| 44 | { |
| 45 | FREE(cb->buf); |
| 46 | } |
| 47 | |
Jerome Glisse | 5ceb872 | 2012-09-05 15:18:24 -0400 | [diff] [blame] | 48 | void r600_init_atom(struct r600_context *rctx, |
| 49 | struct r600_atom *atom, |
| 50 | unsigned id, |
Marek Olšák | e280984 | 2012-02-02 14:01:12 +0100 | [diff] [blame] | 51 | void (*emit)(struct r600_context *ctx, struct r600_atom *state), |
Jerome Glisse | 5ceb872 | 2012-09-05 15:18:24 -0400 | [diff] [blame] | 52 | unsigned num_dw) |
Marek Olšák | 0813e58 | 2012-01-30 06:21:07 +0100 | [diff] [blame] | 53 | { |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 54 | assert(id < R600_NUM_ATOMS); |
Jerome Glisse | 5ceb872 | 2012-09-05 15:18:24 -0400 | [diff] [blame] | 55 | assert(rctx->atoms[id] == NULL); |
| 56 | rctx->atoms[id] = atom; |
| 57 | atom->id = id; |
Marek Olšák | 0813e58 | 2012-01-30 06:21:07 +0100 | [diff] [blame] | 58 | atom->emit = emit; |
| 59 | atom->num_dw = num_dw; |
Jerome Glisse | 5ceb872 | 2012-09-05 15:18:24 -0400 | [diff] [blame] | 60 | atom->dirty = false; |
Marek Olšák | 0813e58 | 2012-01-30 06:21:07 +0100 | [diff] [blame] | 61 | } |
| 62 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 63 | void r600_emit_cso_state(struct r600_context *rctx, struct r600_atom *atom) |
| 64 | { |
| 65 | r600_emit_command_buffer(rctx->cs, ((struct r600_cso_state*)atom)->cb); |
| 66 | } |
| 67 | |
Jerome Glisse | 5ceb872 | 2012-09-05 15:18:24 -0400 | [diff] [blame] | 68 | void r600_emit_alphatest_state(struct r600_context *rctx, struct r600_atom *atom) |
Marek Olšák | bc2f5fc | 2012-07-18 03:45:25 +0200 | [diff] [blame] | 69 | { |
| 70 | struct radeon_winsys_cs *cs = rctx->cs; |
| 71 | struct r600_alphatest_state *a = (struct r600_alphatest_state*)atom; |
| 72 | unsigned alpha_ref = a->sx_alpha_ref; |
| 73 | |
Marek Olšák | de4fd08 | 2012-07-18 04:17:11 +0200 | [diff] [blame] | 74 | if (rctx->chip_class >= EVERGREEN && a->cb0_export_16bpc) { |
Marek Olšák | bc2f5fc | 2012-07-18 03:45:25 +0200 | [diff] [blame] | 75 | alpha_ref &= ~0x1FFF; |
| 76 | } |
| 77 | |
| 78 | r600_write_context_reg(cs, R_028410_SX_ALPHA_TEST_CONTROL, |
| 79 | a->sx_alpha_test_control | |
| 80 | S_028410_ALPHA_TEST_BYPASS(a->bypass)); |
| 81 | r600_write_context_reg(cs, R_028438_SX_ALPHA_REF, alpha_ref); |
| 82 | } |
| 83 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 84 | static void r600_texture_barrier(struct pipe_context *ctx) |
Marek Olšák | 0813e58 | 2012-01-30 06:21:07 +0100 | [diff] [blame] | 85 | { |
| 86 | struct r600_context *rctx = (struct r600_context *)ctx; |
| 87 | |
Marek Olšák | fd2e34d | 2012-09-09 06:08:39 +0200 | [diff] [blame] | 88 | rctx->flags |= R600_CONTEXT_CB_FLUSH | R600_CONTEXT_TEX_FLUSH; |
| 89 | |
| 90 | /* R6xx errata */ |
| 91 | if (rctx->chip_class == R600) { |
| 92 | rctx->flags |= R600_CONTEXT_FLUSH_AND_INV; |
| 93 | } |
Marek Olšák | 0813e58 | 2012-01-30 06:21:07 +0100 | [diff] [blame] | 94 | } |
| 95 | |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 96 | static unsigned r600_conv_pipe_prim(unsigned prim) |
Dave Airlie | d737857 | 2011-04-25 09:05:08 +1000 | [diff] [blame] | 97 | { |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 98 | static const unsigned prim_conv[] = { |
Dave Airlie | de0adb6 | 2011-06-03 10:10:01 +1000 | [diff] [blame] | 99 | V_008958_DI_PT_POINTLIST, |
| 100 | V_008958_DI_PT_LINELIST, |
| 101 | V_008958_DI_PT_LINELOOP, |
| 102 | V_008958_DI_PT_LINESTRIP, |
| 103 | V_008958_DI_PT_TRILIST, |
| 104 | V_008958_DI_PT_TRISTRIP, |
| 105 | V_008958_DI_PT_TRIFAN, |
| 106 | V_008958_DI_PT_QUADLIST, |
| 107 | V_008958_DI_PT_QUADSTRIP, |
| 108 | V_008958_DI_PT_POLYGON, |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 109 | V_008958_DI_PT_LINELIST_ADJ, |
| 110 | V_008958_DI_PT_LINESTRIP_ADJ, |
| 111 | V_008958_DI_PT_TRILIST_ADJ, |
| 112 | V_008958_DI_PT_TRISTRIP_ADJ, |
Marek Olšák | 187d7fb | 2012-08-24 05:57:22 +0200 | [diff] [blame] | 113 | V_008958_DI_PT_RECTLIST |
Dave Airlie | de0adb6 | 2011-06-03 10:10:01 +1000 | [diff] [blame] | 114 | }; |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 115 | return prim_conv[prim]; |
Dave Airlie | d737857 | 2011-04-25 09:05:08 +1000 | [diff] [blame] | 116 | } |
| 117 | |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 118 | /* common state between evergreen and r600 */ |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 119 | |
| 120 | static void r600_bind_blend_state_internal(struct r600_context *rctx, |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 121 | struct r600_blend_state *blend, bool blend_disable) |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 122 | { |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 123 | unsigned color_control; |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 124 | bool update_cb = false; |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 125 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 126 | rctx->alpha_to_one = blend->alpha_to_one; |
| 127 | rctx->dual_src_blend = blend->dual_src_blend; |
Marek Olšák | 0ea7691 | 2012-07-07 07:15:04 +0200 | [diff] [blame] | 128 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 129 | if (!blend_disable) { |
| 130 | r600_set_cso_state_with_cb(&rctx->blend_state, blend, &blend->buffer); |
| 131 | color_control = blend->cb_color_control; |
| 132 | } else { |
| 133 | /* Blending is disabled. */ |
| 134 | r600_set_cso_state_with_cb(&rctx->blend_state, blend, &blend->buffer_no_blend); |
| 135 | color_control = blend->cb_color_control_no_blend; |
| 136 | } |
| 137 | |
| 138 | /* Update derived states. */ |
Marek Olšák | 0ea7691 | 2012-07-07 07:15:04 +0200 | [diff] [blame] | 139 | if (rctx->cb_misc_state.blend_colormask != blend->cb_target_mask) { |
| 140 | rctx->cb_misc_state.blend_colormask = blend->cb_target_mask; |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 141 | update_cb = true; |
Marek Olšák | 0ea7691 | 2012-07-07 07:15:04 +0200 | [diff] [blame] | 142 | } |
Marek Olšák | a1a1ff5 | 2012-07-07 07:40:36 +0200 | [diff] [blame] | 143 | if (rctx->chip_class <= R700 && |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 144 | rctx->cb_misc_state.cb_color_control != color_control) { |
| 145 | rctx->cb_misc_state.cb_color_control = color_control; |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 146 | update_cb = true; |
| 147 | } |
| 148 | if (rctx->cb_misc_state.dual_src_blend != blend->dual_src_blend) { |
| 149 | rctx->cb_misc_state.dual_src_blend = blend->dual_src_blend; |
| 150 | update_cb = true; |
| 151 | } |
| 152 | if (update_cb) { |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 153 | rctx->cb_misc_state.atom.dirty = true; |
Marek Olšák | a1a1ff5 | 2012-07-07 07:40:36 +0200 | [diff] [blame] | 154 | } |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 155 | } |
| 156 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 157 | static void r600_bind_blend_state(struct pipe_context *ctx, void *state) |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 158 | { |
| 159 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 160 | struct r600_blend_state *blend = (struct r600_blend_state *)state; |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 161 | |
| 162 | if (blend == NULL) |
| 163 | return; |
| 164 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 165 | r600_bind_blend_state_internal(rctx, blend, rctx->force_blend_disable); |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 166 | } |
| 167 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 168 | static void r600_set_blend_color(struct pipe_context *ctx, |
| 169 | const struct pipe_blend_color *state) |
Marek Olšák | 014198e | 2012-02-14 15:24:25 +0100 | [diff] [blame] | 170 | { |
| 171 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 014198e | 2012-02-14 15:24:25 +0100 | [diff] [blame] | 172 | |
Marek Olšák | de89fe1 | 2012-09-10 19:41:39 +0200 | [diff] [blame] | 173 | rctx->blend_color.state = *state; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 174 | rctx->blend_color.atom.dirty = true; |
Marek Olšák | de89fe1 | 2012-09-10 19:41:39 +0200 | [diff] [blame] | 175 | } |
Marek Olšák | 014198e | 2012-02-14 15:24:25 +0100 | [diff] [blame] | 176 | |
Marek Olšák | de89fe1 | 2012-09-10 19:41:39 +0200 | [diff] [blame] | 177 | void r600_emit_blend_color(struct r600_context *rctx, struct r600_atom *atom) |
| 178 | { |
| 179 | struct radeon_winsys_cs *cs = rctx->cs; |
| 180 | struct pipe_blend_color *state = &rctx->blend_color.state; |
Marek Olšák | 014198e | 2012-02-14 15:24:25 +0100 | [diff] [blame] | 181 | |
Marek Olšák | de89fe1 | 2012-09-10 19:41:39 +0200 | [diff] [blame] | 182 | r600_write_context_reg_seq(cs, R_028414_CB_BLEND_RED, 4); |
| 183 | r600_write_value(cs, fui(state->color[0])); /* R_028414_CB_BLEND_RED */ |
| 184 | r600_write_value(cs, fui(state->color[1])); /* R_028418_CB_BLEND_GREEN */ |
| 185 | r600_write_value(cs, fui(state->color[2])); /* R_02841C_CB_BLEND_BLUE */ |
| 186 | r600_write_value(cs, fui(state->color[3])); /* R_028420_CB_BLEND_ALPHA */ |
Marek Olšák | 014198e | 2012-02-14 15:24:25 +0100 | [diff] [blame] | 187 | } |
| 188 | |
Marek Olšák | 1f5a756 | 2012-09-11 01:16:32 +0200 | [diff] [blame] | 189 | void r600_emit_vgt_state(struct r600_context *rctx, struct r600_atom *atom) |
| 190 | { |
| 191 | struct radeon_winsys_cs *cs = rctx->cs; |
| 192 | struct r600_vgt_state *a = (struct r600_vgt_state *)atom; |
| 193 | |
| 194 | r600_write_context_reg(cs, R_028A94_VGT_MULTI_PRIM_IB_RESET_EN, a->vgt_multi_prim_ib_reset_en); |
| 195 | r600_write_context_reg(cs, R_02840C_VGT_MULTI_PRIM_IB_RESET_INDX, a->vgt_multi_prim_ib_reset_indx); |
| 196 | } |
| 197 | |
| 198 | void r600_emit_vgt2_state(struct r600_context *rctx, struct r600_atom *atom) |
| 199 | { |
| 200 | struct radeon_winsys_cs *cs = rctx->cs; |
| 201 | struct r600_vgt2_state *a = (struct r600_vgt2_state *)atom; |
| 202 | |
| 203 | r600_write_context_reg(cs, R_028408_VGT_INDX_OFFSET, a->vgt_indx_offset); |
| 204 | } |
| 205 | |
Marek Olšák | 2b8d39b | 2012-09-10 20:03:09 +0200 | [diff] [blame] | 206 | static void r600_set_clip_state(struct pipe_context *ctx, |
| 207 | const struct pipe_clip_state *state) |
| 208 | { |
| 209 | struct r600_context *rctx = (struct r600_context *)ctx; |
| 210 | struct pipe_constant_buffer cb; |
| 211 | |
| 212 | rctx->clip_state.state = *state; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 213 | rctx->clip_state.atom.dirty = true; |
Marek Olšák | 2b8d39b | 2012-09-10 20:03:09 +0200 | [diff] [blame] | 214 | |
| 215 | cb.buffer = NULL; |
| 216 | cb.user_buffer = state->ucp; |
| 217 | cb.buffer_offset = 0; |
| 218 | cb.buffer_size = 4*4*8; |
| 219 | ctx->set_constant_buffer(ctx, PIPE_SHADER_VERTEX, 1, &cb); |
| 220 | pipe_resource_reference(&cb.buffer, NULL); |
| 221 | } |
| 222 | |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 223 | static void r600_set_stencil_ref(struct pipe_context *ctx, |
| 224 | const struct r600_stencil_ref *state) |
| 225 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 226 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 227 | |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 228 | rctx->stencil_ref.state = *state; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 229 | rctx->stencil_ref.atom.dirty = true; |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 230 | } |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 231 | |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 232 | void r600_emit_stencil_ref(struct r600_context *rctx, struct r600_atom *atom) |
| 233 | { |
| 234 | struct radeon_winsys_cs *cs = rctx->cs; |
| 235 | struct r600_stencil_ref_state *a = (struct r600_stencil_ref_state*)atom; |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 236 | |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 237 | r600_write_context_reg_seq(cs, R_028430_DB_STENCILREFMASK, 2); |
| 238 | r600_write_value(cs, /* R_028430_DB_STENCILREFMASK */ |
| 239 | S_028430_STENCILREF(a->state.ref_value[0]) | |
| 240 | S_028430_STENCILMASK(a->state.valuemask[0]) | |
| 241 | S_028430_STENCILWRITEMASK(a->state.writemask[0])); |
| 242 | r600_write_value(cs, /* R_028434_DB_STENCILREFMASK_BF */ |
| 243 | S_028434_STENCILREF_BF(a->state.ref_value[1]) | |
| 244 | S_028434_STENCILMASK_BF(a->state.valuemask[1]) | |
| 245 | S_028434_STENCILWRITEMASK_BF(a->state.writemask[1])); |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 246 | } |
| 247 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 248 | static void r600_set_pipe_stencil_ref(struct pipe_context *ctx, |
| 249 | const struct pipe_stencil_ref *state) |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 250 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 251 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 252 | struct r600_pipe_dsa *dsa = (struct r600_pipe_dsa*)rctx->states[R600_PIPE_STATE_DSA]; |
| 253 | struct r600_stencil_ref ref; |
| 254 | |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 255 | rctx->stencil_ref.pipe_state = *state; |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 256 | |
| 257 | if (!dsa) |
| 258 | return; |
| 259 | |
| 260 | ref.ref_value[0] = state->ref_value[0]; |
| 261 | ref.ref_value[1] = state->ref_value[1]; |
| 262 | ref.valuemask[0] = dsa->valuemask[0]; |
| 263 | ref.valuemask[1] = dsa->valuemask[1]; |
| 264 | ref.writemask[0] = dsa->writemask[0]; |
| 265 | ref.writemask[1] = dsa->writemask[1]; |
| 266 | |
| 267 | r600_set_stencil_ref(ctx, &ref); |
| 268 | } |
| 269 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 270 | static void r600_bind_dsa_state(struct pipe_context *ctx, void *state) |
Henri Verbeet | f60235e | 2011-05-05 20:54:36 +0200 | [diff] [blame] | 271 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 272 | struct r600_context *rctx = (struct r600_context *)ctx; |
Henri Verbeet | f60235e | 2011-05-05 20:54:36 +0200 | [diff] [blame] | 273 | struct r600_pipe_dsa *dsa = state; |
| 274 | struct r600_pipe_state *rstate; |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 275 | struct r600_stencil_ref ref; |
Henri Verbeet | f60235e | 2011-05-05 20:54:36 +0200 | [diff] [blame] | 276 | |
| 277 | if (state == NULL) |
| 278 | return; |
| 279 | rstate = &dsa->rstate; |
| 280 | rctx->states[rstate->id] = rstate; |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 281 | r600_context_pipe_state_set(rctx, rstate); |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 282 | |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 283 | ref.ref_value[0] = rctx->stencil_ref.pipe_state.ref_value[0]; |
| 284 | ref.ref_value[1] = rctx->stencil_ref.pipe_state.ref_value[1]; |
Marek Olšák | a236194 | 2012-01-28 05:50:00 +0100 | [diff] [blame] | 285 | ref.valuemask[0] = dsa->valuemask[0]; |
| 286 | ref.valuemask[1] = dsa->valuemask[1]; |
| 287 | ref.writemask[0] = dsa->writemask[0]; |
| 288 | ref.writemask[1] = dsa->writemask[1]; |
| 289 | |
| 290 | r600_set_stencil_ref(ctx, &ref); |
Marek Olšák | bc2f5fc | 2012-07-18 03:45:25 +0200 | [diff] [blame] | 291 | |
| 292 | /* Update alphatest state. */ |
| 293 | if (rctx->alphatest_state.sx_alpha_test_control != dsa->sx_alpha_test_control || |
| 294 | rctx->alphatest_state.sx_alpha_ref != dsa->alpha_ref) { |
| 295 | rctx->alphatest_state.sx_alpha_test_control = dsa->sx_alpha_test_control; |
| 296 | rctx->alphatest_state.sx_alpha_ref = dsa->alpha_ref; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 297 | rctx->alphatest_state.atom.dirty = true; |
Marek Olšák | bc2f5fc | 2012-07-18 03:45:25 +0200 | [diff] [blame] | 298 | } |
Henri Verbeet | f60235e | 2011-05-05 20:54:36 +0200 | [diff] [blame] | 299 | } |
| 300 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 301 | static void r600_bind_rs_state(struct pipe_context *ctx, void *state) |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 302 | { |
Marek Olšák | 711f3ba | 2012-10-05 19:39:14 +0200 | [diff] [blame^] | 303 | struct r600_rasterizer_state *rs = (struct r600_rasterizer_state *)state; |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 304 | struct r600_context *rctx = (struct r600_context *)ctx; |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 305 | |
| 306 | if (state == NULL) |
| 307 | return; |
| 308 | |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 309 | rctx->rasterizer = rs; |
| 310 | |
Marek Olšák | 711f3ba | 2012-10-05 19:39:14 +0200 | [diff] [blame^] | 311 | r600_set_cso_state_with_cb(&rctx->rasterizer_state, rs, &rs->buffer); |
Jerome Glisse | 0b841b0 | 2010-12-03 12:20:40 -0500 | [diff] [blame] | 312 | |
Marek Olšák | ab075de | 2012-10-05 04:59:50 +0200 | [diff] [blame] | 313 | if (rs->offset_enable && |
| 314 | (rs->offset_units != rctx->poly_offset_state.offset_units || |
| 315 | rs->offset_scale != rctx->poly_offset_state.offset_scale)) { |
| 316 | rctx->poly_offset_state.offset_units = rs->offset_units; |
| 317 | rctx->poly_offset_state.offset_scale = rs->offset_scale; |
| 318 | rctx->poly_offset_state.atom.dirty = true; |
Jerome Glisse | 0b841b0 | 2010-12-03 12:20:40 -0500 | [diff] [blame] | 319 | } |
Marek Olšák | aacd653 | 2012-02-26 13:17:53 +0100 | [diff] [blame] | 320 | |
Marek Olšák | c56dca9 | 2012-09-10 21:38:09 +0200 | [diff] [blame] | 321 | /* Update clip_misc_state. */ |
| 322 | if (rctx->clip_misc_state.pa_cl_clip_cntl != rs->pa_cl_clip_cntl || |
| 323 | rctx->clip_misc_state.clip_plane_enable != rs->clip_plane_enable) { |
| 324 | rctx->clip_misc_state.pa_cl_clip_cntl = rs->pa_cl_clip_cntl; |
| 325 | rctx->clip_misc_state.clip_plane_enable = rs->clip_plane_enable; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 326 | rctx->clip_misc_state.atom.dirty = true; |
Marek Olšák | c56dca9 | 2012-09-10 21:38:09 +0200 | [diff] [blame] | 327 | } |
| 328 | |
Marek Olšák | aacd653 | 2012-02-26 13:17:53 +0100 | [diff] [blame] | 329 | /* Workaround for a missing scissor enable on r600. */ |
Marek Olšák | 18a1891 | 2012-10-05 05:37:38 +0200 | [diff] [blame] | 330 | if (rctx->chip_class == R600 && |
| 331 | rs->scissor_enable != rctx->scissor.enable) { |
| 332 | rctx->scissor.enable = rs->scissor_enable; |
| 333 | rctx->scissor.atom.dirty = true; |
Marek Olšák | aacd653 | 2012-02-26 13:17:53 +0100 | [diff] [blame] | 334 | } |
Marek Olšák | 711f3ba | 2012-10-05 19:39:14 +0200 | [diff] [blame^] | 335 | |
| 336 | /* Re-emit PA_SC_LINE_STIPPLE. */ |
| 337 | rctx->last_primitive_type = -1; |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 338 | } |
| 339 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 340 | static void r600_delete_rs_state(struct pipe_context *ctx, void *state) |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 341 | { |
Marek Olšák | 711f3ba | 2012-10-05 19:39:14 +0200 | [diff] [blame^] | 342 | struct r600_rasterizer_state *rs = (struct r600_rasterizer_state *)state; |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 343 | |
Marek Olšák | 711f3ba | 2012-10-05 19:39:14 +0200 | [diff] [blame^] | 344 | r600_release_command_buffer(&rs->buffer); |
| 345 | FREE(rs); |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 346 | } |
| 347 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 348 | static void r600_sampler_view_destroy(struct pipe_context *ctx, |
| 349 | struct pipe_sampler_view *state) |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 350 | { |
| 351 | struct r600_pipe_sampler_view *resource = (struct r600_pipe_sampler_view *)state; |
| 352 | |
| 353 | pipe_resource_reference(&state->texture, NULL); |
| 354 | FREE(resource); |
| 355 | } |
| 356 | |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 357 | void r600_sampler_states_dirty(struct r600_context *rctx, |
| 358 | struct r600_sampler_states *state) |
| 359 | { |
| 360 | if (state->dirty_mask) { |
| 361 | if (state->dirty_mask & state->has_bordercolor_mask) { |
| 362 | rctx->flags |= R600_CONTEXT_PS_PARTIAL_FLUSH; |
| 363 | } |
| 364 | state->atom.num_dw = |
| 365 | util_bitcount(state->dirty_mask & state->has_bordercolor_mask) * 11 + |
| 366 | util_bitcount(state->dirty_mask & ~state->has_bordercolor_mask) * 5; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 367 | state->atom.dirty = true; |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 368 | } |
| 369 | } |
| 370 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 371 | static void r600_bind_sampler_states(struct pipe_context *pipe, |
Brian Paul | d663a55 | 2012-08-09 20:59:44 -0600 | [diff] [blame] | 372 | unsigned shader, |
| 373 | unsigned start, |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 374 | unsigned count, void **states) |
| 375 | { |
Brian Paul | d663a55 | 2012-08-09 20:59:44 -0600 | [diff] [blame] | 376 | struct r600_context *rctx = (struct r600_context *)pipe; |
Marek Olšák | f2eac14 | 2012-09-10 04:53:33 +0200 | [diff] [blame] | 377 | struct r600_textures_info *dst = &rctx->samplers[shader]; |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 378 | struct r600_pipe_sampler_state **rstates = (struct r600_pipe_sampler_state**)states; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 379 | int seamless_cube_map = -1; |
| 380 | unsigned i; |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 381 | /* This sets 1-bit for states with index >= count. */ |
| 382 | uint32_t disable_mask = ~((1ull << count) - 1); |
| 383 | /* These are the new states set by this function. */ |
| 384 | uint32_t new_mask = 0; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 385 | |
Brian Paul | d663a55 | 2012-08-09 20:59:44 -0600 | [diff] [blame] | 386 | assert(start == 0); /* XXX fix below */ |
| 387 | |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 388 | for (i = 0; i < count; i++) { |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 389 | struct r600_pipe_sampler_state *rstate = rstates[i]; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 390 | |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 391 | if (rstate == dst->states.states[i]) { |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 392 | continue; |
| 393 | } |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 394 | |
| 395 | if (rstate) { |
| 396 | if (rstate->border_color_use) { |
| 397 | dst->states.has_bordercolor_mask |= 1 << i; |
| 398 | } else { |
| 399 | dst->states.has_bordercolor_mask &= ~(1 << i); |
| 400 | } |
| 401 | seamless_cube_map = rstate->seamless_cube_map; |
| 402 | |
| 403 | new_mask |= 1 << i; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 404 | } else { |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 405 | disable_mask |= 1 << i; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 406 | } |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 407 | } |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 408 | |
| 409 | memcpy(dst->states.states, rstates, sizeof(void*) * count); |
| 410 | memset(dst->states.states + count, 0, sizeof(void*) * (NUM_TEX_UNITS - count)); |
| 411 | |
| 412 | dst->states.enabled_mask &= ~disable_mask; |
| 413 | dst->states.dirty_mask &= dst->states.enabled_mask; |
| 414 | dst->states.enabled_mask |= new_mask; |
| 415 | dst->states.dirty_mask |= new_mask; |
| 416 | dst->states.has_bordercolor_mask &= dst->states.enabled_mask; |
| 417 | |
| 418 | r600_sampler_states_dirty(rctx, &dst->states); |
| 419 | |
| 420 | /* Seamless cubemap state. */ |
| 421 | if (rctx->chip_class <= R700 && |
| 422 | seamless_cube_map != -1 && |
| 423 | seamless_cube_map != rctx->seamless_cube_map.enabled) { |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 424 | /* change in TA_CNTL_AUX need a pipeline flush */ |
Marek Olšák | fd2e34d | 2012-09-09 06:08:39 +0200 | [diff] [blame] | 425 | rctx->flags |= R600_CONTEXT_PS_PARTIAL_FLUSH; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 426 | rctx->seamless_cube_map.enabled = seamless_cube_map; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 427 | rctx->seamless_cube_map.atom.dirty = true; |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 428 | } |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 429 | } |
| 430 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 431 | static void r600_bind_vs_sampler_states(struct pipe_context *ctx, unsigned count, void **states) |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 432 | { |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 433 | r600_bind_sampler_states(ctx, PIPE_SHADER_VERTEX, 0, count, states); |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 434 | } |
| 435 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 436 | static void r600_bind_ps_sampler_states(struct pipe_context *ctx, unsigned count, void **states) |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 437 | { |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 438 | r600_bind_sampler_states(ctx, PIPE_SHADER_FRAGMENT, 0, count, states); |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 439 | } |
| 440 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 441 | static void r600_delete_sampler_state(struct pipe_context *ctx, void *state) |
Jerome Glisse | 2df399c | 2012-08-01 15:53:11 -0400 | [diff] [blame] | 442 | { |
| 443 | free(state); |
| 444 | } |
| 445 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 446 | static void r600_delete_blend_state(struct pipe_context *ctx, void *state) |
| 447 | { |
| 448 | struct r600_blend_state *blend = (struct r600_blend_state*)state; |
| 449 | |
| 450 | r600_release_command_buffer(&blend->buffer); |
| 451 | r600_release_command_buffer(&blend->buffer_no_blend); |
| 452 | FREE(blend); |
| 453 | } |
| 454 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 455 | static void r600_delete_state(struct pipe_context *ctx, void *state) |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 456 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 457 | struct r600_context *rctx = (struct r600_context *)ctx; |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 458 | struct r600_pipe_state *rstate = (struct r600_pipe_state *)state; |
| 459 | |
| 460 | if (rctx->states[rstate->id] == rstate) { |
| 461 | rctx->states[rstate->id] = NULL; |
| 462 | } |
| 463 | for (int i = 0; i < rstate->nregs; i++) { |
Marek Olšák | 6101b6d | 2011-09-11 22:24:38 +0200 | [diff] [blame] | 464 | pipe_resource_reference((struct pipe_resource**)&rstate->regs[i].bo, NULL); |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 465 | } |
| 466 | free(rstate); |
| 467 | } |
| 468 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 469 | static void r600_bind_vertex_elements(struct pipe_context *ctx, void *state) |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 470 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 471 | struct r600_context *rctx = (struct r600_context *)ctx; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 472 | |
Marek Olšák | a50edc8 | 2012-10-05 04:02:22 +0200 | [diff] [blame] | 473 | r600_set_cso_state(&rctx->vertex_fetch_shader, state); |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 474 | } |
| 475 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 476 | static void r600_delete_vertex_elements(struct pipe_context *ctx, void *state) |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 477 | { |
Marek Olšák | a50edc8 | 2012-10-05 04:02:22 +0200 | [diff] [blame] | 478 | pipe_resource_reference((struct pipe_resource**)&state, NULL); |
Dave Airlie | 9612b48 | 2010-10-24 12:53:50 +1000 | [diff] [blame] | 479 | } |
| 480 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 481 | static void r600_set_index_buffer(struct pipe_context *ctx, |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 482 | const struct pipe_index_buffer *ib) |
| 483 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 484 | struct r600_context *rctx = (struct r600_context *)ctx; |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 485 | |
Marek Olšák | 31714ea | 2012-03-31 04:56:48 +0200 | [diff] [blame] | 486 | if (ib) { |
| 487 | pipe_resource_reference(&rctx->index_buffer.buffer, ib->buffer); |
| 488 | memcpy(&rctx->index_buffer, ib, sizeof(*ib)); |
| 489 | } else { |
| 490 | pipe_resource_reference(&rctx->index_buffer.buffer, NULL); |
| 491 | } |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 492 | } |
| 493 | |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 494 | void r600_vertex_buffers_dirty(struct r600_context *rctx) |
| 495 | { |
| 496 | if (rctx->vertex_buffer_state.dirty_mask) { |
Marek Olšák | fd2e34d | 2012-09-09 06:08:39 +0200 | [diff] [blame] | 497 | rctx->flags |= rctx->has_vertex_cache ? R600_CONTEXT_VTX_FLUSH : R600_CONTEXT_TEX_FLUSH; |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 498 | rctx->vertex_buffer_state.atom.num_dw = (rctx->chip_class >= EVERGREEN ? 12 : 11) * |
| 499 | util_bitcount(rctx->vertex_buffer_state.dirty_mask); |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 500 | rctx->vertex_buffer_state.atom.dirty = true; |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 501 | } |
| 502 | } |
| 503 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 504 | static void r600_set_vertex_buffers(struct pipe_context *ctx, unsigned count, |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 505 | const struct pipe_vertex_buffer *input) |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 506 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 507 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 508 | struct r600_vertexbuf_state *state = &rctx->vertex_buffer_state; |
| 509 | struct pipe_vertex_buffer *vb = state->vb; |
Tom Stellard | c2f444c | 2012-07-12 19:50:28 +0000 | [diff] [blame] | 510 | unsigned i; |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 511 | /* This sets 1-bit for buffers with index >= count. */ |
| 512 | uint32_t disable_mask = ~((1ull << count) - 1); |
| 513 | /* These are the new buffers set by this function. */ |
| 514 | uint32_t new_buffer_mask = 0; |
Marek Olšák | 8c631cf | 2011-01-28 22:04:09 +0100 | [diff] [blame] | 515 | |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 516 | /* Set buffers with index >= count to NULL. */ |
| 517 | uint32_t remaining_buffers_mask = |
| 518 | rctx->vertex_buffer_state.enabled_mask & disable_mask; |
Marek Olšák | 23b9480 | 2012-04-01 23:54:44 +0200 | [diff] [blame] | 519 | |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 520 | while (remaining_buffers_mask) { |
| 521 | i = u_bit_scan(&remaining_buffers_mask); |
| 522 | pipe_resource_reference(&vb[i].buffer, NULL); |
Tom Stellard | c2f444c | 2012-07-12 19:50:28 +0000 | [diff] [blame] | 523 | } |
Marek Olšák | 585baac | 2012-07-06 03:18:06 +0200 | [diff] [blame] | 524 | |
| 525 | /* Set vertex buffers. */ |
| 526 | for (i = 0; i < count; i++) { |
| 527 | if (memcmp(&input[i], &vb[i], sizeof(struct pipe_vertex_buffer))) { |
| 528 | if (input[i].buffer) { |
| 529 | vb[i].stride = input[i].stride; |
| 530 | vb[i].buffer_offset = input[i].buffer_offset; |
| 531 | pipe_resource_reference(&vb[i].buffer, input[i].buffer); |
| 532 | new_buffer_mask |= 1 << i; |
| 533 | } else { |
| 534 | pipe_resource_reference(&vb[i].buffer, NULL); |
| 535 | disable_mask |= 1 << i; |
| 536 | } |
| 537 | } |
| 538 | } |
| 539 | |
| 540 | rctx->vertex_buffer_state.enabled_mask &= ~disable_mask; |
| 541 | rctx->vertex_buffer_state.dirty_mask &= rctx->vertex_buffer_state.enabled_mask; |
| 542 | rctx->vertex_buffer_state.enabled_mask |= new_buffer_mask; |
| 543 | rctx->vertex_buffer_state.dirty_mask |= new_buffer_mask; |
| 544 | |
| 545 | r600_vertex_buffers_dirty(rctx); |
Dave Airlie | f39e6c9 | 2010-10-21 19:11:23 +1000 | [diff] [blame] | 546 | } |
| 547 | |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 548 | void r600_sampler_views_dirty(struct r600_context *rctx, |
| 549 | struct r600_samplerview_state *state) |
| 550 | { |
| 551 | if (state->dirty_mask) { |
Marek Olšák | fd2e34d | 2012-09-09 06:08:39 +0200 | [diff] [blame] | 552 | rctx->flags |= R600_CONTEXT_TEX_FLUSH; |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 553 | state->atom.num_dw = (rctx->chip_class >= EVERGREEN ? 14 : 13) * |
| 554 | util_bitcount(state->dirty_mask); |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 555 | state->atom.dirty = true; |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 556 | } |
| 557 | } |
| 558 | |
Marek Olšák | 48de30e | 2012-09-10 01:04:47 +0200 | [diff] [blame] | 559 | static void r600_set_sampler_views(struct pipe_context *pipe, unsigned shader, |
| 560 | unsigned start, unsigned count, |
| 561 | struct pipe_sampler_view **views) |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 562 | { |
Brian Paul | d663a55 | 2012-08-09 20:59:44 -0600 | [diff] [blame] | 563 | struct r600_context *rctx = (struct r600_context *) pipe; |
Marek Olšák | f2eac14 | 2012-09-10 04:53:33 +0200 | [diff] [blame] | 564 | struct r600_textures_info *dst = &rctx->samplers[shader]; |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 565 | struct r600_pipe_sampler_view **rviews = (struct r600_pipe_sampler_view **)views; |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 566 | uint32_t dirty_sampler_states_mask = 0; |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 567 | unsigned i; |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 568 | /* This sets 1-bit for textures with index >= count. */ |
| 569 | uint32_t disable_mask = ~((1ull << count) - 1); |
| 570 | /* These are the new textures set by this function. */ |
| 571 | uint32_t new_mask = 0; |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 572 | |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 573 | /* Set textures with index >= count to NULL. */ |
Brian Paul | d663a55 | 2012-08-09 20:59:44 -0600 | [diff] [blame] | 574 | uint32_t remaining_mask; |
| 575 | |
| 576 | assert(start == 0); /* XXX fix below */ |
| 577 | |
Brian Paul | d663a55 | 2012-08-09 20:59:44 -0600 | [diff] [blame] | 578 | remaining_mask = dst->views.enabled_mask & disable_mask; |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 579 | |
| 580 | while (remaining_mask) { |
| 581 | i = u_bit_scan(&remaining_mask); |
| 582 | assert(dst->views.views[i]); |
| 583 | |
| 584 | pipe_sampler_view_reference((struct pipe_sampler_view **)&dst->views.views[i], NULL); |
| 585 | } |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 586 | |
| 587 | for (i = 0; i < count; i++) { |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 588 | if (rviews[i] == dst->views.views[i]) { |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 589 | continue; |
| 590 | } |
| 591 | |
| 592 | if (rviews[i]) { |
Marek Olšák | 951ac46 | 2012-08-14 02:29:17 +0200 | [diff] [blame] | 593 | struct r600_texture *rtex = |
| 594 | (struct r600_texture*)rviews[i]->base.texture; |
Marek Olšák | 80755ff | 2012-07-14 17:06:27 +0200 | [diff] [blame] | 595 | |
| 596 | if (rtex->is_depth && !rtex->is_flushing_texture) { |
Marek Olšák | 48edfe0 | 2012-08-13 19:52:57 +0200 | [diff] [blame] | 597 | dst->views.compressed_depthtex_mask |= 1 << i; |
Marek Olšák | 80755ff | 2012-07-14 17:06:27 +0200 | [diff] [blame] | 598 | } else { |
Marek Olšák | 48edfe0 | 2012-08-13 19:52:57 +0200 | [diff] [blame] | 599 | dst->views.compressed_depthtex_mask &= ~(1 << i); |
Marek Olšák | 80755ff | 2012-07-14 17:06:27 +0200 | [diff] [blame] | 600 | } |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 601 | |
Marek Olšák | 64db3cc | 2012-08-30 05:38:02 +0200 | [diff] [blame] | 602 | /* Track compressed colorbuffers for Evergreen (Cayman doesn't need this). */ |
| 603 | if (rctx->chip_class != CAYMAN && rtex->cmask_size && rtex->fmask_size) { |
Marek Olšák | a3d9d7e | 2012-08-12 20:06:33 +0200 | [diff] [blame] | 604 | dst->views.compressed_colortex_mask |= 1 << i; |
| 605 | } else { |
| 606 | dst->views.compressed_colortex_mask &= ~(1 << i); |
| 607 | } |
| 608 | |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 609 | /* Changing from array to non-arrays textures and vice versa requires |
| 610 | * updating TEX_ARRAY_OVERRIDE in sampler states on R6xx-R7xx. */ |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 611 | if (rctx->chip_class <= R700 && |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 612 | (dst->states.enabled_mask & (1 << i)) && |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 613 | (rviews[i]->base.texture->target == PIPE_TEXTURE_1D_ARRAY || |
| 614 | rviews[i]->base.texture->target == PIPE_TEXTURE_2D_ARRAY) != dst->is_array_sampler[i]) { |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 615 | dirty_sampler_states_mask |= 1 << i; |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 616 | } |
| 617 | |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 618 | pipe_sampler_view_reference((struct pipe_sampler_view **)&dst->views.views[i], views[i]); |
| 619 | new_mask |= 1 << i; |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 620 | } else { |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 621 | pipe_sampler_view_reference((struct pipe_sampler_view **)&dst->views.views[i], NULL); |
| 622 | disable_mask |= 1 << i; |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 623 | } |
| 624 | } |
| 625 | |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 626 | dst->views.enabled_mask &= ~disable_mask; |
| 627 | dst->views.dirty_mask &= dst->views.enabled_mask; |
| 628 | dst->views.enabled_mask |= new_mask; |
| 629 | dst->views.dirty_mask |= new_mask; |
Marek Olšák | 48edfe0 | 2012-08-13 19:52:57 +0200 | [diff] [blame] | 630 | dst->views.compressed_depthtex_mask &= dst->views.enabled_mask; |
Marek Olšák | a3d9d7e | 2012-08-12 20:06:33 +0200 | [diff] [blame] | 631 | dst->views.compressed_colortex_mask &= dst->views.enabled_mask; |
Marek Olšák | 5d8d425 | 2012-07-14 15:26:59 +0200 | [diff] [blame] | 632 | |
| 633 | r600_sampler_views_dirty(rctx, &dst->views); |
Marek Olšák | 3fe7859 | 2012-09-10 04:06:20 +0200 | [diff] [blame] | 634 | |
| 635 | if (dirty_sampler_states_mask) { |
| 636 | dst->states.dirty_mask |= dirty_sampler_states_mask; |
| 637 | r600_sampler_states_dirty(rctx, &dst->states); |
| 638 | } |
Marek Olšák | ba48f47 | 2012-07-14 16:23:42 +0200 | [diff] [blame] | 639 | } |
| 640 | |
Marek Olšák | 48de30e | 2012-09-10 01:04:47 +0200 | [diff] [blame] | 641 | static void r600_set_vs_sampler_views(struct pipe_context *ctx, unsigned count, |
| 642 | struct pipe_sampler_view **views) |
| 643 | { |
| 644 | r600_set_sampler_views(ctx, PIPE_SHADER_VERTEX, 0, count, views); |
| 645 | } |
| 646 | |
| 647 | static void r600_set_ps_sampler_views(struct pipe_context *ctx, unsigned count, |
| 648 | struct pipe_sampler_view **views) |
| 649 | { |
| 650 | r600_set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, count, views); |
| 651 | } |
| 652 | |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 653 | static void r600_set_viewport_state(struct pipe_context *ctx, |
Marek Olšák | 605fd0c | 2012-09-10 19:28:34 +0200 | [diff] [blame] | 654 | const struct pipe_viewport_state *state) |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 655 | { |
| 656 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 657 | |
Marek Olšák | 605fd0c | 2012-09-10 19:28:34 +0200 | [diff] [blame] | 658 | rctx->viewport.state = *state; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 659 | rctx->viewport.atom.dirty = true; |
Marek Olšák | 605fd0c | 2012-09-10 19:28:34 +0200 | [diff] [blame] | 660 | } |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 661 | |
Marek Olšák | 605fd0c | 2012-09-10 19:28:34 +0200 | [diff] [blame] | 662 | void r600_emit_viewport_state(struct r600_context *rctx, struct r600_atom *atom) |
| 663 | { |
| 664 | struct radeon_winsys_cs *cs = rctx->cs; |
| 665 | struct pipe_viewport_state *state = &rctx->viewport.state; |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 666 | |
Marek Olšák | 605fd0c | 2012-09-10 19:28:34 +0200 | [diff] [blame] | 667 | r600_write_context_reg_seq(cs, R_02843C_PA_CL_VPORT_XSCALE_0, 6); |
| 668 | r600_write_value(cs, fui(state->scale[0])); /* R_02843C_PA_CL_VPORT_XSCALE_0 */ |
| 669 | r600_write_value(cs, fui(state->translate[0])); /* R_028440_PA_CL_VPORT_XOFFSET_0 */ |
| 670 | r600_write_value(cs, fui(state->scale[1])); /* R_028444_PA_CL_VPORT_YSCALE_0 */ |
| 671 | r600_write_value(cs, fui(state->translate[1])); /* R_028448_PA_CL_VPORT_YOFFSET_0 */ |
| 672 | r600_write_value(cs, fui(state->scale[2])); /* R_02844C_PA_CL_VPORT_ZSCALE_0 */ |
| 673 | r600_write_value(cs, fui(state->translate[2])); /* R_028450_PA_CL_VPORT_ZOFFSET_0 */ |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 674 | } |
| 675 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 676 | /* Compute the key for the hw shader variant */ |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 677 | static INLINE struct r600_shader_key r600_shader_selector_key(struct pipe_context * ctx, |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 678 | struct r600_pipe_shader_selector * sel) |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 679 | { |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 680 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 681 | struct r600_shader_key key; |
| 682 | memset(&key, 0, sizeof(key)); |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 683 | |
| 684 | if (sel->type == PIPE_SHADER_FRAGMENT) { |
Marek Olšák | 9a683d1 | 2012-10-05 16:51:41 +0200 | [diff] [blame] | 685 | key.color_two_side = rctx->rasterizer && rctx->rasterizer->two_side; |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 686 | key.alpha_to_one = rctx->alpha_to_one && |
Marek Olšák | 9a683d1 | 2012-10-05 16:51:41 +0200 | [diff] [blame] | 687 | rctx->rasterizer && rctx->rasterizer->multisample_enable && |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 688 | !rctx->framebuffer.cb0_is_integer; |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 689 | key.nr_cbufs = rctx->framebuffer.state.nr_cbufs; |
Marek Olšák | 8bf7044 | 2012-10-05 03:00:38 +0200 | [diff] [blame] | 690 | /* Dual-source blending only makes sense with nr_cbufs == 1. */ |
| 691 | if (key.nr_cbufs == 1 && rctx->dual_src_blend) |
| 692 | key.nr_cbufs = 2; |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 693 | } |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 694 | return key; |
| 695 | } |
| 696 | |
| 697 | /* Select the hw shader variant depending on the current state. |
| 698 | * (*dirty) is set to 1 if current variant was changed */ |
| 699 | static int r600_shader_select(struct pipe_context *ctx, |
| 700 | struct r600_pipe_shader_selector* sel, |
| 701 | unsigned *dirty) |
| 702 | { |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 703 | struct r600_shader_key key; |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 704 | struct r600_context *rctx = (struct r600_context *)ctx; |
| 705 | struct r600_pipe_shader * shader = NULL; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 706 | int r; |
| 707 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 708 | key = r600_shader_selector_key(ctx, sel); |
Vadim Girlin | eafd331 | 2011-06-24 20:29:13 +0400 | [diff] [blame] | 709 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 710 | /* Check if we don't need to change anything. |
| 711 | * This path is also used for most shaders that don't need multiple |
| 712 | * variants, it will cost just a computation of the key and this |
| 713 | * test. */ |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 714 | if (likely(sel->current && memcmp(&sel->current->key, &key, sizeof(key)) == 0)) { |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 715 | return 0; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 716 | } |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 717 | |
| 718 | /* lookup if we have other variants in the list */ |
| 719 | if (sel->num_shaders > 1) { |
| 720 | struct r600_pipe_shader *p = sel->current, *c = p->next_variant; |
| 721 | |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 722 | while (c && memcmp(&c->key, &key, sizeof(key)) != 0) { |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 723 | p = c; |
| 724 | c = c->next_variant; |
| 725 | } |
| 726 | |
| 727 | if (c) { |
| 728 | p->next_variant = c->next_variant; |
| 729 | shader = c; |
| 730 | } |
| 731 | } |
| 732 | |
| 733 | if (unlikely(!shader)) { |
| 734 | shader = CALLOC(1, sizeof(struct r600_pipe_shader)); |
| 735 | shader->selector = sel; |
| 736 | |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 737 | r = r600_pipe_shader_create(ctx, shader, key); |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 738 | if (unlikely(r)) { |
Marek Olšák | b652180 | 2012-09-17 23:22:00 +0200 | [diff] [blame] | 739 | R600_ERR("Failed to build shader variant (type=%u) %d\n", |
| 740 | sel->type, r); |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 741 | sel->current = NULL; |
| 742 | return r; |
| 743 | } |
| 744 | |
Vadim Girlin | 0c47d9d | 2012-06-26 22:47:27 +0400 | [diff] [blame] | 745 | /* We don't know the value of nr_ps_max_color_exports until we built |
| 746 | * at least one variant, so we may need to recompute the key after |
| 747 | * building first variant. */ |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 748 | if (sel->type == PIPE_SHADER_FRAGMENT && |
Vadim Girlin | 0c47d9d | 2012-06-26 22:47:27 +0400 | [diff] [blame] | 749 | sel->num_shaders == 0) { |
| 750 | sel->nr_ps_max_color_exports = shader->shader.nr_ps_max_color_exports; |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 751 | key = r600_shader_selector_key(ctx, sel); |
| 752 | } |
| 753 | |
| 754 | shader->key = key; |
| 755 | sel->num_shaders++; |
| 756 | } |
| 757 | |
| 758 | if (dirty) |
| 759 | *dirty = 1; |
| 760 | |
| 761 | shader->next_variant = sel->current; |
| 762 | sel->current = shader; |
| 763 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 764 | if (rctx->chip_class < EVERGREEN && rctx->ps_shader && rctx->vs_shader) { |
| 765 | r600_adjust_gprs(rctx); |
| 766 | } |
| 767 | |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 768 | if (rctx->ps_shader && |
| 769 | rctx->cb_misc_state.nr_ps_color_outputs != rctx->ps_shader->current->nr_ps_color_outputs) { |
| 770 | rctx->cb_misc_state.nr_ps_color_outputs = rctx->ps_shader->current->nr_ps_color_outputs; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 771 | rctx->cb_misc_state.atom.dirty = true; |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 772 | } |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 773 | return 0; |
| 774 | } |
| 775 | |
| 776 | static void *r600_create_shader_state(struct pipe_context *ctx, |
| 777 | const struct pipe_shader_state *state, |
| 778 | unsigned pipe_shader_type) |
| 779 | { |
| 780 | struct r600_pipe_shader_selector *sel = CALLOC_STRUCT(r600_pipe_shader_selector); |
| 781 | int r; |
| 782 | |
| 783 | sel->type = pipe_shader_type; |
| 784 | sel->tokens = tgsi_dup_tokens(state->tokens); |
| 785 | sel->so = state->stream_output; |
| 786 | |
| 787 | r = r600_shader_select(ctx, sel, NULL); |
| 788 | if (r) |
| 789 | return NULL; |
| 790 | |
| 791 | return sel; |
| 792 | } |
| 793 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 794 | static void *r600_create_ps_state(struct pipe_context *ctx, |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 795 | const struct pipe_shader_state *state) |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 796 | { |
| 797 | return r600_create_shader_state(ctx, state, PIPE_SHADER_FRAGMENT); |
| 798 | } |
| 799 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 800 | static void *r600_create_vs_state(struct pipe_context *ctx, |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 801 | const struct pipe_shader_state *state) |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 802 | { |
| 803 | return r600_create_shader_state(ctx, state, PIPE_SHADER_VERTEX); |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 804 | } |
| 805 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 806 | static void r600_bind_ps_state(struct pipe_context *ctx, void *state) |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 807 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 808 | struct r600_context *rctx = (struct r600_context *)ctx; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 809 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 810 | if (!state) |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 811 | state = rctx->dummy_pixel_shader; |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 812 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 813 | rctx->ps_shader = (struct r600_pipe_shader_selector *)state; |
| 814 | r600_context_pipe_state_set(rctx, &rctx->ps_shader->current->rstate); |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 815 | |
Marek Olšák | a1a1ff5 | 2012-07-07 07:40:36 +0200 | [diff] [blame] | 816 | if (rctx->chip_class <= R700) { |
| 817 | bool multiwrite = rctx->ps_shader->current->shader.fs_write_all; |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 818 | |
Marek Olšák | a1a1ff5 | 2012-07-07 07:40:36 +0200 | [diff] [blame] | 819 | if (rctx->cb_misc_state.multiwrite != multiwrite) { |
| 820 | rctx->cb_misc_state.multiwrite = multiwrite; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 821 | rctx->cb_misc_state.atom.dirty = true; |
Marek Olšák | a1a1ff5 | 2012-07-07 07:40:36 +0200 | [diff] [blame] | 822 | } |
| 823 | |
| 824 | if (rctx->vs_shader) |
| 825 | r600_adjust_gprs(rctx); |
Dave Airlie | 04554c7 | 2011-06-08 14:35:00 +1000 | [diff] [blame] | 826 | } |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 827 | |
| 828 | if (rctx->cb_misc_state.nr_ps_color_outputs != rctx->ps_shader->current->nr_ps_color_outputs) { |
| 829 | rctx->cb_misc_state.nr_ps_color_outputs = rctx->ps_shader->current->nr_ps_color_outputs; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 830 | rctx->cb_misc_state.atom.dirty = true; |
Marek Olšák | 4fe7441 | 2012-07-07 09:01:38 +0200 | [diff] [blame] | 831 | } |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 832 | } |
| 833 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 834 | static void r600_bind_vs_state(struct pipe_context *ctx, void *state) |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 835 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 836 | struct r600_context *rctx = (struct r600_context *)ctx; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 837 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 838 | rctx->vs_shader = (struct r600_pipe_shader_selector *)state; |
Jerome Glisse | afc56b1 | 2010-12-05 19:24:03 -0500 | [diff] [blame] | 839 | if (state) { |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 840 | r600_context_pipe_state_set(rctx, &rctx->vs_shader->current->rstate); |
| 841 | |
| 842 | if (rctx->chip_class < EVERGREEN && rctx->ps_shader) |
| 843 | r600_adjust_gprs(rctx); |
Marek Olšák | c56dca9 | 2012-09-10 21:38:09 +0200 | [diff] [blame] | 844 | |
| 845 | /* Update clip misc state. */ |
| 846 | if (rctx->vs_shader->current->pa_cl_vs_out_cntl != rctx->clip_misc_state.pa_cl_vs_out_cntl || |
| 847 | rctx->vs_shader->current->shader.clip_dist_write != rctx->clip_misc_state.clip_dist_write) { |
| 848 | rctx->clip_misc_state.pa_cl_vs_out_cntl = rctx->vs_shader->current->pa_cl_vs_out_cntl; |
| 849 | rctx->clip_misc_state.clip_dist_write = rctx->vs_shader->current->shader.clip_dist_write; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 850 | rctx->clip_misc_state.atom.dirty = true; |
Marek Olšák | c56dca9 | 2012-09-10 21:38:09 +0200 | [diff] [blame] | 851 | } |
Dave Airlie | 04554c7 | 2011-06-08 14:35:00 +1000 | [diff] [blame] | 852 | } |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 853 | } |
| 854 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 855 | static void r600_delete_shader_selector(struct pipe_context *ctx, |
| 856 | struct r600_pipe_shader_selector *sel) |
| 857 | { |
| 858 | struct r600_pipe_shader *p = sel->current, *c; |
| 859 | while (p) { |
| 860 | c = p->next_variant; |
| 861 | r600_pipe_shader_destroy(ctx, p); |
| 862 | free(p); |
| 863 | p = c; |
| 864 | } |
| 865 | |
| 866 | free(sel->tokens); |
| 867 | free(sel); |
| 868 | } |
| 869 | |
| 870 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 871 | static void r600_delete_ps_state(struct pipe_context *ctx, void *state) |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 872 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 873 | struct r600_context *rctx = (struct r600_context *)ctx; |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 874 | struct r600_pipe_shader_selector *sel = (struct r600_pipe_shader_selector *)state; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 875 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 876 | if (rctx->ps_shader == sel) { |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 877 | rctx->ps_shader = NULL; |
| 878 | } |
| 879 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 880 | r600_delete_shader_selector(ctx, sel); |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 881 | } |
| 882 | |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 883 | static void r600_delete_vs_state(struct pipe_context *ctx, void *state) |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 884 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 885 | struct r600_context *rctx = (struct r600_context *)ctx; |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 886 | struct r600_pipe_shader_selector *sel = (struct r600_pipe_shader_selector *)state; |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 887 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 888 | if (rctx->vs_shader == sel) { |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 889 | rctx->vs_shader = NULL; |
| 890 | } |
| 891 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 892 | r600_delete_shader_selector(ctx, sel); |
Dave Airlie | a20c234 | 2010-10-24 13:04:44 +1000 | [diff] [blame] | 893 | } |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 894 | |
Marek Olšák | 68bbfc1 | 2012-04-01 22:03:15 +0200 | [diff] [blame] | 895 | void r600_constant_buffers_dirty(struct r600_context *rctx, struct r600_constbuf_state *state) |
| 896 | { |
Marek Olšák | 7022f49 | 2012-07-14 18:15:29 +0200 | [diff] [blame] | 897 | if (state->dirty_mask) { |
Marek Olšák | fd2e34d | 2012-09-09 06:08:39 +0200 | [diff] [blame] | 898 | rctx->flags |= R600_CONTEXT_SHADERCONST_FLUSH; |
Marek Olšák | 7022f49 | 2012-07-14 18:15:29 +0200 | [diff] [blame] | 899 | state->atom.num_dw = rctx->chip_class >= EVERGREEN ? util_bitcount(state->dirty_mask)*20 |
| 900 | : util_bitcount(state->dirty_mask)*19; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 901 | state->atom.dirty = true; |
Marek Olšák | 7022f49 | 2012-07-14 18:15:29 +0200 | [diff] [blame] | 902 | } |
Marek Olšák | 68bbfc1 | 2012-04-01 22:03:15 +0200 | [diff] [blame] | 903 | } |
| 904 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 905 | static void r600_set_constant_buffer(struct pipe_context *ctx, uint shader, uint index, |
| 906 | struct pipe_constant_buffer *input) |
Marek Olšák | 15730a8 | 2011-01-29 03:15:52 +0100 | [diff] [blame] | 907 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 908 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 1bce17e | 2012-09-10 00:56:45 +0200 | [diff] [blame] | 909 | struct r600_constbuf_state *state = &rctx->constbuf_state[shader]; |
Marek Olšák | 5073378 | 2012-04-24 19:52:26 +0200 | [diff] [blame] | 910 | struct pipe_constant_buffer *cb; |
Marek Olšák | 0b7d48c | 2012-04-24 22:53:05 +0200 | [diff] [blame] | 911 | const uint8_t *ptr; |
Marek Olšák | 15730a8 | 2011-01-29 03:15:52 +0100 | [diff] [blame] | 912 | |
| 913 | /* Note that the state tracker can unbind constant buffers by |
| 914 | * passing NULL here. |
| 915 | */ |
Marek Olšák | 5073378 | 2012-04-24 19:52:26 +0200 | [diff] [blame] | 916 | if (unlikely(!input)) { |
Marek Olšák | 68bbfc1 | 2012-04-01 22:03:15 +0200 | [diff] [blame] | 917 | state->enabled_mask &= ~(1 << index); |
| 918 | state->dirty_mask &= ~(1 << index); |
| 919 | pipe_resource_reference(&state->cb[index].buffer, NULL); |
Marek Olšák | 15730a8 | 2011-01-29 03:15:52 +0100 | [diff] [blame] | 920 | return; |
| 921 | } |
| 922 | |
Marek Olšák | 68bbfc1 | 2012-04-01 22:03:15 +0200 | [diff] [blame] | 923 | cb = &state->cb[index]; |
Marek Olšák | 5073378 | 2012-04-24 19:52:26 +0200 | [diff] [blame] | 924 | cb->buffer_size = input->buffer_size; |
Henri Verbeet | 077c448 | 2011-02-07 15:22:08 +0100 | [diff] [blame] | 925 | |
Marek Olšák | 0b7d48c | 2012-04-24 22:53:05 +0200 | [diff] [blame] | 926 | ptr = input->user_buffer; |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 927 | |
| 928 | if (ptr) { |
| 929 | /* Upload the user buffer. */ |
| 930 | if (R600_BIG_ENDIAN) { |
| 931 | uint32_t *tmpPtr; |
Marek Olšák | 5073378 | 2012-04-24 19:52:26 +0200 | [diff] [blame] | 932 | unsigned i, size = input->buffer_size; |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 933 | |
| 934 | if (!(tmpPtr = malloc(size))) { |
| 935 | R600_ERR("Failed to allocate BE swap buffer.\n"); |
| 936 | return; |
| 937 | } |
| 938 | |
| 939 | for (i = 0; i < size / 4; ++i) { |
| 940 | tmpPtr[i] = bswap_32(((uint32_t *)ptr)[i]); |
| 941 | } |
| 942 | |
Marek Olšák | 428855e | 2012-04-11 16:00:09 +0200 | [diff] [blame] | 943 | u_upload_data(rctx->uploader, 0, size, tmpPtr, &cb->buffer_offset, &cb->buffer); |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 944 | free(tmpPtr); |
| 945 | } else { |
Marek Olšák | 5073378 | 2012-04-24 19:52:26 +0200 | [diff] [blame] | 946 | u_upload_data(rctx->uploader, 0, input->buffer_size, ptr, &cb->buffer_offset, &cb->buffer); |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 947 | } |
| 948 | } else { |
| 949 | /* Setup the hw buffer. */ |
Marek Olšák | 5073378 | 2012-04-24 19:52:26 +0200 | [diff] [blame] | 950 | cb->buffer_offset = input->buffer_offset; |
| 951 | pipe_resource_reference(&cb->buffer, input->buffer); |
Marek Olšák | e9abb2c | 2012-04-02 02:45:27 +0200 | [diff] [blame] | 952 | } |
| 953 | |
Marek Olšák | 68bbfc1 | 2012-04-01 22:03:15 +0200 | [diff] [blame] | 954 | state->enabled_mask |= 1 << index; |
| 955 | state->dirty_mask |= 1 << index; |
| 956 | r600_constant_buffers_dirty(rctx, state); |
Marek Olšák | 15730a8 | 2011-01-29 03:15:52 +0100 | [diff] [blame] | 957 | } |
| 958 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 959 | static struct pipe_stream_output_target * |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 960 | r600_create_so_target(struct pipe_context *ctx, |
| 961 | struct pipe_resource *buffer, |
| 962 | unsigned buffer_offset, |
| 963 | unsigned buffer_size) |
| 964 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 965 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 966 | struct r600_so_target *t; |
| 967 | void *ptr; |
| 968 | |
| 969 | t = CALLOC_STRUCT(r600_so_target); |
| 970 | if (!t) { |
| 971 | return NULL; |
| 972 | } |
| 973 | |
| 974 | t->b.reference.count = 1; |
| 975 | t->b.context = ctx; |
| 976 | pipe_resource_reference(&t->b.buffer, buffer); |
| 977 | t->b.buffer_offset = buffer_offset; |
| 978 | t->b.buffer_size = buffer_size; |
| 979 | |
| 980 | t->filled_size = (struct r600_resource*) |
| 981 | pipe_buffer_create(ctx->screen, PIPE_BIND_CUSTOM, PIPE_USAGE_STATIC, 4); |
Marek Olšák | 0a61202 | 2012-04-26 12:02:31 +0200 | [diff] [blame] | 982 | ptr = rctx->ws->buffer_map(t->filled_size->cs_buf, rctx->cs, PIPE_TRANSFER_WRITE); |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 983 | memset(ptr, 0, t->filled_size->buf->size); |
Marek Olšák | 0a61202 | 2012-04-26 12:02:31 +0200 | [diff] [blame] | 984 | rctx->ws->buffer_unmap(t->filled_size->cs_buf); |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 985 | |
| 986 | return &t->b; |
| 987 | } |
| 988 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 989 | static void r600_so_target_destroy(struct pipe_context *ctx, |
| 990 | struct pipe_stream_output_target *target) |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 991 | { |
| 992 | struct r600_so_target *t = (struct r600_so_target*)target; |
| 993 | pipe_resource_reference(&t->b.buffer, NULL); |
| 994 | pipe_resource_reference((struct pipe_resource**)&t->filled_size, NULL); |
| 995 | FREE(t); |
| 996 | } |
| 997 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 998 | static void r600_set_so_targets(struct pipe_context *ctx, |
| 999 | unsigned num_targets, |
| 1000 | struct pipe_stream_output_target **targets, |
| 1001 | unsigned append_bitmask) |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 1002 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1003 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 1004 | unsigned i; |
| 1005 | |
| 1006 | /* Stop streamout. */ |
Marek Olšák | cc2cd8b | 2012-06-26 03:35:25 +0200 | [diff] [blame] | 1007 | if (rctx->num_so_targets && !rctx->streamout_start) { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1008 | r600_context_streamout_end(rctx); |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 1009 | } |
| 1010 | |
| 1011 | /* Set the new targets. */ |
| 1012 | for (i = 0; i < num_targets; i++) { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1013 | pipe_so_target_reference((struct pipe_stream_output_target**)&rctx->so_targets[i], targets[i]); |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 1014 | } |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1015 | for (; i < rctx->num_so_targets; i++) { |
| 1016 | pipe_so_target_reference((struct pipe_stream_output_target**)&rctx->so_targets[i], NULL); |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 1017 | } |
| 1018 | |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1019 | rctx->num_so_targets = num_targets; |
| 1020 | rctx->streamout_start = num_targets != 0; |
| 1021 | rctx->streamout_append_bitmask = append_bitmask; |
Marek Olšák | 543b233 | 2011-11-08 21:58:27 +0100 | [diff] [blame] | 1022 | } |
| 1023 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1024 | static void r600_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask) |
Marek Olšák | a01791a | 2012-07-22 07:48:52 +0200 | [diff] [blame] | 1025 | { |
| 1026 | struct r600_context *rctx = (struct r600_context*)pipe; |
| 1027 | |
| 1028 | if (rctx->sample_mask.sample_mask == (uint16_t)sample_mask) |
| 1029 | return; |
| 1030 | |
| 1031 | rctx->sample_mask.sample_mask = sample_mask; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 1032 | rctx->sample_mask.atom.dirty = true; |
Marek Olšák | a01791a | 2012-07-22 07:48:52 +0200 | [diff] [blame] | 1033 | } |
| 1034 | |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1035 | static void r600_update_derived_state(struct r600_context *rctx) |
Marek Olšák | 765503b | 2011-10-25 19:20:14 +0200 | [diff] [blame] | 1036 | { |
Vadim Girlin | e532c71 | 2011-11-04 21:24:03 +0400 | [diff] [blame] | 1037 | struct pipe_context * ctx = (struct pipe_context*)rctx; |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 1038 | unsigned ps_dirty = 0; |
| 1039 | bool blend_disable; |
Vadim Girlin | e532c71 | 2011-11-04 21:24:03 +0400 | [diff] [blame] | 1040 | |
Marek Olšák | a19e6a8 | 2011-10-27 12:27:34 +0200 | [diff] [blame] | 1041 | if (!rctx->blitter->running) { |
Marek Olšák | f2eac14 | 2012-09-10 04:53:33 +0200 | [diff] [blame] | 1042 | unsigned i; |
| 1043 | |
Marek Olšák | 48edfe0 | 2012-08-13 19:52:57 +0200 | [diff] [blame] | 1044 | /* Decompress textures if needed. */ |
Marek Olšák | f2eac14 | 2012-09-10 04:53:33 +0200 | [diff] [blame] | 1045 | for (i = 0; i < PIPE_SHADER_TYPES; i++) { |
| 1046 | struct r600_samplerview_state *views = &rctx->samplers[i].views; |
| 1047 | if (views->compressed_depthtex_mask) { |
| 1048 | r600_decompress_depth_textures(rctx, views); |
| 1049 | } |
| 1050 | if (views->compressed_colortex_mask) { |
| 1051 | r600_decompress_color_textures(rctx, views); |
| 1052 | } |
Marek Olšák | a3d9d7e | 2012-08-12 20:06:33 +0200 | [diff] [blame] | 1053 | } |
Marek Olšák | 765503b | 2011-10-25 19:20:14 +0200 | [diff] [blame] | 1054 | } |
| 1055 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 1056 | r600_shader_select(ctx, rctx->ps_shader, &ps_dirty); |
Marek Olšák | 765503b | 2011-10-25 19:20:14 +0200 | [diff] [blame] | 1057 | |
Marek Olšák | 9a683d1 | 2012-10-05 16:51:41 +0200 | [diff] [blame] | 1058 | if (rctx->ps_shader && rctx->rasterizer && |
| 1059 | ((rctx->rasterizer->sprite_coord_enable != rctx->ps_shader->current->sprite_coord_enable) || |
| 1060 | (rctx->rasterizer->flatshade != rctx->ps_shader->current->flatshade))) { |
Vadim Girlin | e532c71 | 2011-11-04 21:24:03 +0400 | [diff] [blame] | 1061 | |
| 1062 | if (rctx->chip_class >= EVERGREEN) |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 1063 | evergreen_pipe_shader_ps(ctx, rctx->ps_shader->current); |
Vadim Girlin | e532c71 | 2011-11-04 21:24:03 +0400 | [diff] [blame] | 1064 | else |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 1065 | r600_pipe_shader_ps(ctx, rctx->ps_shader->current); |
Vadim Girlin | e532c71 | 2011-11-04 21:24:03 +0400 | [diff] [blame] | 1066 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 1067 | ps_dirty = 1; |
Vadim Girlin | e532c71 | 2011-11-04 21:24:03 +0400 | [diff] [blame] | 1068 | } |
| 1069 | |
Vadim Girlin | 4acf71f | 2012-06-11 13:11:47 +0400 | [diff] [blame] | 1070 | if (ps_dirty) |
| 1071 | r600_context_pipe_state_set(rctx, &rctx->ps_shader->current->rstate); |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 1072 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 1073 | blend_disable = (rctx->dual_src_blend && |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 1074 | rctx->ps_shader->current->nr_ps_color_outputs < 2); |
| 1075 | |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 1076 | if (blend_disable != rctx->force_blend_disable) { |
| 1077 | rctx->force_blend_disable = blend_disable; |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 1078 | r600_bind_blend_state_internal(rctx, |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 1079 | rctx->blend_state.cso, |
| 1080 | blend_disable); |
Vadim Girlin | 8d1a9a9 | 2012-08-21 15:39:25 +0400 | [diff] [blame] | 1081 | } |
| 1082 | |
Jerome Glisse | b75f1d9 | 2012-06-26 12:24:08 -0400 | [diff] [blame] | 1083 | if (rctx->chip_class >= EVERGREEN) { |
Vadim Girlin | 470d00c | 2012-06-26 12:23:31 -0400 | [diff] [blame] | 1084 | evergreen_update_dual_export_state(rctx); |
Jerome Glisse | b75f1d9 | 2012-06-26 12:24:08 -0400 | [diff] [blame] | 1085 | } else { |
| 1086 | r600_update_dual_export_state(rctx); |
| 1087 | } |
Marek Olšák | 765503b | 2011-10-25 19:20:14 +0200 | [diff] [blame] | 1088 | } |
| 1089 | |
Marek Olšák | 428146c | 2012-02-27 13:56:31 +0100 | [diff] [blame] | 1090 | static unsigned r600_conv_prim_to_gs_out(unsigned mode) |
| 1091 | { |
| 1092 | static const int prim_conv[] = { |
| 1093 | V_028A6C_OUTPRIM_TYPE_POINTLIST, |
| 1094 | V_028A6C_OUTPRIM_TYPE_LINESTRIP, |
| 1095 | V_028A6C_OUTPRIM_TYPE_LINESTRIP, |
| 1096 | V_028A6C_OUTPRIM_TYPE_LINESTRIP, |
| 1097 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
| 1098 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
| 1099 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
| 1100 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
| 1101 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
| 1102 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
| 1103 | V_028A6C_OUTPRIM_TYPE_LINESTRIP, |
| 1104 | V_028A6C_OUTPRIM_TYPE_LINESTRIP, |
| 1105 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
Marek Olšák | 187d7fb | 2012-08-24 05:57:22 +0200 | [diff] [blame] | 1106 | V_028A6C_OUTPRIM_TYPE_TRISTRIP, |
Marek Olšák | 428146c | 2012-02-27 13:56:31 +0100 | [diff] [blame] | 1107 | V_028A6C_OUTPRIM_TYPE_TRISTRIP |
| 1108 | }; |
| 1109 | assert(mode < Elements(prim_conv)); |
| 1110 | |
| 1111 | return prim_conv[mode]; |
| 1112 | } |
| 1113 | |
Marek Olšák | c56dca9 | 2012-09-10 21:38:09 +0200 | [diff] [blame] | 1114 | void r600_emit_clip_misc_state(struct r600_context *rctx, struct r600_atom *atom) |
| 1115 | { |
| 1116 | struct radeon_winsys_cs *cs = rctx->cs; |
| 1117 | struct r600_clip_misc_state *state = &rctx->clip_misc_state; |
| 1118 | |
| 1119 | r600_write_context_reg(cs, R_028810_PA_CL_CLIP_CNTL, |
| 1120 | state->pa_cl_clip_cntl | |
| 1121 | (state->clip_dist_write ? 0 : state->clip_plane_enable & 0x3F)); |
| 1122 | r600_write_context_reg(cs, R_02881C_PA_CL_VS_OUT_CNTL, |
| 1123 | state->pa_cl_vs_out_cntl | |
| 1124 | (state->clip_plane_enable & state->clip_dist_write)); |
| 1125 | } |
| 1126 | |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1127 | static void r600_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info *dinfo) |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 1128 | { |
Marek Olšák | e4340c1 | 2012-01-29 23:25:42 +0100 | [diff] [blame] | 1129 | struct r600_context *rctx = (struct r600_context *)ctx; |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1130 | struct pipe_draw_info info = *dinfo; |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1131 | struct pipe_index_buffer ib = {}; |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 1132 | unsigned i; |
Marek Olšák | 3b04671 | 2012-01-30 02:00:51 +0100 | [diff] [blame] | 1133 | struct r600_block *dirty_block = NULL, *next_block = NULL; |
Marek Olšák | 8f5c172 | 2012-02-02 10:04:29 +0100 | [diff] [blame] | 1134 | struct radeon_winsys_cs *cs = rctx->cs; |
| 1135 | uint64_t va; |
Marek Olšák | 34e53ad | 2012-04-02 03:01:01 +0200 | [diff] [blame] | 1136 | uint8_t *ptr; |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 1137 | |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 1138 | if (!info.count && (info.indexed || !info.count_from_stream_output)) { |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 1139 | assert(0); |
Marek Olšák | dc651af | 2011-10-25 16:39:18 +0200 | [diff] [blame] | 1140 | return; |
| 1141 | } |
| 1142 | |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 1143 | if (!rctx->vs_shader) { |
| 1144 | assert(0); |
Vadim Girlin | e98521e | 2011-12-02 13:44:29 +0400 | [diff] [blame] | 1145 | return; |
Marek Olšák | f71f5ed | 2012-02-24 02:08:32 +0100 | [diff] [blame] | 1146 | } |
Vadim Girlin | e98521e | 2011-12-02 13:44:29 +0400 | [diff] [blame] | 1147 | |
Marek Olšák | 765503b | 2011-10-25 19:20:14 +0200 | [diff] [blame] | 1148 | r600_update_derived_state(rctx); |
Marek Olšák | c4519c3 | 2011-09-02 07:35:48 +0200 | [diff] [blame] | 1149 | |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1150 | if (info.indexed) { |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1151 | /* Initialize the index buffer struct. */ |
Marek Olšák | 31714ea | 2012-03-31 04:56:48 +0200 | [diff] [blame] | 1152 | pipe_resource_reference(&ib.buffer, rctx->index_buffer.buffer); |
Marek Olšák | bf469f4 | 2012-04-24 21:14:44 +0200 | [diff] [blame] | 1153 | ib.user_buffer = rctx->index_buffer.user_buffer; |
Marek Olšák | 31714ea | 2012-03-31 04:56:48 +0200 | [diff] [blame] | 1154 | ib.index_size = rctx->index_buffer.index_size; |
| 1155 | ib.offset = rctx->index_buffer.offset + info.start * ib.index_size; |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1156 | |
| 1157 | /* Translate or upload, if needed. */ |
| 1158 | r600_translate_index_buffer(rctx, &ib, info.count); |
| 1159 | |
Marek Olšák | bf469f4 | 2012-04-24 21:14:44 +0200 | [diff] [blame] | 1160 | ptr = (uint8_t*)ib.user_buffer; |
| 1161 | if (!ib.buffer && ptr) { |
Marek Olšák | 428855e | 2012-04-11 16:00:09 +0200 | [diff] [blame] | 1162 | u_upload_data(rctx->uploader, 0, info.count * ib.index_size, |
Marek Olšák | 34e53ad | 2012-04-02 03:01:01 +0200 | [diff] [blame] | 1163 | ptr, &ib.offset, &ib.buffer); |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1164 | } |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1165 | } else { |
| 1166 | info.index_bias = info.start; |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1167 | } |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 1168 | |
Marek Olšák | c3c83af | 2012-07-18 18:33:37 +0200 | [diff] [blame] | 1169 | /* Enable stream out if needed. */ |
| 1170 | if (rctx->streamout_start) { |
| 1171 | r600_context_streamout_begin(rctx); |
| 1172 | rctx->streamout_start = FALSE; |
| 1173 | } |
| 1174 | |
Marek Olšák | 1f5a756 | 2012-09-11 01:16:32 +0200 | [diff] [blame] | 1175 | /* Set the index offset and multi primitive */ |
| 1176 | if (rctx->vgt2_state.vgt_indx_offset != info.index_bias) { |
| 1177 | rctx->vgt2_state.vgt_indx_offset = info.index_bias; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 1178 | rctx->vgt2_state.atom.dirty = true; |
Marek Olšák | 1f5a756 | 2012-09-11 01:16:32 +0200 | [diff] [blame] | 1179 | } |
| 1180 | if (rctx->vgt_state.vgt_multi_prim_ib_reset_en != info.primitive_restart || |
| 1181 | rctx->vgt_state.vgt_multi_prim_ib_reset_indx != info.restart_index) { |
| 1182 | rctx->vgt_state.vgt_multi_prim_ib_reset_en = info.primitive_restart; |
| 1183 | rctx->vgt_state.vgt_multi_prim_ib_reset_indx = info.restart_index; |
Marek Olšák | eb65fef | 2012-10-07 03:47:43 +0200 | [diff] [blame] | 1184 | rctx->vgt_state.atom.dirty = true; |
Marek Olšák | 1f5a756 | 2012-09-11 01:16:32 +0200 | [diff] [blame] | 1185 | } |
| 1186 | |
Marek Olšák | 8f5c172 | 2012-02-02 10:04:29 +0100 | [diff] [blame] | 1187 | /* Emit states (the function expects that we emit at most 17 dwords here). */ |
Marek Olšák | f237fd4 | 2012-07-18 06:23:28 +0200 | [diff] [blame] | 1188 | r600_need_cs_space(rctx, 0, TRUE); |
Marek Olšák | fd2e34d | 2012-09-09 06:08:39 +0200 | [diff] [blame] | 1189 | r600_flush_emit(rctx); |
Marek Olšák | 3b04671 | 2012-01-30 02:00:51 +0100 | [diff] [blame] | 1190 | |
Marek Olšák | 63bf0f9 | 2012-09-10 19:10:46 +0200 | [diff] [blame] | 1191 | for (i = 0; i < R600_NUM_ATOMS; i++) { |
Jerome Glisse | 5ceb872 | 2012-09-05 15:18:24 -0400 | [diff] [blame] | 1192 | if (rctx->atoms[i] == NULL || !rctx->atoms[i]->dirty) { |
| 1193 | continue; |
| 1194 | } |
| 1195 | r600_emit_atom(rctx, rctx->atoms[i]); |
Marek Olšák | 2fe521f | 2012-01-30 01:23:14 +0100 | [diff] [blame] | 1196 | } |
Marek Olšák | 3b04671 | 2012-01-30 02:00:51 +0100 | [diff] [blame] | 1197 | LIST_FOR_EACH_ENTRY_SAFE(dirty_block, next_block, &rctx->dirty,list) { |
Tom Stellard | e00e158 | 2012-06-25 21:16:11 +0000 | [diff] [blame] | 1198 | r600_context_block_emit_dirty(rctx, dirty_block, 0 /* pkt_flags */); |
Marek Olšák | 3b04671 | 2012-01-30 02:00:51 +0100 | [diff] [blame] | 1199 | } |
Marek Olšák | 3b04671 | 2012-01-30 02:00:51 +0100 | [diff] [blame] | 1200 | rctx->pm4_dirty_cdwords = 0; |
| 1201 | |
Marek Olšák | 1f5a756 | 2012-09-11 01:16:32 +0200 | [diff] [blame] | 1202 | /* Update start instance. */ |
| 1203 | if (rctx->last_start_instance != info.start_instance) { |
| 1204 | r600_write_ctl_const(cs, R_03CFF4_SQ_VTX_START_INST_LOC, info.start_instance); |
| 1205 | rctx->last_start_instance = info.start_instance; |
| 1206 | } |
| 1207 | |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 1208 | /* Update the primitive type. */ |
| 1209 | if (rctx->last_primitive_type != info.mode) { |
| 1210 | unsigned ls_mask = 0; |
| 1211 | |
| 1212 | if (info.mode == PIPE_PRIM_LINES) |
| 1213 | ls_mask = 1; |
| 1214 | else if (info.mode == PIPE_PRIM_LINE_STRIP || |
| 1215 | info.mode == PIPE_PRIM_LINE_LOOP) |
| 1216 | ls_mask = 2; |
| 1217 | |
| 1218 | r600_write_context_reg(cs, R_028A0C_PA_SC_LINE_STIPPLE, |
Marek Olšák | 9a683d1 | 2012-10-05 16:51:41 +0200 | [diff] [blame] | 1219 | S_028A0C_AUTO_RESET_CNTL(ls_mask) | |
| 1220 | (rctx->rasterizer ? rctx->rasterizer->pa_sc_line_stipple : 0)); |
Marek Olšák | 150decf | 2012-09-10 21:59:38 +0200 | [diff] [blame] | 1221 | r600_write_context_reg(cs, R_028A6C_VGT_GS_OUT_PRIM_TYPE, |
| 1222 | r600_conv_prim_to_gs_out(info.mode)); |
| 1223 | r600_write_config_reg(cs, R_008958_VGT_PRIMITIVE_TYPE, |
| 1224 | r600_conv_pipe_prim(info.mode)); |
| 1225 | |
| 1226 | rctx->last_primitive_type = info.mode; |
| 1227 | } |
| 1228 | |
| 1229 | /* Draw packets. */ |
Marek Olšák | 8f5c172 | 2012-02-02 10:04:29 +0100 | [diff] [blame] | 1230 | cs->buf[cs->cdw++] = PKT3(PKT3_NUM_INSTANCES, 0, rctx->predicate_drawing); |
| 1231 | cs->buf[cs->cdw++] = info.instance_count; |
| 1232 | if (info.indexed) { |
Marek Olšák | d9ba1b0 | 2012-07-18 06:13:34 +0200 | [diff] [blame] | 1233 | cs->buf[cs->cdw++] = PKT3(PKT3_INDEX_TYPE, 0, rctx->predicate_drawing); |
| 1234 | cs->buf[cs->cdw++] = ib.index_size == 4 ? |
| 1235 | (VGT_INDEX_32 | (R600_BIG_ENDIAN ? VGT_DMA_SWAP_32_BIT : 0)) : |
| 1236 | (VGT_INDEX_16 | (R600_BIG_ENDIAN ? VGT_DMA_SWAP_16_BIT : 0)); |
| 1237 | |
Marek Olšák | 8f5c172 | 2012-02-02 10:04:29 +0100 | [diff] [blame] | 1238 | va = r600_resource_va(ctx->screen, ib.buffer); |
| 1239 | va += ib.offset; |
| 1240 | cs->buf[cs->cdw++] = PKT3(PKT3_DRAW_INDEX, 3, rctx->predicate_drawing); |
| 1241 | cs->buf[cs->cdw++] = va; |
| 1242 | cs->buf[cs->cdw++] = (va >> 32UL) & 0xFF; |
| 1243 | cs->buf[cs->cdw++] = info.count; |
| 1244 | cs->buf[cs->cdw++] = V_0287F0_DI_SRC_SEL_DMA; |
| 1245 | cs->buf[cs->cdw++] = PKT3(PKT3_NOP, 0, rctx->predicate_drawing); |
| 1246 | cs->buf[cs->cdw++] = r600_context_bo_reloc(rctx, (struct r600_resource*)ib.buffer, RADEON_USAGE_READ); |
| 1247 | } else { |
Marek Olšák | ff9a493 | 2012-07-18 06:06:01 +0200 | [diff] [blame] | 1248 | if (info.count_from_stream_output) { |
| 1249 | struct r600_so_target *t = (struct r600_so_target*)info.count_from_stream_output; |
| 1250 | uint64_t va = r600_resource_va(&rctx->screen->screen, (void*)t->filled_size); |
| 1251 | |
Marek Olšák | ff9a493 | 2012-07-18 06:06:01 +0200 | [diff] [blame] | 1252 | r600_write_context_reg(cs, R_028B30_VGT_STRMOUT_DRAW_OPAQUE_VERTEX_STRIDE, t->stride_in_dw); |
| 1253 | |
| 1254 | cs->buf[cs->cdw++] = PKT3(PKT3_COPY_DW, 4, 0); |
| 1255 | cs->buf[cs->cdw++] = COPY_DW_SRC_IS_MEM | COPY_DW_DST_IS_REG; |
| 1256 | cs->buf[cs->cdw++] = va & 0xFFFFFFFFUL; /* src address lo */ |
| 1257 | cs->buf[cs->cdw++] = (va >> 32UL) & 0xFFUL; /* src address hi */ |
| 1258 | cs->buf[cs->cdw++] = R_028B2C_VGT_STRMOUT_DRAW_OPAQUE_BUFFER_FILLED_SIZE >> 2; /* dst register */ |
| 1259 | cs->buf[cs->cdw++] = 0; /* unused */ |
| 1260 | |
| 1261 | cs->buf[cs->cdw++] = PKT3(PKT3_NOP, 0, 0); |
| 1262 | cs->buf[cs->cdw++] = r600_context_bo_reloc(rctx, t->filled_size, RADEON_USAGE_READ); |
| 1263 | } |
| 1264 | |
Marek Olšák | 8f5c172 | 2012-02-02 10:04:29 +0100 | [diff] [blame] | 1265 | cs->buf[cs->cdw++] = PKT3(PKT3_DRAW_INDEX_AUTO, 1, rctx->predicate_drawing); |
| 1266 | cs->buf[cs->cdw++] = info.count; |
| 1267 | cs->buf[cs->cdw++] = V_0287F0_DI_SRC_SEL_AUTO_INDEX | |
| 1268 | (info.count_from_stream_output ? S_0287F0_USE_OPAQUE(1) : 0); |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 1269 | } |
| 1270 | |
Marek Olšák | dee58f9 | 2012-07-08 01:54:24 +0200 | [diff] [blame] | 1271 | /* Set the depth buffer as dirty. */ |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 1272 | if (rctx->framebuffer.state.zsbuf) { |
| 1273 | struct pipe_surface *surf = rctx->framebuffer.state.zsbuf; |
Marek Olšák | 951ac46 | 2012-08-14 02:29:17 +0200 | [diff] [blame] | 1274 | struct r600_texture *rtex = (struct r600_texture *)surf->texture; |
Marek Olšák | dee58f9 | 2012-07-08 01:54:24 +0200 | [diff] [blame] | 1275 | |
Marek Olšák | 48edfe0 | 2012-08-13 19:52:57 +0200 | [diff] [blame] | 1276 | rtex->dirty_level_mask |= 1 << surf->u.tex.level; |
Henri Verbeet | 38b5415 | 2011-01-30 18:57:39 +0100 | [diff] [blame] | 1277 | } |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 1278 | if (rctx->framebuffer.compressed_cb_mask) { |
Marek Olšák | a3d9d7e | 2012-08-12 20:06:33 +0200 | [diff] [blame] | 1279 | struct pipe_surface *surf; |
| 1280 | struct r600_texture *rtex; |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 1281 | unsigned mask = rctx->framebuffer.compressed_cb_mask; |
Marek Olšák | a3d9d7e | 2012-08-12 20:06:33 +0200 | [diff] [blame] | 1282 | |
| 1283 | do { |
| 1284 | unsigned i = u_bit_scan(&mask); |
Marek Olšák | c8b06dc | 2012-09-18 19:42:29 +0200 | [diff] [blame] | 1285 | surf = rctx->framebuffer.state.cbufs[i]; |
Marek Olšák | a3d9d7e | 2012-08-12 20:06:33 +0200 | [diff] [blame] | 1286 | rtex = (struct r600_texture*)surf->texture; |
| 1287 | |
| 1288 | rtex->dirty_level_mask |= 1 << surf->u.tex.level; |
| 1289 | |
| 1290 | } while (mask); |
| 1291 | } |
Henri Verbeet | 38b5415 | 2011-01-30 18:57:39 +0100 | [diff] [blame] | 1292 | |
Marek Olšák | 344039d | 2011-10-26 02:17:52 +0200 | [diff] [blame] | 1293 | pipe_resource_reference(&ib.buffer, NULL); |
Marek Olšák | 2d7738e | 2011-01-28 22:17:41 +0100 | [diff] [blame] | 1294 | } |
Dave Airlie | 42502b6 | 2011-06-02 14:53:15 +1000 | [diff] [blame] | 1295 | |
Marek Olšák | 187d7fb | 2012-08-24 05:57:22 +0200 | [diff] [blame] | 1296 | void r600_draw_rectangle(struct blitter_context *blitter, |
Marek Olšák | 0b0697e | 2012-09-12 23:37:17 +0200 | [diff] [blame] | 1297 | int x1, int y1, int x2, int y2, float depth, |
Marek Olšák | 187d7fb | 2012-08-24 05:57:22 +0200 | [diff] [blame] | 1298 | enum blitter_attrib_type type, const union pipe_color_union *attrib) |
| 1299 | { |
| 1300 | struct r600_context *rctx = (struct r600_context*)util_blitter_get_pipe(blitter); |
| 1301 | struct pipe_viewport_state viewport; |
| 1302 | struct pipe_resource *buf = NULL; |
| 1303 | unsigned offset = 0; |
| 1304 | float *vb; |
| 1305 | |
| 1306 | if (type == UTIL_BLITTER_ATTRIB_TEXCOORD) { |
| 1307 | util_blitter_draw_rectangle(blitter, x1, y1, x2, y2, depth, type, attrib); |
| 1308 | return; |
| 1309 | } |
| 1310 | |
| 1311 | /* Some operations (like color resolve on r6xx) don't work |
| 1312 | * with the conventional primitive types. |
| 1313 | * One that works is PT_RECTLIST, which we use here. */ |
| 1314 | |
| 1315 | /* setup viewport */ |
| 1316 | viewport.scale[0] = 1.0f; |
| 1317 | viewport.scale[1] = 1.0f; |
| 1318 | viewport.scale[2] = 1.0f; |
| 1319 | viewport.scale[3] = 1.0f; |
| 1320 | viewport.translate[0] = 0.0f; |
| 1321 | viewport.translate[1] = 0.0f; |
| 1322 | viewport.translate[2] = 0.0f; |
| 1323 | viewport.translate[3] = 0.0f; |
| 1324 | rctx->context.set_viewport_state(&rctx->context, &viewport); |
| 1325 | |
| 1326 | /* Upload vertices. The hw rectangle has only 3 vertices, |
| 1327 | * I guess the 4th one is derived from the first 3. |
| 1328 | * The vertex specification should match u_blitter's vertex element state. */ |
| 1329 | u_upload_alloc(rctx->uploader, 0, sizeof(float) * 24, &offset, &buf, (void**)&vb); |
| 1330 | vb[0] = x1; |
| 1331 | vb[1] = y1; |
| 1332 | vb[2] = depth; |
| 1333 | vb[3] = 1; |
| 1334 | |
| 1335 | vb[8] = x1; |
| 1336 | vb[9] = y2; |
| 1337 | vb[10] = depth; |
| 1338 | vb[11] = 1; |
| 1339 | |
| 1340 | vb[16] = x2; |
| 1341 | vb[17] = y1; |
| 1342 | vb[18] = depth; |
| 1343 | vb[19] = 1; |
| 1344 | |
| 1345 | if (attrib) { |
| 1346 | memcpy(vb+4, attrib->f, sizeof(float)*4); |
| 1347 | memcpy(vb+12, attrib->f, sizeof(float)*4); |
| 1348 | memcpy(vb+20, attrib->f, sizeof(float)*4); |
| 1349 | } |
| 1350 | |
| 1351 | /* draw */ |
| 1352 | util_draw_vertex_buffer(&rctx->context, NULL, buf, offset, |
| 1353 | R600_PRIM_RECTANGLE_LIST, 3, 2); |
| 1354 | pipe_resource_reference(&buf, NULL); |
| 1355 | } |
| 1356 | |
Dave Airlie | 62b0323 | 2012-04-23 10:20:10 +0100 | [diff] [blame] | 1357 | void _r600_pipe_state_add_reg_bo(struct r600_context *ctx, |
| 1358 | struct r600_pipe_state *state, |
| 1359 | uint32_t offset, uint32_t value, |
| 1360 | uint32_t range_id, uint32_t block_id, |
| 1361 | struct r600_resource *bo, |
| 1362 | enum radeon_bo_usage usage) |
| 1363 | |
Dave Airlie | 42502b6 | 2011-06-02 14:53:15 +1000 | [diff] [blame] | 1364 | { |
Dave Airlie | 4423c79 | 2011-06-02 14:57:13 +1000 | [diff] [blame] | 1365 | struct r600_range *range; |
| 1366 | struct r600_block *block; |
| 1367 | |
Marek Olšák | 47dcfb8 | 2011-08-07 21:14:38 +0200 | [diff] [blame] | 1368 | if (bo) assert(usage); |
| 1369 | |
Dave Airlie | 4423c79 | 2011-06-02 14:57:13 +1000 | [diff] [blame] | 1370 | range = &ctx->range[range_id]; |
| 1371 | block = range->blocks[block_id]; |
Dave Airlie | 51d0892 | 2011-06-03 08:50:58 +1000 | [diff] [blame] | 1372 | state->regs[state->nregs].block = block; |
| 1373 | state->regs[state->nregs].id = (offset - block->start_offset) >> 2; |
Dave Airlie | 4423c79 | 2011-06-02 14:57:13 +1000 | [diff] [blame] | 1374 | |
Dave Airlie | 42502b6 | 2011-06-02 14:53:15 +1000 | [diff] [blame] | 1375 | state->regs[state->nregs].value = value; |
Dave Airlie | 42502b6 | 2011-06-02 14:53:15 +1000 | [diff] [blame] | 1376 | state->regs[state->nregs].bo = bo; |
Marek Olšák | 47dcfb8 | 2011-08-07 21:14:38 +0200 | [diff] [blame] | 1377 | state->regs[state->nregs].bo_usage = usage; |
Dave Airlie | 51d0892 | 2011-06-03 08:50:58 +1000 | [diff] [blame] | 1378 | |
| 1379 | state->nregs++; |
| 1380 | assert(state->nregs < R600_BLOCK_MAX_REG); |
| 1381 | } |
| 1382 | |
Dave Airlie | 62b0323 | 2012-04-23 10:20:10 +0100 | [diff] [blame] | 1383 | void _r600_pipe_state_add_reg(struct r600_context *ctx, |
| 1384 | struct r600_pipe_state *state, |
| 1385 | uint32_t offset, uint32_t value, |
| 1386 | uint32_t range_id, uint32_t block_id) |
| 1387 | { |
| 1388 | _r600_pipe_state_add_reg_bo(ctx, state, offset, value, |
| 1389 | range_id, block_id, NULL, 0); |
| 1390 | } |
| 1391 | |
Marek Olšák | 9a20130 | 2012-02-14 15:12:49 +0100 | [diff] [blame] | 1392 | uint32_t r600_translate_stencil_op(int s_op) |
| 1393 | { |
| 1394 | switch (s_op) { |
| 1395 | case PIPE_STENCIL_OP_KEEP: |
| 1396 | return V_028800_STENCIL_KEEP; |
| 1397 | case PIPE_STENCIL_OP_ZERO: |
| 1398 | return V_028800_STENCIL_ZERO; |
| 1399 | case PIPE_STENCIL_OP_REPLACE: |
| 1400 | return V_028800_STENCIL_REPLACE; |
| 1401 | case PIPE_STENCIL_OP_INCR: |
| 1402 | return V_028800_STENCIL_INCR; |
| 1403 | case PIPE_STENCIL_OP_DECR: |
| 1404 | return V_028800_STENCIL_DECR; |
| 1405 | case PIPE_STENCIL_OP_INCR_WRAP: |
| 1406 | return V_028800_STENCIL_INCR_WRAP; |
| 1407 | case PIPE_STENCIL_OP_DECR_WRAP: |
| 1408 | return V_028800_STENCIL_DECR_WRAP; |
| 1409 | case PIPE_STENCIL_OP_INVERT: |
| 1410 | return V_028800_STENCIL_INVERT; |
| 1411 | default: |
| 1412 | R600_ERR("Unknown stencil op %d", s_op); |
| 1413 | assert(0); |
| 1414 | break; |
| 1415 | } |
| 1416 | return 0; |
| 1417 | } |
| 1418 | |
| 1419 | uint32_t r600_translate_fill(uint32_t func) |
| 1420 | { |
| 1421 | switch(func) { |
| 1422 | case PIPE_POLYGON_MODE_FILL: |
| 1423 | return 2; |
| 1424 | case PIPE_POLYGON_MODE_LINE: |
| 1425 | return 1; |
| 1426 | case PIPE_POLYGON_MODE_POINT: |
| 1427 | return 0; |
| 1428 | default: |
| 1429 | assert(0); |
| 1430 | return 0; |
| 1431 | } |
| 1432 | } |
Marek Olšák | 5cc9aa0 | 2012-02-14 15:19:27 +0100 | [diff] [blame] | 1433 | |
| 1434 | unsigned r600_tex_wrap(unsigned wrap) |
| 1435 | { |
| 1436 | switch (wrap) { |
| 1437 | default: |
| 1438 | case PIPE_TEX_WRAP_REPEAT: |
| 1439 | return V_03C000_SQ_TEX_WRAP; |
| 1440 | case PIPE_TEX_WRAP_CLAMP: |
| 1441 | return V_03C000_SQ_TEX_CLAMP_HALF_BORDER; |
| 1442 | case PIPE_TEX_WRAP_CLAMP_TO_EDGE: |
| 1443 | return V_03C000_SQ_TEX_CLAMP_LAST_TEXEL; |
| 1444 | case PIPE_TEX_WRAP_CLAMP_TO_BORDER: |
| 1445 | return V_03C000_SQ_TEX_CLAMP_BORDER; |
| 1446 | case PIPE_TEX_WRAP_MIRROR_REPEAT: |
| 1447 | return V_03C000_SQ_TEX_MIRROR; |
| 1448 | case PIPE_TEX_WRAP_MIRROR_CLAMP: |
| 1449 | return V_03C000_SQ_TEX_MIRROR_ONCE_HALF_BORDER; |
| 1450 | case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE: |
| 1451 | return V_03C000_SQ_TEX_MIRROR_ONCE_LAST_TEXEL; |
| 1452 | case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER: |
| 1453 | return V_03C000_SQ_TEX_MIRROR_ONCE_BORDER; |
| 1454 | } |
| 1455 | } |
| 1456 | |
| 1457 | unsigned r600_tex_filter(unsigned filter) |
| 1458 | { |
| 1459 | switch (filter) { |
| 1460 | default: |
| 1461 | case PIPE_TEX_FILTER_NEAREST: |
| 1462 | return V_03C000_SQ_TEX_XY_FILTER_POINT; |
| 1463 | case PIPE_TEX_FILTER_LINEAR: |
| 1464 | return V_03C000_SQ_TEX_XY_FILTER_BILINEAR; |
| 1465 | } |
| 1466 | } |
| 1467 | |
| 1468 | unsigned r600_tex_mipfilter(unsigned filter) |
| 1469 | { |
| 1470 | switch (filter) { |
| 1471 | case PIPE_TEX_MIPFILTER_NEAREST: |
| 1472 | return V_03C000_SQ_TEX_Z_FILTER_POINT; |
| 1473 | case PIPE_TEX_MIPFILTER_LINEAR: |
| 1474 | return V_03C000_SQ_TEX_Z_FILTER_LINEAR; |
| 1475 | default: |
| 1476 | case PIPE_TEX_MIPFILTER_NONE: |
| 1477 | return V_03C000_SQ_TEX_Z_FILTER_NONE; |
| 1478 | } |
| 1479 | } |
| 1480 | |
| 1481 | unsigned r600_tex_compare(unsigned compare) |
| 1482 | { |
| 1483 | switch (compare) { |
| 1484 | default: |
| 1485 | case PIPE_FUNC_NEVER: |
| 1486 | return V_03C000_SQ_TEX_DEPTH_COMPARE_NEVER; |
| 1487 | case PIPE_FUNC_LESS: |
| 1488 | return V_03C000_SQ_TEX_DEPTH_COMPARE_LESS; |
| 1489 | case PIPE_FUNC_EQUAL: |
| 1490 | return V_03C000_SQ_TEX_DEPTH_COMPARE_EQUAL; |
| 1491 | case PIPE_FUNC_LEQUAL: |
| 1492 | return V_03C000_SQ_TEX_DEPTH_COMPARE_LESSEQUAL; |
| 1493 | case PIPE_FUNC_GREATER: |
| 1494 | return V_03C000_SQ_TEX_DEPTH_COMPARE_GREATER; |
| 1495 | case PIPE_FUNC_NOTEQUAL: |
| 1496 | return V_03C000_SQ_TEX_DEPTH_COMPARE_NOTEQUAL; |
| 1497 | case PIPE_FUNC_GEQUAL: |
| 1498 | return V_03C000_SQ_TEX_DEPTH_COMPARE_GREATEREQUAL; |
| 1499 | case PIPE_FUNC_ALWAYS: |
| 1500 | return V_03C000_SQ_TEX_DEPTH_COMPARE_ALWAYS; |
| 1501 | } |
| 1502 | } |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1503 | |
| 1504 | /* keep this at the end of this file, please */ |
| 1505 | void r600_init_common_state_functions(struct r600_context *rctx) |
| 1506 | { |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 1507 | rctx->context.create_fs_state = r600_create_ps_state; |
| 1508 | rctx->context.create_vs_state = r600_create_vs_state; |
Marek Olšák | a50edc8 | 2012-10-05 04:02:22 +0200 | [diff] [blame] | 1509 | rctx->context.create_vertex_elements_state = r600_create_vertex_fetch_shader; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1510 | rctx->context.bind_blend_state = r600_bind_blend_state; |
| 1511 | rctx->context.bind_depth_stencil_alpha_state = r600_bind_dsa_state; |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 1512 | rctx->context.bind_fragment_sampler_states = r600_bind_ps_sampler_states; |
| 1513 | rctx->context.bind_fs_state = r600_bind_ps_state; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1514 | rctx->context.bind_rasterizer_state = r600_bind_rs_state; |
| 1515 | rctx->context.bind_vertex_elements_state = r600_bind_vertex_elements; |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 1516 | rctx->context.bind_vertex_sampler_states = r600_bind_vs_sampler_states; |
| 1517 | rctx->context.bind_vs_state = r600_bind_vs_state; |
Marek Olšák | faaba52 | 2012-10-05 02:45:29 +0200 | [diff] [blame] | 1518 | rctx->context.delete_blend_state = r600_delete_blend_state; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1519 | rctx->context.delete_depth_stencil_alpha_state = r600_delete_state; |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 1520 | rctx->context.delete_fs_state = r600_delete_ps_state; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1521 | rctx->context.delete_rasterizer_state = r600_delete_rs_state; |
Marek Olšák | 3bffd8a | 2012-09-10 00:34:37 +0200 | [diff] [blame] | 1522 | rctx->context.delete_sampler_state = r600_delete_sampler_state; |
| 1523 | rctx->context.delete_vertex_elements_state = r600_delete_vertex_elements; |
| 1524 | rctx->context.delete_vs_state = r600_delete_vs_state; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1525 | rctx->context.set_blend_color = r600_set_blend_color; |
Marek Olšák | 2b8d39b | 2012-09-10 20:03:09 +0200 | [diff] [blame] | 1526 | rctx->context.set_clip_state = r600_set_clip_state; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1527 | rctx->context.set_constant_buffer = r600_set_constant_buffer; |
| 1528 | rctx->context.set_sample_mask = r600_set_sample_mask; |
| 1529 | rctx->context.set_stencil_ref = r600_set_pipe_stencil_ref; |
Marek Olšák | 6c86124 | 2012-09-10 01:08:10 +0200 | [diff] [blame] | 1530 | rctx->context.set_viewport_state = r600_set_viewport_state; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1531 | rctx->context.set_vertex_buffers = r600_set_vertex_buffers; |
| 1532 | rctx->context.set_index_buffer = r600_set_index_buffer; |
Marek Olšák | 48de30e | 2012-09-10 01:04:47 +0200 | [diff] [blame] | 1533 | rctx->context.set_fragment_sampler_views = r600_set_ps_sampler_views; |
| 1534 | rctx->context.set_vertex_sampler_views = r600_set_vs_sampler_views; |
Marek Olšák | f96df32 | 2012-09-10 00:28:46 +0200 | [diff] [blame] | 1535 | rctx->context.sampler_view_destroy = r600_sampler_view_destroy; |
| 1536 | rctx->context.texture_barrier = r600_texture_barrier; |
| 1537 | rctx->context.create_stream_output_target = r600_create_so_target; |
| 1538 | rctx->context.stream_output_target_destroy = r600_so_target_destroy; |
| 1539 | rctx->context.set_stream_output_targets = r600_set_so_targets; |
| 1540 | rctx->context.draw_vbo = r600_draw_vbo; |
| 1541 | } |