heXoCam::heXoCam(Context *context, MasterControl *masterControl):
Object(context),
yaw_{0.0f},
pitch_{0.0f},
yawDelta_{0.0f},
pitchDelta_{0.0f},
forceMultiplier{1.0f}
{
masterControl_ = masterControl;
SubscribeToEvent(E_SCENEUPDATE, URHO3D_HANDLER(heXoCam, HandleSceneUpdate));
rootNode_ = masterControl_->world.scene->CreateChild("Camera");
Node* leftEye = rootNode_->CreateChild("Left Eye");
leftEye->SetPosition(Vector3::LEFT);
stereoCam_.first_ = leftEye->CreateComponent<Camera>();
Node* rightEye = rootNode_->CreateChild("Right Eye");
rightEye->SetPosition(Vector3::RIGHT);
stereoCam_.second_ = rightEye->CreateComponent<Camera>();
camera_ = rootNode_->CreateComponent<Camera>();
camera_->SetFarClip(128.0f);
rootNode_->SetPosition(Vector3(0.0f, 42.0f, -23.0f));
rootNode_->SetRotation(Quaternion(65.0f, 0.0f, 0.0f));
rigidBody_ = rootNode_->CreateComponent<RigidBody>();
rigidBody_->SetAngularDamping(10.0f);
CollisionShape* collisionShape = rootNode_->CreateComponent<CollisionShape>();
collisionShape->SetSphere(0.1f);
rigidBody_->SetMass(1.0f);
SetupViewport();
}
bool Texture2D::SetSize(int width, int height, unsigned format, TextureUsage usage)
{
if (width <= 0 || height <= 0)
{
URHO3D_LOGERROR("Zero or negative texture dimensions");
return false;
}
// Delete the old rendersurface if any
renderSurface_.Reset();
usage_ = usage;
if (usage_ == TEXTURE_RENDERTARGET || usage_ == TEXTURE_DEPTHSTENCIL)
{
renderSurface_ = new RenderSurface(this);
// Clamp mode addressing by default, nearest filtering, and mipmaps disabled
addressMode_[COORD_U] = ADDRESS_CLAMP;
addressMode_[COORD_V] = ADDRESS_CLAMP;
filterMode_ = FILTER_NEAREST;
requestedLevels_ = 1;
}
if (usage_ == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(Texture2D, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = width;
height_ = height;
format_ = format;
return Create();
}
DebugRenderer::DebugRenderer(Context* context) :
Component(context)
{
vertexBuffer_ = new VertexBuffer(context_);
SubscribeToEvent(E_ENDFRAME, URHO3D_HANDLER(DebugRenderer, HandleEndFrame));
}
/** Support objects created, start application specific content. */
void UApp::Start() {
// the mouse must be in cursor mode before setting the UI.
auto input_ = GetSubsystem< Urho3D::Input >();
input_->SetMouseVisible(true);
// resources origin.
cache_ = GetSubsystem< Urho3D::ResourceCache >();
// use the default style from Urho3D.
GetSubsystem< Urho3D::UI >()->GetRoot()->SetDefaultStyle(
cache_->GetResource< Urho3D::XMLFile >("UI/DefaultStyle.xml"));
// grab mouse
input_->SetMouseGrabbed(true);
// setup scene to render.
scene_ = new Urho3D::Scene(context_);
scene_->CreateComponent< Urho3D::Octree >();
// Create the light
{
auto lightNode = scene_->CreateChild("Light");
lightNode->SetPosition(Urho3D::Vector3(6, 6, -20));
auto light = lightNode->CreateComponent< Urho3D::Light >();
light->SetLightType(Urho3D::LIGHT_POINT);
light->SetRange(1000);
}
// setup camera
{
auto cameraNode_ = scene_->CreateChild("Camera");
cameraNode_->SetPosition(Urho3D::Vector3(6, 6, -20));
auto camera_ = cameraNode_->CreateComponent< Urho3D::Camera >();
camera_->SetFarClip(2000);
auto renderer = GetSubsystem< Urho3D::Renderer >();
Urho3D::SharedPtr< Urho3D::Viewport > viewport(new Urho3D::Viewport(context_, scene_, camera_));
renderer->SetViewport(0, viewport);
}
// start the game
game.start();
// subscribe to events
SubscribeToEvent(Urho3D::E_UPDATE,URHO3D_HANDLER(UApp,HandleUpdate));
SubscribeToEvent(Urho3D::E_KEYDOWN,URHO3D_HANDLER(UApp,HandleKeyDown));
SubscribeToEvent(Urho3D::E_KEYUP,URHO3D_HANDLER(UApp,HandleKeyUp));
}
void HelloGUI::InitWindow()
{
// Create the Window and add it to the UI's root node
window_ = new Window(context_);
uiRoot_->AddChild(window_);
// Set Window size and layout settings
window_->SetMinWidth(384);
window_->SetLayout(LM_VERTICAL, 6, IntRect(6, 6, 6, 6));
window_->SetAlignment(HA_CENTER, VA_CENTER);
window_->SetName("Window");
// Create Window 'titlebar' container
auto* titleBar = new UIElement(context_);
titleBar->SetMinSize(0, 24);
titleBar->SetVerticalAlignment(VA_TOP);
titleBar->SetLayoutMode(LM_HORIZONTAL);
// Create the Window title Text
auto* windowTitle = new Text(context_);
windowTitle->SetName("WindowTitle");
windowTitle->SetText("Hello GUI!");
// Create the Window's close button
auto* buttonClose = new Button(context_);
buttonClose->SetName("CloseButton");
// Add the controls to the title bar
titleBar->AddChild(windowTitle);
titleBar->AddChild(buttonClose);
// Add the title bar to the Window
window_->AddChild(titleBar);
// Apply styles
window_->SetStyleAuto();
windowTitle->SetStyleAuto();
buttonClose->SetStyle("CloseButton");
// Subscribe to buttonClose release (following a 'press') events
SubscribeToEvent(buttonClose, E_RELEASED, URHO3D_HANDLER(HelloGUI, HandleClosePressed));
// Subscribe also to all UI mouse clicks just to see where we have clicked
SubscribeToEvent(E_UIMOUSECLICK, URHO3D_HANDLER(HelloGUI, HandleControlClicked));
}
bool TextureCube::SetSize(int size, unsigned format, TextureUsage usage, int multiSample)
{
if (size <= 0)
{
URHO3D_LOGERROR("Zero or negative cube texture size");
return false;
}
if (usage == TEXTURE_DEPTHSTENCIL)
{
URHO3D_LOGERROR("Depth-stencil usage not supported for cube textures");
return false;
}
multiSample = Clamp(multiSample, 1, 16);
if (multiSample > 1 && usage < TEXTURE_RENDERTARGET)
{
URHO3D_LOGERROR("Multisampling is only supported for rendertarget cube textures");
return false;
}
// Delete the old rendersurfaces if any
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i].Reset();
faceMemoryUse_[i] = 0;
}
usage_ = usage;
if (usage == TEXTURE_RENDERTARGET)
{
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i] = new RenderSurface(this);
#ifdef URHO3D_OPENGL
renderSurfaces_[i]->target_ = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
#endif
}
// Nearest filtering by default
filterMode_ = FILTER_NEAREST;
}
if (usage == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(TextureCube, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = size;
height_ = size;
depth_ = 1;
format_ = format;
multiSample_ = multiSample;
autoResolve_ = multiSample > 1;
return Create();
}
/// Called before the first update. At this point all other components of the node should exist. Will also be called if update events are not wanted; in that case the event is immediately unsubscribed afterward.
void PlayerInterface::DelayedStart()
{
// Show UI
// Ensure UI matches size correctly
// Subscribe to events
SubscribeToEvent(Urho3D::E_POSTRENDERUPDATE, URHO3D_HANDLER(PlayerInterface, HandlePostRenderUpdate));
}
WindowConfirmExit::WindowConfirmExit(Context *) :
lWindow()
{
SET_VERTICAL_LAYOUT_0_6(this);
SharedPtr<Label> label(Label::Create("Exit in OS?"));
AddChild(label);
SharedPtr<UIElement> layer(CreateChild<UIElement>());
SET_HORIZONTAL_LAYOUT_6_6(layer);
buttonOk = new ButtonMain(layer, "Ok");
buttonCancel = new ButtonMain(layer, "Cancel");
SubscribeToEvent(buttonOk, Urho3D::E_RELEASED, URHO3D_HANDLER(WindowConfirmExit, HandleButtonRelease));
SubscribeToEvent(buttonCancel, Urho3D::E_RELEASED, URHO3D_HANDLER(WindowConfirmExit, HandleButtonRelease));
AddChild(layer);
}
Pickup::Pickup(Context *context, MasterControl *masterControl):
SceneObject(context, masterControl),
sinceLastPickup_{0.0f},
chaoInterval_{Random(23.0f, 100.0f)}
{
rootNode_->SetName("Pickup");
graphicsNode_ = rootNode_->CreateChild("Graphics");
model_ = graphicsNode_->CreateComponent<StaticModel>();
rootNode_->SetScale(0.8f);
rootNode_->SetEnabledRecursive(false);
rigidBody_ = rootNode_->CreateComponent<RigidBody>();
rigidBody_->SetRestitution(0.666f);
rigidBody_->SetMass(0.666f);
rigidBody_->SetLinearFactor(Vector3::ONE - Vector3::UP);
rigidBody_->SetLinearDamping(0.5f);
rigidBody_->SetFriction(0.0f);
rigidBody_->SetAngularFactor(Vector3::UP);
rigidBody_->SetAngularDamping(0.0f);
rigidBody_->ApplyTorque(Vector3::UP * 32.0f);
rigidBody_->SetLinearRestThreshold(0.0f);
rigidBody_->SetAngularRestThreshold(0.0f);
CollisionShape* collisionShape = rootNode_->CreateComponent<CollisionShape>();
collisionShape->SetSphere(1.5f);
masterControl_->tileMaster_->AddToAffectors(WeakPtr<Node>(rootNode_), WeakPtr<RigidBody>(rigidBody_));
triggerNode_ = masterControl_->world.scene->CreateChild("PickupTrigger");
triggerBody_ = triggerNode_->CreateComponent<RigidBody>();
triggerBody_->SetTrigger(true);
triggerBody_->SetMass(0.0f);
triggerBody_->SetLinearFactor(Vector3::ZERO);
CollisionShape* triggerShape = triggerNode_->CreateComponent<CollisionShape>();
triggerShape->SetSphere(2.5f);
particleEmitter_ = graphicsNode_->CreateComponent<ParticleEmitter>();
particleEmitter_->SetEffect(masterControl_->cache_->GetTempResource<ParticleEffect>("Resources/Particles/Shine.xml"));
SubscribeToEvent(triggerNode_, E_NODECOLLISIONSTART, URHO3D_HANDLER(Pickup, HandleTriggerStart));
SubscribeToEvent(E_SCENEUPDATE, URHO3D_HANDLER(Pickup, HandleSceneUpdate));
}
void MainGameState::create_right_click_menu(int mouse_x, int mouse_y) {
Urho3D::Window *menu = ui_factory.create_window("right_click_menu");
ui_factory.m_sub_root_map["right_click_menu"]->AddChild(menu);
menu->SetLayout(Urho3D::LM_VERTICAL);
std::cout << mouse_x << " " << mouse_y << std::endl;
ui_factory.m_sub_root_map["right_click_menu"]->SetPosition(mouse_x, mouse_y);
Urho3D::UIElement *button_row = ui_factory.create_row(0);
menu->AddChild(button_row);
Urho3D::UIElement *chop = ui_factory.create_button("Chop", 30, 30);
SubscribeToEvent(chop, Urho3D::E_RELEASED, URHO3D_HANDLER(MainGameState, start_select_chop));
button_row->AddChild(chop);
Urho3D::UIElement *gather = ui_factory.create_button("Gather", 30, 30);
button_row->AddChild(gather);
Urho3D::UIElement *pl = ui_factory.create_button("Placeholder", 30, 30);
SubscribeToEvent(gather, Urho3D::E_RELEASED,
URHO3D_HANDLER(MainGameState, start_select_gather));
button_row->AddChild(pl);
}
void MoveController::SetUpJumpSensor() {
sensor = node_->CreateChild("jump_sensor");
const auto collision = node_->GetDerivedComponent<CollisionBox2D>();
sensor->SetPosition2D(0.0, -collision->GetSize().y_ / 2);
const auto rigidBody = sensor->CreateComponent<RigidBody2D>();
rigidBody->SetAllowSleep(false);
rigidBody->SetBodyType(BT_DYNAMIC);
rigidBody->SetMass(0.0);
rigidBody->SetGravityScale(0.0f);
rigidBody->SetVolatilePosition(true);
CollisionBox2D *box = sensor->CreateComponent<CollisionBox2D>();
box->SetTrigger(true);
box->SetGroupIndex(-((short) node_->GetID()));
box->SetSize(collision->GetSize().x_ * 0.7f, 0.01f);
sensor->SubscribeToEvent(E_PHYSICSBEGINCONTACT2D, URHO3D_HANDLER(MoveController, BeginSense));
sensor->SubscribeToEvent(E_PHYSICSENDCONTACT2D, URHO3D_HANDLER(MoveController, StopSense));
}
void RotateTo::Start()
{
//SubscribeToURHO3D_EVENT(E_SETCLIENTMODELNODE, URHO3D_HANDLER(RotateTo, HandleSetClientModelNode));
SubscribeToEvent(E_ROTATEMODELNODE, URHO3D_HANDLER(RotateTo, HandleRotateModelNode));
/*VariantMap vm;
vm[GetClientModelNode::P_NODE] = node_;
SendURHO3D_EVENT(E_GETCLIENTMODELNODE, vm);*/
SetUpdateEventMask(USE_FIXEDUPDATE);
}
bool Texture2D::SetSize(int width, int height, unsigned format, TextureUsage usage, int multiSample, bool autoResolve)
{
if (width <= 0 || height <= 0)
{
URHO3D_LOGERROR("Zero or negative texture dimensions");
return false;
}
multiSample = Clamp(multiSample, 1, 16);
if (multiSample == 1)
autoResolve = false;
else if (multiSample > 1 && usage < TEXTURE_RENDERTARGET)
{
URHO3D_LOGERROR("Multisampling is only supported for rendertarget or depth-stencil textures");
return false;
}
// Disable mipmaps if multisample & custom resolve
if (multiSample > 1 && autoResolve == false)
requestedLevels_ = 1;
// Delete the old rendersurface if any
renderSurface_.Reset();
usage_ = usage;
if (usage >= TEXTURE_RENDERTARGET)
{
renderSurface_ = new RenderSurface(this);
// Clamp mode addressing by default and nearest filtering
addressModes_[COORD_U] = ADDRESS_CLAMP;
addressModes_[COORD_V] = ADDRESS_CLAMP;
filterMode_ = FILTER_NEAREST;
}
if (usage == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(Texture2D, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = width;
height_ = height;
format_ = format;
depth_ = 1;
multiSample_ = multiSample;
autoResolve_ = autoResolve;
return Create();
}
void StaticModel::SetModel(Model* model)
{
if (model == model_)
return;
// If script erroneously calls StaticModel::SetModel on an AnimatedModel, warn and redirect
if (GetType() == AnimatedModel::GetTypeStatic())
{
URHO3D_LOGWARNING("StaticModel::SetModel() called on AnimatedModel. Redirecting to AnimatedModel::SetModel()");
AnimatedModel* animatedModel = static_cast<AnimatedModel*>(this);
animatedModel->SetModel(model);
return;
}
// Unsubscribe from the reload event of previous model (if any), then subscribe to the new
if (model_)
UnsubscribeFromEvent(model_, E_RELOADFINISHED);
model_ = model;
if (model)
{
SubscribeToEvent(model, E_RELOADFINISHED, URHO3D_HANDLER(StaticModel, HandleModelReloadFinished));
// Copy the subgeometry & LOD level structure
SetNumGeometries(model->GetNumGeometries());
const Vector<Vector<SharedPtr<Geometry> > >& geometries = model->GetGeometries();
const PODVector<Vector3>& geometryCenters = model->GetGeometryCenters();
const Matrix3x4* worldTransform = node_ ? &node_->GetWorldTransform() : (const Matrix3x4*)0;
for (unsigned i = 0; i < geometries.Size(); ++i)
{
batches_[i].worldTransform_ = worldTransform;
geometries_[i] = geometries[i];
geometryData_[i].center_ = geometryCenters[i];
}
SetBoundingBox(model->GetBoundingBox());
ResetLodLevels();
}
else
{
SetNumGeometries(0);
SetBoundingBox(BoundingBox());
}
MarkNetworkUpdate();
}
void StaticModel::SetModel(Model* model)
{
if (model == model_)
return;
if (!node_)
{
URHO3D_LOGERROR("Can not set model while model component is not attached to a scene node");
return;
}
// Unsubscribe from the reload event of previous model (if any), then subscribe to the new
if (model_)
UnsubscribeFromEvent(model_, E_RELOADFINISHED);
model_ = model;
if (model)
{
SubscribeToEvent(model, E_RELOADFINISHED, URHO3D_HANDLER(StaticModel, HandleModelReloadFinished));
// Copy the subgeometry & LOD level structure
SetNumGeometries(model->GetNumGeometries());
const ea::vector<ea::vector<ea::shared_ptr<Geometry> > >& geometries = model->GetGeometries();
const ea::vector<Vector3>& geometryCenters = model->GetGeometryCenters();
const Matrix3x4* worldTransform = node_ ? &node_->GetWorldTransform() : nullptr;
for (unsigned i = 0; i < geometries.size(); ++i)
{
batches_[i].worldTransform_ = worldTransform;
geometries_[i] = geometries[i];
geometryData_[i].center_ = geometryCenters[i];
}
SetBoundingBox(model->GetBoundingBox());
ResetLodLevels();
}
else
{
SetNumGeometries(0);
SetBoundingBox(BoundingBox());
}
MarkNetworkUpdate();
}
bool TextureCube::SetSize(int size, unsigned format, TextureUsage usage)
{
if (size <= 0)
{
URHO3D_LOGERROR("Zero or negative cube texture size");
return false;
}
if (usage == TEXTURE_DEPTHSTENCIL)
{
URHO3D_LOGERROR("Depth-stencil usage not supported for cube maps");
return false;
}
// Delete the old rendersurfaces if any
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i].Reset();
faceMemoryUse_[i] = 0;
}
usage_ = usage;
if (usage_ == TEXTURE_RENDERTARGET)
{
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
renderSurfaces_[i] = new RenderSurface(this);
// Nearest filtering and mipmaps disabled by default
filterMode_ = FILTER_NEAREST;
requestedLevels_ = 1;
}
if (usage_ == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(TextureCube, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = size;
height_ = size;
format_ = format;
return Create();
}
GraphicsWorld::GraphicsWorld(UrhoRenderer* owner, Scene* scene) :
Object(owner->GetContext()),
framework_(scene->GetFramework()),
renderer_(owner),
scene_(scene)
{
urhoScene_ = new Urho3D::Scene(context_);
urhoScene_->CreateComponent<Urho3D::Octree>();
urhoScene_->CreateComponent<Urho3D::DebugRenderer>();
// Set a default ambient color that matches the default ambient color of EnvironmentLight, in case there is no environmentlight component.
Urho3D::Zone* zone = urhoScene_->CreateComponent<Urho3D::Zone>();
// Just set up a large bounding zone for the whole scene
/// \todo The octree size is not adjusted yet, so objects outside the default octree range always end up in the root octqant
zone->SetBoundingBox(Urho3D::BoundingBox(-100000.0f, 100000.0f));
zone->SetAmbientColor(DefaultSceneAmbientLightColor());
SetDefaultSceneFog();
SubscribeToEvent(Urho3D::E_POSTRENDERUPDATE, URHO3D_HANDLER(GraphicsWorld, HandlePostRenderUpdate));
}
void Text::SetAutoLocalizable(bool enable)
{
if (enable != autoLocalizable_)
{
autoLocalizable_ = enable;
if (enable)
{
stringId_ = text_;
auto* l10n = GetSubsystem<Localization>();
text_ = l10n->Get(stringId_);
SubscribeToEvent(E_CHANGELANGUAGE, URHO3D_HANDLER(Text, HandleChangeLanguage));
}
else
{
text_ = stringId_;
stringId_ = "";
UnsubscribeFromEvent(E_CHANGELANGUAGE);
}
DecodeToUnicode();
ValidateSelection();
UpdateText();
}
}
UIComponent::UIComponent(Context* context)
: Component(context),
viewportIndex_(0)
{
texture_ = context_->CreateObject<Texture2D>();
texture_->SetFilterMode(FILTER_BILINEAR);
texture_->SetAddressMode(COORD_U, ADDRESS_CLAMP);
texture_->SetAddressMode(COORD_V, ADDRESS_CLAMP);
texture_->SetNumLevels(1); // No mipmaps
rootElement_ = context_->CreateObject<UIElement3D>();
rootElement_->SetTraversalMode(TM_BREADTH_FIRST);
rootElement_->SetEnabled(true);
material_ = context_->CreateObject<Material>();
material_->SetTechnique(0, GetSubsystem<ResourceCache>()->GetResource<Technique>("Techniques/Diff.xml"));
material_->SetTexture(TU_DIFFUSE, texture_);
SubscribeToEvent(rootElement_, E_RESIZED, URHO3D_HANDLER(UIComponent, OnElementResized));
// Triggers resizing of texture.
rootElement_->SetRenderTexture(texture_);
rootElement_->SetSize(UICOMPONENT_DEFAULT_TEXTURE_SIZE, UICOMPONENT_DEFAULT_TEXTURE_SIZE);
}
void MyGame::SubscribeToEvents() {
// Subscribe HandleUpdate() function for processing update events
SubscribeToEvent(E_UPDATE, URHO3D_HANDLER(MyGame, HandleUpdate));
}
void Gravity::Start()
{
SubscribeToEvent(E_GETCLIENTGRAVITY, URHO3D_HANDLER(Gravity, HandleGetGravity));
}
void HelloWorld::SubscribeToEvents()
{
// Subscribe HandleUpdate() function for processing update events
SubscribeToEvent(E_UPDATE, URHO3D_HANDLER(HelloWorld, HandleUpdate));
}
void Sky::Update()
{
if (!urhoNode_)
return;
Urho3D::ResourceCache* cache = GetSubsystem<Urho3D::ResourceCache>();
if (material_ != nullptr && textureRefListListener_->Assets().Size() < 6)
{
// Use material as is
///\todo Remove diff color setting once DefaultOgreMaterialProcessor sets it properly.
material_->UrhoMaterial()->SetShaderParameter("MatDiffColor", Urho3D::Vector4(1, 1, 1, 1));
material_->UrhoMaterial()->SetCullMode(Urho3D::CULL_NONE);
urhoNode_->GetComponent<Urho3D::Skybox>()->SetMaterial(material_->UrhoMaterial());
return;
}
Vector<SharedPtr<Urho3D::Image> > images(6);
Vector<AssetPtr> textureAssets = textureRefListListener_->Assets();
int numLoadedImages = 0;
for(uint mi=0; mi<textureAssets.Size(); ++mi)
{
AssetPtr &TextureAssetPtr = textureAssets[mi];
BinaryAsset *binaryAsset = dynamic_cast<BinaryAsset*>(TextureAssetPtr.Get());
TextureAsset *textureAsset = dynamic_cast<TextureAsset*>(TextureAssetPtr.Get());
if ((textureAsset || binaryAsset) && TextureAssetPtr->IsLoaded())
{
SharedPtr<Urho3D::Image> image = SharedPtr<Urho3D::Image>(new Urho3D::Image(GetContext()));
Vector<u8> data;
if (binaryAsset)
data = binaryAsset->data;
///\todo Loading raw image data from disksource leaves an extra GPU texture resource unused.
else if (!LoadFileToVector(textureAsset->DiskSource(), data))
continue;
Urho3D::MemoryBuffer imageBuffer(&data[0], data.Size());
if (!image->Load(imageBuffer))
continue;
images[mi] = image;
numLoadedImages++;
}
}
if (numLoadedImages == 6)
{
// Reuse the previous cube texture if possible
SharedPtr<Urho3D::TextureCube> textureCube = (cubeTexture_.Get() == nullptr) ? SharedPtr<Urho3D::TextureCube>(new Urho3D::TextureCube(GetContext())) : cubeTexture_.Lock();
const Urho3D::CubeMapFace faces[6] = { Urho3D::FACE_POSITIVE_X, Urho3D::FACE_NEGATIVE_X, Urho3D::FACE_POSITIVE_Y, Urho3D::FACE_NEGATIVE_Y, Urho3D::FACE_POSITIVE_Z, Urho3D::FACE_NEGATIVE_Z };
const int faceOrder[6] = { 3, 2, 4, 5, 0, 1 };
for (size_t i=0 ; i<images.Size() ; ++i)
if (images[faceOrder[i]] != nullptr)
textureCube->SetData(faces[i], images[faceOrder[i]]);
// Remember the created texture for tracking device loss
cubeTexture_ = textureCube;
SubscribeToEvent(Urho3D::E_DEVICERESET, URHO3D_HANDLER(Sky, HandleDeviceReset));
SharedPtr<Urho3D::Material> material;
if (material_)
material = material_->UrhoMaterial()->Clone();
else
material = SharedPtr<Urho3D::Material>(new Urho3D::Material(GetContext()));
material->SetCullMode(Urho3D::CULL_NONE);
material->SetTechnique(0, cache->GetResource<Urho3D::Technique>("Techniques/DiffSkybox.xml"));
material->SetTexture(Urho3D::TU_DIFFUSE, textureCube);
///\todo Remove diff color setting once DefaultOgreMaterialProcessor sets it properly.
material->SetShaderParameter("MatDiffColor", Urho3D::Vector4(1, 1, 1, 1));
urhoNode_->GetComponent<Urho3D::Skybox>()->SetMaterial(material);
}
else
{
if (GetFramework()->HasCommandLineParameter("--useErrorAsset"))
{
urhoNode_->GetComponent<Urho3D::Skybox>()->SetMaterial(cache->GetResource<Urho3D::Material>("Materials/AssetLoadError.xml"));
}
}
}
void Spire::Set(Vector3 position)
{
shotInterval_ = initialShotInterval_;
Enemy::Set(position);
SubscribeToEvent(E_SCENEPOSTUPDATE, URHO3D_HANDLER(Spire, HandleSpireUpdate));
}
PlanetComponent::PlanetComponent(Context* context) : LogicComponent(context)
{
SetUpdateEventMask(USE_FIXEDUPDATE | USE_UPDATE);
SubscribeToEvent(E_POSTRENDERUPDATE, URHO3D_HANDLER(PlanetComponent, HandlePostRenderUpdate));
}
//---------------------------------------------------------------------------------------------------------------------------------------------------
void TerminalTWT::SubscribeToEvents()
{
SubscribeToEvent(E_POSTUPDATE, URHO3D_HANDLER(TerminalTWT, HandlePostUpdate));
}
void MainGameState::subscribe_to_events() {
SubscribeToEvent(Urho3D::E_MOUSEBUTTONUP, URHO3D_HANDLER(MainGameState, HandleMouseButtonUp));
SubscribeToEvent(Urho3D::E_MOUSEBUTTONDOWN,
URHO3D_HANDLER(MainGameState, HandleMouseButtonDown));
SubscribeToEvent(Urho3D::E_MOUSEWHEEL, URHO3D_HANDLER(MainGameState, HandleMouseWheel));
}
void Mortal::Start() {
SubscribeToEvent(node_, EVENT_RECEIVE_DAMAGE, URHO3D_HANDLER(Mortal, ReceiveDamage));
}
void RigidBody::AddBodyToWorld()
{
if (!physicsWorld_)
return;
URHO3D_PROFILE(AddBodyToWorld);
if (mass_ < 0.0f)
mass_ = 0.0f;
if (body_)
RemoveBodyFromWorld();
else
{
// Correct inertia will be calculated below
btVector3 localInertia(0.0f, 0.0f, 0.0f);
body_ = new btRigidBody(mass_, this, shiftedCompoundShape_, localInertia);
body_->setUserPointer(this);
// Check for existence of the SmoothedTransform component, which should be created by now in network client mode.
// If it exists, subscribe to its change events
smoothedTransform_ = GetComponent<SmoothedTransform>();
if (smoothedTransform_)
{
SubscribeToEvent(smoothedTransform_, E_TARGETPOSITION, URHO3D_HANDLER(RigidBody, HandleTargetPosition));
SubscribeToEvent(smoothedTransform_, E_TARGETROTATION, URHO3D_HANDLER(RigidBody, HandleTargetRotation));
}
// Check if CollisionShapes already exist in the node and add them to the compound shape.
// Do not update mass yet, but do it once all shapes have been added
PODVector<CollisionShape*> shapes;
node_->GetComponents<CollisionShape>(shapes);
for (PODVector<CollisionShape*>::Iterator i = shapes.Begin(); i != shapes.End(); ++i)
(*i)->NotifyRigidBody(false);
// Check if this node contains Constraint components that were waiting for the rigid body to be created, and signal them
// to create themselves now
PODVector<Constraint*> constraints;
node_->GetComponents<Constraint>(constraints);
for (PODVector<Constraint*>::Iterator i = constraints.Begin(); i != constraints.End(); ++i)
(*i)->CreateConstraint();
}
UpdateMass();
UpdateGravity();
int flags = body_->getCollisionFlags();
if (trigger_)
flags |= btCollisionObject::CF_NO_CONTACT_RESPONSE;
else
flags &= ~btCollisionObject::CF_NO_CONTACT_RESPONSE;
if (kinematic_)
flags |= btCollisionObject::CF_KINEMATIC_OBJECT;
else
flags &= ~btCollisionObject::CF_KINEMATIC_OBJECT;
body_->setCollisionFlags(flags);
body_->forceActivationState(kinematic_ ? DISABLE_DEACTIVATION : ISLAND_SLEEPING);
if (!IsEnabledEffective())
return;
btDiscreteDynamicsWorld* world = physicsWorld_->GetWorld();
world->addRigidBody(body_, (short)collisionLayer_, (short)collisionMask_);
inWorld_ = true;
readdBody_ = false;
if (mass_ > 0.0f)
Activate();
else
{
SetLinearVelocity(Vector3::ZERO);
SetAngularVelocity(Vector3::ZERO);
}
}
void Urho3DPlayer::Start()
{
// Reattempt reading the command line now on Web platform
#ifdef __EMSCRIPTEN__
if (GetArguments().Empty())
{
SharedPtr<File> commandFile = GetSubsystem<ResourceCache>()->GetFile("CommandLine.txt", false);
if (commandFile)
{
String commandLine = commandFile->ReadLine();
commandFile->Close();
ParseArguments(commandLine, false);
}
}
GetScriptFileName();
if (scriptFileName_.Empty())
{
ErrorExit("Script file name not specified; cannot proceed");
return;
}
#endif
String extension = GetExtension(scriptFileName_);
if (extension != ".lua" && extension != ".luc")
{
#ifdef URHO3D_ANGELSCRIPT
// Instantiate and register the AngelScript subsystem
context_->RegisterSubsystem(new Script(context_));
// Hold a shared pointer to the script file to make sure it is not unloaded during runtime
scriptFile_ = GetSubsystem<ResourceCache>()->GetResource<ScriptFile>(scriptFileName_);
/// \hack If we are running the editor, also instantiate Lua subsystem to enable editing Lua ScriptInstances
#ifdef URHO3D_LUA
if (scriptFileName_.Contains("Editor.as", false))
context_->RegisterSubsystem(new LuaScript(context_));
#endif
// If script loading is successful, proceed to main loop
if (scriptFile_ && scriptFile_->Execute("void Start()"))
{
// Subscribe to script's reload event to allow live-reload of the application
SubscribeToEvent(scriptFile_, E_RELOADSTARTED, URHO3D_HANDLER(Urho3DPlayer, HandleScriptReloadStarted));
SubscribeToEvent(scriptFile_, E_RELOADFINISHED, URHO3D_HANDLER(Urho3DPlayer, HandleScriptReloadFinished));
SubscribeToEvent(scriptFile_, E_RELOADFAILED, URHO3D_HANDLER(Urho3DPlayer, HandleScriptReloadFailed));
return;
}
#else
ErrorExit("AngelScript is not enabled!");
return;
#endif
}
else
{
#ifdef URHO3D_LUA
// Instantiate and register the Lua script subsystem
LuaScript* luaScript = new LuaScript(context_);
context_->RegisterSubsystem(luaScript);
// If script loading is successful, proceed to main loop
if (luaScript->ExecuteFile(scriptFileName_))
{
luaScript->ExecuteFunction("Start");
return;
}
#else
ErrorExit("Lua is not enabled!");
return;
#endif
}
// The script was not successfully loaded. Show the last error message and do not run the main loop
ErrorExit();
}
