@rtzh/engine 0.0.4 → 0.0.6

package/Source/Scene/Model/BarycentricWireframePipelineStage.js

@@ -0,0 +1,355 @@
+import Buffer from "../../Renderer/Buffer.js";
+import BufferUsage from "../../Renderer/BufferUsage.js";
+import Color from "../../Core/Color.js";
+import ComponentDatatype from "../../Core/ComponentDatatype.js";
+import defined from "../../Core/defined.js";
+import IndexDatatype from "../../Core/IndexDatatype.js";
+import ModelUtility from "./ModelUtility.js";
+import PrimitiveType from "../../Core/PrimitiveType.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import oneTimeWarning from "../../Core/oneTimeWarning.js";
+import AttributeType from "../AttributeType.js";
+import Pass from "../../Renderer/Pass.js";
+
+const BarycentricWireframePipelineStage = {
+  name: "BarycentricWireframePipelineStage",
+};
+
+BarycentricWireframePipelineStage.process = function (
+  renderResources,
+  primitive,
+  frameState,
+) {
+  const shaderBuilder = renderResources.shaderBuilder;
+  const model = renderResources.model;
+  const webgl2 = frameState.context.webgl2;
+
+  if (!webgl2) {
+    oneTimeWarning(
+      "barycentric-wireframe-webgl1",
+      "Barycentric wireframe mode requires WebGL 2. Falling back to lines mode.",
+    );
+    return;
+  }
+
+  const barycentricAttributeLocation = shaderBuilder.addAttribute(
+    "vec3",
+    "a_barycentric",
+  );
+
+  shaderBuilder.addDefine(
+    "HAS_BARYCENTRIC_WIREFRAME",
+    undefined,
+    ShaderDestination.BOTH,
+  );
+
+  if (model.debugWireframeOverlay) {
+    shaderBuilder.addDefine(
+      "WIREFRAME_OVERLAY",
+      undefined,
+      ShaderDestination.FRAGMENT,
+    );
+  }
+
+  shaderBuilder.addVarying("vec3", "v_barycentric");
+
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeWidth",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "vec4",
+    "u_wireframeColor",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeFillAlpha",
+    ShaderDestination.FRAGMENT,
+  );
+
+  const stageUniforms = renderResources.uniformMap;
+  stageUniforms.u_wireframeWidth = function () {
+    return model.debugWireframeLineWidth ?? 1.0;
+  };
+  stageUniforms.u_wireframeColor = function () {
+    return model.debugWireframeColor ?? Color.WHITE;
+  };
+  stageUniforms.u_wireframeFillAlpha = function () {
+    return defined(model._debugWireframeFillColor)
+      ? 1.0
+      : (model._debugWireframeFillAlpha ?? 1.0);
+  };
+
+  // Enable alpha blending when fillAlpha < 1.0 in preserve-original-color mode
+  if (!defined(model._debugWireframeFillColor) && (model._debugWireframeFillAlpha ?? 1.0) < 1.0) {
+    renderResources.alphaOptions.pass = Pass.TRANSLUCENT;
+  }
+
+  deindexGeometryAndAddBarycentric(
+    renderResources,
+    primitive,
+    barycentricAttributeLocation,
+    frameState,
+  );
+};
+
+function getAttributeIndex(shaderBuilder, semantic, setIndex) {
+  return shaderBuilder.attributeLocations[semantic + "_" + (setIndex ?? 0)];
+}
+
+function getComponentsFromType(type) {
+  return AttributeType.getNumberOfComponents(type);
+}
+
+function extractAttributeData(attribute) {
+  if (!defined(attribute)) {
+    return undefined;
+  }
+
+  const typedArray = attribute.typedArray;
+  if (!defined(typedArray)) {
+    return undefined;
+  }
+
+  const componentDatatype = attribute.componentDatatype;
+  const componentsPerAttribute = getComponentsFromType(attribute.type);
+  const count = attribute.count;
+  const byteOffset = attribute.byteOffset ?? 0;
+  const byteStride = attribute.byteStride;
+  const componentSize = ComponentDatatype.getSizeInBytes(componentDatatype);
+  const stride = defined(byteStride) && byteStride !== 0
+    ? byteStride
+    : componentsPerAttribute * componentSize;
+
+  const result = ComponentDatatype.createTypedArray(
+    componentDatatype,
+    count * componentsPerAttribute,
+  );
+
+  const baseOffset = byteOffset;
+  for (let i = 0; i < count; i++) {
+    const byteIndex = baseOffset + i * stride;
+    const elementIndex = byteIndex / componentSize;
+    for (let c = 0; c < componentsPerAttribute; c++) {
+      result[i * componentsPerAttribute + c] = typedArray[elementIndex + c];
+    }
+  }
+
+  return {
+    data: result,
+    count: count,
+    componentsPerAttribute: componentsPerAttribute,
+    componentDatatype: componentDatatype,
+    normalized: attribute.normalized,
+  };
+}
+
+function extractIndicesData(primitive) {
+  const indices = primitive.indices;
+  if (!defined(indices)) {
+    return undefined;
+  }
+
+  const typedArray = indices.typedArray;
+  if (defined(typedArray)) {
+    return typedArray;
+  }
+
+  return undefined;
+}
+
+function deindexAttributeData(
+  originalData,
+  originalIndices,
+  componentsPerAttribute,
+  componentDatatype,
+) {
+  const newVertexCount = originalIndices.length;
+  const totalComponents = newVertexCount * componentsPerAttribute;
+  const newData = ComponentDatatype.createTypedArray(componentDatatype, totalComponents);
+
+  for (let i = 0; i < newVertexCount; i++) {
+    const oldIndex = originalIndices[i];
+    const srcOffset = oldIndex * componentsPerAttribute;
+    const dstOffset = i * componentsPerAttribute;
+    for (let c = 0; c < componentsPerAttribute; c++) {
+      newData[dstOffset + c] = originalData[srcOffset + c];
+    }
+  }
+
+  return newData;
+}
+
+function createVertexBuffer(typedArray, frameState, model) {
+  const buffer = Buffer.createVertexBuffer({
+    context: frameState.context,
+    typedArray: typedArray,
+    usage: BufferUsage.STATIC_DRAW,
+  });
+  model._pipelineResources.push(buffer);
+  return buffer;
+}
+
+function deindexGeometryAndAddBarycentric(
+  renderResources,
+  primitive,
+  barycentricAttributeLocation,
+  frameState,
+) {
+  const model = renderResources.model;
+  const shaderBuilder = renderResources.shaderBuilder;
+  const originalIndices = extractIndicesData(primitive);
+  const positionAttr = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.POSITION,
+  );
+
+  if (!defined(positionAttr)) {
+    return;
+  }
+
+  const originalVertexCount = positionAttr.count;
+
+  if (!defined(originalIndices)) {
+    const barycentricValues = new Float32Array(originalVertexCount * 3);
+    for (let i = 0; i < originalVertexCount; i += 3) {
+      barycentricValues[i * 3] = 1.0;
+      barycentricValues[i * 3 + 1] = 0.0;
+      barycentricValues[i * 3 + 2] = 0.0;
+
+      barycentricValues[(i + 1) * 3] = 0.0;
+      barycentricValues[(i + 1) * 3 + 1] = 1.0;
+      barycentricValues[(i + 1) * 3 + 2] = 0.0;
+
+      barycentricValues[(i + 2) * 3] = 0.0;
+      barycentricValues[(i + 2) * 3 + 1] = 0.0;
+      barycentricValues[(i + 2) * 3 + 2] = 1.0;
+    }
+
+    const barycentricBuffer = createVertexBuffer(barycentricValues, frameState, model);
+
+    const barycentricAttribute = {
+      index: barycentricAttributeLocation,
+      vertexBuffer: barycentricBuffer,
+      count: originalVertexCount,
+      componentsPerAttribute: 3,
+      componentDatatype: ComponentDatatype.FLOAT,
+      offsetInBytes: 0,
+      strideInBytes: 0,
+      normalize: false,
+    };
+    renderResources.attributes.push(barycentricAttribute);
+    return;
+  }
+
+  const primitiveType = primitive.primitiveType;
+  if (!PrimitiveType.isTriangles(primitiveType)) {
+    return;
+  }
+
+  const newVertexCount = originalIndices.length;
+  const newAttributes = [];
+  const originalAttributes = primitive.attributes;
+
+  for (let i = 0; i < originalAttributes.length; i++) {
+    const attr = originalAttributes[i];
+    const semantic = attr.semantic;
+    const setIndex = attr.setIndex;
+
+    let attributeIndex;
+    if (semantic === VertexAttributeSemantic.POSITION) {
+      attributeIndex = shaderBuilder.attributeLocations.position;
+    } else if (semantic === VertexAttributeSemantic.NORMAL) {
+      attributeIndex = shaderBuilder.attributeLocations.normal;
+    } else if (semantic === VertexAttributeSemantic.TANGENT) {
+      attributeIndex = shaderBuilder.attributeLocations.tangent;
+    } else if (semantic === VertexAttributeSemantic.TEXCOORD) {
+      attributeIndex = shaderBuilder.attributeLocations["texCoord_" + setIndex];
+    } else if (semantic === VertexAttributeSemantic.COLOR) {
+      attributeIndex = shaderBuilder.attributeLocations["color_" + setIndex];
+    } else if (semantic === VertexAttributeSemantic.JOINTS) {
+      attributeIndex = shaderBuilder.attributeLocations["joints_" + setIndex];
+    } else if (semantic === VertexAttributeSemantic.WEIGHTS) {
+      attributeIndex = shaderBuilder.attributeLocations["weights_" + setIndex];
+    } else {
+      continue;
+    }
+
+    if (!defined(attributeIndex)) {
+      continue;
+    }
+
+    const extracted = extractAttributeData(attr);
+    if (!defined(extracted)) {
+      continue;
+    }
+
+    const newData = deindexAttributeData(
+      extracted.data,
+      originalIndices,
+      extracted.componentsPerAttribute,
+      extracted.componentDatatype,
+    );
+
+    const newBuffer = createVertexBuffer(newData, frameState, model);
+
+    newAttributes.push({
+      index: attributeIndex,
+      vertexBuffer: newBuffer,
+      count: newVertexCount,
+      componentsPerAttribute: extracted.componentsPerAttribute,
+      componentDatatype: extracted.componentDatatype,
+      offsetInBytes: 0,
+      strideInBytes: 0,
+      normalize: extracted.normalized,
+    });
+  }
+
+  const instanceAttributes = renderResources.attributes.filter(
+    function (attr) {
+      return attr.instanceDivisor === 1;
+    },
+  );
+  for (let i = 0; i < instanceAttributes.length; i++) {
+    newAttributes.push(instanceAttributes[i]);
+  }
+
+  const barycentricValues = new Float32Array(newVertexCount * 3);
+  for (let i = 0; i < newVertexCount; i += 3) {
+    barycentricValues[i * 3] = 1.0;
+    barycentricValues[i * 3 + 1] = 0.0;
+    barycentricValues[i * 3 + 2] = 0.0;
+
+    barycentricValues[(i + 1) * 3] = 0.0;
+    barycentricValues[(i + 1) * 3 + 1] = 1.0;
+    barycentricValues[(i + 1) * 3 + 2] = 0.0;
+
+    barycentricValues[(i + 2) * 3] = 0.0;
+    barycentricValues[(i + 2) * 3 + 1] = 0.0;
+    barycentricValues[(i + 2) * 3 + 2] = 1.0;
+  }
+
+  const barycentricBuffer = createVertexBuffer(barycentricValues, frameState, model);
+
+  newAttributes.push({
+    index: barycentricAttributeLocation,
+    vertexBuffer: barycentricBuffer,
+    count: newVertexCount,
+    componentsPerAttribute: 3,
+    componentDatatype: ComponentDatatype.FLOAT,
+    offsetInBytes: 0,
+    strideInBytes: 0,
+    normalize: false,
+  });
+
+  renderResources.attributes = newAttributes;
+  renderResources.indices = undefined;
+  renderResources.count = newVertexCount;
+  renderResources.primitiveType = PrimitiveType.TRIANGLES;
+  renderResources.wireframeIndexBuffer = undefined;
+}
+
+export default BarycentricWireframePipelineStage;