void geDrawLineScreenFadeDepth(int x0, int y0, int z0, int x1, int y1, int z1, u32 color0, u32 color1){
if(abs(z0) > 2048 || abs(z1) > 2048){
return;
}
x0 += libge_context->draw_off_x;
x1 += libge_context->draw_off_x;
y0 += libge_context->draw_off_y;
y1 += libge_context->draw_off_y;
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
if(!ge_current_shader){
geShaderUse(_ge_GetVideoContext()->shader2d);
}
if(ge_current_shader == _ge_GetVideoContext()->shader2d){
geShaderUniform1f(_ge_GetVideoContext()->loc_textured, 0.0);
}
glBegin(GL_LINES);
glColor4ub(R(color0), G(color0), B(color0), A(color0));
glTexCoord3f(-1.0, -1.0, -1.0);
glVertex3f(x0, y0, z0+libge_context->img_stack[z0+2048]);
glColor4ub(R(color1), G(color1), B(color1), A(color1));
glVertex3f(x1, y1, z1+libge_context->img_stack[z1+2048]);
glEnd();
libge_context->img_stack[z0+2048] += 0.001;
libge_context->img_stack[z1+2048] += 0.001;
glEnable(GL_TEXTURE_2D);
}
void geFillRectScreenDepth(int x, int y, int z, int width, int height, u32 color){
if(abs(z) > 2048){
return;
}
x += libge_context->draw_off_x;
y += libge_context->draw_off_y;
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
if(!ge_current_shader){
geShaderUse(_ge_GetVideoContext()->shader2d);
}
if(ge_current_shader == _ge_GetVideoContext()->shader2d){
geShaderUniform1f(_ge_GetVideoContext()->loc_textured, 0.0);
}
glBegin(GL_QUADS);
glColor4ub(R(color), G(color), B(color), A(color));
glTexCoord3f(-1.0, -1.0, -1.0);
glVertex3f(x, y, z+libge_context->img_stack[z+2048]);
glVertex3f(x+width, y, z+libge_context->img_stack[z+2048]);
glVertex3f(x+width, y+height, z+libge_context->img_stack[z+2048]);
glVertex3f(x, y+height, z+libge_context->img_stack[z+2048]);
glEnd();
libge_context->img_stack[z+2048] += 0.001;
glEnable(GL_TEXTURE_2D);
}
void geRendererUpdate(ge_Renderer* render){
if(!render)return;
int i = 0;
int j = 0;
float* mview = geGetMatrix(GE_MATRIX_VIEW);
geShaderUse(render->shader);
for(i=0; i<render->nDynamicLights; i++){
ge_Light* light = render->lights[i];
j = light->i_loc;
glUniform1i(render->shader->loc_lights[j].loc_flags, light->flags);
glUniform4f(render->shader->loc_lights[j].loc_position, light->position.x, light->position.y, light->position.z, light->position.w);
glUniform4f(render->shader->loc_lights[j].loc_target, light->target.x, light->target.y, light->target.z, light->target.w);
glUniform4f(render->shader->loc_lights[j].loc_ambient, light->ambient[0], light->ambient[1], light->ambient[2], light->ambient[3]);
glUniform4f(render->shader->loc_lights[j].loc_diffuse, light->diffuse[0], light->diffuse[1], light->diffuse[2], light->diffuse[3]);
glUniform4f(render->shader->loc_lights[j].loc_specular, light->specular[0], light->specular[1], light->specular[2], light->specular[3]);
glUniform1f(render->shader->loc_lights[j].loc_attenuation, light->attenuation);
glUniform1f(render->shader->loc_lights[j].loc_spotCutoff, light->spot_cutoff);
glUniform1f(render->shader->loc_lights[j].loc_spotCosCutoff, light->spot_coscutoff);
glUniform1f(render->shader->loc_lights[j].loc_spotExponent, light->spot_exponent);
glActiveTexture(GL_TEXTURE7);
glEnable(GL_TEXTURE_2D);
glUniform1i(render->shader->loc_lights[j].loc_shadow, 7);
}
for(i=0; i<render->nLights; i++){
ge_Light* light = render->lights[i+8/*j+scene->nDynamicLights*/];
multMat4Vec4(&light->vector, mview, &light->position);
multMat3Vec3(&light->target_vector, mview, &light->target);
j = light->i_loc;
glUniform1i(render->shader->loc_lights[j].loc_flags, light->flags);
glUniform4f(render->shader->loc_lights[j].loc_position, light->position.x, light->position.y, light->position.z, light->position.w);
glUniform4f(render->shader->loc_lights[j].loc_target, light->target.x, light->target.y, light->target.z, light->target.w);
glUniform4f(render->shader->loc_lights[j].loc_ambient, light->ambient[0], light->ambient[1], light->ambient[2], light->ambient[3]);
glUniform4f(render->shader->loc_lights[j].loc_diffuse, light->diffuse[0], light->diffuse[1], light->diffuse[2], light->diffuse[3]);
glUniform4f(render->shader->loc_lights[j].loc_specular, light->specular[0], light->specular[1], light->specular[2], light->specular[3]);
if(!light->used){
glUniform1f(render->shader->loc_lights[j].loc_attenuation, -1.0);
}else if(light->type != GE_LIGHT_TYPE_SPOT){
glUniform1f(render->shader->loc_lights[j].loc_attenuation, -2.0);
}else{
glUniform1f(render->shader->loc_lights[j].loc_attenuation, light->attenuation);
}
glUniform1f(render->shader->loc_lights[j].loc_spotCutoff, light->spot_cutoff);
glUniform1f(render->shader->loc_lights[j].loc_spotCosCutoff, light->spot_coscutoff);
glUniform1f(render->shader->loc_lights[j].loc_spotExponent, light->spot_exponent);
glUniform3f(render->shader->loc_lights[j].loc_vector, light->vector.x, light->vector.y, light->vector.z);
glUniform3f(render->shader->loc_lights[j].loc_targetVector, light->target_vector.x, light->target_vector.y, light->target_vector.z);
glUniform1f(render->shader->loc_lights[j].loc_CosInnerMinusOuterAngle, light->CosInnerMinusOuterAngle);
glUniform1f(render->shader->loc_lights[j].loc_CosOuterConeAngle, light->CosOuterConeAngle);
glActiveTexture(GL_TEXTURE7);
glEnable(GL_TEXTURE_2D);
if(light->shadow)glBindTexture(GL_TEXTURE_2D, light->shadow->id);
glUniform1i(render->shader->loc_lights[j].loc_shadow, 7);
}
}
int geDrawingMode(int mode){
int last = libge_context->drawing_mode;
if(mode != libge_context->drawing_mode || mode & 0xF0000000){
if(mode & GE_DRAWING_MODE_2D){
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glDisable(GL_CULL_FACE);
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
geMatrixMode(GE_MATRIX_PROJECTION);
geLoadIdentity();
geOrthogonal(0.0, libge_context->width, libge_context->height, 0.0, -2049.0, 2049.0);
geMatrixMode(GE_MATRIX_VIEW);
geLoadIdentity();
geMatrixMode(GE_MATRIX_MODEL);
geLoadIdentity();
geMatrixMode(GE_MATRIX_MODELVIEW);
geLoadIdentity();
geMatrixMode(GE_MATRIX_TEXTURE0);
geLoadIdentity();
geUpdateMatrix();
if(mode & GE_DRAWING_2D_DEPTH){
glEnable(GL_DEPTH_TEST);
geClearMode(GE_CLEAR_COLOR_BUFFER | GE_CLEAR_DEPTH_BUFFER);
}else{
glDisable(GL_DEPTH_TEST);
geClearMode(GE_CLEAR_COLOR_BUFFER);
}
geShaderUse(_ge_GetVideoContext()->shader2d);
glActiveTexture(GL_TEXTURE0);
}
if(mode & GE_DRAWING_MODE_3D){
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glEnable(GL_DEPTH_TEST);
geClearMode(GE_CLEAR_COLOR_BUFFER | GE_CLEAR_DEPTH_BUFFER);
geMatrixMode(GE_MATRIX_PROJECTION);
geLoadIdentity();
if(libge_context->projection_matrix[0] == (float)0xFFFFFFFF){
gePerspective(60.0, (float)libge_context->width / (float)libge_context->height, 0.1, 100000.0);
}else{
geLoadMatrix(libge_context->projection_matrix);
}
}
}
libge_context->drawing_mode = mode;
return last;
}
void geRendererUse(ge_Renderer* render){
geShaderUse(render->shader);
if(ge_current_camera){
glUniform3f(render->shader->loc_camera, ge_current_camera->x, ge_current_camera->y, ge_current_camera->z);
}
geShaderUniform1f(render->shader->loc_time, ((float)geGetTick()) / 1000.0);
glBindVertexArray(render->vao);
#ifndef PLATFORM_mac
// if(render->tesselated && glPatchParameteri){
// glPatchParameteri(GL_PATCH_VERTICES, 3);
// }
#endif
if(render->depth_enabled){
glEnable(GL_DEPTH_TEST);
}else{
glDisable(GL_DEPTH_TEST);
}
glDepthMask(render->depth_mask);
if(render->blend_enabled){
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}else{
glDisable(GL_BLEND);
}
int i;
for(i=0; i<32; i++){
if(_ge_force_caps[i].used){
if(_ge_force_caps[i].state == 1){
glEnable(_ge_force_caps[i].cap);
}else
if(_ge_force_caps[i].state == 0){
glDisable(_ge_force_caps[i].cap);
}
}
}
if(render->ext_func){
render->ext_func(render, -1);
}
}
ge_Shader* geShaderUse(ge_Shader* shader){
if(!libge_context->shaders_available || glUseProgram == 0)return 0;
ge_Shader* ret = ge_current_shader;
if(ge_force_shader){
shader = ge_force_shader;
}
ge_current_shader = shader;
if(!shader){
glUseProgram(0);
if(libge_context->drawing_mode & GE_DRAWING_MODE_2D){
geShaderUse(_ge_GetVideoContext()->shader2d);
}
}else{
glUseProgram(shader->programId);
geMatrixLocations();
// ge_draw_object_set_shader(shader);
}
return ret;
}
void geGraphicsInit(){
LibGE_VideoContext* ctx = (LibGE_VideoContext*)libge_context->vidcontext;
if(!ctx){
ctx = (LibGE_VideoContext*)geMalloc(sizeof(LibGE_VideoContext));
libge_context->vidcontext = (t_ptr)ctx;
libge_context->gpumem += 2 * libge_context->width * libge_context->height * sizeof(u32);
}
if(!ctx->shader2d){
gePrintDebug(0x100, "No 2D shader, loading it..\n");
ctx->shader2d = geCreateShader();
geShaderLoadVertexSource(ctx->shader2d, geFileFromBuffer(_ge_shader_ogl3_generic_2d_vert, sizeof(_ge_shader_ogl3_generic_2d_vert)+1));
geShaderLoadFragmentSource(ctx->shader2d, geFileFromBuffer(_ge_shader_ogl3_generic_2d_frag, sizeof(_ge_shader_ogl3_generic_2d_frag)+1));
ctx->loc_textured = geShaderUniformID(ctx->shader2d, "textured");
geShaderUse(ctx->shader2d);
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(ctx->shader2d->programId, "ge_Texture"), 0);
}
libge_context->blend_src = GE_DEFAULT;
libge_context->blend_dst = GE_DEFAULT;
glViewport(0, 0, libge_context->width, libge_context->height);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glCullFace(GL_FRONT);
glScissor(0, 0, libge_context->width, libge_context->height);
glEnable(GL_SCISSOR_TEST);
if(libge_context->fontbuf){
geFreeImage(libge_context->fontbuf);
libge_context->fontbuf = NULL;
}
libge_context->fontbuf = geCreateSurface(libge_context->width, libge_context->height, 0x00000000);
}
void geSceneDraw(ge_Scene* scene){
current_scene = scene;
int i = 0;
int j = 0;
CalculateModelMatrices();
if(scene->sky.animator){
geRendererUse(&scene->sky);
geShaderUniform1f(scene->sky.depth_enabled, ((float)geGetTick())/1000.0);
geMatrixMode(GE_MATRIX_MODEL);
geLoadIdentity();
geUpdateMatrix();
for(i=0; i< scene->sky.nObjs; i++){
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, scene->sky.objs[i]->material.textures[0]->id);
if(scene->sky.objs[i]->material.textures[1]){
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, scene->sky.objs[i]->material.textures[1]->id);
// geShaderUniform1i(geShaderUniformID(scene->sky.shader, "ge_Texture1"), 1);
}
glDrawArrays(GL_TRIANGLES, scene->sky.objs[i]->vert_start, scene->sky.objs[i]->nVerts);
}
}
if(scene->cloudsGenerator){
// DrawClouds(scene);
}
float time = ((float)geGetTick()) / 1000.0;
for(i=0; i<scene->nRenderers; i++){
if(scene->renderers[i].enabled && scene->renderers[i].extension){
if(((ge_type32_struct*)scene->renderers[i].extension)->type == GE_RENDERER_WATER){
geWaterRender(&scene->renderers[i], ge_current_camera, (void(*)(void*))geSceneDraw, scene);
}
}
}
for(i=0; i<scene->nRenderers; i++){
if(scene->renderers[i].enabled == false)continue;
ge_Shader* fforce = NULL;
if(scene->render_mode == GE_SCENE_RENDER_SHADOW && scene->renderers[i].shadow_shader){
fforce = geForceShader(scene->renderers[i].shadow_shader);
}
/*
if(scene->renderers[i].matrix_used){
geMatrixMode(GE_MATRIX_PROJECTION);
geLoadMatrix(scene->renderers[i].projection_matrix);
}else{
geMatrixMode(GE_MATRIX_PROJECTION);
geLoadMatrix(libge_context->projection_matrix);
}
*/
geShaderUse(scene->renderers[i].shader);
glUniform1f(scene->renderers[i].shader->loc_time, time);
glUniform1f(scene->renderers[i].shader->loc_ratio, ((float)libge_context->width) / ((float)libge_context->height));
if(scene->fogEnabled){
glUniform1f(scene->renderers[i].shader->loc_fog_density, scene->fog->density);
glUniform4f(scene->renderers[i].shader->loc_fog_color, scene->fog->color[0], scene->fog->color[1], scene->fog->color[2], scene->fog->color[3]);
glUniform1f(scene->renderers[i].shader->loc_fog_start, scene->fog->start);
glUniform1f(scene->renderers[i].shader->loc_fog_end, scene->fog->end);
}
if(scene->renderers[i].ext_func){
scene->renderers[i].ext_func(&scene->renderers[i], -1);
}
geRendererUpdate(&scene->renderers[i]);
if(ge_current_camera){
glUniform3f(scene->renderers[i].shader->loc_camera, ge_current_camera->x, ge_current_camera->y, ge_current_camera->z);
}
geRenderObjects(&scene->renderers[i]);
if(scene->renderers[i].callback){
scene->renderers[i].callback(&scene->renderers[i], -1);
}
if(scene->render_mode == GE_SCENE_RENDER_SHADOW && scene->renderers[i].shadow_shader && fforce){
geForceShader(fforce);
}
}
}
void geRenderObjects(ge_Renderer* render){
geRendererUse(render);
geMatrixMode(GE_MATRIX_MODEL);
geLoadIdentity();
int i=0;
int j=0;
// int current_tex_id[8] = { 0 };
int default_matrix_ok = false;
int update_matrices = true;
for(i=0; i<render->nObjs; i++){
ge_Object* obj = render->objs[i];
// gePrintDebug(0x100, "Object %d/%d \"%s\", vert_start: %d, nVerts: %d\n", i+1, render->nObjs, obj->name, obj->vert_start, obj->nVerts);
if(obj->vert_start<0)continue;
if(obj->matrix_used){
geLoadMatrix(obj->matrix);
default_matrix_ok = false;
update_matrices = true;
}else if(!default_matrix_ok){
geLoadIdentity();
default_matrix_ok = true;
update_matrices = true;
}
if(render->ext_func){
render->ext_func(render, i);
}
if(update_matrices){
// CalculateModelMatrices();
geUpdateMatrix();
// StaticLightingFunc2(current_scene, render, -1);
update_matrices = false;
}
bool textured = false;
for(j=7; j>=0; j--){
if(obj->material.textures[j]){
textured = true;
if(obj->material.textures[j]->flags & GE_IMAGE_3D){
glActiveTexture(GL_TEXTURE0+j);
glEnable(GL_TEXTURE_3D);
glBindTexture(GL_TEXTURE_3D, obj->material.textures[j]->id);
}else{
glActiveTexture(GL_TEXTURE0+j);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, obj->material.textures[j]->id);
char tmp[32] = "ge_Texture";
if(j)sprintf(tmp, "ge_Texture%d", j);
glUniform1i(glGetUniformLocation(render->shader->programId, tmp), j);
}
}else{
// glActiveTexture(GL_TEXTURE0+j);
// glDisable(GL_TEXTURE_2D);
// break;
}
}
glUniform4f(render->shader->loc_front_ambient, obj->material.ambient[0], obj->material.ambient[1], obj->material.ambient[2], obj->material.ambient[3]);
glUniform4f(render->shader->loc_front_diffuse, obj->material.diffuse[0], obj->material.diffuse[1], obj->material.diffuse[2], obj->material.diffuse[3]);
glUniform4f(render->shader->loc_front_specular, obj->material.specular[0], obj->material.specular[1], obj->material.specular[2], 1.0);
glUniform1i(render->shader->loc_HasTexture, textured);
glDrawArrays(render->draw_mode, obj->vert_start, obj->nVerts);
if(ge_line_shader){
geShaderUse(ge_line_shader);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDrawArrays(render->draw_mode, render->objs[i]->vert_start, render->objs[i]->nVerts);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
geShaderUse(render->shader);
}
}
}
void geRendererUse(ge_Renderer* render){
geShaderUse(render->shader);
if(ge_current_camera){
glUniform3f(render->shader->loc_camera, ge_current_camera->x, ge_current_camera->y, ge_current_camera->z);
}
geShaderUniform1f(render->shader->loc_time, ((float)geGetTick()) / 1000.0);
glBindBuffer(GL_ARRAY_BUFFER, render->vbo);
if(render->customVert){
if(render->customVert->vertex_offset >= 0){
glEnableVertexAttribArray(3); //pos
glVertexAttribPointer(3, render->customVert->vertex_count, render->customVert->vertex_type, false, render->customVert->size, BUFFER_OFFSET(render->customVert->vertex_offset));
}else{
glDisableVertexAttribArray(3); //pos
}
if(render->customVert->color_offset >= 0){
glEnableVertexAttribArray(1); //color
glVertexAttribPointer(1, render->customVert->color_count, render->customVert->color_type, true, render->customVert->size, BUFFER_OFFSET(render->customVert->color_offset));
}else{
glDisableVertexAttribArray(1); //color
}
if(render->customVert->texture_offset >= 0){
glEnableVertexAttribArray(0); //tex
glVertexAttribPointer(0, render->customVert->texture_count, render->customVert->texture_type, false, render->customVert->size, BUFFER_OFFSET(render->customVert->texture_offset));
}else{
glDisableVertexAttribArray(0); //tex
}
if(render->customVert->normal_offset >= 0){
glEnableVertexAttribArray(2); //normal
glVertexAttribPointer(2, 3, render->customVert->normal_type, true, render->customVert->size, BUFFER_OFFSET(render->customVert->normal_offset));
}else{
glDisableVertexAttribArray(2); //normal
}
}else{
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(ge_Vertex), BUFFER_OFFSET(40)); //3*4 + 4*4 + 3*4 => size(u,v,w,color[4],nx,ny,nz)
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(ge_Vertex), BUFFER_OFFSET(12)); //3*4 => size(u,v,w)
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(ge_Vertex), BUFFER_OFFSET(28)); //3*4 + 4*4 => size(u,v,w,color[4])
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(ge_Vertex), BUFFER_OFFSET(0));
}
if(render->depth_enabled){
glEnable(GL_DEPTH_TEST);
}else{
glDisable(GL_DEPTH_TEST);
}
// glDepthMask(render->depth_mask);
if(render->blend_enabled){
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}else{
glDisable(GL_BLEND);
}
if(render->ext_func){
render->ext_func(render, -1);
}
}
void geSceneDraw(ge_Scene* scene){
current_scene = scene;
int i = 0;
int j = 0;
CalculateModelMatrices();
/*
if(scene->sky.animator){
geRendererUse(&scene->sky);
geShaderUniform1f(scene->sky.depth_enabled, ((float)geGetTick())/1000.0);
geMatrixMode(GE_MATRIX_MODEL);
geLoadIdentity();
geUpdateMatrix();
for(i=0; i< scene->sky.nObjs; i++){
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, scene->sky.objs[i]->material.textures[0]->id);
if(scene->sky.objs[i]->material.textures[1]){
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, scene->sky.objs[i]->material.textures[1]->id);
// geShaderUniform1i(geShaderUniformID(scene->sky.shader, "ge_Texture1"), 1);
}
glDrawArrays(GL_TRIANGLES, scene->sky.objs[i]->vert_start, scene->sky.objs[i]->nVerts);
}
}
*/
if(scene->cloudsGenerator){
}
float time = ((float)geGetTick()) / 1000.0;
for(i=0; i<scene->nRenderers; i++){
if(scene->renderers[i].enabled == false)continue;
if(scene->renderers[i].matrix_used){
geMatrixMode(GE_MATRIX_PROJECTION);
geLoadMatrix(scene->renderers[i].projection_matrix);
}else{
geMatrixMode(GE_MATRIX_PROJECTION);
geLoadMatrix(libge_context->projection_matrix);
}
geShaderUse(scene->renderers[i].shader);
glUniform1f(scene->renderers[i].shader->loc_time, time);
glUniform1f(scene->renderers[i].shader->loc_ratio, ((float)libge_context->width) / ((float)libge_context->height));
if(scene->fogEnabled){
glUniform1f(scene->renderers[i].shader->loc_fog_density, scene->fog->density);
glUniform4f(scene->renderers[i].shader->loc_fog_color, scene->fog->color[0], scene->fog->color[1], scene->fog->color[2], scene->fog->color[3]);
glUniform1f(scene->renderers[i].shader->loc_fog_start, scene->fog->start);
glUniform1f(scene->renderers[i].shader->loc_fog_end, scene->fog->end);
}
/*
if(scene->renderers[i].depth_enabled){
glEnable(GL_DEPTH_TEST);
}else{
glDisable(GL_DEPTH_TEST);
}
if(scene->renderers[i].blend_enabled){
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}else{
glDisable(GL_BLEND);
}
*/
if(scene->renderers[i].ext_func){
scene->renderers[i].ext_func(&scene->renderers[i], -1);
}
StaticLightingFunc2(scene, &scene->renderers[i], -1);
for(j=0; j<scene->nDynamicLights; j++){
glUniform4f(scene->renderers[i].shader->loc_lights[j].loc_position, scene->dynamicLights[j].position.x, scene->dynamicLights[j].position.y, scene->dynamicLights[j].position.z, scene->dynamicLights[j].position.w);
glUniform4f(scene->renderers[i].shader->loc_lights[j].loc_target, scene->dynamicLights[j].target.x, scene->dynamicLights[j].target.y, scene->dynamicLights[j].target.z, scene->dynamicLights[j].target.w);
glUniform4f(scene->renderers[i].shader->loc_lights[j].loc_ambient, scene->dynamicLights[j].ambient[0], scene->dynamicLights[j].ambient[1], scene->dynamicLights[j].ambient[2], scene->dynamicLights[j].ambient[3]);
glUniform4f(scene->renderers[i].shader->loc_lights[j].loc_diffuse, scene->dynamicLights[j].diffuse[0], scene->dynamicLights[j].diffuse[1], scene->dynamicLights[j].diffuse[2], scene->dynamicLights[j].diffuse[3]);
glUniform4f(scene->renderers[i].shader->loc_lights[j].loc_specular, scene->dynamicLights[j].specular[0], scene->dynamicLights[j].specular[1], scene->dynamicLights[j].specular[2], scene->dynamicLights[j].specular[3]);
glUniform1f(scene->renderers[i].shader->loc_lights[j].loc_attenuation, scene->dynamicLights[j].attenuation);
glUniform1f(scene->renderers[i].shader->loc_lights[j].loc_spotCutoff, scene->dynamicLights[j].spot_cutoff);
glUniform1f(scene->renderers[i].shader->loc_lights[j].loc_spotCosCutoff, scene->dynamicLights[j].spot_coscutoff);
glUniform1f(scene->renderers[i].shader->loc_lights[j].loc_spotExponent, scene->dynamicLights[j].spot_exponent);
}
for(j=0; j<scene->nLights; j++){
glUniform4f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_position, scene->lights[j].position.x, scene->lights[j].position.y, scene->lights[j].position.z, scene->lights[j].position.w);
glUniform4f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_target, scene->lights[j].target.x, scene->lights[j].target.y, scene->lights[j].target.z, scene->lights[j].target.w);
glUniform4f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_ambient, scene->lights[j].ambient[0], scene->lights[j].ambient[1], scene->lights[j].ambient[2], scene->lights[j].ambient[3]);
glUniform4f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_diffuse, scene->lights[j].diffuse[0], scene->lights[j].diffuse[1], scene->lights[j].diffuse[2], scene->lights[j].diffuse[3]);
glUniform4f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_specular, scene->lights[j].specular[0], scene->lights[j].specular[1], scene->lights[j].specular[2], scene->lights[j].specular[3]);
if(!scene->lights[j].used){
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_attenuation, -1.0);
}else if(scene->lights[j].type != GE_LIGHT_TYPE_SPOT){
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_attenuation, -2.0);
}else{
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_attenuation, scene->lights[j].attenuation);
}
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_spotCutoff, scene->lights[j].spot_cutoff);
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_spotCosCutoff, scene->lights[j].spot_coscutoff);
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_spotExponent, scene->lights[j].spot_exponent);
glUniform3f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_vector, scene->lights[j].vector.x, scene->lights[j].vector.y, scene->lights[j].vector.z);
glUniform3f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_targetVector, scene->lights[j].target_vector.x, scene->lights[j].target_vector.y, scene->lights[j].target_vector.z);
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_CosInnerMinusOuterAngle, scene->lights[j].CosInnerMinusOuterAngle);
glUniform1f(scene->renderers[i].shader->loc_lights[j+8/*j+scene->nDynamicLights*/].loc_CosOuterConeAngle, scene->lights[j].CosOuterConeAngle);
}
if(ge_current_camera){
glUniform3f(scene->renderers[i].shader->loc_camera, ge_current_camera->x, ge_current_camera->y, ge_current_camera->z);
}
geRenderObjects(&scene->renderers[i]);
if(scene->renderers[i].callback){
scene->renderers[i].callback(&scene->renderers[i], -1);
}
}
}
void geRenderFontOutline(int x, int y, ge_Font* font, u32 color, u32 outlineColor, const char* text, int len){
int i;
int b_x = x;
y += font->size;
int z = 0;
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, font->texture->id);
if(!ge_current_shader){
geShaderUse(_ge_GetVideoContext()->shader2d);
}
if(ge_current_shader == _ge_GetVideoContext()->shader2d){
geShaderUniform1f(_ge_GetVideoContext()->loc_textured, 1.0);
}
glBegin(GL_QUADS);
float rx = font->texture->u / font->texture->width;
float ry = font->texture->v / font->texture->height;
for(i=0; i<len; i++){
if(text[i] == '\n'){
x = b_x;
y += font->size;
continue;
}
float sx = ((float)font->positions[(u8)text[i]].x) * rx;
float sy = ((float)font->positions[(u8)text[i]].y) * ry;
float texMaxX = ((float)font->positions[(u8)text[i]].w) * rx;
float texMaxY = ((float)font->positions[(u8)text[i]].h) * ry;
float width = font->positions[(u8)text[i]].w;
float height = font->positions[(u8)text[i]].h;
float fy = (float)y - font->positions[(u8)text[i]].posY;
if(A(outlineColor) != 0){
float ofs = 0.06;
float scale = 1.1;
glColor4ub(R(outlineColor), G(outlineColor), B(outlineColor), A(outlineColor));
glTexCoord2f(sx, sy);
glVertex3f(x-width*ofs, fy-font->positions[(u8)text[i]].posY*ofs, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy);
glVertex3f(x+width*scale, fy-font->positions[(u8)text[i]].posY*ofs, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy+texMaxY);
glVertex3f(x+width*scale, fy+height*scale, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx, sy+texMaxY);
glVertex3f(x-width*ofs, fy+height*scale, z+libge_context->img_stack[z+2048]);
}
glColor4ub(R(color), G(color), B(color), A(color));
glTexCoord2f(sx, sy);
glVertex3f(x, fy, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy);
glVertex3f(x+width, fy, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy+texMaxY);
glVertex3f(x+width, fy+height, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx, sy+texMaxY);
glVertex3f(x, fy+height, z+libge_context->img_stack[z+2048]);
x += font->positions[(u8)text[i]].advX;
}
glEnd();
libge_context->img_stack[z+2048] += 0.001;
}
void geBlitImageDepthStretchedRotated(int x, int y, int z, ge_Image* img, int _sx, int _sy, int ex, int ey, int width, int height, float angle, int flags){
if(!img)return;
if((t_ptr)img==0xBAADF00D)return;
if(!img->id)return;
if(abs(z) > 2048){
return;
}
if(!(flags & GE_BLIT_NOOFFSET)){
x += libge_context->draw_off_x;
y += libge_context->draw_off_y;
}
if(flags & GE_BLIT_NOALPHA){
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
}else{
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
float texMaxX = img->u;
float texMaxY = img->v;
float sx = _sx*texMaxX/img->width;
float sy = _sy*texMaxY/img->height;
texMaxX = ex*texMaxX/img->width;
texMaxY = ey*texMaxY/img->height;
if(img->flags & GE_IMAGE_ANIMATED){
sy += ((_ge_ImageAnimated*)img)->_ge_n * img->v;
if(geGetTickFloat() - ((_ge_ImageAnimated*)img)->_ge_t >= ((_ge_ImageAnimated*)img)->frameTime){
((_ge_ImageAnimated*)img)->_ge_t = geGetTickFloat();
((_ge_ImageAnimated*)img)->_ge_n = (((_ge_ImageAnimated*)img)->_ge_n + 1) % ((_ge_ImageAnimated*)img)->nImages;
}
}
float Cos = geCos(angle);
float Sin = geSin(-angle);
float sw = Sin*width*0.5;
float sh = Sin*height*0.5;
float cw = Cos*width*0.5;
float ch = Cos*height*0.5;
int mw = 0;
int mh = 0;
if(!(flags & GE_BLIT_CENTERED)){
mw = (width-x) / 2;
mh = (height-y) / 2;
mw += (int)((x - cw - sh) - (x - cw + sh));
mh += (int)((y - sw + ch) - (y - sw - ch));
}
x += mw;
y += mh;
if(!ge_current_shader){
geShaderUse(_ge_GetVideoContext()->shader2d);
}
if(ge_current_shader == _ge_GetVideoContext()->shader2d){
geShaderUniform1f(_ge_GetVideoContext()->loc_textured, 1.0);
glUniform1f(_ge_GetVideoContext()->shader2d->loc_time, ((float)geGetTick()) / 1000.0);
glUniform1f(_ge_GetVideoContext()->shader2d->loc_ratio, ((float)libge_context->width) / ((float)libge_context->height));
}
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, img->id);
glBegin(GL_TRIANGLE_FAN);
glColor4ub(R(img->color), G(img->color), B(img->color), A(img->color));
glTexCoord2f(sx, sy+texMaxY); glVertex3f(x - cw - sh, y - sw + ch, (float)z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx, sy); glVertex3f(x - cw + sh, y - sw - ch, (float)z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy); glVertex3f(x + cw + sh, y + sw - ch, (float)z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy+texMaxY);glVertex3f(x + cw - sh, y + sw + ch, (float)z+libge_context->img_stack[z+2048]);
glEnd();
libge_context->img_stack[z+2048] += 0.001;
}
void geBlitImageDepthStretched(int x, int y, int z, ge_Image* img, int _sx, int _sy, int ex, int ey, int width, int height, int flags){
if(!img)return;
if((t_ptr)img==0xBAADF00D)return;
if(!img->id)return;
if(abs(z) > 2048){
return;
}
x += libge_context->draw_off_x;
y += libge_context->draw_off_y;
if(flags & GE_BLIT_CENTERED){
x -= width / 2;
y -= height / 2;
}
if(x > libge_context->width || x+width < 0 || y > libge_context->height || y+height < 0){
return;
}
if(flags & GE_BLIT_NOALPHA){
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
}else{
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
int b_src = libge_context->blend_src;
int b_dst = libge_context->blend_dst;
b_src = (b_src == GE_DEFAULT) ? GL_SRC_ALPHA : b_src;
b_dst = (b_dst == GE_DEFAULT) ? GL_ONE_MINUS_SRC_ALPHA : b_dst;
glBlendFunc(b_src, b_dst);
}
float texMaxX = img->u;
float texMaxY = img->v;
float sx = _sx*texMaxX/img->width;
float sy = _sy*texMaxY/img->height;
texMaxX = ex*texMaxX/img->width;
texMaxY = ey*texMaxY/img->height;
if(img->flags & GE_IMAGE_ANIMATED){
sy += ((_ge_ImageAnimated*)img)->_ge_n * img->v;
if(geGetTickFloat() - ((_ge_ImageAnimated*)img)->_ge_t >= ((_ge_ImageAnimated*)img)->frameTime){
((_ge_ImageAnimated*)img)->_ge_t = geGetTickFloat();
((_ge_ImageAnimated*)img)->_ge_n = (((_ge_ImageAnimated*)img)->_ge_n + 1) % ((_ge_ImageAnimated*)img)->nImages;
}
}
int tex_mode = GL_TEXTURE_2D;
if(!ge_current_shader){
geShaderUse(_ge_GetVideoContext()->shader2d);
}
if(ge_current_shader == _ge_GetVideoContext()->shader2d){
geShaderUniform1f(_ge_GetVideoContext()->loc_textured, 1.0);
glUniform1f(ge_current_shader->loc_time, ((float)geGetTick()) / 1000.0);
glUniform1f(ge_current_shader->loc_ratio, ((float)libge_context->width) / ((float)libge_context->height));
}
glEnable(tex_mode);
glBindTexture(tex_mode, img->id);
if(flags & GE_BLIT_VFLIP){
glBegin(GL_QUADS);
glColor4ub(R(img->color), G(img->color), B(img->color), A(img->color));
glTexCoord2f(sx, sy+texMaxY);
glVertex3f(x, y, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy+texMaxY);
glVertex3f(x+width, y, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy);
glVertex3f(x+width, y+height, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx, sy);
glVertex3f(x, y+height, z+libge_context->img_stack[z+2048]);
glEnd();
}else{
glBegin(GL_QUADS);
glColor4ub(R(img->color), G(img->color), B(img->color), A(img->color));
glTexCoord2f(sx, sy);
glVertex3f(x, y, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy);
glVertex3f(x+width, y, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx+texMaxX, sy+texMaxY);
glVertex3f(x+width, y+height, z+libge_context->img_stack[z+2048]);
glTexCoord2f(sx, sy+texMaxY);
glVertex3f(x, y+height, z+libge_context->img_stack[z+2048]);
glEnd();
}
libge_context->img_stack[z+2048] += 0.001;
}
