godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Build System Changes 

-=-=-=-=-=-=-=-=-=-=

Build System:
-Big clean up of SCons, changed how builds are done to a much cleaner method (check the Github Wiki for instructions).
-Deactivated BlackBerry10 (sorry), if no mantainer found (or BlackBerry does not send us a Passort ;), platform will be removed as we have no longer devices to test.

Engine:
-Removed deprecated object and scene format (was in there just for compatibility, not in use since a long time).
-Added ability to open scenes even if a node type was removed (will try to guess the closest type).
-Removed deprecated node types.
This commit is contained in:
Juan Linietsky 2014-10-07 01:31:49 -03:00
parent a0ae38e0c1
commit 0fa94a9690
72 changed files with 892 additions and 10494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
SConstruct
View File

@ -8,15 +8,6 @@ import sys
import methods
import multiprocessing
# Enable aggresive compile mode if building on a multi core box
# only is we have not set the number of jobs already or we do
# not want it
if ARGUMENTS.get('spawn_jobs', 'no') == 'yes' and \
int(GetOption('num_jobs')) <= 1:
NUM_JOBS = multiprocessing.cpu_count()
if NUM_JOBS > 1:
SetOption('num_jobs', NUM_JOBS+1)
methods.update_version()
# scan possible build platforms
@ -58,8 +49,7 @@ for x in glob.glob("platform/*"):
module_list=methods.detect_modules()
print "Detected Platforms: "+str(platform_list)
print("Detected Modules: "+str(module_list))
#print "Detected Platforms: "+str(platform_list)
methods.save_active_platforms(active_platforms,active_platform_ids)
@ -99,19 +89,15 @@ if profile:
customs.append(profile+".py")
opts=Variables(customs, ARGUMENTS)
opts.Add('target', 'Compile Target (debug/profile/release).', "debug")
opts.Add('platform','Platform: '+str(platform_list)+'(sfml).',"")
opts.Add('python','Build Python Support: (yes/no)','no')
opts.Add('squirrel','Build Squirrel Support: (yes/no)','no')
opts.Add('target', 'Compile Target (debug/release_debug/release).', "debug")
opts.Add('bits', 'Compile Target Bits (default/32/64).', "default")
opts.Add('platform','Platform: '+str(platform_list)+'.',"")
opts.Add('p','Platform (same as platform=).',"")
opts.Add('tools','Build Tools (Including Editor): (yes/no)','yes')
opts.Add('lua','Build Lua Support: (yes/no)','no')
opts.Add('rfd','Remote Filesystem Driver: (yes/no)','no')
opts.Add('gdscript','Build GDSCript support: (yes/no)','yes')
opts.Add('vorbis','Build Ogg Vorbis Support: (yes/no)','yes')
opts.Add('minizip','Build Minizip Archive Support: (yes/no)','yes')
opts.Add('opengl', 'Build OpenGL Support: (yes/no)', 'yes')
opts.Add('game', 'Game (custom) Code Directory', "")
opts.Add('squish','Squish BC Texture Compression (yes/no)','yes')
opts.Add('squish','Squish BC Texture Compression in editor (yes/no)','yes')
opts.Add('theora','Theora Video (yes/no)','yes')
opts.Add('freetype','Freetype support in editor','yes')
opts.Add('speex','Speex Audio (yes/no)','yes')
@ -124,15 +110,12 @@ opts.Add('pvr','PVR (PowerVR) Texture loader support (yes/no)','yes')
opts.Add('builtin_zlib','Use built-in zlib (yes/no)','yes')
opts.Add('openssl','Use OpenSSL (yes/no/builtin)','no')
opts.Add('musepack','Musepack Audio (yes/no)','yes')
opts.Add('default_gui_theme','Default GUI theme (yes/no)','yes')
opts.Add("CXX", "Compiler");
opts.Add("nedmalloc", "Add nedmalloc support", 'yes');
opts.Add("CCFLAGS", "Custom flags for the C++ compiler");
opts.Add("CFLAGS", "Custom flags for the C compiler");
opts.Add("LINKFLAGS", "Custom flags for the linker");
opts.Add('disable_3d', 'Disable 3D nodes for smaller executable (yes/no)', "no")
opts.Add('disable_advanced_gui', 'Disable advance 3D gui nodes and behaviors (yes/no)', "no")
opts.Add('old_scenes', 'Compatibility with old-style scenes', "yes")
# add platform specific options
@ -152,7 +135,6 @@ Help(opts.GenerateHelpText(env_base)) # generate help
env_base.Append(CPPPATH=['#core','#core/math','#tools','#drivers','#'])
# configure ENV for platform
env_base.detect_python=True
env_base.platform_exporters=platform_exporters
"""
@ -170,17 +152,26 @@ if (env_base['target']=='debug'):
env_base.platforms = {}
for p in platform_list:
selected_platform =""
if env_base['platform'] != "" and env_base['platform'] != p:
continue
sys.path.append("./platform/"+p)
if env_base['platform'] != "":
selected_platform=env_base['platform']
elif env_base['p'] != "":
selected_platform=env_base['p']
env_base["platform"]=selected_platform
if selected_platform in platform_list:
sys.path.append("./platform/"+selected_platform)
import detect
if "create" in dir(detect):
env = detect.create(env_base)
else:
env = env_base.Clone()
env.extra_suffix=""
CCFLAGS = env.get('CCFLAGS', '')
env['CCFLAGS'] = ''
@ -197,17 +188,49 @@ for p in platform_list:
env.Append(LINKFLAGS=string.split(str(LINKFLAGS)))
detect.configure(env)
env['platform'] = p
if not env.has_key('platform_libsuffix'):
env['platform_libsuffix'] = env['LIBSUFFIX']
sys.path.remove("./platform/"+p)
sys.modules.pop('detect')
flag_list = platform_flags[p]
flag_list = platform_flags[selected_platform]
for f in flag_list:
if not (f[0] in ARGUMENTS): # allow command line to override platform flags
env[f[0]] = f[1]
print(f[0]+":"+f[1])
#env['platform_libsuffix'] = env['LIBSUFFIX']
suffix="."+selected_platform
if (env["target"]=="release"):
if (env["tools"]=="yes"):
print("Tools can only be built with targets 'debug' and 'release_debug'.")
sys.exit(255)
suffix+=".opt"
elif (env["target"]=="release_debug"):
if (env["tools"]=="yes"):
suffix+=".opt.tools"
else:
suffix+=".opt.debug"
else:
if (env["tools"]=="yes"):
suffix+=".tools"
else:
suffix+=".debug"
if (env["bits"]=="32"):
suffix+=".32"
elif (env["bits"]=="64"):
suffix+=".64"
suffix+=env.extra_suffix
env["PROGSUFFIX"]=suffix+env["PROGSUFFIX"]
env["OBJSUFFIX"]=suffix+env["OBJSUFFIX"]
env["LIBSUFFIX"]=suffix+env["LIBSUFFIX"]
env["SHLIBSUFFIX"]=suffix+env["SHLIBSUFFIX"]
sys.path.remove("./platform/"+selected_platform)
sys.modules.pop('detect')
env.module_list=[]
@ -218,7 +241,7 @@ for p in platform_list:
sys.path.append(tmppath)
env.current_module=x
import config
if (config.can_build(p)):
if (config.can_build(selected_platform)):
config.configure(env)
env.module_list.append(x)
sys.path.remove(tmppath)
@ -232,11 +255,6 @@ for p in platform_list:
if (env['openssl']=="builtin"):
env.Append(CPPPATH=['#drivers/builtin_openssl2'])
if (env["old_scenes"]=='yes'):
env.Append(CPPFLAGS=['-DOLD_SCENE_FORMAT_ENABLED'])
if (env["rfd"]=='yes'):
env.Append(CPPFLAGS=['-DRFD_ENABLED'])
if (env["builtin_zlib"]=='yes'):
env.Append(CPPPATH=['#drivers/builtin_zlib/zlib'])
@ -281,34 +299,6 @@ for p in platform_list:
if (env['xml']=='yes'):
env.Append(CPPFLAGS=['-DXML_ENABLED'])
if (env['default_gui_theme']=='no'):
env.Append(CPPFLAGS=['-DDEFAULT_THEME_DISABLED'])
if (env["python"]=='yes'):
detected=False;
if (env.detect_python):
print("Python 3.0 Prefix:");
pycfg_exec="python3-config"
errorval=os.system(pycfg_exec+" --prefix")
prefix=""
if (not errorval):
#gah, why can't it get both at the same time like pkg-config, sdl-config, etc?
env.ParseConfig(pycfg_exec+" --cflags")
env.ParseConfig(pycfg_exec+" --libs")
detected=True
if (detected):
env.Append(CPPFLAGS=['-DPYTHON_ENABLED'])
#remove annoying warnings
if ('-Wstrict-prototypes' in env["CCFLAGS"]):
env["CCFLAGS"].remove('-Wstrict-prototypes');
if ('-fwrapv' in env["CCFLAGS"]):
env["CCFLAGS"].remove('-fwrapv');
else:
print("Python 3.0 not detected ("+pycfg_exec+") support disabled.");
#if env['nedmalloc'] == 'yes':
# env.Append(CPPFLAGS = ['-DNEDMALLOC_ENABLED'])
Export('env')
@ -321,11 +311,15 @@ for p in platform_list:
SConscript("drivers/SCsub")
SConscript("bin/SCsub")
if env['game']:
SConscript(env['game']+'/SCsub')
SConscript("modules/SCsub")
SConscript("main/SCsub")
SConscript("platform/"+p+"/SCsub"); # build selected platform
SConscript("platform/"+selected_platform+"/SCsub"); # build selected platform
else:
print("No valid target platform selected.")
print("The following were detected:")
for x in platform_list:
print("\t"+x)
print("\nPlease run scons again with argument: platform=<string>")

2
core/SCsub
View File

@ -60,7 +60,7 @@ SConscript('math/SCsub');
SConscript('io/SCsub');
SConscript('bind/SCsub');
lib = env.Library("core",env.core_sources, LIBSUFFIX=env['platform_libsuffix'])
lib = env.Library("core",env.core_sources)
env.Prepend(LIBS=[lib])

8
core/bind/core_bind.cpp
View File

@ -886,6 +886,12 @@ Dictionary _Geometry::make_atlas(const Vector<Size2>& p_rects) {
};
int _Geometry::get_uv84_normal_bit(const Vector3& p_vector) {
return Geometry::get_uv84_normal_bit(p_vector);
}
void _Geometry::_bind_methods() {
@ -900,6 +906,8 @@ void _Geometry::_bind_methods() {
ObjectTypeDB::bind_method(_MD("get_closest_point_to_segment","point","s1","s2"),&_Geometry::get_closest_point_to_segment);
ObjectTypeDB::bind_method(_MD("get_uv84_normal_bit","normal"),&_Geometry::get_uv84_normal_bit);
ObjectTypeDB::bind_method(_MD("ray_intersects_triangle","from","dir","a","b","c"),&_Geometry::ray_intersects_triangle);
ObjectTypeDB::bind_method(_MD("segment_intersects_triangle","from","to","a","b","c"),&_Geometry::segment_intersects_triangle);
ObjectTypeDB::bind_method(_MD("segment_intersects_sphere","from","to","spos","sradius"),&_Geometry::segment_intersects_sphere);

1
core/bind/core_bind.h
View File

@ -233,6 +233,7 @@ public:
DVector<Vector3> segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius);
DVector<Vector3> segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes);
real_t segment_intersects_circle(const Vector2& p_from, const Vector2& p_to, const Vector2& p_circle_pos, real_t p_circle_radius);
int get_uv84_normal_bit(const Vector3& p_vector);
Vector<int> triangulate_polygon(const Vector<Vector2>& p_polygon);

1491
core/io/object_format_binary.cpp
View File

File diff suppressed because it is too large Load Diff

158
core/io/object_format_binary.h
View File

@ -1,158 +0,0 @@
/*************************************************************************/
/* object_format_binary.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef OBJECT_FORMAT_BINARY_H
#define OBJECT_FORMAT_BINARY_H
#include "object_loader.h"
#include "object_saver_base.h"
#include "dvector.h"
#include "core/os/file_access.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
class ObjectFormatSaverBinary : public ObjectFormatSaver {
String local_path;
Ref<OptimizedSaver> optimizer;
bool relative_paths;
bool bundle_resources;
bool skip_editor;
bool big_endian;
int bin_meta_idx;
FileAccess *f;
String magic;
Map<RES,int> resource_map;
Map<StringName,int> string_map;
Vector<StringName> strings;
struct SavedObject {
Variant meta;
String type;
struct SavedProperty {
int name_idx;
Variant value;
};
List<SavedProperty> properties;
};
int get_string_index(const String& p_string);
void save_unicode_string(const String& p_string);
List<SavedObject*> saved_objects;
List<SavedObject*> saved_resources;
void _pad_buffer(int p_bytes);
Error _save_obj(const Object *p_object,SavedObject *so);
void _find_resources(const Variant& p_variant);
void write_property(int p_idx,const Variant& p_property);
public:
virtual Error save(const Object *p_object,const Variant &p_meta);
ObjectFormatSaverBinary(FileAccess *p_file,const String& p_magic,const String& p_local_path,uint32_t p_flags,const Ref<OptimizedSaver>& p_optimizer);
~ObjectFormatSaverBinary();
};
class ObjectFormatSaverInstancerBinary : public ObjectFormatSaverInstancer {
public:
virtual ObjectFormatSaver* instance(const String& p_file,const String& p_magic,uint32_t p_flags=0,const Ref<OptimizedSaver>& p_optimizer=Ref<OptimizedSaver>());
virtual void get_recognized_extensions(List<String> *p_extensions) const;
virtual ~ObjectFormatSaverInstancerBinary();
};
/***********************************/
/***********************************/
/***********************************/
/***********************************/
class ObjectFormatLoaderBinary : public ObjectFormatLoader {
String local_path;
FileAccess *f;
bool endian_swap;
bool use_real64;
Vector<char> str_buf;
List<RES> resource_cache;
Map<int,StringName> string_map;
String get_unicode_string();
void _advance_padding(uint32_t p_len);
friend class ObjectFormatLoaderInstancerBinary;
Error parse_property(Variant& r_v, int& r_index);
public:
virtual Error load(Object **p_object,Variant &p_meta);
ObjectFormatLoaderBinary(FileAccess *f,bool p_endian_swap,bool p_use64);
virtual ~ObjectFormatLoaderBinary();
};
class ObjectFormatLoaderInstancerBinary : public ObjectFormatLoaderInstancer {
public:
virtual ObjectFormatLoaderBinary* instance(const String& p_file,const String& p_magic);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
};
#endif // OBJECT_FORMAT_BINARY_H
#endif

3190
core/io/object_format_xml.cpp
View File

File diff suppressed because it is too large Load Diff

196
core/io/object_format_xml.h
View File

@ -1,196 +0,0 @@
/*************************************************************************/
/* object_format_xml.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef OBJECT_FORMAT_XML_H
#define OBJECT_FORMAT_XML_H
#ifdef XML_ENABLED
#ifdef OLD_SCENE_FORMAT_ENABLED
#include "io/object_loader.h"
#include "io/object_saver.h"
#include "os/file_access.h"
#include "map.h"
#include "resource.h"
#include "xml_parser.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
class ObjectFormatSaverXML : public ObjectFormatSaver {
String local_path;
Ref<OptimizedSaver> optimizer;
bool relative_paths;
bool bundle_resources;
bool skip_editor;
FileAccess *f;
String magic;
int depth;
Map<RES,int> resource_map;
struct SavedObject {
Variant meta;
String type;
struct SavedProperty {
String name;
Variant value;
};
List<SavedProperty> properties;
};
List<RES> saved_resources;
List<SavedObject*> saved_objects;
void enter_tag(const String& p_section,const String& p_args="");
void exit_tag(const String& p_section);
void _find_resources(const Variant& p_variant);
void write_property(const String& p_name,const Variant& p_property,bool *r_ok=NULL);
void escape(String& p_str);
void write_tabs(int p_diff=0);
void write_string(String p_str,bool p_escape=true);
public:
virtual Error save(const Object *p_object,const Variant &p_meta);
ObjectFormatSaverXML(FileAccess *p_file,const String& p_magic,const String& p_local_path,uint32_t p_flags,const Ref<OptimizedSaver>& p_optimizer);
~ObjectFormatSaverXML();
};
class ObjectFormatSaverInstancerXML : public ObjectFormatSaverInstancer {
public:
virtual ObjectFormatSaver* instance(const String& p_file,const String& p_magic,uint32_t p_flags=0,const Ref<OptimizedSaver>& p_optimizer=Ref<OptimizedSaver>());
virtual void get_recognized_extensions(List<String> *p_extensions) const;
virtual ~ObjectFormatSaverInstancerXML();
};
/***********************************/
/***********************************/
/***********************************/
/***********************************/
//#define OPTIMIZED_XML_LOADER
#ifdef OPTIMIZED_XML_LOADER
class ObjectFormatLoaderXML : public ObjectFormatLoader {
Ref<XMLParser> parser;
String local_path;
Error _close_tag(const String& p_tag);
Error _parse_property(Variant& r_property,String& r_name);
friend class ObjectFormatLoaderInstancerXML;
List<RES> resource_cache;
public:
virtual Error load(Object **p_object,Variant &p_meta);
};
class ObjectFormatLoaderInstancerXML : public ObjectFormatLoaderInstancer {
public:
virtual ObjectFormatLoaderXML* instance(const String& p_file,const String& p_magic);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
};
#else
class ObjectFormatLoaderXML : public ObjectFormatLoader {
String local_path;
FileAccess *f;
struct Tag {
String name;
HashMap<String,String> args;
};
_FORCE_INLINE_ Error _parse_array_element(Vector<char> &buff,bool p_number_only,FileAccess *f,bool *end);
mutable int lines;
uint8_t get_char() const;
int get_current_line() const;
friend class ObjectFormatLoaderInstancerXML;
List<Tag> tag_stack;
List<RES> resource_cache;
Tag* parse_tag(bool* r_exit=NULL);
Error close_tag(const String& p_name);
void unquote(String& p_str);
Error goto_end_of_tag();
Error parse_property_data(String &r_data);
Error parse_property(Variant& r_v, String &r_name);
public:
virtual Error load(Object **p_object,Variant &p_meta);
virtual ~ObjectFormatLoaderXML();
};
class ObjectFormatLoaderInstancerXML : public ObjectFormatLoaderInstancer {
public:
virtual ObjectFormatLoaderXML* instance(const String& p_file,const String& p_magic);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
};
#endif
#endif
#endif
#endif

84
core/io/object_loader.cpp
View File

@ -1,84 +0,0 @@
/*************************************************************************/
/* object_loader.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "object_loader.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
bool ObjectFormatLoaderInstancer::recognize(const String& p_extension) const {
List<String> extensions;
get_recognized_extensions(&extensions);
for (List<String>::Element *E=extensions.front();E;E=E->next()) {
if (E->get().nocasecmp_to(p_extension)==0)
return true;
}
return false;
}
ObjectFormatLoaderInstancer *ObjectLoader::loader[MAX_LOADERS];
int ObjectLoader::loader_count=0;
ObjectFormatLoader *ObjectLoader::instance_format_loader(const String& p_path,const String& p_magic,String p_force_extension) {
String extension=p_force_extension.length()?p_force_extension:p_path.extension();
for (int i=0;i<loader_count;i++) {
if (!loader[i]->recognize(extension))
continue;
ObjectFormatLoader *format_loader = loader[i]->instance(p_path,p_magic);
if (format_loader)
return format_loader;
}
return NULL;
}
void ObjectLoader::get_recognized_extensions(List<String> *p_extensions) {
for (int i=0;i<loader_count;i++) {
loader[i]->get_recognized_extensions(p_extensions);
}
}
void ObjectLoader::add_object_format_loader_instancer(ObjectFormatLoaderInstancer *p_format_loader_instancer) {
ERR_FAIL_COND(loader_count>=MAX_LOADERS );
loader[loader_count++]=p_format_loader_instancer;
}
#endif

76
core/io/object_loader.h
View File

@ -1,76 +0,0 @@
/*************************************************************************/
/* object_loader.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef OBJECT_LOADER_H
#define OBJECT_LOADER_H
#include "object.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#ifdef OLD_SCENE_FORMAT_ENABLED
class ObjectFormatLoader {
public:
virtual Error load(Object **p_object,Variant &p_meta)=0;
virtual ~ObjectFormatLoader() {}
};
class ObjectFormatLoaderInstancer {
public:
virtual ObjectFormatLoader* instance(const String& p_file,const String& p_magic)=0;
virtual void get_recognized_extensions(List<String> *p_extensions) const=0;
bool recognize(const String& p_extension) const;
virtual ~ObjectFormatLoaderInstancer() {}
};
class ObjectLoader {
enum {
MAX_LOADERS=64
};
static ObjectFormatLoaderInstancer *loader[MAX_LOADERS];
static int loader_count;
public:
static ObjectFormatLoader *instance_format_loader(const String& p_path,const String& p_magic,String p_force_extension="");
static void add_object_format_loader_instancer(ObjectFormatLoaderInstancer *p_format_loader_instancer);
static void get_recognized_extensions(List<String> *p_extensions);
};
#endif
#endif

157
core/io/object_saver.cpp
View File

@ -1,157 +0,0 @@
/*************************************************************************/
/* object_saver.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "object_saver.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
void OptimizedSaver::add_property(const StringName& p_name, const Variant& p_value) {
ERR_FAIL_COND(!_list);
Property p;
p.name=p_name;
p.value=p_value;
_list->push_back(p);
}
bool OptimizedSaver::optimize_object(const Object *p_object) {
return false; //not optimize
}
void OptimizedSaver::get_property_list(const Object* p_object,List<Property> *p_properties) {
_list=p_properties;
bool res = call("optimize_object",p_object);
if (!res) {
List<PropertyInfo> plist;
p_object->get_property_list(&plist);
for(List<PropertyInfo>::Element *E=plist.front();E;E=E->next()) {
PropertyInfo pinfo=E->get();
if ((pinfo.usage&PROPERTY_USAGE_STORAGE) || (is_bundle_resources_enabled() && pinfo.usage&PROPERTY_USAGE_BUNDLE)) {
add_property(pinfo.name,p_object->get(pinfo.name));
}
}
}
_list=NULL;
}
void OptimizedSaver::set_target_platform(const String& p_platform) {
ERR_FAIL_COND(p_platform!="" && !p_platform.is_valid_identifier());
platform=p_platform;
}
String OptimizedSaver::get_target_platform() const {
return platform;
}
void OptimizedSaver::set_target_name(const String& p_name) {
name=p_name;
}
String OptimizedSaver::get_target_name() const {
return name;
}
void OptimizedSaver::_bind_methods() {
ObjectTypeDB::bind_method(_MD("set_target_platform","name"),&OptimizedSaver::set_target_platform);
ObjectTypeDB::bind_method(_MD("get_target_platform"),&OptimizedSaver::get_target_platform);
ObjectTypeDB::bind_method(_MD("set_target_name","name"),&OptimizedSaver::set_target_name);
ObjectTypeDB::bind_method(_MD("add_property","name","value"),&OptimizedSaver::add_property);
ObjectTypeDB::bind_method(_MD("optimize_object","obj"),&OptimizedSaver::optimize_object);
}
OptimizedSaver::OptimizedSaver() {
_list=NULL;
}
ObjectFormatSaverInstancer *ObjectSaver::saver[MAX_LOADERS];
int ObjectSaver::saver_count=0;
bool ObjectFormatSaverInstancer::recognize(const String& p_extension) const {
List<String> extensions;
get_recognized_extensions(&extensions);
for (List<String>::Element *E=extensions.front();E;E=E->next()) {
if (E->get().nocasecmp_to(p_extension.extension())==0)
return true;
}
return false;
}
ObjectFormatSaver *ObjectSaver::instance_format_saver(const String& p_path,const String& p_magic,String p_force_extension,uint32_t p_flags,const Ref<OptimizedSaver>& p_optimizer) {
String extension=p_force_extension.length()?p_force_extension:p_path.extension();
for (int i=0;i<saver_count;i++) {
if (!saver[i]->recognize(extension))
continue;
ObjectFormatSaver *format_saver = saver[i]->instance(p_path,p_magic,p_flags,p_optimizer);
if (format_saver)
return format_saver;
}
return NULL;
}
void ObjectSaver::get_recognized_extensions(List<String> *p_extensions) {
for (int i=0;i<saver_count;i++) {
saver[i]->get_recognized_extensions(p_extensions);
}
}
void ObjectSaver::add_object_format_saver_instancer(ObjectFormatSaverInstancer *p_format_saver_instancer) {
ERR_FAIL_COND(saver_count>=MAX_LOADERS );
saver[saver_count++]=p_format_saver_instancer;
}
#endif

128
core/io/object_saver.h
View File

@ -1,128 +0,0 @@
/*************************************************************************/
/* object_saver.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef OBJECT_SAVER_H
#define OBJECT_SAVER_H
#include "object.h"
#include "resource.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#ifdef OLD_SCENE_FORMAT_ENABLED
class OptimizedSaver : public Reference {
OBJ_TYPE(OptimizedSaver,Reference);
public:
struct Property {
StringName name;
Variant value;
};
private:
String name;
String platform;
List<Property> *_list;
protected:
void set_target_platform(const String& p_platform);
void set_target_name(const String& p_name);
void add_property(const StringName& p_name, const Variant& p_value);
static void _bind_methods();
virtual bool optimize_object(const Object *p_object);
public:
virtual bool is_bundle_resources_enabled() const { return false; }
String get_target_platform() const;
String get_target_name() const;
void get_property_list(const Object* p_object, List<Property> *p_properties);
OptimizedSaver();
};
class ObjectFormatSaver {
public:
virtual Error save(const Object *p_object,const Variant &p_meta=Variant())=0;
virtual ~ObjectFormatSaver() {}
};
class ObjectFormatSaverInstancer {
public:
virtual void get_recognized_extensions(List<String> *p_extensions) const=0;
virtual ObjectFormatSaver* instance(const String& p_file,const String& p_magic="",uint32_t p_flags=0,const Ref<OptimizedSaver>& p_optimizer=Ref<OptimizedSaver>())=0;
bool recognize(const String& p_extension) const;
virtual ~ObjectFormatSaverInstancer() {}
};
class ObjectSaver {
enum {
MAX_LOADERS=64
};
static ObjectFormatSaverInstancer *saver[MAX_LOADERS];
static int saver_count;
public:
enum SaverFlags {
FLAG_RELATIVE_PATHS=1,
FLAG_BUNDLE_RESOURCES=2,
FLAG_OMIT_EDITOR_PROPERTIES=4,
FLAG_SAVE_BIG_ENDIAN=8
};
static ObjectFormatSaver *instance_format_saver(const String& p_path,const String& p_magic,String p_force_extension="",uint32_t p_flags=0,const Ref<OptimizedSaver>& p_optimizer=Ref<OptimizedSaver>());
static void get_recognized_extensions(List<String> *p_extensions);
static void add_object_format_saver_instancer(ObjectFormatSaverInstancer *p_format_saver_instancer);
};
#endif
#endif

150
core/io/object_saver_base.cpp
View File

@ -1,150 +0,0 @@
/*************************************************************************/
/* object_saver_base.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "object_saver_base.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
void ObjectSaverBase::_find_resources(const Variant& p_variant) {
switch(p_variant.get_type()) {
case Variant::OBJECT: {
RES res = p_variant.operator RefPtr();
if (res.is_null() || (res->get_path().length() && res->get_path().find("::") == -1 ))
return;
if (resource_map.has(res))
return;
List<PropertyInfo> property_list;
res->get_property_list( &property_list );
List<PropertyInfo>::Element *I=property_list.front();
while(I) {
PropertyInfo pi=I->get();
if (pi.usage&PROPERTY_USAGE_STORAGE) {
if (pi.type==Variant::OBJECT) {
Variant v=res->get(I->get().name);
_find_resources(v);
}
}
I=I->next();
}
resource_map[ res ] = resource_map.size(); //saved after, so the childs it needs are available when loaded
saved_resources.push_back(res);
} break;
case Variant::ARRAY: {
Array varray=p_variant;
int len=varray.size();
for(int i=0;i<len;i++) {
Variant v=varray.get(i);
_find_resources(v);
}
} break;
case Variant::DICTIONARY: {
Dictionary d=p_variant;
List<Variant> keys;
d.get_key_list(&keys);
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
Variant v = d[E->get()];
_find_resources(v);
}
} break;
default: {}
}
}
Error ObjectSaverBase::save(const Object *p_object,const Variant &p_meta) {
ERR_EXPLAIN("write_object should supply either an object, a meta, or both");
ERR_FAIL_COND_V(!p_object && p_meta.get_type()==Variant::NIL, ERR_INVALID_PARAMETER);
SavedObject *so = memnew( SavedObject );
if (p_object) {
so->type=p_object->get_type();
};
_find_resources(p_meta);
so->meta=p_meta;
if (p_object) {
List<PropertyInfo> property_list;
p_object->get_property_list( &property_list );
List<PropertyInfo>::Element *I=property_list.front();
while(I) {
if (I->get().usage&PROPERTY_USAGE_STORAGE) {
SavedObject::SavedProperty sp;
sp.name=I->get().name;
sp.value = p_object->get(I->get().name);
_find_resources(sp.value);
so->properties.push_back(sp);
}
I=I->next();
}
}
saved_objects.push_back(so);
return OK;
}
ObjectSaverBase::ObjectSaverBase() {
};
ObjectSaverBase::~ObjectSaverBase() {
};
#endif

76
core/io/object_saver_base.h
View File

@ -1,76 +0,0 @@
/*************************************************************************/
/* object_saver_base.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef OBJECT_SAVER_BASE_H
#define OBJECT_SAVER_BASE_H
#ifdef OLD_SCENE_FORMAT_ENABLED
#include "object_saver.h"
#include "map.h"
#include "resource.h"
class ObjectSaverBase : public ObjectFormatSaver {
protected:
Map<RES,int> resource_map;
struct SavedObject {
Variant meta;
String type;
struct SavedProperty {
String name;
Variant value;
};
List<SavedProperty> properties;
};
List<RES> saved_resources;
List<SavedObject*> saved_objects;
void _find_resources(const Variant& p_variant);
virtual Error write()=0;
public:
virtual Error save(const Object *p_object,const Variant &p_meta);
ObjectSaverBase();
~ObjectSaverBase();
};
#endif
#endif // OBJECT_SAVER_BASE_H

53
core/math/geometry.h
View File

@ -821,6 +821,59 @@ public:
};
_FORCE_INLINE_ static int get_uv84_normal_bit(const Vector3& p_vector) {
int lat = Math::fast_ftoi(Math::floor(Math::acos(p_vector.dot(Vector3(0,1,0)))*4.0/Math_PI+0.5));
if (lat==0) {
return 24;
} else if (lat==4) {
return 25;
}
int lon = Math::fast_ftoi(Math::floor( (Math_PI+Math::atan2(p_vector.x,p_vector.z))*8.0/(Math_PI*2.0) + 0.5))%8;
return lon+(lat-1)*8;
}
_FORCE_INLINE_ static int get_uv84_normal_bit_neighbors(int p_idx) {
if (p_idx==24) {
return 1|2|4|8;
} else if (p_idx==25) {
return (1<<23)|(1<<22)|(1<<21)|(1<<20);
} else {
int ret = 0;
if ((p_idx%8) == 0)
ret|=(1<<(p_idx+7));
else
ret|=(1<<(p_idx-1));
if ((p_idx%8) == 7)
ret|=(1<<(p_idx-7));
else
ret|=(1<<(p_idx+1));
int mask = ret|(1<<p_idx);
if (p_idx<8)
ret|=24;
else
ret|=mask>>8;
if (p_idx>=16)
ret|=25;
else
ret|=mask<<8;
return ret;
}
}
static MeshData build_convex_mesh(const DVector<Plane> &p_planes);
static DVector<Plane> build_sphere_planes(float p_radius, int p_lats, int p_lons, Vector3::Axis p_axis=Vector3::AXIS_Z);
static DVector<Plane> build_box_planes(const Vector3& p_extents);

35
core/register_core_types.cpp
View File

@ -27,8 +27,6 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "register_core_types.h"
#include "io/object_format_xml.h"
#include "io/object_format_binary.h"
#include "io/tcp_server.h"
#include "io/config_file.h"
@ -56,14 +54,6 @@
#ifdef XML_ENABLED
static ResourceFormatSaverXML *resource_saver_xml=NULL;
static ResourceFormatLoaderXML *resource_loader_xml=NULL;
#ifdef OLD_SCENE_FORMAT_ENABLED
static ObjectFormatSaverInstancerXML *object_format_saver_xml=NULL;
static ObjectFormatLoaderInstancerXML *object_format_loader_xml=NULL;
#endif
#endif
#ifdef OLD_SCENE_FORMAT_ENABLED
static ObjectFormatSaverInstancerBinary * object_format_saver_binary = NULL;
static ObjectFormatLoaderInstancerBinary * object_format_loader_binary = NULL;
#endif
static ResourceFormatSaverBinary *resource_saver_binary=NULL;
static ResourceFormatLoaderBinary *resource_loader_binary=NULL;
@ -101,23 +91,6 @@ void register_core_types() {
CoreStringNames::create();
#ifdef XML_ENABLED
#ifdef OLD_SCENE_FORMAT_ENABLED
object_format_saver_xml = memnew( ObjectFormatSaverInstancerXML );
ObjectSaver::add_object_format_saver_instancer( object_format_saver_xml );
object_format_loader_xml = memnew( ObjectFormatLoaderInstancerXML );
ObjectLoader::add_object_format_loader_instancer( object_format_loader_xml );
#endif
#endif
#ifdef OLD_SCENE_FORMAT_ENABLED
object_format_saver_binary = memnew( ObjectFormatSaverInstancerBinary );
ObjectSaver::add_object_format_saver_instancer( object_format_saver_binary );
object_format_loader_binary = memnew( ObjectFormatLoaderInstancerBinary );
ObjectLoader::add_object_format_loader_instancer( object_format_loader_binary );
#endif
resource_format_po = memnew( TranslationLoaderPO );
ResourceLoader::add_resource_format_loader( resource_format_po );
@ -212,10 +185,6 @@ void unregister_core_types() {
memdelete( _geometry );
#ifdef XML_ENABLED
#ifdef OLD_SCENE_FORMAT_ENABLED
memdelete( object_format_saver_xml );
memdelete( object_format_loader_xml );
#endif
if (resource_saver_xml)
memdelete(resource_saver_xml);
if (resource_loader_xml)
@ -228,10 +197,6 @@ void unregister_core_types() {
memdelete(resource_loader_binary);
#ifdef OLD_SCENE_FORMAT_ENABLED
memdelete( object_format_saver_binary );
memdelete( object_format_loader_binary );
#endif
memdelete( resource_format_po );
if (ip)

2
drivers/SCsub
View File

@ -82,7 +82,7 @@ if len(list) > 0:
drivers_base=[]
env.add_source_files(drivers_base,"*.cpp")
lib_list.insert(0, env.Library("drivers", drivers_base, LIBSUFFIX=env['platform_libsuffix']))
lib_list.insert(0, env.Library("drivers", drivers_base))
env.Prepend(LIBS=lib_list)

2
main/SCsub
View File

@ -5,7 +5,7 @@ env.add_source_files(env.main_sources,"*.cpp")
Export('env')
lib = env.Library("main",env.main_sources, LIBSUFFIX=env['platform_libsuffix'])
lib = env.Library("main",env.main_sources)
env.Prepend(LIBS=[lib])

14
main/main.cpp
View File

@ -43,7 +43,7 @@
#include "io/resource_loader.h"
#include "scene/main/scene_main_loop.h"
#include "scene/io/scene_loader.h"
#include "script_language.h"
#include "io/resource_loader.h"
@ -1131,10 +1131,6 @@ bool Main::start() {
#ifdef TOOLS_ENABLED
if (editor) {
#ifdef OLD_SCENE_FORMAT_ENABLED
if (convert_old)
editor_node->set_convert_old_scene(true);
#endif
if (_import!="") {
@ -1214,14 +1210,6 @@ bool Main::start() {
if (scenedata.is_valid())
scene=scenedata->instance();
#ifdef OLD_SCENE_FORMAT_ENABLED
if (!scene) {
scene = SceneLoader::load(local_game_path,true);
}
#endif
ERR_EXPLAIN("Failed loading scene: "+local_game_path);
ERR_FAIL_COND_V(!scene,false)
sml->get_root()->add_child(scene);

14
methods.py
View File

@ -205,7 +205,7 @@ def build_glsl_header( filename ):
out_file_base = out_file
out_file_base = out_file_base[ out_file_base.rfind("/")+1: ]
out_file_base = out_file_base[ out_file_base.rfind("\\")+1: ]
print("out file "+out_file+" base " +out_file_base)
# print("out file "+out_file+" base " +out_file_base)
out_file_ifdef = out_file_base.replace(".","_").upper()
fd.write("#ifndef "+out_file_ifdef+"\n")
fd.write("#define "+out_file_ifdef+"\n")
@ -504,7 +504,7 @@ def build_hlsl_dx9_header( filename ):
out_file_base = out_file
out_file_base = out_file_base[ out_file_base.rfind("/")+1: ]
out_file_base = out_file_base[ out_file_base.rfind("\\")+1: ]
print("out file "+out_file+" base " +out_file_base)
# print("out file "+out_file+" base " +out_file_base)
out_file_ifdef = out_file_base.replace(".","_").upper()
fd.write("#ifndef "+out_file_ifdef+"\n")
fd.write("#define "+out_file_ifdef+"\n")
@ -714,7 +714,7 @@ def build_legacygl_header( filename, include, class_suffix, output_attribs ):
enumbase = ifdefline[:ifdefline.find("_EN_")];
ifdefline = ifdefline.replace("_EN_","_")
line = line.replace("_EN_","_")
print(enumbase+":"+ifdefline);
# print(enumbase+":"+ifdefline);
if (enumbase not in enums):
enums[enumbase]=[]
if (ifdefline not in enums[enumbase]):
@ -805,7 +805,7 @@ def build_legacygl_header( filename, include, class_suffix, output_attribs ):
out_file_base = out_file
out_file_base = out_file_base[ out_file_base.rfind("/")+1: ]
out_file_base = out_file_base[ out_file_base.rfind("\\")+1: ]
print("out file "+out_file+" base " +out_file_base)
# print("out file "+out_file+" base " +out_file_base)
out_file_ifdef = out_file_base.replace(".","_").upper()
fd.write("#ifndef "+out_file_ifdef+class_suffix+"_120\n")
fd.write("#define "+out_file_ifdef+class_suffix+"_120\n")
@ -952,10 +952,10 @@ def build_legacygl_header( filename, include, class_suffix, output_attribs ):
x=enums[xv]
bits=1
amt = len(x);
print(x)
# print(x)
while(2**bits < amt):
bits+=1
print("amount: "+str(amt)+" bits "+str(bits));
# print("amount: "+str(amt)+" bits "+str(bits));
strs="{"
for i in range(amt):
strs+="\"#define "+x[i]+"\\n\","
@ -1330,7 +1330,7 @@ def save_active_platforms(apnames,ap):
for x in ap:
pth = x+"/logo.png"
print("open path: "+pth)
# print("open path: "+pth)
pngf=open(pth,"rb");
b=pngf.read(1);
str=" /* AUTOGENERATED FILE, DO NOT EDIT */ \n"

2
modules/SCsub
View File

@ -16,7 +16,7 @@ for x in env.module_list:
env_modules.Append(CPPFLAGS=["-DMODULE_"+x.upper()+"_ENABLED"])
SConscript(x+"/SCsub")
lib = env_modules.Library("modules",env.modules_sources, LIBSUFFIX=env['platform_libsuffix'])
lib = env_modules.Library("modules",env.modules_sources)
env.Prepend(LIBS=[lib])

1
modules/gdscript/gd_script.cpp
View File

@ -2410,7 +2410,6 @@ void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
"func" ,
"if" ,
"in" ,
"varl",
"null" ,
"return" ,
"self" ,

4
platform/android/SCsub
View File

@ -66,6 +66,6 @@ for x in env.android_module_libraries:
shutil.copy(x,abspath+"/java/libs")
env_android.SharedLibrary("#platform/android/libgodot_android.so",[android_objects])
env_android.SharedLibrary("#bin/libgodot_android",[android_objects],SHLIBSUFFIX=env["SHLIBSUFFIX"])
env.Command('#bin/libgodot_android.so', '#platform/android/libgodot_android.so', Copy('bin/libgodot_android.so', 'platform/android/libgodot_android.so'))
#env.Command('#bin/libgodot_android.so', '#platform/android/libgodot_android.so', Copy('bin/libgodot_android.so', 'platform/android/libgodot_android.so'))

28
platform/android/detect.py
View File

@ -27,14 +27,13 @@ def get_opts():
('NDK_TARGET', 'toolchain to use for the NDK',"arm-linux-androideabi-4.8"),
('android_stl','enable STL support in android port (for modules)','no'),
('armv6','compile for older phones running arm v6 (instead of v7+neon+smp)','no'),
('x86','compile for x86','no')
('x86','Xompile for Android-x86','no')
]
def get_flags():
return [
('lua', 'no'),
('tools', 'no'),
('nedmalloc', 'no'),
('builtin_zlib', 'no'),
@ -77,13 +76,7 @@ def configure(env):
env.Append(CPPPATH=['#platform/android'])
if env['x86']=='yes':
env['OBJSUFFIX'] = ".android.ox"
env['LIBSUFFIX'] = ".android.ax"
else:
env['OBJSUFFIX'] = ".android.o"
env['LIBSUFFIX'] = ".android.a"
env['PROGSUFFIX'] = ".android"
env['SHLIBSUFFIX'] = ".so"
env.extra_suffix=".x86"
gcc_path=env["ANDROID_NDK_ROOT"]+"/toolchains/"+env["NDK_TARGET"]+"/prebuilt/";
@ -128,7 +121,7 @@ def configure(env):
ld_path=env["ANDROID_NDK_ROOT"]+"/platforms/"+ndk_platform+"/"+env['ARCH']+"/usr/lib"
env.Append(CPPPATH=[gcc_include])
# env['CCFLAGS'] = string.split('-DNO_THREADS -MMD -MP -MF -fpic -ffunction-sections -funwind-tables -fstack-protector -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ -Wno-psabi -march=armv5te -mtune=xscale -msoft-float -fno-exceptions -mthumb -fno-strict-aliasing -DANDROID -Wa,--noexecstack -DGLES2_ENABLED ')
print("********* armv6", env['armv6'])
if env['x86']=='yes':
env['CCFLAGS'] = string.split('-DNO_STATVFS -MMD -MP -MF -fpic -ffunction-sections -funwind-tables -fstack-protector -D__GLIBC__ -Wno-psabi -ftree-vectorize -funsafe-math-optimizations -fno-strict-aliasing -DANDROID -Wa,--noexecstack -DGLES2_ENABLED -DGLES1_ENABLED')
elif env["armv6"]!="no":
@ -149,23 +142,10 @@ def configure(env):
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O2', '-ffast-math','-fomit-frame-pointer'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['-O2', '-ffast-math','-DDEBUG_ENABLED'])
env['OBJSUFFIX'] = "_optd"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_optd"+env['LIBSUFFIX']
elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-O2', '-ffast-math','-fomit-frame-pointer', '-g1'])
env.Append(LIBPATH=['#platform/android/armeabi'])
env.Append(LIBS=['andprof'])
env['OBJSUFFIX'] = "_prof"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_prof"+env['LIBSUFFIX']
env['SHLIBSUFFIX'] = "_prof"+env['SHLIBSUFFIX']
elif (env["target"]=="debug"):
@ -174,8 +154,10 @@ def configure(env):
if env["armv6"] == "no" and env['x86'] != 'yes':
env['neon_enabled']=True
env.Append(CPPFLAGS=['-DANDROID_ENABLED', '-DUNIX_ENABLED', '-DNO_FCNTL','-DMPC_FIXED_POINT'])
# env.Append(CPPFLAGS=['-DANDROID_ENABLED', '-DUNIX_ENABLED','-DMPC_FIXED_POINT'])
if (env['android_stl']=='yes'):
#env.Append(CCFLAGS=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/system/include"])
env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.4.3/include"])

1
platform/flash/SCsub
View File

@ -8,7 +8,6 @@ common_flash=[\
#"dir_access_flash.cpp",
]
print("** path is ", env['ENV']['PATH'])
abc = env.Command('#platform/flash/Console.abc', '#platform/flash/Console.as',
"""

