@predy-js/render-interface 0.1.8 → 0.1.10

package/dist/src/index.d.ts

@@ -6,7 +6,7 @@ export { constants } from './webgl/constants';
 export * from '../types/ShaderLibrary';
 export { MarsRenderFrame as RenderFrame } from './render/MarsRenderFrame';
 export { MarsRenderer as Renderer } from './render/MarsRenderer';
-export { MarsMesh as Mesh } from './render/MarsMesh';
+export { MarsMesh as Mesh, MarsInstancedMesh as InstancedMesh } from './render/MarsMesh';
 export { MarsGeometry as Geometry } from './render/MarsGeometry';
 export { MarsRenderPass as RenderPass } from './render/MarsRenderPass';
 export { MarsTexture as Texture } from './render/MarsTexture';

package/dist/src/render/MarsMesh.d.ts

@@ -1,10 +1,11 @@
-import type { Mesh, MeshDestroyOptions, MeshOptions } from '../../types/Mesh';
+import type { InstancedMeshOptions, Mesh, MeshDestroyOptions, MeshOptions } from '../../types/Mesh';
 import { MarsMaterial } from './MarsMaterial';
 import { MarsGeometry } from './MarsGeometry';
 import type { Material, MaterialDestroyOptions, MaterialOptions } from '../../types/Material';
 import type { MarsRenderer } from './MarsRenderer';
 import type { mat4 } from '../../types';
 import { DestroyOptions } from '../../types/constants';
