int ge_clouds_thread(int args, void* argp){
ge_Scene* scene = (ge_Scene*)argp;
nClouds = scene->cloudsGenerator->n_clouds[0] + scene->cloudsGenerator->n_clouds[1] + scene->cloudsGenerator->n_clouds[2];
float map_size_x = scene->cloudsGenerator->map_size_x;
while(1){
if(!ge_current_camera){
geSleep(1000);
continue;
}
int c=0;
for(c=0; c<nClouds; c++){
if(!ge_current_camera)break;
int type = scene->cloudsGenerator->types[c];
ge_Cloud* cloud = &scene->cloudsGenerator->clouds[c];
float scale = 1.5;
if(type == GE_CLOUD_TYPE_HIGH_LEVEL){
scale = 5.0;
}else
if(type == GE_CLOUD_TYPE_MID_LEVEL){
scale = 10.0;
}else{
scale = 20.0;
}
// if(cloud->x > map_size_x/2.0){
if(cloud->z <= 0.0 && cloud->x > 0.0){
srand(0);
int first_rand = rand()*geGetTick();
srand(first_rand);
GenerateCloud(scene, cloud, c);
// cloud->x = -map_size_x/2.0;
float D = -4 * (-1.0/scene->cloudsGenerator->map_size_x) * (scene->cloudsGenerator->map_size_x / 2.0);
cloud->x = sqrt(D) / (-2.0 / scene->cloudsGenerator->map_size_x);
}
cloud->alpha = 1.0;
if(abs(cloud->x) > map_size_x/2.0*0.6){
// cloud->alpha = 1.0 - (abs(cloud->x) - map_size_x/2.0*0.6) / (map_size_x/2.0*0.4);
}
float dx = (ge_current_camera->x - cloud->x);
float dy = (ge_current_camera->y - cloud->y);
float dz = (ge_current_camera->z - cloud->z);
float rotX = atanf(dx/dz);
float rotY = atanf(dy/dz);
// float rotZ = atanf(dx/-dy);
ge_LoadIdentity(cloud->matrix);
ge_Scale(cloud->matrix, scale, scale, scale);
ge_Rotate(cloud->matrix, -rotY, rotX, 0.0);
}
geSleep(100);
}
return 0;
}
void ge_Translate(float* m, float x, float y, float z){
float t[16];
ge_LoadIdentity(t);
t[12] = x;
t[13] = y;
t[14] = z;
geMatrix44Mult(m, m, t);
}
void geRotate(float x, float y, float z){
float tx[16], ty[16], tz[16], tb[16];
if(x != 0.0f){
ge_LoadIdentity(tx);
float cx = cosf(x);
float sx = sinf(x);
tx[1*4+1] = cx;
tx[1*4+2] = sx;
tx[2*4+1] = -sx;
tx[2*4+2] = cx;
memcpy(tb, ge_current_matrix, sizeof(float)*16);
geMatrix44Mult(ge_current_matrix, tb, tx);
}
if(y != 0.0f){
ge_LoadIdentity(ty);
float cy = cosf(y);
float sy = sinf(y);
ty[0*4+0] = cy;
ty[0*4+2] = -sy;
ty[2*4+0] = sy;
ty[2*4+2] = cy;
float tb[16];
memcpy(tb, ge_current_matrix, sizeof(float)*16);
geMatrix44Mult(ge_current_matrix, tb, ty);
}
if(z != 0.0f){
ge_LoadIdentity(tz);
float cz = cosf(z);
float sz = sinf(z);
tz[0*4+0] = cz;
tz[0*4+1] = sz;
tz[1*4+0] = -sz;
tz[1*4+1] = cz;
float tb[16];
memcpy(tb, ge_current_matrix, sizeof(float)*16);
geMatrix44Mult(ge_current_matrix, tb, tz);
}
ge_current_matrix_update = true;
}
void ge_Scale(float* m, float x, float y, float z){
float t[16];
ge_LoadIdentity(t);
t[0] = x;
t[5] = y;
t[10] = z;
geMatrix44Mult(m, m, t);
}
void geTranslate(float x, float y, float z){
float t[16];
ge_LoadIdentity(t);
t[12] = x;
t[13] = y;
t[14] = z;
geMatrix44Mult(ge_current_matrix, ge_current_matrix, t);
ge_current_matrix_update = true;
}
void geScale(float x, float y, float z){
float t[16];
ge_LoadIdentity(t);
t[0] = x;
t[5] = y;
t[10] = z;
geMatrix44Mult(ge_current_matrix, ge_current_matrix, t);
ge_current_matrix_update = true;
}
void geRK4UpdateTargets(ge_RK4State* state){
ge_RK4Target* curr = state->targets;
float matrix[16];
ge_LoadIdentity(matrix);
ge_Translate(matrix, state->position.x, state->position.y, state->position.z);
while(curr){
if(state->target_cb){
state->target_cb(state, curr, state->target_cbdata);
}else if(curr->obj){
memcpy(curr->obj->matrix, matrix, sizeof(float) * 16);
curr->obj->matrix_used = true;
}
curr = curr->next;
}
}
void geOrthogonal(float left, float right, float bottom, float top, float zNear, float zFar){
ge_LoadIdentity(ge_current_matrix);
float tx = - (right + left) / (right - left);
float ty = - (top + bottom) / (top - bottom);
float tz = - (zFar + zNear) / (zFar - zNear);
ge_current_matrix[0] = 2.0 / (right - left);
ge_current_matrix[5] = 2.0 / (top - bottom);
ge_current_matrix[10] = -2.0 / (zFar - zNear);
ge_current_matrix[12] = tx;
ge_current_matrix[13] = ty;
ge_current_matrix[14] = tz;
if(ge_current_mode == GE_MATRIX_PROJECTION){
// memcpy(libge_context->projection_matrix, ge_current_matrix, sizeof(float)*16);
}
ge_current_matrix_update = true;
}
void geObjectMatrixIdentity(ge_Object* obj){
obj->matrix_used = false;
ge_LoadIdentity(obj->matrix);
}
void LoadRenderer(const char* path, ge_File* fp, ge_Scene* scene, ge_Renderer* render){
gePrintDebug(0x100, "LoadRenderer(\"%s\", 0x%16llX, 0x%16llX, 0x%16llX)\n", path, (t_ptr)fp, (t_ptr)scene, (t_ptr)render);
char buffer[2048] = "";
char tmp[2048] = "";
char fl[2048] = "";
// ge_Object* tmp_obj = NULL;
gePrintDebug(0x100, "LoadRenderer 1\n");
render->shader = geCreateShader();
render->depth_enabled = true;
render->depth_mask = true;
render->blend_enabled = false;
render->enabled = true;
render->matrix_used = false;
render->draw_mode = GE_TRIANGLES;
render->memory_mode = GE_STATIC_DRAW;
gePrintDebug(0x100, "LoadRenderer 2\n");
while(geFileGets(fp, buffer, 2048)){
PASS_COMMENTS;
if(strstr(buffer, "END_RENDERER"))break;
geGetParamInt(buffer, "enabled", &render->enabled);
geGetParamInt(buffer, "depth_enabled", &render->depth_enabled);
geGetParamInt(buffer, "blend_enabled", &render->blend_enabled);
geGetParamInt(buffer, "depth_mask", &render->depth_mask);
if(geGetParamString(buffer, "extension", tmp, 2048)){
float f = 0.0;
if(geGetParamFloat(buffer, "WATER", &f)){
geWaterInit(render, f);
}
}
if(strstr(buffer, "view")){
float params[3];
if(geGetParamFloatMulti(buffer, "view", params, 3)){
render->matrix_used = true;
ge_LoadIdentity(render->projection_matrix);
ge_Perspective(render->projection_matrix, params[0], (float)geGetContext()->width/(float)geGetContext()->height, params[1], params[2]);
}
}
if(geGetParamString(buffer, "objects", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer B\n");
sprintf(fl, "%s%s", path, tmp);
char** obj_list = (char**)geMalloc(sizeof(char*)*256);
int a = 0;
for(a=0; a<256; a++){
obj_list[a] = (char*)geMalloc(sizeof(char)*128);
}
int cnt = geGetStringList(buffer, (char**)obj_list, 128, 256);
if(cnt > 1){
memset(obj_list[0],0x0,128); // Pas the "xxxxx.xxx"
render->nObjs = geObjectsCountInFileSubs(fl, (const char**)obj_list, cnt);
}else if(cnt == 1){
render->nObjs = geObjectsCountInFile(fl);
cnt = 0;
}
gePrintDebug(0x100, " LoadRenderer C\n");
render->objs = (ge_Object**)geMalloc(sizeof(ge_Object*)*render->nObjs);
for(a=0; a<render->nObjs; a++){
render->objs[a] = (ge_Object*)geMalloc(sizeof(ge_Object));
}
if(ObjGetType(fl) == GE_TYPE_DAE){
render->animator = (ge_Animator*)geMalloc(sizeof(ge_Animator));
}
gePrintDebug(0x100, " LoadRenderer D\n");
geLoadObjectsList(fl, (const char**)obj_list, cnt, render->objs, render->animator);
gePrintDebug(0x100, " LoadRenderer E\n");
for(a=0; a<render->nObjs; a++){
render->nVerts += render->objs[a]->nVerts;
}
gePrintDebug(0x100, " LoadRenderer F\n");
render->verts = (ge_Vertex*)geMalloc(sizeof(ge_Vertex)*render->nVerts);
gePrintDebug(0x100, " LoadRenderer G\n");
int v = 0;
for(a=0; a<render->nObjs; a++){
memcpy(&render->verts[v], render->objs[a]->verts, sizeof(ge_Vertex)*render->objs[a]->nVerts);
geFree(render->objs[a]->verts);
render->objs[a]->verts = &render->verts[v];
render->objs[a]->vert_start = v;
v += render->objs[a]->nVerts;
}
gePrintDebug(0x100, " LoadRenderer H\n");
}
if(geGetParamString(buffer, "vertex_shader", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer F\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.vert", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
geShaderLoadVertexSource(render->shader, fl);
}
if(geGetParamString(buffer, "tesselation_control_shader", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer D\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.tess", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
geShaderLoadTessControlSource(render->shader, fl);
render->tesselated = true;
}
if(geGetParamString(buffer, "tesselation_evaluation_shader", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer E\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.tess", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
geShaderLoadTessEvaluationSource(render->shader, fl);
render->tesselated = true;
}
if(geGetParamString(buffer, "geometry_shader", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer C\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.geom", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
geShaderLoadGeometrySource(render->shader, fl);
}
if(geGetParamString(buffer, "fragment_shader", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer G\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.frag", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
geShaderLoadFragmentSource(render->shader, fl);
}
if(geGetParamString(buffer, "vertex_shadow", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer H\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.vert", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
if(!render->shadow_shader){
render->shadow_shader = geCreateShader();
}
geShaderLoadVertexSource(render->shadow_shader, fl);
}
if(geGetParamString(buffer, "fragment_shadow", tmp, 2048)){
gePrintDebug(0x100, " LoadRenderer I\n");
if(!strncmp(tmp, "generic", 7)){
sprintf(fl, "%s/%s.frag", libge_context->default_shaders_path, tmp);
}else{
sprintf(fl, "%s%s", path, tmp);
}
gePrintDebug(0x100, "file: \"%s\"\n", fl);
if(!render->shadow_shader){
render->shadow_shader = geCreateShader();
}
geShaderLoadFragmentSource(render->shadow_shader, fl);
}
}
#ifndef PLATFORM_mac
if(render->tesselated){
render->draw_mode = GE_PATCHES;
}
#endif
gePrintDebug(0x100, "LoadRenderer 3\n");
geRendererCreateContext(scene, render);
gePrintDebug(0x100, "LoadRenderer 4\n");
}
