bool gl_init ()
{
glClearColor (0.5, 0.5, 1.0, 0.0);
#ifdef ANDROID
glClearDepthf (1.0);
#else
glClearDepth (1.0);
#endif
glDepthFunc (GL_LEQUAL);
glEnable (GL_DEPTH_TEST);
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable (GL_TEXTURE_2D);
#ifndef ANDROID
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
glDisable (GL_ALPHA_TEST);
#endif
/* nacteni a kompilace shaderu */
shader[0] = shader_init ("data/shader_ter");
shader[1] = shader_init ("data/shader_skybox");
/* definice osvetleni */
light[0].ambient[0] = light[0].ambient[1] = light[0].ambient[2] = 0.2f;
light[0].ambient[3] = 1.0f;
light[0].diffuse[0] = light[0].diffuse[1] = light[0].diffuse[2] = 0.3f;
light[0].diffuse[3] = 1.0f;
light[0].specular[0] = light[0].specular[1] = light[0].specular[2] = 0.6f;
light[0].specular[3] = 1.0f;
light[0].position[0] = 0.0f;
light[0].position[1] = 0.0f;
light[0].position[2] = 100.0f;
light[0].position[3] = 0.0f;
light[0].name = strdup ("light");
/* definice materialu */
mat[0].ambient[0] = mat[0].ambient[1] = mat[0].ambient[2] = 1.4f;
mat[0].ambient[3] = 1.0f;
mat[0].diffuse[0] = mat[0].diffuse[1] = mat[0].diffuse[2] = 0.1f;
mat[0].diffuse[3] = 1.0f;
mat[0].specular[0] = mat[0].specular[1] = mat[0].specular[2] = mat[0].specular[3] = 0.15f;
mat[0].name = strdup ("material");
gl_mutex = SDL_CreateMutex ();
if (!gl_mutex) {
fprintf (stderr, "Couldn't create mutex\n");
return false;
}
gl_init_skybox ();
return true;
}
bool font_init ()
{
#ifndef ANDROID
TTF_Init ();
font = TTF_OpenFont ("data/DejaVuSans.ttf", 12);
if (!font)
return false;
#endif
GLfloat buf[] = {
//x, y, z, u ,v
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
};
vbo_id = vbo_alloc ((void *) buf, sizeof (buf));
shader = shader_init ("data/shader_font");
return true;
}
struct game *
ejoy2d_game() {
struct game *G = (struct game *)malloc(sizeof(*G));
lua_State *L = luaL_newstate();
checkluaversion(L);
lua_pushliteral(L, OS_STRING);
lua_setglobal(L , "OS");
G->L = L;
G->real_time = 0;
G->logic_time = 0;
lua_atpanic(L, _panic);
luaL_openlibs(L);
luaL_requiref(L, "ejoy2d.shader.c", ejoy2d_shader, 0);
luaL_requiref(L, "ejoy2d.framework", ejoy2d_framework, 0);
luaL_requiref(L, "ejoy2d.ppm", ejoy2d_ppm, 0);
luaL_requiref(L, "ejoy2d.spritepack.c", ejoy2d_spritepack, 0);
luaL_requiref(L, "ejoy2d.sprite.c", ejoy2d_sprite, 0);
luaL_requiref(L, "ejoy2d.matrix.c", ejoy2d_matrix, 0);
luaL_requiref(L, "ejoy2d.particle.c", ejoy2d_particle, 0);
lua_settop(L,0);
shader_init();
label_load();
return G;
}
void setup() {
glClearColor(0,0,0,1);
vbo = vbo_init(shooter.pos,indices);
shader = shader_init("../shaders/shooter.vs","../shaders/shooter.fs");
bind_attribute(shader,0,"coord");
}
bool gl_water_init ()
{
#ifdef OLD
water_surf = (float *) malloc (6 * WATER_RES * (WATER_RES + 1) * sizeof (float));
if (!water_surf)
return false;
water_norm = (float *) malloc (6 * WATER_RES * (WATER_RES + 1) * sizeof (float));
if (!water_norm)
return false;
#endif
GLfloat buf[] = {
//x, y, z, u ,v
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
};
vbo_id = vbo_alloc ((void *) buf, sizeof (buf));
shader = shader_init ("data/shader_water");
return true;
}
/* draw3D {{{*/
void gl_drawbones(Armature *arm, int frame, float *mMat, float *vMat, float *pMat)
{
static Shader *drawbones;
static GLuint tmatloc;
static GLuint bone_enloc;
static GLuint boneloc;
static int once = 1;
if(once)
{
drawbones = malloc(sizeof(Shader));
shader_init(drawbones, "clockwork/glsl/drawbones");
shader_add_attrib(drawbones, "position", 3, GL_FLOAT, false, 32, (void*) 0);
shader_add_fragment_output(drawbones, "fragColor");
tmatloc = glGetUniformLocation(drawbones->program, "t_matrix");
bone_enloc = glGetUniformLocation(drawbones->program, "bones_enable");
boneloc = glGetUniformLocation(drawbones->program, "bones");
once = 0;
}
glDisable(GL_DEPTH_TEST);
static GLuint bonetmp = 0;
if(!bonetmp)
{
glGenBuffers(1, &bonetmp);
}
glBindBuffer(GL_ARRAY_BUFFER, bonetmp);
glBufferData(GL_ARRAY_BUFFER, arm->nbones * 64, NULL, GL_STREAM_DRAW);
struct Mesh_vert *bones = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
int i;
for(i = 0; i < arm->nbones; i++)
{
//TODO: remove
memcpy(&bones[i * 2].position, &arm->bones[i].head, sizeof(float[3]));
memcpy(&bones[i * 2 + 1].position, &arm->bones[i].tail, sizeof(float[3]));
}
glUnmapBuffer(GL_ARRAY_BUFFER);
mat4 t_matrix;
mat4_identity(t_matrix);
mat4_mult(mMat, t_matrix, t_matrix);
mat4_mult(vMat, t_matrix, t_matrix);
mat4_mult(pMat, t_matrix, t_matrix);
gl_bindshader(drawbones);
gl_bindshaderattributes(); //TODO: remove
glUniformMatrix4fv(tmatloc, 1, true, t_matrix);
glUniform1i(bone_enloc, true);
mat4 *m = alloca(arm->nbones * sizeof(mat4));
armature_matrices(arm, frame, m);
glUniformMatrix4fv(boneloc, arm->nbones, true, (float*)m);
glDrawArrays(GL_LINES, 0, arm->nbones * 2);
glBindBuffer(GL_ARRAY_BUFFER, 0);
gl_unbindshader();
glEnable(GL_DEPTH_TEST);
}
int init_shader(struct shader *sh, const char *vp, const char *fp)
{
if (shader_init(sh) < 0)
return -1;
if (shader_read_file(sh, GL_VERTEX_SHADER, vp) < 0)
return -1;
if (shader_read_file(sh, GL_FRAGMENT_SHADER, fp) < 0)
return -1;
if (shader_compile(sh) < 0 || shader_link(sh) < 0)
return -1;
return 0;
}
/* draw2D {{{*/
void gl_drawtexture(Texture *t, float *pos, float rotation)
{
static float default_pos[2] = {0.0f, 0.0f};
static GLuint tmatloc;
static Shader *drawtexture;
static int once = 1;
if(once)
{
drawtexture = malloc(sizeof(Shader));
shader_init(drawtexture, "clockwork/glsl/drawtexture");
shader_add_attrib(drawtexture, "position", 2, GL_FLOAT, false, 32, (void*) 0);
shader_add_fragment_output(drawtexture, "fragColor");
shader_add_texture_target(drawtexture, "tex0", 0);
tmatloc = glGetUniformLocation(drawtexture->program, "tmat");
once = 0;
}
if(!pos)
{
pos = default_pos;
}
matn tmat = alloca(sizeof(float[16]));
matn_init(tmat, 3);
float tsize[3] = {(float) t->w, (float) t->h, 1.0f};
float invfbsize[3] = {(float) 1.0f / (float) acv_framebuffer_w(FRAMEBUFFER_OUTPUT),
(float) 1.0f / (float) acv_framebuffer_h(FRAMEBUFFER_OUTPUT), 1.0f};
matn_scalev(tmat, 3, tsize);
mat3_rotate(tmat, 0.0f, 0.0f, rotation);
matn_scalev(tmat, 3, invfbsize);
mat3_translate(tmat, pos[0] / (float) acv_framebuffer_w(FRAMEBUFFER_OUTPUT),
pos[1] / (float) acv_framebuffer_h(FRAMEBUFFER_OUTPUT));
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
gl_bindshader(drawtexture);
gl_bindtexture(t, 0);
glBindVertexArray(UNIT_SQUARE_VAO);
glUniformMatrix3fv(tmatloc, 1, false, tmat);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
gl_unbindtexture(0);
gl_unbindshader();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
}
int pixel_init(lua_State *L) {
luaL_checkversion(L);
luaL_requiref(L, "pixel.framework", pixel_framework, 0);
luaL_requiref(L, "pixel.texture", pixel_texture, 0);
luaL_requiref(L, "pixel.shader", pixel_shader, 0);
luaL_requiref(L, "pixel.renderbuffer", pixel_renderbuffer, 0);
luaL_requiref(L, "pixel.matrix", pixel_matrix, 0);
luaL_requiref(L, "pixel.color", pixel_color, 0);
luaL_requiref(L, "pixel.geometry", pixel_geometry, 0);
luaL_requiref(L, "pixel.sprite", pixel_sprite, 0);
luaL_requiref(L, "pixel.spritepack", pixel_spritepack, 0);
luaL_requiref(L, "pixel.particle", pixel_particle, 0);
lua_settop(L, 0);
shader_init();
texture_init();
label_init(0);
return 0;
}
/* lighting {{{*/
void gl_lightambient(float color[3])
{
/*{{{ XXX REMOVE*/
static Shader *lightambient;
gl_swapioframebuffers();
static GLBProgram *glbprogram;
static int once = 1;
if(once)
{
/*
glbprogram = glbCreateProgram(NULL);
glbProgramAttachNewShaderSourceFile(glbprogram,
"clockwork/glsl/lighting/ambient.vs", GLB_VERTEX_SHADER);
glbProgramAttachNewShaderSourceFile(glbprogram,
"clockwork/glsl/lighting/ambient.fs", GLB_FRAGMENT_SHADER);
*/
//TODO: rest of shader
lightambient = malloc(sizeof(Shader));
shader_init(lightambient, "clockwork/glsl/lighting/ambient");
shader_add_attrib(lightambient, "position", 2, GL_FLOAT, false, 32, (void*) 0);
shader_add_texture_target(lightambient, "inDepth", 0);
shader_add_texture_target(lightambient, "inColor", 1);
shader_add_texture_target(lightambient, "inNormal", 2);
shader_add_texture_target(lightambient, "inLight", 3);
shader_add_fragment_output(lightambient, "outColor");
shader_add_fragment_output(lightambient, "outNormal");
shader_add_fragment_output(lightambient, "outLight");
once = 0;
}
gl_bindshader(lightambient);
glBindVertexArray(UNIT_SQUARE_VAO);
gl_bindtextures(framebuffer_textures(acv_framebuffers[FRAMEBUFFER_INPUT]),
framebuffer_ntextures(acv_framebuffers[FRAMEBUFFER_INPUT]));
shader_set_parameter(lightambient, "ambient_color", color, sizeof(float[3]));
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
gl_unbindshader();/*}}}*/
//ambient = vec3_addp(color, &ambient);
}
//TODO: buffer directional light, drawing 8/16 lights at a time
//TODO: convert lighting direction to eye space, pass in MVP?
void gl_lightdirect(float color[3], float dir[3])
{
static Shader *lightdirect;
gl_swapioframebuffers();
static GLBProgram *program;
static int once = 1;
if(once)
{
program = glbCreateProgram(NULL);
glbProgramAttachNewShaderSourceFile(program,
"clockwork/glsl/lighting/direct.vs", GLB_VERTEX_SHADER);
glbProgramAttachNewShaderSourceFile(program,
"clockwork/glsl/lighting/direct.fs", GLB_FRAGMENT_SHADER);
lightdirect = malloc(sizeof(Shader));
shader_init(lightdirect, "clockwork/glsl/lighting/direct");
shader_add_attrib(lightdirect, "position", 2, GL_FLOAT, false, 32, (void*) 0);
shader_add_texture_target(lightdirect, "inDepth", 0);
shader_add_texture_target(lightdirect, "inColor", 1);
shader_add_texture_target(lightdirect, "inNormal", 2);
shader_add_texture_target(lightdirect, "inLight", 3);
shader_add_fragment_output(lightdirect, "outColor");
shader_add_fragment_output(lightdirect, "outNormal");
shader_add_fragment_output(lightdirect, "outLight");
once = 0;
}
gl_bindshader(lightdirect);
glBindVertexArray(UNIT_SQUARE_VAO);
gl_bindtextures(framebuffer_textures(acv_framebuffers[FRAMEBUFFER_INPUT]),
framebuffer_ntextures(acv_framebuffers[FRAMEBUFFER_INPUT]));
shader_set_parameter(lightdirect, "light_color", color, sizeof(float[3]));
shader_set_parameter(lightdirect, "light_direction", dir, sizeof(float[3]));
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
gl_unbindshader();
//glbProgramOutput(program, ...);
glbProgramUniform(program, GL_FRAGMENT_SHADER, 0, sizeof(float[3]), color);
glbProgramUniform(program, GL_FRAGMENT_SHADER, 1, sizeof(float[3]), dir);
//glbProgramDraw(program, ...array...);
}
void gl_init_spatter()
{
shader[0] = shader_init ("data/shader_spatter");
//x y z u v
const GLfloat buf[] = {
0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f
};
glGenBuffers (1, &vbo_spatter_id);
glBindBuffer (GL_ARRAY_BUFFER, vbo_spatter_id);
glBufferData (GL_ARRAY_BUFFER, sizeof (buf), buf, GL_STATIC_DRAW);
}
void gl_drawframebuffer(void)
{
//TODO: clean up this silly conditional
Framebuffer *f = acv_framebuffers[FRAMEBUFFER_INPUT];
gl_swapioframebuffers();
gl_unbindframebuffer(FRAMEBUFFER_OUTPUT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
static Shader *drawframebuffer;
static int once = 1;
if(once)
{
drawframebuffer = malloc(sizeof(Shader));
shader_init(drawframebuffer, "glsl/drawframebuffer");
shader_add_attrib(drawframebuffer, "position", 2, GL_FLOAT, false, 32, (void*) 0);
shader_add_fragment_output(drawframebuffer, "outColor");
shader_add_texture_target(drawframebuffer, "depthTex", 0);
shader_add_texture_target(drawframebuffer, "colorTex", 1);
shader_add_texture_target(drawframebuffer, "normalTex", 2);
shader_add_texture_target(drawframebuffer, "lightTex", 3);
once = 0;
}
glViewport(0, 0, acv_framebuffer_w(FRAMEBUFFER_OUTPUT), acv_framebuffer_h(FRAMEBUFFER_OUTPUT));
//gl_bindframebuffer(f, FRAMEBUFFER_INPUT);
gl_bindtextures(framebuffer_textures(acv_framebuffers[FRAMEBUFFER_INPUT]),
framebuffer_ntextures(acv_framebuffers[FRAMEBUFFER_INPUT]));
gl_bindshader(drawframebuffer);
glBindVertexArray(UNIT_SQUARE_VAO);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
//gl_unbindframebuffer(FRAMEBUFFER_INPUT);
gl_unbindshader();
//if(output) //TODO: clean up this too
{
gl_bindframebuffer(f, FRAMEBUFFER_OUTPUT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
}
void
ejoy2d_init(lua_State *L) {
checkluaversion(L);
lua_pushliteral(L, OS_STRING);
lua_setglobal(L , "OS");
luaL_requiref(L, "ejoy2d.shader.c", ejoy2d_shader, 0);
luaL_requiref(L, "ejoy2d.framework", ejoy2d_framework, 0);
luaL_requiref(L, "ejoy2d.ppm", ejoy2d_ppm, 0);
luaL_requiref(L, "ejoy2d.spritepack.c", ejoy2d_spritepack, 0);
luaL_requiref(L, "ejoy2d.sprite.c", ejoy2d_sprite, 0);
luaL_requiref(L, "ejoy2d.renderbuffer", ejoy2d_renderbuffer, 0);
luaL_requiref(L, "ejoy2d.matrix.c", ejoy2d_matrix, 0);
luaL_requiref(L, "ejoy2d.particle.c", ejoy2d_particle, 0);
luaL_requiref(L, "ejoy2d.geometry.c", ejoy2d_geometry, 0);
lua_settop(L,0);
shader_init();
label_load();
}
struct game *
ejoy2d_game() {
struct game *G = (struct game *)malloc(sizeof(*G));
lua_State *L = ejoy2d_lua_init();
G->L = L;
G->real_time = 0;
G->logic_time = 0;
luaL_requiref(L, "ejoy2d.shader.c", ejoy2d_shader, 0);
luaL_requiref(L, "ejoy2d.framework", ejoy2d_framework, 0);
luaL_requiref(L, "ejoy2d.ppm", ejoy2d_ppm, 0);
luaL_requiref(L, "ejoy2d.spritepack.c", ejoy2d_spritepack, 0);
luaL_requiref(L, "ejoy2d.sprite.c", ejoy2d_sprite, 0);
luaL_requiref(L, "ejoy2d.matrix.c", ejoy2d_matrix, 0);
luaL_requiref(L, "ejoy2d.particle.c", ejoy2d_particle, 0);
lua_settop(L,0);
shader_init();
label_load();
return G;
}
void gl_init(int win_w, int win_h)
{
WINDOW_WIDTH = win_w;
WINDOW_HEIGHT = win_h;
glfwInit();
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 0);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
//glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindow(win_w, win_h, 8, 8, 8, 8, 32, 0, GLFW_WINDOW);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
static GLuint bufs[16] =
{GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT4, GL_COLOR_ATTACHMENT5,
GL_COLOR_ATTACHMENT6, GL_COLOR_ATTACHMENT7, GL_COLOR_ATTACHMENT8,
GL_COLOR_ATTACHMENT9, GL_COLOR_ATTACHMENT10, GL_COLOR_ATTACHMENT11,
GL_COLOR_ATTACHMENT12, GL_COLOR_ATTACHMENT13, GL_COLOR_ATTACHMENT14,
GL_COLOR_ATTACHMENT15};
glDrawBuffers(16, bufs);
// create unit square buffer
glGenBuffers(1, &UNIT_SQUARE);
glGenVertexArrays(1, &UNIT_SQUARE_VAO);
glBindVertexArray(UNIT_SQUARE_VAO);
glBindBuffer(GL_ARRAY_BUFFER, UNIT_SQUARE);
glBufferData(GL_ARRAY_BUFFER, sizeof(UNIT_SQUARE_VERTS), UNIT_SQUARE_VERTS, GL_STATIC_DRAW);
glEnableVertexAttribArray(CW_POSITION);
glEnableVertexAttribArray(CW_NORMAL);
glEnableVertexAttribArray(CW_UV);
glVertexAttribPointer(CW_POSITION, 3, GL_FLOAT, false, 32, (void *) 0);
glVertexAttribPointer(CW_NORMAL, 3, GL_SHORT, true, 32, (void *) 12);
glVertexAttribPointer(CW_UV, 2, GL_UNSIGNED_SHORT, true, 32, (void *) 18);
glVertexAttribPointer(CW_MATERIAL, 1, GL_UNSIGNED_SHORT, true, 32, (void *) 22);
glVertexAttribPointer(CW_BONEIDS, 2, GL_UNSIGNED_BYTE, false, 32, (void *) 24);
glVertexAttribPointer(CW_BONEWEIGHTS, 2, GL_UNSIGNED_BYTE, true, 32, (void *) 26);
glBindVertexArray(0);
//glBindBuffer(GL_ARRAY_BUFFER, 0);
drawmodel = malloc(sizeof(Shader));
shader_init(drawmodel, "clockwork/glsl/drawmodel");
shader_add_fragment_output(drawmodel, "outColor");
shader_add_fragment_output(drawmodel, "outNormal");
shader_add_texture_target(drawmodel, "inColor", 0);
/*{{{ XXX debug*/
printf("current\n");
int max_attribs;
glGetProgramiv(drawmodel->program, GL_ACTIVE_ATTRIBUTES, &max_attribs);
int i;
for(i = 0; i < max_attribs; i++)
{
GLchar buf[64];
GLint size;
GLenum type;
glGetActiveAttrib(drawmodel->program, i, 64, NULL, &size, &type, buf);
printf("attrib: %d, %s, %s\n", i, glbTypeString(type), buf);
}
printf("...\n");
/*}}}*/
glbdrawmodel = glbCreateProgram(NULL);
int err =
glbProgramAttachNewShaderSourceFile(glbdrawmodel,
"clockwork/glsl/drawmodel.vs",
GL_VERTEX_SHADER);
glbProgramAttachNewShaderSourceFile(glbdrawmodel,
"clockwork/glsl/drawmodel.fs",
GL_FRAGMENT_SHADER);
struct GLBVertexLayout vlayout[] =
{
{3, GL_FLOAT, false, 32, 0},
{3, GL_SHORT, true, 32, 12},
{2, GL_UNSIGNED_SHORT, true, 32, 18},
{1, GL_UNSIGNED_SHORT, false, 32, 22},
{2, GL_UNSIGNED_BYTE, false, 32, 24},
{2, GL_UNSIGNED_BYTE, true, 32, 26},
};
glbQUAD = glbCreateVertexBuffer(6, sizeof(gl_vertex_t),
UNIT_SQUARE_VERTS, 6, vlayout, GLB_STATIC_DRAW, NULL);
glbframebuffer = glbCreateFramebuffer(NULL);
GLBTexture *fb_color[4] = {
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // color
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // normal
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // light front
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // light back
};
GLBTexture *fb_depth = glbCreateTexture(0, GLB_DEPTH, win_w, win_h, 1, NULL, NULL);
GLBTexture *fb_stencil = glbCreateTexture(0, GLB_STENCIL, win_w, win_h, 1, NULL, NULL);
glbFramebufferTexture(glbframebuffer, fb_color[0]);
glbFramebufferTexture(glbframebuffer, fb_color[1]);
glbFramebufferTexture(glbframebuffer, fb_color[2]);
glbFramebufferTexture(glbframebuffer, fb_color[3]);
glbFramebufferTexture(glbframebuffer, fb_depth);
glbFramebufferTexture(glbframebuffer, fb_stencil);
// framebuffer is now owner of textures
glbReleaseTexture(fb_color[0]);
glbReleaseTexture(fb_color[1]);
glbReleaseTexture(fb_color[2]);
glbReleaseTexture(fb_color[3]);
glbReleaseTexture(fb_depth);
glbReleaseTexture(fb_stencil);
//process framebuffer
glGenFramebuffers(1, &processFBO);
framebuffer_init(&framebuffers[0], win_w, win_h);
framebuffer_init(&framebuffers[1], win_w, win_h);
framebuffer_addtextures(&framebuffers[0], 4,
TEXTURE_DEPTH, TEXTURE_RGBA, TEXTURE_RGBA, TEXTURE_RGBA);
framebuffer_addtextures(&framebuffers[1], 4,
TEXTURE_DEPTH, TEXTURE_RGBA, TEXTURE_RGBA, TEXTURE_RGBA);
gl_bindframebuffer(&framebuffers[0], FRAMEBUFFER_OUTPUT);
gl_bindframebuffer(&framebuffers[1], FRAMEBUFFER_INPUT);
}
int main(int argc, char* argv[])
{
// Args
if(argc > 1)
{
if(!strcmp(argv[1], "-r"))
{
printf("Record mode, will use default recording device.\n\n");
record = true;
}
else
{
record = false;
printf("Going to play %s\n\n", argv[1]);
sound_file = argv[1];
}
if(argc > 2)
{
if(!strcmp(argv[2], "-f"))
{
fullscreen = true;
}
if(argc > 4)
{
WINDOW_WIDTH = atoi(argv[3]);
WINDOW_HEIGHT = atoi(argv[4]);
}
}
}
else
{
printf("Usage: visualizer -r [-f width height]\n visualizer <filename> [-f width height]\n\n -r: record from default audio source\n filename: audio file to play\n\n -f width height: fullscreen at width*height resolution.\n", argv[0]);
return 0;
}
// Intialize SDL, OpenGL context, etc.
if (init() == false)
{
return -1;
}
printf("\nInitialization complete. Enjoy!\n");
shader_init();
// Uniform locations
GLint time_loc = glGetUniformLocation(p, "time");
GLint amplitude_loc = glGetUniformLocation(p, "amplitude");
GLint high_freq_loc = glGetUniformLocation(p, "high_freq");
GLint low_freq_loc = glGetUniformLocation(p, "low_freq");
GLint texture_loc = glGetUniformLocation(p, "texture");
GLint low_freq_max_loc = glGetUniformLocation(p, "low_freq_max");
// Scene
//
// Sphere
GLUquadric* quadric = gluNewQuadric();
gluQuadricNormals(quadric, GLU_SMOOTH);
gluQuadricTexture(quadric, GL_TRUE);
gluQuadricOrientation(quadric, GLU_OUTSIDE);
// Lights
GLfloat light_0_ambient[] = {0.2f, 0.2f, 0.2f, 1.0f};
GLfloat light_0_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat light_0_position[] = {0.0f, 0.0f, 1.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_AMBIENT, light_0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_0_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light_0_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
// Textures and FBOs
glGenTextures(1, &fbo_texture_id);
glBindTexture(GL_TEXTURE_2D, fbo_texture_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 generation included in OpenGL v1.4
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, FBO_TEXTURE_WIDTH, FBO_TEXTURE_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffersEXT(1, &fbo_id);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id);
glGenRenderbuffersEXT(1, &rbo_id);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo_id);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, FBO_TEXTURE_WIDTH, FBO_TEXTURE_HEIGHT);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fbo_texture_id, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rbo_id);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
bool quit = false;
unsigned int length;
bool playing = false;
bool recording = false;
bool looping = true;
unsigned int recordpos = 0;
unsigned int playpos = 0;
int i;
float instant_spectrum[256];
float instant_spectrum_l[256];
float instant_spectrum_r[256];
float rot_angle;
while (quit == false)
{
// Grab spectrums
result = channel->getSpectrum(instant_spectrum_l, 256, 0, FMOD_DSP_FFT_WINDOW_RECT);
if(!record)
{
result = channel->getSpectrum(instant_spectrum_r, 256, 1, FMOD_DSP_FFT_WINDOW_RECT);
}
FMODErrorCheck(result);
// Merge stereo
for(i = 0; i < 256; i++)
{
if(record)
{
instant_spectrum[i] = 10.0f * (float)log10(instant_spectrum_l[i]/2.0f) * 2.0f;
}
else
{
instant_spectrum[i] = 10.0f * (float)log10((instant_spectrum_l[i] + instant_spectrum_r[i])/2.0f) * 2.0f;
}
}
//instant_spectrum[255] = 0;
// Rolling spectrum average
for(i = 7; i >= 1; i = i - 1)
{
arrayCopy(256, spectrum[i-1], spectrum[i]);
}
arrayCopy(256, instant_spectrum, spectrum[0]);
int j;
for(j = 0; j < 256; j++)
{
rolling_spectrum[j] = 0;
for(i = 0; i < 8; i++)
{
rolling_spectrum[j] += spectrum[i][j];
}
rolling_spectrum[j] = rolling_spectrum[j] / 8.0f;
}
float max = -100.0f;
int max_index = 0;
for(i = 0; i < 256; i++)
{
if(rolling_spectrum[i] > max)
{
max = rolling_spectrum[i];
max_index = i;
}
}
// Normalize
float low_avg = 0;
float low_mid_avg = 0;
float mid_avg = 0;
float high_avg = 0;
float low_max = 0;
float low_mid_max = 0;
float mid_max = 0;
float high_max = 0;
int low_max_index = 0;
int low_mid_max_index = 0;
int mid_max_index = 0;
int high_max_index = 0;
for(i = 0; i < 256; i++)
{
processed_spectrum[i] = (rolling_spectrum[i] + 100)/(100);
if(i < 64)
{
low_avg += processed_spectrum[i];
if(processed_spectrum[i] > low_max)
{
low_max = processed_spectrum[i];
low_max_index = i;
}
}
else if(i < 128 && i >= 64)
{
low_mid_avg += processed_spectrum[i];
if(processed_spectrum[i] > low_mid_max)
{
low_mid_max = processed_spectrum[i];
low_mid_max_index = i;
}
}
else if(i < 196 && i >= 128)
{
mid_avg += processed_spectrum[i];
if(processed_spectrum[i] > mid_max)
{
mid_max = processed_spectrum[i];
mid_max_index = i;
}
}
else if(i < 256 && i >= 196 )
{
high_avg += processed_spectrum[i];
if(processed_spectrum[i] > high_max)
{
high_max = processed_spectrum[i];
high_max_index = i;
}
}
}
low_avg = low_avg/64.0f;
low_mid_avg = low_mid_avg/64.0f;
mid_avg = mid_avg/64.0f;
high_avg = high_avg/64.0f;
float high_freq_avg = 0;
float low_freq_avg = 0;
float high_freq_max = spectrum_freq*(low_mid_max_index+1);
float low_freq_max = spectrum_freq*(low_max_index+1);
for(i = 63; i >= 1; i = i-1)
{
low_freq_samples[i] = low_freq_samples[i-1];
high_freq_samples[i] = high_freq_samples[i-1];
}
high_freq_samples[0] = high_freq_max;
low_freq_samples[0] = low_freq_max;
for(i = 0; i < 64; i++)
{
high_freq_avg += high_freq_samples[i];
low_freq_avg += low_freq_samples[i];
}
high_freq_avg = high_freq_avg / 64.0f;
low_freq_avg = low_freq_avg / 64.0f;
//printf("dominant high freq: %f dominant low freq: %f\n", high_freq_avg, low_freq_avg);
// OpenGL
// Uniforms for shaders
glUniform1f(time_loc, (GLfloat)SDL_GetTicks()*0.001);
//glUniform1f(amplitude_loc, 8.0f*smoothstep(-1, 1, log(low_mid_max/low_mid_avg)));
glUniform1f(amplitude_loc, 0.5/normalize(low_avg, low_max));
glUniform1f(high_freq_loc, high_freq_avg);
glUniform1f(low_freq_loc, low_freq_avg);
glUniform1f(low_freq_max_loc, low_freq_max);
printf("low: %f high: %f midmax-mid %f\n", low_freq_avg, high_freq_avg, 1/normalize(low_avg, low_max));
// Into the FBO
glViewport(0, 0, FBO_TEXTURE_WIDTH, FBO_TEXTURE_HEIGHT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (float)(FBO_TEXTURE_WIDTH)/FBO_TEXTURE_HEIGHT, 1.0f, 100.0f);
glMatrixMode(GL_MODELVIEW);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id);
glClearColor(1, 1, 1, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glTranslatef(0.0f, 0.0f, -50.0f);
glColor4f(0.4f, 0.2f, 1.0f, 1.0f);
gluSphere(quadric, 8.0f, 64, 64);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindTexture(GL_TEXTURE_2D, fbo_texture_id);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
// Normal render
glViewport(0, 0, (GLsizei) WINDOW_WIDTH, (GLsizei) WINDOW_HEIGHT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (GLfloat)WINDOW_WIDTH/(GLfloat)WINDOW_HEIGHT, 0.1f, 100.0f);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity ();
glBindTexture(GL_TEXTURE_2D, fbo_texture_id);
glUniform1f(texture_loc, fbo_texture_id);
rot_angle += 0.9f;
glTranslatef(0.0f, 0.0f, -40.0f);
glRotatef(rot_angle,0.0f,1.0f,0.0f);
glRotatef(20,0.0f,0.0f,1.0f);
glColor4f(0.4f, 0.2f, 1.0f, 1.0f);
gluSphere(quadric, 8.0f, 64, 64);
glFlush();
glFinish();
SDL_GL_SwapBuffers();
// FMOD
fmod_system->update();
result = sound->getLength(&length, FMOD_TIMEUNIT_PCM);
FMODErrorCheck(result);
result = fmod_system->isRecording(0, &recording);
FMODErrorCheck(result);
result = fmod_system->getRecordPosition(0, &recordpos);
FMODErrorCheck(result);
if (channel)
{
result = channel->isPlaying(&playing);
FMODErrorCheck(result);
result = channel->getPosition(&playpos, FMOD_TIMEUNIT_PCM);
FMODErrorCheck(result);
}
//printf("State: %-19s. Record pos = %6d : Play pos = %6d : Loop %-3s\r", recording ? playing ? "Recording / playing" : "Recording" : playing ? "Playing" : "Idle", recordpos, playpos, looping ? "On" : "Off");
// SDL
while (SDL_PollEvent(&event))
{
if(event.type == SDL_QUIT)
{
quit = true;
}
else if(event.type == SDL_KEYDOWN)
{
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
quit = true;
break;
case SDLK_f:
break;
}
}
}
}
fmod_system->release();
SDL_Quit();
return 0;
}
//extern void drawModelSetMax(void);
int glInit(void){
cvar_register(&cvar_gl_MSAA_Samples);
cvar_pset(&cvar_gl_MSAA_Samples, "0");
// console_printf("cvar id is %i\n", cvar_gl_MSAA_Samples.myid);
// console_printf("cvar name is %s\n", cvar_gl_MSAA_Samples.name);
// console_printf("cvar value is %s\n", cvar_gl_MSAA_Samples.valuestring);
glewExperimental = TRUE;
GLenum glewError = glewInit();
CHECKGLERROR
if(glewError != GLEW_OK){
console_printf("ERROR with the glew: %s\n", glewGetErrorString(glewError));
return FALSE;
}
shader_init();
CHECKGLERROR
if(!shader_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
texture_init();
CHECKGLERROR
if(!texture_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
framebuffer_init();
CHECKGLERROR
if(!framebuffer_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
vbo_init();
CHECKGLERROR
if(!vbo_ok){
return FALSE;
//todo call some sort of shutdown of everything
}
ubo_init();
CHECKGLERROR
if(!ubo_ok){
return FALSE;
//todo call some sort of shutdown of everything
}
anim_init();
CHECKGLERROR
if(!anim_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
model_init();
CHECKGLERROR
if(!model_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
/*
initParticleSystem(128);
if(!particlesOK){
//todo call some sort of shutdown of everything
return FALSE;
}
*/
light_init();
CHECKGLERROR
if(!light_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
lighttile_init();
CHECKGLERROR
if(!lighttile_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
viewport_init();
CHECKGLERROR
if(!viewport_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
text_init();
CHECKGLERROR
if(!text_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
rendermodel_init();
CHECKGLERROR
//todo errorcheck
drawbb_init();
CHECKGLERROR
//todo errorcheck
states_enableForce(GL_MULTISAMPLE);
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
CHECKGLERROR
// states_disableForce(GL_FOG);
states_enableForce(GL_DEPTH_TEST);
CHECKGLERROR
// glDepthFunc(GL_LESS);
states_depthFunc(GL_LESS);
states_enableForce(GL_CULL_FACE);
states_cullFace(GL_BACK);
// states_depthMask(GL_TRUE);
int maxSamples = 0, maxIntSamples = 0, maxColorTextureSamples = 0, maxDepthTextureSamples = 0;
glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &maxIntSamples);
glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &maxDepthTextureSamples);
maxMSAASamples = maxSamples;
if(maxIntSamples < maxMSAASamples) maxMSAASamples = maxIntSamples;
if(maxColorTextureSamples < maxMSAASamples) maxMSAASamples = maxColorTextureSamples;
if(maxDepthTextureSamples < maxMSAASamples) maxMSAASamples = maxDepthTextureSamples;
console_printf("Max multisample samples: %i\n", maxMSAASamples);
cam = createAndAddViewportRPOINT("cam", 1);
camid = cam->myid;
cam->outfbid = findFramebufferByNameRINT("screen");
unsigned char dflags[] = {3, 7, 3};
// unsigned char drb = FRAMEBUFFERRBFLAGSDEPTH| 2;
unsigned char drb = FRAMEBUFFERRBFLAGSDEPTH;
unsigned char dcount = 3;
cam->dfbid = createAndAddFramebufferRINT("screend", dcount, drb, dflags);
resizeViewport(cam, 800, 600);
screenWidth = 800;
screenHeight = 600;
glGenBuffers(1, &instancevbo);
glGenBuffers(1, &instancevbo2);
//temporary
CHECKGLERROR
vbo_t * tvbo = createAndAddVBORPOINT("text", 2);
textvbo = tvbo->myid;
textshaderid = shader_createAndAddRINT("text");
fsblendshaderid = shader_createAndAddRINT("fsblend");
depthonlyid = shader_createAndAddRINT("depthmodel");
forwardmodelid = shader_createAndAddRINT("forwardmodel");
fsquadmodel = model_findByNameRINT("fsquad");
readyRenderQueueBuffers();
return TRUE; // so far so good
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
bool quit = false;
Test test;
memset( &test, 0, sizeof(test) );
ret = Initialize( &test, &argc, &argv );
if (ret)
goto error;
ret = InitGL( &test );
if (ret)
goto error;
shader_init();
/*
* Main Loop
*/
while (!quit) {
DFBInputEvent evt;
const static GLfloat v[6] = { -1.0, -1.0, 1.0, 0.0, -1.0, 1.0 };
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glDisable( GL_CULL_FACE );
glDisable( GL_DEPTH_TEST );
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 0, 2, GL_FLOAT, GL_TRUE, 0, v );
glDrawArrays( GL_TRIANGLE_FAN, 0, 3 );
eglSwapBuffers( display, surface );
sleep(30);
/*
* Process events
*/
while (test.events->GetEvent( test.events, DFB_EVENT(&evt) ) == DFB_OK) {
switch (evt.type) {
case DIET_KEYPRESS:
switch (evt.key_symbol) {
case DIKS_CURSOR_LEFT:
//view_rot[1] += 5.0;
break;
case DIKS_CURSOR_RIGHT:
//view_rot[1] -= 5.0;
break;
case DIKS_CURSOR_UP:
//view_rot[0] += 5.0;
break;
case DIKS_CURSOR_DOWN:
//view_rot[0] -= 5.0;
break;
case DIKS_ESCAPE:
quit = true;
break;
default:
;
}
break;
case DIET_KEYRELEASE:
switch (evt.key_symbol) {
default:
;
}
break;
case DIET_AXISMOTION:
if (evt.flags & DIEF_AXISREL) {
switch (evt.axis) {
default:
;
}
}
break;
default:
;
}
}
}
error:
Shutdown( &test );
return ret;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
bool quit = false;
Test test;
int n = 1;
memset( &test, 0, sizeof(test) );
#if 1
DFBSurfaceDescription dsc;
IDirectFB *dfb;
// IDirectFBDisplayLayer *layer;
/*
* Initialize DirectFB options
*/
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DirectFBInit() failed!\n" );
return ret;
}
/*
* Create the super interface
*/
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DirectFBCreate() failed!\n" );
return ret;
}
EGLDisplay gEGLDisplay = 0;
EGLConfig gEGLConfig;
EGLContext gEGLContext;
const char *s;
//Display* display = sharedDisplay();
//gEGLDisplay = eglGetDisplay(display);
gEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (gEGLDisplay == EGL_NO_DISPLAY)
return 0;
if (!eglInitialize(gEGLDisplay, 0, 0))
return 0;
s = eglQueryString(gEGLDisplay, EGL_VERSION);
printf("EGL_VERSION = %s\n", s);
s = eglQueryString(gEGLDisplay, EGL_VENDOR);
printf("EGL_VENDOR = %s\n", s);
s = eglQueryString(gEGLDisplay, EGL_EXTENSIONS);
printf("EGL_EXTENSIONS = %s\n", s);
s = eglQueryString(gEGLDisplay, EGL_CLIENT_APIS);
printf("EGL_CLIENT_APIS = %s\n", s);
const int fbConfigAttrbs[] = {
// EGL_BUFFER_SIZE, EGL_DONT_CARE,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 1,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, /*EGL_PIXMAP_BIT |*/ EGL_WINDOW_BIT,
EGL_NONE
};
EGLint numOfConfig;
if (!eglChooseConfig(gEGLDisplay, fbConfigAttrbs, &gEGLConfig, 1, &numOfConfig)) {
printf("egl choose config failed\n");
return 0;
}
if (!numOfConfig) {
printf("no egl configs found\n");
return 0;
}
const EGLint eglContextAttrbs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
gEGLContext = eglCreateContext(gEGLDisplay, gEGLConfig, EGL_NO_CONTEXT, eglContextAttrbs);
if (gEGLContext)
eglBindAPI(EGL_OPENGL_ES_API);
IDirectFBSurface *m_dfbsurface;
EGLSurface m_surface;
{
IDirectFB *dfb;
if (DirectFBCreate(&dfb)) {
printf("failed to DirectFBCreate\n");
return -1;
}
DFBSurfaceDescription dsc;
dsc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS);
dsc.width = 1024;
dsc.height = 1024;
dsc.pixelformat = DSPF_ARGB;
dsc.caps = DSCAPS_DOUBLE;
// surf->GetSize( surf, &dsc.width, &dsc.height );
// surf->GetPixelFormat( surf, &dsc.pixelformat );
if (dfb->CreateSurface(dfb, &dsc, &m_dfbsurface)) {
printf("failed to DFB::CreateSurface\n");
return -1;
}
EGLint windowsAttr[] = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE };
m_surface = eglCreateWindowSurface(gEGLDisplay, gEGLConfig, (EGLNativeWindowType)m_dfbsurface, windowsAttr);
if (m_surface == EGL_NO_SURFACE) {
printf("failed to eglCreateWindowSurface()\n");
return -1;
}
}
eglMakeCurrent(gEGLDisplay, m_surface, m_surface, gEGLContext);
// WKViewPaintToCurrentGLContext(_view->wkView());
glClearColor( 0, 0, 1, 1 );
glClear( GL_COLOR_BUFFER_BIT );
eglSwapBuffers(gEGLDisplay, m_surface);
// m_dfbsurface->Dump( m_dfbsurface, ".", "dfbsurface" );
//sleep(1);
// m_dfbsurface->Dump( m_dfbsurface, ".", "dfbsurface" );
//sleep(999);
//exit(1);
#endif
ret = Initialize( &test, &argc, &argv );
if (ret)
goto error;
ret = InitGL( &test );
if (ret)
goto error;
shader_init();
/*
* Main Loop
*/
while (!quit) {
DFBInputEvent evt;
#if 0
GLfloat color[4] = { n * 100 / 100.0f, n * 100 / 100.0f, n * 100 / 100.0f, 1.0f };
const static GLfloat v[6] = { -1.0, -1.0, 1.0, 0.0, -1.0, 1.0 };
glClearColor(n/10.0, n/10.0, n/10.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glDisable( GL_CULL_FACE );
glDisable( GL_DEPTH_TEST );
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 0, 2, GL_FLOAT, GL_TRUE, 0, v );
glUniform4fv( color_location, 4, color );
glDrawArrays( GL_TRIANGLE_FAN, 0, 3 );
eglSwapBuffers( display, surface );
test.offscreen->Dump( test.offscreen, ".", "offscreen" );
//exit(0);
#endif
// behaves like eglCopyBuffers( display, surface, test.primary );
//test.primary->Blit( test.primary, test.offscreen, NULL, 0, 0 );
test.primary->Blit( test.primary, m_dfbsurface, NULL, 0, 0 );
test.primary->Flip( test.primary, NULL, DSFLIP_NONE );
/*
* Process events
*/
sleep( 3 );
while (test.events->GetEvent( test.events, DFB_EVENT(&evt) ) == DFB_OK) {
switch (evt.type) {
case DIET_KEYPRESS:
switch (evt.key_symbol) {
case DIKS_ESCAPE:
quit = true;
break;
default:
;
}
break;
default:
;
}
}
n++;
}
error:
Shutdown( &test );
return ret;
}
