@anov/3d-ability 0.0.4-alpha1

package/dist/environment/sun/index.js

@@ -0,0 +1,76 @@
+import { DirectionalLight, Group, Mesh, MeshBasicMaterial, SphereGeometry, Vector3 } from '@anov/3d-core';
+import { getPosition } from 'suncalc';
+
+/**
+ * 获取当前笛卡尔坐标
+ * @param date
+ * @param latitude
+ * @param longitude
+ */
+var getThreePosition = function getThreePosition(date, latitude, longitude, distance) {
+  var _getPosition = getPosition(date, latitude, longitude),
+    altitude = _getPosition.altitude,
+    azimuth = _getPosition.azimuth;
+  var x = distance * Math.cos(altitude) * Math.cos(azimuth);
+  var z = distance * Math.cos(altitude) * Math.sin(azimuth);
+  var y = distance * Math.sin(altitude);
+  return new Vector3(x, y, z);
+};
+export var getSunPosition = function getSunPosition(date, latitude, longitude) {
+  var _getPosition2 = getPosition(date, latitude, longitude),
+    altitude = _getPosition2.altitude,
+    azimuth = _getPosition2.azimuth;
+  return {
+    altitude: altitude,
+    azimuth: azimuth
+  };
+};
+
+/**
+ * entity
+ * @returns
+ */
+var createSunEntity = function createSunEntity() {
+  var box = new SphereGeometry(1);
+  var mater = new MeshBasicMaterial({
+    color: 'yellow'
+  });
+  var mesh = new Mesh(box, mater);
+  return mesh;
+};
+
+/**
+ * sun light
+ * @returns
+ */
+var createSunLight = function createSunLight() {
+  var sunLight = new DirectionalLight('white', 8);
+  sunLight.castShadow = true;
+  sunLight.shadow.bias = -0.005;
+  sunLight.shadow.mapSize.set(1024, 1024);
+  return sunLight;
+};
+
+/**
+ * create init
+ * @param date
+ * @param latitude
+ * @param longitude
+ * @param distance
+ */
+export var createSun = function createSun(date, latitude, longitude) {
+  var distance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1000;
+  var autoUpdate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var position = getThreePosition(date, latitude, longitude, distance);
+  var group = new Group();
+  group.add(createSunEntity(), createSunLight());
+  group.position.set(position.x, position.y, position.z);
+  group.lookAt(0, 0, 0);
+  var updateSunPosition = function updateSunPosition(date, latitude, longitude) {
+    var currentPosition = getThreePosition(date, latitude, longitude, distance);
+    group.position.set(currentPosition.x, currentPosition.y, currentPosition.z);
+  };
+  return [group, updateSunPosition, function (currentDate) {
+    return getSunPosition(currentDate || date, latitude, longitude);
+  }];
+};

package/dist/environment/utils/points.d.ts

@@ -0,0 +1,26 @@
+import { BufferGeometry, Points, PointsMaterial, Vector3 } from '@anov/3d-core';
+import type { SpeedType } from '../rain';
+interface EnvPointsOptions {
+    range?: number;
+    count?: number;
+    opacity?: number;
+    url: string;
+    size?: number;
+    speed?: SpeedType;
+}
+export declare type AVector3 = Vector3 & {
+    speedX: number;
+    speedY: number;
+    speedZ: number;
+};
+declare class EnvironmentPoints {
+    private opts;
+    points: AVector3[];
+    material: PointsMaterial | null;
+    geometry: BufferGeometry | null;
+    point: Points | null;
+    constructor(opts: EnvPointsOptions);
+    private createEnvPoints;
+    animation(handlefn: (position: AVector3) => void): void;
+}
+export default EnvironmentPoints;

package/dist/environment/utils/points.js

