Babylon.js/Viewer/src/configuration/configuration.ts

import { ITemplateConfiguration } from './../templateManager';
import { EngineOptions, IGlowLayerOptions, DepthOfFieldEffectBlurLevel } from 'babylonjs';

export function getConfigurationKey(key: string, configObject: any) {
    let splits = key.split('.');

    if (splits.length === 0 || !configObject) return false;
    else if (splits.length === 1) {
        if (configObject[key] !== undefined) {
            return configObject[key];
        }
    } else {
        let firstKey = splits.shift();
        return getConfigurationKey(splits.join("."), configObject[firstKey!])
    }
}

export interface ViewerConfiguration {

    // configuration version
    version?: string;
    extends?: string; // is this configuration extending an existing configuration?

    pageUrl?: string; // will be used for sharing and other fun stuff. This is the page showing the model (not the model's url!)

    configuration?: string | {
        url?: string;
        payload?: any;
        mapper?: string; // json (default), html, yaml, xml, etc'. if not provided, file extension will be used.
    };

    // names of functions in the window context.
    observers?: IObserversConfiguration;

    canvasElement?: string; // if there is a need to override the standard implementation - ID of HTMLCanvasElement

    model?: IModelConfiguration | string;

    scene?: ISceneConfiguration;
    optimizer?: ISceneOptimizerConfiguration | boolean;
    // at the moment, support only a single camera.
    camera?: ICameraConfiguration,
    skybox?: boolean | ISkyboxConfiguration;

    ground?: boolean | IGroundConfiguration;
    lights?: { [name: string]: boolean | ILightConfiguration },
    // engine configuration. optional!
    engine?: {
        antialiasing?: boolean;
        disableResize?: boolean;
        engineOptions?: EngineOptions;
        adaptiveQuality?: boolean;
    },
    //templateStructure?: ITemplateStructure,
    templates?: {
        main: ITemplateConfiguration,
        [key: string]: ITemplateConfiguration
    };

    customShaders?: {
        shaders?: {
            [key: string]: string;
        };
        includes?: {
            [key: string]: string;
        }
    }

    loaderPlugins?: {
        extendedMaterial?: boolean;
        msftLod?: boolean;
        telemetry?: boolean;
        minecraft?: boolean;

        [propName: string]: boolean | undefined;
    };

    // features that are being tested.
    // those features' syntax will change and move out! 
    // Don't use in production (or be ready to make the changes :) )
    lab?: {
        flashlight?: boolean | {
            exponent?: number;
            angle?: number;
            intensity?: number;
            diffuse?: { r: number, g: number, b: number };
            specular?: { r: number, g: number, b: number };
        }
        hideLoadingDelay?: number;
        assetsRootURL?: string;
        environmentMap?: {
            /**
             * Environment map texture path in relative to the asset folder.
             */
            texture: string;

            /**
             * Default rotation to apply to the environment map.
             */
            rotationY: number;

            /**
             * Tint level of the main color on the environment map.
             */
            tintLevel: number;
        }
        defaultRenderingPipelines?: boolean | IDefaultRenderingPipelineConfiguration;
    }
}

export interface IDefaultRenderingPipelineConfiguration {
    sharpenEnabled?: boolean;
    bloomEnabled?: boolean;
    bloomThreshold?: number;
    depthOfFieldEnabled?: boolean;
    depthOfFieldBlurLevel?: DepthOfFieldEffectBlurLevel;
    fxaaEnabled?: boolean;
    imageProcessingEnabled?: boolean;
    defaultPipelineTextureType?: number;
    bloomScale?: number;
    chromaticAberrationEnabled?: boolean;
    grainEnabled?: boolean;
    bloomKernel?: number;
    hardwareScaleLevel?: number;
    bloomWeight?: number;
    bllomThreshold?: number;
    hdr?: boolean;
    samples?: number;
}

export interface IModelConfiguration {
    id?: string;
    url?: string;
    root?: string; //optional
    loader?: string; // obj, gltf?
    position?: { x: number, y: number, z: number };
    rotation?: { x: number, y: number, z: number, w?: number };
    scaling?: { x: number, y: number, z: number };
    parentObjectIndex?: number; // the index of the parent object of the model in the loaded meshes array.

    castShadow?: boolean;
    receiveShadows?: boolean;
    normalize?: boolean | {
        center?: boolean;
        unitSize?: boolean;
        parentIndex?: number;
    }; // should the model be scaled to unit-size

    title?: string;
    subtitle?: string;
    thumbnail?: string; // URL or data-url

