@divinevoxel/vlox 0.0.0

package/Shaders/Code/Snippets/VoxelSnippets.js

@@ -0,0 +1,137 @@
+export function RegisterVoxelSnippets(builder) {
+    builder.snippets.create({
+        id: "#dve_solid_vertex",
+        body: {
+            GLSL: () => `@standard_position`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_solid_frag",
+        body: {
+            GLSL: () => `@standard_color`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_transparent_vertex",
+        body: {
+            GLSL: () => `@standard_position`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_transparent_frag",
+        body: {
+            GLSL: () => `@standard_transparent_color`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_glow_vertex",
+        body: {
+            GLSL: () => `@standard_position`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_glow_frag",
+        body: {
+            GLSL: () => `@standard_color`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_flora_vertex",
+        body: {
+            GLSL: () => /* glsl */ `vec3 p = position;
+
+#ifdef INSTANCES
+      mat4 finalWorld = mat4(world0,world1,world2,world3); 
+
+      vDistance = 0.;
+
+
+      finalWorld[3].xyz += worldOrigin.xyz;
+      gl_Position = viewProjection *   finalWorld * vec4(position, 1.0);  
+#endif      
+#ifndef INSTANCES
+    vec4 worldPosition = world * vec4(p , 1.0);
+
+    if(doEffects == 1.){
+
+        if(VOXEL[1].y == 1.) {
+          p.xz = dve_crossed_panel_wind_anim(worldPosition, p).xz;
+        }
+        if(VOXEL[1].y == 2.) {
+          p.xz = dve_flat_panel_wind_anim(worldPosition, p).xz;
+        }
+        if(VOXEL[1].y == 3.) {
+          p.xz = dve_cube_wind_anim(worldPosition, p).xz;
+        }
+      }
+   
+    gl_Position = viewProjection * world * vec4(p, 1.0); 
+#endif
+
+#ifdef THREE 
+gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+#endif
+
+  `,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_flora_frag",
+        body: {
+            GLSL: () => `@standard_color`,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_liquid_vertex",
+        body: {
+            GLSL: () => /* glsl */ `
+  vFlow = 0.;
+  if(VOXEL[1].y == 1.) {
+    vFlow = -1.;
+  }
+  if(VOXEL[1].y == 2.) {
+    vFlow = 1.;
+  }
+
+
+#ifdef INSTANCES
+  mat4 finalWorld = mat4(world0,world1,world2,world3); 
+
+  vDistance = 0.;
+
+
+  finalWorld[3].xyz += worldOrigin.xyz;
+  gl_Position = viewProjection *   finalWorld * vec4(position, 1.0);  
+#endif  
+
+#ifndef INSTANCESw
+  vec3 p = position;
+  vec4 worldPosition = world * vec4(p , 1.0);
+  
+  if(doEffects == 1.){
+  float height = fbm(worldPosition.xz * 0.08 + time * .01);
+    p.y += (height * 0.03) - .05;
+   }
+  
+  gl_Position = viewProjection * world * vec4(p, 1.0); 
+#endif
+
+#ifdef THREE 
+gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+#endif
+
+  `,
+        },
+    });
+    builder.snippets.create({
+        id: "#dve_liquid_frag",
+        body: {
+            GLSL: () => /* glsl */ `
+  vec4 rgb = getBaseColor(vec2(0.,time * .01 * -4. * vFlow));
+  rgb = getColor(rgb);
+  vec4 mixLight = getLight(rgb);
+  vec3 finalColor = doFog(mixLight);
+  FragColor = vec4(finalColor.rgb ,.7 );`,
+        },
+    });
+}

package/Shaders/DVEShaderRegister.d.ts

@@ -0,0 +1,42 @@
+import { URIShader } from "@amodx/uri/Shaders/Classes/URIShader.js";
+export declare class DVEShaderRegister {
+    shaders: Map<string, URIShader>;
+    create(shaders: URIShader[]): void;
+    get(id: string): URIShader | undefined;
+    getBulder(): {
+        shaders: {
+            _shaders: Map<string, URIShader>;
+            create(id: string): URIShader;
+        };
+        functions: {
+            _functions: Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderFunctionData<any>>;
+            _functionSets: Map<string, string[]>;
+            create(id: string, data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderFunctionData<any>): void;
+            _processFunctinos(id: string, data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderFunctionData<any>, shader?: URIShader | null): string;
+            build(id: string, data?: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderFunctionData<any> | null, shader?: URIShader | null, predicate?: (id: string, type: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderFunctionData<any>) => boolean): string;
+        };
+        define: {
+            _process(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderDefinesData): string;
+            build(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderDefinesData | import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderDefinesData[] | Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderDefinesData>): string;
+        };
+        constants: {
+            _process(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderConstantData): string;
+            build(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderConstantData | import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderConstantData[] | Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderConstantData>): string;
+        };
+        uniforms: {
+            _process(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderUniformData): string;
+            build(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderUniformData[] | Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderUniformData>, predicate?: (id: string, type: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderUniformData) => boolean): string;
+        };
+        snippets: {
+            _snippets: Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderSnippetData<any>>;
+            create(data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderSnippetData<any>): void;
+            override(id: string, data: import("@amodx/uri/Shaders/Types/ShaderData.types").ShaderSnippetData<any>): boolean;
+            get(id: string, args?: any): string;
+            _process(text: string, shader?: URIShader): {
+                newBody: string;
+                foundSnippet: boolean;
+            };
+            build(text: string, shader?: URIShader): string;
+        };
+    };
+}

package/Shaders/DVEShaderRegister.js

@@ -0,0 +1,15 @@
+import { URIShaderBuilder } from "@amodx/uri/Shaders/URIShaderBuilder.js";
+export class DVEShaderRegister {
+    shaders = new Map();
+    create(shaders) {
+        for (const shader of shaders) {
+            this.shaders.set(shader.id, shader);
+        }
+    }
+    get(id) {
+        return this.shaders.get(id);
+    }
+    getBulder() {
+        return URIShaderBuilder;
+    }
+}

package/Shaders/DVEShaders.d.ts

@@ -0,0 +1,55 @@
+import { ShaderAttributeData, ShaderConstantData, ShaderUniformData, ShaderVaryingData } from "@amodx/uri/Shaders/Types/ShaderData.types.js";
+import { DVEShaderRegister } from "./DVEShaderRegister.js";
+import { URIShader } from "@amodx/uri/Shaders/Classes/URIShader.js";
+export declare class DVEShaders {
+    static register: DVEShaderRegister;
+    static builder: {
+        shaders: {
+            _shaders: Map<string, URIShader>;
+            create(id: string): URIShader;
+        };
+        functions: {
+            _functions: Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderFunctionData<any>>;
+            _functionSets: Map<string, string[]>;
+            create(id: string, data: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderFunctionData<any>): void;
+            _processFunctinos(id: string, data: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderFunctionData<any>, shader?: URIShader | null): string;
+            build(id: string, data?: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderFunctionData<any> | null, shader?: URIShader | null, predicate?: (id: string, type: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderFunctionData<any>) => boolean): string;
+        };
+        define: {
+            _process(data: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderDefinesData): string;
+            build(data: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderDefinesData | import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderDefinesData[] | Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderDefinesData>): string;
+        };
+        constants: {
+            _process(data: ShaderConstantData): string;
+            build(data: ShaderConstantData | ShaderConstantData[] | Map<string, ShaderConstantData>): string;
+        };
+        uniforms: {
+            _process(data: ShaderUniformData): string;
+            build(data: ShaderUniformData[] | Map<string, ShaderUniformData>, predicate?: (id: string, type: ShaderUniformData) => boolean): string;
+        };
+        snippets: {
+            _snippets: Map<string, import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderSnippetData<any>>;
+            create(data: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderSnippetData<any>): void;
+            override(id: string, data: import("@amodx/uri/Shaders/Types/ShaderData.types.js").ShaderSnippetData<any>): boolean;
+            get(id: string, args?: any): string;
+            _process(text: string, shader?: URIShader): {
+                newBody: string;
+                foundSnippet: boolean;
+            };
+            build(text: string, shader?: URIShader): string;
+        };
+    };
+    static voxelAttributes: ShaderAttributeData[];
+    static voxelSharedUniforms: ShaderUniformData[];
+    static voxelVertexUniforms: ShaderUniformData[];
+    static voxelConstants: ShaderConstantData[];
+    static voxelVarying: ShaderVaryingData<any>[];
+    static voxelFragFunctions: string[];
+    static voxelVertexFunctions: string[];
+    static _defaultShader: URIShader;
+    static init(): void;
+    static _addInstances(shader: URIShader): void;
+    static createVoxelShader(id: string): URIShader;
+    static createBasicTextureShader(id: string): URIShader;
+    static createSkyBoxShader(id: string): URIShader;
+}

package/Shaders/DVEShaders.js

@@ -0,0 +1,369 @@
+import { URIShaderBuilder } from "@amodx/uri/Shaders/URIShaderBuilder.js";
+import { RegisterFragFunctions } from "./Code/Functions/FragmentFunctions.js";
+import { RegisterVertexFunctions } from "./Code/Functions/VertexFunctions.js";
+import { RegisterVertexSnippets } from "./Code/Snippets/VertexSnippets.js";
+import { RegisterFragmentSnippets } from "./Code/Snippets/FragmentSnippets.js";
+import { RegisterFogShaders } from "./Code/Functions/FogShaders.js";
+import { RegisterNoiseFunctions } from "./Code/Functions/UtilShaders.js";
+import { RegisterVoxelSnippets } from "./Code/Snippets/VoxelSnippets.js";
+import { DVEShaderRegister } from "./DVEShaderRegister.js";
+export class DVEShaders {
+    static register = new DVEShaderRegister();
+    static builder = URIShaderBuilder;
+    static voxelAttributes = [
+        ["position", "vec3"],
+        ["normal", "vec3"],
+        ["indices", "float"],
+        ["faceData", "float"],
+        ["voxelData", "float"],
+        ["textureIndex", "vec3"],
+        ["uv", "vec2"],
+        ["colors", "vec3"],
+    ];
+    static voxelSharedUniforms = [
+        ["time", "float"],
+        ["fogOptions", "vec4"],
+        ["vFogColor", "vec3"],
+        ["sunLightLevel", "float"],
+        ["baseLevel", "float"],
+        ["doAO", "float"],
+        ["doSun", "float"],
+        ["doRGB", "float"],
+        ["doColor", "float"],
+        ["doEffects", "float"],
+        ["mipMapBias", "float"],
+    ];
+    static voxelVertexUniforms = [
+        ["world", "mat4"],
+        ["viewProjection", "mat4"],
+        ["worldOrigin", "vec3"],
+        ["cameraPosition", "vec3"],
+        ["lightGradient", "float", 16],
+    ];
+    static voxelConstants = [
+        {
+            id: "voxelConstants",
+            body: {
+                GLSL: /* glsl */ `
+const uint lightMask = uint(0xf);
+const uint aoMask = uint(0xf);
+const uint animMask = uint(0xfff);
+const uint sVLIndex = uint(0);
+const uint rVLIndex = uint(4);
+const uint gVLIndex = uint(8);
+const uint bVLIndex = uint(12);
+const uint aoIndex = uint(16);
+const uint animIndex = uint(20);
+const float aoValue =  pow( .5, 2.2);
+        `,
+            },
+        },
+    ];
+    static voxelVarying = [
+        {
+            id: "VOXEL",
+            type: "mat4",
+            body: {
+                GLSL: () => /* glsl */ `
+mat4 vData;
+uint vUID = uint(voxelData);
+float sVL = lightGradient[int(((lightMask << sVLIndex) & vUID) >> sVLIndex)];
+
+int redValue = int(((lightMask << rVLIndex) & vUID) >> rVLIndex);
+
+int greenValue = int(((lightMask << gVLIndex) & vUID) >> gVLIndex);
+
+int blueValue = int(((lightMask << bVLIndex) & vUID) >> bVLIndex);
+
+
+float AOVL = float(((aoMask << aoIndex) & vUID) >> aoIndex);
+if(AOVL > 0.) {
+  AOVL = aoValue;
+} else {
+  AOVL = 1.;
+}
+
+float animVL = float(((animMask << animIndex) & vUID) >> animIndex);
+
+
+vData[0] = vec4(
+    max(
+        ( ( vec3(lightGradient[redValue], lightGradient[greenValue], lightGradient[blueValue]) * doRGB) 
+        +  (sVL * doSun * sunLightLevel) ), 
+        baseLevel
+    ),
+    1.0
+);
+
+/*
+vData[0] = vec4(
+      lightGradient[redValue] * doRGB, 
+      lightGradient[greenValue] * doRGB, 
+      lightGradient[blueValue] * doRGB,
+      (sVL * doSun * sunLightLevel) 
+);
+   
+*/
+
+vData[1] = vec4(AOVL,animVL,baseLevel,0.);     
+
+
+VOXEL = vData;
+`,
+            },
+        },
+        {
+            id: "cameraPOS",
+            type: "vec3",
+            body: {
+                GLSL: () => "cameraPOS = cameraPosition;\n",
+            },
+        },
+        {
+            id: "worldPOS",
+            type: "vec3",
+            body: {
+                GLSL: () => /* glsl */ `vec4 worldPOSTemp =  world * vec4(position, 1.0);
+      worldPOS = vec3(worldPOSTemp.x,worldPOSTemp.y,worldPOSTemp.z);`,
+            },
+        },
+        {
+            id: "vDistance",
+            type: "float",
+            body: {
+                GLSL: () => "vDistance = distance(cameraPOS , worldPOS );\n",
+            },
+        },
+        {
+            id: "worldPOSNoOrigin",
+            type: "vec3",
+            body: {
+                GLSL: () => /* glsl */ `mat4 a;
+a[0] = world[0];
+a[1] = world[1];
+a[2] = world[2];
+a[3] = vec4(world[3].xyz - worldOrigin.xyz, 1.);
+vec4 temp =  a * vec4(position , 1.0);
+worldPOSNoOrigin =  vec3(temp.x,temp.y,temp.z);`,
+            },
+        },
+        {
+            id: "vNormal",
+            type: "vec3",
+            body: {
+                GLSL: () => "vNormal = normal;\n",
+            },
+        },
+        {
+            id: "vColors",
+            type: "vec4",
+            body: {
+                GLSL: () => /* glsl */ `if(doColor == 1.0){
+     vColors = vec4(1.0,1.0,1.0,1.0); 
+} else {
+     vColors = vec4(1.0,1.0,1.0,1.0); 
+}`,
+            },
+        },
+        {
+            id: "vFlow",
+            type: "float",
+            body: {
+                GLSL: () => ``,
+            },
+        },
+    ];
+    static voxelFragFunctions = [];
+    static voxelVertexFunctions = [];
+    static _defaultShader = {};
+    static init() {
+        RegisterVoxelSnippets(URIShaderBuilder);
+        RegisterVertexSnippets(URIShaderBuilder);
+        RegisterFragmentSnippets(URIShaderBuilder);
+        RegisterNoiseFunctions(URIShaderBuilder);
+        RegisterFogShaders(URIShaderBuilder);
+        RegisterVertexFunctions(URIShaderBuilder);
+        RegisterFragFunctions(URIShaderBuilder);
+        this.voxelFragFunctions = [
+            "#dve_fmb2",
+            "#dve_fmb3",
+            "#dve_fog",
+            "#dve_frag",
+        ];
+        this.voxelVertexFunctions = ["#dve_fmb2", "#dve_fmb3", "#dve_vertex"];
+        const shader = URIShaderBuilder.shaders.create("default");
+        shader.addAttributes(this.voxelAttributes);
+        shader.addUniform(this.voxelSharedUniforms, "shared");
+        shader.addUniform(this.voxelVertexUniforms, "vertex");
+        shader.addVarying(this.voxelVarying);
+        shader.loadInFunctions(this.voxelFragFunctions, "frag");
+        shader.loadInFunctions(this.voxelVertexFunctions, "vertex");
+        shader.addConstants(this.voxelConstants, "vertex");
+        shader.setCodeBody("vertex", `@standard_position`);
+        shader.setCodeBody("frag", `@standard_color`);
+        this._defaultShader = shader;
+    }
+    static _addInstances(shader) {
+        shader.data.vertexBeforeMain.GLSL = /* glsl */ `
+  #ifdef INSTANCES
+  //matricies
+  in vec4 world0;
+  in vec4 world1;
+  in vec4 world2;
+  in vec4 world3;
+  //custom attributes
+  #endif
+`;
+    }
+    static createVoxelShader(id) {
+        const shader = this._defaultShader.clone(id);
+        this._addInstances(shader);
+        return shader;
+    }
+    static createBasicTextureShader(id) {
+        const shader = URIShaderBuilder.shaders.create(id);
+        this._addInstances(shader);
+        shader.addAttributes([
+            ["position", "vec3"],
+            ["normal", "vec3"],
+            ["indices", "float"],
+            ["uv", "vec3"],
+            ["textureIndex", "vec4"],
+        ]);
+        shader.loadInFunctions([
+            "#dve_fmb2",
+            "#dve_fmb3",
+            "#dve_fog",
+            "doFog",
+            "getBase",
+            "getMainColor",
+        ], "frag");
+        shader.addUniform([...this.voxelVertexUniforms], "vertex");
+        shader.addUniform([...this.voxelSharedUniforms], "shared");
+        shader.addVarying([
+            {
+                id: "vNormal",
+                type: "vec3",
+                body: {
+                    GLSL: () => "vNormal = normal;\n",
+                },
+            },
+            {
+                id: "cameraPOS",
+                type: "vec3",
+                body: {
+                    GLSL: () => "cameraPOS = cameraPosition;\n",
+                },
+            },
+            {
+                id: "worldPOS",
+                type: "vec3",
+                body: {
+                    GLSL: () => /* glsl */ `vec4 worldPOSTemp =  world * vec4(position, 1.0);
+   worldPOS = vec3(worldPOSTemp.x,worldPOSTemp.y,worldPOSTemp.z);`,
+                },
+            },
+            {
+                id: "vDistance",
+                type: "float",
+                body: {
+                    GLSL: () => " vDistance = distance(cameraPOS , worldPOS );\n",
+                },
+            },
+            {
+                id: "vBrightness",
+                type: "float",
+                body: {
+                    GLSL: () => /* glsl */ `vBrightness = 1.0;
+if (normal.y > 0.0) {
+  vBrightness += .5; 
+} else if (normal.y < 0.0) {
+  vBrightness -= .5; 
+}`,
+                },
+            },
+        ]);
+        shader.setCodeBody("vertex", `@standard_position`);
+        shader.setCodeBody("frag", 
+        /* glsl */ `
+  
+/*  
+//view normals 
+ vec3 color = (vNormal + 1.0) * 0.5;
+FragColor = vec4(color, 1.0);
+*/
+/* 
+vec4 rgb = getMainColor(-100.);
+  if (rgb.a < 0.5) { 
+    rgb.a = 1.;
+    rgb.r = 1.;
+}
+vec3 finalColor = doFog(rgb);
+FragColor = vec4(finalColor.rgb * vBrightness,rgb.a);
+*/
+
+
+vec4 rgb = getMainColor(-100.);
+if (rgb.a < 0.5) { 
+  discard;
+}
+vec3 finalColor = doFog(rgb);
+FragColor = vec4(finalColor.rgb * vBrightness,rgb.a);
+
+`);
+        return shader;
+    }
+    static createSkyBoxShader(id) {
+        const shader = URIShaderBuilder.shaders.create(id);
+        shader.addAttributes([
+            ["position", "vec3"],
+            ["indices", "float"],
+            ["normal", "vec3"],
+        ]);
+        shader.loadInFunctions(["#dve_fmb2", "#dve_fmb3", "#dve_fog", "doFog"]);
+        shader.addUniform([
+            ["doEffects", "float"],
+            ["fogOptions", "vec4"],
+            ["vFogInfos", "vec4"],
+            ["vFogColor", "vec3"],
+            ["time", "float"],
+            ["cameraPosition", "vec3"],
+            ["cameraDirection", "vec3"],
+        ], "shared");
+        shader.addVarying([
+            {
+                id: "cameraPOS",
+                type: "vec3",
+                body: {
+                    GLSL: () => "cameraPOS = cameraPosition;\n",
+                },
+            },
+            {
+                id: "worldPOS",
+                type: "vec3",
+                body: {
+                    GLSL: () => /* glsl */ `vec4 worldPOSTemp =  world * vec4(position, 1.0);
+worldPOS = vec3(worldPOSTemp.x,worldPOSTemp.y,worldPOSTemp.z);`,
+                },
+            },
+            {
+                id: "vDistance",
+                type: "float",
+                body: {
+                    GLSL: () => /* glsl */ `
+     vDistance = distance(cameraPOS , worldPOS );
+     `,
+                },
+            },
+        ]);
+        shader.addUniform([
+            ["world", "mat4"],
+            ["viewProjection", "mat4"],
+        ], "vertex");
+        shader.setCodeBody("vertex", `@standard_position`);
+        shader.setCodeBody("frag", `@skybox_frag`);
+        shader.compile();
+        return shader;
+    }
+}
+DVEShaders.init();

package/Shaders/Types/Shader.types.d.ts

@@ -0,0 +1,14 @@
+import { Vec3Array } from "@amodx/math";
+export type DVEFogTypes = "exponential" | "volumetric" | "animated-volumetric";
+export type RenderFogOptions = {
+    mode: DVEFogTypes;
+    color: Vec3Array;
+    density: number;
+    volumetricOptions: {
+        heightFactor: number;
+    };
+};
+export type DVERenderEffectsOptions = {
+    floraEffects: boolean;
+    liquidEffects: boolean;
+};

package/Shaders/Types/Shader.types.js

@@ -0,0 +1 @@
+export {};

package/Templates/Functions/CreateTemplate.d.ts

@@ -0,0 +1,3 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelTemplate } from "../VoxelTemplate";
+export default function CreateTemplate(dimension: string, start: Vec3Array, end: Vec3Array): VoxelTemplate;