Learn URHO3D with Real Code Examples

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Input/Input.h>
#include <Urho3D/Engine/Engine.h>
#include <Urho3D/UI/Text.h>

using namespace Urho3D;

class CounterApp : public Application {
public:
    CounterApp(Context* context) : Application(context), count(0) {}

    void Setup() override {}
    void Start() override {
        text = new Text(context_);
        text->SetText("Count: 0");
        text->SetFont(GetSubsystem<ResourceCache>()->GetFont("Fonts/Anonymous Pro.ttf"), 40);
        GetSubsystem<UI>()->GetRoot()->AddChild(text);
    }

    void Stop() override {}
    void Update(float timeStep) {
        Input* input = GetSubsystem<Input>();
        if (input->GetKeyDown(KEY_UP)) count++;
        if (input->GetKeyDown(KEY_DOWN)) count--;
        text->SetText("Count: " + String(count));
    }
private:
    int count;
    SharedPtr<Text> text;
};

URHO3D_DEFINE_APPLICATION_MAIN(CounterApp)

A minimal Urho3D C++ example demonstrating a counter incremented by keyboard input.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/StaticModel.h>
#include <Urho3D/Graphics/Model.h>
#include <Urho3D/Input/Input.h>
#include <Urho3D/Graphics/Renderer.h>

using namespace Urho3D;

class MoveCubeApp : public Application {
public:
    MoveCubeApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* node = scene_->CreateChild("Cube");
        node->CreateComponent<StaticModel>()->SetModel(GetSubsystem<ResourceCache>()->GetModel("Models/Box.mdl"));
        cubeNode = node;
    }

    void Stop() override {}
    void Update(float timeStep) override {
        cubeNode->Translate(Vector3(0,0,1)*timeStep);
    }

private:
    SharedPtr<Scene> scene_;
    Node* cubeNode;
};

URHO3D_DEFINE_APPLICATION_MAIN(MoveCubeApp)

Moves a cube forward continuously using Urho3D nodes.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/StaticModel.h>
#include <Urho3D/Graphics/Model.h>

using namespace Urho3D;

class RotateApp : public Application {
public:
    RotateApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* node = scene_->CreateChild("RotatingCube");
        node->CreateComponent<StaticModel>()->SetModel(GetSubsystem<ResourceCache>()->GetModel("Models/Box.mdl"));
        cubeNode = node;
    }

    void Update(float timeStep) override {
        cubeNode->Yaw(50*timeStep);
    }

private:
    SharedPtr<Scene> scene_;
    Node* cubeNode;
};

URHO3D_DEFINE_APPLICATION_MAIN(RotateApp)

Rotates an object around the Y-axis every frame.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Input/Input.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/StaticModel.h>
#include <Urho3D/Graphics/Model.h>

using namespace Urho3D;

class InputApp : public Application {
public:
    InputApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* node = scene_->CreateChild("Player");
        node->CreateComponent<StaticModel>()->SetModel(GetSubsystem<ResourceCache>()->GetModel("Models/Box.mdl"));
        playerNode = node;
    }

    void Update(float timeStep) override {
        Input* input = GetSubsystem<Input>();
        if(input->GetKeyDown(KEY_W)) playerNode->Translate(Vector3(0,0,1)*timeStep);
        if(input->GetKeyDown(KEY_S)) playerNode->Translate(Vector3(0,0,-1)*timeStep);
    }

private:
    SharedPtr<Scene> scene_;
    Node* playerNode;
};

URHO3D_DEFINE_APPLICATION_MAIN(InputApp)

Responds to keyboard input to move a character.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/UI/Button.h>
#include <Urho3D/UI/UI.h>
#include <Urho3D/UI/Text.h>

using namespace Urho3D;

