#include "util/u_math.h"
#include "util/u_box.h"
#include "util/u_simple_shaders.h"
+#include "util/u_gen_mipmap.h"
/* CSMT headers */
#include "nine_queue.h"
{
pipe_mutex_lock(ctx->mutex_processed);
while (!p_atomic_read(&ctx->processed)) {
- pipe_condvar_wait(ctx->event_processed, ctx->mutex_processed);
+ cnd_wait(&ctx->event_processed, &ctx->mutex_processed);
}
pipe_mutex_unlock(ctx->mutex_processed);
}
FREE(ctx);
return NULL;
}
- pipe_condvar_init(ctx->event_processed);
+ cnd_init(&ctx->event_processed);
pipe_mutex_init(ctx->mutex_processed);
pipe_mutex_init(ctx->thread_running);
pipe_mutex_init(ctx->thread_resume);
struct pipe_context *
nine_context_get_pipe( struct NineDevice9 *device )
{
- if (device->csmt_active)
- nine_csmt_process(device);
+ nine_csmt_process(device);
return device->context.pipe;
}
if (!device->driver_caps.user_cbufs) {
struct pipe_constant_buffer *cb = &(context->pipe_data.cb0_swvp);
- u_upload_data(device->constbuf_uploader,
+ u_upload_data(device->context.pipe->const_uploader,
0,
cb->buffer_size,
device->constbuf_alignment,
cb->user_buffer,
&(cb->buffer_offset),
&(cb->buffer));
- u_upload_unmap(device->constbuf_uploader);
+ u_upload_unmap(device->context.pipe->const_uploader);
cb->user_buffer = NULL;
cb = &(context->pipe_data.cb1_swvp);
- u_upload_data(device->constbuf_uploader,
+ u_upload_data(device->context.pipe->const_uploader,
0,
cb->buffer_size,
device->constbuf_alignment,
cb->user_buffer,
&(cb->buffer_offset),
&(cb->buffer));
- u_upload_unmap(device->constbuf_uploader);
+ u_upload_unmap(device->context.pipe->const_uploader);
cb->user_buffer = NULL;
cb = &(context->pipe_data.cb2_swvp);
- u_upload_data(device->constbuf_uploader,
+ u_upload_data(device->context.pipe->const_uploader,
0,
cb->buffer_size,
device->constbuf_alignment,
cb->user_buffer,
&(cb->buffer_offset),
&(cb->buffer));
- u_upload_unmap(device->constbuf_uploader);
+ u_upload_unmap(device->context.pipe->const_uploader);
cb->user_buffer = NULL;
cb = &(context->pipe_data.cb3_swvp);
- u_upload_data(device->constbuf_uploader,
+ u_upload_data(device->context.pipe->const_uploader,
0,
cb->buffer_size,
device->constbuf_alignment,
cb->user_buffer,
&(cb->buffer_offset),
&(cb->buffer));
- u_upload_unmap(device->constbuf_uploader);
+ u_upload_unmap(device->context.pipe->const_uploader);
cb->user_buffer = NULL;
}
if (!device->driver_caps.user_cbufs) {
context->pipe_data.cb_vs.buffer_size = cb.buffer_size;
- u_upload_data(device->constbuf_uploader,
+ u_upload_data(device->context.pipe->const_uploader,
0,
cb.buffer_size,
device->constbuf_alignment,
cb.user_buffer,
&context->pipe_data.cb_vs.buffer_offset,
&context->pipe_data.cb_vs.buffer);
- u_upload_unmap(device->constbuf_uploader);
+ u_upload_unmap(device->context.pipe->const_uploader);
context->pipe_data.cb_vs.user_buffer = NULL;
} else
context->pipe_data.cb_vs = cb;
if (!device->driver_caps.user_cbufs) {
context->pipe_data.cb_ps.buffer_size = cb.buffer_size;
- u_upload_data(device->constbuf_uploader,
+ u_upload_data(device->context.pipe->const_uploader,
0,
cb.buffer_size,
device->constbuf_alignment,
cb.user_buffer,
&context->pipe_data.cb_ps.buffer_offset,
&context->pipe_data.cb_ps.buffer);
- u_upload_unmap(device->constbuf_uploader);
+ u_upload_unmap(device->context.pipe->const_uploader);
context->pipe_data.cb_ps.user_buffer = NULL;
} else
context->pipe_data.cb_ps = cb;
UINT Stride)
{
struct pipe_resource *res = NULL;
+ unsigned offset = 0;
if (pVBuf9)
- res = NineVertexBuffer9_GetResource(pVBuf9);
+ res = NineVertexBuffer9_GetResource(pVBuf9, &offset);
/* in the future when there is internal offset, add it
* to OffsetInBytes */
nine_context_set_stream_source_apply(device, StreamNumber,
- res, OffsetInBytes,
+ res, offset + OffsetInBytes,
Stride);
}
{
struct nine_context *context = &device->context;
- if (device->csmt_active) /* TODO: fix */
- nine_csmt_process(device);
+ /* TODO: Use CSMT_* to avoid calling nine_csmt_process */
+ nine_csmt_process(device);
memcpy(context->ff.active_light, active_light, NINE_MAX_LIGHTS_ACTIVE * sizeof(context->ff.active_light[0]));
context->ff.num_lights_active = num_lights_active;
context->changed.group |= NINE_STATE_FF_LIGHTING;
for (i = 0; m; ++i, m >>= 1) {
if (src->changed.vtxbuf & (1 << i)) {
if (src->stream[i]) {
- context->vtxbuf[i].buffer_offset = src->vtxbuf[i].buffer_offset;
+ unsigned offset = 0;
pipe_resource_reference(&context->vtxbuf[i].buffer,
- src->stream[i] ? NineVertexBuffer9_GetResource(src->stream[i]) : NULL);
+ src->stream[i] ? NineVertexBuffer9_GetResource(src->stream[i], &offset) : NULL);
+ context->vtxbuf[i].buffer_offset = src->vtxbuf[i].buffer_offset + offset;
context->vtxbuf[i].stride = src->vtxbuf[i].stride;
}
}
}
CSMT_ITEM_NO_WAIT(nine_context_resource_copy_region,
+ ARG_BIND_REF(struct NineUnknown, dst),
+ ARG_BIND_REF(struct NineUnknown, src),
ARG_BIND_RES(struct pipe_resource, dst_res),
ARG_VAL(unsigned, dst_level),
ARG_COPY_REF(struct pipe_box, dst_box),
{
struct nine_context *context = &device->context;
+ (void) dst;
+ (void) src;
+
context->pipe->resource_copy_region(context->pipe,
dst_res, dst_level,
dst_box->x, dst_box->y, dst_box->z,
}
CSMT_ITEM_NO_WAIT(nine_context_blit,
+ ARG_BIND_REF(struct NineUnknown, dst),
+ ARG_BIND_REF(struct NineUnknown, src),
ARG_BIND_BLIT(struct pipe_blit_info, blit))
{
struct nine_context *context = &device->context;
+ (void) dst;
+ (void) src;
+
context->pipe->blit(context->pipe, blit);
}
context->pipe->clear_render_target(context->pipe, surf, &rgba, x, y, width, height, false);
}
+CSMT_ITEM_NO_WAIT(nine_context_gen_mipmap,
+ ARG_BIND_REF(struct NineUnknown, dst),
+ ARG_BIND_RES(struct pipe_resource, res),
+ ARG_VAL(UINT, base_level),
+ ARG_VAL(UINT, last_level),
+ ARG_VAL(UINT, first_layer),
+ ARG_VAL(UINT, last_layer),
+ ARG_VAL(UINT, filter))
+{
+ struct nine_context *context = &device->context;
+
+ /* We just bind dst for the bind count */
+ (void)dst;
+
+ util_gen_mipmap(context->pipe, res, res->format, base_level,
+ last_level, first_layer, last_layer, filter);
+}
+
CSMT_ITEM_NO_WAIT_WITH_COUNTER(nine_context_range_upload,
ARG_BIND_RES(struct pipe_resource, res),
ARG_VAL(unsigned, offset),
context->pipe->buffer_subdata(context->pipe, res, 0, offset, size, data);
}
+CSMT_ITEM_NO_WAIT_WITH_COUNTER(nine_context_box_upload,
+ ARG_BIND_REF(struct NineUnknown, dst),
+ ARG_BIND_RES(struct pipe_resource, res),
+ ARG_VAL(unsigned, level),
+ ARG_COPY_REF(struct pipe_box, dst_box),
+ ARG_VAL(enum pipe_format, src_format),
+ ARG_VAL(const void *, src),
+ ARG_VAL(unsigned, src_stride),
+ ARG_VAL(unsigned, src_layer_stride),
+ ARG_COPY_REF(struct pipe_box, src_box))
+{
+ struct nine_context *context = &device->context;
+ struct pipe_context *pipe = context->pipe;
+ struct pipe_transfer *transfer = NULL;
+ uint8_t *map;
+
+ /* We just bind dst for the bind count */
+ (void)dst;
+
+ map = pipe->transfer_map(pipe,
+ res,
+ level,
+ PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
+ dst_box, &transfer);
+ if (!map)
+ return;
+
+ /* Note: if formats are the sames, it will revert
+ * to normal memcpy */
+ (void) util_format_translate_3d(res->format,
+ map, transfer->stride,
+ transfer->layer_stride,
+ 0, 0, 0,
+ src_format,
+ src, src_stride,
+ src_layer_stride,
+ src_box->x, src_box->y, src_box->z,
+ dst_box->width, dst_box->height,
+ dst_box->depth);
+
+ pipe_transfer_unmap(pipe, transfer);
+}
+
struct pipe_query *
nine_context_create_query(struct NineDevice9 *device, unsigned query_type)
{
struct pipe_context *pipe;
boolean ret;
- if (wait) {
- if (device->csmt_active)
- nine_csmt_process(device);
- } else if (p_atomic_read(counter) > 0) {
+ if (wait)
+ nine_csmt_process(device);
+ else if (p_atomic_read(counter) > 0) {
if (flush && device->csmt_active)
nine_queue_flush(device->csmt_ctx->pool);
DBG("Pending begin/end. Returning\n");
[NINED3DSAMP_CUBETEX] = 0
};
+/* Note: The following 4 functions assume there is no
+ * pending commands */
+
void nine_state_restore_non_cso(struct NineDevice9 *device)
{
struct nine_context *context = &device->context;
for (i = 0; mask; mask >>= 1, ++i) {
if (mask & 1) {
if (state->stream[i]) {
+ unsigned offset;
struct pipe_resource *buf;
struct pipe_box box;
vtxbuf = state->vtxbuf[i];
- vtxbuf.buffer = NineVertexBuffer9_GetResource(state->stream[i]);
+ vtxbuf.buffer = NineVertexBuffer9_GetResource(state->stream[i], &offset);
DBG("Locking %p (offset %d, length %d)\n", vtxbuf.buffer,
vtxbuf.buffer_offset, num_vertices * vtxbuf.stride);
- u_box_1d(vtxbuf.buffer_offset + start_vertice * vtxbuf.stride,
+ u_box_1d(vtxbuf.buffer_offset + offset + start_vertice * vtxbuf.stride,
num_vertices * vtxbuf.stride, &box);
buf = vtxbuf.buffer;
vtxbuf.user_buffer = pipe->transfer_map(pipe, buf, 0, PIPE_TRANSFER_READ, &box,
&(sw_internal->transfers_so[i]));
vtxbuf.buffer = NULL;
if (!device->driver_caps.user_sw_vbufs) {
- u_upload_data(device->vertex_sw_uploader,
+ u_upload_data(device->pipe_sw->stream_uploader,
0,
box.width,
16,
vtxbuf.user_buffer,
&(vtxbuf.buffer_offset),
&(vtxbuf.buffer));
- u_upload_unmap(device->vertex_sw_uploader);
+ u_upload_unmap(device->pipe_sw->stream_uploader);
vtxbuf.user_buffer = NULL;
}
pipe_sw->set_vertex_buffers(pipe_sw, i, 1, &vtxbuf);
buf = cb.user_buffer;
if (!device->driver_caps.user_sw_cbufs) {
- u_upload_data(device->constbuf_sw_uploader,
+ u_upload_data(device->pipe_sw->const_uploader,
0,
cb.buffer_size,
16,
cb.user_buffer,
&(cb.buffer_offset),
&(cb.buffer));
- u_upload_unmap(device->constbuf_sw_uploader);
+ u_upload_unmap(device->pipe_sw->const_uploader);
cb.user_buffer = NULL;
}
cb.user_buffer = (char *)buf + 4096 * sizeof(float[4]);
if (!device->driver_caps.user_sw_cbufs) {
- u_upload_data(device->constbuf_sw_uploader,
+ u_upload_data(device->pipe_sw->const_uploader,
0,
cb.buffer_size,
16,
cb.user_buffer,
&(cb.buffer_offset),
&(cb.buffer));
- u_upload_unmap(device->constbuf_sw_uploader);
+ u_upload_unmap(device->pipe_sw->const_uploader);
cb.user_buffer = NULL;
}
cb.user_buffer = state->vs_const_i;
if (!device->driver_caps.user_sw_cbufs) {
- u_upload_data(device->constbuf_sw_uploader,
+ u_upload_data(device->pipe_sw->const_uploader,
0,
cb.buffer_size,
16,
cb.user_buffer,
&(cb.buffer_offset),
&(cb.buffer));
- u_upload_unmap(device->constbuf_sw_uploader);
+ u_upload_unmap(device->pipe_sw->const_uploader);
cb.user_buffer = NULL;
}
cb.user_buffer = state->vs_const_b;
if (!device->driver_caps.user_sw_cbufs) {
- u_upload_data(device->constbuf_sw_uploader,
+ u_upload_data(device->pipe_sw->const_uploader,
0,
cb.buffer_size,
16,
cb.user_buffer,
&(cb.buffer_offset),
&(cb.buffer));
- u_upload_unmap(device->constbuf_sw_uploader);
+ u_upload_unmap(device->pipe_sw->const_uploader);
cb.user_buffer = NULL;
}
cb.user_buffer = viewport_data;
{
- u_upload_data(device->constbuf_sw_uploader,
+ u_upload_data(device->pipe_sw->const_uploader,
0,
cb.buffer_size,
16,
cb.user_buffer,
&(cb.buffer_offset),
&(cb.buffer));
- u_upload_unmap(device->constbuf_sw_uploader);
+ u_upload_unmap(device->pipe_sw->const_uploader);
cb.user_buffer = NULL;
}