Added MultipleViewports & RenderToTexture samples.

Added diffuse unlit & notexture unlit techniques.
Do not use occlusion if viewport is very tall compared to width, as the pixel width of the occlusion buffer is fixed and would result in large CPU time consumption.

Bin/CoreData/Techniques/DiffUnlit.xml

@@ -0,0 +1,3 @@
+<technique>
+    <pass name="alpha" vs="Unlit" ps="Unlit_Diff" />
+</technique>

Bin/CoreData/Techniques/NoTextureUnlit.xml

@@ -0,0 +1,3 @@
+<technique>
+    <pass name="alpha" vs="Unlit" ps="Unlit" />
+</technique>

Source/Engine/Graphics/View.cpp

@@ -414,6 +414,10 @@ bool View::Define(RenderSurface* renderTarget, Viewport* viewport)
     if (viewOverrideFlags & VO_DISABLE_OCCLUSION)
         maxOccluderTriangles_ = 0;
     
+    // Occlusion buffer has constant width. If resulting height would be too large due to aspect ratio, disable occlusion
+    if (viewSize_.y_ > viewSize_.x_ * 4)
+        maxOccluderTriangles_ = 0;
+    
     return true;
 }
 

Source/Samples/03_Sprites/Sprites.h

@@ -50,7 +50,7 @@ private:
     void CreateSprites();
     /// Moves the sprites using the delta time step given.
     void MoveSprites(float timeStep);
-    /// Subscribe to application-wide logic update events.
+    /// Subscribes to application-wide logic update events.
     void SubscribeToEvents();
     /// Callback method invoked when a logic update event is dispatched.
     void HandleUpdate(StringHash eventType, VariantMap& eventData);

Source/Samples/04_StaticScene/StaticScene.h

@@ -54,7 +54,7 @@ private:
     void SetupViewport();
     /// Reads input and moves the camera.
     void MoveCamera(float timeStep);
-    /// Subscribe to application-wide logic update events.
+    /// Subscribes to application-wide logic update events.
     void SubscribeToEvents();
     /// Callback method invoked when a logic update event is dispatched.
     void HandleUpdate(StringHash eventType, VariantMap& eventData);

Source/Samples/05_AnimatingScene/AnimatingScene.h

@@ -54,7 +54,7 @@ private:
     void SetupViewport();
     /// Reads input and moves the camera.
     void MoveCamera(float timeStep);
-    /// Subscribe to application-wide logic update events.
+    /// Subscribes to application-wide logic update events.
     void SubscribeToEvents();
     /// Callback method invoked when a logic update event is dispatched.
     void HandleUpdate(StringHash eventType, VariantMap& eventData);

Source/Samples/06_SkeletalAnimation/SkeletalAnimation.cpp

@@ -82,9 +82,8 @@ void SkeletalAnimation::CreateScene()
     
     scene_ = new Scene(context_);
     
-    // Create the Octree component to the scene so that drawable objects can be rendered. Use default volume
-    // (-1000, -1000, -1000) to (1000, 1000, 1000). Also create a DebugRenderer component so that we can draw
-    // debug geometry
+    // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+    // Also create a DebugRenderer component so that we can draw debug geometry
     scene_->CreateComponent<Octree>();
     scene_->CreateComponent<DebugRenderer>();
     
@@ -95,7 +94,7 @@ void SkeletalAnimation::CreateScene()
     planeObject->SetModel(cache->GetResource<Model>("Models/Plane.mdl"));
     planeObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));
     
-    // Create a Zone component for ambient lighting & fog color control
+    // Create a Zone component for ambient lighting & fog control
     Node* zoneNode = scene_->CreateChild("Zone");
     Zone* zone = zoneNode->CreateComponent<Zone>();
     zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));

Source/Samples/06_SkeletalAnimation/SkeletalAnimation.h

@@ -56,7 +56,7 @@ private:
     void SetupViewport();
     /// Reads input and moves the camera.
     void MoveCamera(float timeStep);
-    /// Subscribe to application-wide logic update events.
+    /// Subscribes to application-wide logic update events.
     void SubscribeToEvents();
     /// Callback method invoked when a logic update event is dispatched.
     void HandleUpdate(StringHash eventType, VariantMap& eventData);

Source/Samples/07_Billboards/Billboards.cpp

@@ -78,13 +78,12 @@ void Billboards::CreateScene()
     
     scene_ = new Scene(context_);
     
-    // Create the Octree component to the scene so that drawable objects can be rendered. Use default volume
-    // (-1000, -1000, -1000) to (1000, 1000, 1000). Also create a DebugRenderer component so that we can draw
-    // debug geometry
+    // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+    // Also create a DebugRenderer component so that we can draw debug geometry
     scene_->CreateComponent<Octree>();
     scene_->CreateComponent<DebugRenderer>();
     
