Skip to content

Commit

Permalink
Dead code removed
Browse files Browse the repository at this point in the history
  • Loading branch information
@vblanco20-1
vblanco20-1 committed Jul 26, 2020
1 parent b62b2e8 commit 5852f67
Show file tree
Hide file tree
Showing 3 changed files with 15 additions and 304 deletions.
282 changes: 11 additions & 271 deletions Source/ECSTesting/ECS_Base/ECS_BaseSystems.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,86 +41,6 @@ StaticMeshDrawSystem::ISMData* StaticMeshDrawSystem::GetInstancedMeshForMesh(USt

void StaticMeshDrawSystem::update(ECS_Registry &registry, float dt)
{
//reset instances once per second
Elapsed -= dt;
if (Elapsed < 0)
{
Elapsed = 1;
for (auto i : MeshMap)
{
i.Value.ISM->ClearInstances();
i.Value.rendered = 0;
}
}

{
SCOPE_CYCLE_COUNTER(STAT_InstancedMeshPrepare);
//copy transforms into the ISM RenderTransform
registry.view<FInstancedStaticMesh, FPosition>().each([&, dt](auto entity, FInstancedStaticMesh & ism, FPosition & pos) {
ism.RenderTransform.SetLocation(pos.pos);
});
registry.view<FInstancedStaticMesh, FRotationComponent>().each([&, dt](auto entity, FInstancedStaticMesh & ism, FRotationComponent & rot) {
ism.RenderTransform.SetRotation(rot.rot);
});
registry.view<FInstancedStaticMesh, FScale>().each([&, dt](auto entity, FInstancedStaticMesh & ism, FScale & sc) {
ism.RenderTransform.SetScale3D(sc.scale);
});

}


{
SCOPE_CYCLE_COUNTER(STAT_InstancedMeshDraw);

auto view = registry.view<FInstancedStaticMesh>();

for (auto entity : view) {

FInstancedStaticMesh &mesh = view.get(entity);

auto MeshData = GetInstancedMeshForMesh(mesh.mesh);
auto RenderMesh = MeshData->ISM;

const FTransform &RenderTransform = mesh.RenderTransform;// mesh.RelativeTransform.GetRelativeTransform(mesh.RenderTransform);

if (RenderMesh->GetInstanceCount() < MeshData->rendered)
{
RenderMesh->AddInstanceWorldSpace(RenderTransform);
}
else
{
RenderMesh->UpdateInstanceTransform(MeshData->rendered, RenderTransform, true, false);
}
MeshData->rendered++;
}


}
{
SCOPE_CYCLE_COUNTER(STAT_InstancedMeshClean)
for (auto& i : MeshMap)
{


FTransform nulltransform;
nulltransform.SetScale3D(FVector(0.0, 0.0, 0.0));

//if we have more instances than renderables, set the instances to null transform so they dont draw.
//they will get cleanup once a second.
if (IsValid(i.Value.ISM))
{
while (i.Value.rendered < i.Value.ISM->GetInstanceCount())
{

i.Value.rendered++;
i.Value.ISM->UpdateInstanceTransform(i.Value.rendered, nulltransform, true, false);

}
i.Value.ISM->MarkRenderStateDirty();
}
}
}

}

void StaticMeshDrawSystem::schedule(ECSSystemScheduler* sysScheduler)
Expand Down Expand Up @@ -269,84 +189,7 @@ EntityHandle ArchetypeSpawnerSystem::SpawnFromArchetype(ECS_Registry& registry,

void ArchetypeSpawnerSystem::update(ECS_Registry &registry, float dt)
{
assert(OwnerActor);

SCOPE_CYCLE_COUNTER(STAT_ECSSpawn);

//exclusively update timing
auto SpawnerView = registry.view<FArchetypeSpawner>();
for (auto e : SpawnerView)
{
SpawnerView.get(e).TimeUntilSpawn -= dt;
}

//spawn from arc and actortransform
auto SpawnerArcView = registry.view<FArchetypeSpawner, FRandomArcSpawn, FActorTransform>();
for (auto e : SpawnerArcView)
{
const FTransform &ActorTransform = SpawnerArcView.get<FActorTransform>(e).transform;
FArchetypeSpawner& spawner = SpawnerArcView.get<FArchetypeSpawner>(e);
const FRandomArcSpawn& arc = SpawnerArcView.get<FRandomArcSpawn>(e);

if (spawner.TimeUntilSpawn < 0)
{
if (spawner.ArchetypeClass)
{
EntityHandle h = SpawnFromArchetype(registry, spawner.ArchetypeClass);
registry.accommodate<FPosition>(h.handle, ActorTransform.GetLocation());

if (registry.has<FFaction>(e))
{
registry.accommodate<FFaction>(h.handle, registry.get<FFaction>(e));
}

FVelocity vel;
const float VelMagnitude = World->rng.FRandRange(arc.MinVelocity, arc.MaxVelocity);
const float Arc = FMath::DegreesToRadians(World->rng.FRandRange(arc.MinAngle, arc.MaxAngle));


FVector ArcVel = World->rng.VRandCone(FVector(1.0, 0.0, 0.0), Arc) *VelMagnitude;

FVector BulletVelocity = ActorTransform.GetRotation().RotateVector(ArcVel);
registry.accommodate<FVelocity>(h.handle, BulletVelocity);
}

if (spawner.bLoopSpawn)
{
spawner.TimeUntilSpawn = spawner.SpawnRate;
}
else
{
registry.remove<FArchetypeSpawner>(e);
}
}
}

//Spawn with basic position
auto SpawnerPositionView = registry.view<FArchetypeSpawner, FPosition>();
for (auto e : SpawnerPositionView)
{
const FVector &SpawnPosition = SpawnerPositionView.get<FPosition>(e).pos;
FArchetypeSpawner& spawner = SpawnerPositionView.get<FArchetypeSpawner>(e);

if (spawner.TimeUntilSpawn < 0)
{
if (spawner.ArchetypeClass)
{
EntityHandle h = SpawnFromArchetype(registry, spawner.ArchetypeClass);
registry.accommodate<FPosition>(h.handle, SpawnPosition);
}

if (spawner.bLoopSpawn)
{
spawner.TimeUntilSpawn = spawner.SpawnRate;
}
else
{
registry.remove<FArchetypeSpawner>(e);
}
}
}

}
PRAGMA_DISABLE_OPTIMIZATION
void ArchetypeSpawnerSystem::schedule(ECSSystemScheduler* sysScheduler)
Expand Down Expand Up @@ -501,34 +344,6 @@ void RaycastSystem::CheckRaycasts(ECS_Registry& registry, float dt, UWorld* Game
}
}
});

