@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.2

package/dist/runtime/client/services/camera-effects.registry.js

@@ -0,0 +1,158 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+/**
+ * Registry for built-in and custom cinematic camera effects.
+ */
+let CameraEffectsRegistry = class CameraEffectsRegistry {
+    platform;
+    effects = new Map();
+    presets = new Map();
+    constructor(platform) {
+        this.platform = platform;
+    }
+    /**
+     * Registers a single effect definition.
+     */
+    register(definition) {
+        this.effects.set(definition.id, definition);
+    }
+    /**
+     * Registers a reusable effect preset.
+     */
+    definePreset(preset) {
+        this.presets.set(preset.id, preset);
+    }
+    /**
+     * Returns an effect by id.
+     */
+    get(effectId) {
+        return this.effects.get(effectId);
+    }
+    /**
+     * Returns a cloned effect list from a preset id.
+     */
+    usePreset(presetId) {
+        const preset = this.presets.get(presetId);
+        if (!preset)
+            return [];
+        return preset.effects.map((effect) => ({ ...effect }));
+    }
+    /**
+     * Returns true when an effect id exists in the registry.
+     */
+    has(effectId) {
+        return this.effects.has(effectId);
+    }
+    /**
+     * Returns true when a preset id exists in the registry.
+     */
+    hasPreset(presetId) {
+        return this.presets.has(presetId);
+    }
+    /**
+     * Registers the framework default effect set.
+     */
+    registerBuiltins() {
+        this.register({
+            id: 'fadeIn',
+            defaults: { ms: 500 },
+            setup: (_ctx, params) => {
+                const ms = Number(params.ms ?? 500);
+                this.platform.doScreenFadeIn(ms);
+            },
+        });
+        this.register({
+            id: 'fadeOut',
+            defaults: { ms: 500 },
+            setup: (_ctx, params) => {
+                const ms = Number(params.ms ?? 500);
+                this.platform.doScreenFadeOut(ms);
+            },
+        });
+        this.register({
+            id: 'camShake',
+            defaults: { type: 'HAND_SHAKE', amplitude: 0.35 },
+            setup: (ctx, params) => {
+                const p = params;
+                const type = String(p.type ?? 'HAND_SHAKE');
+                const amplitude = Number(p.amplitude ?? 0.35);
+                ctx.camera.shake(ctx.camHandle, { type, amplitude });
+            },
+            teardown: (ctx) => {
+                ctx.camera.stopShaking(ctx.camHandle, true);
+            },
+        });
+        this.register({
+            id: 'timecycle',
+            defaults: { name: 'default', strength: 1 },
+            setup: (_ctx, params) => {
+                const p = params;
+                const name = String(p.name ?? 'default');
+                const strength = Number(p.strength ?? 1);
+                this.platform.setTimecycleModifier(name);
+                this.platform.setTimecycleModifierStrength(strength);
+            },
+            teardown: () => {
+                this.platform.clearTimecycleModifier();
+            },
+        });
+        this.register({
+            id: 'letterbox',
+            defaults: { top: 0.1, bottom: 0.1, alpha: 230 },
+            update: (ctx, params) => {
+                const p = params;
+                ctx.drawLetterbox(Number(p.top ?? 0.1), Number(p.bottom ?? 0.1), Number(p.alpha ?? 230));
+            },
+        });
+        this.register({
+            id: 'subtitle',
+            defaults: { text: '', durationMs: 1000 },
+            update: (ctx, params) => {
+                const p = params;
+                if (!p.text)
+                    return;
+                ctx.drawSubtitle(String(p.text));
+            },
+        });
+        this.definePreset({
+            id: 'dramatic_intro',
+            effects: [
+                { id: 'fadeIn', params: { ms: 700 }, fromMs: 0, toMs: 700 },
+                { id: 'letterbox', params: { top: 0.12, bottom: 0.12, alpha: 240 } },
+                { id: 'timecycle', params: { name: 'MP_corona_switch', strength: 0.45 } },
+            ],
+        });
+        this.definePreset({
+            id: 'action_chase',
+            effects: [
+                { id: 'camShake', params: { type: 'HAND_SHAKE', amplitude: 0.5 } },
+                { id: 'letterbox', params: { top: 0.08, bottom: 0.08, alpha: 220 } },
+            ],
+        });
+        this.definePreset({
+            id: 'dialog_scene',
+            effects: [
+                { id: 'letterbox', params: { top: 0.1, bottom: 0.1, alpha: 225 } },
+                { id: 'timecycle', params: { name: 'cinema', strength: 0.2 } },
+            ],
+        });
+    }
+};
+CameraEffectsRegistry = __decorate([
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge])
+], CameraEffectsRegistry);
+export { CameraEffectsRegistry };

package/dist/runtime/client/services/camera.d.ts

