clread.c

00001 #include <cl.h>
00002 
00003 /* used for clread methods */
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   CLread: file cannot be NULL
00016           dest cannot be NULL
00017           return 0 on error (will not check file for NULL)
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 }

Generated on Thu Dec 27 13:53:41 2007 for CL by  doxygen 1.4.6