+import type { InstancedMesh } from '../../types/Mesh';
 export declare class MarsMesh implements Mesh {
     readonly material: MarsMaterial;
     readonly geometries: MarsGeometry[];
@@ -16,9 +17,13 @@ export declare class MarsMesh implements Mesh {
     private _isDestroyed;
     get isDestroyed(): boolean;
     get geometry(): MarsGeometry;
-    constructor(options: MeshOptions);
+    constructor(options: MeshOptions, renderer?: MarsRenderer);
     setMaterial(mtl: Material | MaterialOptions, destroyMtl?: MaterialDestroyOptions | DestroyOptions.keep): void;
     setGeometries(geos: MarsGeometry[], destroyGeometries?: DestroyOptions): void;
     destroy(options?: MeshDestroyOptions): void;
     assignRenderer(renderer: MarsRenderer): MarsMesh;
 }
+export declare class MarsInstancedMesh extends MarsMesh implements InstancedMesh {
+    instanceCount: number;
+    constructor(options: InstancedMeshOptions, renderer?: MarsRenderer);
+}

package/dist/src/webgl/GLGPUCapability.d.ts

@@ -7,6 +7,7 @@ interface GLGPUCapabilityDetail extends GPUCapabilityDetail {
     floatLinear: boolean;
     maxSample: number;
     maxShaderTexCount: number;
+    instanceDraw: boolean;
 }
 export declare class GLGPUCapability implements GPUCapability {
     readonly capability: Immutable<GLGPUCapabilityDetail>;
@@ -17,6 +18,7 @@ export declare class GLGPUCapability implements GPUCapability {
     UNSIGNED_INT_24_8: number;
     internalFormatDepth16: number;
     internalFormatDepth24_stencil8: number;
+    instanceDrawExt?: ANGLE_instanced_arrays;
     constructor(opt: {
         glType?: 'webgl' | 'webgl2';
         gl?: WebGLRenderingContext | WebGL2RenderingContext;
@@ -24,6 +26,9 @@ export declare class GLGPUCapability implements GPUCapability {
     _setupCapability(gl?: WebGLRenderingContext | WebGL2RenderingContext): void;
     checkLinearTextureFilter(gl: WebGL2RenderingContext, type: number): boolean;
     framebufferTexture2D(gl: WebGLRenderingContext | WebGL2RenderingContext, target: GLenum, index: number, textarget: number, texture: WebGLTexture): void;
+    vertexAttribDivisor(gl: WebGLRenderingContext | WebGL2RenderingContext, loc: number, divisor: number): void;
+    drawElementsInstanced(gl: WebGLRenderingContext | WebGL2RenderingContext, mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
+    drawArraysInstanced(gl: WebGLRenderingContext | WebGL2RenderingContext, mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
     drawBuffers(gl: WebGLRenderingContext | WebGL2RenderingContext, bufferStates: boolean[]): void;
     setTextureAnisotropic(gl: WebGLRenderingContext | WebGL2RenderingContext, target: GLenum, level: number): void;
     setup(gl: WebGLRenderingContext): void;

package/dist/src/webgl/GLGPURenderer.d.ts

@@ -4,7 +4,6 @@ import { GLShaderLibrary } from './GLShaderLibrary';
 import type { GPURenderer, RendererExtensions } from '../../types';
 import type { GPUBufferOptions } from '../../types/GPUBuffer';
 import type { RenderFrame, RenderFrameOptions } from '../../types/RenderFrame';
-import type { ParsedScene, SceneSchema } from '../../types/Scene';
 import { GLGPUCapability } from './GLGPUCapability';
 import { GLTexture } from './GLTexture';
 import type { GLRenderBuffer } from './GLRenderBuffer';
@@ -34,7 +33,6 @@ export declare class GLGPURenderer implements GPURenderer {
     createGLRenderBuffer(renderbuffer: GLRenderBuffer): WebGLRenderbuffer | null;
     createPipeline(options?: RenderFrameOptions): RenderFrame;
     createBuffer(options: GPUBufferOptions): GLGPUBuffer;
-    parseSceneSchema(schema: SceneSchema): ParsedScene;
     resize(width: number, height: number): void;
     _assignInspectorName(obj: any, name?: string, id?: string): void;
     createGLFrameBuffer(frameBuffer: GLFrameBuffer, name?: string): WebGLFramebuffer | null;

package/dist/src/webgl/constants.d.ts

@@ -1,4 +1,6 @@
 import type { TypedArray } from '../../types/type';
+import type { vec2 } from '@predy-js/specification';
 export declare let constants: WebGL2RenderingContext;
 export declare function createTypedArrayByGLType(type: number, elementCount: number | ArrayBuffer): TypedArray;
 export declare function getBytesPerElementByGLType(type: number): number;
+export declare function getMatAttrLocPair(type: number): vec2;

package/dist/statistic.js

@@ -2,7 +2,7 @@
  * Name: @predy-js/render-interface
  * Description: undefined
  * Author: undefined
- * Version: v0.1.8
+ * Version: v0.1.10
  */
 
 // https://github.com/greggman/webgl-memory/blob/main/src/texture-utils.js

package/dist/types/Mesh.d.ts

@@ -47,4 +47,15 @@ export declare class Mesh implements IGPUResource {
     destroy(options?: MeshDestroyOptions): void;
     assignRenderer(renderer: GPURenderer): Mesh;
 }
+export interface InstancedGeometryMeshOptions extends GeometryMeshOptions {
+    instanceCount: number;
+}
+export interface InstancedGeometriesMeshOptions extends GeometriesMeshOptions {
+    instanceCount: number;
+}
+export type InstancedMeshOptions = InstancedGeometryMeshOptions | InstancedGeometriesMeshOptions;
+export declare class InstancedMesh extends Mesh {
+    instanceCount: number;
+    constructor(options: InstancedMeshOptions, renderer?: IGPURenderer);
+}
 export {};

package/dist/types/RenderFrame.d.ts

@@ -7,9 +7,10 @@ import type { vec4 } from './type';
 import type { GPURenderer } from './index';
 import type { IGPURenderer, IGPUResource } from './IGPURenderer';
 import type { DestroyOptions } from './constants';
+import type { InstancedMesh } from './Mesh';
 export interface RenderState {
     currentCamera: Camera;
-    currentMesh: Mesh;
+    currentMesh: Mesh | InstancedMesh;
     currentFrame: RenderFrame;
     currentPass: RenderPass;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@predy-js/render-interface",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "license": "MIT",
   "module": "./dist/index.mjs",
   "main": "./dist/index.js",

package/dist/types/Scene.d.ts

@@ -1,48 +0,0 @@
-import type { Geometry, GeometryOptions } from './Geometry';
-import type { Material, MaterialOptions, UniformValue } from './Material';
-import type { Texture, TextureOptions } from './Texture';
-import type { RenderPass, RenderPassOptions } from './RenderPass';
-import type { Camera, CameraOptions } from './Camera';
-import type { Mesh } from './Mesh';
-type SceneNode = {
-    meshes: number[];
-    camera: number;
-};
-type SceneMaterial = MaterialOptions | {
-    extends: number;
-    vertexShader: string | number;
-    fragmentShader: string | number;
-    uniforms: {
-        [key: string]: UniformValue;
-    };
-    textures: {
-        [key: string]: number | number[];
-    };
-};
-type SceneMesh = {
-    name: string;
-    material: number;
-    geometries: number[];
-};
-type SceneRenderPass = RenderPassOptions | {
-    attachments: number[];
-};
-export interface SceneSchema {
-    texture: TextureOptions[];
-    geometries: GeometryOptions[];
-    materials: SceneMaterial[];
-    meshes: SceneMesh[];
-    nodes: SceneNode[];
-    renderPasses: SceneRenderPass[];
-    cameras: CameraOptions[];
-    shaders: string[];
-}
-export interface ParsedScene {
-    texture: Texture[];
-    geometries: Geometry[];
-    materials: Material[];
-    meshes: Mesh[];
-    renderPasses: RenderPass[];
-    cameras: Camera[];
-}
-export {};