Waterhouse FC: Premier League Squad, Achievements & Stats

Overview of Waterhouse Football Team

Waterhouse is a prominent football team based in Jamaica, competing in the Jamaican Premier League. Founded in 1973, the team is managed by Coach Patrick Pemberton and plays its home games at the Waterhouse Oval. Known for their dynamic playing style and passionate fanbase, Waterhouse has established itself as a formidable contender in the league.

Team History and Achievements

Waterhouse boasts a rich history filled with numerous titles and accolades. The club has won multiple Jamaican Premier League championships, including titles in 1991, 2005, and 2018. They have also secured several cups and have consistently been among the top teams in the league standings.

Current Squad and Key Players

The current squad features several standout players who contribute significantly to the team’s success. Key players include:

• John Doe – Striker, known for his goal-scoring prowess.
• Jane Smith – Midfielder, renowned for her playmaking abilities.
• Mike Johnson – Defender, crucial for his defensive stability.

Team Playing Style and Tactics

Waterhouse employs a flexible 4-3-3 formation that emphasizes attacking football. Their strategy focuses on quick transitions from defense to attack, utilizing wide wingers to stretch opposition defenses. Strengths include their offensive creativity and solid defensive organization, while weaknesses may arise from occasional lapses in concentration during high-pressure matches.

Interesting Facts and Unique Traits

Nicknamed “The Mighty Warriors,” Waterhouse has a dedicated fanbase known as “The Warriors’ Brigade.” The team has fierce rivalries with clubs like Arnett Gardens and Portmore United. Traditions such as pre-match rituals and fan chants add to the vibrant matchday atmosphere at their home ground.

Lists & Rankings of Players, Stats, or Performance Metrics

• TOP SCORERS: John Doe (🎰), Jane Smith (💡)
• AVERAGE POSSESSION: 58% (✅)
• TACKLE SUCCESS RATE: 75% (✅)

Comparisons with Other Teams in the League or Division

In comparison to other teams in the Jamaican Premier League, Waterhouse often ranks high due to their consistent performance and strategic gameplay. They frequently compete closely with Arnett Gardens for top positions in the league standings.

Case Studies or Notable Matches

A notable match was Waterhouse’s victory against Portmore United in the 2018 season finale, which secured them another league title. This match is remembered for its thrilling finish and strategic brilliance displayed by both teams.

Tables Summarizing Team Stats, Recent Form, Head-to-Head Records, or Odds

Metric	Last Season	This Season (so far)
Total Goals Scored	45	20 (as of current date)
Total Wins/Losses/Draws	18/5/7	10/3/4 (as of current date)
Odds for Next Match Win/Loss/Draw	– / – / –	– / – / –

Tips & Recommendations for Analyzing the Team or Betting Insights 💡 Advice Blocks

To analyze Waterhouse effectively:

• Analyze recent form trends; they are currently on a winning streak.
• Evaluate head-to-head records against upcoming opponents for insights into potential outcomes.
• Focusing on key player performances can provide an edge when placing bets.

Frequently Asked Questions About Betting on Waterhouse ⚽️ FAQ Block:

What makes Waterhouse a good bet?

Their consistent performance history and strong squad make them reliable contenders in matches.

Could recent injuries impact betting odds?

Potential injuries to key players like John Doe could affect their performance; always check injury reports before betting.

Historically how do they perform against top-tier teams?

In past seasons against top-tier teams like Arnett Gardens, they’ve shown competitive spirit but mixed results; analyzing these encounters can guide betting decisions.

Betting Analysis: Pros & Cons of Current Form or Performance ✅❌ Lists 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 📊 Analysis Block 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List 👇🏼 Pros & Cons List :

• Pros:

• Solid defensive record this season (✅).

• Promising young talent emerging within squad (✅).

• Favorable head-to-head stats against upcoming opponent (✅).

Cons:

• Potential fatigue from congested fixture schedule (❌).

• Injury concerns over key midfielder Jane Smith (❌).

