Index: common.h
===================================================================
--- common.h	(revision 90)
+++ common.h	(revision 91)
@@ -211,8 +211,8 @@
 
 #define RAYDIUM_RENDER_MULTITEX_AUTO_UV_FACT	50
 
-#define RAYDIUM_SPHERE_MAX_DETAIL 		30
-#define RAYDIUM_SPHERE_DEFAULT_DETAIL 		25
+#define RAYDIUM_SKY_SPHERE_MAX_DETAIL 		30
+#define RAYDIUM_SKY_SPHERE_DEFAULT_DETAIL 	25
 
 #ifdef MAIN_H
 #define __global extern
@@ -263,8 +263,12 @@
 __global GLfloat raydium_projection_bottom; 	// ortho only
 __global GLfloat raydium_projection_top; 	// ortho only
 __global GLfloat raydium_background_color[4];
-__global signed char	 raydium_sky_force;
 
+__global signed char raydium_sky_force;
+__global signed char raydium_sky_atmosphere_enable_tag;
+__global GLfloat     raydium_sky_sphere_angle_orbit_u;
+__global GLfloat     raydium_sky_sphere_angle_orbit_v;
+__global signed char raydium_sky_sphere_generated;
 
 __global GLsizei raydium_window_tx;
 __global GLsizei raydium_window_ty;
@@ -510,5 +514,11 @@
 __global char raydium_file_log_fopen[RAYDIUM_MAX_LOG_FOPEN][RAYDIUM_MAX_NAME_LEN];
 __global int raydium_file_log_fopen_index;
 
+typedef struct matrix4x4
+{
+  double  ray[16];
+} matrix4x4;
+
+
 #endif
 // EOF
