Tick Source should be able to tick more than once per frame

[jknightdoeswork]

EDIT:

I've implemented this in a PR that adds a ecs_set_fixed_interval()

Describe the problem you are trying to solve.

I'm trying to use the flecs pipeline and system api to build a core loop that requires three distinct concepts to be expressed:

PreSimulation   (once per frame)
FixedSimulation (zero to N times per frame)
PostSimulation  (once per frame)

FixedSimulation runs core simulation logic at a fixed timestep (e.g. 1/60s) using a time accumulator. PreSimulation handles eg) input, and PostSimulation handles eg) rendering.

The key requirement is that the FixedSimulation must be able to tick multiple times in a single frame when the frame's delta time >= 2 * interval.

eg) Imagine a timer with interval 1.0 seconds, if you call ecs_progress with 10 seconds, the timer fires once with a delta time of 10, but I expect it to fire 10 times with a delta time of 1.0.

This is achievable today, but only by splitting the loop across three separate pipelines and implementing the fixed interval logic manually:

ecs_run_pipeline(world, PreSimulation, raw_delta_time);

const float fixed_dt = 1.0f / 60.0f;
accumulator += raw_delta_time;
while (accumulator >= fixed_dt) {
    ecs_run_pipeline(world, FixedSimulation, fixed_dt);
    accumulator -= fixed_dt;
}

ecs_run_pipeline(world, PostSimulation, raw_delta_time);

This works, but it bypasses ecs_progress entirely and requires the user to manually manage what should be expressible within a single pipeline using tick sources.

Describe the solution you'd like

The current tick_source / rate filter API only supports ticking a phase 0 or 1 times per ecs_progress call. If the frame's delta time is large enough to warrant multiple fixed-timestep iterations, the tick source will still only fire once, causing the simulation to fall behind.

I'd like tick_source to support ticking a phase 0 to N times per frame based on accumulated time, so that a single pipeline with phases like this would accurately simulate real time no matter what delta_time is passed into ecs_progress().

PreSimulation  (ticks once per frame)
FixedSimulation (fixed interval tick_source - may tick 0–N times)
PostSimulation (ticks once per frame)

This would eliminate the need for the three-pipeline workaround and let ecs_progress drive the entire core loop as intended.

I've implemented this in a PR that adds a ecs_set_fixed_interval() and changes TickSource.Tick from a bool to an int.

Thanks!

[sunlho]

ecs_run_pipeline(world, PreSimulation, raw_delta_time);

const float fixed_dt = 1.0f / 60.0f;
accumulator += raw_delta_time;

while (accumulator >= fixed_dt) {
    ecs_run_pipeline(world, FixedSimulation, fixed_dt);
    accumulator -= fixed_dt;
}

ecs_run_pipeline(world, PostSimulation, raw_delta_time);

Is there a sample project that demonstrates this pattern?

I've been searching through the Flecs documentation and examples, but I haven't found a complete example showing how to structure a game loop with multiple pipelines (PreSimulation, FixedSimulation, PostSimulation) and a fixed timestep simulation.

I also tried implementing this approach myself, but after rendering the first frame the game appears to get stuck in an infinite loop, so I'm not sure whether I'm missing something in the setup or using it incorrectly.

Any example repositories or additional guidance would be greatly appreciated.

Thanks!

[jknightdoeswork]

It takes quite a bit of setup code to create the 3 pipelines. I'll try to distill it out here. I have something like this working in a larger framework but will try to manually distill the core necessary pieces.

ECS_TAG_DECLARE(FixedUpdatePhaseMeta);
ECS_TAG_DECLARE(PreUpdatePhaseMeta);
ECS_TAG_DECLARE(UpdatePhaseMeta);
ECS_TAG_DECLARE(PreUpdatePhase);
ECS_TAG_DECLARE(UpdatePhase);
ECS_TAG_DECLARE(PostUpdatePhase);
ECS_TAG_DECLARE(PrePhysicsPhase);
ECS_TAG_DECLARE(PhysicsPhase);
ECS_TAG_DECLARE(PostPhysicsPhase);