1
platform/flash/detect.py
View File

@ -11,7 +11,6 @@ def get_name():
def can_build():
#import os
print(os.environ)
if (not os.environ.has_key("FLASCC_ROOT")):
return False
return True

11
platform/iphone/SCsub
View File

@ -35,11 +35,6 @@ if env['ios_appirater'] == "yes":
obj = env_ios.Object('godot_iphone.cpp')
prog = None
if env["target"]=="release" or env["target"] == "release_debug":
prog = env_ios.Program('#bin/godot_opt', [obj] + iphone_lib)
#action = "dsymutil "+File(prog)[0].path+" -o ../build/script_exec/build/Debug-iphoneos/script_exec.app.dSYM"
#env.AddPostAction(prog, action)
else:
prog = env_ios.Program('#bin/godot', [obj] + iphone_lib)
action = "dsymutil "+File(prog)[0].path+" -o bin/godot.iphone.dSYM"
env.AddPostAction(prog, action)
prog = env_ios.Program('#bin/godot', [obj] + iphone_lib)
action = "dsymutil "+File(prog)[0].path+" -o " + File(prog)[0].path + ".dSYM"
env.AddPostAction(prog, action)

6
platform/iphone/app_delegate.mm
View File

@ -257,7 +257,8 @@ static int frame_count = 0;
- (void)applicationDidEnterBackground:(UIApplication *)application
{
printf("********************* did enter background\n");
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
if (OS::get_singleton()->get_main_loop())
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
[view_controller.view stopAnimation];
}
@ -282,7 +283,8 @@ static int frame_count = 0;
printf("********************* mobile app tracker found\n");
[MobileAppTracker measureSession];
#endif
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
if (OS::get_singleton()->get_main_loop())
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
[view_controller.view startAnimation]; // FIXME: resume seems to be recommended elsewhere
}

13
platform/iphone/detect.py
View File

