rhodonite 0.8.3 → 0.8.4

package/VERSION-FILE

@@ -1,2 +1,2 @@
-v0.8.3-0-gd9bf142b-dirty
+v0.8.4-0-g69da65e6-dirty
 master

package/dist/cjs/effekseer/EffekseerComponent.d.ts

@@ -9,6 +9,7 @@ import { ComponentTID, EntityUID, ComponentSID, Second } from '../types/CommonTy
 import { IVector3 } from '../foundation/math/IVector';
 import type { Unzip } from 'zlib';
 import { IEntity } from '../foundation/core/Entity';
+import { RenderPass } from '../foundation/renderer/RenderPass';
 export declare class EffekseerComponent extends Component {
     static readonly ANIMATION_EVENT_PLAY = 0;
     static readonly ANIMATION_EVENT_PAUSE = 1;
@@ -56,6 +57,7 @@ export declare class EffekseerComponent extends Component {
     $load(): void;
     $logic(): void;
     $render(): void;
+    static sort_$render(renderPass: RenderPass): ComponentSID[];
     /**
      * @override
      * Add this component to the entity

package/dist/cjs/foundation/components/Camera/CameraComponent.d.ts

@@ -23,6 +23,7 @@ export declare class CameraComponent extends Component {
     private _filmWidth;
     private _filmHeight;
     private _focalLength;
+    private primitiveMode;
     private _corner;
     private _cornerInner;
     private _parameters;
@@ -95,6 +96,8 @@ export declare class CameraComponent extends Component {
     get fovy(): number;
     set fovyInner(val: number);
     set aspect(val: number);
+    set aspectInner(val: number);
+    get aspectInner(): number;
     get aspect(): number;
     set xMag(val: number);
     get xMag(): number;

package/dist/cjs/foundation/components/Light/LightComponent.d.ts

@@ -13,6 +13,7 @@ export declare class LightComponent extends Component {
     innerConeAngle: number;
     outerConeAngle: number;
     range: number;
+    enable: boolean;
     private __sceneGraphComponent?;
     private static __globalDataRepository;
     private static __tmp_vec4;

package/dist/cjs/foundation/core/GlobalDataRepository.d.ts

@@ -25,6 +25,7 @@ export declare class GlobalDataRepository {
     getGlobalPropertyStruct(propertyIndex: Index): GlobalPropertyStruct | undefined;
     getGlobalProperties(): GlobalPropertyStruct[];
     setUniformLocationsForUniformModeOnly(shaderProgramUid: CGAPIResourceHandle): void;
+    setUniformLocationsForFastestModeOnly(shaderProgramUid: CGAPIResourceHandle): void;
     setUniformValues(shaderProgram: WebGLProgram): void;
     getLocationOffsetOfProperty(propertyIndex: Index): IndexOf16Bytes;
     getCurrentDataNumberOfTheProperty(propertyIndex: Index): number;

package/dist/cjs/foundation/definitions/AlphaMode.d.ts

@@ -1,13 +1,15 @@
 import { EnumIO } from '../misc/EnumIO';
-export declare type AlphaModeEnum = EnumIO;
+export interface AlphaModeEnum extends EnumIO {
+    toGltfString(): string;
+}
 declare function from(index: number): AlphaModeEnum | undefined;
 declare function fromString(str: string): AlphaModeEnum | undefined;
 declare function fromGlTFString(str: string): AlphaModeEnum | undefined;
 export declare const AlphaMode: Readonly<{
-    Opaque: EnumIO;
-    Mask: EnumIO;
-    Translucent: EnumIO;
-    Additive: EnumIO;
+    Opaque: AlphaModeEnum;
+    Mask: AlphaModeEnum;
+    Translucent: AlphaModeEnum;
+    Additive: AlphaModeEnum;
     from: typeof from;
     fromString: typeof fromString;
     fromGlTFString: typeof fromGlTFString;

package/dist/cjs/foundation/definitions/ShaderSemantics.d.ts

@@ -31,6 +31,7 @@ export declare const ShaderSemantics: Readonly<{
     fromStringCaseSensitively: typeof fromStringCaseSensitively;
     WorldMatrix: ShaderSemanticsEnum;
     ViewMatrix: ShaderSemanticsEnum;
+    EnableViewMatrix: ShaderSemanticsEnum;
     ProjectionMatrix: ShaderSemanticsEnum;
     NormalMatrix: ShaderSemanticsEnum;
     BoneMatrix: ShaderSemanticsEnum;
@@ -48,6 +49,7 @@ export declare const ShaderSemantics: Readonly<{
     BrdfLutTexture: ShaderSemanticsEnum;
     DiffuseEnvTexture: ShaderSemanticsEnum;
     SpecularEnvTexture: ShaderSemanticsEnum;
+    InverseEnvironment: ShaderSemanticsEnum;
     IBLParameter: ShaderSemanticsEnum;
     ViewPosition: ShaderSemanticsEnum;
     Wireframe: ShaderSemanticsEnum;
@@ -87,6 +89,10 @@ export declare const ShaderSemantics: Readonly<{
     TransmissionTexture: ShaderSemanticsEnum;
     BackBufferTexture: ShaderSemanticsEnum;
     BackBufferTextureSize: ShaderSemanticsEnum;
+    ThicknessFactor: ShaderSemanticsEnum;
+    ThicknessTexture: ShaderSemanticsEnum;
+    AttenuationDistance: ShaderSemanticsEnum;
+    AttenuationColor: ShaderSemanticsEnum;
     fullSemanticStr: typeof fullSemanticStr;
     getShaderProperty: getShaderPropertyFunc;
     EntityUID: ShaderSemanticsEnum;
@@ -114,5 +120,6 @@ export declare const ShaderSemantics: Readonly<{
     OcclusionStrength: ShaderSemanticsClass;
     envRotation: ShaderSemanticsClass;
     EnvHdriFormat: ShaderSemanticsClass;
+    VrState: ShaderSemanticsClass;
 }>;
 export {};

package/dist/cjs/foundation/geometry/Primitive.d.ts

@@ -26,7 +26,7 @@ export declare class Primitive extends RnObject {
     private __material;
     _prevMaterial: Material;
     private __attributes;
-    private __indices?;
+    private __oIndices;
     private static __primitiveCount;
     private __primitiveUid;
     private static __headerAccessor?;
@@ -34,7 +34,7 @@ export declare class Primitive extends RnObject {
     private __targets;
     private __vertexHandles?;
     private __latestPositionAccessorVersion;
-    private __weakRefMesh;
+    private __woMesh;
     private static __primitives;
     _sortkey: PrimitiveSortKey;
     _viewDepth: number;

package/dist/cjs/foundation/helpers/MaterialHelper.d.ts

@@ -11,16 +11,17 @@ import { IMeshRendererEntityMethods } from '../components/MeshRenderer/IMeshRend
 declare function createMaterial(materialName: string, materialNode?: AbstractMaterialContent, maxInstancesNumber?: Count): Material;
 declare function recreateMaterial(materialName: string, materialNode?: AbstractMaterialContent, maxInstancesNumber?: Count): Material;
 declare function createEmptyMaterial(): Material;
-declare function createPbrUberMaterial({ additionalName, isMorphing, isSkinning, isLighting, isClearCoat, isTransmission, useTangentAttribute, useNormalTexture, alphaMode, maxInstancesNumber, }?: {
+declare function createPbrUberMaterial({ additionalName, isMorphing, isSkinning, isLighting, isClearCoat, isTransmission, isVolume, useTangentAttribute, useNormalTexture, alphaMode, maxInstancesNumber, }?: {
     additionalName?: string | undefined;
     isMorphing?: boolean | undefined;
     isSkinning?: boolean | undefined;
     isLighting?: boolean | undefined;
     isClearCoat?: boolean | undefined;
     isTransmission?: boolean | undefined;
+    isVolume?: boolean | undefined;
     useTangentAttribute?: boolean | undefined;
     useNormalTexture?: boolean | undefined;
-    alphaMode?: import("..").EnumIO | undefined;
+    alphaMode?: import("../definitions/AlphaMode").AlphaModeEnum | undefined;
     maxInstancesNumber?: number | undefined;
 }): Material;
 declare function createClassicUberMaterial({ additionalName, isSkinning, isLighting, isMorphing, alphaMode, maxInstancesNumber, }?: {
@@ -28,7 +29,7 @@ declare function createClassicUberMaterial({ additionalName, isSkinning, isLight
     isSkinning?: boolean | undefined;
     isLighting?: boolean | undefined;
     isMorphing?: boolean | undefined;
-    alphaMode?: import("..").EnumIO | undefined;
+    alphaMode?: import("../definitions/AlphaMode").AlphaModeEnum | undefined;
     maxInstancesNumber?: number | undefined;
 }): Material;
 declare function createEnvConstantMaterial({ additionalName, maxInstancesNumber, makeOutputSrgb, }?: {
@@ -129,7 +130,7 @@ declare function recreateCustomMaterial(vertexShaderStr: string, pixelShaderStr:
     isSkinning?: boolean | undefined;
     isLighting?: boolean | undefined;
     isMorphing?: boolean | undefined;
-    alphaMode?: import("..").EnumIO | undefined;
+    alphaMode?: import("../definitions/AlphaMode").AlphaModeEnum | undefined;
     maxInstancesNumber?: number | undefined;
 }): Material;
 declare function recreateShaderityMaterial(vertexShaderityObj: ShaderityObject, pixelShaderityObj: ShaderityObject, { additionalName, maxInstancesNumber, }?: {

package/dist/cjs/foundation/materials/contents/CustomMaterialContent.d.ts

@@ -5,13 +5,15 @@ import { AlphaModeEnum } from '../../definitions/AlphaMode';
 import { RenderingArg } from '../../../webgl/types/CommonTypes';
 import { ShaderSemanticsInfo } from '../../definitions/ShaderSemanticsInfo';
 export declare class CustomMaterialContent extends AbstractMaterialContent {
-    constructor({ name, isMorphing, isSkinning, isLighting, isClearCoat, isTransmission, alphaMode, useTangentAttribute, useNormalTexture, vertexShader, pixelShader, additionalShaderSemanticInfo, }: {
+    private static __globalDataRepository;
+    constructor({ name, isMorphing, isSkinning, isLighting, isClearCoat, isTransmission, isVolume, alphaMode, useTangentAttribute, useNormalTexture, vertexShader, pixelShader, additionalShaderSemanticInfo, }: {
         name: string;
         isMorphing: boolean;
         isSkinning: boolean;
         isLighting: boolean;
         isClearCoat?: boolean;
         isTransmission?: boolean;
+        isVolume?: boolean;
         alphaMode: AlphaModeEnum;
         useTangentAttribute: boolean;
         useNormalTexture: boolean;

package/dist/cjs/foundation/misc/Option.d.ts

@@ -1,33 +1,38 @@
 export interface IOption<T> {
     then<U>(f: (value: T) => IOption<U>): IOption<U>;
     then(f: (value: T) => None): None;
-    getOrDefault(altValue: T): T;
-    getOrElse(f: (...vals: any) => T): T;
-    getOrError(): T;
+    unwrapOrDefault(altValue: T): T;
+    unwrapOrElse(f: (...vals: any) => T): T;
+    unwrapOrUndefined(): T | undefined;
+    unwrapForce(): T;
+    has(): boolean;
 }
 export declare class Option<T> implements IOption<T> {
     private value?;
+    constructor(value?: T | undefined);
     set(val: T): void;
     /**
-     * This method is essentially same to the Some::and_then() in Rust language
+     * if inner
      * @param f
      */
-    then<U>(f: (value: T) => None): None;
+    then(f: (value: T) => None): None;
     then<U>(f: (value: T) => Some<U>): Some<U>;
     /**
      * @param altValue
      * @returns
      */
-    getOrDefault(altValue: T): T;
+    unwrapOrDefault(altValue: T): T;
     /**
      * @param altValue
      * @returns
      */
-    getOrElse(f: (...vals: any) => T): T;
+    unwrapOrElse(f: (...vals: any) => T): T;
     /**
      * @returns
      */
-    getOrError(): T;
+    unwrapForce(): T;
+    unwrapOrUndefined(): T | undefined;
+    has(): boolean;
 }
 /**
  * a class indicating that the included value exists.
@@ -39,34 +44,34 @@ export declare class Some<T> implements IOption<T> {
      * This method is essentially same to the Some::and_then() in Rust language
      * @param f
      */
-    then<U>(f: (value: T) => None): None;
+    then(f: (value: T) => None): None;
     then<U>(f: (value: T) => Some<U>): Some<U>;
     /**
-     * @deprecated use the 'get' method instead
      * @param altValue
      * @returns
      */
-    getOrDefault(altValue: T): T;
+    unwrapOrDefault(altValue: T): T;
     /**
-     * @deprecated use the 'get' method instead
      * @param altValue
      * @returns
      */
-    getOrElse(f: (value: T) => T): T;
+    unwrapOrElse(f: (value: T) => T): T;
     /**
-     * @deprecated use the 'get' method instead
      * @param altValue
      * @returns
      */
-    getOrError(): T;
-    get(): T;
+    unwrapForce(): T;
+    unwrapOrUndefined(): T;
+    has(): true;
 }
 /**
  * a class indicating no existence.
  */
 export declare class None implements IOption<never> {
     then(): None;
-    getOrDefault<T>(value: T): T;
-    getOrElse(f: (...vals: any) => never): never;
-    getOrError(): never;
+    unwrapOrDefault<T>(value: T): T;
+    unwrapOrElse(f: (...vals: any) => never): never;
+    unwrapForce(): never;
+    unwrapOrUndefined(): never;
+    has(): false;
 }

