mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-05-04 09:59:44 -05:00
Code Issues Packages Projects Releases Wiki Activity

Only use padding for height layers

Browse Source
This commit is contained in:
Kalle Bladin
2017-08-08 14:02:56 +02:00
parent 2ecfd4d05a
commit 1265de0d50
16 changed files with 173 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/globes/chunkedlodglobe.cpp
+1 -1
View File
@@ -187,7 +187,7 @@ float ChunkedLodGlobe::getHeight(glm::dvec3 position) const {
return 0;
}
glm::vec2 transformedUv = Tile::TileUvToTextureSamplePosition(
glm::vec2 transformedUv = layer->TileUvToTextureSamplePosition(
uvTransform,
patchUV,
glm::uvec2(tileTexture->dimensions())
modules/globebrowsing/rendering/gpu/gpulayer.cpp
+10 -3
View File
@@ -25,13 +25,13 @@
#include <modules/globebrowsing/rendering/gpu/gpulayer.h>
#include <modules/globebrowsing/rendering/layer/layer.h>
#include <modules/globebrowsing/tile/tiletextureinitdata.h>
namespace openspace::globebrowsing {
void GPULayer::setValue(ghoul::opengl::ProgramObject* programObject, const Layer& layer,
const TileIndex& tileIndex, int pileSize)
{
ChunkTilePile chunkTilePile = layer.getChunkTilePile(tileIndex, pileSize);
gpuRenderSettings.setValue(programObject, layer.renderSettings());
gpuLayerAdjustment.setValue(programObject, layer.layerAdjustment());
@@ -43,9 +43,13 @@ void GPULayer::setValue(ghoul::opengl::ProgramObject* programObject, const Layer
case layergroupid::TypeID::TemporalTileLayer:
case layergroupid::TypeID::TileIndexTileLayer:
case layergroupid::TypeID::ByIndexTileLayer:
case layergroupid::TypeID::ByLevelTileLayer:
case layergroupid::TypeID::ByLevelTileLayer: {
ChunkTilePile chunkTilePile = layer.getChunkTilePile(tileIndex, pileSize);
gpuChunkTilePile.setValue(programObject, chunkTilePile);
paddingStartOffset.setValue(programObject, layer.tilePixelStartOffset());
paddingSizeDifference.setValue(programObject, layer.tilePixelSizeDifference());
break;
}
case layergroupid::TypeID::SolidColor:
gpuColor.setValue(programObject, layer.otherTypesProperties().color.value());
break;
@@ -68,9 +72,12 @@ void GPULayer::bind(ghoul::opengl::ProgramObject* programObject, const Layer& la
case layergroupid::TypeID::TemporalTileLayer:
case layergroupid::TypeID::TileIndexTileLayer:
case layergroupid::TypeID::ByIndexTileLayer:
case layergroupid::TypeID::ByLevelTileLayer:
case layergroupid::TypeID::ByLevelTileLayer: {
gpuChunkTilePile.bind(programObject, nameBase + "pile.", pileSize);
paddingStartOffset.bind(programObject, nameBase + "padding.startOffset");
paddingSizeDifference.bind(programObject, nameBase + "padding.sizeDifference");
break;
}
case layergroupid::TypeID::SolidColor:
gpuColor.bind(programObject, nameBase + "color");
break;
modules/globebrowsing/rendering/gpu/gpulayer.h
+2
View File
@@ -73,6 +73,8 @@ private:
GPULayerRenderSettings gpuRenderSettings;
GPULayerAdjustment gpuLayerAdjustment;
GPUData<glm::ivec2> paddingStartOffset;
GPUData<glm::ivec2> paddingSizeDifference;
// Adjustment layer stuff
GPUData<glm::vec3> gpuColor;
};
modules/globebrowsing/rendering/layer/layer.cpp
+36
View File
@@ -24,7 +24,9 @@
#include <modules/globebrowsing/rendering/layer/layer.h>
#include <modules/globebrowsing/rendering/layer/layermanager.h>
#include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
#include <modules/globebrowsing/tile/tiletextureinitdata.h>
namespace openspace::globebrowsing {
@@ -102,6 +104,10 @@ Layer::Layer(layergroupid::GroupID id, const ghoul::Dictionary& layerDict)
layerDict.getValue(keyEnabled, enabled);
_enabled.setValue(enabled);
TileTextureInitData initData = LayerManager::getTileTextureInitData(_layerGroupId);
_padTilePixelStartOffset = initData.tilePixelStartOffset();
_padTilePixelSizeDifference = initData.tilePixelSizeDifference();
// Initialize settings
ghoul::Dictionary settingsDict;
if (layerDict.getValue(keySettings, settingsDict)) {
@@ -261,6 +267,36 @@ void Layer::update() {
}
}
glm::ivec2 Layer::tilePixelStartOffset() const {
return _padTilePixelStartOffset;
}
glm::ivec2 Layer::tilePixelSizeDifference() const {
return _padTilePixelSizeDifference;
}
glm::vec2 Layer::compensateSourceTextureSampling(glm::vec2 startOffset, glm::vec2 sizeDiff,
glm::uvec2 resolution, glm::vec2 tileUV)
{
glm::vec2 sourceSize = glm::vec2(resolution) + sizeDiff;
glm::vec2 currentSize = glm::vec2(resolution);
glm::vec2 sourceToCurrentSize = currentSize / sourceSize;
tileUV = sourceToCurrentSize * (tileUV - startOffset / sourceSize);
return tileUV;
}
glm::vec2 Layer::TileUvToTextureSamplePosition(const TileUvTransform& uvTransform,
glm::vec2 tileUV, glm::uvec2 resolution)
{
glm::vec2 uv = uvTransform.uvOffset + uvTransform.uvScale * tileUV;
uv = compensateSourceTextureSampling(
tilePixelStartOffset(),
tilePixelSizeDifference(),
resolution,
uv);
return uv;
}
layergroupid::TypeID Layer::parseTypeIdFromDictionary(
const ghoul::Dictionary& initDict) const
{
modules/globebrowsing/rendering/layer/layer.h
+10
View File
@@ -69,6 +69,13 @@ public:
void update();
glm::ivec2 tilePixelStartOffset() const;
glm::ivec2 tilePixelSizeDifference() const;
glm::vec2 compensateSourceTextureSampling(glm::vec2 startOffset, glm::vec2 sizeDiff,
glm::uvec2 resolution, glm::vec2 tileUV);
glm::vec2 TileUvToTextureSamplePosition(const TileUvTransform& uvTransform,
glm::vec2 tileUV, glm::uvec2 resolution);
private:
layergroupid::TypeID parseTypeIdFromDictionary(const ghoul::Dictionary& initDict) const;
void initializeBasedOnType(layergroupid::TypeID typeId, ghoul::Dictionary initDict);
@@ -86,6 +93,9 @@ private:
LayerRenderSettings _renderSettings;
LayerAdjustment _layerAdjustment;
glm::ivec2 _padTilePixelStartOffset;
glm::ivec2 _padTilePixelSizeDifference;
const layergroupid::GroupID _layerGroupId;
std::function<void(void)> _onChangeCallback;
modules/globebrowsing/rendering/layer/layermanager.cpp
+6 -5
View File
@@ -124,33 +124,34 @@ TileTextureInitData LayerManager::getTileTextureInitData(layergroupid::GroupID i
size_t tileSize = preferredTileSize ? preferredTileSize : 64;
return TileTextureInitData(tileSize, tileSize, GL_FLOAT,
ghoul::opengl::Texture::Format::Red,
true,
TileTextureInitData::ShouldAllocateDataOnCPU::Yes);
}
case layergroupid::GroupID::ColorLayers: {
size_t tileSize = preferredTileSize ? preferredTileSize : 512;
return TileTextureInitData(tileSize, tileSize, GL_UNSIGNED_BYTE,
ghoul::opengl::Texture::Format::BGRA);
ghoul::opengl::Texture::Format::BGRA, false);
}
case layergroupid::GroupID::Overlays: {
size_t tileSize = preferredTileSize ? preferredTileSize : 512;
return TileTextureInitData(tileSize, tileSize, GL_UNSIGNED_BYTE,
ghoul::opengl::Texture::Format::BGRA);
ghoul::opengl::Texture::Format::BGRA, false);
}
case layergroupid::GroupID::NightLayers: {
size_t tileSize = preferredTileSize ? preferredTileSize : 512;
return TileTextureInitData(tileSize, tileSize, GL_UNSIGNED_BYTE,
ghoul::opengl::Texture::Format::BGRA);
ghoul::opengl::Texture::Format::BGRA, false);
}
case layergroupid::GroupID::WaterMasks: {
size_t tileSize = preferredTileSize ? preferredTileSize : 512;
return TileTextureInitData(tileSize, tileSize, GL_UNSIGNED_BYTE,
ghoul::opengl::Texture::Format::BGRA);
ghoul::opengl::Texture::Format::BGRA, false);
}
default: {
ghoul_assert(false, "Unknown layer group ID");
size_t tileSize = preferredTileSize ? preferredTileSize : 512;
return TileTextureInitData(tileSize, tileSize, GL_UNSIGNED_BYTE,
ghoul::opengl::Texture::Format::BGRA);
ghoul::opengl::Texture::Format::BGRA, false);
}
}
}
modules/globebrowsing/rendering/layershadermanager.cpp
-11
View File
@@ -116,17 +116,6 @@ LayerShaderManager::LayerShaderPreprocessingData
);
pairs.emplace_back("defaultHeight", std::to_string(Chunk::DEFAULT_HEIGHT));
pairs.emplace_back("tilePaddingStart",
"ivec2(" +
std::to_string(RawTileDataReader::padding.start.x) + "," +
std::to_string(RawTileDataReader::padding.start.y) + ")"
);
pairs.emplace_back("tilePaddingSizeDiff",
"ivec2(" +
std::to_string(RawTileDataReader::padding.numPixels.x) + "," +
std::to_string(RawTileDataReader::padding.numPixels.y) + ")"
);
return preprocessingData;
}
modules/globebrowsing/shaders/texturetilemapping.hglsl
+12 -8
View File
@@ -119,19 +119,19 @@ vec4 getSample#{layerGroup}#{i}(vec2 uv, LevelWeights levelWeights,
// All tile layers are the same. Sample from texture
#if (#{#{layerGroup}#{i}LayerType} == 0) // DefaultTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 1) // SingleImageTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 2) // SizeReferenceTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 3) // TemporalTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 4) // TileIndexTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 5) // ByIndexTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 6) // ByLevelTileLayer
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv);
color = getTexVal(#{layerGroup}[#{i}].pile, levelWeights, uv, #{layerGroup}[#{i}].padding);
#elif (#{#{layerGroup}#{i}LayerType} == 7) // SolidColor
color.rgb = #{layerGroup}[#{i}].color;
#endif
@@ -296,8 +296,12 @@ vec4 calculateDebugColor(vec2 uv, vec4 fragPos, vec2 vertexResolution) {
}
float tileResolution(vec2 tileUV, ChunkTile chunkTile) {
PixelPadding padding;
padding.startOffset = ivec2(0);
padding.sizeDifference = ivec2(0);
vec2 heightResolution = textureSize(chunkTile.textureSampler, 0);
vec2 uv = TileUVToTextureSamplePosition(chunkTile, tileUV);
vec2 uv = TileUVToTextureSamplePosition(chunkTile, tileUV, padding);
return gridDots(uv, heightResolution);
}
modules/globebrowsing/shaders/tile.hglsl
+57 -73
View File
@@ -25,90 +25,25 @@
#ifndef TEXTURETILE_HGLSL
#define TEXTURETILE_HGLSL
// Must match the values in tiledataset.cpp
// (could be set as shader preprocessing data so that multiple definitions
// are not needed)
#define TILE_PIXEL_START_OFFSET #{tilePaddingStart}
#define TILE_PIXEL_SIZE_DIFFERENCE #{tilePaddingSizeDiff}
vec4 patchBorderOverlay(vec2 uv, vec3 borderColor, float borderSize) {
vec2 uvOffset = uv - vec2(0.5);
float thres = 0.5 - borderSize/2;
bool isBorder = abs(uvOffset.x) > thres || abs(uvOffset.y) > thres;
vec3 color = isBorder ? borderColor : vec3(0);
return vec4(color, 0);
}
/////////////////////////////////////////////////////////////////////
// ChunkTile Depth Transform //
/////////////////////////////////////////////////////////////////////
struct TileDepthTransform {
float depthScale;
float depthOffset;
};
float getTransformedTexVal(TileDepthTransform transform, float val) {
return transform.depthOffset + transform.depthScale * val;
}
vec4 getTransformedTexVal(TileDepthTransform transform, vec4 val) {
return transform.depthOffset + transform.depthScale * val;
}
/////////////////////////////////////////////////////////////////////
// ChunkTile UV Transform //
/////////////////////////////////////////////////////////////////////
struct TileUvTransform {
vec2 uvOffset;
vec2 uvScale;
};
/////////////////////////////////////////////////////////////////////
// ChunkTile //
/////////////////////////////////////////////////////////////////////
struct ChunkTile {
sampler2D textureSampler;
TileUvTransform uvTransform;
};
vec2 compensateSourceTextureSampling(vec2 startOffset, vec2 sizeDiff, ChunkTile chunkTile,
vec2 tileUV)
{
ivec2 resolution = textureSize(chunkTile.textureSampler, 0);
vec2 sourceSize = vec2(resolution) + sizeDiff;
vec2 currentSize = vec2(resolution);
vec2 sourceToCurrentSize = currentSize / sourceSize;
return sourceToCurrentSize * (tileUV - startOffset / sourceSize);
}
vec2 TileUVToTextureSamplePosition(ChunkTile chunkTile, vec2 tileUV) {
vec2 uv = chunkTile.uvTransform.uvOffset + chunkTile.uvTransform.uvScale * tileUV;
return compensateSourceTextureSampling(
TILE_PIXEL_START_OFFSET,
TILE_PIXEL_SIZE_DIFFERENCE,
chunkTile,
uv
);
}
vec4 getTexVal(ChunkTile chunkTile, vec2 tileUV) {
return texture(
chunkTile.textureSampler,
TileUVToTextureSamplePosition(chunkTile, tileUV)
);
}
/////////////////////////////////////////////////////////////////////
// Chunk Tile Pile //
/////////////////////////////////////////////////////////////////////
struct PixelPadding {
ivec2 startOffset;
ivec2 sizeDifference;
};
struct ChunkTilePile {
ChunkTile chunkTile0;
@@ -134,6 +69,7 @@ struct Layer {
TileDepthTransform depthTransform;
LayerSettings settings;
LayerAdjustment adjustment;
PixelPadding padding;
// Other layer type properties stuff
vec3 color;
@@ -145,6 +81,52 @@ struct LevelWeights {
float w3;
};
vec4 patchBorderOverlay(vec2 uv, vec3 borderColor, float borderSize) {
vec2 uvOffset = uv - vec2(0.5);
float thres = 0.5 - borderSize/2;
bool isBorder = abs(uvOffset.x) > thres || abs(uvOffset.y) > thres;
vec3 color = isBorder ? borderColor : vec3(0);
return vec4(color, 0);
}
float getTransformedTexVal(TileDepthTransform transform, float val) {
return transform.depthOffset + transform.depthScale * val;
}
vec4 getTransformedTexVal(TileDepthTransform transform, vec4 val) {
return transform.depthOffset + transform.depthScale * val;
}
vec2 compensateSourceTextureSampling(vec2 startOffset, vec2 sizeDiff, ChunkTile chunkTile,
vec2 tileUV)
{
ivec2 resolution = textureSize(chunkTile.textureSampler, 0);
vec2 sourceSize = vec2(resolution) + sizeDiff;
vec2 currentSize = vec2(resolution);
vec2 sourceToCurrentSize = currentSize / sourceSize;
return sourceToCurrentSize * (tileUV - startOffset / sourceSize);
}
vec2 TileUVToTextureSamplePosition(ChunkTile chunkTile, vec2 tileUV,
PixelPadding padding)
{
vec2 uv = chunkTile.uvTransform.uvOffset + chunkTile.uvTransform.uvScale * tileUV;
return compensateSourceTextureSampling(
padding.startOffset,
padding.sizeDifference,
chunkTile,
uv
);
}
vec4 getTexVal(ChunkTile chunkTile, vec2 tileUV, PixelPadding padding) {
return texture(
chunkTile.textureSampler,
TileUVToTextureSamplePosition(chunkTile, tileUV, padding)
);
}
float getLevelInterpolationParameter(int chunkLevel, float distanceScaleFactor,
float distToVertexOnEllipsoid)
{
@@ -172,10 +154,12 @@ LevelWeights getDefaultLevelWeights() {
return levelWeights;
}
vec4 getTexVal(ChunkTilePile chunkTilePile, LevelWeights w, vec2 uv) {
return w.w1 * getTexVal(chunkTilePile.chunkTile0, uv) +
w.w2 * getTexVal(chunkTilePile.chunkTile1, uv) +
w.w3 * getTexVal(chunkTilePile.chunkTile2, uv);
vec4 getTexVal(ChunkTilePile chunkTilePile, LevelWeights w, vec2 uv,
PixelPadding padding)
{
return w.w1 * getTexVal(chunkTilePile.chunkTile0, uv, padding) +
w.w2 * getTexVal(chunkTilePile.chunkTile1, uv, padding) +
w.w3 * getTexVal(chunkTilePile.chunkTile2, uv, padding);
}
#endif // TEXTURETILE_HGLSL
modules/globebrowsing/tile/rawtiledatareader/rawtiledatareader.cpp
+6 -6
View File
@@ -54,12 +54,7 @@
#include <math.h>
namespace openspace::globebrowsing {
const PixelRegion RawTileDataReader::padding = PixelRegion(
TileTextureInitData::tilePixelStartOffset,
TileTextureInitData::tilePixelSizeDifference
);
RawTileDataReader::RawTileDataReader(const TileTextureInitData& initData,
PerformPreprocessing preprocess)
: _initData(initData)
@@ -256,6 +251,11 @@ IODescription RawTileDataReader::getIODescription(const TileIndex& tileIndex) co
io.read.fullRegion = fullPixelRegion();
// For correct sampling in dataset, we need to pad the texture tile
PixelRegion padding = PixelRegion(
_initData.tilePixelStartOffset(),
_initData.tilePixelSizeDifference()
);
PixelRegion scaledPadding = padding;
double scale =
io.read.region.numPixels.x / static_cast<double>(io.write.region.numPixels.x);
modules/globebrowsing/tile/rawtiledatareader/rawtiledatareader.h
-3
View File
@@ -84,9 +84,6 @@ public:
* Returns a single channeled empty <code>RawTile</code> of size 16 * 16 pixels.
*/
std::shared_ptr<RawTile> defaultTileData() const;
/// Padding around all tiles to read to make sure edge blending works.
const static PixelRegion padding; // same as the two above
protected:
modules/globebrowsing/tile/tile.cpp
-22
View File
@@ -42,26 +42,4 @@ Tile::Tile(ghoul::opengl::Texture* texture,
, _status(status)
{ }
glm::vec2 Tile::compensateSourceTextureSampling(glm::vec2 startOffset, glm::vec2 sizeDiff,
glm::uvec2 resolution, glm::vec2 tileUV)
{
glm::vec2 sourceSize = glm::vec2(resolution) + sizeDiff;
glm::vec2 currentSize = glm::vec2(resolution);
glm::vec2 sourceToCurrentSize = currentSize / sourceSize;
tileUV = sourceToCurrentSize * (tileUV - startOffset / sourceSize);
return tileUV;
}
glm::vec2 Tile::TileUvToTextureSamplePosition(const TileUvTransform& uvTransform,
glm::vec2 tileUV, glm::uvec2 resolution)
{
glm::vec2 uv = uvTransform.uvOffset + uvTransform.uvScale * tileUV;
uv = compensateSourceTextureSampling(
TileTextureInitData::tilePixelStartOffset,
TileTextureInitData::tilePixelSizeDifference,
resolution,
uv);
return uv;
}
} // namespace openspace::globebrowsing
modules/globebrowsing/tile/tile.h
-4
View File
@@ -85,10 +85,6 @@ public:
return _texture;
};
static glm::vec2 compensateSourceTextureSampling(glm::vec2 startOffset,
glm::vec2 sizeDiff, glm::uvec2 resolution, glm::vec2 tileUV);
static glm::vec2 TileUvToTextureSamplePosition(const TileUvTransform& uvTransform,
glm::vec2 tileUV, glm::uvec2 resolution);
/**
* A tile with status unavailable that any user can return to
* indicate that a tile was unavailable.
modules/globebrowsing/tile/tileprovider/tileprovider.cpp
+1 -1
View File
@@ -161,7 +161,7 @@ void TileProvider::initializeDefaultTile() {
using namespace ghoul::opengl;
// Create pixel data
TileTextureInitData initData(8, 8, GL_UNSIGNED_BYTE, Texture::Format::RGBA,
TileTextureInitData initData(8, 8, GL_UNSIGNED_BYTE, Texture::Format::RGBA, false,
TileTextureInitData::ShouldAllocateDataOnCPU::Yes);
int numBytes = initData.totalNumBytes();
char* pixels = new char[numBytes];
modules/globebrowsing/tile/tiletextureinitdata.cpp
+24 -12
View File
@@ -23,22 +23,26 @@
****************************************************************************************/
#include <modules/globebrowsing/tile/tiletextureinitdata.h>
#include <modules/globebrowsing/tile/rawtiledatareader/tiledatatype.h>
namespace openspace::globebrowsing {
const glm::ivec2 TileTextureInitData::tilePixelStartOffset = glm::ivec2(-2);
const glm::ivec2 TileTextureInitData::tilePixelSizeDifference = glm::ivec2(4);
const glm::ivec2 TileTextureInitData::TilePixelStartOffset = glm::ivec2(-2);
const glm::ivec2 TileTextureInitData::TilePixelSizeDifference = glm::ivec2(4);
TileTextureInitData::TileTextureInitData(size_t width, size_t height, GLenum glType,
Format textureFormat, ShouldAllocateDataOnCPU shouldAllocateDataOnCPU)
Format textureFormat, bool padTiles, ShouldAllocateDataOnCPU shouldAllocateDataOnCPU)
: _glType(glType)
, _ghoulTextureFormat(textureFormat)
, _shouldAllocateDataOnCPU(shouldAllocateDataOnCPU)
{
_tilePixelStartOffset = padTiles ? TilePixelStartOffset : glm::ivec2(0);
_tilePixelSizeDifference = padTiles ? TilePixelSizeDifference : glm::ivec2(0);
_dimensionsWithoutPadding = glm::ivec3(width, height, 1);
_dimensionsWithPadding = glm::ivec3(
width + tilePixelSizeDifference.x, height + tilePixelSizeDifference.y, 1);
_dimensionsWithPadding = glm::ivec3( width + _tilePixelSizeDifference.x, height + _tilePixelSizeDifference.y,
1);
_nRasters = tiledatatype::numberOfRasters(_ghoulTextureFormat);
_bytesPerDatum = tiledatatype::numberOfBytes(glType);
_bytesPerPixel = _nRasters * _bytesPerDatum;
@@ -66,6 +70,14 @@ glm::ivec3 TileTextureInitData::dimensionsWithoutPadding() const {
return _dimensionsWithoutPadding;
}
glm::ivec2 TileTextureInitData::tilePixelStartOffset() const {
return _tilePixelStartOffset;
}
glm::ivec2 TileTextureInitData::tilePixelSizeDifference() const {
return _tilePixelSizeDifference;
}
size_t TileTextureInitData::nRasters() const {
return _nRasters;
}
@@ -107,18 +119,18 @@ TileTextureInitData::HashKey TileTextureInitData::hashKey() const {
}
void TileTextureInitData::calculateHashKey() {
ghoul_assert(_dimensionsWithoutPadding.x > 0, "Incorrect dimension");
ghoul_assert(_dimensionsWithoutPadding.y > 0, "Incorrect dimension");
ghoul_assert(_dimensionsWithoutPadding.x <= 1024, "Incorrect dimension");
ghoul_assert(_dimensionsWithoutPadding.y <= 1024, "Incorrect dimension");
ghoul_assert(_dimensionsWithoutPadding.z == 1, "Incorrect dimension");
ghoul_assert(_dimensionsWithPadding.x > 0, "Incorrect dimension");
ghoul_assert(_dimensionsWithPadding.y > 0, "Incorrect dimension");
ghoul_assert(_dimensionsWithPadding.x <= 1024, "Incorrect dimension");
ghoul_assert(_dimensionsWithPadding.y <= 1024, "Incorrect dimension");
ghoul_assert(_dimensionsWithPadding.z == 1, "Incorrect dimension");
unsigned int format = getUniqueIdFromTextureFormat(_ghoulTextureFormat);
ghoul_assert(format < 256, "Incorrect format");
_hashKey = 0LL;
_hashKey |= _dimensionsWithoutPadding.x;
_hashKey |= _dimensionsWithoutPadding.y << 10;
_hashKey |= _dimensionsWithPadding.x;
_hashKey |= _dimensionsWithPadding.y << 10;
_hashKey |= static_cast<std::underlying_type_t<GLenum>>(_glType) << (10 + 16);
_hashKey |= format << (10 + 16 + 4);
};
modules/globebrowsing/tile/tiletextureinitdata.h
+8 -2
View File
@@ -43,6 +43,7 @@ public:
using Format = ghoul::opengl::Texture::Format;
TileTextureInitData(size_t width, size_t height, GLenum glType, Format textureFormat,
bool padTiles,
ShouldAllocateDataOnCPU shouldAllocateDataOnCPU = ShouldAllocateDataOnCPU::No);
TileTextureInitData(const TileTextureInitData& original);
@@ -51,6 +52,8 @@ public:
glm::ivec3 dimensionsWithPadding() const;
glm::ivec3 dimensionsWithoutPadding() const;
glm::ivec2 tilePixelStartOffset() const;
glm::ivec2 tilePixelSizeDifference() const;
size_t nRasters() const;
size_t bytesPerDatum() const;
size_t bytesPerPixel() const;
@@ -62,16 +65,19 @@ public:
bool shouldAllocateDataOnCPU() const;
HashKey hashKey() const;
const static glm::ivec2 tilePixelStartOffset;
const static glm::ivec2 tilePixelSizeDifference;
const static glm::ivec2 TilePixelStartOffset;
const static glm::ivec2 TilePixelSizeDifference;
private:
void calculateHashKey();
unsigned int getUniqueIdFromTextureFormat(Format textureFormat) const;
HashKey _hashKey;
glm::ivec3 _dimensionsWithPadding;
glm::ivec3 _dimensionsWithoutPadding;
glm::ivec2 _tilePixelStartOffset;
glm::ivec2 _tilePixelSizeDifference;
GLenum _glType;
Format _ghoulTextureFormat;
GLenum _glTextureFormat;