-    // Create a Zone component for ambient lighting & fog color control
+    // Create a Zone component for ambient lighting & fog control
     Node* zoneNode = scene_->CreateChild("Zone");
     Zone* zone = zoneNode->CreateComponent<Zone>();
     zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));

Source/Samples/07_Billboards/Billboards.h

@@ -56,7 +56,7 @@ private:
     void MoveCamera(float timeStep);
     /// Animates the scene.
     void AnimateScene(float timeStep);
-    /// Subscribe to application-wide logic update events.
+    /// Subscribes to application-wide logic update events.
     void SubscribeToEvents();
     /// Callback method invoked when a logic update event is dispatched.
     void HandleUpdate(StringHash eventType, VariantMap& eventData);

Source/Samples/08_Decals/Decals.cpp

@@ -80,9 +80,8 @@ void Decals::CreateScene()
     
     scene_ = new Scene(context_);
     
-    // Create the Octree component to the scene so that drawable objects can be rendered. Use default volume
-    // (-1000, -1000, -1000) to (1000, 1000, 1000). Also create a DebugRenderer component so that we can draw
-    // debug geometry
+    // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+    // Also create a DebugRenderer component so that we can draw debug geometry
     scene_->CreateComponent<Octree>();
     scene_->CreateComponent<DebugRenderer>();
     
@@ -93,7 +92,7 @@ void Decals::CreateScene()
     planeObject->SetModel(cache->GetResource<Model>("Models/Plane.mdl"));
     planeObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));
     
-    // Create a Zone component for ambient lighting & fog color control
+    // Create a Zone component for ambient lighting & fog control
     Node* zoneNode = scene_->CreateChild("Zone");
     Zone* zone = zoneNode->CreateComponent<Zone>();
     zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));

Source/Samples/08_Decals/Decals.h

@@ -55,9 +55,9 @@ private:
     void SetupViewport();
     /// Reads input and moves the camera.
     void MoveCamera(float timeStep);
-    /// Paint a decal using a ray cast from the mouse cursor.
+    /// Paints a decal using a ray cast from the mouse cursor.
     void PaintDecal();
-    /// Subscribe to application-wide logic update events.
+    /// Subscribes to application-wide logic update events.
     void SubscribeToEvents();
     /// Callback method invoked when a logic update event is dispatched.
     void HandleUpdate(StringHash eventType, VariantMap& eventData);

Source/Samples/09_MultipleViewports/CMakeLists.txt

@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2008-2013 the Urho3D project.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+# Define target name
+set (TARGET_NAME 09_MultipleViewports)
+
+# Define source files
+file (GLOB CPP_FILES *.cpp)
+file (GLOB H_FILES *.h)
+set (SOURCE_FILES ${CPP_FILES} ${H_FILES} ${COMMON_SAMPLE_H_FILES})
+
+# Setup target with resource copying
+setup_main_executable ()

Source/Samples/09_MultipleViewports/MultipleViewports.cpp