    animation?: {
        autoStart?: boolean | string;
        playOnce?: boolean;
    }

    material?: {
        directEnabled?: boolean;
        directIntensity?: number;
        emissiveIntensity?: number;
        environmentIntensity?: number;
        [propName: string]: any;
    }

    /** 
     * Rotation offset axis definition
     */
    rotationOffsetAxis?: {
        x: number;
        y: number;
        z: number;
    };

    /**
     * the offset angle
     */
    rotationOffsetAngle?: number;

    loaderConfiguration?: {
        maxLODsToLoad?: number;
        progressiveLoading?: boolean;
    }

    // [propName: string]: any; // further configuration, like title and creator
}

export interface ISkyboxConfiguration {
    cubeTexture?: {
        noMipMap?: boolean;
        gammaSpace?: boolean;
        url?: string | Array<string>;
    };
    color?: { r: number, g: number, b: number };
    pbr?: boolean; // deprecated
    scale?: number;
    blur?: number; // deprecated
    material?: {
        imageProcessingConfiguration?: IImageProcessingConfiguration;
        [propName: string]: any;
    };
    infiniteDistance?: boolean;

}

export interface IGroundConfiguration {
    size?: number;
    receiveShadows?: boolean;
    shadowLevel?: number;
    shadowOnly?: boolean; // deprecated
    mirror?: boolean | {
        sizeRatio?: number;
        blurKernel?: number;
        amount?: number;
        fresnelWeight?: number;
        fallOffDistance?: number;
        textureType?: number;
    };
    texture?: string;
    color?: { r: number, g: number, b: number };
    opacity?: number;
    material?: {
        [propName: string]: any;
    };
}

export interface ISceneConfiguration {
    debug?: boolean;
    clearColor?: { r: number, g: number, b: number, a: number };
    mainColor?: { r: number, g: number, b: number };
    environmentMainColor?: { r: number, g: number, b: number };
    imageProcessingConfiguration?: IImageProcessingConfiguration;
    environmentTexture?: string;
    colorGrading?: IColorGradingConfiguration;
    environmentRotationY?: number;
    glow?: boolean | IGlowLayerOptions;
    disableHdr?: boolean;
    renderInBackground?: boolean;
    disableCameraControl?: boolean;
    animationPropertiesOverride?: {
        [propName: string]: any;
    };
    defaultMaterial?: {
        materialType: "standard" | "pbr";
        [propName: string]: any;
    };
    flags?: {
        shadowsEnabled?: boolean;
        particlesEnabled?: boolean;
        collisionsEnabled?: boolean;
        lightsEnabled?: boolean;
        texturesEnabled?: boolean;
        lensFlaresEnabled?: boolean;
        proceduralTexturesEnabled?: boolean;
        renderTargetsEnabled?: boolean;
        spritesEnabled?: boolean;
        skeletonsEnabled?: boolean;
        audioEnabled?: boolean;
    }
}

/**
 * The Color Grading Configuration groups the different settings used to define the color grading used in the viewer.
 */
export interface IColorGradingConfiguration {

    /**
     * Transform data string, encoded as determined by transformDataFormat.
     */
    transformData: string;

    /**
     * The encoding format of TransformData (currently only raw-base16 is supported).
     */
    transformDataFormat: string;

    /**
     * The weight of the transform
     */
    transformWeight: number;

    /**
     * Color curve colorFilterHueGlobal value
     */
    colorFilterHueGlobal: number;

    /**
     * Color curve colorFilterHueShadows value
     */
    colorFilterHueShadows: number;

    /**
     * Color curve colorFilterHueMidtones value
     */
    colorFilterHueMidtones: number;

    /**
     * Color curve colorFilterHueHighlights value
     */
    colorFilterHueHighlights: number;

    /**
     * Color curve colorFilterDensityGlobal value
     */
    colorFilterDensityGlobal: number;

    /**
     * Color curve colorFilterDensityShadows value
     */
    colorFilterDensityShadows: number;

    /**
     * Color curve colorFilterDensityMidtones value
     */
    colorFilterDensityMidtones: number;

    /**
     * Color curve colorFilterDensityHighlights value
     */
    colorFilterDensityHighlights: number;

    /**
     * Color curve saturationGlobal value
     */
    saturationGlobal: number;

    /**
     * Color curve saturationShadows value
     */
    saturationShadows: number;

    /**
     * Color curve saturationMidtones value
     */
    saturationMidtones: number;

