@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.11

package/dist/modules/engine/picking/picking.js

@@ -0,0 +1,198 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { normalizeByteColor4, resolveUseByteColors } from "../../../lib/color/normalize-byte-colors.js";
+// cyan color
+const DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
+const vs = /* glsl */ `\
+layout(std140) uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useByteColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+out vec4 picking_vRGBcolor_Avalid;
+
+// Normalize unsigned byte color to 0-1 range
+vec3 picking_normalizeColor(vec3 color) {
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
+}
+
+// Normalize unsigned byte color to 0-1 range
+vec4 picking_normalizeColor(vec4 color) {
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
+}
+
+bool picking_isColorZero(vec3 color) {
+  return dot(color, vec3(1.0)) < 0.00001;
+}
+
+bool picking_isColorValid(vec3 color) {
+  return dot(color, vec3(1.0)) > 0.00001;
+}
+
+// Check if this vertex is highlighted 
+bool isVertexHighlighted(vec3 vertexColor) {
+  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+  return
+    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+}
+
+// Set the current picking color
+void picking_setPickingColor(vec3 pickingColor) {
+  pickingColor = picking_normalizeColor(pickingColor);
+
+  if (bool(picking.isActive)) {
+    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
+    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
+
+    if (!bool(picking.isAttribute)) {
+      // Stores the picking color so that the fragment shader can render it during picking
+      picking_vRGBcolor_Avalid.rgb = pickingColor;
+    }
+  } else {
+    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
+    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
+  }
+}
+
+void picking_setPickingAttribute(float value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.r = value;
+  }
+}
+
+void picking_setPickingAttribute(vec2 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rg = value;
+  }
+}
+
+void picking_setPickingAttribute(vec3 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rgb = value;
+  }
+}
+`;
+const fs = /* glsl */ `\
+layout(std140) uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useByteColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+in vec4 picking_vRGBcolor_Avalid;
+
+/*
+ * Returns highlight color if this item is selected.
+ */
+vec4 picking_filterHighlightColor(vec4 color) {
+  // If we are still picking, we don't highlight
+  if (picking.isActive > 0.5) {
+    return color;
+  }
+
+  bool selected = bool(picking_vRGBcolor_Avalid.a);
+
+  if (selected) {
+    // Blend in highlight color based on its alpha value
+    float highLightAlpha = picking.highlightColor.a;
+    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+    float highLightRatio = highLightAlpha / blendedAlpha;
+
+    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+    return vec4(blendedRGB, blendedAlpha);
+  } else {
+    return color;
+  }
+}
+
+/*
+ * Returns picking color if picking enabled else unmodified argument.
+ */
+vec4 picking_filterPickingColor(vec4 color) {
+  if (bool(picking.isActive)) {
+    if (picking_vRGBcolor_Avalid.a == 0.0) {
+      discard;
+    }
+    return picking_vRGBcolor_Avalid;
+  }
+  return color;
+}
+
+/*
+ * Returns picking color if picking is enabled if not
+ * highlight color if this item is selected, otherwise unmodified argument.
+ */
+vec4 picking_filterColor(vec4 color) {
+  vec4 highlightColor = picking_filterHighlightColor(color);
+  return picking_filterPickingColor(highlightColor);
+}
+`;
+/**
+ * Deprecated legacy picking module retained for compatibility with existing
+ * shaders users such as deck.gl. Keep the shader contract stable.
+ *
+ * Provides support for color-coding-based picking and highlighting.
+ * In particular, supports picking a specific instance in an instanced
+ * draw call and highlighting an instance based on its picking color,
+ * and correspondingly, supports picking and highlighting groups of
+ * primitives with the same picking color in non-instanced draw-calls
+ */
+export const picking = {
+    props: {},
+    uniforms: {},
+    name: 'picking',
+    uniformTypes: {
+        isActive: 'f32',
+        isAttribute: 'f32',
+        isHighlightActive: 'f32',
+        useByteColors: 'f32',
+        highlightedObjectColor: 'vec3<f32>',
+        highlightColor: 'vec4<f32>'
+    },
+    defaultUniforms: {
+        isActive: false,
+        isAttribute: false,
+        isHighlightActive: false,
+        useByteColors: true,
+        highlightedObjectColor: [0, 0, 0],
+        highlightColor: DEFAULT_HIGHLIGHT_COLOR
+    },
+    vs,
+    fs,
+    getUniforms
+};
+function getUniforms(opts = {}, prevUniforms) {
+    const uniforms = {};
+    const useByteColors = resolveUseByteColors(opts.useByteColors, true);
+    if (opts.highlightedObjectColor === undefined) {
+        // Unless highlightedObjectColor explicitly null or set, do not update state
+    }
+    else if (opts.highlightedObjectColor === null) {
+        uniforms.isHighlightActive = false;
+    }
+    else {
+        uniforms.isHighlightActive = true;
+        const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
+        uniforms.highlightedObjectColor = highlightedObjectColor;
+    }
+    if (opts.highlightColor) {
+        uniforms.highlightColor = normalizeByteColor4(opts.highlightColor, useByteColors);
+    }
+    if (opts.isActive !== undefined) {
+        uniforms.isActive = Boolean(opts.isActive);
+        uniforms.isAttribute = Boolean(opts.isAttribute);
+    }
+    if (opts.useByteColors !== undefined) {
+        uniforms.useByteColors = Boolean(opts.useByteColors);
+    }
+    return uniforms;
+}
+//# sourceMappingURL=picking.js.map

