void SwitchSystem::Process(float32 timeElapsed)
{
TIME_PROFILE("SwitchSystem::Process");
Set<Entity*>::iterator it;
Set<Entity*>::const_iterator itEnd = updatableEntities.end();
for(it = updatableEntities.begin(); it != itEnd; ++it)
{
Entity * entity = *it;
SwitchComponent * sw = (SwitchComponent*)entity->GetComponent(Component::SWITCH_COMPONENT);
if (sw->oldSwitchIndex != sw->newSwitchIndex)
{
SetSwitchHierarchy(entity, sw->newSwitchIndex);
sw->oldSwitchIndex = sw->newSwitchIndex;
ActionComponent* actionComponent = cast_if_equal<ActionComponent*>(entity->GetComponent(Component::ACTION_COMPONENT));
if(NULL != actionComponent)
{
actionComponent->StartSwitch(sw->newSwitchIndex);
}
}
}
updatableEntities.clear();
}
void RecordAndReplay::PlaceRecordedEntity()
{
if (recordedStates.empty())
return;
// pop first
Entity *nextRecorded = recordedStates.front();
recordedStates.pop();
// Find which entity in world to modify
Entity *toModify = ENGINE->GetActiveWorld()->FindEntity(placedEntity);
// set body to be the same as already placed body
if (toModify)
{
Body *bodyP = dynamic_cast<Body*>(toModify->GetComponent(BODY));
toModify->Clear();
toModify->CopyComponents(nextRecorded);
Body *bodyM = dynamic_cast<Body*>(toModify->GetComponent(BODY));
if (bodyM && bodyP)
{
bodyM->body = bodyP->body;
}
ENGINE->GetActiveWorld()->SyncBodyWithEntity(toModify);
// if this is the end of the recorded sequence, remove the replayed entity
if (recordedStates.empty())
{
ENGINE->GetActiveWorld()->RemoveEntity(toModify);
}
}
}
void SelectionSystem::Update()
{
Entity* selectedUnit = FindSingleSelectedEntity(Component::UNIT);
Entity* selectedTile = FindSingleSelectedEntity(Component::HOVER);
// if selected units were found, draw the selection frames
for (Entity* selectedEntity : { selectedUnit, selectedTile })
{
if (selectedEntity != nullptr)
{
SelectionComponent* sc = dynamic_cast<SelectionComponent*>(selectedEntity->GetComponent(Component::SELECTION));
if (sc->state == SelectionComponent::NEW)
{
AddSelectionTexture(selectedEntity);
engine->UpdateEntity(selectedEntity);
sc->state = SelectionComponent::OLD;
}
}
}
// if there is both a selected unit and a selected tile, draw the path between them
if (selectedUnit != NULL && selectedTile != NULL)
{
if (selectedUnit->GetComponent(Component::ANIMATION) != NULL)
{
// don't display the path while an animation is playing
ClearCurrentPath();
}
else
{
Grid selectedPos = dynamic_cast<PositionComponent*>(selectedTile->GetComponent(Component::POSITION))->pos.ToGrid();
if (selectedPos != lastHoveredPos)
{
CreateCurrentPath(selectedUnit, selectedTile);
lastHoveredPos = selectedPos;
AddSelectionTexture(selectedTile);
}
}
}
else
{
ClearCurrentPath();
if (selectedTile != NULL)
{
AddSelectionTexture(selectedTile);
}
}
}
void AISystem::SelectTarget(Vector2 pos)
{
Entity* selectedTile = engine->GetEntityStream()->EntityWithTags({ Component::SELECTION, Component::HOVER });
PositionComponent* tpc = dynamic_cast<PositionComponent*>(selectedTile->GetComponent(Component::POSITION));
tpc->pos = pos;
engine->UpdateEntity(selectedTile);
}
void MapSystem::OnSpawnEntity(const Message& msg)
{
const SpawnEntityMessage& m = static_cast<const SpawnEntityMessage&>(msg);
Entity* entity;
GetEntityManager().CreateEntity(entity);
std::string spawnerName = m.GetSpawnerName();
bool success = Spawn(spawnerName, *entity);
if(!success)
{
LOG_ERROR("Could not spawn entity: spawner not found: " + spawnerName);
return;
}
MapComponent* comp;
if(!entity->GetComponent(comp))
{
entity->CreateComponent(comp);
}
comp->SetUniqueId(m.GetUniqueId());
comp->SetEntityName(m.GetEntityName());
EntitySpawnedMessage smsg;
smsg.SetSpawnerName(spawnerName);
smsg.SetAboutEntityId(entity->GetId());
GetEntityManager().EmitMessage(smsg);
if(m.GetAddToScene())
{
GetEntityManager().AddToScene(entity->GetId());
}
}
Entity * EditorScene::FindSelected(Entity * curr, btCollisionObject * coll)
{
Entity * node = curr;
// LIGHT
// if (node == 0)
// node = dynamic_cast<LightNode *> (curr);
if (node == 0)
node = dynamic_cast<UserNode *> (curr);
BulletComponent * bulletComponent = (BulletComponent*)node->GetComponent(Component::BULLET_COMPONENT);
if (bulletComponent && bulletComponent->GetBulletObject())
{
BulletObject * bulletObject = (BulletObject*)bulletComponent->GetBulletObject();
if (bulletObject->GetCollisionObject() == coll)
return curr;
}
int size = curr->GetChildrenCount();
for (int i = 0; i < size; i++)
{
Entity * result = FindSelected(curr->GetChild(i), coll);
if (result)
return result;
}
return 0;
}
void CreateHealthPickup(Entity *e, SpawnEntityMessage *msg)
{
const int hitboxSize = 43;
Entity *spawner = msg->Spawner();
LocationComponent *spawnerLocation = static_cast<LocationComponent *>(spawner->GetComponent(ComponentType::LOCATION));
double x = spawnerLocation->GetX();
double y = spawnerLocation->GetY();
e->AddComponent(ComponentType::LOCATION, std::unique_ptr<Component>(new LocationComponent(x, y)));
e->AddComponent(ComponentType::VELOCITY, std::unique_ptr<Component>(new VelocityComponent(0, 0)));
e->AddComponent(ComponentType::PHYSICS, std::unique_ptr<Component>(new PhysicsComponent));
std::unique_ptr<GraphicsComponent> graphics(new GraphicsComponent());
graphics->AddFrame(0, 400000);
std::unique_ptr<CollisionComponent> collision(new CollisionComponent);
collision->AddHitbox(0, 0, hitboxSize, hitboxSize, HitboxType::TRIGGER);
e->AddComponent(ComponentType::COLLISION, std::move(collision));
e->AddComponent(ComponentType::GRAPHICS, std::move(graphics));
VMState healCollider = Compiler::Compile("data/scripts/HealColliderScript.txt");
RegisterNativeBindings(healCollider);
e->AddVmScript(std::move(healCollider));
}
Entity* SkyboxSystem::AddSkybox()
{
Entity* result = skyboxEntity;
if(NULL == skyboxEntity)
{
SkyboxRenderObject* skyboxRenderObject = new SkyboxRenderObject();
AABBox3 box = AABBox3(Vector3(-0.5f, -0.5f, -0.5f), Vector3(0.5f, 0.5f, 0.5f));
skyboxRenderObject->Initialize(box); //first time initialization
RenderComponent* renderComponent = new RenderComponent();
renderComponent->SetRenderObject(skyboxRenderObject);
result = new Entity();
result->SetName("Skybox");
result->RemoveComponent(Component::RENDER_COMPONENT);
result->AddComponent(renderComponent);
renderComponent->Release();
GetScene()->AddNode(result);
Matrix4 * worldTransformPointer = ((TransformComponent*)result->GetComponent(Component::TRANSFORM_COMPONENT))->GetWorldTransformPtr();
skyboxRenderObject->SetWorldTransformPtr(worldTransformPointer);
result->GetScene()->renderSystem->MarkForUpdate(skyboxRenderObject);
SafeRelease(skyboxRenderObject);
DVASSERT(skyboxEntity);
result->Release();
}
return result;
}
void EC_Mesh::AutoSetPlaceable()
{
Entity* entity = ParentEntity();
if (entity)
{
ComponentPtr placeable = entity->GetComponent(EC_Placeable::TypeNameStatic());
if (placeable)
SetPlaceable(placeable);
}
}
void MouseSystem::DeselectCurrentUnit()
{
Entity* selectedUnit = engine->GetEntityStream()->EntityWithTags({ Component::SELECTION, Component::UNIT });
if (selectedUnit != nullptr)
{
SelectionComponent* sc = dynamic_cast<SelectionComponent*>(selectedUnit->GetComponent(Component::SELECTION));
sc->state = SelectionComponent::TO_DELETE;
}
}
inline Landscape* Test::GetLandscape()
{
SettingsManager* settings = SettingsManager::Instance();
Entity* landscapeNode = GetScene()->FindByName(settings->GetLandscapeNodeName());
Landscape* landscape = NULL;
if (landscapeNode)
{
RenderComponent* renderComponent = cast_if_equal<RenderComponent*>(landscapeNode->GetComponent(Component::RENDER_COMPONENT));
if (renderComponent)
{
landscape = dynamic_cast<Landscape*>(renderComponent->GetRenderObject());
}
}
return landscape;
}
virtual void Init()
{
if(mInit)
{
return;
}
mInit = true;
assert(mEntity != NULL);
dtEntityOSG::StaticMeshComponent* smc;
if(!mEntity->GetComponent(smc))
{
LOG_ERROR("Error setting up wheel component: Please add mesh component first");
return;
}
PropertyArray props = mWheels.ArrayValue();
for(PropertyArray::iterator i = props.begin(); i != props.end(); ++i)
{
Property* prop = *i;
assert(prop->GetDataType() == DataType::GROUP);
PropertyGroup pg = prop->GroupValue();
assert(pg.find(SID("NodeName")) != pg.end());
assert(pg.find(SID("Radius")) != pg.end());
std::string nodeName = pg[SID("NodeName")]->StringValue();
float radius = pg[SID("Radius")]->FloatValue();
osg::ref_ptr<FindNamedNodeVisitor> v = new FindNamedNodeVisitor(nodeName);
smc->GetNode()->accept(*v);
osgSim::DOFTransform* trans = dynamic_cast<osgSim::DOFTransform*>(v->getNode());
if(trans != NULL)
{
mDOFs.push_back(std::make_pair(trans, radius));
}
}
SetSpeed(mSpeed.FloatValue());
}
/**
* Move all recorded entity positions to be relative to mouse click and
* relative to position of first entity in recording sequence.
*
* @param mouseX, mouseY Mouse coordinates
*/
void RecordAndReplay::MoveRecordedPositionsRelativeTo(int mouseX, int mouseY)
{
int firstX, firstY;
Entity *next;
for (int i = 0; i < static_cast<int>(recordedStates.size()); i++)
{
next = recordedStates.front();
recordedStates.pop();
Position *nextPos = dynamic_cast<Position*>(next->GetComponent(POSITION));
if (i == 0)
{
// Save original position of first entity in recording sequence
firstX = nextPos->x;
firstY = nextPos->y;
}
nextPos->x = mouseX + (nextPos->x - firstX);
nextPos->y = mouseY + (nextPos->y - firstY);
// put item back in queue
recordedStates.push(next);
}
}
void SpritePackerHelper::ReloadParticleSprites(SceneData* sceneData)
{
List<Entity*> particleEffects;
sceneData->GetAllParticleEffects(particleEffects);
for (auto it = particleEffects.begin(); it != particleEffects.end(); ++it)
{
Entity* curNode = (*it);
ParticleEffectComponent * effectComponent = cast_if_equal<ParticleEffectComponent*>(curNode->GetComponent(Component::PARTICLE_EFFECT_COMPONENT));
if (!effectComponent)
{
continue;
}
effectComponent->Stop();
// All the children of this Scene Node must have Emitter components.
int32 emittersCount = curNode->GetChildrenCount();
for (int32 i = 0; i < emittersCount; i ++)
{
Entity* childNode = curNode->GetChild(i);
ParticleEmitter * emitter = GetEmitter(childNode);
if (!emitter)
{
continue;
}
emitter->ReloadLayerSprites();
}
effectComponent->Start();
}
}
Graphics::Sprite SelectionSystem::GetSelectionSpriteForEntity(Entity* entity)
{
// entity is unit
if (entity->GetComponent(Component::UNIT) != NULL)
{
return Graphics::SPRITE_SELECT_HIGHLIGHT;
}
// entity is hover texture
else
{
Entity* selectedUnit = engine->GetEntityStream()->EntityWithTags({ Component::SELECTION, Component::UNIT });
// if there is no currently selected unit
if (selectedUnit == nullptr)
{
return Graphics::SPRITE_SELECT;
}
// if there is a selected unit
else
{
Context::GameState gameState = engine->GetContext()->GetGameState();
World* world = engine->GetContext()->GetWorld();
Entity* unitOnTile = FindUnitOnTile(entity);
// if there is a unit on the hovered tile
if (unitOnTile != nullptr)
{
UnitComponent* uc = dynamic_cast<UnitComponent*>(unitOnTile->GetComponent(Component::UNIT));
// if the unit is an enemy
if ((gameState == Context::PL_PLAY && uc->player == Entity::AI)
|| (gameState == Context::AI_PLAY && uc->player == Entity::HUMAN)
)
{
// if the unit is within range
if (world->IsEnemyInRange(selectedUnit, unitOnTile))
{
return Graphics::SPRITE_CROSSHAIR;
}
else
{
return Graphics::SPRITE_SELECT;
}
}
// if the unit is an ally
else
{
return Graphics::SPRITE_SELECT;
}
}
// if the hovered tile is terrain
else
{
// if the tile is unreachable for the selectedunit
if (currentPath.size() == 0)
{
return Graphics::SPRITE_CROSS_GREY;
}
// if it is reachable
else
{
UnitComponent* uc = dynamic_cast<UnitComponent*>(selectedUnit->GetComponent(Component::UNIT));
if (uc && static_cast<int>(currentPath.size()) <= uc->ap)
{
// no feet underneath SPRITE_DESTINATION
engine->RemoveEntity(*currentPath.rbegin());
currentPath.pop_back();
return Graphics::SPRITE_DESTINATION;
}
else {
return Graphics::SPRITE_SELECT;
}
}
}
}
}
}
Entity* ParticlesEditorSceneModelHelper::PreprocessSceneNode(Entity* rawNode)
{
// There is one and only preprocessing case - if the "raw" node is "orphaned" Particles Emitter
// (without the ParticlesEffectNode parent), we'll create the new Particles Effect node and
// move the raw Emitter node to it.
ParticleEmitter * emitter = GetEmitter(rawNode);
if (!emitter)
{
return rawNode;
}
//ParticleEmitterNode* emitterNode = static_cast<ParticleEmitterNode*>(rawNode);
//emitterNode->SetEmitter(emitterComponent->GetParticleEmitter());
Entity* curParentNode = rawNode->GetParent();
ParticleEffectComponent * effectComponent = cast_if_equal<ParticleEffectComponent*>(curParentNode->GetComponent(Component::PARTICLE_EFFECT_COMPONENT));
// If the Emitter Node has parent, but its parent is not ParticleEffectNode, we need to
// "adopt" this node by creating ParticleEffect node and attaching.
if (curParentNode && (effectComponent == NULL))
{
Entity* newParentNodeParticleEffect = CreateParticleEffectNode();
curParentNode->AddNode(newParentNodeParticleEffect);
// Add the emitter node to the new Effect (this will also remove it from the scene).
newParentNodeParticleEffect->AddNode(rawNode);
// Register the Particle Editor structure for the new node.
EffectParticleEditorNode* effectEditorNode =
ParticlesEditorController::Instance()->RegisterParticleEffectNode(newParentNodeParticleEffect);
EmitterParticleEditorNode* emitterEditorNode = new EmitterParticleEditorNode(newParentNodeParticleEffect,
rawNode, QString::fromStdString(rawNode->GetName()));
effectEditorNode->AddNode(emitterEditorNode);
return newParentNodeParticleEffect;
}
// No preprocessing needed.
return rawNode;
}
void SpritePackerHelper::EnumerateSpritesForReloading(SceneData* sceneData, Map<String, Sprite *> &sprites)
{
List<Entity*> particleEffects;
sceneData->GetAllParticleEffects(particleEffects);
for (auto it = particleEffects.begin(); it != particleEffects.end(); ++it)
{
Entity* curNode = (*it);
ParticleEffectComponent * effectComponent = cast_if_equal<ParticleEffectComponent*>(curNode->GetComponent(Component::PARTICLE_EFFECT_COMPONENT));
if (!effectComponent)
{
continue;
}
bool isStopped = effectComponent->IsStopped();
if (!isStopped)
{
effectComponent->Stop();
}
// All the children of this Scene Node must have Emitter components.
int32 emittersCount = curNode->GetChildrenCount();
for (int32 i = 0; i < emittersCount; i ++)
{
Entity* childNode = curNode->GetChild(i);
ParticleEmitter * emitter = GetEmitter(childNode);
EnumerateSpritesForParticleEmitter(emitter, sprites);
}
if (!isStopped)
{
effectComponent->Start();
}
}
}
void SpritePackerHelper::EnumerateSpritesForReloading(SceneData* sceneData, Map<String, Sprite *> &sprites)
{
List<Entity*> particleEffects;
sceneData->GetAllParticleEffects(particleEffects);
for (auto it = particleEffects.begin(); it != particleEffects.end(); ++it)
{
Entity* curNode = (*it);
ParticleEffectComponent * effectComponent = cast_if_equal<ParticleEffectComponent*>(curNode->GetComponent(Component::PARTICLE_EFFECT_COMPONENT));
if (!effectComponent)
{
continue;
}
effectComponent->Stop();
// All the children of this Scene Node must have Emitter components.
int32 emittersCount = curNode->GetChildrenCount();
for (int32 i = 0; i < emittersCount; i ++)
{
Entity* childNode = curNode->GetChild(i);
ParticleEmitter * emitter = GetEmitter(childNode);
if (!emitter)
{
continue;
}
Vector<ParticleLayer*> & layers = emitter->GetLayers();
int32 layersCount = layers.size();
for (int il = 0; il < layersCount; ++il)
{
Sprite *sprite = layers[il]->GetSprite();
sprites[sprite->GetRelativePathname()] = sprite;
}
}
effectComponent->Start();
}
}
void CreateBullet(Entity *e, SpawnEntityMessage *msg)
{
const int bulletHitboxSize = 15;
Entity *spawner = msg->Spawner();
LocationComponent *spawnerLocation = static_cast<LocationComponent *>(spawner->GetComponent(ComponentType::LOCATION));
FactionComponent *spawnerFaction = static_cast<FactionComponent *>(spawner->GetComponent(ComponentType::FACTION));
SDL_assert(spawnerLocation != nullptr);
Faction bulletFaction = Faction::NONE;
if (spawnerFaction != nullptr)
{
bulletFaction = spawnerFaction->GetFaction();
}
double x = spawnerLocation->GetX();
double y = spawnerLocation->GetY();
double speed = 10.0;
double xVel = 0;
double yVel = 0;
Direction direction = spawnerLocation->GetFiringDirection();
switch (direction)
{
case Direction::RIGHT:
x += bulletHitboxSize;
xVel = speed;
break;
case Direction::LEFT:
x -= bulletHitboxSize;
xVel = -speed;
break;
case Direction::UP:
y -= bulletHitboxSize;
yVel = -speed;
break;
case Direction::DOWN:
y += bulletHitboxSize;
yVel = speed;
break;
default:
break;
}
std::unique_ptr<LocationComponent> location(new LocationComponent());
location->SetLocation(x, y);
location->SetDirection(direction);
std::unique_ptr<GraphicsComponent> graphics(new GraphicsComponent());
graphics->AddFrame(0, 200007);
std::unique_ptr<CollisionComponent> collision(new CollisionComponent);
collision->AddHitbox(8, 8, bulletHitboxSize, bulletHitboxSize, HitboxType::TRIGGER);
std::unique_ptr<VelocityComponent> velocity(new VelocityComponent(0, 0));
velocity->SetVelocity(xVel, yVel);
std::unique_ptr<FactionComponent> faction(new FactionComponent(bulletFaction));
std::unique_ptr<SoundComponent> sound(new SoundComponent());
sound->AddSoundEffect(SoundEffectType::DEATH, SOUND_GUN_HIT);
e->AddComponent(ComponentType::SOUND, std::move(sound));
e->AddComponent(ComponentType::COLLISION, std::move(collision));
e->AddComponent(ComponentType::GRAPHICS, std::move(graphics));
e->AddComponent(ComponentType::LOCATION, std::move(location));
e->AddComponent(ComponentType::VELOCITY, std::move(velocity));
e->AddComponent(ComponentType::FACTION, std::move(faction));
VMState damageColliderScript = Compiler::Compile("data/scripts/DamageColliderScript.txt");
RegisterNativeBindings(damageColliderScript);
e->AddVmScript(std::move(damageColliderScript));
VMState bulletScript = Compiler::Compile("data/scripts/BulletScript.txt");
RegisterNativeBindings(bulletScript);
e->AddVmScript(std::move(bulletScript));
}
void MouseSystem::Update()
{
World* world = engine->GetContext()->GetWorld();
//Grids made as boundaries for the level
Grid upperLeft(0, 0);
Grid bottomRight(world->GetHeight(), world->GetWidth());
if (engine->GetContext()->GetGameState() == Context::PL_PLAY)
{
//Hover event
if (al->IsMouseEvent()) {
ALLEGRO_EVENT ev = al->GetCurrentEvent();
Vector2 vector2(ev.mouse.x, ev.mouse.y);
Grid grid = Graphics::Instance().FromPx(vector2);
if (grid < bottomRight && grid >= upperLeft) {
//Update the old position of the selectionTile.
Entity* selectedTile = engine->GetEntityStream()->EntityWithTags({ Component::SELECTION, Component::HOVER });
PositionComponent* pc = dynamic_cast<PositionComponent*>(selectedTile->GetComponent(Component::POSITION));
pc->pos = Graphics::Instance().ToPx(grid);
engine->UpdateEntity(selectedTile);
}
}
//Click Event
else if (al->IsMouseClickEvent())
{
// left click
if (al->GetCurrentEvent().mouse.button == 1) {
ALLEGRO_EVENT ev = al->GetCurrentEvent();
Vector2 vector2(ev.mouse.x, ev.mouse.y);
Grid grid = Graphics::Instance().FromPx(vector2);
if (grid < bottomRight && grid >= upperLeft)
{
//Select a tile by getting it from the matrix in world and checking the entitystream to know if there's a unit on the tile.
Entity* tile = world->getEntity(grid.row, grid.col);
std::set<Entity*> entities = engine->GetEntityStream()->WithTag(Component::UNIT);
for (Entity* ent : entities) {
PositionComponent* position = dynamic_cast<PositionComponent*>(ent->GetComponent(Component::POSITION));
if (grid == Graphics::Instance().FromPx(position->pos)) {
tile = ent;
}
}
//There was a unit selected.
Entity* currentUnit = engine->GetEntityStream()->EntityWithTags({ Component::SELECTION, Component::UNIT });
if (currentUnit != NULL) {
//Attack
if (tile->GetComponent(Component::UNIT) != NULL &&
((UnitComponent*)tile->GetComponent(Component::UNIT))->player == Entity::Player::AI) {
Attack(currentUnit, vector2, tile);
}
else if (tile->GetComponent(Component::UNIT) != NULL &&
((UnitComponent*)tile->GetComponent(Component::UNIT))->player == Entity::Player::HUMAN &&
((UnitComponent*)tile->GetComponent(Component::UNIT))->type != Entity::UnitType::HQ &&
((UnitComponent*)tile->GetComponent(Component::UNIT))->ap>0) {
SelectUnit(tile);
}
//Move the unit.
else if (tile->GetComponent(Component::UNIT) == NULL) {
//Calculate path to selected tile
std::vector<Grid> path = engine->GetContext()->GetPathfinder()->FindPath(currentUnit, tile);
Move(currentUnit, vector2, path);
}
}
//There was no unit selected.
else
{
//Select the unit if its a unit. The unit should not be a HQ.
if (tile->GetComponent(Component::UNIT) != NULL
&& ((UnitComponent*)tile->GetComponent(Component::UNIT))->player == Entity::Player::HUMAN
&& ((UnitComponent*)tile->GetComponent(Component::UNIT))->type != Entity::UnitType::HQ
&& ((UnitComponent*)tile->GetComponent(Component::UNIT))->ap > 0
)
{
SelectUnit(tile);
}
}
}
}
// right click
else if (al->GetCurrentEvent().mouse.button == 2)
{
DeselectCurrentUnit();
}
}
}
}
bool GameProcess::VOnMouseButtonUp( const int iButtonIndex, const Vector3& vPosition )
{
Vector3 vResolution( IRenderer::Get()->VGetScreenWidth(), IRenderer::Get()->VGetScreenHeight(), 1.0f );
Vector3 vRayPos, vRayDir;
Matrix::Unproject( vPosition, vResolution, m_pCamera->GetProjection(), m_pCamera->GetView(), vRayPos, vRayDir );
float fDistance = 0.0f;
if ( iButtonIndex == 0 )
{
if ( m_pHeightMapEntity->VPick( vRayPos, vRayDir, &fDistance ) )
{
if ( fDistance < 0.0f )
fDistance = -fDistance;
Transform& transform = m_pMrBitey->GetTransform();
if ( InputManager::Get()->GetKeyState( KEY_T ) == HELD_KEYSTATE )
{
transform.SetPosition( vRayPos + vRayDir * fDistance + Vector3::UP );
}
else
{
Vector4 vTarget = vRayPos + vRayDir * fDistance + Vector3( 0.0f, 1.0f, 0.0f );
m_pSteering->SetTargetPosition( vTarget );
}
return false;
}
}
else if ( iButtonIndex == 1 )
{
SceneNode* pSceneNode = SceneManager::Get()->VPickAndReturnClosest( vRayPos, vRayDir, &fDistance );
if ( pSceneNode )
{
Entity* pEntity = pSceneNode->VGetEntity();
if ( pEntity )
{
if ( pEntity != m_pHeightMapEntity->GetOwner() )
{
Transform& matTransform = m_pMrBitey->GetTransform();
Vector4 vPosition( pEntity->GetTransform().GetPosition() - Vector4( Vector4( 0.0f, 0.0f, -20.0f ) ) );
m_pHeightMapEntity->GetHeight( vPosition.x, vPosition.z, vPosition.y );
matTransform.SetPosition( vPosition );
InteractableComponent* pInteractable = (InteractableComponent*)pEntity->GetComponent( InteractableComponent::g_hID );
if ( pInteractable )
{
pInteractable->VOnInteract( m_pMrBitey );
}
Combat::InitiateCombat( m_pCamera, m_pMrBitey, pEntity );
}
else
{
Matrix matTransform;
matTransform.BuildScale( Vector4::ONE * 2.0f );
vRayDir.Normalize();
matTransform.SetPosition( vRayPos + vRayDir * fDistance + Vector4( 0.0f, 1.0f, 0.0f ) );
Entity* pEntity = Game::CreateEntity( matTransform );
MeshComponent* pMeshComponent = new MeshComponent();
pEntity->AddComponent( pMeshComponent );
Mesh* pMesh = Mesh::CreateBox();
pMeshComponent->SetMesh( pMesh );
pMesh->Release();
pMeshComponent->Start();
pMeshComponent->Release();
TalkerComponent* pTalker = new TalkerComponent( "Dialogue.xml" );
pEntity->AddComponent( pTalker );
pTalker->Start();
pTalker->Release();
StateMachineComponent* pStateMachine = new StateMachineComponent();
pEntity->AddComponent( pStateMachine );
//pStateMachine->Start();
pStateMachine->Release();
Character* pCharacter = new Character();
XmlResource* pResource = AssetManager::Get().GetAsset<XmlResource>( "CombatAbilities.xml" );
if ( pResource )
{
auto pElement = pResource->GetRoot()->FirstChildElement();
while ( pElement )
{
CombatAbility ability;
ability.VFromXML( pElement );
pCharacter->AddAbility( ability );
pElement = pElement->NextSiblingElement( "Ability" );
}
}
pEntity->AddComponent( pCharacter );
pCharacter->Release();
/*ParticleEmitter* pSystem = new ParticleEmitter();
pEntity->AddComponent( pSystem );
pSystem->Start();
pSystem->SetTexture( "explosion.png" );
EmitterProcessor* pPositionProcessor = new SphericalSpawnPositionProcessor( 0.5f );
pSystem->AddProcessor( pPositionProcessor );
pPositionProcessor->Release();
pPositionProcessor = new SpawnPositionProcessor( Vector3( 0.0f, 2.0f, 0.0f ) );
pSystem->AddProcessor( pPositionProcessor );
pPositionProcessor->Release();
//pPositionProcessor = new VelocityOverAgeProcessor( new CurveModifier( Vector3( 0.0f, 2.0f, 0.0f ) * 5.0f, Vector3( 1.0f, 2.0f, 1.0f ) * 5.0f, Vector3( -1.0f, 2.0f, -1.0f ) * 5.0f, Vector3( 1.0f, 2.0f, 1.0f ) * 5.0f ) );
pPositionProcessor = new VelocityOverAgeProcessor( new ConstantEmitterModifier( Vector3::UP * 5.0f ) );
pSystem->AddProcessor( pPositionProcessor );
pPositionProcessor->Release();
pPositionProcessor = new RadialVelocityProcessor( Vector3( 1.0f, 1.0f, 1.0f ) * 20.0f );
pSystem->AddProcessor( pPositionProcessor );
pPositionProcessor->Release();
pPositionProcessor = new ColorOverAgeProcessor( new CurveModifier( Vector3::ZERO, Vector3( 1.0f, 0.0f, 0.0f ), Vector3( 0.0f, 1.0f, 0.0f ), Vector3( 0.0f, 0.0f, 1.0f ) ) );
pSystem->AddProcessor( pPositionProcessor );
pPositionProcessor->Release();
pSystem->Release();*/
}
}
}
}
return false;
}
bool EC_Mesh::SetMesh(QString meshResourceName, bool clone)
{
if (!ViewEnabled())
return false;
OgreWorldPtr world = world_.lock();
std::string mesh_name = meshResourceName.trimmed().toStdString();
RemoveMesh();
// If placeable is not set yet, set it manually by searching it from the parent entity
if (!placeable_)
{
Entity* entity = ParentEntity();
if (entity)
{
ComponentPtr placeable = entity->GetComponent(EC_Placeable::TypeNameStatic());
if (placeable)
placeable_ = placeable;
}
}
Ogre::SceneManager* sceneMgr = world->OgreSceneManager();
Ogre::Mesh* mesh = PrepareMesh(mesh_name, clone);
if (!mesh)
return false;
try
{
entity_ = sceneMgr->createEntity(world->GetUniqueObjectName("EC_Mesh_entity"), mesh->getName());
if (!entity_)
{
LogError("EC_Mesh::SetMesh: Could not set mesh " + mesh_name);
return false;
}
entity_->setRenderingDistance(drawDistance.Get());
entity_->setCastShadows(castShadows.Get());
entity_->setUserAny(Ogre::Any(static_cast<IComponent *>(this)));
// Set UserAny also on subentities
for(uint i = 0; i < entity_->getNumSubEntities(); ++i)
entity_->getSubEntity(i)->setUserAny(entity_->getUserAny());
if (entity_->hasSkeleton())
{
Ogre::SkeletonInstance* skel = entity_->getSkeleton();
// Enable cumulative mode on skeletal animations
if (skel)
skel->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
}
// Make sure adjustment node is uptodate
Transform newTransform = nodeTransformation.Get();
adjustment_node_->setPosition(newTransform.pos);
adjustment_node_->setOrientation(newTransform.Orientation());
// Prevent Ogre exception from zero scale
adjustment_node_->setScale(Max(newTransform.scale, float3::FromScalar(0.0000001f)));
// Force a re-apply of all materials to this new mesh.
ApplyMaterial();
}
catch(Ogre::Exception& e)
{
LogError("EC_Mesh::SetMesh: Could not set mesh " + mesh_name + ": " + std::string(e.what()));
return false;
}
AttachEntity();
emit MeshChanged();
return true;
}
void DebugRenderSystem::Process()
{
uint32 size = entities.size();
for(uint32 i = 0; i < size; ++i)
{
Entity * entity = entities[i];
DebugRenderComponent * debugRenderComponent = cast_if_equal<DebugRenderComponent*>(entity->GetComponent(Component::DEBUG_RENDER_COMPONENT));
TransformComponent * transformComponent = cast_if_equal<TransformComponent*>(entity->GetComponent(Component::TRANSFORM_COMPONENT));
//RenderComponent * renderComponent = cast_if_equal<RenderComponent*>(entity->GetComponent(Component::RENDER_COMPONENT));
Matrix4 worldTransform = /*(*transformComponent->GetWorldTransform()) * */camera->GetMatrix();
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, camera->GetMatrix());
AABBox3 debugBoundigBox = entity->GetWTMaximumBoundingBoxSlow();
uint32 debugFlags = debugRenderComponent->GetDebugFlags();
// Camera debug draw
if(debugFlags & DebugRenderComponent::DEBUG_DRAW_CAMERA)
{
CameraComponent * entityCameraComp = (CameraComponent *) entity->GetComponent(Component::CAMERA_COMPONENT);
if(NULL != entityCameraComp)
{
Camera* entityCamera = entityCameraComp->GetCamera();
if(NULL != entityCamera && camera != entityCamera)
{
Color camColor(0.0f, 1.0f, 0.0f, 1.0f);
Vector3 camPos = entityCamera->GetPosition();
//Vector3 camDirect = entityCamera->GetDirection();
AABBox3 camBox(camPos, 2.5f);
// If this is clip camera - show it as red camera
if (entityCamera == entity->GetScene()->GetClipCamera()) camColor = Color(1.0f, 0.0f, 0.0f, 1.0f);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE);
RenderManager::Instance()->SetColor(camColor);
RenderHelper::Instance()->DrawBox(camBox, 2.5f);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->ResetColor();
debugBoundigBox = camBox;
}
}
}
// UserNode debug draw
if(debugFlags & DebugRenderComponent::DEBUG_DRAW_USERNODE)
{
if(NULL != entity->GetComponent(Component::USER_COMPONENT))
{
Color dcColor(0.0f, 0.0f, 1.0f, 1.0f);
AABBox3 dcBox(Vector3(), 1.0f);
Matrix4 prevMatrix = RenderManager::Instance()->GetMatrix(RenderManager::MATRIX_MODELVIEW);
Matrix4 finalMatrix = transformComponent->GetWorldTransform() * prevMatrix;
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, finalMatrix);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE | RenderState::STATE_DEPTH_TEST);
RenderManager::Instance()->SetColor(1.f, 1.f, 0, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(1.f, 0, 0));
RenderManager::Instance()->SetColor(1.f, 0, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 1.f, 0));
RenderManager::Instance()->SetColor(0, 1.f, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 0, 1.f));
RenderManager::Instance()->SetColor(dcColor);
RenderHelper::Instance()->DrawBox(dcBox);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->ResetColor();
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, prevMatrix);
dcBox.GetTransformedBox(transformComponent->GetWorldTransform(), debugBoundigBox);
}
}
// LightNode debug draw
if (debugFlags & DebugRenderComponent::DEBUG_DRAW_LIGHT_NODE)
{
LightComponent *lightComp = (LightComponent *) entity->GetComponent(Component::LIGHT_COMPONENT);
if(NULL != lightComp)
{
Light* light = lightComp->GetLightObject();
if(NULL != light)
{
Vector3 lPosition = light->GetPosition();
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 0.0f, 1.0f);
switch (light->GetType())
{
case Light::TYPE_DIRECTIONAL:
{
Vector3 lDirection = light->GetDirection();
RenderHelper::Instance()->DrawArrow(lPosition, lPosition + lDirection * 10, 2.5f);
RenderHelper::Instance()->DrawBox(AABBox3(lPosition, 0.5f), 1.5f);
debugBoundigBox = AABBox3(lPosition, 2.5f);
}
break;
default:
{
AABBox3 lightBox(lPosition, 2.5f);
RenderHelper::Instance()->DrawBox(lightBox, 2.5f);
debugBoundigBox = lightBox;
}
break;
}
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->ResetColor();
}
}
}
if ((debugFlags & DebugRenderComponent::DEBUG_DRAW_AABOX_CORNERS))
{
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE | RenderState::STATE_DEPTH_TEST);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
RenderHelper::Instance()->DrawCornerBox(debugBoundigBox, 1.5f);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
// RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, prevMatrix);
}
if (debugFlags & DebugRenderComponent::DEBUG_DRAW_RED_AABBOX)
{
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE);
RenderManager::Instance()->SetColor(1.0f, 0.0f, 0.0f, 1.0f);
RenderHelper::Instance()->DrawBox(debugBoundigBox, 1.5f);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
}
// UserNode Draw
#if 0
if (debugFlags & DEBUG_DRAW_USERNODE)
{
Matrix4 prevMatrix = RenderManager::Instance()->GetMatrix(RenderManager::MATRIX_MODELVIEW);
Matrix4 finalMatrix = worldTransform * prevMatrix;
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, finalMatrix);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderStateBlock::STATE_COLORMASK_ALL | RenderStateBlock::STATE_DEPTH_WRITE | RenderStateBlock::STATE_DEPTH_TEST);
RenderManager::Instance()->SetColor(0, 0, 1.0f, 1.0f);
RenderHelper::Instance()->DrawBox(drawBox);
RenderManager::Instance()->SetColor(1.f, 1.f, 0, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(1.f, 0, 0));
RenderManager::Instance()->SetColor(1.f, 0, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 1.f, 0));
RenderManager::Instance()->SetColor(0, 1.f, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 0, 1.f));
RenderManager::Instance()->SetState(RenderStateBlock::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, prevMatrix);
}
#endif
#if 0
// ParticleEffectNode
if (debugFlags != DEBUG_DRAW_NONE)
{
if (!(flags & SceneNode::NODE_VISIBLE))return;
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderStateBlock::STATE_COLORMASK_ALL | RenderStateBlock::STATE_DEPTH_WRITE);
Vector3 position = Vector3(0.0f, 0.0f, 0.0f) * GetWorldTransform();
Matrix3 rotationPart(GetWorldTransform());
Vector3 direction = Vector3(0.0f, 0.0f, 1.0f) * rotationPart;
direction.Normalize();
RenderManager::Instance()->SetColor(0.0f, 0.0f, 1.0f, 1.0f);
RenderHelper::Instance()->DrawLine(position, position + direction * 10, 2.f);
RenderManager::Instance()->SetState(RenderStateBlock::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
}
#endif
}
}
