static void keyboard ()
{
char key = 's';
switch (key) {
case 's':
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//ugPostRedisplay(uwin);
break;
case 'S':
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
//ugPostRedisplay(uwin);
break;
case 't':
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//ugPostRedisplay(uwin);
break;
case 'T':
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//ugPostRedisplay(uwin);
break;
case 27:
exit(0);
break;
default:
break;
}
}
GLES11RenderEngine::GLES11RenderEngine() {
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glPixelStorei(GL_PACK_ALIGNMENT, 4);
glEnableClientState(GL_VERTEX_ARRAY);
glShadeModel(GL_FLAT);
glDisable(GL_DITHER);
glDisable(GL_CULL_FACE);
struct pack565 {
inline uint16_t operator() (int r, int g, int b) const {
return (r<<11)|(g<<5)|b;
}
} pack565;
const uint16_t protTexData[] = { 0 };
glGenTextures(1, &mProtectedTexName);
glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, protTexData);
}
status_t TextureManager::initTexture(Image* pImage, int32_t format)
{
if (pImage->name != -1UL)
return INVALID_OPERATION;
GLuint textureName = -1;
glGenTextures(1, &textureName);
pImage->name = textureName;
pImage->width = 0;
pImage->height = 0;
GLenum target = GL_TEXTURE_2D;
#if defined(GL_OES_EGL_image_external)
if (GLExtensions::getInstance().haveTextureExternal()) {
if (format && isYuvFormat(format)) {
target = GL_TEXTURE_EXTERNAL_OES;
pImage->target = Texture::TEXTURE_EXTERNAL;
}
}
#endif
glBindTexture(target, textureName);
glTexParameterx(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
return NO_ERROR;
}
void TextureManager::activateTexture(const Texture& texture, bool filter)
{
const GLenum target = getTextureTarget(&texture);
if (target == GL_TEXTURE_2D) {
glBindTexture(GL_TEXTURE_2D, texture.name);
glEnable(GL_TEXTURE_2D);
#if defined(GL_OES_EGL_image_external)
if (GLExtensions::getInstance().haveTextureExternal()) {
glDisable(GL_TEXTURE_EXTERNAL_OES);
}
} else {
glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture.name);
glEnable(GL_TEXTURE_EXTERNAL_OES);
glDisable(GL_TEXTURE_2D);
#endif
}
if (filter) {
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
}
static int display_bitmap(PrivInfo* priv, FtkBitmap* bitmap, int x, int y, int width, int height, int xoffset, int yoffset)
{
GLint crop[4] = {0};
crop[0] = x;
crop[1] = y;
crop[2] = width;
crop[3] = height;
if(Android_PreRender() != RET_OK)
{
return 0;
}
glColor4f(1,1,1,1);
glBindTexture(GL_TEXTURE_2D, 0);
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glEnable(GL_TEXTURE_2D);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ftk_bitmap_width(bitmap), ftk_bitmap_height(bitmap),
0, GL_RGBA, GL_UNSIGNED_BYTE, ftk_bitmap_lock(bitmap));
glDrawTexiOES(xoffset, yoffset, 0, width, height);
Android_Render();
return 0;
}
void wyRenderTexture::createFrameBuffer(int w, int h) {
// create texture
glGenTextures(1, (GLuint*)&m_texture);
glBindTexture(GL_TEXTURE_2D, m_texture);
// apply texture parameters
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// allocate buffer and create texture from it
GLvoid* pixels = (GLvoid*)wyCalloc(w * h * 4, sizeof(GLubyte));
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
wyFree(pixels);
// generate a new frame buffer
glGenFramebuffersOES(1, (GLuint*)&m_fbo);
// get old frame buffer object
glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, (GLint*)&m_old_fbo);
// bind
glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_fbo);
// associate texture with FBO
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, m_texture, 0);
// restore old buffer
glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_old_fbo);
}
void init_scene()
{
static GLfloat lightpos[4]={50.0f, 50.0f, -320.f, 1.0f};
GLubyte* tex;
/* Clear error */
glGetError();
/* draw a perspective scene */
glMatrixMode(GL_PROJECTION);
glFrustumf(-100.f, 100.f, -100.f, 100.f, 320.f, 640.f);
glMatrixMode(GL_MODELVIEW);
/* turn on features */
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
/* place light 0 in the right place */
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
/* enable filtering */
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
tex=make_texture(256, 256);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 256, 256, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, tex);
free(tex);
disk_fill=gluNewQuadric();
gluQuadricDrawStyle(disk_fill, GLU_FILL);
gluQuadricNormals(disk_fill, GLU_SMOOTH);
disk_fill_flat=gluNewQuadric();
gluQuadricDrawStyle(disk_fill_flat, GLU_FILL);
gluQuadricNormals(disk_fill_flat, GLU_FLAT);
disk_fill_texture=gluNewQuadric();
gluQuadricDrawStyle(disk_fill_texture, GLU_FILL);
gluQuadricNormals(disk_fill_texture, GLU_SMOOTH);
gluQuadricTexture(disk_fill_texture, GLU_TRUE);
disk_point=gluNewQuadric();
gluQuadricDrawStyle(disk_point, GLU_POINT);
gluQuadricNormals(disk_point, GLU_SMOOTH);
disk_line=gluNewQuadric();
gluQuadricDrawStyle(disk_line, GLU_LINE);
gluQuadricNormals(disk_line, GLU_SMOOTH);
disk_silh=gluNewQuadric();
gluQuadricDrawStyle(disk_silh, GLU_SILHOUETTE);
if (glGetError())
{
printf("Oops! I screwed up my OpenGL ES calls somewhere\n");
}
}
void Texture::setTransparentColor(unsigned char r, unsigned char g, unsigned char b)
{
assert( m_data != 0 );
GLenum fmt;
if( getBytesPerPixel() == 4 )
{
fmt = GL_RGBA;
for( int y=0; y<getHeight(); ++y )
{
for( int x=0; x<getWidth(); ++x )
{
unsigned char* data = getPixel(x,y);
if( data[0] == r && data[1] == g && data[2] == b )
{
data[3] = 0;
}
}
}
}
else if( getBytesPerPixel() == 3 )
{
unsigned char* newData = new unsigned char[m_width*m_height*4];
for( int y=0; y<getHeight(); ++y )
{
for( int x=0; x<getWidth(); ++x )
{
unsigned char* data = getPixel(x,y);
unsigned char* d = &newData[(y*getWidth()+x)*4];
d[0] = data[0];
d[1] = data[1];
d[2] = data[2];
d[3] = 0xff;
if( data[0] == r && data[1] == g && data[2] == b )
{
d[3] = 0x00;
}
}
}
m_bpp = 4;
fmt = GL_RGBA;
delete [] m_data;
m_data = newData;
}
else
{
esLogEngineError("[%s] Unsupported bytes per pixel: %d", __FUNCTION__, m_bpp);
return;
}
glBindTexture(GL_TEXTURE_2D, getNativeId());
glTexImage2D(GL_TEXTURE_2D, 0, fmt, m_width, m_height, 0, fmt, GL_UNSIGNED_BYTE, m_data );
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
void Layer::onDraw(const Region& clip) const
{
if (CC_UNLIKELY(mActiveBuffer == 0)) {
// the texture has not been created yet, this Layer has
// in fact never been drawn into. This happens frequently with
// SurfaceView because the WindowManager can't know when the client
// has drawn the first time.
// If there is nothing under us, we paint the screen in black, otherwise
// we just skip this update.
// figure out if there is something below us
Region under;
const SurfaceFlinger::LayerVector& drawingLayers(
mFlinger->mDrawingState.layersSortedByZ);
const size_t count = drawingLayers.size();
for (size_t i=0 ; i<count ; ++i) {
const sp<LayerBase>& layer(drawingLayers[i]);
if (layer.get() == static_cast<LayerBase const*>(this))
break;
under.orSelf(layer->visibleRegionScreen);
}
// if not everything below us is covered, we plug the holes!
Region holes(clip.subtract(under));
if (!holes.isEmpty()) {
clearWithOpenGL(holes, 0, 0, 0, 1);
}
return;
}
if (!isProtected()) {
glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTextureName);
GLenum filter = GL_NEAREST;
if (getFiltering() || needsFiltering() || isFixedSize() || isCropped()) {
// TODO: we could be more subtle with isFixedSize()
filter = GL_LINEAR;
}
glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, filter);
glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, filter);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(mTextureMatrix);
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_EXTERNAL_OES);
} else {
glBindTexture(GL_TEXTURE_2D, mFlinger->getProtectedTexName());
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_EXTERNAL_OES);
glEnable(GL_TEXTURE_2D);
}
drawWithOpenGL(clip);
glDisable(GL_TEXTURE_EXTERNAL_OES);
glDisable(GL_TEXTURE_2D);
}
void wyDrawTexture2(int texture, wyRect texRect, float texW, float texH, float x, float y, float w, float h, bool flipX, bool flipY) {
// get drawing size
float potWidth = wyMath::getNextPOT(texW);
float potHeight = wyMath::getNextPOT(texH);
// get vertices
float vertices[] = { x, y, 0.0f, w + x, y, 0.0f, x, h + y, 0.0f, w + x, h + y, 0.0f };
// get texture coordination
float left = texRect.x / potWidth;
float right = (texRect.x + texRect.width) / potWidth;
float top = texRect.y / potHeight;
float bottom = (texRect.y + texRect.height) / potHeight;
float texCoords[] = {
left, bottom,
right, bottom,
left, top,
right, top
};
if(flipY) {
wyUtils::swap(texCoords, 0, 4);
wyUtils::swap(texCoords, 1, 5);
wyUtils::swap(texCoords, 2, 6);
wyUtils::swap(texCoords, 3, 7);
}
if(flipX) {
wyUtils::swap(texCoords, 0, 2);
wyUtils::swap(texCoords, 1, 3);
wyUtils::swap(texCoords, 4, 6);
wyUtils::swap(texCoords, 5, 7);
}
// enable states
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
// ensure current texture is active
glBindTexture(GL_TEXTURE_2D, texture);
// apply texture parameters in both direction
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set vertices and texture coordination and draw
glVertexPointer(3, GL_FLOAT, 0, vertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// disable states
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
}
status_t BootAnimation::initTexture(Texture* texture, AssetManager& assets,
const char* name) {
Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
if (!asset)
return NO_INIT;
SkBitmap bitmap;
SkImageDecoder::DecodeMemory(asset->getBuffer(false), asset->getLength(),
&bitmap, SkBitmap::kNo_Config, SkImageDecoder::kDecodePixels_Mode);
asset->close();
delete asset;
// ensure we can call getPixels(). No need to call unlock, since the
// bitmap will go out of scope when we return from this method.
bitmap.lockPixels();
const int w = bitmap.width();
const int h = bitmap.height();
const void* p = bitmap.getPixels();
GLint crop[4] = { 0, h, w, -h };
texture->w = w;
texture->h = h;
glGenTextures(1, &texture->name);
glBindTexture(GL_TEXTURE_2D, texture->name);
switch (bitmap.getConfig()) {
case SkBitmap::kA8_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
GL_UNSIGNED_BYTE, p);
break;
case SkBitmap::kARGB_4444_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
GL_UNSIGNED_SHORT_4_4_4_4, p);
break;
case SkBitmap::kARGB_8888_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
GL_UNSIGNED_BYTE, p);
break;
case SkBitmap::kRGB_565_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
GL_UNSIGNED_SHORT_5_6_5, p);
break;
default:
break;
}
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
return NO_ERROR;
}
void init_scene(int width, int height)
{
static GLfloat lightpos[4]={50.0f, 50.0f, -320.f, 1.0f};
GLubyte* tex;
if (height==0)
{
height=1;
}
/* Clear error */
glGetError();
/* Setup our viewport */
glViewport(0, 0, (GLint)width, (GLint)height);
/* draw a perspective scene */
glMatrixMode(GL_PROJECTION);
gluPerspective(35.0f, (GLfloat)width/(GLfloat)height, 320.0f, 6000.0f);
glMatrixMode(GL_MODELVIEW);
/* turn on features */
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
/* place light 0 in the right place */
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
/* enable filtering */
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
tex=make_texture(512, 512);
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, 512, 512, GL_LUMINANCE,
GL_UNSIGNED_BYTE, tex);
free(tex);
sphere=gluNewQuadric();
gluQuadricDrawStyle(sphere, GLU_FILL);
gluQuadricTexture(sphere, GLU_TRUE);
cone=gluNewQuadric();
gluQuadricDrawStyle(cone, GLU_FILL);
gluQuadricTexture(cone, GLU_TRUE);
if (glGetError())
{
printf("Oops! I screwed up my OpenGL ES calls somewhere\n");
}
}
/*
* Draw a bitmap character
*/
void FGAPIENTRY
glutBitmapCharacterTex(void* fontID, int x, int y, int character)
{
#if (GL_OES_VERSION_1_1 >= 1)
const GLubyte* face;
SFG_Font* font = fghFontByID(fontID);
GLint v[] = {0, 0, _INT2FIXED(64), _INT2FIXED(64)}; //face[0], font->Height};
GLubyte buff[64*64];
GLuint tid;
if(!font)
return;
if(!(character >= 1)&&(character < 256))
return;
/*
* Find the character we want to draw (???)
*/
face = font->Characters[ character - 1 ];
memset(buff, 0, 64*64*sizeof(GLubyte));
BitsToBytes(face+1, face[0], font->Height, buff, 64, 64);
glGenTextures(1, &tid);
glBindTexture(GL_TEXTURE_2D, tid);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA,
64, 64, 0, GL_ALPHA, GL_UNSIGNED_BYTE,
buff);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glEnable(GL_TEXTURE_2D);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_ALPHA_TEST);
glAlphaFuncx(GL_EQUAL, 0);
glTexParameterxv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, v);
glDrawTexxOES(_INT2FIXED(x), _INT2FIXED(y), _INT2FIXED(0), _INT2FIXED(16), _INT2FIXED(16)); //face[0], font->Height);
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tid);
#endif
}
a3d_texfont_t* a3d_texfont_new(const char* fname)
{
assert(fname);
LOGD("debug");
a3d_texfont_t* self = (a3d_texfont_t*) malloc(sizeof(a3d_texfont_t));
if(self == NULL)
{
LOGE("malloc failed");
goto fail_malloc;
}
self->tex = a3d_tex_new(fname);
if(self->tex == NULL)
{
// log message already output
goto fail_tex;
}
if(a3d_tex_load(self->tex) == A3D_TEX_ERROR)
{
// log message already output
goto fail_load;
}
self->char_w = self->tex->width / 26;
self->char_h = self->tex->height / 4;
glGenTextures(1, &self->tex->id);
glBindTexture(GL_TEXTURE_2D, self->tex->id);
#if defined(A3D_GLESv1_CM)
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#else
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#endif
glTexImage2D(GL_TEXTURE_2D, 0, self->tex->format, self->tex->stride, self->tex->vstride,
0, self->tex->format, self->tex->type, self->tex->pixels);
a3d_tex_reclaim(self->tex);
// success
return self;
// failure
fail_load:
a3d_tex_delete(&self->tex);
fail_tex:
free(self);
fail_malloc:
return NULL;
}
static void init(void)
{
static const GLfloat v[] = {
-2.0, -1.0, 0.0,
-2.0, 1.0, 0.0,
0.0, -1.0, 0.0,
0.0, 1.0, 0.0,
1.0, -1.0, 0.0,
1.0, 1.0, 0.0,
2.41421f, -1.0, -1.41421f,
2.41421f, 1.0, -1.41421f,
};
static const GLfloat t[] = {
0.0, 0.0,
0.0, 3.0,
3.0, 0.0,
3.0, 3.0,
0.0, 0.0,
0.0, 3.0,
3.0, 0.0,
3.0, 3.0,
};
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
makeCheckImage();
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &texName);
glBindTexture(GL_TEXTURE_2D, texName);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight,
0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
#if 0
glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth, checkImageHeight,
0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
#endif
glVertexPointer(3, GL_FLOAT, 0, v);
glTexCoordPointer(2, GL_FLOAT, 0, t);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
GLuint initTexture(MAHandle image) {
GLuint textureHandle;
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &textureHandle);
glBindTexture(GL_TEXTURE_2D, textureHandle);
maOpenGLTexImage2D(image);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
return textureHandle;
}
void init(void)
{
static const GLfloat v[] = {
-2.0, -1.0, 0.0,
-2.0, 1.0, 0.0,
0.0, -1.0, 0.0,
0.0, 1.0, 0.0,
1.0, -1.0, 0.0,
1.0, 1.0, 0.0,
2.41421, -1.0, -1.41421,
2.41421, 1.0, -1.41421,
};
static const GLfloat t[] = {
0.0, 0.0,
0.0, 1.0,
1.0, 0.0,
1.0, 1.0,
0.0, 0.0,
0.0, 1.0,
1.0, 0.0,
1.0, 1.0,
};
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
makeCheckImages();
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(2, texName);
glBindTexture(GL_TEXTURE_2D, texName[0]);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
checkImage);
glBindTexture(GL_TEXTURE_2D, texName[1]);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
otherImage);
glEnable(GL_TEXTURE_2D);
glVertexPointer(3, GL_FLOAT, 0, v);
glTexCoordPointer(2, GL_FLOAT, 0, t);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
int initGL(int w_orig, int h_orig)
{
checkGLVersion();
GLint crop[4] = { 0, h_orig, w_orig, -h_orig };
glBindTexture(GL_TEXTURE_2D, 0);
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glEnable(GL_TEXTURE_2D);
glColor4f(1,1,1,1);
CHECK_GL_ERROR();
return 1;
}
void GLES11RenderEngine::setupLayerTexturing(const Texture& texture) {
GLuint target = texture.getTextureTarget();
glBindTexture(target, texture.getTextureName());
GLenum filter = GL_NEAREST;
if (texture.getFiltering()) {
filter = GL_LINEAR;
}
glTexParameterx(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, filter);
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, filter);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(texture.getMatrix().asArray());
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_EXTERNAL_OES);
}
void
init_gles(Evas_Object *obj)
{
ELEMENTARY_GLVIEW_USE(obj);
appdata_s *ad = (appdata_s *)evas_object_data_get(obj, APPDATA_KEY);
int width;
int height;
elm_glview_size_get(obj, &width, &height);
ad->current_tex_index = 0;
{
glGenTextures(2, ad->tex_ids);
glBindTexture(GL_TEXTURE_2D, ad->tex_ids[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 128, 128, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, IMAGE_4444_128_128_1);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, ad->tex_ids[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 128, 128, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, IMAGE_565_128_128_1);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
glShadeModel(GL_SMOOTH);
glViewport(0, 0, width, height);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
{
glEnable(GL_FOG);
glFogx(GL_FOG_MODE, GL_LINEAR);
glFog(GL_FOG_DENSITY, GetGlUnit(0.25f));
glFog(GL_FOG_START, GetGlUnit(4.0f));
glFog(GL_FOG_END, GetGlUnit(6.5f));
glHint(GL_FOG_HINT, GL_DONT_CARE);
}
SetPerspective(obj, 60.0f, 1.0f * width / height, 1.0f, 400.0f);
glClearColorEx(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
/**
* Create the texture used for rendering.
*/
void createTexture()
{
// Create an OpenGL 2D texture from the R_BOX resource.
glEnable(GL_TEXTURE_2D);
glGenTextures(5, mBoxTextureHandle);
glBindTexture(GL_TEXTURE_2D, mBoxTextureHandle[0]);
maOpenGLTexImage2D(R_CANVAS_TEXTURE);
// Set texture parameters.
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Create an OpenGL 2D texture from the R_BOX resource.
glBindTexture(GL_TEXTURE_2D, mBoxTextureHandle[1]);
maOpenGLTexImage2D(R_CANVAS_TEXTURE_HIT);
// Set texture parameters.
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Create an OpenGL 2D texture from the R_BOX resource.
glBindTexture(GL_TEXTURE_2D, mBoxTextureHandle[2]);
maOpenGLTexImage2D(R_CANVAS_TEXTURE_DEAD);
// Set texture parameters.
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Create an OpenGL 2D texture from the R_BOX resource.
glBindTexture(GL_TEXTURE_2D, mBoxTextureHandle[3]);
maOpenGLTexImage2D(R_CANVAS_TEXTURE_FINISH);
// Set texture parameters.
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Create an OpenGL 2D texture from the R_BOX resource.
glBindTexture(GL_TEXTURE_2D, mBoxTextureHandle[4]);
maOpenGLTexImage2D(R_CANVAS_TEXTURE_THROTTLE);
// Set texture parameters.
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
void video_init(void)
{
int tex_width, tex_height;
GLint crop[4] = { VIDEO_WIDTH, 0, -VIDEO_WIDTH, VIDEO_HEIGHT };
INFO("initializing OpenGL video rendering...\n");
// FIXME: this should be computed (smallest power of 2 > dimension)
tex_width = 256;
tex_height = 256;
otick = 0;
if (!pixbuf) {
pixbuf = malloc(tex_width * tex_height * 2);
assert(pixbuf);
//memcpy(pixbuf, default_image, VIDEO_WIDTH*VIDEO_HEIGHT*2);
}
glEnable(GL_TEXTURE_2D);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDeleteTextures(1, &texture);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
// Call glTexImage2D only once, and use glTexSubImage2D later
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex_width, tex_height, 0, GL_RGB,
GL_UNSIGNED_SHORT_5_6_5, pixbuf);
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, VIDEO_WIDTH, VIDEO_HEIGHT,
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, default_image);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDisable(GL_BLEND);
glDisable(GL_DITHER);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glShadeModel(GL_FLAT);
glClear(GL_COLOR_BUFFER_BIT);
}
status_t TextureManager::initTexture(Texture* texture)
{
if (texture->name != -1UL)
return INVALID_OPERATION;
GLuint textureName = -1;
glGenTextures(1, &textureName);
texture->name = textureName;
texture->width = 0;
texture->height = 0;
const GLenum target = GL_TEXTURE_2D;
glBindTexture(target, textureName);
glTexParameterx(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterx(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
return NO_ERROR;
}
void create_texture(void)
{
const unsigned int on = 0xff0000ff;
const unsigned int off = 0xffffffff;
const unsigned int pixels[] =
{
on, off, on, off, on, off, on, off,
off, on, off, on, off, on, off, on,
on, off, on, off, on, off, on, off,
off, on, off, on, off, on, off, on,
on, off, on, off, on, off, on, off,
off, on, off, on, off, on, off, on,
on, off, on, off, on, off, on, off,
off, on, off, on, off, on, off, on,
};
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
void Texture::setData(unsigned char* data, int width, int height, int bpp, int nativeIdIndex)
{
m_width = width;
m_height = height;
m_bpp = bpp;
if( data != m_data )
{
if( m_data != 0 )
{
delete [] m_data;
m_data = 0;
}
m_data = new uint8_t[m_width*m_height*m_bpp];
memcpy(m_data,data,m_width*m_height*m_bpp);
}
GLenum fmt;
if( m_bpp == 4 )
{
fmt = GL_RGBA;
}
else if (m_bpp == 3 )
{
fmt = GL_RGB;
}
else
{
yam2d::esLogMessage("[%s] Unsupported bytes per pixel: %d", __FUNCTION__, m_bpp);
return;
}
glBindTexture(GL_TEXTURE_2D, m_nativeIds[nativeIdIndex]);
glTexImage2D(GL_TEXTURE_2D, 0, fmt, m_width, m_height, 0, fmt, GL_UNSIGNED_BYTE, m_data );
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
static Texture* getTexture(MAHandle image) {
int i;
GLuint handle;
for(i = numTextures-1; i >= 0; i--) {
// should check more things than handle here (handle may be reused with placeholder pool)
if(textures[i].maTexture == image) {
return &textures[i];
}
}
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &handle);
glBindTexture(GL_TEXTURE_2D, handle);
maOpenGLTexImage2D(image);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
return addTexture(image, handle);
}
static void ogl_notifyImageUpdated(MAHandle image) {
int i;
GLuint handle;
for(i = 0; i < numTextures; i++) {
if(textures[i].maTexture == image) {
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textures[i].glTexture);
maOpenGLTexSubImage2D(image);
return;
}
}
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &handle);
glBindTexture(GL_TEXTURE_2D, handle);
maOpenGLTexImage2D(image);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
addTexture(image, handle);
}
bool OverlayComposer::initOpenGLES()
{
// Initialize OpenGL|ES
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glPixelStorei(GL_PACK_ALIGNMENT, 4);
glEnableClientState(GL_VERTEX_ARRAY);
glShadeModel(GL_FLAT);
glDisable(GL_DITHER);
glDisable(GL_CULL_FACE);
const uint16_t g0 = pack565(0x0F,0x1F,0x0F);
const uint16_t g1 = pack565(0x17,0x2f,0x17);
const uint16_t wormholeTexData[4] = { g0, g1, g1, g0 };
glGenTextures(1, &mWormholeTexName);
glBindTexture(GL_TEXTURE_2D, mWormholeTexName);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0,
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, wormholeTexData);
const uint16_t protTexData[] = { pack565(0x03, 0x03, 0x03) };
glGenTextures(1, &mProtectedTexName);
glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, protTexData);
unsigned int mFBWidth = mDisplayPlane->getWidth();
unsigned int mFBHeight = mDisplayPlane->getHeight();
glViewport(0, 0, mFBWidth, mFBHeight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// put the origin in the left-bottom corner
glOrthof(0, mFBWidth, 0, mFBHeight, 0, 1);
// l=0, r=w ; b=0, t=h
return true;
}
GLuint LayerBase::createTexture() const
{
GLuint textureName = -1;
glGenTextures(1, &textureName);
glBindTexture(GL_TEXTURE_2D, textureName);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (mFlags & DisplayHardware::SLOW_CONFIG) {
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
} else {
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
return textureName;
}
bool BootAnimation::movie()
{
ZipEntryRO desc = mZip->findEntryByName("desc.txt");
ALOGE_IF(!desc, "couldn't find desc.txt");
if (!desc) {
return false;
}
FileMap* descMap = mZip->createEntryFileMap(desc);
mZip->releaseEntry(desc);
ALOGE_IF(!descMap, "descMap is null");
if (!descMap) {
return false;
}
String8 desString((char const*)descMap->getDataPtr(),
descMap->getDataLength());
descMap->release();
char const* s = desString.string();
Animation animation;
// Parse the description file
for (;;) {
const char* endl = strstr(s, "\n");
if (!endl) break;
String8 line(s, endl - s);
const char* l = line.string();
int fps, width, height, count, pause;
char path[ANIM_ENTRY_NAME_MAX];
char pathType;
if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {
//LOGD("> w=%d, h=%d, fps=%d", width, height, fps);
animation.width = width;
animation.height = height;
animation.fps = fps;
}
else if (sscanf(l, " %c %d %d %s", &pathType, &count, &pause, path) == 4) {
//LOGD("> type=%c, count=%d, pause=%d, path=%s", pathType, count, pause, path);
Animation::Part part;
part.playUntilComplete = pathType == 'c';
part.count = count;
part.pause = pause;
part.path = path;
animation.parts.add(part);
}
s = ++endl;
}
// read all the data structures
const size_t pcount = animation.parts.size();
void *cookie = NULL;
if (!mZip->startIteration(&cookie)) {
return false;
}
ZipEntryRO entry;
char name[ANIM_ENTRY_NAME_MAX];
while ((entry = mZip->nextEntry(cookie)) != NULL) {
const int foundEntryName = mZip->getEntryFileName(entry, name, ANIM_ENTRY_NAME_MAX);
if (foundEntryName > ANIM_ENTRY_NAME_MAX || foundEntryName == -1) {
ALOGE("Error fetching entry file name");
continue;
}
const String8 entryName(name);
const String8 path(entryName.getPathDir());
const String8 leaf(entryName.getPathLeaf());
if (leaf.size() > 0) {
for (size_t j=0 ; j<pcount ; j++) {
if (path == animation.parts[j].path) {
int method;
// supports only stored png files
if (mZip->getEntryInfo(entry, &method, NULL, NULL, NULL, NULL, NULL)) {
if (method == ZipFileRO::kCompressStored) {
FileMap* map = mZip->createEntryFileMap(entry);
if (map) {
Animation::Frame frame;
frame.name = leaf;
frame.map = map;
Animation::Part& part(animation.parts.editItemAt(j));
part.frames.add(frame);
}
}
}
}
}
}
}
mZip->endIteration(cookie);
// clear screen
glShadeModel(GL_FLAT);
glDisable(GL_DITHER);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(mDisplay, mSurface);
glBindTexture(GL_TEXTURE_2D, 0);
glEnable(GL_TEXTURE_2D);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
const int xc = (mWidth - animation.width) / 2;
const int yc = ((mHeight - animation.height) / 2);
nsecs_t lastFrame = systemTime();
nsecs_t frameDuration = s2ns(1) / animation.fps;
Region clearReg(Rect(mWidth, mHeight));
clearReg.subtractSelf(Rect(xc, yc, xc+animation.width, yc+animation.height));
for (size_t i=0 ; i<pcount ; i++) {
const Animation::Part& part(animation.parts[i]);
const size_t fcount = part.frames.size();
glBindTexture(GL_TEXTURE_2D, 0);
for (int r=0 ; !part.count || r<part.count ; r++) {
// Exit any non playuntil complete parts immediately
if(exitPending() && !part.playUntilComplete)
break;
for (size_t j=0 ; j<fcount && (!exitPending() || part.playUntilComplete) ; j++) {
const Animation::Frame& frame(part.frames[j]);
nsecs_t lastFrame = systemTime();
if (r > 0) {
glBindTexture(GL_TEXTURE_2D, frame.tid);
} else {
if (part.count != 1) {
glGenTextures(1, &frame.tid);
glBindTexture(GL_TEXTURE_2D, frame.tid);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
initTexture(frame);
}
if (!clearReg.isEmpty()) {
Region::const_iterator head(clearReg.begin());
Region::const_iterator tail(clearReg.end());
glEnable(GL_SCISSOR_TEST);
while (head != tail) {
const Rect& r(*head++);
glScissor(r.left, mHeight - r.bottom,
r.width(), r.height());
glClear(GL_COLOR_BUFFER_BIT);
}
glDisable(GL_SCISSOR_TEST);
}
glDrawTexiOES(xc, yc, 0, animation.width, animation.height);
eglSwapBuffers(mDisplay, mSurface);
nsecs_t now = systemTime();
nsecs_t delay = frameDuration - (now - lastFrame);
//ALOGD("%lld, %lld", ns2ms(now - lastFrame), ns2ms(delay));
lastFrame = now;
if (delay > 0) {
struct timespec spec;
spec.tv_sec = (now + delay) / 1000000000;
spec.tv_nsec = (now + delay) % 1000000000;
int err;
do {
err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
} while (err<0 && errno == EINTR);
}
checkExit();
}
usleep(part.pause * ns2us(frameDuration));
// For infinite parts, we've now played them at least once, so perhaps exit
if(exitPending() && !part.count)
break;
}
// free the textures for this part
if (part.count != 1) {
for (size_t j=0 ; j<fcount ; j++) {
const Animation::Frame& frame(part.frames[j]);
glDeleteTextures(1, &frame.tid);
}
}
}
return false;
}