@@ -0,0 +1,287 @@
+//
+// Copyright (c) 2008-2013 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "Camera.h"
+#include "CoreEvents.h"
+#include "Cursor.h"
+#include "DebugRenderer.h"
+#include "DecalSet.h"
+#include "Engine.h"
+#include "Font.h"
+#include "Graphics.h"
+#include "Input.h"
+#include "Light.h"
+#include "Material.h"
+#include "Model.h"
+#include "Octree.h"
+#include "Renderer.h"
+#include "RenderPath.h"
+#include "ResourceCache.h"
+#include "StaticModel.h"
+#include "Text.h"
+#include "UI.h"
+#include "XMLFile.h"
+#include "Zone.h"
+
+#include "MultipleViewports.h"
+
+#include "DebugNew.h"
+
+// Expands to this example's entry-point
+DEFINE_APPLICATION_MAIN(MultipleViewports)
+
+MultipleViewports::MultipleViewports(Context* context) :
+    Sample(context),
+    yaw_(0.0f),
+    pitch_(0.0f),
+    drawDebug_(false)
+{
+}
+
+void MultipleViewports::Start()
+{
+    // Execute base class startup
+    Sample::Start();
+
+    // Create the scene content
+    CreateScene();
+    
+    // Create the UI content
+    CreateInstructions();
+    
+    // Setup the viewports for displaying the scene
+    SetupViewports();
+
+    // Hook up to the frame update and render post-update events
+    SubscribeToEvents();
+}
+
+void MultipleViewports::CreateScene()
+{
+    ResourceCache* cache = GetSubsystem<ResourceCache>();
+    
+    scene_ = new Scene(context_);
+    
+    // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+    // Also create a DebugRenderer component so that we can draw debug geometry
+    scene_->CreateComponent<Octree>();
+    scene_->CreateComponent<DebugRenderer>();
+    
+    // Create scene node & StaticModel component for showing a static plane
+    Node* planeNode = scene_->CreateChild("Plane");
+    planeNode->SetScale(Vector3(100.0f, 1.0f, 100.0f));
+    StaticModel* planeObject = planeNode->CreateComponent<StaticModel>();
+    planeObject->SetModel(cache->GetResource<Model>("Models/Plane.mdl"));
+    planeObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));
+    
+    // Create a Zone component for ambient lighting & fog control
+    Node* zoneNode = scene_->CreateChild("Zone");
+    Zone* zone = zoneNode->CreateComponent<Zone>();
+    zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
+    zone->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
+    zone->SetFogColor(Color(0.5f, 0.5f, 0.7f));
+    zone->SetFogStart(100.0f);
+    zone->SetFogEnd(300.0f);
+    
+    // Create a directional light to the world. Enable cascaded shadows on it
+    Node* lightNode = scene_->CreateChild("Directional light");
+    lightNode->SetDirection(Vector3(0.6f, -1.0f, 0.8f));
+    Light* light = lightNode->CreateComponent<Light>();
+    light->SetLightType(LIGHT_DIRECTIONAL);
+    light->SetCastShadows(true);
+    light->SetShadowBias(BiasParameters(0.0001f, 0.5f));
+    // Set cascade splits at 10, 50 and 200 world units, fade shadows out at 80% of maximum shadow distance
+    light->SetShadowCascade(CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f));
+
+    // Create some mushrooms
+    const unsigned NUM_MUSHROOMS = 240;
+    for (unsigned i = 0; i < NUM_MUSHROOMS; ++i)
+    {
+        Node* mushroomNode = scene_->CreateChild("Mushroom");
+        mushroomNode->SetPosition(Vector3(Random(90.0f) - 45.0f, 0.0f, Random(90.0f) - 45.0f));
+        mushroomNode->SetRotation(Quaternion(0.0f, Random(360.0f), 0.0f));
+        mushroomNode->SetScale(0.5f + Random(2.0f));
+        StaticModel* mushroomObject = mushroomNode->CreateComponent<StaticModel>();
+        mushroomObject->SetModel(cache->GetResource<Model>("Models/Mushroom.mdl"));
+        mushroomObject->SetMaterial(cache->GetResource<Material>("Materials/Mushroom.xml"));
+        mushroomObject->SetCastShadows(true);
+    }
+    
+    // Create randomly sized boxes. If boxes are big enough, make them occluders. Occluders will be software rasterized before
+    // rendering to a low-resolution depth-only buffer to test the objects in the view frustum for visibility
+    const unsigned NUM_BOXES = 20;
+    for (unsigned i = 0; i < NUM_BOXES; ++i)
+    {
+        Node* boxNode = scene_->CreateChild("Box");
+        float size = 1.0f + Random(10.0f);
+        boxNode->SetPosition(Vector3(Random(80.0f) - 40.0f, size * 0.5f, Random(80.0f) - 40.0f));
+        boxNode->SetScale(size);
+        StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
+        boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
+        boxObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
+        boxObject->SetCastShadows(true);
+        if (size >= 5.0f)
+            boxObject->SetOccluder(true);
+    }
+    
+    // Create the cameras. Limit far clip distance to match the fog
+    cameraNode_ = scene_->CreateChild("Camera");
+    Camera* camera = cameraNode_->CreateComponent<Camera>();
+    camera->SetFarClip(300.0f);
+    
+    // Parent the rear camera node to the front camera node and turn it 180 degrees to face backward
+    // Here, we use the angle-axis constructor for Quaternion instead of the usual Euler angles
+    rearCameraNode_ = cameraNode_->CreateChild("RearCamera");
+    rearCameraNode_->Rotate(Quaternion(180.0f, Vector3::UP));
+    Camera* rearCamera = rearCameraNode_->CreateComponent<Camera>();
+    rearCamera->SetFarClip(300.0f);
+    
+    // Set an initial position for the front camera scene node above the plane
+    cameraNode_->SetPosition(Vector3(0.0f, 5.0f, 0.0f));
+}
+
+void MultipleViewports::CreateInstructions()
+{
+    ResourceCache* cache = GetSubsystem<ResourceCache>();
+    UI* ui = GetSubsystem<UI>();
+    
+    // Construct new Text object, set string to display and font to use
+    Text* instructionText = ui->GetRoot()->CreateChild<Text>();
+    instructionText->SetText(
+        "Use WASD keys and mouse to move\n"
+        "B to toggle bloom, F to toggle FXAA\n"
+        "Space to toggle debug geometry\n"
+    );
+    instructionText->SetFont(cache->GetResource<Font>("Fonts/Anonymous Pro.ttf"), 15);
+    
+    // Position the text relative to the screen center
+    instructionText->SetHorizontalAlignment(HA_CENTER);
+    instructionText->SetVerticalAlignment(VA_CENTER);
+    instructionText->SetPosition(0, ui->GetRoot()->GetHeight() / 4);
+}
+
+
+void MultipleViewports::SetupViewports()
+{
+    Graphics* graphics = GetSubsystem<Graphics>();
+    Renderer* renderer = GetSubsystem<Renderer>();
+    
+    renderer->SetNumViewports(2);
+    
+    // Set up the front camera viewport
+    SharedPtr<Viewport> viewport(new Viewport(context_, scene_, cameraNode_->GetComponent<Camera>()));
+    renderer->SetViewport(0, viewport);
+    
+    // Clone the default render path so that we do not interfere with the other viewport, then add
+    // bloom and FXAA post process effects to the front viewport. Render path commands can be tagged
+    // for example with the effect name to allow easy toggling on and off. We start with the effects
+    // disabled.
+    ResourceCache* cache = GetSubsystem<ResourceCache>();
+    SharedPtr<RenderPath> effectRenderPath = viewport->GetRenderPath()->Clone();
+    effectRenderPath->Append(cache->GetResource<XMLFile>("PostProcess/Bloom.xml"));
+    effectRenderPath->Append(cache->GetResource<XMLFile>("PostProcess/EdgeFilter.xml"));
+    // Make the bloom mixing parameter more pronounced
+    effectRenderPath->SetShaderParameter("BloomMix", Vector2(0.9f, 0.6f));
+    effectRenderPath->SetEnabled("Bloom", false);
+    effectRenderPath->SetEnabled("EdgeFilter", false);
+    viewport->SetRenderPath(effectRenderPath);
+    
+    // Set up the rear camera viewport on top of the front view ("rear view mirror")
+    // The viewport index must be greater in that case, otherwise the view would be left behind
+    SharedPtr<Viewport> rearViewport(new Viewport(context_, scene_, rearCameraNode_->GetComponent<Camera>(),
+        IntRect(graphics->GetWidth() * 2 / 3, 32, graphics->GetWidth() - 32, graphics->GetHeight() / 3)));
+    renderer->SetViewport(1, rearViewport);
+}
+
+void MultipleViewports::MoveCamera(float timeStep)
+{
+     // Do not move if the UI has a focused element (the console)
+    if (GetSubsystem<UI>()->GetFocusElement())
+        return;
+    
+    Input* input = GetSubsystem<Input>();
+    
+    // Movement speed as world units per second
+    const float MOVE_SPEED = 20.0f;
+    // Mouse sensitivity as degrees per pixel
+    const float MOUSE_SENSITIVITY = 0.1f;
+    
+    // Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
+    IntVector2 mouseMove = input->GetMouseMove();
+    yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
+    pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
+    pitch_ = Clamp(pitch_, -90.0f, 90.0f);
+    
+    // Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
+    cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
+    
+    // Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
+    if (input->GetKeyDown('W'))
+        cameraNode_->TranslateRelative(Vector3::FORWARD * MOVE_SPEED * timeStep);
+    if (input->GetKeyDown('S'))
+        cameraNode_->TranslateRelative(Vector3::BACK * MOVE_SPEED * timeStep);
+    if (input->GetKeyDown('A'))
+        cameraNode_->TranslateRelative(Vector3::LEFT * MOVE_SPEED * timeStep);
+    if (input->GetKeyDown('D'))
+        cameraNode_->TranslateRelative(Vector3::RIGHT * MOVE_SPEED * timeStep);
+    
+    // Toggle post processing effects on the front viewport. Note that the rear viewport is unaffected
+    RenderPath* effectRenderPath = GetSubsystem<Renderer>()->GetViewport(0)->GetRenderPath();
+    if (input->GetKeyPress('B'))
+        effectRenderPath->ToggleEnabled("Bloom");
+    if (input->GetKeyPress('F'))
+        effectRenderPath->ToggleEnabled("EdgeFilter");
+    
+    // Toggle debug geometry with space
+    if (input->GetKeyPress(KEY_SPACE))
+        drawDebug_ = !drawDebug_;
+}
+
+void MultipleViewports::SubscribeToEvents()
+{
+    // Subscribes HandleUpdate() method for processing update events
+    SubscribeToEvent(E_UPDATE, HANDLER(MultipleViewports, HandleUpdate));
+    
+    // Subscribes HandlePostRenderUpdate() method for processing the post-render update event, sent after Renderer subsystem is
+    // done with defining the draw calls for the viewports (but before actually executing them)
+    SubscribeToEvent(E_POSTRENDERUPDATE, HANDLER(MultipleViewports, HandlePostRenderUpdate));
+}
+
+void MultipleViewports::HandleUpdate(StringHash eventType, VariantMap& eventData)
+{
+    // Event parameters are always defined inside a namespace corresponding to the event's name
+    using namespace Update;
+
+    // Take the frame time step, which is stored as a float
+    float timeStep = eventData[P_TIMESTEP].GetFloat();
+    
+    // Move the camera, scale movement with time step
+    MoveCamera(timeStep);
+}
+
+void MultipleViewports::HandlePostRenderUpdate(StringHash eventType, VariantMap& eventData)
+{
+    // If draw debug mode is enabled, draw viewport debug geometry, which will show eg. drawable bounding boxes and skeleton
+    // bones. Disable depth test so that we can see the effect of occlusion
+    if (drawDebug_)
+        GetSubsystem<Renderer>()->DrawDebugGeometry(false);
+}

