x_ite
Version:
X_ITE X3D Browser, view and manipulate X3D, VRML, glTF and other 3D sources in HTML.
1,184 lines (954 loc) • 126 kB
JavaScript
/* X_ITE v11.6.6 */
const __X_ITE_X3D__ = window [Symbol .for ("X_ITE.X3D-11.6.6")];
/******/ (() => { // webpackBootstrap
/******/ "use strict";
/******/ // The require scope
/******/ var __webpack_require__ = {};
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/************************************************************************/
// UNUSED EXPORTS: default
;// external "__X_ITE_X3D__ .Components"
const external_X_ITE_X3D_Components_namespaceObject = __X_ITE_X3D__ .Components;
var external_X_ITE_X3D_Components_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_Components_namespaceObject);
;// external "__X_ITE_X3D__ .PixelTexture"
const external_X_ITE_X3D_PixelTexture_namespaceObject = __X_ITE_X3D__ .PixelTexture;
var external_X_ITE_X3D_PixelTexture_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_PixelTexture_namespaceObject);
;// external "__X_ITE_X3D__ .TextureProperties"
const external_X_ITE_X3D_TextureProperties_namespaceObject = __X_ITE_X3D__ .TextureProperties;
var external_X_ITE_X3D_TextureProperties_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_TextureProperties_namespaceObject);
;// external "__X_ITE_X3D__ .Fields"
const external_X_ITE_X3D_Fields_namespaceObject = __X_ITE_X3D__ .Fields;
var external_X_ITE_X3D_Fields_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_Fields_namespaceObject);
;// external "__X_ITE_X3D__ .X3DFieldDefinition"
const external_X_ITE_X3D_X3DFieldDefinition_namespaceObject = __X_ITE_X3D__ .X3DFieldDefinition;
var external_X_ITE_X3D_X3DFieldDefinition_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_X3DFieldDefinition_namespaceObject);
;// external "__X_ITE_X3D__ .FieldDefinitionArray"
const external_X_ITE_X3D_FieldDefinitionArray_namespaceObject = __X_ITE_X3D__ .FieldDefinitionArray;
var external_X_ITE_X3D_FieldDefinitionArray_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_FieldDefinitionArray_namespaceObject);
;// external "__X_ITE_X3D__ .X3DNode"
const external_X_ITE_X3D_X3DNode_namespaceObject = __X_ITE_X3D__ .X3DNode;
var external_X_ITE_X3D_X3DNode_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_X3DNode_namespaceObject);
;// external "__X_ITE_X3D__ .X3DConstants"
const external_X_ITE_X3D_X3DConstants_namespaceObject = __X_ITE_X3D__ .X3DConstants;
var external_X_ITE_X3D_X3DConstants_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_X3DConstants_namespaceObject);
;// external "__X_ITE_X3D__ .Namespace"
const external_X_ITE_X3D_Namespace_namespaceObject = __X_ITE_X3D__ .Namespace;
var external_X_ITE_X3D_Namespace_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_Namespace_namespaceObject);
;// ./src/x_ite/Components/VolumeRendering/X3DVolumeRenderStyleNode.js
function X3DVolumeRenderStyleNode (executionContext)
{
external_X_ITE_X3D_X3DNode_default().call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).X3DVolumeRenderStyleNode);
this .volumeDataNodes = new Set ();
}
Object .assign (Object .setPrototypeOf (X3DVolumeRenderStyleNode .prototype, (external_X_ITE_X3D_X3DNode_default()).prototype),
{
addShaderFields (shaderNode)
{ },
getDefines ()
{ },
getUniformsText ()
{
return "";
},
getFunctionsText ()
{
return "";
},
getVolumeData ()
{
return this .volumeDataNodes;
},
addVolumeData (volumeDataNode)
{
this .volumeDataNodes .add (volumeDataNode);
},
removeVolumeData (volumeDataNode)
{
this .volumeDataNodes .delete (volumeDataNode);
},
getNormalText (surfaceNormalsNode)
{
let string = "";
if (surfaceNormalsNode)
{
string += "uniform sampler3D surfaceNormals_" + this .getId () + ";\n";
string += "\n";
string += "vec4\n";
string += "getNormal_" + this .getId () + " (in vec3 texCoord)\n";
string += "{\n";
string += " vec3 n = texture (surfaceNormals_" + this .getId () + ", texCoord) .xyz * 2.0 - 1.0;\n";
string += "\n";
string += " return vec4 (normalize (x3d_TextureNormalMatrix * n), length (n));\n";
string += "}\n";
}
else
{
string += "\n";
string += "vec4\n";
string += "getNormal_" + this .getId () + " (in vec3 texCoord)\n";
string += "{\n";
string += " vec4 offset = vec4 (1.0 / vec3 (textureSize (x3d_Texture3D [0], 0)), 0.0);\n";
string += " float i0 = texture (x3d_Texture3D [0], texCoord + offset .xww) .r;\n";
string += " float i1 = texture (x3d_Texture3D [0], texCoord - offset .xww) .r;\n";
string += " float i2 = texture (x3d_Texture3D [0], texCoord + offset .wyw) .r;\n";
string += " float i3 = texture (x3d_Texture3D [0], texCoord - offset .wyw) .r;\n";
string += " float i4 = texture (x3d_Texture3D [0], texCoord + offset .wwz) .r;\n";
string += " float i5 = texture (x3d_Texture3D [0], texCoord - offset .wwz) .r;\n";
string += " vec3 n = vec3 (i1 - i0, i3 - i2, i5 - i4);\n";
string += "\n";
string += " return vec4 (normalize (x3d_TextureNormalMatrix * n), length (n));\n";
string += "}\n";
}
return string;
},
});
Object .defineProperties (X3DVolumeRenderStyleNode, external_X_ITE_X3D_X3DNode_default().getStaticProperties ("X3DVolumeRenderStyleNode", "VolumeRendering", 1));
const __default__ = X3DVolumeRenderStyleNode;
;
/* harmony default export */ const VolumeRendering_X3DVolumeRenderStyleNode = (external_X_ITE_X3D_Namespace_default().add ("X3DVolumeRenderStyleNode", __default__));
;// ./src/x_ite/Components/VolumeRendering/X3DComposableVolumeRenderStyleNode.js
function X3DComposableVolumeRenderStyleNode (executionContext)
{
VolumeRendering_X3DVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).X3DComposableVolumeRenderStyleNode);
}
Object .setPrototypeOf (X3DComposableVolumeRenderStyleNode .prototype, VolumeRendering_X3DVolumeRenderStyleNode .prototype);
Object .defineProperties (X3DComposableVolumeRenderStyleNode, external_X_ITE_X3D_X3DNode_default().getStaticProperties ("X3DComposableVolumeRenderStyleNode", "VolumeRendering", 1));
const X3DComposableVolumeRenderStyleNode_default_ = X3DComposableVolumeRenderStyleNode;
;
/* harmony default export */ const VolumeRendering_X3DComposableVolumeRenderStyleNode = (external_X_ITE_X3D_Namespace_default().add ("X3DComposableVolumeRenderStyleNode", X3DComposableVolumeRenderStyleNode_default_));
;// external "__X_ITE_X3D__ .X3DCast"
const external_X_ITE_X3D_X3DCast_namespaceObject = __X_ITE_X3D__ .X3DCast;
var external_X_ITE_X3D_X3DCast_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_X3DCast_namespaceObject);
;// ./src/x_ite/Components/VolumeRendering/OpacityMapVolumeStyle.js
function OpacityMapVolumeStyle (executionContext)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).OpacityMapVolumeStyle);
}
Object .assign (Object .setPrototypeOf (OpacityMapVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
{
initialize ()
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
this ._transferFunction .addInterest ("set_transferFunction__", this);
this .set_transferFunction__ ();
},
set_transferFunction__ ()
{
this .transferFunctionNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture2DNode, this ._transferFunction);
if (! this .transferFunctionNode)
this .transferFunctionNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture3DNode, this ._transferFunction);
if (! this .transferFunctionNode)
this .transferFunctionNode = this .getBrowser () .getDefaultTransferFunction ();
},
addShaderFields (shaderNode)
{
if (! this ._enabled .getValue ())
return;
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "transferFunction_" + this .getId (), new (external_X_ITE_X3D_Fields_default()).SFNode (this .transferFunctionNode));
},
getUniformsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += "// OpacityMapVolumeStyle\n";
string += "\n";
if (this .transferFunctionNode .getType () .includes ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture2DNode))
{
string += "uniform sampler2D transferFunction_" + this .getId () + ";\n";
string += "\n";
string += "vec4\n";
string += "getOpacityMapStyle_" + this .getId () + " (in vec4 originalColor)\n";
string += "{\n";
string += " return texture (transferFunction_" + this .getId () + ", originalColor .rg);\n";
string += "}\n";
}
else
{
string += "uniform sampler3D transferFunction_" + this .getId () + ";\n";
string += "\n";
string += "vec4\n";
string += "getOpacityMapStyle_" + this .getId () + " (in vec4 originalColor)\n";
string += "{\n";
string += " return texture (transferFunction_" + this .getId () + ", originalColor .rgb);\n";
string += "}\n";
}
return string;
},
getFunctionsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += " // OpacityMapVolumeStyle\n";
string += "\n";
string += " textureColor = getOpacityMapStyle_" + this .getId () + " (textureColor);\n";
return string;
},
});
Object .defineProperties (OpacityMapVolumeStyle,
{
... external_X_ITE_X3D_X3DNode_default().getStaticProperties ("OpacityMapVolumeStyle", "VolumeRendering", 1, "renderStyle", "3.3"),
fieldDefinitions:
{
value: new (external_X_ITE_X3D_FieldDefinitionArray_default()) ([
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "enabled", new (external_X_ITE_X3D_Fields_default()).SFBool (true)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "metadata", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "transferFunction", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
]),
enumerable: true,
},
});
const OpacityMapVolumeStyle_default_ = OpacityMapVolumeStyle;
;
/* harmony default export */ const VolumeRendering_OpacityMapVolumeStyle = (external_X_ITE_X3D_Namespace_default().add ("OpacityMapVolumeStyle", OpacityMapVolumeStyle_default_));
;// ./src/x_ite/Browser/VolumeRendering/X3DVolumeRenderingContext.js
const
_defaultVoxelsNode = Symbol (),
_defaultVolumeStyle = Symbol (),
_defaultBlendedVolumeStyle = Symbol (),
_defaultTransferFunction = Symbol ();
function X3DVolumeRenderingContext () { }
Object .assign (X3DVolumeRenderingContext .prototype,
{
getDefaultVoxels ()
{
return this [_defaultVoxelsNode] ??= (() =>
{
const defaultVoxelsNode = this .getPrivateScene () .createNode ("PixelTexture3D", false);
defaultVoxelsNode ._image = [1, 1, 1, 1, 255];
defaultVoxelsNode .repeatS = true;
defaultVoxelsNode .repeatT = true;
defaultVoxelsNode .repeatR = true;
defaultVoxelsNode .setup ();
return defaultVoxelsNode;
})();
},
getDefaultVolumeStyle ()
{
return this [_defaultVolumeStyle] ??= (() =>
{
const defaultVolumeStyle = new VolumeRendering_OpacityMapVolumeStyle (this .getPrivateScene ());
defaultVolumeStyle .setup ();
return defaultVolumeStyle;
})();
},
getDefaultBlendedVolumeStyle ()
{
return this [_defaultBlendedVolumeStyle] ??= (() =>
{
const defaultBlendedVolumeStyle = new VolumeRendering_OpacityMapVolumeStyle (this .getPrivateScene ());
defaultBlendedVolumeStyle .setup ();
return defaultBlendedVolumeStyle;
})();
},
getDefaultTransferFunction ()
{
return this [_defaultTransferFunction] ??= (() =>
{
const textureProperties = new (external_X_ITE_X3D_TextureProperties_default()) (this .getPrivateScene ());
textureProperties ._boundaryModeS = "CLAMP_TO_EDGE";
textureProperties ._boundaryModeT = "REPEAT";
textureProperties ._magnificationFilter = "DEFAULT";
textureProperties ._minificationFilter = "DEFAULT";
textureProperties ._generateMipMaps = true;
textureProperties ._textureCompression = "DEFAULT";
textureProperties .setup ();
const defaultTransferFunction = new (external_X_ITE_X3D_PixelTexture_default()) (this .getPrivateScene ());
defaultTransferFunction ._textureProperties = textureProperties;
defaultTransferFunction ._image .width = 256;
defaultTransferFunction ._image .height = 1;
defaultTransferFunction ._image .comp = 2;
defaultTransferFunction ._image .array = Array .from ({ length: 256 }, (v, i) => (i << 8) | i);
defaultTransferFunction .setup ();
return defaultTransferFunction;
})();
},
});
const X3DVolumeRenderingContext_default_ = X3DVolumeRenderingContext;
;
/* harmony default export */ const VolumeRendering_X3DVolumeRenderingContext = (external_X_ITE_X3D_Namespace_default().add ("X3DVolumeRenderingContext", X3DVolumeRenderingContext_default_));
;// ./src/x_ite/Components/VolumeRendering/BlendedVolumeStyle.js
function BlendedVolumeStyle (executionContext)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).BlendedVolumeStyle);
}
Object .assign (Object .setPrototypeOf (BlendedVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
{
initialize ()
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
this ._weightTransferFunction1 .addInterest ("set_weightTransferFunction1__", this);
this ._weightTransferFunction2 .addInterest ("set_weightTransferFunction2__", this);
this ._renderStyle .addInterest ("set_renderStyle__", this);
this ._voxels .addInterest ("set_voxels__", this);
this .set_weightTransferFunction1__ ();
this .set_weightTransferFunction2__ ();
this .set_renderStyle__ ();
this .set_voxels__ ();
},
addVolumeData (volumeDataNode)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .addVolumeData .call (this, volumeDataNode);
if (this .renderStyleNode)
this .renderStyleNode .addVolumeData (volumeDataNode);
},
removeVolumeData (volumeDataNode)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .removeVolumeData .call (this, volumeDataNode);
if (this .renderStyleNode)
this .renderStyleNode .removeVolumeData (volumeDataNode);
},
set_weightTransferFunction1__ ()
{
this .weightTransferFunction1Node = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture2DNode, this ._weightTransferFunction1);
},
set_weightTransferFunction2__ ()
{
this .weightTransferFunction2Node = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture2DNode, this ._weightTransferFunction2);
},
set_renderStyle__ ()
{
if (this .renderStyleNode)
{
this .renderStyleNode .removeInterest ("addNodeEvent", this);
for (const volumeDataNode of this .getVolumeData ())
this .renderStyleNode .removeVolumeData (volumeDataNode);
}
this .renderStyleNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DComposableVolumeRenderStyleNode, this ._renderStyle);
if (this .renderStyleNode)
{
this .renderStyleNode .addInterest ("addNodeEvent", this);
for (const volumeDataNode of this .getVolumeData ())
this .renderStyleNode .addVolumeData (volumeDataNode);
}
},
set_voxels__ ()
{
this .voxelsNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture3DNode, this ._voxels);
},
addShaderFields (shaderNode)
{
if (! this ._enabled .getValue ())
return;
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightConstant1_" + this .getId (), this ._weightConstant1 .copy ());
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightConstant2_" + this .getId (), this ._weightConstant2 .copy ());
if (this .weightTransferFunction1Node)
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightTransferFunction1_" + this .getId (), new (external_X_ITE_X3D_Fields_default()).SFNode (this .weightTransferFunction1Node));
if (this .weightTransferFunction2Node)
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightTransferFunction2_" + this .getId (), new (external_X_ITE_X3D_Fields_default()).SFNode (this .weightTransferFunction2Node));
if (this .voxelsNode)
{
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "voxels_" + this .getId (), new (external_X_ITE_X3D_Fields_default()).SFNode (this .voxelsNode));
}
this .getBrowser () .getDefaultBlendedVolumeStyle () .addShaderFields (shaderNode);
if (this .renderStyleNode)
this .renderStyleNode .addShaderFields (shaderNode);
},
getUniformsText ()
{
if (! this ._enabled .getValue ())
return "";
if (! this .voxelsNode)
return "";
let string = "";
string += "\n";
string += "// BlendedVolumeStyle\n";
string += "\n";
string += "uniform float weightConstant1_" + this .getId () + ";\n";
string += "uniform float weightConstant2_" + this .getId () + ";\n";
if (this .weightTransferFunction1Node)
string += "uniform sampler2D weightTransferFunction1_" + this .getId () + ";\n";
if (this .weightTransferFunction2Node)
string += "uniform sampler2D weightTransferFunction2_" + this .getId () + ";\n";
string += "uniform sampler3D voxels_" + this .getId () + ";\n";
let uniformsText = this .getBrowser () .getDefaultBlendedVolumeStyle () .getUniformsText ();
if (this .renderStyleNode)
uniformsText += this .renderStyleNode .getUniformsText ();
uniformsText = uniformsText .replace (/x3d_Texture3D\s*\[0\]/g, "voxels_" + this .getId ());
string += "\n";
string += uniformsText;
string += "\n";
string += "vec4\n";
string += "getBlendedStyle_" + this .getId () + " (in vec4 originalColor, in vec3 texCoord)\n";
string += "{\n";
string += " vec4 blendColor_" + this .getId () + " = texture (voxels_" + this .getId () + ", texCoord);";
let functionsText = this .getBrowser () .getDefaultBlendedVolumeStyle () .getFunctionsText ();
if (this .renderStyleNode)
functionsText += this .renderStyleNode .getFunctionsText ();
functionsText = functionsText .replace (/textureColor/g, "blendColor_" + this .getId ());
string += "\n";
string += functionsText;
switch (this ._weightFunction1 .getValue ())
{
default: // CONSTANT
{
string += " float w1_" + this .getId () + " = weightConstant1_" + this .getId () + ";\n";
break;
}
case "ALPHA0":
{
string += " float w1_" + this .getId () + " = originalColor .a;\n";
break;
}
case "ALPHA1":
{
string += " float w1_" + this .getId () + " = blendColor_ " + this .getId () + " .a;\n";
break;
}
case "ONE_MINUS_ALPHA0":
{
string += " float w1_" + this .getId () + " = 1.0 - originalColor .a;\n";
break;
}
case "ONE_MINUS_ALPHA1":
{
string += " float w1_" + this .getId () + " = 1.0 - blendColor_ " + this .getId () + " .a;\n";
break;
}
case "TABLE":
{
if (this .weightTransferFunction1Node)
{
string += " float w1_" + this .getId () + " = texture (weightTransferFunction1_" + this .getId () + ", vec2 (originalColor .a, blendColor_" + this .getId () + " .a)) .r;\n";
}
else
{
// Use default CONSTANT value.
string += " float w1_" + this .getId () + " = weightConstant1_" + this .getId () + ";\n";
}
break;
}
}
switch (this ._weightFunction2 .getValue ())
{
default: // CONSTANT
{
string += " float w2_" + this .getId () + " = weightConstant2_" + this .getId () + ";\n";
break;
}
case "ALPHA0":
{
string += " float w2_" + this .getId () + " = originalColor .a;\n";
break;
}
case "ALPHA1":
{
string += " float w2_" + this .getId () + " = blendColor_ " + this .getId () + " .a;\n";
break;
}
case "ONE_MINUS_ALPHA0":
{
string += " float w2_" + this .getId () + " = 1.0 - originalColor .a;\n";
break;
}
case "ONE_MINUS_ALPHA1":
{
string += " float w2_" + this .getId () + " = 1.0 - blendColor_ " + this .getId () + " .a;\n";
break;
}
case "TABLE":
{
if (this .weightTransferFunction2Node)
{
string += " float w2_" + this .getId () + " = texture (weightTransferFunction2_" + this .getId () + ", vec2 (originalColor .a, blendColor_" + this .getId () + " .a)) .r;\n";
}
else
{
// Use default CONSTANT value.
string += " float w2_" + this .getId () + " = weightConstant2_" + this .getId () + ";\n";
}
break;
}
}
string += "\n";
string += " return clamp (originalColor * w1_" + this .getId () + " + blendColor_" + this .getId () + " * w2_" + this .getId () + ", 0.0, 1.0);\n";
string += "}\n";
return string;
},
getFunctionsText ()
{
if (! this ._enabled .getValue ())
return "";
if (! this .voxelsNode)
return "";
let string = "";
string += "\n";
string += " // BlendedVolumeStyle\n";
string += "\n";
string += " textureColor = getBlendedStyle_" + this .getId () + " (textureColor, texCoord);\n";
return string;
},
});
Object .defineProperties (BlendedVolumeStyle,
{
... external_X_ITE_X3D_X3DNode_default().getStaticProperties ("BlendedVolumeStyle", "VolumeRendering", 3, "renderStyle", "3.3"),
fieldDefinitions:
{
value: new (external_X_ITE_X3D_FieldDefinitionArray_default()) ([
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "metadata", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "enabled", new (external_X_ITE_X3D_Fields_default()).SFBool (true)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightConstant1", new (external_X_ITE_X3D_Fields_default()).SFFloat (0.5)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightConstant2", new (external_X_ITE_X3D_Fields_default()).SFFloat (0.5)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightFunction1", new (external_X_ITE_X3D_Fields_default()).SFString ("CONSTANT")),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightFunction2", new (external_X_ITE_X3D_Fields_default()).SFString ("CONSTANT")),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightTransferFunction1", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "weightTransferFunction2", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "renderStyle", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "voxels", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
]),
enumerable: true,
},
});
const BlendedVolumeStyle_default_ = BlendedVolumeStyle;
;
/* harmony default export */ const VolumeRendering_BlendedVolumeStyle = (external_X_ITE_X3D_Namespace_default().add ("BlendedVolumeStyle", BlendedVolumeStyle_default_));
;// ./src/x_ite/Components/VolumeRendering/BoundaryEnhancementVolumeStyle.js
function BoundaryEnhancementVolumeStyle (executionContext)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).BoundaryEnhancementVolumeStyle);
}
Object .assign (Object .setPrototypeOf (BoundaryEnhancementVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
{
addShaderFields (shaderNode)
{
if (! this ._enabled .getValue ())
return;
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "retainedOpacity_" + this .getId (), this ._retainedOpacity .copy ());
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "boundaryOpacity_" + this .getId (), this ._boundaryOpacity .copy ());
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "opacityFactor_" + this .getId (), this ._opacityFactor .copy ());
},
getUniformsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += "// BoundaryEnhancementVolumeStyle\n";
string += "\n";
string += "uniform float retainedOpacity_" + this .getId () + ";\n";
string += "uniform float boundaryOpacity_" + this .getId () + ";\n";
string += "uniform float opacityFactor_" + this .getId () + ";\n";
string += "\n";
string += "vec4\n";
string += "getBoundaryEnhancementStyle_" + this .getId () + " (in vec4 originalColor, in vec3 texCoord)\n";
string += "{\n";
string += " float f0 = texture (x3d_Texture3D [0], texCoord) .r;\n";
string += " float f1 = texture (x3d_Texture3D [0], texCoord + vec3 (0.0, 0.0, 1.0 / float (textureSize (x3d_Texture3D [0], 0) .z))) .r;\n";
string += " float f = abs (f0 - f1);\n";
string += "\n";
string += " float retainedOpacity = retainedOpacity_" + this .getId () + ";\n";
string += " float boundaryOpacity = boundaryOpacity_" + this .getId () + ";\n";
string += " float opacityFactor = opacityFactor_" + this .getId () + ";\n";
string += "\n";
string += " return vec4 (originalColor .rgb, originalColor .a * (retainedOpacity + boundaryOpacity * pow (f, opacityFactor)));\n";
string += "}\n";
return string;
},
getFunctionsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += " // BoundaryEnhancementVolumeStyle\n";
string += "\n";
string += " textureColor = getBoundaryEnhancementStyle_" + this .getId () + " (textureColor, texCoord);\n";
return string;
},
});
Object .defineProperties (BoundaryEnhancementVolumeStyle,
{
... external_X_ITE_X3D_X3DNode_default().getStaticProperties ("BoundaryEnhancementVolumeStyle", "VolumeRendering", 2, "renderStyle", "3.3"),
fieldDefinitions:
{
value: new (external_X_ITE_X3D_FieldDefinitionArray_default()) ([
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "metadata", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "enabled", new (external_X_ITE_X3D_Fields_default()).SFBool (true)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "retainedOpacity", new (external_X_ITE_X3D_Fields_default()).SFFloat (0.2)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "boundaryOpacity", new (external_X_ITE_X3D_Fields_default()).SFFloat (0.9)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "opacityFactor", new (external_X_ITE_X3D_Fields_default()).SFFloat (2)),
]),
enumerable: true,
},
});
const BoundaryEnhancementVolumeStyle_default_ = BoundaryEnhancementVolumeStyle;
;
/* harmony default export */ const VolumeRendering_BoundaryEnhancementVolumeStyle = (external_X_ITE_X3D_Namespace_default().add ("BoundaryEnhancementVolumeStyle", BoundaryEnhancementVolumeStyle_default_));
;// ./src/x_ite/Components/VolumeRendering/CartoonVolumeStyle.js
function CartoonVolumeStyle (executionContext)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).CartoonVolumeStyle);
}
Object .assign (Object .setPrototypeOf (CartoonVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
{
initialize ()
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
this ._surfaceNormals .addInterest ("set_surfaceNormals__", this);
this .set_surfaceNormals__ ();
},
set_surfaceNormals__ ()
{
this .surfaceNormalsNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
},
addShaderFields (shaderNode)
{
if (! this ._enabled .getValue ())
return;
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "colorSteps_" + this .getId (), this ._colorSteps .copy ());
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "orthogonalColor_" + this .getId (), this ._orthogonalColor .copy ());
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "parallelColor_" + this .getId (), this ._parallelColor .copy ());
if (this .surfaceNormalsNode)
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (external_X_ITE_X3D_Fields_default()).SFNode (this .surfaceNormalsNode));
},
getDefines (defines)
{
defines .add ("#define X3D_HSV");
},
getUniformsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += "// CartoonVolumeStyle\n";
string += "\n";
string += "uniform int colorSteps_" + this .getId () + ";\n";
string += "uniform vec4 orthogonalColor_" + this .getId () + ";\n";
string += "uniform vec4 parallelColor_" + this .getId () + ";\n";
string += this .getNormalText (this .surfaceNormalsNode);
string += "\n";
string += "vec4\n";
string += "getCartoonStyle_" + this .getId () + " (in vec4 originalColor, vec3 texCoord)\n";
string += "{\n";
string += " vec4 surfaceNormal = getNormal_" + this .getId () + " (texCoord);\n";
string += "\n";
string += " if (surfaceNormal .w == 0.0)\n";
string += " return vec4 (0.0);\n";
string += "\n";
string += " vec4 orthogonalColor = orthogonalColor_" + this .getId () + ";\n";
string += " vec4 parallelColor = parallelColor_" + this .getId () + ";\n";
string += " int colorSteps = colorSteps_" + this .getId () + ";\n";
string += "\n";
string += " float steps = clamp (float (colorSteps), 1.0, 64.0);\n";
string += " float step = M_PI / 2.0 / steps;\n";
string += " float cosTheta = min (dot (surfaceNormal .xyz, normalize (vertex)), 1.0);\n";
string += "\n";
string += " if (cosTheta < 0.0)\n";
string += " return vec4 (0.0);\n";
string += "\n";
string += " float t = cos (min (floor (acos (cosTheta) / step) * (steps > 1.0 ? steps / (steps - 1.0) : 1.0), steps) * step);\n";
string += " vec3 orthogonalHSV = rgb2hsv (orthogonalColor .rgb);\n";
string += " vec3 parallelHSV = rgb2hsv (parallelColor .rgb);\n";
string += "\n";
string += " return vec4 (hsv2rgb (mix_hsv (orthogonalHSV, parallelHSV, t)), originalColor .a);\n";
string += "}\n";
return string;
},
getFunctionsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += " // CartoonVolumeStyle\n";
string += "\n";
string += " textureColor = getCartoonStyle_" + this .getId () + " (textureColor, texCoord);\n";
return string;
},
});
Object .defineProperties (CartoonVolumeStyle,
{
... external_X_ITE_X3D_X3DNode_default().getStaticProperties ("CartoonVolumeStyle", "VolumeRendering", 3, "renderStyle", "3.3"),
fieldDefinitions:
{
value: new (external_X_ITE_X3D_FieldDefinitionArray_default()) ([
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "metadata", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "enabled", new (external_X_ITE_X3D_Fields_default()).SFBool (true)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "colorSteps", new (external_X_ITE_X3D_Fields_default()).SFInt32 (4)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "orthogonalColor", new (external_X_ITE_X3D_Fields_default()).SFColorRGBA (1, 1, 1, 1)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "parallelColor", new (external_X_ITE_X3D_Fields_default()).SFColorRGBA (0, 0, 0, 1)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "surfaceNormals", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
]),
enumerable: true,
},
});
const CartoonVolumeStyle_default_ = CartoonVolumeStyle;
;
/* harmony default export */ const VolumeRendering_CartoonVolumeStyle = (external_X_ITE_X3D_Namespace_default().add ("CartoonVolumeStyle", CartoonVolumeStyle_default_));
;// ./src/x_ite/Components/VolumeRendering/ComposedVolumeStyle.js
function ComposedVolumeStyle (executionContext)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).ComposedVolumeStyle);
this .renderStyleNodes = [ ];
}
Object .assign (Object .setPrototypeOf (ComposedVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
{
initialize ()
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
this ._renderStyle .addInterest ("set_renderStyle__", this);
this .set_renderStyle__ ();
},
addVolumeData (volumeDataNode)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .addVolumeData .call (this, volumeDataNode);
for (const renderStyleNode of this .renderStyleNodes)
renderStyleNode .addVolumeData (volumeDataNode);
},
removeVolumeData (volumeDataNode)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .removeVolumeData .call (this, volumeDataNode);
for (const renderStyleNode of this .renderStyleNodes)
renderStyleNode .removeVolumeData (volumeDataNode);
},
set_renderStyle__ ()
{
const renderStyleNodes = this .renderStyleNodes;
for (const renderStyleNode of renderStyleNodes)
{
renderStyleNode .removeInterest ("addNodeEvent", this);
for (const volumeDataNode of this .getVolumeData ())
renderStyleNode .removeVolumeData (volumeDataNode);
}
renderStyleNodes .length = 0;
for (const node of this ._renderStyle)
{
const renderStyleNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DComposableVolumeRenderStyleNode, node);
if (renderStyleNode)
renderStyleNodes .push (renderStyleNode);
}
for (const renderStyleNode of renderStyleNodes)
{
renderStyleNode .addInterest ("addNodeEvent", this);
for (const volumeDataNode of this .getVolumeData ())
renderStyleNode .addVolumeData (volumeDataNode);
}
},
addShaderFields (shaderNode)
{
if (! this ._enabled .getValue ())
return;
for (const renderStyleNode of this .renderStyleNodes)
renderStyleNode .addShaderFields (shaderNode);
},
getDefines (defines)
{
for (const renderStyleNode of this .renderStyleNodes)
renderStyleNode .getDefines (defines);
},
getUniformsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
for (const renderStyleNode of this .renderStyleNodes)
string += renderStyleNode .getUniformsText ();
string += "\n";
string += "vec4\n";
string += "getComposedStyle_" + this .getId () + " (in vec4 textureColor, in vec3 texCoord)\n";
string += "{\n";
for (const renderStyleNode of this .renderStyleNodes)
string += renderStyleNode .getFunctionsText ();
string += "\n";
string += " return textureColor;\n";
string += "}\n";
return string;
},
getFunctionsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += " // ComposedVolumeStyle\n";
string += "\n";
string += " textureColor = getComposedStyle_" + this .getId () + " (textureColor, texCoord);\n";
return string;
}
});
Object .defineProperties (ComposedVolumeStyle,
{
... external_X_ITE_X3D_X3DNode_default().getStaticProperties ("ComposedVolumeStyle", "VolumeRendering", 3, "renderStyle", "3.3"),
fieldDefinitions:
{
value: new (external_X_ITE_X3D_FieldDefinitionArray_default()) ([
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "metadata", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "enabled", new (external_X_ITE_X3D_Fields_default()).SFBool (true)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "renderStyle", new (external_X_ITE_X3D_Fields_default()).MFNode ()),
]),
enumerable: true,
},
});
const ComposedVolumeStyle_default_ = ComposedVolumeStyle;
;
/* harmony default export */ const VolumeRendering_ComposedVolumeStyle = (external_X_ITE_X3D_Namespace_default().add ("ComposedVolumeStyle", ComposedVolumeStyle_default_));
;// ./src/x_ite/Components/VolumeRendering/EdgeEnhancementVolumeStyle.js
function EdgeEnhancementVolumeStyle (executionContext)
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
this .addType ((external_X_ITE_X3D_X3DConstants_default()).EdgeEnhancementVolumeStyle);
}
Object .assign (Object .setPrototypeOf (EdgeEnhancementVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
{
initialize ()
{
VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
this ._surfaceNormals .addInterest ("set_surfaceNormals__", this);
this .set_surfaceNormals__ ();
},
set_surfaceNormals__ ()
{
this .surfaceNormalsNode = external_X_ITE_X3D_X3DCast_default() ((external_X_ITE_X3D_X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
},
addShaderFields (shaderNode)
{
if (! this ._enabled .getValue ())
return;
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "edgeColor_" + this .getId (), this ._edgeColor .copy ());
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "gradientThreshold_" + this .getId (), this ._gradientThreshold .copy ());
if (this .surfaceNormalsNode)
shaderNode .addUserDefinedField ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (external_X_ITE_X3D_Fields_default()).SFNode (this .surfaceNormalsNode));
},
getUniformsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += "// EdgeEnhancementVolumeStyle\n";
string += "\n";
string += "uniform vec4 edgeColor_" + this .getId () + ";\n";
string += "uniform float gradientThreshold_" + this .getId () + ";\n";
string += this .getNormalText (this .surfaceNormalsNode);
string += "\n";
string += "vec4\n";
string += "getEdgeEnhacementStyle_" + this .getId () + " (in vec4 originalColor, in vec3 texCoord)\n";
string += "{\n";
string += " vec4 surfaceNormal = getNormal_" + this .getId () + " (texCoord);\n";
string += "\n";
string += " if (surfaceNormal .w == 0.0)\n";
string += " return vec4 (0.0);\n";
string += "\n";
string += " vec4 edgeColor = edgeColor_" + this .getId () + ";\n";
string += " float gradientThreshold = gradientThreshold_" + this .getId () + ";\n";
string += "\n";
string += " float angle = abs (dot (surfaceNormal .xyz, normalize (vertex)));\n";
string += "\n";
string += " if (angle >= cos (gradientThreshold))\n";
string += " return originalColor;\n";
string += " else\n";
string += " return vec4 (mix (edgeColor .rgb, originalColor.rgb, angle), originalColor .a);\n";
string += "}\n";
return string;
},
getFunctionsText ()
{
if (! this ._enabled .getValue ())
return "";
let string = "";
string += "\n";
string += " // EdgeEnhancementVolumeStyle\n";
string += "\n";
string += " textureColor = getEdgeEnhacementStyle_" + this .getId () + " (textureColor, texCoord);\n";
return string;
},
});
Object .defineProperties (EdgeEnhancementVolumeStyle,
{
... external_X_ITE_X3D_X3DNode_default().getStaticProperties ("EdgeEnhancementVolumeStyle", "VolumeRendering", 2, "renderStyle", "3.3"),
fieldDefinitions:
{
value: new (external_X_ITE_X3D_FieldDefinitionArray_default()) ([
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "metadata", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "enabled", new (external_X_ITE_X3D_Fields_default()).SFBool (true)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "edgeColor", new (external_X_ITE_X3D_Fields_default()).SFColorRGBA (0, 0, 0, 1)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "gradientThreshold", new (external_X_ITE_X3D_Fields_default()).SFFloat (0.4)),
new (external_X_ITE_X3D_X3DFieldDefinition_default()) ((external_X_ITE_X3D_X3DConstants_default()).inputOutput, "surfaceNormals", new (external_X_ITE_X3D_Fields_default()).SFNode ()),
]),
enumerable: true,
},
});
const EdgeEnhancementVolumeStyle_default_ = EdgeEnhancementVolumeStyle;
;
/* harmony default export */ const VolumeRendering_EdgeEnhancementVolumeStyle = (external_X_ITE_X3D_Namespace_default().add ("EdgeEnhancementVolumeStyle", EdgeEnhancementVolumeStyle_default_));
;// external "__X_ITE_X3D__ .X3DChildNode"
const external_X_ITE_X3D_X3DChildNode_namespaceObject = __X_ITE_X3D__ .X3DChildNode;
var external_X_ITE_X3D_X3DChildNode_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_X3DChildNode_namespaceObject);
;// external "__X_ITE_X3D__ .X3DBoundedObject"
const external_X_ITE_X3D_X3DBoundedObject_namespaceObject = __X_ITE_X3D__ .X3DBoundedObject;
var external_X_ITE_X3D_X3DBoundedObject_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_X3DBoundedObject_namespaceObject);
;// external "__X_ITE_X3D__ .TextureQuality"
const external_X_ITE_X3D_TextureQuality_namespaceObject = __X_ITE_X3D__ .TextureQuality;
var external_X_ITE_X3D_TextureQuality_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_TextureQuality_namespaceObject);
;// external "__X_ITE_X3D__ .UnlitMaterial"
const external_X_ITE_X3D_UnlitMaterial_namespaceObject = __X_ITE_X3D__ .UnlitMaterial;
var external_X_ITE_X3D_UnlitMaterial_default = /*#__PURE__*/__webpack_require__.n(external_X_ITE_X3D_UnlitMaterial_namespaceObject);
;// ./src/x_ite/Browser/VolumeRendering/VolumeStyle.vs.js
const VolumeStyle_vs_default_ = /* glsl */ `#version 300 es
precision highp float;precision highp int;uniform mat4 x3d_ProjectionMatrix;uniform mat4 x3d_ModelViewMatrix;uniform mat4 x3d_TextureMatrix[1];
#if defined(X3D_XR_SESSION)
uniform mat4 x3d_EyeMatrix;
#endif
in vec4 x3d_TexCoord0;in vec4 x3d_Vertex;out vec3 vertex;out vec4 texCoord;
#if defined(X3D_LOGARITHMIC_DEPTH_BUFFER)
out float depth;
#endif
void main(){vec4 position=x3d_ModelViewMatrix*x3d_Vertex;
#if defined(X3D_XR_SESSION)
position=x3d_EyeMatrix*position;
#endif
vertex=position.xyz;texCoord=x3d_TextureMatrix[0]*x3d_TexCoord0;gl_Position=x3d_ProjectionMatrix*position;
#if defined(X3D_LOGARITHMIC_DEPTH_BUFFER)
depth=1.+gl_Position.w;
#endif
}`
;
/* harmony default export */ const VolumeStyle_vs = (external_X_ITE_X3D_Namespace_default().add ("VolumeStyle.vs", VolumeStyle_vs_default_));
;// ./src/x_ite/Browser/VolumeRendering/VolumeStyle.fs.js
const VolumeStyle_fs_default_ = /* glsl */ `#version 300 es
precision highp float;precision highp int;precision highp sampler3D;in vec3 vertex;in vec4 texCoord;
#if defined(X3D_LOGARITHMIC_DEPTH_BUFFER)
uniform float x3d_LogarithmicFarFactor1_2;in float depth;
#endif
uniform sampler3D x3d_Texture3D[1];uniform mat3 x3d_TextureNormalMatrix;uniform x3d_LightSourceParameters x3d_LightSource[x3d_MaxLights];const float M_PI=3.141592653589793;const float M_SQRT2=1.4142135623730951;cons