• Varying away form compared to home performances (❌).

Betting Tips 💡 Advice Blocks 💡 Advice Blocks 💡 Advice Blocks 💡 Advice Blocks 💡 Advice Blocks 💡 Advice Blocks 💡 Advice Blocks 💡 Advice Blocks :

• Analyze recent head-to-head records between Waterhouse and their opponents to gauge potential outcomes accurately.

Step-by-step Guide on Analyzing Team’s Tactics for Betting Purposes 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides 🔍 How-to Guides :</u#pragma once

#include “core.h”

#include “LunarGfx.h”
#include “LunarGfxRenderer.h”

#include “ui/UIManager.h”

namespace Lunar {
class RenderPass {
friend class Renderer;

public:
RenderPass();
~RenderPass();

void AddCommandBuffer(const CommandBuffer& commandBuffer);
void SetRenderTarget(const Texture* renderTarget);

void Execute();

private:
std::vector m_CommandBuffers;
Texture* m_RenderTarget = nullptr;
};

class Renderer {
friend class RenderPass;

public:
static Renderer* GetInstance();

void BeginFrame();
void EndFrame();

CommandBuffer* CreateCommandBuffer();
RenderPass* CreateRenderPass();

private:
Lunar::Renderer();

std::vector m_CommandBuffers;
};
}
DerekJi98/LunarEngineSetPerspectiveProjection(60.f * MathUtils::DegreeToRadianf(), Application::GetInstance()->GetWindow()->GetAspectRatio(), .01f, 1000.f);
}

GameScene::~GameScene()
{
delete m_Camera;
}

void GameScene::Init()
{
m_SphereMesh = new Mesh(“Sphere.obj”);
m_CubeMesh = new Mesh(“Cube.obj”);

m_SphereMaterial = new Material();
m_SphereMaterial->SetDiffuseTexture(new Texture(“Textures/sphere_albedo.png”));
m_SphereMaterial->SetNormalTexture(new Texture(“Textures/sphere_normal.png”));

m_CubeMaterial = new Material();
m_CubeMaterial->SetDiffuseTexture(new Texture(“Textures/cube_albedo.png”));
m_CubeMaterial->SetNormalTexture(new Texture(“Textures/cube_normal.png”));

for(int i = 0; i <= 10; ++i) {
for(int j = 0; j <= 10; ++j) {
for(int k = 0; k <= 10; ++k) {
float x = static_cast(i * Random(-100.f, 100.f));
float y = static_cast(j * Random(-100.f, 100.f));
float z = static_cast(k * Random(-100.f, 100.f));

Sphere* sphereObject = new Sphere(m_SphereMesh);
sphereObject->SetPosition(Vector3(x,y,z));

Cube* cubeObject = new Cube(m_CubeMesh);
cubeObject->SetPosition(Vector3(x,y,z));

sphereObject->SetRotation(MathUtils::Random() * MathUtils::PI * .25f,
MathUtils::Random() * MathUtils::PI * .25f,
MathUtils::Random() * MathUtils::PI * .25f);

cubeObject->SetRotation(MathUtils::Random() * MathUtils::PI * .25f,
MathUtils::Random() * MathUtils::PI * .25f,
MathUtils::Random() * MathUtils::PI * .25f);

sphereObject->GetTransform()->Scale(Vector3(.05f,.05f,.05f));
cubeObject->GetTransform()->Scale(Vector3(.05f,.05f,.05f));

sphereObject->GetMaterial()->SetColor(Color(Random(.5f), Random(.5f), Random(.5f)));
cubeObject->GetMaterial()->SetColor(Color(Random(.5f), Random(.5f), Random(.5f)));

AddChild(sphereObject);
AddChild(cubeObject);
}
}
}
}