package/dist/modules/engine/picking/picking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"picking.js","sourceRoot":"","sources":["../../../../src/modules/engine/picking/picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,oDAAiD;AAEnG,aAAa;AACb,MAAM,uBAAuB,GAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AA2C3D,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwErB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDrB,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,KAAK,EAAE,EAAkB;IACzB,QAAQ,EAAE,EAAqB;IAE/B,IAAI,EAAE,SAAS;IAEf,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,iBAAiB,EAAE,KAAK;QACxB,aAAa,EAAE,KAAK;QACpB,sBAAsB,EAAE,WAAW;QACnC,cAAc,EAAE,WAAW;KAC5B;IACD,eAAe,EAAE;QACf,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,iBAAiB,EAAE,KAAK;QACxB,aAAa,EAAE,IAAI;QACnB,sBAAsB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACjC,cAAc,EAAE,uBAAuB;KACxC;IAED,EAAE;IACF,EAAE;IACF,WAAW;CACmD,CAAC;AAEjE,SAAS,WAAW,CAAC,OAAqB,EAAE,EAAE,YAA8B;IAC1E,MAAM,QAAQ,GAAG,EAAqB,CAAC;IACvC,MAAM,aAAa,GAAG,oBAAoB,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;IAErE,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE,CAAC;QAC9C,4EAA4E;IAC9E,CAAC;SAAM,IAAI,IAAI,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAChD,QAAQ,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACrC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAClC,MAAM,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAiB,CAAC;QACvF,QAAQ,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,QAAQ,CAAC,cAAc,GAAG,mBAAmB,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;IACpF,CAAC;IAED,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QAChC,QAAQ,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3C,QAAQ,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;QACrC,QAAQ,CAAC,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/modules/engine/project/project.cjs

@@ -0,0 +1,138 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_exports = {};
+__export(project_exports, {
+  projection: () => projection
+});
+module.exports = __toCommonJS(project_exports);
+var import_core = require("@math.gl/core");
+const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const DEFAULT_MODULE_OPTIONS = {
+  viewMatrix: IDENTITY_MATRIX,
+  projectionMatrix: IDENTITY_MATRIX,
+  viewProjectionMatrix: IDENTITY_MATRIX,
+  cameraPositionWorld: [0, 0, 0]
+};
+function getUniforms(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
+  const uniforms = {};
+  if (opts.viewMatrix !== void 0) {
+    uniforms.viewMatrix = opts.viewMatrix;
+  }
+  if (opts.projectionMatrix !== void 0) {
+    uniforms.projectionMatrix = opts.projectionMatrix;
+  }
+  if (opts.cameraPositionWorld !== void 0) {
+    uniforms.cameraPositionWorld = opts.cameraPositionWorld;
+  }
+  if (opts.projectionMatrix !== void 0) {
+    if (opts.viewMatrix !== void 0) {
+      uniforms.viewProjectionMatrix = new import_core.Matrix4(uniforms.projectionMatrix).multiplyRight(opts.viewMatrix);
+    }
+  }
+  return uniforms;
+}
+const vs = (
+  /* glsl */
+  `varying vec4 project_vPositionWorld;
+varying vec3 project_vNormalWorld;
+
+// Project uniform block
+layout(std140) uniform Project {
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+  mat4 viewProjectionMatrix;
+  vec3 cameraPositionWorld;
+} project;
+
+struct World {
+  vec3 position;
+  vec3 normal;
+};
+
+World world;
+
+void project_setPosition(vec4 position) {
+  project_vPositionWorld = position;
+}
+
+void project_setNormal(vec3 normal) {
+  project_vNormalWorld = normal;
+}
+
+void project_setPositionAndNormal_World(vec3 position, vec3 normal) {
+  world.position = position;
+  world.normal = normal;
+}
+
+void project_setPositionAndNormal_Model(vec3 position, vec3 normal, mat4 modelMatrix) {
+  world.position = (modelMatrix * vec4(position, 1.)).xyz;
+  world.normal = mat3(modelMatrix) * normal;
+}
+
+vec4 project_model_to_clipspace(vec4 position) {
+  return project.viewProjectionMatrix * position;
+}
+
+vec4 project_model_to_clipspace_Model(vec3 position, mat4 modelMatrix) {
+  return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);
+}
+
+vec4 project_world_to_clipspace(vec3 position) {
+  return project.viewProjectionMatrix * vec4(position, 1.);
+}
+
+vec4 project_view_to_clipspace(vec3 position) {
+  return project.projectionMatrix * vec4(position, 1.);
+}
+
+vec4 project_to_clipspace(vec3 position) {
+  return project.viewProjectionMatrix * vec4(position, 1.);
+}
+`
+);
+const fs = (
+  /* glsl */
+  `varying vec4 project_vPositionWorld;
+varying vec3 project_vNormalWorld;
+
+vec4 project_getPosition_World() {
+  return project_vPositionWorld;
+}
+
+vec3 project_getNormal_World() {
+  return project_vNormalWorld;
+}
+`
+);
+const projection = {
+  name: "projection",
+  // Note: order and types MUST match declarations in shader
+  uniformTypes: {
+    viewMatrix: "mat4x4<f32>",
+    projectionMatrix: "mat4x4<f32>",
+    viewProjectionMatrix: "mat4x4<f32>",
+    cameraPositionWorld: "vec3<f32>"
+  },
+  getUniforms,
+  vs,
+  fs
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  projection
+});

