4 * ***** BEGIN GPL LICENSE BLOCK *****
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21 * All rights reserved.
23 * The Original Code is: all of this file.
25 * Contributor(s): none yet.
27 * ***** END GPL LICENSE BLOCK *****
31 * \brief Struct muncher for making SDNA.
34 * \section aboutmakesdnac About makesdna tool
35 * Originally by Ton, some mods by Frank, and some cleaning and
38 * Makesdna creates a .c file with a long string of numbers that
39 * encode the Blender file format. It is fast, because it is basically
40 * a binary dump. There are some details to mind when reconstructing
41 * the file (endianness and byte-alignment).
43 * This little program scans all structs that need to be serialized,
44 * and determined the names and types of all members. It calculates
45 * how much memory (on disk or in ram) is needed to store that struct,
46 * and the offsets for reaching a particular one.
48 * There is a facility to get verbose output from sdna. Search for
49 * \ref debugSDNA. This int can be set to 0 (no output) to some int. Higher
50 * numbers give more output.
53 #define DNA_VERSION_DATE "$Id$"
59 #include "MEM_guardedalloc.h"
60 #include "DNA_sdna_types.h"
62 #include "BLO_sys_types.h" // for intptr_t support
64 #define SDNA_MAX_FILENAME_LENGTH 255
67 /* Included the path relative from /source/blender/ here, so we can move */
68 /* headers around with more freedom. */
69 const char *includefiles[] = {
71 // if you add files here, please add them at the end
72 // of makesdna.c (this file) as well
80 "DNA_packedFile_types.h",
83 "DNA_texture_types.h",
85 "DNA_material_types.h",
87 // if you add files here, please add them at the end
88 // of makesdna.c (this file) as well
92 "DNA_meshdata_types.h",
93 "DNA_modifier_types.h",
94 "DNA_lattice_types.h",
97 "DNA_object_fluidsim.h",
100 "DNA_view3d_types.h",
101 "DNA_view2d_types.h",
103 "DNA_userdef_types.h",
104 "DNA_screen_types.h",
106 // if you add files here, please add them at the end
107 // of makesdna.c (this file) as well
108 "DNA_fileglobal_types.h",
109 "DNA_sequence_types.h",
110 "DNA_effect_types.h",
111 "DNA_outliner_types.h",
112 "DNA_property_types.h",
113 "DNA_sensor_types.h",
114 "DNA_controller_types.h",
115 "DNA_actuator_types.h",
118 "DNA_armature_types.h",
119 "DNA_action_types.h",
120 "DNA_constraint_types.h",
125 "DNA_customdata_types.h",
126 "DNA_particle_types.h",
128 "DNA_gpencil_types.h",
129 // if you add files here, please add them at the end
130 // of makesdna.c (this file) as well
131 "DNA_windowmanager_types.h",
135 "DNA_speaker_types.h",
136 "DNA_dynamicpaint_types.h",
138 // empty string to indicate end of includefiles
142 static int maxdata= 500000, maxnr= 50000;
143 static int nr_names=0;
144 static int nr_types=0;
145 static int nr_structs=0;
146 static char **names, *namedata; /* at address names[a] is string a */
147 static char **types, *typedata; /* at address types[a] is string a */
148 static short *typelens; /* at typelens[a] is de length of type a */
149 static short *alphalens; /* contains sizes as they are calculated on the DEC Alpha (64 bits), infact any 64bit system */
150 static short **structs, *structdata;/* at sp= structs[a] is the first address of a struct definition
152 sp[1] is amount of elements
153 sp[2] sp[3] is typenr, namenr (etc) */
155 * Variable to control debug output of makesdna.
157 * - 0 = no output, except errors
158 * - 1 = detail actions
159 * - 2 = full trace, tell which names and types were found
160 * - 4 = full trace, plus all gritty details
162 static int debugSDNA = 0;
163 static int additional_slen_offset;
165 /* ************************************************************************** */
167 /* ************************************************************************** */
170 * Add type \c str to struct indexed by \c len, if it was not yet found.
174 int add_type(const char *str, int len);
177 * Add variable \c str to
180 int add_name(char *str);
183 * Search whether this structure type was already found, and if not,
186 short *add_struct(int namecode);
189 * Remove comments from this buffer. Assumes that the buffer refers to
192 int preprocess_include(char *maindata, int len);
195 * Scan this file for serializable types.
197 int convert_include(char *filename);
200 * Determine how many bytes are needed for an array.
202 int arraysize(char *astr, int len);
205 * Determine how many bytes are needed for each struct.
207 static int calculate_structlens(int);
210 * Construct the DNA.c file
212 void dna_write(FILE *file, void *pntr, int size);
215 * Report all structures found so far, and print their lengths.
217 void printStructLenghts(void);
221 /* ************************************************************************** */
223 /* ************************************************************************** */
225 /* ************************* MAKEN DNA ********************** */
227 int add_type(const char *str, int len)
232 if(str[0]==0) return -1;
234 /* search through type array */
235 for(nr=0; nr<nr_types; nr++) {
236 if(strcmp(str, types[nr])==0) {
245 /* append new type */
246 if(nr_types==0) cp= typedata;
248 cp= types[nr_types-1]+strlen(types[nr_types-1])+1;
252 typelens[nr_types]= len;
253 alphalens[nr_types]= len;
255 if(nr_types>=maxnr) {
256 printf("too many types\n");
267 * Because of the weird way of tokenizing, we have to 'cast' function
268 * pointers to ... (*f)(), whatever the original signature. In fact,
269 * we add name and type at the same time... There are two special
270 * cases, unfortunately. These are explicitly checked.
273 int add_name(char *str)
277 char buf[255]; /* stupid limit, change it :) */
280 additional_slen_offset = 0;
282 if(str[0]==0 /* || (str[1]==0) */) return -1;
284 if (str[0] == '(' && str[1] == '*') {
285 /* we handle function pointer and special array cases here, e.g.
286 void (*function)(...) and float (*array)[..]. the array case
287 name is still converted to (array*)() though because it is that
288 way in old dna too, and works correct with elementsize() */
289 int isfuncptr = (strchr(str+1, '(')) != NULL;
291 if (debugSDNA > 3) printf("\t\t\t\t*** Function pointer or multidim array pointer found\n");
292 /* functionpointer: transform the type (sometimes) */
295 while (str[i] != ')') {
300 /* Another number we need is the extra slen offset. This extra
301 * offset is the overshoot after a space. If there is no
302 * space, no overshoot should be calculated. */
303 j = i; /* j at first closing brace */
305 if (debugSDNA > 3) printf("first brace after offset %d\n", i);
307 j++; /* j beyond closing brace ? */
308 while ((str[j] != 0) && (str[j] != ')' )) {
309 if (debugSDNA > 3) printf("seen %c ( %d) \n", str[j], str[j]);
312 if (debugSDNA > 3) printf("seen %c ( %d) \n", str[j], str[j]);
313 if (debugSDNA > 3) printf("special after offset %d\n", j);
316 /* multidimensional array pointer case */
318 if (debugSDNA > 3) printf("offsetting for multidim array pointer\n");
321 printf("Error during tokening multidim array pointer\n");
323 else if (str[j] == 0 ) {
324 if (debugSDNA > 3) printf("offsetting for space\n");
325 /* get additional offset */
327 while (str[j] != ')') {
331 if (debugSDNA > 3) printf("extra offset %d\n", k);
332 additional_slen_offset = k;
333 } else if (str[j] == ')' ) {
334 if (debugSDNA > 3) printf("offsetting for brace\n");
335 ; /* don't get extra offset */
337 printf("Error during tokening function pointer argument list\n");
341 * Put )(void) at the end? Maybe )(). Should check this with
342 * old sdna. Actually, sometimes )(), sometimes )(void...)
343 * Alas.. such is the nature of braindamage :(
345 * Sorted it out: always do )(), except for headdraw and
346 * windraw, part of ScrArea. This is important, because some
347 * linkers will treat different fp's differently when called
348 * !!! This has to do with interference in byte-alignment and
349 * the way args are pushed on the stack.
353 if (debugSDNA > 3) printf("Name before chomping: %s\n", buf);
354 if ( (strncmp(buf,"(*headdraw", 10) == 0)
355 || (strncmp(buf,"(*windraw", 9) == 0) ) {
370 /* now precede with buf*/
371 if (debugSDNA > 3) printf("\t\t\t\t\tProposing fp name %s\n", buf);
374 /* normal field: old code */
378 /* search name array */
379 for(nr=0; nr<nr_names; nr++) {
380 if(strcmp(name, names[nr])==0) {
385 /* append new type */
386 if(nr_names==0) cp= namedata;
388 cp= names[nr_names-1]+strlen(names[nr_names-1])+1;
393 if(nr_names>=maxnr) {
394 printf("too many names\n");
402 short *add_struct(int namecode)
408 structs[0]= structdata;
411 sp= structs[nr_structs-1];
413 structs[nr_structs]= sp+ 2*len+2;
416 sp= structs[nr_structs];
419 if(nr_structs>=maxnr) {
420 printf("too many structs\n");
428 int preprocess_include(char *maindata, int len)
430 int a, newlen, comment = 0;
431 char *cp, *temp, *md;
433 /* note: len + 1, last character is a dummy to prevent
434 * comparisons using uninitialized memory */
435 temp= MEM_mallocN(len + 1, "preprocess_include");
438 memcpy(temp, maindata, len);
440 // remove all c++ comments
441 /* replace all enters/tabs/etc with spaces */
446 if(cp[0]=='/' && cp[1]=='/') {
451 if (comment || *cp<32 || *cp>128 ) *cp= 32;
456 /* data from temp copy to maindata, remove comments and double spaces */
464 if(cp[0]=='/' && cp[1]=='*') {
468 if(cp[0]=='*' && cp[1]=='/') {
473 /* do not copy when: */
475 else if( cp[0]==' ' && cp[1]==' ' );
476 else if( cp[-1]=='*' && cp[0]==' ' ); /* pointers with a space */
489 static void *read_file_data(char *filename, int *len_r)
492 FILE *fp= fopen(filename, "rb");
494 FILE *fp= fopen(filename, "r");
503 fseek(fp, 0L, SEEK_END);
505 fseek(fp, 0L, SEEK_SET);
507 data= MEM_mallocN(*len_r, "read_file_data");
514 if (fread(data, *len_r, 1, fp)!=1) {
525 int convert_include(char *filename)
527 /* read include file, skip structs with a '#' before it.
528 store all data in temporal arrays.
530 int filelen, count, overslaan, slen, type, name, strct;
531 short *structpoin, *sp;
532 char *maindata, *mainend, *md, *md1;
534 md= maindata= read_file_data(filename, &filelen);
536 printf("Can't read file %s\n", filename);
540 filelen= preprocess_include(maindata, filelen);
541 mainend= maindata+filelen-1;
543 /* we look for '{' and then back to 'struct' */
546 while(count<filelen) {
548 /* code for skipping a struct: two hashes on 2 lines. (preprocess added a space) */
549 if(md[0]=='#' && md[1]==' ' && md[2]=='#') {
559 if(md[-1]==' ') md[-1]= 0;
561 while( *md1!=32) md1--; /* to beginning of word */
564 /* we've got a struct name when... */
565 if( strncmp(md1-7, "struct", 6)==0 ) {
568 strct= add_type(md1, 0);
569 structpoin= add_struct(strct);
572 if (debugSDNA > 1) printf("\t|\t|-- detected struct %s\n", types[strct]);
574 /* first lets make it all nice strings */
577 if(md1>mainend) break;
579 if(*md1==',' || *md1==' ') *md1= 0;
583 /* read types and names until first character that is not '}' */
585 while( *md1 != '}' ) {
586 if(md1>mainend) break;
588 /* skip when it says 'struct' or 'unsigned' or 'const' */
590 if( strncmp(md1, "struct", 6)==0 ) md1+= 7;
591 if( strncmp(md1, "unsigned", 8)==0 ) md1+= 9;
592 if( strncmp(md1, "const", 5)==0 ) md1+= 6;
594 /* we've got a type! */
595 type= add_type(md1, 0);
597 if (debugSDNA > 1) printf("\t|\t|\tfound type %s (", md1);
603 while( *md1 != ';' ) {
604 if(md1>mainend) break;
607 /* We've got a name. slen needs
608 * correction for function
610 slen= (int) strlen(md1);
611 if( md1[slen-1]==';' ) {
616 slen += additional_slen_offset;
620 if ((debugSDNA>1) && (names[name] != NULL)) printf("%s |", names[name]);
631 slen += additional_slen_offset;
635 if ((debugSDNA > 1) && (names[name] != NULL)) printf("%s ||", names[name]);
645 if (debugSDNA > 1) printf(")\n");
662 int arraysize(char *astr, int len)
665 char str[100], *cp=NULL;
667 memcpy(str, astr, len+1);
669 for(a=0; a<len; a++) {
673 else if( str[a]==']' && cp) {
675 /* if 'cp' is a preprocessor definition, it will evaluate to 0,
676 * the caller needs to check for this case and throw an error */
684 static int calculate_structlens(int firststruct)
686 int a, b, len, alphalen, unknown= nr_structs, lastunknown, structtype, type, mul, namelen;
687 short *sp, *structpoin;
689 int has_pointer, dna_error = 0;
692 lastunknown= unknown;
695 /* check all structs... */
696 for(a=0; a<nr_structs; a++) {
697 structpoin= structs[a];
698 structtype= structpoin[0];
700 /* when length is not known... */
701 if(typelens[structtype]==0) {
708 /* check all elements in struct */
709 for(b=0; b<structpoin[1]; b++, sp+=2) {
713 namelen= (int) strlen(cp);
714 /* is it a pointer or function pointer? */
715 if(cp[0]=='*' || cp[1]=='*') {
717 /* has the name an extra length? (array) */
719 if( cp[namelen-1]==']') mul= arraysize(cp, namelen);
722 printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
727 if(sizeof(void *) == 4) {
729 printf("Align pointer error in struct (len4): %s %s\n", types[structtype], cp);
734 printf("Align pointer error in struct (len8): %s %s\n", types[structtype], cp);
740 printf("Align pointer error in struct (alphalen8): %s %s\n", types[structtype],cp);
744 len += sizeof(void *) * mul;
747 } else if(cp[0]=='[') {
748 /* parsing can cause names "var" and "[3]" to be found for "float var [3]" ... */
749 printf("Parse error in struct, invalid member name: %s %s\n", types[structtype], cp);
751 } else if( typelens[type] ) {
752 /* has the name an extra length? (array) */
754 if( cp[namelen-1]==']') mul= arraysize(cp, namelen);
757 printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
761 /* struct alignment */
762 if(type >= firststruct) {
763 if(sizeof(void *)==8 && (len % 8) ) {
764 printf("Align struct error: %s %s\n", types[structtype],cp);
770 if(typelens[type]>3 && (len % 4) ) {
771 printf("Align 4 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len%4);
774 else if(typelens[type]==2 && (len % 2) ) {
775 printf("Align 2 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len%2);
779 len += mul*typelens[type];
780 alphalen += mul * alphalens[type];
792 typelens[structtype]= len;
793 alphalens[structtype]= alphalen;
794 // two ways to detect if a struct contains a pointer:
795 // has_pointer is set or alphalen != len
796 if (has_pointer || alphalen != len) {
798 printf("Sizeerror 8 in struct: %s (add %d bytes)\n", types[structtype], alphalen%8);
804 printf("Sizeerror 4 in struct: %s (add %d bytes)\n", types[structtype], len%4);
812 if(unknown==lastunknown) break;
816 printf("ERROR: still %d structs unknown\n", unknown);
819 printf("*** Known structs : \n");
821 for(a=0; a<nr_structs; a++) {
822 structpoin= structs[a];
823 structtype= structpoin[0];
826 if(typelens[structtype]!=0) {
827 printf(" %s\n", types[structtype]);
833 printf("*** Unknown structs : \n");
835 for(a=0; a<nr_structs; a++) {
836 structpoin= structs[a];
837 structtype= structpoin[0];
839 /* length unkown yet */
840 if(typelens[structtype]==0) {
841 printf(" %s\n", types[structtype]);
849 #define MAX_DNA_LINE_LENGTH 20
851 void dna_write(FILE *file, void *pntr, int size)
853 static int linelength = 0;
857 data = (char *) pntr;
859 for (i = 0 ; i < size ; i++)
861 fprintf(file, "%d,", data[i]);
863 if (linelength >= MAX_DNA_LINE_LENGTH) {
870 void printStructLenghts(void)
872 int a, unknown= nr_structs, structtype;
873 /*int lastunknown;*/ /*UNUSED*/
875 printf("\n\n*** All detected structs:\n");
878 /*lastunknown= unknown;*/ /*UNUSED*/
881 /* check all structs... */
882 for(a=0; a<nr_structs; a++) {
883 structpoin= structs[a];
884 structtype= structpoin[0];
885 printf("\t%s\t:%d\n", types[structtype], typelens[structtype]);
889 printf("*** End of list\n");
894 static int make_structDNA(char *baseDirectory, FILE *file)
898 /* str contains filenames. Since we now include paths, I stretched */
899 /* it a bit. Hope this is enough :) -nzc- */
900 char str[SDNA_MAX_FILENAME_LENGTH], *cp;
903 if (debugSDNA > -1) {
905 printf("Running makesdna at debug level %d\n", debugSDNA);
906 printf("\tProgram version: %s\n", DNA_VERSION_DATE);
909 /* the longest known struct is 50k, so we assume 100k is sufficent! */
910 namedata= MEM_callocN(maxdata, "namedata");
911 typedata= MEM_callocN(maxdata, "typedata");
912 structdata= MEM_callocN(maxdata, "structdata");
914 /* a maximum of 5000 variables, must be sufficient? */
915 names= MEM_callocN(sizeof(char *)*maxnr, "names");
916 types= MEM_callocN(sizeof(char *)*maxnr, "types");
917 typelens= MEM_callocN(sizeof(short)*maxnr, "typelens");
918 alphalens= MEM_callocN(sizeof(short)*maxnr, "alphalens");
919 structs= MEM_callocN(sizeof(short)*maxnr, "structs");
921 /* insertion of all known types */
922 /* watch it: uint is not allowed! use in structs an unsigned int */
923 add_type("char", 1); /* 0 */
924 add_type("uchar", 1); /* 1 */
925 add_type("short", 2); /* 2 */
926 add_type("ushort", 2); /* 3 */
927 add_type("int", 4); /* 4 */
928 add_type("long", 4); /* 5 */ /* should it be 8 on 64 bits? */
929 add_type("ulong", 4); /* 6 */
930 add_type("float", 4); /* 7 */
931 add_type("double", 8); /* 8 */
932 add_type("void", 0); /* 9 */
934 // the defines above shouldn't be output in the padding file...
935 firststruct = nr_types;
937 /* add all include files defined in the global array */
938 /* Since the internal file+path name buffer has limited length, I do a */
939 /* little test first... */
940 /* Mind the breaking condition here! */
941 if (debugSDNA) printf("\tStart of header scan:\n");
942 for (i = 0; strlen(includefiles[i]); i++) {
943 sprintf(str, "%s%s", baseDirectory, includefiles[i]);
944 if (debugSDNA) printf("\t|-- Converting %s\n", str);
945 if (convert_include(str)) {
949 if (debugSDNA) printf("\tFinished scanning %d headers.\n", i);
951 if (calculate_structlens(firststruct)) {
963 printf("nr_names %d nr_types %d nr_structs %d\n", nr_names, nr_types, nr_structs);
964 for(a=0; a<nr_names; a++) {
965 printf(" %s \n", names[a]);
970 for(a=0; a<nr_types; a++, sp++) {
971 printf(" %s %d\n", types[a], *sp);
975 for(a=0; a<nr_structs; a++) {
977 printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1],typelens[sp[0]]);
980 /* ? num_types was elem? */
981 for(b=0; b< num_types; b++, sp+= 2) {
982 printf(" %s %s\n", types[sp[0]], names[sp[1]]);
989 if (debugSDNA > -1) printf("Writing file ... ");
991 if(nr_names==0 || nr_structs==0);
994 dna_write(file, str, 4);
998 dna_write(file, str, 4);
1000 dna_write(file, &len, 4);
1002 /* calculate size of datablock with strings */
1003 cp= names[nr_names-1];
1004 cp+= strlen(names[nr_names-1]) + 1; /* +1: null-terminator */
1005 len= (intptr_t) (cp - (char*) names[0]);
1007 dna_write(file, names[0], len);
1010 strcpy(str, "TYPE");
1011 dna_write(file, str, 4);
1013 dna_write(file, &len, 4);
1015 /* calculate datablock size */
1016 cp= types[nr_types-1];
1017 cp+= strlen(types[nr_types-1]) + 1; /* +1: null-terminator */
1018 len= (intptr_t) (cp - (char*) types[0]);
1021 dna_write(file, types[0], len);
1023 /* WRITE TYPELENGTHS */
1024 strcpy(str, "TLEN");
1025 dna_write(file, str, 4);
1028 if(nr_types & 1) len+= 2;
1029 dna_write(file, typelens, len);
1032 strcpy(str, "STRC");
1033 dna_write(file, str, 4);
1035 dna_write(file, &len, 4);
1037 /* calc datablock size */
1038 sp= structs[nr_structs-1];
1039 sp+= 2+ 2*( sp[1] );
1040 len= (intptr_t) ((char*) sp - (char*) structs[0]);
1043 dna_write(file, structs[0], len);
1045 /* a simple dna padding test */
1050 fp= fopen("padding.c", "w");
1054 // add all include files defined in the global array
1055 for (i = 0; strlen(includefiles[i]); i++) {
1056 fprintf(fp, "#include \"%s%s\"\n", baseDirectory, includefiles[i]);
1059 fprintf(fp, "main(){\n");
1062 for(a=firststruct; a<nr_types; a++, sp++) {
1064 fprintf(fp, "\tif(sizeof(struct %s) - %d) printf(\"ALIGN ERROR:", types[a], *sp);
1065 fprintf(fp, "%%d %s %d ", types[a], *sp);
1066 fprintf(fp, "\\n\", sizeof(struct %s) - %d);\n", types[a], *sp);
1073 /* end end padding test */
1077 MEM_freeN(namedata);
1078 MEM_freeN(typedata);
1079 MEM_freeN(structdata);
1082 MEM_freeN(typelens);
1083 MEM_freeN(alphalens);
1086 if (debugSDNA > -1) printf("done.\n");
1091 /* ************************* END MAKE DNA ********************** */
1093 static void make_bad_file(char *file, int line)
1095 FILE *fp= fopen(file, "w");
1096 fprintf(fp, "#error \"Error! can't make correct DNA.c file from %s:%d, STUPID!\"\n", __FILE__, line);
1101 #define BASE_HEADER "../"
1104 int main(int argc, char ** argv)
1107 int return_status = 0;
1109 if (argc!=2 && argc!=3) {
1110 printf("Usage: %s outfile.c [base directory]\n", argv[0]);
1113 file = fopen(argv[1], "w");
1115 printf ("Unable to open file: %s\n", argv[1]);
1118 char baseDirectory[256];
1121 strcpy(baseDirectory, argv[2]);
1123 strcpy(baseDirectory, BASE_HEADER);
1126 fprintf (file, "unsigned char DNAstr[]= {\n");
1127 if (make_structDNA(baseDirectory, file)) {
1130 make_bad_file(argv[1], __LINE__);
1133 fprintf(file, "};\n");
1134 fprintf(file, "int DNAlen= sizeof(DNAstr);\n");
1142 return(return_status);
1145 // include files for automatic dependancies
1146 #include "DNA_listBase.h"
1147 #include "DNA_vec_types.h"
1149 #include "DNA_ipo_types.h"
1150 #include "DNA_key_types.h"
1151 #include "DNA_text_types.h"
1152 #include "DNA_packedFile_types.h"
1153 #include "DNA_camera_types.h"
1154 #include "DNA_image_types.h"
1155 #include "DNA_texture_types.h"
1156 #include "DNA_lamp_types.h"
1157 #include "DNA_material_types.h"
1158 #include "DNA_vfont_types.h"
1159 #include "DNA_meta_types.h"
1160 #include "DNA_curve_types.h"
1161 #include "DNA_mesh_types.h"
1162 #include "DNA_meshdata_types.h"
1163 #include "DNA_modifier_types.h"
1164 #include "DNA_lattice_types.h"
1165 #include "DNA_object_types.h"
1166 #include "DNA_object_force.h"
1167 #include "DNA_object_fluidsim.h"
1168 #include "DNA_world_types.h"
1169 #include "DNA_scene_types.h"
1170 #include "DNA_view3d_types.h"
1171 #include "DNA_view2d_types.h"
1172 #include "DNA_space_types.h"
1173 #include "DNA_userdef_types.h"
1174 #include "DNA_screen_types.h"
1175 #include "DNA_sdna_types.h"
1176 #include "DNA_fileglobal_types.h"
1177 #include "DNA_sequence_types.h"
1178 #include "DNA_effect_types.h"
1179 #include "DNA_outliner_types.h"
1180 #include "DNA_property_types.h"
1181 #include "DNA_sensor_types.h"
1182 #include "DNA_controller_types.h"
1183 #include "DNA_actuator_types.h"
1184 #include "DNA_sound_types.h"
1185 #include "DNA_group_types.h"
1186 #include "DNA_armature_types.h"
1187 #include "DNA_action_types.h"
1188 #include "DNA_constraint_types.h"
1189 #include "DNA_nla_types.h"
1190 #include "DNA_node_types.h"
1191 #include "DNA_color_types.h"
1192 #include "DNA_brush_types.h"
1193 #include "DNA_customdata_types.h"
1194 #include "DNA_particle_types.h"
1195 #include "DNA_cloth_types.h"
1196 #include "DNA_gpencil_types.h"
1197 #include "DNA_windowmanager_types.h"
1198 #include "DNA_anim_types.h"
1199 #include "DNA_boid_types.h"
1200 #include "DNA_smoke_types.h"
1201 #include "DNA_speaker_types.h"
1202 #include "DNA_dynamicpaint_types.h"