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()); } } } } }