void UrhoRenderer::Initialize()
{
framework->RegisterRenderer(this);
// Connect to scene change signals.
framework->Scene()->SceneCreated.Connect(this, &UrhoRenderer::CreateGraphicsWorld);
framework->Scene()->SceneAboutToBeRemoved.Connect(this, &UrhoRenderer::RemoveGraphicsWorld);
// Enable the main (full-screen) viewport
Urho3D::Renderer* rend = GetSubsystem<Urho3D::Renderer>();
if (rend)
{
rend->SetNumViewports(1);
rend->SetViewport(0, new Urho3D::Viewport(context_));
// Track window position and screen mode changes to keep config up-to-date
SubscribeToEvent(Urho3D::E_WINDOWPOS, URHO3D_HANDLER(UrhoRenderer, HandleScreenModeChange));
SubscribeToEvent(Urho3D::E_SCREENMODE, URHO3D_HANDLER(UrhoRenderer, HandleScreenModeChange));
// Disable shadows completely for now on mobile devices, as the shadow bias is problematic, and it consumes GPU performance
// Also disable specular highlights for per-pixel lighting
if (Urho3D::GetPlatform() == "Android" || Urho3D::GetPlatform() == "iOS")
{
rend->SetDrawShadows(false);
rend->SetSpecularLighting(false);
}
}
}
void UrhoRenderer::Uninitialize()
{
framework->RegisterRenderer(0);
Urho3D::Renderer* rend = GetSubsystem<Urho3D::Renderer>();
// Let go of the viewport that we created. If done later at Urho Context destruction time, may cause a crash
if (rend)
rend->SetViewport(0, nullptr);
}
void UrhoRenderer::SetMainCamera(Entity *mainCameraEntity)
{
activeMainCamera = mainCameraEntity;
Urho3D::Camera *newActiveCamera = 0;
Camera *cameraComponent = mainCameraEntity ? mainCameraEntity->Component<Camera>().Get() : 0;
if (cameraComponent)
newActiveCamera = cameraComponent->UrhoCamera();
else
{
activeMainCamera.Reset();
if (mainCameraEntity)
LogWarning("Cannot activate camera '" + mainCameraEntity->Name() + "': It does not have a Camera component!");
}
if (mainCameraEntity && !mainCameraEntity->ParentScene()) // If the new to-be camera is not in a scene, don't add it as active.
{
LogWarning("Cannot activate camera \"" + mainCameraEntity->Name() + "\": It is not attached to a scene!");
activeMainCamera.Reset();
newActiveCamera = 0;
}
if (!activeMainCamera.Lock() || !newActiveCamera)
LogWarning("Setting main window camera to null!");
Urho3D::Renderer* rend = GetSubsystem<Urho3D::Renderer>();
if (!rend)
return; // In headless mode the renderer doesn't exist
Urho3D::Viewport* vp = rend->GetViewport(0);
if (vp)
{
vp->SetCamera(newActiveCamera);
vp->SetScene(mainCameraEntity->ParentScene()->Subsystem<GraphicsWorld>()->UrhoScene());
}
else
LogWarning("Could not set active camera, no viewport defined");
MainCameraChanged.Emit(mainCameraEntity);
}
void MainGameState::Start() {
std::cout << "starting main game " << std::endl;
Urho3D::ResourceCache *cache = GetSubsystem<Urho3D::ResourceCache>();
// We will be needing to load resources.
// All the resources used in this example comes with Urho3D.
// If the engine can't find them, check the ResourcePrefixPath.
// Seems like the mouse must be in cursor mode before creating the UI or it won't work.
// Let's use the default style that comes with Urho3D.
// GetSubsystem<Urho3D::UI>()->GetRoot()->AddChild(texts["FPS_text"]);
// Let's create some text to display.
// Add a button, just as an interactive UI sample.
// Note, must be part of the UI system before SetSize calls!
GetSubsystem<Urho3D::UI>()->GetRoot()->AddChild(ui_elements["side_bar"]);
// Now we can change the mouse mode.
// Let's setup a scene to render.
scene_ = new Urho3D::Scene(context_);
// Let the scene have an Octree component!
scene_->CreateComponent<Urho3D::Octree>();
// Let's add an additional scene component for fun.
scene_->CreateComponent<Urho3D::DebugRenderer>();
// Let's put some sky in there.
// Again, if the engine can't find these resources you need to check
// the "ResourcePrefixPath". These files come with Urho3D.
Urho3D::Node *skyNode = scene_->CreateChild("Sky");
skyNode->SetScale(500.0f); // The scale actually does not matter
Urho3D::Skybox *skybox = skyNode->CreateComponent<Urho3D::Skybox>();
skybox->SetModel(cache->GetResource<Urho3D::Model>("Models/Box.mdl"));
skybox->SetMaterial(cache->GetResource<Urho3D::Material>("Materials/Skybox.xml"));
int worldsize = 40;
Urho3D::SharedPtr<Urho3D::Node> bed_rock(new Urho3D::Node(context_));
for (int x = -worldsize; x < worldsize; x++) {
for (int y = -worldsize; y < worldsize; y++) {
Urho3D::Vector3 pos = Urho3D::Vector3(x, y, 0);
EntityNode *boxNode_ = new EntityNode(context_, &m_entity_manager);
bed_rock->AddChild(boxNode_);
boxNode_->SetPosition(pos);
Urho3D::StaticModel *boxObject = boxNode_->CreateComponent<Urho3D::StaticModel>();
boxObject->SetModel(cache->GetResource<Urho3D::Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Urho3D::Material>("Materials/Mushroom.xml"));
boxObject->SetCastShadows(true);
boxNode_->assign<terrain_type>("Stone", STONE);
}
}
z_levels.push_back(bed_rock);
for (int z = 1; z <= m_world_height; z++) {
Urho3D::SharedPtr<Urho3D::Node> cur_level(new Urho3D::Node(context_));
for (int x = -worldsize; x < worldsize; x++)
for (int y = -worldsize; y < worldsize; y++) {
/* if (sqrt(x * x + y * y) / 30 <
20 +
4 * sin(5 * sin(6 * (glm::dot(glm::normalize(glm::vec2(x, y)),
glm::vec2(0, 1)))))) */
double noise = m_noise_gen.noise_3D(0.02 * x, 0.002 * y, 0.02 * z) +
m_noise_gen.noise_3D(x, 4 * y, z);
std::cout << 2 - ((z) / (float)m_world_height) << " "
<< m_noise_gen.noise_2D(x, y) + 1 << std::endl;
if ((z / (float)m_world_height) <
0.1 * m_noise_gen.noise_2D(0.1 * x, y * 0.1) + 1) {
if (noise > 0.2) {
Urho3D::Vector3 pos = Urho3D::Vector3(x, y, z);
auto lol = new TerrainFactory(context_, &m_entity_manager,cache );
cur_level->AddChild(lol->create_stone_terrain(pos));
} else if (true) {
Urho3D::Vector3 pos = Urho3D::Vector3(x, y, z);
EntityNode *boxNode_ = new EntityNode(context_, &m_entity_manager);
cur_level->AddChild(boxNode_);
boxNode_->SetPosition(pos);
Urho3D::StaticModel *boxObject =
boxNode_->CreateComponent<Urho3D::StaticModel>();
boxObject->SetModel(cache->GetResource<Urho3D::Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Urho3D::Material>(
"Materials/NinjaSnowWar/Snow.xml"));
boxObject->SetCastShadows(true);
boxNode_->assign<terrain_type>("Stone", STONE);
}
}
}
z_levels.push_back(cur_level);
if (z > m_world_height - m_world_render_depth)
scene_->AddChild(cur_level);
}
std::cout << z_levels.size() << std::endl;
// We need a camera from which the viewport can render.
cameraNode_ = scene_->CreateChild("Camera");
m_camera = cameraNode_->CreateComponent<Urho3D::Camera>();
m_camera->SetFarClip(2000);
cameraNode_->Pitch(45);
cameraNode_->Yaw(180);
cameraNode_->SetPosition(Urho3D::Vector3(0, 0, m_world_height + m_world_render_depth));
// Create two lights
{
Urho3D::Node *lightNode = scene_->CreateChild("Light");
lightNode->SetPosition(Urho3D::Vector3(-5, 0, m_world_height + 20));
Urho3D::Light *light = lightNode->CreateComponent<Urho3D::Light>();
light->SetLightType(Urho3D::LIGHT_POINT);
light->SetRange(50);
light->SetBrightness(1.2);
light->SetColor(Urho3D::Color(1, .5, .8, 1));
light->SetCastShadows(true);
}
// add one to the camera node as well
// Now we setup the viewport. Ofcourse, you can have more than one!
Urho3D::Renderer *renderer = GetSubsystem<Urho3D::Renderer>();
Urho3D::SharedPtr<Urho3D::Viewport> viewport(
new Urho3D::Viewport(context_, scene_, cameraNode_->GetComponent<Urho3D::Camera>()));
renderer->SetViewport(0, viewport);
// We subscribe to the events we'd like to handle.
// In this example we will be showing what most of them do,
// but in reality you would only subscribe to the events
// you really need to handle.
// These are sort of subscribed in the order in which the engine
// would send the events. Read each handler method's comment for
// details.
std::cout << "start main done" << std::endl;
}
void GraphicsWorld::HandlePostRenderUpdate(StringHash /*eventType*/, VariantMap& /*eventData*/)
{
URHO3D_PROFILE(GraphicsWorld_PostRenderUpdate);
visibleEntities_.Clear();
Urho3D::Renderer* renderer = GetSubsystem<Urho3D::Renderer>();
Camera* cameraComp = renderer_->MainCameraComponent();
if (IsActive() && renderer)
{
Urho3D::Camera* cam = cameraComp ? cameraComp->UrhoCamera() : nullptr;
Urho3D::Viewport* vp = renderer->GetViewport(0);
Urho3D::View* view = vp ? vp->GetView() : nullptr;
if (view)
{
const Urho3D::PODVector<Urho3D::Drawable*>& geometries = view->GetGeometries();
for (uint i = 0; i < geometries.Size(); ++i)
{
// Verify that the geometry is in main camera view, as also eg. shadow geometries get listed
Urho3D::Drawable* dr = geometries[i];
if (!dr || !dr->IsInView(cam))
continue;
EntityWeakPtr ent(static_cast<Entity*>(dr->GetNode()->GetVar(entityLink).GetPtr()));
if (!ent)
continue;
visibleEntities_.Insert(ent);
}
}
}
// Perform visibility change tracking
for (HashMap<EntityWeakPtr, bool>::Iterator i = visibilityTrackedEntities_.Begin(); i != visibilityTrackedEntities_.End();)
{
// Check whether entity has expired
if (!i->first_)
i = visibilityTrackedEntities_.Erase(i);
else
{
bool current = visibleEntities_.Contains(i->first_);
bool prev = i->second_;
if (current != prev)
{
i->second_ = current;
if (current)
{
i->first_->EmitEnterView(cameraComp);
EntityEnterView.Emit(i->first_.Get());
}
else
{
i->first_->EmitLeaveView(cameraComp);
EntityLeaveView.Emit(i->first_.Get());
}
}
++i;
}
}
}
