00001 #include <cl.h>
00002
00003
00004 #define _CL_FREAD(ptr, size, nmemb, stream) \
00005 do { \
00006 if ((fread((ptr), (size), (nmemb), (stream)) * (size)) \
00007 < ((nmemb) * (size))) \
00008 return GL_FALSE; \
00009 } while(0)
00010
00011 #define _CL_MALLOC(n) \
00012 ((n) ? malloc(n) : 0)
00013
00014
00015
00016
00017
00018
00019 bool clReadColour(CLcolour* dest, FILE* file)
00020 {
00021 if (!dest)
00022 return GL_FALSE;
00023
00024 _CL_FREAD(dest, sizeof(CLcolour), 1, file);
00025
00026 return GL_TRUE;
00027 }
00028
00029 bool clReadVertex(CLvertex* dest, FILE* file)
00030 {
00031 if (!dest)
00032 return GL_FALSE;
00033
00034 _CL_FREAD(dest, sizeof(CLvertex), 1, file);
00035
00036 return GL_TRUE;
00037 }
00038
00039 bool clReadNormal(CLnormal* dest, FILE* file)
00040 {
00041 if (!dest)
00042 return GL_FALSE;
00043
00044 _CL_FREAD(dest, sizeof(CLnormal), 1, file);
00045
00046 return GL_TRUE;
00047 }
00048
00049 bool clReadTexCoord(CLtexcoord* dest, FILE* file)
00050 {
00051 if (!dest)
00052 return GL_FALSE;
00053
00054 _CL_FREAD(dest, sizeof(CLtexcoord), 1, file);
00055
00056 return GL_TRUE;
00057 }
00058
00059 bool clReadEdgeFlag(CLedgeflag* dest, FILE* file)
00060 {
00061 if (!dest)
00062 return GL_FALSE;
00063
00064 _CL_FREAD(dest, sizeof(CLedgeflag), 1, file);
00065
00066 return GL_TRUE;
00067 }
00068
00069 bool clReadMatrix(CLmatrix* dest, FILE* file)
00070 {
00071 if (!dest)
00072 return GL_FALSE;
00073
00074 _CL_FREAD(dest, sizeof(CLmatrix), 1, file);
00075
00076 return GL_TRUE;
00077 }
00078
00079 bool clReadImage(CLimage* dest, FILE* file)
00080 {
00081 GLuint s;
00082
00083 if (!dest)
00084 return GL_FALSE;
00085
00086 _CL_FREAD(dest, sizeof(CLimage), 1, file);
00087
00088 s = clImageDataSize(dest);
00089 dest->data = (GLvoid*)_CL_MALLOC(s);
00090 _CL_FREAD(dest->data, s, 1, file);
00091
00092 return GL_TRUE;
00093 }
00094
00095 bool clReadLight(CLlight* dest, FILE* file)
00096 {
00097 if (!dest)
00098 return GL_FALSE;
00099
00100 _CL_FREAD(dest, sizeof(CLlight), 1, file);
00101
00102 dest->display_list = 0;
00103
00104 return GL_TRUE;
00105 }
00106
00107 bool clReadMaterial(CLmaterial* dest, FILE* file)
00108 {
00109 if (!dest)
00110 return GL_FALSE;
00111
00112 _CL_FREAD(dest, sizeof(CLmaterial), 1, file);
00113
00114 dest->display_list = 0;
00115
00116 return GL_TRUE;
00117 }
00118
00119 bool clReadTexture(CLtexture* dest, FILE* file)
00120 {
00121 GLuint s;
00122
00123 if (!dest)
00124 return GL_FALSE;
00125
00126 _CL_FREAD(dest, sizeof(CLtexture), 1, file);
00127
00128 s = clImageDataSize(&dest->image);
00129 dest->image.data = (GLvoid*)_CL_MALLOC(s);
00130 _CL_FREAD(dest->image.data, s, 1, file);
00131
00132 dest->texture_object = 0;
00133
00134 return GL_TRUE;
00135 }
00136
00137 bool clReadPrimitiveSet(CLprimitiveset* dest, FILE* file)
00138 {
00139 if (!dest)
00140 return GL_FALSE;
00141
00142 _CL_FREAD(dest, sizeof(CLprimitiveset), 1, file);
00143
00144 dest->indices = (GLuint*)_CL_MALLOC(dest->num_indices * sizeof(GLuint));
00145 _CL_FREAD(dest->indices, sizeof(GLuint), dest->num_indices, file);
00146
00147 return GL_TRUE;
00148 }
00149
00150 bool clReadMesh(CLmesh* dest, FILE* file)
00151 {
00152 GLuint i;
00153
00154 if (!dest)
00155 return GL_FALSE;
00156
00157 _CL_FREAD(dest, sizeof(CLmesh), 1, file);
00158
00159 if (dest->colour)
00160 {
00161 dest->colour = clNewColour();
00162 clReadColour(dest->colour, file);
00163 }
00164
00165 dest->vertices = (CLvertex*)_CL_MALLOC(dest->num_vertices * sizeof(CLvertex));
00166 _CL_FREAD(dest->vertices, sizeof(CLvertex), dest->num_vertices, file);
00167
00168 if (dest->colours)
00169 {
00170 dest->colours = (CLcolour*)_CL_MALLOC(dest->num_vertices
00171 * sizeof(CLcolour));
00172 _CL_FREAD(dest->colours, sizeof(CLcolour), dest->num_vertices, file);
00173 }
00174
00175 if (dest->normals)
00176 {
00177 dest->normals = (CLnormal*)_CL_MALLOC(dest->num_vertices
00178 * sizeof(CLnormal));
00179 _CL_FREAD(dest->normals, sizeof(CLnormal), dest->num_vertices, file);
00180 }
00181
00182 if (dest->texcoords)
00183 {
00184 dest->texcoords = (CLtexcoord*)_CL_MALLOC(dest->num_vertices
00185 * sizeof(CLtexcoord));
00186 _CL_FREAD(dest->texcoords, sizeof(CLtexcoord), dest->num_vertices, file);
00187 }
00188
00189 if (dest->edgeflags)
00190 {
00191 dest->edgeflags = (CLedgeflag*)_CL_MALLOC(dest->num_vertices
00192 * sizeof(CLedgeflag));
00193 _CL_FREAD(dest->edgeflags, sizeof(CLedgeflag), dest->num_vertices, file);
00194 }
00195
00196 dest->primitivesets = (CLprimitiveset**)_CL_MALLOC(dest->num_primitivesets
00197 * sizeof(CLprimitiveset*));
00198 for (i = 0; i < dest->num_primitivesets; i++)
00199 {
00200 dest->primitivesets[i] = clNewPrimitiveSet();
00201 if (!(clReadPrimitiveSet(dest->primitivesets[i], file)))
00202 return GL_FALSE;
00203 }
00204
00205 dest->context = 0;
00206 dest->display_list = 0;
00207
00208 return GL_TRUE;
00209 }
00210
00211 bool clReadContext(CLcontext* dest, FILE* file)
00212 {
00213 GLuint i;
00214 GLuint j;
00215
00216 if (!dest)
00217 return GL_FALSE;
00218
00219 _CL_FREAD(dest, sizeof(CLcontext), 1, file);
00220
00221 dest->materials = (CLmaterial**)_CL_MALLOC(dest->num_materials
00222 * sizeof(CLmaterial*));
00223 for (i = 0; i < dest->num_materials; i++)
00224 {
00225 dest->materials[i] = clNewMaterial();
00226 if (!(clReadMaterial(dest->materials[i], file)))
00227 return GL_FALSE;
00228 }
00229
00230 dest->textures = (CLtexture**)_CL_MALLOC(dest->num_textures
00231 * sizeof(CLtexture*));
00232 for (i = 0; i < dest->num_textures; i++)
00233 {
00234 dest->textures[i] = clNewTexture();
00235 if (!(clReadTexture(dest->textures[i], file)))
00236 return GL_FALSE;
00237 }
00238
00239 dest->lights = (CLlight**)_CL_MALLOC(dest->num_lights * sizeof(CLlight*));
00240 for (i = 0; i < dest->num_lights; i++)
00241 {
00242 dest->lights[i] = clNewLight();
00243 if (!(clReadLight(dest->lights[i], file)))
00244 return GL_FALSE;
00245 }
00246
00247 dest->models = (CLmodel**)_CL_MALLOC(dest->num_models * sizeof(CLmodel*));
00248 for (i = 0; i < dest->num_models; i++)
00249 {
00250 dest->models[i] = clNewModel();
00251 if (!(clReadModel(dest->models[i], file)))
00252 return GL_FALSE;
00253 dest->models[i]->context = dest;
00254
00255 for (j = 0; j < dest->models[i]->num_meshes; j++)
00256 dest->models[i]->meshes[j]->context = dest;
00257 }
00258
00259 return GL_TRUE;
00260 }
00261
00262 bool clReadModel(CLmodel* dest, FILE* file)
00263 {
00264 GLuint i;
00265
00266 if (!dest)
00267 return GL_FALSE;
00268
00269 _CL_FREAD(dest, sizeof(CLmodel), 1, file);
00270
00271 dest->meshes = (CLmesh**)_CL_MALLOC(dest->num_meshes * sizeof(CLmesh*));
00272 for (i = 0; i < dest->num_meshes; i++)
00273 {
00274 dest->meshes[i] = clNewMesh();
00275 if (!(clReadMesh(dest->meshes[i], file)))
00276 return GL_FALSE;
00277 }
00278
00279 dest->context = 0;
00280
00281 return GL_TRUE;
00282 }