[Python-ogre-commit] SF.net SVN: python-ogre:[845] trunk/python-ogre
Brought to you by:
andy_miller,
roman_yakovenko
Menu
▾
▴
[Python-ogre-commit] SF.net SVN: python-ogre:[845] trunk/python-ogre
|
From: <and...@us...> - 2009-01-25 03:51:18
|
Revision: 845
http://python-ogre.svn.sourceforge.net/python-ogre/?rev=845&view=rev
Author: andy_miller
Date: 2009-01-25 03:51:12 +0000 (Sun, 25 Jan 2009)
Log Message:
-----------
Updated to Caelum 0.4
Small fixes for Ogre 1.6.1 (exposed a missing class)
Added Mac changes to environment.py
Modified Paths:
--------------
trunk/python-ogre/PythonOgreConfig_nt.py
trunk/python-ogre/ThirdParty/caelum/Caelum.h
trunk/python-ogre/ThirdParty/caelum/CaelumPrerequisites.h
trunk/python-ogre/ThirdParty/caelum/CaelumSystem.cpp
trunk/python-ogre/ThirdParty/caelum/CaelumSystem.h
trunk/python-ogre/ThirdParty/caelum/CloudSystem.cpp
trunk/python-ogre/ThirdParty/caelum/CloudSystem.h
trunk/python-ogre/ThirdParty/caelum/DepthComposer.cpp
trunk/python-ogre/ThirdParty/caelum/DepthComposer.h
trunk/python-ogre/ThirdParty/caelum/FlatCloudLayer.cpp
trunk/python-ogre/ThirdParty/caelum/FlatCloudLayer.h
trunk/python-ogre/ThirdParty/caelum/GeometryFactory.cpp
trunk/python-ogre/ThirdParty/caelum/GeometryFactory.h
trunk/python-ogre/ThirdParty/caelum/GroundFog.cpp
trunk/python-ogre/ThirdParty/caelum/GroundFog.h
trunk/python-ogre/ThirdParty/caelum/Moon.h
trunk/python-ogre/ThirdParty/caelum/OwnedPtr.h
trunk/python-ogre/ThirdParty/caelum/PointStarfield.cpp
trunk/python-ogre/ThirdParty/caelum/PointStarfield.h
trunk/python-ogre/ThirdParty/caelum/PrecipitationController.cpp
trunk/python-ogre/ThirdParty/caelum/PrecipitationController.h
trunk/python-ogre/ThirdParty/caelum/SkyDome.cpp
trunk/python-ogre/ThirdParty/caelum/SkyDome.h
trunk/python-ogre/ThirdParty/caelum/SkyLight.cpp
trunk/python-ogre/ThirdParty/caelum/SkyLight.h
trunk/python-ogre/ThirdParty/caelum/Sun.cpp
trunk/python-ogre/ThirdParty/caelum/UniversalClock.h
trunk/python-ogre/code_generators/caelum/generate_code.py
trunk/python-ogre/code_generators/caelum/python_caelum_aliases.h
trunk/python-ogre/code_generators/ogre/generate_code.py
trunk/python-ogre/code_generators/ogre/python_ogre_aliases.h
trunk/python-ogre/code_generators/ogre/python_ogre_masterlist.h
trunk/python-ogre/code_generators/ogre/python_ogre_sizeof.h
trunk/python-ogre/code_generators/quickgui/python_quickgui_aliases.h
trunk/python-ogre/environment.py
trunk/python-ogre/scripts/UpdateDLLs.bat
trunk/python-ogre/setup.py
Added Paths:
-----------
trunk/python-ogre/ThirdParty/caelum/CaelumDefaultTypeDescriptorData.cpp
trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.cpp
trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.h
trunk/python-ogre/ThirdParty/caelum/CaelumScriptTranslator.cpp
trunk/python-ogre/ThirdParty/caelum/CaelumScriptTranslator.h
trunk/python-ogre/ThirdParty/caelum/TypeDescriptor.cpp
trunk/python-ogre/ThirdParty/caelum/TypeDescriptor.h
Modified: trunk/python-ogre/PythonOgreConfig_nt.py
===================================================================
--- trunk/python-ogre/PythonOgreConfig_nt.py 2009-01-24 05:00:41 UTC (rev 844)
+++ trunk/python-ogre/PythonOgreConfig_nt.py 2009-01-25 03:51:12 UTC (rev 845)
@@ -1,6 +1,6 @@
import os
-SDK=True # Changes Ogre include path settings
+SDK=False # Changes Ogre include path settings
## The root directory is where this module is located
module_dir = os.path.abspath(os.path.dirname(__file__) )
@@ -31,7 +31,8 @@
## Parent directories of the libraries
PATH_THIRDPARTY = os.path.join(module_dir, 'ThirdParty' )
PATH_Ogre = os.path.join(BASE_DIR, 'ogre')
-PATH_Ogre = "C:\\OgreSDK"
+if SDK:
+ PATH_Ogre = "C:\\OgreSDK"
PATH_OgreAddons = os.path.join(BASE_DIR, 'OgreAddons')
PATH_CEGUI = os.path.join(BASE_DIR, 'CEGUI-0.6.2')
@@ -96,7 +97,7 @@
###
PATH_LIB_Ogre_CEGUIRenderer = os.path.join( PATH_Ogre, 'Samples/Common/CEGUIRenderer/lib')
PATH_LIB_Ogre_OgreMain= os.path.join( PATH_Ogre, 'lib' )
-PATH_LIB_Ogre_Dependencies = ""# os.path.join( PATH_Ogre, 'Dependencies/lib/Release')
+PATH_LIB_Ogre_Dependencies = os.path.join( PATH_Ogre, 'Dependencies/lib/Release')
PATH_LIB_OgreRefApp = os.path.join( PATH_Ogre, 'lib')
PATH_LIB_OgreNewt = os.path.join( PATH_OgreAddons, 'ogrenewt/OgreNewt_Main/lib/Release')
PATH_LIB_Newton = os.path.join( PATH_Newton ,'dll') ##NOTE Posix platforms this lives in 'lib-mt'
@@ -140,7 +141,7 @@
PATH_INCLUDE_Ogre= os.path.join(PATH_Ogre,'OgreMain/include')
PATH_INCLUDE_NEDMALLOC= "" #os.path.join(PATH_Ogre,'OgreMain', 'src', 'nedmalloc')
-PATH_INCLUDE_Ogre_Dependencies = "" #os.path.join( PATH_Ogre, 'Dependencies/include')
+PATH_INCLUDE_Ogre_Dependencies = os.path.join( PATH_Ogre, 'Dependencies/include')
PATH_INCLUDE_OIS = os.path.join(PATH_OIS,'includes') ## Note the plural include's
PATH_INCLUDE_OgreRefApp = os.path.join(PATH_Ogre,'ReferenceApplication/ReferenceAppLayer/include')
PATH_INCLUDE_OgreNewt = os.path.join(PATH_OgreAddons,'ogrenewt/OgreNewt_Main/inc')
Modified: trunk/python-ogre/ThirdParty/caelum/Caelum.h
===================================================================
--- trunk/python-ogre/ThirdParty/caelum/Caelum.h 2009-01-24 05:00:41 UTC (rev 844)
+++ trunk/python-ogre/ThirdParty/caelum/Caelum.h 2009-01-25 03:51:12 UTC (rev 845)
@@ -22,6 +22,9 @@
#define CAELUM_H
#include "CaelumPrerequisites.h"
+#include "CaelumScriptTranslator.h"
+#include "TypeDescriptor.h"
+#include "CaelumPlugin.h"
#include "CaelumExceptions.h"
#include "CaelumSystem.h"
#include "CameraBoundElement.h"
Added: trunk/python-ogre/ThirdParty/caelum/CaelumDefaultTypeDescriptorData.cpp
===================================================================
--- trunk/python-ogre/ThirdParty/caelum/CaelumDefaultTypeDescriptorData.cpp (rev 0)
+++ trunk/python-ogre/ThirdParty/caelum/CaelumDefaultTypeDescriptorData.cpp 2009-01-25 03:51:12 UTC (rev 845)
@@ -0,0 +1,419 @@
+/*
+This file is part of Caelum.
+See http://www.ogre3d.org/wiki/index.php/Caelum
+
+Copyright (c) 2008 Caelum team. See Contributors.txt for details.
+
+Caelum is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Caelum is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with Caelum. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "CaelumPrecompiled.h"
+#include "CaelumPrerequisites.h"
+
+#if CAELUM_TYPE_DESCRIPTORS
+
+#include "TypeDescriptor.h"
+#include "CaelumSystem.h"
+#include "FlatCloudLayer.h"
+
+using namespace Ogre;
+
+namespace Caelum
+{
+ CaelumDefaultTypeDescriptorData::CaelumDefaultTypeDescriptorData ():
+ CaelumSystemTypeDescriptor(0),
+ PointStarfieldTypeDescriptor(0),
+ BaseSkyLightTypeDescriptor(0),
+ GroundFogTypeDescriptor(0),
+ PrecipitationTypeDescriptor(0),
+ DepthComposerTypeDescriptor(0),
+ FlatCloudLayerTypeDescriptor(0),
+ SkyDomeTypeDescriptor(0)
+ {
+ try {
+ load ();
+ } catch (...) {
+ unload ();
+ throw;
+ }
+ }
+
+ CaelumDefaultTypeDescriptorData::~CaelumDefaultTypeDescriptorData ()
+ {
+ unload ();
+ }
+
+ template<class T>
+ inline void delete_zero(T*& member) {
+ // Remember: delete 0 is a legal no-op.
+ delete member;
+ member = 0;
+ }
+
+ void CaelumDefaultTypeDescriptorData::unload ()
+ {
+ delete_zero(CaelumSystemTypeDescriptor);
+ delete_zero(PointStarfieldTypeDescriptor);
+ delete_zero(BaseSkyLightTypeDescriptor);
+ delete_zero(GroundFogTypeDescriptor);
+ delete_zero(PrecipitationTypeDescriptor);
+ delete_zero(DepthComposerTypeDescriptor);
+ delete_zero(FlatCloudLayerTypeDescriptor);
+ delete_zero(SkyDomeTypeDescriptor);
+ }
+
+ void CaelumDefaultTypeDescriptorData::load ()
+ {
+ if (!CaelumSystemTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+
+ // Timing settings.
+ td->add("time_scale",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
+ &Caelum::CaelumSystem::getTimeScale,
+ &Caelum::CaelumSystem::setTimeScale));
+ td->add("julian_day",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, LongReal, LongReal, LongReal>(
+ &Caelum::CaelumSystem::getJulianDay,
+ &Caelum::CaelumSystem::setJulianDay));
+
+ // Latitude/longitude
+ td->add("latitude",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, Degree, Degree, const Degree>(
+ &Caelum::CaelumSystem::getObserverLatitude,
+ &Caelum::CaelumSystem::setObserverLatitude));
+ td->add("longitude",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, Degree, Degree, const Degree>(
+ &Caelum::CaelumSystem::getObserverLongitude,
+ &Caelum::CaelumSystem::setObserverLongitude));
+
+ // Fog settings.
+ td->add("global_fog_density_multiplier",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
+ &Caelum::CaelumSystem::getGlobalFogDensityMultiplier,
+ &Caelum::CaelumSystem::setGlobalFogDensityMultiplier));
+ td->add("global_fog_colour_multiplier",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
+ &Caelum::CaelumSystem::getGlobalFogColourMultiplier,
+ &Caelum::CaelumSystem::setGlobalFogColourMultiplier));
+ td->add("manage_scene_fog",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
+ &Caelum::CaelumSystem::getManageSceneFog,
+ &Caelum::CaelumSystem::setManageSceneFog));
+ td->add("scene_fog_density_multiplier",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
+ &Caelum::CaelumSystem::getSceneFogDensityMultiplier,
+ &Caelum::CaelumSystem::setSceneFogDensityMultiplier));
+ td->add("scene_fog_colour_multiplier",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
+ &Caelum::CaelumSystem::getSceneFogColourMultiplier,
+ &Caelum::CaelumSystem::setSceneFogColourMultiplier));
+ td->add("ground_fog_density_multiplier",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
+ &Caelum::CaelumSystem::getGroundFogDensityMultiplier,
+ &Caelum::CaelumSystem::setGroundFogDensityMultiplier));
+ td->add("ground_fog_colour_multiplier",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
+ &Caelum::CaelumSystem::getGroundFogColourMultiplier,
+ &Caelum::CaelumSystem::setGroundFogColourMultiplier));
+
+ // Lighting settings.
+ td->add("manage_ambient_light",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
+ &Caelum::CaelumSystem::getManageAmbientLight,
+ &Caelum::CaelumSystem::setManageAmbientLight));
+ td->add("minimum_ambient_light",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
+ &Caelum::CaelumSystem::getMinimumAmbientLight,
+ &Caelum::CaelumSystem::setMinimumAmbientLight));
+ td->add("ensure_single_light_source",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
+ &Caelum::CaelumSystem::getEnsureSingleLightSource,
+ &Caelum::CaelumSystem::setEnsureSingleLightSource));
+ td->add("ensure_single_shadow_source",
+ new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
+ &Caelum::CaelumSystem::getEnsureSingleShadowSource,
+ &Caelum::CaelumSystem::setEnsureSingleShadowSource));
+
+ CaelumSystemTypeDescriptor = td.release ();
+ }
+
+ if (!PointStarfieldTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+ td->add("magnitude_scale",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
+ &Caelum::PointStarfield::getMagnitudeScale,
+ &Caelum::PointStarfield::setMagnitudeScale));
+ td->add("mag0_pixel_size",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
+ &Caelum::PointStarfield::getMag0PixelSize,
+ &Caelum::PointStarfield::setMag0PixelSize));
+ td->add("min_pixel_size",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
+ &Caelum::PointStarfield::getMinPixelSize,
+ &Caelum::PointStarfield::setMinPixelSize));
+ td->add("max_pixel_size",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
+ &Caelum::PointStarfield::getMaxPixelSize,
+ &Caelum::PointStarfield::setMaxPixelSize));
+ td->add("latitude",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Degree, Degree, Degree>(
+ &Caelum::PointStarfield::getObserverLatitude,
+ &Caelum::PointStarfield::setObserverLatitude));
+ td->add("longitude",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Degree, Degree, Degree>(
+ &Caelum::PointStarfield::getObserverLongitude,
+ &Caelum::PointStarfield::setObserverLongitude));
+ td->add("observer_position_rebuild_delta",
+ new AccesorPropertyDescriptor<Caelum::PointStarfield, Degree, Degree, Degree>(
+ &Caelum::PointStarfield::getObserverPositionRebuildDelta,
+ &Caelum::PointStarfield::setObserverPositionRebuildDelta));
+ PointStarfieldTypeDescriptor = td.release ();
+ }
+
+ if (!BaseSkyLightTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+ td->add("ambient_multiplier",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
+ &Caelum::BaseSkyLight::getAmbientMultiplier,
+ &Caelum::BaseSkyLight::setAmbientMultiplier));
+ td->add("specular_multiplier",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
+ &Caelum::BaseSkyLight::getSpecularMultiplier,
+ &Caelum::BaseSkyLight::setSpecularMultiplier));
+ td->add("diffuse_multiplier",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
+ &Caelum::BaseSkyLight::getDiffuseMultiplier,
+ &Caelum::BaseSkyLight::setDiffuseMultiplier));
+ td->add("light_colour",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
+ &Caelum::BaseSkyLight::getLightColour,
+ &Caelum::BaseSkyLight::setLightColour));
+ td->add("body_colour",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
+ &Caelum::BaseSkyLight::getBodyColour,
+ &Caelum::BaseSkyLight::setBodyColour));
+ td->add("auto_disable_threshold",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, Real, Real, Real>(
+ &Caelum::BaseSkyLight::getAutoDisableThreshold,
+ &Caelum::BaseSkyLight::setAutoDisableThreshold));
+ td->add("auto_disable",
+ new AccesorPropertyDescriptor<Caelum::BaseSkyLight, bool, bool, bool>(
+ &Caelum::BaseSkyLight::getAutoDisable,
+ &Caelum::BaseSkyLight::setAutoDisable));
+ BaseSkyLightTypeDescriptor = td.release ();
+ }
+
+ if (!GroundFogTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+ td->add("density",
+ new AccesorPropertyDescriptor<Caelum::GroundFog, Real, Real, Real>(
+ &Caelum::GroundFog::getDensity,
+ &Caelum::GroundFog::setDensity));
+ td->add("vertical_decay",
+ new AccesorPropertyDescriptor<Caelum::GroundFog, Real, Real, Real>(
+ &Caelum::GroundFog::getVerticalDecay,
+ &Caelum::GroundFog::setVerticalDecay));
+ td->add("ground_level",
+ new AccesorPropertyDescriptor<Caelum::GroundFog, Real, Real, Real>(
+ &Caelum::GroundFog::getGroundLevel,
+ &Caelum::GroundFog::setGroundLevel));
+ td->add("colour",
+ new AccesorPropertyDescriptor<Caelum::GroundFog, ColourValue>(
+ &Caelum::GroundFog::getColour,
+ &Caelum::GroundFog::setColour));
+ GroundFogTypeDescriptor = td.release ();
+ }
+
+ if (!DepthComposerTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+ td->add("debug_depth_render",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, bool, bool, bool>(
+ &Caelum::DepthComposer::getDebugDepthRender,
+ &Caelum::DepthComposer::setDebugDepthRender));
+
+ // Legacy haze
+ td->add("haze_enabled",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, bool, bool, bool>(
+ &Caelum::DepthComposer::getSkyDomeHazeEnabled,
+ &Caelum::DepthComposer::setSkyDomeHazeEnabled));
+ td->add("haze_colour",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, ColourValue>(
+ &Caelum::DepthComposer::getHazeColour,
+ &Caelum::DepthComposer::setHazeColour));
+ td->add("haze_sun_direction",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, Vector3>(
+ &Caelum::DepthComposer::getSunDirection,
+ &Caelum::DepthComposer::setSunDirection));
+
+ // Ground fog
+ td->add("ground_fog_enabled",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, bool, bool, bool>(
+ &Caelum::DepthComposer::getGroundFogEnabled,
+ &Caelum::DepthComposer::setGroundFogEnabled));
+ td->add("ground_fog_density",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, Real, Real, Real>(
+ &Caelum::DepthComposer::getGroundFogDensity,
+ &Caelum::DepthComposer::setGroundFogDensity));
+ td->add("ground_fog_vertical_decay",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, Real, Real, Real>(
+ &Caelum::DepthComposer::getGroundFogVerticalDecay,
+ &Caelum::DepthComposer::setGroundFogVerticalDecay));
+ td->add("ground_fog_base_level",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, Real, Real, Real>(
+ &Caelum::DepthComposer::getGroundFogBaseLevel,
+ &Caelum::DepthComposer::setGroundFogBaseLevel));
+ td->add("ground_fog_colour",
+ new AccesorPropertyDescriptor<Caelum::DepthComposer, ColourValue>(
+ &Caelum::DepthComposer::getGroundFogColour,
+ &Caelum::DepthComposer::setGroundFogColour));
+
+ DepthComposerTypeDescriptor = td.release ();
+ }
+
+ if (!PrecipitationTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+
+ td->add("texture",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, String>(
+ &Caelum::PrecipitationController::getTextureName,
+ &Caelum::PrecipitationController::setTextureName));
+ td->add("precipitation_colour",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, ColourValue>(
+ &Caelum::PrecipitationController::getColour,
+ &Caelum::PrecipitationController::setColour));
+ td->add("falling_speed",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, Real, Real, Real>(
+ &Caelum::PrecipitationController::getSpeed,
+ &Caelum::PrecipitationController::setSpeed));
+ td->add("wind_speed",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, Vector3>(
+ &Caelum::PrecipitationController::getWindSpeed,
+ &Caelum::PrecipitationController::setWindSpeed));
+ td->add("camera_speed_scale",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, Vector3>(
+ &Caelum::PrecipitationController::getCameraSpeedScale,
+ &Caelum::PrecipitationController::setCameraSpeedScale));
+ td->add("intensity",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, Real, Real, Real>(
+ &Caelum::PrecipitationController::getIntensity,
+ &Caelum::PrecipitationController::setIntensity));
+ td->add("auto_disable_intensity",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, Real, Real, Real>(
+ &Caelum::PrecipitationController::getAutoDisableThreshold,
+ &Caelum::PrecipitationController::setAutoDisableThreshold));
+ td->add("falling_direction",
+ new AccesorPropertyDescriptor<Caelum::PrecipitationController, Vector3>(
+ &Caelum::PrecipitationController::getFallingDirection,
+ &Caelum::PrecipitationController::setFallingDirection));
+
+ PrecipitationTypeDescriptor = td.release ();
+ }
+
+ if (!FlatCloudLayerTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+
+ td->add("height",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getHeight,
+ &Caelum::FlatCloudLayer::setHeight));
+ td->add("coverage",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getCloudCover,
+ &Caelum::FlatCloudLayer::setCloudCover));
+ td->add("cloud_speed",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Vector2>(
+ &Caelum::FlatCloudLayer::getCloudSpeed,
+ &Caelum::FlatCloudLayer::setCloudSpeed));
+ td->add("blend_time",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getCloudBlendTime,
+ &Caelum::FlatCloudLayer::setCloudBlendTime));
+ td->add("mesh_width",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getMeshWidth,
+ &Caelum::FlatCloudLayer::setMeshWidth));
+ td->add("mesh_height",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getMeshHeight,
+ &Caelum::FlatCloudLayer::setMeshHeight));
+ td->add("mesh_width_segments",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, int, int, int>(
+ &Caelum::FlatCloudLayer::getMeshWidthSegments,
+ &Caelum::FlatCloudLayer::setMeshWidthSegments));
+ td->add("mesh_height_segments",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, int, int, int>(
+ &Caelum::FlatCloudLayer::getMeshHeightSegments,
+ &Caelum::FlatCloudLayer::setMeshHeightSegments));
+ td->add("cloud_uv_factor",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getCloudUVFactor,
+ &Caelum::FlatCloudLayer::setCloudUVFactor));
+ td->add("height_red_factor",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getHeightRedFactor,
+ &Caelum::FlatCloudLayer::setHeightRedFactor));
+ td->add("near_fade_dist",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getNearFadeDist,
+ &Caelum::FlatCloudLayer::setNearFadeDist));
+ td->add("far_fade_dist",
+ new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
+ &Caelum::FlatCloudLayer::getFarFadeDist,
+ &Caelum::FlatCloudLayer::setFarFadeDist));
+
+ FlatCloudLayerTypeDescriptor = td.release ();
+ }
+
+ if (!SkyDomeTypeDescriptor)
+ {
+ std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
+
+ // SkyDome is slightly special because most properties are write-only.
+
+ // Reset by CaelumSystem every frame anyway
+ td->add("sun_direction",
+ new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::Vector3>(
+ 0, &Caelum::SkyDome::setSunDirection));
+ td->add("haze_colour",
+ new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::ColourValue>(
+ 0, &Caelum::SkyDome::setHazeColour));
+
+ // Different files not supported anyway
+ td->add("sky_gradients_image",
+ new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::String>(
+ 0, &Caelum::SkyDome::setSkyGradientsImage));
+ td->add("atmosphere_depth_image",
+ new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::String>(
+ 0, &Caelum::SkyDome::setAtmosphereDepthImage));
+
+ // This does actually make sense.
+ td->add("haze_enabled",
+ new AccesorPropertyDescriptor<Caelum::SkyDome, bool, bool, bool>(
+ &Caelum::SkyDome::getHazeEnabled,
+ &Caelum::SkyDome::setHazeEnabled));
+
+ SkyDomeTypeDescriptor = td.release ();
+ }
+ }
+}
+
+#endif // CAELUM_TYPE_DESCRIPTORS
Added: trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.cpp
===================================================================
--- trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.cpp (rev 0)
+++ trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.cpp 2009-01-25 03:51:12 UTC (rev 845)
@@ -0,0 +1,162 @@
+/*
+This file is part of Caelum.
+See http://www.ogre3d.org/wiki/index.php/Caelum
+
+Copyright (c) 2008 Caelum team. See Contributors.txt for details.
+
+Caelum is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Caelum is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with Caelum. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "CaelumPrecompiled.h"
+#include "CaelumPlugin.h"
+
+template<> Caelum::CaelumPlugin* Ogre::Singleton<Caelum::CaelumPlugin>::ms_Singleton = 0;
+
+namespace Caelum
+{
+ CaelumPlugin* CaelumPlugin::getSingletonPtr () {
+ return ms_Singleton;
+ }
+
+ CaelumPlugin& CaelumPlugin::getSingleton () {
+ assert (ms_Singleton);
+ return *ms_Singleton;
+ }
+
+ extern "C" void CAELUM_EXPORT dllStartPlugin () {
+ assert (CaelumPlugin::getSingletonPtr () == 0);
+ CaelumPlugin* plugin = new CaelumPlugin();
+ assert (CaelumPlugin::getSingletonPtr () == plugin);
+ Ogre::Root::getSingleton ().installPlugin (CaelumPlugin::getSingletonPtr ());
+ }
+
+ extern "C" void CAELUM_EXPORT dllStopPlugin () {
+ assert (CaelumPlugin::getSingletonPtr () != 0);
+ Ogre::Root::getSingleton ().uninstallPlugin (CaelumPlugin::getSingletonPtr ());
+ delete CaelumPlugin::getSingletonPtr ();
+ assert (CaelumPlugin::getSingletonPtr () == 0);
+ }
+
+#if CAELUM_SCRIPT_SUPPORT
+ CaelumPlugin::CaelumPlugin(): mScriptTranslatorManager(&mTypeDescriptorData)
+#else
+ CaelumPlugin::CaelumPlugin()
+#endif
+ {
+ mIsInstalled = false;
+ }
+
+ CaelumPlugin::~CaelumPlugin() {
+ }
+
+ const Ogre::String CaelumPlugin::CAELUM_PLUGIN_NAME = "Caelum";
+
+ const Ogre::String& CaelumPlugin::getName () const {
+ return CAELUM_PLUGIN_NAME;
+ }
+
+ void CaelumPlugin::install ()
+ {
+ assert(!mIsInstalled && "Already installed");
+
+ Ogre::LogManager::getSingleton ().logMessage("Caelum plugin version " +
+ Ogre::StringConverter::toString (CAELUM_VERSION_MAIN) + "." +
+ Ogre::StringConverter::toString (CAELUM_VERSION_SEC) + "." +
+ Ogre::StringConverter::toString (CAELUM_VERSION_TER) + " "
+ "installed");
+
+#if CAELUM_SCRIPT_SUPPORT
+ Ogre::ScriptCompilerManager::getSingleton ().addTranslatorManager (
+ getScriptTranslatorManager ());
+ Ogre::ResourceGroupManager::getSingleton()._registerResourceManager (
+ getPropScriptResourceManager ()->getResourceType (),
+ getPropScriptResourceManager ());
+
+ getScriptTranslatorManager()->_setPropScriptResourceManager (
+ &mPropScriptResourceManager);
+#endif // CAELUM_SCRIPT_SUPPORT
+
+ mIsInstalled = true;
+ }
+
+ void CaelumPlugin::initialise () {
+ }
+
+ void CaelumPlugin::shutdown () {
+ }
+
+ void CaelumPlugin::uninstall ()
+ {
+ assert(mIsInstalled && "Not installed");
+
+#if CAELUM_SCRIPT_SUPPORT
+ getScriptTranslatorManager()->_setPropScriptResourceManager (0);
+
+ Ogre::ResourceGroupManager::getSingleton ()._unregisterResourceManager (
+ getPropScriptResourceManager ()->getResourceType ());
+ Ogre::ScriptCompilerManager::getSingleton ().removeTranslatorManager (
+ getScriptTranslatorManager ());
+#endif // CAELUM_SCRIPT_SUPPORT
+
+ Ogre::LogManager::getSingleton ().logMessage("Caelum plugin uninstalled");
+
+ mIsInstalled = false;
+ }
+
+#if CAELUM_SCRIPT_SUPPORT
+ void CaelumPlugin::loadCaelumSystemFromScript (
+ CaelumSystem* sys,
+ const Ogre::String& objectName,
+ const Ogre::String& groupName)
+ {
+ assert (sys);
+ assert (this->isInstalled () && "Must install CaelumPlugin before loading scripts");
+
+ // Fetch raw resource ptr. Attempt to support explicit resource groups currently in Ogre trunk.
+#if OGRE_VERSION >= 0x00010700
+ Ogre::ResourcePtr res = getPropScriptResourceManager ()->getByName (objectName, groupName);
+#else
+ Ogre::ResourcePtr res = getPropScriptResourceManager ()->getByName (objectName);
+#endif
+
+ // Check a PropScriptResource was found.
+ PropScriptResource* propRes = static_cast<PropScriptResource*> (res.get ());
+ if (!propRes) {
+ OGRE_EXCEPT (Ogre::Exception::ERR_ITEM_NOT_FOUND,
+ "Could not find caelum_sky_system " + objectName,
+ "CaelumPlugin::loadCaelumSystemFromScript");
+ }
+
+ // Fetch the resource stream. Look in the actual group of the resource!
+ const Ogre::String& scriptFileName = propRes->getOrigin();
+ const Ogre::String& scriptFileGroup = propRes->getGroup();
+ Ogre::DataStreamPtr streamPtr = Ogre::ResourceGroupManager::getSingleton ().openResource (
+ scriptFileName, scriptFileGroup, false);
+
+ // Feed it into the compiler.
+ this->getScriptTranslatorManager()->getCaelumSystemTranslator()->setTranslationTarget (sys, objectName);
+ Ogre::ScriptCompilerManager::getSingleton ().parseScript (streamPtr, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+ bool found = this->getScriptTranslatorManager()->getCaelumSystemTranslator()->foundTranslationTarget ();
+
+ // This shouldn't normally happen.
+ if (!found) {
+ OGRE_EXCEPT (Ogre::Exception::ERR_ITEM_NOT_FOUND,
+ "Could not find caelum_sky_system " + objectName + " in file " + scriptFileName + " on reparsing. "
+ "Perhaps information in PropScriptResourceManager is out of date?",
+ "CaelumPlugin::loadCaelumSystemFromScript");
+ }
+ this->getScriptTranslatorManager()->getCaelumSystemTranslator()->clearTranslationTarget ();
+ }
+#endif // CAELUM_SCRIPT_SUPPORT
+}
Added: trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.h
===================================================================
--- trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.h (rev 0)
+++ trunk/python-ogre/ThirdParty/caelum/CaelumPlugin.h 2009-01-25 03:51:12 UTC (rev 845)
@@ -0,0 +1,97 @@
+/*
+This file is part of Caelum.
+See http://www.ogre3d.org/wiki/index.php/Caelum
+
+Copyright (c) 2008 Caelum team. See Contributors.txt for details.
+
+Caelum is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Caelum is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with Caelum. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CAELUM__CAELUM_PLUGIN_H
+#define CAELUM__CAELUM_PLUGIN_H
+
+#include "CaelumPrerequisites.h"
+#include "CaelumScriptTranslator.h"
+#include "TypeDescriptor.h"
+#include "OgrePlugin.h"
+
+namespace Caelum
+{
+ /** Implement an Ogre::Plugin for Caelum.
+ *
+ * Ogre plugins are usually loaded from config files and they register
+ * various stuff in ogre managers. But you can also just link to the
+ * library normally and call install functions manually.
+ */
+ class CAELUM_EXPORT CaelumPlugin: public Ogre::Singleton<CaelumPlugin>, public Ogre::Plugin
+ {
+ public:
+ /// Get reference to singleton instance; or crash if N/A.
+ static CaelumPlugin& getSingleton(void);
+ /// Get pointer to singleton instance; or pointer if N/A.
+ static CaelumPlugin* getSingletonPtr(void);
+
+ CaelumPlugin();
+ ~CaelumPlugin();
+
+ virtual void install ();
+ virtual void initialise ();
+ virtual void shutdown ();
+ virtual void uninstall ();
+
+ static const Ogre::String CAELUM_PLUGIN_NAME;
+ virtual const String& getName () const;
+
+ // Determine if the plugin was installed (if install was called).
+ inline bool isInstalled () const { return mIsInstalled; }
+
+ private:
+ bool mIsInstalled;
+
+#if CAELUM_TYPE_DESCRIPTORS
+ public:
+ /// Get default type descriptor data for caelum components.
+ CaelumDefaultTypeDescriptorData* getTypeDescriptorData () { return &mTypeDescriptorData; }
+
+ private:
+ CaelumDefaultTypeDescriptorData mTypeDescriptorData;
+#endif
+
+#if CAELUM_SCRIPT_SUPPORT
+ public:
+ /** Load CaelumSystem and it's components from a script file.
+ * @param sys Target CaelumSystem.
+ * This is cleared using CaelumSystem::clear before loading.
+ * If scripting data is not found then this is not modified.
+ * @param objectName Name of caelum_sky_system from *.os file.
+ * @param scriptFileGroup The group to search in (unused in Ogre 1.6)
+ */
+ void loadCaelumSystemFromScript (
+ CaelumSystem* sys,
+ const Ogre::String& objectName,
+ const Ogre::String& scriptFileGroup = Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME
+ );
+
+ /// @see PropScriptResourceManager
+ PropScriptResourceManager* getPropScriptResourceManager () { return &mPropScriptResourceManager; }
+ CaelumScriptTranslatorManager* getScriptTranslatorManager () { return &mScriptTranslatorManager; }
+
+ private:
+ PropScriptResourceManager mPropScriptResourceManager;
+ CaelumScriptTranslatorManager mScriptTranslatorManager;
+#endif
+ };
+}
+
+#endif // CAELUM__CAELUM_PLUGIN_H
Modified: trunk/python-ogre/ThirdParty/caelum/CaelumPrerequisites.h
===================================================================
--- trunk/python-ogre/ThirdParty/caelum/CaelumPrerequisites.h 2009-01-24 05:00:41 UTC (rev 844)
+++ trunk/python-ogre/ThirdParty/caelum/CaelumPrerequisites.h 2009-01-25 03:51:12 UTC (rev 845)
@@ -31,21 +31,21 @@
#include <memory>
// Define the dll export qualifier if compiling for Windows
-// #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
-// #ifdef CAELUM_LIB
-// #define CAELUM_EXPORT __declspec (dllexport)
-// #else
-// #ifdef __MINGW32__
-// #define CAELUM_EXPORT
-// #else
-// #define CAELUM_EXPORT __declspec (dllimport)
-// #endif
-// #endif
-// #elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
-// #define CAELUM_EXPORT __attribute__ ((visibility("default")))
-// #else
+/*#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+ #ifdef CAELUM_LIB
+ #define CAELUM_EXPORT __declspec (dllexport)
+ #else
+ #ifdef __MINGW32__
+ #define CAELUM_EXPORT
+ #else
+ #define CAELUM_EXPORT __declspec (dllimport)
+ #endif
+ #endif
+#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+ #define CAELUM_EXPORT __attribute__ ((visibility("default")))
+#else */
#define CAELUM_EXPORT
-// #endif
+//#endif
// Define the version code
#define CAELUM_VERSION_MAIN 0
@@ -53,6 +53,35 @@
#define CAELUM_VERSION_TER 0
#define CAELUM_VERSION = (CAELUM_VERSION_MAIN << 16) | (CAELUM_VERSION_SEC << 8) | CAELUM_VERSION_TER
+// By default only compile type descriptors for scripting.
+#ifndef CAELUM_TYPE_DESCRIPTORS
+ #if (OGRE_VERSION >= 0x00010600) && OGRE_USE_NEW_COMPILERS
+ #define CAELUM_TYPE_DESCRIPTORS 1
+ #else
+ #define CAELUM_TYPE_DESCRIPTORS 0
+ #endif
+#endif
+
+// Scripting support requires Ogre 1.6
+// Can be also configured on compiler command line
+#ifndef CAELUM_SCRIPT_SUPPORT
+ #if (OGRE_VERSION >= 0x00010600) && OGRE_USE_NEW_COMPILERS
+ #define CAELUM_SCRIPT_SUPPORT 1
+ #else
+ #define CAELUM_SCRIPT_SUPPORT 0
+ #endif
+#else
+ #if !(OGRE_VERSION > 0x00010600)
+ #error "Caelum script support requires Ogre 1.6."
+ #endif
+ #if !(OGRE_USE_NEW_COMPILERS)
+ #error "Caelum script support requires Ogre 1.6 with OGRE_USE_NEW_COMPILERS."
+ #endif
+ #if !(CAELUM_TYPE_DESCRIPTORS)
+ #error "Caelum script support also requires type descriptors."
+ #endif
+#endif
+
/// @file
/** @mainpage
@@ -62,8 +91,11 @@
* Caelum::CaelumSystem class which ties them all together in an easy-to-use
* way.
*
- * For more information see the great %Caelum thread in the ogre forum:
- * http://www.ogre3d.org/phpBB2/viewtopic.php?t=24961&postorder=desc
+ * More information is available on the wiki page:
+ * http://www.ogre3d.org/wiki/index.php/Caelum
+ *
+ * You can discuss and report issues in the forum:
+ * http://www.ogre3d.org/addonforums/viewforum.php?f=21
*/
/** Caelum namespace
@@ -114,6 +146,7 @@
class ImageStarfield;
class PointStarfield;
class CloudSystem;
+ class CaelumSystem;
class FlatCloudLayer;
class PrecipitationController;
class PrecipitationInstance;
@@ -123,4 +156,17 @@
class DepthRenderer;
}
+namespace Ogre {
+ // Write an Ogre::Degree to a stream.
+ //
+ // Ogre::Any requires that the wrapped type can be written to a stream;
+ // otherwise it will fail on instantation. This function was placed here
+ // so it's available everywhere.
+ //
+ // This can't be placed in namespace Caelum.
+ inline std::ostream& operator << (std::ostream& out, Ogre::Degree deg) {
+ return out << deg.valueDegrees();
+ }
+}
+
#endif // CAELUM__CAELUM_PREREQUISITES_H
Added: trunk/python-ogre/ThirdParty/caelum/CaelumScriptTranslator.cpp
===================================================================
--- trunk/python-ogre/ThirdParty/caelum/CaelumScriptTranslator.cpp (rev 0)
+++ trunk/python-ogre/ThirdParty/caelum/CaelumScriptTranslator.cpp 2009-01-25 03:51:12 UTC (rev 845)
@@ -0,0 +1,635 @@
+/*
+This file is part of Caelum.
+See http://www.ogre3d.org/wiki/index.php/Caelum
+
+Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
+
+Caelum is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Caelum is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with Caelum. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "CaelumPrecompiled.h"
+#include "CaelumPrerequisites.h"
+
+#if CAELUM_SCRIPT_SUPPORT
+
+#include "CaelumScriptTranslator.h"
+#include "CaelumSystem.h"
+#include "CaelumExceptions.h"
+
+using namespace Ogre;
+
+namespace Caelum
+{
+ PropScriptResource::PropScriptResource
+ (
+ Ogre::ResourceManager* creator, const Ogre::String& name, Ogre::ResourceHandle handle,
+ const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader
+ ):
+ Ogre::Resource (creator, name, handle, group, isManual, loader)
+ {
+ //Ogre::LogManager::getSingleton().logMessage(
+ // "PropScriptResource::PropScriptResource");
+ }
+
+ PropScriptResource::~PropScriptResource() {
+ //Ogre::LogManager::getSingleton().logMessage(
+ // "PropScriptResource::~PropScriptResource");
+ }
+
+ PropScriptResourceManager::PropScriptResourceManager() {
+ mLoadOrder = 1000;
+ mResourceType = "PropertyScript";
+ }
+
+ PropScriptResource* PropScriptResourceManager::createImpl(
+ const String& name, ResourceHandle handle, const String& group,
+ bool isManual, ManualResourceLoader* loader, const NameValuePairList* createParams)
+ {
+ //Ogre::LogManager::getSingleton().logMessage(
+ // "PropScriptResourceManager::createImpl");
+ return new PropScriptResource (this, name, handle, group, isManual, loader);
+ }
+
+ TypeDescriptorScriptTranslator::TypeDescriptorScriptTranslator (TypeDescriptor* typeDescriptor):
+ mTypeDescriptor(typeDescriptor)
+ {
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ bool& value)
+ {
+ if (prop->values.empty ()) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 1) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 1 argument");
+ return false;
+ }
+ if (!Ogre::ScriptTranslator::getBoolean(prop->values.front(), &value)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ prop->values.front()->getValue() + " is not a valid number");
+ return false;
+ }
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ ColourValue& value)
+ {
+ if (prop->values.empty ()) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 4) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 4 arguments");
+ return false;
+ }
+ if (prop->values.size () < 3) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at least 3 arguments");
+ }
+ if (!getColour(prop->values.begin(), prop->values.end(), &value)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ prop->name + " requires a colour argument");
+ }
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ float& value)
+ {
+ if (prop->values.empty ()) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 1) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 1 argument");
+ return false;
+ }
+ if (!Ogre::ScriptTranslator::getFloat(prop->values.front(), &value)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ prop->values.front()->getValue() + " is not a valid number");
+ return false;
+ }
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ int& value)
+ {
+ if (prop->values.empty ()) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 1) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 1 argument");
+ return false;
+ }
+ if (!Ogre::ScriptTranslator::getInt(prop->values.front(), &value)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ prop->values.front()->getValue() + " is not a valid integer");
+ return false;
+ }
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ double& value)
+ {
+ if (prop->values.empty ()) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 1) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 1 argument");
+ return false;
+ }
+ // We do need a string stream here for the extra precision.
+ std::stringstream strStream (std::string(prop->values.front()->getValue()));
+ strStream >> value;
+ if (strStream.fail()) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ prop->values.front()->getValue() + " is not a valid number");
+ return false;
+ }
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ Ogre::Degree& value)
+ {
+ if (prop->values.size () == 0) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 3) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 3 arguments");
+ return false;
+ }
+ // Allow 3 components.
+ float degMinSec[3] = { 0, 0, 0 };
+ int k = 0;
+ for (AbstractNodeList::const_iterator it = prop->values.begin(), endIt = prop->values.end(); it != endIt; ++it, ++k) {
+ if (!Ogre::ScriptTranslator::getFloat(*it, °MinSec[k])) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ (*it)->getValue () + " is not a valid number");
+ return false;
+ }
+ }
+ value = Ogre::Degree(degMinSec[0] + degMinSec[1] / 60.0 + degMinSec[2] / 3600);
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ Ogre::String& value)
+ {
+ if (prop->values.size () == 0) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 1) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 1 arguments");
+ return false;
+ }
+ if (!Ogre::ScriptTranslator::getString(prop->values.front(), &value)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ prop->values.front()->getValue() + " is not a valid string");
+ return false;
+ }
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ Ogre::Vector3& value)
+ {
+ if (prop->values.size () == 0) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 3) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 3 arguments");
+ return false;
+ }
+ float floats[3];
+ if (!Ogre::ScriptTranslator::getFloats(prop->values.begin(), prop->values.end(), floats, 3)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ "incorrect vector parameters.");
+ return false;
+ }
+ value.x = floats[0];
+ value.y = floats[1];
+ value.z = floats[2];
+ return true;
+ }
+
+ bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ Ogre::Vector2& value)
+ {
+ if (prop->values.size () == 0) {
+ compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
+ return false;
+ }
+ if (prop->values.size () > 2) {
+ compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
+ prop->name + " must have at most 3 arguments");
+ return false;
+ }
+ float floats[2];
+ if (!Ogre::ScriptTranslator::getFloats(prop->values.begin(), prop->values.end(), floats, 2)) {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
+ "incorrect vector parameters.");
+ return false;
+ }
+ value.x = floats[0];
+ value.y = floats[1];
+ return true;
+ }
+
+ template<class T>
+ static bool tryHandlePropertyType (
+ ScriptCompiler* compiler, PropertyAbstractNode* propNode,
+ void* targetObject, const ValuePropertyDescriptor* propDesc)
+ {
+ if (propDesc->getValueTypeId () == typeid(T)) {
+ T val;
+ if (TypeDescriptorScriptTranslator::getPropValueOrAddError (compiler, propNode, val)) {
+ propDesc->setValue (targetObject, Ogre::Any(val));
+ }
+ return true;
+ }
+ return false;
+ }
+
+ void TypeDescriptorScriptTranslator::translateProperty (
+ ScriptCompiler* compiler,
+ PropertyAbstractNode* prop,
+ void* targetObject,
+ const TypeDescriptor* typeDescriptor)
+ {
+ const ValuePropertyDescriptor* propDesc = typeDescriptor->getPropertyDescriptor (prop->name);
+ if (!propDesc) {
+ compiler->addError (ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
+ "property \"" + prop->name + "\" not recognized; missing from type descriptor.");
+ return;
+ }
+ if (!propDesc->canSetValue ()) {
+ compiler->addError (ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
+ "property \"" + prop->name + "\" is read-only and can't be set from a script.");
+ return;
+ }
+
+ //LogManager::getSingleton ().logMessage ("TypeDescriptorScriptTranslator::translateProperty"
+ // " name '" + prop->name + "'");
+
+ bool handled = false
+ || tryHandlePropertyType<int> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<float> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<double> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<bool> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<Ogre::Degree> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<Ogre::String> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<Ogre::Vector3> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<Ogre::Vector2> (compiler, prop, targetObject, propDesc)
+ || tryHandlePropertyType<Ogre::ColourValue> (compiler, prop, targetObject, propDesc);
+
+ if (!handled) {
+ compiler->addError (ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
+ "property \"" + prop->name + "\" is found in type descriptor but has "
+ "unsupported type. Mangled typeid is '" + propDesc->getValueTypeId().name() + "'");
+ }
+ }
+
+ void TypeDescriptorScriptTranslator::translate (ScriptCompiler* compiler, const AbstractNodePtr& node)
+ {
+ //LogManager::getSingleton ().logMessage ("TypeDescriptorScriptTranslator::translate begin");
+
+ // Check type descriptor was set.
+ assert (getTypeDescriptor () && "Type descriptor must be set before we can translate.");
+
+ // Fetch target object.
+ ObjectAbstractNode *objNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
+ assert (!objNode->context.isEmpty ());
+ void* targetObject = any_cast<void*> (objNode->context);
+ assert (targetObject);
+
+ for (AbstractNodeList::iterator i = objNode->children.begin(); i != objNode->children.end(); ++i)
+ {
+ if ((*i)->type == ANT_PROPERTY)
+ {
+ PropertyAbstractNode *prop = reinterpret_cast<PropertyAbstractNode*>((*i).get());
+
+ translateProperty (compiler, prop, targetObject, getTypeDescriptor());
+ }
+ else if((*i)->type == ANT_OBJECT)
+ {
+ compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, (*i)->file, (*i)->line);
+ }
+ }
+
+ //LogManager::getSingleton ().logMessage ("TypeDescriptorScriptTranslator::translate end");
+ }
+
+ CaelumSystemScriptTranslator::CaelumSystemScriptTranslator ():
+ mResourceManager(false),
+ mTranslationTarget(0),
+ mTranslationTargetFound(false),
+ mTypeDescriptor(0)
+ {
+ }
+
+ void CaelumSystemScriptTranslator::setTranslationTarget (CaelumSystem* target, const Ogre::String& name)
+ {
+ assert (target != 0);
+ this->mTranslationTarget = target;
+ this->mTranslationTargetName = name;
+ this->mTranslationTargetFound = false;
+ }
+
+ void CaelumSystemScriptTranslator::clearTranslationTarget () {
+ this->mTranslationTarget = 0;
+ this->mTranslationTargetName.clear();
+ this->mTranslationTargetFound = false;
+ }
+
+ void CaelumSystemScriptTranslator::translate (ScriptCompiler* compiler, const AbstractNodePtr& node)
+ {
+ //LogManager::getSingleton ().logMessage ("CaelumSystemScriptTranslator::translate begin");
+
+ ObjectAbstractNode *objNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
+
+ CaelumSystem* sys = 0;
+
+ // Check for a translation target.
+ if (this->getTran...
[truncated message content] |