package/dist/modules/engine/project/project.d.ts

@@ -0,0 +1,39 @@
+import { Matrix4, Vector3 } from '@math.gl/core';
+import type { NumberArray3, NumberArray16 } from '@math.gl/core';
+/**
+ * @note Projection uniforms are normally constant across draw calls,
+ * at least for each view.
+ */
+export type ProjectionProps = {
+    viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+    projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+    cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
+};
+/**
+ * @note Projection uniforms are normally constant across draw calls,
+ * at least for each view.
+ */
+export type ProjectionUniforms = {
+    viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+    projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+    viewProjectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+    cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
+};
+declare function getUniforms(opts?: ProjectionProps, prevUniforms?: ProjectionUniforms): ProjectionUniforms;
+/**
+ * Projects coordinates
+ */
+export declare const projection: {
+    readonly name: "projection";
+    readonly uniformTypes: {
+        readonly viewMatrix: "mat4x4<f32>";
+        readonly projectionMatrix: "mat4x4<f32>";
+        readonly viewProjectionMatrix: "mat4x4<f32>";
+        readonly cameraPositionWorld: "vec3<f32>";
+    };
+    readonly getUniforms: typeof getUniforms;
+    readonly vs: "varying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\n// Project uniform block\nlayout(std140) uniform Project {\n  mat4 viewMatrix;\n  mat4 projectionMatrix;\n  mat4 viewProjectionMatrix;\n  vec3 cameraPositionWorld;\n} project;\n\nstruct World {\n  vec3 position;\n  vec3 normal;\n};\n\nWorld world;\n\nvoid project_setPosition(vec4 position) {\n  project_vPositionWorld = position;\n}\n\nvoid project_setNormal(vec3 normal) {\n  project_vNormalWorld = normal;\n}\n\nvoid project_setPositionAndNormal_World(vec3 position, vec3 normal) {\n  world.position = position;\n  world.normal = normal;\n}\n\nvoid project_setPositionAndNormal_Model(vec3 position, vec3 normal, mat4 modelMatrix) {\n  world.position = (modelMatrix * vec4(position, 1.)).xyz;\n  world.normal = mat3(modelMatrix) * normal;\n}\n\nvec4 project_model_to_clipspace(vec4 position) {\n  return project.viewProjectionMatrix * position;\n}\n\nvec4 project_model_to_clipspace_Model(vec3 position, mat4 modelMatrix) {\n  return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);\n}\n\nvec4 project_world_to_clipspace(vec3 position) {\n  return project.viewProjectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_view_to_clipspace(vec3 position) {\n  return project.projectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_to_clipspace(vec3 position) {\n  return project.viewProjectionMatrix * vec4(position, 1.);\n}\n";
+    readonly fs: "varying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\nvec4 project_getPosition_World() {\n  return project_vPositionWorld;\n}\n\nvec3 project_getNormal_World() {\n  return project_vNormalWorld;\n}\n";
+};
+export {};
+//# sourceMappingURL=project.d.ts.map