@ -34,9 +34,7 @@ def get_opts():
def get_flags():
return [
('lua', 'no'),
('tools', 'no'),
('nedmalloc', 'no'),
('webp', 'yes'),
('openssl','builtin'), #use builtin openssl
]
@ -47,10 +45,6 @@ def configure(env):
env.Append(CPPPATH=['#platform/iphone', '#platform/iphone/include'])
env['OBJSUFFIX'] = ".iphone.o"
env['LIBSUFFIX'] = ".iphone.a"
env['PROGSUFFIX'] = ".iphone"
env['ENV']['PATH'] = env['IPHONEPATH']+"/Developer/usr/bin/:"+env['ENV']['PATH']
# env['CC'] = '$IPHONEPATH/Developer/usr/bin/gcc'
@ -101,15 +95,11 @@ def configure(env):
env.Append(CCFLAGS=['-Os', '-ffast-math', '-DNS_BLOCK_ASSERTIONS=1','-Wall'])
env.Append(LINKFLAGS=['-Os', '-ffast-math'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif env["target"] == "release_debug":
env.Append(CCFLAGS=['-Os', '-ffast-math', '-DNS_BLOCK_ASSERTIONS=1','-Wall','-DDEBUG_ENABLED'])
env.Append(LINKFLAGS=['-Os', '-ffast-math'])
env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ENABLED'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif (env["target"]=="debug"):
@ -131,8 +121,5 @@ def configure(env):
#env['neon_enabled']=True
env['S_compiler'] = '$IPHONEPATH/Developer/usr/bin/gcc'
if env['lua'] == "yes":
env.Append(CCFLAGS=['-DLUA_USE_FLOAT'])
# /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang -x objective-c-header -arch armv7s -fmessage-length=0 -std=gnu99 -fobjc-arc -Wno-trigraphs -fpascal-strings -Os -Wno-missing-field-initializers -Wno-missing-prototypes -Wreturn-type -Wno-implicit-atomic-properties -Wno-receiver-is-weak -Wduplicate-method-match -Wformat -Wno-missing-braces -Wparentheses -Wswitch -Wno-unused-function -Wno-unused-label -Wno-unused-parameter -Wunused-variable -Wunused-value -Wempty-body -Wuninitialized -Wno-unknown-pragmas -Wno-shadow -Wno-four-char-constants -Wno-conversion -Wno-shorten-64-to-32 -Wpointer-sign -Wno-newline-eof -Wno-selector -Wno-strict-selector-match -Wno-undeclared-selector -Wno-deprecated-implementations -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.0.sdk -Wprotocol -Wdeprecated-declarations -g -fvisibility=hidden -Wno-sign-conversion "-DIBOutlet=__attribute__((iboutlet))" "-DIBOutletCollection(ClassName)=__attribute__((iboutletcollection(ClassName)))" "-DIBAction=void)__attribute__((ibaction)" -miphoneos-version-min=4.3 -iquote /Users/lucasgondolo/test/build/test.build/Release-iphoneos/test.build/test-generated-files.hmap -I/Users/lucasgondolo/test/build/test.build/Release-iphoneos/test.build/test-own-target-headers.hmap -I/Users/lucasgondolo/test/build/test.build/Release-iphoneos/test.build/test-all-target-headers.hmap -iquote /Users/lucasgondolo/test/build/test.build/Release-iphoneos/test.build/test-project-headers.hmap -I/Users/lucasgondolo/test/build/Release-iphoneos/include -I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include -I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include -I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include -I/Users/lucasgondolo/test/build/test.build/Release-iphoneos/test.build/DerivedSources/armv7s -I/Users/lucasgondolo/test/build/test.build/Release-iphoneos/test.build/DerivedSources -F/Users/lucasgondolo/test/build/Release-iphoneos -DNS_BLOCK_ASSERTIONS=1 --serialize-diagnostics /var/folders/9r/_65jj9457bgb4n4nxcsm0xl80000gn/C/com.apple.Xcode.501/SharedPrecompiledHeaders/test-Prefix-esrzoamhgruxcxbhemvvlrjmmvoh/test-Prefix.pch.dia -c /Users/lucasgondolo/test/test/test-Prefix.pch -o /var/folders/9r/_65jj9457bgb4n4nxcsm0xl80000gn/C/com.apple.Xcode.501/SharedPrecompiledHeaders/test-Prefix-esrzoamhgruxcxbhemvvlrjmmvoh/test-Prefix.pch.pth -MMD -MT dependencies -MF /var/folders/9r/_65jj9457bgb4n4nxcsm0xl80000gn/C/com.apple.Xcode.501/SharedPrecompiledHeaders/test-Prefix-esrzoamhgruxcxbhemvvlrjmmvoh/test-Prefix.pch.d

4
platform/javascript/SCsub
View File

@ -6,8 +6,6 @@ javascript_files = [
"javascript_main.cpp"
]
#env.Depends('#core/math/vector3.h', 'vector3_psp.h')
#obj = env.SharedObject('godot_javascript.cpp')
env_javascript = env.Clone()
@ -22,4 +20,4 @@ prog = None
#env_javascript.SharedLibrary("#platform/javascript/libgodot_javascript.so",[javascript_objects])
env.Program('#bin/godot.html', javascript_objects)
env.Program('#bin/godot',javascript_objects,PROGSUFFIX=env["PROGSUFFIX"]+".html")

11
platform/javascript/detect.py
View File

@ -46,11 +46,7 @@ def get_flags():
def configure(env):
env.Append(CPPPATH=['#platform/android'])
env['OBJSUFFIX'] = ".js.o"
env['LIBSUFFIX'] = ".js.a"
env['PROGSUFFIX'] = ".html"
env.Append(CPPPATH=['#platform/javascript'])
em_path=os.environ["EMSCRIPTEN_ROOT"]
@ -68,17 +64,12 @@ def configure(env):
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O2'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['-O2','-DDEBUG_ENABLED'])
env['OBJSUFFIX'] = "_optd"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_optd"+env['LIBSUFFIX']
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['-D_DEBUG', '-Wall', '-O2', '-DDEBUG_ENABLED'])
env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ALLOC'])

2
platform/osx/SCsub
View File

@ -8,4 +8,4 @@ files = [
# 'context_gl_osx.cpp',
]
env.Program('#bin/godot_osx',files)
env.Program('#bin/godot',files)

18
platform/osx/detect.py
View File

@ -38,42 +38,30 @@ def configure(env):
env.Append(CPPPATH=['#platform/osx'])
if (env["tools"]=="no"):
#no tools suffix
env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
if (env["bits"]=="default"):
env["bits"]="32"
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer','-ftree-vectorize','-msse2'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['-O2','-DDEBUG_ENABLED'])
env['OBJSUFFIX'] = "_optd"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_optd"+env['LIBSUFFIX']
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['-g3', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg'])
if (env["freetype"]!="no"):
env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
env.Append(CPPPATH=['#tools/freetype'])
env.Append(CPPPATH=['#tools/freetype/freetype/include'])
if (env["force_64_bits"]!="no"):
if (env["bits"]=="64"):
env.Append(CCFLAGS=['-arch', 'x86_64'])
env.Append(LINKFLAGS=['-arch', 'x86_64'])
env['OBJSUFFIX'] = ".64"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".64"+env['LIBSUFFIX']
else:
env.Append(CCFLAGS=['-arch', 'i386'])
env.Append(LINKFLAGS=['-arch', 'i386'])

38
platform/server/detect.py
View File

@ -41,50 +41,36 @@ def configure(env):
env["CXX"]="clang++"
env["LD"]="clang++"
env['OBJSUFFIX'] = ".srv"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".srv"+env['LIBSUFFIX']
is64=sys.maxsize > 2**32
if (env["force_32_bits"]!="no"):
env['OBJSUFFIX'] = ".32"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".32"+env['LIBSUFFIX']
if (env["bits"]=="default"):
if (is64):
env["bits"]="64"
else:
env["bits"]="32"
if (env["tools"]=="no"):
#no tools suffix
env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
#if (env["tools"]=="no"):
# #no tools suffix
# env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
# env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['-O2','-ffast-math','-DDEBUG_ENABLED'])
env['OBJSUFFIX'] = "_optd"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_optd"+env['LIBSUFFIX']
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['-g2', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg'])
env.Append(CPPFLAGS=['-DSERVER_ENABLED','-DUNIX_ENABLED'])
env.Append(LIBS=['pthread','z']) #TODO detect linux/BSD!
if (env["force_32_bits"]=="yes"):
env.Append(CPPFLAGS=['-m32'])
env.Append(LINKFLAGS=['-m32','-L/usr/lib/i386-linux-gnu'])
if (env["CXX"]=="clang++"):
env.Append(CPPFLAGS=['-DTYPED_METHOD_BIND'])
env["CC"]="clang"

2
platform/windows/SCsub
View File

@ -10,4 +10,4 @@ common_win=[
"stream_peer_winsock.cpp",
]
env.Program('#bin/godot.exe',['godot_win.cpp']+common_win)
env.Program('#bin/godot',['godot_win.cpp']+common_win,PROGSUFFIX=env["PROGSUFFIX"]+".exe")

109
platform/windows/detect.py
View File

@ -25,26 +25,38 @@ def can_build():
if (os.name=="posix"):
if os.system("i586-mingw32msvc-gcc --version") == 0:
mingw = "i586-mingw32msvc-"
mingw64 = "i686-w64-mingw32-"
if (os.getenv("MINGW32_PREFIX")):
mingw=os.getenv("MINGW32_PREFIX")
if (os.getenv("MINGW64_PREFIX")):
mingw64=os.getenv("MINGW64_PREFIX")
if os.system(mingw+"gcc --version >/dev/null") == 0 or os.system(mingw64+"gcc --version >/dev/null") ==0:
return True
return False
def get_opts():
mwp=""
mwp64=""
mingw=""
mingw64=""
if (os.name!="nt"):
mwp="i586-mingw32msvc-"
mwp64="x86_64-w64-mingw32-"
mingw = "i586-mingw32msvc-"
mingw64 = "i686-w64-mingw32-"
if (os.getenv("MINGW32_PREFIX")):
mingw=os.getenv("MINGW32_PREFIX")
if (os.getenv("MINGW64_PREFIX")):
mingw64=os.getenv("MINGW64_PREFIX")
return [
('force_64_bits','Force 64 bits binary','no'),
('force_32_bits','Force 32 bits binary','no'),
('mingw_prefix','Mingw Prefix',mwp),
('mingw_prefix_64','Mingw Prefix 64 bits',mwp64),
('mingw_prefix','Mingw Prefix',mingw),
('mingw_prefix_64','Mingw Prefix 64 bits',mingw64),
('mingw64_for_32','Use Mingw 64 for 32 Bits Build',"no"),
]
def get_flags():
@ -58,19 +70,8 @@ def get_flags():
def configure(env):
if os.name == "posix":
env['OBJSUFFIX'] = ".win"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".win"+env['LIBSUFFIX']
env.Append(CPPPATH=['#platform/windows'])
if (env["tools"]=="no"):
#no tools suffix
env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
#env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
env['platform_libsuffix'] = ".nt"+env['LIBSUFFIX']
if (os.name=="nt" and os.getenv("VSINSTALLDIR")!=None):
#build using visual studio
@ -89,21 +90,17 @@ def configure(env):
env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup'])
elif (env["target"]=="test"):
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED'])
env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO','/O1'])
env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DDEBUG_MEMORY_ENABLED','/DD3D_DEBUG_INFO','/O1'])
env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
env.Append(LINKFLAGS=['/DEBUG'])
elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg'])
env.Append(CCFLAGS=['/MT','/Gd','/GR','/nologo'])
env.Append(CXXFLAGS=['/TP'])
@ -142,44 +139,52 @@ def configure(env):
mingw_prefix=""
if (env["force_32_bits"]!="no"):
env['OBJSUFFIX'] = ".32"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".32"+env['LIBSUFFIX']
env.Append(CCFLAGS=['-m32'])
env.Append(LINKFLAGS=['-m32'])
env.Append(LINKFLAGS=['-static-libgcc'])
env.Append(LINKFLAGS=['-static-libstdc++'])
if (env["bits"]=="default"):
env["bits"]="32"
use64=False
if (env["bits"]=="32"):
if (env["mingw64_for_32"]=="yes"):
env.Append(CCFLAGS=['-m32'])
env.Append(LINKFLAGS=['-m32'])
env.Append(LINKFLAGS=['-static-libgcc'])
env.Append(LINKFLAGS=['-static-libstdc++'])
mingw_prefix=env["mingw_prefix_64"];
else:
mingw_prefix=env["mingw_prefix"];
if (env["force_64_bits"]!="no"):
mingw_prefix=env["mingw_prefix_64"];
env['OBJSUFFIX'] = ".64"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".64"+env['LIBSUFFIX']
env.Append(LINKFLAGS=['-static'])
else:
mingw_prefix=env["mingw_prefix"];
mingw_prefix=env["mingw_prefix_64"];
env.Append(LINKFLAGS=['-static'])
nulstr=""
if (os.name=="posix"):
nulstr=">/dev/null"
else:
nulstr=">nul"
if os.system(mingw_prefix+"gcc --version"+nulstr)!=0:
#not really super consistent but..
print("Can't find Windows compiler: "+mingw_prefix)
sys.exit(255)
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O3','-ffast-math','-fomit-frame-pointer','-msse2'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
env.Append(LINKFLAGS=['-Wl,--subsystem,windows'])
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['-O2','-DDEBUG_ENABLED'])
env['OBJSUFFIX'] = "_optd"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_optd"+env['LIBSUFFIX']
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['-g', '-Wall','-DDEBUG_ENABLED'])
elif (env["target"]=="release_tools"):
env.Append(CCFLAGS=['-O2','-Wall','-DDEBUG_ENABLED'])
env.Append(CCFLAGS=['-g', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
if (env["freetype"]!="no"):
env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])

2
platform/x11/SCsub
View File

@ -8,5 +8,3 @@ common_x11=[\
]
env.Program('#bin/godot',['godot_x11.cpp']+common_x11)
if env['target'] == "release":
env.Command('#bin/godot_rel', '#bin/godot', Copy('bin/godot_rel', 'bin/godot'))

64
platform/x11/detect.py
View File

@ -47,14 +47,11 @@ def get_opts():
return [
('use_llvm','Use llvm compiler','no'),
('use_sanitizer','Use llvm compiler sanitize address','no'),
('force_32_bits','Force 32 bits binary','no')
]
def get_flags():
return [
('opengl', 'no'),
('legacygl', 'yes'),
('builtin_zlib', 'no'),
("openssl", "yes"),
]
@ -63,6 +60,15 @@ def get_flags():
def configure(env):
is64=sys.maxsize > 2**32
if (env["bits"]=="default"):
if (is64):
env["bits"]="64"
else:
env["bits"]="32"
env.Append(CPPPATH=['#platform/x11'])
if (env["use_llvm"]=="yes"):
env["CC"]="clang"
@ -74,50 +80,23 @@ def configure(env):
if (env["tools"]=="no"):
#no tools suffix
env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
#if (env["tools"]=="no"):
# #no tools suffix
# env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
# env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer'])
env['OBJSUFFIX'] = "_opt"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_opt"+env['LIBSUFFIX']
elif (env["target"]=="release_debug"):
env.Append(CCFLAGS=['-O2','-ffast-math','-DDEBUG_ENABLED'])
env['OBJSUFFIX'] = "_optd"+env['OBJSUFFIX']
env['LIBSUFFIX'] = "_optd"+env['LIBSUFFIX']
# env.Append(CCFLAGS=['-Os','-ffast-math','-fomit-frame-pointer'])
#does not seem to have much effect
# env.Append(CCFLAGS=['-fno-default-inline'])
#recommended by wxwidgets
# env.Append(CCFLAGS=['-ffunction-sections','-fdata-sections'])
# env.Append(LINKFLAGS=['-Wl','--gc-sections'])
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['-g2', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
#does not seem to have much effect
# env.Append(CCFLAGS=['-fno-default-inline'])
#recommended by wxwidgets
# env.Append(CCFLAGS=['-ffunction-sections','-fdata-sections'])
# env.Append(LINKFLAGS=['-Wl','--gc-sections'])
elif (env["target"]=="debug_light"):
env.Append(CCFLAGS=['-g1', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg'])
env.ParseConfig('pkg-config x11 --cflags --libs')
env.ParseConfig('pkg-config xcursor --cflags --libs')
@ -128,19 +107,20 @@ def configure(env):
env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
if env['opengl'] == 'yes':
env.Append(CPPFLAGS=['-DOPENGL_ENABLED','-DGLEW_ENABLED'])
#env.Append(CPPFLAGS=["-DRTAUDIO_ENABLED"])
env.Append(CPPFLAGS=['-DOPENGL_ENABLED','-DGLEW_ENABLED'])
env.Append(CPPFLAGS=["-DALSA_ENABLED"])
env.Append(CPPFLAGS=['-DX11_ENABLED','-DUNIX_ENABLED','-DGLES2_ENABLED','-DGLES1_ENABLED','-DGLES_OVER_GL'])
# env.Append(CPPFLAGS=['-DX11_ENABLED','-DUNIX_ENABLED','-DGLES2_ENABLED','-DGLES_OVER_GL'])
env.Append(LIBS=['GL', 'GLU', 'pthread','asound','z']) #TODO detect linux/BSD!
#env.Append(CPPFLAGS=['-DMPC_FIXED_POINT'])
if (env["force_32_bits"]=="yes"):
#host compiler is default..
if (is64 and env["bits"]=="32"):
env.Append(CPPFLAGS=['-m32'])
env.Append(LINKFLAGS=['-m32','-L/usr/lib/i386-linux-gnu'])
env['OBJSUFFIX'] = ".32"+env['OBJSUFFIX']
env['LIBSUFFIX'] = ".32"+env['LIBSUFFIX']
elif (not is64 and env["bits"]=="32"):
env.Append(CPPFLAGS=['-m64'])
env.Append(LINKFLAGS=['-m64','-L/usr/lib/i686-linux-gnu'])
if (env["CXX"]=="clang++"):

1
scene/3d/SCsub
View File

@ -1,7 +1,6 @@
Import('env')
print("V: "+env["disable_3d"])
if (env["disable_3d"]=="yes"):
env.scene_sources.append("3d/spatial.cpp")

741
scene/3d/car_body.cpp
View File

@ -1,741 +0,0 @@
/*************************************************************************/
/* car_body.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "car_body.h"
#define DEG2RADMUL (Math_PI/180.0)
#define RAD2DEGMUL (180.0/Math_PI)
void CarWheel::_notification(int p_what) {
if (p_what==NOTIFICATION_ENTER_SCENE) {
if (!get_parent())
return;
CarBody *cb = get_parent()->cast_to<CarBody>();
if (!cb)
return;
body=cb;
local_xform=get_transform();
cb->wheels.push_back(this);
}
if (p_what==NOTIFICATION_EXIT_SCENE) {
if (!get_parent())
return;
CarBody *cb = get_parent()->cast_to<CarBody>();
if (!cb)
return;
cb->wheels.erase(this);
body=NULL;
}
}
void CarWheel::set_side_friction(real_t p_friction) {
side_friction=p_friction;
}
void CarWheel::set_forward_friction(real_t p_friction) {
forward_friction=p_friction;
}
void CarWheel::set_travel(real_t p_travel) {
travel=p_travel;
update_gizmo();
}
void CarWheel::set_radius(real_t p_radius) {
radius=p_radius;
update_gizmo();
}
void CarWheel::set_resting_frac(real_t p_frac) {
resting_frac=p_frac;
}
void CarWheel::set_damping_frac(real_t p_frac) {
damping_frac=p_frac;
}
void CarWheel::set_num_rays(real_t p_rays) {
num_rays=p_rays;
}
real_t CarWheel::get_side_friction() const{
return side_friction;
}
real_t CarWheel::get_forward_friction() const{
return forward_friction;
}
real_t CarWheel::get_travel() const{
return travel;
}
real_t CarWheel::get_radius() const{
return radius;
}
real_t CarWheel::get_resting_frac() const{
return resting_frac;
}
real_t CarWheel::get_damping_frac() const{
return damping_frac;
}
int CarWheel::get_num_rays() const{
return num_rays;
}
void CarWheel::update(real_t dt) {
if (dt <= 0.0f)
return;
float origAngVel = angVel;
if (locked)
{
angVel = 0;
torque = 0;
}
else
{
float wheelMass = 0.03f * body->mass;
float inertia = 0.5f * (radius * radius) * wheelMass;
angVel += torque * dt / inertia;
torque = 0;
// prevent friction from reversing dir - todo do this better
// by limiting the torque
if (((origAngVel > angVelForGrip) && (angVel < angVelForGrip)) ||
((origAngVel < angVelForGrip) && (angVel > angVelForGrip)))
angVel = angVelForGrip;
angVel += driveTorque * dt / inertia;
driveTorque = 0;
float maxAngVel = 200;
print_line("angvel: "+rtos(angVel));
angVel = CLAMP(angVel, -maxAngVel, maxAngVel);
axisAngle += Math::rad2deg(dt * angVel);
}
}
bool CarWheel::add_forces(PhysicsDirectBodyState *s) {
Vector3 force;
PhysicsDirectSpaceState *space = s->get_space_state();
Transform world = s->get_transform() * local_xform;
// OpenGl has differnet row/column order for matrixes than XNA has ..
//Vector3 wheelFwd = world.get_basis().get_axis(Vector3::AXIS_Z);
//Vector3 wheelFwd = RotationMatrix(mSteerAngle, worldAxis) * carBody.GetOrientation().GetCol(0);
Vector3 wheelUp = world.get_basis().get_axis(Vector3::AXIS_Y);
Vector3 wheelFwd = Matrix3(wheelUp,Math::deg2rad(steerAngle)).xform( world.get_basis().get_axis(Vector3::AXIS_Z) );
Vector3 wheelLeft = -wheelUp.cross(wheelFwd).normalized();
Vector3 worldPos = world.origin;
Vector3 worldAxis = wheelUp;
// start of ray
float rayLen = 2.0f * radius + travel;
Vector3 wheelRayEnd = worldPos - radius * worldAxis;
Vector3 wheelRayBegin = wheelRayEnd + rayLen * worldAxis;
//wheelRayEnd = -rayLen * worldAxis;
//Assert(PhysicsSystem.CurrentPhysicsSystem);
///Assert(collSystem);
///
const int maxNumRays = 32;
int numRaysUse = MIN(num_rays, maxNumRays);
// adjust the start position of the ray - divide the wheel into numRays+2
// rays, but don't use the first/last.
float deltaFwd = (2.0f * radius) / (numRaysUse + 1);
float deltaFwdStart = deltaFwd;
float fracs[maxNumRays];
Vector3 segmentEnds[maxNumRays];
Vector3 groundPositions[maxNumRays];
Vector3 groundNormals[maxNumRays];
lastOnFloor = false;
int bestIRay = 0;
int iRay;
for (iRay = 0; iRay < numRaysUse; ++iRay)
{
fracs[iRay] = 1e20;
// work out the offset relative to the middle ray
float distFwd = (deltaFwdStart + iRay * deltaFwd) - radius;
float zOffset = radius * (1.0f - (float)Math::cos( Math::deg2rad( 90.0f * (distFwd / radius))));
segmentEnds[iRay] = wheelRayEnd + distFwd * wheelFwd + zOffset * wheelUp;
PhysicsDirectSpaceState::RayResult rr;
bool collided = space->intersect_ray(wheelRayBegin,segmentEnds[iRay],rr,body->exclude);
if (collided){
lastOnFloor = true;
groundPositions[iRay]=rr.position;
groundNormals[iRay]=rr.normal;
fracs[iRay] = ((wheelRayBegin-rr.position).length() / (wheelRayBegin-wheelRayEnd).length());
if (fracs[iRay] < fracs[bestIRay])
bestIRay = iRay;
}
}
if (!lastOnFloor)
return false;
//Assert(bestIRay < numRays);
// use the best one
Vector3 groundPos = groundPositions[bestIRay];
float frac = fracs[bestIRay];
// const Vector3 groundNormal = (worldPos - segments[bestIRay].GetEnd()).NormaliseSafe();
// const Vector3 groundNormal = groundNormals[bestIRay];
Vector3 groundNormal = worldAxis;
if (numRaysUse > 1)
{
for (iRay = 0; iRay < numRaysUse; ++iRay)
{
if (fracs[iRay] <= 1.0f)
{
groundNormal += (1.0f - fracs[iRay]) * (worldPos - segmentEnds[iRay]);
}
}
groundNormal.normalize();
}
else
{
groundNormal = groundNormals[bestIRay];
}
float spring = (body->mass/body->wheels.size()) * s->get_total_gravity().length() / (resting_frac * travel);
float displacement = rayLen * (1.0f - frac);
displacement = CLAMP(displacement, 0, travel);
float displacementForceMag = displacement * spring;
// reduce force when suspension is par to ground
displacementForceMag *= groundNormals[bestIRay].dot(worldAxis);
// apply damping
float damping = 2.0f * (float)Math::sqrt(spring * body->mass);
damping /= body->wheels.size(); // assume wheels act together
damping *= damping_frac; // a bit bouncy
float upSpeed = (displacement - lastDisplacement) / s->get_step();
float dampingForceMag = upSpeed * damping;
float totalForceMag = displacementForceMag + dampingForceMag;
if (totalForceMag < 0.0f) totalForceMag = 0.0f;
Vector3 extraForce = totalForceMag * worldAxis;
force += extraForce;
// side-slip friction and drive force. Work out wheel- and floor-relative coordinate frame
Vector3 groundUp = groundNormal;
Vector3 groundLeft = groundNormal.cross(wheelFwd).normalized();
Vector3 groundFwd = groundLeft.cross(groundUp);
Vector3 wheelPointVel = s->get_linear_velocity() +
(s->get_angular_velocity()).cross(s->get_transform().basis.xform(local_xform.origin));// * mPos);
Vector3 rimVel = -angVel * wheelLeft.cross(groundPos - worldPos);
wheelPointVel += rimVel;
// if sitting on another body then adjust for its velocity.
/*if (worldBody != null)
{
Vector3 worldVel = worldBody.Velocity +
Vector3.Cross(worldBody.AngularVelocity, groundPos - worldBody.Position);
wheelPointVel -= worldVel;
}*/
// sideways forces
float noslipVel = 0.2f;
float slipVel = 0.4f;
float slipFactor = 0.7f;
float smallVel = 3;
float friction = side_friction;
float sideVel = wheelPointVel.dot(groundLeft);
if ((sideVel > slipVel) || (sideVel < -slipVel))
friction *= slipFactor;
else
if ((sideVel > noslipVel) || (sideVel < -noslipVel))
friction *= 1.0f - (1.0f - slipFactor) * (Math::absf(sideVel) - noslipVel) / (slipVel - noslipVel);
if (sideVel < 0.0f)
friction *= -1.0f;
if (Math::absf(sideVel) < smallVel)
friction *= Math::absf(sideVel) / smallVel;
float sideForce = -friction * totalForceMag;
extraForce = sideForce * groundLeft;
force += extraForce;
// fwd/back forces
friction = forward_friction;
float fwdVel = wheelPointVel.dot(groundFwd);
if ((fwdVel > slipVel) || (fwdVel < -slipVel))
friction *= slipFactor;
else
if ((fwdVel > noslipVel) || (fwdVel < -noslipVel))
friction *= 1.0f - (1.0f - slipFactor) * (Math::absf(fwdVel) - noslipVel) / (slipVel - noslipVel);
if (fwdVel < 0.0f)
friction *= -1.0f;
if (Math::absf(fwdVel) < smallVel)
friction *= Math::absf(fwdVel) / smallVel;
float fwdForce = -friction * totalForceMag;
extraForce = fwdForce * groundFwd;
force += extraForce;
//if (!force.IsSensible())
//{
// TRACE_FILE_IF(ONCE_1)
// TRACE("Bad force in car wheel\n");
// return true;
//}
// fwd force also spins the wheel
Vector3 wheelCentreVel = s->get_linear_velocity() +
(s->get_angular_velocity()).cross(s->get_transform().basis.xform(local_xform.origin));
angVelForGrip = wheelCentreVel.dot(groundFwd) / radius;
torque += -fwdForce * radius;
// add force to car
// carBody.AddWorldForce(force, groundPos);
s->add_force(force,(groundPos-s->get_transform().origin));
// add force to the world
/*
if (worldBody != null && !worldBody.Immovable)
{
// todo get the position in the right place...
// also limit the velocity that this force can produce by looking at the
// mass/inertia of the other object
float maxOtherBodyAcc = 500.0f;
float maxOtherBodyForce = maxOtherBodyAcc * worldBody.Mass;
if (force.LengthSquared() > (maxOtherBodyForce * maxOtherBodyForce))
force *= maxOtherBodyForce / force.Length();
worldBody.AddWorldForce(-force, groundPos);
}*/
Transform wheel_xf = local_xform;
wheel_xf.origin += wheelUp * displacement;
wheel_xf.basis = wheel_xf.basis * Matrix3(Vector3(0,1,0),Math::deg2rad(steerAngle));
//wheel_xf.basis = wheel_xf.basis * Matrix3(wheel_xf.basis[0],-Math::deg2rad(axisAngle));
set_transform(wheel_xf);
lastDisplacement=displacement;
return true;
}
void CarWheel::set_type_drive(bool p_enable) {
type_drive=p_enable;
}
bool CarWheel::is_type_drive() const {
return type_drive;
}
void CarWheel::set_type_steer(bool p_enable) {
type_steer=p_enable;
}
bool CarWheel::is_type_steer() const {
return type_steer;
}
void CarWheel::_bind_methods() {
ObjectTypeDB::bind_method(_MD("set_side_friction","friction"),&CarWheel::set_side_friction);
ObjectTypeDB::bind_method(_MD("set_forward_friction","friction"),&CarWheel::set_forward_friction);
ObjectTypeDB::bind_method(_MD("set_travel","distance"),&CarWheel::set_travel);
ObjectTypeDB::bind_method(_MD("set_radius","radius"),&CarWheel::set_radius);
ObjectTypeDB::bind_method(_MD("set_resting_frac","frac"),&CarWheel::set_resting_frac);
ObjectTypeDB::bind_method(_MD("set_damping_frac","frac"),&CarWheel::set_damping_frac);
ObjectTypeDB::bind_method(_MD("set_num_rays","amount"),&CarWheel::set_num_rays);
ObjectTypeDB::bind_method(_MD("get_side_friction"),&CarWheel::get_side_friction);
ObjectTypeDB::bind_method(_MD("get_forward_friction"),&CarWheel::get_forward_friction);
ObjectTypeDB::bind_method(_MD("get_travel"),&CarWheel::get_travel);
ObjectTypeDB::bind_method(_MD("get_radius"),&CarWheel::get_radius);
ObjectTypeDB::bind_method(_MD("get_resting_frac"),&CarWheel::get_resting_frac);
ObjectTypeDB::bind_method(_MD("get_damping_frac"),&CarWheel::get_damping_frac);
ObjectTypeDB::bind_method(_MD("get_num_rays"),&CarWheel::get_num_rays);
ObjectTypeDB::bind_method(_MD("set_type_drive","enable"),&CarWheel::set_type_drive);
ObjectTypeDB::bind_method(_MD("is_type_drive"),&CarWheel::is_type_drive);
ObjectTypeDB::bind_method(_MD("set_type_steer","enable"),&CarWheel::set_type_steer);
ObjectTypeDB::bind_method(_MD("is_type_steer"),&CarWheel::is_type_steer);
ADD_PROPERTY( PropertyInfo(Variant::BOOL,"type/drive"),_SCS("set_type_drive"),_SCS("is_type_drive"));
ADD_PROPERTY( PropertyInfo(Variant::BOOL,"type/steer"),_SCS("set_type_steer"),_SCS("is_type_steer"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/side_friction",PROPERTY_HINT_RANGE,"0.01,64,0.01"),_SCS("set_side_friction"),_SCS("get_side_friction"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/forward_friction",PROPERTY_HINT_RANGE,"0.01,64,0.01"),_SCS("set_forward_friction"),_SCS("get_forward_friction"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/travel",PROPERTY_HINT_RANGE,"0.01,1024,0.01"),_SCS("set_travel"),_SCS("get_travel"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/radius",PROPERTY_HINT_RANGE,"0.01,1024,0.01"),_SCS("set_radius"),_SCS("get_radius"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/resting_frac",PROPERTY_HINT_RANGE,"0.01,64,0.01"),_SCS("set_resting_frac"),_SCS("get_resting_frac"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/damping_frac",PROPERTY_HINT_RANGE,"0.01,64,0.01"),_SCS("set_damping_frac"),_SCS("get_damping_frac"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/num_rays",PROPERTY_HINT_RANGE,"1,32,1"),_SCS("set_num_rays"),_SCS("get_num_rays"));
}
CarWheel::CarWheel() {
side_friction=4.7;
forward_friction=5.0;
travel=0.2;
radius=0.4;
resting_frac=0.45;
damping_frac=0.3;
num_rays=1;
angVel = 0.0f;
steerAngle = 0.0f;
torque = 0.0f;
driveTorque = 0.0f;
axisAngle = 0.0f;
upSpeed = 0.0f;
locked = false;
lastDisplacement = 0.0f;
lastOnFloor = false;
angVelForGrip = 0.0f;
angVelForGrip=0;
type_drive=false;
type_steer=false;
}
///
void CarBody::set_max_steer_angle(real_t p_angle) {
max_steer_angle=p_angle;
}
void CarBody::set_steer_rate(real_t p_rate) {
steer_rate=p_rate;
}
void CarBody::set_drive_torque(real_t p_torque) {
drive_torque=p_torque;
}
real_t CarBody::get_max_steer_angle() const{
return max_steer_angle;
}
real_t CarBody::get_steer_rate() const{
return steer_rate;
}
real_t CarBody::get_drive_torque() const{
return drive_torque;
}
void CarBody::set_target_steering(float p_steering) {
target_steering=p_steering;
}
void CarBody::set_target_accelerate(float p_accelerate) {
target_accelerate=p_accelerate;
}
void CarBody::set_hand_brake(float p_amont) {
hand_brake=p_amont;
}
real_t CarBody::get_target_steering() const {
return target_steering;
}
real_t CarBody::get_target_accelerate() const {
return target_accelerate;
}
real_t CarBody::get_hand_brake() const {
return hand_brake;
}
void CarBody::_direct_state_changed(Object *p_state) {
PhysicsDirectBodyState *state=p_state->cast_to<PhysicsDirectBodyState>();
float dt = state->get_step();
AABB aabb;
int drive_total=0;
for(int i=0;i<wheels.size();i++) {
CarWheel *w=wheels[i];
if (i==0) {
aabb.pos=w->local_xform.origin;
} else {
aabb.expand_to(w->local_xform.origin);
}
if (w->type_drive)
drive_total++;
}
// control inputs
float deltaAccelerate = dt * 4.0f;
float dAccelerate = target_accelerate - accelerate;
dAccelerate = CLAMP(dAccelerate, -deltaAccelerate, deltaAccelerate);
accelerate += dAccelerate;
float deltaSteering = dt * steer_rate;
float dSteering = target_steering - steering;
dSteering = CLAMP(dSteering, -deltaSteering, deltaSteering);
steering += dSteering;
// apply these inputs
float maxTorque = drive_torque;
float torque_div = drive_total/2;
if (torque_div>0)
maxTorque/=torque_div;
float alpha = ABS(max_steer_angle * steering);
float angleSgn = steering > 0.0f ? 1.0f : -1.0f;
int wheels_on_floor=0;
for(int i=0;i<wheels.size();i++) {
CarWheel *w=wheels[i];
if (w->type_drive)
w->driveTorque+=maxTorque * accelerate;
w->locked = !w->type_steer && (hand_brake > 0.5f);
if (w->type_steer) {
//steering
bool inner = (steering > 0 && w->local_xform.origin.x > 0) || (steering < 0 && w->local_xform.origin.x < 0);
if (inner || alpha==0.0) {
w->steerAngle = (angleSgn * alpha);
} else {
float dx = aabb.size.z;
float dy = aabb.size.x;
float beta = Math::atan2(dy, dx + (dy / (float)Math::tan(Math::deg2rad(alpha))));
beta = Math::rad2deg(beta);
w->steerAngle = (angleSgn * beta);
}
}
if (w->add_forces(state))
wheels_on_floor++;
w->update(dt);
}
print_line("onfloor: "+itos(wheels_on_floor));
set_ignore_transform_notification(true);
set_global_transform(state->get_transform());
linear_velocity=state->get_linear_velocity();
angular_velocity=state->get_angular_velocity();
//active=!state->is_sleeping();
//if (get_script_instance())
// get_script_instance()->call("_integrate_forces",state);
set_ignore_transform_notification(false);
}
void CarBody::set_mass(real_t p_mass) {
mass=p_mass;
PhysicsServer::get_singleton()->body_set_param(get_rid(),PhysicsServer::BODY_PARAM_MASS,mass);
}
real_t CarBody::get_mass() const{
return mass;
}
void CarBody::set_friction(real_t p_friction) {
friction=p_friction;
PhysicsServer::get_singleton()->body_set_param(get_rid(),PhysicsServer::BODY_PARAM_FRICTION,friction);
}
real_t CarBody::get_friction() const{
return friction;
}
void CarBody::_bind_methods() {
ObjectTypeDB::bind_method(_MD("set_max_steer_angle","value"),&CarBody::set_max_steer_angle);
ObjectTypeDB::bind_method(_MD("set_steer_rate","rate"),&CarBody::set_steer_rate);
ObjectTypeDB::bind_method(_MD("set_drive_torque","value"),&CarBody::set_drive_torque);
ObjectTypeDB::bind_method(_MD("get_max_steer_angle"),&CarBody::get_max_steer_angle);
ObjectTypeDB::bind_method(_MD("get_steer_rate"),&CarBody::get_steer_rate);
ObjectTypeDB::bind_method(_MD("get_drive_torque"),&CarBody::get_drive_torque);
ObjectTypeDB::bind_method(_MD("set_target_steering","amount"),&CarBody::set_target_steering);
ObjectTypeDB::bind_method(_MD("set_target_accelerate","amount"),&CarBody::set_target_accelerate);
ObjectTypeDB::bind_method(_MD("set_hand_brake","amount"),&CarBody::set_hand_brake);
ObjectTypeDB::bind_method(_MD("get_target_steering"),&CarBody::get_target_steering);
ObjectTypeDB::bind_method(_MD("get_target_accelerate"),&CarBody::get_target_accelerate);
ObjectTypeDB::bind_method(_MD("get_hand_brake"),&CarBody::get_hand_brake);
ObjectTypeDB::bind_method(_MD("set_mass","mass"),&CarBody::set_mass);
ObjectTypeDB::bind_method(_MD("get_mass"),&CarBody::get_mass);
ObjectTypeDB::bind_method(_MD("set_friction","friction"),&CarBody::set_friction);
ObjectTypeDB::bind_method(_MD("get_friction"),&CarBody::get_friction);
ObjectTypeDB::bind_method(_MD("_direct_state_changed"),&CarBody::_direct_state_changed);
ADD_PROPERTY( PropertyInfo(Variant::REAL,"body/mass",PROPERTY_HINT_RANGE,"0.01,65536,0.01"),_SCS("set_mass"),_SCS("get_mass"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"body/friction",PROPERTY_HINT_RANGE,"0.01,1,0.01"),_SCS("set_friction"),_SCS("get_friction"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/max_steer_angle",PROPERTY_HINT_RANGE,"1,90,1"),_SCS("set_max_steer_angle"),_SCS("get_max_steer_angle"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/drive_torque",PROPERTY_HINT_RANGE,"0.01,64,0.01"),_SCS("set_drive_torque"),_SCS("get_drive_torque"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"config/steer_rate",PROPERTY_HINT_RANGE,"0.01,64,0.01"),_SCS("set_steer_rate"),_SCS("get_steer_rate"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"drive/target_steering",PROPERTY_HINT_RANGE,"-1,1,0.01"),_SCS("set_target_steering"),_SCS("get_target_steering"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"drive/target_accelerate",PROPERTY_HINT_RANGE,"-1,1,0.01"),_SCS("set_target_accelerate"),_SCS("get_target_accelerate"));
ADD_PROPERTY( PropertyInfo(Variant::REAL,"drive/hand_brake",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_hand_brake"),_SCS("get_hand_brake"));
}
CarBody::CarBody() : PhysicsBody(PhysicsServer::BODY_MODE_RIGID) {
forward_drive=true;
backward_drive=true;
max_steer_angle=30;
steer_rate=1;
drive_torque=520;
target_steering=0;
target_accelerate=0;
hand_brake=0;
steering=0;
accelerate=0;
mass=1;
friction=1;
ccd=false;
// can_sleep=true;
exclude.insert(get_rid());
PhysicsServer::get_singleton()->body_set_force_integration_callback(get_rid(),this,"_direct_state_changed");
}

170
scene/3d/car_body.h
View File

@ -1,170 +0,0 @@
/*************************************************************************/
/* car_body.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef CAR_BODY_H
#define CAR_BODY_H
#include "scene/3d/physics_body.h"
class CarBody;
class CarWheel : public Spatial {
OBJ_TYPE(CarWheel,Spatial);
friend class CarBody;
real_t side_friction;
real_t forward_friction;
real_t travel;
real_t radius;
real_t resting_frac;
real_t damping_frac;
int num_rays;
Transform local_xform;
CarBody *body;
float angVel;
float steerAngle;
float torque;
float driveTorque;
float axisAngle;
float upSpeed; // speed relative to the car
bool locked;
// last frame stuff
float lastDisplacement;
float angVelForGrip;
bool lastOnFloor;
bool type_drive;
bool type_steer;
protected:
void update(real_t dt);
bool add_forces(PhysicsDirectBodyState *s);
void _notification(int p_what);
static void _bind_methods();
public:
void set_side_friction(real_t p_friction);
void set_forward_friction(real_t p_friction);
void set_travel(real_t p_travel);
void set_radius(real_t p_radius);
void set_resting_frac(real_t p_frac);
void set_damping_frac(real_t p_frac);
void set_num_rays(real_t p_rays);
real_t get_side_friction() const;
real_t get_forward_friction() const;
real_t get_travel() const;
real_t get_radius() const;
real_t get_resting_frac() const;
real_t get_damping_frac() const;
int get_num_rays() const;
void set_type_drive(bool p_enable);
bool is_type_drive() const;
void set_type_steer(bool p_enable);
bool is_type_steer() const;
CarWheel();
};
class CarBody : public PhysicsBody {
OBJ_TYPE(CarBody,PhysicsBody);
real_t mass;
real_t friction;
Vector3 linear_velocity;
Vector3 angular_velocity;
bool ccd;
real_t max_steer_angle;
real_t steer_rate;
int wheel_num_rays;
real_t drive_torque;
// control stuff
real_t target_steering;
real_t target_accelerate;
bool forward_drive;
bool backward_drive;
real_t steering;
real_t accelerate;
real_t hand_brake;
Set<RID> exclude;
friend class CarWheel;
Vector<CarWheel*> wheels;
static void _bind_methods();
void _direct_state_changed(Object *p_state);
public:
void set_mass(real_t p_mass);
real_t get_mass() const;
void set_friction(real_t p_friction);
real_t get_friction() const;
void set_max_steer_angle(real_t p_angle);
void set_steer_rate(real_t p_rate);
void set_drive_torque(real_t p_torque);
real_t get_max_steer_angle() const;
real_t get_steer_rate() const;
real_t get_drive_torque() const;
void set_target_steering(float p_steering);
void set_target_accelerate(float p_accelerate);
void set_hand_brake(float p_amont);
real_t get_target_steering() const;
real_t get_target_accelerate() const;
real_t get_hand_brake() const;
CarBody();
};
#endif // CAR_BODY_H

85
scene/3d/editable_shape.cpp
View File

@ -1,85 +0,0 @@
/*************************************************************************/
/* editable_shape.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "editable_shape.h"
void EditableShape::_notification(int p_what) {
}
void EditableShape::set_bsp_tree(const BSP_Tree& p_bsp) {
bsp=p_bsp;
}
void EditableShape::set_shape(const Ref<Shape>& p_shape) {
shape=p_shape;
}
EditableShape::EditableShape()
{
}
/////////////////////////
void EditableSphere::set_radius(float p_radius) {
radius=p_radius;
update_gizmo();
_change_notify("params/radius");
}
float EditableSphere::get_radius() const{
return radius;
}
void EditableSphere::_bind_methods() {
ObjectTypeDB::bind_method(_MD("set_radius","radius"),&EditableSphere::set_radius);
ObjectTypeDB::bind_method(_MD("get_radius"),&EditableSphere::get_radius);
ADD_PROPERTY( PropertyInfo(Variant::REAL,"params/radius",PROPERTY_HINT_EXP_RANGE,"0.001,16384,0.001"),_SCS("set_radius"),_SCS("get_radius"));
}
EditableSphere::EditableSphere() {
radius=1.0;
}

73
scene/3d/editable_shape.h
View File

@ -1,73 +0,0 @@
/*************************************************************************/
/* editable_shape.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef EDITABLE_SHAPE_H
#define EDITABLE_SHAPE_H
#include "scene/3d/spatial.h"
#include "scene/resources/shape.h"
class EditableShape : public Spatial {
OBJ_TYPE(EditableShape,Spatial);
//can hold either of those
BSP_Tree bsp;
Ref<Shape> shape;
void _update_parent();
protected:
void _notification(int p_what);
void set_bsp_tree(const BSP_Tree& p_bsp);
void set_shape(const Ref<Shape>& p_shape);
public:
EditableShape();
};
class EditableSphere : public EditableShape {
OBJ_TYPE( EditableSphere, EditableShape );
float radius;
protected:
static void _bind_methods();
public:
void set_radius(float p_radius);
float get_radius() const;
EditableSphere();
};
#endif // EDITABLE_SHAPE_H

2
scene/SCsub
View File

@ -15,7 +15,7 @@ SConscript('resources/SCsub');
SConscript('io/SCsub');
lib = env.Library("scene",env.scene_sources, LIBSUFFIX=env['platform_libsuffix'])
lib = env.Library("scene",env.scene_sources)
env.Prepend(LIBS=[lib])

851
scene/io/scene_format_object.cpp
View File

@ -1,851 +0,0 @@
/*************************************************************************/
/* scene_format_object.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "scene_format_object.h"
#include "print_string.h"
#include "globals.h"
#include "scene/resources/packed_scene.h"
#include "io/resource_loader.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
void SceneFormatSaverObject::save_node(const Node* p_root,const Node* p_node,const Node* p_owner,ObjectFormatSaver *p_saver,String p_base_path,uint32_t p_flags,Map<const Node*,uint32_t>& owner_id) const {
if (p_node!=p_root && p_node->get_owner()==NULL)
return;
if (p_flags&SceneSaver::FLAG_BUNDLE_INSTANCED_SCENES || p_node->get_owner() == p_owner || p_node == p_owner ) {
Dictionary d;
if (p_root!=p_node) {
d["path"]=p_root->get_path_to(p_node->get_parent());
}
d["name"]=p_node->get_name();
/* Connections */
List<MethodInfo> signal_list;
p_node->get_signal_list(&signal_list);
int conn_count=0;
Set<Node::Connection> exclude_connections;
if (!(p_flags&SceneSaver::FLAG_BUNDLE_INSTANCED_SCENES)) {
Vector<Node::Connection> ex = p_node->get_instance_connections();
for(int i=0;i<ex.size();i++) {
exclude_connections.insert(ex[i]);
}
}
for (List<MethodInfo>::Element *S=signal_list.front();S;S=S->next()) {
List<Node::Connection> connections;
p_node->get_signal_connection_list(S->get().name,&connections);
for(List<Node::Connection>::Element *E=connections.front();E;E=E->next()) {
Node::Connection &c=E->get();
if (!(c.flags&Object::CONNECT_PERSIST))
continue;
if (exclude_connections.has(c))
continue;
Node *target = c.target->cast_to<Node>();
if (!target)
continue; //connected to something not a node, ignoring
Dictionary cd;
cd["signal"]=c.signal;
cd["target"]=p_node->get_path_to(target);
cd["method"]=c.method;
cd["realtime"]=!(c.flags&Object::CONNECT_DEFERRED);
if (c.binds.size())
cd["binds"]=c.binds;
d["connection/"+itos(conn_count+1)]=cd;
conn_count++;
}
}
d["connection_count"]=conn_count;
if (owner_id.has(p_node->get_owner())) {
d["owner"]=owner_id[p_node->get_owner()];
}
/* Groups */
DVector<String> group_array;
List<Node::GroupInfo> groups;
p_node->get_groups(&groups);
Set<StringName> exclude_groups;
if (!(p_flags&SceneSaver::FLAG_BUNDLE_INSTANCED_SCENES)) {
//generate groups to exclude (came from instance)
Vector<StringName> eg;
eg=p_node->get_instance_groups();
for(int i=0;i<eg.size();i++)
exclude_groups.insert(eg[i]);
}
for(List<Node::GroupInfo>::Element*E=groups.front();E;E=E->next()) {
if (E->get().persistent && !exclude_groups.has(E->get().name))
group_array.push_back(E->get().name);
}
if (group_array.size())
d["groups"]=group_array;
/* Save */
if (p_owner!=p_node && p_node->get_filename()!="") {
String instance_path;
if (p_flags&SceneSaver::FLAG_RELATIVE_PATHS)
instance_path=p_base_path.path_to_file(Globals::get_singleton()->localize_path(p_node->get_filename()));
else
instance_path=p_node->get_filename();
d["instance"]=instance_path;
if (p_flags&SceneSaver::FLAG_BUNDLE_INSTANCED_SCENES) {
int id = owner_id.size();
d["owner_id"]=id;
owner_id[p_node]=id;
p_saver->save(p_node,d);
//owner change!
for (int i=0;i<p_node->get_child_count();i++) {
save_node(p_root,p_node->get_child(i),p_node,p_saver,p_base_path,p_flags,owner_id);
}
return;
} else {
DVector<String> prop_names;
Array prop_values;
List<PropertyInfo> properties;
p_node->get_property_list(&properties);
//instance state makes sure that only changes to instance are saved
Dictionary instance_state=p_node->get_instance_state();
for(List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) {
if (!(E->get().usage&PROPERTY_USAGE_STORAGE))
continue;
String name=E->get().name;
Variant value=p_node->get(E->get().name);
if (!instance_state.has(name))
continue; // did not change since it was loaded, not save
if (value==instance_state[name])
continue;
prop_names.push_back( name );
prop_values.push_back( value );
}
d["override_names"]=prop_names;
d["override_values"]=prop_values;
p_saver->save(NULL,d);
}
} else {
p_saver->save(p_node,d);
}
}
for (int i=0;i<p_node->get_child_count();i++) {
save_node(p_root,p_node->get_child(i),p_owner,p_saver,p_base_path,p_flags,owner_id);
}
}
Error SceneFormatSaverObject::save(const String &p_path,const Node* p_scene,uint32_t p_flags,const Ref<OptimizedSaver> &p_optimizer) {
String extension=p_path.extension();
if (extension=="scn")
extension="bin";
if (extension=="xscn")
extension="xml";
String local_path=Globals::get_singleton()->localize_path(p_path);
uint32_t saver_flags=0;
if (p_flags&SceneSaver::FLAG_RELATIVE_PATHS)
saver_flags|=ObjectSaver::FLAG_RELATIVE_PATHS;
if (p_flags&SceneSaver::FLAG_BUNDLE_RESOURCES)
saver_flags|=ObjectSaver::FLAG_BUNDLE_RESOURCES;
if (p_flags&SceneSaver::FLAG_OMIT_EDITOR_PROPERTIES)
saver_flags|=ObjectSaver::FLAG_OMIT_EDITOR_PROPERTIES;
if (p_flags&SceneSaver::FLAG_SAVE_BIG_ENDIAN)
saver_flags|=ObjectSaver::FLAG_SAVE_BIG_ENDIAN;
ObjectFormatSaver *saver = ObjectSaver::instance_format_saver(local_path,"SCENE",extension,saver_flags,p_optimizer);
ERR_FAIL_COND_V(!saver,ERR_FILE_UNRECOGNIZED);
/* SAVE SCENE */
Map<const Node*,uint32_t> node_id_map;
save_node(p_scene,p_scene,p_scene,saver,local_path,p_flags,node_id_map);
memdelete(saver);
return OK;
}
void SceneFormatSaverObject::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("xml");
p_extensions->push_back("scn");
p_extensions->push_back("xscn");
// ObjectSaver::get_recognized_extensions(p_extensions);
}
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
void SceneFormatLoaderObject::_apply_meta(Node *node, const Variant&meta, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,Map<uint32_t,Node*>& owner_map) {
r_err = OK;
Dictionary d=meta;
if (!d.has("name")) {
r_err=ERR_WTF;
memdelete(node);
ERR_FAIL_COND(!d.has("name"));
}
node->set_name(d["name"]);
int connection_count=d.has("connection_count")?d["connection_count"].operator int():0;
for (int i=0;i<connection_count;i++) {
Dictionary cd=d["connection/"+itos(i+1)];
ERR_CONTINUE(!cd.has("target"));
ERR_CONTINUE(!cd.has("method"));
ERR_CONTINUE(!cd.has("realtime"));
ERR_CONTINUE(!cd.has("signal"));
ConnectionItem ci;
ci.node=node;
ci.target=cd["target"];
ci.method=cd["method"];
ci.signal=cd["signal"];
ci.realtime=cd["realtime"];
if (cd.has("binds"))
ci.binds=cd["binds"];
connections.push_back(ci);
}
DVector<String> groups=d.has("groups")?d["groups"].operator DVector<String>():DVector<String>();
for (int i=0;i<groups.size();i++) {
node->add_to_group(groups[i],true);
}
}
Ref<SceneInteractiveLoader> SceneFormatLoaderObject::load_interactive(const String &p_path,bool p_save_root_state) {
SceneInteractiveLoaderObject *sil = memnew( SceneInteractiveLoaderObject(p_path,p_save_root_state) );
if (sil->error!=OK) {
memdelete( sil );
return Ref<SceneInteractiveLoader>();
}
return Ref<SceneInteractiveLoader>( sil );
}
Node* SceneFormatLoaderObject::load_node(Object *obj, const Variant& meta, Node *p_root, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,bool p_save_instance_state,Map<uint32_t,Node*>& owner_map) {
r_err = OK;
Node *node=obj->cast_to<Node>();
_apply_meta(node,meta,p_loader,connections,r_err,owner_map);
if (r_err!=OK)
return NULL;
Dictionary d=meta;
if (p_root) {
NodePath path=d.has("path")?d["path"].operator NodePath():NodePath(".");
Node *parent=p_root->get_node(path);
if (!parent) {
memdelete(node);
r_err=ERR_FILE_CORRUPT;
ERR_FAIL_COND_V(!parent,NULL);
}
parent->add_child(node);
if (d.has("owner_id")) {
//is owner
owner_map[d["owner_id"]]=node;
if (d.has("instance"))
node->set_filename(d["instance"]);
}
if (d.has("owner")) {
uint32_t owner = d["owner"];
ERR_FAIL_COND_V(!owner_map.has(owner),NULL);
node->set_owner(owner_map[owner]);
} else {
node->set_owner(p_root);
}
}
return node;
}
void SceneFormatLoaderObject::_apply_connections(List<ConnectionItem>& connections) {
int idx=0;
for (List<ConnectionItem>::Element *E=connections.front();E;E=E->next()) {
ConnectionItem &ci=E->get();
Node *target = ci.node->get_node(ci.target);
ERR_CONTINUE(!target);
ci.node->connect(ci.signal,target,ci.method,ci.binds,(ci.realtime?0:Object::CONNECT_DEFERRED)|Object::CONNECT_PERSIST);
idx++;
}
}
Node* SceneFormatLoaderObject::load(const String &p_path,bool p_save_instance_state) {
List<ConnectionItem> connections;
String extension=p_path.extension();
if (extension=="scn")
extension="bin";
if (extension=="xscn")
extension="xml";
String local_path = Globals::get_singleton()->localize_path(p_path);
ObjectFormatLoader *loader = ObjectLoader::instance_format_loader(local_path,"SCENE",extension);
ERR_EXPLAIN("Couldn't load scene: "+p_path);
ERR_FAIL_COND_V(!loader,NULL);
Node *root=NULL;
Map<uint32_t,Node*> owner_map;
while(true) {
Object *obj=NULL;
Variant metav;
Error r_err=loader->load(&obj,metav);
if (r_err == ERR_SKIP) {
continue;
};
if (r_err==ERR_FILE_EOF) {
memdelete(loader);
ERR_FAIL_COND_V(!root,NULL);
_apply_connections(connections);
return root;
}
if (r_err || (!obj && metav.get_type()==Variant::NIL)) {
memdelete(loader);
ERR_EXPLAIN("Object Loader Failed for Scene: "+p_path) ;
ERR_FAIL_COND_V( r_err, NULL);
ERR_EXPLAIN("Object Loader Failed for Scene: "+p_path) ;
ERR_FAIL_COND_V( !obj && metav.get_type()==Variant::NIL,NULL);
}
if (obj) {
if (obj->cast_to<Node>()) {
Error err;
Node* node = load_node(obj, metav, root, loader,connections,err,p_save_instance_state,owner_map);
if (err)
memdelete(loader);
ERR_FAIL_COND_V( err, NULL );
if (!root)
root=node;
} else {
memdelete(loader);
ERR_FAIL_V( NULL );
}
} else {
// check for instance
Dictionary meta=metav;
if (meta.has("instance")) {
if (!root) {
memdelete(loader);
ERR_FAIL_COND_V(!root,NULL);
}
String path = meta["instance"];
if (path.find("://")==-1 && path.is_rel_path()) {
// path is relative to file being loaded, so convert to a resource path
path=Globals::get_singleton()->localize_path(
local_path.get_base_dir()+"/"+path);
}
Node *scene = SceneLoader::load(path);
if (!scene) {
Ref<PackedScene> sd = ResourceLoader::load(path);
if (sd.is_valid()) {
scene=sd->instance();
}
}
if (!scene) {
memdelete(loader);
ERR_FAIL_COND_V(!scene,NULL);
}
if (p_save_instance_state)
scene->generate_instance_state();
Error err;
_apply_meta(scene,metav,loader,connections,err,owner_map);
if (err!=OK) {
memdelete(loader);
ERR_FAIL_COND_V(err!=OK,NULL);
}
Node *parent=root;
if (meta.has("path"))
parent=root->get_node(meta["path"]);
if (!parent) {
memdelete(loader);
ERR_FAIL_COND_V(!parent,NULL);
}
if (meta.has("override_names") && meta.has("override_values")) {
DVector<String> override_names=meta["override_names"];
Array override_values=meta["override_values"];
int len = override_names.size();
if ( len > 0 && len == override_values.size() ) {
DVector<String>::Read names = override_names.read();
for(int i=0;i<len;i++) {
scene->set(names[i],override_values[i]);
}
}
}
scene->set_filename(path);
parent->add_child(scene);
scene->set_owner(root);
}
}
}
return NULL;
}
void SceneFormatLoaderObject::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("xml");
p_extensions->push_back("scn");
p_extensions->push_back("xscn");
// ObjectLoader::get_recognized_extensions(p_extensions);
}
///////////////////////////////////////////////////
void SceneInteractiveLoaderObject::_apply_meta(Node *node, const Variant&meta, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,Map<uint32_t,Node*>& owner_map) {
r_err = OK;
Dictionary d=meta;
if (!d.has("name")) {
r_err=ERR_WTF;
memdelete(node);
ERR_FAIL_COND(!d.has("name"));
}
node->set_name(d["name"]);
int connection_count=d.has("connection_count")?d["connection_count"].operator int():0;
for (int i=0;i<connection_count;i++) {
Dictionary cd=d["connection/"+itos(i+1)];
ERR_CONTINUE(!cd.has("target"));
ERR_CONTINUE(!cd.has("method"));
ERR_CONTINUE(!cd.has("realtime"));
ERR_CONTINUE(!cd.has("signal"));
ConnectionItem ci;
ci.node=node;
ci.target=cd["target"];
ci.method=cd["method"];
ci.signal=cd["signal"];
ci.realtime=cd["realtime"];
if (cd.has("binds"))
ci.binds=cd["binds"];
connections.push_back(ci);
}
DVector<String> groups=d.has("groups")?d["groups"].operator DVector<String>():DVector<String>();
for (int i=0;i<groups.size();i++) {
node->add_to_group(groups[i],true);
}
}
Node* SceneInteractiveLoaderObject::load_node(Object *obj, const Variant& meta, Node *p_root, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,bool p_save_instance_state,Map<uint32_t,Node*>& owner_map) {
r_err = OK;
Node *node=obj->cast_to<Node>();
_apply_meta(node,meta,p_loader,connections,r_err,owner_map);
if (r_err!=OK)
return NULL;
Dictionary d=meta;
if (p_root) {
NodePath path=d.has("path")?d["path"].operator NodePath():NodePath(".");
Node *parent=p_root->get_node(path);
if (!parent) {
memdelete(node);
r_err=ERR_FILE_CORRUPT;
ERR_FAIL_COND_V(!parent,NULL);
}
parent->add_child(node);
if (d.has("owner_id")) {
//is owner
owner_map[d["owner_id"]]=node;
if (d.has("instance"))
node->set_filename(d["instance"]);
}
if (d.has("owner")) {
uint32_t owner = d["owner"];
ERR_FAIL_COND_V(!owner_map.has(owner),NULL);
node->set_owner(owner_map[owner]);
} else {
node->set_owner(p_root);
}
}
return node;
}
void SceneInteractiveLoaderObject::_apply_connections(List<ConnectionItem>& connections) {
int idx=0;
for (List<ConnectionItem>::Element *E=connections.front();E;E=E->next()) {
ConnectionItem &ci=E->get();
Node *target = ci.node->get_node(ci.target);
ERR_CONTINUE(!target);
ci.node->connect(ci.signal,target,ci.method,ci.binds,(ci.realtime?0:Object::CONNECT_DEFERRED)|Object::CONNECT_PERSIST);
idx++;
}
}
SceneInteractiveLoaderObject::SceneInteractiveLoaderObject(const String &p_path,bool p_save_root_state) {
error=OK;
path=p_path;
save_instance_state=p_save_root_state;
node_path=p_path;
root=NULL;
stage_max=1;
stage=0;
String extension=p_path.extension();
if (extension=="scn")
extension="bin";
if (extension=="xscn")
extension="xml";
local_path = Globals::get_singleton()->localize_path(p_path);
loader = ObjectLoader::instance_format_loader(local_path,"SCENE",extension);
if (!loader) {
error=ERR_CANT_OPEN;
}
ERR_EXPLAIN("Couldn't load scene: "+p_path);
ERR_FAIL_COND(!loader);
}
void SceneInteractiveLoaderObject::set_local_path(const String& p_local_path) {
node_path=p_local_path;
}
Node *SceneInteractiveLoaderObject::get_scene() {
if (error==ERR_FILE_EOF)
return root;
return NULL;
}
Error SceneInteractiveLoaderObject::poll() {
if (error!=OK)
return error;
Object *obj=NULL;
Variant metav;
Error r_err=loader->load(&obj,metav);
if (r_err == ERR_SKIP) {
stage++;
return OK;
};
if (r_err==ERR_FILE_EOF) {
memdelete(loader);
error=ERR_FILE_CORRUPT;
ERR_FAIL_COND_V(!root,ERR_FILE_CORRUPT);
_apply_connections(connections);
error=ERR_FILE_EOF;
if (root)
root->set_filename(node_path);
return error;
}
if (r_err || (!obj && metav.get_type()==Variant::NIL)) {
memdelete(loader);
error=ERR_FILE_CORRUPT;
ERR_EXPLAIN("Object Loader Failed for Scene: "+path);
ERR_FAIL_COND_V( r_err, ERR_FILE_CORRUPT);
ERR_EXPLAIN("Object Loader Failed for Scene: "+path);
ERR_FAIL_COND_V( !obj && metav.get_type()==Variant::NIL,ERR_FILE_CORRUPT);
}
if (obj) {
if (obj->cast_to<Node>()) {
Error err;
Node* node = load_node(obj, metav, root, loader,connections,err,save_instance_state,owner_map);
if (err) {
error=ERR_FILE_CORRUPT;
memdelete(loader);
}
ERR_FAIL_COND_V( err, ERR_FILE_CORRUPT );
if (!root)
root=node;
} else {
error=ERR_FILE_CORRUPT;
memdelete(loader);
ERR_EXPLAIN("Loaded something not a node.. (?)");
ERR_FAIL_V( ERR_FILE_CORRUPT );
}
} else {
// check for instance
Dictionary meta=metav;
if (meta.has("instance")) {
if (!root) {
error=ERR_FILE_CORRUPT;
memdelete(loader);
ERR_FAIL_COND_V(!root,ERR_FILE_CORRUPT);
}
String path = meta["instance"];
if (path.find("://")==-1 && path.is_rel_path()) {
// path is relative to file being loaded, so convert to a resource path
path=Globals::get_singleton()->localize_path(
local_path.get_base_dir()+"/"+path);
}
Node *scene = SceneLoader::load(path);
if (!scene) {
error=ERR_FILE_CORRUPT;
memdelete(loader);
ERR_FAIL_COND_V(!scene,ERR_FILE_CORRUPT);
}
if (save_instance_state)
scene->generate_instance_state();
Error err;
_apply_meta(scene,metav,loader,connections,err,owner_map);
if (err!=OK) {
error=ERR_FILE_CORRUPT;
memdelete(loader);
ERR_FAIL_COND_V(err!=OK,ERR_FILE_CORRUPT);
}
Node *parent=root;
if (meta.has("path"))
parent=root->get_node(meta["path"]);
if (!parent) {
error=ERR_FILE_CORRUPT;
memdelete(loader);
ERR_FAIL_COND_V(!parent,ERR_FILE_CORRUPT);
}
if (meta.has("override_names") && meta.has("override_values")) {
DVector<String> override_names=meta["override_names"];
Array override_values=meta["override_values"];
int len = override_names.size();
if ( len > 0 && len == override_values.size() ) {
DVector<String>::Read names = override_names.read();
for(int i=0;i<len;i++) {
scene->set(names[i],override_values[i]);
}
}
}
scene->set_filename(path);
parent->add_child(scene);
scene->set_owner(root);
}
}
stage++;
error=OK;
return error;
}
int SceneInteractiveLoaderObject::get_stage() const {
return stage;
}
int SceneInteractiveLoaderObject::get_stage_count() const {
return stage_max;
}
#endif

128
scene/io/scene_format_object.h
View File

@ -1,128 +0,0 @@
/*************************************************************************/
/* scene_format_object.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef SCENE_FORMAT_OBJECT_H
#define SCENE_FORMAT_OBJECT_H
#include "scene/main/node.h"
#include "scene/io/scene_saver.h"
#include "scene/io/scene_loader.h"
#include "io/object_saver.h"
#include "io/object_loader.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#ifdef OLD_SCENE_FORMAT_ENABLED
class SceneFormatSaverObject : public SceneFormatSaver {
void save_node(const Node* p_root,const Node* p_node,const Node* p_owner,ObjectFormatSaver *p_saver,String p_base_path,uint32_t p_flags,Map<const Node*,uint32_t>& owner_id) const;
public:
virtual Error save(const String &p_path,const Node* p_scenezz,uint32_t p_flags=0,const Ref<OptimizedSaver> &p_optimizer=Ref<OptimizedSaver>());
virtual void get_recognized_extensions(List<String> *p_extensions) const;
virtual ~SceneFormatSaverObject() {}
};
class SceneFormatLoaderObject : public SceneFormatLoader {
struct ConnectionItem {
Node *node;
NodePath target;
StringName method;
StringName signal;
Vector<Variant> binds;
bool realtime;
};
Node* load_node(Object *obj, const Variant& meta, Node *p_root, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,bool p_root_scene_hint,Map<uint32_t,Node*>& owner_map);
void _apply_connections(List<ConnectionItem>& connections);
void _apply_meta(Node *node, const Variant& meta, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,Map<uint32_t,Node*>& owner_map);
public:
virtual Ref<SceneInteractiveLoader> load_interactive(const String &p_path,bool p_root_scene_hint=false);
virtual Node* load(const String &p_path,bool p_save_root_state=false);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
};
class SceneInteractiveLoaderObject : public SceneInteractiveLoader {
OBJ_TYPE(SceneInteractiveLoaderObject,SceneInteractiveLoader);
struct ConnectionItem {
Node *node;
NodePath target;
StringName method;
StringName signal;
Vector<Variant> binds;
bool realtime;
};
ObjectFormatLoader *loader;
String path;
String node_path;
String local_path;
Error error;
bool save_instance_state;
List<ConnectionItem> connections;
Map<uint32_t,Node*> owner_map;
Node *root;
int stage_max;
int stage;
Node* load_node(Object *obj, const Variant& meta, Node *p_root, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,bool p_root_scene_hint,Map<uint32_t,Node*>& owner_map);
void _apply_connections(List<ConnectionItem>& connections);
void _apply_meta(Node *node, const Variant& meta, ObjectFormatLoader *p_loader,List<ConnectionItem>& connections,Error& r_err,Map<uint32_t,Node*>& owner_map);
friend class SceneFormatLoaderObject;
public:
virtual void set_local_path(const String& p_local_path);
virtual Node *get_scene();
virtual Error poll();
virtual int get_stage() const;
virtual int get_stage_count() const;
SceneInteractiveLoaderObject(const String &p_path,bool p_save_root_state=false);
};
#endif
#endif

65
scene/io/scene_format_script.cpp
View File

@ -1,65 +0,0 @@
/*************************************************************************/
/* scene_format_script.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "scene_format_script.h"
#if 0
Node* SceneFormatLoaderScript::load(const String &p_path,bool p_save_instance_state) {
Ref<Script> script = ResourceLoader::load(p_path);
ERR_EXPLAIN("Can't load script-based scene: "+p_path);
ERR_FAIL_COND_V(script.is_null(),NULL);
ERR_EXPLAIN("Script does not instance in a node: "+p_path);
ERR_FAIL_COND_V(script->get_node_type()=="",NULL);
String node_type=script->get_node_type();
Object *obj = ObjectTypeDB::instance(node_type);
ERR_EXPLAIN("Unknown node type for instancing '"+node_type+"' in script: "+p_path);
ERR_FAIL_COND_V(!obj,NULL);
Node *node = obj->cast_to<Node>();
if (!node)
memdelete(obj);
ERR_EXPLAIN("Node type '"+node_type+"' not of type 'Node'' in script: "+p_path);
ERR_FAIL_COND_V(!node,NULL);
node->set_script(script.get_ref_ptr());
return node;
}
void SceneFormatLoaderScript::get_recognized_extensions(List<String> *p_extensions) const {
for (int i=0;i<ScriptServer::get_language_count();i++) {
ScriptServer::get_language(i)->get_recognized_extensions(p_extensions);
}
}
SceneFormatLoaderScript::SceneFormatLoaderScript()
{
}
#endif

45
scene/io/scene_format_script.h
View File

@ -1,45 +0,0 @@
/*************************************************************************/
/* scene_format_script.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef SCENE_FORMAT_SCRIPT_H
#define SCENE_FORMAT_SCRIPT_H
#include "scene/io/scene_loader.h"
#include "io/resource_loader.h"
#if 0
class SceneFormatLoaderScript : public SceneFormatLoader {
public:
virtual Node* load(const String &p_path,bool p_save_instance_state=false);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
SceneFormatLoaderScript();
};
#endif
#endif // SCENE_FORMAT_SCRIPT_H

161
scene/io/scene_loader.cpp
View File

@ -1,161 +0,0 @@
/*************************************************************************/
/* scene_loader.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "scene_loader.h"
#include "globals.h"
#include "path_remap.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
SceneFormatLoader *SceneLoader::loader[MAX_LOADERS];
int SceneLoader::loader_count=0;
void SceneInteractiveLoader::_bind_methods() {
ObjectTypeDB::bind_method(_MD("get_scene"),&SceneInteractiveLoader::get_scene);
ObjectTypeDB::bind_method(_MD("poll"),&SceneInteractiveLoader::poll);
ObjectTypeDB::bind_method(_MD("get_stage"),&SceneInteractiveLoader::get_stage);
ObjectTypeDB::bind_method(_MD("get_stage_count"),&SceneInteractiveLoader::get_stage_count);
}
class SceneInteractiveLoaderDefault : public SceneInteractiveLoader {
OBJ_TYPE( SceneInteractiveLoaderDefault, SceneInteractiveLoader );
public:
Node *scene;
virtual void set_local_path(const String& p_local_path) { scene->set_filename(p_local_path); }
virtual Node *get_scene() { return scene; }
virtual Error poll() { return ERR_FILE_EOF; }
virtual int get_stage() const { return 1; }
virtual int get_stage_count() const { return 1; }
SceneInteractiveLoaderDefault() {}
};
Ref<SceneInteractiveLoader> SceneFormatLoader::load_interactive(const String &p_path,bool p_root_scene_hint) {
Node *scene = load(p_path,p_root_scene_hint);
if (!scene)
return Ref<SceneInteractiveLoader>();
Ref<SceneInteractiveLoaderDefault> sil = Ref<SceneInteractiveLoaderDefault>( memnew( SceneInteractiveLoaderDefault ));
sil->scene=scene;
return sil;
}
bool SceneFormatLoader::recognize(const String& p_extension) const {
List<String> extensions;
get_recognized_extensions(&extensions);
for (List<String>::Element *E=extensions.front();E;E=E->next()) {
if (E->get().nocasecmp_to(p_extension.extension())==0)
return true;
}
return false;
}
Ref<SceneInteractiveLoader> SceneLoader::load_interactive(const String &p_path,bool p_save_root_state) {
String local_path=Globals::get_singleton()->localize_path(p_path);
String remapped_path = PathRemap::get_singleton()->get_remap(local_path);
String extension=remapped_path.extension();
for (int i=0;i<loader_count;i++) {
if (!loader[i]->recognize(extension))
continue;
Ref<SceneInteractiveLoader> il = loader[i]->load_interactive(remapped_path,p_save_root_state);
if (il.is_null() && remapped_path!=local_path)
il = loader[i]->load_interactive(local_path,p_save_root_state);
ERR_EXPLAIN("Error loading scene: "+local_path);
ERR_FAIL_COND_V(il.is_null(),Ref<SceneInteractiveLoader>());
il->set_local_path(local_path);
return il;
}
ERR_EXPLAIN("No loader found for scene: "+p_path);
ERR_FAIL_V(Ref<SceneInteractiveLoader>());
return Ref<SceneInteractiveLoader>();
}
Node* SceneLoader::load(const String &p_path,bool p_root_scene_hint) {
String local_path=Globals::get_singleton()->localize_path(p_path);
String remapped_path = PathRemap::get_singleton()->get_remap(local_path);
String extension=remapped_path.extension();
for (int i=0;i<loader_count;i++) {
if (!loader[i]->recognize(extension))
continue;
Node*node = loader[i]->load(remapped_path,p_root_scene_hint);
if (!node && remapped_path!=local_path)
node = loader[i]->load(local_path,p_root_scene_hint);
ERR_EXPLAIN("Error loading scene: "+local_path);
ERR_FAIL_COND_V(!node,NULL);
node->set_filename(local_path);
return node;
}
ERR_EXPLAIN("No loader found for scene: "+p_path);
ERR_FAIL_V(NULL);
}
void SceneLoader::get_recognized_extensions(List<String> *p_extensions) {
for (int i=0;i<loader_count;i++) {
loader[i]->get_recognized_extensions(p_extensions);
}
}
void SceneLoader::add_scene_format_loader(SceneFormatLoader *p_format_loader) {
ERR_FAIL_COND( loader_count >= MAX_LOADERS );
loader[loader_count++]=p_format_loader;
}
#endif

90
scene/io/scene_loader.h
View File

@ -1,90 +0,0 @@
/*************************************************************************/
/* scene_loader.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef SCENE_LOADER_H
#define SCENE_LOADER_H
#include "scene/main/node.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#ifdef OLD_SCENE_FORMAT_ENABLED
class SceneInteractiveLoader : public Reference {
OBJ_TYPE(SceneInteractiveLoader,Reference);
protected:
static void _bind_methods();
public:
virtual void set_local_path(const String& p_local_path)=0;
virtual Node *get_scene()=0;
virtual Error poll()=0;
virtual int get_stage() const=0;
virtual int get_stage_count() const=0;
SceneInteractiveLoader() {}
};
class SceneFormatLoader {
public:
virtual Ref<SceneInteractiveLoader> load_interactive(const String &p_path,bool p_root_scene_hint=false);
virtual Node* load(const String &p_path,bool p_root_scene_hint=false)=0;
virtual void get_recognized_extensions(List<String> *p_extensions) const=0;
bool recognize(const String& p_extension) const;
virtual ~SceneFormatLoader() {}
};
class SceneLoader {
enum {
MAX_LOADERS=64
};
static SceneFormatLoader *loader[MAX_LOADERS];
static int loader_count;
public:
static Ref<SceneInteractiveLoader> load_interactive(const String &p_path,bool p_save_root_state=false);
static Node* load(const String &p_path,bool p_save_root_state=false);
static void add_scene_format_loader(SceneFormatLoader *p_format_loader);
static void get_recognized_extensions(List<String> *p_extensions);
};
#endif
#endif

94
scene/io/scene_saver.cpp
View File

@ -1,94 +0,0 @@
/*************************************************************************/
/* scene_saver.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "scene_saver.h"
#include "print_string.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
SceneFormatSaver *SceneSaver::saver[MAX_SAVERS];
int SceneSaver::saver_count=0;
bool SceneFormatSaver::recognize(const String& p_extension) const {
List<String> extensions;
get_recognized_extensions(&extensions);
for (List<String>::Element *E=extensions.front();E;E=E->next()) {
if (E->get().nocasecmp_to(p_extension.extension())==0)
return true;
}
return false;
}
Error SceneSaver::save(const String &p_path,const Node* p_scene,uint32_t p_flags,const Ref<OptimizedSaver> &p_optimizer) {
String extension=p_path.extension();
Error err=ERR_FILE_UNRECOGNIZED;
bool recognized=false;
for (int i=0;i<saver_count;i++) {
if (!saver[i]->recognize(extension))
continue;
recognized=true;
err = saver[i]->save(p_path,p_scene,p_flags,p_optimizer);
if (err == OK )
return OK;
}
if (err) {
if (!recognized) {
ERR_EXPLAIN("No saver format found for scene: "+p_path);
} else {
ERR_EXPLAIN("Couldn't save scene: "+p_path);
}
ERR_FAIL_V(err);
}
return err;
}
void SceneSaver::get_recognized_extensions(List<String> *p_extensions) {
for (int i=0;i<saver_count;i++) {
saver[i]->get_recognized_extensions(p_extensions);
}
}
void SceneSaver::add_scene_format_saver(SceneFormatSaver *p_format_saver) {
ERR_FAIL_COND( saver_count >= MAX_SAVERS );
saver[saver_count++]=p_format_saver;
}
#endif

80
scene/io/scene_saver.h
View File

@ -1,80 +0,0 @@
/*************************************************************************/
/* scene_saver.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef SCENE_SAVER_H
#define SCENE_SAVER_H
#include "scene/main/node.h"
#include "io/object_saver.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#ifdef OLD_SCENE_FORMAT_ENABLED
class SceneFormatSaver {
public:
virtual Error save(const String &p_path,const Node* p_scen,uint32_t p_flags=0,const Ref<OptimizedSaver> &p_optimizer=Ref<OptimizedSaver>())=0;
virtual void get_recognized_extensions(List<String> *p_extensions) const=0;
bool recognize(const String& p_extension) const;
virtual ~SceneFormatSaver() {}
};
class SceneSaver {
enum {
MAX_SAVERS=64
};
static SceneFormatSaver *saver[MAX_SAVERS];
static int saver_count;
public:
enum SaverFlags {
FLAG_RELATIVE_PATHS=1,
FLAG_BUNDLE_RESOURCES=2,
FLAG_BUNDLE_INSTANCED_SCENES=4,
FLAG_OMIT_EDITOR_PROPERTIES=8,
FLAG_SAVE_BIG_ENDIAN=16
};
static Error save(const String &p_path,const Node* p_scenezz,uint32_t p_flags=0,const Ref<OptimizedSaver> &p_optimizer=Ref<OptimizedSaver>());
static void add_scene_format_saver(SceneFormatSaver *p_format_saver);
static void get_recognized_extensions(List<String> *p_extensions);
};
#endif
#endif

1
scene/main/node.cpp
View File

@ -28,7 +28,6 @@
/*************************************************************************/
#include "node.h"
#include "print_string.h"
#include "scene/io/scene_loader.h"
#include "message_queue.h"
#include "scene/scene_string_names.h"
#include "scene/resources/packed_scene.h"

56
scene/register_scene_types.cpp
View File

@ -32,7 +32,7 @@
#include "scene/io/resource_format_image.h"
#include "scene/io/resource_format_wav.h"
#include "scene/io/scene_format_script.h"
//#include "scene/io/scene_format_script.h"
#include "resources/default_theme/default_theme.h"
#include "object_type_db.h"
#include "scene/main/canvas_layer.h"
@ -120,7 +120,7 @@
#include "scene/resources/scene_preloader.h"
#include "scene/main/timer.h"
#include "scene/io/scene_format_object.h"
#include "scene/audio/stream_player.h"
#include "scene/audio/event_player.h"
#include "scene/audio/sound_room_params.h"
@ -142,7 +142,7 @@
#include "scene/resources/mesh_library.h"
#include "scene/resources/image_path_finder.h"
#include "scene/resources/polygon_path_finder.h"
#include "scene/resources/sample.h"
@ -174,7 +174,7 @@
#ifndef _3D_DISABLED
#include "scene/3d/camera.h"
#include "scene/3d/editable_shape.h"
#include "scene/3d/interpolated_camera.h"
#include "scene/3d/follow_camera.h"
#include "scene/3d/position_3d.h"
@ -186,7 +186,7 @@
#include "scene/3d/portal.h"
#include "scene/resources/environment.h"
#include "scene/3d/physics_body.h"
#include "scene/3d/car_body.h"
#include "scene/3d/vehicle_body.h"
#include "scene/3d/body_shape.h"
#include "scene/3d/area.h"
@ -204,7 +204,7 @@
#include "scene/3d/collision_polygon.h"
#endif
#include "scene/scene_binds.h"
static ResourceFormatLoaderImage *resource_loader_image=NULL;
static ResourceFormatLoaderWAV *resource_loader_wav=NULL;
@ -216,15 +216,6 @@ static ResourceFormatLoaderBitMap *resource_loader_bitmap=NULL;
#endif
static ResourceFormatLoaderTheme *resource_loader_theme=NULL;
static ResourceFormatLoaderShader *resource_loader_shader=NULL;
#ifdef OLD_SCENE_FORMAT_ENABLED
static SceneFormatSaverObject *scene_saver_object=NULL;
static SceneFormatLoaderObject *scene_loader_object=NULL;
//static SceneFormatLoaderScript *scene_loader_script=NULL;
#endif
#ifdef OLD_SCENE_FORMAT_ENABLED
SceneIO *scene_io=NULL;
#endif
//static SceneStringNames *string_names;
@ -236,13 +227,6 @@ void register_scene_types() {
Node::init_node_hrcr();
#ifdef OLD_SCENE_FORMAT_ENABLED
ObjectTypeDB::register_type<SceneIO>();
ObjectTypeDB::register_virtual_type<SceneInteractiveLoader>();
scene_io = memnew( SceneIO );
Globals::get_singleton()->add_singleton(Globals::Singleton("SceneIO",scene_io));
#endif
resource_loader_image = memnew( ResourceFormatLoaderImage );
ResourceLoader::add_resource_format_loader( resource_loader_image );
@ -263,16 +247,6 @@ void register_scene_types() {
resource_loader_shader = memnew( ResourceFormatLoaderShader );
ResourceLoader::add_resource_format_loader( resource_loader_shader );
#ifdef OLD_SCENE_FORMAT_ENABLED
scene_saver_object=memnew( SceneFormatSaverObject );
SceneSaver::add_scene_format_saver(scene_saver_object);
scene_loader_object=memnew( SceneFormatLoaderObject );
SceneLoader::add_scene_format_loader(scene_loader_object);
// scene_loader_script=memnew( SceneFormatLoaderScript );
// SceneLoader::add_scene_format_loader(scene_loader_script);
#endif
make_default_theme();
@ -405,8 +379,8 @@ void register_scene_types() {
ObjectTypeDB::register_type<StaticBody>();
ObjectTypeDB::register_type<RigidBody>();
ObjectTypeDB::register_type<KinematicBody>();
ObjectTypeDB::register_type<CarBody>();
ObjectTypeDB::register_type<CarWheel>();
ObjectTypeDB::register_type<VehicleBody>();
ObjectTypeDB::register_type<VehicleWheel>();
ObjectTypeDB::register_type<Area>();
@ -414,8 +388,6 @@ void register_scene_types() {
ObjectTypeDB::register_type<CollisionShape>();
ObjectTypeDB::register_type<CollisionPolygon>();
ObjectTypeDB::register_type<RayCast>();
ObjectTypeDB::register_virtual_type<EditableShape>();
ObjectTypeDB::register_type<EditableSphere>();
ObjectTypeDB::register_type<MultiMeshInstance>();
ObjectTypeDB::register_type<Room>();
ObjectTypeDB::register_type<Curve3D>();
@ -561,7 +533,7 @@ void register_scene_types() {
ObjectTypeDB::register_type<StyleBoxFlat>();
ObjectTypeDB::register_type<StyleBoxImageMask>();
ObjectTypeDB::register_type<Theme>();
ObjectTypeDB::register_type<ImagePathFinder>();
ObjectTypeDB::register_type<PolygonPathFinder>();
ObjectTypeDB::register_type<BitMap>();
@ -592,10 +564,6 @@ void register_scene_types() {
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<PackedScene>();
#ifdef OLD_SCENE_FORMAT_ENABLED
ObjectTypeDB::register_type<ScenePreloader>();
#endif
ObjectTypeDB::register_type<SceneMainLoop>();
@ -619,11 +587,5 @@ void unregister_scene_types() {
memdelete( resource_loader_theme );
memdelete( resource_loader_shader );
#ifdef OLD_SCENE_FORMAT_ENABLED
memdelete( scene_saver_object );
memdelete( scene_loader_object );
// memdelete( scene_loader_script );
memdelete( scene_io );
#endif
SceneStringNames::free();
}

427
scene/resources/image_path_finder.cpp
View File

@ -1,427 +0,0 @@
/*************************************************************************/
/* image_path_finder.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "image_path_finder.h"
void ImagePathFinder::_unlock() {
lock=DVector<Cell>::Write();
cells=NULL;
}
void ImagePathFinder::_lock() {
lock = cell_data.write();
cells=lock.ptr();
}
bool ImagePathFinder::_can_go_straigth(const Point2& p_from, const Point2& p_to) const {
int x1=p_from.x;
int y1=p_from.y;
int x2=p_to.x;
int y2=p_to.y;
#define _TEST_VALID \
{\
uint32_t ofs=drawy*width+drawx;\
if (cells[ofs].solid) {\
if (!((drawx>0 && cells[ofs-1].visited) ||\
(drawx<width-1 && cells[ofs+1].visited) ||\
(drawy>0 && cells[ofs-width].visited) ||\
(drawy<height-1 && cells[ofs+width].visited))) {\
return false;\
}\
}\
}\
int n, deltax, deltay, sgndeltax, sgndeltay, deltaxabs, deltayabs, x, y, drawx, drawy;
deltax = x2 - x1;
deltay = y2 - y1;
deltaxabs = ABS(deltax);
deltayabs = ABS(deltay);
sgndeltax = SGN(deltax);
sgndeltay = SGN(deltay);
x = deltayabs >> 1;
y = deltaxabs >> 1;
drawx = x1;
drawy = y1;
int pc=0;
_TEST_VALID
if(deltaxabs >= deltayabs) {
for(n = 0; n < deltaxabs; n++) {
y += deltayabs;
if(y >= deltaxabs){
y -= deltaxabs;
drawy += sgndeltay;
}
drawx += sgndeltax;
_TEST_VALID
}
} else {
for(n = 0; n < deltayabs; n++) {
x += deltaxabs;
if(x >= deltayabs) {
x -= deltayabs;
drawx += sgndeltax;
}
drawy += sgndeltay;
_TEST_VALID
}
}
return true;
}
bool ImagePathFinder::_is_linear_path(const Point2& p_from, const Point2& p_to) {
int x1=p_from.x;
int y1=p_from.y;
int x2=p_to.x;
int y2=p_to.y;
#define _TEST_CELL \
if (cells[drawy*width+drawx].solid)\
return false;
int n, deltax, deltay, sgndeltax, sgndeltay, deltaxabs, deltayabs, x, y, drawx, drawy;
deltax = x2 - x1;
deltay = y2 - y1;
deltaxabs = ABS(deltax);
deltayabs = ABS(deltay);
sgndeltax = SGN(deltax);
sgndeltay = SGN(deltay);
x = deltayabs >> 1;
y = deltaxabs >> 1;
drawx = x1;
drawy = y1;
int pc=0;
_TEST_CELL
if(deltaxabs >= deltayabs) {
for(n = 0; n < deltaxabs; n++) {
y += deltayabs;
if(y >= deltaxabs){
y -= deltaxabs;
drawy += sgndeltay;
}
drawx += sgndeltax;
_TEST_CELL
}
} else {
for(n = 0; n < deltayabs; n++) {
x += deltaxabs;
if(x >= deltayabs) {
x -= deltayabs;
drawx += sgndeltax;
}
drawy += sgndeltay;
_TEST_CELL
}
}
return true;
}
DVector<Point2> ImagePathFinder::find_path(const Point2& p_from, const Point2& p_to,bool p_optimize) {
Point2i from=p_from;
Point2i to=p_to;
ERR_FAIL_COND_V(from.x < 0,DVector<Point2>());
ERR_FAIL_COND_V(from.y < 0,DVector<Point2>());
ERR_FAIL_COND_V(from.x >=width,DVector<Point2>());
ERR_FAIL_COND_V(from.y >=height,DVector<Point2>());
ERR_FAIL_COND_V(to.x < 0,DVector<Point2>());
ERR_FAIL_COND_V(to.y < 0,DVector<Point2>());
ERR_FAIL_COND_V(to.x >=width,DVector<Point2>());
ERR_FAIL_COND_V(to.y >=height,DVector<Point2>());
if (from==to) {
DVector<Point2> p;
p.push_back(from);
return p;
}
_lock();
if (p_optimize) { //try a line first
if (_is_linear_path(p_from,p_to)) {
_unlock();
DVector<Point2> p;
p.push_back(from);
p.push_back(to);
return p;
}
}
//clear all
for(int i=0;i<width*height;i++) {
bool s = cells[i].solid;
cells[i].data=0;
cells[i].solid=s;
}
#define CELL_INDEX(m_p) (m_p.y*width+m_p.x)
#define CELL_COST(m_p) (cells[CELL_INDEX(m_p)].cost+( ABS(m_p.x-to.x)+ABS(m_p.y-to.y))*10)
Set<Point2i> pending;
pending.insert(from);
//helper constants
static const Point2i neighbour_rel[8]={
Point2i(-1,-1), //0
Point2i(-1, 0), //1
Point2i(-1,+1), //2
Point2i( 0,-1), //3
Point2i( 0,+1), //4
Point2i(+1,-1), //5
Point2i(+1, 0), //6
Point2i(+1,+1) }; //7
static const int neighbour_cost[8]={
14,
10,
14,
10,
10,
14,
10,
14
};
static const int neighbour_parent[8]={
7,
6,
5,
4,
3,
2,
1,
0,
};
while(true) {
if (pending.size() == 0) {
_unlock();
return DVector<Point2>(); // points don't connect
}
Point2i current;
int lc=0x7FFFFFFF;
{ //find the one with the least cost
Set<Point2i>::Element *Efound=NULL;
for (Set<Point2i>::Element *E=pending.front();E;E=E->next()) {
int cc =CELL_COST(E->get());
if (cc<lc) {
lc=cc;
current=E->get();
Efound=E;
}
}
pending.erase(Efound);
}
Cell &c = cells[CELL_INDEX(current)];
//search around other cells
int accum_cost = (from==current) ? 0 : cells[CELL_INDEX((current + neighbour_rel[c.parent]))].cost;
bool done=false;
for(int i=0;i<8;i++) {
Point2i neighbour=current+neighbour_rel[i];
if (neighbour.x<0 || neighbour.y<0 || neighbour.x>=width || neighbour.y>=height)
continue;
Cell &n = cells[CELL_INDEX(neighbour)];
if (n.solid)
continue; //no good
int cost = neighbour_cost[i]+accum_cost;
if (n.visited && n.cost < cost)
continue;
n.cost=cost;
n.parent=neighbour_parent[i];
n.visited=true;
pending.insert(neighbour);
if (neighbour==to)
done=true;
}
if (done)
break;
}
// go througuh poins twice, first compute amount, then add them
Point2i current=to;
int pcount=0;
while(true) {
Cell &c = cells[CELL_INDEX(current)];
c.visited=true;
pcount++;
if (current==from)
break;
current+=neighbour_rel[ c.parent ];
}
//now place them in an array
DVector<Vector2> result;
result.resize(pcount);
DVector<Vector2>::Write res=result.write();
current=to;
int pidx=pcount-1;
while(true) {
Cell &c = cells[CELL_INDEX(current)];
res[pidx]=current;
pidx--;
if (current==from)
break;
current+=neighbour_rel[ c.parent ];
}
//simplify..
if (p_optimize) {
int p=pcount-1;
while(p>0) {
int limit=p;
while(limit>0) {
limit--;
if (!_can_go_straigth(res[p],res[limit]))
break;
}
if (limit<p-1) {
int diff = p-limit-1;
pcount-=diff;
for(int i=limit+1;i<pcount;i++) {
res[i]=res[i+diff];
}
}
p=limit;
}
}
res=DVector<Vector2>::Write();
result.resize(pcount);
return result;
}
Size2 ImagePathFinder::get_size() const {
return Size2(width,height);
}
bool ImagePathFinder::is_solid(const Point2& p_pos) {
Point2i pos = p_pos;
ERR_FAIL_COND_V(pos.x<0,true);
ERR_FAIL_COND_V(pos.y<0,true);
ERR_FAIL_COND_V(pos.x>=width,true);
ERR_FAIL_COND_V(pos.y>=height,true);
return cell_data[pos.y*width+pos.x].solid;
}
void ImagePathFinder::create_from_image_alpha(const Image& p_image) {
ERR_FAIL_COND(p_image.get_format() != Image::FORMAT_RGBA);
width = p_image.get_width();
height = p_image.get_height();
DVector<uint8_t> data = p_image.get_data();
cell_data.resize(width * height);
DVector<uint8_t>::Read read = data.read();
DVector<Cell>::Write write = cell_data.write();
for (int i=0; i<width * height; i++) {
Cell cell;
cell.data = 0;
cell.solid = read[i*4+3] < 128;
write[i] = cell;
};
};
void ImagePathFinder::_bind_methods() {
ObjectTypeDB::bind_method(_MD("find_path","from","to","optimize"),&ImagePathFinder::find_path,DEFVAL(false));
ObjectTypeDB::bind_method(_MD("get_size"),&ImagePathFinder::get_size);
ObjectTypeDB::bind_method(_MD("is_solid","pos"),&ImagePathFinder::is_solid);
ObjectTypeDB::bind_method(_MD("create_from_image_alpha"),&ImagePathFinder::create_from_image_alpha);
}
ImagePathFinder::ImagePathFinder()
{
cells=NULL;
width=0;
height=0;
}

84
scene/resources/image_path_finder.h
View File

@ -1,84 +0,0 @@
/*************************************************************************/
/* image_path_finder.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef IMAGE_PATH_FINDER_H
#define IMAGE_PATH_FINDER_H
#include "resource.h"
class ImagePathFinder : public Resource{
OBJ_TYPE(ImagePathFinder,Resource);
union Cell {
struct {
bool solid:1;
bool visited:1;
bool final:1;
uint8_t parent:3;
uint32_t cost:26;
};
uint32_t data;
};
DVector<Cell>::Write lock;
DVector<Cell> cell_data;
uint32_t width;
uint32_t height;
Cell* cells; //when unlocked
void _unlock();
void _lock();
_FORCE_INLINE_ bool _can_go_straigth(const Point2& p_from, const Point2& p_to) const;
_FORCE_INLINE_ bool _is_linear_path(const Point2& p_from, const Point2& p_to);
protected:
static void _bind_methods();
public:
DVector<Point2> find_path(const Point2& p_from, const Point2& p_to,bool p_optimize=false);
Size2 get_size() const;
bool is_solid(const Point2& p_pos);
void create_from_image_alpha(const Image& p_image);
ImagePathFinder();
};
#endif // IMAGE_PATH_FINDER_H

26
scene/resources/packed_scene.cpp
View File

@ -29,6 +29,9 @@
#include "packed_scene.h"
#include "globals.h"
#include "io/resource_loader.h"
#include "scene/3d/spatial.h"
#include "scene/gui/control.h"
#include "scene/2d/node_2d.h"
bool PackedScene::can_instance() const {
@ -80,9 +83,26 @@ Node *PackedScene::instance(bool p_gen_edit_state) const {
} else {
//create anew
Object * obj = ObjectTypeDB::instance(snames[ n.type ]);
ERR_FAIL_COND_V(!obj,NULL);
node = obj->cast_to<Node>();
ERR_FAIL_COND_V(!node,NULL);
if (!obj || !obj->cast_to<Node>()) {
if (obj) {
memdelete(obj);
obj=NULL;
}
WARN_PRINT(String("Warning node of type "+snames[n.type].operator String()+" does not exist.").ascii().get_data());
if (n.parent>=0 && n.parent<nc && ret_nodes[n.parent]) {
if (ret_nodes[n.parent]->cast_to<Spatial>()) {
obj = memnew( Spatial );
} else if (ret_nodes[n.parent]->cast_to<Control>()) {
obj = memnew( Control );
} else if (ret_nodes[n.parent]->cast_to<Node2D>()) {
obj = memnew( Node2D );
}
}
if (!obj) {
obj = memnew( Node );
}
}
}

853
scene/resources/scene_preloader.cpp
View File

@ -26,430 +26,429 @@
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "scene_preloader.h"
#include "scene/io/scene_loader.h"
#include "globals.h"
bool ScenePreloader::can_instance() const {
return nodes.size()>0;
}
Node *ScenePreloader::instance() const {
int nc = nodes.size();
ERR_FAIL_COND_V(nc==0,NULL);
const StringName*snames=NULL;
int sname_count=names.size();
if (sname_count)
snames=&names[0];
const Variant*props=NULL;
int prop_count=variants.size();
if (prop_count)
props=&variants[0];
Vector<Variant> properties;
const NodeData *nd = &nodes[0];
Node **ret_nodes=(Node**)alloca( sizeof(Node*)*nc );
for(int i=0;i<nc;i++) {
const NodeData &n=nd[i];
if (!ObjectTypeDB::is_type_enabled(snames[n.type])) {
ret_nodes[i]=NULL;
continue;
}
Object * obj = ObjectTypeDB::instance(snames[ n.type ]);
ERR_FAIL_COND_V(!obj,NULL);
Node *node = obj->cast_to<Node>();
ERR_FAIL_COND_V(!node,NULL);
int nprop_count=n.properties.size();
if (nprop_count) {
const NodeData::Property* nprops=&n.properties[0];
for(int j=0;j<nprop_count;j++) {
bool valid;
node->set(snames[ nprops[j].name ],props[ nprops[j].value ],&valid);
}
}
node->set_name( snames[ n.name ] );
ret_nodes[i]=node;
if (i>0) {
ERR_FAIL_INDEX_V(n.parent,i,NULL);
ERR_FAIL_COND_V(!ret_nodes[n.parent],NULL);
ret_nodes[n.parent]->add_child(node);
}
}
//do connections
int cc = connections.size();
const ConnectionData *cdata = connections.ptr();
for(int i=0;i<cc;i++) {
const ConnectionData &c=cdata[i];
ERR_FAIL_INDEX_V( c.from, nc, NULL );
ERR_FAIL_INDEX_V( c.to, nc, NULL );
Vector<Variant> binds;
if (c.binds.size()) {
binds.resize(c.binds.size());
for(int j=0;j<c.binds.size();j++)
binds[j]=props[ c.binds[j] ];
}
if (!ret_nodes[c.from] || !ret_nodes[c.to])
continue;
ret_nodes[c.from]->connect( snames[ c.signal], ret_nodes[ c.to ], snames[ c.method], binds,CONNECT_PERSIST );
}
return ret_nodes[0];
}
static int _nm_get_string(const String& p_string, Map<StringName,int> &name_map) {
if (name_map.has(p_string))
return name_map[p_string];
int idx = name_map.size();
name_map[p_string]=idx;
return idx;
}
static int _vm_get_variant(const Variant& p_variant, HashMap<Variant,int,VariantHasher> &variant_map) {
if (variant_map.has(p_variant))
return variant_map[p_variant];
int idx = variant_map.size();
variant_map[p_variant]=idx;
return idx;
}
void ScenePreloader::_parse_node(Node *p_owner,Node *p_node,int p_parent_idx, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher> &variant_map,Map<Node*,int> &node_map) {
if (p_node!=p_owner && !p_node->get_owner())
return;
NodeData nd;
nd.name=_nm_get_string(p_node->get_name(),name_map);
nd.type=_nm_get_string(p_node->get_type(),name_map);
nd.parent=p_parent_idx;
List<PropertyInfo> plist;
p_node->get_property_list(&plist);
for (List<PropertyInfo>::Element *E=plist.front();E;E=E->next()) {
if (!(E->get().usage & PROPERTY_USAGE_STORAGE))
continue;
NodeData::Property prop;
prop.name=_nm_get_string(E->get().name,name_map);
prop.value=_vm_get_variant( p_node->get( E->get().name ), variant_map);
nd.properties.push_back(prop);
}
int idx = nodes.size();
node_map[p_node]=idx;
nodes.push_back(nd);
for(int i=0;i<p_node->get_child_count();i++) {
Node *c=p_node->get_child(i);
_parse_node(p_owner,c,idx,name_map,variant_map,node_map);
}
}
void ScenePreloader::_parse_connections(Node *p_node, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher> &variant_map,Map<Node*,int> &node_map,bool p_instance) {
List<MethodInfo> signals;
p_node->get_signal_list(&signals);
for(List<MethodInfo>::Element *E=signals.front();E;E=E->next()) {
List<Node::Connection> conns;
p_node->get_signal_connection_list(E->get().name,&conns);
for(List<Node::Connection>::Element *F=conns.front();F;F=F->next()) {
const Node::Connection &c = F->get();
if (!(c.flags&CONNECT_PERSIST))
continue;
Node *n=c.target->cast_to<Node>();
if (!n)
continue;
if (!node_map.has(n))
continue;
ConnectionData cd;
cd.from=node_map[p_node];
cd.to=node_map[n];
cd.method=_nm_get_string(c.method,name_map);
cd.signal=_nm_get_string(c.signal,name_map);
for(int i=0;i<c.binds.size();i++) {
cd.binds.push_back( _vm_get_variant(c.binds[i],variant_map));
}
connections.push_back(cd);
}
}
}
Error ScenePreloader::load_scene(const String& p_path) {
return ERR_CANT_OPEN;
#if 0
if (path==p_path)
return OK;
String p=Globals::get_singleton()->localize_path(p_path);
clear();
Node *scene = SceneLoader::load(p);
ERR_FAIL_COND_V(!scene,ERR_CANT_OPEN);
path=p;
Map<StringName,int> name_map;
HashMap<Variant,int,VariantHasher> variant_map;
Map<Node*,int> node_map;
_parse_node(scene,scene,-1,name_map,variant_map,node_map);
names.resize(name_map.size());
for(Map<StringName,int>::Element *E=name_map.front();E;E=E->next()) {
names[E->get()]=E->key();
}
variants.resize(variant_map.size());
const Variant *K=NULL;
while((K=variant_map.next(K))) {
int idx = variant_map[*K];
variants[idx]=*K;
}
memdelete(scene); // <- me falto esto :(
return OK;
#endif
}
String ScenePreloader::get_scene_path() const {
return path;
}
void ScenePreloader::clear() {
names.clear();
variants.clear();
nodes.clear();
connections.clear();
}
void ScenePreloader::_set_bundled_scene(const Dictionary& d) {
ERR_FAIL_COND( !d.has("names"));
ERR_FAIL_COND( !d.has("variants"));
ERR_FAIL_COND( !d.has("node_count"));
ERR_FAIL_COND( !d.has("nodes"));
ERR_FAIL_COND( !d.has("conn_count"));
ERR_FAIL_COND( !d.has("conns"));
ERR_FAIL_COND( !d.has("path"));
DVector<String> snames = d["names"];
if (snames.size()) {
int namecount = snames.size();
names.resize(namecount);
DVector<String>::Read r =snames.read();
for(int i=0;i<names.size();i++)
names[i]=r[i];
}
Array svariants = d["variants"];
if (svariants.size()) {
int varcount=svariants.size();
variants.resize(varcount);
for(int i=0;i<varcount;i++) {
variants[i]=svariants[i];
}
} else {
variants.clear();
}
nodes.resize(d["node_count"]);
int nc=nodes.size();
if (nc) {
DVector<int> snodes = d["nodes"];
DVector<int>::Read r = snodes.read();
int idx=0;
for(int i=0;i<nc;i++) {
NodeData &nd = nodes[i];
nd.parent=r[idx++];
nd.type=r[idx++];
nd.name=r[idx++];
nd.properties.resize(r[idx++]);
for(int j=0;j<nd.properties.size();j++) {
nd.properties[j].name=r[idx++];
nd.properties[j].value=r[idx++];
}
}
}
connections.resize(d["conn_count"]);
int cc=connections.size();
if (cc) {
DVector<int> sconns = d["conns"];
DVector<int>::Read r = sconns.read();
int idx=0;
for(int i=0;i<nc;i++) {
ConnectionData &cd = connections[nc];
cd.from=r[idx++];
cd.to=r[idx++];
cd.signal=r[idx++];
cd.method=r[idx++];
cd.binds.resize(r[idx++]);
for(int j=0;j<cd.binds.size();j++) {
cd.binds[j]=r[idx++];
}
}
}
path=d["path"];
}
Dictionary ScenePreloader::_get_bundled_scene() const {
DVector<String> rnames;
rnames.resize(names.size());
if (names.size()) {
DVector<String>::Write r=rnames.write();
for(int i=0;i<names.size();i++)
r[i]=names[i];
}
Dictionary d;
d["names"]=rnames;
d["variants"]=variants;
Vector<int> rnodes;
d["node_count"]=nodes.size();
for(int i=0;i<nodes.size();i++) {
const NodeData &nd=nodes[i];
rnodes.push_back(nd.parent);
rnodes.push_back(nd.type);
rnodes.push_back(nd.name);
rnodes.push_back(nd.properties.size());
for(int j=0;j<nd.properties.size();j++) {
rnodes.push_back(nd.properties[j].name);
rnodes.push_back(nd.properties[j].value);
}
}
d["nodes"]=rnodes;
Vector<int> rconns;
d["conn_count"]=connections.size();
for(int i=0;i<connections.size();i++) {
const ConnectionData &cd=connections[i];
rconns.push_back(cd.from);
rconns.push_back(cd.to);
rconns.push_back(cd.signal);
rconns.push_back(cd.method);
rconns.push_back(cd.binds.size());
for(int j=0;j<cd.binds.size();i++)
rconns.push_back(cd.binds[j]);
}
d["conns"]=rconns;
d["path"]=path;
return d;
}
void ScenePreloader::_bind_methods() {
ObjectTypeDB::bind_method(_MD("load_scene","path"),&ScenePreloader::load_scene);
ObjectTypeDB::bind_method(_MD("get_scene_path"),&ScenePreloader::get_scene_path);
ObjectTypeDB::bind_method(_MD("instance:Node"),&ScenePreloader::instance);
ObjectTypeDB::bind_method(_MD("can_instance"),&ScenePreloader::can_instance);
ObjectTypeDB::bind_method(_MD("_set_bundled_scene"),&ScenePreloader::_set_bundled_scene);
ObjectTypeDB::bind_method(_MD("_get_bundled_scene"),&ScenePreloader::_get_bundled_scene);
ADD_PROPERTY( PropertyInfo(Variant::DICTIONARY,"_bundled",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_BUNDLE),_SCS("_set_bundled_scene"),_SCS("_get_bundled_scene"));
#if 0
List<String> extensions;
SceneLoader::get_recognized_extensions(&extensions);
String exthint;
for (List<String>::Element*E=extensions.front();E;E=E->next()) {
if (exthint!="")
exthint+=",";
exthint+="*."+E->get();
}
exthint+="; Scenes";
ADD_PROPERTY( PropertyInfo(Variant::STRING,"scene",PROPERTY_HINT_FILE,exthint),_SCS("load_scene"),_SCS("get_scene_path"));
#endif
}
ScenePreloader::ScenePreloader() {
}
#include "scene_preloader.h"
#include "globals.h"
bool ScenePreloader::can_instance() const {
return nodes.size()>0;
}
Node *ScenePreloader::instance() const {
int nc = nodes.size();
ERR_FAIL_COND_V(nc==0,NULL);
const StringName*snames=NULL;
int sname_count=names.size();
if (sname_count)
snames=&names[0];
const Variant*props=NULL;
int prop_count=variants.size();
if (prop_count)
props=&variants[0];
Vector<Variant> properties;
const NodeData *nd = &nodes[0];
Node **ret_nodes=(Node**)alloca( sizeof(Node*)*nc );
for(int i=0;i<nc;i++) {
const NodeData &n=nd[i];
if (!ObjectTypeDB::is_type_enabled(snames[n.type])) {
ret_nodes[i]=NULL;
continue;
}
Object * obj = ObjectTypeDB::instance(snames[ n.type ]);
ERR_FAIL_COND_V(!obj,NULL);
Node *node = obj->cast_to<Node>();
ERR_FAIL_COND_V(!node,NULL);
int nprop_count=n.properties.size();
if (nprop_count) {
const NodeData::Property* nprops=&n.properties[0];
for(int j=0;j<nprop_count;j++) {
bool valid;
node->set(snames[ nprops[j].name ],props[ nprops[j].value ],&valid);
}
}
node->set_name( snames[ n.name ] );
ret_nodes[i]=node;
if (i>0) {
ERR_FAIL_INDEX_V(n.parent,i,NULL);
ERR_FAIL_COND_V(!ret_nodes[n.parent],NULL);
ret_nodes[n.parent]->add_child(node);
}
}
//do connections
int cc = connections.size();
const ConnectionData *cdata = connections.ptr();
for(int i=0;i<cc;i++) {
const ConnectionData &c=cdata[i];
ERR_FAIL_INDEX_V( c.from, nc, NULL );
ERR_FAIL_INDEX_V( c.to, nc, NULL );
Vector<Variant> binds;
if (c.binds.size()) {
binds.resize(c.binds.size());
for(int j=0;j<c.binds.size();j++)
binds[j]=props[ c.binds[j] ];
}
if (!ret_nodes[c.from] || !ret_nodes[c.to])
continue;
ret_nodes[c.from]->connect( snames[ c.signal], ret_nodes[ c.to ], snames[ c.method], binds,CONNECT_PERSIST );
}
return ret_nodes[0];
}
static int _nm_get_string(const String& p_string, Map<StringName,int> &name_map) {
if (name_map.has(p_string))
return name_map[p_string];
int idx = name_map.size();
name_map[p_string]=idx;
return idx;
}
static int _vm_get_variant(const Variant& p_variant, HashMap<Variant,int,VariantHasher> &variant_map) {
if (variant_map.has(p_variant))
return variant_map[p_variant];
int idx = variant_map.size();
variant_map[p_variant]=idx;
return idx;
}
void ScenePreloader::_parse_node(Node *p_owner,Node *p_node,int p_parent_idx, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher> &variant_map,Map<Node*,int> &node_map) {
if (p_node!=p_owner && !p_node->get_owner())
return;
NodeData nd;
nd.name=_nm_get_string(p_node->get_name(),name_map);
nd.type=_nm_get_string(p_node->get_type(),name_map);
nd.parent=p_parent_idx;
List<PropertyInfo> plist;
p_node->get_property_list(&plist);
for (List<PropertyInfo>::Element *E=plist.front();E;E=E->next()) {
if (!(E->get().usage & PROPERTY_USAGE_STORAGE))
continue;
NodeData::Property prop;
prop.name=_nm_get_string(E->get().name,name_map);
prop.value=_vm_get_variant( p_node->get( E->get().name ), variant_map);
nd.properties.push_back(prop);
}
int idx = nodes.size();
node_map[p_node]=idx;
nodes.push_back(nd);
for(int i=0;i<p_node->get_child_count();i++) {
Node *c=p_node->get_child(i);
_parse_node(p_owner,c,idx,name_map,variant_map,node_map);
}
}
void ScenePreloader::_parse_connections(Node *p_node, Map<StringName,int> &name_map,HashMap<Variant,int,VariantHasher> &variant_map,Map<Node*,int> &node_map,bool p_instance) {
List<MethodInfo> signals;
p_node->get_signal_list(&signals);
for(List<MethodInfo>::Element *E=signals.front();E;E=E->next()) {
List<Node::Connection> conns;
p_node->get_signal_connection_list(E->get().name,&conns);
for(List<Node::Connection>::Element *F=conns.front();F;F=F->next()) {
const Node::Connection &c = F->get();
if (!(c.flags&CONNECT_PERSIST))
continue;
Node *n=c.target->cast_to<Node>();
if (!n)
continue;
if (!node_map.has(n))
continue;
ConnectionData cd;
cd.from=node_map[p_node];
cd.to=node_map[n];
cd.method=_nm_get_string(c.method,name_map);
cd.signal=_nm_get_string(c.signal,name_map);
for(int i=0;i<c.binds.size();i++) {
cd.binds.push_back( _vm_get_variant(c.binds[i],variant_map));
}
connections.push_back(cd);
}
}
}
Error ScenePreloader::load_scene(const String& p_path) {
return ERR_CANT_OPEN;
#if 0
if (path==p_path)
return OK;
String p=Globals::get_singleton()->localize_path(p_path);
clear();
Node *scene = SceneLoader::load(p);
ERR_FAIL_COND_V(!scene,ERR_CANT_OPEN);
path=p;
Map<StringName,int> name_map;
HashMap<Variant,int,VariantHasher> variant_map;
Map<Node*,int> node_map;
_parse_node(scene,scene,-1,name_map,variant_map,node_map);
names.resize(name_map.size());
for(Map<StringName,int>::Element *E=name_map.front();E;E=E->next()) {
names[E->get()]=E->key();
}
variants.resize(variant_map.size());
const Variant *K=NULL;
while((K=variant_map.next(K))) {
int idx = variant_map[*K];
variants[idx]=*K;
}
memdelete(scene); // <- me falto esto :(
return OK;
#endif
}
String ScenePreloader::get_scene_path() const {
return path;
}
void ScenePreloader::clear() {
names.clear();
variants.clear();
nodes.clear();
connections.clear();
}
void ScenePreloader::_set_bundled_scene(const Dictionary& d) {
ERR_FAIL_COND( !d.has("names"));
ERR_FAIL_COND( !d.has("variants"));
ERR_FAIL_COND( !d.has("node_count"));
ERR_FAIL_COND( !d.has("nodes"));
ERR_FAIL_COND( !d.has("conn_count"));
ERR_FAIL_COND( !d.has("conns"));
ERR_FAIL_COND( !d.has("path"));
DVector<String> snames = d["names"];
if (snames.size()) {
int namecount = snames.size();
names.resize(namecount);
DVector<String>::Read r =snames.read();
for(int i=0;i<names.size();i++)
names[i]=r[i];
}
Array svariants = d["variants"];
if (svariants.size()) {
int varcount=svariants.size();
variants.resize(varcount);
for(int i=0;i<varcount;i++) {
variants[i]=svariants[i];
}
} else {
variants.clear();
}
nodes.resize(d["node_count"]);
int nc=nodes.size();
if (nc) {
DVector<int> snodes = d["nodes"];
DVector<int>::Read r = snodes.read();
int idx=0;
for(int i=0;i<nc;i++) {
NodeData &nd = nodes[i];
nd.parent=r[idx++];
nd.type=r[idx++];
nd.name=r[idx++];
nd.properties.resize(r[idx++]);
for(int j=0;j<nd.properties.size();j++) {
nd.properties[j].name=r[idx++];
nd.properties[j].value=r[idx++];
}
}
}
connections.resize(d["conn_count"]);
int cc=connections.size();
if (cc) {
DVector<int> sconns = d["conns"];
DVector<int>::Read r = sconns.read();
int idx=0;
for(int i=0;i<nc;i++) {
ConnectionData &cd = connections[nc];
cd.from=r[idx++];
cd.to=r[idx++];
cd.signal=r[idx++];
cd.method=r[idx++];
cd.binds.resize(r[idx++]);
for(int j=0;j<cd.binds.size();j++) {
cd.binds[j]=r[idx++];
}
}
}
path=d["path"];
}
Dictionary ScenePreloader::_get_bundled_scene() const {
DVector<String> rnames;
rnames.resize(names.size());
if (names.size()) {
DVector<String>::Write r=rnames.write();
for(int i=0;i<names.size();i++)
r[i]=names[i];
}
Dictionary d;
d["names"]=rnames;
d["variants"]=variants;
Vector<int> rnodes;
d["node_count"]=nodes.size();
for(int i=0;i<nodes.size();i++) {
const NodeData &nd=nodes[i];
rnodes.push_back(nd.parent);
rnodes.push_back(nd.type);
rnodes.push_back(nd.name);
rnodes.push_back(nd.properties.size());
for(int j=0;j<nd.properties.size();j++) {
rnodes.push_back(nd.properties[j].name);
rnodes.push_back(nd.properties[j].value);
}
}
d["nodes"]=rnodes;
Vector<int> rconns;
d["conn_count"]=connections.size();
for(int i=0;i<connections.size();i++) {
const ConnectionData &cd=connections[i];
rconns.push_back(cd.from);
rconns.push_back(cd.to);
rconns.push_back(cd.signal);
rconns.push_back(cd.method);
rconns.push_back(cd.binds.size());
for(int j=0;j<cd.binds.size();i++)
rconns.push_back(cd.binds[j]);
}
d["conns"]=rconns;
d["path"]=path;
return d;
}
void ScenePreloader::_bind_methods() {
ObjectTypeDB::bind_method(_MD("load_scene","path"),&ScenePreloader::load_scene);
ObjectTypeDB::bind_method(_MD("get_scene_path"),&ScenePreloader::get_scene_path);
ObjectTypeDB::bind_method(_MD("instance:Node"),&ScenePreloader::instance);
ObjectTypeDB::bind_method(_MD("can_instance"),&ScenePreloader::can_instance);
ObjectTypeDB::bind_method(_MD("_set_bundled_scene"),&ScenePreloader::_set_bundled_scene);
ObjectTypeDB::bind_method(_MD("_get_bundled_scene"),&ScenePreloader::_get_bundled_scene);
ADD_PROPERTY( PropertyInfo(Variant::DICTIONARY,"_bundled",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_BUNDLE),_SCS("_set_bundled_scene"),_SCS("_get_bundled_scene"));
#if 0
List<String> extensions;
SceneLoader::get_recognized_extensions(&extensions);
String exthint;
for (List<String>::Element*E=extensions.front();E;E=E->next()) {
if (exthint!="")
exthint+=",";
exthint+="*."+E->get();
}
exthint+="; Scenes";
ADD_PROPERTY( PropertyInfo(Variant::STRING,"scene",PROPERTY_HINT_FILE,exthint),_SCS("load_scene"),_SCS("get_scene_path"));
#endif
}
ScenePreloader::ScenePreloader() {
}

55
scene/scene_binds.cpp
View File

@ -1,55 +0,0 @@
/*************************************************************************/
/* scene_binds.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "scene_binds.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
void SceneIO::_bind_methods() {
ObjectTypeDB::bind_method(_MD("load:Node","path"),&SceneIO::load);
ObjectTypeDB::bind_method(_MD("save","path","scene:Node","flags","optimizer:OptimizedSaver","scene"),&SceneIO::save,DEFVAL(0),DEFVAL(Ref<OptimizedSaver>()));
ObjectTypeDB::bind_method(_MD("load_interactive:SceneInteractiveLoader","path"),&SceneIO::load_interactive);
}
Node* SceneIO::load(const String& p_scene) {
return SceneLoader::load(p_scene);
}
Error SceneIO::save(const String& p_path, Node *p_scene,int p_flags,const Ref<OptimizedSaver> &p_optimizer) {
return SceneSaver::save(p_path,p_scene,p_flags,p_optimizer);
}
Ref<SceneInteractiveLoader> SceneIO::load_interactive(const String& p_scene) {
return SceneLoader::load_interactive(p_scene);
}
#endif

62
scene/scene_binds.h
View File

@ -1,62 +0,0 @@
/*************************************************************************/
/* scene_binds.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef SCENE_BINDS_H
#define SCENE_BINDS_H
#include "scene/io/scene_loader.h"
#include "scene/io/scene_saver.h"
#ifdef OLD_SCENE_FORMAT_ENABLED
class SceneIO : public Object {
OBJ_TYPE( SceneIO, Object );
protected:
static void _bind_methods();
public:
enum SaveFlags {
SAVE_FLAG_RELATIVE_PATHS=SceneSaver::FLAG_RELATIVE_PATHS,
SAVE_FLAG_BUNDLE_RESOURCES=SceneSaver::FLAG_BUNDLE_RESOURCES,
SAVE_FLAG_BUNDLE_INSTANCED_SCENES=SceneSaver::FLAG_BUNDLE_INSTANCED_SCENES,
SAVE_FLAG_OMIT_EDITOR_PROPERTIES=SceneSaver::FLAG_OMIT_EDITOR_PROPERTIES,
SAVE_FLAG_SAVE_BIG_ENDIAN=SceneSaver::FLAG_SAVE_BIG_ENDIAN
};
Node* load(const String& p_scene);
Error save(const String& p_path, Node *p_scene,int p_flags=0,const Ref<OptimizedSaver> &p_optimizer=Ref<OptimizedSaver>());
Ref<SceneInteractiveLoader> load_interactive(const String& p_scene);
SceneIO() {}
};
#endif
#endif // SCENE_BINDS_H

2
servers/SCsub
View File

@ -12,7 +12,7 @@ SConscript('audio/SCsub');
SConscript('spatial_sound/SCsub');
SConscript('spatial_sound_2d/SCsub');
lib = env.Library("servers",env.servers_sources, LIBSUFFIX=env['platform_libsuffix'])
lib = env.Library("servers",env.servers_sources)
env.Prepend(LIBS=[lib])

2
tools/SCsub
View File

@ -13,7 +13,7 @@ SConscript('freetype/SCsub');
SConscript('doc/SCsub');
SConscript('pck/SCsub');
lib = env.Library("tool",env.tool_sources, LIBSUFFIX=env['platform_libsuffix'])
lib = env.Library("tool",env.tool_sources)
env.Prepend(LIBS=[lib])

105
tools/editor/editor_node.cpp
View File

@ -33,8 +33,6 @@
#include "editor_fonts.h"
#include "editor_help.h"
#include "scene/io/scene_saver.h"
#include "scene/io/scene_loader.h"
#include "core/io/resource_saver.h"
#include "core/io/resource_loader.h"
#include "servers/physics_2d_server.h"
@ -233,25 +231,6 @@ void EditorNode::_notification(int p_what) {
if (defer_load_scene!="") {
#ifdef OLD_SCENE_FORMAT_ENABLED
if (convert_old) {
get_scene()->quit();
Node *scn = SceneLoader::load(defer_load_scene,true);
ERR_EXPLAIN("Couldn't load scene: "+defer_load_scene);
ERR_FAIL_COND(!scn);
Ref<PackedScene> sdata = memnew( PackedScene );
Error err = sdata->pack(scn);
ERR_EXPLAIN("Couldn't repack scene: "+defer_load_scene);
ERR_FAIL_COND(err!=OK);
err = ResourceSaver::save(defer_load_scene,sdata);
ERR_EXPLAIN("Couldn't resave scene: "+defer_load_scene);
ERR_FAIL_COND(err!=OK);
return;
}
#endif
load_scene(defer_load_scene);
defer_load_scene="";
}
@ -886,65 +865,6 @@ void EditorNode::_dialog_action(String p_file) {
load_scene(p_file);
} break;
#ifdef OLD_SCENE_FORMAT_ENABLED
case FILE_OPEN_OLD_SCENE: {
String lpath = Globals::get_singleton()->localize_path(p_file);
if (!lpath.begins_with("res://")) {
current_option=-1;
//accept->get_cancel()->hide();
accept->get_ok()->set_text("Ugh");
accept->set_text("Error loading scene, it must be inside the project path. Use 'Import' to open the scene, then save it inside the project path.");
accept->popup_centered(Size2(300,120));
return ;
}
Node*new_scene=SceneLoader::load(lpath,true);
if (!new_scene) {
current_option=-1;
//accept->get_cancel()->hide();
accept->get_ok()->set_text("Ugh");
accept->set_text("Error loading scene.");
accept->popup_centered(Size2(300,70));;
return ;
}
Node *old_scene = edited_scene;
_hide_top_editors();
set_edited_scene(NULL);
editor_data.clear_editor_states();
if (old_scene) {
memdelete(old_scene);
}
set_edited_scene(new_scene);
scene_tree_dock->set_selected(new_scene);
_get_scene_metadata();
editor_data.get_undo_redo().clear_history();
saved_version=editor_data.get_undo_redo().get_version();
_update_title();
_add_to_recent_scenes(lpath);
if (new_scene->has_meta("__editor_plugin_screen__")) {
String editor = new_scene->get_meta("__editor_plugin_screen__");
for(int i=0;i<editor_table.size();i++) {
if (editor_table[i]->get_name()==editor) {
_editor_select(i);
break;
}
}
}
} break;
#endif
case FILE_SAVE_OPTIMIZED: {
@ -1679,28 +1599,6 @@ void EditorNode::_menu_option_confirm(int p_option,bool p_confirmed) {
open_request(previous_scenes.back()->get());
} break;
#ifdef OLD_SCENE_FORMAT_ENABLED
case FILE_OPEN_OLD_SCENE: {
//print_tree();
file->set_mode(FileDialog::MODE_OPEN_FILE);
//not for now?
file->clear_filters();
file->add_filter("*.xml");
//file->set_current_path(current_path);
Node *scene = edited_scene;
if (scene) {
file->set_current_path(scene->get_filename());
};
file->set_title("Open Scene");
file->popup_centered_ratio();
} break;
#endif
case FILE_SAVE_SCENE: {
@ -3549,9 +3447,6 @@ EditorNode::EditorNode() {
p=import_menu->get_popup();
p->add_item("Sub-Scene",FILE_IMPORT_SUBSCENE);
#ifdef OLD_SCENE_FORMAT_ENABLED
p->add_item("Import Old Scene",FILE_OPEN_OLD_SCENE);
#endif
p->add_separator();
p->connect("item_pressed",this,"_menu_option");

2
tools/editor/editor_settings.cpp
View File

@ -30,7 +30,7 @@
#include "os/os.h"
#include "os/dir_access.h"
#include "os/file_access.h"
#include "io/object_format_xml.h"
#include "version.h"
#include "scene/main/scene_main_loop.h"
#include "os/os.h"

468
tools/editor/editor_shape_gizmos.cpp
View File

@ -1,468 +0,0 @@
/*************************************************************************/
/* editor_shape_gizmos.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "editor_shape_gizmos.h"
String EditableShapeSpatialGizmo::get_handle_name(int p_idx) const {
if (es->cast_to<EditableSphere>()) {
return "Radius";
}
#if 0
if (es->cast_to<EditableBox>()) {
return "Extents";
}
if (es->cast_to<EditableCapsule>()) {
return p_idx==0?"Radius":"Height";
}
if (es->cast_to<EditableRay>()) {
return "Length";
}
#endif
return "";
}
Variant EditableShapeSpatialGizmo::get_handle_value(int p_idx) const{
if (es->cast_to<EditableSphere>()) {
EditableSphere *ss = es->cast_to<EditableSphere>();
return ss->get_radius();
}
#if 0
if (es->cast_to<EditableBox>()) {
EditableBox *bs = es->cast_to<EditableBox>();
return bs->get_extents();
}
if (es->cast_to<EditableCapsule>()) {
EditableCapsule *cs = es->cast_to<EditableCapsule>();
return p_idx==0?es->get_radius():es->get_height();
}
if (es->cast_to<EditableRay>()) {
EditableRay* cs = es->cast_to<EditableRay>();
return es->get_length();
}
#endif
return Variant();
}
void EditableShapeSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point){
Transform gt = es->get_global_transform();
gt.orthonormalize();
Transform gi = gt.affine_inverse();
Vector3 ray_from = p_camera->project_ray_origin(p_point);
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
Vector3 sg[2]={gi.xform(ray_from),gi.xform(ray_from+ray_dir*4096)};
if (es->cast_to<EditableSphere>()) {
EditableSphere *ss = es->cast_to<EditableSphere>();
Vector3 ra,rb;
Geometry::get_closest_points_between_segments(Vector3(),Vector3(4096,0,0),sg[0],sg[1],ra,rb);
float d = ra.x;
if (d<0.001)
d=0.001;
ss->set_radius(d);
}
#if 0
if (es->cast_to<EditableRay>()) {
EditableRay*cs = es->cast_to<EditableRay>();
Vector3 ra,rb;
Geometry::get_closest_points_between_segments(Vector3(),Vector3(0,0,4096),sg[0],sg[1],ra,rb);
float d = ra.z;
if (d<0.001)
d=0.001;
rs->set_length(d);
}
if (es->cast_to<EditableBox>()) {
Vector3 axis;
axis[p_idx]=1.0;
EditableBox *bs = es->cast_to<EditableBox>();
Vector3 ra,rb;
Geometry::get_closest_points_between_segments(Vector3(),axis*4096,sg[0],sg[1],ra,rb);
float d = ra[p_idx];
if (d<0.001)
d=0.001;
Vector3 he = bs->get_extents();
he[p_idx]=d;
bs->set_extents(he);
}
if (es->cast_to<EditableCapsule>()) {
Vector3 axis;
axis[p_idx]=1.0;
EditableCapsule *cs = es->cast_to<EditableCapsule>();
Vector3 ra,rb;
Geometry::get_closest_points_between_segments(Vector3(),axis*4096,sg[0],sg[1],ra,rb);
float d = ra[p_idx];
if (p_idx==1)
d-=es->get_radius();
if (d<0.001)
d=0.001;
if (p_idx==0)
es->set_radius(d);
else if (p_idx==1)
es->set_height(d*2.0);
}
#endif
}
void EditableShapeSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
if (es->cast_to<EditableSphere>()) {
EditableSphere *ss = es->cast_to<EditableSphere>();
if (p_cancel) {
ss->set_radius(p_restore);
return;
}
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
ur->create_action("Change Sphere Shape Radius");
ur->add_do_method(ss,"set_radius",ss->get_radius());
ur->add_undo_method(ss,"set_radius",p_restore);
ur->commit_action();
}
#if 0
if (es->cast_to<EditableBox>()) {
EditableBox *ss = es->cast_to<EditableBox>();
if (p_cancel) {
ss->set_extents(p_restore);
return;
}
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
ur->create_action("Change Box Shape Extents");
ur->add_do_method(ss,"set_extents",ss->get_extents());
ur->add_undo_method(ss,"set_extents",p_restore);
ur->commit_action();
}
if (es->cast_to<EditableCapsule>()) {
EditableCapsule *cs = es->cast_to<EditableCapsule>();
if (p_cancel) {
if (p_idx==0)
ss->set_radius(p_restore);
else
ss->set_height(p_restore);
return;
}
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
if (p_idx==0) {
ur->create_action("Change Capsule Shape Radius");
ur->add_do_method(ss,"set_radius",ss->get_radius());
ur->add_undo_method(ss,"set_radius",p_restore);
} else {
ur->create_action("Change Capsule Shape Height");
ur->add_do_method(ss,"set_height",ss->get_height());
ur->add_undo_method(ss,"set_height",p_restore);
}
ur->commit_action();
}
if (es->cast_to<EditableRay>()) {
EditableRay*rs = es->cast_to<EditableRay>()
if (p_cancel) {
ss->set_length(p_restore);
return;
}
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
ur->create_action("Change Ray Shape Length");
ur->add_do_method(ss,"set_length",ss->get_length());
ur->add_undo_method(ss,"set_length",p_restore);
ur->commit_action();
}
#endif
}
void EditableShapeSpatialGizmo::redraw(){
clear();
if (es->cast_to<EditableSphere>()) {
EditableSphere* sp= es->cast_to<EditableSphere>();
float r=sp->get_radius();
Vector<Vector3> points;
for(int i=0;i<=360;i++) {
float ra=Math::deg2rad(i);
float rb=Math::deg2rad(i+1);
Point2 a = Vector2(Math::sin(ra),Math::cos(ra))*r;
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*r;
points.push_back(Vector3(a.x,0,a.y));
points.push_back(Vector3(b.x,0,b.y));
points.push_back(Vector3(0,a.x,a.y));
points.push_back(Vector3(0,b.x,b.y));
points.push_back(Vector3(a.x,a.y,0));
points.push_back(Vector3(b.x,b.y,0));
}
Vector<Vector3> collision_segments;
for(int i=0;i<64;i++) {
float ra=i*Math_PI*2.0/64.0;
float rb=(i+1)*Math_PI*2.0/64.0;
Point2 a = Vector2(Math::sin(ra),Math::cos(ra))*r;
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*r;
collision_segments.push_back(Vector3(a.x,0,a.y));
collision_segments.push_back(Vector3(b.x,0,b.y));
collision_segments.push_back(Vector3(0,a.x,a.y));
collision_segments.push_back(Vector3(0,b.x,b.y));
collision_segments.push_back(Vector3(a.x,a.y,0));
collision_segments.push_back(Vector3(b.x,b.y,0));
}
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
add_collision_segments(collision_segments);
Vector<Vector3> handles;
handles.push_back(Vector3(r,0,0));
add_handles(handles);
}
#if 0
if (es->cast_to<EditableBox>()) {
EditableBox*bs = es->cast_to<EditableBox>();
Vector<Vector3> lines;
AABB aabb;
aabb.pos=-bs->get_extents();
aabb.size=aabb.pos*-2;
for(int i=0;i<12;i++) {
Vector3 a,b;
aabb.get_edge(i,a,b);
lines.push_back(a);
lines.push_back(b);
}
Vector<Vector3> handles;
for(int i=0;i<3;i++) {
Vector3 ax;
ax[i]=bs->get_extents()[i];
handles.push_back(ax);
}
add_lines(lines,SpatialEditorGizmos::singleton->shape_material);
add_collision_segments(lines);
add_handles(handles);
}
if (es->cast_to<EditableCapsule>()) {
EditableCapsule *cs = es->cast_to<EditableCapsule>();
float radius = es->get_radius();
float height = es->get_height();
Vector<Vector3> points;
Vector3 d(0,height*0.5,0);
for(int i=0;i<360;i++) {
float ra=Math::deg2rad(i);
float rb=Math::deg2rad(i+1);
Point2 a = Vector2(Math::sin(ra),Math::cos(ra))*radius;
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*radius;
points.push_back(Vector3(a.x,0,a.y)+d);
points.push_back(Vector3(b.x,0,b.y)+d);
points.push_back(Vector3(a.x,0,a.y)-d);
points.push_back(Vector3(b.x,0,b.y)-d);
if (i%90==0) {
points.push_back(Vector3(a.x,0,a.y)+d);
points.push_back(Vector3(a.x,0,a.y)-d);
}
Vector3 dud = i<180?d:-d;
points.push_back(Vector3(0,a.x,a.y)+dud);
points.push_back(Vector3(0,b.x,b.y)+dud);
points.push_back(Vector3(a.y,a.x,0)+dud);
points.push_back(Vector3(b.y,b.x,0)+dud);
}
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
Vector<Vector3> collision_segments;
for(int i=0;i<64;i++) {
float ra=i*Math_PI*2.0/64.0;
float rb=(i+1)*Math_PI*2.0/64.0;
Point2 a = Vector2(Math::sin(ra),Math::cos(ra))*radius;
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*radius;
collision_segments.push_back(Vector3(a.x,0,a.y)+d);
collision_segments.push_back(Vector3(b.x,0,b.y)+d);
collision_segments.push_back(Vector3(a.x,0,a.y)-d);
collision_segments.push_back(Vector3(b.x,0,b.y)-d);
if (i%16==0) {
collision_segments.push_back(Vector3(a.x,0,a.y)+d);
collision_segments.push_back(Vector3(a.x,0,a.y)-d);
}
Vector3 dud = i<32?d:-d;
collision_segments.push_back(Vector3(0,a.x,a.y)+dud);
collision_segments.push_back(Vector3(0,b.x,b.y)+dud);
collision_segments.push_back(Vector3(a.y,a.x,0)+dud);
collision_segments.push_back(Vector3(b.y,b.x,0)+dud);
}
add_collision_segments(collision_segments);
Vector<Vector3> handles;
handles.push_back(Vector3(es->get_radius(),0,0));
handles.push_back(Vector3(0,es->get_height()*0.5+es->get_radius(),0));
add_handles(handles);
}
if (es->cast_to<EditablePlane>()) {
EditablePlane* ps=es->cast_to<EditablePlane();
Plane p = ps->get_plane();
Vector<Vector3> points;
Vector3 n1 = p.get_any_perpendicular_normal();
Vector3 n2 = p.normal.cross(n1).normalized();
Vector3 pface[4]={
p.normal*p.d+n1*10.0+n2*10.0,
p.normal*p.d+n1*10.0+n2*-10.0,
p.normal*p.d+n1*-10.0+n2*-10.0,
p.normal*p.d+n1*-10.0+n2*10.0,
};
points.push_back(pface[0]);
points.push_back(pface[1]);
points.push_back(pface[1]);
points.push_back(pface[2]);
points.push_back(pface[2]);
points.push_back(pface[3]);
points.push_back(pface[3]);
points.push_back(pface[0]);
points.push_back(p.normal*p.d);
points.push_back(p.normal*p.d+p.normal*3);
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
add_collision_segments(points);
}
if (es->cast_to<EditableRay>()) {
EditableRay*cs = es->cast_to<EditableRay>();
Vector<Vector3> points;
points.push_back(Vector3());
points.push_back(Vector3(0,0,rs->get_length()));
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
add_collision_segments(points);
Vector<Vector3> handles;
handles.push_back(Vector3(0,0,rs->get_length()));
add_handles(handles);
}
#endif
}
EditableShapeSpatialGizmo::EditableShapeSpatialGizmo(EditableShape* p_cs) {
es=p_cs;
set_spatial_node(p_cs);
}
EditorShapeGizmos::EditorShapeGizmos()
{
}

60
tools/editor/editor_shape_gizmos.h
View File

@ -1,60 +0,0 @@
/*************************************************************************/
/* editor_shape_gizmos.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef EDITOR_SHAPE_GIZMOS_H
#define EDITOR_SHAPE_GIZMOS_H
#include "spatial_editor_gizmos.h"
#include "scene/3d/editable_shape.h"
class EditableShapeSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(EditableShapeSpatialGizmo,SpatialGizmoTool);
EditableShape *es;
public:
virtual String get_handle_name(int p_idx) const;
virtual Variant get_handle_value(int p_idx) const;
virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
void redraw();
EditableShapeSpatialGizmo(EditableShape* p_cs=NULL);
};
class EditorShapeGizmos
{
public:
EditorShapeGizmos();
};
#endif // EDITOR_SHAPE_GIZMOS_H

204
tools/editor/plugins/baked_light_baker.cpp
View File

@ -6,6 +6,44 @@
#include "tools/editor/editor_node.h"
_FORCE_INLINE_ static uint64_t get_uv_normal_bit(const Vector3& p_vector) {
int lat = Math::fast_ftoi(Math::floor(Math::acos(p_vector.dot(Vector3(0,1,0)))*6.0/Math_PI+0.5));
if (lat==0) {
return 60;
} else if (lat==6) {
return 61;
}
int lon = Math::fast_ftoi(Math::floor( (Math_PI+Math::atan2(p_vector.x,p_vector.z))*12.0/(Math_PI*2.0) + 0.5))%12;
return lon+(lat-1)*12;
}
_FORCE_INLINE_ static Vector3 get_bit_normal(int p_bit) {
if (p_bit==61) {
return Vector3(0,1,0);
} else if (p_bit==62){
return Vector3(0,-1,0);
}
float latang = ((p_bit / 12)+1)*Math_PI/6.0;
Vector2 latv(Math::sin(latang),Math::cos(latang));
float lonang = ((p_bit%12)*Math_PI*2.0/12.0)-Math_PI;
Vector2 lonv(Math::sin(lonang),Math::cos(lonang));
return Vector3(lonv.x*latv.x,latv.y,lonv.y*latv.x).normalized();
}
BakedLightBaker::MeshTexture* BakedLightBaker::_get_mat_tex(const Ref<Texture>& p_tex) {
if (!tex_map.has(p_tex)) {
@ -533,10 +571,12 @@ void BakedLightBaker::_octree_insert(int p_octant,Triangle* p_triangle, int p_de
child->offset[2]=child->aabb.pos.z+child->aabb.size.z*0.5;
child->next_leaf=leaf_list;
for(int ci=0;ci<8;ci++) {
child->normal_accum[ci][0]=0;
child->normal_accum[ci][1]=0;
child->normal_accum[ci][2]=0;
}
child->bake_neighbour=0;
@ -593,11 +633,26 @@ void BakedLightBaker::_octree_insert(int p_octant,Triangle* p_triangle, int p_de
pos.y=floor((pos.y+cell_size*0.5)/cell_size);
pos.z=floor((pos.z+cell_size*0.5)/cell_size);
Map<Vector3,Vector3>::Element *E=endpoint_normal.find(pos);
if (!E) {
endpoint_normal[pos]=n;
} else {
E->get()+=n;
{
Map<Vector3,Vector3>::Element *E=endpoint_normal.find(pos);
if (!E) {
endpoint_normal[pos]=n;
} else {
E->get()+=n;
}
}
{
uint64_t bit = get_uv_normal_bit(n);
Map<Vector3,uint64_t>::Element *E=endpoint_normal_bits.find(pos);
if (!E) {
endpoint_normal_bits[pos]=(1<<bit);
} else {
E->get()|=(1<<bit);
}
}
}
@ -677,18 +732,58 @@ void BakedLightBaker::_make_octree() {
pos.y=floor((pos.y+cell_size*0.5)/cell_size);
pos.z=floor((pos.z+cell_size*0.5)/cell_size);
Map<Vector3,Vector3>::Element *E=endpoint_normal.find(pos);
if (!E) {
//?
print_line("lolwut?");
} else {
Vector3 n = E->get().normalized();
oct->normal_accum[ci][0]=n.x;
oct->normal_accum[ci][1]=n.y;
oct->normal_accum[ci][2]=n.z;
{
Map<Vector3,Vector3>::Element *E=endpoint_normal.find(pos);
if (!E) {
//?
print_line("lolwut?");
} else {
Vector3 n = E->get().normalized();
oct->normal_accum[ci][0]=n.x;
oct->normal_accum[ci][1]=n.y;
oct->normal_accum[ci][2]=n.z;
}
}
{
Map<Vector3,uint64_t>::Element *E=endpoint_normal_bits.find(pos);
if (!E) {
//?
print_line("lolwut?");
} else {
float max_aper=0;
for(uint64_t i=0;i<62;i++) {
if (!(E->get()&(1<<i)))
continue;
Vector3 ang_i = get_bit_normal(i);
for(uint64_t j=0;j<62;j++) {
if (i==j)
continue;
if (!(E->get()&(1<<j)))
continue;
Vector3 ang_j = get_bit_normal(j);
float ang = Math::acos(ang_i.dot(ang_j));
if (ang>max_aper)
max_aper=ang;
}
}
if (max_aper>0.75*Math_PI) {
//angle too wide prevent problems and forget
oct->normal_accum[ci][0]=0;
oct->normal_accum[ci][1]=0;
oct->normal_accum[ci][2]=0;
}
}
}
}
oct_idx=oct->next_leaf;
@ -742,13 +837,23 @@ void BakedLightBaker::_plot_light(int p_light_index, const Vector3& p_plot_pos,
float d = p_plot_pos.distance_to(pos);
if (d<=r) {
if ((p_plane.distance_to(pos)>-cell_size*1.75) && d<=r) {
float intensity = 1.0 - (d/r)*(d/r); //not gauss but..
float damp = Math::abs(p_plane.normal.dot(Vector3(octant.normal_accum[i][0],octant.normal_accum[i][1],octant.normal_accum[i][2])));
intensity*=pow(damp,edge_damp);
if (edge_damp>0) {
Vector3 normal = Vector3(octant.normal_accum[i][0],octant.normal_accum[i][1],octant.normal_accum[i][2]);
if (normal.x>0 || normal.y>0 || normal.z>0) {
float damp = Math::abs(p_plane.normal.dot(normal));
intensity*=pow(damp,edge_damp);
}
}
//intensity*=1.0-Math::abs(p_plane.distance_to(pos))/(plot_size*cell_size);
//intensity = Math::cos(d*Math_PI*0.5/r);
octant.light[p_light_index].accum[i][0]+=p_light.r*intensity;
octant.light[p_light_index].accum[i][1]+=p_light.g*intensity;
octant.light[p_light_index].accum[i][2]+=p_light.b*intensity;
@ -788,7 +893,7 @@ void BakedLightBaker::_plot_light(int p_light_index, const Vector3& p_plot_pos,
}
float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, const Vector3& p_end,float p_rest,const Color& p_light,float *p_att_curve,float p_att_pos,int p_att_curve_len,int p_bounces,bool p_first_bounce) {
float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, const Vector3& p_end,float p_rest,const Color& p_light,float *p_att_curve,float p_att_pos,int p_att_curve_len,int p_bounces,bool p_first_bounce,bool p_only_dist) {
uint32_t* stack = ray_stack;
@ -918,8 +1023,13 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
}
if (inters) {
if (p_only_dist) {
return p_begin.distance_to(r_point);
}
//should check if there is normals first
@ -932,6 +1042,9 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
}
if (n.dot(r_normal)>0)
return -1;
if (n.dot(r_normal)>0)
r_normal=-r_normal;
@ -969,6 +1082,20 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
//the multiplication can happen with more detail in the shader
if (triangle->material) {
//triangle->get_uv(r_point);
diffuse_at_point=triangle->material->diffuse.get_color(uv);
specular_at_point=triangle->material->specular.get_color(uv);
}
diffuse_at_point.r=res_light.r*diffuse_at_point.r;
diffuse_at_point.g=res_light.g*diffuse_at_point.g;
diffuse_at_point.b=res_light.b*diffuse_at_point.b;
float ret=1e6;
if (p_bounces>0) {
@ -985,18 +1112,6 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
if (triangle->material) {
//triangle->get_uv(r_point);
diffuse_at_point=triangle->material->diffuse.get_color(uv);
specular_at_point=triangle->material->specular.get_color(uv);
}
diffuse_at_point.r=res_light.r*diffuse_at_point.r;
diffuse_at_point.g=res_light.g*diffuse_at_point.g;
diffuse_at_point.b=res_light.b*diffuse_at_point.b;
specular_at_point.r=res_light.r*specular_at_point.r;
specular_at_point.g=res_light.g*specular_at_point.g;
@ -1043,7 +1158,7 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
// _plot_light_point(r_point,octree,octree_aabb,p_light);
Color plot_light=res_light;
Color plot_light=diffuse_at_point;
plot_light.r*=att;
plot_light.g*=att;
plot_light.b*=att;
@ -1051,11 +1166,31 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
if (!p_first_bounce) {
float r = plot_size * cell_size*4;
if (ret<r) {
float r = plot_size * cell_size*2;
if (dist<r) {
//avoid accumulaiton of light on corners
//plot_light=plot_light.linear_interpolate(Color(0,0,0,0),1.0-sd/plot_size*plot_size);
plot_light=Color(0,0,0,0);
} else {
Vector3 c1=r_normal.cross(n).normalized();
Vector3 c2=r_normal.cross(c1).normalized();
double r1 = double(rand())/RAND_MAX;
double r2 = double(rand())/RAND_MAX;
double r3 = double(rand())/RAND_MAX;
Vector3 rn = ((c1*(r1-0.5)) + (c2*(r2-0.5)) + (r_normal*r3*0.25)).normalized();
float d =_throw_ray(p_light_index,r_point,r_point+rn*p_rest,p_rest,diffuse_at_point,p_att_curve,p_att_pos,p_att_curve_len,p_bounces-1,false,true);
r = plot_size*cell_size*0.7;
if (d>0 && d<r) {
//avoid accumulaiton of light on corners
//plot_light=plot_light.linear_interpolate(Color(0,0,0,0),1.0-sd/plot_size*plot_size);
plot_light=Color(0,0,0,0);
} else {
//plot_light=Color(0,0,0,0);
}
}
}
@ -1070,7 +1205,7 @@ float BakedLightBaker::_throw_ray(int p_light_index,const Vector3& p_begin, cons
return dist;
}
return 0;
return -1;
}
@ -2248,6 +2383,7 @@ void BakedLightBaker::clear() {
lights.clear();
triangles.clear();;
endpoint_normal.clear();
endpoint_normal_bits.clear();
baked_octree_texture_w=0;
baked_octree_texture_h=0;
paused=false;

3
tools/editor/plugins/baked_light_baker.h
View File

@ -239,6 +239,7 @@ public:
uint32_t *octant_stack;
uint32_t *octantptr_stack;
Map<Vector3,Vector3> endpoint_normal;
Map<Vector3,uint64_t> endpoint_normal_bits;
BVH **bvh_stack;
float cell_size;
float plot_size; //multiplied by cell size
@ -287,7 +288,7 @@ public:
void _plot_light(int p_light_index,const Vector3& p_plot_pos,const AABB& p_plot_aabb,const Color& p_light,const Plane& p_plane);
//void _plot_light_point(const Vector3& p_plot_pos, Octant *p_octant, const AABB& p_aabb,const Color& p_light);
float _throw_ray(int p_light_index,const Vector3& p_begin, const Vector3& p_end,float p_rest,const Color& p_light,float *p_att_curve,float p_att_pos,int p_att_curve_len,int p_bounces,bool p_first_bounce=false);
float _throw_ray(int p_light_index,const Vector3& p_begin, const Vector3& p_end,float p_rest,const Color& p_light,float *p_att_curve,float p_att_pos,int p_att_curve_len,int p_bounces,bool p_first_bounce=false,bool p_only_dist=false);
float total_light_area;

4
tools/editor/project_export.cpp
View File

@ -31,13 +31,13 @@
#include "os/dir_access.h"
#include "os/file_access.h"
#include "globals.h"
#include "scene/io/scene_loader.h"
#include "io/resource_loader.h"
#include "io/resource_saver.h"
#include "os/os.h"
#include "scene/gui/box_container.h"
#include "default_saver.h"
#include "scene/io/scene_saver.h"
#include "scene/gui/tab_container.h"
#include "scene/gui/scroll_container.h"
#include "editor_data.h"

2
tools/editor/scenes_dock.cpp
View File

@ -30,7 +30,7 @@
#include "os/dir_access.h"
#include "os/file_access.h"
#include "globals.h"
#include "scene/io/scene_loader.h"
#include "io/resource_loader.h"
#include "os/os.h"
#include "editor_node.h"

75
tools/editor/spatial_editor_gizmos.cpp
View File

@ -36,7 +36,7 @@
#include "scene/resources/ray_shape.h"
#include "scene/resources/convex_polygon_shape.h"
#include "scene/resources/plane_shape.h"
#include "editor_shape_gizmos.h"
// Keep small children away from this file.
// It's so ugly it will eat them alive
@ -1474,69 +1474,6 @@ RayCastSpatialGizmo::RayCastSpatialGizmo(RayCast* p_raycast){
}
/////
void CarWheelSpatialGizmo::redraw() {
clear();
Vector<Vector3> points;
float r = car_wheel->get_radius();
const int skip=10;
for(int i=0;i<=360;i+=skip) {
float ra=Math::deg2rad(i);
float rb=Math::deg2rad(i+skip);
Point2 a = Vector2(Math::sin(ra),Math::cos(ra))*r;
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*r;
points.push_back(Vector3(0,a.x,a.y));
points.push_back(Vector3(0,b.x,b.y));
const int springsec=4;
for(int j=0;j<springsec;j++) {
float t = car_wheel->get_travel()*5;
points.push_back(Vector3(a.x,i/360.0*t/springsec+j*(t/springsec),a.y)*0.2);
points.push_back(Vector3(b.x,(i+skip)/360.0*t/springsec+j*(t/springsec),b.y)*0.2);
}
}
//travel
points.push_back(Vector3(0,0,0));
points.push_back(Vector3(0,car_wheel->get_travel(),0));
//axis
points.push_back(Vector3(r*0.2,car_wheel->get_travel(),0));
points.push_back(Vector3(-r*0.2,car_wheel->get_travel(),0));
//axis
points.push_back(Vector3(r*0.2,0,0));
points.push_back(Vector3(-r*0.2,0,0));
//forward line
points.push_back(Vector3(0,-r,0));
points.push_back(Vector3(0,-r,r*2));
points.push_back(Vector3(0,-r,r*2));
points.push_back(Vector3(r*2*0.2,-r,r*2*0.8));
points.push_back(Vector3(0,-r,r*2));
points.push_back(Vector3(-r*2*0.2,-r,r*2*0.8));
add_lines(points,SpatialEditorGizmos::singleton->car_wheel_material);
add_collision_segments(points);
}
CarWheelSpatialGizmo::CarWheelSpatialGizmo(CarWheel* p_car_wheel){
set_spatial_node(p_car_wheel);
car_wheel=p_car_wheel;
}
/////
@ -2888,16 +2825,6 @@ Ref<SpatialEditorGizmo> SpatialEditorGizmos::get_gizmo(Spatial *p_spatial) {
return misg;
}
if (p_spatial->cast_to<EditableShape>()) {
Ref<EditableShapeSpatialGizmo> misg = memnew( EditableShapeSpatialGizmo(p_spatial->cast_to<EditableShape>()) );
return misg;
}
if (p_spatial->cast_to<CarWheel>()) {
Ref<CarWheelSpatialGizmo> misg = memnew( CarWheelSpatialGizmo(p_spatial->cast_to<CarWheel>()) );
return misg;
}
if (p_spatial->cast_to<VehicleWheel>()) {
Ref<VehicleWheelSpatialGizmo> misg = memnew( VehicleWheelSpatialGizmo(p_spatial->cast_to<VehicleWheel>()) );

15
tools/editor/spatial_editor_gizmos.h
View File

@ -44,7 +44,7 @@
#include "scene/3d/portal.h"
#include "scene/3d/ray_cast.h"
#include "scene/3d/navigation_mesh.h"
#include "scene/3d/car_body.h"
#include "scene/3d/vehicle_body.h"
#include "scene/3d/collision_polygon.h"
#include "scene/3d/physics_joint.h"
@ -332,19 +332,6 @@ public:
};
class CarWheelSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(CarWheelSpatialGizmo,SpatialGizmoTool);
CarWheel* car_wheel;
public:
void redraw();
CarWheelSpatialGizmo(CarWheel* p_car_wheel=NULL);
};
class VehicleWheelSpatialGizmo : public SpatialGizmoTool {