@@ -0,0 +1,55 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { BufferGeometry, Points, PointsMaterial, TextureLoader, Vector3 } from '@anov/3d-core';
+var EnvironmentPoints = /*#__PURE__*/function () {
+  function EnvironmentPoints(opts) {
+    _classCallCheck(this, EnvironmentPoints);
+    _defineProperty(this, "opts", {});
+    _defineProperty(this, "points", []);
+    _defineProperty(this, "material", null);
+    _defineProperty(this, "geometry", null);
+    _defineProperty(this, "point", null);
+    this.opts = opts;
+    this.createEnvPoints();
+  }
+  _createClass(EnvironmentPoints, [{
+    key: "createEnvPoints",
+    value: function createEnvPoints() {
+      var _this$opts$range;
+      this.material = new PointsMaterial({
+        size: this.opts.size || 1,
+        map: new TextureLoader().load(this.opts.url),
+        transparent: true,
+        opacity: this.opts.opacity,
+        depthTest: false
+      });
+      this.geometry = new BufferGeometry();
+      var range = (_this$opts$range = this.opts.range) !== null && _this$opts$range !== void 0 ? _this$opts$range : 1000;
+      for (var i = 0; i < (this.opts.count || 500); i++) {
+        var _this$opts$speed, _this$opts$speed2, _this$opts$speed3;
+        var _position = new Vector3(Math.random() * range - range / 2, Math.random() * range, Math.random() * range - range / 2);
+        _position.speedX = ((_this$opts$speed = this.opts.speed) === null || _this$opts$speed === void 0 ? void 0 : _this$opts$speed.x) || 0;
+        _position.speedY = ((_this$opts$speed2 = this.opts.speed) === null || _this$opts$speed2 === void 0 ? void 0 : _this$opts$speed2.x) || 10;
+        _position.speedZ = ((_this$opts$speed3 = this.opts.speed) === null || _this$opts$speed3 === void 0 ? void 0 : _this$opts$speed3.x) || 0;
+        this.points.push(_position);
+      }
+      this.geometry.setFromPoints(this.points);
+      this.point = new Points(this.geometry, this.material);
+    }
+  }, {
+    key: "animation",
+    value: function animation(handlefn) {
+      this.points.forEach(function (position) {
+        handlefn(position);
+      });
+      this.point.geometry.setFromPoints(this.points);
+    }
+  }]);
+  return EnvironmentPoints;
+}();
+export default EnvironmentPoints;

package/dist/environment/volumetricCloud/cloudMaterial.d.ts

@@ -0,0 +1,3 @@
+import { RawShaderMaterial } from '@anov/3d-core';
+declare const cloudMaterial: RawShaderMaterial;
+export default cloudMaterial;

package/dist/environment/volumetricCloud/cloudMaterial.js

