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.
442 lines
12 KiB
442 lines
12 KiB
/***************************************************************************
|
|
* wince_gfx.c
|
|
*
|
|
* December 2009, Steffen Pohle steffen@gulpe.de
|
|
****************************************************************************/
|
|
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
#include <png.h>
|
|
|
|
#include "osmroute.h"
|
|
|
|
#include "draw.h"
|
|
#include "memoryleak.h"
|
|
#include "system.h"
|
|
|
|
iPoint gfx_screensize = {0, 0};
|
|
int gfx_last_alloc_img = 0;
|
|
int gfx_last_img_fbo = 0;
|
|
|
|
void gfx_fbo_switch (struct image *img);
|
|
|
|
/*****************************************************************************/
|
|
|
|
void gfx_init (int width, int height) {
|
|
/* init viewport */
|
|
glViewport( 0, 0, ( GLint )width, ( GLint )height );
|
|
glMatrixMode( GL_PROJECTION );
|
|
glLoadIdentity( );
|
|
glOrtho( 0.0f, width, height, 0.0f, -1.0f, 1.0f );
|
|
glMatrixMode( GL_MODELVIEW );
|
|
glLoadIdentity( );
|
|
|
|
/* init opengl */
|
|
glShadeModel( GL_SMOOTH );
|
|
glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
|
|
glClearDepth( 1.0f );
|
|
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
|
|
glEnable( GL_BLEND );
|
|
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
|
|
gfx_screensize.x = width;
|
|
gfx_screensize.y = height;
|
|
gfx_resize (width, height);
|
|
};
|
|
|
|
|
|
void gfx_resize (int width, int height) {
|
|
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 () {
|
|
gfx_fbo_switch (NULL);
|
|
glFlush();
|
|
glFinish ();
|
|
SDL_GL_SwapBuffers();
|
|
};
|
|
|
|
|
|
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) {
|
|
gfx_last_img_fbo = 0;
|
|
glBindFramebuffer (GL_FRAMEBUFFER, 0);
|
|
glViewport (0, 0, gfx_screensize.x, gfx_screensize.y);
|
|
glMatrixMode( GL_PROJECTION );
|
|
glLoadIdentity( );
|
|
glOrtho( 0.0f, gfx_screensize.x, gfx_screensize.y, 0.0f, -1.0f, 1.0f );
|
|
glMatrixMode( GL_MODELVIEW );
|
|
glLoadIdentity( );
|
|
}
|
|
else if (gfx_last_img_fbo == img->img_id) return;
|
|
else {
|
|
gfx_last_img_fbo = img->img_id;
|
|
glBindFramebuffer (GL_FRAMEBUFFER, img->fbo_id);
|
|
glViewport (0, 0, img->width, img->height);
|
|
glMatrixMode( GL_PROJECTION );
|
|
glLoadIdentity( );
|
|
glOrtho( 0.0f, img->width, 0.0f, img->height, -1.0f, 1.0f );
|
|
glMatrixMode( GL_MODELVIEW );
|
|
glLoadIdentity( );
|
|
}
|
|
};
|
|
|
|
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.r = (float)r / (float)0xFFFF;
|
|
c->c.g = (float)g / (float)0xFFFF;
|
|
c->c.b = (float)b / (float)0xFFFF;
|
|
return 1;
|
|
};
|
|
|
|
|
|
void gfx_clear (struct image *dimg, struct color *c) {
|
|
gfx_fbo_switch (dimg);
|
|
glClearColor(c->c.r, c->c.g, c->c.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) {
|
|
/* polygon mit runden ecken....? bei width > 1 */
|
|
gfx_fbo_switch (dimg);
|
|
if (style.width < 1.0) style.width = 1.0;
|
|
glLineWidth (style.width);
|
|
glColor3f (style.c.c.r, style.c.c.g, style.c.c.b);
|
|
glBegin (GL_LINES);
|
|
glVertex2i (x1, y1);
|
|
glVertex2i (x2, y2);
|
|
glEnd ();
|
|
};
|
|
|
|
|
|
/*
|
|
* draw polygon
|
|
*/
|
|
void gfx_draw_polygon (struct image *dimg, iPoint *p, int pcnt, struct line_style style, struct color c) {
|
|
int i;
|
|
|
|
gfx_fbo_switch (dimg);
|
|
glBegin (GL_POLYGON);
|
|
glColor4f (c.c.r, c.c.g, c.c.b, 1.0f);
|
|
for (i = 0; i < pcnt; i++)
|
|
glVertex2i (p[i].x, p[i].y);
|
|
glEnd ();
|
|
|
|
// glBegin (GL_LINES);
|
|
// d_printf ("line width: %f",style.width);
|
|
// glLineWidth (style.width/2.0);
|
|
// glColor4f (style.c.c.r, style.c.c.g, style.c.c.b, 1.0f);
|
|
// for (i = 0; i < pcnt; i++)
|
|
// glVertex2i (p[i].x, p[i].y);
|
|
// glEnd ();
|
|
};
|
|
|
|
|
|
/*
|
|
* text drawing functions
|
|
*/
|
|
void gfx_draw_text (struct image *dimg, int x, int y, char *text, struct color *c) {
|
|
gfx_fbo_switch (dimg);
|
|
};
|
|
|
|
|
|
/*
|
|
* 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) {
|
|
float fx, fy, fw, fh;
|
|
|
|
gfx_fbo_switch (dimg);
|
|
glEnable (GL_TEXTURE_2D);
|
|
glBindTexture (GL_TEXTURE_2D, simg->txt_id);
|
|
|
|
glBegin (GL_QUADS);
|
|
glColor4f (1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
fx = (float) sx/(float) simg->width;
|
|
fy = (float) sy/(float) simg->height;
|
|
fw = (float) dw/(float) simg->width;
|
|
fh = (float) dh/(float) simg->height;
|
|
|
|
glTexCoord2d (fx, fy);
|
|
glVertex2i (dx, dy);
|
|
glTexCoord2d (fx, fy+fh);
|
|
glVertex2i (dx, dy+dh);
|
|
glTexCoord2d (fx+fw, fy+fh);
|
|
glVertex2i (dx+dw, dy+dh);
|
|
glTexCoord2d (fx+fw, fy);
|
|
glVertex2i (dx+dw, dy);
|
|
|
|
glEnd ();
|
|
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 = ml_malloc (sizeof (struct image));
|
|
img->width = w;
|
|
img->height = h;
|
|
img->rbo_id = 0;
|
|
img->txt_id = 0;
|
|
img->fbo_id = 0;
|
|
img->img_id = (++gfx_last_alloc_img);
|
|
d_printf ("gfx_img_alloc img_id:%d size: %d x %d", img->img_id, w, h);
|
|
|
|
/*
|
|
* create texture object */
|
|
glGenTextures(1, &img->txt_id);
|
|
glBindTexture(GL_TEXTURE_2D, img->txt_id);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, img->width, img->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
/*
|
|
* create renderbuffer oobject */
|
|
glGenRenderbuffers(1, &img->rbo_id);
|
|
glBindRenderbuffer(GL_RENDERBUFFER, img->rbo_id);
|
|
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, img->width, img->height);
|
|
glBindRenderbuffer(GL_RENDERBUFFER, 0);
|
|
|
|
/*
|
|
* create framebuffer object */
|
|
glGenFramebuffers(1, &img->fbo_id);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, img->fbo_id);
|
|
|
|
/* attach renderbuffer and texture color to the framebuffer */
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, img->txt_id, 0);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, img->rbo_id);
|
|
|
|
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);
|
|
}
|
|
|
|
glMatrixMode( GL_PROJECTION );
|
|
glLoadIdentity( );
|
|
glOrtho( 0.0f, w, h, 0.0f, -1.0f, 1.0f );
|
|
glMatrixMode( GL_MODELVIEW );
|
|
glLoadIdentity( );
|
|
|
|
/* init opengl */
|
|
glShadeModel( GL_SMOOTH );
|
|
glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
|
|
glClearDepth( 1.0f );
|
|
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
|
|
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");
|
|
glDeleteFramebuffers (1, &img->fbo_id);
|
|
glDeleteRenderbuffers (1, &img->rbo_id);
|
|
glDeleteTextures (1, &img->txt_id);
|
|
if (img) ml_free (img);
|
|
};
|
|
|
|
|
|
void gfx_draw_rect (struct image *dimg, int x1, int y1, int x2, int y2, struct color *c) {
|
|
};
|
|
|
|
|
|
|
|
#define HEADER_SIZE 8
|
|
int gfxpng_fd = 0;
|
|
void png_fd_read(png_structp png, png_bytep data, png_size_t size) {
|
|
read(gfxpng_fd, data, size);
|
|
};
|
|
|
|
|
|
struct image* gfx_img_load (char *name) {
|
|
int bit_depth, color_type;
|
|
int transparency, i, rowbytes;
|
|
png_uint_32 twidth, theight;
|
|
png_byte* buffer = 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;
|
|
char fname[LEN_FILENAME];
|
|
struct stat st_buf;
|
|
|
|
sprintf (fname, "%s/%s", cfg.appdatapath, name);
|
|
if ((gfxpng_fd = open(fname, O_RDONLY)) == 0) {
|
|
d_printf ("File %s not found.", name);
|
|
return NULL;
|
|
}
|
|
fstat (gfxpng_fd, &st_buf);
|
|
buffer = malloc (sizeof (png_byte)*HEADER_SIZE);
|
|
|
|
read(gfxpng_fd, buffer, HEADER_SIZE);
|
|
if (png_sig_cmp(buffer, 0, 8)) {
|
|
d_printf ("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) {
|
|
d_printf ("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);
|
|
d_printf ("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);
|
|
d_printf ("Unable to create png end info : %s", name);
|
|
return NULL;
|
|
}
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr))) {
|
|
d_printf ("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_fd_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);
|
|
d_printf ("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);
|
|
d_printf ("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);
|
|
d_printf ("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);
|
|
close(gfxpng_fd);
|
|
|
|
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;
|
|
};
|