    /**
     * Color curve saturationHighlights value
     */
    saturationHighlights: number;

    /**
     * Color curve exposureGlobal value
     */
    exposureGlobal: number;

    /**
     * Color curve exposureShadows value
     */
    exposureShadows: number;

    /**
     * Color curve exposureMidtones value
     */
    exposureMidtones: number;

    /**
     * Color curve exposureHighlights value
     */
    exposureHighlights: number;

}

export interface ISceneOptimizerConfiguration {
    targetFrameRate?: number;
    trackerDuration?: number;
    autoGeneratePriorities?: boolean;
    improvementMode?: boolean;
    degradation?: string; // low, moderate, high
    types?: {
        texture?: ISceneOptimizerParameters;
        hardwareScaling?: ISceneOptimizerParameters;
        shadow?: ISceneOptimizerParameters;
        postProcess?: ISceneOptimizerParameters;
        lensFlare?: ISceneOptimizerParameters;
        particles?: ISceneOptimizerParameters;
        renderTarget?: ISceneOptimizerParameters;
        mergeMeshes?: ISceneOptimizerParameters;
    }
    custom?: string;
}

export interface IObserversConfiguration {
    onEngineInit?: string;
    onSceneInit?: string;
    onModelLoaded?: string;
}

export interface ICameraConfiguration {
    position?: { x: number, y: number, z: number };
    rotation?: { x: number, y: number, z: number, w: number };
    fov?: number;
    fovMode?: number;
    minZ?: number;
    maxZ?: number;
    inertia?: number;
    exposure?: number;
    pinchPrecision?: number;
    behaviors?: {
        [name: string]: number | {
            type: number;
            [propName: string]: any;
        };
    };
    disableCameraControl?: boolean;
    disableCtrlForPanning?: boolean;
    disableAutoFocus?: boolean;

    [propName: string]: any;
}

export interface ILightConfiguration {
    type: number;
    name?: string;
    disabled?: boolean;
    position?: { x: number, y: number, z: number };
    target?: { x: number, y: number, z: number };
    direction?: { x: number, y: number, z: number };
    diffuse?: { r: number, g: number, b: number };
    specular?: { r: number, g: number, b: number };
    intensity?: number;
    intensityMode?: number;
    radius?: number;
    shadownEnabled?: boolean; // only on specific lights!
    shadowConfig?: {
        useBlurExponentialShadowMap?: boolean;
        useBlurCloseExponentialShadowMap?: boolean;
        useKernelBlur?: boolean;
        blurKernel?: number;
        blurScale?: number;
        minZ?: number;
        maxZ?: number;
        frustumSize?: number;
        angleScale?: number;
        frustumEdgeFalloff?: number;
        [propName: string]: any;
    };
    spotAngle?: number;
    shadowFieldOfView?: number;
    shadowBufferSize?: number;
    shadowFrustumSize?: number;
    shadowMinZ?: number;
    shadowMaxZ?: number;
    [propName: string]: any;

    // no behaviors for light at the moment, but allowing configuration for future reference.
    behaviors?: {
        [name: string]: number | {
            type: number;
            [propName: string]: any;
        };
    };
}

export interface ISceneOptimizerParameters {
    priority?: number;
    maximumSize?: number;
    step?: number;
}

export interface IImageProcessingConfiguration {
    colorGradingEnabled?: boolean;
    colorCurvesEnabled?: boolean;
    colorCurves?: {
        globalHue?: number;
        globalDensity?: number;
        globalSaturation?: number;
        globalExposure?: number;
        highlightsHue?: number;
        highlightsDensity?: number;
        highlightsSaturation?: number;
        highlightsExposure?: number;
        midtonesHue?: number;
        midtonesDensity?: number;
        midtonesSaturation?: number;
        midtonesExposure?: number;
        shadowsHue?: number;
        shadowsDensity?: number;
        shadowsSaturation?: number;
        shadowsExposure?: number;
    };
    colorGradingWithGreenDepth?: boolean;
    colorGradingBGR?: boolean;
    exposure?: number;
    toneMappingEnabled?: boolean;
    contrast?: number;
    vignetteEnabled?: boolean;
    vignetteStretch?: number;
    vignetteCentreX?: number;
    vignetteCentreY?: number;
    vignetteWeight?: number;
    vignetteColor?: { r: number, g: number, b: number, a?: number };
    vignetteCameraFov?: number;
    vignetteBlendMode?: number;
    vignetteM?: boolean;
    applyByPostProcess?: boolean;
    isEnabled?: boolean;
}