// if (GameWorld->IsTraceHandleValid(ray.handle, false))
// {
// FTraceDatum tdata;
// GameWorld->QueryTraceData(ray.handle, tdata);
// if (tdata.OutHits.IsValidIndex(0))
// {
// //it actually hit
// if (tdata.OutHits[0].bBlockingHit)
// {
// ////if its an actor, try to damage it.
// AActor* act = tdata.OutHits[0].GetActor();
// if (act)
// {
// actorCalls.enqueue({act});
// }
//
// //if the entity was a projectile, create explosion and destroy it
// if (registry.has<FProjectile>(entity))
// {
// FVector ExplosionPoint = tdata.OutHits[0].ImpactPoint;
//
// explosions.enqueue({entity,ExplosionPoint});
// }
// }
// }
// }
//});
}

void RaycastSystem::CreateExplosion(ECS_Registry& registry, EntityID entity, FVector ExplosionPoint)
Expand Down Expand Up @@ -656,33 +471,7 @@ void RaycastSystem::schedule(ECSSystemScheduler* sysScheduler)

void LifetimeSystem::update(ECS_Registry& registry, float dt)
{
assert(OwnerActor);

SCOPE_CYCLE_COUNTER(STAT_Lifetime);

////tick the lifetime timers
//auto LifetimeView = registry.view<FLifetime>();
//for (auto e : LifetimeView)
//{
// auto& Deleter = LifetimeView.get(e);
//
// Deleter.LifeLeft -= dt;
// if (Deleter.LifeLeft < 0)
// {
// //add a Destroy component so it gets deleted
// registry.accommodate<FDestroy>(e);
// }
//}
//
////logic can be done here for custom deleters, nothing right now
//
//
////delete everything with a FDestroy component
//auto DeleteView = registry.view<FDestroy>();
//for (auto e : DeleteView)
//{
// registry.destroy(e);
//}

}


Expand Down Expand Up @@ -758,24 +547,26 @@ void LifetimeSystem::schedule(ECSSystemScheduler* sysScheduler)

void CopyTransformToActorSystem::update(ECS_Registry& registry, float dt)
{
}

