More work on user manuals

Documentation/Doxygen/doxystyle.css

@@ -15,6 +15,7 @@ h2 {
 	margin-bottom: 0.07em;
 	padding: 10px 0px 5px 0px;
 	border-bottom: 1px solid rgba(89, 160, 195, 0.86);
+	font-size: 1.314rem !important;
 }
 
 h2.groupheader {
@@ -26,6 +27,7 @@ h3 {
 	margin-bottom: 0.07em;
 	padding: 10px 0px 5px 0px;
 	border-bottom: 1px dashed rgba(89, 160, 195, 0.86);
+	font-size: 1.0rem !important;
 }
 
 a:visited {

Documentation/Manuals/Native/User/inputEvents.md

@@ -0,0 +1,4 @@
+Input events						{#inputEvents}
+===============
+
+Events represent another way of handling user input. They are an alternative to input polling, and it's up to the developer to choose which way of handling input he prefers. These approaches aren't identical though, and events can provide more information to the developer. Same as polling, events are also handled by the **Input** class.

Documentation/Manuals/Native/User/inputPolling.md

@@ -0,0 +1,52 @@
+Input polling						{#inputPolling}
+===============
+
+Input polling refers to the process of querying the input system to check if user interacted with a input device in some way. This may include checking if the user pressed a keyboard, mouse or a gamepad button or moved the mouse or an analog axis. 
+
+All the input in Banshee is handled though the @ref bs::Input "Input" class, which can always be accessed from the @ref bs::gInput "gInput" method.
+
+# Button presses
+Use the following methods to check if a button has been pressed, released or is currently being held down:
+ - @ref bs::Input::isButtonDown "Input::isButtonDown" - Checks has the button been pressed this frame. Only valid for one frame.
+ - @ref bs::Input::isButtonHeld "Input::isButtonHeld" - Checks is the button currently being held. This is valid for the first frame the button is pressed, and for any following frame until it is released.
+ - @ref bs::Input::isButtonUp "Input::isButtonUp" - Checks has the button been released this frame. Only valid for one frame.
+ 
+These methods work on any kind of input device buttons, including keyboard, gamepad and mouse. Use @ref bs::ButtonCode "ButtonCode" to choose which button to query for.
+
+~~~~~~~~~~~~~{.cpp}
+Vector3 position(BsZero);
+
+// Move 5 units forward for every frame while W key is pressed
+if(gInput().isButtonHeld(BC_W))
+	position.z += 5.0f;
+~~~~~~~~~~~~~
+
+# Analog input
+Moving the mouse, gamepad sticks or triggers results in an analog input. While buttons can only be toggled on or off, analog input is received in a specific range (for example, anywhere between -1 and 1). This allows more precise input for games that require it.
+
+In Banshee analog input is represented through the concept of *axes*. Use @ref bs::Input::getAxisValue "Input::getAxisValue" to get a value for a specific axis. Check @ref bs::InputAxis "InputAxis" for a list of all supported axes.
+
+~~~~~~~~~~~~~{.cpp}
+Vector3 position(BsZero);
+
+// Move forward or backwards depending on how much does the user move the left gamepad stick forward or backwards
+position.z += gInput().getAxisValue(InputAxis::LeftStickY);
+~~~~~~~~~~~~~
+
+Most axes report their input in range [-1, 1], with the exception of mouse axes, which are unbound. 
+
+# Mouse position
+Often it is useful to receive mouse position directly, rather than dealing with raw mouse axis data. Use @ref bs::Input::getPointerPosition "Input::getPointerPosition" to retrieve the current position of the mouse cursor, in coordinates relative to the screen.
+
+Use @ref bs::Input::getPointerDelta "Input::getPointerDelta" to get the difference in coordinates between the position of the mouse on the previous and current frame.
+
+~~~~~~~~~~~~~{.cpp}
+Vector2I screenPos = gInput().getPointerPosition();
+~~~~~~~~~~~~~
+
+You can also check if the left mouse button has been double-clicked by checking @ref bs::Input::isPointerDoubleClicked "Input::isPointerDoubleClicked".
+
+~~~~~~~~~~~~~{.cpp}
+if(gInput().isPointerDoubleClicked())
+	gDebug().logDebug("Mouse double-clicked!");
+~~~~~~~~~~~~~

Documentation/Manuals/Native/User/lights.md

@@ -14,21 +14,61 @@ HLight light = lightSO->addComponent<CLight>();
 Once created light can be positioned and oriented normally using its **SceneObject**.
 
 # Light types
+Lights have three variants that determine how light affects surrounding objects: point, spot and directional. You can change between light variants with @ref bs::CLight::setType "CLight::setType".
 
-// TODO
+~~~~~~~~~~~~~{.cpp}
+// Make a point light
+light->setType(LightType::Point);
+~~~~~~~~~~~~~
+
+## Point light
+
+Point light affects everything within a certain radius from the light (i.e. its sphere of influence). It is the most basic type of light.
+
+@ref TODO_IMAGE
+
+## Spot light
+
+Spot lights only illuminate a certain direction (i.e. like a flash-light). The user can specify the angle of illumination.
+
+@ref TODO_IMAGE
+
+## Directional light
+
+Directional lights are a special type of light primarily used for simulating sun-light, or otherwise far-away objects. Unlike point or spot lights they cannot be positioned. Only their orientation matters and they equally affect every object in the scene.
+
+@ref TODO_IMAGE
 
 # Light properties
+Each light has a set of properties you can adjust (aside from position/orientation, which are handled by the **SceneObject**). Most of the properties are common for all light types but some are only relevant for specific types. We'll go over all of the properties below.
 
 ## Color
+As the name implies, this controls what color light is being emitted from the source. It can be set by calling @ref bs::CLight::setColor "CLight::setColor" and it is valid for all light types.
+
+## Range
+Range determines how far away does the light's influence reach. For point lights this is the radius of the sphere of influence, and for spot lights this is the distance from the origin in the direction of the light. This property is not relevant for directional lights as their range is infinite. Use @ref bs::CLight::setRange "CLight::setRange" to set the range.
+
+Note that the manually set range will only be used if physically based attenuation is disabled. You can toggle this by calling @ref bs::CLight::setPhysicallyBasedAttenuation "CLight::setPhysicallyBasedAttenuation". When physically based attenuation is enabled the maximum range is calculated automatically based on the light intensity (described below) and using a real-world light attenuation model. You might assume that this is always wanted, but sometimes the designer might want more control in which case setting the range manually might be preferable.
 
 ## Intensity
+This controls how strong is the light. Although you could technically control light intensity using the color property (by using a lighter or darker color), using the intensity allows the engine to simulate high-dynamic range. 
 
-## Range
+In nature the range of light intensities varies highly - standing outside at a sunlit day may be hundreds or thousands of times brighter than standing indoors illuminated by a lightbulb. We won't perceive such a large difference because our eyes are able to adjust to different intensities.
 
-// TODO - Also mention physically based attenuation
+Banshee uses a HDR algorithm to try to approximate this adjustment, which results in more realistic and higher quality lighting. Therefore it can be important for realism to set up the light intensities similar to what they would be in nature. 
+
+Use @ref bs::CLight::setIntensity "CLight::setIntensity" to change the light intensity. 
+
+The specific units used for intensity (in case you want to look them up for actual light sources) are *luminous flux* for point/spot lights, and *radiance* for directional lights.
 
 ## Shadows
+Lights may or may not cast shadows. For realism all lights should cast shadows, but that is not feasible due to the high performance costs of using shadows. Therefore you should enable shadows only for one, or a few important lights. Use @ref bs::CLight::setCastsShadow "CLight::setCastsShadow" to enable or disable shadow casting.
 
 ## Spot angles
+Spot light have a property that defines at how wide an angle do they cast light in. Narrower angle means a more focused light beam, while wider angle means a weaker light covering a larger area. 
+
+You can set the spot light angle (also knows as total angle) with @ref bs::CLight::setSpotAngle "CLight::setSpotAngle". Note that light intensity will be spread out over the range, so when increasing the angle, you might also want to increase the intensity to keep the perceived brightness the same.
+
+You can also call @ref bs::CLight::setSpotFalloffAngle "CLight::setSpotFalloffAngle" to set an angle that allows a smooth falloff at the edge of the lights radius. This must be an angle smaller than the total spot angle. Within this angle the light intensity will be uniform, but as the angle increases past the falloff angle and towards the total angle and intensity will slowly reduce, resulting in a smooth falloff curve. If you don't want the smooth falloff, set this angle to the same value as the total angle.
 
-// TODO - Mention both angle types
+@ref TODO_IMAGE

Documentation/Manuals/Native/manuals.md

@@ -17,6 +17,9 @@ Manuals									{#manuals}
  - [Materials](@ref simpleMaterial)
  - [Rendering objects](@ref renderingObjects)
  - [Lighting](@ref lights)
+- **Input**
+ - [Input polling](@ref inputPolling) 
+ - [Input events](@ref inputEvents)  
 - **Utilities**
  - [Containers](@ref containers)
  - [Strings](@ref strings)

Documentation/Manuals/Native/renderAPI.md

@@ -269,7 +269,7 @@ For convenience a specialized @ref bs::RenderAPI::convertProjectionMatrix "Rende
 # Command buffers {#renderAPI_i}
 Almost all @ref bs::RenderAPICore "RenderAPICore" commands we talked about so far support @ref bs::CommandBuffer "CommandBuffer"s. Command buffers are optional, but they allow the rendering commands to be generated from threads other than the core thread.
 
-To create a command buffer call @ref bs::CommandBuffer::create "CommandBuffer::create" after which provide it to the relevant @ref bs::RenderAPICore "RenderAPICore" calls. Those commands will get recorded in the command buffer, but not executed. To actually execute the commands call @ref bs::RenderAPICore::executeCommands "RenderAPICore::executeCommands".
+To create a command buffer call @ref bs::CommandBuffer::create "CommandBuffer::create" after which provide it to the relevant @ref bs::RenderAPICore "RenderAPICore" calls. Those commands will get recorded in the command buffer, but not executed. To actually execute the commands call @ref bs::RenderAPICore::submitCommandBuffer "RenderAPICore::submitCommandBuffer".
 
 This allows rendering to be faster since work can be distributed over multiple CPU cores. Note that only command queuing can happen on a separate thread, command buffer creation and execution must still happen on the core thread.
 
@@ -290,5 +290,5 @@ rapi.setGpuParams(computeGpuParams, cmdBuffer);
 rapi.dispatchCompute(512, 512, cmdBuffer);
 
 // Core thread
-rapi.executeCommands(cmdBuffer);
+rapi.submitCommandBuffer(cmdBuffer);
 ~~~~~~~~~~~~~

Source/BansheeCore/Include/BsInput.h

@@ -233,7 +233,7 @@ namespace bs
 		static const float WEIGHT_MODIFIER;
 	};
 
-	/** Provides easier access to Input. */
+	/** Provides global access to Input. */
 	BS_CORE_EXPORT Input& gInput();
 
 	/** @} */

Source/BansheeEngine/Include/BsCLight.h

@@ -62,6 +62,12 @@ namespace bs
 	    /** @copydoc Light::setSpotAngle */
 		void setSpotAngle(const Degree& spotAngle) { mInternal->setSpotAngle(spotAngle); }
 
+		/** @copydoc Light::getSpotFalloffAngle */
+		Degree getSpotFalloffAngle() const { return mInternal->getSpotFalloffAngle(); }
+
+		/** @copydoc Light::setSpotFalloffAngle */
+		void setSpotFalloffAngle(const Degree& spotAngle) { mInternal->setSpotFalloffAngle(spotAngle); }
+
 		/** @copydoc Light::getPhysicallyBasedAttenuation  */
 		bool getPhysicallyBasedAttenuation() const { return mInternal->getPhysicallyBasedAttenuation(); }
 

Source/MBansheeEngine/Input/Input.cs

@@ -671,8 +671,8 @@ namespace BansheeEngine
     /// <summary>
     /// Available types of input axes.
     /// </summary>
-	public enum InputAxis // Note: Must match C++ enum InputBox
-	{
+	public enum InputAxis // Note: Must match C++ enum InputAxis
+    {
 		MouseX,
 		MouseY,
 		MouseZ,