You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
559 lines
17 KiB
559 lines
17 KiB
|
|
#include <jni.h>
|
|
#include <errno.h>
|
|
|
|
#include "osmroute.h"
|
|
#include "system.h"
|
|
|
|
#include <png.h>
|
|
|
|
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "sposmroute", __VA_ARGS__))
|
|
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "sposmroute", __VA_ARGS__))
|
|
|
|
iPoint gfx_screensize;
|
|
struct font *drawfont = NULL;
|
|
|
|
int gfx_last_img_fbo = 0;
|
|
int gfx_last_alloc_img = 0;
|
|
void gfx_fbo_switch (struct image *img);
|
|
|
|
/*********************** GLES functions **************************************/
|
|
GLuint LoadShader (const char *shader_src, GLenum type) {
|
|
GLuint shader;
|
|
GLint compiled;
|
|
|
|
shader = glCreateShader(type);
|
|
if (shader == 0) return 0;
|
|
|
|
glShaderSource (shader, 1, &shader_src, NULL);
|
|
glCompileShader (shader);
|
|
glGetShaderiv (shader, GL_COMPILE_STATUS, &compiled);
|
|
if (!compiled) {
|
|
GLint info_len = 0;
|
|
glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &info_len);
|
|
if (info_len > 1) {
|
|
char *info_log = malloc (info_len);
|
|
|
|
glGetShaderInfoLog (shader, info_len, NULL, info_log);
|
|
d_printf ("LoadShader compile error: '%s'", info_log);
|
|
exit (1);
|
|
}
|
|
|
|
glDeleteShader (shader);
|
|
return 0;
|
|
}
|
|
|
|
return shader;
|
|
};
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
void gfx_init (int width, int height) {
|
|
GLbyte vshader_str[] = {
|
|
"attribute vec4 vPosition; \n"
|
|
"attribute vec2 vTexture; \n"
|
|
"varying vec2 v_txcoordinate; \n"
|
|
"uniform mat4 uMvp; \n"
|
|
"void main() { \n"
|
|
" v_txcoordinate = vTexture; \n"
|
|
" gl_Position = vPosition * uMvp; \n"
|
|
"} \n" };
|
|
GLbyte fshader_str[] = {
|
|
"precision mediump float; \n"
|
|
"uniform vec4 vColor; \n"
|
|
"uniform int txenabled; \n"
|
|
"uniform sampler2D s_texture; \n"
|
|
"varying mediump vec2 v_txcoordinate; \n"
|
|
"void main() { \n"
|
|
" if (txenabled == 1) \n"
|
|
" gl_FragColor = vColor * texture2D(s_texture, v_txcoordinate); \n"
|
|
" else if (txenabled == 2) \n"
|
|
" gl_FragColor = vColor * vec4 (1.0, 1.0, 1.0, texture2D(s_texture, v_txcoordinate).a); \n"
|
|
" else \n"
|
|
" gl_FragColor = vColor; \n"
|
|
"} \n" };
|
|
GLuint vshader;
|
|
GLuint fshader;
|
|
GLuint prgobject;
|
|
GLint linked;
|
|
|
|
d_printf ("gfx_init");
|
|
|
|
vshader = LoadShader (vshader_str, GL_VERTEX_SHADER);
|
|
fshader = LoadShader (fshader_str, GL_FRAGMENT_SHADER);
|
|
prgobject = glCreateProgram ();
|
|
if (prgobject == 0) {
|
|
d_printf ("glCreateProgramm failed..");
|
|
exit (1);
|
|
}
|
|
glAttachShader (prgobject, vshader);
|
|
glAttachShader (prgobject, fshader);
|
|
glBindAttribLocation (prgobject, 0, "vPosition");
|
|
glLinkProgram (prgobject);
|
|
glGetProgramiv(prgobject, GL_LINK_STATUS, &linked);
|
|
if (!linked) {
|
|
GLint info_len;
|
|
|
|
glGetProgramiv (prgobject, GL_INFO_LOG_LENGTH, &info_len);
|
|
if (info_len > 0) {
|
|
char *info_log = malloc (info_len);
|
|
glGetProgramInfoLog(prgobject, info_len, NULL, info_log);
|
|
d_printf ("Link Programm failed. : '%s'", info_log);
|
|
exit (1);
|
|
}
|
|
}
|
|
engine.gles_pos = glGetAttribLocation(prgobject, "vPosition");
|
|
engine.gles_txcoord = glGetAttribLocation(prgobject, "vTexture");
|
|
engine.gles_color = glGetUniformLocation(prgobject, "vColor");
|
|
engine.gles_umvp = glGetUniformLocation(prgobject, "uMvp");
|
|
engine.gles_txsampler = glGetUniformLocation(prgobject, "s_texture");
|
|
engine.gles_txenabled = glGetUniformLocation(prgobject, "txenabled");
|
|
engine.gles_prgobject = prgobject;
|
|
|
|
glEnableVertexAttribArray (engine.gles_pos);
|
|
glEnableVertexAttribArray (engine.gles_txcoord);
|
|
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
|
|
glEnable(GL_CULL_FACE);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glEnable( GL_BLEND );
|
|
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
|
|
gfx_screensize.x = width;
|
|
gfx_screensize.y = height;
|
|
gfx_resize (width, height);
|
|
|
|
font_init ();
|
|
drawfont = font_load ("FreeSans.ttf");
|
|
};
|
|
|
|
|
|
void gfx_resize (int width, int height) {
|
|
GLfloat matrix[] = {
|
|
2.0/(float)width, 0.0, 0.0, -1.0,
|
|
0.0, -2.0/(float)height, 0.0, 1.0,
|
|
0.0, 0.0, 1.0, 0.0,
|
|
0.0, 0.0, 0.0, 1.0 };
|
|
|
|
d_printf ("gfx_resize %d,%d", width, height);
|
|
glViewport (0, 0, width, height);
|
|
glUseProgram (engine.gles_prgobject);
|
|
glUniformMatrix4fv(engine.gles_umvp, 1, GL_FALSE, matrix);
|
|
|
|
if (height==0) height = 1;
|
|
gfx_screensize.x = width;
|
|
gfx_screensize.y = height;
|
|
gfx_last_img_fbo = 1; /* force to switch fbo to default */
|
|
gfx_fbo_switch (NULL);
|
|
return;
|
|
};
|
|
|
|
|
|
void gfx_flip () {
|
|
if (engine.surface == NULL) return;
|
|
gfx_fbo_switch (NULL);
|
|
glFlush();
|
|
glFinish ();
|
|
eglSwapBuffers(engine.display, engine.surface);
|
|
};
|
|
|
|
|
|
void gfx_fbo_switch (struct image *img) {
|
|
/* check if we need to switch back to default frame buffer */
|
|
if (img == NULL && gfx_last_img_fbo == 0) {
|
|
return;
|
|
}
|
|
if (img == NULL) {
|
|
GLfloat matrix[] = {
|
|
2.0/(float)gfx_screensize.x, 0.0, 0.0, -1.0,
|
|
0.0, -2.0/(float)gfx_screensize.y, 0.0, 1.0,
|
|
0.0, 0.0, 1.0, 0.0,
|
|
0.0, 0.0, 0.0, 1.0 };
|
|
|
|
gfx_last_img_fbo = 0;
|
|
glBindFramebuffer (GL_FRAMEBUFFER, 0);
|
|
glViewport (0, 0, gfx_screensize.x, gfx_screensize.y);
|
|
glUseProgram (engine.gles_prgobject);
|
|
glUniformMatrix4fv(engine.gles_umvp, 1, GL_FALSE, matrix);
|
|
glEnableVertexAttribArray (engine.gles_pos);
|
|
glEnableVertexAttribArray (engine.gles_txcoord);
|
|
}
|
|
else if (gfx_last_img_fbo == img->img_id) {
|
|
return;
|
|
}
|
|
else {
|
|
GLfloat matrix[] = {
|
|
2.0/(float)img->width, 0.0, 0.0, -1.0,
|
|
0.0, -2.0/(float)img->height, 0.0, 1.0,
|
|
0.0, 0.0, 1.0, 0.0,
|
|
0.0, 0.0, 0.0, 1.0 };
|
|
gfx_last_img_fbo = img->img_id;
|
|
glBindFramebuffer(GL_FRAMEBUFFER, img->fbo_id);
|
|
glViewport (0, 0, img->width, img->height);
|
|
glUseProgram (engine.gles_prgobject);
|
|
glUniformMatrix4fv(engine.gles_umvp, 1, GL_FALSE, matrix);
|
|
glEnableVertexAttribArray (engine.gles_pos);
|
|
glEnableVertexAttribArray (engine.gles_txcoord);
|
|
}
|
|
};
|
|
|
|
|
|
int gfx_color_alloc (struct color *c, unsigned short int r, unsigned short int g, unsigned short int b) {
|
|
c->r = r;
|
|
c->g = g;
|
|
c->b = b;
|
|
c->alloc = 1;
|
|
c->c.elements.r = (float)r / (float)0xFFFF;
|
|
c->c.elements.g = (float)g / (float)0xFFFF;
|
|
c->c.elements.b = (float)b / (float)0xFFFF;
|
|
c->c.elements.a = 1.0;
|
|
return 1;
|
|
};
|
|
|
|
|
|
void gfx_clear (struct image *dimg, struct color *c) {
|
|
gfx_fbo_switch (dimg);
|
|
glClearColor(c->c.elements.r, c->c.elements.g, c->c.elements.b, 1.0f );
|
|
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
};
|
|
|
|
|
|
/*
|
|
* draw line */
|
|
void gfx_draw_line (struct image *dimg, int x1, int y1, int x2, int y2, struct line_style style) {
|
|
GLfloat vp[] = {x1, y1, 0.0, x2, y2, 0.0};
|
|
gfx_fbo_switch (dimg);
|
|
|
|
if (style.width < 1.0) style.width = 1.0;
|
|
glLineWidth (style.width);
|
|
|
|
glUseProgram (engine.gles_prgobject);
|
|
glUniform1i (engine.gles_txenabled, 0);
|
|
glUniform4fv(engine.gles_color, 1, style.c.c.array);
|
|
glVertexAttribPointer (engine.gles_pos, 3, GL_FLOAT, GL_FALSE, 0, vp);
|
|
glDrawArrays(GL_LINES,0,2);
|
|
};
|
|
|
|
|
|
/*
|
|
* draw polygon
|
|
*/
|
|
void gfx_draw_polygon (struct image *dimg, iPoint *p, int pcnt, struct line_style style, struct color c) {
|
|
static GLfloat *polygon = NULL;
|
|
static int polygon_cnt = 0;
|
|
int i;
|
|
|
|
if (polygon_cnt < pcnt) { /* copied from GTK port.. if here is a bug, there is one as well.. */
|
|
polygon_cnt = pcnt;
|
|
if (polygon != NULL)
|
|
polygon = (GLfloat *) ml_realloc (polygon, sizeof (GLfloat) * polygon_cnt * 3);
|
|
else
|
|
polygon = (GLfloat *) ml_malloc (sizeof (GLfloat) * polygon_cnt * 3);
|
|
}
|
|
|
|
for (i = 0; i < pcnt; i++) {
|
|
polygon[i*3] = p[i].x;
|
|
polygon[i*3+1] = p[i].y;
|
|
polygon[i*3+2] = 0.0;
|
|
}
|
|
|
|
gfx_fbo_switch (dimg);
|
|
|
|
glUseProgram (engine.gles_prgobject);
|
|
glUniform1i (engine.gles_txenabled, 0);
|
|
glUniform4fv(engine.gles_color, 1, c.c.array);
|
|
glVertexAttribPointer (engine.gles_pos, 3, GL_FLOAT, GL_FALSE, 0, polygon);
|
|
glDrawArrays (GL_TRIANGLE_FAN, 0, pcnt);
|
|
};
|
|
|
|
|
|
/*
|
|
* text drawing functions
|
|
*/
|
|
void gfx_draw_text (struct image *dimg, int x, int y, char *text, struct color *c) {
|
|
gfx_fbo_switch (dimg);
|
|
glUniform4fv(engine.gles_color, 1, c->c.array);
|
|
font_draw (drawfont, text, x, y+16, 1.0, 1.0);
|
|
};
|
|
|
|
|
|
/*
|
|
* drawing bitmap on the screen
|
|
*/
|
|
void gfx_draw_img (struct image *dimg, int dx, int dy, int dw, int dh, struct image *simg, int sx, int sy) {
|
|
GLfloat vp[] = { dx, dy, 0.0,
|
|
dx, dy+dh, 0.0,
|
|
dx+dw, dy+dh, 0.0,
|
|
dx+dw, dy, 0.0};
|
|
float fx = (float) sx/(float) simg->width;
|
|
float fy = (float) sy/(float) simg->height;
|
|
float fw = (float) dw/(float) simg->width;
|
|
float fh = (float) dh/(float) simg->height;
|
|
GLfloat vt[] = { fx, fy,
|
|
fx, fy+fh,
|
|
fx+fw, fy+fh,
|
|
fx+fw, fy };
|
|
GLfloat colwhite[] = { 1.0, 1.0, 1.0, 1.0 };
|
|
int i;
|
|
if (simg == NULL) {
|
|
d_printf ("ERROR: gfx_draw_img simg:%p", simg);
|
|
return;
|
|
}
|
|
gfx_fbo_switch (dimg);
|
|
|
|
/* somehow frame buffered devices are upside down */
|
|
if (simg->fbo_id) for (i = 0; i < 4; i++) vt[i*2+1] = 1.0-vt[i*2+1];
|
|
|
|
glEnable (GL_TEXTURE_2D);
|
|
glActiveTexture (GL_TEXTURE0);
|
|
glBindTexture (GL_TEXTURE_2D, simg->txt_id);
|
|
glUniform1i (engine.gles_txenabled, 1);
|
|
glUniform4fv(engine.gles_color, 1, colwhite);
|
|
glUniform1i(engine.gles_txsampler, 0);
|
|
|
|
glVertexAttribPointer (engine.gles_pos, 3, GL_FLOAT, GL_FALSE, 0, vp);
|
|
glVertexAttribPointer (engine.gles_txcoord, 2, GL_FLOAT, GL_FALSE, 0, vt);
|
|
|
|
glDrawArrays(GL_TRIANGLE_FAN,0,4);
|
|
glUniform1i (engine.gles_txenabled, 0);
|
|
glBindTexture (GL_TEXTURE_2D, 0);
|
|
glDisable (GL_TEXTURE_2D);
|
|
};
|
|
|
|
|
|
/*
|
|
* allocate memory bitmap
|
|
*/
|
|
struct image *gfx_img_alloc (int w, int h) {
|
|
struct image *img;
|
|
GLenum status;
|
|
|
|
img = (struct image *) ml_malloc (sizeof (struct image));
|
|
img->width = w;
|
|
img->height = h;
|
|
img->rbo_id = 0;
|
|
img->txt_id = 0;
|
|
img->fbo_id = 0;
|
|
img->srb_id = 0;
|
|
img->data = NULL;
|
|
img->img_id = (++gfx_last_alloc_img);
|
|
|
|
d_printf ("gfx_img_alloc img_id:%d size: %d x %d", img->img_id, w, h);
|
|
|
|
glGenFramebuffers(1, &img->fbo_id);
|
|
glGenTextures(1, &img->txt_id);
|
|
glGenRenderbuffers(1, &img->rbo_id);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, img->fbo_id);
|
|
|
|
// initialize color texture
|
|
glBindTexture(GL_TEXTURE_2D, img->txt_id);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, img->txt_id, 0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
// initialize depth renderbuffer
|
|
glBindRenderbuffer(GL_RENDERBUFFER, img->rbo_id);
|
|
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, w, h);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, img->rbo_id);
|
|
|
|
/*
|
|
* create renderbuffer oobject */
|
|
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
if(status != GL_FRAMEBUFFER_COMPLETE) {
|
|
d_printf ("could not create framebuffer object w:%d h:%d txt_id:%d rbo_id:%d fbo_id:%d status:%d",
|
|
img->width, img->height, img->txt_id, img->rbo_id, img->fbo_id, status);
|
|
errorexit (-1);
|
|
}
|
|
|
|
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
|
|
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
|
|
glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
|
|
glClearDepthf( 1.0f );
|
|
|
|
glEnable( GL_BLEND );
|
|
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
|
|
/* switch back framebuffer to default */
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
return img;
|
|
};
|
|
|
|
|
|
void gfx_img_free (struct image *img) {
|
|
d_printf ("gfx_img_free img:%p data:%p", img, img == NULL? NULL : img->data);
|
|
glDeleteFramebuffers (1, &img->fbo_id);
|
|
glDeleteRenderbuffers (1, &img->rbo_id);
|
|
glDeleteTextures (1, &img->txt_id);
|
|
if (img->data) ml_free (img->data);
|
|
if (img) ml_free (img);
|
|
};
|
|
|
|
|
|
void gfx_draw_rect (struct image *dimg, int x1, int y1, int x2, int y2, struct color *c) {
|
|
GLfloat vp[] = { x1, y1, 0.0,
|
|
x1, y2, 0.0,
|
|
x2, y2, 0.0,
|
|
x2, y1, 0.0 };
|
|
gfx_fbo_switch (dimg);
|
|
|
|
glUseProgram (engine.gles_prgobject);
|
|
glUniform1i (engine.gles_txenabled, 0);
|
|
glUniform4fv(engine.gles_color, 1, c->c.array);
|
|
glVertexAttribPointer (engine.gles_pos, 3, GL_FLOAT, GL_FALSE, 0, vp);
|
|
glDrawArrays (GL_TRIANGLE_FAN, 0, 4);
|
|
};
|
|
|
|
|
|
#define HEADER_SIZE 8
|
|
AAsset* gfxpng_asset = NULL;
|
|
void png_asset_read(png_structp png, png_bytep data, png_size_t size) {
|
|
int remain;
|
|
AAsset_read(gfxpng_asset, data, size);
|
|
remain = AAsset_getRemainingLength(gfxpng_asset);
|
|
};
|
|
|
|
|
|
struct image* gfx_img_load (char *name) {
|
|
AAssetManager *mgr = engine.app->activity->assetManager;
|
|
off_t size;
|
|
int bytesremaining;
|
|
int bytesread;
|
|
int bit_depth, color_type;
|
|
int transparency, i, rowbytes;
|
|
png_uint_32 twidth, theight;
|
|
png_byte* buffer = NULL;
|
|
png_byte* image_data = NULL;
|
|
png_bytep *row_pointers = NULL;
|
|
png_structp png_ptr = NULL;
|
|
png_infop info_ptr = NULL;
|
|
png_infop end_info = NULL;
|
|
struct image *img = NULL;
|
|
|
|
if ((gfxpng_asset = AAssetManager_open(mgr, name, AASSET_MODE_UNKNOWN)) == 0) {
|
|
LOGW("Asset \"%s\" not found.", name);
|
|
return NULL;
|
|
}
|
|
|
|
size = AAsset_getLength(gfxpng_asset);
|
|
buffer = malloc (sizeof (png_byte)*HEADER_SIZE);
|
|
|
|
bytesread = AAsset_read(gfxpng_asset, buffer, HEADER_SIZE);
|
|
bytesremaining = AAsset_getRemainingLength(gfxpng_asset);
|
|
|
|
if (png_sig_cmp(buffer, 0, 8)) {
|
|
LOGW("File %s format is not PNG.", name);
|
|
return NULL;
|
|
}
|
|
|
|
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
if (!png_ptr) {
|
|
LOGW("Unable to create PNG structure: %s", name);
|
|
return NULL;
|
|
}
|
|
|
|
info_ptr = png_create_info_struct(png_ptr);
|
|
if (!info_ptr) {
|
|
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
|
|
LOGW("Unable to create png info : %s", name);
|
|
return NULL;
|
|
}
|
|
|
|
end_info = png_create_info_struct(png_ptr);
|
|
if (!end_info) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
|
|
LOGW("Unable to create png end info : %s", name);
|
|
return NULL;
|
|
}
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr))) {
|
|
LOGW("Error during setjmp : %s", name);
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
|
|
return NULL;
|
|
}
|
|
png_set_read_fn(png_ptr, NULL, png_asset_read);
|
|
png_set_sig_bytes(png_ptr, 8);
|
|
png_read_info(png_ptr, info_ptr);
|
|
png_get_IHDR(png_ptr, info_ptr, &twidth, &theight, &bit_depth, &color_type,
|
|
NULL, NULL, NULL);
|
|
d_printf ("Width: %d, height: %d, Depth: %d", twidth, theight, bit_depth);
|
|
|
|
transparency = FALSE;
|
|
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
|
|
png_set_tRNS_to_alpha(png_ptr);
|
|
transparency = TRUE;
|
|
}
|
|
|
|
if (bit_depth < 8) png_set_packing (png_ptr);
|
|
else if (bit_depth >16) png_set_strip_16 (png_ptr);
|
|
|
|
img = (struct image *) ml_malloc (sizeof (struct image));
|
|
img->width = twidth;
|
|
img->height = theight;
|
|
img->rbo_id = 0;
|
|
img->txt_id = 0;
|
|
img->fbo_id = 0;
|
|
img->img_id = (++gfx_last_alloc_img);
|
|
|
|
switch (color_type) {
|
|
case PNG_COLOR_TYPE_PALETTE:
|
|
png_set_palette_to_rgb(png_ptr);
|
|
img->data_fmt = transparency ? GL_RGBA : GL_RGB;
|
|
break;
|
|
case PNG_COLOR_TYPE_RGB:
|
|
img->data_fmt = transparency ? GL_RGBA : GL_RGB;
|
|
break;
|
|
case PNG_COLOR_TYPE_RGBA:
|
|
img->data_fmt = GL_RGBA;
|
|
break;
|
|
default:
|
|
d_printf ("unknown color_type:%x", color_type);
|
|
break;
|
|
}
|
|
|
|
png_read_update_info(png_ptr, info_ptr);
|
|
|
|
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
|
|
LOGI("Row size: %d bytes.", rowbytes);
|
|
|
|
img->data = (uint8_t*) ml_malloc (sizeof (png_byte) * rowbytes * theight);
|
|
if (!img->data) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
|
|
LOGW("Unable to allocate image_data while loading %s ", name);
|
|
exit (0);
|
|
}
|
|
|
|
row_pointers = malloc (sizeof (png_bytep) *theight);
|
|
if (!row_pointers) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
|
|
ml_free (img->data);
|
|
LOGW("Unable to allocate row_pointer while loading %s ", name);
|
|
exit (0);
|
|
}
|
|
for (i = 0; i < theight; ++i)
|
|
row_pointers[i] = img->data + i * rowbytes;
|
|
|
|
png_read_image(png_ptr, row_pointers);
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
|
|
AAsset_close(gfxpng_asset);
|
|
|
|
free (buffer);
|
|
free (row_pointers);
|
|
|
|
glGenTextures (1, &img->txt_id);
|
|
glBindTexture (GL_TEXTURE_2D, img->txt_id);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexImage2D (GL_TEXTURE_2D, 0, img->data_fmt, img->width, img->height, 0,
|
|
img->data_fmt, GL_UNSIGNED_BYTE, img->data);
|
|
glBindTexture (GL_TEXTURE_2D, 0);
|
|
|
|
d_printf ("image loaded");
|
|
|
|
return img;
|
|
};
|