ecs_entity_t PreUpdatePipeline;
ecs_entity_t FixedUpdatePipeline;
ecs_entity_t UpdatePipeline;
typedef struct {
	float delta_time;
	float accumulator;
	float interpolator;
} PhysicsMeta;
extern ECS_COMPONENT_DECLARE(PhysicsMeta);
...
void some_initializer(ecs_world_t* world) {
	ECS_TAG_DEFINE(world, FixedUpdatePhaseMeta);

	ECS_TAG_DEFINE(world, PrePhysicsPhase);
	ecs_add(world, PrePhysicsPhase, FixedUpdatePhaseMeta);
	ecs_add_pair(world, PrePhysicsPhase, EcsDependsOn, FixedUpdatePhaseMeta);

	ECS_TAG_DEFINE(world, PhysicsPhase);
	ecs_add_pair(world, PhysicsPhase, EcsDependsOn, PrePhysicsPhase);

	ECS_TAG_DEFINE(world, PostPhysicsPhase);
	ecs_add_pair(world, PostPhysicsPhase, EcsDependsOn, PhysicsPhase);
	FixedUpdatePipeline = ecs_pipeline(
		world,
		{.query.terms = {
			 {.id = EcsSystem},
			 {.id = FixedUpdatePhaseMeta, .src.id = EcsCascade, .trav = EcsDependsOn},
		 }}
	);

	ECS_TAG_DEFINE(world, PreUpdatePhaseMeta);
	ECS_TAG_DEFINE(world, PreUpdatePhase);
	ecs_add(world, PreUpdatePhase, PreUpdatePhaseMeta);
	ecs_add_pair(world, PreUpdatePhase, EcsDependsOn, PreUpdatePhaseMeta);
	PreUpdatePipeline = ecs_pipeline(
		world,
		{.query.terms = {
			 {.id = EcsSystem},
			 {.id = PreUpdatePhaseMeta, .src.id = EcsCascade, .trav = EcsDependsOn},
		 }}
	);

	ECS_TAG_DEFINE(world, UpdatePhaseMeta);

	ECS_TAG_DEFINE(world, UpdatePhase);
	ecs_add(world, UpdatePhase, UpdatePhaseMeta);
	ecs_add_pair(world, UpdatePhase, EcsDependsOn, UpdatePhaseMeta);

	ECS_TAG_DEFINE(world, PostUpdatePhase);
	ecs_add_pair(world, PostUpdatePhase, EcsDependsOn, UpdatePhase);
	UpdatePipeline = ecs_pipeline(
		world,
		{.query.terms = {
			 {.id = EcsSystem},
			 {.id = UpdatePhaseMeta, .src.id = EcsCascade, .trav = EcsDependsOn},
		 }}
	);

        // create a singleton that will hold the data
       // for the fixed rate tick pipeline
      // delta_time here is the fixed rate interval, ie: 1/60
	ecs_set(
		world,
		ecs_id(PhysicsMeta),
		PhysicsMeta,
		{
			.delta_time = 1.0f / 60.0f,
			.accumulator = 0.0f,
			.interpolator = 0.0f,
		}
	);
}

void update(float raw_delta_time) {
	ecs_frame_begin(world, raw_delta_time);

	const ecs_world_info_t* world_info = ecs_get_world_info(world);
	ecs_run_pipeline(world, PreUpdatePipeline, world_info->delta_time);

	PhysicsMeta* physics_meta = ecs_get_mut(world, ecs_id(PhysicsMeta), PhysicsMeta);
	physics_meta->accumulator += world_info->delta_time;
	while (physics_meta->accumulator > physics_meta->delta_time) {
		ecs_run_pipeline(world, FixedUpdatePipeline, physics_meta->delta_time);
		physics_meta->accumulator -= physics_meta->delta_time;
	}
	physics_meta->interpolator = physics_meta->accumulator / physics_meta->delta_time;

	ecs_run_pipeline(world, UpdatePipeline, world_info->delta_time);

	ecs_frame_end(world);
}

I've got something like this working, and I tried to copy out the core pieces of it to show how it can be done. There could be errors in this example.

I think this pattern would be far more elegantly expressed if this PR was merged.

[sunlho]

It takes quite a bit of setup code to create the 3 pipelines. I'll try to distill it out here. I have something like this working in a larger framework but will try to manually distill the core necessary pieces.

ECS_TAG_DECLARE(FixedUpdatePhaseMeta);
ECS_TAG_DECLARE(PreUpdatePhaseMeta);
ECS_TAG_DECLARE(UpdatePhaseMeta);
ECS_TAG_DECLARE(PreUpdatePhase);
ECS_TAG_DECLARE(UpdatePhase);
ECS_TAG_DECLARE(PostUpdatePhase);
ECS_TAG_DECLARE(PrePhysicsPhase);
ECS_TAG_DECLARE(PhysicsPhase);
ECS_TAG_DECLARE(PostPhysicsPhase);