package/dist/modules/engine/project/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/project/project.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AAI/D;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IAC/C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IACrD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,YAAY,CAAC,CAAC;CACxD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IAC/C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IACrD,oBAAoB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;IACzD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,YAAY,CAAC,CAAC;CACxD,CAAC;AASF,iBAAS,WAAW,CAClB,IAAI,GAAE,eAAwC,EAC9C,YAAY,GAAE,kBAAuB,GACpC,kBAAkB,CA0BpB;AAmFD;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;CAY+C,CAAC"}

package/dist/modules/engine/project/project.js

@@ -0,0 +1,129 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { Matrix4 } from '@math.gl/core';
+const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const DEFAULT_MODULE_OPTIONS = {
+    viewMatrix: IDENTITY_MATRIX,
+    projectionMatrix: IDENTITY_MATRIX,
+    viewProjectionMatrix: IDENTITY_MATRIX,
+    cameraPositionWorld: [0, 0, 0]
+};
+function getUniforms(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
+    // const viewProjectionInverse = viewProjection.invert();
+    // viewInverseMatrix: view.invert(),
+    // viewProjectionInverseMatrix: viewProjectionInverse
+    const uniforms = {};
+    if (opts.viewMatrix !== undefined) {
+        uniforms.viewMatrix = opts.viewMatrix;
+    }
+    if (opts.projectionMatrix !== undefined) {
+        uniforms.projectionMatrix = opts.projectionMatrix;
+    }
+    if (opts.cameraPositionWorld !== undefined) {
+        uniforms.cameraPositionWorld = opts.cameraPositionWorld;
+    }
+    // COMPOSITE UNIFORMS
+    if (opts.projectionMatrix !== undefined) {
+        if (opts.viewMatrix !== undefined) {
+            uniforms.viewProjectionMatrix = new Matrix4(uniforms.projectionMatrix).multiplyRight(opts.viewMatrix);
+        }
+    }
+    return uniforms;
+}
+/**
+ * Projection uniforms are normally constant across draw calls,
+ * at least for each view.
+ * @note varyings must match vertex shader
+ * @note project module uses unprefixed uniforms to match conventions
+ */
+const vs = /* glsl */ `\
+varying vec4 project_vPositionWorld;
+varying vec3 project_vNormalWorld;
+
+// Project uniform block
+layout(std140) uniform Project {
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+  mat4 viewProjectionMatrix;
+  vec3 cameraPositionWorld;
+} project;
+
+struct World {
+  vec3 position;
+  vec3 normal;
+};
+
+World world;
+
+void project_setPosition(vec4 position) {
+  project_vPositionWorld = position;
+}
+
+void project_setNormal(vec3 normal) {
+  project_vNormalWorld = normal;
+}
+
+void project_setPositionAndNormal_World(vec3 position, vec3 normal) {
+  world.position = position;
+  world.normal = normal;
+}
+
+void project_setPositionAndNormal_Model(vec3 position, vec3 normal, mat4 modelMatrix) {
+  world.position = (modelMatrix * vec4(position, 1.)).xyz;
+  world.normal = mat3(modelMatrix) * normal;
+}
+
+vec4 project_model_to_clipspace(vec4 position) {
+  return project.viewProjectionMatrix * position;
+}
+
+vec4 project_model_to_clipspace_Model(vec3 position, mat4 modelMatrix) {
+  return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);
+}
+
+vec4 project_world_to_clipspace(vec3 position) {
+  return project.viewProjectionMatrix * vec4(position, 1.);
+}
+
+vec4 project_view_to_clipspace(vec3 position) {
+  return project.projectionMatrix * vec4(position, 1.);
+}
+
+vec4 project_to_clipspace(vec3 position) {
+  return project.viewProjectionMatrix * vec4(position, 1.);
+}
+`;
+/**
+ * Functions to get the position and normal from the vertex shader
+ * @note varyings must match vertex shader
+ */
+const fs = /* glsl */ `\
+varying vec4 project_vPositionWorld;
+varying vec3 project_vNormalWorld;
+
+vec4 project_getPosition_World() {
+  return project_vPositionWorld;
+}
+
+vec3 project_getNormal_World() {
+  return project_vNormalWorld;
+}
+`;
+/**
+ * Projects coordinates
+ */
+export const projection = {
+    name: 'projection',
+    // Note: order and types MUST match declarations in shader
+    uniformTypes: {
+        viewMatrix: 'mat4x4<f32>',
+        projectionMatrix: 'mat4x4<f32>',
+        viewProjectionMatrix: 'mat4x4<f32>',
+        cameraPositionWorld: 'vec3<f32>'
+    },
+    getUniforms,
+    vs,
+    fs
+};
+//# sourceMappingURL=project.js.map