Source/Samples/09_MultipleViewports/MultipleViewports.h

@@ -0,0 +1,75 @@
+//
+// Copyright (c) 2008-2013 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+#include "Sample.h"
+#include "Scene.h"
+
+// All Urho3D classes reside in namespace Urho3D
+using namespace Urho3D;
+
+/// Multiple viewports example.
+/// This sample demonstrates:
+///     - Setting up two viewports with two separate cameras;
+///     - Adding post processing effects to a viewport's render path and toggling them;
+class MultipleViewports : public Sample
+{
+    // Mandatory when deriving from Object, enables type information
+    OBJECT(MultipleViewports)
+
+public:
+    /// Construct.
+    MultipleViewports(Context* context);
+
+    /// Setup after engine initialization and before running the main loop.
+    virtual void Start();
+
+private:
+    /// Constructs the scene content.
+    void CreateScene();
+    /// Constructs an instruction text to the UI.
+    void CreateInstructions();
+    /// Sets up viewports.
+    void SetupViewports();
+    /// Reads input and moves the camera.
+    void MoveCamera(float timeStep);
+    /// Subscribes to application-wide logic update events.
+    void SubscribeToEvents();
+    /// Callback method invoked when a logic update event is dispatched.
+    void HandleUpdate(StringHash eventType, VariantMap& eventData);
+    /// Callback method invoked when the post-render update event is dispatched.
+    void HandlePostRenderUpdate(StringHash eventType, VariantMap& eventData);
+    
+    /// Scene.
+    SharedPtr<Scene> scene_;
+    /// Camera scene node.
+    SharedPtr<Node> cameraNode_;
+    /// Rear-facing camera scene node.
+    SharedPtr<Node> rearCameraNode_;
+    /// Camera yaw angle.
+    float yaw_;
+    /// Camera pitch angle.
+    float pitch_;
+    /// Flag for drawing debug geometry.
+    bool drawDebug_;
+};

