TileMaster::TileMaster(Context *context, MasterControl* masterControl):
Object(context),
masterControl_{masterControl}
{
rootNode_ = masterControl_->world.scene->CreateChild("TileMaster");
//Create hexagonal field
//Lays a field of hexagons at the origin
int bigHexSize = 23;
for (int i = 0; i < bigHexSize; i++) {
for (int j = 0; j < bigHexSize; j++) {
if (i < (bigHexSize - bigHexSize / 4) + j / 2 && //Exclude bottom right
i > (bigHexSize / 4) - (j + 1) / 2 && //Exclude bottom left
i + 1 < (bigHexSize - bigHexSize / 4) + ((bigHexSize - j + 1)) / 2 && //Exclude top right
i - 1 > (bigHexSize / 4) - ((bigHexSize - j + 2) / 2)) { //Exclude top left
Vector3 tilePos = Vector3((-bigHexSize / 2.0f + i) * 2.0f + j % 2, -0.1f, (-bigHexSize / 2.0f + j + 0.5f) * 1.8f);
tileMap_[IntVector2(i, j)] = new Tile(context_, this, tilePos);
}
}
}
//Add a directional light to the arena. Enable cascaded shadows on it
Node* lightNode = rootNode_->CreateChild("Sun");
lightNode->SetPosition(Vector3::UP*5.0f);
lightNode->SetRotation(Quaternion(90.0f, 0.0f, 0.0f));
Light* playLight = lightNode->CreateComponent<Light>();
playLight->SetLightType(LIGHT_DIRECTIONAL);
playLight->SetBrightness(0.8f);
playLight->SetRange(10.0f);
playLight->SetColor(Color(1.0f, 0.9f, 0.95f));
playLight->SetCastShadows(false);
}
CameraMaster::CameraMaster(
Context *context,
MasterControl *masterControl
) :
Object(context),
masterControl_{masterControl}
{
SubscribeToEvent(E_SCENEUPDATE, HANDLER(CameraMaster, HandleSceneUpdate));
//Create the camera. Limit far clip distance to match the fog
translationNode_ = masterControl_->world_.scene->CreateChild("CamTrans");
rotationNode_ = translationNode_->CreateChild("CamRot");
camera_ = rotationNode_->CreateComponent<Camera>();
camera_->SetFarClip(1024.0f);
//Set an initial position for the camera scene node above the origin
//translationNode_->SetPosition(Vector3(0.0f, 3.0f, 0.0f));
translationNode_->SetPosition(Vector3(0.0, 3.0,-20.0));
rotationNode_->SetRotation(Quaternion(0.0f, 90.0f, 0.0f));
rigidBody_ = translationNode_->CreateComponent<RigidBody>();
rigidBody_->SetAngularDamping(10.0f);
CollisionShape* collisionShape = translationNode_->CreateComponent<CollisionShape>();
collisionShape->SetSphere(0.1f);
rigidBody_->SetMass(1.0f);
Node* lightNode = translationNode_->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.0f, -1.0f, 0.0f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_POINT);
light->SetBrightness(0.5f);
light->SetColor(Color(0.7f, 0.9f, 0.6f));
light->SetCastShadows(false);
SetupViewport();
}
void LightFlash::FixedUpdate(float timeStep)
{
// Call superclass to handle lifetime
GameObject::FixedUpdate(timeStep);
Light* light = node_->GetComponent<Light>();
if (light)
{
light->SetBrightness(light->GetBrightness() * Max(1.0f - timeStep * 10.0f, 0.0f));
}
}
/// Setup the main viewport
void GameEconomicGameClient::SetupScreenViewport(void)
{
/// Get Needed SubSystems
ResourceCache* cache = GetSubsystem<ResourceCache>();
Renderer* renderer = GetSubsystem<Renderer>();
Graphics* graphics = GetSubsystem<Graphics>();
UI* ui = GetSubsystem<UI>();
/// Get rendering window size as floats
float width = (float)graphics->GetWidth();
float height = (float)graphics->GetHeight();
/// Set renderer quality
renderer -> SetTextureQuality (QUALITY_MAX);
renderer ->SetMaterialQuality (QUALITY_MAX);
renderer ->SetShadowQuality (SHADOWQUALITY_HIGH_24BIT);
renderer -> SetDynamicInstancing(true);
/// create a new scene
scene_= new Scene(context_);
scene_-> CreateComponent<Octree>();
scene_-> CreateComponent<DebugRenderer>();
Node* existencelogobackgroundNode = scene_->CreateChild("Plane");
existencelogobackgroundNode ->SetScale(Vector2(width*.012,height*.012));
existencelogobackgroundNode ->SetPosition(Vector3(0.0,0.0,-2.93435));
existencelogobackgroundNode ->SetRotation(Quaternion(0.0,0.0,0.0));
StaticModel* existencelogobackgroundObject = existencelogobackgroundNode->CreateComponent<StaticModel>();
existencelogobackgroundObject->SetModel(cache->GetResource<Model>("Resources/Models/existencelogobackground.mdl"));
existencelogobackgroundObject->SetMaterial(cache->GetResource<Material>("Resources/Materials/existencelogobackground.xml"));
/// Create a directional light to the world so that we can see something. The light scene node's orientation controls the
/// light direction; we will use the SetDirection() function which calculates the orientation from a forward direction vector.
/// The light will use default settings (white light, no shadows)
Node* lightNode = scene_->CreateChild("DirectionalLight");
//lightNode->SetDirection(Vector3(0.0,0.9,2)); /// The direction vector does not need to be normalized
lightNode->SetRotation(Quaternion(0.0,160.0,0.0));
Light* lightObject = lightNode->CreateComponent<Light>();
lightObject->SetLightType(LIGHT_DIRECTIONAL);
lightObject->SetBrightness(.7);
lightObject->SetSpecularIntensity(0);
/// Add a component
Node* lightNode2 = scene_->CreateChild("DirectionalLight");
//lightNode2->SetDirection(Vector3(0.0,0.9,0.0)); /// The direction vector does not need to be normalized
lightNode2->SetRotation(Quaternion(0.0,200.0,0.0));
Light* lightObject2 = lightNode2->CreateComponent<Light>();
lightObject2->SetLightType(LIGHT_DIRECTIONAL);
lightObject2->SetBrightness(.4);
lightObject2->SetSpecularIntensity(0);
Node* lightNode3 = scene_->CreateChild("DirectionalLight");
//lightNode3->SetDirection(Vector3(0.0,12,0.0)); /// The direction vector does not need to be normalized
//lightNode3->SetRotation(Quaternion(0.0,180.0,0.0));
lightNode3->LookAt(Vector3(0.0f,0.0f,0.0f));
Light* lightObject3 = lightNode3->CreateComponent<Light>();
lightObject3->SetLightType(LIGHT_DIRECTIONAL);
lightObject3->SetBrightness(.1);
lightObject3->SetSpecularIntensity(1);
Node* emptyNode = scene_->CreateChild("EmptyNode");
emptyNode->SetPosition(Vector3(2.0f,2.0f,2.0f));
/// Create a scene node for the camera, which we will move around
/// The camera will use default settings (1000 far clip distance, 45 degrees FOV, set aspect ratio automatically)
cameraNode_ = scene_->CreateChild("Camera");
/// Set an initial position for the camera scene node above the plane
cameraNode_->SetPosition(Vector3(0.0,0.0,5.0));
cameraNode_->SetRotation(Quaternion(0.0,-180.0,0.0));
Camera* cameraObject = cameraNode_->CreateComponent<Camera>();
cameraObject->SetOrthographic(1);
cameraObject->SetZoom(3);
/// Set up a viewport to the Renderer subsystem so that the 3D scene can be seen. We need to define the scene and the camera
/// at minimum. Additionally we could configure the viewport screen size and the rendering path (eg. forward / deferred) to
/// use, but now we just use full screen and default render path configured SetOrthographic ( in the engine command line options
SharedPtr<Viewport> viewport(new Viewport(context_, scene_, cameraNode_->GetComponent<Camera>()));
renderer->SetViewport(0, viewport);
return;
}
void MasterControl::CreateScene()
{
world_.scene = new Scene(context_);
//Create octree, use default volume (-1000, -1000, -1000) to (1000,1000,1000)
{
world_.scene->CreateComponent<Octree>();
}
//Create the physics
{
PhysicsWorld * const physicsWorld = world_.scene->CreateComponent<PhysicsWorld>();
physicsWorld->SetGravity(Vector3::ZERO);
}
world_.scene->CreateComponent<DebugRenderer>();
//Create an invisible plane for mouse raycasting
world_.voidNode = world_.scene->CreateChild("Void");
//Location is set in update since the plane moves with the camera.
world_.voidNode->SetScale(Vector3(1000.0f, 1.0f, 1000.0f));
StaticModel* planeModel = world_.voidNode->CreateComponent<StaticModel>();
planeModel->SetModel(cache_->GetResource<Model>("Models/Plane.mdl"));
planeModel->SetMaterial(cache_->GetResource<Material>("Materials/Terrain.xml"));
CreateBackground();
{
// 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
Node* skyNode = world_.scene->CreateChild("Sky");
skyNode->SetScale(500.0f); // The scale actually does not matter
Skybox* skybox = skyNode->CreateComponent<Skybox>();
skybox->SetModel(cache_->GetResource<Model>("Models/Box.mdl"));
skybox->SetMaterial(cache_->GetResource<Material>("Materials/Skybox.xml"));
}
//Create a directional light to the world. Enable cascaded shadows on it
{
Node* lightNode = world_.scene->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.0f, -1.0f, 0.0f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetBrightness(1.0f);
light->SetColor(Color(1.0f, 0.8f, 0.7f));
light->SetCastShadows(true);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
//Set cascade splits at 10, 50, 200 world unitys, fade shadows at 80% of maximum shadow distance
light->SetShadowCascade(CascadeParameters(7.0f, 23.0f, 42.0f, 500.0f, 0.8f));
}
//Create a second directional light without shadows
{
Node * const lightNode = world_.scene->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.0, 1.0, 0.0));
Light * const light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetBrightness(0.25);
light->SetColor(Color(1.0, 1.0, 1.0));
light->SetCastShadows(true);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
}
//Create camera
world_.camera = new CameraMaster(context_, this);
}
void MasterControl::CreateScene()
{
world.scene = new Scene(context_);
world.octree = world.scene->CreateComponent<Octree>();
physicsWorld_ = world.scene->CreateComponent<PhysicsWorld>();
physicsWorld_->SetGravity(Vector3::ZERO);
world.scene->CreateComponent<DebugRenderer>();
//Create a Zone component for ambient ing & fog control
Node* zoneNode = world.scene->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
zone->SetBoundingBox(BoundingBox(Vector3(-100.0f, -50.0f, -100.0f),Vector3(100.0f, 0.0f, 100.0f)));
zone->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
zone->SetFogColor(Color(0.0f, 0.0f, 0.0f));
zone->SetFogStart(56.8f);
zone->SetFogEnd(61.8f);
//Add a directional light to the world. Enable cascaded shadows on it
Node* lightNode = world.scene->CreateChild("PointLight");
lightNode->SetPosition(Vector3::UP*5.0);
lightNode->SetRotation(Quaternion(90.0f, 0.0f, 0.0f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetBrightness(1.0f);
light->SetRange(7.0f);
light->SetColor(Color(1.0f, 0.9f, 0.95f));
light->SetCastShadows(false);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
//Set cascade splits at 10, 50, 200 world unitys, fade shadows at 80% of maximum shadow distance
light->SetShadowCascade(CascadeParameters(7.0f, 23.0f, 42.0f, 500.0f, 0.8f));
//Create cursor
world.cursor.sceneCursor = world.scene->CreateChild("Cursor");
//world.cursor.sceneCursor->SetPosition(Vector3(0.0f,0.0f,0.0f));
StaticModel* cursorObject = world.cursor.sceneCursor->CreateComponent<StaticModel>();
cursorObject->SetModel(cache_->GetResource<Model>("Resources/Models/Hexagon.mdl"));
cursorObject->SetMaterial(cache_->GetResource<Material>("Resources/Materials/Glow.xml"));
world.cursor.sceneCursor->SetEnabled(false);
//Create an invisible plane for mouse raycasting
world.voidNode = world.scene->CreateChild("Void");
//Location is set in update since the plane moves with the camera.
world.voidNode->SetScale(Vector3(1000.0f, 1.0f, 1000.0f));
StaticModel* planeObject = world.voidNode->CreateComponent<StaticModel>();
planeObject->SetModel(cache_->GetResource<Model>("Models/Plane.mdl"));
planeObject->SetMaterial(cache_->GetResource<Material>("Resources/Materials/Invisible.xml"));
//Create camera
world.camera = new heXoCam(context_, this);
//Create arena
tileMaster_ = new TileMaster(context_, this);
for (int i = 0; i < 6; i++){
new ArenaEdge(context_, this, (60.0f * i)+30.0f);
}
spawnMaster_ = new SpawnMaster(context_, this);
player_ = new Player(context_, this);
apple_ = new Apple(context_, this);
heart_ = new Heart(context_, this);
}
void GameApplication::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/dikuang.mdl"));
Material* material = cache->GetResource<Material>("Materials/Water.xml");
planeObject->SetMaterial(material); //dikuang
// 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.3f, 0.3f, 0.3f));
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("DirectionalLight");
lightNode->SetDirection(Vector3(0.2f, -0.5f, -0.1f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
// light->SetSpecularIntensity(3);
light->SetBrightness(1);
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));
InitGridModels();
// Create the camera. Limit far clip distance to match the fog
cameraNode_ = scene_->CreateChild("Camera");
Camera* camera = cameraNode_->CreateComponent<Camera>();
//float fZoom = camera->GetFov();
//camera->SetFov(fZoom);
camera->SetFarClip(300.0f);
// Set an initial position for the camera scene node above the plane
cameraNode_->SetPosition(Vector3(0.2318,7.5248,-0.2721));
yaw_ = 0.10003410;
pitch_ = 90;
// cameraNode_->SetPosition(Vector3(5.0f, 5.0f, -15.0f));
//pitch_ = 19;
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
}