PostProcessSettings -> RenderSettings

Source/BansheeCore/CMakeSources.cmake

@@ -97,7 +97,7 @@ set(BS_BANSHEECORE_INC_RENDERER
 	"Include/BsRendererMeshData.h"
 	"Include/BsParamBlocks.h"
 	"Include/BsCamera.h"
-	"Include/BsPostProcessSettings.h"
+	"Include/BsRenderSettings.h"
 	"Include/BsRendererExtension.h"
 	"Include/BsReflectionProbe.h"
 	"Include/BsSkybox.h"
@@ -350,7 +350,7 @@ set(BS_BANSHEECORE_INC_RTTI
 	"Include/BsSkeletonRTTI.h"
 	"Include/BsCCameraRTTI.h"
 	"Include/BsCameraRTTI.h"
-	"Include/BsPostProcessSettingsRTTI.h"
+	"Include/BsRenderSettingsRTTI.h"
 	"Include/BsMorphShapesRTTI.h"
 	"Include/BsAudioClipImportOptionsRTTI.h"
 	"Include/BsCRenderableRTTI.h"
@@ -373,7 +373,7 @@ set(BS_BANSHEECORE_SRC_RENDERER
 	"Source/BsRendererMeshData.cpp"
 	"Source/BsParamBlocks.cpp"
 	"Source/BsCamera.cpp"
-	"Source/BsPostProcessSettings.cpp"
+	"Source/BsRenderSettings.cpp"
 	"Source/BsRendererExtension.cpp"
 	"Source/BsReflectionProbe.cpp"
 	"Source/BsSkybox.cpp"

Source/BansheeCore/Include/BsCCamera.h

@@ -142,11 +142,11 @@ namespace bs
 		/** @copydoc Camera::setMSAACount */
 		void setMSAACount(UINT32 count) { mInternal->setMSAACount(count); }
 
-		/** Returns settings that are used for controling post-process operations like tonemapping. */
-		const SPtr<PostProcessSettings>& getPostProcessSettings() const { return mInternal->getPostProcessSettings(); }
+		/** @copydoc Camera::getRenderSettings() */
+		const SPtr<RenderSettings>& getRenderSettings() const { return mInternal->getRenderSettings(); }
 
-		/** Sets settings that are used for controling post-process operations like tonemapping. */
-		void setPostProcessSettings(const SPtr<PostProcessSettings>& settings) { mInternal->setPostProcessSettings(settings); }
+		/** @copydoc Camera::setRenderSettings() */
+		void setRenderSettings(const SPtr<RenderSettings>& settings) { mInternal->setRenderSettings(settings); }
 
 		/** @copydoc Camera::getFlags */
 		CameraFlags getFlags() const { return mInternal->getFlags(); }

Source/BansheeCore/Include/BsCamera.h

@@ -13,7 +13,7 @@
 #include "BsRay.h"
 #include "BsCoreObject.h"
 #include "BsConvexVolume.h"
-#include "BsPostProcessSettings.h"
+#include "BsRenderSettings.h"
 
 namespace bs 
 {
@@ -26,7 +26,7 @@ namespace bs
 	{
 		Transform = 1<<0,
 		Everything = 1<<1,
-		PostProcess = 1<<2
+		RenderSettings = 1<<2
 	};
 
 	/**	Flags that describe a camera. */
@@ -309,11 +309,14 @@ namespace bs
 		 */
 		void setMSAACount(UINT32 count) { mMSAA = count; _markCoreDirty(); }
 
-		/** Returns settings that are used for controling post-process operations like tonemapping. */
-		const SPtr<PostProcessSettings>& getPostProcessSettings() const { return mPPSettings; }
+		/** @copydoc setRenderSettings() */
+		const SPtr<RenderSettings>& getRenderSettings() const { return mRenderSettings; }
 
-		/** Sets settings that are used for controling post-process operations like tonemapping. */
-		void setPostProcessSettings(const SPtr<PostProcessSettings>& settings) { mPPSettings = settings; _markCoreDirty(CameraDirtyFlag::PostProcess); }
+		/** 
+		 * Settings that control rendering for this view. They determine how will the renderer process this view, which
+		 * effects will be enabled, and what properties will those effects use.
+		 */
+		void setRenderSettings(const SPtr<RenderSettings>& settings) { mRenderSettings = settings; _markCoreDirty(CameraDirtyFlag::RenderSettings); }
 
 		/**	Retrieves flags that define the camera. */
 		CameraFlags getFlags() const { return mCameraFlags; }
@@ -476,7 +479,7 @@ namespace bs
 		bool mCustomProjMatrix; /**< Is custom projection matrix set. */
 		UINT8 mMSAA; /**< Number of samples to render the scene with. */
 
-		SPtr<PostProcessSettings> mPPSettings; /**< Settings used to control post-process operations. */
+		SPtr<RenderSettings> mRenderSettings; /**< Settings used to control rendering for this camera. */
 
 		bool mFrustumExtentsManuallySet; /**< Are frustum extents manually set. */
 

Source/BansheeCore/Include/BsCameraRTTI.h

@@ -41,7 +41,7 @@ namespace bs
 			BS_RTTI_MEMBER_PLAIN(mCameraFlags, 22)
 			BS_RTTI_MEMBER_PLAIN(mMSAA, 23)
 			/** BS_RTTI_MEMBER_PLAIN(mPPSettings, 24) */
-			BS_RTTI_MEMBER_REFLPTR(mPPSettings, 25)
+			BS_RTTI_MEMBER_REFLPTR(mRenderSettings, 25)
 			/** BS_RTTI_MEMBER_REFL(mSkyTexture, 26) */
 		BS_END_RTTI_MEMBERS
 			

Source/BansheeCore/Include/BsCorePrerequisites.h

@@ -562,7 +562,7 @@ namespace bs
 		TID_ImportedAnimationEvents = 1124,
 		TID_CBone = 1125,
 		TID_MaterialParamData = 1126,
-		TID_PostProcessSettings = 1127,
+		TID_RenderSettings = 1127,
 		TID_MorphShape = 1128,
 		TID_MorphShapes = 1129,
 		TID_MorphChannel = 1130,

Source/BansheeCore/Include/BsPostProcessSettings.h → Source/BansheeCore/Include/BsRenderSettings.h

@@ -354,11 +354,11 @@ namespace bs
 		RTTITypeBase* getRTTI() const override;
 	};
 	
-	/** Base class whose implementations contain settings that control post-process operations during rendering. */
-	struct BS_CORE_EXPORT PostProcessSettings : public IReflectable
+	/** Settings that control rendering for a specific camera (view). */
+	struct BS_CORE_EXPORT RenderSettings : public IReflectable
 	{
-		PostProcessSettings();
-		virtual ~PostProcessSettings() { }
+		RenderSettings();
+		virtual ~RenderSettings() { }
 
 		/**
 		 * Determines should automatic exposure be applied to the HDR image. When turned on the average scene brightness
@@ -460,7 +460,7 @@ namespace bs
 		/* 								RTTI		                     		*/
 		/************************************************************************/
 	public:
-		friend class PostProcessSettingsRTTI;
+		friend class RenderSettingsRTTI;
 		static RTTITypeBase* getRTTIStatic();
 		RTTITypeBase* getRTTI() const override;
 	};

Source/BansheeCore/Include/BsPostProcessSettingsRTTI.h → Source/BansheeCore/Include/BsRenderSettingsRTTI.h

@@ -4,7 +4,7 @@
 
 #include "BsCorePrerequisites.h"
 #include "BsRTTIType.h"
-#include "BsPostProcessSettings.h"
+#include "BsRenderSettings.h"
 
 namespace bs
 {
@@ -249,7 +249,7 @@ namespace bs
 		}
 	};
 
-	class BS_CORE_EXPORT PostProcessSettingsRTTI : public RTTIType <PostProcessSettings, IReflectable, PostProcessSettingsRTTI>
+	class BS_CORE_EXPORT RenderSettingsRTTI : public RTTIType <RenderSettings, IReflectable, RenderSettingsRTTI>
 	{
 	private:
 		BS_BEGIN_RTTI_MEMBERS
@@ -268,24 +268,24 @@ namespace bs
 		BS_END_RTTI_MEMBERS
 			
 	public:
-		PostProcessSettingsRTTI()
+		RenderSettingsRTTI()
 			:mInitMembers(this)
 		{ }
 
 		const String& getRTTIName() override
 		{
-			static String name = "PostProcessSettings";
+			static String name = "RenderSettings";
 			return name;
 		}
 
 		UINT32 getRTTIId() override
 		{
-			return TID_PostProcessSettings;
+			return TID_RenderSettings;
 		}
 
 		SPtr<IReflectable> newRTTIObject() override
 		{
-			return bs_shared_ptr_new<PostProcessSettings>();
+			return bs_shared_ptr_new<RenderSettings>();
 		}
 	};
 

Source/BansheeCore/Include/BsRenderer.h

@@ -10,7 +10,7 @@ namespace bs
 { 
 	class RendererExtension;
 	class LightProbeVolume;
-	struct PostProcessSettings;
+	struct RenderSettings;
 
 	namespace ct
 	{

Source/BansheeCore/Source/BsCamera.cpp

@@ -26,7 +26,7 @@ namespace bs
 		, mProjMatrixRSInv(BsZero), mProjMatrixInv(BsZero), mViewMatrixInv(BsZero), mRecalcFrustum(true)
 		, mRecalcFrustumPlanes(true), mRecalcView(true)
 	{
-		mPPSettings = bs_shared_ptr_new<PostProcessSettings>();
+		mRenderSettings = bs_shared_ptr_new<RenderSettings>();
 
 		invalidateFrustum();
 	}
@@ -763,9 +763,9 @@ namespace bs
 			size += rttiGetElemSize(mMSAA);
 			size += sizeof(UINT32);
 
-			if(mPPSettings != nullptr)
+			if(mRenderSettings != nullptr)
 			{
-				mPPSettings->_getSyncData(nullptr, ppSize);
+				mRenderSettings->_getSyncData(nullptr, ppSize);
 				size += ppSize;
 			}
 		}
@@ -796,8 +796,8 @@ namespace bs
 
 			dataPtr = rttiWriteElem(ppSize, dataPtr);
 
-			if(mPPSettings != nullptr)
-				mPPSettings->_getSyncData((UINT8*)dataPtr, ppSize);
+			if(mRenderSettings != nullptr)
+				mRenderSettings->_getSyncData((UINT8*)dataPtr, ppSize);
 
 			dataPtr += ppSize;
 		}
@@ -891,10 +891,10 @@ namespace bs
 
 			if(ppSize > 0)
 			{
-				if (mPPSettings == nullptr)
-					mPPSettings = bs_shared_ptr_new<PostProcessSettings>();
+				if (mRenderSettings == nullptr)
+					mRenderSettings = bs_shared_ptr_new<RenderSettings>();
 
-				mPPSettings->_setSyncData((UINT8*)dataPtr, ppSize);
+				mRenderSettings->_setSyncData((UINT8*)dataPtr, ppSize);
 				dataPtr += ppSize;
 			}
 		}

Source/BansheeCore/Source/BsPostProcessSettings.cpp → Source/BansheeCore/Source/BsRenderSettings.cpp

@@ -1,7 +1,7 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "BsPostProcessSettings.h"
-#include "BsPostProcessSettingsRTTI.h"
+#include "BsRenderSettings.h"
+#include "BsRenderSettingsRTTI.h"
 
 namespace bs
 {
@@ -108,21 +108,21 @@ namespace bs
 		return ScreenSpaceReflectionsSettings::getRTTIStatic();
 	}
 
-	PostProcessSettings::PostProcessSettings()
+	RenderSettings::RenderSettings()
 		: enableAutoExposure(true), enableTonemapping(true), enableFXAA(false), exposureScale(0.0f), gamma(2.2f)
 	{ }
 
-	RTTITypeBase* PostProcessSettings::getRTTIStatic()
+	RTTITypeBase* RenderSettings::getRTTIStatic()
 	{
-		return PostProcessSettingsRTTI::instance();
+		return RenderSettingsRTTI::instance();
 	}
 
-	RTTITypeBase* PostProcessSettings::getRTTI() const
+	RTTITypeBase* RenderSettings::getRTTI() const
 	{
-		return PostProcessSettings::getRTTIStatic();
+		return RenderSettings::getRTTIStatic();
 	}
 
-	void PostProcessSettings::_getSyncData(UINT8* buffer, UINT32& size)
+	void RenderSettings::_getSyncData(UINT8* buffer, UINT32& size)
 	{
 		UINT32 bufferSize = 0;
 		bufferSize += rttiGetElemSize(enableAutoExposure);
@@ -245,7 +245,7 @@ namespace bs
 		writeDst = rttiWriteElem(screenSpaceReflections.quality, writeDst);
 	}
 
-	void PostProcessSettings::_setSyncData(UINT8* buffer, UINT32 size)
+	void RenderSettings::_setSyncData(UINT8* buffer, UINT32 size)
 	{
 		char* readSource = (char*)buffer;
 

Source/MBansheeEditor/Inspectors/CameraInspector.cs

@@ -34,9 +34,9 @@ namespace BansheeEditor
         private GUIToggleField hdrField = new GUIToggleField(new LocEdString("HDR"));
         private GUIToggleField mainField = new GUIToggleField(new LocEdString("Main"));
 
-        private GUIToggle postProcessFoldout = new GUIToggle(new LocEdString("Post processing"), EditorStyles.Foldout);
-        private PostProcessSettingsGUI postProcessGUI;
-        private GUILayout postProcessLayout;
+        private GUIToggle renderSettingsFoldout = new GUIToggle(new LocEdString("Render settings"), EditorStyles.Foldout);
+        private RenderSettingsGUI renderSettingsGUI;
+        private GUILayout renderSettingsLayout;
 
         private ulong layersValue = 0;
         private InspectableState modifyState;
@@ -77,7 +77,7 @@ namespace BansheeEditor
             priorityField.Value = camera.Priority;
             mainField.Value = camera.Main;
             hdrField.Value = camera.HDR;
-            postProcessGUI.Settings = camera.PostProcess;
+            renderSettingsGUI.Settings = camera.RenderSettings;
 
             if (layersValue != camera.Layers)
             {
@@ -257,25 +257,25 @@ namespace BansheeEditor
                 Layout.AddElement(mainField);
                 Layout.AddElement(hdrField);
 
-                postProcessFoldout.OnToggled += x =>
+                renderSettingsFoldout.OnToggled += x =>
                 {
-                    Persistent.SetBool("postProcess_Expanded", x);
-                    postProcessLayout.Active = x;
+                    Persistent.SetBool("renderSettings_Expanded", x);
+                    renderSettingsLayout.Active = x;
                 };
-                Layout.AddElement(postProcessFoldout);
+                Layout.AddElement(renderSettingsFoldout);
 
-                postProcessLayout = Layout.AddLayoutX();
+                renderSettingsLayout = Layout.AddLayoutX();
                 {
-                    postProcessLayout.AddSpace(10);
+                    renderSettingsLayout.AddSpace(10);
 
-                    GUILayoutY contentsLayout = postProcessLayout.AddLayoutY();
-                    postProcessGUI = new PostProcessSettingsGUI(camera.PostProcess, contentsLayout, Persistent);
-                    postProcessGUI.OnChanged += x => { camera.PostProcess = x; MarkAsModified(); };
-                    postProcessGUI.OnConfirmed += ConfirmModify;
+                    GUILayoutY contentsLayout = renderSettingsLayout.AddLayoutY();
+                    renderSettingsGUI = new RenderSettingsGUI(camera.RenderSettings, contentsLayout, Persistent);
+                    renderSettingsGUI.OnChanged += x => { camera.RenderSettings = x; MarkAsModified(); };
+                    renderSettingsGUI.OnConfirmed += ConfirmModify;
                 }
 
                 ToggleTypeSpecificFields(camera.ProjectionType);
-                postProcessLayout.Active = Persistent.GetBool("postProcess_Expanded");
+                renderSettingsLayout.Active = Persistent.GetBool("renderSettings_Expanded");
             }
         }
 

Source/MBansheeEditor/Inspectors/PostProcessSettingsInspector.cs → Source/MBansheeEditor/Inspectors/RenderSettingsInspector.cs

@@ -351,11 +351,11 @@ namespace BansheeEditor
     }
 
     /// <summary>
