tex_templ.height0 = 256;
tex_templ.depth0 = 1;
tex_templ.array_size = 1;
- tex_templ.usage = PIPE_USAGE_STATIC;
+ tex_templ.usage = PIPE_USAGE_DEFAULT;
tex_templ.bind = PIPE_BIND_SAMPLER_VIEW;
tex = screen->resource_create(screen, &tex_templ);
ppq->constbuf = pipe_buffer_create(ppq->p->screen,
PIPE_BIND_CONSTANT_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(constants));
if (ppq->constbuf == NULL) {
pp_debug("Failed to allocate constant buffer\n");
res.format = PIPE_FORMAT_R8G8_UNORM;
res.width0 = res.height0 = 165;
res.bind = PIPE_BIND_SAMPLER_VIEW;
- res.usage = PIPE_USAGE_STATIC;
+ res.usage = PIPE_USAGE_DEFAULT;
res.depth0 = res.array_size = res.nr_samples = 1;
if (!ppq->p->screen->is_format_supported(ppq->p->screen, res.format,
};
p->vbuf = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC, sizeof(verts));
+ PIPE_USAGE_DEFAULT, sizeof(verts));
pipe_buffer_write(p->pipe, p->vbuf, 0, sizeof(verts), verts);
}
new_elts = pipe_buffer_create(context->screen,
PIPE_BIND_INDEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
2 * count);
out_map = pipe_buffer_map(context, new_elts, PIPE_TRANSFER_WRITE,
new_elts = pipe_buffer_create(context->screen,
PIPE_BIND_INDEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
2 * count);
out_map = pipe_buffer_map(context, new_elts,
new_elts = pipe_buffer_create(context->screen,
PIPE_BIND_INDEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
2 * count);
out_map = pipe_buffer_map(context, new_elts,
(
pipe->screen,
PIPE_BIND_CONSTANT_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(csc_matrix)
);
dec->idct_source = vl_video_buffer_create_ex
(
dec->context, &templat,
- formats, 1, 1, PIPE_USAGE_STATIC
+ formats, 1, 1, PIPE_USAGE_DEFAULT
);
if (!dec->idct_source)
dec->mc_source = vl_video_buffer_create_ex
(
dec->context, &templat,
- formats, nr_of_idct_render_targets, 1, PIPE_USAGE_STATIC
+ formats, nr_of_idct_render_targets, 1, PIPE_USAGE_DEFAULT
);
if (!dec->mc_source)
dec->mc_source = vl_video_buffer_create_ex
(
dec->context, &templat,
- formats, 1, 1, PIPE_USAGE_STATIC
+ formats, 1, 1, PIPE_USAGE_DEFAULT
);
return dec->mc_source != NULL;
(
pipe->screen,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(struct vertex2f) * 4
);
quad.user_buffer = NULL;
(
pipe->screen,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(struct vertex2s) * width * height
);
pos.user_buffer = NULL;
result = vl_video_buffer_create_ex
(
pipe, &templat, resource_formats,
- 1, tmpl->interlaced ? 2 : 1, PIPE_USAGE_STATIC
+ 1, tmpl->interlaced ? 2 : 1, PIPE_USAGE_DEFAULT
);
template.height0 = reply->height;
template.depth0 = 1;
template.array_size = 1;
- template.usage = PIPE_USAGE_STATIC;
+ template.usage = PIPE_USAGE_DEFAULT;
template.bind = PIPE_BIND_RENDER_TARGET;
template.flags = 0;
not expected to be mapped or changed (even by the GPU) after the first upload.
* ``PIPE_USAGE_DYNAMIC``: Expect frequent write-only CPU access. What is
uploaded is expected to be used at least several times by the GPU.
-* ``PIPE_USAGE_STATIC``: Same as PIPE_USAGE_DEFAULT.
* ``PIPE_USAGE_STREAM``: Expect frequent write-only CPU access. What is
uploaded is expected to be used only once by the GPU.
* ``PIPE_USAGE_STAGING``: Optimized for fast CPU access.
switch (buffer->base.usage) {
case PIPE_USAGE_DEFAULT:
case PIPE_USAGE_IMMUTABLE:
- case PIPE_USAGE_STATIC:
buffer->domain = NOUVEAU_BO_VRAM;
break;
case PIPE_USAGE_DYNAMIC:
templ.depth0 = 1;
templ.array_size = 1;
templ.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
- templ.usage = PIPE_USAGE_STATIC;
+ templ.usage = PIPE_USAGE_DEFAULT;
templ.flags = NOUVEAU_RESOURCE_FLAG_LINEAR;
buffer->resources[0] = pipe->screen->resource_create(pipe->screen, &templ);
templ.height0 = info->src.resource->height0;
templ.depth0 = 1;
templ.array_size = 1;
- templ.usage = PIPE_USAGE_STATIC;
+ templ.usage = PIPE_USAGE_DEFAULT;
templ.flags = R300_RESOURCE_FORCE_MICROTILING;
tmp = screen->resource_create(screen, &templ);
memset(&vb, 0, sizeof(vb));
vb.target = PIPE_BUFFER;
vb.format = PIPE_FORMAT_R8_UNORM;
- vb.usage = PIPE_USAGE_STATIC;
+ vb.usage = PIPE_USAGE_DEFAULT;
vb.width0 = sizeof(float) * 16;
vb.height0 = 1;
vb.depth0 = 1;
}
rctx->allocator_fetch_shader = u_suballocator_create(&rctx->b.b, 64 * 1024, 256,
- 0, PIPE_USAGE_STATIC, FALSE);
+ 0, PIPE_USAGE_DEFAULT, FALSE);
if (!rctx->allocator_fetch_shader)
goto fail;
templ.array_size = 1;
templ.target = PIPE_TEXTURE_2D;
templ.format = PIPE_FORMAT_R8G8B8A8_UNORM;
- templ.usage = PIPE_USAGE_STATIC;
+ templ.usage = PIPE_USAGE_DEFAULT;
struct r600_resource *res = r600_resource(rscreen->screen.resource_create(&rscreen->screen, &templ));
unsigned char *map = ws->buffer_map(res->cs_buf, NULL, PIPE_TRANSFER_WRITE);
buffer.target = PIPE_BUFFER;
buffer.format = PIPE_FORMAT_R8_UNORM;
buffer.bind = PIPE_BIND_CUSTOM;
- buffer.usage = PIPE_USAGE_STATIC;
+ buffer.usage = PIPE_USAGE_DEFAULT;
buffer.flags = 0;
buffer.width0 = size;
buffer.height0 = 1;
unsigned size = 0x1C000;
rctx->gs_rings.esgs_ring.buffer =
pipe_buffer_create(rctx->b.b.screen, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC, size);
+ PIPE_USAGE_DEFAULT, size);
rctx->gs_rings.esgs_ring.buffer_size = size;
size = 0x4000000;
rctx->gs_rings.gsvs_ring.buffer =
pipe_buffer_create(rctx->b.b.screen, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC, size);
+ PIPE_USAGE_DEFAULT, size);
rctx->gs_rings.gsvs_ring.buffer_size = size;
}
template.width = align(tmpl->width, VL_MACROBLOCK_WIDTH);
template.height = align(tmpl->height / array_size, VL_MACROBLOCK_HEIGHT);
- vl_video_buffer_template(&templ, &template, resource_formats[0], 1, array_size, PIPE_USAGE_STATIC, 0);
+ vl_video_buffer_template(&templ, &template, resource_formats[0], 1, array_size, PIPE_USAGE_DEFAULT, 0);
if (ctx->b.chip_class < EVERGREEN || tmpl->interlaced)
templ.bind = PIPE_BIND_LINEAR;
resources[0] = (struct r600_texture *)
goto error;
if (resource_formats[1] != PIPE_FORMAT_NONE) {
- vl_video_buffer_template(&templ, &template, resource_formats[1], 1, array_size, PIPE_USAGE_STATIC, 1);
+ vl_video_buffer_template(&templ, &template, resource_formats[1], 1, array_size, PIPE_USAGE_DEFAULT, 1);
if (ctx->b.chip_class < EVERGREEN || tmpl->interlaced)
templ.bind = PIPE_BIND_LINEAR;
resources[1] = (struct r600_texture *)
}
if (resource_formats[2] != PIPE_FORMAT_NONE) {
- vl_video_buffer_template(&templ, &template, resource_formats[2], 1, array_size, PIPE_USAGE_STATIC, 2);
+ vl_video_buffer_template(&templ, &template, resource_formats[2], 1, array_size, PIPE_USAGE_DEFAULT, 2);
if (ctx->b.chip_class < EVERGREEN || tmpl->interlaced)
templ.bind = PIPE_BIND_LINEAR;
resources[2] = (struct r600_texture *)
res->domains = RADEON_DOMAIN_GTT;
break;
case PIPE_USAGE_DEFAULT:
- case PIPE_USAGE_STATIC:
case PIPE_USAGE_IMMUTABLE:
default:
/* Not listing GTT here improves performance in some apps. */
r600_query_init(rctx);
rctx->allocator_so_filled_size = u_suballocator_create(&rctx->b, 4096, 4,
- 0, PIPE_USAGE_STATIC, TRUE);
+ 0, PIPE_USAGE_DEFAULT, TRUE);
if (!rctx->allocator_so_filled_size)
return false;
rtex->cmask_buffer = (struct r600_resource *)
pipe_buffer_create(&rscreen->b, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC, rtex->cmask.size);
+ PIPE_USAGE_DEFAULT, rtex->cmask.size);
if (rtex->cmask_buffer == NULL) {
rtex->cmask.size = 0;
}
/* XXX don't allocate it separately */
rtex->htile_buffer = (struct r600_resource*)
pipe_buffer_create(&rscreen->b, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC, htile_size);
+ PIPE_USAGE_DEFAULT, htile_size);
if (rtex->htile_buffer == NULL) {
/* this is not a fatal error as we can still keep rendering
* without htile buffer */
resource.array_size = texture->array_size;
resource.last_level = texture->last_level;
resource.nr_samples = texture->nr_samples;
- resource.usage = staging ? PIPE_USAGE_STAGING : PIPE_USAGE_STATIC;
+ resource.usage = staging ? PIPE_USAGE_STAGING : PIPE_USAGE_DEFAULT;
resource.bind = texture->bind & ~PIPE_BIND_DEPTH_STENCIL;
resource.flags = texture->flags | R600_RESOURCE_FLAG_FLUSHED_DEPTH;
res->height0 = box->height;
res->depth0 = 1;
res->array_size = 1;
- res->usage = flags & R600_RESOURCE_FLAG_TRANSFER ? PIPE_USAGE_STAGING : PIPE_USAGE_STATIC;
+ res->usage = flags & R600_RESOURCE_FLAG_TRANSFER ? PIPE_USAGE_STAGING : PIPE_USAGE_DEFAULT;
res->flags = flags;
/* We must set the correct texture target and dimensions for a 3D box. */
desc->buffer = (struct r600_resource*)
pipe_buffer_create(sctx->b.b.screen, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
SI_NUM_CONTEXTS * desc->context_size);
r600_context_bo_reloc(&sctx->b, &sctx->b.rings.gfx, desc->buffer, RADEON_USAGE_READWRITE);
* with a NULL buffer). We need to use a dummy buffer instead. */
if (sctx->b.chip_class == CIK) {
sctx->null_const_buf.buffer = pipe_buffer_create(screen, PIPE_BIND_CONSTANT_BUFFER,
- PIPE_USAGE_STATIC, 16);
+ PIPE_USAGE_DEFAULT, 16);
sctx->null_const_buf.buffer_size = sctx->null_const_buf.buffer->width0;
for (shader = 0; shader < SI_NUM_SHADERS; shader++) {
sctx->esgs_ring.buffer =
pipe_buffer_create(sctx->b.b.screen, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC, size);
+ PIPE_USAGE_DEFAULT, size);
sctx->esgs_ring.buffer_size = size;
size = 64 * 1024 * 1024;
sctx->gsvs_ring.buffer =
pipe_buffer_create(sctx->b.b.screen, PIPE_BIND_CUSTOM,
- PIPE_USAGE_STATIC, size);
+ PIPE_USAGE_DEFAULT, size);
sctx->gsvs_ring.buffer_size = size;
if (sctx->b.chip_class >= CIK) {
template.width = align(tmpl->width, VL_MACROBLOCK_WIDTH);
template.height = align(tmpl->height / array_size, VL_MACROBLOCK_HEIGHT);
- vl_video_buffer_template(&templ, &template, resource_formats[0], 1, array_size, PIPE_USAGE_STATIC, 0);
+ vl_video_buffer_template(&templ, &template, resource_formats[0], 1, array_size, PIPE_USAGE_DEFAULT, 0);
/* TODO: get tiling working */
templ.bind = PIPE_BIND_LINEAR;
resources[0] = (struct r600_texture *)
goto error;
if (resource_formats[1] != PIPE_FORMAT_NONE) {
- vl_video_buffer_template(&templ, &template, resource_formats[1], 1, array_size, PIPE_USAGE_STATIC, 1);
+ vl_video_buffer_template(&templ, &template, resource_formats[1], 1, array_size, PIPE_USAGE_DEFAULT, 1);
templ.bind = PIPE_BIND_LINEAR;
resources[1] = (struct r600_texture *)
pipe->screen->resource_create(pipe->screen, &templ);
}
if (resource_formats[2] != PIPE_FORMAT_NONE) {
- vl_video_buffer_template(&templ, &template, resource_formats[2], 1, array_size, PIPE_USAGE_STATIC, 2);
+ vl_video_buffer_template(&templ, &template, resource_formats[2], 1, array_size, PIPE_USAGE_DEFAULT, 2);
templ.bind = PIPE_BIND_LINEAR;
resources[2] = (struct r600_texture *)
pipe->screen->resource_create(pipe->screen, &templ);
void *dst_map = NULL;
dst = pipe_buffer_create(pipe->screen,
- PIPE_BIND_INDEX_BUFFER, PIPE_USAGE_STATIC, size);
+ PIPE_BIND_INDEX_BUFFER, PIPE_USAGE_DEFAULT, size);
if (dst == NULL)
goto fail;
size = index_size * nr;
dst = pipe_buffer_create(pipe->screen,
- PIPE_BIND_INDEX_BUFFER, PIPE_USAGE_STATIC, size);
+ PIPE_BIND_INDEX_BUFFER, PIPE_USAGE_DEFAULT, size);
if (dst == NULL)
goto fail;
#define PIPE_USAGE_DYNAMIC 2 /* uploaded data is used multiple times */
#define PIPE_USAGE_STREAM 3 /* uploaded data is used once */
#define PIPE_USAGE_STAGING 4 /* fast CPU access */
-#define PIPE_USAGE_STATIC 5 /* same as DEFAULT, will be removed */
/**
res_tmpl.depth0 = 1;
res_tmpl.array_size = 1;
res_tmpl.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
- res_tmpl.usage = frequently_accessed ? PIPE_USAGE_DYNAMIC : PIPE_USAGE_STATIC;
+ res_tmpl.usage = frequently_accessed ? PIPE_USAGE_DYNAMIC : PIPE_USAGE_DEFAULT;
pipe_mutex_lock(dev->mutex);
res_tmpl.depth0 = 1;
res_tmpl.array_size = 1;
res_tmpl.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
- res_tmpl.usage = PIPE_USAGE_STATIC;
+ res_tmpl.usage = PIPE_USAGE_DEFAULT;
pipe_mutex_lock(dev->mutex);
pipe_resource_reference(&cbuf, NULL);
cbuf = pipe_buffer_create(renderer->pipe->screen,
PIPE_BIND_CONSTANT_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(consts));
if (cbuf) {
pipe_buffer_write(renderer->pipe, cbuf,
pipe_resource_reference(&cbuf, NULL);
cbuf = pipe_buffer_create(renderer->pipe->screen,
- PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_STATIC,
+ PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_DEFAULT,
const_buffer_len);
pipe_buffer_write(renderer->pipe, cbuf, 0,
const_buffer_len, const_buffer);
pipe_resource_reference(cbuf, NULL);
*cbuf = pipe_buffer_create(r->pipe->screen,
- PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_STATIC,
+ PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_DEFAULT,
param_bytes);
if (*cbuf) {
tex_templ.format = PIPE_FORMAT_R8G8B8X8_UNORM;
tex_templ.width0 = subpicture->num_palette_entries;
tex_templ.height0 = 1;
- tex_templ.usage = PIPE_USAGE_STATIC;
+ tex_templ.usage = PIPE_USAGE_DEFAULT;
tex = pipe->screen->resource_create(pipe->screen, &tex_templ);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
if (draw_strip) {
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices_strip),
vertices_strip);
} else {
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
}
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
bytes,
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
num_verts * sizeof(struct vertex),
verts);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf[0].buffer_offset = 0;
vbuf[0].buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf[1].buffer_offset = 0;
vbuf[1].buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(inst_data),
inst_data);
/* index data */
ibuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_INDEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(indices),
indices);
ibuf.offset = 0;
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
vbuf.buffer_offset = 0;
vbuf.buffer = pipe_buffer_create_with_data(ctx,
PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC,
+ PIPE_USAGE_DEFAULT,
sizeof(vertices),
vertices);
};
p->vbuf = pipe_buffer_create(p->screen, PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC, sizeof(vertices));
+ PIPE_USAGE_DEFAULT, sizeof(vertices));
pipe_buffer_write(p->pipe, p->vbuf, 0, sizeof(vertices), vertices);
}
};
p->vbuf = pipe_buffer_create(p->screen, PIPE_BIND_VERTEX_BUFFER,
- PIPE_USAGE_STATIC, sizeof(vertices));
+ PIPE_USAGE_DEFAULT, sizeof(vertices));
pipe_buffer_write(p->pipe, p->vbuf, 0, sizeof(vertices), vertices);
}
case GL_STATIC_DRAW:
case GL_STATIC_READ:
case GL_STATIC_COPY:
- pipe_usage = PIPE_USAGE_STATIC;
+ default:
+ pipe_usage = PIPE_USAGE_DEFAULT;
break;
case GL_DYNAMIC_DRAW:
case GL_DYNAMIC_READ:
case GL_STREAM_COPY:
pipe_usage = PIPE_USAGE_STREAM;
break;
- default:
- pipe_usage = PIPE_USAGE_DEFAULT;
}
pipe_resource_reference( &st_obj->buffer, NULL );
projects / mesa.git / commitdiff