sdfsdfs

node_modules/pixi.js/lib/scene/mesh/shared/MeshPipe.js

@@ -0,0 +1,149 @@
+'use strict';
+
+var Extensions = require('../../../extensions/Extensions.js');
+var Matrix = require('../../../maths/matrix/Matrix.js');
+var BindGroup = require('../../../rendering/renderers/gpu/shader/BindGroup.js');
+var UniformGroup = require('../../../rendering/renderers/shared/shader/UniformGroup.js');
+var getAdjustedBlendModeBlend = require('../../../rendering/renderers/shared/state/getAdjustedBlendModeBlend.js');
+var PoolGroup = require('../../../utils/pool/PoolGroup.js');
+var colorToUniform = require('../../graphics/gpu/colorToUniform.js');
+var BatchableMesh = require('./BatchableMesh.js');
+
+"use strict";
+class MeshPipe {
+  constructor(renderer, adaptor) {
+    this.localUniforms = new UniformGroup.UniformGroup({
+      uTransformMatrix: { value: new Matrix.Matrix(), type: "mat3x3<f32>" },
+      uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+      uRound: { value: 0, type: "f32" }
+    });
+    this.localUniformsBindGroup = new BindGroup.BindGroup({
+      0: this.localUniforms
+    });
+    this._meshDataHash = /* @__PURE__ */ Object.create(null);
+    this._gpuBatchableMeshHash = /* @__PURE__ */ Object.create(null);
+    this._destroyRenderableBound = this.destroyRenderable.bind(this);
+    this.renderer = renderer;
+    this._adaptor = adaptor;
+    this._adaptor.init();
+  }
+  validateRenderable(mesh) {
+    const meshData = this._getMeshData(mesh);
+    const wasBatched = meshData.batched;
+    const isBatched = mesh.batched;
+    meshData.batched = isBatched;
+    if (wasBatched !== isBatched) {
+      return true;
+    } else if (isBatched) {
+      const geometry = mesh._geometry;
+      if (geometry.indices.length !== meshData.indexSize || geometry.positions.length !== meshData.vertexSize) {
+        meshData.indexSize = geometry.indices.length;
+        meshData.vertexSize = geometry.positions.length;
+        return true;
+      }
+      const batchableMesh = this._getBatchableMesh(mesh);
+      const texture = mesh.texture;
+      if (batchableMesh.texture._source !== texture._source) {
+        if (batchableMesh.texture._source !== texture._source) {
+          return !batchableMesh._batcher.checkAndUpdateTexture(batchableMesh, texture);
+        }
+      }
+    }
+    return false;
+  }
+  addRenderable(mesh, instructionSet) {
+    const batcher = this.renderer.renderPipes.batch;
+    const { batched } = this._getMeshData(mesh);
+    if (batched) {
+      const gpuBatchableMesh = this._getBatchableMesh(mesh);
+      gpuBatchableMesh.texture = mesh._texture;
+      gpuBatchableMesh.geometry = mesh._geometry;
+      batcher.addToBatch(gpuBatchableMesh, instructionSet);
+    } else {
+      batcher.break(instructionSet);
+      instructionSet.add(mesh);
+    }
+  }
+  updateRenderable(mesh) {
+    if (mesh.batched) {
+      const gpuBatchableMesh = this._gpuBatchableMeshHash[mesh.uid];
+      gpuBatchableMesh.texture = mesh._texture;
+      gpuBatchableMesh.geometry = mesh._geometry;
+      gpuBatchableMesh._batcher.updateElement(gpuBatchableMesh);
+    }
+  }
+  destroyRenderable(mesh) {
+    this._meshDataHash[mesh.uid] = null;
+    const gpuMesh = this._gpuBatchableMeshHash[mesh.uid];
+    if (gpuMesh) {
+      PoolGroup.BigPool.return(gpuMesh);
+      this._gpuBatchableMeshHash[mesh.uid] = null;
+    }
+    mesh.off("destroyed", this._destroyRenderableBound);
+  }
+  execute(mesh) {
+    if (!mesh.isRenderable)
+      return;
+    mesh.state.blendMode = getAdjustedBlendModeBlend.getAdjustedBlendModeBlend(mesh.groupBlendMode, mesh.texture._source);
+    const localUniforms = this.localUniforms;
+    localUniforms.uniforms.uTransformMatrix = mesh.groupTransform;
+    localUniforms.uniforms.uRound = this.renderer._roundPixels | mesh._roundPixels;
+    localUniforms.update();
+    colorToUniform.color32BitToUniform(
+      mesh.groupColorAlpha,
+      localUniforms.uniforms.uColor,
+      0
+    );
+    this._adaptor.execute(this, mesh);
+  }
+  _getMeshData(mesh) {
+    return this._meshDataHash[mesh.uid] || this._initMeshData(mesh);
+  }
+  _initMeshData(mesh) {
+    this._meshDataHash[mesh.uid] = {
+      batched: mesh.batched,
+      indexSize: mesh._geometry.indices?.length,
+      vertexSize: mesh._geometry.positions?.length
+    };
+    mesh.on("destroyed", this._destroyRenderableBound);
+    return this._meshDataHash[mesh.uid];
+  }
+  _getBatchableMesh(mesh) {
+    return this._gpuBatchableMeshHash[mesh.uid] || this._initBatchableMesh(mesh);
+  }
+  _initBatchableMesh(mesh) {
+    const gpuMesh = PoolGroup.BigPool.get(BatchableMesh.BatchableMesh);
+    gpuMesh.renderable = mesh;
+    gpuMesh.texture = mesh._texture;
+    gpuMesh.transform = mesh.groupTransform;
+    gpuMesh.roundPixels = this.renderer._roundPixels | mesh._roundPixels;
+    this._gpuBatchableMeshHash[mesh.uid] = gpuMesh;
+    return gpuMesh;
+  }
+  destroy() {
+    for (const i in this._gpuBatchableMeshHash) {
+      if (this._gpuBatchableMeshHash[i]) {
+        PoolGroup.BigPool.return(this._gpuBatchableMeshHash[i]);
+      }
+    }
+    this._gpuBatchableMeshHash = null;
+    this._meshDataHash = null;
+    this.localUniforms = null;
+    this.localUniformsBindGroup = null;
+    this._adaptor.destroy();
+    this._adaptor = null;
+    this.renderer = null;
+  }
+}
+/** @ignore */
+MeshPipe.extension = {
+  type: [
+    Extensions.ExtensionType.WebGLPipes,
+    Extensions.ExtensionType.WebGPUPipes,
+    Extensions.ExtensionType.CanvasPipes
+  ],
+  name: "mesh"
+};
+
+exports.MeshPipe = MeshPipe;
+//# sourceMappingURL=MeshPipe.js.map