ile=raydium_file_fopen(filename,"rb");
+ if(!file)
+  {
+    raydium_log("Cannot open %s texture",filename);
+    return 0;
+  }
+
+ fread(temp,1,12,file);
+ if(temp[2]!=2 && temp[2]!=3) 
+ { 
+ fclose(file); 
+ raydium_log("%s is not an uncompressed TGA RGB or grayscale file (type %i)",filename,temp[2]);
+ return 0; //not a: uncompressed TGA RGB file
+ } 
+
+ fread(temp,1,6,file);
+
+ tx = temp[1] * 256 + temp[0]; // highbyte*256+lowbyte
+ ty = temp[3] * 256 + temp[2]; // highbyte*256+lowbyte
+
+ if( !raydium_texture_size_is_correct(tx) || !raydium_texture_size_is_correct(ty) )
+ {
+ raydium_log("texture: ERROR: cannot load %s: invalid size %ix%i (must be a power of two and inferior to your max hardware size: %i)",filename,tx,ty,raydium_texture_size_max);
+ raydium_log("texture: I will fake this texture.");
+ tx=ty=1;
+ }
+ bpp= temp[4] / 8;
+ texsize = tx * ty * bpp;
+
+ data=malloc(texsize);
+ if(!data) { 
+ fclose(file); 
+ raydium_log("texture: ERROR ! malloc for %s failed ! (%i bytes needed)",filename,tx*ty*bpp);
+ return 0; }
+
+ for(j=0; j<ty; j++)
+ for(i=0; i<tx; i++)
+ {
+ if(fread(temp,1,bpp,file)!=bpp) 
+ { free(data); fclose(file); 
+ raydium_log("Invalid data in %s",filename);
+ return 0; }
+ k=(( (ty-j-1) *tx)+i)*bpp;
+ if(bpp == 1) data[k]=temp[0];
+ else // no greyscale
+  {
+   data[k]=temp[2];
+   data[k+1]=temp[1];
+   data[k+2]=temp[0];
+   if(bpp == 4) 
+    { 
+    data[k+3]=temp[3]; 
+    if(temp[3]>0 && temp[3]<255)
+	blended=1;
+    if(temp[3]==0)
+	cutout=1;
+    }
+  }
+ }
+
+ fclose(file);
+ glPixelStorei(GL_UNPACK_ALIGNMENT,1); //TEMPO
+} //end !rgb
+
+
+
+if(raydium_texture_to_replace)
+ { id=raydium_texture_to_replace; raydium_texture_to_replace=0; }
+ else
+ id=raydium_texture_index++;
+ 
+if(raydium_texture_index>RAYDIUM_MAX_TEXTURES) 
+    { 
+    raydium_log("texture: No more texture slots left ! (%i max)",
+		RAYDIUM_MAX_TEXTURES); 
+    return 0; 
+    }
+
+strcpy(raydium_texture_name[id],as);
+
+if(!rgb)
+{
+ if(bpp==1) 
+    { 
+    GLbpp=GL_ALPHA;
+    GLbppi=GL_ALPHA8;
+    blended=1; 
+    }
+
+ if(bpp==3) 
+    {
+    GLbpp=GL_RGB;
+    GLbppi=GL_RGBA8; // force RGBA (since ATI cards needs it)
+    texsize += tx * ty;
+    }
+    
+ if(bpp==4) 
+    {
+    GLbpp=GL_RGBA;
+    GLbppi=GL_RGBA8;
+    }
+
+ raydium_texture_blended[id]=0;
+ if(blended)
+    raydium_texture_blended[id]=1;
+
+ if(cutout && !blended)
+    {
+    raydium_texture_blended[id]=2;
+    blended=2;
+    }
+
+
+ raydium_texture_used_memory+=texsize;
+ if(raydium_texture_filter==RAYDIUM_TEXTURE_FILTER_TRILINEAR)
+    raydium_texture_used_memory+=(texsize/3); // mipmaps
+
+ glBindTexture(GL_TEXTURE_2D,id);
+
+
+ if(strstr(filename,".tri."))
+    raydium_texture_islightmap[id]=1;
+
+ memcpy(temp,filename,3);						// TEMP !!
+ temp[3]=0;								// TEMP !!
+ if(!strcmp("BOX",temp))						// TEMP !!
+ {									// TEMP !!
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);		// TEMP !!
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);		// TEMP !!
+ }									// TEMP !!
+ else
+ {
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
+ }
+
+ filter=raydium_texture_filter;
+ if(filter==RAYDIUM_TEXTURE_FILTER_TRILINEAR && blended)
+ filter=RAYDIUM_TEXTURE_FILTER_BILINEAR;
+
+  if(filter==RAYDIUM_TEXTURE_FILTER_NONE)
+  {
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); 
+  glTexImage2D(GL_TEXTURE_2D,0,GLbppi,tx,ty,0,GLbpp,GL_UNSIGNED_BYTE,data);
+  }
+
+  if(filter==RAYDIUM_TEXTURE_FILTER_BILINEAR)
+  {
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexImage2D(GL_TEXTURE_2D,0,GLbppi,tx,ty,0,GLbpp,GL_UNSIGNED_BYTE,data);
+  }
+
+  if(filter==RAYDIUM_TEXTURE_FILTER_TRILINEAR)
+  {
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); // Trilinear filtering
+  gluBuild2DMipmaps(GL_TEXTURE_2D, GLbppi, tx, ty, GLbpp, GL_UNSIGNED_BYTE, data);
+  }
+
+ raydium_log("Texture num %i (%s) loaded: %ix%i, %i bpp (b%i lm%i)",
+	     id,raydium_texture_name[id],tx,ty,bpp,
+	     blended,raydium_texture_islightmap[id]);
+ free(data);
+} else /* is rgb color */
+{
+ sscanf(filename,"rgb(%f,%f,%f)",&r,&g,&b);
+ raydium_texture_rgb[id][0]=r;
+ raydium_texture_rgb[id][1]=g;
+ raydium_texture_rgb[id][2]=b;
+ raydium_texture_rgb[id][3]=1.f;
+ raydium_texture_blended[id]=0;
+ raydium_log("Texture num %i, rgb(%f,%f,%f) is RGB Color",id,r,g,b);
+}
+ 
+return id;
+}
+
+GLuint raydium_texture_load(char *filename)
+{
+GLuint res;
+res=raydium_texture_load_internal(filename,filename);
+if(res<=0)
+    {
+    raydium_log("texture: faking '%s' with pink color");
+    res=raydium_texture_load_internal("rgb(1,0,1)",filename);
+    }
+return res;
+}
+
+
+GLuint raydium_texture_load_erase(char *filename, GLuint to_replace)
+{
+if(to_replace<=0) return 0;
+raydium_texture_to_replace=to_replace;
+return raydium_texture_load(filename);
+}
+
+
+char raydium_texture_current_set(GLuint current)
+{
+if(current<RAYDIUM_MAX_TEXTURES)
+{ raydium_texture_current=current; return current; }
+return 0;
+}
+
+GLuint raydium_texture_find_by_name(char *name)
+{
+GLuint i;
+char flag=0;
+GLuint ret=0;
+
+for(i=0;i<raydium_texture_index;i++)
+if(!strcmp(raydium_texture_name[i],name)) { flag++; ret=i; }
+
+if(!flag) ret=raydium_texture_load(name);
+return ret;
+}
+
+
+char raydium_texture_current_set_name(char *name)
+{
+/*
+GLuint i;
+char flag=0;
+char ret=0;
+
+for(i=0;i<raydium_texture_index;i++)
+if(!strcmp(raydium_texture_name[i],name)) { flag++; raydium_texture_current_set(i); ret=i; }
+
+if(!flag) ret=raydium_texture_current_set(raydium_texture_load(name));
+*/
+return raydium_texture_current_set(raydium_texture_find_by_name(name));
+}
+
+
+void raydium_texture_filter_change(GLuint filter)
+{
+GLuint i;
+char force[RAYDIUM_MAX_NAME_LEN];
+
+if(raydium_init_cli_option("filter",force))
+    {
+    if(!strcmp(force,"none")) filter=RAYDIUM_TEXTURE_FILTER_NONE;
+    if(!strcmp(force,"bilinear")) filter=RAYDIUM_TEXTURE_FILTER_BILINEAR;
+    if(!strcmp(force,"trilinear")) filter=RAYDIUM_TEXTURE_FILTER_TRILINEAR;
+    }
+
+raydium_texture_filter=filter;
+
+for(i=0;i<raydium_texture_index;i++)
+    raydium_texture_load_erase(raydium_texture_name[i],i);
+
+}
+