Add RenderToTexture and Physics sample in Lua.

Bin/Data/LuaScripts/10_RenderToTexture.lua

@@ -0,0 +1,239 @@
+-- Render to texture example
+-- This sample demonstrates:
+--     - Creating two 3D scenes and rendering the other into a texture
+--     - Creating rendertarget textures and materials programmatically
+
+require "LuaScripts/Utilities/Sample"
+
+local scene_ = nil
+local rttScene_ = nil
+local cameraNode = nil
+local rttCameraNode = nil
+local yaw = 0.0
+local pitch = 0.0
+
+local context = GetContext()
+
+local cache = GetCache()
+local input = GetInput()
+local graphics = GetGraphics()
+local renderer = GetRenderer()
+local ui = GetUI()
+
+function Start()
+    -- Execute the common startup for samples
+    SampleStart()
+
+    -- 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()
+end
+
+function CreateScene()
+    -- Create the scene which will be rendered to a texture
+    rttScene_ = 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
+    local zoneNode = rttScene_:CreateChild("Zone")
+    local zone = zoneNode:CreateComponent("Zone")
+    -- Set same volume as the Octree, set a close bluish fog and some ambient light
+    zone.boundingBox = BoundingBox(-1000.0, 1000.0)
+    zone.ambientColor = Color(0.05, 0.1, 0.15)
+    zone.fogColor = Color(0.1, 0.2, 0.3)
+    zone.fogStart = 10.0
+    zone.fogEnd = 100.0
+
+    -- Create randomly positioned and oriented box StaticModels in the scene
+    local NUM_OBJECTS = 2000
+    for i = 1, NUM_OBJECTS do
+        local boxNode = rttScene_:CreateChild("Box")
+        boxNode.position = Vector3(Random(200.0) - 100.0, Random(200.0) - 100.0, Random(200.0) - 100.0)
+        -- Orient using random pitch, yaw and roll Euler angles
+        boxNode.rotation = Quaternion(Random(360.0), Random(360.0), Random(360.0))
+        local boxObject = boxNode:CreateComponent("StaticModel")
+        boxObject.model = cache:GetResource("Model", "Models/Box.mdl")
+        boxObject.material = 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
+        local rotator = boxNode:CreateScriptObject("Rotator")
+        rotator.rotationSpeed = Vector3(10.0, 20.0, 30.0)
+    end
+
+    -- 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")
+    local camera = rttCameraNode:CreateComponent("Camera")
+    camera.farClip = 100.0
+    
+    -- Create a point light to the camera scene node
+    local light = rttCameraNode:CreateComponent("Light")
+    light.lightType = LIGHT_POINT
+    light.range = 30.0
+
+    -- Create the scene in which we move around
+    scene_ = 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
+    local zoneNode = scene_:CreateChild("Zone")
+    local zone = zoneNode:CreateComponent("Zone")
+    zone.boundingBox = BoundingBox(-1000.0, 1000.0)
+    zone.ambientColor = Color(0.1, 0.1, 0.1)
+    zone.fogStart = 100.0
+    zone.fogEnd = 300.0
+
+    -- Create a directional light without shadows
+    local lightNode = scene_:CreateChild("DirectionalLight")
+    lightNode.direction = Vector3(0.5, -1.0, 0.5)
+    local light = lightNode:CreateComponent("Light")
+    light.lightType = LIGHT_DIRECTIONAL
+    light.color = Color(0.2, 0.2, 0.2)
+    light.specularIntensity = 1.0
+    
+    -- Create a "floor" consisting of several tiles
+    for y = -5, 5 do
+        for x = -5, 5 do
+            local floorNode = scene_:CreateChild("FloorTile")
+            floorNode.position = Vector3(x * 20.5, -0.5, y * 20.5)
+            floorNode.scale = Vector3(20.0, 1.0, 20.)
+            local floorObject = floorNode:CreateComponent("StaticModel")
+            floorObject.model = cache:GetResource("Model", "Models/Box.mdl")
+            floorObject.material = cache:GetResource("Material", "Materials/Stone.xml")
+        end
+    end
+
+    -- 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
+    local boxNode = scene_:CreateChild("ScreenBox")
+    boxNode.position = Vector3(0.0, 10.0, 0.0)
+    boxNode.scale = Vector3(21.0, 16.0, 0.5)
+    local boxObject = boxNode:CreateComponent("StaticModel")
+    boxObject.model = cache:GetResource("Model", "Models/Box.mdl")
+    boxObject.material = cache:GetResource("Material", "Materials/Stone.xml")
+
+    local screenNode = scene_:CreateChild("Screen")
+    screenNode.position = Vector3(0.0, 10.0, -0.27)
+    screenNode.rotation = Quaternion(-90.0, 0.0, 0.0)
+    screenNode.scale = Vector3(20.0, 0.0, 15.0)
+    local screenObject = screenNode:CreateComponent("StaticModel")
+    screenObject.model = cache:GetResource("Model", "Models/Plane.mdl")
+
+    -- Create a renderable texture (1024x768, RGB format), enable bilinear filtering on it
+    local renderTexture = Texture2D:new(context)
+    renderTexture:SetSize(1024, 768, Graphics:GetRGBFormat(), TEXTURE_RENDERTARGET)
+    renderTexture.filterMode = FILTER_BILINEAR
+    
+    -- 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
+    local renderMaterial = Material:new(context)
+    renderMaterial:SetTechnique(0, cache:GetResource("Technique", "Techniques/DiffUnlit.xml"))
+    renderMaterial:SetTexture(TU_DIFFUSE, renderTexture)
+    screenObject.material = 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
+    local surface = renderTexture.renderSurface
+    local rttViewport = Viewport:new(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")
+    local camera = cameraNode:CreateComponent("Camera")
+    camera.farClip = 300.0
+
+    -- Set an initial position for the camera scene node above the plane
+    cameraNode.position = Vector3(0.0, 7.0, -30.0)
+end
+
+function CreateInstructions()
+    -- Construct new Text object, set string to display and font to use
+    local instructionText = ui.root:CreateChild("Text")
+    instructionText.text = "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.horizontalAlignment = HA_CENTER
+    instructionText.verticalAlignment = VA_CENTER
+    instructionText:SetPosition(0, ui.root.height / 4)
+end
+
+function SetupViewport()
+    -- Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
+    local viewport = Viewport:new(context, scene_, cameraNode:GetComponent("Camera"))
+    renderer:SetViewport(0, viewport)
+end
+
+function MoveCamera(timeStep)
+    -- Do not move if the UI has a focused element (the console)
+    if ui.focusElement ~= nil then
+        return
+    end
+
+    -- Movement speed as world units per second
+    local MOVE_SPEED = 20.0
+    -- Mouse sensitivity as degrees per pixel
+    local MOUSE_SENSITIVITY = 0.1
+
+    -- Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
+    local mouseMove = input.mouseMove
+    yaw = yaw + MOUSE_SENSITIVITY * mouseMove.x
+    pitch = pitch + MOUSE_SENSITIVITY * mouseMove.y
+    pitch = Clamp(pitch, -90.0, 90.0)
+    
+    -- Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
+    cameraNode.rotation = Quaternion(pitch, yaw, 0.0)
+    -- Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
+    local delta = MOVE_SPEED * timeStep
+    if input:GetKeyDown(KEY_W) then
+        cameraNode:TranslateRelativeXYZ(0.0, 0.0, delta)
+    end
+    if input:GetKeyDown(KEY_S) then
+        cameraNode:TranslateRelativeXYZ(0.0, 0.0, -delta)
+    end
+    if input:GetKeyDown(KEY_A) then
+        cameraNode:TranslateRelativeXYZ(-delta, 0.0, 0.0)
+    end
+    if input:GetKeyDown(KEY_D) then
+        cameraNode:TranslateRelativeXYZ(delta, 0.0, 0.0)
+    end
+end
+
+function SubscribeToEvents()
+    -- Subscribe HandleUpdate() function for processing update events
+    SubscribeToEvent("Update", "HandleUpdate")
+end
+
+function HandleUpdate(eventType, eventData)
+    -- Take the frame time step, which is stored as a float
+    local timeStep = eventData:GetFloat("TimeStep")
+    
+    -- Move the camera, scale movement with time step
+    MoveCamera(timeStep)
+end
+
+-- Rotator script object class. Script objects to be added to a scene node must implement the empty ScriptObject interface
+Rotator = ScriptObject()
+
+function Rotator:Start()
+    self.rotationSpeed = Vector3(0.0, 0.0, 0.0)
+end
+
+-- Update is called during the variable timestep scene update
+function Rotator:Update(timeStep)
+    self.node:RotateXYZ(self.rotationSpeed.x * timeStep, self.rotationSpeed.y * timeStep, self.rotationSpeed.z * timeStep)
+end

Bin/Data/LuaScripts/11_Physics.lua

@@ -0,0 +1,254 @@
+-- Physics example.
+-- This sample demonstrates:
+--     - Creating both static and moving physics objects to a scene
+--     - Displaying physics debug geometry
+--     - Using the Skybox component for setting up an unmoving sky
+--     - Saving a scene to a file and loading it to restore a previous 
+
+require "LuaScripts/Utilities/Sample"
+
+local scene_ = nil
+local cameraNode
+local yaw = 0.0
+local pitch = 0.0
+local drawDebug = false
+
+local context = GetContext()
+
+local cache = GetCache()
+local fileSystem = GetFileSystem()
+local input = GetInput()
+local renderer = GetRenderer()
+local ui = GetUI()
+
+function Start()
+    -- Execute the common startup for samples
+    SampleStart()
+
+    -- Create the scene content
+    CreateScene()
+
+    -- Create the UI content
+    CreateInstructions()
+
+    -- Setup the viewport for displaying the scene
+    SetupViewport()
+
+    -- Hook up to the frame update and render post-update events
+    SubscribeToEvents()
+end
+
+function CreateScene()
+    scene_ = Scene(context)
+
+    -- Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+    -- Create a physics simulation world with default parameters, which will update at 60fps. Like the Octree must
+    -- exist before creating drawable components, the PhysicsWorld must exist before creating physics components.
+    -- Finally, create a DebugRenderer component so that we can draw physics debug geometry
+    scene_:CreateComponent("Octree")
+    scene_:CreateComponent("PhysicsWorld")
+    scene_:CreateComponent("DebugRenderer")
+    
+    -- Create a Zone component for ambient lighting & fog control
+    local zoneNode = scene_:CreateChild("Zone")
+    local zone = zoneNode:CreateComponent("Zone")
+    zone.boundingBox = BoundingBox(-1000.0, 1000.0)
+    zone.ambientColor = Color(0.15, 0.15, 0.15)
+    zone.fogColor = Color(0.7, 0.6, 0.5)
+    zone.fogStart = 150.0
+    zone.fogEnd = 500.0
+
+    -- Create a directional light to the world. Enable cascaded shadows on it
+    local lightNode = scene_:CreateChild("DirectionalLight")
+    lightNode.direction = Vector3(0.6, -1.0, 0.8)
+    local light = lightNode:CreateComponent("Light")
+    light.lightType = LIGHT_DIRECTIONAL
+    light.castShadows = true
+    light.shadowBias = BiasParameters(0.0001, 0.5)
+    -- Set cascade splits at 10, 50 and 200 world units, fade shadows out at 80% of maximum shadow distance
+    light.shadowCascade = CascadeParameters(10.0, 50.0, 200.0, 0.0, 0.8)
+    
+    -- Create skybox. The Skybox component is used like StaticModel, but it will be always located at the camera, giving the
+    -- illusion of the box planes being far away. Use just the ordinary Box model and a suitable material, whose shader will
+    -- generate the necessary 3D texture coordinates for cube mapping
+    local skyNode = scene_:CreateChild("Sky")
+    skyNode:SetScale(500.0) -- The scale actually does not matter
+    local skybox = skyNode:CreateComponent("Skybox")
+    skybox.model = cache:GetResource("Model", "Models/Box.mdl")
+    skybox.material = cache:GetResource("Material", "Materials/Skybox.xml")
+
+    -- Create a floor object, 1000 x 1000 world units. Adjust position so that the ground is at zero Y
+    local floorNode = scene_:CreateChild("Floor")
+    floorNode.position = Vector3(0.0, -0.5, 0.0)
+    floorNode.scale = Vector3(1000.0, 1.0, 1000.0)
+    local floorObject = floorNode:CreateComponent("StaticModel")
+    floorObject.model = cache:GetResource("Model", "Models/Box.mdl")
+    floorObject.material = cache:GetResource("Material", "Materials/StoneTiled.xml")
+
+    -- Make the floor physical by adding RigidBody and CollisionShape components. The RigidBody's default
+    -- parameters make the object static (zero mass.) Note that a CollisionShape by itself will not participate
+    -- in the physics simulation
+    local body = floorNode:CreateComponent("RigidBody")
+    local shape = floorNode:CreateComponent("CollisionShape")
+    -- Set a box shape of size 1 x 1 x 1 for collision. The shape will be scaled with the scene node scale, so the
+    -- rendering and physics representation sizes should match (the box model is also 1 x 1 x 1.)
+    shape:SetBox(Vector3(1.0, 1.0, 1.0))
+    
+    -- Create a pyramid of movable physics objects
+    for y = 0, 7 do
+        for x = -y, y do
+            local boxNode = scene_:CreateChild("Box")
+            boxNode.position = Vector3(x, -y + 8.0, 0.0)
+            local boxObject = boxNode:CreateComponent("StaticModel")
+            boxObject.model = cache:GetResource("Model", "Models/Box.mdl")
+            boxObject.material = cache:GetResource("Material", "Materials/StoneEnvMapSmall.xml")
+            boxObject.castShadows = true
+            
+            -- Create RigidBody and CollisionShape components like above. Give the RigidBody mass to make it movable
+            -- and also adjust friction. The actual mass is not important only the mass ratios between colliding 
+            -- objects are significant
+            local body = boxNode:CreateComponent("RigidBody")
+            body.mass = 1.0
+            body.friction = 0.75
+            local shape = boxNode:CreateComponent("CollisionShape")
+            shape:SetBox(Vector3(1.0, 1.0, 1.0))
+        end
+    end
+    
+    -- Create the camera. Set far clip to match the fog. Note: now we actually create the camera node outside
+    -- the scene, because we want it to be unaffected by scene load / save
+    cameraNode = Node(context)
+    local camera = cameraNode:CreateComponent("Camera")
+    camera.farClip = 500.0
+
+    -- Set an initial position for the camera scene node above the floor
+    cameraNode.position = Vector3(0.0, 5.0, -20.0)
+end
+
+function CreateInstructions()
+    -- Construct new Text object, set string to display and font to use
+    local instructionText = ui.root:CreateChild("Text")
+    instructionText:SetText("Use WASD keys and mouse to move\n"..
+        "LMB to spawn physics objects\n"..
+        "F5 to save scene, F7 to load\n"..
+        "Space to toggle physics debug geometry")
+    instructionText:SetFont(cache:GetResource("Font", "Fonts/Anonymous Pro.ttf"), 15)
+    -- The text has multiple rows. Center them in relation to each other
+    instructionText.textAlignment = HA_CENTER
+
+    -- Position the text relative to the screen center
+    instructionText.horizontalAlignment = HA_CENTER
+    instructionText.verticalAlignment = VA_CENTER
+    instructionText:SetPosition(0, ui.root.height / 4)
+end
+
+function SetupViewport()
+    -- Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
+    local viewport = Viewport:new(context, scene_, cameraNode:GetComponent("Camera"))
+    renderer:SetViewport(0, viewport)
+end
+
+function SubscribeToEvents()
+    -- Subscribe HandleUpdate() function for processing update events
+    SubscribeToEvent("Update", "HandleUpdate")
+
+    -- Subscribe HandlePostRenderUpdate() function for processing the post-render update event, during which we request
+    -- debug geometry
+    SubscribeToEvent("PostRenderUpdate", "HandlePostRenderUpdate")
+end
+
+function MoveCamera(timeStep)
+    -- Do not move if the UI has a focused element (the console)
+    if ui.focusElement ~= nil then
+        return
+    end
+
+    -- Movement speed as world units per second
+    local MOVE_SPEED = 20.0
+    -- Mouse sensitivity as degrees per pixel
+    local MOUSE_SENSITIVITY = 0.1
+
+    -- Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
+    local mouseMove = input.mouseMove
+    yaw = yaw + MOUSE_SENSITIVITY * mouseMove.x
+    pitch = pitch  +MOUSE_SENSITIVITY * mouseMove.y
+    pitch = Clamp(pitch, -90.0, 90.0)
+
+    -- Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
+    cameraNode.rotation = Quaternion(pitch, yaw, 0.0)
+
+    -- Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
+    if input:GetKeyDown(KEY_W) then
+        cameraNode:TranslateRelative(Vector3(0.0, 0.0, 1.0) * MOVE_SPEED * timeStep)
+    end
+    if input:GetKeyDown(KEY_S) then
+        cameraNode:TranslateRelative(Vector3(0.0, 0.0, -1.0) * MOVE_SPEED * timeStep)
+    end
+    if input:GetKeyDown(KEY_A) then
+        cameraNode:TranslateRelative(Vector3(-1.0, 0.0, 0.0) * MOVE_SPEED * timeStep)
+    end
+    if input:GetKeyDown(KEY_D) then
+        cameraNode:TranslateRelative(Vector3(1.0, 0.0, 0.0) * MOVE_SPEED * timeStep)
+    end
+    
+    -- "Shoot" a physics object with left mousebutton
+    if input:GetMouseButtonPress(MOUSEB_LEFT) then
+        SpawnObject()
+    end
+    
+    -- Check for loading/saving the scene. Save the scene to the file Data/Scenes/Physics.xml relative to the executable
+    -- directory
+    if input:GetKeyPress(KEY_F5) then
+        scene_:SaveXML(fileSystem:GetProgramDir().."Data/Scenes/PhysicsStressTest.xml")
+    end
+    if input:GetKeyPress(KEY_F7) then
+        scene_:LoadXML(fileSystem:GetProgramDir().."Data/Scenes/PhysicsStressTest.xml")
+    end
+
+    -- Toggle debug geometry with space
+    if input:GetKeyPress(KEY_SPACE) then
+        drawDebug = not drawDebug
+    end
+end
+
+function SpawnObject()
+    -- Create a smaller box at camera position
+    local boxNode = scene_:CreateChild("SmallBox")
+    boxNode.position = cameraNode.position
+    boxNode.rotation = cameraNode.rotation
+    boxNode:SetScale(0.25)
+    local boxObject = boxNode:CreateComponent("StaticModel")
+    boxObject.model = cache:GetResource("Model", "Models/Box.mdl")
+    boxObject.material = cache:GetResource("Material", "Materials/StoneEnvMapSmall.xml")
+    boxObject.castShadows = true
+
+    -- Create physics components, use a smaller mass also
+    local body = boxNode:CreateComponent("RigidBody")
+    body.mass = 0.25
+    body.friction = 0.75
+    local shape = boxNode:CreateComponent("CollisionShape")
+    shape:SetBox(Vector3(1.0, 1.0, 1.0))
+
+    local OBJECT_VELOCITY = 10.0
+
+    -- Set initial velocity for the RigidBody based on camera forward vector. Add also a slight up component
+    -- to overcome gravity better
+    body.linearVelocity = cameraNode.rotation * Vector3(0.0, 0.25, 1.0) * OBJECT_VELOCITY
+end
+
+function HandleUpdate(eventType, eventData)
+    -- Take the frame time step, which is stored as a float
+    local timeStep = eventData:GetFloat("TimeStep")
+
+    -- Move the camera, scale movement with time step
+    MoveCamera(timeStep)
+end
+
+function HandlePostRenderUpdate(eventType, eventData)
+
+    -- If draw debug mode is enabled, draw physics debug geometry. Use depth test to make the result easier to interpret
+    -- Note the convenience accessor to the physics world component
+    if drawDebug then
+        scene_:GetComponent("PhysicsWorld"):DrawDebugGeometry(true)
+    end
+end

Source/Extras/LuaScript/pkgs/Graphics/Graphics.pkg

@@ -38,6 +38,8 @@ class Graphics : public Object
     bool GetSRGBSupport() const;
     bool GetSRGBWriteSupport() const;
     
+    static unsigned GetRGBFormat();
+    
     tolua_readonly tolua_property__is_set bool initialized;
     tolua_property__get_set const String windowTitle;
     tolua_readonly tolua_property__get_set int width;

Source/Extras/LuaScript/pkgs/Graphics/Material.pkg

@@ -4,7 +4,26 @@ enum CullMode{};
 
 class Material : public Resource
 {
+    Material(Context* context);
+    ~Material();
+    
+    void SetNumTechniques(unsigned num);
+    void SetTechnique(unsigned index, Technique* tech, unsigned qualityLevel = 0, float lodDistance = 0.0f);
+    void SetShaderParameter(const String name, const Variant& value);
+    void SetTexture(TextureUnit unit, Texture* texture);
+    void SetUVTransform(const Vector2& offset, float rotation, const Vector2& repeat);
+    void SetUVTransform(const Vector2& offset, float rotation, float repeat);
+    void SetCullMode(CullMode mode);
+    void SetShadowCullMode(CullMode mode);
+    void SetDepthBias(const BiasParameters& parameters);
+    void RemoveShaderParameter(const String name);
+    void ReleaseShaders();
+    // SharedPtr<Material> Clone(const String cloneName = String::EMPTY) const;
+    void SortTechniques();
+    void MarkForAuxView(unsigned frameNumber);
+    
     unsigned GetNumTechniques() const;
+    
     Technique* GetTechnique(unsigned index) const;
     
     Pass* GetPass(unsigned index, StringHash passType) const;

Source/Extras/LuaScript/pkgs/Graphics/Texture2D.pkg

@@ -1,6 +1,15 @@
 $#include "Texture2D.h"
 
+enum TextureUsage{};
+
 class Texture2D : public Texture
 {
+    Texture2D(Context* context);
+    ~Texture2D();
+    
+    bool SetSize(int width, int height, unsigned format, TextureUsage usage = TEXTURE_STATIC);
+    
     RenderSurface* GetRenderSurface() const;
+    
+    tolua_readonly tolua_property__get_set RenderSurface* renderSurface;
 };