void geObjectDraw(ge_Object* obj){
/*
geMatrixMode(GE_MATRIX_MODEL);
geLoadMatrix(obj->matrix);
CalculateModelMatrices();
geUpdateMatrix();
if(obj->material.textures[0]){
glBindTexture(GL_TEXTURE_2D, obj->material.textures[0]->id);
}else{
glBindTexture(GL_TEXTURE_2D, 0);
}
glDrawArrays(GL_TRIANGLES, obj->vert_start, obj->nVerts);
*/
geMatrixMode(GE_MATRIX_MODEL);
geLoadIdentity();
if(obj->matrix_used){
geLoadMatrix(obj->matrix);
}
geUpdateMatrix();
if(obj->material.textures[0]){
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, obj->material.textures[0]->id);
}else{
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
}
glDrawArrays(GL_TRIANGLES, obj->vert_start, obj->nVerts);
}
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 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 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;
}
for(j=7; j>=0; j--){
if(obj->material.textures[j]){
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);
}
}else{
glActiveTexture(GL_TEXTURE0+j);
glDisable(GL_TEXTURE_2D);
// break;
}
}
glDrawArrays(GL_TRIANGLES, render->objs[i]->vert_start, render->objs[i]->nVerts);
if(ge_line_shader){
//todo
}
}
}
