import defined from "../../Core/defined.js";
|
import ShaderDestination from "../../Renderer/ShaderDestination.js";
|
import ModelExperimentalUtility from "./ModelExperimentalUtility.js";
|
|
/**
|
* The dequantization stage generates shader code to dequantize attributes
|
* in the vertex shader
|
*
|
* @namespace DequantizationPipelineStage
|
*
|
* @private
|
*/
|
var DequantizationPipelineStage = {};
|
DequantizationPipelineStage.name = "DequantizationPipelineStage"; // Helps with debugging
|
|
DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS =
|
"dequantizationStage";
|
DequantizationPipelineStage.FUNCTION_SIGNATURE_DEQUANTIZATION_STAGE_VS =
|
"void dequantizationStage(inout ProcessedAttributes attributes)";
|
|
/**
|
* Process a primitive with quantized attributes. This stage modifies the
|
* following parts of the render resources:
|
* <ul>
|
* <li>generates dequantization function and adds it to the shader</li>
|
* <li>adds any uniforms needed for dequantization to the shader and uniform map</li>
|
* </ul>
|
*
|
* @param {PrimitiveRenderResources} renderResources The render resources for this primitive.
|
* @param {ModelComponents.Primitive} primitive The primitive
|
*
|
* @private
|
*/
|
DequantizationPipelineStage.process = function (renderResources, primitive) {
|
var shaderBuilder = renderResources.shaderBuilder;
|
shaderBuilder.addFunction(
|
DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS,
|
DequantizationPipelineStage.FUNCTION_SIGNATURE_DEQUANTIZATION_STAGE_VS,
|
ShaderDestination.VERTEX
|
);
|
|
shaderBuilder.addDefine(
|
"USE_DEQUANTIZATION",
|
undefined,
|
ShaderDestination.VERTEX
|
);
|
|
var attributes = primitive.attributes;
|
for (var i = 0; i < attributes.length; i++) {
|
var attribute = attributes[i];
|
var quantization = attribute.quantization;
|
if (!defined(quantization)) {
|
// non-quantized attributes were already handled in GeometryPipelineStage
|
continue;
|
}
|
var attributeInfo = ModelExperimentalUtility.getAttributeInfo(attribute);
|
updateDequantizationFunction(shaderBuilder, attributeInfo);
|
addDequantizationUniforms(renderResources, attributeInfo);
|
}
|
};
|
|
function addDequantizationUniforms(renderResources, attributeInfo) {
|
var shaderBuilder = renderResources.shaderBuilder;
|
var uniformMap = renderResources.uniformMap;
|
var variableName = attributeInfo.variableName;
|
var quantization = attributeInfo.attribute.quantization;
|
|
if (quantization.octEncoded) {
|
var normalizationRange = "model_normalizationRange_" + variableName;
|
shaderBuilder.addUniform(
|
"float",
|
normalizationRange,
|
ShaderDestination.VERTEX
|
);
|
uniformMap[normalizationRange] = function () {
|
return quantization.normalizationRange;
|
};
|
} else {
|
var offset = "model_quantizedVolumeOffset_" + variableName;
|
var stepSize = "model_quantizedVolumeStepSize_" + variableName;
|
var glslType = attributeInfo.glslType;
|
shaderBuilder.addUniform(glslType, offset, ShaderDestination.VERTEX);
|
shaderBuilder.addUniform(glslType, stepSize, ShaderDestination.VERTEX);
|
|
uniformMap[offset] = function () {
|
return quantization.quantizedVolumeOffset;
|
};
|
|
uniformMap[stepSize] = function () {
|
return quantization.quantizedVolumeStepSize;
|
};
|
}
|
}
|
|
function updateDequantizationFunction(shaderBuilder, attributeInfo) {
|
var variableName = attributeInfo.variableName;
|
var quantization = attributeInfo.attribute.quantization;
|
|
var line;
|
if (quantization.octEncoded) {
|
line = generateOctDecodeLine(variableName, quantization);
|
} else {
|
line = generateDequantizeLine(variableName);
|
}
|
|
shaderBuilder.addFunctionLines(
|
DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS,
|
[line]
|
);
|
}
|
|
function generateOctDecodeLine(variableName, quantization) {
|
var structField = "attributes." + variableName;
|
|
var quantizedAttribute = "a_quantized_" + variableName;
|
var normalizationRange = "model_normalizationRange_" + variableName;
|
|
// Draco stores things as .zxy instead of xyz, so be explicit about the
|
// swizzle to avoid confusion
|
var swizzle = quantization.octEncodedZXY ? ".zxy" : ".xyz";
|
|
// This generates lines such as:
|
// attributes.normal = czm_octDecode(a_quantized_normal, model_normalizationRange_normal).zxy;
|
return (
|
structField +
|
" = czm_octDecode(" +
|
quantizedAttribute +
|
", " +
|
normalizationRange +
|
")" +
|
swizzle +
|
";"
|
);
|
}
|
|
function generateDequantizeLine(variableName) {
|
var structField = "attributes." + variableName;
|
var quantizedAttribute = "a_quantized_" + variableName;
|
var offset = "model_quantizedVolumeOffset_" + variableName;
|
var stepSize = "model_quantizedVolumeStepSize_" + variableName;
|
|
// This generates lines such as:
|
// attributes.texCoord_0 = model_quantizedVolumeOffset_texCoord_0 + a_quantized_texCoord_0 * model_quantizedVolumeStepSize;
|
return (
|
structField +
|
" = " +
|
offset +
|
" + " +
|
quantizedAttribute +
|
" * " +
|
stepSize +
|
";"
|
);
|
}
|
|
export default DequantizationPipelineStage;
|
