Provide default setup to avoid boilerplate code about pex-renderer HOT 16 CLOSED

const ecs = defaultSetup()

ctx.frame(() => {
  ecs.update(entities)
})

const app = defaultSetup()

ctx.frame(() => {
  app.update(entities)
})

const engine = defaultSetup()

ctx.frame(() => {
  engine.update(entities)
})

const systems = defaultSystems()

ctx.frame(() => {
  systems.update(entities)
})

module.exports = (node, graph) => {
  const {
    systems,
    renderGraph: createRenderGraph,
    resourceCache: createResourceCache,
  } = require("pex-renderer");

  const triggerIn = node.triggerIn("in");
  const triggerOut = node.triggerOut("out");

  const ctx = graph.ctx;

  const renderGraph = createRenderGraph(ctx);
  const resourceCache = createResourceCache(ctx);

  const renderPipelineSystem = systems.renderPipeline({
    ctx: graph.ctx,
    outputEncoding: graph.ctx.Encoding.Gamma,
    resourceCache,
    renderGraph,
  });

  const standardRendererSystem = systems.renderer.standard({
    ctx,
    resourceCache,
    renderGraph,
  });
  const basicRendererSystem = systems.renderer.basic({
    ctx,
    resourceCache,
    renderGraph,
  });
  const lineRendererSystem = systems.renderer.line({
    ctx,
    resourceCache,
    renderGraph,
  });
  const helperRendererSys = systems.renderer.helper({ ctx });
  const skyboxRendererSys = systems.renderer.skybox({ ctx });

  triggerIn.onTrigger = (props) => {
    const { entities, renderWidth, renderHeight } = props;
    resourceCache.beginFrame();
    renderGraph.beginFrame();

    const cameraEntity = entities.find((e) => e.camera);

    const renderView = {
      camera: cameraEntity.camera,
      cameraEntity: cameraEntity,
      viewport: [0, 0, renderWidth, renderHeight],
    };

    node.comment = cameraEntity.camera.fov + "\n" + renderView.viewport;

    renderPipelineSystem.update(props.entities, {
      renderView,
      renderers: [
        standardRendererSystem,
        // basicRendererSystem,
        lineRendererSystem,
        skyboxRendererSys,
        // helperRendererSys,
      ],
    });

    renderGraph.endFrame();
    resourceCache.endFrame();

    // node.comment = props.entities.length;

    triggerOut.trigger(props);
  };
};

const engine = defaultEngine()

ctx.frame(() => {
  engine.update(entities)
})

const defaultSystems = defaultSetup()
defaultSystems.forEach((system) => {
   system.update(entities, defaultSystems)
})

export default function engine(ctx) {
  const renderGraph = createRenderGraph(ctx);
  const resourceCache = createResourceCache(ctx);

  const renderPipelineSystem = systems.renderPipeline({
    ctx,
    outputEncoding: ctx.Encoding.Gamma,
    resourceCache,
    renderGraph,
  });

  const standardRendererSystem = systems.renderer.standard({
    ctx,
    resourceCache,
    renderGraph,
  });
  const lineRendererSystem = systems.renderer.line({
    ctx,
    resourceCache,
    renderGraph,
  });
  const helperRendererSys = systems.renderer.helper({ ctx });
  const skyboxRendererSys = systems.renderer.skybox({ ctx });

  const renderers = [
    standardRendererSystem,
    lineRendererSystem,
    skyboxRendererSys,
    helperRendererSys,
  ];

  return {
    renderers,
    update(entities, { viewport }) {
      resourceCache.beginFrame();
      renderGraph.beginFrame();

      const cameraEntity = entities.find((e) => e.camera);

      const renderView = {
        camera: cameraEntity.camera,
        cameraEntity: cameraEntity,
        viewport,
      };

      renderPipelineSystem.update(entities, { renderView, renderers });

      renderGraph.endFrame();
      resourceCache.endFrame();
    },
  };
}

import { engineSystem } from "pex-renderer";
const engine = engineSystem({ ctx });

const entities = []
// entities.push(entity);

ctx.frame(() => {
  engine.update(entities);
})

const engine = createDefaultEngine({ ctx });

ctx.frame(() => {
  const now = Date.now();
  const deltaTime = (now - prevTime) / 1000;
  prevTime = now;

  const cameraEntity = world.entities.find((e) => e.camera);

  engine.update(world.entities, deltaTime);
  engine.render(world.entities, cameraEntity);

  gui.draw();
});

world.addSystem(systems.geometry({ ctx }));
world.addSystem(systems.animation());
world.addSystem(systems.transform());
world.addSystem(systems.camera());
world.addSystem(systems.skybox({ ctx }));
world.addSystem(systems.reflectionProbe({ ctx }));
world.addSystem(systems.renderer({ ctx, outputEncoding: ctx.Encoding.Gamma }));
world.addSystem(systems.helper({ ctx }));

...

ctx.frame(() => {
  world.update();
  gui.draw();
});