Source/Samples/10_RenderToTexture/CMakeLists.txt

@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2008-2013 the Urho3D project.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+# Define target name
+set (TARGET_NAME 10_RenderToTexture)
+
+# Define source files
+file (GLOB CPP_FILES *.cpp)
+file (GLOB H_FILES *.h)
+set (SOURCE_FILES ${CPP_FILES} ${H_FILES} ${COMMON_SAMPLE_H_FILES})
+
+# Setup target with resource copying
+setup_main_executable ()

Source/Samples/10_RenderToTexture/RenderToTexture.cpp

@@ -0,0 +1,286 @@
+//
+// Copyright (c) 2008-2013 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "Camera.h"
+#include "CoreEvents.h"
+#include "Engine.h"
+#include "Font.h"
+#include "Graphics.h"
+#include "Input.h"
+#include "Material.h"
+#include "Model.h"
+#include "Octree.h"
+#include "Renderer.h"
+#include "RenderSurface.h"
+#include "ResourceCache.h"
+#include "Rotator.h"
+#include "StaticModel.h"
+#include "Technique.h"
+#include "Text.h"
+#include "Texture2D.h"
+#include "UI.h"
+#include "Zone.h"
+
+#include "RenderToTexture.h"
+
+#include "DebugNew.h"
+
+// Expands to this example's entry-point
+DEFINE_APPLICATION_MAIN(RenderToTexture)
+
+RenderToTexture::RenderToTexture(Context* context) :
+    Sample(context),
+    yaw_(0.0f),
+    pitch_(0.0f)
+{
+    // Register an object factory for our custom Rotator component so that we can create them to scene nodes
+    context->RegisterFactory<Rotator>();
+}
+
+void RenderToTexture::Start()
+{
+    // Execute base class startup
+    Sample::Start();
+
+    // Create the scene content
+    CreateScene();
+    
+    // Create the UI content
+    CreateInstructions();
+    
+    // Setup the viewport for displaying the scene
+    SetupViewport();
+
+    // Hook up to the frame update events
+    SubscribeToEvents();
+}
+
+void RenderToTexture::CreateScene()
+{
+    ResourceCache* cache = GetSubsystem<ResourceCache>();
+    
+    {
+        // Create the scene which will be rendered to a texture
+        rttScene_ = new Scene(context_);
+        
+        // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+        rttScene_->CreateComponent<Octree>();
+        
+        // Create a Zone for ambient light & fog control
+        Node* zoneNode = rttScene_->CreateChild("Zone");
+        Zone* zone = zoneNode->CreateComponent<Zone>();
+        // Set same volume as the Octree, set a close bluish fog and some ambient light
+        zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
+        zone->SetAmbientColor(Color(0.05f, 0.1f, 0.15f));
+        zone->SetFogColor(Color(0.1f, 0.2f, 0.3f));
+        zone->SetFogStart(10.0f);
+        zone->SetFogEnd(100.0f);
+        
+        // Create randomly positioned and oriented box StaticModels in the scene. Use less of them as in the actual
+        // AnimatingScene sample to avoid the scene update (rotating the boxes) taking too much CPU time
+        const unsigned NUM_OBJECTS = 1000;
+        for (unsigned i = 0; i < NUM_OBJECTS; ++i)
+        {
+            Node* boxNode = rttScene_->CreateChild("Box");
+            boxNode->SetPosition(Vector3(Random(100.0f) - 50.0f, Random(100.0f) - 50.0f, Random(100.0f) - 50.0f));
+            // Orient using random pitch, yaw and roll Euler angles
+            boxNode->SetRotation(Quaternion(Random(360.0f), Random(360.0f), Random(360.0f)));
+            StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
+            boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
+            boxObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
+            
+            // Add our custom Rotator component which will rotate the scene node each frame, when the scene sends its update event.
+            // Simply set same rotation speed for all objects
+            Rotator* rotator = boxNode->CreateComponent<Rotator>();
+            rotator->SetRotationSpeed(Vector3(10.0f, 20.0f, 30.0f));
+        }
+        
+        // Create a camera for the render-to-texture scene. Simply leave it at the world origin and let it observe the scene
+        rttCameraNode_ = rttScene_->CreateChild("Camera");
+        Camera* camera = rttCameraNode_->CreateComponent<Camera>();
+        camera->SetFarClip(100.0f);
+        
+        // Create a point light to the camera scene node
+        Light* light = rttCameraNode_->CreateComponent<Light>();
+        light->SetLightType(LIGHT_POINT);
+        light->SetRange(30.0f);
+    }
+    
+    {
+        // Create the scene in which we move around
+        scene_ = new Scene(context_);
+        
+        // Create octree, use also default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+        scene_->CreateComponent<Octree>();
+        
+        // Create a Zone component for ambient lighting & fog control
+        Node* zoneNode = scene_->CreateChild("Zone");
+        Zone* zone = zoneNode->CreateComponent<Zone>();
+        zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
+        zone->SetAmbientColor(Color(0.1f, 0.1f, 0.1f));
+        zone->SetFogStart(100.0f);
+        zone->SetFogEnd(300.0f);
+        
+        // Create a directional light without shadows
+        Node* lightNode = scene_->CreateChild("Light");
+        lightNode->SetDirection(Vector3(0.5f, -1.0f, 0.5f));
+        Light* light = lightNode->CreateComponent<Light>();
+        light->SetLightType(LIGHT_DIRECTIONAL);
+        light->SetColor(Color(0.2f, 0.2f, 0.2f));
+        light->SetSpecularIntensity(1.0f);
+        
+        // Create a "floor" consisting of several tiles
+        for (int y = -5; y <= 5; ++y)
+        {
+            for (int x = -5; x <= 5; ++x)
+            {
+                Node* floorNode = scene_->CreateChild("FloorTile");
+                floorNode->SetPosition(Vector3(x * 20.5f, -0.5f, y * 20.5f));
+                floorNode->SetScale(Vector3(20.0f, 1.0f, 20.f));
+                StaticModel* floorObject = floorNode->CreateComponent<StaticModel>();
+                floorObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
+                floorObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
+            }
+        }
+        
+        // Create a "screen" like object for viewing the second scene. Construct it from two StaticModels, a box for the frame
+        // and a plane for the actual view
+        {
+            Node* boxNode = scene_->CreateChild("ScreenBox");
+            boxNode->SetPosition(Vector3(0.0f, 10.0f, 20.0f));
+            boxNode->SetScale(Vector3(21.0f, 16.0f, 0.5f));
+            StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
+            boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
+            boxObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
+            
+            Node* screenNode = scene_->CreateChild("Screen");
+            screenNode->SetPosition(Vector3(0.0f, 10.0f, 19.74f));
+            screenNode->SetRotation(Quaternion(-90.0f, 0.0f, 0.0f));
+            screenNode->SetScale(Vector3(20.0f, 0.0f, 15.0f));
+            StaticModel* screenObject = screenNode->CreateComponent<StaticModel>();
+            screenObject->SetModel(cache->GetResource<Model>("Models/Plane.mdl"));
+            
+            // Create a renderable texture (1024x768, RGB format) and a material for it
+            SharedPtr<Texture2D> renderTexture(new Texture2D(context_));
+            renderTexture->SetSize(1024, 768, Graphics::GetRGBFormat(), TEXTURE_RENDERTARGET);
+            
+            // Create a new material from scratch, use the diffuse unlit technique, assign the render texture
+            // as its diffuse texture, then assign the material to the screen plane object
+            SharedPtr<Material> renderMaterial(new Material(context_));
+            renderMaterial->SetTechnique(0, cache->GetResource<Technique>("Techniques/DiffUnlit.xml"));
+            renderMaterial->SetTexture(TU_DIFFUSE, renderTexture);
+            screenObject->SetMaterial(renderMaterial);
+            
+            // Get the texture's RenderSurface object (exists when the texture has been created in rendertarget mode)
+            // and define the viewport for rendering the second scene, similarly as how backbuffer viewports are defined
+            // to the Renderer subsystem. By default the texture viewport will be updated when the texture is visible
+            // in the main view
+            RenderSurface* surface = renderTexture->GetRenderSurface();
+            SharedPtr<Viewport> rttViewport(new Viewport(context_, rttScene_, rttCameraNode_->GetComponent<Camera>()));
+            surface->SetViewport(0, rttViewport);
+        }
+        
+        // Create the camera which we will move around. Limit far clip distance to match the fog
+        cameraNode_ = scene_->CreateChild("Camera");
+        Camera* camera = cameraNode_->CreateComponent<Camera>();
+        camera->SetFarClip(300.0f);
+        
+        // Set an initial position for the camera scene node above the plane
+        cameraNode_->SetPosition(Vector3(0.0f, 5.0f, 0.0f));
+    }
+}
+
+void RenderToTexture::CreateInstructions()
+{
+    ResourceCache* cache = GetSubsystem<ResourceCache>();
+    UI* ui = GetSubsystem<UI>();
+    
+    // Construct new Text object, set string to display and font to use
+    Text* instructionText = ui->GetRoot()->CreateChild<Text>();
+    instructionText->SetText("Use WASD keys and mouse to move");
+    instructionText->SetFont(cache->GetResource<Font>("Fonts/Anonymous Pro.ttf"), 15);
+    
+    // Position the text relative to the screen center
+    instructionText->SetHorizontalAlignment(HA_CENTER);
+    instructionText->SetVerticalAlignment(VA_CENTER);
+    instructionText->SetPosition(0, ui->GetRoot()->GetHeight() / 4);
+}
+
+void RenderToTexture::SetupViewport()
+{
+    Renderer* renderer = GetSubsystem<Renderer>();
+    
+    // Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
+    SharedPtr<Viewport> viewport(new Viewport(context_, scene_, cameraNode_->GetComponent<Camera>()));
+    renderer->SetViewport(0, viewport);
+}
+
+void RenderToTexture::MoveCamera(float timeStep)
+{
+    // Do not move if the UI has a focused element (the console)
+    if (GetSubsystem<UI>()->GetFocusElement())
+        return;
+    
+    Input* input = GetSubsystem<Input>();
+    
+    // Movement speed as world units per second
+    const float MOVE_SPEED = 20.0f;
+    // Mouse sensitivity as degrees per pixel
+    const float MOUSE_SENSITIVITY = 0.1f;
+    
+    // Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
+    IntVector2 mouseMove = input->GetMouseMove();
+    yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
+    pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
+    pitch_ = Clamp(pitch_, -90.0f, 90.0f);
+    
+    // Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
+    cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
+    
+    // Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
+    if (input->GetKeyDown('W'))
+        cameraNode_->TranslateRelative(Vector3::FORWARD * MOVE_SPEED * timeStep);
+    if (input->GetKeyDown('S'))
+        cameraNode_->TranslateRelative(Vector3::BACK * MOVE_SPEED * timeStep);
+    if (input->GetKeyDown('A'))
+        cameraNode_->TranslateRelative(Vector3::LEFT * MOVE_SPEED * timeStep);
+    if (input->GetKeyDown('D'))
+        cameraNode_->TranslateRelative(Vector3::RIGHT * MOVE_SPEED * timeStep);
+}
+
+void RenderToTexture::SubscribeToEvents()
+{
+    // Subscribes HandleUpdate() method for processing update events
+    SubscribeToEvent(E_UPDATE, HANDLER(RenderToTexture, HandleUpdate));
+}
+
+void RenderToTexture::HandleUpdate(StringHash eventType, VariantMap& eventData)
+{
+    // Event parameters are always defined inside a namespace corresponding to the event's name
+    using namespace Update;
+
+    // Take the frame time step, which is stored as a float
+    float timeStep = eventData[P_TIMESTEP].GetFloat();
+    
+    // Move the camera, scale movement with time step
+    MoveCamera(timeStep);
+}

