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; }