2 * ***** BEGIN GPL LICENSE BLOCK *****
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19 * All rights reserved.
21 * The Original Code is: all of this file.
23 * Contributor(s): none yet.
25 * ***** END GPL LICENSE BLOCK *****
29 * \brief Struct muncher for making SDNA.
32 * \section aboutmakesdnac About makesdna tool
33 * Originally by Ton, some mods by Frank, and some cleaning and
36 * Makesdna creates a .c file with a long string of numbers that
37 * encode the Blender file format. It is fast, because it is basically
38 * a binary dump. There are some details to mind when reconstructing
39 * the file (endianness and byte-alignment).
41 * This little program scans all structs that need to be serialized,
42 * and determined the names and types of all members. It calculates
43 * how much memory (on disk or in ram) is needed to store that struct,
44 * and the offsets for reaching a particular one.
46 * There is a facility to get verbose output from sdna. Search for
47 * \ref debugSDNA. This int can be set to 0 (no output) to some int. Higher
48 * numbers give more output.
51 #define DNA_VERSION_DATE "FIXME-DNA_VERSION_DATE"
57 #include "MEM_guardedalloc.h"
58 #include "DNA_sdna_types.h"
60 #include "BLO_sys_types.h" // for intptr_t support
62 #define SDNA_MAX_FILENAME_LENGTH 255
65 /* Included the path relative from /source/blender/ here, so we can move */
66 /* headers around with more freedom. */
67 const char *includefiles[] = {
69 // if you add files here, please add them at the end
70 // of makesdna.c (this file) as well
78 "DNA_packedFile_types.h",
81 "DNA_texture_types.h",
83 "DNA_material_types.h",
85 // if you add files here, please add them at the end
86 // of makesdna.c (this file) as well
90 "DNA_meshdata_types.h",
91 "DNA_modifier_types.h",
92 "DNA_lattice_types.h",
95 "DNA_object_fluidsim.h",
101 "DNA_userdef_types.h",
102 "DNA_screen_types.h",
104 // if you add files here, please add them at the end
105 // of makesdna.c (this file) as well
106 "DNA_fileglobal_types.h",
107 "DNA_sequence_types.h",
108 "DNA_effect_types.h",
109 "DNA_outliner_types.h",
110 "DNA_property_types.h",
111 "DNA_sensor_types.h",
112 "DNA_controller_types.h",
113 "DNA_actuator_types.h",
116 "DNA_armature_types.h",
117 "DNA_action_types.h",
118 "DNA_constraint_types.h",
123 "DNA_customdata_types.h",
124 "DNA_particle_types.h",
126 "DNA_gpencil_types.h",
127 // if you add files here, please add them at the end
128 // of makesdna.c (this file) as well
129 "DNA_windowmanager_types.h",
133 "DNA_speaker_types.h",
135 // empty string to indicate end of includefiles
139 static int maxdata= 500000, maxnr= 50000;
140 static int nr_names=0;
141 static int nr_types=0;
142 static int nr_structs=0;
143 static char **names, *namedata; /* at address names[a] is string a */
144 static char **types, *typedata; /* at address types[a] is string a */
145 static short *typelens; /* at typelens[a] is de length of type a */
146 static short *alphalens; /* contains sizes as they are calculated on the DEC Alpha (64 bits), infact any 64bit system */
147 static short **structs, *structdata;/* at sp= structs[a] is the first address of a struct definition
149 sp[1] is amount of elements
150 sp[2] sp[3] is typenr, namenr (etc) */
152 * Variable to control debug output of makesdna.
154 * - 0 = no output, except errors
155 * - 1 = detail actions
156 * - 2 = full trace, tell which names and types were found
157 * - 4 = full trace, plus all gritty details
159 static int debugSDNA = 0;
160 static int additional_slen_offset;
162 /* ************************************************************************** */
164 /* ************************************************************************** */
167 * Add type \c str to struct indexed by \c len, if it was not yet found.
171 static int add_type(const char *str, int len);
174 * Add variable \c str to
177 static int add_name(const char *str);
180 * Search whether this structure type was already found, and if not,
183 static short *add_struct(int namecode);
186 * Remove comments from this buffer. Assumes that the buffer refers to
189 static int preprocess_include(char *maindata, int len);
192 * Scan this file for serializable types.
194 static int convert_include(char *filename);
197 * Determine how many bytes are needed for an array.
199 static int arraysize(char *astr, int len);
202 * Determine how many bytes are needed for each struct.
204 static int calculate_structlens(int);
207 * Construct the DNA.c file
209 void dna_write(FILE *file, void *pntr, int size);
212 * Report all structures found so far, and print their lengths.
214 void printStructLenghts(void);
218 /* ************************************************************************** */
220 /* ************************************************************************** */
222 /* ************************* MAKEN DNA ********************** */
224 int add_type(const char *str, int len)
229 if(str[0]==0) return -1;
231 /* search through type array */
232 for(nr=0; nr<nr_types; nr++) {
233 if(strcmp(str, types[nr])==0) {
242 /* append new type */
243 if(nr_types==0) cp= typedata;
245 cp= types[nr_types-1]+strlen(types[nr_types-1])+1;
249 typelens[nr_types]= len;
250 alphalens[nr_types]= len;
252 if(nr_types>=maxnr) {
253 printf("too many types\n");
264 * Because of the weird way of tokenizing, we have to 'cast' function
265 * pointers to ... (*f)(), whatever the original signature. In fact,
266 * we add name and type at the same time... There are two special
267 * cases, unfortunately. These are explicitly checked.
270 static int add_name(const char *str)
274 char buf[255]; /* stupid limit, change it :) */
277 additional_slen_offset = 0;
279 if(str[0]==0 /* || (str[1]==0) */) return -1;
281 if (str[0] == '(' && str[1] == '*') {
282 /* we handle function pointer and special array cases here, e.g.
283 void (*function)(...) and float (*array)[..]. the array case
284 name is still converted to (array*)() though because it is that
285 way in old dna too, and works correct with elementsize() */
286 int isfuncptr = (strchr(str+1, '(')) != NULL;
288 if (debugSDNA > 3) printf("\t\t\t\t*** Function pointer or multidim array pointer found\n");
289 /* functionpointer: transform the type (sometimes) */
292 while (str[i] != ')') {
297 /* Another number we need is the extra slen offset. This extra
298 * offset is the overshoot after a space. If there is no
299 * space, no overshoot should be calculated. */
300 j = i; /* j at first closing brace */
302 if (debugSDNA > 3) printf("first brace after offset %d\n", i);
304 j++; /* j beyond closing brace ? */
305 while ((str[j] != 0) && (str[j] != ')' )) {
306 if (debugSDNA > 3) printf("seen %c ( %d) \n", str[j], str[j]);
309 if (debugSDNA > 3) printf("seen %c ( %d) \n", str[j], str[j]);
310 if (debugSDNA > 3) printf("special after offset %d\n", j);
313 /* multidimensional array pointer case */
315 if (debugSDNA > 3) printf("offsetting for multidim array pointer\n");
318 printf("Error during tokening multidim array pointer\n");
320 else if (str[j] == 0 ) {
321 if (debugSDNA > 3) printf("offsetting for space\n");
322 /* get additional offset */
324 while (str[j] != ')') {
328 if (debugSDNA > 3) printf("extra offset %d\n", k);
329 additional_slen_offset = k;
330 } else if (str[j] == ')' ) {
331 if (debugSDNA > 3) printf("offsetting for brace\n");
332 ; /* don't get extra offset */
334 printf("Error during tokening function pointer argument list\n");
338 * Put )(void) at the end? Maybe )(). Should check this with
339 * old sdna. Actually, sometimes )(), sometimes )(void...)
340 * Alas.. such is the nature of braindamage :(
342 * Sorted it out: always do )(), except for headdraw and
343 * windraw, part of ScrArea. This is important, because some
344 * linkers will treat different fp's differently when called
345 * !!! This has to do with interference in byte-alignment and
346 * the way args are pushed on the stack.
350 if (debugSDNA > 3) printf("Name before chomping: %s\n", buf);
351 if ( (strncmp(buf,"(*headdraw", 10) == 0)
352 || (strncmp(buf,"(*windraw", 9) == 0) ) {
367 /* now precede with buf*/
368 if (debugSDNA > 3) printf("\t\t\t\t\tProposing fp name %s\n", buf);
371 /* normal field: old code */
375 /* search name array */
376 for(nr=0; nr<nr_names; nr++) {
377 if(strcmp(name, names[nr])==0) {
382 /* append new type */
383 if(nr_names==0) cp= namedata;
385 cp= names[nr_names-1]+strlen(names[nr_names-1])+1;
390 if(nr_names>=maxnr) {
391 printf("too many names\n");
399 short *add_struct(int namecode)
405 structs[0]= structdata;
408 sp= structs[nr_structs-1];
410 structs[nr_structs]= sp+ 2*len+2;
413 sp= structs[nr_structs];
416 if(nr_structs>=maxnr) {
417 printf("too many structs\n");
425 static int preprocess_include(char *maindata, int len)
427 int a, newlen, comment = 0;
428 char *cp, *temp, *md;
430 /* note: len + 1, last character is a dummy to prevent
431 * comparisons using uninitialized memory */
432 temp= MEM_mallocN(len + 1, "preprocess_include");
435 memcpy(temp, maindata, len);
437 // remove all c++ comments
438 /* replace all enters/tabs/etc with spaces */
443 if(cp[0]=='/' && cp[1]=='/') {
448 if (comment || *cp<32 || *cp>128 ) *cp= 32;
453 /* data from temp copy to maindata, remove comments and double spaces */
461 if(cp[0]=='/' && cp[1]=='*') {
465 if(cp[0]=='*' && cp[1]=='/') {
470 /* do not copy when: */
472 else if( cp[0]==' ' && cp[1]==' ' );
473 else if( cp[-1]=='*' && cp[0]==' ' ); /* pointers with a space */
486 static void *read_file_data(char *filename, int *len_r)
489 FILE *fp= fopen(filename, "rb");
491 FILE *fp= fopen(filename, "r");
500 fseek(fp, 0L, SEEK_END);
502 fseek(fp, 0L, SEEK_SET);
504 data= MEM_mallocN(*len_r, "read_file_data");
511 if (fread(data, *len_r, 1, fp)!=1) {
522 int convert_include(char *filename)
524 /* read include file, skip structs with a '#' before it.
525 store all data in temporal arrays.
527 int filelen, count, overslaan, slen, type, name, strct;
528 short *structpoin, *sp;
529 char *maindata, *mainend, *md, *md1;
531 md= maindata= read_file_data(filename, &filelen);
533 printf("Can't read file %s\n", filename);
537 filelen= preprocess_include(maindata, filelen);
538 mainend= maindata+filelen-1;
540 /* we look for '{' and then back to 'struct' */
543 while(count<filelen) {
545 /* code for skipping a struct: two hashes on 2 lines. (preprocess added a space) */
546 if(md[0]=='#' && md[1]==' ' && md[2]=='#') {
556 if(md[-1]==' ') md[-1]= 0;
558 while( *md1!=32) md1--; /* to beginning of word */
561 /* we've got a struct name when... */
562 if( strncmp(md1-7, "struct", 6)==0 ) {
565 strct= add_type(md1, 0);
566 structpoin= add_struct(strct);
569 if (debugSDNA > 1) printf("\t|\t|-- detected struct %s\n", types[strct]);
571 /* first lets make it all nice strings */
574 if(md1>mainend) break;
576 if(*md1==',' || *md1==' ') *md1= 0;
580 /* read types and names until first character that is not '}' */
582 while( *md1 != '}' ) {
583 if(md1>mainend) break;
585 /* skip when it says 'struct' or 'unsigned' or 'const' */
587 if( strncmp(md1, "struct", 6)==0 ) md1+= 7;
588 if( strncmp(md1, "unsigned", 8)==0 ) md1+= 9;
589 if( strncmp(md1, "const", 5)==0 ) md1+= 6;
591 /* we've got a type! */
592 type= add_type(md1, 0);
594 if (debugSDNA > 1) printf("\t|\t|\tfound type %s (", md1);
600 while( *md1 != ';' ) {
601 if(md1>mainend) break;
604 /* We've got a name. slen needs
605 * correction for function
607 slen= (int) strlen(md1);
608 if( md1[slen-1]==';' ) {
613 slen += additional_slen_offset;
617 if ((debugSDNA>1) && (names[name] != NULL)) printf("%s |", names[name]);
628 slen += additional_slen_offset;
632 if ((debugSDNA > 1) && (names[name] != NULL)) printf("%s ||", names[name]);
642 if (debugSDNA > 1) printf(")\n");
659 int arraysize(char *astr, int len)
662 char str[100], *cp=NULL;
664 memcpy(str, astr, len+1);
666 for(a=0; a<len; a++) {
670 else if( str[a]==']' && cp) {
672 /* if 'cp' is a preprocessor definition, it will evaluate to 0,
673 * the caller needs to check for this case and throw an error */
681 static int calculate_structlens(int firststruct)
683 int a, b, len, alphalen, unknown= nr_structs, lastunknown, structtype, type, mul, namelen;
684 short *sp, *structpoin;
686 int has_pointer, dna_error = 0;
689 lastunknown= unknown;
692 /* check all structs... */
693 for(a=0; a<nr_structs; a++) {
694 structpoin= structs[a];
695 structtype= structpoin[0];
697 /* when length is not known... */
698 if(typelens[structtype]==0) {
705 /* check all elements in struct */
706 for(b=0; b<structpoin[1]; b++, sp+=2) {
710 namelen= (int) strlen(cp);
711 /* is it a pointer or function pointer? */
712 if(cp[0]=='*' || cp[1]=='*') {
714 /* has the name an extra length? (array) */
716 if( cp[namelen-1]==']') mul= arraysize(cp, namelen);
719 printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
724 if(sizeof(void *) == 4) {
726 printf("Align pointer error in struct (len4): %s %s\n", types[structtype], cp);
731 printf("Align pointer error in struct (len8): %s %s\n", types[structtype], cp);
737 printf("Align pointer error in struct (alphalen8): %s %s\n", types[structtype],cp);
741 len += sizeof(void *) * mul;
744 } else if(cp[0]=='[') {
745 /* parsing can cause names "var" and "[3]" to be found for "float var [3]" ... */
746 printf("Parse error in struct, invalid member name: %s %s\n", types[structtype], cp);
748 } else if( typelens[type] ) {
749 /* has the name an extra length? (array) */
751 if( cp[namelen-1]==']') mul= arraysize(cp, namelen);
754 printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
758 /* struct alignment */
759 if(type >= firststruct) {
760 if(sizeof(void *)==8 && (len % 8) ) {
761 printf("Align struct error: %s %s\n", types[structtype],cp);
767 if(typelens[type]>3 && (len % 4) ) {
768 printf("Align 4 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len%4);
771 else if(typelens[type]==2 && (len % 2) ) {
772 printf("Align 2 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len%2);
776 len += mul*typelens[type];
777 alphalen += mul * alphalens[type];
789 typelens[structtype]= len;
790 alphalens[structtype]= alphalen;
791 // two ways to detect if a struct contains a pointer:
792 // has_pointer is set or alphalen != len
793 if (has_pointer || alphalen != len) {
795 printf("Sizeerror 8 in struct: %s (add %d bytes)\n", types[structtype], alphalen%8);
801 printf("Sizeerror 4 in struct: %s (add %d bytes)\n", types[structtype], len%4);
809 if(unknown==lastunknown) break;
813 printf("ERROR: still %d structs unknown\n", unknown);
816 printf("*** Known structs : \n");
818 for(a=0; a<nr_structs; a++) {
819 structpoin= structs[a];
820 structtype= structpoin[0];
823 if(typelens[structtype]!=0) {
824 printf(" %s\n", types[structtype]);
830 printf("*** Unknown structs : \n");
832 for(a=0; a<nr_structs; a++) {
833 structpoin= structs[a];
834 structtype= structpoin[0];
836 /* length unkown yet */
837 if(typelens[structtype]==0) {
838 printf(" %s\n", types[structtype]);
846 #define MAX_DNA_LINE_LENGTH 20
848 void dna_write(FILE *file, void *pntr, int size)
850 static int linelength = 0;
854 data = (char *) pntr;
856 for (i = 0 ; i < size ; i++)
858 fprintf(file, "%d,", data[i]);
860 if (linelength >= MAX_DNA_LINE_LENGTH) {
867 void printStructLenghts(void)
869 int a, unknown= nr_structs, structtype;
870 /*int lastunknown;*/ /*UNUSED*/
872 printf("\n\n*** All detected structs:\n");
875 /*lastunknown= unknown;*/ /*UNUSED*/
878 /* check all structs... */
879 for(a=0; a<nr_structs; a++) {
880 structpoin= structs[a];
881 structtype= structpoin[0];
882 printf("\t%s\t:%d\n", types[structtype], typelens[structtype]);
886 printf("*** End of list\n");
891 static int make_structDNA(char *baseDirectory, FILE *file)
895 /* str contains filenames. Since we now include paths, I stretched */
896 /* it a bit. Hope this is enough :) -nzc- */
897 char str[SDNA_MAX_FILENAME_LENGTH], *cp;
900 if (debugSDNA > -1) {
902 printf("Running makesdna at debug level %d\n", debugSDNA);
903 printf("\tProgram version: %s\n", DNA_VERSION_DATE);
906 /* the longest known struct is 50k, so we assume 100k is sufficent! */
907 namedata= MEM_callocN(maxdata, "namedata");
908 typedata= MEM_callocN(maxdata, "typedata");
909 structdata= MEM_callocN(maxdata, "structdata");
911 /* a maximum of 5000 variables, must be sufficient? */
912 names= MEM_callocN(sizeof(char *)*maxnr, "names");
913 types= MEM_callocN(sizeof(char *)*maxnr, "types");
914 typelens= MEM_callocN(sizeof(short)*maxnr, "typelens");
915 alphalens= MEM_callocN(sizeof(short)*maxnr, "alphalens");
916 structs= MEM_callocN(sizeof(short)*maxnr, "structs");
918 /* insertion of all known types */
919 /* watch it: uint is not allowed! use in structs an unsigned int */
920 add_type("char", 1); /* 0 */
921 add_type("uchar", 1); /* 1 */
922 add_type("short", 2); /* 2 */
923 add_type("ushort", 2); /* 3 */
924 add_type("int", 4); /* 4 */
925 add_type("long", 4); /* 5 */ /* should it be 8 on 64 bits? */
926 add_type("ulong", 4); /* 6 */
927 add_type("float", 4); /* 7 */
928 add_type("double", 8); /* 8 */
929 add_type("void", 0); /* 9 */
931 // the defines above shouldn't be output in the padding file...
932 firststruct = nr_types;
934 /* add all include files defined in the global array */
935 /* Since the internal file+path name buffer has limited length, I do a */
936 /* little test first... */
937 /* Mind the breaking condition here! */
938 if (debugSDNA) printf("\tStart of header scan:\n");
939 for (i = 0; strlen(includefiles[i]); i++) {
940 sprintf(str, "%s%s", baseDirectory, includefiles[i]);
941 if (debugSDNA) printf("\t|-- Converting %s\n", str);
942 if (convert_include(str)) {
946 if (debugSDNA) printf("\tFinished scanning %d headers.\n", i);
948 if (calculate_structlens(firststruct)) {
960 printf("nr_names %d nr_types %d nr_structs %d\n", nr_names, nr_types, nr_structs);
961 for(a=0; a<nr_names; a++) {
962 printf(" %s \n", names[a]);
967 for(a=0; a<nr_types; a++, sp++) {
968 printf(" %s %d\n", types[a], *sp);
972 for(a=0; a<nr_structs; a++) {
974 printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1],typelens[sp[0]]);
977 /* ? num_types was elem? */
978 for(b=0; b< num_types; b++, sp+= 2) {
979 printf(" %s %s\n", types[sp[0]], names[sp[1]]);
986 if (debugSDNA > -1) printf("Writing file ... ");
988 if(nr_names==0 || nr_structs==0);
991 dna_write(file, str, 4);
995 dna_write(file, str, 4);
997 dna_write(file, &len, 4);
999 /* calculate size of datablock with strings */
1000 cp= names[nr_names-1];
1001 cp+= strlen(names[nr_names-1]) + 1; /* +1: null-terminator */
1002 len= (intptr_t) (cp - (char*) names[0]);
1004 dna_write(file, names[0], len);
1007 strcpy(str, "TYPE");
1008 dna_write(file, str, 4);
1010 dna_write(file, &len, 4);
1012 /* calculate datablock size */
1013 cp= types[nr_types-1];
1014 cp+= strlen(types[nr_types-1]) + 1; /* +1: null-terminator */
1015 len= (intptr_t) (cp - (char*) types[0]);
1018 dna_write(file, types[0], len);
1020 /* WRITE TYPELENGTHS */
1021 strcpy(str, "TLEN");
1022 dna_write(file, str, 4);
1025 if(nr_types & 1) len+= 2;
1026 dna_write(file, typelens, len);
1029 strcpy(str, "STRC");
1030 dna_write(file, str, 4);
1032 dna_write(file, &len, 4);
1034 /* calc datablock size */
1035 sp= structs[nr_structs-1];
1036 sp+= 2+ 2*( sp[1] );
1037 len= (intptr_t) ((char*) sp - (char*) structs[0]);
1040 dna_write(file, structs[0], len);
1042 /* a simple dna padding test */
1047 fp= fopen("padding.c", "w");
1051 // add all include files defined in the global array
1052 for (i = 0; strlen(includefiles[i]); i++) {
1053 fprintf(fp, "#include \"%s%s\"\n", baseDirectory, includefiles[i]);
1056 fprintf(fp, "main(){\n");
1059 for(a=firststruct; a<nr_types; a++, sp++) {
1061 fprintf(fp, "\tif(sizeof(struct %s) - %d) printf(\"ALIGN ERROR:", types[a], *sp);
1062 fprintf(fp, "%%d %s %d ", types[a], *sp);
1063 fprintf(fp, "\\n\", sizeof(struct %s) - %d);\n", types[a], *sp);
1070 /* end end padding test */
1074 MEM_freeN(namedata);
1075 MEM_freeN(typedata);
1076 MEM_freeN(structdata);
1079 MEM_freeN(typelens);
1080 MEM_freeN(alphalens);
1083 if (debugSDNA > -1) printf("done.\n");
1088 /* ************************* END MAKE DNA ********************** */
1090 static void make_bad_file(const char *file, int line)
1092 FILE *fp= fopen(file, "w");
1093 fprintf(fp, "#error \"Error! can't make correct DNA.c file from %s:%d, STUPID!\"\n", __FILE__, line);
1098 #define BASE_HEADER "../"
1101 int main(int argc, char ** argv)
1104 int return_status = 0;
1106 if (argc!=2 && argc!=3) {
1107 printf("Usage: %s outfile.c [base directory]\n", argv[0]);
1110 file = fopen(argv[1], "w");
1112 printf ("Unable to open file: %s\n", argv[1]);
1115 char baseDirectory[256];
1118 strcpy(baseDirectory, argv[2]);
1120 strcpy(baseDirectory, BASE_HEADER);
1123 fprintf (file, "unsigned char DNAstr[]= {\n");
1124 if (make_structDNA(baseDirectory, file)) {
1127 make_bad_file(argv[1], __LINE__);
1130 fprintf(file, "};\n");
1131 fprintf(file, "int DNAlen= sizeof(DNAstr);\n");
1139 return(return_status);
1142 // include files for automatic dependancies
1143 #include "DNA_listBase.h"
1144 #include "DNA_vec_types.h"
1146 #include "DNA_ipo_types.h"
1147 #include "DNA_key_types.h"
1148 #include "DNA_text_types.h"
1149 #include "DNA_packedFile_types.h"
1150 #include "DNA_camera_types.h"
1151 #include "DNA_image_types.h"
1152 #include "DNA_texture_types.h"
1153 #include "DNA_lamp_types.h"
1154 #include "DNA_material_types.h"
1155 #include "DNA_vfont_types.h"
1156 #include "DNA_meta_types.h"
1157 #include "DNA_curve_types.h"
1158 #include "DNA_mesh_types.h"
1159 #include "DNA_meshdata_types.h"
1160 #include "DNA_modifier_types.h"
1161 #include "DNA_lattice_types.h"
1162 #include "DNA_object_types.h"
1163 #include "DNA_object_force.h"
1164 #include "DNA_object_fluidsim.h"
1165 #include "DNA_world_types.h"
1166 #include "DNA_scene_types.h"
1167 #include "DNA_view3d_types.h"
1168 #include "DNA_view2d_types.h"
1169 #include "DNA_space_types.h"
1170 #include "DNA_userdef_types.h"
1171 #include "DNA_screen_types.h"
1172 #include "DNA_sdna_types.h"
1173 #include "DNA_fileglobal_types.h"
1174 #include "DNA_sequence_types.h"
1175 #include "DNA_effect_types.h"
1176 #include "DNA_outliner_types.h"
1177 #include "DNA_property_types.h"
1178 #include "DNA_sensor_types.h"
1179 #include "DNA_controller_types.h"
1180 #include "DNA_actuator_types.h"
1181 #include "DNA_sound_types.h"
1182 #include "DNA_group_types.h"
1183 #include "DNA_armature_types.h"
1184 #include "DNA_action_types.h"
1185 #include "DNA_constraint_types.h"
1186 #include "DNA_nla_types.h"
1187 #include "DNA_node_types.h"
1188 #include "DNA_color_types.h"
1189 #include "DNA_brush_types.h"
1190 #include "DNA_customdata_types.h"
1191 #include "DNA_particle_types.h"
1192 #include "DNA_cloth_types.h"
1193 #include "DNA_gpencil_types.h"
1194 #include "DNA_windowmanager_types.h"
1195 #include "DNA_anim_types.h"
1196 #include "DNA_boid_types.h"
1197 #include "DNA_smoke_types.h"
1198 #include "DNA_speaker_types.h"