assert(OwnerActor);
void CopyTransformToActorSystem::PackTransforms(ECS_Registry& registry)
{
SCOPE_CYCLE_COUNTER(STAT_PackActorTransform);
{

//fill ActorTransform from separate components
registry.view<FActorTransform, FPosition>().each([&, dt](auto entity, FActorTransform& transform, FPosition& pos) {
registry.view<FActorTransform, FPosition>().each([&](auto entity, FActorTransform& transform, FPosition& pos) {
transform.transform.SetLocation(pos.pos);
});
registry.view<FActorTransform, FRotationComponent>().each([&, dt](auto entity, FActorTransform& transform, FRotationComponent& rot) {
registry.view<FActorTransform, FRotationComponent>().each([&](auto entity, FActorTransform& transform, FRotationComponent& rot) {
transform.transform.SetRotation(rot.rot);
});
registry.view<FActorTransform, FScale>().each([&, dt](auto entity, FActorTransform& transform, FScale& sc) {
registry.view<FActorTransform, FScale>().each([&](auto entity, FActorTransform& transform, FScale& sc) {

transform.transform.SetScale3D(sc.scale);
});
}

//copy transforms from actor into FActorTransform
auto TransformView = registry.view<FCopyTransformToActor, FActorReference, FActorTransform>();
for (auto e : TransformView)
Expand Down Expand Up @@ -805,7 +596,7 @@ void CopyTransformToActorSystem::schedule(ECSSystemScheduler* sysScheduler)
builder.AddTask(deps1,
//builder.AddSyncTask(
[=](ECS_Registry& reg) {
this->update(reg, 1.0 / 60.0);
PackTransforms(reg);
}
);

Expand Down Expand Up @@ -834,39 +625,6 @@ void CopyTransformToActorSystem::schedule(ECSSystemScheduler* sysScheduler)

void CopyTransformToECSSystem::update(ECS_Registry& registry, float dt)
{
#if 0
assert(OwnerActor);

//copy transforms from actor into FActorTransform
auto ActorTransformView = registry.view<FCopyTransformToECS, FActorReference>();
for (auto e : ActorTransformView)
{
SCOPE_CYCLE_COUNTER(STAT_CopyTransformECS);
FActorReference& actor = ActorTransformView.get<FActorReference>(e);
if (actor.ptr.IsValid())
{
const FTransform& ActorTransform = actor.ptr->GetActorTransform();
registry.accommodate<FActorTransform>(e, ActorTransform);
}
}
{

SCOPE_CYCLE_COUNTER(STAT_UnpackActorTransform);
//unpack from ActorTransform into the separate transform components, only if the entity does have that component
registry.view<FActorTransform, FPosition>().each([&, dt](auto entity, FActorTransform& transform, FPosition& pos) {

pos.pos = transform.transform.GetLocation();
});
registry.view<FActorTransform, FRotationComponent>().each([&, dt](auto entity, FActorTransform& transform, FRotationComponent& rot) {

rot.rot = transform.transform.GetRotation();
});
registry.view<FActorTransform, FScale>().each([&, dt](auto entity, FActorTransform& transform, FScale& sc) {

sc.scale = transform.transform.GetScale3D();
});
}
#endif
}

void CopyTransformToECSSystem::schedule(ECSSystemScheduler* sysScheduler)
Expand Down Expand Up @@ -933,24 +691,6 @@ void CopyTransformToECSSystem::schedule(ECSSystemScheduler* sysScheduler)

void MovementSystem::update(ECS_Registry& registry, float dt)
{
#if 0
SCOPE_CYCLE_COUNTER(STAT_Movement);

//movement raycast gets a "last position" component
registry.view<FMovementRaycast, FPosition>().each([&, dt](auto entity, FMovementRaycast& ray, FPosition& pos) {
registry.accommodate<FLastPosition>(entity, pos.pos);
});

//add gravity and basic movement from velocity
registry.view<FMovement, FPosition, FVelocity>().each([&, dt](auto entity, FMovement& m, FPosition& pos, FVelocity& vel) {

//gravity
const FVector gravity = FVector(0.f, 0.f, -980) * m.GravityStrenght;
vel.Add(gravity * dt);

pos.Add(vel.vel * dt);
});
#endif
}

void MovementSystem::schedule(ECSSystemScheduler* sysScheduler)
Expand Down
2 changes: 2 additions & 0 deletions Source/ECSTesting/ECS_Base/ECS_BaseSystems.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,6 +50,8 @@ struct CopyTransformToActorSystem :public System {

void update(ECS_Registry &registry, float dt) override;

void PackTransforms(ECS_Registry& registry);


void schedule(ECSSystemScheduler* sysScheduler) override;

Expand Down
Loading

0 comments on commit 5852f67

Please sign in to comment.