diff options
Diffstat (limited to 'source/blender/makesrna')
-rw-r--r-- | source/blender/makesrna/Makefile | 31 | ||||
-rw-r--r-- | source/blender/makesrna/RNA_access.h | 75 | ||||
-rw-r--r-- | source/blender/makesrna/RNA_define.h | 96 | ||||
-rw-r--r-- | source/blender/makesrna/RNA_types.h | 247 | ||||
-rw-r--r-- | source/blender/makesrna/SConscript | 11 | ||||
-rw-r--r-- | source/blender/makesrna/intern/Makefile | 79 | ||||
-rw-r--r-- | source/blender/makesrna/intern/SConscript | 49 | ||||
-rw-r--r-- | source/blender/makesrna/intern/makesrna.c | 780 | ||||
-rw-r--r-- | source/blender/makesrna/intern/rna_access.c | 411 | ||||
-rw-r--r-- | source/blender/makesrna/intern/rna_define.c | 847 | ||||
-rw-r--r-- | source/blender/makesrna/intern/rna_internal.h | 94 | ||||
-rw-r--r-- | source/blender/makesrna/intern/rna_object.c | 52 | ||||
-rw-r--r-- | source/blender/makesrna/intern/rna_scene.c | 115 |
13 files changed, 2887 insertions, 0 deletions
diff --git a/source/blender/makesrna/Makefile b/source/blender/makesrna/Makefile new file mode 100644 index 00000000000..bed3e85550d --- /dev/null +++ b/source/blender/makesrna/Makefile @@ -0,0 +1,31 @@ +# +# $Id$ +# +# ***** BEGIN GPL 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. +# +# 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. +# +# Contributor(s): Blender Foundation (2008). +# +# ***** END GPL LICENSE BLOCK ***** +# +# This module does not build normal .o's, but a RNA.c file, to be +# compiled with the rest of the sources. +# + +SOURCEDIR = source/blender/makesrna +DIRS = intern + +include nan_subdirs.mk diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h new file mode 100644 index 00000000000..828bcff82b1 --- /dev/null +++ b/source/blender/makesrna/RNA_access.h @@ -0,0 +1,75 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef RNA_ACCESS +#define RNA_ACCESS + +struct bContext; +struct BlenderRNA; +struct PropertyRNA; +struct StructRNA; +struct CollectionPropertyIterator; + +/* Property */ + +void RNA_property_notify(struct PropertyRNA *prop, struct bContext *C, void *data); +int RNA_property_readonly(struct PropertyRNA *prop, struct bContext *C, void *data); + +int RNA_property_boolean_get(struct PropertyRNA *prop, void *data); +void RNA_property_boolean_set(struct PropertyRNA *prop, void *data, int value); +int RNA_property_boolean_get_array(struct PropertyRNA *prop, void *data, int index); +void RNA_property_boolean_set_array(struct PropertyRNA *prop, void *data, int index, int value); + +int RNA_property_int_get(struct PropertyRNA *prop, void *data); +void RNA_property_int_set(struct PropertyRNA *prop, void *data, int value); +int RNA_property_int_get_array(struct PropertyRNA *prop, void *data, int index); +void RNA_property_int_set_array(struct PropertyRNA *prop, void *data, int index, int value); + +float RNA_property_float_get(struct PropertyRNA *prop, void *data); +void RNA_property_float_set(struct PropertyRNA *prop, void *data, float value); +float RNA_property_float_get_array(struct PropertyRNA *prop, void *data, int index); +void RNA_property_float_set_array(struct PropertyRNA *prop, void *data, int index, float value); + +void RNA_property_string_get(struct PropertyRNA *prop, void *data, char *value); +int RNA_property_string_length(struct PropertyRNA *prop, void *data); +void RNA_property_string_set(struct PropertyRNA *prop, void *data, const char *value); + +int RNA_property_enum_get(struct PropertyRNA *prop, void *data); +void RNA_property_enum_set(struct PropertyRNA *prop, void *data, int value); + +void *RNA_property_pointer_get(struct PropertyRNA *prop, void *data); +void RNA_property_pointer_set(struct PropertyRNA *prop, void *data, void *value); +struct StructRNA *RNA_property_pointer_type(struct PropertyRNA *prop, void *data); + +void RNA_property_collection_begin(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter, void *data); +void RNA_property_collection_next(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter); +void RNA_property_collection_end(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter); +void *RNA_property_collection_get(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter); +struct StructRNA *RNA_property_collection_type(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter); +int RNA_property_collection_length(struct PropertyRNA *prop, void *data); +void *RNA_property_collection_lookup_int(struct PropertyRNA *prop, void *data, int key, struct StructRNA **type); +void *RNA_property_collection_lookup_string(struct PropertyRNA *prop, void *data, const char *key, struct StructRNA **type); + +#endif /* RNA_ACCESS */ + diff --git a/source/blender/makesrna/RNA_define.h b/source/blender/makesrna/RNA_define.h new file mode 100644 index 00000000000..0eb96da4d1f --- /dev/null +++ b/source/blender/makesrna/RNA_define.h @@ -0,0 +1,96 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef RNA_DEFINE_H +#define RNA_DEFINE_H + +/* Functions used during preprocess, for defining the RNA. + * + * This is currently only used internally in the module, but should eventually + * also become available outside of that, at runtime for python and plugins. + * Where the result of such runtime RNA is stored and how it integrates needs + * to be figured out still. */ + +#include "DNA_listBase.h" + +struct BlenderRNA; +struct StructRNA; +struct PropertyRNA; +struct PropertyEnumItem; + +/* Blender RNA */ + +struct BlenderRNA *RNA_create(void); +void RNA_define_free(struct BlenderRNA *brna); +void RNA_free(struct BlenderRNA *brna); + +/* Struct */ + +struct StructRNA *RNA_def_struct(struct BlenderRNA *brna, const char *cname, const char *name); +void RNA_def_struct_sdna(struct StructRNA *rna, const char *structname); +void RNA_def_struct_name_property(struct StructRNA *rna, struct PropertyRNA *prop); + +/* Property */ + +struct PropertyRNA *RNA_def_property(struct StructRNA *strct, const char *cname, int type, int subtype); + +void RNA_def_property_boolean_sdna(struct PropertyRNA *prop, const char *structname, const char *propname, int bit); +void RNA_def_property_int_sdna(struct PropertyRNA *prop, const char *structname, const char *propname); +void RNA_def_property_float_sdna(struct PropertyRNA *prop, const char *structname, const char *propname); +void RNA_def_property_string_sdna(struct PropertyRNA *prop, const char *structname, const char *propname); +void RNA_def_property_enum_sdna(struct PropertyRNA *prop, const char *structname, const char *propname); +void RNA_def_property_pointer_sdna(struct PropertyRNA *prop, const char *structname, const char *propname); +void RNA_def_property_collection_sdna(struct PropertyRNA *prop, const char *structname, const char *propname); + +void RNA_def_property_array(struct PropertyRNA *prop, int arraylength); +void RNA_def_property_access(struct PropertyRNA *prop, int editable, int evaluatable); +void RNA_def_property_range(struct PropertyRNA *prop, double min, double max); + +void RNA_def_property_enum_items(struct PropertyRNA *prop, const struct PropertyEnumItem *item); +void RNA_def_property_string_maxlength(struct PropertyRNA *prop, int maxlength); +void RNA_def_property_struct_type(struct PropertyRNA *prop, const char *type); + +void RNA_def_property_boolean_default(struct PropertyRNA *prop, int value); +void RNA_def_property_boolean_array_default(struct PropertyRNA *prop, const int *array); +void RNA_def_property_int_default(struct PropertyRNA *prop, int value); +void RNA_def_property_int_array_default(struct PropertyRNA *prop, const int *array); +void RNA_def_property_float_default(struct PropertyRNA *prop, float value); +void RNA_def_property_float_array_default(struct PropertyRNA *prop, const float *array); +void RNA_def_property_enum_default(struct PropertyRNA *prop, int value); +void RNA_def_property_string_default(struct PropertyRNA *prop, const char *value); + +void RNA_def_property_ui_text(struct PropertyRNA *prop, const char *name, const char *description); +void RNA_def_property_ui_range(struct PropertyRNA *prop, double min, double max, double step, double precision); + +void RNA_def_property_funcs(struct PropertyRNA *prop, char *notify, char *readonly); +void RNA_def_property_boolean_funcs(struct PropertyRNA *prop, char *get, char *set); +void RNA_def_property_int_funcs(struct PropertyRNA *prop, char *get, char *set); +void RNA_def_property_float_funcs(struct PropertyRNA *prop, char *get, char *set); +void RNA_def_property_enum_funcs(struct PropertyRNA *prop, char *get, char *set); +void RNA_def_property_string_funcs(struct PropertyRNA *prop, char *get, char *length, char *set); +void RNA_def_property_pointer_funcs(struct PropertyRNA *prop, char *get, char *type, char *set); +void RNA_def_property_collection_funcs(struct PropertyRNA *prop, char *begin, char *next, char *end, char *get, char *type, char *length, char *lookupint, char *lookupstring); + +#endif /* RNA_DEFINE_H */ + diff --git a/source/blender/makesrna/RNA_types.h b/source/blender/makesrna/RNA_types.h new file mode 100644 index 00000000000..9faa8b2fd8e --- /dev/null +++ b/source/blender/makesrna/RNA_types.h @@ -0,0 +1,247 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef RNA_TYPES +#define RNA_TYPES + +#include "DNA_listBase.h" + +struct BlenderRNA; +struct StructRNA; +struct PropertyRNA; +struct CollectionPropertyIterator; +struct bContext; + +typedef void (*PropNotifyFunc)(struct bContext *C, void *data); +typedef int (*PropBooleanGetFunc)(void *data); +typedef void (*PropBooleanSetFunc)(void *data, int value); +typedef int (*PropBooleanArrayGetFunc)(void *data, int index); +typedef void (*PropBooleanArraySetFunc)(void *data, int index, int value); +typedef int (*PropIntGetFunc)(void *data); +typedef void (*PropIntSetFunc)(void *data, int value); +typedef int (*PropIntArrayGetFunc)(void *data, int index); +typedef void (*PropIntArraySetFunc)(void *data, int index, int value); +typedef float (*PropFloatGetFunc)(void *data); +typedef void (*PropFloatSetFunc)(void *data, float value); +typedef float (*PropFloatArrayGetFunc)(void *data, int index); +typedef void (*PropFloatArraySetFunc)(void *data, int index, float value); +typedef void (*PropStringGetFunc)(void *data, char *value); +typedef int (*PropStringLengthFunc)(void *data); +typedef void (*PropStringSetFunc)(void *data, const char *value); +typedef int (*PropEnumGetFunc)(void *data); +typedef void (*PropEnumSetFunc)(void *data, int value); +typedef void* (*PropPointerGetFunc)(void *data); +typedef void (*PropPointerSetFunc)(void *data, void *value); +typedef struct StructRNA* (*PropPointerTypeFunc)(void *data); +typedef void (*PropCollectionBeginFunc)(struct CollectionPropertyIterator *iter, void *data); +typedef void (*PropCollectionNextFunc)(struct CollectionPropertyIterator *iter); +typedef void (*PropCollectionEndFunc)(struct CollectionPropertyIterator *iter); +typedef void* (*PropCollectionGetFunc)(struct CollectionPropertyIterator *iter); +typedef struct StructRNA* (*PropCollectionTypeFunc)(struct CollectionPropertyIterator *iter); +typedef int (*PropCollectionLengthFunc)(void *data); +typedef void* (*PropCollectionLookupIntFunc)(void *data, int key, struct StructRNA **type); +typedef void* (*PropCollectionLookupStringFunc)(void *data, const char *key, struct StructRNA **type); + +typedef enum PropertyType { + PROP_BOOLEAN = 0, + PROP_INT = 1, + PROP_FLOAT = 2, + PROP_STRING = 3, + PROP_ENUM = 4, + PROP_POINTER = 5, + PROP_COLLECTION = 6 +} PropertyType; + +typedef enum PropertySubType { + PROP_NONE = 0, + PROP_UNSIGNED = 1, + PROP_FILEPATH = 2, + PROP_COLOR = 3, + PROP_VECTOR = 4, + PROP_MATRIX = 5, + PROP_ROTATION = 6 +} PropertySubType; + +typedef enum PropertyFlag { + PROP_EDITABLE = 1, + PROP_EVALUATEABLE = 2 +} PropertyFlag; + +typedef struct CollectionPropertyIterator { + void *internal; + int valid; +} CollectionPropertyIterator; + +typedef struct PropertyEnumItem { + int value; + const char *cname; + const char *name; +} PropertyEnumItem; + +typedef struct PropertyRNA { + struct PropertyRNA *next, *prev; + + /* C code name */ + const char *cname; + /* various options */ + int flag; + + /* user readable name */ + const char *name; + /* single line description, displayed in the tooltip for example */ + const char *description; + + /* property type as it appears to the outside */ + PropertyType type; + /* subtype, 'interpretation' of the property */ + PropertySubType subtype; + /* if an array this is > 0, specifying the length */ + unsigned int arraylength; + + /* callback for notifys on change */ + PropNotifyFunc notify; +} PropertyRNA; + +/* information specific to the property type */ +typedef struct BooleanPropertyRNA { + PropertyRNA property; + + PropBooleanGetFunc get; + PropBooleanSetFunc set; + + PropBooleanArrayGetFunc getarray; + PropBooleanArraySetFunc setarray; + + int defaultvalue; + const int *defaultarray; +} BooleanPropertyRNA; + +typedef struct IntPropertyRNA { + PropertyRNA property; + + PropIntGetFunc get; + PropIntSetFunc set; + + PropIntArrayGetFunc getarray; + PropIntArraySetFunc setarray; + + int softmin, softmax; + int hardmin, hardmax; + int step; + + int defaultvalue; + const int *defaultarray; +} IntPropertyRNA; + +typedef struct FloatPropertyRNA { + PropertyRNA property; + + PropFloatGetFunc get; + PropFloatSetFunc set; + + PropFloatArrayGetFunc getarray; + PropFloatArraySetFunc setarray; + + float softmin, softmax; + float hardmin, hardmax; + float step, precision; + + float defaultvalue; + const float *defaultarray; +} FloatPropertyRNA; + +typedef struct StringPropertyRNA { + PropertyRNA property; + + PropStringGetFunc get; + PropStringLengthFunc length; + PropStringSetFunc set; + + int maxlength; /* includes string terminator! */ + + const char *defaultvalue; +} StringPropertyRNA; + +typedef struct EnumPropertyRNA { + PropertyRNA property; + + PropEnumGetFunc get; + PropEnumSetFunc set; + + const PropertyEnumItem *item; + int totitem; + + int defaultvalue; +} EnumPropertyRNA; + +typedef struct PointerPropertyRNA { + PropertyRNA property; + + PropPointerGetFunc get; + PropPointerSetFunc set; + PropPointerTypeFunc type; /* optional */ + + struct StructRNA *structtype; +} PointerPropertyRNA; + +typedef struct CollectionPropertyRNA { + PropertyRNA property; + + PropCollectionBeginFunc begin; + PropCollectionNextFunc next; + PropCollectionEndFunc end; /* optional */ + PropCollectionGetFunc get; + PropCollectionTypeFunc type; /* optional */ + PropCollectionLengthFunc length; /* optional */ + PropCollectionLookupIntFunc lookupint; /* optional */ + PropCollectionLookupStringFunc lookupstring; /* optional */ + + struct StructRNA *structtype; +} CollectionPropertyRNA; + +typedef struct StructRNA { + struct StructRNA *next, *prev; + + /* C code name */ + const char *cname; + /* various options */ + int flag; + + /* user readable name */ + const char *name; + + /* property that defines the name */ + PropertyRNA *nameproperty; + + /* properties of this struct */ + ListBase properties; +} StructRNA; + +typedef struct BlenderRNA { + /* structs */ + ListBase structs; +} BlenderRNA; + +#endif /* RNA_TYPES */ + diff --git a/source/blender/makesrna/SConscript b/source/blender/makesrna/SConscript new file mode 100644 index 00000000000..a580072895a --- /dev/null +++ b/source/blender/makesrna/SConscript @@ -0,0 +1,11 @@ +#!/usr/bin/python +Import ('env') + +objs = [] + +o = SConscript('intern/SConscript') +objs += o + +incs = '#/intern/guardedalloc ../blenkernel ../blenlib ../makesdna intern .' + +env.BlenderLib ( 'bf_rna', objs, Split(incs), [], libtype=['common','intern'], priority = [95, 95] ) diff --git a/source/blender/makesrna/intern/Makefile b/source/blender/makesrna/intern/Makefile new file mode 100644 index 00000000000..475e3944397 --- /dev/null +++ b/source/blender/makesrna/intern/Makefile @@ -0,0 +1,79 @@ +# +# $Id: Makefile 13161 2008-01-07 19:13:47Z hos $ +# +# ***** BEGIN GPL 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. +# +# 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. +# +# Contributor(s): Blender Foundation (2008). +# +# ***** END GPL LICENSE BLOCK ***** +# + +LIBNAME = rna +DIR = $(OCGDIR)/blender/makesrna +CSRCS = RNA.c $(wildcard rna_*.c) + +include nan_compile.mk + +CFLAGS += $(LEVEL_1_C_WARNINGS) + +CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include +CPPFLAGS += -I../../blenlib +CPPFLAGS += -I../../blenkernel +CPPFLAGS += -I../../makesdna +CPPFLAGS += -I.. +CPPFLAGS += -I. + +ifeq ($(OS),windows) + # Windows needs these extra libs because of winstuff... It is not + # _really_ needed, but it is the easiest fix for now. If you have + # some spare time, try to trace down the exact dep. + ifneq ($(FREE_WINDOWS),true) + WINLIBS = kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib + WINLIBS += advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib + WINLIBS += winmm.lib opengl32.lib glu32.lib largeint.lib + WINLIBS += /link /nodefaultlib:libc + else + LDFLAGS += -mwindows -mno-cygwin + endif +endif + +clean:: + @$(RM) $(DIR)/makesrna* $(DIR)/RNA.c + @$(RM) $(DIR)/debug/makesrna* $(DIR)/debug/RNA.c + +# TODO include right .mk for ldflags + +# A small note: we do not use the debug version of the alloc lib. That +# is done quite intentionally. If there is a bug in that lib, it needs +# to be fixed by the module maintainer. + +RNAOBJS = $(filter-out %RNA.o, $(OBJS)) + +$(DIR)/$(DEBUG_DIR)makesrna: $(RNAOBJS) $(DIR)/$(DEBUG_DIR)makesrna.o $(OCGDIR)/blender/makesdna/$(DEBUG_DIR)libdna.a $(NAN_GUARDEDALLOC)/lib/libguardedalloc.a + $(CC) $(LDFLAGS) -o $@ $(WINLIBS) $^ + +$(DIR)/$(DEBUG_DIR)RNA.c: $(DIR)/$(DEBUG_DIR)makesrna + ifeq ($(OS),windows) + $(SRCHOME)/tools/cygwin/cl_wrapper.pl - $(DIR)/$(DEBUG_DIR)makesrna \ + $(DIR)/$(DEBUG_DIR)RNA.c + else + $(DIR)/$(DEBUG_DIR)makesrna $(DIR)/$(DEBUG_DIR)RNA.c + endif + +$(DIR)/$(DEBUG_DIR)makesrna.o: makesrna.c $(wildcard rna_*.c) + $(CC) -c $(CFLAGS) $(CPPFLAGS) makesrna.c -o $@ + diff --git a/source/blender/makesrna/intern/SConscript b/source/blender/makesrna/intern/SConscript new file mode 100644 index 00000000000..1dfc5df4202 --- /dev/null +++ b/source/blender/makesrna/intern/SConscript @@ -0,0 +1,49 @@ +#!/usr/bin/python +import sys +import os + +Import ('env') +cflags = '' +defines = [] +root_build_dir=env['BF_BUILDDIR'] + +source_files = env.Glob('*.c') + +# making rna_access.c part of both makesrna and blender seems to +# give conflict, how to solve? +source_files.remove('rna_access.c') + +makesrna_tool = env.Copy() +rna = env.Copy() +makesrna_tool.Append(CCFLAGS = '-DBASE_HEADER="\\"source/blender/makesrna/\\"" ') + +makesrna_tool.Append (CPPPATH = ['#/intern/guardedalloc', + '../../makesdna', + '../../makesrna']) + +if env['OURPLATFORM'] == 'linuxcross': + makesrna_tool.Replace(CC='gcc') + makesrna_tool.Replace(AR='ar') + makesrna_tool.Replace(LINK='gcc') + +if sys.platform != 'cygwin': + makesrna_tool.Append (CCFLAGS = cflags) +makesrna_tool.Append (CPPDEFINES = defines) +makesrna_tool.Append (LIBPATH = '#'+root_build_dir+'/lib') +if env['BF_PROFILE']: + makesrna_tool.Append (LINKFLAGS = env['BF_PROFILE_FLAGS']) + +if env['OURPLATFORM'] == 'linux2' and root_build_dir[0]==os.sep: + makesrna = makesrna_tool.Program (target = root_build_dir+'/makesrna', source = source_files, LIBS=['bf_guardedalloc', 'bf_dna']) +else: + makesrna = makesrna_tool.Program (target = '#'+root_build_dir+'/makesrna', source = source_files, LIBS=['bf_guardedalloc', 'bf_dna']) + +rna_dict = rna.Dictionary() +rna.Depends ('rna.c', makesrna) +if env['OURPLATFORM'] != 'linuxcross': + rna.Command ('rna.c', '', root_build_dir+os.sep+"makesrna $TARGET") +else: + rna.Command ('rna.c', '', root_build_dir+os.sep+"makesrna.exe $TARGET") +obj = ['intern/rna.c', 'intern/rna_access.c'] +Return ('obj') + diff --git a/source/blender/makesrna/intern/makesrna.c b/source/blender/makesrna/intern/makesrna.c new file mode 100644 index 00000000000..2ac287bfce2 --- /dev/null +++ b/source/blender/makesrna/intern/makesrna.c @@ -0,0 +1,780 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <float.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "MEM_guardedalloc.h" + +#include "RNA_access.h" +#include "RNA_define.h" +#include "RNA_types.h" + +#include "rna_internal.h" + +#define RNA_VERSION_DATE "$Id$" + +#ifdef _WIN32 +#ifndef snprintf +#define snprintf _snprintf +#endif +#endif + +/* TODO + * - better crash checks for autogenerated functions + * - missing warnings for makesdna/rna scons compile? + */ + +/* Preprocessing */ + +static void rna_print_c_string(FILE *f, const char *str) +{ + static char *escape[] = {"\''", "\"\"", "\??", "\\\\","\aa", "\bb", "\ff", "\nn", "\rr", "\tt", "\vv", NULL}; + int i, j; + + fprintf(f, "\""); + for(i=0; str[i]; i++) { + for(j=0; escape[j]; j++) + if(str[i] == escape[j][0]) + break; + + if(escape[j]) fprintf(f, "\\%c", escape[j][1]); + else fprintf(f, "%c", str[i]); + } + fprintf(f, "\""); +} + +static char *rna_alloc_function_name(const char *structname, const char *propname, const char *type) +{ + AllocDefRNA *alloc; + char buffer[2048]; + char *result; + + snprintf(buffer, sizeof(buffer), "rna_%s_%s_%s", structname, propname, type); + result= MEM_callocN(sizeof(char)*strlen(buffer)+1, "rna_alloc_function_name"); + strcpy(result, buffer); + + alloc= MEM_callocN(sizeof(AllocDefRNA), "AllocDefRNA"); + alloc->mem= result; + rna_addtail(&DefRNA.allocs, alloc); + + return result; +} + +static const char *rna_type_type(PropertyRNA *prop) +{ + switch(prop->type) { + case PROP_BOOLEAN: + case PROP_INT: + case PROP_ENUM: + return "int"; + case PROP_FLOAT: + return "float"; + case PROP_STRING: + return "char*"; + default: + return "void*"; + } +} + +static char *rna_def_property_get_func(FILE *f, PropertyRNA *prop, PropertyDefRNA *dp) +{ + char *func; + + if(!dp->dnastructname || !dp->dnaname) { + fprintf(stderr, "rna_def_property_get_func: %s has no valid dna info.\n", prop->cname); + DefRNA.error= 1; + return NULL; + } + + if(prop->type == PROP_STRING && ((StringPropertyRNA*)prop)->maxlength == 0) { + fprintf(stderr, "rna_def_property_get_func: string %s has max length 0.\n", prop->cname); + DefRNA.error= 1; + return NULL; + } + + func= rna_alloc_function_name(dp->strct->cname, prop->cname, "get"); + + switch(prop->type) { + case PROP_STRING: { + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + fprintf(f, "static void %s(void *data, char *value)\n", func); + fprintf(f, "{\n"); + fprintf(f, " BLI_strncpy(value, ((%s*)data)->%s, %d);\n", dp->dnastructname, dp->dnaname, sprop->maxlength); + fprintf(f, "}\n\n"); + break; + } + default: + if(prop->arraylength) { + fprintf(f, "static %s %s(void *data, int index)\n", rna_type_type(prop), func); + fprintf(f, "{\n"); + if(prop->type == PROP_BOOLEAN && dp->booleanbit && dp->dnaarraylength==1) + fprintf(f, " return ((((%s*)data)->%s & (%d<<index)) != 0);\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + else if(prop->type == PROP_BOOLEAN && dp->booleanbit) + fprintf(f, " return ((((%s*)data)->%s[index] & %d) != 0);\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + else + fprintf(f, " return (%s)(((%s*)data)->%s[index]);\n", rna_type_type(prop), dp->dnastructname, dp->dnaname); + fprintf(f, "}\n\n"); + } + else { + fprintf(f, "static %s %s(void *data)\n", rna_type_type(prop), func); + fprintf(f, "{\n"); + if(prop->type == PROP_BOOLEAN && dp->booleanbit) + fprintf(f, " return (((((%s*)data)->%s) & %d) != 0);\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + else + fprintf(f, " return (%s)(((%s*)data)->%s);\n", rna_type_type(prop), dp->dnastructname, dp->dnaname); + fprintf(f, "}\n\n"); + } + break; + } + + return func; +} + +static const char *rna_function_string(void *func) +{ + return (func)? (const char*)func: "NULL"; +} + +static void rna_float_print(FILE *f, float num) +{ + if(num == -FLT_MAX) fprintf(f, "-FLT_MAX"); + else if(num == FLT_MAX) fprintf(f, "FLT_MAX"); + else if((int)num == num) fprintf(f, "%.1ff", num); + else fprintf(f, "%.10ff", num); +} + +static void rna_clamp_value(FILE *f, PropertyRNA *prop) +{ + if(prop->type == PROP_INT) { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + if(iprop->hardmin != INT_MIN || iprop->hardmax != INT_MAX) + fprintf(f, " CLAMP(value, %d, %d);\n", iprop->hardmin, iprop->hardmax); + } + else if(prop->type == PROP_FLOAT) { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + if(fprop->hardmin != -FLT_MAX || fprop->hardmax != FLT_MAX) { + fprintf(f, " CLAMP(value, "); + rna_float_print(f, fprop->hardmin); fprintf(f, ", "); + rna_float_print(f, fprop->hardmax); fprintf(f, ");\n"); + } + } +} + +static char *rna_def_property_set_func(FILE *f, PropertyRNA *prop, PropertyDefRNA *dp) +{ + char *func; + + if(!dp->dnastructname || !dp->dnaname) { + fprintf(stderr, "rna_def_property_set_func: %s has no valid dna info.\n", prop->cname); + DefRNA.error= 1; + return NULL; + } + + func= rna_alloc_function_name(dp->strct->cname, prop->cname, "set"); + + switch(prop->type) { + case PROP_STRING: { + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + fprintf(f, "static void %s(void *data, const char *value)\n", func); + fprintf(f, "{\n"); + fprintf(f, " BLI_strncpy(((%s*)data)->%s, value, %d);\n", dp->dnastructname, dp->dnaname, sprop->maxlength); + fprintf(f, "}\n\n"); + break; + } + default: + if(prop->arraylength) { + fprintf(f, "static void %s(void *data, int index, %s value)\n", func, rna_type_type(prop)); + fprintf(f, "{\n"); + if(prop->type == PROP_BOOLEAN && dp->booleanbit && dp->dnaarraylength==1) { + fprintf(f, " if(value) ((%s*)data)->%s |= (%d<<index);\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + fprintf(f, " else ((%s*)data)->%s &= ~(%d<<index);\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + } + else if(prop->type == PROP_BOOLEAN && dp->booleanbit) { + fprintf(f, " if(value) ((%s*)data)->%s[index] |= %d;\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + fprintf(f, " else ((%s*)data)->%s[index] &= ~%d;\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + } + else { + rna_clamp_value(f, prop); + fprintf(f, " ((%s*)data)->%s[index]= value;\n", dp->dnastructname, dp->dnaname); + } + fprintf(f, "}\n\n"); + } + else { + fprintf(f, "static void %s(void *data, %s value)\n", func, rna_type_type(prop)); + fprintf(f, "{\n"); + if(prop->type == PROP_BOOLEAN && dp->booleanbit) { + fprintf(f, " if(value) ((%s*)data)->%s |= %d;\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + fprintf(f, " else ((%s*)data)->%s &= ~%d;\n", dp->dnastructname, dp->dnaname, dp->booleanbit); + } + else { + rna_clamp_value(f, prop); + fprintf(f, " ((%s*)data)->%s= value;\n", dp->dnastructname, dp->dnaname); + } + fprintf(f, "}\n\n"); + } + break; + } + + return func; +} + +static char *rna_def_property_length_func(FILE *f, PropertyRNA *prop, PropertyDefRNA *dp) +{ + char *func; + + if(!dp->dnastructname || !dp->dnaname) { + fprintf(stderr, "rna_def_property_length_func: %s has no valid dna info.\n", prop->cname); + DefRNA.error= 1; + return NULL; + } + + func= rna_alloc_function_name(dp->strct->cname, prop->cname, "length"); + + fprintf(f, "static int %s(void *data)\n", func); + fprintf(f, "{\n"); + fprintf(f, " return strlen(((%s*)data)->%s);\n", dp->dnastructname, dp->dnaname); + fprintf(f, "}\n\n"); + + return func; +} + +static char *rna_def_property_begin_func(FILE *f, PropertyRNA *prop, PropertyDefRNA *dp) +{ + char *func; + + if(!dp->dnastructname || !dp->dnaname) { + fprintf(stderr, "rna_def_property_begin_func: %s has no valid dna info.\n", prop->cname); + DefRNA.error= 1; + return NULL; + } + + func= rna_alloc_function_name(dp->strct->cname, prop->cname, "begin"); + + fprintf(f, "static void %s(CollectionPropertyIterator *iter, void *data)\n", func); + fprintf(f, "{\n"); + fprintf(f, " rna_iterator_listbase_begin(iter, &((%s*)data)->%s);\n", dp->dnastructname, dp->dnaname); + fprintf(f, "}\n\n"); + + return func; +} + +static void rna_def_property_funcs(FILE *f, PropertyDefRNA *dp) +{ + PropertyRNA *prop; + + prop= dp->prop; + + switch(prop->type) { + case PROP_BOOLEAN: { + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + + if(!prop->arraylength) { + if(!bprop->get) bprop->get= (void*)rna_def_property_get_func(f, prop, dp); + if(!bprop->set) bprop->set= (void*)rna_def_property_set_func(f, prop, dp); + } + else { + if(!bprop->getarray) bprop->getarray= (void*)rna_def_property_get_func(f, prop, dp); + if(!bprop->setarray) bprop->setarray= (void*)rna_def_property_set_func(f, prop, dp); + } + break; + } + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + if(!prop->arraylength) { + if(!iprop->get) iprop->get= (void*)rna_def_property_get_func(f, prop, dp); + if(!iprop->set) iprop->set= (void*)rna_def_property_set_func(f, prop, dp); + } + else { + if(!iprop->getarray) iprop->getarray= (void*)rna_def_property_get_func(f, prop, dp); + if(!iprop->setarray) iprop->setarray= (void*)rna_def_property_set_func(f, prop, dp); + } + break; + } + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + if(!prop->arraylength) { + if(!fprop->get) fprop->get= (void*)rna_def_property_get_func(f, prop, dp); + if(!fprop->set) fprop->set= (void*)rna_def_property_set_func(f, prop, dp); + } + else { + if(!fprop->getarray) fprop->getarray= (void*)rna_def_property_get_func(f, prop, dp); + if(!fprop->setarray) fprop->setarray= (void*)rna_def_property_set_func(f, prop, dp); + } + break; + } + case PROP_ENUM: { + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + + if(!eprop->get) eprop->get= (void*)rna_def_property_get_func(f, prop, dp); + if(!eprop->set) eprop->set= (void*)rna_def_property_set_func(f, prop, dp); + break; + } + case PROP_STRING: { + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + + if(!sprop->get) sprop->get= (void*)rna_def_property_get_func(f, prop, dp); + if(!sprop->length) sprop->length= (void*)rna_def_property_length_func(f, prop, dp); + if(!sprop->set) sprop->set= (void*)rna_def_property_set_func(f, prop, dp); + break; + } + case PROP_POINTER: { + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + + if(!pprop->get) pprop->get= (void*)rna_def_property_get_func(f, prop, dp); + if(!pprop->set) pprop->set= (void*)rna_def_property_set_func(f, prop, dp); + break; + } + case PROP_COLLECTION: { + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if(dp->dnatype && strcmp(dp->dnatype, "ListBase")==0) + if(!cprop->begin) + cprop->begin= (void*)rna_def_property_begin_func(f, prop, dp); + break; + } + } +} + +static const char *rna_find_type(const char *type) +{ + StructDefRNA *ds; + + for(ds=DefRNA.structs.first; ds; ds=ds->next) + if(ds->dnaname && strcmp(ds->dnaname, type)==0) + return ds->strct->cname; + + return NULL; +} + +static void rna_auto_types() +{ + StructDefRNA *ds; + PropertyDefRNA *dp; + + for(ds=DefRNA.structs.first; ds; ds=ds->next) { + for(dp=ds->properties.first; dp; dp=dp->next) { + if(dp->dnatype) { + if(dp->prop->type == PROP_POINTER) { + PointerPropertyRNA *pprop= (PointerPropertyRNA*)dp->prop; + + if(!pprop->structtype && !pprop->type) + pprop->structtype= (StructRNA*)rna_find_type(dp->dnatype); + } + else if(dp->prop->type== PROP_COLLECTION) { + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop; + + if(!cprop->structtype && !cprop->type && strcmp(dp->dnatype, "ListBase")==0) + cprop->structtype= (StructRNA*)rna_find_type(dp->dnatype); + } + } + } + } +} + +static void rna_auto_functions(FILE *f) +{ + StructDefRNA *ds; + PropertyDefRNA *dp; + + fprintf(f, "/* Autogenerated Functions */\n\n"); + + for(ds=DefRNA.structs.first; ds; ds=ds->next) + for(dp=ds->properties.first; dp; dp=dp->next) + rna_def_property_funcs(f, dp); +} + +static const char *rna_property_structname(PropertyType type) +{ + switch(type) { + case PROP_BOOLEAN: return "BooleanPropertyRNA"; + case PROP_INT: return "IntPropertyRNA"; + case PROP_FLOAT: return "FloatPropertyRNA"; + case PROP_STRING: return "StringPropertyRNA"; + case PROP_ENUM: return "EnumPropertyRNA"; + case PROP_POINTER: return "PointerPropertyRNA"; + case PROP_COLLECTION: return "CollectionPropertyRNA"; + default: return "UnknownPropertyRNA"; + } +} + +static const char *rna_property_typename(PropertyType type) +{ + switch(type) { + case PROP_BOOLEAN: return "PROP_BOOLEAN"; + case PROP_INT: return "PROP_INT"; + case PROP_FLOAT: return "PROP_FLOAT"; + case PROP_STRING: return "PROP_STRING"; + case PROP_ENUM: return "PROP_ENUM"; + case PROP_POINTER: return "PROP_POINTER"; + case PROP_COLLECTION: return "PROP_COLLECTION"; + default: return "PROP_UNKNOWN"; + } +} + +static const char *rna_property_subtypename(PropertyType type) +{ + switch(type) { + case PROP_NONE: return "PROP_NONE"; + case PROP_UNSIGNED: return "PROP_UNSIGNED"; + case PROP_FILEPATH: return "PROP_FILEPATH"; + case PROP_COLOR: return "PROP_COLOR"; + case PROP_VECTOR: return "PROP_VECTOR"; + case PROP_MATRIX: return "PROP_MATRIX"; + default: return "PROP_UNKNOWN"; + } +} + +static void rna_generate_prototypes(BlenderRNA *brna, FILE *f) +{ + StructRNA *strct; + + for(strct=brna->structs.first; strct; strct=strct->next) + fprintf(f, "StructRNA RNA_%s;\n", strct->cname); + fprintf(f, "\n"); + + fprintf(f, "BlenderRNA BLENDER_RNA = {"); + + strct= brna->structs.first; + if(strct) fprintf(f, "{&RNA_%s, ", strct->cname); + else fprintf(f, "{NULL, "); + + strct= brna->structs.last; + if(strct) fprintf(f, "&RNA_%s}", strct->cname); + else fprintf(f, "NULL}"); + + fprintf(f, "};\n\n"); +} + +static void rna_generate_struct(BlenderRNA *brna, StructRNA *strct, FILE *f) +{ + PropertyRNA *prop; + + fprintf(f, "/* %s */\n", strct->name); + + if(strct->properties.first) + fprintf(f, "\n"); + + for(prop=strct->properties.first; prop; prop=prop->next) + fprintf(f, "static %s rna_%s_%s;\n", rna_property_structname(prop->type), strct->cname, prop->cname); + fprintf(f, "\n"); + + for(prop=strct->properties.first; prop; prop=prop->next) { + switch(prop->type) { + case PROP_ENUM: { + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + int i; + + if(eprop->item) { + fprintf(f, "static PropertyEnumItem rna_%s_%s_items[%d] = {", strct->cname, prop->cname, eprop->totitem); + + for(i=0; i<eprop->totitem; i++) { + fprintf(f, "{%d, ", eprop->item[i].value); + rna_print_c_string(f, eprop->item[i].cname); fprintf(f, ", "); + rna_print_c_string(f, eprop->item[i].name); fprintf(f, "}"); + if(i != eprop->totitem-1) + fprintf(f, ", "); + } + + fprintf(f, "};\n\n"); + } + break; + } + case PROP_BOOLEAN: { + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + int i; + + if(bprop->defaultarray) { + fprintf(f, "static int rna_%s_%s_default[%d] = {", strct->cname, prop->cname, prop->arraylength); + + for(i=0; i<prop->arraylength; i++) { + fprintf(f, "%d", bprop->defaultarray[i]); + if(i != prop->arraylength-1) + fprintf(f, ", "); + } + + fprintf(f, "};\n\n"); + } + break; + } + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + int i; + + if(iprop->defaultarray) { + fprintf(f, "static int rna_%s_%s_default[%d] = {", strct->cname, prop->cname, prop->arraylength); + + for(i=0; i<prop->arraylength; i++) { + fprintf(f, "%d", iprop->defaultarray[i]); + if(i != prop->arraylength-1) + fprintf(f, ", "); + } + + fprintf(f, "};\n\n"); + } + break; + } + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + int i; + + if(fprop->defaultarray) { + fprintf(f, "static float rna_%s_%s_default[%d] = {", strct->cname, prop->cname, prop->arraylength); + + for(i=0; i<prop->arraylength; i++) { + rna_float_print(f, fprop->defaultarray[i]); + if(i != prop->arraylength-1) + fprintf(f, ", "); + } + + fprintf(f, "};\n\n"); + } + break; + } + default: + break; + } + + fprintf(f, "static %s rna_%s_%s = {\n", rna_property_structname(prop->type), strct->cname, prop->cname); + + if(prop->next) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", strct->cname, prop->next->cname); + else fprintf(f, "\t{NULL, "); + if(prop->prev) fprintf(f, "(PropertyRNA*)&rna_%s_%s,\n", strct->cname, prop->prev->cname); + else fprintf(f, "NULL,\n"); + fprintf(f, "\t"); rna_print_c_string(f, prop->cname); + fprintf(f, ", %d, ", prop->flag); + rna_print_c_string(f, prop->name); fprintf(f, ",\n\t"); + rna_print_c_string(f, prop->description); fprintf(f, ",\n"); + fprintf(f, "\t%s, %s, %d,\n", rna_property_typename(prop->type), rna_property_subtypename(prop->subtype), prop->arraylength); + fprintf(f, "\t%s},\n", rna_function_string(prop->notify)); + + switch(prop->type) { + case PROP_BOOLEAN: { + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + fprintf(f, "\t%s, %s, %s, %s, %d, ", rna_function_string(bprop->get), rna_function_string(bprop->set), rna_function_string(bprop->getarray), rna_function_string(bprop->setarray), bprop->defaultvalue); + if(bprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", strct->name, prop->cname); + else fprintf(f, "NULL\n"); + break; + } + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + fprintf(f, "\t%s, %s, %s, %s, %d, %d, %d, %d, %d,\n\t%d, \n", rna_function_string(iprop->get), rna_function_string(iprop->set), rna_function_string(iprop->getarray), rna_function_string(iprop->setarray), iprop->softmin, iprop->softmax, iprop->hardmin, iprop->hardmax, iprop->step, iprop->defaultvalue); + if(iprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", strct->name, prop->cname); + else fprintf(f, "NULL\n"); + break; + } + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + fprintf(f, "\t%s, %s, %s, %s, ", rna_function_string(fprop->get), rna_function_string(fprop->set), rna_function_string(fprop->getarray), rna_function_string(fprop->setarray)); + rna_float_print(f, fprop->softmin); fprintf(f, ", "); + rna_float_print(f, fprop->softmax); fprintf(f, ", "); + rna_float_print(f, fprop->hardmin); fprintf(f, ", "); + rna_float_print(f, fprop->hardmax); fprintf(f, ", "); + rna_float_print(f, fprop->step); fprintf(f, ", "); + rna_float_print(f, fprop->precision); fprintf(f, ", "); + rna_float_print(f, fprop->defaultvalue); fprintf(f, ", "); + if(fprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", strct->name, prop->cname); + else fprintf(f, "NULL\n"); + break; + } + case PROP_STRING: { + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + fprintf(f, "\t%s, %s, %s, %d, ", rna_function_string(sprop->get), rna_function_string(sprop->length), rna_function_string(sprop->set), sprop->maxlength); + rna_print_c_string(f, sprop->defaultvalue); fprintf(f, "\n"); + break; + } + case PROP_ENUM: { + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + fprintf(f, "\t%s, %s, rna_%s_%s_items, %d, %d\n", rna_function_string(eprop->get), rna_function_string(eprop->set), strct->cname, prop->cname, eprop->totitem, eprop->defaultvalue); + break; + } + case PROP_POINTER: { + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + fprintf(f, "\t%s, %s, %s, ", rna_function_string(pprop->get), rna_function_string(pprop->set), rna_function_string(pprop->type)); + if(pprop->structtype) fprintf(f, "&RNA_%s\n", (char*)pprop->structtype); + else fprintf(f, "NULL\n"); + break; + } + case PROP_COLLECTION: { + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + fprintf(f, "\t%s, %s, %s, %s, %s, %s, %s, %s, ", rna_function_string(cprop->begin), rna_function_string(cprop->next), rna_function_string(cprop->end), rna_function_string(cprop->get), rna_function_string(cprop->type), rna_function_string(cprop->length), rna_function_string(cprop->lookupint), rna_function_string(cprop->lookupstring)); + if(cprop->structtype) fprintf(f, "&RNA_%s\n", (char*)cprop->structtype); + else fprintf(f, "NULL\n"); + break; + } + } + + fprintf(f, "};\n\n"); + } + + fprintf(f, "StructRNA RNA_%s = {\n", strct->cname); + + if(strct->next) fprintf(f, "\t&RNA_%s, ", strct->next->cname); + else fprintf(f, "\tNULL, "); + if(strct->prev) fprintf(f, "&RNA_%s,\n", strct->prev->cname); + else fprintf(f, "NULL,\n"); + + fprintf(f, "\t"); + rna_print_c_string(f, strct->cname); + fprintf(f, ", %d, ", strct->flag); + rna_print_c_string(f, strct->name); + fprintf(f, ",\n"); + + prop= strct->nameproperty; + if(prop) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s,\n", strct->cname, prop->cname); + else fprintf(f, "\tNULL,\n"); + + prop= strct->properties.first; + if(prop) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", strct->cname, prop->cname); + else fprintf(f, "\t{NULL, "); + + prop= strct->properties.last; + if(prop) fprintf(f, "(PropertyRNA*)&rna_%s_%s}\n", strct->cname, prop->cname); + else fprintf(f, "NULL}\n"); + + fprintf(f, "};\n"); + + fprintf(f, "\n"); +} + +typedef struct RNAProcessItem { + char *filename; + void (*define)(BlenderRNA *brna); +} RNAProcessItem; + +RNAProcessItem PROCESS_ITEMS[]= { + {"rna_object.c", RNA_def_object}, + {"rna_scene.c", RNA_def_scene}, + {NULL, NULL}}; + +static int rna_preprocess(char *basedirectory, FILE *f) +{ + BlenderRNA *brna; + StructRNA *strct; + int i, status; + + fprintf(f, "\n/* Automatically generated struct definitions for the Data API.\n" + " Do not edit manually, changes will be overwritten */\n\n" + "#define RNA_RUNTIME\n\n"); + + brna= RNA_create(); + + fprintf(f, "#include <float.h>\n"); + fprintf(f, "#include <limits.h>\n"); + fprintf(f, "#include <string.h>\n\n"); + + fprintf(f, "#include \"BLI_blenlib.h\"\n\n"); + + fprintf(f, "#include \"BKE_utildefines.h\"\n\n"); + + fprintf(f, "#include \"RNA_define.h\"\n\n"); + fprintf(f, "#include \"RNA_types.h\"\n\n"); + + fprintf(f, "#include \"rna_internal.h\"\n\n"); + for(i=0; PROCESS_ITEMS[i].define; i++) + fprintf(f, "#include \"%s\"\n", PROCESS_ITEMS[i].filename); + fprintf(f, "\n"); + + for(i=0; PROCESS_ITEMS[i].define; i++) + PROCESS_ITEMS[i].define(brna); + rna_auto_types(); + + rna_generate_prototypes(brna, f); + rna_auto_functions(f); + + for(strct=brna->structs.first; strct; strct=strct->next) + rna_generate_struct(brna, strct, f); + + status= DefRNA.error; + + RNA_define_free(brna); + RNA_free(brna); + + return status; +} + +static void make_bad_file(char *file) +{ + FILE *fp= fopen(file, "w"); + fprintf(fp, "ERROR! Cannot make correct RNA.c file, STUPID!\n"); + fclose(fp); +} + +#ifndef BASE_HEADER +#define BASE_HEADER "../" +#endif + +int main(int argc, char **argv) +{ + FILE *file; + int return_status = 0; + extern int totblock; + + if (argc!=2 && argc!=3) { + printf("Usage: %s outfile.c [base directory]\n", argv[0]); + return_status = 1; + } + else { + file = fopen(argv[1], "w"); + + if (!file) { + printf ("Unable to open file: %s\n", argv[1]); + return_status = 1; + } + else { + char baseDirectory[256]; + + printf("Running makesrna, program versions %s\n", RNA_VERSION_DATE); + + if (argc==3) + strcpy(baseDirectory, argv[2]); + else + strcpy(baseDirectory, BASE_HEADER); + + return_status= (rna_preprocess(baseDirectory, file)); + fclose(file); + + if(return_status) { + /* error */ + make_bad_file(argv[1]); + return_status = 1; + } + } + } + + if(totblock!=0) { + printf("Error Totblock: %d\n",totblock); + MEM_printmemlist(); + } + + return return_status; +} + diff --git a/source/blender/makesrna/intern/rna_access.c b/source/blender/makesrna/intern/rna_access.c new file mode 100644 index 00000000000..af4a4b47cb3 --- /dev/null +++ b/source/blender/makesrna/intern/rna_access.c @@ -0,0 +1,411 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <stdlib.h> +#include <string.h> + +#include "MEM_guardedalloc.h" + +#include "RNA_access.h" +#include "RNA_types.h" + +/* Accessors */ + +void RNA_property_notify(PropertyRNA *prop, struct bContext *C, void *data) +{ + if(prop->notify) + prop->notify(C, data); +} + +int RNA_property_editable(PropertyRNA *prop, struct bContext *C, void *data) +{ + return (prop->flag & PROP_EDITABLE); +} + +int RNA_property_evaluatable(PropertyRNA *prop, struct bContext *C, void *data) +{ + return (prop->flag & PROP_EVALUATEABLE); +} + +int RNA_property_boolean_get(PropertyRNA *prop, void *data) +{ + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + + return bprop->get(data); +} + +void RNA_property_boolean_set(PropertyRNA *prop, void *data, int value) +{ + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + + bprop->set(data, value); +} + +int RNA_property_boolean_get_array(PropertyRNA *prop, void *data, int index) +{ + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + + return bprop->getarray(data, index); +} + +void RNA_property_boolean_set_array(PropertyRNA *prop, void *data, int index, int value) +{ + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + + bprop->setarray(data, index, value); +} + +int RNA_property_int_get(PropertyRNA *prop, void *data) +{ + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + return iprop->get(data); +} + +void RNA_property_int_set(PropertyRNA *prop, void *data, int value) +{ + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + iprop->set(data, value); +} + +int RNA_property_int_get_array(PropertyRNA *prop, void *data, int index) +{ + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + return iprop->getarray(data, index); +} + +void RNA_property_int_set_array(PropertyRNA *prop, void *data, int index, int value) +{ + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + iprop->setarray(data, index, value); +} + +float RNA_property_float_get(PropertyRNA *prop, void *data) +{ + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + return fprop->get(data); +} + +void RNA_property_float_set(PropertyRNA *prop, void *data, float value) +{ + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + fprop->set(data, value); +} + +float RNA_property_float_get_array(PropertyRNA *prop, void *data, int index) +{ + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + return fprop->getarray(data, index); +} + +void RNA_property_float_set_array(PropertyRNA *prop, void *data, int index, float value) +{ + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + fprop->setarray(data, index, value); +} + +void RNA_property_string_get(PropertyRNA *prop, void *data, char *value) +{ + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + + sprop->get(data, value); +} + +int RNA_property_string_length(PropertyRNA *prop, void *data) +{ + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + + return sprop->length(data); +} + +void RNA_property_string_set(PropertyRNA *prop, void *data, const char *value) +{ + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + + sprop->set(data, value); +} + +int RNA_property_enum_get(PropertyRNA *prop, void *data) +{ + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + + return eprop->get(data); +} + +void RNA_property_enum_set(PropertyRNA *prop, void *data, int value) +{ + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + + eprop->set(data, value); +} + +void *RNA_property_pointer_get(PropertyRNA *prop, void *data) +{ + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + + return pprop->get(data); +} + +void RNA_property_pointer_set(PropertyRNA *prop, void *data, void *value) +{ + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + + pprop->set(data, value); +} + +StructRNA *RNA_property_pointer_type(PropertyRNA *prop, void *data) +{ + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + + if(pprop->type) + return pprop->type(data); + + return pprop->structtype; +} + +void RNA_property_collection_begin(PropertyRNA *prop, struct CollectionPropertyIterator *iter, void *data) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + cprop->begin(iter, data); +} + +void RNA_property_collection_next(PropertyRNA *prop, struct CollectionPropertyIterator *iter) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + cprop->next(iter); +} + +void RNA_property_collection_end(PropertyRNA *prop, struct CollectionPropertyIterator *iter) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if(cprop->end) + cprop->end(iter); +} + +void *RNA_property_collection_get(PropertyRNA *prop, struct CollectionPropertyIterator *iter) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + return cprop->get(iter); +} + +StructRNA *RNA_property_collection_type(PropertyRNA *prop, struct CollectionPropertyIterator *iter) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if(cprop->type) + return cprop->type(iter); + + return cprop->structtype; +} + +int RNA_property_collection_length(PropertyRNA *prop, void *data) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if(cprop->length) { + return cprop->length(data); + } + else { + CollectionPropertyIterator iter; + int length= 0; + + for(cprop->begin(&iter, data); iter.valid; cprop->next(&iter)) + length++; + + if(cprop->end) + cprop->end(&iter); + + return length; + } +} + +void *RNA_property_collection_lookup_int(PropertyRNA *prop, void *data, int key, StructRNA **type) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + void *value; + + if(cprop->lookupint) { + value= cprop->lookupint(data, key, type); + + if(value && type && !*type) + *type= cprop->structtype; + + return value; + } + else { + CollectionPropertyIterator iter; + int i= 0; + void *value; + + for(cprop->begin(&iter, data); iter.valid; cprop->next(&iter), i++) + if(i == key) + break; + + if(iter.valid) { + value= cprop->get(&iter); + if(type) *type= RNA_property_collection_type(prop, &iter); + } + else { + value= NULL; + if(type) *type= NULL; + } + + if(cprop->end) + cprop->end(&iter); + + return value; + } +} + +void *RNA_property_collection_lookup_string(PropertyRNA *prop, void *data, const char *key, StructRNA **type) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + void *value; + + if(cprop->lookupstring) { + value= cprop->lookupstring(data, key, type); + + if(value && type && !*type) + *type= cprop->structtype; + + return value; + } + else { + CollectionPropertyIterator iter; + StructRNA *itertype= NULL; + StringPropertyRNA *sprop; + void *value= NULL; + char name[256], *nameptr; + int length, alloc, found= 0; + + for(cprop->begin(&iter, data); iter.valid && !found; cprop->next(&iter)) { + itertype= RNA_property_collection_type(prop, &iter); + + if(itertype->nameproperty) { + value= cprop->get(&iter); + + if(value) { + sprop= (StringPropertyRNA*)itertype->nameproperty; + length= sprop->length(value); + + if(sizeof(name)-1 < length) { + nameptr= name; + alloc= 0; + } + else { + nameptr= MEM_mallocN(sizeof(char)*length+1, "RNA_lookup_string"); + alloc= 1; + } + + sprop->get(value, nameptr); + + if(strcmp(nameptr, key) == 0) + found= 1; + + if(alloc) + MEM_freeN(nameptr); + } + } + } + + if(found && type) + *type= itertype; + + if(cprop->end) + cprop->end(&iter); + + return value; + } + + return NULL; +} + +/* Standard iterator functions */ + +void rna_iterator_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb) +{ + iter->internal= lb->first; + iter->valid= (iter->internal != NULL); +} + +void rna_iterator_listbase_next(CollectionPropertyIterator *iter) +{ + iter->internal= ((Link*)iter->internal)->next; + iter->valid= (iter->internal != NULL); +} + +void *rna_iterator_listbase_get(CollectionPropertyIterator *iter) +{ + return iter->internal; +} + +typedef struct ArrayIterator { + char *ptr; + char *endptr; + int itemsize; +} ArrayIterator; + +void rna_iterator_array_begin(CollectionPropertyIterator *iter, void *ptr, int itemsize, int length) +{ + ArrayIterator *internal; + + internal= MEM_callocN(sizeof(ArrayIterator), "ArrayIterator"); + internal->ptr= ptr; + internal->endptr= ptr+length*itemsize; + + iter->internal= internal; + iter->valid= (internal->ptr != internal->endptr); +} + +void rna_iterator_array_next(CollectionPropertyIterator *iter) +{ + ArrayIterator *internal= iter->internal; + + internal->ptr += internal->itemsize; + iter->valid= (internal->ptr != internal->endptr); +} + +void *rna_iterator_array_get(CollectionPropertyIterator *iter) +{ + ArrayIterator *internal= iter->internal; + + return internal->ptr; +} + +void rna_iterator_array_end(CollectionPropertyIterator *iter) +{ + MEM_freeN(iter->internal); +} + diff --git a/source/blender/makesrna/intern/rna_define.c b/source/blender/makesrna/intern/rna_define.c new file mode 100644 index 00000000000..b3399df67ab --- /dev/null +++ b/source/blender/makesrna/intern/rna_define.c @@ -0,0 +1,847 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <float.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "MEM_guardedalloc.h" + +#include "DNA_genfile.h" +#include "DNA_sdna_types.h" + +#include "RNA_access.h" +#include "RNA_define.h" +#include "RNA_types.h" + +#include "rna_internal.h" + +/* Global used during defining */ + +BlenderDefRNA DefRNA; + +/* Duplicated code since we can't link in blenkernel or blenlib */ + +#define MIN2(x,y) ((x)<(y)? (x): (y)) +#define MAX2(x,y) ((x)>(y)? (x): (y)) + +void rna_addtail(ListBase *listbase, void *vlink) +{ + Link *link= vlink; + + link->next = NULL; + link->prev = listbase->last; + + if (listbase->last) ((Link *)listbase->last)->next = link; + if (listbase->first == 0) listbase->first = link; + listbase->last = link; +} + +void rna_freelistN(ListBase *listbase) +{ + Link *link, *next; + + for(link=listbase->first; link; link=next) { + next= link->next; + MEM_freeN(link); + } + + listbase->first= listbase->last= NULL; +} + +/* DNA utility function for looking up members */ + +typedef struct DNAStructMember { + char *type; + char *name; + int arraylength; +} DNAStructMember; + +static int rna_member_cmp(const char *name, const char *oname) +{ + int a=0; + + /* compare without pointer or array part */ + while(name[0]=='*') + name++; + while(oname[0]=='*') + oname++; + + while(1) { + if(name[a]=='[' && oname[a]==0) return 1; + if(name[a]==0) break; + if(name[a] != oname[a]) return 0; + a++; + } + if(name[a]==0 && oname[a] == '.') return 2; + if(name[a]==0 && oname[a] == '-' && oname[a+1] == '>') return 3; + + return (name[a] == oname[a]); +} + +static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember) +{ + char *dnaname; + short *sp; + int a, structnr, totmember, cmp; + + structnr= DNA_struct_find_nr(sdna, structname); + if(structnr == -1) + return 0; + + sp= sdna->structs[structnr]; + totmember= sp[1]; + sp+= 2; + + for(a=0; a<totmember; a++, sp+=2) { + dnaname= sdna->names[sp[1]]; + + cmp= rna_member_cmp(dnaname, membername); + + if(cmp == 1) { + smember->type= sdna->types[sp[0]]; + smember->name= dnaname; + smember->arraylength= DNA_elem_array_size(smember->name, strlen(smember->name)); + return 1; + } + else if(cmp == 2) { + membername= strstr(membername, ".") + strlen("."); + return rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember); + } + else if(cmp == 3) { + membername= strstr(membername, "->") + strlen("->"); + return rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember); + } + } + + return 0; +} + +/* Blender Data Definition */ + +BlenderRNA *RNA_create() +{ + BlenderRNA *brna; + + brna= MEM_callocN(sizeof(BlenderRNA), "BlenderRNA"); + + DefRNA.sdna= DNA_sdna_from_data(DNAstr, DNAlen, 0); + DefRNA.structs.first= DefRNA.structs.last= NULL; + DefRNA.error= 0; + + return brna; +} + +void RNA_define_free(BlenderRNA *brna) +{ + StructDefRNA *strct; + AllocDefRNA *alloc; + + for(alloc=DefRNA.allocs.first; alloc; alloc=alloc->next) + MEM_freeN(alloc->mem); + rna_freelistN(&DefRNA.allocs); + + for(strct=DefRNA.structs.first; strct; strct=strct->next) + rna_freelistN(&strct->properties); + + rna_freelistN(&DefRNA.structs); + + if(DefRNA.sdna) { + DNA_sdna_free(DefRNA.sdna); + DefRNA.sdna= NULL; + } + + DefRNA.error= 0; +} + +void RNA_free(BlenderRNA *brna) +{ + StructRNA *strct; + + RNA_define_free(brna); + + for(strct=brna->structs.first; strct; strct=strct->next) + rna_freelistN(&strct->properties); + + rna_freelistN(&brna->structs); + + MEM_freeN(brna); +} + +/* Struct Definition */ + +StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, const char *name) +{ + StructRNA *strct; + StructDefRNA *ds; + + ds= MEM_callocN(sizeof(StructDefRNA), "StructDefRNA"); + rna_addtail(&DefRNA.structs, ds); + + strct= MEM_callocN(sizeof(StructRNA), "StructRNA"); + strct->cname= cname; + strct->name= name; + + ds->strct= strct; + + rna_addtail(&brna->structs, strct); + + RNA_def_struct_sdna(strct, strct->cname); + + return strct; +} + +void RNA_def_struct_sdna(StructRNA *srna, const char *structname) +{ + StructDefRNA *ds= DefRNA.structs.last; + + if(!DNA_struct_find_nr(DefRNA.sdna, structname)) { + if(!DefRNA.silent) { + fprintf(stderr, "RNA_def_struct_sdna: %s not found.\n", structname); + DefRNA.error= 1; + } + return; + } + + ds->dnaname= structname; +} + +void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop) +{ + if(prop->type != PROP_STRING) { + fprintf(stderr, "RNA_def_struct_name_property: must be a string property.\n"); + DefRNA.error= 1; + } + else + srna->nameproperty= prop; +} + +/* Property Definition */ + +PropertyRNA *RNA_def_property(StructRNA *strct, const char *cname, int type, int subtype) +{ + StructDefRNA *ds; + PropertyDefRNA *dp; + PropertyRNA *prop; + + ds= DefRNA.structs.last; + dp= MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA"); + rna_addtail(&ds->properties, dp); + + switch(type) { + case PROP_BOOLEAN: + prop= MEM_callocN(sizeof(BooleanPropertyRNA), "BooleanPropertyRNA"); + break; + case PROP_INT: { + IntPropertyRNA *iprop; + iprop= MEM_callocN(sizeof(IntPropertyRNA), "IntPropertyRNA"); + prop= &iprop->property; + + iprop->hardmin= (subtype == PROP_UNSIGNED)? 0: INT_MIN; + iprop->hardmax= INT_MAX; + + iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */ + iprop->softmax= 10000; + break; + } + case PROP_FLOAT: { + FloatPropertyRNA *fprop; + fprop= MEM_callocN(sizeof(FloatPropertyRNA), "FloatPropertyRNA"); + prop= &fprop->property; + + fprop->hardmin= (subtype == PROP_UNSIGNED)? 0: -FLT_MAX; + fprop->hardmax= FLT_MAX; + + fprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */ + fprop->softmax= 10000; + break; + } + case PROP_STRING: { + StringPropertyRNA *sprop; + sprop= MEM_callocN(sizeof(StringPropertyRNA), "StringPropertyRNA"); + prop= &sprop->property; + + sprop->defaultvalue= ""; + sprop->maxlength= 0; + break; + } + case PROP_ENUM: + prop= MEM_callocN(sizeof(EnumPropertyRNA), "EnumPropertyRNA"); + break; + case PROP_POINTER: + prop= MEM_callocN(sizeof(PointerPropertyRNA), "PointerPropertyRNA"); + break; + case PROP_COLLECTION: + prop= MEM_callocN(sizeof(CollectionPropertyRNA), "CollectionPropertyRNA"); + break; + default: + fprintf(stderr, "RNA_def_property: invalid property type.\n"); + DefRNA.error= 1; + return NULL; + } + + dp->strct= strct; + dp->prop= prop; + + prop->cname= cname; + prop->type= type; + prop->subtype= subtype; + prop->name= cname; + prop->description= ""; + prop->flag= PROP_EDITABLE|PROP_EVALUATEABLE; + + switch(type) { + case PROP_BOOLEAN: + DefRNA.silent= 1; + RNA_def_property_boolean_sdna(prop, strct->cname, cname, 0); + DefRNA.silent= 0; + break; + case PROP_INT: { + DefRNA.silent= 1; + RNA_def_property_int_sdna(prop, strct->cname, cname); + DefRNA.silent= 0; + break; + } + case PROP_FLOAT: { + DefRNA.silent= 1; + RNA_def_property_float_sdna(prop, strct->cname, cname); + DefRNA.silent= 0; + break; + } + case PROP_STRING: { + DefRNA.silent= 1; + RNA_def_property_string_sdna(prop, strct->cname, cname); + DefRNA.silent= 0; + break; + } + case PROP_ENUM: + DefRNA.silent= 1; + RNA_def_property_enum_sdna(prop, strct->cname, cname); + DefRNA.silent= 0; + break; + case PROP_POINTER: + DefRNA.silent= 1; + RNA_def_property_pointer_sdna(prop, strct->cname, cname); + DefRNA.silent= 0; + break; + case PROP_COLLECTION: + DefRNA.silent= 1; + RNA_def_property_collection_sdna(prop, strct->cname, cname); + DefRNA.silent= 0; + break; + } + + rna_addtail(&strct->properties, prop); + + return prop; +} + +void RNA_def_property_access(PropertyRNA *prop, int editable, int evaluatable) +{ + if(editable) prop->flag |= PROP_EDITABLE; + else prop->flag &= ~PROP_EDITABLE; + + if(evaluatable) prop->flag |= PROP_EVALUATEABLE; + else prop->flag &= ~PROP_EVALUATEABLE; +} + +void RNA_def_property_array(PropertyRNA *prop, int arraylength) +{ + switch(prop->type) { + case PROP_BOOLEAN: + case PROP_INT: + case PROP_FLOAT: + prop->arraylength= arraylength; + break; + default: + fprintf(stderr, "RNA_def_property_array: only boolean/int/float can be array.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description) +{ + prop->name= name; + prop->description= description; +} + +void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, double precision) +{ + switch(prop->type) { + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + iprop->softmin= (int)min; + iprop->softmax= (int)max; + iprop->step= (int)step; + break; + } + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + fprop->softmin= (float)min; + fprop->softmax= (float)max; + fprop->step= (float)step; + fprop->precision= (float)precision; + break; + } + default: + fprintf(stderr, "RNA_def_property_ui_range: invalid type for ui range.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_range(PropertyRNA *prop, double min, double max) +{ + switch(prop->type) { + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + iprop->hardmin= (int)min; + iprop->hardmax= (int)max; + iprop->softmin= MAX2(min, iprop->hardmin); + iprop->softmax= MIN2(max, iprop->hardmax); + break; + } + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + fprop->hardmin= (float)min; + fprop->hardmax= (float)max; + fprop->softmin= MAX2(min, fprop->hardmin); + fprop->softmax= MIN2(max, fprop->hardmax); + break; + } + default: + fprintf(stderr, "RNA_def_property_range: invalid type for range.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_struct_type(PropertyRNA *prop, const char *type) +{ + switch(prop->type) { + case PROP_POINTER: { + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + pprop->structtype = (StructRNA*)type; + break; + } + case PROP_COLLECTION: { + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + cprop->structtype = (StructRNA*)type; + break; + } + default: + fprintf(stderr, "RNA_def_property_struct_type: invalid type for struct type.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item) +{ + int i; + + switch(prop->type) { + case PROP_ENUM: { + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + eprop->item= item; + eprop->totitem= 0; + for(i=0; item[i].cname; i++) + eprop->totitem++; + + break; + } + default: + fprintf(stderr, "RNA_def_property_struct_type: invalid type for struct type.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength) +{ + switch(prop->type) { + case PROP_STRING: { + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + sprop->maxlength= maxlength; + break; + } + default: + fprintf(stderr, "RNA_def_property_string_maxlength: type is not string.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_boolean_default(PropertyRNA *prop, int value) +{ + switch(prop->type) { + case PROP_BOOLEAN: { + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + bprop->defaultvalue= value; + break; + } + default: + fprintf(stderr, "RNA_def_property_boolean_default: type is not boolean.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array) +{ + switch(prop->type) { + case PROP_BOOLEAN: { + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + bprop->defaultarray= array; + break; + } + default: + fprintf(stderr, "RNA_def_property_boolean_default: type is not boolean.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_int_default(PropertyRNA *prop, int value) +{ + switch(prop->type) { + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + iprop->defaultvalue= value; + break; + } + default: + fprintf(stderr, "RNA_def_property_int_default: type is not int.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array) +{ + switch(prop->type) { + case PROP_INT: { + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + iprop->defaultarray= array; + break; + } + default: + fprintf(stderr, "RNA_def_property_int_default: type is not int.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_float_default(PropertyRNA *prop, float value) +{ + switch(prop->type) { + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + fprop->defaultvalue= value; + break; + } + default: + fprintf(stderr, "RNA_def_property_float_default: type is not float.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array) +{ + switch(prop->type) { + case PROP_FLOAT: { + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + fprop->defaultarray= array; + break; + } + default: + fprintf(stderr, "RNA_def_property_float_default: type is not float.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_string_default(PropertyRNA *prop, const char *value) +{ + switch(prop->type) { + case PROP_STRING: { + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + sprop->defaultvalue= value; + break; + } + default: + fprintf(stderr, "RNA_def_property_string_default: type is not string.\n"); + DefRNA.error= 1; + break; + } +} + +void RNA_def_property_enum_default(PropertyRNA *prop, int value) +{ + switch(prop->type) { + case PROP_ENUM: { + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + eprop->defaultvalue= value; + break; + } + default: + fprintf(stderr, "RNA_def_property_enum_default: type is not enum.\n"); + DefRNA.error= 1; + break; + } +} + +/* SDNA */ + +static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + DNAStructMember smember; + StructDefRNA *ds= DefRNA.structs.last; + PropertyDefRNA *dp= ds->properties.last; + + if(!structname) + structname= ds->dnaname; + if(!propname) + propname= prop->cname; + + if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) { + if(!DefRNA.silent) { + fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname); + DefRNA.error= 1; + } + return NULL; + } + + if(smember.arraylength > 1) + prop->arraylength= smember.arraylength; + else + prop->arraylength= 0; + + dp->dnastructname= structname; + dp->dnaname= propname; + dp->dnatype= smember.type; + dp->dnaarraylength= smember.arraylength; + + return dp; +} + +void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit) +{ + PropertyDefRNA *dp; + + if((dp=rna_def_property_sdna(prop, structname, propname))) + dp->booleanbit= bit; +} + +void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + PropertyDefRNA *dp; + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + if((dp= rna_def_property_sdna(prop, structname, propname))) { + /* SDNA doesn't pass us unsigned unfortunately .. */ + if(strcmp(dp->dnatype, "char") == 0) { + iprop->hardmin= iprop->softmin= CHAR_MIN; + iprop->hardmax= iprop->softmax= CHAR_MAX; + } + else if(strcmp(dp->dnatype, "short") == 0) { + iprop->hardmin= iprop->softmin= SHRT_MIN; + iprop->hardmax= iprop->softmax= SHRT_MAX; + } + else if(strcmp(dp->dnatype, "int") == 0) { + iprop->hardmin= INT_MIN; + iprop->hardmax= INT_MAX; + + iprop->softmin= -10000; /* rather arbitrary .. */ + iprop->softmax= 10000; + } + + if(prop->subtype == PROP_UNSIGNED) + iprop->hardmin= iprop->softmin= 0; + } +} + +void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + rna_def_property_sdna(prop, structname, propname); +} + +void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + PropertyDefRNA *dp; + + if((dp=rna_def_property_sdna(prop, structname, propname))) { + if(prop->arraylength) { + prop->arraylength= 0; + if(!DefRNA.silent) { + fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname); + DefRNA.error= 1; + } + } + } +} + +void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + PropertyDefRNA *dp; + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + + if((dp=rna_def_property_sdna(prop, structname, propname))) { + if(prop->arraylength) { + sprop->maxlength= prop->arraylength; + prop->arraylength= 0; + } + } +} + +void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + PropertyDefRNA *dp; + + if((dp=rna_def_property_sdna(prop, structname, propname))) { + if(prop->arraylength) { + prop->arraylength= 0; + if(!DefRNA.silent) { + fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname); + DefRNA.error= 1; + } + } + } +} + +void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname) +{ + PropertyDefRNA *dp; + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if((dp=rna_def_property_sdna(prop, structname, propname))) { + if(prop->arraylength) { + prop->arraylength= 0; + + if(!DefRNA.silent) { + fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array not supported for collection type.\n", structname, propname); + DefRNA.error= 1; + } + } + + if(strcmp(dp->dnatype, "ListBase") == 0) { + cprop->next= (PropCollectionNextFunc)"rna_iterator_listbase_next"; + cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get"; + } + } +} + +/* Functions */ + +void RNA_def_property_notify_func(PropertyRNA *prop, char *notify) +{ + if(notify) prop->notify= (PropNotifyFunc)notify; +} + +void RNA_def_property_boolean_funcs(PropertyRNA *prop, char *get, char *set) +{ + BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop; + + if(prop->arraylength) { + if(get) bprop->getarray= (PropBooleanArrayGetFunc)get; + if(set) bprop->setarray= (PropBooleanArraySetFunc)set; + } + else { + if(get) bprop->get= (PropBooleanGetFunc)get; + if(set) bprop->set= (PropBooleanSetFunc)set; + } +} + +void RNA_def_property_int_funcs(PropertyRNA *prop, char *get, char *set) +{ + IntPropertyRNA *iprop= (IntPropertyRNA*)prop; + + if(prop->arraylength) { + if(get) iprop->getarray= (PropIntArrayGetFunc)get; + if(set) iprop->setarray= (PropIntArraySetFunc)set; + } + else { + if(get) iprop->get= (PropIntGetFunc)get; + if(set) iprop->set= (PropIntSetFunc)set; + } +} + +void RNA_def_property_float_funcs(PropertyRNA *prop, char *get, char *set) +{ + FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; + + if(prop->arraylength) { + if(get) fprop->getarray= (PropFloatArrayGetFunc)get; + if(set) fprop->setarray= (PropFloatArraySetFunc)set; + } + else { + if(get) fprop->get= (PropFloatGetFunc)get; + if(set) fprop->set= (PropFloatSetFunc)set; + } +} + +void RNA_def_property_enum_funcs(PropertyRNA *prop, char *get, char *set) +{ + EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + + if(get) eprop->get= (PropEnumGetFunc)get; + if(set) eprop->set= (PropEnumSetFunc)set; +} + +void RNA_def_property_string_funcs(PropertyRNA *prop, char *get, char *length, char *set) +{ + StringPropertyRNA *sprop= (StringPropertyRNA*)prop; + + if(get) sprop->get= (PropStringGetFunc)get; + if(length) sprop->length= (PropStringLengthFunc)length; + if(set) sprop->set= (PropStringSetFunc)set; +} + +void RNA_def_property_pointer_funcs(PropertyRNA *prop, char *get, char *type, char *set) +{ + PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop; + + if(get) pprop->get= (PropPointerGetFunc)get; + if(type) pprop->type= (PropPointerTypeFunc)type; + if(set) pprop->set= (PropPointerSetFunc)set; +} + +void RNA_def_property_collection_funcs(PropertyRNA *prop, char *begin, char *next, char *end, char *get, char *type, char *length, char *lookupint, char *lookupstring) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if(begin) cprop->begin= (PropCollectionBeginFunc)begin; + if(next) cprop->next= (PropCollectionNextFunc)next; + if(end) cprop->end= (PropCollectionEndFunc)end; + if(get) cprop->get= (PropCollectionGetFunc)get; + if(type) cprop->type= (PropCollectionTypeFunc)type; + if(length) cprop->length= (PropCollectionLengthFunc)length; + if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint; + if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring; +} + diff --git a/source/blender/makesrna/intern/rna_internal.h b/source/blender/makesrna/intern/rna_internal.h new file mode 100644 index 00000000000..7c2cb8e36be --- /dev/null +++ b/source/blender/makesrna/intern/rna_internal.h @@ -0,0 +1,94 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef RNA_INTERNAL_H +#define RNA_INTERNAL_H + +struct StructRNA; +struct PropertyRNA; +struct SDNA; +struct ListBase; + +/* Data structures used during define */ + +typedef struct PropertyDefRNA { + struct PropertyDefRNA *next, *prev; + + struct StructRNA *strct; + struct PropertyRNA *prop; + + const char *dnastructname; + const char *dnaname; + const char *dnatype; + int dnaarraylength; + + int booleanbit; +} PropertyDefRNA; + +typedef struct StructDefRNA { + struct StructDefRNA *next, *prev; + + struct StructRNA *strct; + + const char *dnaname; + ListBase properties; +} StructDefRNA; + +typedef struct AllocDefRNA { + struct AllocDefRNA *next, *prev; + void *mem; +} AllocDefRNA; + +typedef struct BlenderDefRNA { + struct SDNA *sdna; + ListBase structs; + ListBase allocs; + int error, silent; +} BlenderDefRNA; + +extern BlenderDefRNA DefRNA; + +/* Define functions for all types */ + +void RNA_def_object(struct BlenderRNA *brna); +void RNA_def_scene(struct BlenderRNA *brna); + +/* Standard iterator functions */ + +void rna_iterator_listbase_begin(struct CollectionPropertyIterator *iter, struct ListBase *lb); +void rna_iterator_listbase_next(struct CollectionPropertyIterator *iter); +void *rna_iterator_listbase_get(struct CollectionPropertyIterator *iter); + +void rna_iterator_array_begin(struct CollectionPropertyIterator *iter, void *ptr, int itemsize, int length); +void rna_iterator_array_next(struct CollectionPropertyIterator *iter); +void *rna_iterator_array_get(struct CollectionPropertyIterator *iter); +void rna_iterator_array_end(struct CollectionPropertyIterator *iter); + +/* Duplicated code since we can't link in blenlib */ + +void rna_addtail(struct ListBase *listbase, void *vlink); +void rna_freelistN(struct ListBase *listbase); + +#endif /* RNA_INTERNAL_H */ + diff --git a/source/blender/makesrna/intern/rna_object.c b/source/blender/makesrna/intern/rna_object.c new file mode 100644 index 00000000000..ac1320a52db --- /dev/null +++ b/source/blender/makesrna/intern/rna_object.c @@ -0,0 +1,52 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <stdlib.h> + +#include "RNA_define.h" +#include "RNA_types.h" + +#include "DNA_object_types.h" + +#ifdef RNA_RUNTIME + +#else + +void RNA_def_object(BlenderRNA *brna) +{ + StructRNA *strct; + PropertyRNA *prop; + + strct= RNA_def_struct(brna, "Object", "Object"); + + prop= RNA_def_property(strct, "name", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, "ID", "name"); + RNA_def_property_ui_text(prop, "Name", "Object ID name."); + RNA_def_property_string_funcs(prop, "rna_ID_name_get", "rna_ID_name_length", "rna_ID_name_set"); + + RNA_def_struct_name_property(strct, prop); +} + +#endif + diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c new file mode 100644 index 00000000000..c26c73f011d --- /dev/null +++ b/source/blender/makesrna/intern/rna_scene.c @@ -0,0 +1,115 @@ +/** + * $Id$ + * + * ***** BEGIN GPL 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. + * + * 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. + * + * Contributor(s): Blender Foundation (2008). + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <stdlib.h> + +#include "RNA_define.h" +#include "RNA_types.h" + +#include "DNA_scene_types.h" + +#ifdef RNA_RUNTIME + +#include "BKE_global.h" + +void *rna_Scene_objects_get(CollectionPropertyIterator *iter) +{ + /* we are actually iterating a Base list, so override get */ + return ((Base*)iter->internal)->object; +} + +/* name functions that ignore the first two ID characters */ +static void rna_ID_name_get(void *data, char *value) +{ + BLI_strncpy(value, ((ID*)data)->name+2, sizeof(((ID*)data)->name)-2); +} + +static int rna_ID_name_length(void *data) +{ + return strlen(((ID*)data)->name+2); +} + +static void rna_ID_name_set(void *data, const char *value) +{ + BLI_strncpy(((ID*)data)->name+2, value, sizeof(((ID*)data)->name)-2); +} + +#else + +void RNA_def_scene(BlenderRNA *brna) +{ + StructRNA *srna; + PropertyRNA *prop; + static PropertyEnumItem prop_mode_items[] = {{PROP_SMOOTH, "SMOOTH", "Smooth"}, {PROP_SPHERE, "SPHERE", "Sphere"}, {PROP_ROOT, "ROOT", "Root"}, {PROP_SHARP, "SHARP", "Sharp"}, {PROP_LIN, "LINEAR", "Linear"}, {PROP_CONST, "CONSTANT", "Constant"}, {PROP_RANDOM, "RANDOM", "Random"}, {0, NULL, NULL}}; + static PropertyEnumItem unwrapper_items[] = {{0, "CONFORMAL", "Conformal"}, {1, "ANGLEBASED", "Angle Based"}, {0, NULL, NULL}}; + + srna= RNA_def_struct(brna, "Scene", "Scene"); + + prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, "ID", "name"); + RNA_def_property_ui_text(prop, "Name", "Object ID name."); + RNA_def_property_string_funcs(prop, "rna_ID_name_get", "rna_ID_name_length", "rna_ID_name_set"); + + RNA_def_struct_name_property(srna, prop); + + prop= RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE); + RNA_def_property_ui_text(prop, "Active Camera", "Active camera used for rendering the scene."); + + prop= RNA_def_property(srna, "cursor", PROP_FLOAT, PROP_VECTOR); + RNA_def_property_ui_text(prop, "Cursor Location", "3D cursor location."); + RNA_def_property_ui_range(prop, -10000.0, 10000.0, 10, 4); + + prop= RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE); + RNA_def_property_collection_sdna(prop, NULL, "base"); + RNA_def_property_struct_type(prop, "Object"); + RNA_def_property_ui_text(prop, "Objects", "Objects in the scene."); + RNA_def_property_collection_funcs(prop, 0, 0, 0, "rna_Scene_objects_get", 0, 0, 0, 0); + + prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "lay", 1); + RNA_def_property_array(prop, 20); + RNA_def_property_ui_text(prop, "Visible Layers", "Layers visible when rendering the scene."); + + prop= RNA_def_property(srna, "prop_mode", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_items(prop, prop_mode_items); + RNA_def_property_ui_text(prop, "Proportional Mode", "Proportional edit mode."); + + prop= RNA_def_property(srna, "current_frame", PROP_INT, PROP_NONE); + RNA_def_property_int_sdna(prop, NULL, "r.cfra"); + RNA_def_property_range(prop, MINFRAME, MAXFRAME); + RNA_def_property_ui_text(prop, "Current Frame", "Current frame."); + RNA_def_property_access(prop, PROP_EDITABLE, 0); + + prop= RNA_def_property(srna, "stamp_note", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "r.stamp_udata"); + RNA_def_property_ui_text(prop, "Stamp Note", "User define note for the render stamping."); + + prop= RNA_def_property(srna, "unwrapper", PROP_ENUM, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "toolsettings->unwrapper"); + RNA_def_property_enum_items(prop, unwrapper_items); + RNA_def_property_ui_text(prop, "Unwrapper", "Unwrap algorithm used by the Unwrap tool."); +} + +#endif + |