ecs_entity_t PreUpdatePipeline;
ecs_entity_t FixedUpdatePipeline;
ecs_entity_t UpdatePipeline;
typedef struct {
	float delta_time;
	float accumulator;
	float interpolator;
} PhysicsMeta;
extern ECS_COMPONENT_DECLARE(PhysicsMeta);
...
void some_initializer(ecs_world_t* world) {
	ECS_TAG_DEFINE(world, FixedUpdatePhaseMeta);

	ECS_TAG_DEFINE(world, PrePhysicsPhase);
	ecs_add(world, PrePhysicsPhase, FixedUpdatePhaseMeta);
	ecs_add_pair(world, PrePhysicsPhase, EcsDependsOn, FixedUpdatePhaseMeta);

	ECS_TAG_DEFINE(world, PhysicsPhase);
	ecs_add_pair(world, PhysicsPhase, EcsDependsOn, PrePhysicsPhase);

	ECS_TAG_DEFINE(world, PostPhysicsPhase);
	ecs_add_pair(world, PostPhysicsPhase, EcsDependsOn, PhysicsPhase);
	FixedUpdatePipeline = ecs_pipeline(
		world,
		{.query.terms = {
			 {.id = EcsSystem},
			 {.id = FixedUpdatePhaseMeta, .src.id = EcsCascade, .trav = EcsDependsOn},
		 }}
	);

	ECS_TAG_DEFINE(world, PreUpdatePhaseMeta);
	ECS_TAG_DEFINE(world, PreUpdatePhase);
	ecs_add(world, PreUpdatePhase, PreUpdatePhaseMeta);
	ecs_add_pair(world, PreUpdatePhase, EcsDependsOn, PreUpdatePhaseMeta);
	PreUpdatePipeline = ecs_pipeline(
		world,
		{.query.terms = {
			 {.id = EcsSystem},
			 {.id = PreUpdatePhaseMeta, .src.id = EcsCascade, .trav = EcsDependsOn},
		 }}
	);

	ECS_TAG_DEFINE(world, UpdatePhaseMeta);

	ECS_TAG_DEFINE(world, UpdatePhase);
	ecs_add(world, UpdatePhase, UpdatePhaseMeta);
	ecs_add_pair(world, UpdatePhase, EcsDependsOn, UpdatePhaseMeta);

	ECS_TAG_DEFINE(world, PostUpdatePhase);
	ecs_add_pair(world, PostUpdatePhase, EcsDependsOn, UpdatePhase);
	UpdatePipeline = ecs_pipeline(
		world,
		{.query.terms = {
			 {.id = EcsSystem},
			 {.id = UpdatePhaseMeta, .src.id = EcsCascade, .trav = EcsDependsOn},
		 }}
	);

        // create a singleton that will hold the data
       // for the fixed rate tick pipeline
      // delta_time here is the fixed rate interval, ie: 1/60
	ecs_set(
		world,
		ecs_id(PhysicsMeta),
		PhysicsMeta,
		{
			.delta_time = 1.0f / 60.0f,
			.accumulator = 0.0f,
			.interpolator = 0.0f,
		}
	);
}

void update(float raw_delta_time) {
	ecs_frame_begin(world, raw_delta_time);

	const ecs_world_info_t* world_info = ecs_get_world_info(world);
	ecs_run_pipeline(world, PreUpdatePipeline, world_info->delta_time);

	PhysicsMeta* physics_meta = ecs_get_mut(world, ecs_id(PhysicsMeta), PhysicsMeta);
	physics_meta->accumulator += world_info->delta_time;
	while (physics_meta->accumulator > physics_meta->delta_time) {
		ecs_run_pipeline(world, FixedUpdatePipeline, physics_meta->delta_time);
		physics_meta->accumulator -= physics_meta->delta_time;
	}
	physics_meta->interpolator = physics_meta->accumulator / physics_meta->delta_time;

	ecs_run_pipeline(world, UpdatePipeline, world_info->delta_time);

	ecs_frame_end(world);
}

I've got something like this working, and I tried to copy out the core pieces of it to show how it can be done. There could be errors in this example.

I think this pattern would be far more elegantly expressed if this PR was merged.

Thanks for the explanation and the example.

This pointed me in the right direction.