void
nvfx_draw_vbo_swtnl(struct pipe_context *pipe, const struct pipe_draw_info* info)
{
struct nvfx_context *nvfx = nvfx_context(pipe);
unsigned i;
void *map;
if (!nvfx_state_validate_swtnl(nvfx))
return;
nvfx_state_emit(nvfx);
/* these must be passed without adding the offsets */
for (i = 0; i < nvfx->vtxbuf_nr; i++) {
map = nvfx_buffer(nvfx->vtxbuf[i].buffer)->data;
draw_set_mapped_vertex_buffer(nvfx->draw, i, map);
}
map = NULL;
if (info->indexed && nvfx->idxbuf.buffer)
map = nvfx_buffer(nvfx->idxbuf.buffer)->data;
draw_set_mapped_index_buffer(nvfx->draw, map);
if (nvfx->constbuf[PIPE_SHADER_VERTEX]) {
const unsigned nr = nvfx->constbuf_nr[PIPE_SHADER_VERTEX];
map = nvfx_buffer(nvfx->constbuf[PIPE_SHADER_VERTEX])->data;
draw_set_mapped_constant_buffer(nvfx->draw, PIPE_SHADER_VERTEX, 0,
map, nr);
}
draw_vbo(nvfx->draw, info);
draw_flush(nvfx->draw);
}
/**
* Instanced drawing.
* \sa draw_vbo
*/
void
draw_arrays_instanced(struct draw_context *draw,
unsigned mode,
unsigned start,
unsigned count,
unsigned startInstance,
unsigned instanceCount)
{
struct pipe_draw_info info;
util_draw_init_info(&info);
info.mode = mode;
info.start = start;
info.count = count;
info.start_instance = startInstance;
info.instance_count = instanceCount;
info.indexed = (draw->pt.user.elts != NULL);
if (!info.indexed) {
info.min_index = start;
info.max_index = start + count - 1;
}
draw_vbo(draw, &info);
}
/**
* Draw vertex arrays, with optional indexing, optional instancing.
* All the other drawing functions are implemented in terms of this function.
* Basically, map the vertex buffers (and drawing surfaces), then hand off
* the drawing to the 'draw' module.
*/
static void
llvmpipe_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
{
struct llvmpipe_context *lp = llvmpipe_context(pipe);
struct draw_context *draw = lp->draw;
const void *mapped_indices = NULL;
unsigned i;
if (!llvmpipe_check_render_cond(lp))
return;
if (lp->dirty)
llvmpipe_update_derived( lp );
/*
* Map vertex buffers
*/
for (i = 0; i < lp->num_vertex_buffers; i++) {
const void *buf = lp->vertex_buffer[i].user_buffer;
if (!buf)
buf = llvmpipe_resource_data(lp->vertex_buffer[i].buffer);
draw_set_mapped_vertex_buffer(draw, i, buf);
}
/* Map index buffer, if present */
if (info->indexed) {
mapped_indices = lp->index_buffer.user_buffer;
if (!mapped_indices)
mapped_indices = llvmpipe_resource_data(lp->index_buffer.buffer);
draw_set_indexes(draw,
(ubyte *) mapped_indices + lp->index_buffer.offset,
lp->index_buffer.index_size);
}
llvmpipe_prepare_vertex_sampling(lp,
lp->num_sampler_views[PIPE_SHADER_VERTEX],
lp->sampler_views[PIPE_SHADER_VERTEX]);
/* draw! */
draw_vbo(draw, info);
/*
* unmap vertex/index buffers
*/
for (i = 0; i < lp->num_vertex_buffers; i++) {
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
if (mapped_indices) {
draw_set_indexes(draw, NULL, 0);
}
llvmpipe_cleanup_vertex_sampling(lp);
/*
* TODO: Flush only when a user vertex/index buffer is present
* (or even better, modify draw module to do this
* internally when this condition is seen?)
*/
draw_flush(draw);
}
/* SW TCL elements, using Draw. */
static void r300_swtcl_draw_vbo(struct pipe_context* pipe,
const struct pipe_draw_info *info)
{
struct r300_context* r300 = r300_context(pipe);
struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
struct pipe_transfer *ib_transfer = NULL;
int i;
void *indices = NULL;
boolean indexed = info->indexed && r300->vbuf_mgr->index_buffer.buffer;
if (r300->skip_rendering) {
return;
}
r300_update_derived_state(r300);
r300_reserve_cs_dwords(r300,
PREP_EMIT_STATES | PREP_EMIT_VARRAYS_SWTCL |
(indexed ? PREP_INDEXED : 0),
indexed ? 256 : 6);
for (i = 0; i < r300->vbuf_mgr->nr_vertex_buffers; i++) {
if (r300->vbuf_mgr->vertex_buffer[i].buffer) {
void *buf = pipe_buffer_map(pipe,
r300->vbuf_mgr->vertex_buffer[i].buffer,
PIPE_TRANSFER_READ |
PIPE_TRANSFER_UNSYNCHRONIZED,
&vb_transfer[i]);
draw_set_mapped_vertex_buffer(r300->draw, i, buf);
}
}
if (indexed) {
indices = pipe_buffer_map(pipe, r300->vbuf_mgr->index_buffer.buffer,
PIPE_TRANSFER_READ |
PIPE_TRANSFER_UNSYNCHRONIZED, &ib_transfer);
}
draw_set_mapped_index_buffer(r300->draw, indices);
r300->draw_vbo_locked = TRUE;
r300->draw_first_emitted = FALSE;
draw_vbo(r300->draw, info);
draw_flush(r300->draw);
r300->draw_vbo_locked = FALSE;
for (i = 0; i < r300->vbuf_mgr->nr_vertex_buffers; i++) {
if (r300->vbuf_mgr->vertex_buffer[i].buffer) {
pipe_buffer_unmap(pipe, vb_transfer[i]);
draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
}
}
if (indexed) {
pipe_buffer_unmap(pipe, ib_transfer);
draw_set_mapped_index_buffer(r300->draw, NULL);
}
}
static void
i915_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
{
struct i915_context *i915 = i915_context(pipe);
struct draw_context *draw = i915->draw;
const void *mapped_indices = NULL;
/*
* Ack vs contants here, helps ipers a lot.
*/
i915->dirty &= ~I915_NEW_VS_CONSTANTS;
if (i915->dirty)
i915_update_derived(i915);
/*
* Map index buffer, if present
*/
if (info->indexed) {
mapped_indices = i915->index_buffer.user_buffer;
if (!mapped_indices)
mapped_indices = i915_buffer(i915->index_buffer.buffer)->data;
draw_set_indexes(draw,
(ubyte *) mapped_indices + i915->index_buffer.offset,
i915->index_buffer.index_size);
}
if (i915->constants[PIPE_SHADER_VERTEX])
draw_set_mapped_constant_buffer(draw, PIPE_SHADER_VERTEX, 0,
i915_buffer(i915->constants[PIPE_SHADER_VERTEX])->data,
(i915->current.num_user_constants[PIPE_SHADER_VERTEX] *
4 * sizeof(float)));
else
draw_set_mapped_constant_buffer(draw, PIPE_SHADER_VERTEX, 0, NULL, 0);
if (i915->num_vertex_sampler_views > 0)
i915_prepare_vertex_sampling(i915);
/*
* Do the drawing
*/
draw_vbo(i915->draw, info);
if (mapped_indices)
draw_set_indexes(draw, NULL, 0);
if (i915->num_vertex_sampler_views > 0)
i915_cleanup_vertex_sampling(i915);
/*
* Instead of flushing on every state change, we flush once here
* when we fire the vbo.
*/
draw_flush(i915->draw);
}
static void
ilo_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
{
struct ilo_context *ilo = ilo_context(pipe);
int vs_scratch_size, gs_scratch_size, fs_scratch_size;
if (ilo_debug & ILO_DEBUG_DRAW) {
if (info->indexed) {
ilo_printf("indexed draw %s: "
"index start %d, count %d, vertex range [%d, %d]\n",
u_prim_name(info->mode), info->start, info->count,
info->min_index, info->max_index);
}
else {
ilo_printf("draw %s: vertex start %d, count %d\n",
u_prim_name(info->mode), info->start, info->count);
}
ilo_state_vector_dump_dirty(&ilo->state_vector);
}
if (ilo_skip_rendering(ilo))
return;
if (info->primitive_restart && info->indexed &&
draw_vbo_need_sw_restart(ilo, info)) {
draw_vbo_with_sw_restart(ilo, info);
return;
}
ilo_finalize_3d_states(ilo, info);
/* upload kernels */
ilo_shader_cache_upload(ilo->shader_cache, &ilo->cp->builder);
/* prepare scratch spaces */
ilo_shader_cache_get_max_scratch_sizes(ilo->shader_cache,
&vs_scratch_size, &gs_scratch_size, &fs_scratch_size);
ilo_render_prepare_scratch_spaces(ilo->render,
vs_scratch_size, gs_scratch_size, fs_scratch_size);
ilo_blit_resolve_framebuffer(ilo);
/* If draw_vbo ever fails, return immediately. */
if (!draw_vbo(ilo, &ilo->state_vector))
return;
/* clear dirty status */
ilo->state_vector.dirty = 0x0;
/* avoid dangling pointer reference */
ilo->state_vector.draw = NULL;
if (ilo_debug & ILO_DEBUG_NOCACHE)
ilo_render_emit_flush(ilo->render);
}
/* SW TCL elements, using Draw. */
static void r300_swtcl_draw_vbo(struct pipe_context* pipe,
const struct pipe_draw_info *info)
{
struct r300_context* r300 = r300_context(pipe);
if (r300->skip_rendering) {
return;
}
r300_update_derived_state(r300);
draw_vbo(r300->draw, info);
draw_flush(r300->draw);
}
void draw_objects(simulation_t *simulation, buffer_t *buffer, shader_t *shader, GLfloat camera[16]) {
GLfloat modelview[16];
for (unsigned int i = 0; i < simulation->count; i++) {
particle_t particle = simulation->src_buf[i];
vec3f p = particle.position;
load_identity(modelview);
translate(modelview, p.x, p.y, p.z);
scale(modelview, particle.radius, particle.radius, particle.radius);
multiply_matrix(modelview, camera, modelview);
set_matrix(shader, MODELVIEW_MATRIX, modelview);
glColor3f(particle.r, particle.g, particle.b);
draw_vbo(buffer);
}
}
// ----------------------------------------
static VALUE draw_block(VALUE yield_value, VALUE self, int argc, VALUE argv[])
{
EMITTER();
if(!NIL_P(emitter->rb_shader))
{
rb_funcall(emitter->rb_shader, rb_intern("image="), 1, emitter->rb_image);
rb_funcall(emitter->rb_shader, rb_intern("color="), 1, UINT2NUM(color_to_argb(&emitter->color)));
}
draw_vbo(emitter);
return Qnil;
}
/**
* Draw vertex arrays, with optional indexing.
* Basically, map the vertex buffers (and drawing surfaces), then hand off
* the drawing to the 'draw' module.
*
* XXX should the element buffer be specified/bound with a separate function?
*/
static void
cell_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
{
struct cell_context *cell = cell_context(pipe);
struct draw_context *draw = cell->draw;
void *mapped_indices = NULL;
unsigned i;
if (cell->dirty)
cell_update_derived( cell );
#if 0
cell_map_surfaces(cell);
#endif
/*
* Map vertex buffers
*/
for (i = 0; i < cell->num_vertex_buffers; i++) {
void *buf = cell_resource(cell->vertex_buffer[i].buffer)->data;
draw_set_mapped_vertex_buffer(draw, i, buf);
}
/* Map index buffer, if present */
if (info->indexed && cell->index_buffer.buffer)
mapped_indices = cell_resource(cell->index_buffer.buffer)->data;
draw_set_mapped_index_buffer(draw, mapped_indices);
/* draw! */
draw_vbo(draw, info);
/*
* unmap vertex/index buffers - will cause draw module to flush
*/
for (i = 0; i < cell->num_vertex_buffers; i++) {
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
if (mapped_indices) {
draw_set_mapped_index_buffer(draw, NULL);
}
/*
* TODO: Flush only when a user vertex/index buffer is present
* (or even better, modify draw module to do this
* internally when this condition is seen?)
*/
draw_flush(draw);
}
int main(void){
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) != 0){
fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
return 1;
}
SDL_WM_SetCaption("OpenGL test window", "OpenGL");
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_Surface *surface = SDL_SetVideoMode(400, 400, 32, SDL_OPENGL);
if (surface == NULL) {
fprintf(stderr, "Failed to initialize OpenGL: %s\n", SDL_GetError());
return 1;
}
GLenum err = glewInit();
if (GLEW_OK != err) {
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Failed to initialize GLEW: %s\n", glewGetErrorString(err));
return 1;
}
printf("OpenGL Version is %s\n", glGetString(GL_VERSION));
setup_rendering();
buffer_t buffer = create_vbo(10, 10);
while(1) {
//glScalef(1.0, 1.0, 1.1f);
glRotatef(10, 0,0,1);
glColor3f(1.0f, 0.0f, 0.0f);
draw_vbo(buffer);
glColor3f(1.0f, 1.0f, 0.0f);
draw_vbo_raw(buffer);
SDL_GL_SwapBuffers();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_Delay(500);
if(handle_events() == 1) {
destroy_vbo(buffer);
SDL_Quit();
exit(0);
}
}
}
enum pipe_error
svga_swtnl_draw_vbo(struct svga_context *svga,
const struct pipe_draw_info *info)
{
struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
struct pipe_transfer *ib_transfer = NULL;
struct pipe_transfer *cb_transfer = NULL;
struct draw_context *draw = svga->swtnl.draw;
unsigned i;
const void *map;
enum pipe_error ret;
assert(!svga->dirty);
assert(svga->state.sw.need_swtnl);
assert(draw);
/* Make sure that the need_swtnl flag does not go away */
svga->state.sw.in_swtnl_draw = TRUE;
ret = svga_update_state(svga, SVGA_STATE_SWTNL_DRAW);
if (ret != PIPE_OK) {
svga_context_flush(svga, NULL);
ret = svga_update_state(svga, SVGA_STATE_SWTNL_DRAW);
svga->swtnl.new_vbuf = TRUE;
assert(ret == PIPE_OK);
}
/*
* Map vertex buffers
*/
for (i = 0; i < svga->curr.num_vertex_buffers; i++) {
if (svga->curr.vb[i].buffer) {
map = pipe_buffer_map(&svga->pipe,
svga->curr.vb[i].buffer,
PIPE_TRANSFER_READ,
&vb_transfer[i]);
draw_set_mapped_vertex_buffer(draw, i, map);
}
}
/* Map index buffer, if present */
map = NULL;
if (info->indexed && svga->curr.ib.buffer) {
map = pipe_buffer_map(&svga->pipe, svga->curr.ib.buffer,
PIPE_TRANSFER_READ,
&ib_transfer);
draw_set_indexes(draw,
(const ubyte *) map + svga->curr.ib.offset,
svga->curr.ib.index_size);
}
if (svga->curr.cb[PIPE_SHADER_VERTEX]) {
map = pipe_buffer_map(&svga->pipe,
svga->curr.cb[PIPE_SHADER_VERTEX],
PIPE_TRANSFER_READ,
&cb_transfer);
assert(map);
draw_set_mapped_constant_buffer(
draw, PIPE_SHADER_VERTEX, 0,
map,
svga->curr.cb[PIPE_SHADER_VERTEX]->width0);
}
draw_vbo(draw, info);
draw_flush(svga->swtnl.draw);
/* Ensure the draw module didn't touch this */
assert(i == svga->curr.num_vertex_buffers);
/*
* unmap vertex/index buffers
*/
for (i = 0; i < svga->curr.num_vertex_buffers; i++) {
if (svga->curr.vb[i].buffer) {
pipe_buffer_unmap(&svga->pipe, vb_transfer[i]);
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
}
if (ib_transfer) {
pipe_buffer_unmap(&svga->pipe, ib_transfer);
draw_set_indexes(draw, NULL, 0);
}
if (svga->curr.cb[PIPE_SHADER_VERTEX]) {
pipe_buffer_unmap(&svga->pipe, cb_transfer);
}
/* Now safe to remove the need_swtnl flag in any update_state call */
svga->state.sw.in_swtnl_draw = FALSE;
svga->dirty |= SVGA_NEW_NEED_PIPELINE | SVGA_NEW_NEED_SWVFETCH;
return ret;
}
/**
* Draw vertex arrays, with optional indexing, optional instancing.
* All the other drawing functions are implemented in terms of this function.
* Basically, map the vertex buffers (and drawing surfaces), then hand off
* the drawing to the 'draw' module.
*/
static void
llvmpipe_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
{
struct llvmpipe_context *lp = llvmpipe_context(pipe);
struct draw_context *draw = lp->draw;
const void *mapped_indices = NULL;
unsigned i;
if (!llvmpipe_check_render_cond(lp))
return;
if (info->indirect) {
util_draw_indirect(pipe, info);
return;
}
if (lp->dirty)
llvmpipe_update_derived( lp );
/*
* Map vertex buffers
*/
for (i = 0; i < lp->num_vertex_buffers; i++) {
const void *buf = lp->vertex_buffer[i].is_user_buffer ?
lp->vertex_buffer[i].buffer.user : NULL;
size_t size = ~0;
if (!buf) {
if (!lp->vertex_buffer[i].buffer.resource) {
continue;
}
buf = llvmpipe_resource_data(lp->vertex_buffer[i].buffer.resource);
size = lp->vertex_buffer[i].buffer.resource->width0;
}
draw_set_mapped_vertex_buffer(draw, i, buf, size);
}
/* Map index buffer, if present */
if (info->index_size) {
unsigned available_space = ~0;
mapped_indices = info->has_user_indices ? info->index.user : NULL;
if (!mapped_indices) {
mapped_indices = llvmpipe_resource_data(info->index.resource);
available_space = info->index.resource->width0;
}
draw_set_indexes(draw,
(ubyte *) mapped_indices,
info->index_size, available_space);
}
for (i = 0; i < lp->num_so_targets; i++) {
void *buf = 0;
if (lp->so_targets[i]) {
buf = llvmpipe_resource(lp->so_targets[i]->target.buffer)->data;
lp->so_targets[i]->mapping = buf;
}
}
draw_set_mapped_so_targets(draw, lp->num_so_targets,
lp->so_targets);
llvmpipe_prepare_vertex_sampling(lp,
lp->num_sampler_views[PIPE_SHADER_VERTEX],
lp->sampler_views[PIPE_SHADER_VERTEX]);
llvmpipe_prepare_geometry_sampling(lp,
lp->num_sampler_views[PIPE_SHADER_GEOMETRY],
lp->sampler_views[PIPE_SHADER_GEOMETRY]);
if (lp->gs && lp->gs->no_tokens) {
/* we have an empty geometry shader with stream output, so
attach the stream output info to the current vertex shader */
if (lp->vs) {
draw_vs_attach_so(lp->vs, &lp->gs->stream_output);
}
}
draw_collect_pipeline_statistics(draw,
lp->active_statistics_queries > 0);
/* draw! */
draw_vbo(draw, info);
/*
* unmap vertex/index buffers
*/
for (i = 0; i < lp->num_vertex_buffers; i++) {
draw_set_mapped_vertex_buffer(draw, i, NULL, 0);
}
if (mapped_indices) {
draw_set_indexes(draw, NULL, 0, 0);
}
draw_set_mapped_so_targets(draw, 0, NULL);
if (lp->gs && lp->gs->no_tokens) {
/* we have attached stream output to the vs for rendering,
now lets reset it */
if (lp->vs) {
draw_vs_reset_so(lp->vs);
}
}
/*
* TODO: Flush only when a user vertex/index buffer is present
* (or even better, modify draw module to do this
* internally when this condition is seen?)
*/
draw_flush(draw);
}
void
nv30_render_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
{
struct nv30_context *nv30 = nv30_context(pipe);
struct draw_context *draw = nv30->draw;
struct pipe_transfer *transfer[PIPE_MAX_ATTRIBS] = {NULL};
struct pipe_transfer *transferi = NULL;
int i;
nv30_render_validate(nv30);
if (nv30->draw_dirty & NV30_NEW_VIEWPORT)
draw_set_viewport_states(draw, 0, 1, &nv30->viewport);
if (nv30->draw_dirty & NV30_NEW_RASTERIZER)
draw_set_rasterizer_state(draw, &nv30->rast->pipe, NULL);
if (nv30->draw_dirty & NV30_NEW_CLIP)
draw_set_clip_state(draw, &nv30->clip);
if (nv30->draw_dirty & NV30_NEW_ARRAYS) {
draw_set_vertex_buffers(draw, 0, nv30->num_vtxbufs, nv30->vtxbuf);
draw_set_vertex_elements(draw, nv30->vertex->num_elements, nv30->vertex->pipe);
}
if (nv30->draw_dirty & NV30_NEW_FRAGPROG) {
struct nv30_fragprog *fp = nv30->fragprog.program;
if (!fp->draw)
fp->draw = draw_create_fragment_shader(draw, &fp->pipe);
draw_bind_fragment_shader(draw, fp->draw);
}
if (nv30->draw_dirty & NV30_NEW_VERTPROG) {
struct nv30_vertprog *vp = nv30->vertprog.program;
if (!vp->draw)
vp->draw = draw_create_vertex_shader(draw, &vp->pipe);
draw_bind_vertex_shader(draw, vp->draw);
}
if (nv30->draw_dirty & NV30_NEW_VERTCONST) {
if (nv30->vertprog.constbuf) {
void *map = nv04_resource(nv30->vertprog.constbuf)->data;
draw_set_mapped_constant_buffer(draw, PIPE_SHADER_VERTEX, 0,
map, nv30->vertprog.constbuf_nr * 16);
} else {
draw_set_mapped_constant_buffer(draw, PIPE_SHADER_VERTEX, 0, NULL, 0);
}
}
for (i = 0; i < nv30->num_vtxbufs; i++) {
const void *map = nv30->vtxbuf[i].user_buffer;
if (!map) {
if (nv30->vtxbuf[i].buffer)
map = pipe_buffer_map(pipe, nv30->vtxbuf[i].buffer,
PIPE_TRANSFER_UNSYNCHRONIZED |
PIPE_TRANSFER_READ, &transfer[i]);
}
draw_set_mapped_vertex_buffer(draw, i, map, ~0);
}
if (info->indexed) {
const void *map = nv30->idxbuf.user_buffer;
if (!map)
map = pipe_buffer_map(pipe, nv30->idxbuf.buffer,
PIPE_TRANSFER_UNSYNCHRONIZED |
PIPE_TRANSFER_READ, &transferi);
draw_set_indexes(draw,
(ubyte *) map + nv30->idxbuf.offset,
nv30->idxbuf.index_size, ~0);
} else {
draw_set_indexes(draw, NULL, 0, 0);
}
draw_vbo(draw, info);
draw_flush(draw);
if (info->indexed && transferi)
pipe_buffer_unmap(pipe, transferi);
for (i = 0; i < nv30->num_vtxbufs; i++)
if (transfer[i])
pipe_buffer_unmap(pipe, transfer[i]);
nv30->draw_dirty = 0;
nv30_state_release(nv30);
}
/* SW TCL elements, using Draw. */
static void r300_swtcl_draw_vbo(struct pipe_context* pipe,
const struct pipe_draw_info *info)
{
struct r300_context* r300 = r300_context(pipe);
struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
struct pipe_transfer *ib_transfer = NULL;
unsigned count = info->count;
int i;
void *indices = NULL;
boolean indexed = info->indexed && r300->index_buffer.buffer;
if (r300->skip_rendering) {
return;
}
if (!u_trim_pipe_prim(info->mode, &count)) {
return;
}
r300_update_derived_state(r300);
r300_reserve_cs_dwords(r300,
PREP_FIRST_DRAW | PREP_EMIT_AOS_SWTCL |
(indexed ? PREP_INDEXED : 0),
indexed ? 256 : 6);
for (i = 0; i < r300->vertex_buffer_count; i++) {
if (r300->vertex_buffer[i].buffer) {
void *buf = pipe_buffer_map(pipe,
r300->vertex_buffer[i].buffer,
PIPE_TRANSFER_READ,
&vb_transfer[i]);
draw_set_mapped_vertex_buffer(r300->draw, i, buf);
}
}
if (indexed) {
indices = pipe_buffer_map(pipe, r300->index_buffer.buffer,
PIPE_TRANSFER_READ, &ib_transfer);
}
draw_set_mapped_index_buffer(r300->draw, indices);
r300->draw_vbo_locked = TRUE;
r300->draw_first_emitted = FALSE;
draw_vbo(r300->draw, info);
draw_flush(r300->draw);
r300->draw_vbo_locked = FALSE;
for (i = 0; i < r300->vertex_buffer_count; i++) {
if (r300->vertex_buffer[i].buffer) {
pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
vb_transfer[i]);
draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
}
}
if (indexed) {
pipe_buffer_unmap(pipe, r300->index_buffer.buffer, ib_transfer);
draw_set_mapped_index_buffer(r300->draw, NULL);
}
}
void loop(void)
{
const float spd1=30.0f*dt();
const float spd2=15.0f*dt();
float r=0.0f;
float dc=0.0f, ds=0.0f;
float tc=0.0f, ts=0.0f;
/*viewport(0,0,nsw,nsh);*/
use_basic();
send_lpview(pview);
if(mm() || mw()!=0.0f)
{
if(mm())
{
dir+=mx()*spd1;
if(dir<-0.0f)
{
dir+=360.0f;
ndir+=360.0f;
}
else if(dir>360.0f)
{
dir-=360.0f;
ndir-=360.0f;
}
tilt-=my()*spd1;
if(tilt<0.001f) tilt=0.001f;
else if(tilt>100.0f) tilt=100.0f;
}
if(mw()!=0.0f)
{
zoom-=mw();
if(zoom<7.0f) zoom=7.0f;
else if(zoom>12.0f) zoom=12.0f;
}
}
if(mp(3)) zoom=10.0f;
ndir-=(ndir-dir)*spd2;
r=d2r(ndir);
dc=cosf(r);
ds=sinf(r);
ntilt-=(ntilt-tilt)*spd2;
r=d2r(ntilt);
tc=cosf(r);
ts=sinf(r);
nzoom-=(nzoom-zoom)*spd2;
look(view,v3(ds*ts*nzoom,dc*ts*nzoom,3.0f+(tc*nzoom)),v3(0.0f,0.0f,3.0f));
mult(pview,proj,view);
send_pview(pview);
/* ----- */
use_fb(fbos[0]);
clear();
/* ----- */
use_tex(area_tex);
/* ----- */
draw_vbo(&area_mod);
use_fb(0);
blit_fb(fbos[0],fbos[1],nsw,nsh);
/* ----- */
use_fb(fbos[2]);
set_drawbufs(2);
clear();
draw_vbo(&area_mod);
use_fb(0);
use_mblur();
use_tex(texs[0]); /* ----- */
active_tex(GL_TEXTURE1,texs[2]);
default_tex();
use_fb(fbos[3]);
set_drawbufs(1);
clear();
quad();
use_fb(0);
active_tex(GL_TEXTURE1,0);
default_tex();
/*viewport(0,0,sw,sh);*/
use_vig();
use_tex(texs[3]);
clear();
quad();
if(kp(SDL_SCANCODE_DELETE) || kp(SDL_SCANCODE_ESCAPE))
quit();
}
