VolumeGL::VolumeGL(size3_t dimensions, const DataFormatBase* format, bool initializeTexture)
: VolumeRepresentation(format), dimensions_(dimensions)
, volumeTexture_(std::make_shared<Texture3D>(dimensions_, getGLFormats()->getGLFormat(format->getId()), GL_LINEAR)) {
if (initializeTexture) {
volumeTexture_->initialize(nullptr);
}
}
LayerGL::LayerGL(size2_t dimensions, LayerType type, const DataFormatBase* format, std::shared_ptr<Texture2D> tex)
: LayerRepresentation(dimensions, type, format), texture_(tex) {
if (!texture_) {
GLFormats::GLFormat glFormat = getGLFormats()->getGLFormat(getDataFormatId());
if (getLayerType() == LayerType::Depth) {
texture_ = std::make_shared<Texture2D>(getDimensions(), GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24,
glFormat.type, GL_NEAREST);
} else {
texture_ = std::make_shared<Texture2D>(getDimensions(), glFormat, GL_LINEAR);
}
}
}
void setShaderUniforms(Shader& shader, const Volume& volume, const std::string& samplerID) {
const StructuredCoordinateTransformer<3>& ct = volume.getCoordinateTransformer();
shader.setUniform(samplerID + ".dataToModel", ct.getDataToModelMatrix());
shader.setUniform(samplerID + ".modelToData", ct.getModelToDataMatrix());
shader.setUniform(samplerID + ".dataToWorld", ct.getDataToWorldMatrix());
shader.setUniform(samplerID + ".worldToData", ct.getWorldToDataMatrix());
shader.setUniform(samplerID + ".modelToWorld", ct.getModelToWorldMatrix());
shader.setUniform(samplerID + ".worldToModel", ct.getWorldToModelMatrix());
shader.setUniform(samplerID + ".worldToTexture", ct.getWorldToTextureMatrix());
shader.setUniform(samplerID + ".textureToWorld", ct.getTextureToWorldMatrix());
auto textureToWorldNormalMatrix = glm::inverseTranspose(ct.getTextureToWorldMatrix());
shader.setUniform(samplerID + ".textureToWorldNormalMatrix", textureToWorldNormalMatrix);
shader.setUniform(samplerID + ".textureToIndex", ct.getTextureToIndexMatrix());
shader.setUniform(samplerID + ".indexToTexture", ct.getIndexToTextureMatrix());
float gradientSpacing = volume.getWorldSpaceGradientSpacing();
// Scale the world matrix by the gradient spacing and the transform it to texture space.
// Note that since we are dealing with real values we can multiply the scalar after the
// transform as well
shader.setUniform(
samplerID + ".textureSpaceGradientSpacing",
gradientSpacing * mat3(ct.getWorldToTextureMatrix()));
vec3 dimF = static_cast<vec3>(volume.getDimensions());
shader.setUniform(samplerID + ".dimensions", dimF);
shader.setUniform(samplerID + ".reciprocalDimensions", vec3(1.f) / dimF);
shader.setUniform(samplerID + ".worldSpaceGradientSpacing", gradientSpacing);
dvec2 dataRange = volume.dataMap_.dataRange;
DataMapper defaultRange(volume.getDataFormat());
double typescale = 1.0 - getGLFormats()->getGLFormat(volume.getDataFormat()->getId()).scaling;
defaultRange.dataRange = defaultRange.dataRange * typescale;
double scalingFactor = 1.0;
double signedScalingFactor = 1.0;
double offset = 0.0;
double signedOffset = 0.0;
double invRange = 1.0 / (dataRange.y - dataRange.x);
double defaultToDataRange = (defaultRange.dataRange.y - defaultRange.dataRange.x) * invRange;
double defaultToDataOffset = (dataRange.x - defaultRange.dataRange.x) /
(defaultRange.dataRange.y - defaultRange.dataRange.x);
switch (getGLFormats()->getGLFormat(volume.getDataFormat()->getId()).normalization) {
case GLFormats::NONE:
scalingFactor = invRange;
offset = -dataRange.x;
signedScalingFactor = scalingFactor;
signedOffset = offset;
break;
case GLFormats::NORMALIZED:
scalingFactor = defaultToDataRange;
offset = -defaultToDataOffset;
signedScalingFactor = scalingFactor;
signedOffset = offset;
break;
case GLFormats::SIGN_NORMALIZED:
scalingFactor = 0.5 * defaultToDataRange;
offset = 1.0 - 2 * defaultToDataOffset;
signedScalingFactor = defaultToDataRange;
signedOffset = -defaultToDataOffset;
break;
}
// offset scaling because of reversed scaling in the shader, i.e. (1 - formatScaling_)
shader.setUniform(samplerID + ".formatScaling", static_cast<float>(1.0 - scalingFactor));
shader.setUniform(samplerID + ".formatOffset", static_cast<float>(offset));
shader.setUniform(samplerID + ".signedFormatScaling",
static_cast<float>(1.0 - signedScalingFactor));
shader.setUniform(samplerID + ".signedFormatOffset", static_cast<float>(signedOffset));
}
