static void
galahad_set_index_buffer(struct pipe_context *_pipe,
const struct pipe_index_buffer *_ib)
{
struct galahad_context *glhd_pipe = galahad_context(_pipe);
struct pipe_context *pipe = glhd_pipe->pipe;
struct pipe_index_buffer unwrapped_ib, *ib = NULL;
if (_ib->buffer) {
switch (_ib->index_size) {
case 1:
case 2:
case 4:
break;
default:
glhd_warn("index buffer %p has unrecognized index size %d",
(void *) _ib->buffer, _ib->index_size);
break;
}
}
else if (_ib->offset || _ib->index_size) {
glhd_warn("non-indexed state with index offset %d and index size %d",
_ib->offset, _ib->index_size);
}
if (_ib) {
unwrapped_ib = *_ib;
unwrapped_ib.buffer = galahad_resource_unwrap(_ib->buffer);
ib = &unwrapped_ib;
}
pipe->set_index_buffer(pipe, ib);
}
static void
galahad_set_framebuffer_state(struct pipe_context *_pipe,
const struct pipe_framebuffer_state *_state)
{
struct galahad_context *glhd_pipe = galahad_context(_pipe);
struct pipe_context *pipe = glhd_pipe->pipe;
struct pipe_framebuffer_state unwrapped_state;
struct pipe_framebuffer_state *state = NULL;
unsigned i;
if (_state->nr_cbufs > PIPE_MAX_COLOR_BUFS) {
glhd_error("%d render targets bound, but only %d are permitted by API",
_state->nr_cbufs, PIPE_MAX_COLOR_BUFS);
} else if (_state->nr_cbufs >
pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS)) {
glhd_warn("%d render targets bound, but only %d are supported",
_state->nr_cbufs,
pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS));
}
/* unwrap the input state */
if (_state) {
memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
for(i = 0; i < _state->nr_cbufs; i++)
unwrapped_state.cbufs[i] = galahad_surface_unwrap(_state->cbufs[i]);
for (; i < PIPE_MAX_COLOR_BUFS; i++)
unwrapped_state.cbufs[i] = NULL;
unwrapped_state.zsbuf = galahad_surface_unwrap(_state->zsbuf);
state = &unwrapped_state;
}
pipe->set_framebuffer_state(pipe,
state);
}
static void
galahad_context_resource_copy_region(struct pipe_context *_pipe,
struct pipe_resource *_dst,
unsigned dst_level,
unsigned dstx,
unsigned dsty,
unsigned dstz,
struct pipe_resource *_src,
unsigned src_level,
const struct pipe_box *src_box)
{
struct galahad_context *glhd_pipe = galahad_context(_pipe);
struct galahad_resource *glhd_resource_dst = galahad_resource(_dst);
struct galahad_resource *glhd_resource_src = galahad_resource(_src);
struct pipe_context *pipe = glhd_pipe->pipe;
struct pipe_resource *dst = glhd_resource_dst->resource;
struct pipe_resource *src = glhd_resource_src->resource;
if (_dst->format != _src->format) {
const struct util_format_description *src_desc =
util_format_description(_src->format);
const struct util_format_description *dst_desc =
util_format_description(_dst->format);
if (!util_is_format_compatible(src_desc, dst_desc))
glhd_warn("Format mismatch: Source is %s, destination is %s",
src_desc->short_name,
dst_desc->short_name);
}
if ((_src->target == PIPE_BUFFER && _dst->target != PIPE_BUFFER) ||
(_src->target != PIPE_BUFFER && _dst->target == PIPE_BUFFER)) {
glhd_warn("Resource target mismatch: Source is %i, destination is %i",
_src->target, _dst->target);
}
pipe->resource_copy_region(pipe,
dst,
dst_level,
dstx,
dsty,
dstz,
src,
src_level,
src_box);
}
static void *
galahad_create_rasterizer_state(struct pipe_context *_pipe,
const struct pipe_rasterizer_state *rasterizer)
{
struct galahad_context *glhd_pipe = galahad_context(_pipe);
struct pipe_context *pipe = glhd_pipe->pipe;
if (rasterizer->point_quad_rasterization) {
if (rasterizer->point_smooth) {
glhd_warn("Point smoothing requested but ignored");
}
} else {
if (rasterizer->sprite_coord_enable) {
glhd_warn("Point sprites requested but ignored");
}
}
return pipe->create_rasterizer_state(pipe,
rasterizer);
}
static void *
galahad_create_blend_state(struct pipe_context *_pipe,
const struct pipe_blend_state *blend)
{
struct galahad_context *glhd_pipe = galahad_context(_pipe);
struct pipe_context *pipe = glhd_pipe->pipe;
if (blend->logicop_enable) {
if (blend->rt[0].blend_enable) {
glhd_warn("Blending enabled for render target 0, but logicops "
"are enabled");
}
}
return pipe->create_blend_state(pipe,
blend);
}
static struct pipe_resource *
galahad_screen_resource_create(struct pipe_screen *_screen,
const struct pipe_resource *templat)
{
struct galahad_screen *glhd_screen = galahad_screen(_screen);
struct pipe_screen *screen = glhd_screen->screen;
struct pipe_resource *result;
if (templat->target >= PIPE_MAX_TEXTURE_TYPES)
glhd_warn("Received bogus resource target %d", templat->target);
if(templat->target != PIPE_TEXTURE_RECT && templat->target != PIPE_BUFFER && !screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES))
{
if(!util_is_power_of_two(templat->width0) || !util_is_power_of_two(templat->height0))
glhd_warn("Requested NPOT (%ux%u) non-rectangle texture without NPOT support", templat->width0, templat->height0);
}
if(templat->target == PIPE_TEXTURE_RECT && templat->last_level)
glhd_warn("Rectangle textures cannot have mipmaps, but last_level = %u", templat->last_level);
if(templat->target == PIPE_BUFFER && templat->last_level)
glhd_warn("Buffers cannot have mipmaps, but last_level = %u", templat->last_level);
if(templat->target != PIPE_TEXTURE_3D && templat->depth0 != 1)
glhd_warn("Only 3D textures can have depth != 1, but received target %u and depth %u", templat->target, templat->depth0);
if(templat->target == PIPE_TEXTURE_1D && templat->height0 != 1)
glhd_warn("1D textures must have height 1 but got asked for height %u", templat->height0);
if(templat->target == PIPE_BUFFER && templat->height0 != 1)
glhd_warn("Buffers must have height 1 but got asked for height %u", templat->height0);
if(templat->target == PIPE_TEXTURE_CUBE && templat->width0 != templat->height0)
glhd_warn("Cube maps must be square, but got asked for %ux%u", templat->width0, templat->height0);
result = screen->resource_create(screen,
templat);
if (result)
return galahad_resource_create(glhd_screen, result);
return NULL;
}
static boolean
galahad_screen_is_format_supported(struct pipe_screen *_screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage)
{
struct galahad_screen *glhd_screen = galahad_screen(_screen);
struct pipe_screen *screen = glhd_screen->screen;
if (target >= PIPE_MAX_TEXTURE_TYPES) {
glhd_warn("Received bogus texture target %d", target);
}
return screen->is_format_supported(screen,
format,
target,
sample_count,
tex_usage);
}
static void
galahad_context_transfer_unmap(struct pipe_context *_context,
struct pipe_transfer *_transfer)
{
struct galahad_context *glhd_context = galahad_context(_context);
struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer);
struct pipe_context *context = glhd_context->pipe;
struct pipe_transfer *transfer = glhd_transfer->transfer;
struct galahad_resource *glhd_resource = galahad_resource(_transfer->resource);
if (glhd_resource->map_count < 1) {
glhd_warn("context::transfer_unmap() called too many times"
" (count = %d)\n", glhd_resource->map_count);
}
glhd_resource->map_count--;
context->transfer_unmap(context,
transfer);
}
struct pipe_screen *
galahad_screen_create(struct pipe_screen *screen)
{
struct galahad_screen *glhd_screen;
if (!debug_get_option_galahad())
return screen;
glhd_screen = CALLOC_STRUCT(galahad_screen);
if (!glhd_screen) {
return screen;
}
glhd_screen->base.destroy = galahad_screen_destroy;
glhd_screen->base.get_name = galahad_screen_get_name;
glhd_screen->base.get_vendor = galahad_screen_get_vendor;
glhd_screen->base.get_param = galahad_screen_get_param;
glhd_screen->base.get_shader_param = galahad_screen_get_shader_param;
glhd_screen->base.get_paramf = galahad_screen_get_paramf;
glhd_screen->base.is_format_supported = galahad_screen_is_format_supported;
glhd_screen->base.context_create = galahad_screen_context_create;
glhd_screen->base.resource_create = galahad_screen_resource_create;
glhd_screen->base.resource_from_handle = galahad_screen_resource_from_handle;
glhd_screen->base.resource_get_handle = galahad_screen_resource_get_handle;
glhd_screen->base.resource_destroy = galahad_screen_resource_destroy;
glhd_screen->base.flush_frontbuffer = galahad_screen_flush_frontbuffer;
glhd_screen->base.fence_reference = galahad_screen_fence_reference;
glhd_screen->base.fence_signalled = galahad_screen_fence_signalled;
glhd_screen->base.fence_finish = galahad_screen_fence_finish;
glhd_screen->screen = screen;
glhd_warn("Created screen %p", (void *) glhd_screen);
return &glhd_screen->base;
}
struct pipe_context *
galahad_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
{
struct galahad_context *glhd_pipe;
(void)galahad_screen(_screen);
glhd_pipe = CALLOC_STRUCT(galahad_context);
if (!glhd_pipe) {
return NULL;
}
glhd_pipe->base.winsys = NULL;
glhd_pipe->base.screen = _screen;
glhd_pipe->base.priv = pipe->priv; /* expose wrapped data */
glhd_pipe->base.draw = NULL;
glhd_pipe->base.destroy = galahad_destroy;
glhd_pipe->base.draw_vbo = galahad_draw_vbo;
glhd_pipe->base.create_query = galahad_create_query;
glhd_pipe->base.destroy_query = galahad_destroy_query;
glhd_pipe->base.begin_query = galahad_begin_query;
glhd_pipe->base.end_query = galahad_end_query;
glhd_pipe->base.get_query_result = galahad_get_query_result;
glhd_pipe->base.create_blend_state = galahad_create_blend_state;
glhd_pipe->base.bind_blend_state = galahad_bind_blend_state;
glhd_pipe->base.delete_blend_state = galahad_delete_blend_state;
glhd_pipe->base.create_sampler_state = galahad_create_sampler_state;
glhd_pipe->base.bind_fragment_sampler_states = galahad_bind_fragment_sampler_states;
glhd_pipe->base.bind_vertex_sampler_states = galahad_bind_vertex_sampler_states;
glhd_pipe->base.delete_sampler_state = galahad_delete_sampler_state;
glhd_pipe->base.create_rasterizer_state = galahad_create_rasterizer_state;
glhd_pipe->base.bind_rasterizer_state = galahad_bind_rasterizer_state;
glhd_pipe->base.delete_rasterizer_state = galahad_delete_rasterizer_state;
glhd_pipe->base.create_depth_stencil_alpha_state = galahad_create_depth_stencil_alpha_state;
glhd_pipe->base.bind_depth_stencil_alpha_state = galahad_bind_depth_stencil_alpha_state;
glhd_pipe->base.delete_depth_stencil_alpha_state = galahad_delete_depth_stencil_alpha_state;
glhd_pipe->base.create_fs_state = galahad_create_fs_state;
glhd_pipe->base.bind_fs_state = galahad_bind_fs_state;
glhd_pipe->base.delete_fs_state = galahad_delete_fs_state;
glhd_pipe->base.create_vs_state = galahad_create_vs_state;
glhd_pipe->base.bind_vs_state = galahad_bind_vs_state;
glhd_pipe->base.delete_vs_state = galahad_delete_vs_state;
glhd_pipe->base.create_vertex_elements_state = galahad_create_vertex_elements_state;
glhd_pipe->base.bind_vertex_elements_state = galahad_bind_vertex_elements_state;
glhd_pipe->base.delete_vertex_elements_state = galahad_delete_vertex_elements_state;
glhd_pipe->base.set_blend_color = galahad_set_blend_color;
glhd_pipe->base.set_stencil_ref = galahad_set_stencil_ref;
glhd_pipe->base.set_clip_state = galahad_set_clip_state;
glhd_pipe->base.set_sample_mask = galahad_set_sample_mask;
glhd_pipe->base.set_constant_buffer = galahad_set_constant_buffer;
glhd_pipe->base.set_framebuffer_state = galahad_set_framebuffer_state;
glhd_pipe->base.set_polygon_stipple = galahad_set_polygon_stipple;
glhd_pipe->base.set_scissor_state = galahad_set_scissor_state;
glhd_pipe->base.set_viewport_state = galahad_set_viewport_state;
glhd_pipe->base.set_fragment_sampler_views = galahad_set_fragment_sampler_views;
glhd_pipe->base.set_vertex_sampler_views = galahad_set_vertex_sampler_views;
glhd_pipe->base.set_vertex_buffers = galahad_set_vertex_buffers;
glhd_pipe->base.set_index_buffer = galahad_set_index_buffer;
glhd_pipe->base.resource_copy_region = galahad_resource_copy_region;
glhd_pipe->base.clear = galahad_clear;
glhd_pipe->base.clear_render_target = galahad_clear_render_target;
glhd_pipe->base.clear_depth_stencil = galahad_clear_depth_stencil;
glhd_pipe->base.flush = galahad_flush;
glhd_pipe->base.create_sampler_view = galahad_context_create_sampler_view;
glhd_pipe->base.sampler_view_destroy = galahad_context_sampler_view_destroy;
glhd_pipe->base.create_surface = galahad_context_create_surface;
glhd_pipe->base.surface_destroy = galahad_context_surface_destroy;
glhd_pipe->base.get_transfer = galahad_context_get_transfer;
glhd_pipe->base.transfer_destroy = galahad_context_transfer_destroy;
glhd_pipe->base.transfer_map = galahad_context_transfer_map;
glhd_pipe->base.transfer_unmap = galahad_context_transfer_unmap;
glhd_pipe->base.transfer_flush_region = galahad_context_transfer_flush_region;
glhd_pipe->base.transfer_inline_write = galahad_context_transfer_inline_write;
glhd_pipe->base.redefine_user_buffer = galahad_redefine_user_buffer;
glhd_pipe->pipe = pipe;
glhd_warn("Created context %p", (void *) glhd_pipe);
return &glhd_pipe->base;
}
