@polygonjs/polygonjs/dist/src/engine/nodes/mat/RayMarchingBuilder.js

node-based WebGL 3D engine https://polygonjs.com

"use strict";
import { BaseBuilderParamConfig, TypedBuilderMatNode } from "./_BaseBuilder";
import { NodeParamsConfig, ParamConfig } from "../utils/params/ParamsConfig";
import {
  RayMarchingController,
  RayMarchingMainParamConfig,
  RayMarchingEnvMapParamConfig,
  RayMarchingDebugParamConfig
} from "./utils/RayMarchingController";
import { AssemblerName } from "../../poly/registers/assemblers/_BaseRegister";
import { Poly } from "../../Poly";
import { DefaultFolderParamConfig } from "./utils/DefaultFolder";
import { TexturesFolderParamConfig } from "./utils/TexturesFolder";
import { AdvancedFolderParamConfig } from "./utils/AdvancedFolder";
import { updateMaterialSide } from "./utils/helpers/MaterialSideHelper";
import { FogParamConfig, UniformFogController } from "./utils/UniformsFogController";
import {
  CustomMaterialRayMarchingParamConfig,
  materialRayMarchingAssemblerCustomMaterialRequested
} from "./utils/customMaterials/CustomMaterialRayMarching";
import { MatType } from "../../poly/registers/nodes/types/Mat";
export function AdvancedCommonParamConfig(Base) {
  return class Mixin extends Base {
    constructor() {
      super(...arguments);
      /** @param defines if the material is double sided or not */
      this.doubleSided = ParamConfig.BOOLEAN(0, {
        separatorBefore: true
      });
      /** @param if the material is not double sided, it can be front sided, or back sided */
      this.front = ParamConfig.BOOLEAN(0, {
        visibleIf: { doubleSided: false }
      });
    }
  };
}
class RayMarchingBuilderMatParamsConfig extends RayMarchingDebugParamConfig(
  CustomMaterialRayMarchingParamConfig(
    FogParamConfig(
      AdvancedCommonParamConfig(
        BaseBuilderParamConfig(
          AdvancedFolderParamConfig(
            RayMarchingEnvMapParamConfig(
              TexturesFolderParamConfig(
                RayMarchingMainParamConfig(DefaultFolderParamConfig(NodeParamsConfig))
              )
            )
          )
        )
      )
    )
  )
) {
}
const ParamsConfig = new RayMarchingBuilderMatParamsConfig();
export class RayMarchingBuilderMatNode extends TypedBuilderMatNode {
  constructor() {
    super(...arguments);
    this.paramsConfig = ParamsConfig;
    this._rayMarchingController = new RayMarchingController(this);
    this.controllers = {
      uniformFog: new UniformFogController(this)
    };
  }
  static type() {
    return MatType.RAY_MARCHING_BUILDER;
  }
  usedAssembler() {
    return AssemblerName.GL_RAYMARCHING;
  }
  _createAssemblerController() {
    return Poly.assemblersRegister.assembler(this, this.usedAssembler());
  }
  customMaterialRequested(customName) {
    return materialRayMarchingAssemblerCustomMaterialRequested(this, customName);
  }
  initializeNode() {
  }
  async cook() {
    this._material = this._material || this.createMaterial();
    this._rayMarchingController.updateUniformsFromParams(this._material);
    this.compileIfRequired(this._material);
    UniformFogController.update(this);
    updateMaterialSide(this._material, this.pv);
    this.setMaterial(this._material);
  }
}