@@ -0,0 +1,60 @@
+import { BackSide, Color, Data3DTexture, GLSL3, LinearFilter, RawShaderMaterial, RedFormat, Vector3, lib } from '@anov/3d-core';
+var size = 128;
+var data = new Uint8Array(size * size * size);
+var i = 0;
+var scale = 0.05;
+var perlin = new lib.ImprovedNoise();
+var vector = new Vector3();
+for (var z = 0; z < size; z++) {
+  for (var y = 0; y < size; y++) {
+    for (var x = 0; x < size; x++) {
+      var d = 1.0 - vector.set(x, y, z).subScalar(size / 2).divideScalar(size).length();
+      data[i] = (128 + 128 * perlin.noise(x * scale / 1.5, y * scale, z * scale / 1.5)) * d * d;
+      i++;
+    }
+  }
+}
+var texture = new Data3DTexture(data, size, size, size);
+texture.format = RedFormat;
+texture.minFilter = LinearFilter;
+texture.magFilter = LinearFilter;
+texture.unpackAlignment = 1;
+texture.needsUpdate = true;
+
+// Material
+var vertexShader = /* glsl */"\nin vec3 position;\n\nuniform mat4 modelMatrix;\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform vec3 cameraPos;\nout vec3 vOrigin;\nout vec3 vDirection;\nvoid main() {\n    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);\n    vOrigin = vec3(inverse(modelMatrix) * vec4(cameraPos, 1.0)).xyz;\n    vDirection = position - vOrigin;\n    gl_Position = projectionMatrix * mvPosition;\n}\n";
+var fragmentShader = /* glsl */"\n\n\nprecision highp float;\nprecision highp sampler3D;\n\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\n\nin vec3 vOrigin;\nin vec3 vDirection;\n\nout vec4 color;\n\nuniform vec3 base;\nuniform sampler3D map;\n\nuniform float threshold;\nuniform float range;\nuniform float opacity;\nuniform float steps;\nuniform float frame;\n\nuint wang_hash(uint seed) {\n    seed = (seed ^ 61u) ^ (seed >> 16u);\n    seed *= 9u;\n    seed = seed ^ (seed >> 4u);\n    seed *= 0x27d4eb2du;\n    seed = seed ^ (seed >> 15u);\n    return seed;\n}\n\nfloat randomFloat(inout uint seed) {\n    return float(wang_hash(seed)) / 4294967296.;\n}\n\nvec2 hitBox(vec3 orig, vec3 dir) {\n    const vec3 box_min = vec3(-0.5);\n    const vec3 box_max = vec3(0.5);\n    vec3 inv_dir = 1.0 / dir;\n    vec3 tmin_tmp = (box_min - orig) * inv_dir;\n    vec3 tmax_tmp = (box_max - orig) * inv_dir;\n    vec3 tmin = min(tmin_tmp, tmax_tmp);\n    vec3 tmax = max(tmin_tmp, tmax_tmp);\n    float t0 = max(tmin.x, max(tmin.y, tmin.z));\n    float t1 = min(tmax.x, min(tmax.y, tmax.z));\n    return vec2(t0, t1);\n}\n\nfloat sample1(vec3 p) {\n    return texture(map, p).r;\n}\n\nfloat shading(vec3 coord) {\n    float step = 0.01;\n    return sample1(coord + vec3(-step)) - sample1(coord + vec3(step));\n}\n\nvec4 linearToSRGB(in vec4 value) {\n    return vec4(mix(pow(value.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), value.rgb * 12.92, vec3(lessThanEqual(value.rgb, vec3(0.0031308)))), value.a);\n}\n\nvoid main() {\n    vec3 rayDir = normalize(vDirection);\n    vec2 bounds = hitBox(vOrigin, rayDir);\n\n    if(bounds.x > bounds.y)\n        discard;\n\n    bounds.x = max(bounds.x, 0.0);\n\n    vec3 p = vOrigin + bounds.x * rayDir;\n    vec3 inc = 1.0 / abs(rayDir);\n    float delta = min(inc.x, min(inc.y, inc.z));\n    delta /= steps;\n\n// Jitter\n// Nice little seed from\n// https://blog.demofox.org/2020/05/25/casual-shadertoy-path-tracing-1-basic-camera-diffuse-emissive/\n    uint seed = uint(gl_FragCoord.x) * uint(1973) + uint(gl_FragCoord.y) * uint(9277) + uint(frame) * uint(26699);\n    vec3 size = vec3(textureSize(map, 0));\n    float randNum = randomFloat(seed) * 2.0 - 1.0;\n    p += rayDir * randNum * (1.0 / size);\n\n    vec4 ac = vec4(base, 0.0);\n\n    for(float t = bounds.x; t < bounds.y; t += delta) {\n\n        float d = sample1(p + 0.5);\n\n        d = smoothstep(threshold - range, threshold + range, d) * opacity;\n\n        float col = shading(p + 0.5) * 3.0 + ((p.x + p.y) * 0.25) + 0.2;\n\n        ac.rgb += (1.0 - ac.a) * d * col;\n\n        ac.a += (1.0 - ac.a) * d;\n\n        if(ac.a >= 0.95)\n            break;\n\n        p += rayDir * delta;\n\n    }\n\n    color = linearToSRGB(ac);\n\n    if(color.a == 0.0)\n        discard;\n\n}\n\n";
+var cloudMaterial = new RawShaderMaterial({
+  glslVersion: GLSL3,
+  uniforms: {
+    base: {
+      value: new Color(0x798AA0)
+    },
+    map: {
+      value: texture
+    },
+    cameraPos: {
+      value: new Vector3()
+    },
+    threshold: {
+      value: 0.25
+    },
+    opacity: {
+      value: 0.25
+    },
+    range: {
+      value: 0.1
+    },
+    steps: {
+      value: 100
+    },
+    frame: {
+      value: 0
+    }
+  },
+  vertexShader: vertexShader,
+  fragmentShader: fragmentShader,
+  side: BackSide,
+  transparent: true
+});
+export default cloudMaterial;

