diff options
Diffstat (limited to 'source/blender/blenloader')
| -rw-r--r-- | source/blender/blenloader/BLO_genfile.h | 39 | ||||
| -rw-r--r-- | source/blender/blenloader/BLO_readfile.h | 241 | ||||
| -rw-r--r-- | source/blender/blenloader/BLO_soundfile.h | 43 | ||||
| -rw-r--r-- | source/blender/blenloader/BLO_writefile.h | 40 | ||||
| -rw-r--r-- | source/blender/blenloader/Makefile | 37 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/Makefile | 75 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/genfile.c | 1098 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/genfile.h | 48 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/readblenentry.c | 340 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/readfile.c | 4810 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/readfile.h | 130 | ||||
| -rw-r--r-- | source/blender/blenloader/intern/writefile.c | 1788 |
12 files changed, 8689 insertions, 0 deletions
diff --git a/source/blender/blenloader/BLO_genfile.h b/source/blender/blenloader/BLO_genfile.h new file mode 100644 index 00000000000..2e14c9d8fff --- /dev/null +++ b/source/blender/blenloader/BLO_genfile.h @@ -0,0 +1,39 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * external genfile function prototypes + */ + +#ifndef BLO_GENFILE_H +#define BLO_GENFILE_H + +int BLO_findstruct_offset(char *structname, char *member);// used by py_main.c + +#endif diff --git a/source/blender/blenloader/BLO_readfile.h b/source/blender/blenloader/BLO_readfile.h new file mode 100644 index 00000000000..3487334db93 --- /dev/null +++ b/source/blender/blenloader/BLO_readfile.h @@ -0,0 +1,241 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * external readfile function prototypes + */ +#ifndef BLO_READFILE_H +#define BLO_READFILE_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct SpaceFile; +struct LinkNode; +struct Main; +struct UserDef; +struct bScreen; +struct Scene; + +typedef struct BlendHandle BlendHandle; + +typedef enum BlenFileType { + BLENFILETYPE_BLEND= 1, + BLENFILETYPE_PUB= 2, + BLENFILETYPE_RUNTIME= 3 +} BlenFileType; + +typedef enum { + BRE_NONE, + + BRE_UNABLE_TO_OPEN, + BRE_UNABLE_TO_READ, + + BRE_OUT_OF_MEMORY, + BRE_INTERNAL_ERROR, + + BRE_NOT_A_BLEND, + BRE_NOT_A_PUBFILE, + BRE_INCOMPLETE, + BRE_CORRUPT, + + BRE_TOO_NEW, + BRE_NOT_ALLOWED, + + BRE_NO_SCREEN, + BRE_NO_SCENE, + + BRE_INVALID +} BlendReadError; + +typedef struct BlendFileData { + struct Main* main; + struct UserDef* user; + + int winpos; + int fileflags; + int displaymode; + + struct bScreen* curscreen; + struct Scene* curscene; + + BlenFileType type; +} BlendFileData; + + /** + * Open a blender file from a pathname. The function + * returns NULL and sets the @a error_r argument if + * it cannot open the file. + * + * @param file The path of the file to open. + * @param error_r If the return value is NULL, an error + * code indicating the cause of the failure. + * @return The data of the file. + */ +BlendFileData* BLO_read_from_file (char *file, BlendReadError *error_r); + + /** + * Open a blender file from memory. The function + * returns NULL and sets the @a error_r argument if + * it cannot open the file. + * + * @param mem The file data. + * @param memsize The length of @a mem. + * @param error_r If the return value is NULL, an error + * code indicating the cause of the failure. + * @return The data of the file. + */ +BlendFileData* BLO_read_from_memory (void *mem, int memsize, BlendReadError *error_r); + + +/** + * Convert a BlendReadError to a human readable string. + * The string is static and does not need to be free'd. + * + * @param error The error to return a string for. + * @return A static human readable string representation + * of @a error. + */ + char* +BLO_bre_as_string( + BlendReadError error); + +/** + * Free's a BlendFileData structure and _all_ the + * data associated with it (the userdef data, and + * the main libblock data). + * + * @param bfd The structure to free. + */ + void +BLO_blendfiledata_free( + BlendFileData *bfd); + +/** + * Convert an idcode into a name. + * + * @param code The code to convert. + * @return A static string representing the name of + * the code. + */ + char* +BLO_idcode_to_name( + int code); + +/** + * Convert a name into an idcode (ie. ID_SCE) + * + * @param name The name to convert. + * @return The code for the name, or 0 if invalid. + */ + int +BLO_idcode_from_name( + char *name); + +/** + * Open a blendhandle from a file path. + * + * @param file The file path to open. + * @return A handle on success, or NULL on failure. + */ + BlendHandle* +BLO_blendhandle_from_file( + char *file); + +/** + * Gets the names of all the datablocks in a file + * of a certain type (ie. All the scene names in + * a file). + * + * @param bh The blendhandle to access. + * @param ofblocktype The type of names to get. + * @return A BLI_linklist of strings. The string links + * should be freed with malloc. + */ + struct LinkNode* +BLO_blendhandle_get_datablock_names( + BlendHandle *bh, + int ofblocktype); + +/** + * Gets the names of all the datablock groups in a + * file. (ie. file contains Scene, Mesh, and Lamp + * datablocks). + * + * @param bh The blendhandle to access. + * @return A BLI_linklist of strings. The string links + * should be freed with malloc. + */ + struct LinkNode* +BLO_blendhandle_get_linkable_groups( + BlendHandle *bh); + +/** + * Close and free a blendhandle. The handle + * becomes invalid after this call. + * + * @param bh The handle to close. + */ + void +BLO_blendhandle_close( + BlendHandle *bh); + + /***/ + +char *BLO_gethome(void); +int BLO_has_bfile_extension(char *str); + +void BLO_library_append(struct SpaceFile *sfile, char *dir, int idcode); + + +/* Ick ick ick, why are internal loader functions + * being exported out of the loader? IMHO readstreamglue + * should not need to know anything about the loader, + * but this is a point of contention. - zr + */ + void* +blo_readstreamfile_begin( + void *endControl); + + int +blo_readstreamfile_process( + void *filedataVoidPtr, + unsigned char *data, + unsigned int dataIn); + + int +blo_readstreamfile_end( + void *filedataVoidPtr); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/source/blender/blenloader/BLO_soundfile.h b/source/blender/blenloader/BLO_soundfile.h new file mode 100644 index 00000000000..aa2c2c443b3 --- /dev/null +++ b/source/blender/blenloader/BLO_soundfile.h @@ -0,0 +1,43 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef BLO_SOUNDFILE_H +#define BLO_SOUNDFILE_H + +#include "DNA_sound_types.h" +#include "DNA_packedFile_types.h" + +struct bSound; +struct PackedFile; + +//void sound_read_wav_data(bSound * sound, PackedFile * pf); + +#endif diff --git a/source/blender/blenloader/BLO_writefile.h b/source/blender/blenloader/BLO_writefile.h new file mode 100644 index 00000000000..b771d438bfc --- /dev/null +++ b/source/blender/blenloader/BLO_writefile.h @@ -0,0 +1,40 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * external writefile function prototypes + */ + +#ifndef BLO_WRITEFILE_H +#define BLO_WRITEFILE_H + +int BLO_write_file(char *dir, int write_flags, char **error_r); +void BLO_write_runtime(char *file, char *exename); + +#endif diff --git a/source/blender/blenloader/Makefile b/source/blender/blenloader/Makefile new file mode 100644 index 00000000000..0d7cd16453e --- /dev/null +++ b/source/blender/blenloader/Makefile @@ -0,0 +1,37 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# Bounces make to subdirectories. + +SOURCEDIR = source/blender/blenloader +DIRS = intern + +include nan_subdirs.mk diff --git a/source/blender/blenloader/intern/Makefile b/source/blender/blenloader/intern/Makefile new file mode 100644 index 00000000000..bbda61c53f5 --- /dev/null +++ b/source/blender/blenloader/intern/Makefile @@ -0,0 +1,75 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +LIBNAME = blenloader +DIR = $(OCGDIR)/blender/$(LIBNAME) + +include nan_compile.mk + +CFLAGS += $(LEVEL_2_C_WARNINGS) + +ifeq ($(OS),$(findstring $(OS), "beos darwin freebsd linux openbsd solaris windows")) + CFLAGS += -funsigned-char +endif + +# OpenGL and Python +CPPFLAGS += $(OGL_CPPFLAGS) +CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) + +# zlib +ifeq ($(OS),$(findstring $(OS), "solaris windows")) + CPPFLAGS += -I$(NAN_ZLIB)/include +endif + +# streaming write function +CPPFLAGS += -I../../writestreamglue +CPPFLAGS += -I../../readstreamglue + +# initiate a streaming read pipe +CPPFLAGS += -I../../readblenfile + +# This mod uses the GEN, DNA, BLI and BKE modules +CPPFLAGS += -I../../../kernel/gen_messaging +CPPFLAGS += -I../../makesdna +CPPFLAGS += -I../../blenlib +# path to the guarded memory allocator +CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include +CPPFLAGS += -I../../blenkernel +CPPFLAGS += -I../../render/extern/include/ +CPPFLAGS += -I../../bpython/include + +# we still refer to /include a bit... +CPPFLAGS += -I../../include + +# path to our own external headerfiles +CPPFLAGS += -I.. diff --git a/source/blender/blenloader/intern/genfile.c b/source/blender/blenloader/intern/genfile.c new file mode 100644 index 00000000000..6d897b500bd --- /dev/null +++ b/source/blender/blenloader/intern/genfile.c @@ -0,0 +1,1098 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * DNA handling + */ + +#ifndef WIN32 +#include <unistd.h> // for read close +#else +#include <io.h> // for open close read +#endif + +#include <string.h> // strncmp +#include <stdio.h> // for printf +#include <stdlib.h> // for atoi +#include <fcntl.h> // for open O_RDONLY + +#include "MEM_guardedalloc.h" // for MEM_freeN MEM_mallocN MEM_callocN +#include "BLI_blenlib.h" // for BLI_filesize + +#include "BKE_utildefines.h" // for O_BINARY TRUE MIN2 + +#include "DNA_sdna_types.h" // for SDNA ;-) + +#include "BLO_writefile.h" +#include "BLO_genfile.h" + +#include "genfile.h" + + +/* + * - pas op: geen beveiling tegen dubbele structen + * - struct niet in DNA file: twee hekjes erboven (#<enter>#<enter>) +Aanmaken structDNA: alleen wanneer includes wijzigen. +File Syntax: + SDNA (4 bytes) (voor fileherkenning) + NAME (4 bytes) + <nr> (4 bytes) aantal namen (int) + <string> + <string> + ... + ... + TYPE (4 bytes) + <nr> aantal types (int) + <string> + <string> + ... + ... + TLEN (4 bytes) + <len> (short) + <len> + ... + ... + STRC (4 bytes) + <nr> aantal structen (int) + <typenr><nr_of_elems> <typenr><namenr> <typenr><namenr> ... + +!!Denk aan integer en short aligned schrijven/lezen!! + +Bij het wegschrijven van files worden namen structen aangegeven +met type= findstruct_nr(SDNA *, char *), 'type' correspondeert met nummer +structarray in structDNA. + +Voor het moment: complete DNA file appenden achter blenderfile. +In toekomst nadenken over slimmere methode (alleen gebruikte +structen?, voorgeprepareerde DNA files? (TOT, OB, MAT ) + +TOEGESTANE EN GETESTE WIJZIGINGEN IN STRUCTS: + - type verandering (bij chars naar float wordt door 255 gedeeld) + - plek in struct (alles kan door elkaar) + - struct in struct (in struct etc, is recursief) + - nieuwe elementen toevoegen (standaard op 0) + - elementen eruit (worden niet meer ingelezen) + - array's groter/kleiner + - verschillende typepointers met zelfde naam worden altijd gekopieerd. +(NOG) NIET: + - float-array (vec[3]) naar struct van floats (vec3f) +GEDAAN: + - DNA file in (achter) blender-executable plakken voor upward + compatibility Gebruikte methode: het makesdna programma schrijft + een c-file met een met spaties gevuld char-array van de juiste + lengte. Makesdna maakt er een .o van en vult de spaties met de + DNA file. + - endian compatibility + - 32 bits en 64 bits pointers +LET OP: + - uint mag niet in een struct, gebruik unsigned int. (backwards + compatibility vanwege 64 bits code!) + - structen moeten altijd (intern) 4/8-aligned en short-aligned zijn. + de SDNA routine test hierop en print duidelijke errors. + DNA files met align errors zijn onbruikbaar! + - switch_endian doet alleen long long pointers, + zodat ze veilig gecast kunnen worden naar 32 bits + - casten van 64 naar 32 bits poinetrs: >>3. +*/ + +/* local */ +static int le_int(int temp); +static short le_short(short temp); + +/* ************************* ENDIAN STUFF ********************** */ + +static short le_short(short temp) +{ + short new; + char *rt=(char *)&temp, *rtn=(char *)&new; + + rtn[0]= rt[1]; + rtn[1]= rt[0]; + + return new; +} + + +static int le_int(int temp) +{ + int new; + char *rt=(char *)&temp, *rtn=(char *)&new; + + rtn[0]= rt[3]; + rtn[1]= rt[2]; + rtn[2]= rt[1]; + rtn[3]= rt[0]; + + return new; +} + + +/* ************************* MAKEN DNA ********************** */ + +/* allowed duplicate code from makesdna.c */ +static int arraysize(char *astr, int len) +{ + int a, mul=1; + char str[100], *cp=0; + + memcpy(str, astr, len+1); + + for(a=0; a<len; a++) { + if( str[a]== '[' ) { + cp= &(str[a+1]); + } + else if( str[a]==']' && cp) { + str[a]= 0; + mul*= atoi(cp); + } + } + + return mul; +} + +/* ************************* END MAKEN DNA ********************** */ + +/* ************************* DIV ********************** */ + +void dna_freestructDNA(struct SDNA *sdna) +{ + MEM_freeN(sdna->data); + MEM_freeN(sdna->names); + MEM_freeN(sdna->types); + MEM_freeN(sdna->structs); + + MEM_freeN(sdna); +} + +static int elementsize(struct SDNA *sdna, short type, short name) +/* aanroepen met nummers uit struct-array */ +{ + int mul, namelen, len; + char *cp; + + cp= sdna->names[name]; + len= 0; + + namelen= strlen(cp); + /* is het een pointer of functiepointer? */ + if(cp[0]=='*' || cp[1]=='*') { + /* heeft de naam een extra lente? (array) */ + mul= 1; + if( cp[namelen-1]==']') mul= arraysize(cp, namelen); + + len= sdna->pointerlen*mul; + } + else if( sdna->typelens[type] ) { + /* heeft de naam een extra lente? (array) */ + mul= 1; + if( cp[namelen-1]==']') mul= arraysize(cp, namelen); + + len= mul*sdna->typelens[type]; + + } + + return len; +} + +#if 0 +static void printstruct(struct SDNA *sdna, short strnr) +{ + /* geef het structnummer door, is voor debug */ + int b, nr; + short *sp; + + sp= sdna->structs[strnr]; + + printf("struct %s\n", sdna->types[ sp[0] ]); + nr= sp[1]; + sp+= 2; + + for(b=0; b< nr; b++, sp+= 2) { + printf(" %s %s\n", sdna->types[sp[0]], sdna->names[sp[1]]); + } +} +#endif + +static short *findstruct_name(struct SDNA *sdna, char *str) +{ + int a; + short *sp=0; + + + for(a=0; a<sdna->nr_structs; a++) { + + sp= sdna->structs[a]; + + if(strcmp( sdna->types[ sp[0] ], str )==0) return sp; + } + + return 0; +} + +int dna_findstruct_nr(struct SDNA *sdna, char *str) +{ + short *sp=0; + int a; + + if(sdna->lastfind<sdna->nr_structs) { + sp= sdna->structs[sdna->lastfind]; + if(strcmp( sdna->types[ sp[0] ], str )==0) return sdna->lastfind; + } + + for(a=0; a<sdna->nr_structs; a++) { + + sp= sdna->structs[a]; + + if(strcmp( sdna->types[ sp[0] ], str )==0) { + sdna->lastfind= a; + return a; + } + } + + return -1; +} + +/* ************************* END DIV ********************** */ + +/* ************************* LEZEN DNA ********************** */ + +static void init_structDNA(struct SDNA *sdna, int do_endian_swap) +/* in sdna->data staat de data, uit elkaar pulken */ +{ + int *data, *verg; + long nr; + short *sp; + char str[8], *cp; + + verg= (int *)str; + data= (int *)sdna->data; + + strcpy(str, "SDNA"); + if( *data == *verg ) { + + data++; + + /* laad namen array */ + strcpy(str, "NAME"); + if( *data == *verg ) { + data++; + + if(do_endian_swap) sdna->nr_names= le_int(*data); + else sdna->nr_names= *data; + + data++; + sdna->names= MEM_callocN( sizeof(void *)*sdna->nr_names, "sdnanames"); + } + else { + printf("NAME error in SDNA file\n"); + return; + } + + nr= 0; + cp= (char *)data; + while(nr<sdna->nr_names) { + sdna->names[nr]= cp; + while( *cp) cp++; + cp++; + nr++; + } + nr= (long)cp; /* BUS error voorkomen */ + nr= (nr+3) & ~3; + cp= (char *)nr; + + /* laad typenamen array */ + data= (int *)cp; + strcpy(str, "TYPE"); + if( *data == *verg ) { + data++; + + if(do_endian_swap) sdna->nr_types= le_int(*data); + else sdna->nr_types= *data; + + data++; + sdna->types= MEM_callocN( sizeof(void *)*sdna->nr_types, "sdnatypes"); + } + else { + printf("TYPE error in SDNA file\n"); + return; + } + + nr= 0; + cp= (char *)data; + while(nr<sdna->nr_types) { + sdna->types[nr]= cp; + + /* met deze patch kunnen structnamen gewijzigd worden */ + /* alleen gebruiken voor conflicten met systeem-structen (opengl/X) */ + + if( *cp == 'b') { + /* struct Screen was already used by X, 'bScreen' replaces the old IrisGL 'Screen' struct */ + if( strcmp("bScreen", cp)==0 ) sdna->types[nr]= cp+1; + } + + while( *cp) cp++; + cp++; + nr++; + } + nr= (long)cp; /* BUS error voorkomen */ + nr= (nr+3) & ~3; + cp= (char *)nr; + + /* laad typelen array */ + data= (int *)cp; + strcpy(str, "TLEN"); + if( *data == *verg ) { + data++; + sp= (short *)data; + sdna->typelens= sp; + + if(do_endian_swap) { + short a, *spo= sp; + + a= sdna->nr_types; + while(a--) { + spo[0]= le_short(spo[0]); + spo++; + } + } + + sp+= sdna->nr_types; + } + else { + printf("TLEN error in SDNA file\n"); + return; + } + if(sdna->nr_types & 1) sp++; /* BUS error voorkomen */ + + /* laad structen array */ + data= (int *)sp; + strcpy(str, "STRC"); + if( *data == *verg ) { + data++; + + if(do_endian_swap) sdna->nr_structs= le_int(*data); + else sdna->nr_structs= *data; + + data++; + sdna->structs= MEM_callocN( sizeof(void *)*sdna->nr_structs, "sdnastrcs"); + } + else { + printf("STRC error in SDNA file\n"); + return; + } + + nr= 0; + sp= (short *)data; + while(nr<sdna->nr_structs) { + sdna->structs[nr]= sp; + + if(do_endian_swap) { + short a; + + sp[0]= le_short(sp[0]); + sp[1]= le_short(sp[1]); + + a= sp[1]; + sp+= 2; + while(a--) { + sp[0]= le_short(sp[0]); + sp[1]= le_short(sp[1]); + sp+= 2; + } + } + else { + sp+= 2*sp[1]+2; + } + + nr++; + } + + /* finally pointerlen: use struct ListBase to test it, never change the size of it! */ + sp= findstruct_name(sdna, "ListBase"); + + sdna->pointerlen= sdna->typelens[ sp[0] ]/2; + + if(sp[1]!=2 || (sdna->pointerlen!=4 && sdna->pointerlen!=8)) { + printf("ListBase struct error! Needs it to calculate pointerize.\n"); + exit(0); + } + + } +} + +struct SDNA *dna_sdna_from_data(void *data, int datalen, int do_endian_swap) +{ + struct SDNA *sdna= MEM_mallocN(sizeof(*sdna), "sdna"); + + sdna->lastfind= 0; + + sdna->datalen= datalen; + sdna->data= MEM_mallocN(datalen, "sdna_data"); + memcpy(sdna->data, data, datalen); + + init_structDNA(sdna, do_endian_swap); + + return sdna; +} + /* XXX, this routine was added because at one + * point I thought using the dna more would be + * nice, but really thats a flawed idea, you + * already know about your memory structures when + * you are compiling no need to redirect that + * through the DNA, the python stuff should be + * changed to not use this routine (a bit + * o' work). - zr + */ +int BLO_findstruct_offset(char *structname, char *member) +{ + extern char DNAstr[]; /* DNA.c */ + extern int DNAlen; + + struct SDNA *sdna; + int a, offset; + short *sp; + + sdna= dna_sdna_from_data(DNAstr, DNAlen, 0); + + sp= findstruct_name(sdna, structname); + + if(sp) { + a= sp[1]; /* aantal elems */ + sp+= 2; + offset= 0; + + while(a--) { + if(strcmp(sdna->names[sp[1]], member)==0) { + dna_freestructDNA(sdna); + return offset; + } + + offset+= elementsize(sdna, sp[0], sp[1]); + sp+= 2; + } + } + + dna_freestructDNA(sdna); + return -1; +} + +/* ******************** END LEZEN DNA ********************** */ + +/* ******************* AFHANDELEN DNA ***************** */ + +static void recurs_test_compflags(struct SDNA *sdna, char *compflags, int structnr) +{ + int a, b, typenr, elems; + short *sp; + char *cp; + + /* loop alle structen af en test of deze struct in andere zit */ + sp= sdna->structs[structnr]; + typenr= sp[0]; + + for(a=0; a<sdna->nr_structs; a++) { + if(a!=structnr && compflags[a]==1) { + sp= sdna->structs[a]; + elems= sp[1]; + sp+= 2; + for(b=0; b<elems; b++, sp+=2) { + if(sp[0]==typenr) { + cp= sdna->names[ sp[1] ]; + if(cp[0]!= '*') { + compflags[a]= 2; + recurs_test_compflags(sdna, compflags, a); + } + } + } + } + } + +} + + /* Unsure of exact function - compares the sdna argument to + * newsdna and sets up the information necessary to convert + * data written with a dna of oldsdna to inmemory data with a + * structure defined by the newsdna sdna (I think). -zr + */ +char *dna_get_structDNA_compareflags(struct SDNA *sdna, struct SDNA *newsdna) +{ + /* flag: 0:bestaat niet meer (of nog niet) + * 1: is gelijk + * 2: is anders + */ + int a, b; + short *spold, *spcur; + char *str1, *str2; + char *compflags; + + if(sdna->nr_structs==0) { + printf("error: file without SDNA\n"); + return NULL; + } + + compflags= MEM_callocN(sdna->nr_structs, "compflags"); + + /* We lopen alle structs in 'sdna' af, vergelijken ze met + * de structs in 'newsdna' + */ + + for(a=0; a<sdna->nr_structs; a++) { + spold= sdna->structs[a]; + + /* type zoeken in cur */ + spcur= findstruct_name(newsdna, sdna->types[spold[0]]); + + if(spcur) { + compflags[a]= 2; + + /* lengte en aantal elems vergelijken */ + if( spcur[1] == spold[1]) { + if( newsdna->typelens[spcur[0]] == sdna->typelens[spold[0]] ) { + + /* evenlang en evenveel elems, nu per type en naam */ + b= spold[1]; + spold+= 2; + spcur+= 2; + while(b > 0) { + str1= newsdna->types[spcur[0]]; + str2= sdna->types[spold[0]]; + if(strcmp(str1, str2)!=0) break; + + str1= newsdna->names[spcur[1]]; + str2= sdna->names[spold[1]]; + if(strcmp(str1, str2)!=0) break; + + /* naam gelijk, type gelijk, nu nog pointersize, dit geval komt haast nooit voor! */ + if(str1[0]=='*') { + if(sdna->pointerlen!=newsdna->pointerlen) break; + } + + b--; + spold+= 2; + spcur+= 2; + } + if(b==0) compflags[a]= 1; + + } + } + + } + } + + /* eerste struct in util.h is struct Link, deze wordt in de compflags overgeslagen (als # 0). + * Vuile patch! Nog oplossen.... + */ + compflags[0]= 1; + + /* Aangezien structen in structen kunnen zitten gaan we recursief + * vlaggen zetten als er een struct veranderd is + */ + for(a=0; a<sdna->nr_structs; a++) { + if(compflags[a]==2) recurs_test_compflags(sdna, compflags, a); + } + +/* + for(a=0; a<sdna->nr_structs; a++) { + if(compflags[a]==2) { + spold= sdna->structs[a]; + printf("changed: %s\n", sdna->types[ spold[0] ]); + } + } +*/ + + return compflags; +} + +static void cast_elem(char *ctype, char *otype, char *name, char *curdata, char *olddata) +{ + double val = 0.0; + int arrlen, curlen=1, oldlen=1, ctypenr, otypenr; + + arrlen= arraysize(name, strlen(name)); + + /* otypenr bepalen */ + if(strcmp(otype, "char")==0) otypenr= 0; + else if((strcmp(otype, "uchar")==0)||(strcmp(otype, "unsigned char")==0)) otypenr= 1; + else if(strcmp(otype, "short")==0) otypenr= 2; + else if((strcmp(otype, "ushort")==0)||(strcmp(otype, "unsigned short")==0)) otypenr= 3; + else if(strcmp(otype, "int")==0) otypenr= 4; + else if(strcmp(otype, "long")==0) otypenr= 5; + else if((strcmp(otype, "ulong")==0)||(strcmp(otype, "unsigned long")==0)) otypenr= 6; + else if(strcmp(otype, "float")==0) otypenr= 7; + else if(strcmp(otype, "double")==0) otypenr= 8; + else return; + + /* ctypenr bepalen */ + if(strcmp(ctype, "char")==0) ctypenr= 0; + else if((strcmp(ctype, "uchar")==0)||(strcmp(ctype, "unsigned char")==0)) ctypenr= 1; + else if(strcmp(ctype, "short")==0) ctypenr= 2; + else if((strcmp(ctype, "ushort")==0)||(strcmp(ctype, "unsigned short")==0)) ctypenr= 3; + else if(strcmp(ctype, "int")==0) ctypenr= 4; + else if(strcmp(ctype, "long")==0) ctypenr= 5; + else if((strcmp(ctype, "ulong")==0)||(strcmp(ctype, "unsigned long")==0)) ctypenr= 6; + else if(strcmp(ctype, "float")==0) ctypenr= 7; + else if(strcmp(ctype, "double")==0) ctypenr= 8; + else return; + + /* lengtes bepalen */ + if(otypenr < 2) oldlen= 1; + else if(otypenr < 4) oldlen= 2; + else if(otypenr < 8) oldlen= 4; + else oldlen= 8; + + if(ctypenr < 2) curlen= 1; + else if(ctypenr < 4) curlen= 2; + else if(ctypenr < 8) curlen= 4; + else curlen= 8; + + while(arrlen>0) { + switch(otypenr) { + case 0: + val= *olddata; break; + case 1: + val= *( (unsigned char *)olddata); break; + case 2: + val= *( (short *)olddata); break; + case 3: + val= *( (unsigned short *)olddata); break; + case 4: + val= *( (int *)olddata); break; + case 5: + val= *( (int *)olddata); break; + case 6: + val= *( (unsigned int *)olddata); break; + case 7: + val= *( (float *)olddata); break; + case 8: + val= *( (double *)olddata); break; + } + + switch(ctypenr) { + case 0: + *curdata= val; break; + case 1: + *( (unsigned char *)curdata)= val; break; + case 2: + *( (short *)curdata)= val; break; + case 3: + *( (unsigned short *)curdata)= val; break; + case 4: + *( (int *)curdata)= val; break; + case 5: + *( (int *)curdata)= val; break; + case 6: + *( (unsigned int *)curdata)= val; break; + case 7: + if(otypenr<2) val/= 255; + *( (float *)curdata)= val; break; + case 8: + if(otypenr<2) val/= 255; + *( (double *)curdata)= val; break; + } + + olddata+= oldlen; + curdata+= curlen; + arrlen--; + } +} + +static void cast_pointer(int curlen, int oldlen, char *name, char *curdata, char *olddata) +{ +#ifdef WIN32 + __int64 lval; +#else + long long lval; +#endif + int arrlen; + + arrlen= arraysize(name, strlen(name)); + + while(arrlen>0) { + + if(curlen==oldlen) { + memcpy(curdata, olddata, curlen); + } + else if(curlen==4 && oldlen==8) { +#ifdef WIN32 + lval= *( (__int64 *)olddata ); +#else + lval= *( (long long *)olddata ); +#endif + *((int *)curdata) = lval>>3; /* is natuurlijk een beetje een gok! */ + } + else if(curlen==8 && oldlen==4) { +#ifdef WIN32 + *( (__int64 *)curdata ) = *((int *)olddata); +#else + *( (long long *)curdata ) = *((int *)olddata); +#endif + } + else { + /* voor debug */ + printf("errpr: illegal pointersize! \n"); + } + + olddata+= oldlen; + curdata+= curlen; + arrlen--; + + } +} + +static int elem_strcmp(char *name, char *oname) +{ + int a=0; + + /* strcmp without array part */ + + while(TRUE) { + if(name[a] != oname[a]) return 1; + if(name[a]=='[') break; + if(name[a]==0) break; + a++; + } + if(name[a] != oname[a]) return 1; + return 0; +} + +static char *find_elem(struct SDNA *sdna, char *type, char *name, short *old, char *olddata, short **sppo) +{ + int a, elemcount, len; + char *otype, *oname; + + /* without arraypart, so names can differ: return old namenr and type */ + + /* in old staat de oude struct */ + elemcount= old[1]; + old+= 2; + for(a=0; a<elemcount; a++, old+=2) { + + otype= sdna->types[old[0]]; + oname= sdna->names[old[1]]; + + len= elementsize(sdna, old[0], old[1]); + + if( elem_strcmp(name, oname)==0 ) { /* naam gelijk */ + if( strcmp(type, otype)==0 ) { /* type gelijk */ + if(sppo) *sppo= old; + return olddata; + } + + return 0; + } + + olddata+= len; + } + return 0; +} + +static void reconstruct_elem(struct SDNA *newsdna, struct SDNA *oldsdna, char *type, char *name, char *curdata, short *old, char *olddata) +{ + /* regels: testen op NAAM: + - naam volledig gelijk: + - type casten + - naam gedeeltelijk gelijk (array anders) + - type gelijk: memcpy + - types casten + (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where + can I force this? + */ + int a, elemcount, len, array, oldsize, cursize, mul; + char *otype, *oname, *cp; + + /* is 'name' een array? */ + cp= name; + array= 0; + while( *cp && *cp!='[') { + cp++; array++; + } + if( *cp!= '[' ) array= 0; + + /* in old staat de oude struct */ + elemcount= old[1]; + old+= 2; + for(a=0; a<elemcount; a++, old+=2) { + otype= oldsdna->types[old[0]]; + oname= oldsdna->names[old[1]]; + len= elementsize(oldsdna, old[0], old[1]); + + if( strcmp(name, oname)==0 ) { /* naam gelijk */ + + if( name[0]=='*') { /* pointer afhandelen */ + cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata); + } + else if( strcmp(type, otype)==0 ) { /* type gelijk */ + memcpy(curdata, olddata, len); + } + else cast_elem(type, otype, name, curdata, olddata); + + return; + } + else if(array) { /* de naam is een array */ + + if( strncmp(name, oname, array)==0 ) { /* basis gelijk */ + + cursize= arraysize(name, strlen(name)); + oldsize= arraysize(oname, strlen(oname)); + + if( name[0]=='*') { /* pointer afhandelen */ + if(cursize>oldsize) cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, oname, curdata, olddata); + else cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata); + } + else if(name[0]=='*' || strcmp(type, otype)==0 ) { /* type gelijk */ + mul= len/oldsize; + mul*= MIN2(cursize, oldsize); + memcpy(curdata, olddata, mul); + } + else { + if(cursize>oldsize) cast_elem(type, otype, oname, curdata, olddata); + else cast_elem(type, otype, name, curdata, olddata); + } + return; + } + } + olddata+= len; + } +} + +static void reconstruct_struct(struct SDNA *newsdna, struct SDNA *oldsdna, char *compflags, int oldSDNAnr, char *data, int curSDNAnr, char *cur) +{ + /* Recursief! + * Per element van cur_struct data lezen uit old_struct. + * Als element een struct is, recursief aanroepen. + */ + int a, elemcount, elen, eleno, mul, mulo, firststructtypenr; + short *spo, *spc, *sppo; + char *name, *nameo, *type, *cpo, *cpc; + + if(oldSDNAnr== -1) return; + if(curSDNAnr== -1) return; + + if( compflags[oldSDNAnr]==1 ) { /* bij recurs: testen op gelijk */ + + spo= oldsdna->structs[oldSDNAnr]; + elen= oldsdna->typelens[ spo[0] ]; + memcpy( cur, data, elen); + + return; + } + + firststructtypenr= *(newsdna->structs[0]); + + spo= oldsdna->structs[oldSDNAnr]; + spc= newsdna->structs[curSDNAnr]; + + elemcount= spc[1]; + + spc+= 2; + cpc= cur; + for(a=0; a<elemcount; a++, spc+=2) { + type= newsdna->types[spc[0]]; + name= newsdna->names[spc[1]]; + + elen= elementsize(newsdna, spc[0], spc[1]); + + /* testen: is type een struct? */ + if(spc[0]>=firststructtypenr && name[0]!='*') { + + /* waar start de oude struct data (is ie er wel?) */ + cpo= find_elem(oldsdna, type, name, spo, data, &sppo); + + if(cpo) { + oldSDNAnr= dna_findstruct_nr(oldsdna, type); + curSDNAnr= dna_findstruct_nr(newsdna, type); + + /* array! */ + mul= arraysize(name, strlen(name)); + nameo= oldsdna->names[sppo[1]]; + mulo= arraysize(nameo, strlen(nameo)); + + eleno= elementsize(oldsdna, sppo[0], sppo[1]); + + elen/= mul; + eleno/= mulo; + + while(mul--) { + reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc); + cpo+= eleno; + cpc+= elen; + + /* new struct array larger than old */ + mulo--; + if(mulo<=0) break; + } + } + else cpc+= elen; + } + else { + + reconstruct_elem(newsdna, oldsdna, type, name, cpc, spo, data); + cpc+= elen; + + } + } +} + +void dna_switch_endian_struct(struct SDNA *oldsdna, int oldSDNAnr, char *data) +{ + /* Recursief! + * Als element een struct is, recursief aanroepen. + */ + int a, mul, elemcount, elen, elena, firststructtypenr; + short *spo, *spc, skip; + char *name, *type, *cpo, *cur, cval; + + if(oldSDNAnr== -1) return; + firststructtypenr= *(oldsdna->structs[0]); + + spo= spc= oldsdna->structs[oldSDNAnr]; + + elemcount= spo[1]; + + spc+= 2; + cur= data; + + for(a=0; a<elemcount; a++, spc+=2) { + type= oldsdna->types[spc[0]]; + name= oldsdna->names[spc[1]]; + + /* elementsize = including arraysize */ + elen= elementsize(oldsdna, spc[0], spc[1]); + + /* testen: is type een struct? */ + if(spc[0]>=firststructtypenr && name[0]!='*') { + /* waar start de oude struct data (is ie er wel?) */ + cpo= find_elem(oldsdna, type, name, spo, data, 0); + if(cpo) { + oldSDNAnr= dna_findstruct_nr(oldsdna, type); + + mul= arraysize(name, strlen(name)); + elena= elen/mul; + + while(mul--) { + dna_switch_endian_struct(oldsdna, oldSDNAnr, cpo); + cpo += elena; + } + } + } + else { + + if( name[0]=='*' ) { + if(oldsdna->pointerlen==8) { + + mul= arraysize(name, strlen(name)); + cpo= cur; + while(mul--) { + cval= cpo[0]; cpo[0]= cpo[7]; cpo[7]= cval; + cval= cpo[1]; cpo[1]= cpo[6]; cpo[6]= cval; + cval= cpo[2]; cpo[2]= cpo[5]; cpo[5]= cval; + cval= cpo[3]; cpo[3]= cpo[4]; cpo[4]= cval; + + cpo+= 8; + } + + } + } + else { + + if( spc[0]==2 || spc[0]==3 ) { /* short-ushort */ + + /* uitzondering: variable die blocktype/ipowin heet: van ID_ afgeleid */ + skip= 0; + if(name[0]=='b' && name[1]=='l') { + if(strcmp(name, "blocktype")==0) skip= 1; + } + else if(name[0]=='i' && name[1]=='p') { + if(strcmp(name, "ipowin")==0) skip= 1; + } + + if(skip==0) { + mul= arraysize(name, strlen(name)); + cpo= cur; + while(mul--) { + cval= cpo[0]; + cpo[0]= cpo[1]; + cpo[1]= cval; + cpo+= 2; + } + } + } + else if(spc[0]>3 && spc[0]<8) { /* int-long-ulong-float */ + + mul= arraysize(name, strlen(name)); + cpo= cur; + while(mul--) { + cval= cpo[0]; + cpo[0]= cpo[3]; + cpo[3]= cval; + cval= cpo[1]; + cpo[1]= cpo[2]; + cpo[2]= cval; + cpo+= 4; + } + } + } + } + cur+= elen; + } +} + +void *dna_reconstruct(struct SDNA *newsdna, struct SDNA *oldsdna, char *compflags, int oldSDNAnr, int blocks, void *data) +{ + int a, curSDNAnr, curlen=0, oldlen; + short *spo, *spc; + char *cur, *type, *cpc, *cpo; + + /* oldSDNAnr == structnr, we zoeken het corresponderende 'cur' nummer */ + spo= oldsdna->structs[oldSDNAnr]; + type= oldsdna->types[ spo[0] ]; + oldlen= oldsdna->typelens[ spo[0] ]; + curSDNAnr= dna_findstruct_nr(newsdna, type); + + /* data goedzetten en nieuwe calloc doen */ + if(curSDNAnr >= 0) { + spc= newsdna->structs[curSDNAnr]; + curlen= newsdna->typelens[ spc[0] ]; + } + if(curlen==0) { + return NULL; + } + + cur= MEM_callocN( blocks*curlen, "reconstruct"); + cpc= cur; + cpo= data; + for(a=0; a<blocks; a++) { + reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc); + cpc+= curlen; + cpo+= oldlen; + } + + return cur; +} + diff --git a/source/blender/blenloader/intern/genfile.h b/source/blender/blenloader/intern/genfile.h new file mode 100644 index 00000000000..a861dbd9d9f --- /dev/null +++ b/source/blender/blenloader/intern/genfile.h @@ -0,0 +1,48 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * blenloader genfile private function prototypes + */ + +#ifndef GENFILE_H +#define GENFILE_H + +struct SDNA; + +int dna_findstruct_nr(struct SDNA *sdna, char *str); +char *dna_get_structDNA_compareflags(struct SDNA *sdna, struct SDNA *newsdna); +void dna_switch_endian_struct(struct SDNA *oldsdna, int oldSDNAnr, char *data); +void *dna_reconstruct(struct SDNA *newsdna, struct SDNA *oldsdna, char *compflags, int oldSDNAnr, int blocks, void *data); + +struct SDNA *dna_sdna_from_data(void *data, int datalen, int do_endian_swap); +void dna_freestructDNA(struct SDNA *sdna); + + +#endif diff --git a/source/blender/blenloader/intern/readblenentry.c b/source/blender/blenloader/intern/readblenentry.c new file mode 100644 index 00000000000..2f4723e6b8c --- /dev/null +++ b/source/blender/blenloader/intern/readblenentry.c @@ -0,0 +1,340 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * .blend file reading entry point + */ + +#ifdef WIN32 +#include "BLI_winstuff.h" +#endif + +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <math.h> + +#include "MEM_guardedalloc.h" + +#include "BLI_blenlib.h" +#include "BLI_ghash.h" +#include "BLI_linklist.h" + +#include "DNA_sdna_types.h" +#include "DNA_space_types.h" +#include "DNA_userdef_types.h" +#include "DNA_ID.h" + +#include "BKE_utildefines.h" // for ENDB + +#include "BKE_main.h" +#include "BKE_library.h" // for free_main + +#include "BLO_readfile.h" +#include "readfile.h" + +#include "BLO_readblenfile.h" + + /** + * IDType stuff, I plan to move this + * out into its own file + prefix, and + * make sure all IDType handling goes through + * these routines. + */ + +typedef struct { + unsigned short code; + char *name; + + int flags; +#define IDTYPE_FLAGS_ISLINKABLE (1<<0) +} IDType; + +static IDType idtypes[]= { + { ID_AC, "Action", IDTYPE_FLAGS_ISLINKABLE}, + { ID_AR, "Armature", IDTYPE_FLAGS_ISLINKABLE}, + { ID_CA, "Camera", IDTYPE_FLAGS_ISLINKABLE}, + { ID_CU, "Curve", IDTYPE_FLAGS_ISLINKABLE}, + { ID_GR, "Group", 0}, + { ID_ID, "ID", 0}, + { ID_IK, "Ika", IDTYPE_FLAGS_ISLINKABLE}, + { ID_IM, "Image", IDTYPE_FLAGS_ISLINKABLE}, + { ID_IP, "Ipo", IDTYPE_FLAGS_ISLINKABLE}, + { ID_KE, "Key", 0}, + { ID_LA, "Lamp", IDTYPE_FLAGS_ISLINKABLE}, + { ID_LF, "Life", 0}, + { ID_LI, "Library", 0}, + { ID_LT, "Lattice", IDTYPE_FLAGS_ISLINKABLE}, + { ID_MA, "Material", IDTYPE_FLAGS_ISLINKABLE}, + { ID_MB, "Metaball", IDTYPE_FLAGS_ISLINKABLE}, + { ID_ME, "Mesh", IDTYPE_FLAGS_ISLINKABLE}, + { ID_OB, "Object", IDTYPE_FLAGS_ISLINKABLE}, + { ID_SAMPLE, "Sample", 0}, + { ID_SCE, "Scene", IDTYPE_FLAGS_ISLINKABLE}, + { ID_SCR, "Screen", 0}, + { ID_SEQ, "Sequence", 0}, + { ID_SE, "Sector", 0}, + { ID_SO, "Sound", IDTYPE_FLAGS_ISLINKABLE}, + { ID_TE, "Texture", IDTYPE_FLAGS_ISLINKABLE}, + { ID_TXT, "Text", IDTYPE_FLAGS_ISLINKABLE}, + { ID_VF, "VFont", IDTYPE_FLAGS_ISLINKABLE}, + { ID_WO, "World", IDTYPE_FLAGS_ISLINKABLE}, + { ID_WV, "Wave", 0}, +}; +static int nidtypes= sizeof(idtypes)/sizeof(idtypes[0]); + +static IDType *idtype_from_name(char *str) { + int i= nidtypes; + + while (i--) + if (BLI_streq(str, idtypes[i].name)) + return &idtypes[i]; + + return NULL; +} +static IDType *idtype_from_code(int code) { + int i= nidtypes; + + while (i--) + if (code==idtypes[i].code) + return &idtypes[i]; + + return NULL; +} + +static int bheadcode_is_idcode(int code) { + return idtype_from_code(code)?1:0; +} + +static int idcode_is_linkable(int code) { + IDType *idt= idtype_from_code(code); + return idt?(idt->flags&IDTYPE_FLAGS_ISLINKABLE):0; +} + +char *BLO_idcode_to_name(int code) { + IDType *idt= idtype_from_code(code); + + return idt?idt->name:NULL; +} + +int BLO_idcode_from_name(char *name) { + IDType *idt= idtype_from_name(name); + + return idt?idt->code:0; +} + + /* Access routines used by filesel. */ + +BlendHandle *BLO_blendhandle_from_file(char *file) { + return (BlendHandle*) blo_openblenderfile(file); +} + +void BLO_blendhandle_print_sizes(BlendHandle *bh, void *fp) { + FileData *fd= (FileData*) bh; + BHead *bhead; + + fprintf(fp, "[\n"); + for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) { + if (bhead->code==ENDB) + break; + else { + short *sp= fd->filesdna->structs[bhead->SDNAnr]; + char *name= fd->filesdna->types[ sp[0] ]; + char buf[4]; + + buf[0]= (bhead->code>>24)&0xFF; + buf[1]= (bhead->code>>16)&0xFF; + buf[2]= (bhead->code>>8)&0xFF; + buf[3]= (bhead->code>>0)&0xFF; + + buf[0]= buf[0]?buf[0]:' '; + buf[1]= buf[1]?buf[1]:' '; + buf[2]= buf[2]?buf[2]:' '; + buf[3]= buf[3]?buf[3]:' '; + + fprintf(fp, "['%.4s', '%s', %d, %d], \n", buf, name, bhead->nr, bhead->len+sizeof(BHead)); + } + } + fprintf(fp, "]\n"); +} + +LinkNode *BLO_blendhandle_get_datablock_names(BlendHandle *bh, int ofblocktype) { + FileData *fd= (FileData*) bh; + LinkNode *names= NULL; + BHead *bhead; + + for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) { + if (bhead->code==ofblocktype) { + ID *id= (ID*) (bhead+1); + + BLI_linklist_prepend(&names, strdup(id->name+2)); + } else if (bhead->code==ENDB) + break; + } + + return names; +} + +LinkNode *BLO_blendhandle_get_linkable_groups(BlendHandle *bh) { + FileData *fd= (FileData*) bh; + GHash *gathered= BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp); + LinkNode *names= NULL; + BHead *bhead; + + for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) { + if (bhead->code==ENDB) { + break; + } else if (bheadcode_is_idcode(bhead->code)) { + if (idcode_is_linkable(bhead->code)) { + char *str= BLO_idcode_to_name(bhead->code); + + if (!BLI_ghash_haskey(gathered, str)) { + BLI_linklist_prepend(&names, strdup(str)); + BLI_ghash_insert(gathered, str, NULL); + } + } + } + } + + BLI_ghash_free(gathered, NULL, NULL); + + return names; +} + +void BLO_blendhandle_close(BlendHandle *bh) { + FileData *fd= (FileData*) bh; + + blo_freefiledata(fd); +} + + /**********/ + +BlendFileData *BLO_read_from_file(char *file, BlendReadError *error_r) { + BlendFileData *bfd = NULL; + FileData *fd; + + fd = blo_openblenderfile(file); + if (fd) { + bfd= blo_read_file_internal(fd, error_r); + if (bfd) { + bfd->type= BLENFILETYPE_BLEND; + strcpy(bfd->main->name, file); + } + blo_freefiledata(fd); + } else if (blo_is_a_runtime(file)) { + bfd= blo_read_runtime(file, error_r); + if (bfd) { + bfd->type= BLENFILETYPE_RUNTIME; + strcpy(bfd->main->name, file); + } + } else { + bfd= BLO_readblenfilename(file, error_r); + if (bfd) { + bfd->type= BLENFILETYPE_PUB; + strcpy(bfd->main->name, file); + } + } + + return bfd; +} + +BlendFileData *BLO_read_from_memory(void *mem, int memsize, BlendReadError *error_r) { + BlendFileData *bfd = NULL; + FileData *fd; + + fd = blo_openblendermemory(mem, memsize); + if (fd) { + bfd= blo_read_file_internal(fd, error_r); + if (bfd) { + bfd->type= BLENFILETYPE_BLEND; + strcpy(bfd->main->name, ""); + } + blo_freefiledata(fd); + } else { + bfd= BLO_readblenfilememory(mem, memsize, error_r); + if (bfd) { + bfd->type= BLENFILETYPE_PUB; + strcpy(bfd->main->name, ""); + } + } + + return bfd; +} + +void BLO_blendfiledata_free(BlendFileData *bfd) { + if (bfd->main) { + free_main(bfd->main); + } + + if (bfd->user) { + MEM_freeN(bfd->user); + } + + MEM_freeN(bfd); +} + +char *BLO_bre_as_string(BlendReadError error) { + switch (error) { + case BRE_NONE: + return "No error"; + + case BRE_UNABLE_TO_OPEN: + return "Unable to open"; + case BRE_UNABLE_TO_READ: + return "Unable to read"; + + case BRE_OUT_OF_MEMORY: + return "Out of memory"; + case BRE_INTERNAL_ERROR: + return "<internal error>"; + + case BRE_NOT_A_BLEND: + return "File is not a Blender file"; + case BRE_NOT_A_PUBFILE: + return "File is not a compressed, locked or signed Blender file"; + case BRE_INCOMPLETE: + return "File incomplete"; + case BRE_CORRUPT: + return "File corrupt"; + + case BRE_TOO_NEW: + return "File needs newer Blender version, please upgrade"; + case BRE_NOT_ALLOWED: + return "File is locked"; + + case BRE_NO_SCREEN: + return "File has no screen"; + case BRE_NO_SCENE: + return "File has no scene"; + + default: + case BRE_INVALID: + return "<invalid read error>"; + } +} diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c new file mode 100644 index 00000000000..7addde6e529 --- /dev/null +++ b/source/blender/blenloader/intern/readfile.c @@ -0,0 +1,4810 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * .blend file reading + */ + +#ifdef WIN32 +#include "winsock2.h" +#include "BLI_winstuff.h" +#endif + +#include <stdio.h> // for printf fopen fwrite fclose sprintf FILE +#include <stdlib.h> // for getenv atoi +#include <fcntl.h> // for open +#include <string.h> // for strcasecmp strrchr strncmp strstr +#include <math.h> // for pow + +#ifndef WIN32 + #include <unistd.h> // for read close + #include <sys/param.h> // for MAXPATHLEN +#else + #include <io.h> // for open close read +#endif + +#include "nla.h" + +#include "DNA_ID.h" +#include "DNA_packedFile_types.h" +#include "DNA_property_types.h" +#include "DNA_actuator_types.h" +#include "DNA_controller_types.h" +#include "DNA_sensor_types.h" +#include "DNA_sdna_types.h" +#include "DNA_scene_types.h" +#include "DNA_sequence_types.h" +#include "DNA_ika_types.h" +#include "DNA_camera_types.h" +#include "DNA_lattice_types.h" +#include "DNA_texture_types.h" +#include "DNA_key_types.h" +#include "DNA_meta_types.h" +#include "DNA_lamp_types.h" +#include "DNA_object_types.h" +#include "DNA_world_types.h" +#include "DNA_ipo_types.h" +#include "DNA_mesh_types.h" +#include "DNA_image_types.h" +#include "DNA_material_types.h" +#include "DNA_curve_types.h" +#include "DNA_vfont_types.h" +#include "DNA_effect_types.h" +#include "DNA_text_types.h" +#include "DNA_view3d_types.h" +#include "DNA_screen_types.h" +#include "DNA_sound_types.h" +#include "DNA_space_types.h" +#include "DNA_oops_types.h" +#include "DNA_group_types.h" +#include "DNA_userdef_types.h" +#include "DNA_fileglobal_types.h" +#include "DNA_constraint_types.h" +#include "DNA_action_types.h" +#include "DNA_armature_types.h" +#include "DNA_nla_types.h" + +#include "GEN_messaging.h" + +#include "MEM_guardedalloc.h" +#include "BLI_blenlib.h" +#include "BLI_storage_types.h" // for relname flags + +#include "BKE_bad_level_calls.h" // for reopen_text build_seqar (from WHILE_SEQ) open_plugin_seq set_rects_butspace check_imasel_copy + +#include "BKE_utildefines.h" // SWITCH_INT WHILE_SEQ END_SEQ DATA ENDB DNA1 O_BINARY GLOB USER TEST REND +#include "BKE_constraint.h" +#include "BKE_main.h" // for Main +#include "BKE_global.h" // for G +#include "BKE_property.h" // for get_property +#include "BKE_library.h" // for wich_libbase +#include "BKE_texture.h" // for open_plugin_tex +#include "BKE_effect.h" // for give_parteff +#include "BKE_sca.h" // for init_actuator +#include "BKE_mesh.h" // for ME_ defines (patching) +#include "BKE_armature.h" // for precalc_bonelist_irestmats +#include "BKE_action.h" + +#include "BPY_extern.h" // for BPY_do_pyscript + +#include "BLO_readfile.h" +#include "readfile.h" + +#include "genfile.h" + +#include "BLO_readblenfile.h" // streaming read pipe, for BLO_readblenfile BLO_readblenfilememory + +#include "mydevice.h" + +/* +ZWAK PUNT: newadres berekening en meerdere files: oplossen +bijvoorbeeld door per file aparte newadresarrays te maken? + +LEZEN +- Bestaande Library (Main) pushen of vrijgeven +- Nieuwe Main alloceren +- load file +- read SDNA +- for each LibBlock + - read LibBlock + - als Library + - make a new Main + - ID's eraan hangen + - else + - lees bijhorende direkte data + - link direkte data (intern en aan LibBlock) +- lees FileGlobal +- lees USER data, als aangegeven (~/.B.blend) +- file vrijgeven +- per Library met Scene (per Main) + - file inlezen + - lees SDNA + - alle LibBlocks uit Scene opzoeken en ID's aan Main hagen + - als extern LibBlock + - zoek Main's af + - is al ingelezen: + - nog niet ingelezen + - of nieuwe Main maken + - per LibBlock + - recursief dieper lezen + - lees bijhorende direkte data + - link direkte data (intern en aan LibBlock) + - file vrijgeven +- per Library met nog niet gelezen LibBlocks + - file inlezen + - lees SDNA + - per LibBlock + - recursief dieper lezen + - lees bijhorende direkte data + - link direkte data (intern en aan LibBlock) + - file vrijgeven +- alle Main's samenvoegen +- alle LibBlocks linken en indirekte pointers naar libblocks +- FileGlobal goedzetten en pointers naar Global kopieeren +*/ + +/* also occurs in library.c */ +/* GS reads the memory pointed at in a specific ordering. There are, + * however two definitions for it. I have jotted them down here, both, + * but I think the first one is actually used. The thing is that + * big-endian systems might read this the wrong way round. OTOH, we + * constructed the IDs that are read out with this macro explicitly as + * well. I expect we'll sort it out soon... */ + +/* from blendef: */ +#define GS(a) (*((short *)(a))) + +/* from misc_util: flip the bytes from x */ +/* #define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1]) */ + +// only used here in readfile.c +#define SWITCH_LONGINT(a) { \ + char s_i, *p_i; \ + p_i= (char *)&(a); \ + s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \ + s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \ + s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \ + s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; } +// only used here in readfile.c +#define SWITCH_SHORT(a) { \ + char s_i, *p_i; \ + p_i= (char *)&(a); \ + s_i=p_i[0]; p_i[0]=p_i[1]; p_i[1]=s_i; } + +/***/ + +static char *functionality_check= "\0FUNCTIONALITY_CHECK += blo_readfile\n"; + +/***/ + +typedef struct OldNew { + void *old, *newp; + int nr; +} OldNew; + +typedef struct OldNewMap { + OldNew *entries; + int nentries, entriessize; + + int lasthit; +} OldNewMap; + +static OldNewMap *oldnewmap_new(void) { + OldNewMap *onm= MEM_mallocN(sizeof(*onm), "OldNewMap"); + onm->lasthit= 0; + onm->nentries= 0; + onm->entriessize= 1024; + onm->entries= MEM_mallocN(sizeof(*onm->entries)*onm->entriessize, "OldNewMap.entries"); + + return onm; +} + +static void oldnewmap_insert(OldNewMap *onm, void *oldaddr, void *newaddr, int nr) { + OldNew *entry; + + if (onm->nentries==onm->entriessize) { + int osize= onm->entriessize; + OldNew *oentries= onm->entries; + + onm->entriessize*= 2; + onm->entries= MEM_mallocN(sizeof(*onm->entries)*onm->entriessize, "OldNewMap.entries"); + + memcpy(onm->entries, oentries, sizeof(*oentries)*osize); + MEM_freeN(oentries); + } + + entry= &onm->entries[onm->nentries++]; + entry->old= oldaddr; + entry->newp= newaddr; + entry->nr= nr; +} + +static void *oldnewmap_lookup_and_inc(OldNewMap *onm, void *addr) { + int i; + + if (onm->lasthit<onm->nentries-1) { + OldNew *entry= &onm->entries[++onm->lasthit]; + + if (entry->old==addr) { + entry->nr++; + + return entry->newp; + } + } + + for (i=0; i<onm->nentries; i++) { + OldNew *entry= &onm->entries[i]; + + if (entry->old==addr) { + onm->lasthit= i; + + entry->nr++; + return entry->newp; + } + } + + return NULL; +} + +static void *oldnewmap_liblookup_and_inc(OldNewMap *onm, void *addr, void *lib) { + int i; + + if (onm->lasthit<onm->nentries-1) { + OldNew *entry= &onm->entries[++onm->lasthit]; + + if (entry->old==addr) { + ID *id= entry->newp; + + if (id && (!lib || id->lib)) { + entry->nr++; + + return entry->newp; + } + } + } + + for (i=0; i<onm->nentries; i++) { + OldNew *entry= &onm->entries[i]; + + if (entry->old==addr) { + ID *id= entry->newp; + + if (id && (!lib || id->lib)) { + entry->nr++; + + return entry->newp; + } + } + } + + return NULL; +} + +static void *oldnewmap_typelookup_and_inc(OldNewMap *onm, void *addr, short type) { + int i; + + if (onm->lasthit<onm->nentries-1) { + OldNew *entry= &onm->entries[++onm->lasthit]; + + if (entry->old==addr) { + ID *id= entry->newp; + + if (id && (GS(id->name) == type)) { + entry->nr++; + + return entry->newp; + } + } + } + + for (i=0; i<onm->nentries; i++) { + OldNew *entry= &onm->entries[i]; + + if (entry->old==addr) { + ID *id= entry->newp; + + if (id && (GS(id->name) == type)) { + entry->nr++; + + return entry->newp; + } + } + } + + return NULL; +} + +static void oldnewmap_free_unused(OldNewMap *onm) { + int i; + + for (i=0; i<onm->nentries; i++) { + OldNew *entry= &onm->entries[i]; + if (entry->nr==0) { + MEM_freeN(entry->newp); + entry->newp= NULL; + } + } +} + +static void oldnewmap_clear(OldNewMap *onm) { + onm->nentries= 0; + onm->lasthit= 0; +} + +static void oldnewmap_free(OldNewMap *onm) { + MEM_freeN(onm->entries); + MEM_freeN(onm); +} + +/***/ + +static void read_libraries(FileData *basefd, ListBase *mainlist); + +/* ************ OTHER CRAP ***************** */ + +static void add_main_to_main(Main *mainvar, Main *from) +{ + ListBase *lbarray[30], *fromarray[30]; + int a; + + a= set_listbasepointers(mainvar, lbarray); + a= set_listbasepointers(from, fromarray); + while(a--) { + addlisttolist(lbarray[a], fromarray[a]); + } +} + +void blo_join_main(ListBase *mainlist) +{ + Main *tojoin, *main= mainlist->first; + + while (tojoin= main->next) { + add_main_to_main(main, tojoin); + BLI_remlink(mainlist, tojoin); + MEM_freeN(tojoin); + } +} + +static void split_libdata(ListBase *lb, Main *first) +{ + ListBase *lbn; + ID *id, *idnext; + Main *mainvar; + + id= lb->first; + while(id) { + idnext= id->next; + if(id->lib) { + mainvar= first; + while(mainvar) { + if(mainvar->curlib==id->lib) { + lbn= wich_libbase(mainvar, GS(id->name)); + BLI_remlink(lb, id); + BLI_addtail(lbn, id); + break; + } + mainvar= mainvar->next; + } + if(mainvar==0) printf("error split_libdata\n"); + } + id= idnext; + } +} + +void blo_split_main(ListBase *mainlist) +{ + Main *main= mainlist->first; + ListBase *lbarray[30]; + Library *lib; + int i; + + for (lib= main->library.first; lib; lib= lib->id.next) { + Main *libmain= MEM_callocN(sizeof(*libmain), "libmain"); + libmain->curlib= lib; + + BLI_addtail(mainlist, libmain); + } + + i= set_listbasepointers(main, lbarray); + while(i--) + split_libdata(lbarray[i], main->next); +} + +static Main *blo_find_main(ListBase *mainlist, char *name) +{ + Main *m; + Library *lib; + + for (m= mainlist->first; m; m= m->next) { + char *libname= (m->curlib)?m->curlib->name:m->name; + + if (BLI_streq(name, libname)) + return m; + } + + m= MEM_callocN(sizeof(*m), "find_main"); + BLI_addtail(mainlist, m); + + lib= alloc_libblock(&m->library, ID_LI, "lib"); + strcpy(lib->name, name); + m->curlib= lib; + + return m; +} + + +/* ************ FILE PARSING ****************** */ + +static void switch_endian_bh4(BHead4 *bhead) +{ + /* de ID_.. codes */ + if((bhead->code & 0xFFFF)==0) bhead->code >>=16; + + if (bhead->code != ENDB) { + SWITCH_INT(bhead->len); + SWITCH_INT(bhead->SDNAnr); + SWITCH_INT(bhead->nr); + } +} + +static void switch_endian_bh8(BHead8 *bhead) +{ + /* de ID_.. codes */ + if((bhead->code & 0xFFFF)==0) bhead->code >>=16; + + if (bhead->code != ENDB) { + SWITCH_INT(bhead->len); + SWITCH_INT(bhead->SDNAnr); + SWITCH_INT(bhead->nr); + } +} + +static void bh4_from_bh8(BHead *bhead, BHead8 *bhead8, int do_endian_swap) +{ + BHead4 *bhead4 = (BHead4 *) bhead; +#ifdef WIN32 + __int64 old; +#else + long long old; +#endif + + bhead4->code= bhead8->code; + bhead4->len= bhead8->len; + + if (bhead4->code != ENDB) { + + // why is this here ?? + if (do_endian_swap) { + SWITCH_LONGINT(bhead8->old); + } + + /* this patch is to avoid a long long being read from not-eight aligned positions + is necessary on SGI with -n32 compiling (no, is necessary on + any modern 64bit architecture) */ + memcpy(&old, &bhead8->old, 8); + bhead4->old = (int) (old >> 3); + + bhead4->SDNAnr= bhead8->SDNAnr; + bhead4->nr= bhead8->nr; + } +} + +static void bh8_from_bh4(BHead *bhead, BHead4 *bhead4) +{ + BHead8 *bhead8 = (BHead8 *) bhead; + + bhead8->code= bhead4->code; + bhead8->len= bhead4->len; + + if (bhead8->code != ENDB) { + bhead8->old= bhead4->old; + bhead8->SDNAnr= bhead4->SDNAnr; + bhead8->nr= bhead4->nr; + } +} + +static BHeadN *get_bhead(FileData *fd) +{ + BHead8 bhead8; + BHead4 bhead4; + BHead bhead; + BHeadN *new_bhead = 0; + int readsize; + + if (fd) { + if ( ! fd->eof) { + + // First read the bhead structure. + // Depending on the platform the file was written on this can + // be a big or little endian BHead4 or BHead8 structure. + + // As usual 'ENDB' (the last *partial* bhead of the file) + // needs some special handling. We don't want to EOF just yet. + + if (fd->flags & FD_FLAGS_FILE_POINTSIZE_IS_4) { + bhead4.code = DATA; + readsize = fd->read(fd, &bhead4, sizeof(bhead4)); + + if (readsize == sizeof(bhead4) || bhead4.code == ENDB) { + if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) { + switch_endian_bh4(&bhead4); + } + + if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) { + bh8_from_bh4(&bhead, &bhead4); + } else { + memcpy(&bhead, &bhead4, sizeof(bhead)); + } + } else { + fd->eof = 1; + } + } else { + bhead8.code = DATA; + readsize = fd->read(fd, &bhead8, sizeof(bhead8)); + + if (readsize == sizeof(bhead8) || bhead8.code == ENDB) { + if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) { + switch_endian_bh8(&bhead8); + } + + if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) { + bh4_from_bh8(&bhead, &bhead8, (fd->flags & FD_FLAGS_SWITCH_ENDIAN)); + } else { + memcpy(&bhead, &bhead8, sizeof(bhead)); + } + } else { + fd->eof = 1; + } + } + + // bhead now contains the (converted) bhead structure. Now read + // the associated data and put everything in a BHeadN (creative naming !) + + if ( ! fd->eof) { + new_bhead = MEM_mallocN(sizeof(BHeadN) + bhead.len, "new_bhead"); + if (new_bhead) { + new_bhead->next = new_bhead->prev = 0; + new_bhead->bhead = bhead; + + readsize = fd->read(fd, new_bhead + 1, bhead.len); + + if (readsize != bhead.len) { + fd->eof = 1; + MEM_freeN(new_bhead); + } + } else { + fd->eof = 1; + } + } + } + } + + // We've read a new block. Now add it to the list + // of blocks. + + if (new_bhead) { + BLI_addtail(&fd->listbase, new_bhead); + } + + return(new_bhead); +} + +BHead *blo_firstbhead(FileData *fd) +{ + BHeadN *new_bhead; + BHead *bhead = 0; + + // Rewind the file + // Read in a new block if necessary + + new_bhead = fd->listbase.first; + if (new_bhead == 0) { + new_bhead = get_bhead(fd); + } + + if (new_bhead) { + bhead = &new_bhead->bhead; + } + + return(bhead); +} + +BHead *blo_prevbhead(FileData *fd, BHead *thisblock) +{ + BHeadN *bheadn= (BHeadN *) (((char *) thisblock) - (int) (&((BHeadN*)0)->bhead)); + BHeadN *prev= bheadn->prev; + + return prev?&prev->bhead:NULL; +} + +BHead *blo_nextbhead(FileData *fd, BHead *thisblock) +{ + BHeadN *new_bhead = 0; + BHead *bhead = 0; + + if (thisblock) { + // bhead is actually a sub part of BHeadN + // We calculate the BHeadN pointer from the BHead pointer below + new_bhead = (BHeadN *) (((char *) thisblock) - (int) (&((BHeadN*)0)->bhead)); + + // get the next BHeadN. If it doesn't exist we read in the next one + new_bhead = new_bhead->next; + if (new_bhead == 0) { + new_bhead = get_bhead(fd); + } + } + + if (new_bhead) { + // here we do the reverse: + // go from the BHeadN pointer to the BHead pointer + bhead = &new_bhead->bhead; + } + + return(bhead); +} + +static void decode_blender_header(FileData *fd) +{ + char header[SIZEOFBLENDERHEADER], num[4]; + int readsize; + + // read in the header data + readsize = fd->read(fd, header, sizeof(header)); + + if (readsize == sizeof(header)) { + if(strncmp(header, "BLENDER", 7) == 0) { + int remove_this_endian_test= 1; + + fd->flags |= FD_FLAGS_FILE_OK; + + // what size are pointers in the file ? + if(header[7]=='_') { + fd->flags |= FD_FLAGS_FILE_POINTSIZE_IS_4; + if (sizeof(void *) != 4) { + fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS; + } + } else { + if (sizeof(void *) != 8) { + fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS; + } + } + + // is the file saved in a different endian + // than we need ? + if (((((char*)&remove_this_endian_test)[0]==1)?L_ENDIAN:B_ENDIAN) != ((header[8]=='v')?L_ENDIAN:B_ENDIAN)) { + fd->flags |= FD_FLAGS_SWITCH_ENDIAN; + } + + // get the version number + + memcpy(num, header+9, 3); + num[3] = 0; + fd->fileversion = atoi(num); + } + } +} + +static int read_file_dna(FileData *fd) +{ + BHead *bhead; + + for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) { + if (bhead->code==DNA1) { + int do_endian_swap= (fd->flags&FD_FLAGS_SWITCH_ENDIAN)?1:0; + + fd->filesdna= dna_sdna_from_data(&bhead[1], bhead->len, do_endian_swap); + if (fd->filesdna) + fd->compflags= dna_get_structDNA_compareflags(fd->filesdna, fd->memsdna); + + return 1; + } else if (bhead->code==ENDB) + break; + } + + return 0; +} +static int fd_read_from_file(FileData *filedata, void *buffer, int size) +{ + int readsize = read(filedata->filedes, buffer, size); + + if (readsize < 0) { + readsize = EOF; + } else { + filedata->seek += readsize; + } + + return (readsize); +} + +static int fd_read_from_memory(FileData *filedata, void *buffer, int size) +{ + // don't read more bytes then there are available in the buffer + int readsize = MIN2(size, filedata->buffersize - filedata->seek); + + memcpy(buffer, filedata->buffer + filedata->seek, readsize); + filedata->seek += readsize; + + return (readsize); +} + +static FileData *filedata_new(void) +{ + extern char DNAstr[]; /* DNA.c */ + extern int DNAlen; + FileData *fd = MEM_callocN(sizeof(*fd), "FileData"); + + fd->filedes = -1; + + /* XXX, this doesn't need to be done all the time, + * but it keeps us reentrant, remove once we have + * a lib that provides a nice lock. - zr + */ + fd->memsdna = dna_sdna_from_data(DNAstr, DNAlen, 0); + + fd->datamap = oldnewmap_new(); + fd->globmap = oldnewmap_new(); + fd->libmap = oldnewmap_new(); + + return fd; +} + +FileData *blo_openblenderfile(char *name) +{ + int file= open(name, O_BINARY|O_RDONLY); + + if (file == -1) { + return NULL; + } else { + FileData *fd = filedata_new(); + fd->filedes = file; + fd->buffersize = BLI_filesize(file); + fd->read = fd_read_from_file; + + decode_blender_header(fd); + + if (fd->flags & FD_FLAGS_FILE_OK) { + if (!read_file_dna(fd)) { + blo_freefiledata(fd); + fd= NULL; + } + } else { + blo_freefiledata(fd); + fd= NULL; + } + + return fd; + } +} + +FileData *blo_openblendermemory(void *mem, int memsize) +{ + if (!mem || memsize<SIZEOFBLENDERHEADER) { + return NULL; + } else { + FileData *fd= filedata_new(); + fd->buffer= mem; + fd->buffersize= memsize; + fd->read= fd_read_from_memory; + fd->flags|= FD_FLAGS_NOT_MY_BUFFER; + + decode_blender_header(fd); + + if (fd->flags & FD_FLAGS_FILE_OK) { + if (!read_file_dna(fd)) { + blo_freefiledata(fd); + fd= NULL; + } + } else { + blo_freefiledata(fd); + fd= NULL; + } + + return fd; + } +} + +void blo_freefiledata(FileData *fd) +{ + if (fd) { + if (fd->filedes != -1) { + close(fd->filedes); + } + + if (fd->buffer && !(fd->flags & FD_FLAGS_NOT_MY_BUFFER)) { + MEM_freeN(fd->buffer); + fd->buffer = 0; + } + + // Free all BHeadN data blocks + BLI_freelistN(&fd->listbase); + + if (fd->memsdna) + dna_freestructDNA(fd->memsdna); + if (fd->filesdna) + dna_freestructDNA(fd->filesdna); + if (fd->compflags) + MEM_freeN(fd->compflags); + + if (fd->datamap) + oldnewmap_free(fd->datamap); + if (fd->globmap) + oldnewmap_free(fd->globmap); + if (fd->libmap && !(fd->flags & FD_FLAGS_NOT_MY_LIBMAP)) + oldnewmap_free(fd->libmap); + + MEM_freeN(fd); + } +} + +/* ************ DIV ****************** */ + +int BLO_has_bfile_extension(char *str) +{ + return (BLI_testextensie(str, ".ble") || BLI_testextensie(str, ".blend")); +} + +/* ************** OLD POINTERS ******************* */ + +static void *newdataadr(FileData *fd, void *adr) /* only direct databocks */ +{ + return oldnewmap_lookup_and_inc(fd->datamap, adr); +} + +static void *newglobadr(FileData *fd, void *adr) /* direct datablocks with global linking */ +{ + return oldnewmap_lookup_and_inc(fd->globmap, adr); +} + +static void *newlibadr(FileData *fd, void *lib, void *adr) /* only lib data */ +{ + return oldnewmap_liblookup_and_inc(fd->libmap, adr, lib); +} + +static void *newlibadr_us_type(FileData *fd, short type, void *adr) /* alleen Lib datablokken */ +{ + ID *id= oldnewmap_typelookup_and_inc(fd->libmap, adr, type); + + if (id) { + id->us++; + } + + return id; +} + +static void *newlibadr_us(FileData *fd, void *lib, void *adr) /* hoogt usernummer op */ +{ + ID *id= newlibadr(fd, lib, adr); + + if(id) { + id->us++; + } + + return id; +} + +static void change_libadr(FileData *fd, void *old, void *new) +{ + int i; + + /* changed one thing here, the old change_libadr + * only remapped addresses that had an id->lib, + * but that doesn't make sense to me... its an + * old pointer, period, it needs to be remapped. - zr + */ + + /* + * Ton seemed to think it was necessary to look + * through all entries, and not return after finding + * a match, leaving this cryptic comment, + * // geen return blijkbaar kunnen er meer zijn? + * + * That doesn't make sense to me either but I am + * too scared to remove it... it only would make + * sense if two distinct old address map to the + * same new address - obviously that shouldn't happen + * because memory addresses are unique. + * + * The only case it might happen is when two distinct + * libraries are mapped using the same table... this + * won't work to start with... At some point this + * all needs to be made sense of and made understandable, + * but I'm afraid I don't have time now. -zr + * + */ + for (i=0; i<fd->libmap->nentries; i++) { + OldNew *entry= &fd->libmap->entries[i]; + + if (old==entry->newp) { + entry->newp= new; + break; + } + } +} + + +/* ********** END OUDE POINTERS ****************** */ +/* ********** READ FILE ****************** */ + +static void switch_endian_structs(struct SDNA *filesdna, BHead *bhead) +{ + int blocksize, nblocks; + char *data; + + data= (char *)(bhead+1); /* BHEAD+DATA dependancy */ + blocksize= filesdna->typelens[ filesdna->structs[bhead->SDNAnr][0] ]; + + nblocks= bhead->nr; + while(nblocks--) { + dna_switch_endian_struct(filesdna, bhead->SDNAnr, data); + + data+= blocksize; + } +} + +static void *read_struct(FileData *fd, BHead *bh) +{ + void *temp= NULL; + + if (bh->len) { + if (bh->SDNAnr && (fd->flags & FD_FLAGS_SWITCH_ENDIAN)) + switch_endian_structs(fd->filesdna, bh); + + if (fd->compflags[bh->SDNAnr]) { /* flag==0: doesn't exist anymore */ + if(fd->compflags[bh->SDNAnr]==2) { + temp= dna_reconstruct(fd->memsdna, fd->filesdna, fd->compflags, bh->SDNAnr, bh->nr, (bh+1)); + } else { + temp= MEM_mallocN(bh->len, "read_struct"); + memcpy(temp, (bh+1), bh->len); /* BHEAD+DATA dependancy */ + } + } + } + + return temp; +} + +static void link_list(FileData *fd, ListBase *lb) /* alleen direkte data */ +{ + Link *ln, *prev; + + if(lb->first==0) return; + + lb->first= newdataadr(fd, lb->first); + ln= lb->first; + prev= 0; + while(ln) { + ln->next= newdataadr(fd, ln->next); + ln->prev= prev; + prev= ln; + ln= ln->next; + } + lb->last= prev; +} + +static void link_glob_list(FileData *fd, ListBase *lb) /* for glob data */ +{ + Link *ln, *prev; + void *poin; + + if(lb->first==0) return; + + poin= newdataadr(fd, lb->first); + if(lb->first) { + oldnewmap_insert(fd->globmap, lb->first, poin, 0); + } + lb->first= poin; + + ln= lb->first; + prev= 0; + while(ln) { + poin= newdataadr(fd, ln->next); + if(ln->next) { + oldnewmap_insert(fd->globmap, ln->next, poin, 0); + } + ln->next= poin; + ln->prev= prev; + prev= ln; + ln= ln->next; + } + lb->last= prev; +} + +static void test_pointer_array(FileData *fd, void **mat) +{ +#ifdef WIN32 + __int64 *lpoin, *lmat; +#else + long long *lpoin, *lmat; +#endif + int len, *ipoin, *imat; + + /* manually convert the pointer array in + * the old dna format to a pointer array in + * the new dna format. + */ + if(*mat) { + len= MEM_allocN_len(*mat)/fd->filesdna->pointerlen; + + if(fd->filesdna->pointerlen==8 && fd->memsdna->pointerlen==4) { + ipoin=imat= MEM_mallocN( len*4, "newmatar"); + lpoin= *mat; + + while(len-- > 0) { + if((fd->flags & FD_FLAGS_SWITCH_ENDIAN)) + SWITCH_LONGINT(*lpoin); + *ipoin= (int) ((*lpoin) >> 3); + ipoin++; + lpoin++; + } + MEM_freeN(*mat); + *mat= imat; + } + + if(fd->filesdna->pointerlen==4 && fd->memsdna->pointerlen==8) { + lpoin=lmat= MEM_mallocN( len*8, "newmatar"); + ipoin= *mat; + + while(len-- > 0) { + *lpoin= *ipoin; + ipoin++; + lpoin++; + } + MEM_freeN(*mat); + *mat= lmat; + } + } +} + +/* ************ READ PACKEDFILE *************** */ + +static PackedFile *direct_link_packedfile(FileData *fd, PackedFile *oldpf) +{ + PackedFile *pf= newdataadr(fd, oldpf); + + if (pf) { + pf->data= newdataadr(fd, pf->data); + } + + return pf; +} + +/* ************ READ SCRIPTLINK *************** */ + +static void lib_link_scriptlink(FileData *fd, ID *id, ScriptLink *slink) +{ + int i; + + for(i=0; i<slink->totscript; i++) { + slink->scripts[i]= newlibadr(fd, id->lib, slink->scripts[i]); + } +} + +static void direct_link_scriptlink(FileData *fd, ScriptLink *slink) +{ + slink->scripts= newdataadr(fd, slink->scripts); + slink->flag= newdataadr(fd, slink->flag); + + if(fd->flags & FD_FLAGS_SWITCH_ENDIAN) { + int a; + + for(a=0; a<slink->totscript; a++) { + SWITCH_SHORT(slink->flag[a]); + } + } +} + +/* ************ READ IKA ***************** */ + +static void lib_link_ika(FileData *fd, Main *main) +{ + Ika *ika; + int a; + Deform *def; + + ika= main->ika.first; + while(ika) { + if(ika->id.flag & LIB_NEEDLINK) { + + ika->parent= newlibadr(fd, ika->id.lib, ika->parent); + + a= ika->totdef; + def= ika->def; + while(a--) { + def->ob= newlibadr(fd, ika->id.lib, def->ob); + def++; + } + ika->id.flag -= LIB_NEEDLINK; + } + ika= ika->id.next; + } +} + +static void direct_link_ika(FileData *fd, Ika *ika) +{ + link_list(fd, &ika->limbbase); + + ika->def= newdataadr(fd, ika->def); + + /* afvangen fout uit V.138 en ouder */ + if(ika->def==0) ika->totdef= 0; +} + +/* ************ READ ARMATURE ***************** */ + +static void lib_link_nlastrips(FileData *fd, ID *id, ListBase *striplist) +{ + bActionStrip *strip; + + for (strip=striplist->first; strip; strip=strip->next){ + strip->act = newlibadr(fd, id->lib, strip->act); + strip->ipo = newlibadr(fd, id->lib, strip->ipo); + }; +} + +static void lib_link_constraint_channels(FileData *fd, ID *id, ListBase *chanbase) +{ + bConstraintChannel *chan; + + for (chan=chanbase->first; chan; chan=chan->next){ + chan->ipo = newlibadr_us(fd, id->lib, chan->ipo); + } +} + +static void lib_link_constraints(FileData *fd, ID *id, ListBase *conlist) +{ + bConstraint *con; + + for (con = conlist->first; con; con=con->next) { + switch (con->type) { + case CONSTRAINT_TYPE_ACTION: + { + bActionConstraint *data; + data= ((bActionConstraint*)con->data); + data->tar = newlibadr(fd, id->lib, data->tar); + data->act = newlibadr(fd, id->lib, data->act); + } + break; + case CONSTRAINT_TYPE_LOCLIKE: + { + bLocateLikeConstraint *data; + data= ((bLocateLikeConstraint*)con->data); + data->tar = newlibadr(fd, id->lib, data->tar); + }; + break; + case CONSTRAINT_TYPE_ROTLIKE: + { + bRotateLikeConstraint *data; + data= ((bRotateLikeConstraint*)con->data); + data->tar = newlibadr(fd, id->lib, data->tar); + }; + break; + case CONSTRAINT_TYPE_KINEMATIC: + { + bKinematicConstraint *data; + data = ((bKinematicConstraint*)con->data); + data->tar = newlibadr(fd, id->lib, data->tar); + } + break; + case CONSTRAINT_TYPE_NULL: + break; + case CONSTRAINT_TYPE_TRACKTO: + { + bTrackToConstraint *data; + data = ((bTrackToConstraint*)con->data); + data->tar = newlibadr(fd, id->lib, data->tar); + } + break; + + } + } +} + +static void direct_link_constraints(FileData *fd, ListBase *lb) +{ + bConstraint *cons; + + link_list(fd, lb); + for (cons=lb->first; cons; cons=cons->next) { + cons->data = newdataadr(fd, cons->data); + switch (cons->type) { + default: + break; + } + // Link data + } +} + +static void lib_link_bone(FileData *fd, ID *id, Bone *bone) +{ + Bone *curBone; + +// lib_link_constraints(fd, id, &bone->constraints); + + for (curBone=bone->childbase.first; curBone; curBone=curBone->next) { + lib_link_bone(fd, id, curBone); + } +} + + +static void lib_link_pose(FileData *fd, ID *id, bPose *pose) +{ + bPoseChannel *chan; + + if (!pose) + return; + + for (chan = pose->chanbase.first; chan; chan=chan->next) { + lib_link_constraints(fd, id, &chan->constraints); + } +} + +static void lib_link_armature(FileData *fd, Main *main) +{ + bArmature *arm; + Bone *bone; + + arm= main->armature.first; + + while(arm) { + if(arm->id.flag & LIB_NEEDLINK) { + arm->id.flag -= LIB_NEEDLINK; + } + + for (bone=arm->bonebase.first; bone; bone=bone->next) { + lib_link_bone(fd, &arm->id, bone); + } + + arm= arm->id.next; + } +} + +static void lib_link_action(FileData *fd, Main *main) +{ + bAction *act; + bActionChannel *chan; + + act= main->action.first; + while(act) { + if(act->id.flag & LIB_NEEDLINK) { + act->id.flag -= LIB_NEEDLINK; + + for (chan=act->chanbase.first; chan; chan=chan->next) { + chan->ipo= newlibadr_us(fd, act->id.lib, chan->ipo); + lib_link_constraint_channels(fd, &act->id, &chan->constraintChannels); + } + + } + act= act->id.next; + } +} + +static void direct_link_bones(FileData *fd, Bone* bone) +{ + Bone *child; + + bone->parent= newdataadr(fd, bone->parent); + + link_list(fd, &bone->childbase); + + for (child=bone->childbase.first; child; child=child->next) { + direct_link_bones(fd, child); + } +} + + +static void direct_link_action(FileData *fd, bAction *act) +{ + bActionChannel *achan; + + link_list(fd, &act->chanbase); + + for (achan = act->chanbase.first; achan; achan=achan->next) + link_list(fd, &achan->constraintChannels); + +} + +static void direct_link_armature(FileData *fd, bArmature *arm) +{ + Bone *bone; + + link_list(fd, &arm->bonebase); + + bone=arm->bonebase.first; + while (bone) { + direct_link_bones(fd, bone); + bone=bone->next; + } +} + +/* ************ READ CAMERA ***************** */ + +static void lib_link_camera(FileData *fd, Main *main) +{ + Camera *ca; + + ca= main->camera.first; + while(ca) { + if(ca->id.flag & LIB_NEEDLINK) { + + ca->ipo= newlibadr_us(fd, ca->id.lib, ca->ipo); + + lib_link_scriptlink(fd, &ca->id, &ca->scriptlink); + + ca->id.flag -= LIB_NEEDLINK; + } + ca= ca->id.next; + } +} + +static void direct_link_camera(FileData *fd, Camera *ca) +{ + direct_link_scriptlink(fd, &ca->scriptlink); +} + + +/* ************ READ LATTICE ***************** */ + +static void lib_link_latt(FileData *fd, Main *main) +{ + Lattice *lt; + + lt= main->latt.first; + while(lt) { + if(lt->id.flag & LIB_NEEDLINK) { + + lt->ipo= newlibadr_us(fd, lt->id.lib, lt->ipo); + lt->key= newlibadr_us(fd, lt->id.lib, lt->key); + + lt->id.flag -= LIB_NEEDLINK; + } + lt= lt->id.next; + } +} + +static void direct_link_latt(FileData *fd, Lattice *lt) +{ + lt->def= newdataadr(fd, lt->def); +} + +/* ************ READ LAMP ***************** */ + +static void lib_link_lamp(FileData *fd, Main *main) +{ + Lamp *la; + MTex *mtex; + int a; + + la= main->lamp.first; + while(la) { + if(la->id.flag & LIB_NEEDLINK) { + + for(a=0; a<8; a++) { + mtex= la->mtex[a]; + if(mtex) { + mtex->tex= newlibadr_us(fd, la->id.lib, mtex->tex); + mtex->object= newlibadr(fd, la->id.lib, mtex->object); + } + } + + la->ipo= newlibadr_us(fd, la->id.lib, la->ipo); + + lib_link_scriptlink(fd, &la->id, &la->scriptlink); + + la->id.flag -= LIB_NEEDLINK; + } + la= la->id.next; + } +} + +static void direct_link_lamp(FileData *fd, Lamp *la) +{ + int a; + + direct_link_scriptlink(fd, &la->scriptlink); + + for(a=0; a<8; a++) { + la->mtex[a]= newdataadr(fd, la->mtex[a]); + } +} + +/* ************ READ keys ***************** */ + +static void lib_link_key(FileData *fd, Main *main) +{ + Key *key; + + key= main->key.first; + while(key) { + if(key->id.flag & LIB_NEEDLINK) { + + key->ipo= newlibadr_us(fd, key->id.lib, key->ipo); + key->from= newlibadr(fd, key->id.lib, key->from); + + key->id.flag -= LIB_NEEDLINK; + } + key= key->id.next; + } +} + +static void switch_endian_keyblock(Key *key, KeyBlock *kb) +{ + int elemsize, a, b; + char *data, *poin, *cp; + + elemsize= key->elemsize; + data= kb->data; + + for(a=0; a<kb->totelem; a++) { + + cp= key->elemstr; + poin= data; + + while( cp[0] ) { /* cp[0]==aantal */ + + switch(cp[1]) { /* cp[1]= type */ + case IPO_FLOAT: + case IPO_BPOINT: + case IPO_BEZTRIPLE: + b= cp[0]; + while(b--) { + SWITCH_INT((*poin)); + poin+= 4; + } + break; + } + + cp+= 2; + + } + data+= elemsize; + } +} + +static void direct_link_key(FileData *fd, Key *key) +{ + KeyBlock *kb; + + link_list(fd, &(key->block)); + + key->refkey= newdataadr(fd, key->refkey); + + kb= key->block.first; + while(kb) { + + kb->data= newdataadr(fd, kb->data); + + if(fd->flags & FD_FLAGS_SWITCH_ENDIAN) + switch_endian_keyblock(key, kb); + + kb= kb->next; + } +} + +/* ************ READ mball ***************** */ + +static void lib_link_mball(FileData *fd, Main *main) +{ + MetaBall *mb; + int a; + + mb= main->mball.first; + while(mb) { + if(mb->id.flag & LIB_NEEDLINK) { + + for(a=0; a<mb->totcol; a++) mb->mat[a]= newlibadr_us(fd, mb->id.lib, mb->mat[a]); + + mb->ipo= newlibadr_us(fd, mb->id.lib, mb->ipo); + + mb->id.flag -= LIB_NEEDLINK; + } + mb= mb->id.next; + } +} + +static void direct_link_mball(FileData *fd, MetaBall *mb) +{ + mb->mat= newdataadr(fd, mb->mat); + test_pointer_array(fd, (void **)&mb->mat); + + link_list(fd, &(mb->elems)); + + mb->disp.first= mb->disp.last= 0; + + mb->bb= 0; +} + +/* ************ READ WORLD ***************** */ + +static void lib_link_world(FileData *fd, Main *main) +{ + World *wrld; + MTex *mtex; + int a; + + wrld= main->world.first; + while(wrld) { + if(wrld->id.flag & LIB_NEEDLINK) { + + wrld->ipo= newlibadr_us(fd, wrld->id.lib, wrld->ipo); + + for(a=0; a<8; a++) { + mtex= wrld->mtex[a]; + if(mtex) { + mtex->tex= newlibadr_us(fd, wrld->id.lib, mtex->tex); + mtex->object= newlibadr(fd, wrld->id.lib, mtex->object); + } + } + + lib_link_scriptlink(fd, &wrld->id, &wrld->scriptlink); + + wrld->id.flag -= LIB_NEEDLINK; + } + wrld= wrld->id.next; + } +} + +static void direct_link_world(FileData *fd, World *wrld) +{ + int a; + + direct_link_scriptlink(fd, &wrld->scriptlink); + + for(a=0; a<8; a++) { + wrld->mtex[a]= newdataadr(fd, wrld->mtex[a]); + } +} + + +/* ************ READ IPO ***************** */ + +static void lib_link_ipo(FileData *fd, Main *main) +{ + Ipo *ipo; + + ipo= main->ipo.first; + while(ipo) { + if(ipo->id.flag & LIB_NEEDLINK) { + + ipo->id.flag -= LIB_NEEDLINK; + } + ipo= ipo->id.next; + } +} + +static void direct_link_ipo(FileData *fd, Ipo *ipo) +{ + IpoCurve *icu; + + link_list(fd, &(ipo->curve)); + icu= ipo->curve.first; + while(icu) { + icu->bezt= newdataadr(fd, icu->bezt); + icu->bp= newdataadr(fd, icu->bp); + icu= icu->next; + } +} + +/* ************ READ VFONT ***************** */ + +static void lib_link_vfont(FileData *fd, Main *main) +{ + VFont *vf; + + vf= main->vfont.first; + while(vf) { + if(vf->id.flag & LIB_NEEDLINK) { + vf->id.flag -= LIB_NEEDLINK; + } + vf= vf->id.next; + } +} + +static void direct_link_vfont(FileData *fd, VFont *vf) +{ + vf->data= NULL; + vf->packedfile= direct_link_packedfile(fd, vf->packedfile); +} + +/* ************ READ TEXT ****************** */ + +static void lib_link_text(FileData *fd, Main *main) +{ + Text *text; + + text= main->text.first; + while(text) { + if(text->id.flag & LIB_NEEDLINK) { + text->id.flag -= LIB_NEEDLINK; + } + text= text->id.next; + } +} + +static void direct_link_text(FileData *fd, Text *text) +{ + TextLine *ln; + + text->name= newdataadr(fd, text->name); + + text->undo_pos= -1; + text->undo_len= TXT_INIT_UNDO; + text->undo_buf= MEM_mallocN(text->undo_len, "undo buf"); + + text->compiled= NULL; + + if(text->flags & TXT_ISEXT) { + /* not implemented yet... */ + /* reopen_text(text); */ + } else { + + if(text->lines.first==0) return; + + link_list(fd, &text->lines); + + text->curl= newdataadr(fd, text->curl); + text->sell= newdataadr(fd, text->sell); + + ln= text->lines.first; + while(ln) { + ln->line= newdataadr(fd, ln->line); + + if (ln->len != (int) strlen(ln->line)) { + printf("Error loading text, line lengths differ\n"); + ln->len = strlen(ln->line); + } + + ln= ln->next; + } + + text->flags |= TXT_ISTMP; + } + + text->id.us= 1; +} + +/* ************ READ IMAGE ***************** */ + +static void lib_link_image(FileData *fd, Main *main) +{ + Image *ima; + + ima= main->image.first; + while (ima) { + if(ima->id.flag & LIB_NEEDLINK) { + + ima->id.flag -= LIB_NEEDLINK; + } + ima= ima->id.next; + } +} + +static void direct_link_image(FileData *fd, Image *ima) +{ + ima->ibuf= 0; + ima->anim= 0; + memset(ima->mipmap, 0, sizeof(ima->mipmap)); + ima->repbind= 0; + ima->bindcode= 0; + + ima->packedfile = direct_link_packedfile(fd, ima->packedfile); + + ima->ok= 1; +} + + +/* ************ READ CURVE ***************** */ + +static void lib_link_curve(FileData *fd, Main *main) +{ + Curve *cu; + int a; + + cu= main->curve.first; + while(cu) { + if(cu->id.flag & LIB_NEEDLINK) { + + for(a=0; a<cu->totcol; a++) cu->mat[a]= newlibadr_us(fd, cu->id.lib, cu->mat[a]); + + cu->bevobj= newlibadr(fd, cu->id.lib, cu->bevobj); + cu->textoncurve= newlibadr(fd, cu->id.lib, cu->textoncurve); + cu->vfont= newlibadr_us(fd, cu->id.lib, cu->vfont); + + cu->ipo= newlibadr_us(fd, cu->id.lib, cu->ipo); + cu->key= newlibadr_us(fd, cu->id.lib, cu->key); + + cu->id.flag -= LIB_NEEDLINK; + } + cu= cu->id.next; + } +} + + +static void switch_endian_knots(Nurb *nu) +{ + int len; + + if(nu->knotsu) { + len= KNOTSU(nu); + while(len--) { + SWITCH_INT(nu->knotsu[len]); + } + } + if(nu->knotsv) { + len= KNOTSV(nu); + while(len--) { + SWITCH_INT(nu->knotsv[len]); + } + } +} + +static void direct_link_curve(FileData *fd, Curve *cu) +{ + Nurb *nu; + + cu->mat= newdataadr(fd, cu->mat); + test_pointer_array(fd, (void **)&cu->mat); + cu->str= newdataadr(fd, cu->str); + + if(cu->vfont==0) link_list(fd, &(cu->nurb)); + else { + cu->nurb.first=cu->nurb.last= 0; + } + + cu->bev.first=cu->bev.last= 0; + cu->disp.first=cu->disp.last= 0; + cu->path= 0; + + nu= cu->nurb.first; + while(nu) { + nu->bezt= newdataadr(fd, nu->bezt); + nu->bp= newdataadr(fd, nu->bp); + nu->knotsu= newdataadr(fd, nu->knotsu); + nu->knotsv= newdataadr(fd, nu->knotsv); + + if(fd->flags & FD_FLAGS_SWITCH_ENDIAN) { + switch_endian_knots(nu); + } + + nu= nu->next; + } + cu->bb= 0; +} + +/* ************ READ TEX ***************** */ + +static void lib_link_texture(FileData *fd, Main *main) +{ + Tex *tex; + + tex= main->tex.first; + while(tex) { + if(tex->id.flag & LIB_NEEDLINK) { + + tex->ima= newlibadr_us(fd, tex->id.lib, tex->ima); + tex->ipo= newlibadr_us(fd, tex->id.lib, tex->ipo); + if(tex->env) tex->env->object= newlibadr(fd, tex->id.lib, tex->env->object); + + tex->id.flag -= LIB_NEEDLINK; + } + tex= tex->id.next; + } +} + +static void direct_link_texture(FileData *fd, Tex *tex) +{ + tex->plugin= newdataadr(fd, tex->plugin); + if(tex->plugin) { + tex->plugin->handle= 0; + open_plugin_tex(tex->plugin); + } + tex->coba= newdataadr(fd, tex->coba); + tex->env= newdataadr(fd, tex->env); + if(tex->env) { + tex->env->ima= 0; + memset(tex->env->cube, 0, 6*sizeof(void *)); + tex->env->ok= 0; + } +} + + + +/* ************ READ MATERIAL ***************** */ + +static void lib_link_material(FileData *fd, Main *main) +{ + Material *ma; + MTex *mtex; + int a; + + ma= main->mat.first; + while(ma) { + if(ma->id.flag & LIB_NEEDLINK) { + + ma->ipo= newlibadr_us(fd, ma->id.lib, ma->ipo); + + for(a=0; a<8; a++) { + mtex= ma->mtex[a]; + if(mtex) { + mtex->tex= newlibadr_us(fd, ma->id.lib, mtex->tex); + mtex->object= newlibadr(fd, ma->id.lib, mtex->object); + } + } + lib_link_scriptlink(fd, &ma->id, &ma->scriptlink); + ma->id.flag -= LIB_NEEDLINK; + } + ma= ma->id.next; + } +} + +static void direct_link_material(FileData *fd, Material *ma) +{ + int a; + + direct_link_scriptlink(fd, &ma->scriptlink); + + for(a=0; a<8; a++) { + ma->mtex[a]= newdataadr(fd, ma->mtex[a]); + } + ma->ren= 0; /* mag niet blijven hangen, maarja */ +} + +/* ************ READ MESH ***************** */ + +static void lib_link_mesh(FileData *fd, Main *main) +{ + Mesh *me; + + me= main->mesh.first; + while(me) { + if(me->id.flag & LIB_NEEDLINK) { + int i; + + for(i=0; i<me->totcol; i++) + me->mat[i]= newlibadr_us(fd, me->id.lib, me->mat[i]); + + me->ipo= newlibadr_us(fd, me->id.lib, me->ipo); + me->key= newlibadr_us(fd, me->id.lib, me->key); + me->texcomesh= newlibadr_us(fd, me->id.lib, me->texcomesh); + + if(me->tface) { + TFace *tfaces= me->tface; + + for (i=0; i<me->totface; i++) { + TFace *tf= &tfaces[i]; + + tf->tpage= newlibadr(fd, me->id.lib, tf->tpage); + if(tf->tpage) { + Image *ima= tf->tpage; + if(ima->id.us==0) + ima->id.us= 1; + } + } + } + me->id.flag -= LIB_NEEDLINK; + } + me= me->id.next; + } +} + +static void direct_link_dverts(FileData *fd, int count, MDeformVert *mdverts) +{ + int i, j; + + if (!mdverts) + return; + + for (i=0; i<count; i++) { + mdverts[i].dw=newdataadr(fd, mdverts[i].dw); + if (!mdverts[i].dw) + mdverts[i].totweight=0; + + for (j=0; j< mdverts[i].totweight; j++) { + mdverts[i].dw[j].data = newdataadr(fd, mdverts[i].dw[j].data); + } + } + +} + +static void direct_link_mesh(FileData *fd, Mesh *mesh) +{ + mesh->mat= newdataadr(fd, mesh->mat); + test_pointer_array(fd, (void **)&mesh->mat); + mesh->mvert= newdataadr(fd, mesh->mvert); + + mesh->dvert= newdataadr(fd, mesh->dvert); + direct_link_dverts(fd, mesh->totvert, mesh->dvert); + + mesh->mface= newdataadr(fd, mesh->mface); + mesh->tface= newdataadr(fd, mesh->tface); + mesh->mcol= newdataadr(fd, mesh->mcol); + mesh->msticky= newdataadr(fd, mesh->msticky); + + mesh->disp.first= mesh->disp.last= 0; + mesh->bb= 0; + mesh->oc= 0; + mesh->dface= 0; + mesh->orco= 0; + + if (mesh->tface) { + TFace *tfaces= mesh->tface; + int i; + + for (i=0; i<mesh->totface; i++) { + TFace *tf= &tfaces[i]; + + if(fd->flags & FD_FLAGS_SWITCH_ENDIAN) { + SWITCH_INT(tf->col[0]); + SWITCH_INT(tf->col[1]); + SWITCH_INT(tf->col[2]); + SWITCH_INT(tf->col[3]); + } + } + } +} + +/* ************ READ OBJECT ***************** */ + +static void lib_link_object(FileData *fd, Main *main) +{ + Object *ob; + bSensor *sens; + bController *cont; + bActuator *act; + + void *poin; + int warn=0, a; + + ob= main->object.first; + while(ob) { + if(ob->id.flag & LIB_NEEDLINK) { + + ob->parent= newlibadr(fd, ob->id.lib, ob->parent); + ob->track= newlibadr(fd, ob->id.lib, ob->track); + ob->ipo= newlibadr_us(fd, ob->id.lib, ob->ipo); + ob->action = newlibadr_us(fd, ob->id.lib, ob->action); + +// ob->activecon = newglobadr(fd, ob->activecon); + + poin= ob->data; + ob->data= newlibadr_us(fd, ob->id.lib, ob->data); + + if(ob->data==NULL && poin!=NULL) { + ob->type= OB_EMPTY; + warn= 1; + if(ob->id.lib) printf("Can't find obdata of %s lib %s\n", ob->id.name+2, ob->id.lib->name); + else printf("Object %s lost data. Lib:%x\n", ob->id.name+2, (unsigned int) ob->id.lib); + } + for(a=0; a<ob->totcol; a++) ob->mat[a]= newlibadr_us(fd, ob->id.lib, ob->mat[a]); + + ob->id.flag -= LIB_NEEDLINK; + /* dit stond er eerst: weggehaald omdat de fie give_base_to... er niet meer is */ + /* if(ob->id.us) ob->id.flag -= LIB_NEEDLINK; */ + /* als us==0 wordt verderop nog een base gemaakt */ + + /* WARNING! Also check expand_object(), should reflect the stuff below. */ + lib_link_pose(fd, &ob->id, ob->pose); + lib_link_constraints(fd, &ob->id, &ob->constraints); + lib_link_nlastrips(fd, &ob->id, &ob->nlastrips); + lib_link_constraint_channels(fd, &ob->id, &ob->constraintChannels); + + + sens= ob->sensors.first; + while(sens) { + for(a=0; a<sens->totlinks; a++) { + sens->links[a]= newglobadr(fd, sens->links[a]); + } + if(sens->type==SENS_TOUCH) { + bTouchSensor *ts= sens->data; + ts->ma= newlibadr(fd, ob->id.lib, ts->ma); + } + else if(sens->type==SENS_MESSAGE) { + bMessageSensor *ms= sens->data; + ms->fromObject= + newlibadr(fd, ob->id.lib, ms->fromObject); + } + sens= sens->next; + } + + cont= ob->controllers.first; + while(cont) { + for(a=0; a<cont->totlinks; a++) { + cont->links[a]= newglobadr(fd, cont->links[a]); + } + if(cont->type==CONT_PYTHON) { + bPythonCont *pc= cont->data; + pc->text= newlibadr(fd, ob->id.lib, pc->text); + } + cont->slinks= NULL; + cont->totslinks= 0; + + cont= cont->next; + } + + act= ob->actuators.first; + while(act) { + if(act->type==ACT_SOUND) { + bSoundActuator *sa= act->data; + sa->sound= newlibadr_us(fd, ob->id.lib, sa->sound); + } + else if(act->type==ACT_CD) { + /* bCDActuator *cda= act->data; */ + } + else if(act->type==ACT_GAME) { + /* bGameActuator *ga= act->data; */ + } + else if(act->type==ACT_CAMERA) { + bCameraActuator *ca= act->data; + ca->ob= newlibadr(fd, ob->id.lib, ca->ob); + } + /* leave this one, it's obsolete but necessary to read for conversion */ + else if(act->type==ACT_ADD_OBJECT) { + bAddObjectActuator *eoa= act->data; + if(eoa) eoa->ob= newlibadr(fd, ob->id.lib, eoa->ob); + } + else if(act->type==ACT_EDIT_OBJECT) { + bEditObjectActuator *eoa= act->data; + if(eoa==NULL) { + init_actuator(act); + } + eoa->ob= newlibadr(fd, ob->id.lib, eoa->ob); + eoa->me= newlibadr(fd, ob->id.lib, eoa->me); + } + else if(act->type==ACT_SCENE) { + bSceneActuator *sa= act->data; + sa->camera= newlibadr(fd, ob->id.lib, sa->camera); + sa->scene= newlibadr(fd, ob->id.lib, sa->scene); + } + else if(act->type==ACT_ACTION) { + bActionActuator *aa= act->data; + aa->act= newlibadr(fd, ob->id.lib, aa->act); + } + else if(act->type==ACT_PROPERTY) { + bPropertyActuator *pa= act->data; + pa->ob= newlibadr(fd, ob->id.lib, pa->ob); + } + else if(act->type==ACT_MESSAGE) { + bMessageActuator *ma= act->data; + ma->toObject= newlibadr(fd, ob->id.lib, ma->toObject); + } + act= act->next; + } + + lib_link_scriptlink(fd, &ob->id, &ob->scriptlink); + } + ob= ob->id.next; + } + + if(warn) error("WARNING IN CONSOLE"); +} + + +static void direct_link_pose(FileData *fd, bPose *pose) { + + bPoseChannel *chan; + + if (!pose) + return; + + link_list(fd, &pose->chanbase); + + for (chan = pose->chanbase.first; chan; chan=chan->next) { + direct_link_constraints(fd, &chan->constraints); + } + +} + +static void direct_link_object(FileData *fd, Object *ob) +{ + PartEff *paf; + bProperty *prop; + bSensor *sens; + bController *cont; + bActuator *act; + + ob->disp.first=ob->disp.last= 0; + + ob->pose= newdataadr(fd, ob->pose); + direct_link_pose(fd, ob->pose); + + link_list(fd, &ob->defbase); + link_list(fd, &ob->nlastrips); + link_list(fd, &ob->constraintChannels); + + ob->activecon = newdataadr(fd, ob->activecon); + + direct_link_scriptlink(fd, &ob->scriptlink); + + ob->mat= newdataadr(fd, ob->mat); + test_pointer_array(fd, (void **)&ob->mat); + link_list(fd, &ob->effect); + paf= ob->effect.first; + while(paf) { + if(paf->type==EFF_PARTICLE) { + paf->keys= 0; + } + if(paf->type==EFF_WAVE) { + + } + paf= paf->next; + } + + link_list(fd, &ob->network); + + link_list(fd, &ob->prop); + prop= ob->prop.first; + while(prop) { + prop->poin= newdataadr(fd, prop->poin); + if(prop->poin==0) prop->poin= &prop->data; + prop= prop->next; + } + + link_list(fd, &ob->sensors); + sens= ob->sensors.first; + while(sens) { + sens->data= newdataadr(fd, sens->data); + sens->links= newdataadr(fd, sens->links); + test_pointer_array(fd, (void **)&sens->links); + sens= sens->next; + } + + direct_link_constraints(fd, &ob->constraints); + + link_glob_list(fd, &ob->controllers); + cont= ob->controllers.first; + while(cont) { + cont->data= newdataadr(fd, cont->data); + cont->links= newdataadr(fd, cont->links); + test_pointer_array(fd, (void **)&cont->links); + cont= cont->next; + } + + link_glob_list(fd, &ob->actuators); + act= ob->actuators.first; + while(act) { + act->data= newdataadr(fd, act->data); + act= act->next; + } + + ob->bb= 0; +} + +/* ************ READ SCENE ***************** */ + +static void lib_link_scene(FileData *fd, Main *main) +{ + Scene *sce; + Base *base, *next; + Editing *ed; + Sequence *seq; + + sce= main->scene.first; + while(sce) { + if(sce->id.flag & LIB_NEEDLINK) { + sce->id.us= 1; + sce->camera= newlibadr(fd, sce->id.lib, sce->camera); + sce->world= newlibadr_us(fd, sce->id.lib, sce->world); + sce->set= newlibadr(fd, sce->id.lib, sce->set); + sce->ima= newlibadr_us(fd, sce->id.lib, sce->ima); + sce->group= newlibadr_us(fd, sce->id.lib, sce->group); + + base= sce->base.first; + while(base) { + next= base->next; + + /* base->object= newlibadr_us(fd, sce->id.lib, base->object); */ + + base->object= newlibadr_us_type(fd, ID_OB, base->object); + + if(base->object==0) { + printf("LIB ERROR: base removed\n"); + BLI_remlink(&sce->base, base); + if(base==sce->basact) sce->basact= 0; + MEM_freeN(base); + } + base= next; + } + + ed= sce->ed; + if(ed) { + WHILE_SEQ(ed->seqbasep) { + if(seq->ipo) seq->ipo= newlibadr_us(fd, sce->id.lib, seq->ipo); + if(seq->scene) seq->scene= newlibadr(fd, sce->id.lib, seq->scene); + seq->anim= 0; + } + END_SEQ + } + sce->id.flag -= LIB_NEEDLINK; + } + + lib_link_scriptlink(fd, &sce->id, &sce->scriptlink); + + sce= sce->id.next; + } +} + +static void link_recurs_seq(FileData *fd, ListBase *lb) +{ + Sequence *seq; + + link_list(fd, lb); + seq= lb->first; + while(seq) { + if(seq->seqbase.first) link_recurs_seq(fd, &seq->seqbase); + seq= seq->next; + } +} + +static void direct_link_scene(FileData *fd, Scene *sce) +{ + Editing *ed; + Sequence *seq; + StripElem *se; + int a; + + link_list(fd, &(sce->base)); + + sce->basact= newdataadr(fd, sce->basact); + + sce->radio= newdataadr(fd, sce->radio); + sce->fcam= newdataadr(fd, sce->fcam); + + sce->r.avicodecdata = newdataadr(fd, sce->r.avicodecdata); + if (sce->r.avicodecdata) { + sce->r.avicodecdata->lpFormat = newdataadr(fd, sce->r.avicodecdata->lpFormat); + sce->r.avicodecdata->lpParms = newdataadr(fd, sce->r.avicodecdata->lpParms); + } + + if(sce->ed) { + ed= sce->ed= newdataadr(fd, sce->ed); + + ed->metastack.first= ed->metastack.last= 0; + + /* recursief sequenties linken, ook lb wordt goedgezet */ + link_recurs_seq(fd, &ed->seqbase); + + ed->seqbasep= &ed->seqbase; + + WHILE_SEQ(ed->seqbasep) { + seq->seq1= newdataadr(fd, seq->seq1); + seq->seq2= newdataadr(fd, seq->seq2); + seq->seq3= newdataadr(fd, seq->seq3); + /* eigenlijk een patch: na invoering drie-seq effects */ + if(seq->seq3==0) seq->seq3= seq->seq2; + + seq->curelem= 0; + + seq->plugin= newdataadr(fd, seq->plugin); + if(seq->plugin) open_plugin_seq(seq->plugin, seq->name+2); + + seq->strip= newdataadr(fd, seq->strip); + if(seq->strip && seq->strip->done==0) { + seq->strip->done= 1; + + /* standaard: strips van effecten/meta's worden niet weggeschreven, wel malloccen */ + + if(seq->type==SEQ_IMAGE) { + seq->strip->stripdata= newdataadr(fd, seq->strip->stripdata); + se= seq->strip->stripdata; + if(se) { + for(a=0; a<seq->strip->len; a++, se++) { + se->ok= 1; + se->ibuf= 0; + } + } + } + else if(seq->type==SEQ_MOVIE) { + /* alleen eerste stripelem zit in file */ + se= newdataadr(fd, seq->strip->stripdata); + + if(se) { + seq->strip->stripdata= MEM_callocN(seq->len*sizeof(StripElem), "stripelem"); + *seq->strip->stripdata= *se; + MEM_freeN(se); + + se= seq->strip->stripdata; + + for(a=0; a<seq->strip->len; a++, se++) { + se->ok= 1; + se->ibuf= 0; + se->nr= a + 1; + } + } + } + else if(seq->len>0) + seq->strip->stripdata= MEM_callocN(seq->len*sizeof(StripElem), "stripelem"); + + } + } + END_SEQ + } + + direct_link_scriptlink(fd, &sce->scriptlink); +} + +/* ************ READ SCREEN ***************** */ + +static void lib_link_screen(FileData *fd, Main *main) +{ + bScreen *sc; + ScrArea *sa; + + sc= main->screen.first; + while(sc) { + if(sc->id.flag & LIB_NEEDLINK) { + sc->id.us= 1; + sc->scene= newlibadr(fd, sc->id.lib, sc->scene); + + sa= sc->areabase.first; + while(sa) { + SpaceLink *sl; + + sa->full= newlibadr(fd, sc->id.lib, sa->full); + + for (sl= sa->spacedata.first; sl; sl= sl->next) { + if(sl->spacetype==SPACE_VIEW3D) { + View3D *v3d= (View3D*) sl; + + v3d->camera= newlibadr(fd, sc->id.lib, v3d->camera); + + if(v3d->bgpic) { + v3d->bgpic->ima= newlibadr_us(fd, sc->id.lib, v3d->bgpic->ima); + v3d->bgpic->tex= newlibadr_us(fd, sc->id.lib, v3d->bgpic->tex); + v3d->bgpic->rect= 0; + } + if(v3d->localvd) { + v3d->localvd->camera= newlibadr(fd, sc->id.lib, v3d->localvd->camera); + } + } + else if(sl->spacetype==SPACE_IPO) { + SpaceIpo *sipo= (SpaceIpo *)sl; + sipo->editipo= 0; + sipo->from= newlibadr(fd, sc->id.lib, sipo->from); + sipo->ipokey.first= sipo->ipokey.last= 0; + sipo->ipo= newlibadr(fd, sc->id.lib, sipo->ipo); + } + else if(sl->spacetype==SPACE_BUTS) { + SpaceButs *sbuts= (SpaceButs *)sl; + sbuts->rect= 0; + sbuts->lockpoin= 0; + if(main->versionfile<132) set_rects_butspace(sbuts); + } + else if(sl->spacetype==SPACE_FILE) { + SpaceFile *sfile= (SpaceFile *)sl; + + sfile->filelist= 0; + sfile->libfiledata= 0; + sfile->returnfunc= 0; + } + else if(sl->spacetype==SPACE_IMASEL) { + check_imasel_copy((SpaceImaSel *)sl); + } + else if(sl->spacetype==SPACE_ACTION) { + SpaceAction *saction= (SpaceAction *)sl; + saction->action = newlibadr(fd, sc->id.lib, saction->action); + } + else if(sl->spacetype==SPACE_IMAGE) { + SpaceImage *sima= (SpaceImage *)sl; + + sima->image= newlibadr_us(fd, sc->id.lib, sima->image); + } + else if(sl->spacetype==SPACE_NLA){ + SpaceNla *snla= (SpaceNla *)sl; + } + else if(sl->spacetype==SPACE_TEXT) { + SpaceText *st= (SpaceText *)sl; + + st->text= newlibadr(fd, sc->id.lib, st->text); + + st->py_draw= NULL; + st->py_event= NULL; + st->py_button= NULL; + st->py_globaldict= NULL; + } + else if(sl->spacetype==SPACE_OOPS) { + SpaceOops *so= (SpaceOops *)sl; + Oops *oops; + + oops= so->oops.first; + while(oops) { + oops->id= newlibadr(fd, 0, oops->id); + oops= oops->next; + } + so->lockpoin= 0; + } + else if(sl->spacetype==SPACE_SOUND) { + SpaceSound *ssound= (SpaceSound *)sl; + + ssound->sound= newlibadr_us(fd, sc->id.lib, ssound->sound); + } + } + sa= sa->next; + } + sc->id.flag -= LIB_NEEDLINK; + } + sc= sc->id.next; + } +} + +static void direct_link_screen(FileData *fd, bScreen *sc) +{ + ScrArea *sa; + ScrVert *sv; + ScrEdge *se; + Oops *oops; + + link_list(fd, &(sc->vertbase)); + link_list(fd, &(sc->edgebase)); + link_list(fd, &(sc->areabase)); + sc->winakt= 0; + + /* edges */ + se= sc->edgebase.first; + while(se) { + se->v1= newdataadr(fd, se->v1); + se->v2= newdataadr(fd, se->v2); + if( (long)se->v1 > (long)se->v2) { + sv= se->v1; + se->v1= se->v2; + se->v2= sv; + } + + if(se->v1==NULL) { + printf("error reading screen... file corrupt\n"); + se->v1= se->v2; + } + se= se->next; + } + + /* areas */ + sa= sc->areabase.first; + while(sa) { + SpaceLink *sl; + + link_list(fd, &(sa->spacedata)); + + for (sl= sa->spacedata.first; sl; sl= sl->next) { + if (sl->spacetype==SPACE_VIEW3D) { + View3D *v3d= (View3D*) sl; + v3d->bgpic= newdataadr(fd, v3d->bgpic); + v3d->localvd= newdataadr(fd, v3d->localvd); + } + else if (sl->spacetype==SPACE_OOPS) { + SpaceOops *soops= (SpaceOops*) sl; + link_list(fd, &(soops->oops)); + oops= soops->oops.first; + while(oops) { + oops->link.first= oops->link.last= 0; + oops= oops->next; + } + } + } + + sa->v1= newdataadr(fd, sa->v1); + sa->v2= newdataadr(fd, sa->v2); + sa->v3= newdataadr(fd, sa->v3); + sa->v4= newdataadr(fd, sa->v4); + + sa->win= sa->headwin= 0; + + sa->uiblocks.first= sa->uiblocks.last= NULL; + + sa= sa->next; + } +} + +/* ********** READ LIBRARY *************** */ + + +static void direct_link_library(FileData *fd, Library *lib) +{ + Main *newmain; + + /* nieuwe main */ + newmain= MEM_callocN(sizeof(Main), "directlink"); + BLI_addtail(&fd->mainlist, newmain); + newmain->curlib= lib; +} + +static void lib_link_library(FileData *fd, Main *main) +{ + Library *lib; + + lib= main->library.first; + while(lib) { + lib->id.us= 1; + lib= lib->id.next; + } +} + +/* ************** READ SOUND ******************* */ + +static void direct_link_sound(FileData *fd, bSound *sound) +{ + sound->sample = NULL; + sound->snd_sound = NULL; + + sound->packedfile = direct_link_packedfile(fd, sound->packedfile); + sound->newpackedfile = direct_link_packedfile(fd, sound->newpackedfile); +} + +static void lib_link_sound(FileData *fd, Main *main) +{ + bSound *sound; + + sound= main->sound.first; + while(sound) { + if(sound->id.flag & LIB_NEEDLINK) { + sound->id.flag -= LIB_NEEDLINK; + sound->ipo= newlibadr_us(fd, sound->id.lib, sound->ipo); + } + sound= sound->id.next; + } +} + +/* ***************** READ GROUP *************** */ + +static void direct_link_group(FileData *fd, Group *group) +{ + GroupObject *go; + ObjectKey *ok; + + link_list(fd, &group->gobject); + link_list(fd, &group->gkey); + group->active= newdataadr(fd, group->active); + + go= group->gobject.first; + while(go) { + link_list(fd, &go->okey); + ok= go->okey.first; + while(ok) { + ok->gkey= newdataadr(fd, ok->gkey); + ok= ok->next; + } + go= go->next; + } +} + +static void lib_link_group(FileData *fd, Main *main) +{ + Group *group= main->group.first; + GroupObject *go; + ObjectKey *ok; + + while(group) { + if(group->id.flag & LIB_NEEDLINK) { + group->id.flag -= LIB_NEEDLINK; + + go= group->gobject.first; + while(go) { + go->ob= newlibadr(fd, group->id.lib, go->ob); + ok= go->okey.first; + while(ok) { + ok->parent= newlibadr(fd, group->id.lib, ok->parent); + ok->track= newlibadr(fd, group->id.lib, ok->track); + ok->ipo= newlibadr_us(fd, group->id.lib, ok->ipo); + ok= ok->next; + } + go= go->next; + } + } + group= group->id.next; + } +} + +/* ************** ALG & MAIN ******************** */ + +static BHead *read_libblock(FileData *fd, Main *main, BHead *bhead, int flag, ID **id_r) +{ + /* deze routine leest libblock en direkte data. Met linkfunkties + * alles aan elkaar hangen. + */ + + ID *id; + ListBase *lb; + + if(bhead->code==ID_ID) { + ID *linkedid= (ID *)(bhead + 1); /* BHEAD+DATA dependancy */ + + lb= wich_libbase(main, GS(linkedid->name)); + } + else { + lb= wich_libbase(main, bhead->code); + } + + /* libblock inlezen */ + id = read_struct(fd, bhead); + if (id_r) + *id_r= id; + if (!id) + return blo_nextbhead(fd, bhead); + + oldnewmap_insert(fd->libmap, bhead->old, id, 1); + BLI_addtail(lb, id); + + /* eerste acht bits wissen */ + id->flag= (id->flag & 0xFF00) | flag | LIB_NEEDLINK; + id->lib= main->curlib; + if(id->flag & LIB_FAKEUSER) id->us= 1; + else id->us= 0; + + /* deze mag niet door de direct_link molen: is alleen het ID deel */ + + if(bhead->code==ID_ID) { + return blo_nextbhead(fd, bhead); + } + + bhead = blo_nextbhead(fd, bhead); + + /* alle data inlezen */ + while(bhead && bhead->code==DATA) { + void *data= read_struct(fd, bhead); + + if (data) { + oldnewmap_insert(fd->datamap, bhead->old, data, 0); + } + + bhead = blo_nextbhead(fd, bhead); + } + + /* pointers directe data goedzetten */ + switch( GS(id->name) ) { + case ID_SCR: + direct_link_screen(fd, (bScreen *)id); + break; + case ID_SCE: + direct_link_scene(fd, (Scene *)id); + break; + case ID_OB: + direct_link_object(fd, (Object *)id); + break; + case ID_ME: + direct_link_mesh(fd, (Mesh *)id); + break; + case ID_CU: + direct_link_curve(fd, (Curve *)id); + break; + case ID_MB: + direct_link_mball(fd, (MetaBall *)id); + break; + case ID_MA: + direct_link_material(fd, (Material *)id); + break; + case ID_TE: + direct_link_texture(fd, (Tex *)id); + break; + case ID_IM: + direct_link_image(fd, (Image *)id); + break; + case ID_LA: + direct_link_lamp(fd, (Lamp *)id); + break; + case ID_VF: + direct_link_vfont(fd, (VFont *)id); + break; + case ID_TXT: + direct_link_text(fd, (Text *)id); + break; + case ID_IP: + direct_link_ipo(fd, (Ipo *)id); + break; + case ID_KE: + direct_link_key(fd, (Key *)id); + break; + case ID_LT: + direct_link_latt(fd, (Lattice *)id); + break; + case ID_IK: + direct_link_ika(fd, (Ika *)id); + break; + case ID_WO: + direct_link_world(fd, (World *)id); + break; + case ID_LI: + direct_link_library(fd, (Library *)id); + break; + case ID_CA: + direct_link_camera(fd, (Camera *)id); + break; + case ID_SO: + direct_link_sound(fd, (bSound *)id); + break; + case ID_GR: + direct_link_group(fd, (Group *)id); + break; + case ID_AR: + direct_link_armature(fd, (bArmature*)id); + break; + case ID_AC: + direct_link_action(fd, (bAction*)id); + break; + } + + oldnewmap_free_unused(fd->datamap); + oldnewmap_clear(fd->datamap); + + return (bhead); +} + +static void link_global(FileData *fd, BlendFileData *bfd, FileGlobal *fg) +{ + bfd->winpos= fg->winpos; + bfd->fileflags= fg->fileflags; + bfd->displaymode= fg->displaymode; + + bfd->curscreen= newlibadr(fd, 0, fg->curscreen); +} + +static void vcol_to_fcol(Mesh *me) +{ + MFace *mface; + unsigned int *mcol, *mcoln, *mcolmain; + int a; + + if(me->totface==0 || me->mcol==0) return; + + mcoln= mcolmain= MEM_mallocN(4*sizeof(int)*me->totface, "mcoln"); + mcol = (unsigned int *)me->mcol; + mface= me->mface; + for(a=me->totface; a>0; a--, mface++) { + mcoln[0]= mcol[mface->v1]; + mcoln[1]= mcol[mface->v2]; + mcoln[2]= mcol[mface->v3]; + mcoln[3]= mcol[mface->v4]; + mcoln+= 4; + } + + MEM_freeN(me->mcol); + me->mcol= (MCol *)mcolmain; +} + +static int map_223_keybd_code_to_224_keybd_code(int code) +{ + switch (code) { + case 312: return F12KEY; + case 159: return PADSLASHKEY; + case 161: return PAD0; + case 154: return PAD1; + case 150: return PAD2; + case 155: return PAD3; + case 151: return PAD4; + case 156: return PAD5; + case 152: return PAD6; + case 157: return PAD7; + case 153: return PAD8; + case 158: return PAD9; + default: return code; + } +} + +static void do_versions(Main *main) +{ + /* PAS OP: pointers van libdata zijn nog niet omgezet */ + + if(main->versionfile == 100) { + /* tex->extend en tex->imageflag veranderd: */ + Tex *tex = main->tex.first; + while(tex) { + if(tex->id.flag & LIB_NEEDLINK) { + + if(tex->extend==0) { + if(tex->xrepeat || tex->yrepeat) tex->extend= TEX_REPEAT; + else { + tex->extend= TEX_EXTEND; + tex->xrepeat= tex->yrepeat= 1; + } + } + + if(tex->imaflag & TEX_ANIM5) { + tex->imaflag |= TEX_MORKPATCH; + tex->imaflag |= TEX_ANTIALI; + } + } + tex= tex->id.next; + } + } + if(main->versionfile <= 101) { + /* frame mapping */ + Scene *sce = main->scene.first; + while(sce) { + sce->r.framapto= 100; + sce->r.images= 100; + sce->r.framelen= 1.0; + sce= sce->id.next; + } + } + if(main->versionfile <= 102) { + /* init halo's op 1.0 */ + Material *ma = main->mat.first; + while(ma) { + ma->add= 1.0; + ma= ma->id.next; + } + } + if(main->versionfile <= 103) { + /* nieuwe variabele in object: colbits */ + Object *ob = main->object.first; + int a; + while(ob) { + ob->colbits= 0; + if(ob->totcol) { + for(a=0; a<ob->totcol; a++) { + if(ob->mat[a]) ob->colbits |= (1<<a); + } + } + ob= ob->id.next; + } + } + if(main->versionfile <= 104) { + /* de timeoffs zit op betere plek */ + Object *ob = main->object.first; + while(ob) { + if(ob->transflag & 1) { + ob->transflag -= 1; + ob->ipoflag |= OB_OFFS_OB; + } + ob= ob->id.next; + } + } + if(main->versionfile <= 105) { + Object *ob = main->object.first; + while(ob) { + ob->dupon= 1; ob->dupoff= 0; + ob->dupsta= 1; ob->dupend= 100; + ob= ob->id.next; + } + } + if(main->versionfile <= 106) { + /* mcol is veranderd */ + Mesh *me = main->mesh.first; + while(me) { + if(me->mcol) vcol_to_fcol(me); + me= me->id.next; + } + + } + if(main->versionfile <= 107) { + Object *ob; + Scene *sce = main->scene.first; + while(sce) { + sce->r.mode |= R_GAMMA; + sce= sce->id.next; + } + ob= main->object.first; + while(ob) { + ob->ipoflag |= OB_OFFS_PARENT; + if(ob->dt==0) ob->dt= 3; + ob= ob->id.next; + } + + } + if(main->versionfile <= 109) { + /* nieuwe variabele: gridlines */ + bScreen *sc = main->screen.first; + while(sc) { + ScrArea *sa= sc->areabase.first; + while(sa) { + SpaceLink *sl= sa->spacedata.first; + while (sl) { + if (sl->spacetype==SPACE_VIEW3D) { + View3D *v3d= (View3D*) sl; + + if (v3d->gridlines==0) v3d->gridlines= 20; + } + sl= sl->next; + } + sa= sa->next; + } + sc= sc->id.next; + } + } + if(main->versionfile <= 112) { + Mesh *me = main->mesh.first; + while(me) { + me->cubemapsize= 1.0; + me= me->id.next; + } + } + if(main->versionfile <= 113) { + Material *ma = main->mat.first; + while(ma) { + if(ma->flaresize==0.0) ma->flaresize= 1.0; + ma->subsize= 1.0; + ma->flareboost= 1.0; + ma= ma->id.next; + } + } + if(main->versionfile <= 114) { + Mesh *me= main->mesh.first; + MFace *mface; + int a_int; + + /* edge drawflags veranderd */ + while(me) { + a_int= me->totface; + mface= me->mface; + while(a_int--) { + if(mface->edcode & 16) { + mface->edcode -= 16; + mface->edcode |= ME_V3V1; + } + mface++; + } + me= me->id.next; + } + } + + /* eentje overgeslagen voor bug in freeware versie */ + + if(main->versionfile <= 121) { + /* O2 versie gemaakt. */ + } + if(main->versionfile <= 122) { + /* dithering gaat soms af (backbuf, pas sinds 121) */ + /* relatieve paden hersteld */ + /* sequences: endframe van seq wordt op betere plek geprint */ + } + if(main->versionfile <= 123) { + /* nog een paar O2 foutjes: keylines in ipo window */ + /* vertices halo object (O2) nu ook goed */ + /* zoomwin: ook op O2 */ + /* bug eruit: schaduw render in ortho */ + } + if(main->versionfile <= 124) { + /* inventor lezer */ + /* key kleur 24 bits beveiligd */ + /* schrijf plaatje: je kun niet naderhand 24bits naar 32 + * omzetten */ + } + if(main->versionfile <= 125) { + /* bug vanwege compileer fout (makefile/.h dependency)*/ + } + if(main->versionfile <= 126) { + /* overdraw text beter (clever numbuts) */ + /* bug uit inventor lezer: node ambientColor werd niet + * herkend */ + /* bugje uit toolbox: clear loc= alt-g */ + } + + if(main->versionfile <= 131) { + /* jpeq quality button */ + /* anim5 and blacksmith demo */ + /* foutje uit transp zbuf: te vroege afbreek */ + /* geen paarse code meer als imap onvindbaar is meer */ + /* locx werd niet geprint: string overflow! */ + /* unieke namen: werkte niet */ + /* toolbox menu: ook alt en ctrl keys */ + } + if(main->versionfile <= 132) { + /* strings in Userdef: eroverheen! */ + /* betere overdraw implementatie (numbuts) */ + /* snapmenu redraw */ + /* warp met 1 vertex */ + } + if(main->versionfile <= 133) { + /* bug uit 'make edge face' (array overflow */ + /* volledig X getekende menu's */ + /* storage.c terug */ + } + if(main->versionfile <= 134) { + /* Play (flipbook) restored */ + /* Timecursor restored */ + /* Debug option -d; prints a lot of info in console */ + /* Text Object. Accentcodes fixed: ALT+BACKSPACE */ + /* Cursor was sometimes wrong after reading files */ + /* Texspace draw error: dashed lines */ + /* Draw Schematic View now with icons in Objects */ + /* Ortho camera: zbuffer improved. Near/far still not OK */ + /* Text Object. Character pound= alt-l */ + /* In editmode and 'set', draw error fixed. */ + /* Scanline display during rendering had dropouts */ + /* Sometimes-after render- frontbuffer drawing wasnt disabled */ + /* Sometimes the render window got black and Blender 'hung' */ + /* Better 'active window' implementation. */ + /* Automatic name was too critical, more intuitive now */ + Tex *tex = main->tex.first; + while (tex) { + if ((tex->rfac == 0.0) && + (tex->gfac == 0.0) && + (tex->bfac == 0.0)) { + tex->rfac = 1.0; + tex->gfac = 1.0; + tex->bfac = 1.0; + tex->filtersize = 1.0; + } + tex = tex->id.next; + } + } + if(main->versionfile <= 135) { + /* 'Windows' key resistant */ + /* Preview-render: RGB flip (material, lamp, world) */ + /* Fileselect draw error: 2nd time no redraw! */ + /* Names error: names were not unique automatically */ + /* Metaball display error: because of previous */ + /* CTRL and ALT and SHIFT keys sometimes were locked */ + } + if(main->versionfile <= 136) { + /* Files incompatibility Colorband PC-SGI solved */ + /* RightMouse selecting was blocked after border-select */ + /* Border select: print size */ + /* Inventor: reads some 2.0 syntaxes too. Under development */ + /* Shift/Ctrl/Alt release events got lost while moving view */ + /* Particles draw (size) error fixed */ + /* Display type 'DispView' works */ + /* Metaballs convert to Mesh, normals error fixed. */ + } + if(main->versionfile <= 137) { + /* who know */ + } + if(main->versionfile <= 138) { + /* fixed: z buffer draw and Mesh with no materials: coredump! */ + /* bug removed from calculation 3D Bevel Objects */ + /* view translation in perspective fixed */ + /* Drawing with ortho camera fixed */ + /* timing error FreeBSD version fixed */ + /* Mesa 3.0 included in static version */ + /* New: LeftMouse+RightMouse allowed at numerber-button + * to type in values */ + /* Vertex paint bug fixed */ + /* New: ALT+(1, 2, 3...) for layers 11, 12, 13... */ + } + if(main->versionfile <= 140) { + /* r-g-b-fac in texure */ + Tex *tex = main->tex.first; + while (tex) { + if ((tex->rfac == 0.0) && + (tex->gfac == 0.0) && + (tex->bfac == 0.0)) { + tex->rfac = 1.0; + tex->gfac = 1.0; + tex->bfac = 1.0; + tex->filtersize = 1.0; + } + tex = tex->id.next; + } + } + if(main->versionfile <= 153) { + Scene *sce = main->scene.first; + while(sce) { + if(sce->r.blurfac==0.0) sce->r.blurfac= 1.0; + sce= sce->id.next; + } + } + if(main->versionfile <= 163) { + Scene *sce = main->scene.first; + while(sce) { + if(sce->r.frs_sec==0) sce->r.frs_sec= 25; + sce= sce->id.next; + } + } + if(main->versionfile <= 164) { + Mesh *me= main->mesh.first; + while(me) { + me->smoothresh= 30; + me= me->id.next; + } + } + if(main->versionfile <= 165) { + Mesh *me= main->mesh.first; + TFace *tface; + Ika *ika= main->ika.first; + Deform *def; + int nr; + char *cp; + + while(ika) { + ika->xyconstraint= .5; + + def= ika->def; + nr= ika->totdef; + while(nr--) { + if(def->fac==0.0) def->fac= 1.0; + def++; + } + ika= ika->id.next; + } + + while(me) { + if(me->tface) { + nr= me->totface; + tface= me->tface; + while(nr--) { + cp= (char *)&tface->col[0]; + if(cp[1]>126) cp[1]= 255; else cp[1]*=2; + if(cp[2]>126) cp[2]= 255; else cp[2]*=2; + if(cp[3]>126) cp[3]= 255; else cp[3]*=2; + cp= (char *)&tface->col[1]; + if(cp[1]>126) cp[1]= 255; else cp[1]*=2; + if(cp[2]>126) cp[2]= 255; else cp[2]*=2; + if(cp[3]>126) cp[3]= 255; else cp[3]*=2; + cp= (char *)&tface->col[2]; + if(cp[1]>126) cp[1]= 255; else cp[1]*=2; + if(cp[2]>126) cp[2]= 255; else cp[2]*=2; + if(cp[3]>126) cp[3]= 255; else cp[3]*=2; + cp= (char *)&tface->col[3]; + if(cp[1]>126) cp[1]= 255; else cp[1]*=2; + if(cp[2]>126) cp[2]= 255; else cp[2]*=2; + if(cp[3]>126) cp[3]= 255; else cp[3]*=2; + + tface++; + } + } + me= me->id.next; + } + } + + if(main->versionfile <= 169) { + Mesh *me= main->mesh.first; + while(me) { + if(me->subdiv==0) me->subdiv= 3; + me= me->id.next; + } + } + + if(main->versionfile <= 169) { + bScreen *sc= main->screen.first; + while(sc) { + ScrArea *sa= sc->areabase.first; + while(sa) { + SpaceLink *sl= sa->spacedata.first; + while(sl) { + if(sl->spacetype==SPACE_IPO) { + SpaceIpo *sipo= (SpaceIpo*) sl; + sipo->v2d.max[0]= 15000.0; + } + sl= sl->next; + } + sa= sa->next; + } + sc= sc->id.next; + } + } + + if(main->versionfile <= 170) { + Object *ob = main->object.first; + PartEff *paf; + while (ob) { + paf = give_parteff(ob); + if (paf) { + if (paf->staticstep == 0) { + paf->staticstep= 5; + } + } + ob = ob->id.next; + } + } + + if(main->versionfile <= 171) { + bScreen *sc= main->screen.first; + while(sc) { + ScrArea *sa= sc->areabase.first; + while(sa) { + SpaceLink *sl= sa->spacedata.first; + while(sl) { + if(sl->spacetype==SPACE_TEXT) { + SpaceText *st= (SpaceText*) sl; + if(st->font_id>1) { + st->font_id= 0; + st->lheight= 13; + } + } + sl= sl->next; + } + sa= sa->next; + } + sc= sc->id.next; + } + } + + if(main->versionfile <= 173) { + int a, b; + Mesh *me= main->mesh.first; + while(me) { + if(me->tface) { + TFace *tface= me->tface; + for(a=0; a<me->totface; a++, tface++) { + for(b=0; b<4; b++) { + tface->uv[b][0]/= 32767.0; + tface->uv[b][1]/= 32767.0; + } + } + } + me= me->id.next; + } + } + + if(main->versionfile <= 191) { + bScreen *sc= main->screen.first; + Object *ob= main->object.first; + Material *ma = main->mat.first; + + /* let faces have default add factor of 0.0 */ + while(ma) { + if (!(ma->mode & MA_HALO)) ma->add = 0.0; + ma = ma->id.next; + } + + while(ob) { + ob->mass= 1.0f; + ob->damping= 0.1f; + ob->quat[1]= 1.0f; + ob= ob->id.next; + } + + while(sc) { + ScrArea *sa= sc->areabase.first; + while(sa) { + SpaceLink *sl= sa->spacedata.first; + while(sl) { + if(sl->spacetype==SPACE_BUTS) { + SpaceButs *sbuts= (SpaceButs*) sl; + sbuts->scaflag= BUTS_SENS_LINK|BUTS_SENS_ACT|BUTS_CONT_ACT|BUTS_ACT_ACT|BUTS_ACT_LINK; + } + sl= sl->next; + } + sa= sa->next; + } + sc= sc->id.next; + } + } + + if(main->versionfile <= 193) { + Object *ob= main->object.first; + while(ob) { + ob->inertia= 1.0f; + ob->rdamping= 0.1f; + ob= ob->id.next; + } + } + + if(main->versionfile <= 196) { + Mesh *me= main->mesh.first; + int a, b; + while(me) { + if(me->tface) { + TFace *tface= me->tface; + for(a=0; a<me->totface; a++, tface++) { + for(b=0; b<4; b++) { + tface->mode |= TF_DYNAMIC; + tface->mode &= ~TF_INVISIBLE; + } + } + } + me= me->id.next; + } + } + + if(main->versionfile <= 200) { + Object *ob= main->object.first; + while(ob) { + ob->scaflag = ob->gameflag & (64+128+256+512+1024+2048); + /* 64 is do_fh */ + ob->gameflag &= ~(128+256+512+1024+2048); + ob = ob->id.next; + } + } + + if(main->versionfile <= 201) { + /* add-object + end-object are joined to edit-object actuator */ + Object *ob = main->object.first; + bProperty *prop; + bActuator *act; + bIpoActuator *ia; + bEditObjectActuator *eoa; + bAddObjectActuator *aoa; + while (ob) { + act = ob->actuators.first; + while (act) { + if(act->type==ACT_IPO) { + ia= act->data; + prop= get_property(ob, ia->name); + if(prop) { + ia->type= ACT_IPO_FROM_PROP; + } + } + else if(act->type==ACT_ADD_OBJECT) { + aoa= act->data; + eoa= MEM_callocN(sizeof(bEditObjectActuator), "edit ob act"); + eoa->type= ACT_EDOB_ADD_OBJECT; + eoa->ob= aoa->ob; + eoa->time= aoa->time; + MEM_freeN(aoa); + act->data= eoa; + act->type= act->otype= ACT_EDIT_OBJECT; + } + else if(act->type==ACT_END_OBJECT) { + eoa= MEM_callocN(sizeof(bEditObjectActuator), "edit ob act"); + eoa->type= ACT_EDOB_END_OBJECT; + act->data= eoa; + act->type= act->otype= ACT_EDIT_OBJECT; + } + act= act->next; + } + ob = ob->id.next; + } + } + + if(main->versionfile <= 202) { + /* add-object and end-object are joined to edit-object + * actuator */ + Object *ob= main->object.first; + bActuator *act; + bObjectActuator *oa; + while(ob) { + act= ob->actuators.first; + while(act) { + if(act->type==ACT_OBJECT) { + oa= act->data; + oa->flag &= ~(ACT_TORQUE_LOCAL|ACT_DROT_LOCAL); /* this actuator didn't do local/glob rot before */ + } + act= act->next; + } + ob= ob->id.next; + } + } + + if(main->versionfile <= 204) { + /* patches for new physics */ + Object *ob= main->object.first; + Material *ma= main->mat.first; + bActuator *act; + bObjectActuator *oa; + bSound *sound; + while(ob) { + /* rotdamping */ + ob->damping= (float) pow(ob->damping, 0.05); + ob->rdamping= (float) pow(ob->rdamping, 0.05); + + /* please check this for demo20 files like + * original Egypt levels etc. converted + * rotation factor of 50 is not workable */ + act= ob->actuators.first; + while(act) { + if(act->type==ACT_OBJECT) { + oa= act->data; + + oa->forceloc[0]*= 25.0; + oa->forceloc[1]*= 25.0; + oa->forceloc[2]*= 25.0; + + oa->forcerot[0]*= 10.0; + oa->forcerot[1]*= 10.0; + oa->forcerot[2]*= 10.0; + } + act= act->next; + } + ob= ob->id.next; + } + + while(ma) { + ma->friction= (float) pow(ma->friction, 0.2); + ma->xyfrict= (float) pow(ma->xyfrict, 0.2); + ma= ma->id.next; + } + + sound = main->sound.first; + while (sound) { + if (sound->volume < 0.01) { + sound->volume = 1.0; + } + sound = sound->id.next; + } + } + + if(main->versionfile <= 205) { + /* patches for new physics */ + Object *ob= main->object.first; + bActuator *act; + bSensor *sens; + bEditObjectActuator *oa; + bRaySensor *rs; + bCollisionSensor *cs; + while(ob) { + /* Set anisotropic friction off for old objects, + * values to 1.0. */ + ob->gameflag &= ~OB_ANISOTROPIC_FRICTION; + ob->anisotropicFriction[0] = 1.0; + ob->anisotropicFriction[1] = 1.0; + ob->anisotropicFriction[2] = 1.0; + + act= ob->actuators.first; + while(act) { + if(act->type==ACT_EDIT_OBJECT) { + /* Zero initial velocity for newly + * added objects */ + oa= act->data; + oa->linVelocity[0] = 0.0; + oa->linVelocity[1] = 0.0; + oa->linVelocity[2] = 0.0; + oa->localflag = 0; + } + act= act->next; + } + + sens= ob->sensors.first; + while (sens) { + /* Extra fields for radar sensors. */ + if(sens->type == SENS_RADAR) { + bRadarSensor *s = sens->data; + s->range = 10000.0; + } + + /* Pulsing: defaults for new sensors. */ + if(sens->type != SENS_ALWAYS) { + sens->pulse = 0; + sens->freq = 0; + } else { + sens->pulse = 1; + } + + /* Invert: off. */ + sens->invert = 0; + + /* Collision and ray: default = trigger + * on property. The material field can + * remain empty. */ + if(sens->type == SENS_COLLISION) { + cs = (bCollisionSensor*) sens->data; + cs->mode = 0; + } + if(sens->type == SENS_RAY) { + rs = (bRaySensor*) sens->data; + rs->mode = 0; + } + sens = sens->next; + } + ob= ob->id.next; + } + /* have to check the exact multiplier */ + } + + if(main->versionfile <= 210) { + Scene *sce= main->scene.first; + + while(sce) { + if(sce->r.postmul== 0.0) sce->r.postmul= 1.0; + if(sce->r.postgamma== 0.0) sce->r.postgamma= 1.0; + sce= sce->id.next; + } + } + + if(main->versionfile <= 211) { + /* Render setting: per scene, the applicable gamma value + * can be set. Default is 1.0, which means no + * correction. */ + bActuator *act; + bObjectActuator *oa; + Object *ob; + Scene *sce= main->scene.first; + while(sce) { + sce->r.gamma = 2.0; + sce= sce->id.next; + } + + /* added alpha in obcolor */ + ob= main->object.first; + while(ob) { + ob->col[3]= 1.0; + ob= ob->id.next; + } + + /* added alpha in obcolor */ + ob= main->object.first; + while(ob) { + act= ob->actuators.first; + while(act) { + if (act->type==ACT_OBJECT) { + /* multiply velocity with 50 in old files */ + oa= act->data; + if (fabs(oa->linearvelocity[0]) >= 0.01f) + oa->linearvelocity[0] *= 50.0; + if (fabs(oa->linearvelocity[1]) >= 0.01f) + oa->linearvelocity[1] *= 50.0; + if (fabs(oa->linearvelocity[2]) >= 0.01f) + oa->linearvelocity[2] *= 50.0; + if (fabs(oa->angularvelocity[0])>=0.01f) + oa->angularvelocity[0] *= 50.0; + if (fabs(oa->angularvelocity[1])>=0.01f) + oa->angularvelocity[1] *= 50.0; + if (fabs(oa->angularvelocity[2])>=0.01f) + oa->angularvelocity[2] *= 50.0; + } + act= act->next; + } + ob= ob->id.next; + } + } + + if(main->versionfile <= 212) { + + bSound* sound; + bProperty *prop; + Object *ob; + Mesh *me; + + sound = main->sound.first; + while (sound) + { + sound->max_gain = 1.0; + sound->min_gain = 0.0; + sound->distance = 1.0; + + if (sound->attenuation > 0.0) + sound->flags |= SOUND_FLAGS_3D; + else + sound->flags &= ~SOUND_FLAGS_3D; + + sound = sound->id.next; + } + + ob = main->object.first; + + while (ob) { + prop= ob->prop.first; + while(prop) { + if (prop->type == PROP_TIME) { + // convert old PROP_TIME values from int to float + *((float *)&prop->data) = (float) prop->data; + } + + prop= prop->next; + } + ob = ob->id.next; + } + + /* me->subdiv changed to reflect the actual reparametization + * better, and smeshes were removed - if it was a smesh make + * it a subsurf, and reset the subdiv level because subsurf + * takes a lot more work to calculate. + */ + for (me= main->mesh.first; me; me= me->id.next) { + if (me->flag&ME_SMESH) { + me->flag&= ~ME_SMESH; + me->flag|= ME_SUBSURF; + + me->subdiv= 1; + } else { + if (me->subdiv<2) + me->subdiv= 1; + else + me->subdiv--; + } + } + } + + if(main->versionfile <= 220) { + Object *ob; + Mesh *me; + bArmature *arm; + + ob = main->object.first; + + /* adapt form factor in order to get the 'old' physics + * behaviour back...*/ + + while (ob) { + /* in future, distinguish between different + * object bounding shapes */ + ob->formfactor = 0.4f; + /* patch form factor , note that inertia equiv radius + * of a rotation symmetrical obj */ + if (ob->inertia != 1.0) { + ob->formfactor /= ob->inertia * ob->inertia; + } + ob = ob->id.next; + } + + /* Precalculate rest position matrices for old armatures. -rvo + */ + for (arm= main->armature.first; arm; arm= arm->id.next) { + precalc_bonelist_irestmats (&arm->bonebase); + } + + /* Began using alpha component of vertex colors, but + * old file vertex colors are undefined, reset them + * to be fully opaque. -zr + */ + for (me= main->mesh.first; me; me= me->id.next) { + if (me->mcol) { + int i; + + for (i=0; i<me->totface*4; i++) { + MCol *mcol= &me->mcol[i]; + mcol->a= 255; + } + } + if (me->tface) { + int i, j; + + for (i=0; i<me->totface; i++) { + TFace *tf= &((TFace*) me->tface)[i]; + + for (j=0; j<4; j++) { + char *col= (char*) &tf->col[j]; + + col[0]= 255; + } + } + } + } + } + if(main->versionfile <= 221) { + Scene *sce= main->scene.first; + + // new variables for std-alone player and runtime + while(sce) { + + sce->r.xplay= 640; + sce->r.yplay= 480; + sce->r.freqplay= 60; + + sce= sce->id.next; + } + + } + if(main->versionfile <= 222) { + Scene *sce= main->scene.first; + + // new variables for std-alone player and runtime + while(sce) { + + sce->r.depth= 32; + + sce= sce->id.next; + } + } + + + if(main->versionfile <= 223) { + VFont *vf; + Image *ima; + Object *ob; + + for (vf= main->vfont.first; vf; vf= vf->id.next) { + if (BLI_streq(vf->name+strlen(vf->name)-6, ".Bfont")) { + strcpy(vf->name, "<builtin>"); + } + } + + /* Old textures animate at 25 FPS */ + for (ima = main->image.first; ima; ima=ima->id.next){ + ima->animspeed = 25; + } + + /* Zr remapped some keyboard codes to be linear (stupid zr) */ + for (ob= main->object.first; ob; ob= ob->id.next) { + bSensor *sens; + + for (sens= ob->sensors.first; sens; sens= sens->next) { + if (sens->type==SENS_KEYBOARD) { + bKeyboardSensor *ks= sens->data; + + ks->key= map_223_keybd_code_to_224_keybd_code(ks->key); + ks->qual= map_223_keybd_code_to_224_keybd_code(ks->qual); + ks->qual2= map_223_keybd_code_to_224_keybd_code(ks->qual2); + } + } + } + } + if(main->versionfile <= 224) { + bSound* sound; + Scene *sce; + Mesh *me; + bScreen *sc; + Object *ob; + + for (sound=main->sound.first; sound; sound=sound->id.next) + { + if (sound->packedfile) { + if (sound->newpackedfile == NULL) { + sound->newpackedfile = sound->packedfile; + } + sound->packedfile = NULL; + } + } + + /* Clear some (now) unused pose flags */ + for (ob=main->object.first; ob; ob=ob->id.next){ + if (ob->pose){ + bPoseChannel *pchan; + for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next){ + pchan->flag &= ~(POSE_UNUSED1|POSE_UNUSED2|POSE_UNUSED3|POSE_UNUSED4|POSE_UNUSED5); + } + } + } + + /* Make sure that old subsurf meshes don't have zero subdivision level for rendering */ + for (me=main->mesh.first; me; me=me->id.next){ + if ((me->flag & ME_SUBSURF) && (me->subdivr==0)) + me->subdivr=me->subdiv; + } + + for (sce= main->scene.first; sce; sce= sce->id.next) { + sce->r.stereomode = 1; // no stereo + } + + /* some oldfile patch, moved from set_func_space */ + for (sc= main->screen.first; sc; sc= sc->id.next) { + ScrArea *sa; + + for (sa= sc->areabase.first; sa; sa= sa->next) { + SpaceLink *sl; + + for (sl= sa->spacedata.first; sl; sl= sl->next) { + if (sl->spacetype==SPACE_IPO) { + SpaceSeq *sseq= (SpaceSeq*) sl; + sseq->v2d.keeptot= 0; + } + } + } + } + } + + /* onder in blender.c de nummers wijzigen! */ +} + +static void lib_link_all(FileData *fd, Main *main) +{ + lib_link_screen(fd, main); + lib_link_scene(fd, main); + lib_link_object(fd, main); + lib_link_curve(fd, main); + lib_link_mball(fd, main); + lib_link_material(fd, main); + lib_link_texture(fd, main); + lib_link_image(fd, main); + lib_link_ipo(fd, main); + lib_link_key(fd, main); + lib_link_world(fd, main); + lib_link_lamp(fd, main); + lib_link_latt(fd, main); + lib_link_ika(fd, main); + lib_link_text(fd, main); + lib_link_camera(fd, main); + lib_link_sound(fd, main); + lib_link_group(fd, main); + lib_link_armature(fd, main); + lib_link_action(fd, main); + lib_link_vfont(fd, main); + + lib_link_mesh(fd, main); /* als laatste: tpage images met users op nul */ + + lib_link_library(fd, main); /* alleen users goedzetten */ +} + +BlendFileData *blo_read_file_internal(FileData *fd, BlendReadError *error_r) +{ + BHead *bhead= blo_firstbhead(fd); + BlendFileData *bfd; + FileGlobal *fg; + + bfd= MEM_callocN(sizeof(*bfd), "blendfiledata"); + bfd->main= MEM_callocN(sizeof(*bfd->main), "main"); + BLI_addtail(&fd->mainlist, bfd->main); + + bfd->main->versionfile= fd->fileversion; + + while(bhead) { + switch(bhead->code) { + case GLOB: + case DATA: + case DNA1: + case TEST: + case REND: + case USER: + if (bhead->code==USER) { + bfd->user= read_struct(fd, bhead); + } else if (bhead->code==GLOB) { + fg= read_struct(fd, bhead); + } + bhead = blo_nextbhead(fd, bhead); + break; + case ENDB: + bhead = NULL; + break; + + case ID_LI: + bhead = read_libblock(fd, bfd->main, bhead, LIB_LOCAL, NULL); + break; + case ID_ID: + /* always adds to the most recently loaded + * ID_LI block, see direct_link_library. + * this is part of the file format definition. + */ + bhead = read_libblock(fd, fd->mainlist.last, bhead, LIB_READ+LIB_EXTERN, NULL); + break; + + default: + bhead = read_libblock(fd, bfd->main, bhead, LIB_LOCAL, NULL); + } + } + + /* before read_libraries */ + do_versions(bfd->main); + read_libraries(fd, &fd->mainlist); + blo_join_main(&fd->mainlist); + + lib_link_all(fd, bfd->main); + link_global(fd, bfd, fg); /* als laatste */ + + if (!bfd->curscreen) + bfd->curscreen= bfd->main->screen.first; + + if (bfd->curscreen) { + bfd->curscene= bfd->curscreen->scene; + if (!bfd->curscene) { + bfd->curscene= bfd->main->scene.first; + bfd->curscreen->scene= bfd->curscene; + } + } + + MEM_freeN(fg); + + /* require all files to have an active scene + * and screen. (implicitly: require all files + * to have at least one scene and one screen). + */ + if (!bfd->curscreen || !bfd->curscene) { + *error_r= (!bfd->curscreen)?BRE_NO_SCREEN:BRE_NO_SCENE; + + BLO_blendfiledata_free(bfd); + return NULL; + } + + return bfd; +} + +/* ************* APPEND LIBRARY ************** */ + +static BHead *find_previous_lib(FileData *fd, BHead *bhead) +{ + for (; bhead; bhead= blo_prevbhead(fd, bhead)) + if (bhead->code==ID_LI) + break; + + return bhead; +} + +static BHead *find_bhead(FileData *fd, void *old) +{ + BHead *bhead; + + if (!old) + return NULL; + + for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) + if (bhead->old==old) + return bhead; + + return NULL; +} + +static ID *is_yet_read(Main *mainvar, BHead *bhead) +{ + ListBase *lb; + ID *idtest, *id; + + // BHEAD+DATA dependancy + idtest= (ID *)(bhead +1); + lb= wich_libbase(mainvar, GS(idtest->name)); + if(lb) { + id= lb->first; + while(id) { + if( strcmp(id->name, idtest->name)==0 ) return id; + id= id->next; + } + } + return 0; +} + +static void expand_doit(FileData *fd, Main *mainvar, void *old) +{ + BHead *bhead; + ID *id; + + bhead= find_bhead(fd, old); + if(bhead) { + /* from another library? */ + if(bhead->code==ID_ID) { + BHead *bheadlib= find_previous_lib(fd, bhead); + + if(bheadlib) { + // BHEAD+DATA dependancy + Library *lib= (Library *)(bheadlib+1); + mainvar= blo_find_main(&fd->mainlist, lib->name); + + id= is_yet_read(mainvar, bhead); + + if(id==0) { + read_libblock(fd, mainvar, bhead, LIB_READ+LIB_INDIRECT, NULL); + printf("expand: other lib %s\n", lib->name); + } + else { + oldnewmap_insert(fd->libmap, bhead->old, id, 1); + printf("expand: already linked: %s lib: %s\n", id->name, lib->name); + } + } + } + else { + id= is_yet_read(mainvar, bhead); + if(id==0) { + // BHEAD+DATA dependancy + id= (ID *)(bhead+1); + read_libblock(fd, mainvar, bhead, LIB_TESTIND, NULL); + } + else { + oldnewmap_insert(fd->libmap, bhead->old, id, 1); + /* printf("expand: al ingelezen %s\n", id->name); */ + } + } + } +} + +static void expand_key(FileData *fd, Main *mainvar, Key *key) +{ + expand_doit(fd, mainvar, key->ipo); +} + + +static void expand_texture(FileData *fd, Main *mainvar, Tex *tex) +{ + expand_doit(fd, mainvar, tex->ima); +} + +static void expand_material(FileData *fd, Main *mainvar, Material *ma) +{ + int a; + + for(a=0; a<8; a++) { + if(ma->mtex[a]) { + expand_doit(fd, mainvar, ma->mtex[a]->tex); + expand_doit(fd, mainvar, ma->mtex[a]->object); + } + } + expand_doit(fd, mainvar, ma->ipo); +} + +static void expand_lamp(FileData *fd, Main *mainvar, Lamp *la) +{ + int a; + + for(a=0; a<8; a++) { + if(la->mtex[a]) { + expand_doit(fd, mainvar, la->mtex[a]->tex); + expand_doit(fd, mainvar, la->mtex[a]->object); + } + } + expand_doit(fd, mainvar, la->ipo); +} + +static void expand_lattice(FileData *fd, Main *mainvar, Lattice *lt) +{ + expand_doit(fd, mainvar, lt->ipo); + expand_doit(fd, mainvar, lt->key); +} + + +static void expand_world(FileData *fd, Main *mainvar, World *wrld) +{ + int a; + + for(a=0; a<8; a++) { + if(wrld->mtex[a]) { + expand_doit(fd, mainvar, wrld->mtex[a]->tex); + expand_doit(fd, mainvar, wrld->mtex[a]->object); + } + } + expand_doit(fd, mainvar, wrld->ipo); +} + + +static void expand_mball(FileData *fd, Main *mainvar, MetaBall *mb) +{ + int a; + + for(a=0; a<mb->totcol; a++) { + expand_doit(fd, mainvar, mb->mat[a]); + } +} + +static void expand_curve(FileData *fd, Main *mainvar, Curve *cu) +{ + int a; + + for(a=0; a<cu->totcol; a++) { + expand_doit(fd, mainvar, cu->mat[a]); + } + expand_doit(fd, mainvar, cu->vfont); + expand_doit(fd, mainvar, cu->key); + expand_doit(fd, mainvar, cu->ipo); + expand_doit(fd, mainvar, cu->bevobj); + expand_doit(fd, mainvar, cu->textoncurve); +} + +static void expand_mesh(FileData *fd, Main *mainvar, Mesh *me) +{ + int a; + TFace *tface; + + for(a=0; a<me->totcol; a++) { + expand_doit(fd, mainvar, me->mat[a]); + } + + expand_doit(fd, mainvar, me->key); + expand_doit(fd, mainvar, me->texcomesh); + + if(me->tface) { + tface= me->tface; + a= me->totface; + while(a--) { + if(tface->tpage) expand_doit(fd, mainvar, tface->tpage); + tface++; + } + } +} + +static void expand_constraints(FileData *fd, Main *mainvar, ListBase *lb) +{ + bConstraint *curcon; + + for (curcon=lb->first; curcon; curcon=curcon->next) { + switch (curcon->type) { + case CONSTRAINT_TYPE_ACTION: + { + bActionConstraint *data = (bActionConstraint*)curcon->data; + expand_doit(fd, mainvar, data->tar); + expand_doit(fd, mainvar, data->act); + } + break; + case CONSTRAINT_TYPE_LOCLIKE: + { + bLocateLikeConstraint *data = (bLocateLikeConstraint*)curcon->data; + expand_doit(fd, mainvar, data->tar); + break; + } + case CONSTRAINT_TYPE_ROTLIKE: + { + bRotateLikeConstraint *data = (bRotateLikeConstraint*)curcon->data; + expand_doit(fd, mainvar, data->tar); + break; + } + case CONSTRAINT_TYPE_KINEMATIC: + { + bKinematicConstraint *data = (bKinematicConstraint*)curcon->data; + expand_doit(fd, mainvar, data->tar); + break; + } + case CONSTRAINT_TYPE_TRACKTO: + { + bTrackToConstraint *data = (bTrackToConstraint*)curcon->data; + expand_doit(fd, mainvar, data->tar); + break; + } + case CONSTRAINT_TYPE_NULL: + break; + default: + break; + } + } +} + +static void expand_bones(FileData *fd, Main *mainvar, Bone *bone) +{ + Bone *curBone; + +// expand_constraints(fd, main, &bone->constraints); + + for (curBone = bone->childbase.first; curBone; curBone=curBone->next) { + expand_bones(fd, mainvar, curBone); + } + +} + +static void expand_pose(FileData *fd, Main *mainvar, bPose *pose) +{ + bPoseChannel *chan; + + if (!pose) + return; + + for (chan = pose->chanbase.first; chan; chan=chan->next) { + expand_constraints(fd, mainvar, &chan->constraints); + } +} + +static void expand_armature(FileData *fd, Main *mainvar, bArmature *arm) +{ + Bone *curBone; + + for (curBone = arm->bonebase.first; curBone; curBone=curBone->next) { + expand_bones(fd, mainvar, curBone); + } +} + +static void expand_constraint_channels(FileData *fd, Main *mainvar, ListBase *chanbase) +{ + bConstraintChannel *chan; + for (chan=chanbase->first; chan; chan=chan->next){ + expand_doit(fd, mainvar, chan->ipo); + } +} + +static void expand_action(FileData *fd, Main *mainvar, bAction *act) +{ + bActionChannel *chan; + for (chan=act->chanbase.first; chan; chan=chan->next) { + expand_doit(fd, mainvar, chan->ipo); + expand_constraint_channels(fd, mainvar, &chan->constraintChannels); + } +} + +static void expand_object(FileData *fd, Main *mainvar, Object *ob) +{ + bSensor *sens; + bController *cont; + bActuator *act; + bActionStrip *strip; + int a; + + + expand_doit(fd, mainvar, ob->data); + expand_doit(fd, mainvar, ob->ipo); + expand_doit(fd, mainvar, ob->action); + + expand_pose(fd, mainvar, ob->pose); + expand_constraints(fd, mainvar, &ob->constraints); + expand_constraint_channels(fd, mainvar, &ob->constraintChannels); + + for (strip=ob->nlastrips.first; strip; strip=strip->next){ + expand_doit(fd, mainvar, strip->act); + expand_doit(fd, mainvar, strip->ipo); + } + + for(a=0; a<ob->totcol; a++) { + expand_doit(fd, mainvar, ob->mat[a]); + } + sens= ob->sensors.first; + while(sens) { + if(sens->type==SENS_TOUCH) { + bTouchSensor *ts= sens->data; + expand_doit(fd, mainvar, ts->ma); + } + else if(sens->type==SENS_MESSAGE) { + bMessageSensor *ms= sens->data; + expand_doit(fd, mainvar, ms->fromObject); + } + sens= sens->next; + } + + cont= ob->controllers.first; + while(cont) { + if(cont->type==CONT_PYTHON) { + bPythonCont *pc= cont->data; + expand_doit(fd, mainvar, pc->text); + } + cont= cont->next; + } + + act= ob->actuators.first; + while(act) { + if(act->type==ACT_SOUND) { + bSoundActuator *sa= act->data; + expand_doit(fd, mainvar, sa->sound); + } + else if(act->type==ACT_CAMERA) { + bCameraActuator *ca= act->data; + expand_doit(fd, mainvar, ca->ob); + } + else if(act->type==ACT_EDIT_OBJECT) { + bEditObjectActuator *eoa= act->data; + if(eoa) { + expand_doit(fd, mainvar, eoa->ob); + expand_doit(fd, mainvar, eoa->me); + } + } + else if(act->type==ACT_SCENE) { + bSceneActuator *sa= act->data; + expand_doit(fd, mainvar, sa->camera); + expand_doit(fd, mainvar, sa->scene); + } + else if(act->type==ACT_ACTION) { + bActionActuator *aa= act->data; + expand_doit(fd, mainvar, aa->act); + } + else if(act->type==ACT_PROPERTY) { + bPropertyActuator *pa= act->data; + expand_doit(fd, mainvar, pa->ob); + } + else if(act->type==ACT_MESSAGE) { + bMessageActuator *ma= act->data; + expand_doit(fd, mainvar, ma->toObject); + } + act= act->next; + } +} + +static void expand_scene(FileData *fd, Main *mainvar, Scene *sce) +{ + Base *base; + + base= sce->base.first; + while(base) { + expand_doit(fd, mainvar, base->object); + base= base->next; + } + expand_doit(fd, mainvar, sce->camera); + expand_doit(fd, mainvar, sce->world); +} + +static void expand_camera(FileData *fd, Main *mainvar, Camera *ca) +{ + expand_doit(fd, mainvar, ca->ipo); +} + +static void expand_sound(FileData *fd, Main *mainvar, bSound *snd) +{ + expand_doit(fd, mainvar, snd->ipo); +} + + +static void expand_main(FileData *fd, Main *mainvar) +{ + ListBase *lbarray[30]; + ID *id; + int a, doit= 1; + + if(fd==0) return; + + while(doit) { + doit= 0; + + a= set_listbasepointers(mainvar, lbarray); + while(a--) { + id= lbarray[a]->first; + + while(id) { + if(id->flag & LIB_TEST) { + + switch(GS(id->name)) { + + case ID_OB: + expand_object(fd, mainvar, (Object *)id); + break; + case ID_ME: + expand_mesh(fd, mainvar, (Mesh *)id); + break; + case ID_CU: + expand_curve(fd, mainvar, (Curve *)id); + break; + case ID_MB: + expand_mball(fd, mainvar, (MetaBall *)id); + break; + case ID_SCE: + expand_scene(fd, mainvar, (Scene *)id); + break; + case ID_MA: + expand_material(fd, mainvar, (Material *)id); + break; + case ID_TE: + expand_texture(fd, mainvar, (Tex *)id); + break; + case ID_WO: + expand_world(fd, mainvar, (World *)id); + break; + case ID_LT: + expand_lattice(fd, mainvar, (Lattice *)id); + break; + case ID_LA: + expand_lamp(fd, mainvar,(Lamp *)id); + break; + case ID_KE: + expand_key(fd, mainvar, (Key *)id); + break; + case ID_CA: + expand_camera(fd, mainvar, (Camera *)id); + break; + case ID_SO: + expand_sound(fd, mainvar, (bSound *)id); + break; + case ID_AR: + expand_armature(fd, mainvar, (bArmature *)id); + break; + case ID_AC: + expand_action(fd, mainvar, (bAction *)id); + break; + } + + doit= 1; + id->flag -= LIB_TEST; + + } + id= id->next; + } + } + } +} + +#if 0 +static void give_base_to_objects(Scene *sce, ListBase *lb) +{ + Object *ob; + Base *base; + + /* alle objects die LIB_EXTERN en LIB_NEEDLINK zijn, een base geven */ + ob= lb->first; + while(ob) { + + if(ob->id.us==0) { + + if(ob->id.flag & LIB_NEEDLINK) { + + ob->id.flag -= LIB_NEEDLINK; + + if( ob->id.flag & LIB_INDIRECT ) { + + base= MEM_callocN( sizeof(Base), "add_ext_base"); + BLI_addtail(&(sce->base), base); + base->lay= ob->lay; + base->object= ob; + ob->id.us= 1; + + ob->id.flag -= LIB_INDIRECT; + ob->id.flag |= LIB_EXTERN; + + } + } + } + ob= ob->id.next; + } +} +#endif + +static void append_named_part(SpaceFile *sfile, Main *mainvar, Scene *scene, char *name, int idcode) +{ + Object *ob; + Base *base; + BHead *bhead; + ID *id; + FileData *fd= (FileData*) sfile->libfiledata; + int afbreek=0; + + bhead = blo_firstbhead(fd); + while(bhead && afbreek==0) { + + if(bhead->code==ENDB) afbreek= 1; + else if(bhead->code==idcode) { + // BHEAD+DATA dependancy + id= (ID *)(bhead+1); + if(strcmp(id->name+2, name)==0) { + + id= is_yet_read(mainvar, bhead); + if(id==0) { + read_libblock(fd, mainvar, bhead, LIB_TESTEXT, NULL); + } + else { + printf("append: already linked\n"); + oldnewmap_insert(fd->libmap, bhead->old, id, 1); + if(id->flag & LIB_INDIRECT) { + id->flag -= LIB_INDIRECT; + id->flag |= LIB_EXTERN; + } + } + + if(idcode==ID_OB) { /* los object: base geven */ + base= MEM_callocN( sizeof(Base), "app_nam_part"); + BLI_addtail(&scene->base, base); + + if(id==0) ob= mainvar->object.last; + else ob= (Object *)id; + + base->lay= ob->lay; + base->object= ob; + ob->id.us++; + } + afbreek= 1; + } + } + + bhead = blo_nextbhead(fd, bhead); + } +} + +static void append_id_part(FileData *fd, Main *mainvar, ID *id, ID **id_r) +{ + BHead *bhead; + + for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) { + if (bhead->code == GS(id->name)) { + ID *idread= (ID *)(bhead+1); /* BHEAD+DATA dependancy */ + + if (BLI_streq(id->name, idread->name)) { + id->flag -= LIB_READ; + id->flag |= LIB_TEST; + + read_libblock(fd, mainvar, bhead, id->flag, id_r); + + break; + } + } else if (bhead->code==ENDB) + break; + } +} + + + /* append aan G.scene */ +void BLO_library_append(SpaceFile *sfile, char *dir, int idcode) +{ + FileData *fd= (FileData*) sfile->libfiledata; + ListBase mainlist; + Main *main; + int a, totsel=0; + + /* zijn er geselecteerde files? */ + for(a=0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + totsel++; + } + } + + if(totsel==0) { + /* is de aangegeven file in de filelist? */ + if(sfile->file[0]) { + for(a=0; a<sfile->totfile; a++) { + if( strcmp(sfile->filelist[a].relname, sfile->file)==0) break; + } + if(a==sfile->totfile) { + error("Wrong indicated name"); + return; + } + } + else { + error("Nothing indicated"); + return; + } + } + /* nu hebben OF geselecteerde, OF 1 aangegeven file */ + + mainlist.first= mainlist.last= G.main; + G.main->next= NULL; + + /* mains maken */ + blo_split_main(&mainlist); + + /* welke moeten wij hebben? */ + main= blo_find_main(&mainlist, dir); + + if(totsel==0) { + append_named_part(sfile, main, G.scene, sfile->file, idcode); + } + else { + for(a=0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + append_named_part(sfile, main, G.scene, sfile->filelist[a].relname, idcode); + } + } + } + + /* de main consistent maken */ + expand_main(fd, main); + + /* als expand nog andere libs gevonden heeft: */ + read_libraries(fd, &mainlist); + + blo_join_main(&mainlist); + G.main= mainlist.first; + + lib_link_all(fd, G.main); + + /* losse objects aan G.scene hangen deze hebben nog een linkflag + moet na lib_link ivm gelinkte scenes (ob->us==0) */ + + /* indirecte objects kunnen geen kwaad */ + /* als je deze terugzet, denk aan de 'need_link' flag: doe een find naar 'give_base_to' */ + /* give_base_to_objects(G.scene, &(G.main->object)); */ + + /* voorlopige patch om te voorkomen dat de switch_endian 2x gebeurt */ + if(fd->flags & FD_FLAGS_SWITCH_ENDIAN) { + blo_freefiledata((FileData*) sfile->libfiledata); + sfile->libfiledata= 0; + } +} + +/* ************* READ LIBRARY ************** */ + +static int mainvar_count_libread_blocks(Main *mainvar) +{ + ListBase *lbarray[30]; + int a, tot= 0; + + a= set_listbasepointers(mainvar, lbarray); + while(a--) { + ID *id= lbarray[a]->first; + + for (id= lbarray[a]->first; id; id= id->next) + if (id->flag & LIB_READ) + tot++; + } + return tot; +} + +static void read_libraries(FileData *basefd, ListBase *mainlist) +{ + Main *main= mainlist->first; + Main *mainptr; + ListBase *lbarray[30]; + int a, doit= 1; + + while(doit) { + doit= 0; + + /* test 1: inlezen libdata */ + mainptr= main->next; + + while(mainptr) { + int tot= mainvar_count_libread_blocks(mainptr); + + if(tot) { + FileData *fd= mainptr->curlib->filedata; + + if(fd==0) { + printf("read lib %s\n", mainptr->curlib->name); + fd= blo_openblenderfile(mainptr->curlib->name); + if (fd) { + if (fd->libmap) + oldnewmap_free(fd->libmap); + + fd->libmap= basefd->libmap; + fd->flags|= FD_FLAGS_NOT_MY_LIBMAP; + } + + mainptr->curlib->filedata= fd; + + if (!fd) + printf("ERROR: can't find lib %s \n", mainptr->curlib->name); + } + if(fd) { + doit= 1; + a= set_listbasepointers(mainptr, lbarray); + while(a--) { + ID *id= lbarray[a]->first; + + while(id) { + ID *idn= id->next; + if(id->flag & LIB_READ) { + ID *realid= NULL; + BLI_remlink(lbarray[a], id); + + append_id_part(fd, mainptr, id, &realid); + if (!realid) + printf("LIB ERROR: can't find %s\n", id->name); + change_libadr(fd, id, realid); + + MEM_freeN(id); + } + id= idn; + } + } + + expand_main(fd, mainptr); + } + } + + mainptr= mainptr->next; + } + } + mainptr= main->next; + while(mainptr) { + /* test of er libblocken niet zijn gelezen */ + a= set_listbasepointers(mainptr, lbarray); + while(a--) { + ID *id= lbarray[a]->first; + while(id) { + ID *idn= id->next; + if(id->flag & LIB_READ) { + BLI_remlink(lbarray[a], id); + + printf("LIB ERROR: can't find %s\n", id->name); + change_libadr(basefd, id, 0); + + MEM_freeN(id); + } + id= idn; + } + } + + /* sommige mains moeten nog worden ingelezen, dan is + * versionfile nog nul! */ + if(mainptr->versionfile) do_versions(mainptr); + + if(mainptr->curlib->filedata) blo_freefiledata(mainptr->curlib->filedata); + mainptr->curlib->filedata= 0; + + mainptr= mainptr->next; + } +} + +// ****************** STREAM GLUE READER ********************** + +static int fd_read_from_streambuffer(FileData *filedata, void *buffer, int size) +{ + int readsize = EOF; + int type; + + if (size <= (filedata->inbuffer - filedata->seek)) { + memmove(buffer, filedata->buffer + filedata->seek, size); + filedata->seek += size; + readsize = size; + } else { + // special ENDB handling + if (((filedata->inbuffer - filedata->seek) == 8) && (size > 8)) { + memmove(&type, filedata->buffer + filedata->seek, sizeof(type)); + + if (type == ENDB) { + memmove(buffer, filedata->buffer + filedata->seek, 8); + readsize = 8; + } else { +#ifndef NDEBUG + fprintf(GEN_errorstream, + "Error in fd_read_from_streambuffer\n"); +#endif + } + } else { +#ifndef NDEBUG + fprintf(GEN_errorstream, + "Error in fd_read_from_streambuffer: not enough data available\n"); +#endif + } + } + + return (readsize); +} + +void *blo_readstreamfile_begin(void *endControl) +{ + void **params = endControl; + + FileData *fd = filedata_new(); + fd->read = fd_read_from_streambuffer; + fd->buffersize = 100000; + fd->buffer = MEM_mallocN(fd->buffersize, "Buffer readstreamfile"); + fd->bfd_r = params[0]; + fd->error_r = params[1]; + + return fd; +} + +int blo_readstreamfile_process(void *filedataVoidPtr, unsigned char *data, unsigned int dataIn) +{ + struct FileData *filedata = filedataVoidPtr; + int err = 0; + int size, datasize; + char *newbuffer; + BHead8 bhead8; + BHead4 bhead4; + + // copy everything in the buffer + + if (((int) dataIn + filedata->inbuffer) > filedata->buffersize) { + // do we need a bigger buffer ? + if (((int) dataIn + filedata->inbuffer - filedata->seek) > filedata->buffersize) { + // copy data and ajust settings + filedata->buffersize = dataIn + filedata->inbuffer - filedata->seek; + newbuffer = MEM_mallocN(filedata->buffersize, "readstreamfile newbuffer"); + memmove(newbuffer, filedata->buffer + filedata->seek, filedata->inbuffer - filedata->seek); + MEM_freeN(filedata->buffer); + filedata->buffer = newbuffer; + } else { + // we just move the existing data to the start + // of the block + memmove(filedata->buffer, filedata->buffer + filedata->seek, filedata->inbuffer - filedata->seek); + } + // adjust seek and inbuffer accordingly + filedata->inbuffer -= filedata->seek; + filedata->seek = 0; + } + + memmove(filedata->buffer + filedata->inbuffer, data, dataIn); + filedata->inbuffer += dataIn; + + // OK, so now we have everything in one buffer. What are we + // going to do with it... + + while (1) { + datasize = filedata->inbuffer - filedata->seek; + + if (filedata->headerdone) { + if (filedata->flags & FD_FLAGS_FILE_POINTSIZE_IS_4) { + if (datasize > sizeof(bhead4)) { + datasize -= sizeof(bhead4); + memmove(&bhead4, filedata->buffer + filedata->seek, sizeof(bhead4)); + size = bhead4.len; + } else { + break; + } + } else { + if (datasize > sizeof(bhead8)) { + datasize -= sizeof(bhead8); + memmove(&bhead8, filedata->buffer + filedata->seek, sizeof(bhead8)); + size = bhead8.len; + } else { + break; + } + } + + if (filedata->flags & FD_FLAGS_SWITCH_ENDIAN) { + SWITCH_INT(size); + } + + // do we have enough left in the buffer to read + // in a full bhead + data ? + if (size <= datasize) { + get_bhead(filedata); + } else { + break; + } + + } else { + if (datasize < SIZEOFBLENDERHEADER) { + // still need more data to continue.. + break; + } else { + decode_blender_header(filedata); + filedata->headerdone = 1; + if (! (filedata->flags & FD_FLAGS_FILE_OK)) { + // not a blender file ... ? + err = 1; + break; + } + } + } + } + + return err; +} + +int blo_readstreamfile_end(void *filedataVoidPtr) +{ + struct FileData *fd = filedataVoidPtr; + int err = 1; + + *fd->bfd_r= NULL; + if (!(fd->flags & FD_FLAGS_FILE_OK)) { + *fd->error_r= BRE_NOT_A_BLEND; + } else if ((fd->inbuffer - fd->seek) != 8) { + *fd->error_r= BRE_INCOMPLETE; + } else if (!get_bhead(fd) || !read_file_dna(fd)) { + // ENDB block ! + *fd->error_r= BRE_INCOMPLETE; + } else { + *fd->bfd_r= blo_read_file_internal(fd, fd->error_r); + err = 0; + } + + blo_freefiledata(fd); + + return err; +} diff --git a/source/blender/blenloader/intern/readfile.h b/source/blender/blenloader/intern/readfile.h new file mode 100644 index 00000000000..af0d2f8ff12 --- /dev/null +++ b/source/blender/blenloader/intern/readfile.h @@ -0,0 +1,130 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * blenloader readfile private function prototypes + */ +#ifndef READFILE_H +#define READFILE_H + +struct OldNewMap; + +typedef struct FileData { + // linked list of BHeadN's + ListBase listbase; + int flags; + int eof; + int buffersize; + int seek; + int (*read)(struct FileData *filedata, void *buffer, int size); + + // variables needed for reading from memory / stream + char * buffer; + + // variables needed for reading from file + int filedes; + + // variables needed for reading from stream + char headerdone; + int inbuffer; + + // general reading variables + struct SDNA *filesdna; + struct SDNA *memsdna; + char *compflags; + + int fileversion; + + struct OldNewMap *datamap; + struct OldNewMap *globmap; + struct OldNewMap *libmap; + + ListBase mainlist; + + /* ick ick, used to return + * data through streamglue. + */ + BlendFileData **bfd_r; + BlendReadError *error_r; +} FileData; + +typedef struct BHeadN { + struct BHeadN *next, *prev; + struct BHead bhead; +} BHeadN; + +#define FD_FLAGS_SWITCH_ENDIAN (1<<0) +#define FD_FLAGS_FILE_POINTSIZE_IS_4 (1<<1) +#define FD_FLAGS_POINTSIZE_DIFFERS (1<<2) +#define FD_FLAGS_FILE_OK (1<<3) +#define FD_FLAGS_NOT_MY_BUFFER (1<<4) +#define FD_FLAGS_NOT_MY_LIBMAP (1<<5) + +#define SIZEOFBLENDERHEADER 12 + + /***/ + +void blo_join_main(ListBase *mainlist); +void blo_split_main(ListBase *mainlist); + + BlendFileData* +blo_read_file_internal( + FileData *fd, + BlendReadError *error_r); + + + FileData* +blo_openblenderfile( + char *name); + + FileData* +blo_openblendermemory( + void *buffer, + int buffersize); + + void +blo_freefiledata( + FileData *fd); + + + BHead* +blo_firstbhead( + FileData *fd); + + BHead* +blo_nextbhead( + FileData *fd, + BHead *thisblock); + + BHead* +blo_prevbhead( + FileData *fd, + BHead *thisblock); + +#endif diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c new file mode 100644 index 00000000000..61c933cb005 --- /dev/null +++ b/source/blender/blenloader/intern/writefile.c @@ -0,0 +1,1788 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * .blend file writing + */ + +/* +MIXED MODEL +FILEFORMAAT: IFF-achtige structuur (niet meer IFF compatible!) + +start file: + BLENDER_V100 12 bytes (versie 1.00) + V = big endian, v = little endian + _ = 4 byte pointer, - = 8 byte pointer + +datablokken: zie ook struct BHead + <bh.code> 4 chars + <bh.len> int, len data achter BHead + <bh.old> void, oude pointer + <bh.SDNAnr> int + <bh.nr> int, bij array: aantal structs + data + ... + ... + +Vrijwel alle data in blender zijn structs. Elke struct krijgt +een BHead header mee. Met BHead kan de struktuur weer worden +gelinkt en wordt met StructDNA vergeleken. + +SCHRIJVEN + +Voorkeur volgorde schrijven: (waarschijnlijk mag ook door +elkaar, maar waarom zou je? ) In ieder geval MOET indirekte data +ACHTER LibBlock + +(Locale data) +- voor elk LibBlock + - schrijf LibBlock + - schrijf bijhorende direkte data +(Externe data) +- per library + - schrijf library block + - per LibBlock + - schrijf ID LibBlock +- schrijf FileGlobal (een selectie uit globale data ) +- schrijf SDNA +- schrijf USER als aangegeven (~/.B.blend) +*/ + +#ifndef WIN32 +#include <unistd.h> +#else +#include "winsock2.h" +#include "BLI_winstuff.h" +#include <io.h> +#include <process.h> // for getpid +#endif + +#include <math.h> +#include <fcntl.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include "nla.h" // __NLA is defined + +#include "DNA_packedFile_types.h" +#include "DNA_sdna_types.h" +#include "DNA_property_types.h" +#include "DNA_sensor_types.h" +#include "DNA_controller_types.h" +#include "DNA_actuator_types.h" +#include "DNA_effect_types.h" +#include "DNA_object_types.h" +#include "DNA_userdef_types.h" +#include "DNA_vfont_types.h" +#include "DNA_ipo_types.h" +#include "DNA_curve_types.h" +#include "DNA_camera_types.h" +#include "DNA_meta_types.h" +#include "DNA_mesh_types.h" +#include "DNA_material_types.h" +#include "DNA_lattice_types.h" +#include "DNA_armature_types.h" +#include "DNA_sequence_types.h" +#include "DNA_ika_types.h" +#include "DNA_group_types.h" +#include "DNA_oops_types.h" +#include "DNA_space_types.h" +#include "DNA_screen_types.h" +#include "DNA_view3d_types.h" +#include "DNA_lamp_types.h" +#include "DNA_fileglobal_types.h" +#include "DNA_sound_types.h" +#include "DNA_texture_types.h" +#include "DNA_text_types.h" +#include "DNA_image_types.h" +#include "DNA_key_types.h" +#include "DNA_scene_types.h" +#include "DNA_constraint_types.h" +#include "DNA_listBase.h" /* for Listbase, the type of samples, ...*/ +#include "DNA_action_types.h" +#include "DNA_nla_types.h" + +#include "MEM_guardedalloc.h" // MEM_freeN +#include "BLI_blenlib.h" +#include "BLI_linklist.h" + +#include "BKE_action.h" +#include "BKE_utildefines.h" // for KNOTSU KNOTSV WHILE_SEQ END_SEQ defines +#include "BKE_bad_level_calls.h" // build_seqar (from WHILE_SEQ) free_oops error +#include "BKE_constraint.h" +#include "BKE_main.h" // G.main +#include "BKE_global.h" // for G +#include "BKE_screen.h" // for waitcursor +#include "BKE_packedFile.h" // for packAll +#include "BKE_library.h" // for set_listbasepointers +#include "BKE_sound.h" /* ... and for samples */ + +#include "GEN_messaging.h" + +#include "BLO_writefile.h" +#include "BLO_readfile.h" + +#include "readfile.h" +#include "genfile.h" + +/* ******* MYWRITE ********* */ + +#include "BLO_writeStreamGlue.h" + +/***/ + +typedef struct { + struct SDNA *sdna; + + int file; + unsigned char *buf; + + int tot, count, error; + + int is_publisher; + struct writeStreamGlueStruct *streamGlue; +} WriteData; + +static WriteData *writedata_new(int file, int is_publisher) +{ + extern char DNAstr[]; /* DNA.c */ + extern int DNAlen; + + WriteData *wd= MEM_callocN(sizeof(*wd), "writedata"); + + /* XXX, see note about this in readfile.c, remove + * once we have an xp lock - zr + */ + wd->sdna= dna_sdna_from_data(DNAstr, DNAlen, 0); + + wd->file= file; + wd->is_publisher= is_publisher; + + wd->buf= MEM_mallocN(100000, "wd->buf"); + + return wd; +} + +static void writedata_do_write(WriteData *wd, void *mem, int memlen) +{ + if (wd->error) return; + + if (wd->is_publisher) { + wd->error = writeStreamGlue(Global_streamGlueControl, &wd->streamGlue, mem, memlen, 0); + } else { + if (write(wd->file, mem, memlen) != memlen) + wd->error= 1; + } +} + +static void writedata_free(WriteData *wd) +{ + dna_freestructDNA(wd->sdna); + + MEM_freeN(wd->buf); + MEM_freeN(wd); +} + +/***/ + +struct streamGlueControlStruct *Global_streamGlueControl; +int mywfile; + +#include "license_key.h" + +/** + * Low level WRITE(2) wrapper that buffers data + * @param adr Pointer to new chunk of data + * @param len Length of new chunk of data + * @warning Talks to other functions with global parameters + */ + static void +mywrite( + WriteData *wd, + void *adr, + int len) +{ + if (wd->error) return; + + wd->tot+= len; + + if(len>50000) { + if(wd->count) { + writedata_do_write(wd, wd->buf, wd->count); + wd->count= 0; + } + writedata_do_write(wd, adr, len); + return; + } + if(len+wd->count>99999) { + writedata_do_write(wd, wd->buf, wd->count); + wd->count= 0; + } + memcpy(&wd->buf[wd->count], adr, len); + wd->count+= len; +} + +/** + * BeGiN initializer for mywrite + * @param file File descriptor + * @param write_flags Write parameters + * @warning Talks to other functions with global parameters + */ + static WriteData * +bgnwrite( + int file, + int write_flags) +{ + int is_publisher= ((write_flags & (G_FILE_COMPRESS | G_FILE_LOCK | G_FILE_SIGN | G_FILE_PUBLISH)) && LICENSE_KEY_VALID); + WriteData *wd= writedata_new(file, is_publisher); + + if (is_publisher) { + mywfile= file; + wd->streamGlue = NULL; + Global_streamGlueControl = streamGlueControlConstructor(); + streamGlueControlAppendAction(Global_streamGlueControl, DUMPFROMMEMORY); + if (write_flags & G_FILE_COMPRESS) { + streamGlueControlAppendAction(Global_streamGlueControl, DEFLATE); + } + if (write_flags & G_FILE_LOCK) { + streamGlueControlAppendAction(Global_streamGlueControl, ENCRYPT); + } + if (write_flags & G_FILE_SIGN) { + streamGlueControlAppendAction(Global_streamGlueControl, SIGN); + } + streamGlueControlAppendAction(Global_streamGlueControl, WRITEBLENFILE); + } + + return wd; +} + +/** + * END the mywrite wrapper + * @return 1 if write failed + * @return unknown global variable otherwise + * @warning Talks to other functions with global parameters + */ + static int +endwrite( + WriteData *wd) +{ + int err; + + if (wd->count) { + writedata_do_write(wd, wd->buf, wd->count); + wd->count= 0; + } + if (wd->is_publisher) { + writeStreamGlue(Global_streamGlueControl, &wd->streamGlue, NULL, 0, 1); + streamGlueControlDestructor(Global_streamGlueControl); + // final writestream error handling goes here + if (wd->error) { + int err = wd->error; + int errFunction = BWS_GETFUNCTION(err); + int errGeneric = BWS_GETGENERR(err); + int errSpecific = BWS_GETSPECERR(err); + char *errFunctionStrings[] = { + "", + "The write stream", + "The deflation", + "The encryption", + "The signing", + "Writing the blendfile" + }; + char *errGenericStrings[] = { + "", + "generated an out of memory error", + "is not allowed in this version", + "has problems with your key" + }; + char *errWriteStreamGlueStrings[] = { + "", + "does not know how to proceed" + }; + char *errDeflateStrings[] = { + "", + "bumped on a compress error" + }; + char *errEncryptStrings[] = { + "", + "could not write the key", + "bumped on an encrypt error" + }; + char *errSignStrings[] = { + "", + "could not write the key", + "failed" + }; + char *errWriteBlenFileStrings[] = { + "", + "encountered problems writing the filedescription", + "encountered problems writing the blendfile", + "encountered problems writing one (or more) parameters" + }; + char *errFunctionString= errFunctionStrings[errFunction]; + char *errExtraString= ""; + + if (errGeneric) + { + errExtraString= errGenericStrings[errGeneric]; + } + else if (errSpecific) + { + switch (errFunction) + { + case BWS_WRITESTREAMGLUE: + errExtraString= errWriteStreamGlueStrings[errSpecific]; + break; + case BWS_DEFLATE: + errExtraString= errDeflateStrings[errSpecific]; + break; + case BWS_ENCRYPT: + errExtraString= errEncryptStrings[errSpecific]; + break; + case BWS_SIGN: + errExtraString= errSignStrings[errSpecific]; + break; + case BWS_WRITEBLENFILE: + errExtraString= errWriteBlenFileStrings[errSpecific]; + break; + default: + break; + } + } + + // call Blender error popup window + error("%s %s", errFunctionString, errExtraString); + } + } + + err= wd->error; + writedata_free(wd); + + return err; +} + +/* ********** WRITE FILE ****************** */ + +static void writestruct(WriteData *wd, int filecode, char *structname, int nr, void *adr) +{ + BHead bh; + short *sp; + + if(adr==0 || nr==0) return; + + /* BHead vullen met data */ + bh.code= filecode; + bh.old= adr; + bh.nr= nr; + + bh.SDNAnr= dna_findstruct_nr(wd->sdna, structname); + if(bh.SDNAnr== -1) { + printf("error: can't find SDNA code %s\n", structname); + return; + } + sp= wd->sdna->structs[bh.SDNAnr]; + + bh.len= nr*wd->sdna->typelens[sp[0]]; + + if(bh.len==0) return; + + mywrite(wd, &bh, sizeof(BHead)); + mywrite(wd, adr, bh.len); +} + +static void writedata(WriteData *wd, int filecode, int len, void *adr) /* geen struct */ +{ + BHead bh; + + if(adr==0) return; + if(len==0) return; + + len+= 3; + len-= ( len % 4); + + /* BHead vullen met data */ + bh.code= filecode; + bh.old= adr; + bh.nr= 1; + bh.SDNAnr= 0; + bh.len= len; + + mywrite(wd, &bh, sizeof(BHead)); + if(len) mywrite(wd, adr, len); +} + +static void write_scriptlink(WriteData *wd, ScriptLink *slink) +{ + writedata(wd, DATA, sizeof(void *)*slink->totscript, slink->scripts); + writedata(wd, DATA, sizeof(short)*slink->totscript, slink->flag); +} + +static void write_renderinfo(WriteData *wd) /* alleen voor renderdaemon */ +{ + Scene *sce; + int data[8]; + + sce= G.main->scene.first; + while(sce) { + if(sce->id.lib==0 && ( sce==G.scene || (sce->r.scemode & R_BG_RENDER)) ) { + data[0]= sce->r.sfra; + data[1]= sce->r.efra; + + strncpy((char *)(data+2), sce->id.name+2, 23); + + writedata(wd, REND, 32, data); + } + sce= sce->id.next; + } +} + +static void write_userdef(WriteData *wd) +{ + writestruct(wd, USER, "UserDef", 1, &U); +} + +static void write_effects(WriteData *wd, ListBase *lb) +{ + Effect *eff; + + eff= lb->first; + while(eff) { + + switch(eff->type) { + case EFF_BUILD: + writestruct(wd, DATA, "BuildEff", 1, eff); + break; + case EFF_PARTICLE: + writestruct(wd, DATA, "PartEff", 1, eff); + break; + case EFF_WAVE: + writestruct(wd, DATA, "WaveEff", 1, eff); + break; + default: + writedata(wd, DATA, MEM_allocN_len(eff), eff); + } + + eff= eff->next; + } +} + +static void write_properties(WriteData *wd, ListBase *lb) +{ + bProperty *prop; + + prop= lb->first; + while(prop) { + writestruct(wd, DATA, "bProperty", 1, prop); + + if(prop->poin && prop->poin != &prop->data) + writedata(wd, DATA, MEM_allocN_len(prop->poin), prop->poin); + + prop= prop->next; + } +} + +static void write_sensors(WriteData *wd, ListBase *lb) +{ + bSensor *sens; + + sens= lb->first; + while(sens) { + writestruct(wd, DATA, "bSensor", 1, sens); + + writedata(wd, DATA, sizeof(void *)*sens->totlinks, sens->links); + + switch(sens->type) { + case SENS_NEAR: + writestruct(wd, DATA, "bNearSensor", 1, sens->data); + break; + case SENS_MOUSE: + writestruct(wd, DATA, "bMouseSensor", 1, sens->data); + break; + case SENS_TOUCH: + writestruct(wd, DATA, "bTouchSensor", 1, sens->data); + break; + case SENS_KEYBOARD: + writestruct(wd, DATA, "bKeyboardSensor", 1, sens->data); + break; + case SENS_PROPERTY: + writestruct(wd, DATA, "bPropertySensor", 1, sens->data); + break; + case SENS_COLLISION: + writestruct(wd, DATA, "bCollisionSensor", 1, sens->data); + break; + case SENS_RADAR: + writestruct(wd, DATA, "bRadarSensor", 1, sens->data); + break; + case SENS_RANDOM: + writestruct(wd, DATA, "bRandomSensor", 1, sens->data); + break; + case SENS_RAY: + writestruct(wd, DATA, "bRaySensor", 1, sens->data); + break; + case SENS_MESSAGE: + writestruct(wd, DATA, "bMessageSensor", 1, sens->data); + break; + default: + ; /* error: don't know how to write this file */ + } + + sens= sens->next; + } +} + +static void write_controllers(WriteData *wd, ListBase *lb) +{ + bController *cont; + + cont= lb->first; + while(cont) { + writestruct(wd, DATA, "bController", 1, cont); + + writedata(wd, DATA, sizeof(void *)*cont->totlinks, cont->links); + + switch(cont->type) { + case CONT_EXPRESSION: + writestruct(wd, DATA, "bExpressionCont", 1, cont->data); + break; + case CONT_PYTHON: + writestruct(wd, DATA, "bPythonCont", 1, cont->data); + break; + default: + ; /* error: don't know how to write this file */ + } + + cont= cont->next; + } +} + +static void write_actuators(WriteData *wd, ListBase *lb) +{ + bActuator *act; + + act= lb->first; + while(act) { + writestruct(wd, DATA, "bActuator", 1, act); + + switch(act->type) { + case ACT_ACTION: + writestruct(wd, DATA, "bActionActuator", 1, act->data); + break; + case ACT_SOUND: + writestruct(wd, DATA, "bSoundActuator", 1, act->data); + break; + case ACT_CD: + writestruct(wd, DATA, "bCDActuator", 1, act->data); + break; + case ACT_OBJECT: + writestruct(wd, DATA, "bObjectActuator", 1, act->data); + break; + case ACT_IPO: + writestruct(wd, DATA, "bIpoActuator", 1, act->data); + break; + case ACT_PROPERTY: + writestruct(wd, DATA, "bPropertyActuator", 1, act->data); + break; + case ACT_CAMERA: + writestruct(wd, DATA, "bCameraActuator", 1, act->data); + break; + case ACT_CONSTRAINT: + writestruct(wd, DATA, "bConstraintActuator", 1, act->data); + break; + case ACT_EDIT_OBJECT: + writestruct(wd, DATA, "bEditObjectActuator", 1, act->data); + break; + case ACT_SCENE: + writestruct(wd, DATA, "bSceneActuator", 1, act->data); + break; + case ACT_GROUP: + writestruct(wd, DATA, "bGroupActuator", 1, act->data); + break; + case ACT_RANDOM: + writestruct(wd, DATA, "bRandomActuator", 1, act->data); + break; + case ACT_MESSAGE: + writestruct(wd, DATA, "bMessageActuator", 1, act->data); + break; + case ACT_GAME: + writestruct(wd, DATA, "bGameActuator", 1, act->data); + break; + case ACT_VISIBILITY: + writestruct(wd, DATA, "bVisibilityActuator", 1, act->data); + break; + default: + ; /* error: don't know how to write this file */ + } + + act= act->next; + } +} + +static void write_nlastrips(WriteData *wd, ListBase *nlabase) +{ + bActionStrip *strip; + + for (strip=nlabase->first; strip; strip=strip->next) + writestruct(wd, DATA, "bActionStrip", 1, strip); +} + +static void write_constraints(WriteData *wd, ListBase *conlist) +{ + bConstraint *con; + + for (con=conlist->first; con; con=con->next) { + /* Write the specific data */ + switch (con->type) { + case CONSTRAINT_TYPE_NULL: + break; + case CONSTRAINT_TYPE_TRACKTO: + writestruct(wd, DATA, "bTrackToConstraint", 1, con->data); + break; + case CONSTRAINT_TYPE_KINEMATIC: + writestruct(wd, DATA, "bKinematicConstraint", 1, con->data); + break; + case CONSTRAINT_TYPE_ROTLIKE: + writestruct(wd, DATA, "bRotateLikeConstraint", 1, con->data); + break; + case CONSTRAINT_TYPE_LOCLIKE: + writestruct(wd, DATA, "bLocateLikeConstraint", 1, con->data); + break; + case CONSTRAINT_TYPE_ACTION: + writestruct(wd, DATA, "bActionConstraint", 1, con->data); + break; + default: + break; + } + /* Write the constraint */ + writestruct(wd, DATA, "bConstraint", 1, con); + } +} + +static void write_pose(WriteData *wd, bPose *pose) +{ + bPoseChannel *chan; + + /* Write each channel */ + + if (!pose) + return; + + // Write channels + for (chan=pose->chanbase.first; chan; chan=chan->next) { + write_constraints(wd, &chan->constraints); + writestruct(wd, DATA, "bPoseChannel", 1, chan); + } + + // Write this pose + writestruct(wd, DATA, "bPose", 1, pose); +} + +static void write_defgroups(WriteData *wd, ListBase *defbase) +{ + bDeformGroup *defgroup; + + for (defgroup=defbase->first; defgroup; defgroup=defgroup->next) + writestruct(wd, DATA, "bDeformGroup", 1, defgroup); +} + +static void write_constraint_channels(WriteData *wd, ListBase *chanbase) +{ + bConstraintChannel *chan; + + for (chan = chanbase->first; chan; chan=chan->next) + writestruct(wd, DATA, "bConstraintChannel", 1, chan); + +} + +static void write_objects(WriteData *wd, ListBase *idbase) +{ + Object *ob; + + ob= idbase->first; + while(ob) { + if(ob->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_OB, "Object", 1, ob); + + /* alle direkte data */ + writedata(wd, DATA, sizeof(void *)*ob->totcol, ob->mat); + write_effects(wd, &ob->effect); + write_properties(wd, &ob->prop); + write_sensors(wd, &ob->sensors); + write_controllers(wd, &ob->controllers); + write_actuators(wd, &ob->actuators); + write_scriptlink(wd, &ob->scriptlink); + write_pose(wd, ob->pose); + write_defgroups(wd, &ob->defbase); + write_constraints(wd, &ob->constraints); + write_constraint_channels(wd, &ob->constraintChannels); + write_nlastrips(wd, &ob->nlastrips); + } + ob= ob->id.next; + } +} + + +static void write_vfonts(WriteData *wd, ListBase *idbase) +{ + VFont *vf; + PackedFile * pf; + + vf= idbase->first; + while(vf) { + if(vf->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_VF, "VFont", 1, vf); + + /* alle direkte data */ + + if (vf->packedfile) { + pf = vf->packedfile; + writestruct(wd, DATA, "PackedFile", 1, pf); + writedata(wd, DATA, pf->size, pf->data); + } + } + + vf= vf->id.next; + } +} + +static void write_ipos(WriteData *wd, ListBase *idbase) +{ + Ipo *ipo; + IpoCurve *icu; + + ipo= idbase->first; + while(ipo) { + if(ipo->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_IP, "Ipo", 1, ipo); + + /* alle direkte data */ + icu= ipo->curve.first; + while(icu) { + writestruct(wd, DATA, "IpoCurve", 1, icu); + icu= icu->next; + } + + icu= ipo->curve.first; + while(icu) { + if(icu->bezt) writestruct(wd, DATA, "BezTriple", icu->totvert, icu->bezt); + if(icu->bp) writestruct(wd, DATA, "BPoint", icu->totvert, icu->bp); + icu= icu->next; + } + } + + ipo= ipo->id.next; + } +} + +static void write_keys(WriteData *wd, ListBase *idbase) +{ + Key *key; + KeyBlock *kb; + + key= idbase->first; + while(key) { + if(key->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_KE, "Key", 1, key); + + /* alle direkte data */ + kb= key->block.first; + while(kb) { + writestruct(wd, DATA, "KeyBlock", 1, kb); + if(kb->data) writedata(wd, DATA, kb->totelem*key->elemsize, kb->data); + kb= kb->next; + } + } + + key= key->id.next; + } +} + +static void write_cameras(WriteData *wd, ListBase *idbase) +{ + Camera *cam; + + cam= idbase->first; + while(cam) { + if(cam->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_CA, "Camera", 1, cam); + + /* alle direkte data */ + write_scriptlink(wd, &cam->scriptlink); + } + + cam= cam->id.next; + } +} + +static void write_mballs(WriteData *wd, ListBase *idbase) +{ + MetaBall *mb; + MetaElem *ml; + + mb= idbase->first; + while(mb) { + if(mb->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_MB, "MetaBall", 1, mb); + + /* alle direkte data */ + writedata(wd, DATA, sizeof(void *)*mb->totcol, mb->mat); + + ml= mb->elems.first; + while(ml) { + writestruct(wd, DATA, "MetaElem", 1, ml); + ml= ml->next; + } + } + mb= mb->id.next; + } +} + +static void write_curves(WriteData *wd, ListBase *idbase) +{ + Curve *cu; + Nurb *nu; + + cu= idbase->first; + while(cu) { + if(cu->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_CU, "Curve", 1, cu); + + /* alle direkte data */ + writedata(wd, DATA, sizeof(void *)*cu->totcol, cu->mat); + + if(cu->vfont) { + writedata(wd, DATA, cu->len+1, cu->str); + } + else { + /* is ook volgorde van inlezen */ + nu= cu->nurb.first; + while(nu) { + writestruct(wd, DATA, "Nurb", 1, nu); + nu= nu->next; + } + nu= cu->nurb.first; + while(nu) { + if( (nu->type & 7)==CU_BEZIER) + writestruct(wd, DATA, "BezTriple", nu->pntsu, nu->bezt); + else { + writestruct(wd, DATA, "BPoint", nu->pntsu*nu->pntsv, nu->bp); + if(nu->knotsu) writedata(wd, DATA, KNOTSU(nu)*sizeof(float), nu->knotsu); + if(nu->knotsv) writedata(wd, DATA, KNOTSV(nu)*sizeof(float), nu->knotsv); + } + nu= nu->next; + } + } + } + cu= cu->id.next; + } +} + +static void write_dverts(WriteData *wd, int count, MDeformVert *dvlist) +{ + int i; + + /* Write the dvert list */ + writestruct(wd, DATA, "MDeformVert", count, dvlist); + + /* Write deformation data for each dvert */ + if (dvlist) { + for (i=0; i<count; i++) { + if (dvlist[i].dw) + writestruct(wd, DATA, "MDeformWeight", dvlist[i].totweight, dvlist[i].dw); + } + } +} + +static void write_meshs(WriteData *wd, ListBase *idbase) +{ + Mesh *mesh; + + mesh= idbase->first; + while(mesh) { + if(mesh->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_ME, "Mesh", 1, mesh); + + /* alle direkte data */ + writedata(wd, DATA, sizeof(void *)*mesh->totcol, mesh->mat); + writestruct(wd, DATA, "MVert", mesh->totvert, mesh->mvert); + write_dverts(wd, mesh->totvert, mesh->dvert); + writestruct(wd, DATA, "MFace", mesh->totface, mesh->mface); + writestruct(wd, DATA, "TFace", mesh->totface, mesh->tface); + writestruct(wd, DATA, "MCol", 4*mesh->totface, mesh->mcol); + writestruct(wd, DATA, "MSticky", mesh->totvert, mesh->msticky); + + } + mesh= mesh->id.next; + } +} + +static void write_images(WriteData *wd, ListBase *idbase) +{ + Image *ima; + PackedFile * pf; + + ima= idbase->first; + while(ima) { + if(ima->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_IM, "Image", 1, ima); + + if (ima->packedfile) { + pf = ima->packedfile; + writestruct(wd, DATA, "PackedFile", 1, pf); + writedata(wd, DATA, pf->size, pf->data); + } + } + ima= ima->id.next; + } +} + +static void write_textures(WriteData *wd, ListBase *idbase) +{ + Tex *tex; + + tex= idbase->first; + while(tex) { + if(tex->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_TE, "Tex", 1, tex); + + /* alle direkte data */ + if(tex->plugin) writestruct(wd, DATA, "PluginTex", 1, tex->plugin); + if(tex->coba) writestruct(wd, DATA, "ColorBand", 1, tex->coba); + if(tex->env) writestruct(wd, DATA, "EnvMap", 1, tex->env); + } + tex= tex->id.next; + } +} + +static void write_materials(WriteData *wd, ListBase *idbase) +{ + Material *ma; + int a; + + ma= idbase->first; + while(ma) { + if(ma->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_MA, "Material", 1, ma); + + for(a=0; a<8; a++) { + if(ma->mtex[a]) writestruct(wd, DATA, "MTex", 1, ma->mtex[a]); + } + + write_scriptlink(wd, &ma->scriptlink); + } + ma= ma->id.next; + } +} + +static void write_worlds(WriteData *wd, ListBase *idbase) +{ + World *wrld; + int a; + + wrld= idbase->first; + while(wrld) { + if(wrld->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_WO, "World", 1, wrld); + + for(a=0; a<8; a++) { + if(wrld->mtex[a]) writestruct(wd, DATA, "MTex", 1, wrld->mtex[a]); + } + + write_scriptlink(wd, &wrld->scriptlink); + } + wrld= wrld->id.next; + } +} + +static void write_lamps(WriteData *wd, ListBase *idbase) +{ + Lamp *la; + int a; + + la= idbase->first; + while(la) { + if(la->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_LA, "Lamp", 1, la); + + /* alle direkte data */ + for(a=0; a<8; a++) { + if(la->mtex[a]) writestruct(wd, DATA, "MTex", 1, la->mtex[a]); + } + + write_scriptlink(wd, &la->scriptlink); + } + la= la->id.next; + } +} + +static void write_lattices(WriteData *wd, ListBase *idbase) +{ + Lattice *lt; + + lt= idbase->first; + while(lt) { + if(lt->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_LT, "Lattice", 1, lt); + + /* alle direkte data */ + writestruct(wd, DATA, "BPoint", lt->pntsu*lt->pntsv*lt->pntsw, lt->def); + } + lt= lt->id.next; + } +} + +static void write_ikas(WriteData *wd, ListBase *idbase) +{ + Ika *ika; + Limb *li; + + ika= idbase->first; + while(ika) { + if(ika->id.us>0) { + /* schrijf LibData */ + writestruct(wd, ID_IK, "Ika", 1, ika); + + /* alle direkte data */ + li= ika->limbbase.first; + while(li) { + writestruct(wd, DATA, "Limb", 1, li); + li= li->next; + } + + writestruct(wd, DATA, "Deform", ika->totdef, ika->def); + } + ika= ika->id.next; + } +} + +static void write_scenes(WriteData *wd, ListBase *scebase) +{ + Scene *sce; + Base *base; + Editing *ed; + Sequence *seq; + Strip *strip; + + sce= scebase->first; + while(sce) { + /* schrijf LibData */ + writestruct(wd, ID_SCE, "Scene", 1, sce); + + /* alle direkte data */ + base= sce->base.first; + while(base) { + writestruct(wd, DATA, "Base", 1, base); + base= base->next; + } + + writestruct(wd, DATA, "Radio", 1, sce->radio); + writestruct(wd, DATA, "FreeCamera", 1, sce->fcam); + + ed= sce->ed; + if(ed) { + writestruct(wd, DATA, "Editing", 1, ed); + + /* ook schrijfflags op nul */ + WHILE_SEQ(&ed->seqbase) { + if(seq->strip) seq->strip->done= 0; + writestruct(wd, DATA, "Sequence", 1, seq); + } + END_SEQ + + WHILE_SEQ(&ed->seqbase) { + if(seq->strip && seq->strip->done==0) { + /* strip wegschrijven met done op 0 ivm readfile */ + + if(seq->plugin) writestruct(wd, DATA, "PluginSeq", 1, seq->plugin); + + strip= seq->strip; + writestruct(wd, DATA, "Strip", 1, strip); + + if(seq->type==SEQ_IMAGE) + writestruct(wd, DATA, "StripElem", strip->len, strip->stripdata); + else if(seq->type==SEQ_MOVIE) + writestruct(wd, DATA, "StripElem", 1, strip->stripdata); + + strip->done= 1; + } + } + END_SEQ + } + + write_scriptlink(wd, &sce->scriptlink); + + if (sce->r.avicodecdata) { + writestruct(wd, DATA, "AviCodecData", 1, sce->r.avicodecdata); + if (sce->r.avicodecdata->lpFormat) writedata(wd, DATA, sce->r.avicodecdata->cbFormat, sce->r.avicodecdata->lpFormat); + if (sce->r.avicodecdata->lpParms) writedata(wd, DATA, sce->r.avicodecdata->cbParms, sce->r.avicodecdata->lpParms); + } + + sce= sce->id.next; + } +} + +static void write_screens(WriteData *wd, ListBase *scrbase) +{ + bScreen *sc; + ScrArea *sa; + ScrVert *sv; + ScrEdge *se; + + sc= scrbase->first; + while(sc) { + /* schrijf LibData */ + writestruct(wd, ID_SCR, "Screen", 1, sc); + + /* alle direkte data */ + sv= sc->vertbase.first; + while(sv) { + writestruct(wd, DATA, "ScrVert", 1, sv); + sv= sv->next; + } + + se= sc->edgebase.first; + while(se) { + writestruct(wd, DATA, "ScrEdge", 1, se); + se= se->next; + } + + sa= sc->areabase.first; + while(sa) { + SpaceLink *sl; + + writestruct(wd, DATA, "ScrArea", 1, sa); + + sl= sa->spacedata.first; + while(sl) { + if(sl->spacetype==SPACE_VIEW3D) { + View3D *v3d= (View3D*) sl; + writestruct(wd, DATA, "View3D", 1, v3d); + if(v3d->bgpic) writestruct(wd, DATA, "BGpic", 1, v3d->bgpic); + if(v3d->localvd) writestruct(wd, DATA, "View3D", 1, v3d->localvd); + } + else if(sl->spacetype==SPACE_IPO) { + writestruct(wd, DATA, "SpaceIpo", 1, sl); + } + else if(sl->spacetype==SPACE_BUTS) { + writestruct(wd, DATA, "SpaceButs", 1, sl); + } + else if(sl->spacetype==SPACE_FILE) { + writestruct(wd, DATA, "SpaceFile", 1, sl); + } + else if(sl->spacetype==SPACE_SEQ) { + writestruct(wd, DATA, "SpaceSeq", 1, sl); + } + else if(sl->spacetype==SPACE_OOPS) { + SpaceOops *so= (SpaceOops *)sl; + Oops *oops; + + /* cleanup */ + oops= so->oops.first; + while(oops) { + Oops *oopsn= oops->next; + if(oops->id==0) { + BLI_remlink(&so->oops, oops); + free_oops(oops); + } + oops= oopsn; + } + + /* NA de cleanup, ivm listbase! */ + writestruct(wd, DATA, "SpaceOops", 1, so); + + oops= so->oops.first; + while(oops) { + writestruct(wd, DATA, "Oops", 1, oops); + oops= oops->next; + } + } + else if(sl->spacetype==SPACE_IMAGE) { + writestruct(wd, DATA, "SpaceImage", 1, sl); + } + else if(sl->spacetype==SPACE_IMASEL) { + writestruct(wd, DATA, "SpaceImaSel", 1, sl); + } + else if(sl->spacetype==SPACE_TEXT) { + writestruct(wd, DATA, "SpaceText", 1, sl); + } + else if(sl->spacetype==SPACE_ACTION) { + writestruct(wd, DATA, "SpaceAction", 1, sl); + } + else if(sl->spacetype==SPACE_SOUND) { + writestruct(wd, DATA, "SpaceSound", 1, sl); + } + else if(sl->spacetype==SPACE_NLA){ + writestruct(wd, DATA, "SpaceNla", 1, sl); + } + sl= sl->next; + } + + sa= sa->next; + } + + sc= sc->id.next; + } +} + +static void write_libraries(WriteData *wd, Main *main) +{ + ListBase *lbarray[30]; + ID *id; + int a, tot, foundone; + + while(main) { + + a=tot= set_listbasepointers(main, lbarray); + + /* test: wordt lib nog gebruikt */ + foundone= 0; + while(tot--) { + id= lbarray[tot]->first; + while(id) { + if(id->us>0 && (id->flag & LIB_EXTERN)) { + foundone= 1; + break; + } + id= id->next; + } + if(foundone) break; + } + + if(foundone) { + writestruct(wd, ID_LI, "Library", 1, main->curlib); + + while(a--) { + id= lbarray[a]->first; + while(id) { + if(id->us>0 && (id->flag & LIB_EXTERN)) { + + writestruct(wd, ID_ID, "ID", 1, id); + } + id= id->next; + } + } + } + + main= main->next; + } +} + +static void write_bone(WriteData *wd, Bone* bone) +{ + Bone* cbone; + +// write_constraints(wd, &bone->constraints); + + // Write this bone + writestruct(wd, DATA, "Bone", 1, bone); + + // Write Children + cbone= bone->childbase.first; + while(cbone) { + write_bone(wd, cbone); + cbone= cbone->next; + } +} + +static void write_armatures(WriteData *wd, ListBase *idbase) +{ + bArmature *arm; + Bone *bone; + + arm=idbase->first; + while (arm) { + if (arm->id.us>0) { + writestruct(wd, ID_AR, "bArmature", 1, arm); + + /* Direct data */ + bone= arm->bonebase.first; + while(bone) { + write_bone(wd, bone); + bone=bone->next; + } + } + arm=arm->id.next; + } +} + +static void write_actions(WriteData *wd, ListBase *idbase) +{ + bAction *act; + bActionChannel *chan; + act=idbase->first; + while (act) { + if (act->id.us>0) { + writestruct(wd, ID_AC, "bAction", 1, act); + + for (chan=act->chanbase.first; chan; chan=chan->next) { + writestruct(wd, DATA, "bActionChannel", 1, chan); + write_constraint_channels(wd, &chan->constraintChannels); + } + } + act=act->id.next; + } +} + +static void write_texts(WriteData *wd, ListBase *idbase) +{ + Text *text; + TextLine *tmp; + + text= idbase->first; + while(text) { + if ( (text->flags & TXT_ISMEM) && (text->flags & TXT_ISEXT)) text->flags &= ~TXT_ISEXT; + + /* write LibData */ + writestruct(wd, ID_TXT, "Text", 1, text); + if(text->name) writedata(wd, DATA, strlen(text->name)+1, text->name); + + if(!(text->flags & TXT_ISEXT)) { + /* now write the text data, in two steps for optimization in the readfunction */ + tmp= text->lines.first; + while (tmp) { + writestruct(wd, DATA, "TextLine", 1, tmp); + tmp= tmp->next; + } + + tmp= text->lines.first; + while (tmp) { + writedata(wd, DATA, tmp->len+1, tmp->line); + tmp= tmp->next; + } + } + text= text->id.next; + } +} + +static void write_sounds(WriteData *wd, ListBase *idbase) +{ + bSound *sound; + bSample *sample; + + PackedFile * pf; + + // set all samples to unsaved status + + sample = samples->first; + while (sample) { + sample->flags |= SAMPLE_NEEDS_SAVE; + sample = sample->id.next; + } + + sound= idbase->first; + while(sound) { + if(sound->id.us>0) { + // do we need to save the packedfile as well ? + sample = sound->sample; + if (sample) { + if (sample->flags & SAMPLE_NEEDS_SAVE) { + sound->newpackedfile = sample->packedfile; + sample->flags &= ~SAMPLE_NEEDS_SAVE; + } else { + sound->newpackedfile = NULL; + } + } + + /* write LibData */ + writestruct(wd, ID_SO, "bSound", 1, sound); + + if (sound->newpackedfile) { + pf = sound->newpackedfile; + writestruct(wd, DATA, "PackedFile", 1, pf); + writedata(wd, DATA, pf->size, pf->data); + } + + if (sample) { + sound->newpackedfile = sample->packedfile; + } + } + sound= sound->id.next; + } +} + +static void write_groups(WriteData *wd, ListBase *idbase) +{ + Group *group; + GroupKey *gk; + GroupObject *go; + ObjectKey *ok; + + group= idbase->first; + while(group) { + if(group->id.us>0) { + /* write LibData */ + writestruct(wd, ID_GR, "Group", 1, group); + + gk= group->gkey.first; + while(gk) { + writestruct(wd, DATA, "GroupKey", 1, gk); + gk= gk->next; + } + + go= group->gobject.first; + while(go) { + writestruct(wd, DATA, "GroupObject", 1, go); + go= go->next; + } + go= group->gobject.first; + while(go) { + ok= go->okey.first; + while(ok) { + writestruct(wd, DATA, "ObjectKey", 1, ok); + ok= ok->next; + } + go= go->next; + } + + } + group= group->id.next; + } +} + +static void write_global(WriteData *wd) +{ + FileGlobal fg; + + fg.curscreen= G.curscreen; + fg.displaymode= R.displaymode; + fg.winpos= R.winpos; + fg.fileflags= G.fileflags; + + writestruct(wd, GLOB, "FileGlobal", 1, &fg); +} + +static int write_file_handle(int handle, int write_user_block, int write_flags) +{ + ListBase mainlist; + char buf[13]; + WriteData *wd; + int data; + + mainlist.first= mainlist.last= G.main; + G.main->next= NULL; + + blo_split_main(&mainlist); + + wd= bgnwrite(handle, write_flags); + + sprintf(buf, "BLENDER%c%c%.3d", (sizeof(void*)==8)?'-':'_', (G.order==B_ENDIAN)?'V':'v', G.version); + mywrite(wd, buf, 12); + + write_renderinfo(wd); + + write_screens (wd, &G.main->screen); + write_scenes (wd, &G.main->scene); + write_objects (wd, &G.main->object); + write_meshs (wd, &G.main->mesh); + write_curves (wd, &G.main->curve); + write_mballs (wd, &G.main->mball); + write_materials(wd, &G.main->mat); + write_textures (wd, &G.main->tex); + write_images (wd, &G.main->image); + write_cameras (wd, &G.main->camera); + write_lamps (wd, &G.main->lamp); + write_lattices (wd, &G.main->latt); + write_ikas (wd, &G.main->ika); + write_vfonts (wd, &G.main->vfont); + write_ipos (wd, &G.main->ipo); + write_keys (wd, &G.main->key); + write_worlds (wd, &G.main->world); + write_texts (wd, &G.main->text); + write_sounds (wd, &G.main->sound); + write_groups (wd, &G.main->group); + write_armatures(wd, &G.main->armature); + write_actions (wd, &G.main->action); + write_libraries(wd, G.main->next); + + write_global(wd); + if (write_user_block) { + write_userdef(wd); + } + + /* dna als laatste i.v.m. (nog te schrijven) test op welke gebruikt zijn */ + writedata(wd, DNA1, wd->sdna->datalen, wd->sdna->data); + + data= ENDB; + mywrite(wd, &data, 4); + + data= 0; + mywrite(wd, &data, 4); + + blo_join_main(&mainlist); + G.main= mainlist.first; + + return endwrite(wd); +} + +int BLO_write_file(char *dir, int write_flags, char **error_r) +{ + char userfilename[FILE_MAXDIR+FILE_MAXFILE]; + char tempname[FILE_MAXDIR+FILE_MAXFILE]; + int file, fout, write_user_block; + + sprintf(tempname, "%s@", dir); + + file = open(tempname,O_BINARY+O_WRONLY+O_CREAT+O_TRUNC, 0666); + if(file == -1) { + *error_r= "Unable to open"; + return 0; + } + + BLI_make_file_string(G.sce, userfilename, BLI_gethome(), ".B.blend"); + write_user_block= BLI_streq(dir, userfilename); + + fout= write_file_handle(file, write_user_block, write_flags); + close(file); + + if(!fout) { + if(BLI_rename(tempname, dir) < 0) { + *error_r= "Can't change old file. File saved with @"; + return 0; + } + } else { + remove(tempname); + + *error_r= "Not enough diskspace"; + return 0; + } + + return 1; +} + + /* Runtime writing */ + +#ifdef WIN32 +#define PATHSEPERATOR "\\" +#else +#define PATHSEPERATOR "/" +#endif + +static char *get_install_dir(void) { + extern char bprogname[]; + char *tmpname = BLI_strdup(bprogname); + char *cut; + +#ifdef __APPLE__ + cut = strstr(tmpname, ".app"); + if (cut) cut[0] = 0; +#endif + + cut = BLI_last_slash(tmpname); + + if (cut) { + cut[0] = 0; + return tmpname; + } else { + MEM_freeN(tmpname); + return NULL; + } +} + +static char *get_runtime_path(char *exename) { + char *installpath= get_install_dir(); + + if (!installpath) { + return NULL; + } else { + char *path= MEM_mallocN(strlen(installpath)+strlen(PATHSEPERATOR)+strlen(exename)+1, "runtimepath"); + strcpy(path, installpath); + strcat(path, PATHSEPERATOR); + strcat(path, exename); + + MEM_freeN(installpath); + + return path; + } +} + +#ifdef __APPLE__ + +static int recursive_copy_runtime(char *outname, char *exename, char **cause_r) { + char *cause = NULL, *runtime = get_runtime_path(exename); + char command[2 * (FILE_MAXDIR+FILE_MAXFILE) + 32]; + int progfd = -1; + + if (!runtime) { + cause= "Unable to find runtime"; + goto cleanup; + } + + progfd= open(runtime, O_BINARY|O_RDONLY, 0); + if (progfd==-1) { + cause= "Unable to find runtime"; + goto cleanup; + } + + sprintf(command, "/bin/cp -R %s %s", runtime, outname); + if (system(command) == -1) { + cause = "Couldn't copy runtime"; + } + +cleanup: + if (progfd!=-1) + close(progfd); + if (runtime) + MEM_freeN(runtime); + + if (cause) { + *cause_r= cause; + return 0; + } else + return 1; +} + +void BLO_write_runtime(char *file, char *exename) { + char gamename[FILE_MAXDIR+FILE_MAXFILE]; + int outfd = -1; + char *cause= NULL; + + // remove existing file / bundle + BLI_delete(file, NULL, TRUE); + + if (!recursive_copy_runtime(file, exename, &cause)) + goto cleanup; + + strcpy(gamename, file); + strcat(gamename, "/Contents/Resources/game.blend"); + + outfd= open(gamename, O_BINARY|O_WRONLY|O_CREAT|O_TRUNC, 0777); + if (outfd != -1) { + + /* Ensure runtime's are built with Publisher files */ + write_file_handle(outfd, 0, G.fileflags|G_FILE_PUBLISH); + + if (write(outfd, " ", 1) != 1) { + cause= "Unable to write to output file"; + goto cleanup; + } + } else { + cause = "Unable to open blenderfile"; + } + +cleanup: + if (outfd!=-1) + close(outfd); + + if (cause) + error("Unable to make runtime: %s", cause); +} + +#else !__APPLE__ + +static int handle_append_runtime(int handle, char *exename, char **cause_r) { + char *cause= NULL, *runtime= get_runtime_path(exename); + unsigned char buf[1024]; + int count, progfd= -1; + + if (!runtime) { + cause= "Unable to find runtime"; + goto cleanup; + } + + progfd= open(runtime, O_BINARY|O_RDONLY, 0); + if (progfd==-1) { + cause= "Unable to find runtime"; + goto cleanup; + } + + while ((count= read(progfd, buf, sizeof(buf)))>0) { + if (write(handle, buf, count)!=count) { + cause= "Unable to write to output file"; + goto cleanup; + } + } + +cleanup: + if (progfd!=-1) + close(progfd); + if (runtime) + MEM_freeN(runtime); + + if (cause) { + *cause_r= cause; + return 0; + } else + return 1; +} + +static int handle_write_msb_int(int handle, int i) { + unsigned char buf[4]; + buf[0]= (i>>24)&0xFF; + buf[1]= (i>>16)&0xFF; + buf[2]= (i>>8)&0xFF; + buf[3]= (i>>0)&0xFF; + + return (write(handle, buf, 4)==4); +} + +void BLO_write_runtime(char *file, char *exename) { + int outfd= open(file, O_BINARY|O_WRONLY|O_CREAT|O_TRUNC, 0777); + char *cause= NULL; + int datastart; + + if (!outfd) { + cause= "Unable to open output file"; + goto cleanup; + } + if (!handle_append_runtime(outfd, exename, &cause)) + goto cleanup; + + datastart= lseek(outfd, 0, SEEK_CUR); + + /* Ensure runtime's are built with Publisher files */ + write_file_handle(outfd, 0, G.fileflags|G_FILE_PUBLISH); + + if (!handle_write_msb_int(outfd, datastart) || (write(outfd, "BRUNTIME", 8)!=8)) { + cause= "Unable to write to output file"; + goto cleanup; + } + +cleanup: + if (outfd!=-1) + close(outfd); + + if (cause) + error("Unable to make runtime: %s", cause); +} + +#endif // !__APPLE__ |