1657 lines
51 KiB
C++
1657 lines
51 KiB
C++
/* libs/opengles/texture.cpp
|
|
**
|
|
** 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "context.h"
|
|
#include "fp.h"
|
|
#include "state.h"
|
|
#include "texture.h"
|
|
#include "TextureObjectManager.h"
|
|
|
|
#include <ETC1/etc1.h>
|
|
|
|
namespace android {
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void bindTextureTmu(
|
|
ogles_context_t* c, int tmu, GLuint texture, const sp<EGLTextureObject>& tex);
|
|
|
|
static __attribute__((noinline))
|
|
void generateMipmap(ogles_context_t* c, GLint level);
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Init
|
|
#endif
|
|
|
|
void ogles_init_texture(ogles_context_t* c)
|
|
{
|
|
c->textures.packAlignment = 4;
|
|
c->textures.unpackAlignment = 4;
|
|
|
|
// each context has a default named (0) texture (not shared)
|
|
c->textures.defaultTexture = new EGLTextureObject();
|
|
c->textures.defaultTexture->incStrong(c);
|
|
|
|
// bind the default texture to each texture unit
|
|
for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
bindTextureTmu(c, i, 0, c->textures.defaultTexture);
|
|
memset(c->current.texture[i].v, 0, sizeof(vec4_t));
|
|
c->current.texture[i].Q = 0x10000;
|
|
}
|
|
}
|
|
|
|
void ogles_uninit_texture(ogles_context_t* c)
|
|
{
|
|
if (c->textures.ggl)
|
|
gglUninit(c->textures.ggl);
|
|
c->textures.defaultTexture->decStrong(c);
|
|
for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (c->textures.tmu[i].texture)
|
|
c->textures.tmu[i].texture->decStrong(c);
|
|
}
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
void validate_tmu(ogles_context_t* c, int i)
|
|
{
|
|
texture_unit_t& u(c->textures.tmu[i]);
|
|
if (u.dirty) {
|
|
u.dirty = 0;
|
|
c->rasterizer.procs.activeTexture(c, i);
|
|
c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
|
|
c->rasterizer.procs.texGeni(c, GGL_S,
|
|
GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
|
|
c->rasterizer.procs.texGeni(c, GGL_T,
|
|
GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
|
|
c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
|
|
GGL_TEXTURE_WRAP_S, u.texture->wraps);
|
|
c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
|
|
GGL_TEXTURE_WRAP_T, u.texture->wrapt);
|
|
c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
|
|
GGL_TEXTURE_MIN_FILTER, u.texture->min_filter);
|
|
c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
|
|
GGL_TEXTURE_MAG_FILTER, u.texture->mag_filter);
|
|
|
|
// disable this texture unit if it's not complete
|
|
if (!u.texture->isComplete()) {
|
|
c->rasterizer.procs.disable(c, GGL_TEXTURE_2D);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ogles_validate_texture(ogles_context_t* c)
|
|
{
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (c->rasterizer.state.texture[i].enable)
|
|
validate_tmu(c, i);
|
|
}
|
|
c->rasterizer.procs.activeTexture(c, c->textures.active);
|
|
}
|
|
|
|
static
|
|
void invalidate_texture(ogles_context_t* c, int tmu, uint8_t flags = 0xFF) {
|
|
c->textures.tmu[tmu].dirty = flags;
|
|
}
|
|
|
|
/*
|
|
* If the active textures are EGLImage, they need to be locked before
|
|
* they can be used.
|
|
*
|
|
* FIXME: code below is far from being optimal
|
|
*
|
|
*/
|
|
|
|
void ogles_lock_textures(ogles_context_t* c)
|
|
{
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (c->rasterizer.state.texture[i].enable) {
|
|
texture_unit_t& u(c->textures.tmu[i]);
|
|
ANativeWindowBuffer* native_buffer = u.texture->buffer;
|
|
if (native_buffer) {
|
|
c->rasterizer.procs.activeTexture(c, i);
|
|
hw_module_t const* pModule;
|
|
if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &pModule))
|
|
continue;
|
|
|
|
gralloc_module_t const* module =
|
|
reinterpret_cast<gralloc_module_t const*>(pModule);
|
|
|
|
void* vaddr;
|
|
int err = module->lock(module, native_buffer->handle,
|
|
GRALLOC_USAGE_SW_READ_OFTEN,
|
|
0, 0, native_buffer->width, native_buffer->height,
|
|
&vaddr);
|
|
|
|
u.texture->setImageBits(vaddr);
|
|
c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ogles_unlock_textures(ogles_context_t* c)
|
|
{
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (c->rasterizer.state.texture[i].enable) {
|
|
texture_unit_t& u(c->textures.tmu[i]);
|
|
ANativeWindowBuffer* native_buffer = u.texture->buffer;
|
|
if (native_buffer) {
|
|
c->rasterizer.procs.activeTexture(c, i);
|
|
hw_module_t const* pModule;
|
|
if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &pModule))
|
|
continue;
|
|
|
|
gralloc_module_t const* module =
|
|
reinterpret_cast<gralloc_module_t const*>(pModule);
|
|
|
|
module->unlock(module, native_buffer->handle);
|
|
u.texture->setImageBits(NULL);
|
|
c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
|
|
}
|
|
}
|
|
}
|
|
c->rasterizer.procs.activeTexture(c, c->textures.active);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Format conversion
|
|
#endif
|
|
|
|
static uint32_t gl2format_table[6][4] = {
|
|
// BYTE, 565, 4444, 5551
|
|
{ GGL_PIXEL_FORMAT_A_8,
|
|
0, 0, 0 }, // GL_ALPHA
|
|
{ GGL_PIXEL_FORMAT_RGB_888,
|
|
GGL_PIXEL_FORMAT_RGB_565,
|
|
0, 0 }, // GL_RGB
|
|
{ GGL_PIXEL_FORMAT_RGBA_8888,
|
|
0,
|
|
GGL_PIXEL_FORMAT_RGBA_4444,
|
|
GGL_PIXEL_FORMAT_RGBA_5551 }, // GL_RGBA
|
|
{ GGL_PIXEL_FORMAT_L_8,
|
|
0, 0, 0 }, // GL_LUMINANCE
|
|
{ GGL_PIXEL_FORMAT_LA_88,
|
|
0, 0, 0 }, // GL_LUMINANCE_ALPHA
|
|
};
|
|
|
|
static int32_t convertGLPixelFormat(GLint format, GLenum type)
|
|
{
|
|
int32_t fi = -1;
|
|
int32_t ti = -1;
|
|
switch (format) {
|
|
case GL_ALPHA: fi = 0; break;
|
|
case GL_RGB: fi = 1; break;
|
|
case GL_RGBA: fi = 2; break;
|
|
case GL_LUMINANCE: fi = 3; break;
|
|
case GL_LUMINANCE_ALPHA: fi = 4; break;
|
|
}
|
|
switch (type) {
|
|
case GL_UNSIGNED_BYTE: ti = 0; break;
|
|
case GL_UNSIGNED_SHORT_5_6_5: ti = 1; break;
|
|
case GL_UNSIGNED_SHORT_4_4_4_4: ti = 2; break;
|
|
case GL_UNSIGNED_SHORT_5_5_5_1: ti = 3; break;
|
|
}
|
|
if (fi==-1 || ti==-1)
|
|
return 0;
|
|
return gl2format_table[fi][ti];
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static GLenum validFormatType(ogles_context_t* c, GLenum format, GLenum type)
|
|
{
|
|
GLenum error = 0;
|
|
if (format<GL_ALPHA || format>GL_LUMINANCE_ALPHA) {
|
|
error = GL_INVALID_ENUM;
|
|
}
|
|
if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 &&
|
|
type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_SHORT_5_6_5) {
|
|
error = GL_INVALID_ENUM;
|
|
}
|
|
if (type == GL_UNSIGNED_SHORT_5_6_5 && format != GL_RGB) {
|
|
error = GL_INVALID_OPERATION;
|
|
}
|
|
if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
|
|
type == GL_UNSIGNED_SHORT_5_5_5_1) && format != GL_RGBA) {
|
|
error = GL_INVALID_OPERATION;
|
|
}
|
|
if (error) {
|
|
ogles_error(c, error);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
GGLContext* getRasterizer(ogles_context_t* c)
|
|
{
|
|
GGLContext* ggl = c->textures.ggl;
|
|
if (ggl_unlikely(!ggl)) {
|
|
// this is quite heavy the first time...
|
|
gglInit(&ggl);
|
|
if (!ggl) {
|
|
return 0;
|
|
}
|
|
GGLfixed colors[4] = { 0, 0, 0, 0x10000 };
|
|
c->textures.ggl = ggl;
|
|
ggl->activeTexture(ggl, 0);
|
|
ggl->enable(ggl, GGL_TEXTURE_2D);
|
|
ggl->texEnvi(ggl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE);
|
|
ggl->disable(ggl, GGL_DITHER);
|
|
ggl->shadeModel(ggl, GGL_FLAT);
|
|
ggl->color4xv(ggl, colors);
|
|
}
|
|
return ggl;
|
|
}
|
|
|
|
static __attribute__((noinline))
|
|
int copyPixels(
|
|
ogles_context_t* c,
|
|
const GGLSurface& dst,
|
|
GLint xoffset, GLint yoffset,
|
|
const GGLSurface& src,
|
|
GLint x, GLint y, GLsizei w, GLsizei h)
|
|
{
|
|
if ((dst.format == src.format) &&
|
|
(dst.stride == src.stride) &&
|
|
(dst.width == src.width) &&
|
|
(dst.height == src.height) &&
|
|
(dst.stride > 0) &&
|
|
((x|y) == 0) &&
|
|
((xoffset|yoffset) == 0))
|
|
{
|
|
// this is a common case...
|
|
const GGLFormat& pixelFormat(c->rasterizer.formats[src.format]);
|
|
const size_t size = src.height * src.stride * pixelFormat.size;
|
|
memcpy(dst.data, src.data, size);
|
|
return 0;
|
|
}
|
|
|
|
// use pixel-flinger to handle all the conversions
|
|
GGLContext* ggl = getRasterizer(c);
|
|
if (!ggl) {
|
|
// the only reason this would fail is because we ran out of memory
|
|
return GL_OUT_OF_MEMORY;
|
|
}
|
|
|
|
ggl->colorBuffer(ggl, &dst);
|
|
ggl->bindTexture(ggl, &src);
|
|
ggl->texCoord2i(ggl, x-xoffset, y-yoffset);
|
|
ggl->recti(ggl, xoffset, yoffset, xoffset+w, yoffset+h);
|
|
return 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static __attribute__((noinline))
|
|
sp<EGLTextureObject> getAndBindActiveTextureObject(ogles_context_t* c)
|
|
{
|
|
sp<EGLTextureObject> tex;
|
|
const int active = c->textures.active;
|
|
const GLuint name = c->textures.tmu[active].name;
|
|
|
|
// free the reference to the previously bound object
|
|
texture_unit_t& u(c->textures.tmu[active]);
|
|
if (u.texture)
|
|
u.texture->decStrong(c);
|
|
|
|
if (name == 0) {
|
|
// 0 is our local texture object, not shared with anyone.
|
|
// But it affects all bound TMUs immediately.
|
|
// (we need to invalidate all units bound to this texture object)
|
|
tex = c->textures.defaultTexture;
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (c->textures.tmu[i].texture == tex.get())
|
|
invalidate_texture(c, i);
|
|
}
|
|
} else {
|
|
// get a new texture object for that name
|
|
tex = c->surfaceManager->replaceTexture(name);
|
|
}
|
|
|
|
// bind this texture to the current active texture unit
|
|
// and add a reference to this texture object
|
|
u.texture = tex.get();
|
|
u.texture->incStrong(c);
|
|
u.name = name;
|
|
invalidate_texture(c, active);
|
|
return tex;
|
|
}
|
|
|
|
void bindTextureTmu(
|
|
ogles_context_t* c, int tmu, GLuint texture, const sp<EGLTextureObject>& tex)
|
|
{
|
|
if (tex.get() == c->textures.tmu[tmu].texture)
|
|
return;
|
|
|
|
// free the reference to the previously bound object
|
|
texture_unit_t& u(c->textures.tmu[tmu]);
|
|
if (u.texture)
|
|
u.texture->decStrong(c);
|
|
|
|
// bind this texture to the current active texture unit
|
|
// and add a reference to this texture object
|
|
u.texture = tex.get();
|
|
u.texture->incStrong(c);
|
|
u.name = texture;
|
|
invalidate_texture(c, tmu);
|
|
}
|
|
|
|
int createTextureSurface(ogles_context_t* c,
|
|
GGLSurface** outSurface, int32_t* outSize, GLint level,
|
|
GLenum format, GLenum type, GLsizei width, GLsizei height,
|
|
GLenum compressedFormat = 0)
|
|
{
|
|
// find out which texture is bound to the current unit
|
|
const int active = c->textures.active;
|
|
const GLuint name = c->textures.tmu[active].name;
|
|
|
|
// convert the pixelformat to one we can handle
|
|
const int32_t formatIdx = convertGLPixelFormat(format, type);
|
|
if (formatIdx == 0) { // we don't know what to do with this
|
|
return GL_INVALID_OPERATION;
|
|
}
|
|
|
|
// figure out the size we need as well as the stride
|
|
const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
|
|
const int32_t align = c->textures.unpackAlignment-1;
|
|
const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
|
|
const size_t size = bpr * height;
|
|
const int32_t stride = bpr / pixelFormat.size;
|
|
|
|
if (level > 0) {
|
|
const int active = c->textures.active;
|
|
EGLTextureObject* tex = c->textures.tmu[active].texture;
|
|
status_t err = tex->reallocate(level,
|
|
width, height, stride, formatIdx, compressedFormat, bpr);
|
|
if (err != NO_ERROR)
|
|
return GL_OUT_OF_MEMORY;
|
|
GGLSurface& surface = tex->editMip(level);
|
|
*outSurface = &surface;
|
|
*outSize = size;
|
|
return 0;
|
|
}
|
|
|
|
sp<EGLTextureObject> tex = getAndBindActiveTextureObject(c);
|
|
status_t err = tex->reallocate(level,
|
|
width, height, stride, formatIdx, compressedFormat, bpr);
|
|
if (err != NO_ERROR)
|
|
return GL_OUT_OF_MEMORY;
|
|
|
|
tex->internalformat = format;
|
|
*outSurface = &tex->surface;
|
|
*outSize = size;
|
|
return 0;
|
|
}
|
|
|
|
static size_t dataSizePalette4(int numLevels, int width, int height, int format)
|
|
{
|
|
int indexBits = 8;
|
|
int entrySize = 0;
|
|
switch (format) {
|
|
case GL_PALETTE4_RGB8_OES:
|
|
indexBits = 4;
|
|
/* FALLTHROUGH */
|
|
case GL_PALETTE8_RGB8_OES:
|
|
entrySize = 3;
|
|
break;
|
|
|
|
case GL_PALETTE4_RGBA8_OES:
|
|
indexBits = 4;
|
|
/* FALLTHROUGH */
|
|
case GL_PALETTE8_RGBA8_OES:
|
|
entrySize = 4;
|
|
break;
|
|
|
|
case GL_PALETTE4_R5_G6_B5_OES:
|
|
case GL_PALETTE4_RGBA4_OES:
|
|
case GL_PALETTE4_RGB5_A1_OES:
|
|
indexBits = 4;
|
|
/* FALLTHROUGH */
|
|
case GL_PALETTE8_R5_G6_B5_OES:
|
|
case GL_PALETTE8_RGBA4_OES:
|
|
case GL_PALETTE8_RGB5_A1_OES:
|
|
entrySize = 2;
|
|
break;
|
|
}
|
|
|
|
size_t size = (1 << indexBits) * entrySize; // palette size
|
|
|
|
for (int i=0 ; i< numLevels ; i++) {
|
|
int w = (width >> i) ? : 1;
|
|
int h = (height >> i) ? : 1;
|
|
int levelSize = h * ((w * indexBits) / 8) ? : 1;
|
|
size += levelSize;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
static void decodePalette4(const GLvoid *data, int level, int width, int height,
|
|
void *surface, int stride, int format)
|
|
|
|
{
|
|
int indexBits = 8;
|
|
int entrySize = 0;
|
|
switch (format) {
|
|
case GL_PALETTE4_RGB8_OES:
|
|
indexBits = 4;
|
|
/* FALLTHROUGH */
|
|
case GL_PALETTE8_RGB8_OES:
|
|
entrySize = 3;
|
|
break;
|
|
|
|
case GL_PALETTE4_RGBA8_OES:
|
|
indexBits = 4;
|
|
/* FALLTHROUGH */
|
|
case GL_PALETTE8_RGBA8_OES:
|
|
entrySize = 4;
|
|
break;
|
|
|
|
case GL_PALETTE4_R5_G6_B5_OES:
|
|
case GL_PALETTE4_RGBA4_OES:
|
|
case GL_PALETTE4_RGB5_A1_OES:
|
|
indexBits = 4;
|
|
/* FALLTHROUGH */
|
|
case GL_PALETTE8_R5_G6_B5_OES:
|
|
case GL_PALETTE8_RGBA4_OES:
|
|
case GL_PALETTE8_RGB5_A1_OES:
|
|
entrySize = 2;
|
|
break;
|
|
}
|
|
|
|
const int paletteSize = (1 << indexBits) * entrySize;
|
|
|
|
uint8_t const* pixels = (uint8_t *)data + paletteSize;
|
|
for (int i=0 ; i<level ; i++) {
|
|
int w = (width >> i) ? : 1;
|
|
int h = (height >> i) ? : 1;
|
|
pixels += h * ((w * indexBits) / 8);
|
|
}
|
|
width = (width >> level) ? : 1;
|
|
height = (height >> level) ? : 1;
|
|
|
|
if (entrySize == 2) {
|
|
uint8_t const* const palette = (uint8_t*)data;
|
|
for (int y=0 ; y<height ; y++) {
|
|
uint8_t* p = (uint8_t*)surface + y*stride*2;
|
|
if (indexBits == 8) {
|
|
for (int x=0 ; x<width ; x++) {
|
|
int index = 2 * (*pixels++);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
}
|
|
} else {
|
|
for (int x=0 ; x<width ; x+=2) {
|
|
int v = *pixels++;
|
|
int index = 2 * (v >> 4);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
if (x+1 < width) {
|
|
index = 2 * (v & 0xF);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (entrySize == 3) {
|
|
uint8_t const* const palette = (uint8_t*)data;
|
|
for (int y=0 ; y<height ; y++) {
|
|
uint8_t* p = (uint8_t*)surface + y*stride*3;
|
|
if (indexBits == 8) {
|
|
for (int x=0 ; x<width ; x++) {
|
|
int index = 3 * (*pixels++);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
*p++ = palette[index + 2];
|
|
}
|
|
} else {
|
|
for (int x=0 ; x<width ; x+=2) {
|
|
int v = *pixels++;
|
|
int index = 3 * (v >> 4);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
*p++ = palette[index + 2];
|
|
if (x+1 < width) {
|
|
index = 3 * (v & 0xF);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
*p++ = palette[index + 2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (entrySize == 4) {
|
|
uint8_t const* const palette = (uint8_t*)data;
|
|
for (int y=0 ; y<height ; y++) {
|
|
uint8_t* p = (uint8_t*)surface + y*stride*4;
|
|
if (indexBits == 8) {
|
|
for (int x=0 ; x<width ; x++) {
|
|
int index = 4 * (*pixels++);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
*p++ = palette[index + 2];
|
|
*p++ = palette[index + 3];
|
|
}
|
|
} else {
|
|
for (int x=0 ; x<width ; x+=2) {
|
|
int v = *pixels++;
|
|
int index = 4 * (v >> 4);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
*p++ = palette[index + 2];
|
|
*p++ = palette[index + 3];
|
|
if (x+1 < width) {
|
|
index = 4 * (v & 0xF);
|
|
*p++ = palette[index + 0];
|
|
*p++ = palette[index + 1];
|
|
*p++ = palette[index + 2];
|
|
*p++ = palette[index + 3];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static __attribute__((noinline))
|
|
void set_depth_and_fog(ogles_context_t* c, GGLfixed z)
|
|
{
|
|
const uint32_t enables = c->rasterizer.state.enables;
|
|
// we need to compute Zw
|
|
int32_t iterators[3];
|
|
iterators[1] = iterators[2] = 0;
|
|
GGLfixed Zw;
|
|
GGLfixed n = gglFloatToFixed(c->transforms.vpt.zNear);
|
|
GGLfixed f = gglFloatToFixed(c->transforms.vpt.zFar);
|
|
if (z<=0) Zw = n;
|
|
else if (z>=0x10000) Zw = f;
|
|
else Zw = gglMulAddx(z, (f-n), n);
|
|
if (enables & GGL_ENABLE_FOG) {
|
|
// set up fog if needed...
|
|
iterators[0] = c->fog.fog(c, Zw);
|
|
c->rasterizer.procs.fogGrad3xv(c, iterators);
|
|
}
|
|
if (enables & GGL_ENABLE_DEPTH_TEST) {
|
|
// set up z-test if needed...
|
|
int32_t z = (Zw & ~(Zw>>31));
|
|
if (z >= 0x10000)
|
|
z = 0xFFFF;
|
|
iterators[0] = (z << 16) | z;
|
|
c->rasterizer.procs.zGrad3xv(c, iterators);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Generate mimaps
|
|
#endif
|
|
|
|
extern status_t buildAPyramid(ogles_context_t* c, EGLTextureObject* tex);
|
|
|
|
void generateMipmap(ogles_context_t* c, GLint level)
|
|
{
|
|
if (level == 0) {
|
|
const int active = c->textures.active;
|
|
EGLTextureObject* tex = c->textures.tmu[active].texture;
|
|
if (tex->generate_mipmap) {
|
|
if (buildAPyramid(c, tex) != NO_ERROR) {
|
|
ogles_error(c, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void texParameterx(
|
|
GLenum target, GLenum pname, GLfixed param, ogles_context_t* c)
|
|
{
|
|
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
EGLTextureObject* textureObject = c->textures.tmu[c->textures.active].texture;
|
|
switch (pname) {
|
|
case GL_TEXTURE_WRAP_S:
|
|
if ((param == GL_REPEAT) ||
|
|
(param == GL_CLAMP_TO_EDGE)) {
|
|
textureObject->wraps = param;
|
|
} else {
|
|
goto invalid_enum;
|
|
}
|
|
break;
|
|
case GL_TEXTURE_WRAP_T:
|
|
if ((param == GL_REPEAT) ||
|
|
(param == GL_CLAMP_TO_EDGE)) {
|
|
textureObject->wrapt = param;
|
|
} else {
|
|
goto invalid_enum;
|
|
}
|
|
break;
|
|
case GL_TEXTURE_MIN_FILTER:
|
|
if ((param == GL_NEAREST) ||
|
|
(param == GL_LINEAR) ||
|
|
(param == GL_NEAREST_MIPMAP_NEAREST) ||
|
|
(param == GL_LINEAR_MIPMAP_NEAREST) ||
|
|
(param == GL_NEAREST_MIPMAP_LINEAR) ||
|
|
(param == GL_LINEAR_MIPMAP_LINEAR)) {
|
|
textureObject->min_filter = param;
|
|
} else {
|
|
goto invalid_enum;
|
|
}
|
|
break;
|
|
case GL_TEXTURE_MAG_FILTER:
|
|
if ((param == GL_NEAREST) ||
|
|
(param == GL_LINEAR)) {
|
|
textureObject->mag_filter = param;
|
|
} else {
|
|
goto invalid_enum;
|
|
}
|
|
break;
|
|
case GL_GENERATE_MIPMAP:
|
|
textureObject->generate_mipmap = param;
|
|
break;
|
|
default:
|
|
invalid_enum:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
invalidate_texture(c, c->textures.active);
|
|
}
|
|
|
|
|
|
|
|
static void drawTexxOESImp(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h,
|
|
ogles_context_t* c)
|
|
{
|
|
ogles_lock_textures(c);
|
|
|
|
const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
|
|
y = gglIntToFixed(cbSurface.height) - (y + h);
|
|
w >>= FIXED_BITS;
|
|
h >>= FIXED_BITS;
|
|
|
|
// set up all texture units
|
|
for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
|
|
if (!c->rasterizer.state.texture[i].enable)
|
|
continue;
|
|
|
|
int32_t texcoords[8];
|
|
texture_unit_t& u(c->textures.tmu[i]);
|
|
|
|
// validate this tmu (bind, wrap, filter)
|
|
validate_tmu(c, i);
|
|
// we CLAMP here, which works with premultiplied (s,t)
|
|
c->rasterizer.procs.texParameteri(c,
|
|
GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_S, GGL_CLAMP);
|
|
c->rasterizer.procs.texParameteri(c,
|
|
GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_T, GGL_CLAMP);
|
|
u.dirty = 0xFF; // XXX: should be more subtle
|
|
|
|
EGLTextureObject* textureObject = u.texture;
|
|
const GLint Ucr = textureObject->crop_rect[0] << 16;
|
|
const GLint Vcr = textureObject->crop_rect[1] << 16;
|
|
const GLint Wcr = textureObject->crop_rect[2] << 16;
|
|
const GLint Hcr = textureObject->crop_rect[3] << 16;
|
|
|
|
// computes texture coordinates (pre-multiplied)
|
|
int32_t dsdx = Wcr / w; // dsdx = ((Wcr/w)/Wt)*Wt
|
|
int32_t dtdy =-Hcr / h; // dtdy = -((Hcr/h)/Ht)*Ht
|
|
int32_t s0 = Ucr - gglMulx(dsdx, x); // s0 = Ucr - x * dsdx
|
|
int32_t t0 = (Vcr+Hcr) - gglMulx(dtdy, y); // t0 = (Vcr+Hcr) - y*dtdy
|
|
texcoords[0] = s0;
|
|
texcoords[1] = dsdx;
|
|
texcoords[2] = 0;
|
|
texcoords[3] = t0;
|
|
texcoords[4] = 0;
|
|
texcoords[5] = dtdy;
|
|
texcoords[6] = 0;
|
|
texcoords[7] = 0;
|
|
c->rasterizer.procs.texCoordGradScale8xv(c, i, texcoords);
|
|
}
|
|
|
|
const uint32_t enables = c->rasterizer.state.enables;
|
|
if (ggl_unlikely(enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)))
|
|
set_depth_and_fog(c, z);
|
|
|
|
c->rasterizer.procs.activeTexture(c, c->textures.active);
|
|
c->rasterizer.procs.color4xv(c, c->currentColorClamped.v);
|
|
c->rasterizer.procs.disable(c, GGL_W_LERP);
|
|
c->rasterizer.procs.disable(c, GGL_AA);
|
|
c->rasterizer.procs.shadeModel(c, GL_FLAT);
|
|
c->rasterizer.procs.recti(c,
|
|
gglFixedToIntRound(x),
|
|
gglFixedToIntRound(y),
|
|
gglFixedToIntRound(x)+w,
|
|
gglFixedToIntRound(y)+h);
|
|
|
|
ogles_unlock_textures(c);
|
|
}
|
|
|
|
static void drawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h,
|
|
ogles_context_t* c)
|
|
{
|
|
// quickly reject empty rects
|
|
if ((w|h) <= 0)
|
|
return;
|
|
|
|
drawTexxOESImp(x, y, z, w, h, c);
|
|
}
|
|
|
|
static void drawTexiOES(GLint x, GLint y, GLint z, GLint w, GLint h, ogles_context_t* c)
|
|
{
|
|
// All coordinates are integer, so if we have only one
|
|
// texture unit active and no scaling is required
|
|
// THEN, we can use our special 1:1 mapping
|
|
// which is a lot faster.
|
|
|
|
if (ggl_likely(c->rasterizer.state.enabled_tmu == 1)) {
|
|
const int tmu = 0;
|
|
texture_unit_t& u(c->textures.tmu[tmu]);
|
|
EGLTextureObject* textureObject = u.texture;
|
|
const GLint Wcr = textureObject->crop_rect[2];
|
|
const GLint Hcr = textureObject->crop_rect[3];
|
|
|
|
if ((w == Wcr) && (h == -Hcr)) {
|
|
if ((w|h) <= 0) return; // quickly reject empty rects
|
|
|
|
if (u.dirty) {
|
|
c->rasterizer.procs.activeTexture(c, tmu);
|
|
c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
|
|
c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
|
|
GGL_TEXTURE_MIN_FILTER, u.texture->min_filter);
|
|
c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
|
|
GGL_TEXTURE_MAG_FILTER, u.texture->mag_filter);
|
|
}
|
|
c->rasterizer.procs.texGeni(c, GGL_S,
|
|
GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
|
|
c->rasterizer.procs.texGeni(c, GGL_T,
|
|
GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
|
|
u.dirty = 0xFF; // XXX: should be more subtle
|
|
c->rasterizer.procs.activeTexture(c, c->textures.active);
|
|
|
|
const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
|
|
y = cbSurface.height - (y + h);
|
|
const GLint Ucr = textureObject->crop_rect[0];
|
|
const GLint Vcr = textureObject->crop_rect[1];
|
|
const GLint s0 = Ucr - x;
|
|
const GLint t0 = (Vcr + Hcr) - y;
|
|
|
|
const GLuint tw = textureObject->surface.width;
|
|
const GLuint th = textureObject->surface.height;
|
|
if ((uint32_t(s0+x+w) > tw) || (uint32_t(t0+y+h) > th)) {
|
|
// The GL spec is unclear about what should happen
|
|
// in this case, so we just use the slow case, which
|
|
// at least won't crash
|
|
goto slow_case;
|
|
}
|
|
|
|
ogles_lock_textures(c);
|
|
|
|
c->rasterizer.procs.texCoord2i(c, s0, t0);
|
|
const uint32_t enables = c->rasterizer.state.enables;
|
|
if (ggl_unlikely(enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)))
|
|
set_depth_and_fog(c, gglIntToFixed(z));
|
|
|
|
c->rasterizer.procs.color4xv(c, c->currentColorClamped.v);
|
|
c->rasterizer.procs.disable(c, GGL_W_LERP);
|
|
c->rasterizer.procs.disable(c, GGL_AA);
|
|
c->rasterizer.procs.shadeModel(c, GL_FLAT);
|
|
c->rasterizer.procs.recti(c, x, y, x+w, y+h);
|
|
|
|
ogles_unlock_textures(c);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
slow_case:
|
|
drawTexxOESImp(
|
|
gglIntToFixed(x), gglIntToFixed(y), gglIntToFixed(z),
|
|
gglIntToFixed(w), gglIntToFixed(h),
|
|
c);
|
|
}
|
|
|
|
|
|
}; // namespace android
|
|
// ----------------------------------------------------------------------------
|
|
|
|
using namespace android;
|
|
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Texture API
|
|
#endif
|
|
|
|
void glActiveTexture(GLenum texture)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (uint32_t(texture-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->textures.active = texture - GL_TEXTURE0;
|
|
c->rasterizer.procs.activeTexture(c, c->textures.active);
|
|
}
|
|
|
|
void glBindTexture(GLenum target, GLuint texture)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
// Bind or create a texture
|
|
sp<EGLTextureObject> tex;
|
|
if (texture == 0) {
|
|
// 0 is our local texture object
|
|
tex = c->textures.defaultTexture;
|
|
} else {
|
|
tex = c->surfaceManager->texture(texture);
|
|
if (ggl_unlikely(tex == 0)) {
|
|
tex = c->surfaceManager->createTexture(texture);
|
|
if (tex == 0) {
|
|
ogles_error(c, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
bindTextureTmu(c, c->textures.active, texture, tex);
|
|
}
|
|
|
|
void glGenTextures(GLsizei n, GLuint *textures)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (n<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
// generate unique (shared) texture names
|
|
c->surfaceManager->getToken(n, textures);
|
|
}
|
|
|
|
void glDeleteTextures(GLsizei n, const GLuint *textures)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (n<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
// If deleting a bound texture, bind this unit to 0
|
|
for (int t=0 ; t<GGL_TEXTURE_UNIT_COUNT ; t++) {
|
|
if (c->textures.tmu[t].name == 0)
|
|
continue;
|
|
for (int i=0 ; i<n ; i++) {
|
|
if (textures[i] && (textures[i] == c->textures.tmu[t].name)) {
|
|
// bind this tmu to texture 0
|
|
sp<EGLTextureObject> tex(c->textures.defaultTexture);
|
|
bindTextureTmu(c, t, 0, tex);
|
|
}
|
|
}
|
|
}
|
|
c->surfaceManager->deleteTextures(n, textures);
|
|
c->surfaceManager->recycleTokens(n, textures);
|
|
}
|
|
|
|
void glMultiTexCoord4f(
|
|
GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (uint32_t(target-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
const int tmu = target-GL_TEXTURE0;
|
|
c->current.texture[tmu].S = gglFloatToFixed(s);
|
|
c->current.texture[tmu].T = gglFloatToFixed(t);
|
|
c->current.texture[tmu].R = gglFloatToFixed(r);
|
|
c->current.texture[tmu].Q = gglFloatToFixed(q);
|
|
}
|
|
|
|
void glMultiTexCoord4x(
|
|
GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (uint32_t(target-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
const int tmu = target-GL_TEXTURE0;
|
|
c->current.texture[tmu].S = s;
|
|
c->current.texture[tmu].T = t;
|
|
c->current.texture[tmu].R = r;
|
|
c->current.texture[tmu].Q = q;
|
|
}
|
|
|
|
void glPixelStorei(GLenum pname, GLint param)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if ((pname != GL_PACK_ALIGNMENT) && (pname != GL_UNPACK_ALIGNMENT)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if ((param<=0 || param>8) || (param & (param-1))) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (pname == GL_PACK_ALIGNMENT)
|
|
c->textures.packAlignment = param;
|
|
if (pname == GL_UNPACK_ALIGNMENT)
|
|
c->textures.unpackAlignment = param;
|
|
}
|
|
|
|
void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.texEnvi(c, target, pname, GLint(param));
|
|
}
|
|
|
|
void glTexEnvfv(
|
|
GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (pname == GL_TEXTURE_ENV_MODE) {
|
|
c->rasterizer.procs.texEnvi(c, target, pname, GLint(*params));
|
|
return;
|
|
}
|
|
if (pname == GL_TEXTURE_ENV_COLOR) {
|
|
GGLfixed fixed[4];
|
|
for (int i=0 ; i<4 ; i++)
|
|
fixed[i] = gglFloatToFixed(params[i]);
|
|
c->rasterizer.procs.texEnvxv(c, target, pname, fixed);
|
|
return;
|
|
}
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
}
|
|
|
|
void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.texEnvi(c, target, pname, param);
|
|
}
|
|
|
|
void glTexEnvxv(
|
|
GLenum target, GLenum pname, const GLfixed *params)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.texEnvxv(c, target, pname, params);
|
|
}
|
|
|
|
void glTexParameteriv(
|
|
GLenum target, GLenum pname, const GLint* params)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
EGLTextureObject* textureObject = c->textures.tmu[c->textures.active].texture;
|
|
switch (pname) {
|
|
case GL_TEXTURE_CROP_RECT_OES:
|
|
memcpy(textureObject->crop_rect, params, 4*sizeof(GLint));
|
|
break;
|
|
default:
|
|
texParameterx(target, pname, GLfixed(params[0]), c);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void glTexParameterf(
|
|
GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
texParameterx(target, pname, GLfixed(param), c);
|
|
}
|
|
|
|
void glTexParameterx(
|
|
GLenum target, GLenum pname, GLfixed param)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
texParameterx(target, pname, param, c);
|
|
}
|
|
|
|
void glTexParameteri(
|
|
GLenum target, GLenum pname, GLint param)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
texParameterx(target, pname, GLfixed(param), c);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
void glCompressedTexImage2D(
|
|
GLenum target, GLint level, GLenum internalformat,
|
|
GLsizei width, GLsizei height, GLint border,
|
|
GLsizei imageSize, const GLvoid *data)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (width<0 || height<0 || border!=0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
// "uncompress" the texture since pixelflinger doesn't support
|
|
// any compressed texture format natively.
|
|
GLenum format;
|
|
GLenum type;
|
|
switch (internalformat) {
|
|
case GL_PALETTE8_RGB8_OES:
|
|
case GL_PALETTE4_RGB8_OES:
|
|
format = GL_RGB;
|
|
type = GL_UNSIGNED_BYTE;
|
|
break;
|
|
case GL_PALETTE8_RGBA8_OES:
|
|
case GL_PALETTE4_RGBA8_OES:
|
|
format = GL_RGBA;
|
|
type = GL_UNSIGNED_BYTE;
|
|
break;
|
|
case GL_PALETTE8_R5_G6_B5_OES:
|
|
case GL_PALETTE4_R5_G6_B5_OES:
|
|
format = GL_RGB;
|
|
type = GL_UNSIGNED_SHORT_5_6_5;
|
|
break;
|
|
case GL_PALETTE8_RGBA4_OES:
|
|
case GL_PALETTE4_RGBA4_OES:
|
|
format = GL_RGBA;
|
|
type = GL_UNSIGNED_SHORT_4_4_4_4;
|
|
break;
|
|
case GL_PALETTE8_RGB5_A1_OES:
|
|
case GL_PALETTE4_RGB5_A1_OES:
|
|
format = GL_RGBA;
|
|
type = GL_UNSIGNED_SHORT_5_5_5_1;
|
|
break;
|
|
#ifdef GL_OES_compressed_ETC1_RGB8_texture
|
|
case GL_ETC1_RGB8_OES:
|
|
format = GL_RGB;
|
|
type = GL_UNSIGNED_BYTE;
|
|
break;
|
|
#endif
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
if (!data || !width || !height) {
|
|
// unclear if this is an error or not...
|
|
return;
|
|
}
|
|
|
|
int32_t size;
|
|
GGLSurface* surface;
|
|
|
|
#ifdef GL_OES_compressed_ETC1_RGB8_texture
|
|
if (internalformat == GL_ETC1_RGB8_OES) {
|
|
GLsizei compressedSize = etc1_get_encoded_data_size(width, height);
|
|
if (compressedSize > imageSize) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
int error = createTextureSurface(c, &surface, &size,
|
|
level, format, type, width, height);
|
|
if (error) {
|
|
ogles_error(c, error);
|
|
return;
|
|
}
|
|
if (etc1_decode_image(
|
|
(const etc1_byte*)data,
|
|
(etc1_byte*)surface->data,
|
|
width, height, 3, surface->stride*3) != 0) {
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
// all mipmap levels are specified at once.
|
|
const int numLevels = level<0 ? -level : 1;
|
|
|
|
if (dataSizePalette4(numLevels, width, height, format) > imageSize) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
for (int i=0 ; i<numLevels ; i++) {
|
|
int lod_w = (width >> i) ? : 1;
|
|
int lod_h = (height >> i) ? : 1;
|
|
int error = createTextureSurface(c, &surface, &size,
|
|
i, format, type, lod_w, lod_h);
|
|
if (error) {
|
|
ogles_error(c, error);
|
|
return;
|
|
}
|
|
decodePalette4(data, i, width, height,
|
|
surface->data, surface->stride, internalformat);
|
|
}
|
|
}
|
|
|
|
|
|
void glTexImage2D(
|
|
GLenum target, GLint level, GLint internalformat,
|
|
GLsizei width, GLsizei height, GLint border,
|
|
GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (width<0 || height<0 || border!=0 || level < 0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (format != (GLenum)internalformat) {
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
if (validFormatType(c, format, type)) {
|
|
return;
|
|
}
|
|
|
|
int32_t size = 0;
|
|
GGLSurface* surface = 0;
|
|
int error = createTextureSurface(c, &surface, &size,
|
|
level, format, type, width, height);
|
|
if (error) {
|
|
ogles_error(c, error);
|
|
return;
|
|
}
|
|
|
|
if (pixels) {
|
|
const int32_t formatIdx = convertGLPixelFormat(format, type);
|
|
const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
|
|
const int32_t align = c->textures.unpackAlignment-1;
|
|
const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
|
|
const size_t size = bpr * height;
|
|
const int32_t stride = bpr / pixelFormat.size;
|
|
|
|
GGLSurface userSurface;
|
|
userSurface.version = sizeof(userSurface);
|
|
userSurface.width = width;
|
|
userSurface.height = height;
|
|
userSurface.stride = stride;
|
|
userSurface.format = formatIdx;
|
|
userSurface.compressedFormat = 0;
|
|
userSurface.data = (GLubyte*)pixels;
|
|
|
|
int err = copyPixels(c, *surface, 0, 0, userSurface, 0, 0, width, height);
|
|
if (err) {
|
|
ogles_error(c, err);
|
|
return;
|
|
}
|
|
generateMipmap(c, level);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glCompressedTexSubImage2D(
|
|
GLenum target, GLint level, GLint xoffset,
|
|
GLint yoffset, GLsizei width, GLsizei height,
|
|
GLenum format, GLsizei imageSize,
|
|
const GLvoid *data)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
}
|
|
|
|
void glTexSubImage2D(
|
|
GLenum target, GLint level, GLint xoffset,
|
|
GLint yoffset, GLsizei width, GLsizei height,
|
|
GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (xoffset<0 || yoffset<0 || width<0 || height<0 || level<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (validFormatType(c, format, type)) {
|
|
return;
|
|
}
|
|
|
|
// find out which texture is bound to the current unit
|
|
const int active = c->textures.active;
|
|
EGLTextureObject* tex = c->textures.tmu[active].texture;
|
|
const GGLSurface& surface(tex->mip(level));
|
|
|
|
if (!tex->internalformat || tex->direct) {
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
|
|
if (format != tex->internalformat) {
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
if ((xoffset + width > GLsizei(surface.width)) ||
|
|
(yoffset + height > GLsizei(surface.height))) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (!width || !height) {
|
|
return; // okay, but no-op.
|
|
}
|
|
|
|
// figure out the size we need as well as the stride
|
|
const int32_t formatIdx = convertGLPixelFormat(format, type);
|
|
if (formatIdx == 0) { // we don't know what to do with this
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
|
|
const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
|
|
const int32_t align = c->textures.unpackAlignment-1;
|
|
const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
|
|
const size_t size = bpr * height;
|
|
const int32_t stride = bpr / pixelFormat.size;
|
|
GGLSurface userSurface;
|
|
userSurface.version = sizeof(userSurface);
|
|
userSurface.width = width;
|
|
userSurface.height = height;
|
|
userSurface.stride = stride;
|
|
userSurface.format = formatIdx;
|
|
userSurface.compressedFormat = 0;
|
|
userSurface.data = (GLubyte*)pixels;
|
|
|
|
int err = copyPixels(c,
|
|
surface, xoffset, yoffset,
|
|
userSurface, 0, 0, width, height);
|
|
if (err) {
|
|
ogles_error(c, err);
|
|
return;
|
|
}
|
|
|
|
generateMipmap(c, level);
|
|
|
|
// since we only changed the content of the texture, we don't need
|
|
// to call bindTexture on the main rasterizer.
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glCopyTexImage2D(
|
|
GLenum target, GLint level, GLenum internalformat,
|
|
GLint x, GLint y, GLsizei width, GLsizei height,
|
|
GLint border)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (internalformat<GL_ALPHA || internalformat>GL_LUMINANCE_ALPHA) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (width<0 || height<0 || border!=0 || level<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
GLenum format = 0;
|
|
GLenum type = GL_UNSIGNED_BYTE;
|
|
const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
|
|
const int cbFormatIdx = cbSurface.format;
|
|
switch (cbFormatIdx) {
|
|
case GGL_PIXEL_FORMAT_RGB_565:
|
|
type = GL_UNSIGNED_SHORT_5_6_5;
|
|
break;
|
|
case GGL_PIXEL_FORMAT_RGBA_5551:
|
|
type = GL_UNSIGNED_SHORT_5_5_5_1;
|
|
break;
|
|
case GGL_PIXEL_FORMAT_RGBA_4444:
|
|
type = GL_UNSIGNED_SHORT_4_4_4_4;
|
|
break;
|
|
}
|
|
switch (internalformat) {
|
|
case GL_ALPHA:
|
|
case GL_LUMINANCE_ALPHA:
|
|
case GL_LUMINANCE:
|
|
type = GL_UNSIGNED_BYTE;
|
|
break;
|
|
}
|
|
|
|
// figure out the format to use for the new texture
|
|
switch (cbFormatIdx) {
|
|
case GGL_PIXEL_FORMAT_RGBA_8888:
|
|
case GGL_PIXEL_FORMAT_A_8:
|
|
case GGL_PIXEL_FORMAT_RGBA_5551:
|
|
case GGL_PIXEL_FORMAT_RGBA_4444:
|
|
format = internalformat;
|
|
break;
|
|
case GGL_PIXEL_FORMAT_RGBX_8888:
|
|
case GGL_PIXEL_FORMAT_RGB_888:
|
|
case GGL_PIXEL_FORMAT_RGB_565:
|
|
case GGL_PIXEL_FORMAT_L_8:
|
|
switch (internalformat) {
|
|
case GL_LUMINANCE:
|
|
case GL_RGB:
|
|
format = internalformat;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (format == 0) {
|
|
// invalid combination
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
// create the new texture...
|
|
int32_t size;
|
|
GGLSurface* surface;
|
|
int error = createTextureSurface(c, &surface, &size,
|
|
level, format, type, width, height);
|
|
if (error) {
|
|
ogles_error(c, error);
|
|
return;
|
|
}
|
|
|
|
// The bottom row is stored first in textures
|
|
GGLSurface txSurface(*surface);
|
|
txSurface.stride = -txSurface.stride;
|
|
|
|
// (x,y) is the lower-left corner of colorBuffer
|
|
y = cbSurface.height - (y + height);
|
|
|
|
/* The GLES spec says:
|
|
* If any of the pixels within the specified rectangle are outside
|
|
* the framebuffer associated with the current rendering context,
|
|
* then the values obtained for those pixels are undefined.
|
|
*/
|
|
if (x+width > GLint(cbSurface.width))
|
|
width = cbSurface.width - x;
|
|
|
|
if (y+height > GLint(cbSurface.height))
|
|
height = cbSurface.height - y;
|
|
|
|
int err = copyPixels(c,
|
|
txSurface, 0, 0,
|
|
cbSurface, x, y, width, height);
|
|
if (err) {
|
|
ogles_error(c, err);
|
|
}
|
|
|
|
generateMipmap(c, level);
|
|
}
|
|
|
|
void glCopyTexSubImage2D(
|
|
GLenum target, GLint level, GLint xoffset, GLint yoffset,
|
|
GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (xoffset<0 || yoffset<0 || width<0 || height<0 || level<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (!width || !height) {
|
|
return; // okay, but no-op.
|
|
}
|
|
|
|
// find out which texture is bound to the current unit
|
|
const int active = c->textures.active;
|
|
EGLTextureObject* tex = c->textures.tmu[active].texture;
|
|
const GGLSurface& surface(tex->mip(level));
|
|
|
|
if (!tex->internalformat) {
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
if ((xoffset + width > GLsizei(surface.width)) ||
|
|
(yoffset + height > GLsizei(surface.height))) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
// The bottom row is stored first in textures
|
|
GGLSurface txSurface(surface);
|
|
txSurface.stride = -txSurface.stride;
|
|
|
|
// (x,y) is the lower-left corner of colorBuffer
|
|
const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
|
|
y = cbSurface.height - (y + height);
|
|
|
|
/* The GLES spec says:
|
|
* If any of the pixels within the specified rectangle are outside
|
|
* the framebuffer associated with the current rendering context,
|
|
* then the values obtained for those pixels are undefined.
|
|
*/
|
|
if (x+width > GLint(cbSurface.width))
|
|
width = cbSurface.width - x;
|
|
|
|
if (y+height > GLint(cbSurface.height))
|
|
height = cbSurface.height - y;
|
|
|
|
int err = copyPixels(c,
|
|
txSurface, xoffset, yoffset,
|
|
cbSurface, x, y, width, height);
|
|
if (err) {
|
|
ogles_error(c, err);
|
|
return;
|
|
}
|
|
|
|
generateMipmap(c, level);
|
|
}
|
|
|
|
void glReadPixels(
|
|
GLint x, GLint y, GLsizei width, GLsizei height,
|
|
GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if ((format != GL_RGBA) && (format != GL_RGB)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if ((type != GL_UNSIGNED_BYTE) && (type != GL_UNSIGNED_SHORT_5_6_5)) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
if (width<0 || height<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (x<0 || y<0) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
int32_t formatIdx = GGL_PIXEL_FORMAT_NONE;
|
|
if ((format == GL_RGBA) && (type == GL_UNSIGNED_BYTE)) {
|
|
formatIdx = GGL_PIXEL_FORMAT_RGBA_8888;
|
|
} else if ((format == GL_RGB) && (type == GL_UNSIGNED_SHORT_5_6_5)) {
|
|
formatIdx = GGL_PIXEL_FORMAT_RGB_565;
|
|
} else {
|
|
ogles_error(c, GL_INVALID_OPERATION);
|
|
return;
|
|
}
|
|
|
|
const GGLSurface& readSurface = c->rasterizer.state.buffers.read.s;
|
|
if ((x+width > GLint(readSurface.width)) ||
|
|
(y+height > GLint(readSurface.height))) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
|
|
const int32_t align = c->textures.packAlignment-1;
|
|
const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
|
|
const int32_t stride = bpr / pixelFormat.size;
|
|
|
|
GGLSurface userSurface;
|
|
userSurface.version = sizeof(userSurface);
|
|
userSurface.width = width;
|
|
userSurface.height = height;
|
|
userSurface.stride = -stride; // bottom row is transfered first
|
|
userSurface.format = formatIdx;
|
|
userSurface.compressedFormat = 0;
|
|
userSurface.data = (GLubyte*)pixels;
|
|
|
|
// use pixel-flinger to handle all the conversions
|
|
GGLContext* ggl = getRasterizer(c);
|
|
if (!ggl) {
|
|
// the only reason this would fail is because we ran out of memory
|
|
ogles_error(c, GL_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
|
|
ggl->colorBuffer(ggl, &userSurface); // destination is user buffer
|
|
ggl->bindTexture(ggl, &readSurface); // source is read-buffer
|
|
ggl->texCoord2i(ggl, x, readSurface.height - (y + height));
|
|
ggl->recti(ggl, 0, 0, width, height);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark DrawTexture Extension
|
|
#endif
|
|
|
|
void glDrawTexsvOES(const GLshort* coords) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexiOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
|
|
}
|
|
void glDrawTexivOES(const GLint* coords) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexiOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
|
|
}
|
|
void glDrawTexsOES(GLshort x , GLshort y, GLshort z, GLshort w, GLshort h) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexiOES(x, y, z, w, h, c);
|
|
}
|
|
void glDrawTexiOES(GLint x, GLint y, GLint z, GLint w, GLint h) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexiOES(x, y, z, w, h, c);
|
|
}
|
|
|
|
void glDrawTexfvOES(const GLfloat* coords) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexxOES(
|
|
gglFloatToFixed(coords[0]),
|
|
gglFloatToFixed(coords[1]),
|
|
gglFloatToFixed(coords[2]),
|
|
gglFloatToFixed(coords[3]),
|
|
gglFloatToFixed(coords[4]),
|
|
c);
|
|
}
|
|
void glDrawTexxvOES(const GLfixed* coords) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexxOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
|
|
}
|
|
void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h){
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexxOES(
|
|
gglFloatToFixed(x), gglFloatToFixed(y), gglFloatToFixed(z),
|
|
gglFloatToFixed(w), gglFloatToFixed(h),
|
|
c);
|
|
}
|
|
void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
drawTexxOES(x, y, z, w, h, c);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark EGL Image Extension
|
|
#endif
|
|
|
|
void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
if (image == EGL_NO_IMAGE_KHR) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
ANativeWindowBuffer* native_buffer = (ANativeWindowBuffer*)image;
|
|
if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (native_buffer->common.version != sizeof(ANativeWindowBuffer)) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
// bind it to the texture unit
|
|
sp<EGLTextureObject> tex = getAndBindActiveTextureObject(c);
|
|
tex->setImage(native_buffer);
|
|
}
|
|
|
|
void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (target != GL_RENDERBUFFER_OES) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
if (image == EGL_NO_IMAGE_KHR) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
ANativeWindowBuffer* native_buffer = (ANativeWindowBuffer*)image;
|
|
if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
if (native_buffer->common.version != sizeof(ANativeWindowBuffer)) {
|
|
ogles_error(c, GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
// well, we're not supporting this extension anyways
|
|
}
|