void GameScene::Update(float deltaTime)
{
if(InputManager::GetInstance()->IsKeyPressed(GLFW_KEY_W)) {
Vector3 translationVector(0,fabs(deltaTime),0);

if(InputManager::GetInstance()->IsKeyPressed(GLFW_KEY_A)) {
translationVector.x -= fabs(deltaTime);
translationVector.y += fabs(deltaTime) / sqrt(1 + pow(fabs(deltaTime),4));
translationVector.z -= fabs(deltaTime) / sqrt(1 + pow(fabs(deltaTime),4));
translationVector.Normalize();
} else if(InputManager::GetInstance()->IsKeyPressed(GLFW_KEY_D)) {
translationVector.x += fabs(deltaTime);
translationVector.y += fabs(deltaTime) / sqrt(1 + pow(fabs(deltaTime),4));
translationVector.z -= fabs(deltaTime) / sqrt(1 + pow(fabs(deltaTime),4));
translationVector.Normalize();
}

if(InputManager::GetInstance()->IsKeyPressed(GLFW_KEY_Q)) {
Vector3 upDirection(m_Camera->GetPosition().y > .001 ? Vector3(0,-1.f/m_Camera->GetPosition().y,-m_Camera->GetPosition().z/m_Camera->GetPosition().y).Normalized() : Vector3());
Vector3 rightDirection(m_Camera->GetPosition().x > .001 ? Vector3(-m_Camera->GetPosition().z/m_Camera->GetPosition().x,m_Camera->GetPosition().y/m_Camera->GetPosition().x,-1).Normalized() : Vector3());

Vector4 directionToTranslate(cos(m_Camera->_rotation.y)*upDirection + sin(m_Camera->_rotation.y)*rightDirection);

directionToTranslate.w += deltaTime;
directionToTranslate.Normalize();

directionToTranslate *= deltaTime;

directionToTranslate.w *= directionToTranslate.w > .001 ? m_Camera->_position.z/directionToTranslate.w : deltaTime;

directionToTranslate.w *= directionToTranslate.w > .001 ? m_Camera->_position.x/directionToTranslate.w : deltaTime;

directionToTranslate.Normalize();

Vector4 finalTranslation(directionToTranslate.x*(directionToTranslate.y >= .001 ? cos(directionToTranslate.z) : cos(directionToTranslate.z)/directionToTranslate.y),
directionToTranslate.y*(directionToTranslate.x >= .001 ? sin(directionToTranslate.z) : sin(directionToTranslate.z)/directionToTranslate.x),
directionToTranslate.z,
deltaTime);

finalTranslation.Normalize();

finalTranslation *= deltaTime;

finalTranslation.w *= finalTranslation.w > .001 ? m_Camera->_position.z/finalTranslation.w : deltaTime;

finalTranslation.w *= finalTranslation.w > .001 ? m_Camera->_position.x/finalTranslation.w : deltaTime;

finalTranslation.Normalize();

finalTranslation *= delta_time;

m_Camera->_position += Vector3(finalTranslation.x,(finalTranslation.y >= -.9999 && finalTranslation.y = -.00001 && finalTranslation.y = -.9999 && finalTranslation.y = -.00001 && finalTranslation.y IsKeyPressed(GLFW_KEY_E)) {
Vector4 forwardDirection(cos(m_Camera->_rotation.y),
sin(m_Camera->_rotation.y),
-(m_PerspectiveProjection._farPlaneDistance/(m_PerspectiveProjection._farPlaneDistance-m_PerspectiveProjection._nearPlaneDistance)),
-(m_PerspectiveProjection._farPlaneDistance*m_PerspectiveProjection._nearPlaneDistance/(m_PerspectiveProjection._farPlaneDistance-m_PerspectiveProjection._nearPlaneDistance)));

forwardDirection /= forwardDirection.LengthSquared();

forwardDirection *= delta_time;

forwardDirection /= forwardDirection.LengthSquared();

forwardDirection *= delta_time;

forwardDirection /= forwardDirection.LengthSquared();

forwardDirection /= forwardDirection.LengthSquared();

m_camera_position += Vector(forward_direction[0],forward_direction[1],forward_direction[2]);
}

if(InputManager::_instance.is_key_pressed(GLFW_KEY_A)) { // Left
rotation_vector[1] -= delta_time;
rotation_vector[1] -= rotation_vector[1] == M_PI_4 || rotation_vector[1] == -M_PI_4 ? delta_time*.99 : delta_time;
} else if(InputManager::_instance.is_key_pressed(GLFW_KEY_D)) { // Right
rotation_vector[1] += delta_time;
rotation_vector[1] += rotation_vector[1] == M_PI_4 || rotation_vector[1] == -M_PI_4 ? delta_time*.99 : delta_time;
}

if(InputManager::_instance.is_key_pressed(GLFW_KEY_Q)) { // Up
Vector up_direction(rotation_vector_y > M_PI_8 && rotation_vector_y M_PI)
camera_rotation_z -= M_PI

if(camera_rotation_z <-M_PI)
camera_rotation_z += M_PI

camera_transform.set_position(vector(camera_position_x,camera_position_y,camera_position_z))
camera_transform.set_scale(vector(10.,10.,10.))

camera_transform.set_orientation(quaternion(vector(camera_rotation_x,camera_rotation_y,camera_rotation_z)))
camera_transform.update()

scene.set_camera_transform(camera_transform)
}
}<|file_sepc++
#pragma once

// This file is part of Lunar Engine.

// MIT License

// Copyright(c)2020 Derek Ji

// Permission is hereby granted,freely,to any person obtaining a copy
// of this softwareand associated documentation files(the"Software"),to deal
// inthe Software without restriction,including without limitationthe rights
// to use,copy,to modify,to merge,to publish,distribute,sublicense,and/or sell copiesofthe Software,andto permit persons towhomthe Softwareis furnishedto do so,nitherebeing any conditionsofnoteitherto.The Software is provided"AS IS",without warrantyofany kind,either express or implied,nitherebeing any warrantyofmerchantability,fitnessfor a particular purposeor non-infringement.Asidefromwhat istheretoforestated,nithecopyright holders noranyoneelse involvedinthecreation,the distribution,and/or maintenanceofthe Software shall be liablefor any claim,damagesor other liability,wetherin an actionofcontract,tortor otherwisearising fromoutoforin connectionwiththeSoftwareortherelateddocumentationfiles(the"Softwarerelated activities").

namespace Lunar {

template class ComponentSystem {

public:

/**
*
*/
ComponentSystem(void(TInstance::*constructor_method)(void)=nullptr,void(TInstance::*destructor_method)(void)=nullptr): _constructor_method(constructor_method?constructor_method:&TInstance::__default_constructor__), _destructor_method(destructor_method?destructor_method:&TInstance::__default_destructor__) {

_component_array_pointer_pointer=_component_array_pointer_end=_component_array_iterator_pointer_start=_component_array_iterator_pointer_end=_node_id_t_index_pair_node_id_t_index_pair_pair_array_pointer_start=_node_id_t_index_pair_node_id_t_index_pair_pair_array_pointer_end=nullptr;
_owns_memory=owns_memory?true:false;
_type_name_string=TTypeNameString;
_type_name_string_const_char_ptr=TTypeNameStringConstCharPtr?TTypeNameStringConstCharPtr:TTypeNameString.c_str();
_pretty_name_string_const_char_ptr=TPrettyNameStringConstCharPtr?TPrettyNameStringConstCharPtr:””;
_pretty_name=pretty_name?true:false;
_safe_mode=safe_mode?true:false;
}

/**
*
*/
virtual ~ComponentSystem(void(TInstance::*destructor_method)(void)=nullptr): _constructor_method(nullptr,_destructor_method(destructor_method?destructor_method:&TInstance::__default_destructor__)) {

delete[](_owns_memory&&(_component_array_pointer_start!=nullptr&&_component_array_pointer_end!=nullptr))?_component_array_pointer_start:_node_id_t_index_pair_node_id_t_index_pair_pair_array_pointer_start,nullptr,_owns_memory&&(_component_array_iterator_pointer_start!=nullptr&&_component_array_iterator_pointer_end!=nullptr)?_component_array_iterator_pointer_start:_node_id_t_index_pair_node_id_t_index_pair_pair_array_iterator_pointer_start,nullptr,_owns_memory&&(_node_id_t_index_pair_node_id_t_index_pair_pair_array_iterator_pointer_start!=nullptr&&_node_id_t_index_pair_node_id_t_index_pair_pair_array_iterator_pointer_end!=nullptr)?_node_id_t_index_pair_node_id_t_index_pair_pair_array_iterator_pointer_start:nullptr,nullptr,_owns_memory&&(_node_id_t_index_pair_node_id_t_index_pair_pairs!=nullpointerr&_nodeidtindexpairnodidtindexpairpairsend!=nullpointer)?_nodeidtindexpairnodidtindexpairpairs:nullptr,nullptr,_owns_memory&&(_nodes_with_components_ids_and_indices_arrays!=nullpointerr&_nodes_with_components_ids_and_indices_arraysend!=nullpointer)?nodes_with_components_ids_and_indices_arrays:nullptr,nullptr,_owns_memory&&(_components_count_per_nodes_arrays!=nullpointerr&_components_count_per_nodes_arraysend!=nullpointer)?components_count_per_nodes_arrays:nullptr,nullptr,_owns_memory&&(_components_per_nodes_arrays!=nullpointerr&_components_per_nodes_arraysend!=nullpointer)?components_per_nodes_arrays:nullptr,nullptr,_owns_memory&&(_nodes_with_components_ids_and_indices_map_hash_table_keys_hash_tables!=nullpointerr&_nodes_with_components_ids_and_indices_map_hash_table_keys_hash_tablesend!=nullpointer)?nodes_with_components_ids_and_indices_map_hash_table_keys_hash_tables:nullptr,nullptr,_owns_memory&&(_nodes_with_components_ids_and_indices_map_hash_table_values_hash_tables != nullpointer&&!&nodes_with_components_ids_and_indices_map_hash_table_values_hash_tablesend != nullpointer )? nodes_with_components_ids_and_indices_map_hash_table_values_hash_tables:nullpoiter,nullpoiter,

_returns_code=returns_code==SUCCESS||returns_code==FAILURE?(returns_code==SUCCESS?SUCCESS:(TReturnCode==SUCCESS?SUCCESS:(TReturnCode==FAILURE_FAILURE_FAILURE_FAILURE_FAILURE_FAILURE_FAILUREFAILUREFAILUREFAILUREFAILUREFAILUREFAILUREFAILUREFAILUREFAILU?:TReturnCode)):returns_code):returns_code,

(_pretty_name||!TSafeMode)&&(!TSafeMode||!(*this)._pretty_name)&&(*this)._type_name_string_const_char_ptr[_type_name_string_const_char_ptr.size()-sizeof(char)-sizeof(char)]!=”’?

printf(“%sn”,static_cast(typeid(TInstance).name())):

((_pretty_name||!TSafeMode)&&(!TSafeMode||!(*this)._pretty_name)&&(*this)._type_name_string_const_char_ptr[_type_name_string_const_char_ptr.size()-sizeof(char)-sizeof(char)]==”’)?

printf(“%sn”,static_cast(typeid(TPrettyName).name())):

NULL,

(_pretty_name||!TSafeMode)&&(!TSafeMode||!(*this)._pretty_name)&&(*this)._type_nametstringconstcharpt[_typenamestringconstcharpt.size()-sizeof(char)-sizeof(char)]=='”‘)?

printf(“”%s”n”,static_cast(typeid(TInstance).name())):

((_pretty_name||!TSafe_Mode)&&(!TSafe_Mode||!(*this)._pretty_Name)&&(*this)_typenamestringconstcharpt[_typenamestringconstcharpt.size()-sizeof(char)-sizeof(char)]=='”‘)?

printf(“”%s”n”,static_cast(typeid(TPretty_Name).name())):

NULL,

(_prety_Name&&!Safe_Mode)||(!Safe_Mode&&!((*this)_prety_Name))?printf(“%sn”,(static_cast(typeid(TInstancce).name()))):

(((*_prety_Namme)||!*Safe_MoDe)&&((*Safe_MoDe)||!*(*this)_prety_Namme)&&(static_cast(*(typename(TInstancce)).name())[typenamestringconstcharpt.size()-sizeof(char)-sizeof(char)])==”’)?

printf(“%sn”,(static_cast(*(typename(TInstancce)).name()))):

(((*_prety_Namme)||!*Safe_MoDe)&&((*Safe_MoDe)||!*(*this)_prety_Namme)&&(static_cast(*(typename(TPretyNamme)).name())[typenamestringconstcharpt.size()-sizeof(char)-sizeof(char)])==”’)?

printf(“%sn”,(static_cast(*(typename(TPretyNamme)).name()))):

NULL,

((*__prettymode)||!*__safe_mode)&&(( *__safe_mode)||!*(__prettypmode))&&(static_cast((*(typename(__ptype))).name())[(__ptype.name()).size()-sizeof(char)-sizeof(char)])=='”‘)?

printf(“”%s”n”,(static_cast((*(typename(__ptype))).name()))):

(((( *__prettymode)||!*__safe_mode)&&( *__safe_mode)||!*(__prettypmode)))&&(static_cast((*(typename(__pprettynamne))).name())[( __pprettypnamne.name()).size()- sizeof(char)- sizeof(charr)])=='”‘)?

printf(“”%s”n”,( static cast((*( typename (__pprettynamne))). name()))) :

NULL :

NULL ;

};

/**
*
*/
bool Add(const NodeID node_ID,const Index index,const Index count,const void* const component_data,void*& component_data_out): component_data_out=(count<=std :: size_of(component_data_out)<std :: size_of(component_data))?count<=std :: size_of(component_data_out)<std :: size_of(component_data)?

memcpy(&component_data_out,&component_data,count):

count<=std :: size_of(component_data)<std :: size_of(component_data_out)?

memcpy(&component_data_out,&component_data,std :: size_of(component_data)):

memcpy(&component_data,&component_data_out,std :: size_of(component_datapointer)),(

!_owner_s_memoey||

!_owner_s_memoey?

!(

(

(

(

(

(

(

(

(

!(

(* this ) ._ component array pointer pointer ||

(! (* this ) ._ component array pointer pointer)?

(! (* this ) ._ component array pointer end)?

(! (* this ) ._ component array iterator pointer start)?

(! (* this ) ._ component array iterator pointer end)?

(! (* this ) ._ node id t index pair node id t index pair pair array pointer start)?

(! (* this ) ._ node id t index pair node id t index pair pair array pointer end)?

(! (* this ) ._ node id t index pair node id t index pair pair array iterator pointer start)?

(! (* this ) ._ node id t index pair node id t index pair pair array iterator pointer end)?

!(

!(

)

):

(!_owner_s_memoey?

(!_owner_s_memoey?
(!_owner_s_memoey?

(!_owner_s_memoey?

)
:
!

)
:
!

)
:
!
)
):
!
)
):
!
)
):
!
)
):
!
)

):

(_owners_memoeys?

(_owners_memoeys?

(_owners_memoeys?

(_owners_memoeys?

(_owners_memoeys?

(_owners_memoeys?

(!(* this )._
components count per nodes arrays ||

!(
!(
!(
!(
!(
!(
!(
!(
!(

!( *( *( *( (*( (*( (*( (*( (*( *( (*( (*( *( _( components count per nodes arrays ). begin () ). get () ). get () ). get () ). get () ). get () ). get () ). get () ). get () ().get ()) ;
)
);
);
);
);
);
);
);
);
);
);
);
);
);
);

delete [] components_count_per_nodes_arrays , nullptr , components_count_per_nodes_arrays begin (), nullptr , components_count_per_nodes_arrays end (), nullptr , components_count_per_nodes_arrays begin (), nullptr , components_count_per_nodes_arrays end (), nullptr ;

delete [] nodes_with_components_ids_and_indices_maps , nullptr , nodes_with_components_ids_and_indices_maps begin (), nullptr , nodes_with_components_ids_and_indices_maps end (), nullptr , nodes_with_components_ids_and_indices_maps begin (), nullptr , nodes_with_components_ids_and_indices_maps end (), nullptr ;

delete [] nodes_wih_componets_ids_and_indicies_maps_keys_hashtables , nullpoiter , nodes_wih_componets_ids_and_indicies_maps_keys_hashtables_begin (), nullpoiter , nodes_wih_componets_ids_and_indicies_maps_keys_hashtables_end (), nullpoiter , nodes_wih_componets_ids_and_indicies_maps_keys_hashtables_begin (), nullpoiter , nodes_wih_componets_ids_and_indicies_maps_keys_hashtables_end (), nullpoiter ;

delete [] nodes_wih_componetsidsandindiciesmaps_values_hashtables , nullpoiter , nodes_wih_componetsidsandindiciesmaps_values_hashtables_begin (), nullpoiter , nodes_wih_componetsidsandindiciesmaps_values_hashtables_end (), nullpoiter , nodewithcomponetssidsandindicesmapshashhtablevalueshashtablebegin(), nullopter,nodewithcomponetssidsandindicesmapshashhtablevalueshashtableend(), nullopter ;

delete [] comoponentspernodesarrays_, nullopter_, comoponentspernodesarraysbegin(), nullopter_, comoponentspernodesarraysend(), nullopter_, comoponentspernodesarraysbegin(), nullopter_, comoponentspernodesarraysend(), nullopter_;

):

(_owners_memoeys?

(_owners_memoeys?

(_owners_memoeys?

(!_owners_memoeys)?

delete [] components_count_per_nodes_arrays_begin(),

delete [] components_count_per_nodes_arrays_end(),

delete [] components_count_per_nodes_arrays(),

delete [] nodswithcompenentsidsandindicesarrays(),

delete [] nodswithcompenentsidsandindicesarraybegins(),

delete [] nodswithcompenentsidsandindicesarrayends(),

delete [] nodswithcompenentsidsandindicesarraybegins(),

delete [] nodswithcompenentsidsandindicesarrayends():

):

(

(!_owner_s_memeoy)?

(

delete[] comoponentscountpernodeselementsbegin(),

delete[] comoponentscountpernodeselementsends(),

delete[] comoponentselementspernodeselements(),

delete[] nodewithcompentssindexeselements(),

delelte[] nodewithcompentssindexeselementselementsbegins(),

delelte[] nodewithcompentssindexeselementselementsendss(),

delelte[] nodewithcompentssindexeselementselementsbegins(),

delelte[] nodewithcompentssindexeselementselementsendss():

):

):

):

):

!

(

!_ownrs_meomey?

(

delte[]

):

(

delte[]

);

)

?

false:

(

!_owner_s_memoey?

(

delte[]

):

(

delte[]

);

);

:

false;

return true;

};

/**
*
*/
bool Remove(const NodeID node_ID): return false;

/**
*
*/
bool Update(): return true;

/**
*
*/
void Clear(): return true;

/**
*
*/
template: void Construct(void*& instance,**args_types…): instance=new((*args_types,…))(ArgsTypes…);

/**
*
*/
template: void Destruct(void*& instance,**args_types…): instance=new((*args_types,…))(ArgsTypes…);

/**
*
*/
template: bool Contains(const NodeID node_ID,**args_types…): args_types…=new((*args_types,…))(ArgsTypes…);

};
}
#include “CameraController.h”

using namespace Lunar;

CameraController::~CameraController()
{

}

CameraController& CameraController::_singleton_instance()
{
static CameraController singleton_instance{};

return singleton_instance;
}

bool CameraController::_initialize(Camera& camera)
{
if(!_initialized)
{