package/dist/modules/engine/project/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../../../src/modules/engine/project/project.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,OAAO,EAAC,OAAO,EAAU,MAAM,eAAe,CAAC;AAI/C,MAAM,eAAe,GAA4B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAuBlG,MAAM,sBAAsB,GAAiC;IAC3D,UAAU,EAAE,eAAe;IAC3B,gBAAgB,EAAE,eAAe;IACjC,oBAAoB,EAAE,eAAe;IACrC,mBAAmB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAC/B,CAAC;AAEF,SAAS,WAAW,CAClB,OAAwB,sBAAsB,EAC9C,eAAmC,EAAE;IAErC,yDAAyD;IACzD,oCAAoC;IACpC,qDAAqD;IAErD,MAAM,QAAQ,GAAuB,EAAE,CAAC;IACxC,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QAClC,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;IACxC,CAAC;IACD,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACxC,QAAQ,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;IACpD,CAAC;IACD,IAAI,IAAI,CAAC,mBAAmB,KAAK,SAAS,EAAE,CAAC;QAC3C,QAAQ,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;IAC1D,CAAC;IAED,qBAAqB;IACrB,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACxC,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YAClC,QAAQ,CAAC,oBAAoB,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,aAAa,CAClF,IAAI,CAAC,UAAU,CAChB,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;GAKG;AACH,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDrB,CAAC;AAEF;;;GAGG;AACH,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;CAWrB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,0DAA0D;IAC1D,YAAY,EAAE;QACZ,UAAU,EAAE,aAAa;QACzB,gBAAgB,EAAE,aAAa;QAC/B,oBAAoB,EAAE,aAAa;QACnC,mBAAmB,EAAE,WAAW;KACjC;IACD,WAAW;IACX,EAAE;IACF,EAAE;CACkE,CAAC"}