class UIButtonApp : public Application {
public:
    UIButtonApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        Button* button = GetSubsystem<UI>()->GetRoot()->CreateChild<Button>();
        button->SetPosition(300,200);
        button->SetSize(200,80);
        Text* buttonText = button->CreateChild<Text>();
        buttonText->SetText("Click Me");
        buttonText->SetFont(GetSubsystem<ResourceCache>()->GetFont("Fonts/Anonymous Pro.ttf"),40);
        button->SubscribeToEvent(button, E_RELEASED, URHO3D_HANDLER(UIButtonApp, HandleButton));
    }

    void HandleButton(StringHash eventType, VariantMap& eventData) {
        URHO3D_LOGINFO("Button Clicked!");
    }
};

URHO3D_DEFINE_APPLICATION_MAIN(UIButtonApp)

Creates a simple UI button and responds to click events.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Graphics/Light.h>
#include <Urho3D/Scene/Scene.h>

using namespace Urho3D;

class LightApp : public Application {
public:
    LightApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* lightNode = scene_->CreateChild("Light");
        Light* light = lightNode->CreateComponent<Light>();
        light->SetLightType(LIGHT_DIRECTIONAL);
        lightNode->SetDirection(Vector3(-1,-1,0));
    }

private:
    SharedPtr<Scene> scene_;
};

URHO3D_DEFINE_APPLICATION_MAIN(LightApp)

Adds a directional light to the scene.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Graphics/Camera.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/StaticModel.h>
#include <Urho3D/Graphics/Model.h>

using namespace Urho3D;

class CameraFollowApp : public Application {
public:
    CameraFollowApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* playerNode = scene_->CreateChild("Player");
        playerNode->CreateComponent<StaticModel>()->SetModel(GetSubsystem<ResourceCache>()->GetModel("Models/Box.mdl"));

        cameraNode = scene_->CreateChild("Camera");
        Camera* camera = cameraNode->CreateComponent<Camera>();
    }

    void Update(float timeStep) override {
        cameraNode->SetPosition(Vector3(0,50,-100)+Vector3(0,0,0));
    }

private:
    SharedPtr<Scene> scene_;
    Node* cameraNode;
};

URHO3D_DEFINE_APPLICATION_MAIN(CameraFollowApp)

Makes the camera follow a moving object.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Particles/ParticleEmitter.h>

using namespace Urho3D;

class ParticleApp : public Application {
public:
    ParticleApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* node = scene_->CreateChild("Emitter");
        node->CreateComponent<ParticleEmitter>()->SetEffect(GetSubsystem<ResourceCache>()->GetParticleEffect("Particle/Fire.xml"));
    }

private:
    SharedPtr<Scene> scene_;
};

URHO3D_DEFINE_APPLICATION_MAIN(ParticleApp)

Attaches a particle emitter to a node.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Physics/PhysicsWorld.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/StaticModel.h>
#include <Urho3D/Graphics/Model.h>

using namespace Urho3D;

class PhysicsApp : public Application {
public:
    PhysicsApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* cube = scene_->CreateChild("Cube");
        cube->CreateComponent<StaticModel>()->SetModel(GetSubsystem<ResourceCache>()->GetModel("Models/Box.mdl"));
        cube->CreateComponent<RigidBody>();
        cube->CreateComponent<CollisionShape>()->SetBox(Vector3::ONE);
    }

private:
    SharedPtr<Scene> scene_;
};

URHO3D_DEFINE_APPLICATION_MAIN(PhysicsApp)

Applies physics to a cube object.

#include <Urho3D/Engine/Application.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/AnimatedModel.h>
#include <Urho3D/Animation/AnimationController.h>

using namespace Urho3D;

class AnimatedApp : public Application {
public:
    AnimatedApp(Context* context) : Application(context) {}

    void Setup() override {}
    void Start() override {
        scene_ = new Scene(context_);
        Node* node = scene_->CreateChild("Robot");
        AnimatedModel* model = node->CreateComponent<AnimatedModel>();
        model->SetModel(GetSubsystem<ResourceCache>()->GetModel("Models/Jack.mdl"));
        node->CreateComponent<AnimationController>()->PlayExclusive("Models/Jack_Walk.ani",0,true);
    }

private:
    SharedPtr<Scene> scene_;
};

URHO3D_DEFINE_APPLICATION_MAIN(AnimatedApp)

Animates a model using an animation controller.