This->ps_const_size = max_const_ps * sizeof(float[4]);
/* Include space for I,B constants for user constbuf. */
if (This->may_swvp) {
- This->state.vs_const_f_swvp = CALLOC(NINE_MAX_CONST_F_SWVP * sizeof(float[4]),1);
- if (!This->state.vs_const_f_swvp)
+ This->state.vs_const_f = CALLOC(NINE_MAX_CONST_F_SWVP * sizeof(float[4]),1);
+ This->context.vs_const_f_swvp = CALLOC(NINE_MAX_CONST_F_SWVP * sizeof(float[4]),1);
+ if (!This->context.vs_const_f_swvp)
return E_OUTOFMEMORY;
This->state.vs_lconstf_temp = CALLOC(NINE_MAX_CONST_F_SWVP * sizeof(float[4]),1);
+ This->context.vs_lconstf_temp = CALLOC(NINE_MAX_CONST_F_SWVP * sizeof(float[4]),1);
This->state.vs_const_i = CALLOC(NINE_MAX_CONST_I_SWVP * sizeof(int[4]), 1);
+ This->context.vs_const_i = CALLOC(NINE_MAX_CONST_I_SWVP * sizeof(int[4]), 1);
This->state.vs_const_b = CALLOC(NINE_MAX_CONST_B_SWVP * sizeof(BOOL), 1);
+ This->context.vs_const_b = CALLOC(NINE_MAX_CONST_B_SWVP * sizeof(BOOL), 1);
} else {
- This->state.vs_const_f_swvp = NULL;
+ This->state.vs_const_f = CALLOC(NINE_MAX_CONST_F * sizeof(float[4]), 1);
+ This->context.vs_const_f_swvp = NULL;
This->state.vs_lconstf_temp = CALLOC(This->vs_const_size,1);
+ This->context.vs_lconstf_temp = CALLOC(This->vs_const_size,1);
This->state.vs_const_i = CALLOC(NINE_MAX_CONST_I * sizeof(int[4]), 1);
+ This->context.vs_const_i = CALLOC(NINE_MAX_CONST_I * sizeof(int[4]), 1);
This->state.vs_const_b = CALLOC(NINE_MAX_CONST_B * sizeof(BOOL), 1);
+ This->context.vs_const_b = CALLOC(NINE_MAX_CONST_B * sizeof(BOOL), 1);
}
- This->state.vs_const_f = CALLOC(This->vs_const_size, 1);
+ This->context.vs_const_f = CALLOC(This->vs_const_size, 1);
This->state.ps_const_f = CALLOC(This->ps_const_size, 1);
- This->state.ps_lconstf_temp = CALLOC(This->ps_const_size,1);
- if (!This->state.vs_const_f || !This->state.ps_const_f ||
- !This->state.vs_lconstf_temp || !This->state.ps_lconstf_temp ||
- !This->state.vs_const_i || !This->state.vs_const_b)
+ This->context.ps_const_f = CALLOC(This->ps_const_size, 1);
+ This->context.ps_lconstf_temp = CALLOC(This->ps_const_size,1);
+ if (!This->state.vs_const_f || !This->context.vs_const_f ||
+ !This->state.ps_const_f || !This->context.ps_const_f ||
+ !This->state.vs_lconstf_temp || !This->context.vs_lconstf_temp ||
+ !This->context.ps_lconstf_temp ||
+ !This->state.vs_const_i || !This->context.vs_const_i ||
+ !This->state.vs_const_b || !This->context.vs_const_b)
return E_OUTOFMEMORY;
if (strstr(pScreen->get_name(pScreen), "AMD") ||
pipe_resource_reference(&This->dummy_texture, NULL);
pipe_resource_reference(&This->dummy_vbo, NULL);
FREE(This->state.vs_const_f);
+ FREE(This->context.vs_const_f);
FREE(This->state.ps_const_f);
+ FREE(This->context.ps_const_f);
FREE(This->state.vs_lconstf_temp);
- FREE(This->state.ps_lconstf_temp);
+ FREE(This->context.vs_lconstf_temp);
+ FREE(This->context.ps_lconstf_temp);
FREE(This->state.vs_const_i);
+ FREE(This->context.vs_const_i);
FREE(This->state.vs_const_b);
- FREE(This->state.vs_const_f_swvp);
+ FREE(This->context.vs_const_b);
+ FREE(This->context.vs_const_f_swvp);
pipe_resource_reference(&This->cursor.image, NULL);
FREE(This->cursor.hw_upload_temp);
UINT Vector4fCount )
{
struct nine_state *state = This->update;
- float *vs_const_f = This->may_swvp ? state->vs_const_f_swvp : state->vs_const_f;
+ float *vs_const_f = state->vs_const_f;
DBG("This=%p StartRegister=%u pConstantData=%p Vector4fCount=%u\n",
This, StartRegister, pConstantData, Vector4fCount);
return D3D_OK;
user_assert(pConstantData, D3DERR_INVALIDCALL);
- if (!This->is_recording) {
- if (!memcmp(&vs_const_f[StartRegister * 4], pConstantData,
- Vector4fCount * 4 * sizeof(state->vs_const_f[0])))
- return D3D_OK;
+ if (unlikely(This->is_recording)) {
+ memcpy(&vs_const_f[StartRegister * 4],
+ pConstantData,
+ Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
+
+ nine_ranges_insert(&state->changed.vs_const_f,
+ StartRegister, StartRegister + Vector4fCount,
+ &This->range_pool);
+
+ state->changed.group |= NINE_STATE_VS_CONST;
+
+ return D3D_OK;
}
+ if (!memcmp(&vs_const_f[StartRegister * 4], pConstantData,
+ Vector4fCount * 4 * sizeof(state->vs_const_f[0])))
+ return D3D_OK;
+
memcpy(&vs_const_f[StartRegister * 4],
pConstantData,
Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
- nine_ranges_insert(&state->changed.vs_const_f,
- StartRegister, StartRegister + Vector4fCount,
- &This->range_pool);
-
- if (This->may_swvp) {
- Vector4fCount = MIN2(StartRegister + Vector4fCount, NINE_MAX_CONST_F) - StartRegister;
- if (StartRegister < NINE_MAX_CONST_F)
- memcpy(&state->vs_const_f[StartRegister * 4],
- pConstantData,
- Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
- }
-
- state->changed.group |= NINE_STATE_VS_CONST;
+ nine_context_set_vertex_shader_constant_f(This, StartRegister, pConstantData, Vector4fCount);
return D3D_OK;
}
UINT Vector4fCount )
{
const struct nine_state *state = &This->state;
- float *vs_const_f = This->may_swvp ? state->vs_const_f_swvp : state->vs_const_f;
user_assert(StartRegister < This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
user_assert(StartRegister + Vector4fCount <= This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
user_assert(pConstantData, D3DERR_INVALIDCALL);
memcpy(pConstantData,
- &vs_const_f[StartRegister * 4],
+ &state->vs_const_f[StartRegister * 4],
Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
return D3D_OK;
}
}
- nine_ranges_insert(&state->changed.vs_const_i,
- StartRegister, StartRegister + Vector4iCount,
- &This->range_pool);
- state->changed.group |= NINE_STATE_VS_CONST;
+ if (unlikely(This->is_recording)) {
+ nine_ranges_insert(&state->changed.vs_const_i,
+ StartRegister, StartRegister + Vector4iCount,
+ &This->range_pool);
+ state->changed.group |= NINE_STATE_VS_CONST;
+ } else
+ nine_context_set_vertex_shader_constant_i(This, StartRegister, pConstantData, Vector4iCount);
return D3D_OK;
}
for (i = 0; i < BoolCount; i++)
state->vs_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
- nine_ranges_insert(&state->changed.vs_const_b,
- StartRegister, StartRegister + BoolCount,
- &This->range_pool);
- state->changed.group |= NINE_STATE_VS_CONST;
+ if (unlikely(This->is_recording)) {
+ nine_ranges_insert(&state->changed.vs_const_b,
+ StartRegister, StartRegister + BoolCount,
+ &This->range_pool);
+ state->changed.group |= NINE_STATE_VS_CONST;
+ } else
+ nine_context_set_vertex_shader_constant_b(This, StartRegister, pConstantData, BoolCount);
return D3D_OK;
}
return D3D_OK;
user_assert(pConstantData, D3DERR_INVALIDCALL);
- if (!This->is_recording) {
- if (!memcmp(&state->ps_const_f[StartRegister * 4], pConstantData,
- Vector4fCount * 4 * sizeof(state->ps_const_f[0])))
- return D3D_OK;
+ if (unlikely(This->is_recording)) {
+ memcpy(&state->ps_const_f[StartRegister * 4],
+ pConstantData,
+ Vector4fCount * 4 * sizeof(state->ps_const_f[0]));
+
+ nine_ranges_insert(&state->changed.ps_const_f,
+ StartRegister, StartRegister + Vector4fCount,
+ &This->range_pool);
+
+ state->changed.group |= NINE_STATE_PS_CONST;
+ return D3D_OK;
}
+ if (!memcmp(&state->ps_const_f[StartRegister * 4], pConstantData,
+ Vector4fCount * 4 * sizeof(state->ps_const_f[0])))
+ return D3D_OK;
+
memcpy(&state->ps_const_f[StartRegister * 4],
pConstantData,
Vector4fCount * 4 * sizeof(state->ps_const_f[0]));
- nine_ranges_insert(&state->changed.ps_const_f,
- StartRegister, StartRegister + Vector4fCount,
- &This->range_pool);
-
- state->changed.group |= NINE_STATE_PS_CONST;
+ nine_context_set_pixel_shader_constant_f(This, StartRegister, pConstantData, Vector4fCount);
return D3D_OK;
}
state->ps_const_i[StartRegister+i][3] = fui((float)(pConstantData[4*i+3]));
}
}
- state->changed.ps_const_i |= ((1 << Vector4iCount) - 1) << StartRegister;
- state->changed.group |= NINE_STATE_PS_CONST;
+
+ if (unlikely(This->is_recording)) {
+ state->changed.ps_const_i |= ((1 << Vector4iCount) - 1) << StartRegister;
+ state->changed.group |= NINE_STATE_PS_CONST;
+ } else
+ nine_context_set_pixel_shader_constant_i(This, StartRegister, pConstantData, Vector4iCount);
return D3D_OK;
}
for (i = 0; i < BoolCount; i++)
state->ps_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
- state->changed.ps_const_b |= ((1 << BoolCount) - 1) << StartRegister;
- state->changed.group |= NINE_STATE_PS_CONST;
+ if (unlikely(This->is_recording)) {
+ state->changed.ps_const_b |= ((1 << BoolCount) - 1) << StartRegister;
+ state->changed.group |= NINE_STATE_PS_CONST;
+ } else
+ nine_context_set_pixel_shader_constant_b(This, StartRegister, pConstantData, BoolCount);
return D3D_OK;
}
struct nine_state *state = &device->state;
struct nine_context *context = &device->context;
- if (state->changed.vs_const_f || state->changed.group & NINE_STATE_SWVP) {
+ if (context->changed.vs_const_f || state->changed.group & NINE_STATE_SWVP) {
struct pipe_constant_buffer cb;
cb.buffer_offset = 0;
cb.buffer_size = 4096 * sizeof(float[4]);
- cb.user_buffer = state->vs_const_f_swvp;
+ cb.user_buffer = context->vs_const_f_swvp;
if (context->vs->lconstf.ranges) {
const struct nine_lconstf *lconstf = &(context->vs->lconstf);
const struct nine_range *r = lconstf->ranges;
unsigned n = 0;
- float *dst = device->state.vs_lconstf_temp;
+ float *dst = context->vs_lconstf_temp;
float *src = (float *)cb.user_buffer;
memcpy(dst, src, cb.buffer_size);
while (r) {
context->pipe.cb1_swvp.buffer_offset = cb.buffer_offset;
context->pipe.cb1_swvp.buffer_size = cb.buffer_size;
context->pipe.cb1_swvp.user_buffer = cb.user_buffer;
+
+ context->changed.vs_const_f = 0;
}
- if (state->changed.vs_const_i || state->changed.group & NINE_STATE_SWVP) {
+ if (context->changed.vs_const_i || state->changed.group & NINE_STATE_SWVP) {
struct pipe_constant_buffer cb;
cb.buffer_offset = 0;
cb.buffer_size = 2048 * sizeof(float[4]);
- cb.user_buffer = state->vs_const_i;
+ cb.user_buffer = context->vs_const_i;
context->pipe.cb2_swvp.buffer_offset = cb.buffer_offset;
context->pipe.cb2_swvp.buffer_size = cb.buffer_size;
context->pipe.cb2_swvp.user_buffer = cb.user_buffer;
+ context->changed.vs_const_i = 0;
}
- if (state->changed.vs_const_b || state->changed.group & NINE_STATE_SWVP) {
+ if (context->changed.vs_const_b || state->changed.group & NINE_STATE_SWVP) {
struct pipe_constant_buffer cb;
cb.buffer_offset = 0;
cb.buffer_size = 512 * sizeof(float[4]);
- cb.user_buffer = state->vs_const_b;
+ cb.user_buffer = context->vs_const_b;
context->pipe.cb3_swvp.buffer_offset = cb.buffer_offset;
context->pipe.cb3_swvp.buffer_size = cb.buffer_size;
context->pipe.cb3_swvp.user_buffer = cb.user_buffer;
+ context->changed.vs_const_b = 0;
}
if (!device->driver_caps.user_cbufs) {
cb->user_buffer = NULL;
}
- if (device->state.changed.vs_const_f) {
- struct nine_range *r = device->state.changed.vs_const_f;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.vs_const_f = NULL;
- }
-
- if (device->state.changed.vs_const_i) {
- struct nine_range *r = device->state.changed.vs_const_i;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.vs_const_i = NULL;
- }
-
- if (device->state.changed.vs_const_b) {
- struct nine_range *r = device->state.changed.vs_const_b;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.vs_const_b = NULL;
- }
-
state->changed.group &= ~NINE_STATE_VS_CONST;
context->commit |= NINE_STATE_COMMIT_CONST_VS;
}
cb.buffer = NULL;
cb.buffer_offset = 0;
cb.buffer_size = context->vs->const_used_size;
- cb.user_buffer = device->state.vs_const_f;
+ cb.user_buffer = context->vs_const_f;
if (device->swvp) {
prepare_vs_constants_userbuf_swvp(device);
return;
}
- if (state->changed.vs_const_i || state->changed.group & NINE_STATE_SWVP) {
- int *idst = (int *)&state->vs_const_f[4 * device->max_vs_const_f];
- memcpy(idst, state->vs_const_i, NINE_MAX_CONST_I * sizeof(int[4]));
+ if (context->changed.vs_const_i || state->changed.group & NINE_STATE_SWVP) {
+ int *idst = (int *)&context->vs_const_f[4 * device->max_vs_const_f];
+ memcpy(idst, context->vs_const_i, NINE_MAX_CONST_I * sizeof(int[4]));
+ context->changed.vs_const_i = 0;
}
- if (state->changed.vs_const_b || state->changed.group & NINE_STATE_SWVP) {
- int *idst = (int *)&state->vs_const_f[4 * device->max_vs_const_f];
+ if (context->changed.vs_const_b || state->changed.group & NINE_STATE_SWVP) {
+ int *idst = (int *)&context->vs_const_f[4 * device->max_vs_const_f];
uint32_t *bdst = (uint32_t *)&idst[4 * NINE_MAX_CONST_I];
- memcpy(bdst, state->vs_const_b, NINE_MAX_CONST_B * sizeof(BOOL));
- }
-
- if (device->state.changed.vs_const_i) {
- struct nine_range *r = device->state.changed.vs_const_i;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.vs_const_i = NULL;
- }
-
- if (device->state.changed.vs_const_b) {
- struct nine_range *r = device->state.changed.vs_const_b;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.vs_const_b = NULL;
+ memcpy(bdst, context->vs_const_b, NINE_MAX_CONST_B * sizeof(BOOL));
+ context->changed.vs_const_b = 0;
}
if (!cb.buffer_size)
const struct nine_lconstf *lconstf = &(context->vs->lconstf);
const struct nine_range *r = lconstf->ranges;
unsigned n = 0;
- float *dst = device->state.vs_lconstf_temp;
+ float *dst = context->vs_lconstf_temp;
float *src = (float *)cb.user_buffer;
memcpy(dst, src, cb.buffer_size);
while (r) {
} else
context->pipe.cb_vs = cb;
- if (device->state.changed.vs_const_f) {
- struct nine_range *r = device->state.changed.vs_const_f;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.vs_const_f = NULL;
- }
+ context->changed.vs_const_f = 0;
state->changed.group &= ~NINE_STATE_VS_CONST;
context->commit |= NINE_STATE_COMMIT_CONST_VS;
cb.buffer = NULL;
cb.buffer_offset = 0;
cb.buffer_size = device->state.ps->const_used_size;
- cb.user_buffer = device->state.ps_const_f;
+ cb.user_buffer = context->ps_const_f;
- if (state->changed.ps_const_i) {
- int *idst = (int *)&state->ps_const_f[4 * device->max_ps_const_f];
- memcpy(idst, state->ps_const_i, sizeof(state->ps_const_i));
- state->changed.ps_const_i = 0;
+ if (context->changed.ps_const_i) {
+ int *idst = (int *)&context->ps_const_f[4 * device->max_ps_const_f];
+ memcpy(idst, context->ps_const_i, sizeof(context->ps_const_i));
+ context->changed.ps_const_i = 0;
}
- if (state->changed.ps_const_b) {
- int *idst = (int *)&state->ps_const_f[4 * device->max_ps_const_f];
+ if (context->changed.ps_const_b) {
+ int *idst = (int *)&context->ps_const_f[4 * device->max_ps_const_f];
uint32_t *bdst = (uint32_t *)&idst[4 * NINE_MAX_CONST_I];
- memcpy(bdst, state->ps_const_b, sizeof(state->ps_const_b));
- state->changed.ps_const_b = 0;
+ memcpy(bdst, context->ps_const_b, sizeof(context->ps_const_b));
+ context->changed.ps_const_b = 0;
}
/* Upload special constants needed to implement PS1.x instructions like TEXBEM,TEXBEML and BEM */
if (device->state.ps->bumpenvmat_needed) {
- memcpy(device->state.ps_lconstf_temp, cb.user_buffer, cb.buffer_size);
- memcpy(&device->state.ps_lconstf_temp[4 * 8], &device->context.bumpmap_vars, sizeof(device->context.bumpmap_vars));
+ memcpy(context->ps_lconstf_temp, cb.user_buffer, cb.buffer_size);
+ memcpy(&context->ps_lconstf_temp[4 * 8], &device->context.bumpmap_vars, sizeof(device->context.bumpmap_vars));
- cb.user_buffer = device->state.ps_lconstf_temp;
+ cb.user_buffer = context->ps_lconstf_temp;
}
if (state->ps->byte_code.version < 0x30 &&
context->rs[D3DRS_FOGENABLE]) {
- float *dst = &state->ps_lconstf_temp[4 * 32];
- if (cb.user_buffer != state->ps_lconstf_temp) {
- memcpy(state->ps_lconstf_temp, cb.user_buffer, cb.buffer_size);
- cb.user_buffer = state->ps_lconstf_temp;
+ float *dst = &context->ps_lconstf_temp[4 * 32];
+ if (cb.user_buffer != context->ps_lconstf_temp) {
+ memcpy(context->ps_lconstf_temp, cb.user_buffer, cb.buffer_size);
+ cb.user_buffer = context->ps_lconstf_temp;
}
d3dcolor_to_rgba(dst, context->rs[D3DRS_FOGCOLOR]);
} else
context->pipe.cb_ps = cb;
- if (device->state.changed.ps_const_f) {
- struct nine_range *r = device->state.changed.ps_const_f;
- struct nine_range *p = r;
- while (p->next)
- p = p->next;
- nine_range_pool_put_chain(&device->range_pool, r, p);
- device->state.changed.ps_const_f = NULL;
- }
+ context->changed.ps_const_f = 0;
+
state->changed.group &= ~NINE_STATE_PS_CONST;
context->commit |= NINE_STATE_COMMIT_CONST_PS;
}
state->changed.group |= NINE_STATE_VS;
}
+void
+nine_context_set_vertex_shader_constant_f(struct NineDevice9 *device,
+ UINT StartRegister,
+ const float *pConstantData,
+ UINT Vector4fCount)
+{
+ struct nine_state *state = &device->state;
+ struct nine_context *context = &device->context;
+ float *vs_const_f = device->may_swvp ? context->vs_const_f_swvp : context->vs_const_f;
+
+ memcpy(&vs_const_f[StartRegister * 4],
+ pConstantData,
+ Vector4fCount * 4 * sizeof(context->vs_const_f[0]));
+
+ if (device->may_swvp) {
+ Vector4fCount = MIN2(StartRegister + Vector4fCount, NINE_MAX_CONST_F) - StartRegister;
+ if (StartRegister < NINE_MAX_CONST_F)
+ memcpy(&context->vs_const_f[StartRegister * 4],
+ pConstantData,
+ Vector4fCount * 4 * sizeof(context->vs_const_f[0]));
+ }
+
+ context->changed.vs_const_f = TRUE;
+ state->changed.group |= NINE_STATE_VS_CONST;
+}
+
+
+void
+nine_context_set_vertex_shader_constant_i(struct NineDevice9 *device,
+ UINT StartRegister,
+ const int *pConstantData,
+ UINT Vector4iCount)
+{
+ struct nine_state *state = &device->state;
+ struct nine_context *context = &device->context;
+ int i;
+
+ if (device->driver_caps.vs_integer) {
+ memcpy(&context->vs_const_i[4 * StartRegister],
+ pConstantData,
+ Vector4iCount * sizeof(int[4]));
+ } else {
+ for (i = 0; i < Vector4iCount; i++) {
+ context->vs_const_i[4 * (StartRegister + i)] = fui((float)(pConstantData[4 * i]));
+ context->vs_const_i[4 * (StartRegister + i) + 1] = fui((float)(pConstantData[4 * i + 1]));
+ context->vs_const_i[4 * (StartRegister + i) + 2] = fui((float)(pConstantData[4 * i + 2]));
+ context->vs_const_i[4 * (StartRegister + i) + 3] = fui((float)(pConstantData[4 * i + 3]));
+ }
+ }
+
+ context->changed.vs_const_i = TRUE;
+ state->changed.group |= NINE_STATE_VS_CONST;
+}
+
+void
+nine_context_set_vertex_shader_constant_b(struct NineDevice9 *device,
+ UINT StartRegister,
+ const BOOL *pConstantData,
+ UINT BoolCount)
+{
+ struct nine_state *state = &device->state;
+ struct nine_context *context = &device->context;
+ int i;
+ uint32_t bool_true = device->driver_caps.vs_integer ? 0xFFFFFFFF : fui(1.0f);
+
+ for (i = 0; i < BoolCount; i++)
+ context->vs_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
+
+ context->changed.vs_const_b = TRUE;
+ state->changed.group |= NINE_STATE_VS_CONST;
+}
+
+void
+nine_context_set_pixel_shader_constant_f(struct NineDevice9 *device,
+ UINT StartRegister,
+ const float *pConstantData,
+ UINT Vector4fCount)
+{
+ struct nine_state *state = &device->state;
+ struct nine_context *context = &device->context;
+
+ memcpy(&context->ps_const_f[StartRegister * 4],
+ pConstantData,
+ Vector4fCount * 4 * sizeof(context->ps_const_f[0]));
+
+ context->changed.ps_const_f = TRUE;
+ state->changed.group |= NINE_STATE_PS_CONST;
+}
+
+void
+nine_context_set_pixel_shader_constant_i(struct NineDevice9 *device,
+ UINT StartRegister,
+ const int *pConstantData,
+ UINT Vector4iCount)
+{
+ struct nine_state *state = &device->state;
+ struct nine_context *context = &device->context;
+ int i;
+
+ if (device->driver_caps.ps_integer) {
+ memcpy(&context->ps_const_i[StartRegister][0],
+ pConstantData,
+ Vector4iCount * sizeof(context->ps_const_i[0]));
+ } else {
+ for (i = 0; i < Vector4iCount; i++) {
+ context->ps_const_i[StartRegister+i][0] = fui((float)(pConstantData[4*i]));
+ context->ps_const_i[StartRegister+i][1] = fui((float)(pConstantData[4*i+1]));
+ context->ps_const_i[StartRegister+i][2] = fui((float)(pConstantData[4*i+2]));
+ context->ps_const_i[StartRegister+i][3] = fui((float)(pConstantData[4*i+3]));
+ }
+ }
+ context->changed.ps_const_i = TRUE;
+ state->changed.group |= NINE_STATE_PS_CONST;
+}
+
+void
+nine_context_set_pixel_shader_constant_b(struct NineDevice9 *device,
+ UINT StartRegister,
+ const BOOL *pConstantData,
+ UINT BoolCount)
+{
+ struct nine_state *state = &device->state;
+ struct nine_context *context = &device->context;
+ int i;
+ uint32_t bool_true = device->driver_caps.ps_integer ? 0xFFFFFFFF : fui(1.0f);
+
+ for (i = 0; i < BoolCount; i++)
+ context->ps_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
+
+ context->changed.ps_const_b = TRUE;
+ state->changed.group |= NINE_STATE_PS_CONST;
+}
+
void
nine_context_apply_stateblock(struct NineDevice9 *device,
const struct nine_state *src)
nine_bind(&context->vs, src->vs);
context->programmable_vs = context->vs && !(context->vdecl && context->vdecl->position_t);
+
+ /* Vertex constants */
+ if (src->changed.group & NINE_STATE_VS_CONST) {
+ struct nine_range *r;
+ if (device->may_swvp) {
+ for (r = src->changed.vs_const_f; r; r = r->next) {
+ int bgn = r->bgn;
+ int end = r->end;
+ memcpy(&context->vs_const_f_swvp[bgn * 4],
+ &src->vs_const_f[bgn * 4],
+ (end - bgn) * 4 * sizeof(float));
+ if (bgn < device->max_vs_const_f) {
+ end = MIN2(end, device->max_vs_const_f);
+ memcpy(&context->vs_const_f[bgn * 4],
+ &src->vs_const_f[bgn * 4],
+ (end - bgn) * 4 * sizeof(float));
+ }
+ }
+ } else {
+ for (r = src->changed.vs_const_f; r; r = r->next) {
+ memcpy(&context->vs_const_f[r->bgn * 4],
+ &src->vs_const_f[r->bgn * 4],
+ (r->end - r->bgn) * 4 * sizeof(float));
+ }
+ }
+ for (r = src->changed.vs_const_i; r; r = r->next) {
+ memcpy(&context->vs_const_i[r->bgn * 4],
+ &src->vs_const_i[r->bgn * 4],
+ (r->end - r->bgn) * 4 * sizeof(int));
+ }
+ for (r = src->changed.vs_const_b; r; r = r->next) {
+ memcpy(&context->vs_const_b[r->bgn],
+ &src->vs_const_b[r->bgn],
+ (r->end - r->bgn) * sizeof(int));
+ }
+ context->changed.vs_const_f = !!src->changed.vs_const_f;
+ context->changed.vs_const_i = !!src->changed.vs_const_i;
+ context->changed.vs_const_b = !!src->changed.vs_const_b;
+ }
+
+ /* Pixel constants */
+ if (src->changed.group & NINE_STATE_PS_CONST) {
+ struct nine_range *r;
+ for (r = src->changed.ps_const_f; r; r = r->next) {
+ memcpy(&context->ps_const_f[r->bgn * 4],
+ &src->ps_const_f[r->bgn * 4],
+ (r->end - r->bgn) * 4 * sizeof(float));
+ }
+ if (src->changed.ps_const_i) {
+ uint16_t m = src->changed.ps_const_i;
+ for (i = ffs(m) - 1, m >>= i; m; ++i, m >>= 1)
+ if (m & 1)
+ memcpy(context->ps_const_i[i], src->ps_const_i[i], 4 * sizeof(int));
+ }
+ if (src->changed.ps_const_b) {
+ uint16_t m = src->changed.ps_const_b;
+ for (i = ffs(m) - 1, m >>= i; m; ++i, m >>= 1)
+ if (m & 1)
+ context->ps_const_b[i] = src->ps_const_b[i];
+ }
+ context->changed.ps_const_f = !!src->changed.ps_const_f;
+ context->changed.ps_const_i = !!src->changed.ps_const_i;
+ context->changed.ps_const_b = !!src->changed.ps_const_b;
+ }
}
static void
sizeof(state->samp_advertised[s]));
}
- if (state->vs_const_f)
- memset(state->vs_const_f, 0, device->vs_const_size);
- if (state->ps_const_f)
- memset(state->ps_const_f, 0, device->ps_const_size);
+ memset(state->vs_const_f, 0, VS_CONST_F_SIZE(device));
+ memset(context->vs_const_f, 0, device->vs_const_size);
+ if (context->vs_const_f_swvp)
+ memset(context->vs_const_f_swvp, 0, NINE_MAX_CONST_F_SWVP * sizeof(float[4]));
+ memset(state->vs_const_i, 0, VS_CONST_I_SIZE(device));
+ memset(context->vs_const_i, 0, VS_CONST_I_SIZE(device));
+ memset(state->vs_const_b, 0, VS_CONST_B_SIZE(device));
+ memset(context->vs_const_b, 0, VS_CONST_B_SIZE(device));
+ memset(state->ps_const_f, 0, device->ps_const_size);
+ memset(context->ps_const_f, 0, device->ps_const_size);
+ memset(state->ps_const_i, 0, sizeof(state->ps_const_i));
+ memset(context->ps_const_i, 0, sizeof(context->ps_const_i));
+ memset(state->ps_const_b, 0, sizeof(state->ps_const_b));
+ memset(context->ps_const_b, 0, sizeof(context->ps_const_b));
/* Cap dependent initial state:
*/
cb.buffer = NULL;
cb.buffer_offset = 0;
cb.buffer_size = 4096 * sizeof(float[4]);
- cb.user_buffer = state->vs_const_f_swvp;
+ cb.user_buffer = state->vs_const_f;
if (state->vs->lconstf.ranges) {
const struct nine_lconstf *lconstf = &device->state.vs->lconstf;
((nconstf) * 4 * sizeof(float) + \
NINE_MAX_CONST_I * 4 * sizeof(int))
+#define VS_CONST_F_SIZE(device) (device->may_swvp ? (NINE_MAX_CONST_F_SWVP * sizeof(float[4])) : (NINE_MAX_CONST_F * sizeof(float[4])))
+#define VS_CONST_I_SIZE(device) (device->may_swvp ? (NINE_MAX_CONST_I_SWVP * sizeof(int[4])) : (NINE_MAX_CONST_I * sizeof(int[4])))
+#define VS_CONST_B_SIZE(device) (device->may_swvp ? (NINE_MAX_CONST_B_SWVP * sizeof(BOOL)) : (NINE_MAX_CONST_B * sizeof(BOOL)))
+
#define NINE_MAX_TEXTURE_STAGES 8
uint32_t stream_freq; /* stateblocks only */
uint32_t texture; /* stateblocks only */
uint16_t sampler[NINE_MAX_SAMPLERS]; /* stateblocks only */
- struct nine_range *vs_const_f;
- struct nine_range *ps_const_f;
- struct nine_range *vs_const_i;
+ struct nine_range *vs_const_f; /* stateblocks only */
+ struct nine_range *ps_const_f; /* stateblocks only */
+ struct nine_range *vs_const_i; /* stateblocks only */
uint16_t ps_const_i; /* NINE_MAX_CONST_I == 16 */
- struct nine_range *vs_const_b;
+ struct nine_range *vs_const_b; /* stateblocks only */
uint16_t ps_const_b; /* NINE_MAX_CONST_B == 16 */
uint8_t ucp;
} changed;
*/
struct NineVertexShader9 *vs;
float *vs_const_f;
- float *vs_const_f_swvp;
int *vs_const_i;
BOOL *vs_const_b;
- float *vs_lconstf_temp;
+ float *vs_lconstf_temp; /* ProcessVertices */
struct NinePixelShader9 *ps;
float *ps_const_f;
int ps_const_i[NINE_MAX_CONST_I][4];
BOOL ps_const_b[NINE_MAX_CONST_B];
- float *ps_lconstf_temp;
struct NineVertexDeclaration9 *vdecl;
struct {
uint16_t sampler[NINE_MAX_SAMPLERS];
uint32_t vtxbuf;
+ BOOL vs_const_f;
+ BOOL vs_const_i;
+ BOOL vs_const_b;
+ BOOL ps_const_f;
+ BOOL ps_const_i;
+ BOOL ps_const_b;
} changed;
uint32_t bumpmap_vars[6 * NINE_MAX_TEXTURE_STAGES];
struct NineVertexShader9 *vs;
BOOL programmable_vs;
+ float *vs_const_f;
+ float *vs_const_f_swvp;
+ int *vs_const_i;
+ BOOL *vs_const_b;
+ float *vs_lconstf_temp;
+
+ float *ps_const_f;
+ int ps_const_i[NINE_MAX_CONST_I][4];
+ BOOL ps_const_b[NINE_MAX_CONST_B];
+ float *ps_lconstf_temp;
struct NineVertexDeclaration9 *vdecl;
nine_context_set_vertex_shader(struct NineDevice9 *device,
struct NineVertexShader9 *pShader);
+void
+nine_context_set_vertex_shader_constant_f(struct NineDevice9 *device,
+ UINT StartRegister,
+ const float *pConstantData,
+ UINT Vector4fCount);
+
+void
+nine_context_set_vertex_shader_constant_i(struct NineDevice9 *device,
+ UINT StartRegister,
+ const int *pConstantData,
+ UINT Vector4iCount);
+
+void
+nine_context_set_vertex_shader_constant_b(struct NineDevice9 *device,
+ UINT StartRegister,
+ const BOOL *pConstantData,
+ UINT BoolCount);
+
+void
+nine_context_set_pixel_shader_constant_f(struct NineDevice9 *device,
+ UINT StartRegister,
+ const float *pConstantData,
+ UINT Vector4fCount);
+
+void
+nine_context_set_pixel_shader_constant_i(struct NineDevice9 *device,
+ UINT StartRegister,
+ const int *pConstantData,
+ UINT Vector4iCount);
+
+void
+nine_context_set_pixel_shader_constant_b(struct NineDevice9 *device,
+ UINT StartRegister,
+ const BOOL *pConstantData,
+ UINT BoolCount);
+
void
nine_context_apply_stateblock(struct NineDevice9 *device,
const struct nine_state *src);
/* XXX TODO: handling of lights is broken */
-#define VS_CONST_I_SIZE(device) (device->may_swvp ? (NINE_MAX_CONST_I_SWVP * sizeof(int[4])) : (NINE_MAX_CONST_I * sizeof(int[4])))
-#define VS_CONST_B_SIZE(device) (device->may_swvp ? (NINE_MAX_CONST_B_SWVP * sizeof(BOOL)) : (NINE_MAX_CONST_B * sizeof(BOOL)))
-#define VS_CONST_F_SWVP_SIZE (NINE_MAX_CONST_F_SWVP * sizeof(float[4]))
-
HRESULT
NineStateBlock9_ctor( struct NineStateBlock9 *This,
struct NineUnknownParams *pParams,
This->type = type;
- This->state.vs_const_f = MALLOC(This->base.device->vs_const_size);
+ This->state.vs_const_f = MALLOC(VS_CONST_F_SIZE(This->base.device));
This->state.ps_const_f = MALLOC(This->base.device->ps_const_size);
This->state.vs_const_i = MALLOC(VS_CONST_I_SIZE(This->base.device));
This->state.vs_const_b = MALLOC(VS_CONST_B_SIZE(This->base.device));
!This->state.vs_const_i || !This->state.vs_const_b)
return E_OUTOFMEMORY;
- if (This->base.device->may_swvp) {
- This->state.vs_const_f_swvp = MALLOC(VS_CONST_F_SWVP_SIZE);
- if (!This->state.vs_const_f_swvp)
- return E_OUTOFMEMORY;
- } else
- This->state.vs_const_f_swvp = NULL;
-
return D3D_OK;
}
FREE(state->ps_const_f);
FREE(state->vs_const_i);
FREE(state->vs_const_b);
- FREE(state->vs_const_f_swvp);
FREE(state->ff.light);
* Various possibilities for optimization here, like creating a per-SB
* constant buffer, or memcmp'ing for changes.
* Will do that later depending on what works best for specific apps.
+ *
+ * Note: Currently when we apply stateblocks, it's always on the device state.
+ * Should it affect recording stateblocks ? Since it's on device state, there
+ * is no need to copy which ranges are dirty. If it turns out we should affect
+ * recording stateblocks, the info should be copied.
*/
if (mask->changed.group & NINE_STATE_VS_CONST) {
struct nine_range *r;
- if (device->may_swvp) {
- for (r = mask->changed.vs_const_f; r; r = r->next) {
- int bgn = r->bgn;
- int end = r->end;
- memcpy(&dst->vs_const_f_swvp[bgn * 4],
- &src->vs_const_f_swvp[bgn * 4],
- (end - bgn) * 4 * sizeof(float));
- if (apply)
- nine_ranges_insert(&dst->changed.vs_const_f, bgn, end,
- pool);
- if (bgn < device->max_vs_const_f) {
- end = MIN2(end, device->max_vs_const_f);
- memcpy(&dst->vs_const_f[bgn * 4],
- &src->vs_const_f[bgn * 4],
- (end - bgn) * 4 * sizeof(float));
- }
- }
- } else {
- for (r = mask->changed.vs_const_f; r; r = r->next) {
- memcpy(&dst->vs_const_f[r->bgn * 4],
- &src->vs_const_f[r->bgn * 4],
- (r->end - r->bgn) * 4 * sizeof(float));
- if (apply)
- nine_ranges_insert(&dst->changed.vs_const_f, r->bgn, r->end,
- pool);
- }
+ for (r = mask->changed.vs_const_f; r; r = r->next) {
+ memcpy(&dst->vs_const_f[r->bgn * 4],
+ &src->vs_const_f[r->bgn * 4],
+ (r->end - r->bgn) * 4 * sizeof(float));
}
for (r = mask->changed.vs_const_i; r; r = r->next) {
memcpy(&dst->vs_const_i[r->bgn * 4],
&src->vs_const_i[r->bgn * 4],
(r->end - r->bgn) * 4 * sizeof(int));
- if (apply)
- nine_ranges_insert(&dst->changed.vs_const_i, r->bgn, r->end,
- pool);
}
for (r = mask->changed.vs_const_b; r; r = r->next) {
memcpy(&dst->vs_const_b[r->bgn],
&src->vs_const_b[r->bgn],
(r->end - r->bgn) * sizeof(int));
- if (apply)
- nine_ranges_insert(&dst->changed.vs_const_b, r->bgn, r->end,
- pool);
}
}
memcpy(&dst->ps_const_f[r->bgn * 4],
&src->ps_const_f[r->bgn * 4],
(r->end - r->bgn) * 4 * sizeof(float));
- if (apply)
- nine_ranges_insert(&dst->changed.ps_const_f, r->bgn, r->end,
- pool);
}
if (mask->changed.ps_const_i) {
uint16_t m = mask->changed.ps_const_i;
for (i = ffs(m) - 1, m >>= i; m; ++i, m >>= 1)
if (m & 1)
memcpy(dst->ps_const_i[i], src->ps_const_i[i], 4 * sizeof(int));
- if (apply)
- dst->changed.ps_const_i |= mask->changed.ps_const_i;
}
if (mask->changed.ps_const_b) {
uint16_t m = mask->changed.ps_const_b;
for (i = ffs(m) - 1, m >>= i; m; ++i, m >>= 1)
if (m & 1)
dst->ps_const_b[i] = src->ps_const_b[i];
- if (apply)
- dst->changed.ps_const_b |= mask->changed.ps_const_b;
}
}
* Will do that later depending on what works best for specific apps.
*/
if (1) {
- struct nine_range *r = help->changed.vs_const_f;
memcpy(&dst->vs_const_f[0],
- &src->vs_const_f[0], device->max_vs_const_f * 4 * sizeof(float));
- if (device->may_swvp)
- memcpy(dst->vs_const_f_swvp,
- src->vs_const_f_swvp, VS_CONST_F_SWVP_SIZE);
- if (apply)
- nine_ranges_insert(&dst->changed.vs_const_f, r->bgn, r->end, pool);
+ &src->vs_const_f[0], VS_CONST_F_SIZE(device));
memcpy(dst->vs_const_i, src->vs_const_i, VS_CONST_I_SIZE(device));
memcpy(dst->vs_const_b, src->vs_const_b, VS_CONST_B_SIZE(device));
- if (apply) {
- r = help->changed.vs_const_i;
- nine_ranges_insert(&dst->changed.vs_const_i, r->bgn, r->end, pool);
- r = help->changed.vs_const_b;
- nine_ranges_insert(&dst->changed.vs_const_b, r->bgn, r->end, pool);
- }
}
/* Pixel constants. */
struct nine_range *r = help->changed.ps_const_f;
memcpy(&dst->ps_const_f[0],
&src->ps_const_f[0], (r->end - r->bgn) * 4 * sizeof(float));
- if (apply)
- nine_ranges_insert(&dst->changed.ps_const_f, r->bgn, r->end, pool);
memcpy(dst->ps_const_i, src->ps_const_i, sizeof(dst->ps_const_i));
memcpy(dst->ps_const_b, src->ps_const_b, sizeof(dst->ps_const_b));
- if (apply) {
- dst->changed.ps_const_i |= src->changed.ps_const_i;
- dst->changed.ps_const_b |= src->changed.ps_const_b;
- }
}
/* Render states. */
projects / mesa.git / commitdiff