@@ -0,0 +1,49 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+export interface CameraRotation {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface CameraTransform {
+    position: Vector3;
+    rotation?: CameraRotation;
+    fov?: number;
+}
+export interface CameraCreateOptions {
+    camName?: string;
+    active?: boolean;
+    transform?: CameraTransform;
+}
+export interface CameraRenderOptions {
+    ease?: boolean;
+    easeTimeMs?: number;
+}
+export interface CameraShakeOptions {
+    type: string;
+    amplitude: number;
+}
+export declare class Camera {
+    private readonly platform;
+    private activeCam;
+    private rendering;
+    constructor(platform: IClientPlatformBridge);
+    create(options?: CameraCreateOptions): number;
+    getActiveCam(): number | null;
+    setActive(cam: number, active: boolean): void;
+    render(enable: boolean, options?: CameraRenderOptions): void;
+    isRendering(): boolean;
+    destroy(cam: number, destroyActiveCam?: boolean): void;
+    destroyAll(destroyActiveCam?: boolean): void;
+    setPosition(cam: number, position: Vector3): void;
+    setRotation(cam: number, rotation: CameraRotation, rotationOrder?: number): void;
+    setFov(cam: number, fov: number): void;
+    setTransform(cam: number, transform: CameraTransform): void;
+    pointAtCoords(cam: number, position: Vector3): void;
+    pointAtEntity(cam: number, entity: number, offset?: Vector3): void;
+    stopPointing(cam: number): void;
+    interpolate(fromCam: number, toCam: number, durationMs: number, easeLocation?: boolean, easeRotation?: boolean): void;
+    shake(cam: number, options: CameraShakeOptions): void;
+    stopShaking(cam: number, stopImmediately?: boolean): void;
+    reset(options?: CameraRenderOptions): void;
+}

package/dist/runtime/client/services/camera.js

@@ -0,0 +1,102 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+let Camera = class Camera {
+    platform;
+    activeCam = null;
+    rendering = false;
+    constructor(platform) {
+        this.platform = platform;
+    }
+    create(options = {}) {
+        const cam = this.platform.createCam(options.camName ?? 'DEFAULT_SCRIPTED_CAMERA', options.active ?? false);
+        if (options.transform)
+            this.setTransform(cam, options.transform);
+        if (options.active)
+            this.activeCam = cam;
+        return cam;
+    }
+    getActiveCam() {
+        return this.activeCam;
+    }
+    setActive(cam, active) {
+        this.platform.setCamActive(cam, active);
+        if (active)
+            this.activeCam = cam;
+        else if (this.activeCam === cam)
+            this.activeCam = null;
+    }
+    render(enable, options = {}) {
+        this.platform.renderScriptCams(enable, options.ease ?? false, options.easeTimeMs ?? 0, true, true);
+        this.rendering = enable;
+    }
+    isRendering() {
+        return this.rendering;
+    }
+    destroy(cam, destroyActiveCam = false) {
+        this.platform.destroyCam(cam, destroyActiveCam);
+        if (this.activeCam === cam)
+            this.activeCam = null;
+    }
+    destroyAll(destroyActiveCam = false) {
+        this.platform.destroyAllCams(destroyActiveCam);
+        this.activeCam = null;
+    }
+    setPosition(cam, position) {
+        this.platform.setCamCoord(cam, position);
+    }
+    setRotation(cam, rotation, rotationOrder = 2) {
+        this.platform.setCamRot(cam, rotation, rotationOrder);
+    }
+    setFov(cam, fov) {
+        this.platform.setCamFov(cam, fov);
+    }
+    setTransform(cam, transform) {
+        this.setPosition(cam, transform.position);
+        if (transform.rotation)
+            this.setRotation(cam, transform.rotation);
+        if (typeof transform.fov === 'number')
+            this.setFov(cam, transform.fov);
+    }
+    pointAtCoords(cam, position) {
+        this.platform.pointCamAtCoord(cam, position);
+    }
+    pointAtEntity(cam, entity, offset = { x: 0, y: 0, z: 0 }) {
+        this.platform.pointCamAtEntity(cam, entity, offset);
+    }
+    stopPointing(cam) {
+        this.platform.stopCamPointing(cam);
+    }
+    interpolate(fromCam, toCam, durationMs, easeLocation = true, easeRotation = true) {
+        this.platform.setCamActiveWithInterp(toCam, fromCam, durationMs, easeLocation ? 1 : 0, easeRotation ? 1 : 0);
+        this.activeCam = toCam;
+    }
+    shake(cam, options) {
+        this.platform.shakeCam(cam, options.type, options.amplitude);
+    }
+    stopShaking(cam, stopImmediately = true) {
+        this.platform.stopCamShaking(cam, stopImmediately);
+    }
+    reset(options = {}) {
+        if (this.rendering)
+            this.render(false, options);
+        this.destroyAll(false);
+    }
+};
+Camera = __decorate([
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge])
+], Camera);
+export { Camera };

package/dist/runtime/client/services/cinematic-builder.d.ts

