void
batch_draw_elements(GLenum mode, GLsizei count, const unsigned int *indices) {
unsigned int i;
if(count > BATCH_VERTS) {
fprintf(stderr, "count: %d > BATCH_VERTS: %d", count, BATCH_VERTS);
return;
}
if(batch.mode != mode || batch.array.count + count > BATCH_VERTS) {
batch_flush();
batch.mode = mode;
}
for(i = 0; i < count; ++i)
batch.array.vertices[batch.array.count + i]
= TFORMVEC2(batch.tform, batch.vertices[indices[i]]);
if(batch.colors)
for(i = 0; i < count; ++i)
batch.array.colors[batch.array.count + i]
= batch.colors[indices[i]];
else
for(i = 0; i < count; ++i)
batch.array.colors[batch.array.count + i] = batch.color;
if(batch.texcoords)
for(i = 0; i < count; ++i)
batch.array.texcoords[batch.array.count + i]
= batch.texcoords[indices[i]];
batch.array.count += count;
}
void
batch_draw_arrays(GLenum mode, GLint first, GLsizei count) {
unsigned int i;
if(count > BATCH_VERTS) {
fprintf(stderr, "count: %d > BATCH_VERTS: %d", count, BATCH_VERTS);
return;
}
if(batch.mode != mode || batch.array.count + count > BATCH_VERTS) {
batch_flush();
batch.mode = mode;
}
for(i = 0; i < count; ++i)
batch.array.vertices[batch.array.count + i]
= TFORMVEC2(batch.tform, batch.vertices[first + i]);
if(batch.colors)
memcpy(batch.array.colors + batch.array.count,
batch.colors + first,
sizeof(*batch.colors) * count);
else
for(i = 0; i < count; ++i)
batch.array.colors[batch.array.count + i] = batch.color;
if(batch.texcoords)
memcpy(batch.array.texcoords + batch.array.count,
batch.texcoords + first,
sizeof(*batch.texcoords) * count);
batch.array.count += count;
}
void
batch_bind_texture(GLuint texture) {
if(batch.activetex == texture)
return;
batch_flush();
glBindTexture(GL_TEXTURE_2D, texture);
batch.activetex = texture;
}
static int
batch_reserve(struct intel_info *info, int count)
{
int ret = 0;
if (batch_count(info) + count > info->capacity)
ret = batch_flush(info);
return ret;
}
static void intel_blit(struct gralloc_drm_drv_t *drv,
struct gralloc_drm_bo_t *dst,
struct gralloc_drm_bo_t *src,
uint16_t dst_x1, uint16_t dst_y1,
uint16_t dst_x2, uint16_t dst_y2,
uint16_t src_x1, uint16_t src_y1,
uint16_t src_x2, uint16_t src_y2)
{
struct intel_info *info = (struct intel_info *) drv;
struct intel_buffer *dst_ib = (struct intel_buffer *) dst;
struct intel_buffer *src_ib = (struct intel_buffer *) src;
drm_intel_bo *bo_table[3];
uint32_t cmd, br13, dst_pitch, src_pitch;
/*
* XY_SRC_COPY_BLT_CMD does not support scaling,
* rectangle dimensions much match
*/
if (src_x2 - src_x1 != dst_x2 - dst_x1 ||
src_y2 - src_y1 != dst_y2 - dst_y1) {
ALOGE("%s, src and dst rect must match", __func__);
return;
}
if (dst->handle->format != src->handle->format) {
ALOGE("%s, src and dst format must match", __func__);
return;
}
/* nothing to blit */
if (src_x2 <= src_x1 || src_y2 <= src_y1)
return;
/* clamp x2, y2 to surface size */
if (src_x2 > src->handle->width)
src_x2 = src->handle->width;
if (src_y2 > src->handle->height)
src_y2 = src->handle->height;
if (dst_x2 > dst->handle->width)
dst_x2 = dst->handle->width;
if (dst_y2 > dst->handle->height)
dst_y2 = dst->handle->height;
bo_table[0] = info->batch_ibo;
bo_table[1] = src_ib->ibo;
bo_table[2] = dst_ib->ibo;
if (drm_intel_bufmgr_check_aperture_space(bo_table, 3)) {
if (batch_flush(info))
return;
assert(!drm_intel_bufmgr_check_aperture_space(bo_table, 3));
}
cmd = XY_SRC_COPY_BLT_CMD;
br13 = 0xcc << 16; /* ROP_S/GXcopy */
dst_pitch = dst->handle->stride;
src_pitch = src->handle->stride;
/* Blit pitch must be dword-aligned. Otherwise, the hardware appears to
* drop the low bits.
*/
if (src_pitch % 4 != 0 || dst_pitch % 4 != 0) {
ALOGE("%s, src and dst pitch must be dword aligned", __func__);
return;
}
switch (gralloc_drm_get_bpp(dst->handle->format)) {
case 1:
break;
case 2:
br13 |= (1 << 24);
break;
case 4:
br13 |= (1 << 24) | (1 << 25);
cmd |= XY_SRC_COPY_BLT_WRITE_ALPHA | XY_SRC_COPY_BLT_WRITE_RGB;
break;
default:
ALOGE("%s, copy with unsupported format", __func__);
return;
}
if (info->gen >= 40) {
if (dst_ib->tiling != I915_TILING_NONE) {
assert(dst_pitch % 512 == 0);
dst_pitch >>= 2;
cmd |= XY_SRC_COPY_BLT_DST_TILED;
}
if (src_ib->tiling != I915_TILING_NONE) {
assert(src_pitch % 512 == 0);
src_pitch >>= 2;
cmd |= XY_SRC_COPY_BLT_SRC_TILED;
}
/* Gather or scatter the global base array between processes.
* NB: this is a collective operation.
*
* @scatter If true we scatter else we gather
* @global_ary Global base array
*/
static void comm_gather_scatter(int scatter, bh_base *global_ary)
{
bh_error err;
bh_base *local_ary = array_get_local(global_ary);
bh_intp totalsize = global_ary->nelem;
if(totalsize <= 0)
return;
//Find the local size for all processes
int sendcnts[pgrid_worldsize], displs[pgrid_worldsize];
{
bh_intp s = totalsize / pgrid_worldsize;//local size for all but the last process
s *= bh_type_size(global_ary->type);
for(int i=0; i<pgrid_worldsize; ++i)
{
sendcnts[i] = s;
displs[i] = s * i;
}
//The last process gets the rest
sendcnts[pgrid_worldsize-1] += totalsize % pgrid_worldsize * bh_type_size(global_ary->type);
}
int e;
if(scatter)
{
//The slave-processes may need to allocate memory
if(sendcnts[pgrid_myrank] > 0 && local_ary->data == NULL)
{
if((err = bh_data_malloc(local_ary)) != BH_SUCCESS)
EXCEPT_OUT_OF_MEMORY();
}
//The master-process MUST have allocated memory already
assert(pgrid_myrank != 0 || global_ary->data != NULL);
//Scatter from master to slaves
e = MPI_Scatterv(global_ary->data, sendcnts, displs, MPI_BYTE,
local_ary->data, sendcnts[pgrid_myrank], MPI_BYTE,
0, MPI_COMM_WORLD);
}
else
{
//Lets make sure that the 'local_ary' is updated
batch_schedule_inst_on_base(BH_SYNC, local_ary);
batch_flush();
//The master-processes may need to allocate memory
if(pgrid_myrank == 0 && global_ary->data == NULL)
{
if((err = bh_data_malloc(global_ary)) != BH_SUCCESS)
EXCEPT_OUT_OF_MEMORY();
}
//We will always allocate the local array when gathering because
//only the last process knows if the array has been initiated.
if((err = bh_data_malloc(local_ary)) != BH_SUCCESS)
EXCEPT_OUT_OF_MEMORY();
assert(sendcnts[pgrid_myrank] == 0 || local_ary->data != NULL);
//Gather from the slaves to the master
e = MPI_Gatherv(local_ary->data, sendcnts[pgrid_myrank], MPI_BYTE,
global_ary->data, sendcnts, displs, MPI_BYTE,
0, MPI_COMM_WORLD);
}
if(e != MPI_SUCCESS)
EXCEPT_MPI(e);
}
/* Gather the global base array data at the master processes.
* NB: this is a collective operation.
*
* @global_ary Global base array
*/
void comm_slaves2master(bh_base *global_ary)
{
batch_flush();
comm_gather_scatter(0, global_ary);
}
/* Distribute the global base array data to all slave processes.
* The master-process MUST have allocated the @global_ary data.
* NB: this is a collective operation.
*
* @global_ary Global base array
*/
void comm_master2slaves(bh_base *global_ary)
{
batch_flush();
comm_gather_scatter(1, global_ary);
}
void
endscene(void) {
batch_flush();
glFlush();
SDL_GL_SwapBuffers();
}