-    /// Draws GUI elements for inspecting an <see cref="PostProcessSettings"/> object.
+    /// Draws GUI elements for inspecting an <see cref="RenderSettings"/> object.
     /// </summary>
-    internal class PostProcessSettingsGUI
+    internal class RenderSettingsGUI
     {
-        private PostProcessSettings settings;
+        private RenderSettings settings;
         private SerializableProperties properties;
 
         private GUIToggleField enableAutoExposureField = new GUIToggleField(new LocEdString("Enable auto exposure"));
@@ -378,13 +378,13 @@ namespace BansheeEditor
         private GUILayout whiteBalanceLayout;
         private GUILayout colorGradingLayout;
 
-        public Action<PostProcessSettings> OnChanged;
+        public Action<RenderSettings> OnChanged;
         public Action OnConfirmed;
 
         /// <summary>
         /// Current value of the settings object.
         /// </summary>
-        public PostProcessSettings Settings
+        public RenderSettings Settings
         {
             get { return settings; }
             set
@@ -409,7 +409,7 @@ namespace BansheeEditor
         /// <param name="layout">Layout to append the GUI elements to.</param>
         /// <param name="properties">A set of properties that are persisted by the parent inspector. Used for saving state.
         ///                          </param>
-        public PostProcessSettingsGUI(PostProcessSettings settings, GUILayout layout, SerializableProperties properties)
+        public RenderSettingsGUI(RenderSettings settings, GUILayout layout, SerializableProperties properties)
         {
             this.settings = settings;
             this.properties = properties;

Source/MBansheeEditor/MBansheeEditor.csproj

@@ -46,7 +46,7 @@
     <Compile Include="Inspectors\AudioListenerInspector.cs" />
     <Compile Include="Inspectors\AudioSourceInspector.cs" />
     <Compile Include="Inspectors\BoneInspector.cs" />
-    <Compile Include="Inspectors\PostProcessSettingsInspector.cs" />
+    <Compile Include="Inspectors\RenderSettingsInspector.cs" />
     <Compile Include="Utility\EdAnimationCurve.cs" />
     <Compile Include="Utility\SerializedSceneObject.cs" />
     <Compile Include="Utility\SerializedDiff.cs" />

Source/MBansheeEngine/Interop/NativeCamera.cs

@@ -137,10 +137,10 @@ namespace BansheeEngine
             set { Internal_SetNoLighting(mCachedPtr, value); }
         }
 
-        internal PostProcessSettings PostProcess
+        internal RenderSettings RenderSettings
         {
-            get { return Internal_GetPostProcessSettings(mCachedPtr); }
-            set { Internal_SetPostProcessSettings(mCachedPtr, value); }
+            get { return Internal_GetRenderSettings(mCachedPtr); }
+            set { Internal_SetRenderSettings(mCachedPtr, value); }
         }
 
         internal ulong layers
@@ -440,9 +440,9 @@ namespace BansheeEngine
         private static extern void Internal_SetNoLighting(IntPtr instance, bool value);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern PostProcessSettings Internal_GetPostProcessSettings(IntPtr instance);
+        private static extern RenderSettings Internal_GetRenderSettings(IntPtr instance);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetPostProcessSettings(IntPtr instance, PostProcessSettings value);
+        private static extern void Internal_SetRenderSettings(IntPtr instance, RenderSettings value);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern ulong Internal_GetLayers(IntPtr instance);

Source/MBansheeEngine/MBansheeEngine.csproj

@@ -57,7 +57,7 @@
     <Compile Include="Audio\Interop\NativeAudioSource.cs" />
     <Compile Include="GUI\GUICanvas.cs" />
     <Compile Include="GUI\GUIScrollBar.cs" />
-    <Compile Include="Rendering\PostProcessSettings.cs" />
+    <Compile Include="Rendering\RenderSettings.cs" />
     <Compile Include="Serialization\ShowInInspector.cs" />
     <Compile Include="Serialization\Step.cs" />
     <Compile Include="Utility\AsyncOp.cs" />

Source/MBansheeEngine/Rendering/Camera.cs

@@ -158,7 +158,7 @@ namespace BansheeEngine
         /// <summary>
         /// Determines should high dynamic range be enabled. High dynamic range allows light intensity to be more correctly
         /// recorded when rendering by allowing for a larger range of values. The stored light is then converted into
-        /// visible color range using exposure and a tone mapping operator. Use <see cref="PostProcess"/> to customize
+        /// visible color range using exposure and a tone mapping operator. Use <see cref="RenderSettings"/> to customize
         /// those operations.
         /// </summary>
         public bool HDR
@@ -181,10 +181,10 @@ namespace BansheeEngine
         /// Allows you to customize various post process operations that will be executed on the image produced by this 
         /// camera.
         /// </summary>
-        public PostProcessSettings PostProcess
+        public RenderSettings RenderSettings
         {
-            get { return native.PostProcess; }
-            set { native.PostProcess = value;  serializableData.postProcessSettings = value; }
+            get { return native.RenderSettings; }
+            set { native.RenderSettings = value;  serializableData.renderSettings = value; }
         }
 
         /// <summary>
@@ -459,7 +459,7 @@ namespace BansheeEngine
         {
             internal SerializableData()
             {
-                postProcessSettings = PostProcessSettings.CreateDefault();
+                renderSettings = RenderSettings.CreateDefault();
             }
 
             public float aspectRatio = 1.333f;
@@ -476,7 +476,7 @@ namespace BansheeEngine
             public int priority;
             public bool HDR = true;
             public bool noLighting;
-            public PostProcessSettings postProcessSettings;
+            public RenderSettings renderSettings;
             public ulong layers = 0xFFFFFFFFFFFFFFFF;
             public bool main;
         }

Source/MBansheeEngine/Rendering/PostProcessSettings.cs → Source/MBansheeEngine/Rendering/RenderSettings.cs

@@ -172,10 +172,10 @@ namespace BansheeEngine
     };
 
     /// <summary>
-    /// Settings that control the post-process operations.
+    /// Settings that control rendering operations for a single camera.
     /// </summary>
     [SerializeObject]
-    public class PostProcessSettings
+    public class RenderSettings
     {
         /// <summary>
         /// Determines should automatic exposure be applied to the HDR image. When turned on the average scene brightness
@@ -235,15 +235,15 @@ namespace BansheeEngine
         public float Gamma;
 
         /// <summary>
-        /// Creates a new instance of post process settings with the optimal default values.
+        /// Creates a new instance of render settings with the optimal default values.
         /// </summary>
-        /// <returns>New instance of post process settings.</returns>
-        public static PostProcessSettings CreateDefault()
+        /// <returns>New instance of render settings.</returns>
+        public static RenderSettings CreateDefault()
         {
             return Internal_CreateDefault();
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern PostProcessSettings Internal_CreateDefault();
+        private static extern RenderSettings Internal_CreateDefault();
     }
 }

Source/RenderBeast/Include/BsPostProcessing.h

@@ -7,7 +7,7 @@
 #include "BsParamBlocks.h"
 #include "BsGpuResourcePool.h"
 #include "BsLightRendering.h"
-#include "BsPostProcessSettings.h"
+#include "BsRenderSettings.h"
 
 namespace bs { namespace ct
 {
@@ -177,7 +177,7 @@ namespace bs { namespace ct
 		CreateTonemapLUTMat();
 
 		/** Executes the post-process effect with the provided parameters. */
-		void execute(const SPtr<Texture>& output, const PostProcessSettings& settings);
+		void execute(const SPtr<Texture>& output, const RenderSettings& settings);
 
 		/** Returns the texture descriptor that can be used for initializing the output render target. */
 		static POOLED_RENDER_TEXTURE_DESC getOutputDesc();
@@ -209,7 +209,7 @@ namespace bs { namespace ct
 
 		/** Executes the post-process effect with the provided parameters. */
 		void execute(const SPtr<Texture>& sceneColor, const SPtr<Texture>& eyeAdaptation, const SPtr<Texture>& colorLUT,
-			const SPtr<RenderTarget>& output, const PostProcessSettings& settings);
+			const SPtr<RenderTarget>& output, const RenderSettings& settings);
 
 		/** Returns the material variation matching the provided parameters. */
 		static TonemappingMat* getVariation(bool gammaOnly, bool autoExposure, bool MSAA);

Source/RenderBeast/Include/BsRendererView.h

@@ -190,8 +190,8 @@ namespace bs { namespace ct
 		/** Sets state reduction mode that determines how do render queues group & sort renderables. */
 		void setStateReductionMode(StateReduction reductionMode);
 
-		/** Updates the internal camera post-processing data. */
-		void setPostProcessSettings(const SPtr<PostProcessSettings>& ppSettings);
+		/** Updates the internal camera render settings. */
+		void setRenderSettings(const SPtr<RenderSettings>& settings);
 
 		/** Updates the internal information with a new view transform. */
 		void setTransform(const Vector3& origin, const Vector3& direction, const Matrix4& view,
@@ -284,7 +284,7 @@ namespace bs { namespace ct
 		const VisibilityInfo& getVisibilityMasks() const { return mVisibility; }
 
 		/** Returns per-view settings that control rendering. */
-		const PostProcessSettings& getRenderSettings() const { return *mRenderSettings; }
+		const RenderSettings& getRenderSettings() const { return *mRenderSettings; }
 
 		/**
 		 * Retrieves a hash value that is updated whenever render settings change. This can be used by external systems
@@ -341,7 +341,7 @@ namespace bs { namespace ct
 		SPtr<RenderQueue> mTransparentQueue;
 
 		RenderCompositor mCompositor;
-		SPtr<PostProcessSettings> mRenderSettings;
+		SPtr<RenderSettings> mRenderSettings;
 		UINT32 mRenderSettingsHash;
 
 		SPtr<GpuParamBlockBuffer> mParamBuffer;

Source/RenderBeast/Source/BsPostProcessing.cpp

@@ -348,7 +348,7 @@ namespace bs { namespace ct
 		variations.add(variation);
 	}
 
-	void CreateTonemapLUTMat::execute(const SPtr<Texture>& output, const PostProcessSettings& settings)
+	void CreateTonemapLUTMat::execute(const SPtr<Texture>& output, const RenderSettings& settings)
 	{
 		// Set parameters
 		gCreateTonemapLUTParamDef.gGammaAdjustment.set(mParamBuffer, 2.2f / settings.gamma);
@@ -480,7 +480,7 @@ namespace bs { namespace ct
 	}
 
 	void TonemappingMat::execute(const SPtr<Texture>& sceneColor, const SPtr<Texture>& eyeAdaptation, 
-		const SPtr<Texture>& colorLUT, const SPtr<RenderTarget>& output, const PostProcessSettings& settings)
+		const SPtr<Texture>& colorLUT, const SPtr<RenderTarget>& output, const RenderSettings& settings)
 	{
 		const TextureProperties& texProps = sceneColor->getProperties();
 

Source/RenderBeast/Source/BsRenderCompositor.cpp

@@ -1010,7 +1010,7 @@ namespace bs { namespace ct
 		GpuResourcePool& resPool = GpuResourcePool::instance();
 
 		const RendererViewProperties& viewProps = inputs.view.getProperties();
-		const PostProcessSettings& settings = inputs.view.getRenderSettings();
+		const RenderSettings& settings = inputs.view.getRenderSettings();
 
 		RCNodeSceneColor* sceneColorNode = static_cast<RCNodeSceneColor*>(inputs.inputNodes[0]);
 		RCNodePostProcess* postProcessNode = static_cast<RCNodePostProcess*>(inputs.inputNodes[2]);
@@ -1229,7 +1229,7 @@ namespace bs { namespace ct
 
 	void RCNodeFXAA::render(const RenderCompositorNodeInputs& inputs)
 	{
-		const PostProcessSettings& settings = inputs.view.getRenderSettings();
+		const RenderSettings& settings = inputs.view.getRenderSettings();
 		if (!settings.enableFXAA)
 			return;
 

Source/RenderBeast/Source/BsRendererScene.cpp

@@ -36,7 +36,7 @@ namespace bs {	namespace ct
 		RENDERER_VIEW_DESC viewDesc = createViewDesc(camera);
 
 		RendererView* view = bs_new<RendererView>(viewDesc);
-		view->setPostProcessSettings(camera->getPostProcessSettings());
+		view->setRenderSettings(camera->getRenderSettings());
 		view->updatePerViewBuffer();
 
 		UINT32 viewIdx = (UINT32)mInfo.views.size();
@@ -58,13 +58,13 @@ namespace bs {	namespace ct
 			RENDERER_VIEW_DESC viewDesc = createViewDesc(camera);
 
 			view->setView(viewDesc);
-			view->setPostProcessSettings(camera->getPostProcessSettings());
+			view->setRenderSettings(camera->getRenderSettings());
 
 			updateCameraRenderTargets(camera);
 		}
-		else if((updateFlag & (UINT32)CameraDirtyFlag::PostProcess) != 0)
+		else if((updateFlag & (UINT32)CameraDirtyFlag::RenderSettings) != 0)
 		{
-			view->setPostProcessSettings(camera->getPostProcessSettings());
+			view->setRenderSettings(camera->getRenderSettings());
 		}
 		else // Transform
 		{

Source/RenderBeast/Source/BsRendererView.cpp

@@ -109,13 +109,13 @@ namespace bs { namespace ct
 		mTransparentQueue = bs_shared_ptr_new<RenderQueue>(transparentStateReduction);
 	}
 
-	void RendererView::setPostProcessSettings(const SPtr<PostProcessSettings>& ppSettings)
+	void RendererView::setRenderSettings(const SPtr<RenderSettings>& settings)
 	{
 		if (mRenderSettings == nullptr)
-			mRenderSettings = bs_shared_ptr_new<PostProcessSettings>();
+			mRenderSettings = bs_shared_ptr_new<RenderSettings>();
 
-		if (ppSettings != nullptr)
-			*mRenderSettings = *ppSettings;
+		if (settings != nullptr)
+			*mRenderSettings = *settings;
 
 		mRenderSettingsHash++;
 

Source/SBansheeEngine/CMakeSources.cmake

@@ -125,7 +125,7 @@ set(BS_SBANSHEEENGINE_INC_WRAPPERS
 	"Include/BsScriptScene.h"
 	"Include/BsScriptResources.h"
 	"Include/BsScriptResourceRef.h"
-	"Include/BsScriptPostProcessSettings.h"
+	"Include/BsScriptRenderSettings.h"
 	"Include/BsScriptAudioClip.h"
 	"Include/BsScriptAudio.h"
 	"Include/BsScriptAudioSource.h"
@@ -250,7 +250,7 @@ set(BS_SBANSHEEENGINE_SRC_WRAPPERS
 	"Source/BsScriptRenderTexture.cpp"
 	"Source/BsScriptRenderTarget.cpp"
 	"Source/BsScriptRenderable.cpp"
-	"Source/BsScriptPostProcessSettings.cpp"
+	"Source/BsScriptRenderSettings.cpp"
 	"Source/BsScriptAudioClip.cpp"
 	"Source/BsScriptAudio.cpp"
 	"Source/BsScriptAudioSource.cpp"

Source/SBansheeEngine/Include/BsScriptCamera.h

@@ -12,7 +12,7 @@
 #include "BsMatrix4.h"
 #include "BsRect2.h"
 #include "BsColor.h"
-#include "BsPostProcessSettings.h"
+#include "BsRenderSettings.h"
 
 namespace bs
 {
@@ -93,8 +93,8 @@ namespace bs
 		static bool internal_GetNoLighting(ScriptCamera* instance);
 		static void internal_SetNoLighting(ScriptCamera* instance, bool value);
 
-		static MonoObject* internal_GetPostProcessSettings(ScriptCamera* instance);
-		static void internal_SetPostProcessSettings(ScriptCamera* instance, MonoObject* value);
+		static MonoObject* internal_GetRenderSettings(ScriptCamera* instance);
+		static void internal_SetRenderSettings(ScriptCamera* instance, MonoObject* value);
 
 		static UINT64 internal_GetLayers(ScriptCamera* instance);
 		static void internal_SetLayers(ScriptCamera* instance, UINT64 value);

Source/SBansheeEngine/Include/BsScriptPostProcessSettings.h → Source/SBansheeEngine/Include/BsScriptRenderSettings.h

@@ -7,7 +7,7 @@
 
 namespace bs
 {
-	struct PostProcessSettings;
+	struct RenderSettings;
 	struct AutoExposureSettings;
 	struct TonemappingSettings;
 	struct WhiteBalanceSettings;
@@ -118,20 +118,20 @@ namespace bs
 		static MonoField* sOffset;
 	};
 
-	/**	Interop class between C++ & CLR for PostProcessSettings. */
-	class BS_SCR_BE_EXPORT ScriptPostProcessSettings : public ScriptObject<ScriptPostProcessSettings>
+	/**	Interop class between C++ & CLR for RenderSettings. */
+	class BS_SCR_BE_EXPORT ScriptRenderSettings : public ScriptObject<ScriptRenderSettings>
 	{
 	public:
-		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "PostProcessSettings")
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "RenderSettings")
 
 		/** Converts managed object its native counterpart. */
-		static SPtr<PostProcessSettings> toNative(MonoObject* object);
+		static SPtr<RenderSettings> toNative(MonoObject* object);
 
 		/** Converts native object to its managed counterpart. */
-		static MonoObject* toManaged(const SPtr<PostProcessSettings>& value);
+		static MonoObject* toManaged(const SPtr<RenderSettings>& value);
 
 	private:
-		ScriptPostProcessSettings(MonoObject* instance);
+		ScriptRenderSettings(MonoObject* instance);
 
 		/************************************************************************/
 		/* 								CLR HOOKS						   		*/

Source/SBansheeEngine/Source/BsScriptCamera.cpp

@@ -15,8 +15,8 @@
 #include "BsRenderWindow.h"
 #include "BsRenderTexture.h"
 #include "BsGUIManager.h"
-#include "BsPostProcessSettings.h"
-#include "BsScriptPostProcessSettings.h"
+#include "BsRenderSettings.h"
+#include "BsScriptRenderSettings.h"
 
 namespace bs
 {
@@ -79,8 +79,8 @@ namespace bs
 		metaData.scriptClass->addInternalCall("Internal_GetNoLighting", &ScriptCamera::internal_GetNoLighting);
 		metaData.scriptClass->addInternalCall("Internal_SetNoLighting", &ScriptCamera::internal_SetNoLighting);
 
-		metaData.scriptClass->addInternalCall("Internal_GetPostProcessSettings", &ScriptCamera::internal_GetPostProcessSettings);
-		metaData.scriptClass->addInternalCall("Internal_SetPostProcessSettings", &ScriptCamera::internal_SetPostProcessSettings);
+		metaData.scriptClass->addInternalCall("Internal_GetRenderSettings", &ScriptCamera::internal_GetRenderSettings);
+		metaData.scriptClass->addInternalCall("Internal_SetRenderSettings", &ScriptCamera::internal_SetRenderSettings);
 
 		metaData.scriptClass->addInternalCall("Internal_GetLayers", &ScriptCamera::internal_GetLayers);
 		metaData.scriptClass->addInternalCall("Internal_SetLayers", &ScriptCamera::internal_SetLayers);
@@ -314,18 +314,18 @@ namespace bs
 		instance->mCamera->setFlag(CameraFlag::NoLighting, value);
 	}
 
-	MonoObject* ScriptCamera::internal_GetPostProcessSettings(ScriptCamera* instance)
+	MonoObject* ScriptCamera::internal_GetRenderSettings(ScriptCamera* instance)
 	{
-		SPtr<PostProcessSettings> ppSettings = instance->mCamera->getPostProcessSettings();
-		if (ppSettings == nullptr)
-			ppSettings = bs_shared_ptr_new<PostProcessSettings>();
+		SPtr<RenderSettings> settings = instance->mCamera->getRenderSettings();
+		if (settings == nullptr)
+			settings = bs_shared_ptr_new<RenderSettings>();
 
-		return ScriptPostProcessSettings::toManaged(ppSettings);
+		return ScriptRenderSettings::toManaged(settings);
 	}
 
-	void ScriptCamera::internal_SetPostProcessSettings(ScriptCamera* instance, MonoObject* value)
+	void ScriptCamera::internal_SetRenderSettings(ScriptCamera* instance, MonoObject* value)
 	{
-		instance->mCamera->setPostProcessSettings(ScriptPostProcessSettings::toNative(value));
+		instance->mCamera->setRenderSettings(ScriptRenderSettings::toNative(value));
 	}
 
 	UINT64 ScriptCamera::internal_GetLayers(ScriptCamera* instance)
@@ -530,4 +530,4 @@ namespace bs
 
 		ScriptObject::_onManagedInstanceDeleted();
 	}
-}
+}

Source/SBansheeEngine/Source/BsScriptPostProcessSettings.cpp → Source/SBansheeEngine/Source/BsScriptRenderSettings.cpp

@@ -1,12 +1,12 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "BsScriptPostProcessSettings.h"
+#include "BsScriptRenderSettings.h"
 #include "BsMonoManager.h"
 #include "BsMonoAssembly.h"
 #include "BsMonoClass.h"
 #include "BsMonoUtil.h"
 #include "BsCoreThread.h"
-#include "BsPostProcessSettings.h"
+#include "BsRenderSettings.h"
 
 namespace bs
 {
@@ -194,22 +194,22 @@ namespace bs
 		return object;
 	}
 
-	MonoField* ScriptPostProcessSettings::sEnableAutoExposure = nullptr;
-	MonoField* ScriptPostProcessSettings::sAutoExposure = nullptr;
-	MonoField* ScriptPostProcessSettings::sEnableTonemapping = nullptr;
-	MonoField* ScriptPostProcessSettings::sTonemapping = nullptr;
-	MonoField* ScriptPostProcessSettings::sWhiteBalance = nullptr;
-	MonoField* ScriptPostProcessSettings::sColorGrading = nullptr;
-	MonoField* ScriptPostProcessSettings::sExposureScale = nullptr;
-	MonoField* ScriptPostProcessSettings::sGamma = nullptr;
+	MonoField* ScriptRenderSettings::sEnableAutoExposure = nullptr;
+	MonoField* ScriptRenderSettings::sAutoExposure = nullptr;
+	MonoField* ScriptRenderSettings::sEnableTonemapping = nullptr;
+	MonoField* ScriptRenderSettings::sTonemapping = nullptr;
+	MonoField* ScriptRenderSettings::sWhiteBalance = nullptr;
+	MonoField* ScriptRenderSettings::sColorGrading = nullptr;
+	MonoField* ScriptRenderSettings::sExposureScale = nullptr;
+	MonoField* ScriptRenderSettings::sGamma = nullptr;
 
-	ScriptPostProcessSettings::ScriptPostProcessSettings(MonoObject* instance)
+	ScriptRenderSettings::ScriptRenderSettings(MonoObject* instance)
 		:ScriptObject(instance)
 	{ }
 
-	void ScriptPostProcessSettings::initRuntimeData()
+	void ScriptRenderSettings::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateDefault", &ScriptPostProcessSettings::internal_CreateDefault);
+		metaData.scriptClass->addInternalCall("Internal_CreateDefault", &ScriptRenderSettings::internal_CreateDefault);
 
 		sEnableAutoExposure = metaData.scriptClass->getField("EnableAutoExposure");
 		sAutoExposure = metaData.scriptClass->getField("AutoExposure");
@@ -221,9 +221,9 @@ namespace bs
 		sGamma = metaData.scriptClass->getField("Gamma");
 	}
 
-	SPtr<PostProcessSettings> ScriptPostProcessSettings::toNative(MonoObject* object)
+	SPtr<RenderSettings> ScriptRenderSettings::toNative(MonoObject* object)
 	{
-		SPtr<PostProcessSettings> output = bs_shared_ptr_new<PostProcessSettings>();
+		SPtr<RenderSettings> output = bs_shared_ptr_new<RenderSettings>();
 
 		sEnableAutoExposure->get(object, &output->enableAutoExposure);
 		sEnableTonemapping->get(object, &output->enableTonemapping);
@@ -249,7 +249,7 @@ namespace bs
 		return output;
 	}
 
-	MonoObject* ScriptPostProcessSettings::toManaged(const SPtr<PostProcessSettings>& value)
+	MonoObject* ScriptRenderSettings::toManaged(const SPtr<RenderSettings>& value)
 	{
 		MonoObject* object = metaData.scriptClass->createInstance();
 
@@ -273,8 +273,8 @@ namespace bs
 		return object;
 	}
 
-	MonoObject* ScriptPostProcessSettings::internal_CreateDefault()
+	MonoObject* ScriptRenderSettings::internal_CreateDefault()
 	{
-		return toManaged(bs_shared_ptr_new<PostProcessSettings>());
+		return toManaged(bs_shared_ptr_new<RenderSettings>());
 	}
 }