Source/Samples/10_RenderToTexture/RenderToTexture.h

@@ -0,0 +1,73 @@
+//
+// Copyright (c) 2008-2013 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+#include "Sample.h"
+#include "Scene.h"
+
+// All Urho3D classes reside in namespace Urho3D
+using namespace Urho3D;
+
+/// Render to texture example
+/// This sample demonstrates:
+///     - Creating two 3D scenes and rendering the other into a texture;
+///     - Creating rendertarget textures and materials programmatically;
+class RenderToTexture : public Sample
+{
+    // Mandatory when deriving from Object, enables type information
+    OBJECT(RenderToTexture)
+
+public:
+    /// Construct.
+    RenderToTexture(Context* context);
+
+    /// Setup after engine initialization and before running the main loop.
+    virtual void Start();
+
+private:
+    /// Constructs the scene content.
+    void CreateScene();
+    /// Constructs an instruction text to the UI.
+    void CreateInstructions();
+    /// Sets up a viewport for displaying the scene.
+    void SetupViewport();
+    /// Reads input and moves the camera.
+    void MoveCamera(float timeStep);
+    /// Subscribe to application-wide logic update events.
+    void SubscribeToEvents();
+    /// Callback method invoked when a logic update event is dispatched.
+    void HandleUpdate(StringHash eventType, VariantMap& eventData);
+
+    /// Scene in which the user moves.
+    SharedPtr<Scene> scene_;
+    /// Camera scene node.
+    SharedPtr<Node> cameraNode_;
+    /// Scene that is rendered to a texture.
+    SharedPtr<Scene> rttScene_;
+    /// Camera scene node in the render-to-texture scene.
+    SharedPtr<Node> rttCameraNode_;
+    /// Camera yaw angle.
+    float yaw_;
+    /// Camera pitch angle.
+    float pitch_;
+};