@@ -0,0 +1,107 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { type CameraEffectReference } from './camera-effects.registry';
+import { type CameraRotation } from './camera';
+import { type CameraNodeInput, type CinematicDefinition, type CinematicEase, type CinematicEventName, type CinematicEventPayloadMap, type CinematicHandle, type CinematicShot, type CinematicStartOptions, type LookAtInput, type PositionInput } from './cinematic';
+type EffectLike = CameraEffectReference | EffectBuilder;
+type NodeLike = CameraNodeInput | NodeBuilder;
+type LookAtLike = LookAtInput | NodeBuilder;
+type SceneStartFn = (scene: SceneBuildable, options?: CinematicStartOptions) => CinematicHandle;
+export interface SceneDefaults {
+    ease?: CinematicEase;
+    rotation?: CameraRotation;
+    fov?: number;
+    lookAt?: LookAtLike | LookAtLike[];
+    effects?: EffectLike[];
+}
+export interface SceneFlags {
+    skippable?: boolean;
+    freezePlayer?: boolean;
+    invinciblePlayer?: boolean;
+    hideHud?: boolean;
+    hideRadar?: boolean;
+}
+export interface SceneBuildable {
+    build(): CinematicDefinition;
+}
+interface SceneBuilderOptions {
+    id?: string;
+    start?: SceneStartFn;
+}
+export declare class EffectBuilder {
+    private readonly value;
+    constructor(value: CameraEffectReference);
+    window(fromMs: number, toMs: number): EffectBuilder;
+    from(fromMs: number): EffectBuilder;
+    to(toMs: number): EffectBuilder;
+    build(): CameraEffectReference;
+}
+export declare const Fx: {
+    effect(id: string, params?: Record<string, unknown>): EffectBuilder;
+    fadeIn(ms?: number): EffectBuilder;
+    fadeOut(ms?: number): EffectBuilder;
+    camShake(type?: string, amplitude?: number): EffectBuilder;
+    timecycle(name?: string, strength?: number): EffectBuilder;
+    letterbox(top?: number, bottom?: number, alpha?: number): EffectBuilder;
+    subtitle(text: string, durationMs?: number): EffectBuilder;
+};
+export declare class NodeBuilder {
+    private readonly value;
+    private rotationValue;
+    private fovValue;
+    constructor(value: PositionInput);
+    offset(x: number, y: number, z: number): NodeBuilder;
+    rot(x: number, y: number, z: number): NodeBuilder;
+    fov(value: number): NodeBuilder;
+    build(): CameraNodeInput;
+    toPosition(): PositionInput;
+}
+export declare const Pos: {
+    coords(x: number, y: number, z: number): NodeBuilder;
+    entity(entity: number, offset?: Vector3): NodeBuilder;
+    entityBone(entity: number, bone: number, offset?: Vector3): NodeBuilder;
+    anchor(name: string, offset?: Vector3): NodeBuilder;
+    resolver(resolve: () => Vector3 | Promise<Vector3>): NodeBuilder;
+};
+export declare class ShotBuilder {
+    private readonly id?;
+    private shot;
+    constructor(id?: string | undefined);
+    duration(durationMs: number): ShotBuilder;
+    ease(ease: CinematicEase): ShotBuilder;
+    from(node: NodeLike): ShotBuilder;
+    to(node: NodeLike): ShotBuilder;
+    path(...nodes: NodeLike[]): ShotBuilder;
+    lookAt(target: LookAtLike, ...targets: LookAtLike[]): ShotBuilder;
+    effect(effect: EffectLike): ShotBuilder;
+    effects(...effects: EffectLike[]): ShotBuilder;
+    build(defaults?: SceneDefaults): CinematicShot;
+}
+export declare class SceneBuilder implements SceneBuildable {
+    private definition;
+    private defaultsValue;
+    private startFn?;
+    private listeners;
+    constructor(options?: SceneBuilderOptions);
+    id(id: string): SceneBuilder;
+    flags(flags: SceneFlags): SceneBuilder;
+    skippable(value?: boolean): SceneBuilder;
+    freezePlayer(value?: boolean): SceneBuilder;
+    invinciblePlayer(value?: boolean): SceneBuilder;
+    hideHud(value?: boolean): SceneBuilder;
+    hideRadar(value?: boolean): SceneBuilder;
+    defaults(defaults: SceneDefaults): SceneBuilder;
+    anchor(name: string, position: Vector3): SceneBuilder;
+    anchors(anchors: Record<string, Vector3>): SceneBuilder;
+    effect(effect: EffectLike): SceneBuilder;
+    effects(...effects: EffectLike[]): SceneBuilder;
+    preset(id: string): SceneBuilder;
+    presets(...ids: string[]): SceneBuilder;
+    shot(id: string, configure: (shot: ShotBuilder) => ShotBuilder | undefined): SceneBuilder;
+    shot(configure: (shot: ShotBuilder) => ShotBuilder | undefined): SceneBuilder;
+    wait(id: string, waitMs: number): SceneBuilder;
+    wait(waitMs: number): SceneBuilder;
+    on<TEventName extends CinematicEventName>(eventName: TEventName, handler: (payload: CinematicEventPayloadMap[TEventName]) => void): SceneBuilder;
+    build(): CinematicDefinition;
+    start(options?: CinematicStartOptions): CinematicHandle;
+}
+export {};