Actor* addModel(string filename, vec3 pos = vec3(0), vec3 s = vec3(1))
{
Actor* sphere = new Actor;
TransformComponent* trans = new TransformComponent();
trans->setPos(pos);
trans->setScale(s);
sphere->addComponent(trans);
glDebug();
sphere->addComponent(new StaticMeshStaticPhysicsComponent(AssetManager::getBasePath() + filename));
glDebug();
MeshGraphicComponent* mesh = new MeshGraphicComponent(AssetManager::getBasePath() + filename);
glDebug();
mesh->setTextureMatrix(mat2(scale(mat4(1), vec3(10))));
glDebug();
Material *mat = new Material();
glDebug();
mat->setDiffuse(AssetManager::getBasePath() + "Data/Texture/floor1_d.png");
mat->setNormal(AssetManager::getBasePath() + "Data/Texture/floor1_n.png");
mat->setSpecular(AssetManager::getBasePath() + "Data/Texture/floor1_s.png");
mat->setShininess(20);
glDebug();
mesh->addMaterial(mat);
glDebug();
sphere->addComponent(mesh);
glDebug();
return sphere;
}
math::Vec3 TransformComponent::getPosition()
{
// Go trough parents and add transform from those to this.
// Current entity
Entity *ent = (Entity*)getParent();
if (ent == NULL)
return position;
// Get current entities parent
Entity *parent = ent->getParentEntity();
if (parent == NULL)
return position;
TransformComponent *parentTransform = parent->findComponent<TransformComponent>();
if (parentTransform == NULL)
return position;
//TODO: Add parenting to the rotation
return parentTransform->getPosition() + position;
}
Actor* addMap()
{
Actor* sphere = new Actor;
TransformComponent* trans = new TransformComponent();
trans->setPos(vec3(0, -0.01, 0));
Rotation rot;
rot.setEulerAngles(vec3(0, 0.785, 0));
trans->setRotation(rot);
sphere->addComponent(trans);
glDebug();
sphere->addComponent(new StaticMeshStaticPhysicsComponent(AssetManager::getBasePath() + "Data/Model/mappa4.obj"));
glDebug();
MeshGraphicComponent* mesh = new MeshGraphicComponent(AssetManager::getBasePath() + "Data/Model/mappa4.obj");
glDebug();
mesh->setTextureMatrix(mat2(scale(mat4(1), vec3(10))));
glDebug();
Material *mat = new Material();
glDebug();
mat->setDiffuse(AssetManager::getBasePath() + "Data/Texture/floor1_d.png");
mat->setNormal(AssetManager::getBasePath() + "Data/Texture/floor1_n.png");
mat->setSpecular(AssetManager::getBasePath() + "Data/Texture/floor1_s.png");
mat->setShininess(20);
glDebug();
mesh->addMaterial(mat);
glDebug();
sphere->addComponent(mesh);
glDebug();
return sphere;
}
void PhysXPhysics::VSyncVisibleScene()
{
for (ActorIdToPysXRigidBodyTable::const_iterator it = m_actorRigidBodyMap.begin(); it != m_actorRigidBodyMap.end(); it++)
{
ActorId const id = it->first;
PxTransform pxLoc = it->second->getGlobalPose();
Mat4x4 loc;
PxMatrixToMat4x4(PxMat44(pxLoc), &loc);
Actor* pActor = g_pApp->m_pGame->VGetActor(id);
if (pActor)
{
TransformComponent* pTransformComponent = pActor->GetComponent<TransformComponent>(TransformComponent::g_Name);
if (pTransformComponent)
{
if (pTransformComponent->GetTransform() != loc)
{
Vec3 rot = loc.GetYawPitchRoll();
pTransformComponent->SetPosition(loc.GetPosition());
pTransformComponent->SetRotation(Vec3(XMConvertToDegrees(rot.x), XMConvertToDegrees(rot.y), XMConvertToDegrees(rot.z)));
EventDataPtr pEvent(BE_NEW EvtData_Move_Actor(id, loc));
IEventManager::Get()->VQueueEvent(pEvent);
}
}
}
}
}
void RenderSystem::draw(GameObject* gameObject)
{
RenderComponent* render = gameObject->getComponent<RenderComponent>();
if (render != nullptr)
{
RectangleShape shape = *render->getDrawable();
TransformComponent* transform = gameObject->getComponent<TransformComponent>();
if (transform != nullptr)
{
shape.setPosition(transform->getPosition());
}
else
{
BoardComponent* boardComp = gameObject->getComponent<BoardComponent>();
if (boardComp != nullptr && mBoard != nullptr)
{
Vector2i boardPos = boardComp->getPosition();
shape.setPosition(mBoard->getTilePosition(boardPos.x, boardPos.y));
}
}
mWindow->draw(shape);
}
}
//Busca enemigos
void CameraController3rd::lookForEnemies()
{
std::map<Entity*,Component*>* entitiesWithED = EntityManager::get().getAllEntitiesPosessingComponent<EnemyDataComponent>();
if(!entitiesWithED) return;
float distance = FLT_MAX;
float min_distance = distance;
std::map<Entity*,Component*>::iterator iter;
for (iter = entitiesWithED->begin(); iter != entitiesWithED->end(); ++iter)
{
if( iter->second->enabled )
{
Entity* entity = iter->first;
TransformComponent* transformEnemy = EntityManager::get().getComponent<TransformComponent>(entity);
float angle = _front.angle(transformEnemy->getPosition() - _camera->getPosition());
//dbg("angle: %f\n", angle);
if( angle < 1.0f )
{
distance = transformEnemy->getPosition().distance2(_camera->getTarget());
//dbg("distance: %f\n", distance);
if(distance < 30.0f && distance < min_distance)
{
_lockedEntity = entity;
min_distance = distance;
}
}
}
}
}
Actor* addAxis3()
{
Actor* actor = new Actor;
TransformComponent* trans = new TransformComponent();
trans->setPos(vec3(-5, 0, 5));
Rotation rot;
rot.setNormalDirection(vec3(1, 0, 0));
trans->setRotation(rot);
actor->addComponent(trans);
MeshGraphicComponent* mesh = new MeshGraphicComponent(AssetManager::getBasePath() + "Data/Model/axis.obj");
Material *mat = new Material();
mat->setDiffuse("#FF0000");
mesh->addMaterial(mat);
Material *mat1 = new Material();
mat1->setDiffuse("#00FF00");
mesh->addMaterial(mat1);
mesh->addMaterial(mat1);
Material *mat2 = new Material();
mat2->setDiffuse("#0000FF");
mesh->addMaterial(mat2);
actor->addComponent(mesh);
return actor;
}
void BulletScript::Update(GameEngine *game)
{
TransformComponent *transform = this->gameObject->GetComponent<TransformComponent*>();
transform->move(20, 0);
for (std::vector<GameObject*>::iterator it = this->gameObject->gameScene->gameObjects.begin(); it != this->gameObject->gameScene->gameObjects.end(); it++)
{
ColliderComponent *thisObject = this->gameObject->GetComponent<ColliderComponent*>();
if ((*it)->getName() == "enemy")
{
ColliderComponent *anotherObject = (*it)->GetComponent<ColliderComponent*>();
if (anotherObject != NULL && thisObject != anotherObject)
{
//std::cout << anotherObject->getX();
if (thisObject->getX() + thisObject->getWidth() >= anotherObject->getX() && thisObject->getX() <= anotherObject->getX() + anotherObject->getWidth()
&& thisObject->getY() + thisObject->getHeight() >= anotherObject->getY() && thisObject->getY() <= anotherObject->getY() + anotherObject->getHeight())
{
(*it)->setEnable(false);
//BulletScript::SCORE++;
//std::cout << BulletScript::SCORE++;
/*
score_ = db->load_int_data("pontos");
db->save_data("pontos", score_++, 0, 0);
TextComponent * text = this->gameObject->GetComponent<TextComponent*>();
text->set_string(std::string("score: " + score_));*/
(*score)++;
}
}
}
}
}
void
CollisionComponent::Update(GameObject& gameObject, double)
{
TransformComponent *transform = static_cast<TransformComponent*>(gameObject.FilterComponent("Transform").front().get());
SDL_Rect pos = transform->GetPosition();
this->_collider->SetPosition(Vector2D((float)pos.x, (float)pos.y));
}
void PlayerControllerSubsystem::process(unsigned int dt)
{
ALLEGRO_EVENT ev;
while (events.get(&ev))
{
if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_W: button_states[MOVE_FORWARD] = true; break;
case ALLEGRO_KEY_A: button_states[ROTATE_LEFT] = true; break;
case ALLEGRO_KEY_S: button_states[MOVE_BACKWARD] = true; break;
case ALLEGRO_KEY_D: button_states[ROTATE_RIGHT] = true; break;
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_W: button_states[MOVE_FORWARD] = false; break;
case ALLEGRO_KEY_A: button_states[ROTATE_LEFT] = false; break;
case ALLEGRO_KEY_S: button_states[MOVE_BACKWARD] = false; break;
case ALLEGRO_KEY_D: button_states[ROTATE_RIGHT] = false; break;
}
}
}
for (std::set<Entity>::const_iterator iter = active.begin(); iter != active.end(); iter++)
{
TransformComponent *tc = world->get<TransformComponent>(*iter);
static const float max_speed = 0.3;
if (tc->velocity.squaredNorm() > max_speed * max_speed)
{
tc->velocity *= 1 / tc->velocity.norm() * max_speed;
}
if (button_states[MOVE_FORWARD])
{
tc->acceleration(0) += cos(tc->rotation) / 1000;
tc->acceleration(1) += sin(tc->rotation) / 1000;
}
if (button_states[MOVE_BACKWARD])
{
tc->acceleration(0) -= cos(tc->rotation) / 1000;
tc->acceleration(1) -= sin(tc->rotation) / 1000;
}
if (button_states[ROTATE_LEFT])
{
tc->rotation += 0.1;
}
if (button_states[ROTATE_RIGHT])
{
tc->rotation -= 0.1;
}
}
}
void PhysComponent::update()
{
if (m_Obj->hasComponent("Transform")) {
TransformComponent* tc = (TransformComponent*)m_Obj->getComponent("Transform");
b2Vec2 pos = m_Body->GetPosition();
tc->setPosition((double)pos.x, (double)pos.y);
tc->setRotation( m_Body->GetAngle() * (180.0f / (float)Gosu::pi));
}
}
JunctionQueue *GraphicSystem::Process(Entity *entity) {
TransformComponent *transform = (TransformComponent*)(entity->GetComponent(Component::ComponentType::Transform));
GraphicsComponent *graphics = (GraphicsComponent*)(entity->GetComponent(Component::ComponentType::Graphics));
graphics->SetPos(transform->GetX(), transform->GetY());
graphics->SetRotation(transform->GetRotation());
graphics->Draw(_window);
return new JunctionQueue();
}
void update() {
if(win->inputManager->isKeyPressed(GLFW_KEY_F2)) {
scene->addActor(addSphereLight());
}
if(win->inputManager->isKeyPressed(GLFW_KEY_F3)) {
TransformComponent* trans = mainchar->getComponent<TransformComponent>(ComponentId::Transform);
Debug(trans->getPos());
}
}
void PhysXPhysics::AddShape(Actor* pActor, PxGeometry* geometry, float density, const std::string& physicsMaterial, bool gravityEnabled, float linearDamping, float angularDamping, const std::string& bodyType)
{
BE_ASSERT(pActor);
ActorId actorId = pActor->GetId();
BE_ASSERTf(m_actorRigidBodyMap.find(actorId) == m_actorRigidBodyMap.end(), "Actor with more than one rigidbody");
Mat4x4 transform = Mat4x4::g_Identity;
TransformComponent* pTransformComponent = pActor->GetComponent<TransformComponent>(TransformComponent::g_Name);
if (pTransformComponent)
{
transform = pTransformComponent->GetTransform();
}
else
{
//Doesnt work without transform
BE_ERROR("Actor %s PhysicsComponent requires Shape to have Transform Component: %d", actorId);
return;
}
PhysicsMaterialData material(LookupMaterialData(physicsMaterial));
PxMaterial* mat = m_pPhysicsSdk->createMaterial(material.m_friction, material.m_friction, material.m_restitution);
Vec3 translation, scale;
Quaternion rotation;
bool ok = transform.Decompose(translation, rotation, scale);
PxQuat pxRot;
PxVec3 pxLoc;
Vec3ToPxVec(translation, &pxLoc);
QuaternionToPxQuat(rotation, &pxRot);
PxTransform t(pxLoc, pxRot);
if (bodyType == "Dynamic")
{
PxRigidDynamic* body = PxCreateDynamic(*m_pPhysicsSdk, t, *geometry, *mat, density);
body->setActorFlag(PxActorFlag::eDISABLE_GRAVITY, !gravityEnabled);
PxRigidBodyExt::updateMassAndInertia(*body, density);
body->setLinearDamping(linearDamping);
body->setAngularDamping(angularDamping);
m_pScene->addActor(*body);
m_actorRigidBodyMap[actorId] = body;
m_rigidBodyActorMap[body] = actorId;
}
else
{
BE_ERROR("[Physics] BodyType not supported: %s", bodyType.c_str());
return;
}
}
bool InitializeTransformComponent(IActorComponent* cmp, ICMStream* stream)
{
TransformComponent* transformation = (TransformComponent*)cmp;
tinyxml2::XMLElement* pData = (tinyxml2::XMLElement*)stream;
tinyxml2::XMLElement* trans = pData->FirstChildElement("Position");
if(trans)
{
float x, y, z;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != trans->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != trans->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != trans->QueryFloatAttribute("z", &z));
transformation->GetTransformation()->Translate(x, y, z);
}
tinyxml2::XMLElement* rot = pData->FirstChildElement("Rotation");
if(rot)
{
float x, y, z, w;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("z", &z));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("w", &w));
transformation->GetTransformation()->SetRotateQuat(x, y, z, w);
}
rot = pData->FirstChildElement("AxisAngle");
if(rot)
{
float x, y, z, w;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("z", &z));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("w", &w));
transformation->GetTransformation()->SetRotation(util::Vec3(x, y, z), w);
}
tinyxml2::XMLElement* scale = pData->FirstChildElement("Scale");
if(scale)
{
float x, y, z;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != scale->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != scale->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != scale->QueryFloatAttribute("z", &z));
transformation->GetTransformation()->SetScale(x, y, z);
}
return true;
}
void FullbrightMaterialComponent::onRender()
{
if(!hasModelData()) {
return;
}
const CameraComponent &cam = getOwner().getCameraManager().getCurrentCamera();
//const TransformComponent *camTransform = cam.getOwner()->getComponent<TransformComponent>();
TransformComponent *transform = getOwner().getComponent<TransformComponent>();
assert(transform);
CaffMath::Matrix44 worldMat = transform->getWorldMatrix();
glm::mat4 wMat;
memcpy(&wMat[0][0], &worldMat._11, sizeof(float) * 16);
// const glm::mat4 pMat = cam.getProjMatrix();
//
// CaffMath::Matrix44 viewMat = camTransform->getWorldMatrix();
// glm::mat4 vMat;
// const glm::mat4 vMat2 = cam.getViewMatrix();
//
// memcpy(&vMat[0][0], &viewMat._11, sizeof(float) * 16);
//
// //vMat = vMat._inverse();
// vMat = vMat2;
const glm::mat4 wvpMat = cam.getViewProjMatrix() * wMat;
CaffApp::Renderer &renderer = getOwner().getRenderer();
renderer.reset();
renderer.setShader(fullBrightShaderID);
renderer.setVertexFormat(fullBrightVertexID);
renderer.setTexture("diffuseTex", m_diffuseMapID);
renderer.setShader2f("texScale", &m_diffuseScale.x);
renderer.setShaderMatrix44f("wvpMat", &wvpMat[0][0]);
renderer.setShader4f("color", &m_rgba.x);
for(std::size_t i = 0; i < getModelData()->model->getNumberOfMeshes(); ++i)
{
renderer.setVertexBuffer(getModelData()->vertBufferIDs.at(i));
if(getModelData()->indexBufferIDs.size() < i)
{
renderer.setIndexBuffer(getModelData()->indexBufferIDs.at(i));
}
renderer.apply();
renderer.drawArray(CaffApp::Primitive::TRIANGLES, 0, getModelData()->model->getMesh(i).getGLFaces());
}
}
void SpriteComponent::update()
{
// setting position from Transform Component
TransformComponent* transform = parent.getComponent<TransformComponent>();
sprite.setPosition(utils::mToPx(transform->getX()),
utils::mToPx(transform->getY()) );
sprite.setRotation(utils::radToDeg(transform->getRotation()) );
GameManager& gameManager = GameManager::getInstance();
gameManager.getWindow().draw(sprite);
}
void BlinnPhongMaterialComponent::onRender()
{
if(!hasModelData()) {
return;
}
const CameraComponent &cam = getOwner().getCameraManager().getCurrentCamera();
TransformComponent *transform = getOwner().getComponent<TransformComponent>();
assert(transform);
CaffMath::Matrix44 worldMat = transform->getWorldMatrix();
glm::mat4 wMat;
memcpy(&wMat[0][0], &worldMat._11, sizeof(float) * 16);
const glm::mat4 wvpMat = cam.getViewProjMatrix() * wMat;
const TransformComponent *camTransform = cam.getOwner().getComponent<TransformComponent>();
assert(camTransform);
const glm::vec3 camPos = cam.getPosition();
CaffApp::Renderer &renderer = getOwner().getRenderer();
renderer.reset();
renderer.setShader(blinnShaderId);
renderer.setVertexFormat(blinnVertexId);
renderer.setTexture("diffuseTex", m_diffuseMapID);
renderer.setShader2f("texScale", &m_diffuseScale.x);
renderer.setShaderMatrix44f("wMat", &wMat[0][0]);
renderer.setShaderMatrix44f("wvpMat", &wvpMat[0][0]);
renderer.setShader3f("camPos", &camPos[0]);
renderer.setShader4f("color", &m_rgba.x);
LightUtils::UploadShaderInfo(renderer);
for(std::size_t i = 0; i < getModelData()->model->getNumberOfMeshes(); ++i)
{
renderer.setVertexBuffer(getModelData()->vertBufferIDs.at(i));
if(getModelData()->indexBufferIDs.size() < i)
{
renderer.setIndexBuffer(getModelData()->indexBufferIDs.at(i));
}
renderer.apply();
renderer.drawArray(CaffApp::Primitive::TRIANGLES, 0, getModelData()->model->getMesh(i).getGLFaces());
}
}
void CameraComponent::sendCamInformation( GeneralGlWindow * window )
{
glm::vec3 from = glm::vec3();
glm::vec3 to = glm::vec3(1,0,0);
glm::vec3 up = glm::vec3(0,1,0);
TransformComponent * trans = parent->getComponent<TransformComponent>();
if( trans != nullptr )
{
from = glm::vec3( trans->getTransformation() * glm::vec4( from, 1 ) );
to = glm::vec3( trans->getTransformation() * glm::vec4( to, 1 ) );
up = glm::vec3( trans->getRotationMatrix() * glm::vec4( up, 1 ) );
}
glm::mat4 camcam = glm::perspective(fov, aspect, camNear, camFar) * glm::lookAt( from, to, up );
window->setUniformParameter( "mvp", GeneralGlWindow::PT_MAT4, (float*)&camcam );
}
Quat TransformComponent::GetOrientation(bool Relative) const
{
//Entity* P = m_Entity->GetParent();
Quat Orientation = m_Orientation;
if(m_HasParent) {
TransformComponent* t = (TransformComponent*)m_RelativeTo->GetComponentByType(CT_TRANSFORM);
if(t) Orientation *= t->GetOrientation(Relative);
}
/*if(P && !Relative && m_InheritOrientation)
{
TransformComponent* t = GetTransformComponent(P);
if(t) Orientation *= t->GetOrientation(Relative);
P->Destroy();
}*/
return Orientation;
}
Vec3 TransformComponent::GetScale(bool Relative) const
{
//Entity* P = m_Entity->GetParent();
Vec3 Sc = m_Scale;
if(m_HasParent) {
TransformComponent* t = (TransformComponent*)m_RelativeTo->GetComponentByType(CT_TRANSFORM);
if(t) Sc *= t->GetScale(Relative);
}
/*if(P && !Relative && m_InheritScale)
{
TransformComponent* t = GetTransformComponent(P);
if(t) Sc *= t->GetScale(Relative);
P->Destroy();
}*/
return Sc;
}
CollisionComponent*
CollisionComponent::Factory(GameObject &gameObject, Collider *collider)
{
if (nullptr == collider)
{
TransformComponent *transform = static_cast<TransformComponent*>(gameObject.FilterComponent("Transform").front().get());
SDL_Rect pos = transform->GetPosition();
SDL_Rect *scale = transform->GetScale();
collider = new CircleCollider(Vector2D((float)pos.x, (float)pos.y), (scale->h/2));
}
CollisionComponent *collisionComponent = new CollisionComponent(collider);
gameObject.RegisterComponent(Component(new CollisionComponent(collider)));
return collisionComponent;
}
void TransformSystem::update_transform(TransformComponent& transform)
{
if (transform.mobility != Mobility::Dynamic)
{
throw InvalidOperation("TransformComponent is not dynamic");
}
Entity& entity = transform.entity();
EntityHandle parent = entity.parent();
if (parent)
{
// Update the transform hierarchy starting at this entity's parent
update_recursively(*parent, entity);
}
else
{
// Local and global are the same if there is no parent
transform.global_position = transform.local_position;
transform.global_scale = transform.local_scale;
transform.global_rotation = transform.local_rotation;
// Update the transform hierachy for all children
for (Entity& child : entity.children())
{
update_recursively(entity, child);
}
}
// Force the bounding box to update
_bounding_box_system.update_recursively(entity);
}
Vec3 TransformComponent::GetPosition(bool Relative) const
{
//Entity* P = m_Parent->GetParent();
Vec3 Pos = m_Position;
if(m_HasParent) {
TransformComponent* t = (TransformComponent*)m_RelativeTo->GetComponentByType(CT_TRANSFORM);
if(t) Pos += t->GetPosition(Relative);
}
/*if(P && !Relative && m_InheritPosition)
{
TransformComponent* t = GetTransformComponent(P);
if(t) Pos += t->GetPosition(Relative);
P->Destroy();
}*/
return Pos;
}
CascadedShadowMapper::CascadedShadowMapper(UCHAR cascades)
: m_cascades(cascades), m_ppTargets(NULL), /*m_camera(1024, 1024, 0.01, 1000),*/ m_pCascadesSettings(NULL), m_ppBlurChain(NULL)
{
/*
#ifdef CSM_DEBUG
for(USHORT i = 0; i < m_cascades; ++i)
{
m_cascadeCameraActor[i] = chimera::g_pApp->GetLogic()->VCreateActor("staticcamera.xml");
std::stringstream ss;
ss << "cascadeCam";
ss << i;
m_cascadeCameraActor[i]->SetName(ss.str());
}
#endif
*/
m_intensity = util::Vec3(1,1,1);
m_ambient = util::Vec3(0.1f, 0.1f, 0.1f);
std::unique_ptr<ActorDescription> desc = CmGetApp()->VGetLogic()->VGetActorFactory()->VCreateActorDescription();
CameraComponent* cc = desc->AddComponent<CameraComponent>(CM_CMP_CAMERA);
cc->SetCamera(std::shared_ptr<ICamera>(new util::FPSCamera(1,1,1e-2f,1e3)));
TransformComponent* tc = desc->AddComponent<TransformComponent>(CM_CMP_TRANSFORM);
m_lightActorCamera = CmGetApp()->VGetLogic()->VCreateActor(std::move(desc));
//util::Vec3 lightPos(1.0f,1.3f,0.6f);
util::Vec3 lightPos(1.0f, 0.2, 0);
lightPos.Normalize();
lightPos.Scale(util::Vec3(1000.0f, 1000.0f, 1000.0f));
tc->GetTransformation()->SetTranslation(lightPos.x, lightPos.y, lightPos.z);
cc->GetCamera()->MoveToPosition(tc->GetTransformation()->GetTranslation());
m_lightActorCamera->SetName("cascadeLightCamera");
/*
m_viewActor = chimera::g_pApp->GetLogic()->VCreateActor("rendercamera.xml");
m_viewActor->SetName("cascadeViewCamera");
m_viewActor->GetComponent<chimera::TransformComponent>(chimera::TransformComponent::COMPONENT_ID).lock()->GetTransformation()->SetTranslate(0,5,-5);
m_viewActor->GetComponent<chimera::CameraComponent>(chimera::CameraComponent::COMPONENT_ID).lock()->GetCamera()->MoveToPosition(
m_viewActor->GetComponent<chimera::TransformComponent>(chimera::TransformComponent::COMPONENT_ID).lock()->GetTransformation()->GetTranslation());
*/
ADD_EVENT_LISTENER(this, &CascadedShadowMapper::SetSunPositionDelegate, CM_EVENT_SET_SUN_POSITION);
ADD_EVENT_LISTENER(this, &CascadedShadowMapper::SetSunIntensityDelegate, CM_EVENT_SET_SUN_INTENSITY);
ADD_EVENT_LISTENER(this, &CascadedShadowMapper::SetSunAmbientDelegate, CM_EVENT_SET_SUN_AMBIENT);
}
Mat4 TransformComponent::GetTransform(bool Relative)
{
if(m_Updated)
{
/* To do: Optimize. */
m_Transform = Mat4::Identity;
if(m_Position.x + m_Position.y + m_Position.z != 0.0f) m_Transform = Translation(m_Position);
if(!m_FirstPerson) {
if(m_Orientation.w != 0.0f) m_Transform *= m_Orientation.ToMat();
} else {
Quat pitch = Quat(Vec3(1,0,0), m_FirstPersonYRot);
Quat yaw = Quat(Vec3(0,1,0), m_FirstPersonXRot);
m_Orientation = yaw * pitch;
if(m_Orientation.w != 0.0f) m_Transform *= m_Orientation.ToMat();
}
m_Transform *= SandboxSimulator::Scale(m_Scale);
m_NormalMatrix = m_Orientation.ToMat().Inverse().Transpose();
m_Updated = false;
}
//Entity* Parent = m_Entity->GetParent();
if(m_HasParent) {
TransformComponent* t = (TransformComponent*)m_RelativeTo->GetComponentByType(CT_TRANSFORM);
if(t)
{
Mat4 ret = m_Transform;
ret = t->GetOrientation(false).ToMat() * ret;
ret = SandboxSimulator::Translation(t->GetPosition(false)) * ret;
ret = SandboxSimulator::Scale(t->GetScale()) * ret;
return ret;
}
}
/*if(Parent && !m_Simulated && !Relative && (m_InheritPosition || m_InheritOrientation || m_InheritScale))
{
TransformComponent* t = GetTransformComponent(Parent);
if(t)
{
if(m_InheritPosition && m_InheritOrientation && m_InheritScale) return t->GetTransform(Relative) * m_Transform;
Matrix4 ret = m_Transform;
if(m_InheritOrientation) ret = t->GetOrientation(false).ToMatrix() * ret;
if(m_InheritPosition ) ret = Translation(t->GetPosition(false)) * ret;
if(m_InheritScale ) ret = Reality::Scale(t->GetScale()) * ret;
return ret;
}
}*/
return m_Transform;
}
void Camera::updateView(void){
if(isFollowing_){
TransformComponent* transformation = followee_->getComponent<TransformComponent>();
glm::fquat rotation = transformation->getRotation() * rotation_;
// glm::vec3 pos = pos_ + transformation->getPosition();
view_matrix_ = glm::translate(glm::mat4(1.0), transformation->getPosition()) * glm::mat4_cast(rotation) * glm::translate(glm::mat4(1.0), pos_);
}
else if(isMimicking_){
glm::vec3 pos = pos_ + followee_->getComponent<TransformComponent>()->getPosition();
view_matrix_ = glm::translate(glm::mat4(1.0), pos) * glm::mat4_cast(rotation_);
}
else{
view_matrix_ = glm::translate(glm::mat4(1.0), pos_) * glm::mat4_cast(rotation_);
}
view_matrix_ = glm::inverse(view_matrix_);
}
PongField::PongField(Scene& scene) :
Entity(scene)
{
Vector2f size(800.f, 600.f);
Engine& engine = m_Scene.getEngine();
// Add Component
TransformComponent* transform = new TransformComponent(*this);
add<TransformComponent>(transform);
RectangleColliderComponent* collider = new RectangleColliderComponent(*this, engine);
add<RectangleColliderComponent>(collider);
// Init
collider->setSize(size);
transform->setPosition(0, 0);
}
Actor* addSun(Scene *scene)
{
Actor* actor = new Actor;
TransformComponent* trans = new TransformComponent();
trans->setPos(vec3(0, 20, 0));
Rotation rot;
actor->addComponent(trans);
LightComponent* l = new DirectionalLightComponent();
l->setDirectional(1);
l->dir = normalize(vec3(0.5, 1, 0.2));
actor->addComponent(l);
scene->systemManager->getSystem(StringHash("GenericSystem").getHash())->addComponent(l);
scene->addActor(actor);
return actor;
}
void Shader::updateGlobalUniforms(const TransformComponent & transform)
{
for(unsigned i = 0; i < m_global_uniforms_names.size(); ++i)
{
auto uniform_name = m_global_uniforms_names[i];
auto uniform_type = m_global_uniforms_types[i];
switch(uniform_type)
{
case GL_FLOAT_MAT4:
{
if (G_MVP == uniform_name)
{
auto view = CoreServices::getRenderer()->getCamera()->m_view;
auto projection = CoreServices::getRenderer()->getCamera()->m_projection;
auto mvp = projection * view * transform.world_matrix();
setUniform(G_MVP, mvp);
}
else
if (G_MODEL_MATRIX == uniform_name)
{
setUniform(G_MODEL_MATRIX, transform.world_matrix());
}
break;
}
case GL_FLOAT_MAT3:
{
if (G_NORMAL_MATRIX == uniform_name)
{
setUniform(G_NORMAL_MATRIX, transform.normal_matrix());
}
break;
}
case GL_FLOAT_VEC3:
{
if (G_CAM_POS == uniform_name)
{
setUniform(G_CAM_POS, CoreServices::getRenderer()->getCameraTransform()->position());
}
}
}
}
}
