1586 lines
47 KiB
C++
1586 lines
47 KiB
C++
/*
|
|
** Copyright 2006, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include "context.h"
|
|
#include "fp.h"
|
|
#include "state.h"
|
|
#include "matrix.h"
|
|
#include "vertex.h"
|
|
#include "light.h"
|
|
#include "primitives.h"
|
|
#include "texture.h"
|
|
#include "BufferObjectManager.h"
|
|
#ifdef LIBAGL_USE_GRALLOC_COPYBITS
|
|
#include "copybit.h"
|
|
#endif // LIBAGL_USE_GRALLOC_COPYBITS
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#define VC_CACHE_STATISTICS 0
|
|
#define VC_CACHE_TYPE_NONE 0
|
|
#define VC_CACHE_TYPE_INDEXED 1
|
|
#define VC_CACHE_TYPE_LRU 2
|
|
#define VC_CACHE_TYPE VC_CACHE_TYPE_INDEXED
|
|
|
|
#if VC_CACHE_STATISTICS
|
|
#include <utils/Timers.h>
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
namespace android {
|
|
|
|
static void validate_arrays(ogles_context_t* c, GLenum mode);
|
|
|
|
static void compileElements__generic(ogles_context_t*,
|
|
vertex_t*, GLint, GLsizei);
|
|
static void compileElement__generic(ogles_context_t*,
|
|
vertex_t*, GLint);
|
|
|
|
static void drawPrimitivesPoints(ogles_context_t*, GLint, GLsizei);
|
|
static void drawPrimitivesLineStrip(ogles_context_t*, GLint, GLsizei);
|
|
static void drawPrimitivesLineLoop(ogles_context_t*, GLint, GLsizei);
|
|
static void drawPrimitivesLines(ogles_context_t*, GLint, GLsizei);
|
|
static void drawPrimitivesTriangleStrip(ogles_context_t*, GLint, GLsizei);
|
|
static void drawPrimitivesTriangleFan(ogles_context_t*, GLint, GLsizei);
|
|
static void drawPrimitivesTriangles(ogles_context_t*, GLint, GLsizei);
|
|
|
|
static void drawIndexedPrimitivesPoints(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
static void drawIndexedPrimitivesLineStrip(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
static void drawIndexedPrimitivesLineLoop(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
static void drawIndexedPrimitivesLines(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
static void drawIndexedPrimitivesTriangleStrip(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
static void drawIndexedPrimitivesTriangleFan(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
static void drawIndexedPrimitivesTriangles(ogles_context_t*,
|
|
GLsizei, const GLvoid*);
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
typedef void (*arrays_prims_fct_t)(ogles_context_t*, GLint, GLsizei);
|
|
static const arrays_prims_fct_t drawArraysPrims[] = {
|
|
drawPrimitivesPoints,
|
|
drawPrimitivesLines,
|
|
drawPrimitivesLineLoop,
|
|
drawPrimitivesLineStrip,
|
|
drawPrimitivesTriangles,
|
|
drawPrimitivesTriangleStrip,
|
|
drawPrimitivesTriangleFan
|
|
};
|
|
|
|
typedef void (*elements_prims_fct_t)(ogles_context_t*, GLsizei, const GLvoid*);
|
|
static const elements_prims_fct_t drawElementsPrims[] = {
|
|
drawIndexedPrimitivesPoints,
|
|
drawIndexedPrimitivesLines,
|
|
drawIndexedPrimitivesLineLoop,
|
|
drawIndexedPrimitivesLineStrip,
|
|
drawIndexedPrimitivesTriangles,
|
|
drawIndexedPrimitivesTriangleStrip,
|
|
drawIndexedPrimitivesTriangleFan
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
void ogles_init_array(ogles_context_t* c)
|
|
{
|
|
c->arrays.vertex.size = 4;
|
|
c->arrays.vertex.type = GL_FLOAT;
|
|
c->arrays.color.size = 4;
|
|
c->arrays.color.type = GL_FLOAT;
|
|
c->arrays.normal.size = 4;
|
|
c->arrays.normal.type = GL_FLOAT;
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
c->arrays.texture[i].size = 4;
|
|
c->arrays.texture[i].type = GL_FLOAT;
|
|
}
|
|
c->vc.init();
|
|
|
|
if (!c->vc.vBuffer) {
|
|
// this could have failed
|
|
ogles_error(c, GL_OUT_OF_MEMORY);
|
|
}
|
|
}
|
|
|
|
void ogles_uninit_array(ogles_context_t* c)
|
|
{
|
|
c->vc.uninit();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Array fetchers
|
|
#endif
|
|
|
|
static void currentColor(ogles_context_t* c, GLfixed* v, const GLvoid*) {
|
|
memcpy(v, c->current.color.v, sizeof(vec4_t));
|
|
}
|
|
static void currentColor_clamp(ogles_context_t* c, GLfixed* v, const GLvoid*) {
|
|
memcpy(v, c->currentColorClamped.v, sizeof(vec4_t));
|
|
}
|
|
static void currentNormal(ogles_context_t* c, GLfixed* v, const GLvoid*) {
|
|
memcpy(v, c->currentNormal.v, sizeof(vec3_t));
|
|
}
|
|
static void currentTexCoord(ogles_context_t* c, GLfixed* v, const GLvoid*) {
|
|
memcpy(v, c->current.texture[c->arrays.tmu].v, sizeof(vec4_t));
|
|
}
|
|
|
|
|
|
static void fetchNop(ogles_context_t*, GLfixed*, const GLvoid*) {
|
|
}
|
|
static void fetch2b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
|
|
v[0] = gglIntToFixed(p[0]);
|
|
v[1] = gglIntToFixed(p[1]);
|
|
}
|
|
static void fetch2s(ogles_context_t*, GLfixed* v, const GLshort* p) {
|
|
v[0] = gglIntToFixed(p[0]);
|
|
v[1] = gglIntToFixed(p[1]);
|
|
}
|
|
static void fetch2x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
|
|
memcpy(v, p, 2*sizeof(GLfixed));
|
|
}
|
|
static void fetch2f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
|
|
v[0] = gglFloatToFixed(p[0]);
|
|
v[1] = gglFloatToFixed(p[1]);
|
|
}
|
|
static void fetch3b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
|
|
v[0] = gglIntToFixed(p[0]);
|
|
v[1] = gglIntToFixed(p[1]);
|
|
v[2] = gglIntToFixed(p[2]);
|
|
}
|
|
static void fetch3s(ogles_context_t*, GLfixed* v, const GLshort* p) {
|
|
v[0] = gglIntToFixed(p[0]);
|
|
v[1] = gglIntToFixed(p[1]);
|
|
v[2] = gglIntToFixed(p[2]);
|
|
}
|
|
static void fetch3x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
|
|
memcpy(v, p, 3*sizeof(GLfixed));
|
|
}
|
|
static void fetch3f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
|
|
v[0] = gglFloatToFixed(p[0]);
|
|
v[1] = gglFloatToFixed(p[1]);
|
|
v[2] = gglFloatToFixed(p[2]);
|
|
}
|
|
static void fetch4b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
|
|
v[0] = gglIntToFixed(p[0]);
|
|
v[1] = gglIntToFixed(p[1]);
|
|
v[2] = gglIntToFixed(p[2]);
|
|
v[3] = gglIntToFixed(p[3]);
|
|
}
|
|
static void fetch4s(ogles_context_t*, GLfixed* v, const GLshort* p) {
|
|
v[0] = gglIntToFixed(p[0]);
|
|
v[1] = gglIntToFixed(p[1]);
|
|
v[2] = gglIntToFixed(p[2]);
|
|
v[3] = gglIntToFixed(p[3]);
|
|
}
|
|
static void fetch4x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
|
|
memcpy(v, p, 4*sizeof(GLfixed));
|
|
}
|
|
static void fetch4f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
|
|
v[0] = gglFloatToFixed(p[0]);
|
|
v[1] = gglFloatToFixed(p[1]);
|
|
v[2] = gglFloatToFixed(p[2]);
|
|
v[3] = gglFloatToFixed(p[3]);
|
|
}
|
|
static void fetchExpand4ub(ogles_context_t*, GLfixed* v, const GLubyte* p) {
|
|
v[0] = GGL_UB_TO_X(p[0]);
|
|
v[1] = GGL_UB_TO_X(p[1]);
|
|
v[2] = GGL_UB_TO_X(p[2]);
|
|
v[3] = GGL_UB_TO_X(p[3]);
|
|
}
|
|
static void fetchClamp4x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
|
|
v[0] = gglClampx(p[0]);
|
|
v[1] = gglClampx(p[1]);
|
|
v[2] = gglClampx(p[2]);
|
|
v[3] = gglClampx(p[3]);
|
|
}
|
|
static void fetchClamp4f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
|
|
v[0] = gglClampx(gglFloatToFixed(p[0]));
|
|
v[1] = gglClampx(gglFloatToFixed(p[1]));
|
|
v[2] = gglClampx(gglFloatToFixed(p[2]));
|
|
v[3] = gglClampx(gglFloatToFixed(p[3]));
|
|
}
|
|
static void fetchExpand3ub(ogles_context_t*, GLfixed* v, const GLubyte* p) {
|
|
v[0] = GGL_UB_TO_X(p[0]);
|
|
v[1] = GGL_UB_TO_X(p[1]);
|
|
v[2] = GGL_UB_TO_X(p[2]);
|
|
v[3] = 0x10000;
|
|
}
|
|
static void fetchClamp3x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
|
|
v[0] = gglClampx(p[0]);
|
|
v[1] = gglClampx(p[1]);
|
|
v[2] = gglClampx(p[2]);
|
|
v[3] = 0x10000;
|
|
}
|
|
static void fetchClamp3f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
|
|
v[0] = gglClampx(gglFloatToFixed(p[0]));
|
|
v[1] = gglClampx(gglFloatToFixed(p[1]));
|
|
v[2] = gglClampx(gglFloatToFixed(p[2]));
|
|
v[3] = 0x10000;
|
|
}
|
|
static void fetchExpand3b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
|
|
v[0] = GGL_B_TO_X(p[0]);
|
|
v[1] = GGL_B_TO_X(p[1]);
|
|
v[2] = GGL_B_TO_X(p[2]);
|
|
}
|
|
static void fetchExpand3s(ogles_context_t*, GLfixed* v, const GLshort* p) {
|
|
v[0] = GGL_S_TO_X(p[0]);
|
|
v[1] = GGL_S_TO_X(p[1]);
|
|
v[2] = GGL_S_TO_X(p[2]);
|
|
}
|
|
|
|
typedef array_t::fetcher_t fn_t;
|
|
|
|
static const fn_t color_fct[2][16] = { // size={3,4}, type={ub,f,x}
|
|
{ 0, (fn_t)fetchExpand3ub, 0, 0, 0, 0,
|
|
(fn_t)fetch3f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch3x },
|
|
{ 0, (fn_t)fetchExpand4ub, 0, 0, 0, 0,
|
|
(fn_t)fetch4f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch4x },
|
|
};
|
|
static const fn_t color_clamp_fct[2][16] = { // size={3,4}, type={ub,f,x}
|
|
{ 0, (fn_t)fetchExpand3ub, 0, 0, 0, 0,
|
|
(fn_t)fetchClamp3f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetchClamp3x },
|
|
{ 0, (fn_t)fetchExpand4ub, 0, 0, 0, 0,
|
|
(fn_t)fetchClamp4f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetchClamp4x },
|
|
};
|
|
static const fn_t normal_fct[1][16] = { // size={3}, type={b,s,f,x}
|
|
{ (fn_t)fetchExpand3b, 0,
|
|
(fn_t)fetchExpand3s, 0, 0, 0,
|
|
(fn_t)fetch3f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch3x },
|
|
};
|
|
static const fn_t vertex_fct[3][16] = { // size={2,3,4}, type={b,s,f,x}
|
|
{ (fn_t)fetch2b, 0,
|
|
(fn_t)fetch2s, 0, 0, 0,
|
|
(fn_t)fetch2f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch3x },
|
|
{ (fn_t)fetch3b, 0,
|
|
(fn_t)fetch3s, 0, 0, 0,
|
|
(fn_t)fetch3f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch3x },
|
|
{ (fn_t)fetch4b, 0,
|
|
(fn_t)fetch4s, 0, 0, 0,
|
|
(fn_t)fetch4f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch4x }
|
|
};
|
|
static const fn_t texture_fct[3][16] = { // size={2,3,4}, type={b,s,f,x}
|
|
{ (fn_t)fetch2b, 0,
|
|
(fn_t)fetch2s, 0, 0, 0,
|
|
(fn_t)fetch2f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch2x },
|
|
{ (fn_t)fetch3b, 0,
|
|
(fn_t)fetch3s, 0, 0, 0,
|
|
(fn_t)fetch3f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch3x },
|
|
{ (fn_t)fetch4b, 0,
|
|
(fn_t)fetch4s, 0, 0, 0,
|
|
(fn_t)fetch4f, 0, 0, 0, 0, 0,
|
|
(fn_t)fetch4x }
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark array_t
|
|
#endif
|
|
|
|
void array_t::init(
|
|
GLint size, GLenum type, GLsizei stride,
|
|
const GLvoid *pointer, const buffer_t* bo, GLsizei count)
|
|
{
|
|
if (!stride) {
|
|
stride = size;
|
|
switch (type) {
|
|
case GL_SHORT:
|
|
case GL_UNSIGNED_SHORT:
|
|
stride *= 2;
|
|
break;
|
|
case GL_FLOAT:
|
|
case GL_FIXED:
|
|
stride *= 4;
|
|
break;
|
|
}
|
|
}
|
|
this->size = size;
|
|
this->type = type;
|
|
this->stride = stride;
|
|
this->pointer = pointer;
|
|
this->bo = bo;
|
|
this->bounds = count;
|
|
}
|
|
|
|
inline void array_t::resolve()
|
|
{
|
|
physical_pointer = (bo) ? (bo->data + uintptr_t(pointer)) : pointer;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark vertex_cache_t
|
|
#endif
|
|
|
|
void vertex_cache_t::init()
|
|
{
|
|
// make sure the size of vertex_t allows cache-line alignment
|
|
CTA<(sizeof(vertex_t) & 0x1F) == 0> assertAlignedSize;
|
|
|
|
const int align = 32;
|
|
const size_t s = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
|
|
const size_t size = s*sizeof(vertex_t) + align;
|
|
base = malloc(size);
|
|
if (base) {
|
|
memset(base, 0, size);
|
|
vBuffer = (vertex_t*)((size_t(base) + align - 1) & ~(align-1));
|
|
vCache = vBuffer + VERTEX_BUFFER_SIZE;
|
|
sequence = 0;
|
|
}
|
|
}
|
|
|
|
void vertex_cache_t::uninit()
|
|
{
|
|
free(base);
|
|
base = vBuffer = vCache = 0;
|
|
}
|
|
|
|
void vertex_cache_t::clear()
|
|
{
|
|
#if VC_CACHE_STATISTICS
|
|
startTime = systemTime(SYSTEM_TIME_THREAD);
|
|
total = 0;
|
|
misses = 0;
|
|
#endif
|
|
|
|
#if VC_CACHE_TYPE == VC_CACHE_TYPE_LRU
|
|
vertex_t* v = vBuffer;
|
|
size_t count = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
|
|
do {
|
|
v->mru = 0;
|
|
v++;
|
|
} while (--count);
|
|
#endif
|
|
|
|
sequence += INDEX_SEQ;
|
|
if (sequence >= 0x80000000LU) {
|
|
sequence = INDEX_SEQ;
|
|
vertex_t* v = vBuffer;
|
|
size_t count = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
|
|
do {
|
|
v->index = 0;
|
|
v++;
|
|
} while (--count);
|
|
}
|
|
}
|
|
|
|
void vertex_cache_t::dump_stats(GLenum mode)
|
|
{
|
|
#if VC_CACHE_STATISTICS
|
|
nsecs_t time = systemTime(SYSTEM_TIME_THREAD) - startTime;
|
|
uint32_t hits = total - misses;
|
|
uint32_t prim_count;
|
|
switch (mode) {
|
|
case GL_POINTS: prim_count = total; break;
|
|
case GL_LINE_STRIP: prim_count = total - 1; break;
|
|
case GL_LINE_LOOP: prim_count = total - 1; break;
|
|
case GL_LINES: prim_count = total / 2; break;
|
|
case GL_TRIANGLE_STRIP: prim_count = total - 2; break;
|
|
case GL_TRIANGLE_FAN: prim_count = total - 2; break;
|
|
case GL_TRIANGLES: prim_count = total / 3; break;
|
|
default: return;
|
|
}
|
|
printf( "total=%5u, hits=%5u, miss=%5u, hitrate=%3u%%,"
|
|
" prims=%5u, time=%6u us, prims/s=%d, v/t=%f\n",
|
|
total, hits, misses, (hits*100)/total,
|
|
prim_count, int(ns2us(time)), int(prim_count*float(seconds(1))/time),
|
|
float(misses) / prim_count);
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
static __attribute__((noinline))
|
|
void enableDisableClientState(ogles_context_t* c, GLenum array, bool enable)
|
|
{
|
|
const int tmu = c->arrays.activeTexture;
|
|
array_t* a;
|
|
switch (array) {
|
|
case GL_COLOR_ARRAY: a = &c->arrays.color; break;
|
|
case GL_NORMAL_ARRAY: a = &c->arrays.normal; break;
|
|
case GL_TEXTURE_COORD_ARRAY: a = &c->arrays.texture[tmu]; break;
|
|
case GL_VERTEX_ARRAY: a = &c->arrays.vertex; break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
a->enable = enable ? GL_TRUE : GL_FALSE;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Vertex Cache
|
|
#endif
|
|
|
|
static __attribute__((noinline))
|
|
vertex_t* cache_vertex(ogles_context_t* c, vertex_t* v, uint32_t index)
|
|
{
|
|
#if VC_CACHE_STATISTICS
|
|
c->vc.misses++;
|
|
#endif
|
|
if (ggl_unlikely(v->locked)) {
|
|
// we're just looking for an entry in the cache that is not locked.
|
|
// and we know that there cannot be more than 2 locked entries
|
|
// because a triangle needs at most 3 vertices.
|
|
// We never use the first and second entries because they might be in
|
|
// use by the striper or faner. Any other entry will do as long as
|
|
// it's not locked.
|
|
// We compute directly the index of a "free" entry from the locked
|
|
// state of v[2] and v[3].
|
|
v = c->vc.vBuffer + 2;
|
|
v += v[0].locked | (v[1].locked<<1);
|
|
}
|
|
// note: compileElement clears v->flags
|
|
c->arrays.compileElement(c, v, index);
|
|
v->locked = 1;
|
|
return v;
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
vertex_t* fetch_vertex(ogles_context_t* c, size_t index)
|
|
{
|
|
index |= c->vc.sequence;
|
|
|
|
#if VC_CACHE_TYPE == VC_CACHE_TYPE_INDEXED
|
|
|
|
vertex_t* const v = c->vc.vCache +
|
|
(index & (vertex_cache_t::VERTEX_CACHE_SIZE-1));
|
|
|
|
if (ggl_likely(v->index == index)) {
|
|
v->locked = 1;
|
|
return v;
|
|
}
|
|
return cache_vertex(c, v, index);
|
|
|
|
#elif VC_CACHE_TYPE == VC_CACHE_TYPE_LRU
|
|
|
|
vertex_t* v = c->vc.vCache +
|
|
(index & ((vertex_cache_t::VERTEX_CACHE_SIZE-1)>>1))*2;
|
|
|
|
// always record LRU in v[0]
|
|
if (ggl_likely(v[0].index == index)) {
|
|
v[0].locked = 1;
|
|
v[0].mru = 0;
|
|
return &v[0];
|
|
}
|
|
|
|
if (ggl_likely(v[1].index == index)) {
|
|
v[1].locked = 1;
|
|
v[0].mru = 1;
|
|
return &v[1];
|
|
}
|
|
|
|
const int lru = 1 - v[0].mru;
|
|
v[0].mru = lru;
|
|
return cache_vertex(c, &v[lru], index);
|
|
|
|
#elif VC_CACHE_TYPE == VC_CACHE_TYPE_NONE
|
|
|
|
// just for debugging...
|
|
vertex_t* v = c->vc.vBuffer + 2;
|
|
return cache_vertex(c, v, index);
|
|
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Primitive Assembly
|
|
#endif
|
|
|
|
void drawPrimitivesPoints(ogles_context_t* c, GLint first, GLsizei count)
|
|
{
|
|
if (ggl_unlikely(count < 1))
|
|
return;
|
|
|
|
// vertex cache size must be multiple of 1
|
|
const GLsizei vcs =
|
|
(vertex_cache_t::VERTEX_BUFFER_SIZE +
|
|
vertex_cache_t::VERTEX_CACHE_SIZE);
|
|
do {
|
|
vertex_t* v = c->vc.vBuffer;
|
|
GLsizei num = count > vcs ? vcs : count;
|
|
c->arrays.cull = vertex_t::CLIP_ALL;
|
|
c->arrays.compileElements(c, v, first, num);
|
|
first += num;
|
|
count -= num;
|
|
if (!c->arrays.cull) {
|
|
// quick/trivial reject of the whole batch
|
|
do {
|
|
const uint32_t cc = v[0].flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderPoint(c, v);
|
|
v++;
|
|
num--;
|
|
} while (num);
|
|
}
|
|
} while (count);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void drawPrimitivesLineStrip(ogles_context_t* c, GLint first, GLsizei count)
|
|
{
|
|
if (ggl_unlikely(count < 2))
|
|
return;
|
|
|
|
vertex_t *v, *v0, *v1;
|
|
c->arrays.cull = vertex_t::CLIP_ALL;
|
|
c->arrays.compileElement(c, c->vc.vBuffer, first);
|
|
first += 1;
|
|
count -= 1;
|
|
|
|
// vertex cache size must be multiple of 1
|
|
const GLsizei vcs =
|
|
(vertex_cache_t::VERTEX_BUFFER_SIZE +
|
|
vertex_cache_t::VERTEX_CACHE_SIZE - 1);
|
|
do {
|
|
v0 = c->vc.vBuffer + 0;
|
|
v = c->vc.vBuffer + 1;
|
|
GLsizei num = count > vcs ? vcs : count;
|
|
c->arrays.compileElements(c, v, first, num);
|
|
first += num;
|
|
count -= num;
|
|
if (!c->arrays.cull) {
|
|
// quick/trivial reject of the whole batch
|
|
do {
|
|
v1 = v++;
|
|
const uint32_t cc = v0->flags & v1->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v0, v1);
|
|
v0 = v1;
|
|
num--;
|
|
} while (num);
|
|
}
|
|
// copy back the last processed vertex
|
|
c->vc.vBuffer[0] = *v0;
|
|
c->arrays.cull = v0->flags & vertex_t::CLIP_ALL;
|
|
} while (count);
|
|
}
|
|
|
|
void drawPrimitivesLineLoop(ogles_context_t* c, GLint first, GLsizei count)
|
|
{
|
|
if (ggl_unlikely(count < 2))
|
|
return;
|
|
drawPrimitivesLineStrip(c, first, count);
|
|
if (ggl_likely(count >= 3)) {
|
|
vertex_t* v0 = c->vc.vBuffer;
|
|
vertex_t* v1 = c->vc.vBuffer + 1;
|
|
c->arrays.compileElement(c, v1, first);
|
|
const uint32_t cc = v0->flags & v1->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v0, v1);
|
|
}
|
|
}
|
|
|
|
void drawPrimitivesLines(ogles_context_t* c, GLint first, GLsizei count)
|
|
{
|
|
if (ggl_unlikely(count < 2))
|
|
return;
|
|
|
|
// vertex cache size must be multiple of 2
|
|
const GLsizei vcs =
|
|
((vertex_cache_t::VERTEX_BUFFER_SIZE +
|
|
vertex_cache_t::VERTEX_CACHE_SIZE) / 2) * 2;
|
|
do {
|
|
vertex_t* v = c->vc.vBuffer;
|
|
GLsizei num = count > vcs ? vcs : count;
|
|
c->arrays.cull = vertex_t::CLIP_ALL;
|
|
c->arrays.compileElements(c, v, first, num);
|
|
first += num;
|
|
count -= num;
|
|
if (!c->arrays.cull) {
|
|
// quick/trivial reject of the whole batch
|
|
num -= 2;
|
|
do {
|
|
const uint32_t cc = v[0].flags & v[1].flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v, v+1);
|
|
v += 2;
|
|
num -= 2;
|
|
} while (num >= 0);
|
|
}
|
|
} while (count >= 2);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void drawPrimitivesTriangleFanOrStrip(ogles_context_t* c,
|
|
GLint first, GLsizei count, int winding)
|
|
{
|
|
// winding == 2 : fan
|
|
// winding == 1 : strip
|
|
|
|
if (ggl_unlikely(count < 3))
|
|
return;
|
|
|
|
vertex_t *v, *v0, *v1, *v2;
|
|
c->arrays.cull = vertex_t::CLIP_ALL;
|
|
c->arrays.compileElements(c, c->vc.vBuffer, first, 2);
|
|
first += 2;
|
|
count -= 2;
|
|
|
|
// vertex cache size must be multiple of 2. This is extremely important
|
|
// because it allows us to preserve the same winding when the whole
|
|
// batch is culled. We also need 2 extra vertices in the array, because
|
|
// we always keep the two first ones.
|
|
const GLsizei vcs =
|
|
((vertex_cache_t::VERTEX_BUFFER_SIZE +
|
|
vertex_cache_t::VERTEX_CACHE_SIZE - 2) / 2) * 2;
|
|
do {
|
|
v0 = c->vc.vBuffer + 0;
|
|
v1 = c->vc.vBuffer + 1;
|
|
v = c->vc.vBuffer + 2;
|
|
GLsizei num = count > vcs ? vcs : count;
|
|
c->arrays.compileElements(c, v, first, num);
|
|
first += num;
|
|
count -= num;
|
|
if (!c->arrays.cull) {
|
|
// quick/trivial reject of the whole batch
|
|
do {
|
|
v2 = v++;
|
|
const uint32_t cc = v0->flags & v1->flags & v2->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderTriangle(c, v0, v1, v2);
|
|
swap(((winding^=1) ? v1 : v0), v2);
|
|
num--;
|
|
} while (num);
|
|
}
|
|
if (count) {
|
|
v0 = c->vc.vBuffer + 2 + num - 2;
|
|
v1 = c->vc.vBuffer + 2 + num - 1;
|
|
if ((winding&2) == 0) {
|
|
// for strips copy back the two last compiled vertices
|
|
c->vc.vBuffer[0] = *v0;
|
|
}
|
|
c->vc.vBuffer[1] = *v1;
|
|
c->arrays.cull = v0->flags & v1->flags & vertex_t::CLIP_ALL;
|
|
}
|
|
} while (count > 0);
|
|
}
|
|
|
|
void drawPrimitivesTriangleStrip(ogles_context_t* c,
|
|
GLint first, GLsizei count) {
|
|
drawPrimitivesTriangleFanOrStrip(c, first, count, 1);
|
|
}
|
|
|
|
void drawPrimitivesTriangleFan(ogles_context_t* c,
|
|
GLint first, GLsizei count) {
|
|
#ifdef LIBAGL_USE_GRALLOC_COPYBITS
|
|
if (drawTriangleFanWithCopybit(c, first, count)) {
|
|
return;
|
|
}
|
|
#endif // LIBAGL_USE_GRALLOC_COPYBITS
|
|
|
|
drawPrimitivesTriangleFanOrStrip(c, first, count, 2);
|
|
}
|
|
|
|
void drawPrimitivesTriangles(ogles_context_t* c, GLint first, GLsizei count)
|
|
{
|
|
if (ggl_unlikely(count < 3))
|
|
return;
|
|
|
|
// vertex cache size must be multiple of 3
|
|
const GLsizei vcs =
|
|
((vertex_cache_t::VERTEX_BUFFER_SIZE +
|
|
vertex_cache_t::VERTEX_CACHE_SIZE) / 3) * 3;
|
|
do {
|
|
vertex_t* v = c->vc.vBuffer;
|
|
GLsizei num = count > vcs ? vcs : count;
|
|
c->arrays.cull = vertex_t::CLIP_ALL;
|
|
c->arrays.compileElements(c, v, first, num);
|
|
first += num;
|
|
count -= num;
|
|
if (!c->arrays.cull) {
|
|
// quick/trivial reject of the whole batch
|
|
num -= 3;
|
|
do {
|
|
const uint32_t cc = v[0].flags & v[1].flags & v[2].flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderTriangle(c, v, v+1, v+2);
|
|
v += 3;
|
|
num -= 3;
|
|
} while (num >= 0);
|
|
}
|
|
} while (count >= 3);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
// this looks goofy, but gcc does a great job with this...
|
|
static inline unsigned int read_index(int type, const GLvoid*& p) {
|
|
unsigned int r;
|
|
if (type) {
|
|
r = *(const GLubyte*)p;
|
|
p = (const GLubyte*)p + 1;
|
|
} else {
|
|
r = *(const GLushort*)p;
|
|
p = (const GLushort*)p + 1;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void drawIndexedPrimitivesPoints(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices)
|
|
{
|
|
if (ggl_unlikely(count < 1))
|
|
return;
|
|
const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
|
|
do {
|
|
vertex_t * v = fetch_vertex(c, read_index(type, indices));
|
|
if (ggl_likely(!(v->flags & vertex_t::CLIP_ALL)))
|
|
c->prims.renderPoint(c, v);
|
|
v->locked = 0;
|
|
count--;
|
|
} while(count);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void drawIndexedPrimitivesLineStrip(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices)
|
|
{
|
|
if (ggl_unlikely(count < 2))
|
|
return;
|
|
|
|
vertex_t * const v = c->vc.vBuffer;
|
|
vertex_t* v0 = v;
|
|
vertex_t* v1;
|
|
|
|
const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
|
|
c->arrays.compileElement(c, v0, read_index(type, indices));
|
|
count -= 1;
|
|
do {
|
|
v1 = fetch_vertex(c, read_index(type, indices));
|
|
const uint32_t cc = v0->flags & v1->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v0, v1);
|
|
v0->locked = 0;
|
|
v0 = v1;
|
|
count--;
|
|
} while (count);
|
|
v1->locked = 0;
|
|
}
|
|
|
|
void drawIndexedPrimitivesLineLoop(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices)
|
|
{
|
|
if (ggl_unlikely(count <= 2)) {
|
|
drawIndexedPrimitivesLines(c, count, indices);
|
|
return;
|
|
}
|
|
|
|
vertex_t * const v = c->vc.vBuffer;
|
|
vertex_t* v0 = v;
|
|
vertex_t* v1;
|
|
|
|
const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
|
|
c->arrays.compileElement(c, v0, read_index(type, indices));
|
|
count -= 1;
|
|
do {
|
|
v1 = fetch_vertex(c, read_index(type, indices));
|
|
const uint32_t cc = v0->flags & v1->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v0, v1);
|
|
v0->locked = 0;
|
|
v0 = v1;
|
|
count--;
|
|
} while (count);
|
|
v1->locked = 0;
|
|
|
|
v1 = c->vc.vBuffer;
|
|
const uint32_t cc = v0->flags & v1->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v0, v1);
|
|
}
|
|
|
|
void drawIndexedPrimitivesLines(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices)
|
|
{
|
|
if (ggl_unlikely(count < 2))
|
|
return;
|
|
|
|
count -= 2;
|
|
const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
|
|
do {
|
|
vertex_t* const v0 = fetch_vertex(c, read_index(type, indices));
|
|
vertex_t* const v1 = fetch_vertex(c, read_index(type, indices));
|
|
const uint32_t cc = v0->flags & v1->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderLine(c, v0, v1);
|
|
v0->locked = 0;
|
|
v1->locked = 0;
|
|
count -= 2;
|
|
} while (count >= 0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void drawIndexedPrimitivesTriangleFanOrStrip(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices, int winding)
|
|
{
|
|
// winding == 2 : fan
|
|
// winding == 1 : strip
|
|
|
|
if (ggl_unlikely(count < 3))
|
|
return;
|
|
|
|
vertex_t * const v = c->vc.vBuffer;
|
|
vertex_t* v0 = v;
|
|
vertex_t* v1 = v+1;
|
|
vertex_t* v2;
|
|
|
|
const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
|
|
c->arrays.compileElement(c, v0, read_index(type, indices));
|
|
c->arrays.compileElement(c, v1, read_index(type, indices));
|
|
count -= 2;
|
|
|
|
// note: GCC 4.1.1 here makes a prety interesting optimization
|
|
// where it duplicates the loop below based on c->arrays.indicesType
|
|
|
|
do {
|
|
v2 = fetch_vertex(c, read_index(type, indices));
|
|
const uint32_t cc = v0->flags & v1->flags & v2->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderTriangle(c, v0, v1, v2);
|
|
vertex_t* & consumed = ((winding^=1) ? v1 : v0);
|
|
consumed->locked = 0;
|
|
consumed = v2;
|
|
count--;
|
|
} while (count);
|
|
v0->locked = v1->locked = 0;
|
|
v2->locked = 0;
|
|
}
|
|
|
|
void drawIndexedPrimitivesTriangleStrip(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices) {
|
|
drawIndexedPrimitivesTriangleFanOrStrip(c, count, indices, 1);
|
|
}
|
|
|
|
void drawIndexedPrimitivesTriangleFan(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices) {
|
|
drawIndexedPrimitivesTriangleFanOrStrip(c, count, indices, 2);
|
|
}
|
|
|
|
void drawIndexedPrimitivesTriangles(ogles_context_t* c,
|
|
GLsizei count, const GLvoid *indices)
|
|
{
|
|
if (ggl_unlikely(count < 3))
|
|
return;
|
|
|
|
count -= 3;
|
|
if (ggl_likely(c->arrays.indicesType == GL_UNSIGNED_SHORT)) {
|
|
// This case is probably our most common case...
|
|
uint16_t const * p = (uint16_t const *)indices;
|
|
do {
|
|
vertex_t* const v0 = fetch_vertex(c, *p++);
|
|
vertex_t* const v1 = fetch_vertex(c, *p++);
|
|
vertex_t* const v2 = fetch_vertex(c, *p++);
|
|
const uint32_t cc = v0->flags & v1->flags & v2->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderTriangle(c, v0, v1, v2);
|
|
v0->locked = 0;
|
|
v1->locked = 0;
|
|
v2->locked = 0;
|
|
count -= 3;
|
|
} while (count >= 0);
|
|
} else {
|
|
uint8_t const * p = (uint8_t const *)indices;
|
|
do {
|
|
vertex_t* const v0 = fetch_vertex(c, *p++);
|
|
vertex_t* const v1 = fetch_vertex(c, *p++);
|
|
vertex_t* const v2 = fetch_vertex(c, *p++);
|
|
const uint32_t cc = v0->flags & v1->flags & v2->flags;
|
|
if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
|
|
c->prims.renderTriangle(c, v0, v1, v2);
|
|
v0->locked = 0;
|
|
v1->locked = 0;
|
|
v2->locked = 0;
|
|
count -= 3;
|
|
} while (count >= 0);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Array compilers
|
|
#endif
|
|
|
|
void compileElement__generic(ogles_context_t* c,
|
|
vertex_t* v, GLint first)
|
|
{
|
|
v->flags = 0;
|
|
v->index = first;
|
|
first &= vertex_cache_t::INDEX_MASK;
|
|
const GLubyte* vp = c->arrays.vertex.element(first);
|
|
v->obj.z = 0;
|
|
v->obj.w = 0x10000;
|
|
c->arrays.vertex.fetch(c, v->obj.v, vp);
|
|
c->arrays.mvp_transform(&c->transforms.mvp, &v->clip, &v->obj);
|
|
c->arrays.perspective(c, v);
|
|
}
|
|
|
|
void compileElements__generic(ogles_context_t* c,
|
|
vertex_t* v, GLint first, GLsizei count)
|
|
{
|
|
const GLubyte* vp = c->arrays.vertex.element(
|
|
first & vertex_cache_t::INDEX_MASK);
|
|
const size_t stride = c->arrays.vertex.stride;
|
|
transform_t const* const mvp = &c->transforms.mvp;
|
|
do {
|
|
v->flags = 0;
|
|
v->index = first++;
|
|
v->obj.z = 0;
|
|
v->obj.w = 0x10000;
|
|
c->arrays.vertex.fetch(c, v->obj.v, vp);
|
|
c->arrays.mvp_transform(mvp, &v->clip, &v->obj);
|
|
c->arrays.perspective(c, v);
|
|
vp += stride;
|
|
v++;
|
|
} while (--count);
|
|
}
|
|
|
|
/*
|
|
void compileElements__3x_full(ogles_context_t* c,
|
|
vertex_t* v, GLint first, GLsizei count)
|
|
{
|
|
const GLfixed* vp = (const GLfixed*)c->arrays.vertex.element(first);
|
|
const size_t stride = c->arrays.vertex.stride / 4;
|
|
// const GLfixed* const& m = c->transforms.mvp.matrix.m;
|
|
|
|
GLfixed m[16];
|
|
memcpy(&m, c->transforms.mvp.matrix.m, sizeof(m));
|
|
|
|
do {
|
|
const GLfixed rx = vp[0];
|
|
const GLfixed ry = vp[1];
|
|
const GLfixed rz = vp[2];
|
|
vp += stride;
|
|
v->index = first++;
|
|
v->clip.x = mla3a(rx, m[ 0], ry, m[ 4], rz, m[ 8], m[12]);
|
|
v->clip.y = mla3a(rx, m[ 1], ry, m[ 5], rz, m[ 9], m[13]);
|
|
v->clip.z = mla3a(rx, m[ 2], ry, m[ 6], rz, m[10], m[14]);
|
|
v->clip.w = mla3a(rx, m[ 3], ry, m[ 7], rz, m[11], m[15]);
|
|
|
|
const GLfixed w = v->clip.w;
|
|
uint32_t clip = 0;
|
|
if (v->clip.x < -w) clip |= vertex_t::CLIP_L;
|
|
if (v->clip.x > w) clip |= vertex_t::CLIP_R;
|
|
if (v->clip.y < -w) clip |= vertex_t::CLIP_B;
|
|
if (v->clip.y > w) clip |= vertex_t::CLIP_T;
|
|
if (v->clip.z < -w) clip |= vertex_t::CLIP_N;
|
|
if (v->clip.z > w) clip |= vertex_t::CLIP_F;
|
|
v->flags = clip;
|
|
c->arrays.cull &= clip;
|
|
|
|
//c->arrays.perspective(c, v);
|
|
v++;
|
|
} while (--count);
|
|
}
|
|
*/
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark clippers
|
|
#endif
|
|
|
|
static void clipVec4(vec4_t& nv,
|
|
GLfixed t, const vec4_t& s, const vec4_t& p)
|
|
{
|
|
for (int i=0; i<4 ; i++)
|
|
nv.v[i] = gglMulAddx(t, s.v[i] - p.v[i], p.v[i], 28);
|
|
}
|
|
|
|
static void clipVertex(ogles_context_t* c, vertex_t* nv,
|
|
GLfixed t, const vertex_t* s, const vertex_t* p)
|
|
{
|
|
clipVec4(nv->clip, t, s->clip, p->clip);
|
|
nv->fog = gglMulAddx(t, s->fog - p->fog, p->fog, 28);
|
|
ogles_vertex_project(c, nv);
|
|
nv->flags |= vertex_t::LIT | vertex_t::EYE | vertex_t::TT;
|
|
nv->flags &= ~vertex_t::CLIP_ALL;
|
|
}
|
|
|
|
static void clipVertexC(ogles_context_t* c, vertex_t* nv,
|
|
GLfixed t, const vertex_t* s, const vertex_t* p)
|
|
{
|
|
clipVec4(nv->color, t, s->color, p->color);
|
|
clipVertex(c, nv, t, s, p);
|
|
}
|
|
|
|
static void clipVertexT(ogles_context_t* c, vertex_t* nv,
|
|
GLfixed t, const vertex_t* s, const vertex_t* p)
|
|
{
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (c->rasterizer.state.texture[i].enable)
|
|
clipVec4(nv->texture[i], t, s->texture[i], p->texture[i]);
|
|
}
|
|
clipVertex(c, nv, t, s, p);
|
|
}
|
|
|
|
static void clipVertexAll(ogles_context_t* c, vertex_t* nv,
|
|
GLfixed t, const vertex_t* s, const vertex_t* p)
|
|
{
|
|
clipVec4(nv->color, t, s->color, p->color);
|
|
clipVertexT(c, nv, t, s, p);
|
|
}
|
|
|
|
static void clipEye(ogles_context_t* c, vertex_t* nv,
|
|
GLfixed t, const vertex_t* s, const vertex_t* p)
|
|
{
|
|
nv->clear();
|
|
c->arrays.clipVertex(c, nv, t, p, s);
|
|
clipVec4(nv->eye, t, s->eye, p->eye);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
void validate_arrays(ogles_context_t* c, GLenum mode)
|
|
{
|
|
uint32_t enables = c->rasterizer.state.enables;
|
|
|
|
// Perspective correction is not need if Ortho transform, but
|
|
// the user can still provide the w coordinate manually, so we can't
|
|
// automatically turn it off (in fact we could when the 4th coordinate
|
|
// is not spcified in the vertex array).
|
|
// W interpolation is never needed for points.
|
|
GLboolean perspective =
|
|
c->perspective && mode!=GL_POINTS && (enables & GGL_ENABLE_TMUS);
|
|
c->rasterizer.procs.enableDisable(c, GGL_W_LERP, perspective);
|
|
|
|
// set anti-aliasing
|
|
GLboolean smooth = GL_FALSE;
|
|
switch (mode) {
|
|
case GL_POINTS:
|
|
smooth = c->point.smooth;
|
|
break;
|
|
case GL_LINES:
|
|
case GL_LINE_LOOP:
|
|
case GL_LINE_STRIP:
|
|
smooth = c->line.smooth;
|
|
break;
|
|
}
|
|
if (((enables & GGL_ENABLE_AA)?1:0) != smooth)
|
|
c->rasterizer.procs.enableDisable(c, GGL_AA, smooth);
|
|
|
|
// set the shade model for this primitive
|
|
c->rasterizer.procs.shadeModel(c,
|
|
(mode == GL_POINTS) ? GL_FLAT : c->lighting.shadeModel);
|
|
|
|
// compute all the matrices we'll need...
|
|
uint32_t want =
|
|
transform_state_t::MVP |
|
|
transform_state_t::VIEWPORT;
|
|
if (c->lighting.enable) { // needs normal transforms and eye coords
|
|
want |= transform_state_t::MVUI;
|
|
want |= transform_state_t::MODELVIEW;
|
|
}
|
|
if (enables & GGL_ENABLE_TMUS) { // needs texture transforms
|
|
want |= transform_state_t::TEXTURE;
|
|
}
|
|
if (c->clipPlanes.enable || (enables & GGL_ENABLE_FOG)) {
|
|
want |= transform_state_t::MODELVIEW; // needs eye coords
|
|
}
|
|
ogles_validate_transform(c, want);
|
|
|
|
// textures...
|
|
if (enables & GGL_ENABLE_TMUS)
|
|
ogles_validate_texture(c);
|
|
|
|
// vertex compilers
|
|
c->arrays.compileElement = compileElement__generic;
|
|
c->arrays.compileElements = compileElements__generic;
|
|
|
|
// vertex transform
|
|
c->arrays.mvp_transform =
|
|
c->transforms.mvp.pointv[c->arrays.vertex.size - 2];
|
|
|
|
c->arrays.mv_transform =
|
|
c->transforms.modelview.transform.pointv[c->arrays.vertex.size - 2];
|
|
|
|
/*
|
|
* ***********************************************************************
|
|
* pick fetchers
|
|
* ***********************************************************************
|
|
*/
|
|
|
|
array_machine_t& am = c->arrays;
|
|
am.vertex.fetch = fetchNop;
|
|
am.normal.fetch = currentNormal;
|
|
am.color.fetch = currentColor;
|
|
|
|
if (am.vertex.enable) {
|
|
am.vertex.resolve();
|
|
if (am.vertex.bo || am.vertex.pointer) {
|
|
am.vertex.fetch = vertex_fct[am.vertex.size-2][am.vertex.type & 0xF];
|
|
}
|
|
}
|
|
|
|
if (am.normal.enable) {
|
|
am.normal.resolve();
|
|
if (am.normal.bo || am.normal.pointer) {
|
|
am.normal.fetch = normal_fct[am.normal.size-3][am.normal.type & 0xF];
|
|
}
|
|
}
|
|
|
|
if (am.color.enable) {
|
|
am.color.resolve();
|
|
if (c->lighting.enable) {
|
|
if (am.color.bo || am.color.pointer) {
|
|
am.color.fetch = color_fct[am.color.size-3][am.color.type & 0xF];
|
|
}
|
|
} else {
|
|
if (am.color.bo || am.color.pointer) {
|
|
am.color.fetch = color_clamp_fct[am.color.size-3][am.color.type & 0xF];
|
|
}
|
|
}
|
|
}
|
|
|
|
int activeTmuCount = 0;
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
am.texture[i].fetch = currentTexCoord;
|
|
if (c->rasterizer.state.texture[i].enable) {
|
|
|
|
// texture fetchers...
|
|
if (am.texture[i].enable) {
|
|
am.texture[i].resolve();
|
|
if (am.texture[i].bo || am.texture[i].pointer) {
|
|
am.texture[i].fetch = texture_fct[am.texture[i].size-2][am.texture[i].type & 0xF];
|
|
}
|
|
}
|
|
|
|
// texture transform...
|
|
const int index = c->arrays.texture[i].size - 2;
|
|
c->arrays.tex_transform[i] =
|
|
c->transforms.texture[i].transform.pointv[index];
|
|
|
|
am.tmu = i;
|
|
activeTmuCount++;
|
|
}
|
|
}
|
|
|
|
// pick the vertex-clipper
|
|
uint32_t clipper = 0;
|
|
// we must reload 'enables' here
|
|
enables = c->rasterizer.state.enables;
|
|
if (enables & GGL_ENABLE_SMOOTH)
|
|
clipper |= 1; // we need to interpolate colors
|
|
if (enables & GGL_ENABLE_TMUS)
|
|
clipper |= 2; // we need to interpolate textures
|
|
switch (clipper) {
|
|
case 0: c->arrays.clipVertex = clipVertex; break;
|
|
case 1: c->arrays.clipVertex = clipVertexC; break;
|
|
case 2: c->arrays.clipVertex = clipVertexT; break;
|
|
case 3: c->arrays.clipVertex = clipVertexAll; break;
|
|
}
|
|
c->arrays.clipEye = clipEye;
|
|
|
|
// pick the primitive rasterizer
|
|
ogles_validate_primitives(c);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
}; // namespace android
|
|
// ----------------------------------------------------------------------------
|
|
|
|
using namespace android;
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark array API
|
|
#endif
|
|
|
|
void glVertexPointer(
|
|
GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (size<2 || size>4 || stride<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
switch (type) {
|
|
case GL_BYTE:
|
|
case GL_SHORT:
|
|
case GL_FIXED:
|
|
case GL_FLOAT:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->arrays.vertex.init(size, type, stride, pointer, c->arrays.array_buffer, 0);
|
|
}
|
|
|
|
void glColorPointer(
|
|
GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (size!=4 || stride<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
switch (type) {
|
|
case GL_UNSIGNED_BYTE:
|
|
case GL_FIXED:
|
|
case GL_FLOAT:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->arrays.color.init(size, type, stride, pointer, c->arrays.array_buffer, 0);
|
|
}
|
|
|
|
void glNormalPointer(
|
|
GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (stride<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
switch (type) {
|
|
case GL_BYTE:
|
|
case GL_SHORT:
|
|
case GL_FIXED:
|
|
case GL_FLOAT:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->arrays.normal.init(3, type, stride, pointer, c->arrays.array_buffer, 0);
|
|
}
|
|
|
|
void glTexCoordPointer(
|
|
GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (size<2 || size>4 || stride<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
switch (type) {
|
|
case GL_BYTE:
|
|
case GL_SHORT:
|
|
case GL_FIXED:
|
|
case GL_FLOAT:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
const int tmu = c->arrays.activeTexture;
|
|
c->arrays.texture[tmu].init(size, type, stride, pointer,
|
|
c->arrays.array_buffer, 0);
|
|
}
|
|
|
|
|
|
void glEnableClientState(GLenum array) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
enableDisableClientState(c, array, true);
|
|
}
|
|
|
|
void glDisableClientState(GLenum array) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
enableDisableClientState(c, array, false);
|
|
}
|
|
|
|
void glClientActiveTexture(GLenum texture)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (texture<GL_TEXTURE0 || texture>=GL_TEXTURE0+GGL_TEXTURE_UNIT_COUNT) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->arrays.activeTexture = texture - GL_TEXTURE0;
|
|
}
|
|
|
|
void glDrawArrays(GLenum mode, GLint first, GLsizei count)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (count<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
switch (mode) {
|
|
case GL_POINTS:
|
|
case GL_LINE_STRIP:
|
|
case GL_LINE_LOOP:
|
|
case GL_LINES:
|
|
case GL_TRIANGLE_STRIP:
|
|
case GL_TRIANGLE_FAN:
|
|
case GL_TRIANGLES:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
if (count == 0 || !c->arrays.vertex.enable)
|
|
return;
|
|
if ((c->cull.enable) && (c->cull.cullFace == GL_FRONT_AND_BACK))
|
|
return; // all triangles are culled
|
|
|
|
|
|
validate_arrays(c, mode);
|
|
|
|
const uint32_t enables = c->rasterizer.state.enables;
|
|
if (enables & GGL_ENABLE_TMUS)
|
|
ogles_lock_textures(c);
|
|
|
|
drawArraysPrims[mode](c, first, count);
|
|
|
|
if (enables & GGL_ENABLE_TMUS)
|
|
ogles_unlock_textures(c);
|
|
|
|
#if VC_CACHE_STATISTICS
|
|
c->vc.total = count;
|
|
c->vc.dump_stats(mode);
|
|
#endif
|
|
}
|
|
|
|
void glDrawElements(
|
|
GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (count<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
switch (mode) {
|
|
case GL_POINTS:
|
|
case GL_LINE_STRIP:
|
|
case GL_LINE_LOOP:
|
|
case GL_LINES:
|
|
case GL_TRIANGLE_STRIP:
|
|
case GL_TRIANGLE_FAN:
|
|
case GL_TRIANGLES:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
switch (type) {
|
|
case GL_UNSIGNED_BYTE:
|
|
case GL_UNSIGNED_SHORT:
|
|
c->arrays.indicesType = type;
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (count == 0 || !c->arrays.vertex.enable)
|
|
return;
|
|
if ((c->cull.enable) && (c->cull.cullFace == GL_FRONT_AND_BACK))
|
|
return; // all triangles are culled
|
|
|
|
// clear the vertex-cache
|
|
c->vc.clear();
|
|
validate_arrays(c, mode);
|
|
|
|
// if indices are in a buffer object, the pointer is treated as an
|
|
// offset in that buffer.
|
|
if (c->arrays.element_array_buffer) {
|
|
indices = c->arrays.element_array_buffer->data + uintptr_t(indices);
|
|
}
|
|
|
|
const uint32_t enables = c->rasterizer.state.enables;
|
|
if (enables & GGL_ENABLE_TMUS)
|
|
ogles_lock_textures(c);
|
|
|
|
drawElementsPrims[mode](c, count, indices);
|
|
|
|
if (enables & GGL_ENABLE_TMUS)
|
|
ogles_unlock_textures(c);
|
|
|
|
|
|
#if VC_CACHE_STATISTICS
|
|
c->vc.total = count;
|
|
c->vc.dump_stats(mode);
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// buffers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glBindBuffer(GLenum target, GLuint buffer)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
// create a buffer object, or bind an existing one
|
|
buffer_t const* bo = 0;
|
|
if (buffer) {
|
|
bo = c->bufferObjectManager->bind(buffer);
|
|
if (!bo) {
|
|
ogles_error(c, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
}
|
|
((target == GL_ARRAY_BUFFER) ?
|
|
c->arrays.array_buffer : c->arrays.element_array_buffer) = bo;
|
|
}
|
|
|
|
void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (size<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if ((usage!=GL_STATIC_DRAW) && (usage!=GL_DYNAMIC_DRAW)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
buffer_t const* bo = ((target == GL_ARRAY_BUFFER) ?
|
|
c->arrays.array_buffer : c->arrays.element_array_buffer);
|
|
|
|
if (bo == 0) {
|
|
// can't modify buffer 0
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
|
|
buffer_t* edit_bo = const_cast<buffer_t*>(bo);
|
|
if (c->bufferObjectManager->allocateStore(edit_bo, size, usage) != 0) {
|
|
ogles_error(c, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
if (data) {
|
|
memcpy(bo->data, data, size);
|
|
}
|
|
}
|
|
|
|
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (offset<0 || size<0 || data==0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
buffer_t const* bo = ((target == GL_ARRAY_BUFFER) ?
|
|
c->arrays.array_buffer : c->arrays.element_array_buffer);
|
|
|
|
if (bo == 0) {
|
|
// can't modify buffer 0
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
if (offset+size > bo->size) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
memcpy(bo->data + offset, data, size);
|
|
}
|
|
|
|
void glDeleteBuffers(GLsizei n, const GLuint* buffers)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (n<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
for (int i=0 ; i<n ; i++) {
|
|
GLuint name = buffers[i];
|
|
if (name) {
|
|
// unbind bound deleted buffers...
|
|
if (c->arrays.element_array_buffer->name == name) {
|
|
c->arrays.element_array_buffer = 0;
|
|
}
|
|
if (c->arrays.array_buffer->name == name) {
|
|
c->arrays.array_buffer = 0;
|
|
}
|
|
if (c->arrays.vertex.bo->name == name) {
|
|
c->arrays.vertex.bo = 0;
|
|
}
|
|
if (c->arrays.normal.bo->name == name) {
|
|
c->arrays.normal.bo = 0;
|
|
}
|
|
if (c->arrays.color.bo->name == name) {
|
|
c->arrays.color.bo = 0;
|
|
}
|
|
for (int t=0 ; t<GGL_TEXTURE_UNIT_COUNT ; t++) {
|
|
if (c->arrays.texture[t].bo->name == name) {
|
|
c->arrays.texture[t].bo = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
c->bufferObjectManager->deleteBuffers(n, buffers);
|
|
c->bufferObjectManager->recycleTokens(n, buffers);
|
|
}
|
|
|
|
void glGenBuffers(GLsizei n, GLuint* buffers)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (n<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
c->bufferObjectManager->getToken(n, buffers);
|
|
}
|