package/dist/environment/volumetricCloud/inex.d.ts

@@ -0,0 +1,8 @@
+import { Mesh } from '@anov/3d-core';
+export declare class VolumetricCloud {
+    private geometries;
+    cloudGroup: Mesh;
+    constructor();
+}
+declare const createVolumetricCloud: () => Mesh;
+export default createVolumetricCloud;

package/dist/environment/volumetricCloud/inex.js

@@ -0,0 +1,42 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { BoxGeometry, Mesh, use } from '@anov/3d-core';
+import cloudMaterial from "./cloudMaterial";
+export var VolumetricCloud = /*#__PURE__*/_createClass(function VolumetricCloud() {
+  _classCallCheck(this, VolumetricCloud);
+  _defineProperty(this, "geometries", []);
+  _defineProperty(this, "cloudGroup", void 0);
+  // cloud density
+  // for (let i = 0; i < 100; i++) {
+  //   const cloud = new BoxGeometry(100, 100, 100)
+
+  //   cloud.translate(Math.random() * 1000 - 500, -Math.random() * Math.random() * 200 - 15, i)
+  //   // cloud.rotateZ(Math.random() * Math.PI / 2)
+  //   cloud.scale(Math.random() * Math.random() * 1.1 + 0.5, Math.random() * Math.random() * 1.1 + 0.5, 1)
+  //   this.geometries.push(cloud)
+  // }
+
+  var box = new BoxGeometry(100, 100, 100);
+  // const mergedGeometry = BufferGeometryUtils.mergeGeometries(this.geometries, false)
+  this.cloudGroup = new Mesh(box, cloudMaterial);
+  var _use$useScene = use.useScene(),
+    camera = _use$useScene.camera;
+  use.useframe(function () {
+    // @ts-ignore
+    // this.cloudGroup.material.uniforms.cameraPos.value.copy(camera!.position)
+  });
+});
+var createVolumetricCloud = function createVolumetricCloud() {
+  var _use$useScene2 = use.useScene(),
+    scene = _use$useScene2.scene;
+  var cloudGroup = new VolumetricCloud().cloudGroup;
+  if (!scene) throw new Error('scene is not defined');
+  scene.add(cloudGroup);
+  return cloudGroup;
+};
+export default createVolumetricCloud;

package/dist/helper/view/index.d.ts

@@ -0,0 +1,40 @@
+import type { LineSegments, OrbitControls, PerspectiveCamera, Sprite, WebGLRenderer, lib } from '@anov/3d-core';
+import { Mesh, Object3D, OrthographicCamera, Vector3, Vector4 } from '@anov/3d-core';
+declare type GizmoOrientation = '+x' | '-x' | '+y' | '-y' | '+z' | '-z';
+export declare type DomPlacement = 'top-left' | 'top-right' | 'top-center' | 'center-right' | 'center-left' | 'center-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
+declare class ViewHelper extends Object3D {
+    camera: OrthographicCamera | PerspectiveCamera;
+    orthoCamera: OrthographicCamera;
+    isViewHelper: boolean;
+    animating: boolean;
+    target: Vector3;
+    backgroundSphere: Mesh;
+    axesLines: LineSegments;
+    spritePoints: Sprite[];
+    domElement: HTMLElement;
+    domContainer: HTMLElement;
+    domRect: DOMRect;
+    dragging: boolean;
+    renderer: WebGLRenderer;
+    controls?: OrbitControls | lib.TrackballControls;
+    controlsChangeEvent: {
+        listener: () => void;
+    };
+    viewport: Vector4;
+    offsetHeight: number;
+    constructor(camera: PerspectiveCamera | OrthographicCamera, renderer: WebGLRenderer, placement?: DomPlacement, size?: number);
+    startListening(): void;
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerLeave(): void;
+    handleClick(e: PointerEvent): void;
+    handleHover(e: PointerEvent): void;
+    setControls(controls?: OrbitControls | lib.TrackballControls): void;
+    render(): void;
+    updateOrientation(fromCamera?: boolean): void;
+    update(): void;
+    animate(delta: number): void;
+    setOrientation(orientation: GizmoOrientation): void;
+    dispose(): void;
+}
+export default ViewHelper;