Source/Samples/10_RenderToTexture/Rotator.cpp

@@ -0,0 +1,62 @@
+//
+// Copyright (c) 2008-2013 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "Rotator.h"
+#include "Scene.h"
+#include "SceneEvents.h"
+
+Rotator::Rotator(Context* context) :
+    Component(context),
+    rotationSpeed_(Vector3::ZERO)
+{
+}
+
+void Rotator::SetRotationSpeed(const Vector3& speed)
+{
+    rotationSpeed_ = speed;
+}
+
+void Rotator::OnNodeSet(Node* node)
+{
+    // If the node pointer is nonzero, this component has been created into a scene node. Subscribe to the variable timestep
+    // scene update event now. If the node pointer is zero, the component is being removed from a scene node at destruction
+    // time. In that case we do nothing
+    if (node)
+    {
+        Scene* scene = node->GetScene();
+        // The scene pointer will be nonzero if the scene node belongs to a scene (it is also legal to create free-standing
+        // scene nodes)
+        if (scene)
+            SubscribeToEvent(scene, E_SCENEUPDATE, HANDLER(Rotator, HandleSceneUpdate));
+    }
+}
+
+void Rotator::HandleSceneUpdate(StringHash eventType, VariantMap& eventData)
+{
+    // Get the timestep from the update event
+    using namespace SceneUpdate;
+    float timeStep = eventData[P_TIMESTEP].GetFloat();
+    
+    // Components have their scene node as a member variable for convenient access. Rotate the scene node now: construct a
+    // rotation quaternion from Euler angles, scale rotation speed with the scene update time step
+    node_->Rotate(Quaternion(rotationSpeed_.x_ * timeStep, rotationSpeed_.y_ * timeStep, rotationSpeed_.z_ * timeStep));
+}