package/dist/cjs/foundation/misc/Result.d.ts

@@ -1,6 +1,6 @@
 export interface RnError<ErrObj> {
     message: string;
-    error: ErrObj;
+    error?: ErrObj;
 }
 /**
  * An interface to handle the results in a unified manner,
@@ -20,8 +20,8 @@ export interface IResult<T, ErrObj> {
     name(): string;
 }
 declare abstract class Result<T, ErrObj> {
-    protected val: T | RnError<ErrObj>;
-    constructor(val: T | RnError<ErrObj>);
+    protected val?: T | RnError<ErrObj> | undefined;
+    constructor(val?: T | RnError<ErrObj> | undefined);
     match(obj: {
         Ok: (value: T) => void;
         Err: (value: RnError<ErrObj>) => void;
@@ -33,7 +33,7 @@ declare abstract class Result<T, ErrObj> {
  * a class indicating that the result is Ok (Succeeded).
  */
 export declare class Ok<T, ErrObj> extends Result<T, ErrObj> implements IResult<T, ErrObj> {
-    constructor(val: T);
+    constructor(val?: T);
     /**
      * This method is essentially same to the Ok::and_then() in Rust language
      * @param f
@@ -51,7 +51,7 @@ export declare class Ok<T, ErrObj> extends Result<T, ErrObj> implements IResult<
  */
 export declare class Err<T, ErrObj> extends Result<T, ErrObj> implements IResult<T, ErrObj> {
     private __rnException;
-    constructor(val: RnError<ErrObj>);
+    constructor(val?: RnError<ErrObj>);
     then(f: (value: never) => void): void;
     catch(f: (value: RnError<ErrObj>) => void): Finalizer;
     unwrap(catchFn: (err: RnError<ErrObj>) => void): void;

package/dist/cjs/foundation/misc/WeakOption.d.ts

@@ -0,0 +1,63 @@
+export interface IWeakOption<B extends object, T> {
+    unwrapOrDefault(base: B, altValue: T): T;
+    unwrapOrElse(base: B, f: (...vals: any) => T): T;
+    unwrapForce(base: B): T;
+    unwrapOrUndefined(base: B): T | undefined;
+    has(base: B): boolean;
+}
+export declare class WeakOption<B extends object, T> implements IWeakOption<B, T> {
+    private __weakMap;
+    set(base: B, val: T): void;
+    /**
+     * @param altValue
+     * @returns
+     */
+    unwrapOrDefault(base: B, altValue: T): T;
+    /**
+     * @param altValue
+     * @returns
+     */
+    unwrapOrElse(base: B, f: (...vals: any) => T): T;
+    /**
+     * @returns
+     */
+    unwrapForce(base: B): T;
+    unwrapOrUndefined(base: B): T | undefined;
+    has(base: B): boolean;
+}
+/**
+ * a class indicating that the included value exists.
+ */
+export declare class WeakSome<B extends object, T> implements IWeakOption<B, T> {
+    private __weakMap;
+    constructor(base: B, value: T);
+    /**
+     * @param altValue
+     * @returns
+     */
+    unwrapOrDefault(base: B, altValue: T): T;
+    /**
+     * @param altValue
+     * @returns
+     */
+    unwrapOrElse(base: B, f: (value: T) => T): T;
+    /**
+     * @param altValue
+     * @returns
+     */
+    unwrapForce(base: B): T;
+    get(base: B): T;
+    unwrapOrUndefined(base: B): T | undefined;
+    has(base: B): true;
+}
+/**
+ * a class indicating no existence.
+ */
+export declare class WeakNone<B extends object> implements IWeakOption<B, never> {
+    then(): WeakNone<B>;
+    unwrapOrDefault<T>(base: B, value: T): T;
+    unwrapOrElse(base: B, f: (...vals: any) => never): never;
+    unwrapForce(base: B): never;
+    unwrapOrUndefined(base: B): never;
+    has(): false;
+}

package/dist/cjs/foundation/misc/cache/Cache.d.ts

@@ -0,0 +1,5 @@
+export declare class Cache<T> {
+    private __symbolWeakMap;
+    constructor();
+    register(value: T): void;
+}

package/dist/cjs/foundation/misc/cache/SymbolWeakMap.d.ts

@@ -0,0 +1,33 @@
+export declare class SymbolWeakMap<V> {
+    private __weakMap;
+    constructor();
+    /**
+     * set key and value
+     * @param symbol the key for access
+     * @param value the value as a cache item
+     * @returns true: succeed to set value, false: not set (already exists)
+     */
+    set(symbol: Symbol, value: V): boolean;
+    /**
+     * return the boolean value whether it have the key or not
+     * @param symbol the key for access
+     * @returns Whether it have the key or not.
+     */
+    has(symbol: Symbol): boolean;
+    /**
+     * return the number of this cache items
+     * @returns the number of this cache items
+     */
+    /**
+     * return the value in the cache by the key
+     * @param symbol the key for access
+     * @returns the value in the cache by the key
+     */
+    get(symbol: Symbol): V | undefined;
+    /**
+     * delete the value
+     * @param symbol the key for access
+     * @returns the flag of the deletion was succeed or not
+     */
+    delete(symbol: Symbol): boolean;
+}

package/dist/cjs/foundation/misc/cache/cachify.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This is from : https://github.com/threepointone/glamor/blob/667b480d31b3721a905021b26e1290ce92ca2879/docs/weakmaps.md#so-what-does-a-cache-built-with-a-weakmap-look-like
+ * Thank you!
+ */
+import { primitives } from '../../../types/CommonTypes';
+declare type ObjectFnType = (arg: object) => unknown;
+/**
+ * Return the caching wrapper function
+ * @param fn the target function for caching result
+ * @returns
+ */
+export declare const objectCachify: (fn: ObjectFnType) => ObjectFnType;
+/**
+ * Return the caching wrapper function
+ * @param fn the target function for caching result
+ * @returns
+ */
+export declare const primitiveCachify1: <P extends primitives>(fn: (arg: P) => unknown) => (arg: P) => unknown;
+export {};

package/dist/cjs/foundation/misc/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Cache';
+export * from './cachify';
+export * from './SymbolWeakMap';

package/dist/cjs/foundation/misc/index.d.ts

@@ -1,10 +1,11 @@
+export * from './cache';
 export * from './DataUtil';
 export * from './EnumIO';
 export * from './ImageUtil';
 export * from './Is';
-export * from './ManualCache';
 export * from './MiscUtil';
 export * from './Option';
 export * from './Result';
 export * from './RnPromise';
 export * from './Time';
+export * from './WeakOption';

package/dist/cjs/foundation/renderer/RenderPass.d.ts

@@ -39,6 +39,7 @@ export declare class RenderPass extends RnObject {
     isOutputForVr: boolean;
     toRenderOpaquePrimitives: boolean;
     toRenderTransparentPrimitives: boolean;
+    toRenderEffekseerEffects: boolean;
     __renderTargetColorAttachments?: RenderBufferTargetEnum[];
     private __preRenderFunc?;
     private static __tmp_Vector4_0;

package/dist/cjs/foundation/renderer/pipelines/ForwardRenderPipeline.d.ts

@@ -0,0 +1,36 @@
+import { MeshComponent } from '../../components/Mesh/MeshComponent';
+import { ShaderSemanticsEnum } from '../../definitions/ShaderSemantics';
+import { Some } from '../../misc/Option';
+import { CubeTexture } from '../../textures/CubeTexture';
+import { Expression } from '../Expression';
+import { Frame } from '../Frame';
+import { FrameBuffer } from '../FrameBuffer';
+import { RenderPass } from '../RenderPass';
+import { Material } from '../../materials/core/Material';
+import { CameraComponent } from '../../components/Camera/CameraComponent';
+import { RenderTargetTexture } from '../../textures';
+import { Size } from '../../../types';
+import { Err, Ok } from '../../misc/Result';
+export declare class ForwardRenderPipeline {
+    private __oFrame;
+    private __oFrameBufferMsaa;
+    private __oFrameBufferResolve;
+    private __oFrameBufferResolveForReference;
+    constructor();
+    setup(canvasWidth: number, canvasHeight: number): boolean;
+    setOpaqueRenderPass(renderPass: RenderPass): void;
+    setTransparentRenderPass(renderPass: RenderPass): void;
+    __setupInitialExpression(framebufferTargetOfGammaMsaa: FrameBuffer): Expression;
+    __createRenderTargets(canvasWidth: number, canvasHeight: number): {
+        framebufferMsaa: FrameBuffer;
+        framebufferResolve: FrameBuffer;
+        framebufferResolveForReference: FrameBuffer;
+    };
+    __attachIBLTextureToAllMeshComponents(diffuseCubeTexture: CubeTexture, specularCubeTexture: CubeTexture, rotation: number): void;
+    __setupMsaaResolveExpression(frame: Some<Frame>, framebufferTargetOfGammaMsaa: FrameBuffer, framebufferTargetOfGammaResolve: FrameBuffer, framebufferTargetOfGammaResolveForReference: FrameBuffer): Expression;
+    __createPostEffectCameraEntity(): import("../../helpers/EntityHelper").ICameraEntity;
+    __setupGammaExpression(frame: Frame, gammaTargetFramebuffer: FrameBuffer): void;
+    __setTextureParameterForMeshComponents(meshComponents: MeshComponent[], shaderSemantic: ShaderSemanticsEnum, value: RenderTargetTexture): void;
+    __createGammaRenderPass(material: Material, cameraComponent: CameraComponent): RenderPass;
+    resize(width: Size, height: Size): Err<unknown, unknown> | Ok<unknown, unknown>;
+}