Source/Samples/10_RenderToTexture/Rotator.h

@@ -0,0 +1,53 @@
+//
+// Copyright (c) 2008-2013 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+#include "Component.h"
+
+// All Urho3D classes reside in namespace Urho3D
+using namespace Urho3D;
+
+/// Custom component for rotating a scene node.
+class Rotator : public Component
+{
+public:
+    /// Construct.
+    Rotator(Context* context);
+    
+    /// Set rotation speed about the Euler axes. Will be scaled with scene update time step.
+    void SetRotationSpeed(const Vector3& speed);
+    
+    /// Return rotation speed.
+    const Vector3& GetRotationSpeed() const { return rotationSpeed_; }
+    
+protected:
+    /// Handle node being assigned.
+    virtual void OnNodeSet(Node* node);
+    
+private:
+    /// Handle scene update event.
+    void HandleSceneUpdate(StringHash eventType, VariantMap& eventData);
+    
+    /// Rotation speed.
+    Vector3 rotationSpeed_;
+};

Source/Samples/CMakeLists.txt

@@ -45,4 +45,6 @@ add_subdirectory (05_AnimatingScene)
 add_subdirectory (06_SkeletalAnimation)
 add_subdirectory (07_Billboards)
 add_subdirectory (08_Decals)
+add_subdirectory (09_MultipleViewports)
+add_subdirectory (10_RenderToTexture)