tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

take 2, still not working

Browse Source
This commit is contained in:
Lauren Budorick
2014-08-05 18:13:02 -07:00
parent df925fe0e5
commit 9e1156d660
13 changed files with 152 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/mbgl/map/tile_parser.hpp
View File

@@ -22,6 +22,7 @@ class Sprite;
class Style;
class StyleBucket;
class StyleBucketFill;
class StyleBucketRaster;
class StyleBucketLine;
class StyleBucketSymbol;
class StyleLayerGroup;
@@ -45,6 +46,7 @@ private:
std::unique_ptr<Bucket> createBucket(std::shared_ptr<StyleBucket> bucket_desc);
std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill);
std::unique_ptr<Bucket> createRasterBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketRaster &raster);
std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line);
std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol);

5
include/mbgl/renderer/prerendered_texture.hpp
View File

@@ -4,6 +4,7 @@
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/platform/gl.hpp>
#include <mbgl/style/rasterize_properties.hpp>
//#include <mbgl/renderer/raster_bucket.hpp>
namespace mbgl {
@@ -11,7 +12,7 @@ class Painter;
class PrerenderedTexture : private util::noncopyable {
public:
PrerenderedTexture(const RasterizedProperties &properties);
PrerenderedTexture(const RasterBucket &properties);
~PrerenderedTexture();
void bindTexture();
@@ -23,7 +24,7 @@ public:
void blur(Painter& painter, uint16_t passes);
public:
const RasterizedProperties properties;
const RasterBucket properties;
private:
GLint previous_fbo = 0;

2
include/mbgl/style/rasterize_properties.hpp
View File

@@ -15,7 +15,7 @@ public:
class RasterizeProperties {
public:
// Function<bool> enabled = ConstantFunction<bool>(false); // going to need to delete this? or keep ?
Function<bool> enabled = ConstantFunction<bool>(false); // maybe delete?
Function<float> buffer = ConstantFunction<float>(1.0f / 32.0f);
Function<float> size = ConstantFunction<float>(256);
Function<float> blur = ConstantFunction<float>(0);

1
include/mbgl/style/style_bucket.hpp
View File

@@ -82,6 +82,7 @@ public:
class StyleBucketRaster {
public:
bool prerendered = false;
uint16_t raster_size = 256;
float blur = 0.0f;
float buffer = 0.03125f;

5
include/mbgl/style/style_layer.hpp
View File

@@ -20,8 +20,7 @@ class StyleLayerGroup;
class StyleLayer {
public:
StyleLayer(const std::string &id, std::map<ClassID, ClassProperties> &&styles,
std::unique_ptr<const RasterizeProperties> &&rasterize);
StyleLayer(const std::string &id, std::map<ClassID, ClassProperties> &&styles);
template <typename T> const T &getProperties() {
if (properties.is<T>()) {
@@ -83,7 +82,7 @@ public:
// Rasterization properties are used for prerendering the tile to a bitmap,
// which is then used as a raster image instead of rendering this layer
// directly in every frame.
const std::unique_ptr<const RasterizeProperties> rasterize;
// const std::unique_ptr<const RasterizeProperties> rasterize;
// Child layer array (if this layer has child layers).
std::shared_ptr<StyleLayerGroup> layers;

68
src/map/map.cpp
View File

@@ -649,29 +649,63 @@ void Map::renderLayers(std::shared_ptr<StyleLayerGroup> group) {
}
void Map::renderLayer(std::shared_ptr<StyleLayer> layer_desc, RenderPass pass) {
if (layer_desc->layers && layer_desc->type != StyleLayerType::Raster) {
// This is a layer group. We render them during our translucent render pass.
if (pass == Translucent) {
const CompositeProperties &properties = layer_desc->getProperties<CompositeProperties>();
if (properties.isVisible()) {
gl::group group(std::string("group: ") + layer_desc->id);
if (layer_desc->layers) {
if (layer_desc->type == StyleLayerType::Raster) {
const RasterProperties &properties = layer_desc->getProperties<RasterProperties>();
// const RasterizedProperties rasterize = layer_desc->getProperties<RasterProperties>();
//
// auto prerendered = std::make_unique<PrerenderedTexture>(rasterize);
// prerendered->bindFramebuffer();
//
// painter.preparePrerender(*prerendered);
//
// const int buffer = rasterize.buffer * 4096.0f;
// const mat4 vtxMatrix = [&]{
// mat4 vtxMatrix;
// matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
// matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
// return vtxMatrix;
// }();
//
// painter.setOpaque();
// renderLayers(layer_desc->layers);
// painter.setTranslucent();
// renderLayers(layer_desc->layers);
//
// if (rasterize.blur > 0) {
// prerendered->blur(painter, rasterize.blur);
// }
//
// prerendered->unbindFramebuffer();
// painter.finishPrerender(*prerendered);
//
// painter.renderPrerenderedTexture(*prerendered, rasterize);
} else {
// This is a layer group. We render them during our translucent render pass.
if (pass == Translucent) {
const CompositeProperties &properties = layer_desc->getProperties<CompositeProperties>();
if (properties.isVisible()) {
gl::group group(std::string("group: ") + layer_desc->id);
if (debug::renderTree) {
std::cout << std::string(indent++ * 4, ' ') << "+ " << layer_desc->id
<< " (Composite) {" << std::endl;
}
if (debug::renderTree) {
std::cout << std::string(indent++ * 4, ' ') << "+ " << layer_desc->id
<< " (Composite) {" << std::endl;
}
painter.pushFramebuffer();
painter.pushFramebuffer();
renderLayers(layer_desc->layers);
renderLayers(layer_desc->layers);
GLuint texture = painter.popFramebuffer();
GLuint texture = painter.popFramebuffer();
// Render the previous texture onto the screen.
painter.drawComposite(texture, properties);
// Render the previous texture onto the screen.
painter.drawComposite(texture, properties);
if (debug::renderTree) {
std::cout << std::string(--indent * 4, ' ') << "}" << std::endl;
if (debug::renderTree) {
std::cout << std::string(--indent * 4, ' ') << "}" << std::endl;
}
}
}
}

14
src/map/tile_parser.cpp
View File

@@ -82,6 +82,7 @@ void TileParser::parseStyleLayers(std::shared_ptr<StyleLayerGroup> group) {
// contain any data that falls into this bucket.
tile.buckets[layer_desc->bucket->name] = std::move(bucket);
}
// TODO? here, no bucket is being created for prerender raster layers (though buckets are being created for its sublayers)...
}
} else {
fprintf(stderr, "[WARNING] layer '%s' does not have child layers or buckets\n", layer_desc->id.c_str());
@@ -100,8 +101,8 @@ std::unique_ptr<Bucket> TileParser::createBucket(std::shared_ptr<StyleBucket> bu
if (tile.id.z >= std::ceil(bucket_desc->max_zoom)) return nullptr;
auto layer_it = vector_data.layers.find(bucket_desc->source_layer);
const VectorTileLayer &layer = layer_it->second;
if (layer_it != vector_data.layers.end()) {
const VectorTileLayer &layer = layer_it->second;
if (bucket_desc->render.is<StyleBucketFill>()) {
return createFillBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketFill>());
} else if (bucket_desc->render.is<StyleBucketLine>()) {
@@ -113,6 +114,9 @@ std::unique_ptr<Bucket> TileParser::createBucket(std::shared_ptr<StyleBucket> bu
} else {
fprintf(stderr, "[WARNING] unknown bucket render type for layer '%s' (source layer '%s')\n", bucket_desc->name.c_str(), bucket_desc->source_layer.c_str());
}
} else if (bucket_desc->render.is<StyleBucketRaster>()) {
// Assume this is a prerendered raster layer -- TODO more thorough checking here??
return createRasterBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketRaster>());
} else {
// The layer specified in the bucket does not exist. Do nothing.
if (debug::tileParseWarnings) {
@@ -148,6 +152,12 @@ std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer& laye
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createRasterBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketRaster &raster) {
std::unique_ptr<RasterBucket> bucket = std::make_unique<RasterBucket>(raster);
// addBucketFeatures(bucket, layer, filter);
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line) {
std::unique_ptr<LineBucket> bucket = std::make_unique<LineBucket>(tile.lineVertexBuffer, tile.triangleElementsBuffer, tile.pointElementsBuffer, line);
addBucketGeometries(bucket, layer, filter);
@@ -158,4 +168,4 @@ std::unique_ptr<Bucket> TileParser::createSymbolBucket(const VectorTileLayer& la
std::unique_ptr<SymbolBucket> bucket = std::make_unique<SymbolBucket>(symbol, collision);
bucket->addFeatures(layer, filter, tile.id, *spriteAtlas, *sprite, *glyphAtlas, *glyphStore);
return obsolete() ? nullptr : std::move(bucket);
}
}

52
src/renderer/painter_fill.cpp
View File

@@ -150,6 +150,54 @@ void Painter::renderFill(FillBucket& bucket, std::shared_ptr<StyleLayer> layer_d
// Abort early.
if (!bucket.hasData()) return;
const FillProperties &properties = layer_desc->getProperties<FillProperties>();
const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor);
renderFill(bucket, properties, id, vtxMatrix);
// if (layer_desc->rasterize && layer_desc->rasterize->isEnabled(id.z)) {
// if (pass == Translucent) {
// const RasterizedProperties rasterize = layer_desc->rasterize->get(id.z);
// // Buffer value around the 0..4096 extent that will be drawn into the 256x256 pixel
// // texture. We later scale the texture so that the actual bounds will align with this
// // tile's bounds. The reason we do this is so that the
// if (!bucket.prerendered) {
// bucket.prerendered = std::make_unique<PrerenderedTexture>(rasterize);
// bucket.prerendered->bindFramebuffer();
//
// preparePrerender(*bucket.prerendered);
//
// const FillProperties modifiedProperties = [&]{
// FillProperties modifiedProperties = properties;
// modifiedProperties.opacity = 1;
// return modifiedProperties;
// }();
//
// // When drawing the fill, we want to draw a buffer around too, so we
// // essentially downscale everyting, and then upscale it later when rendering.
// const int buffer = rasterize.buffer * 4096.0f;
// const mat4 vtxMatrix = [&]{
// mat4 vtxMatrix;
// matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
// matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
// return vtxMatrix;
// }();
//
// setOpaque();
// renderFill(bucket, modifiedProperties, id, vtxMatrix);
//
// setTranslucent();
// renderFill(bucket, modifiedProperties, id, vtxMatrix);
//
// if (rasterize.blur > 0) {
// bucket.prerendered->blur(*this, rasterize.blur);
// }
//
// // RESET STATE
// bucket.prerendered->unbindFramebuffer();
// finishPrerender(*bucket.prerendered);
// }
//
// renderPrerenderedTexture(*bucket.prerendered, properties);
// }
// } else {
const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor);
renderFill(bucket, properties, id, vtxMatrix);
// }
}

5
src/renderer/painter_prerender.cpp
View File

@@ -38,11 +38,12 @@ void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Proper
glActiveTexture(GL_TEXTURE0);
rasterShader->setImage(0);
rasterShader->setBuffer(buffer);
rasterShader->setOpacity(properties.opacity);
rasterShader->setOpacity(1);
// rasterShader->setOpacity(properties.opacity); // TODO find a place to pass opacity and change this back
texture.bindTexture();
coveringRasterArray.bind(*rasterShader, tileStencilBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
}
template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const FillProperties &);
template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const RasterProperties &);
template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const RasterizedProperties &);

3
src/renderer/prerendered_texture.cpp
View File

@@ -40,7 +40,8 @@ void PrerenderedTexture::bindFramebuffer() {
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); // TODO change this back once i have non-zero size readings
glBindTexture(GL_TEXTURE_2D, 0);
}

6
src/renderer/raster_bucket.cpp
View File

@@ -7,6 +7,12 @@ RasterBucket::RasterBucket(const std::shared_ptr<Texturepool> &texturepool)
: raster(texturepool) {
}
//RasterBucket::RasterBucket(const StyleBucketRaster &properties)
// : properties(properties) {
//}
// TODO ^ Somehow overload with another constructor for prerender?
void RasterBucket::render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id) {
painter.renderRaster(*this, layer_desc, id);
}

5
src/style/style_layer.cpp
View File

@@ -5,9 +5,8 @@
namespace mbgl {
StyleLayer::StyleLayer(const std::string &id, std::map<ClassID, ClassProperties> &&styles,
std::unique_ptr<const RasterizeProperties> &&rasterize)
: id(id), styles(std::move(styles)), rasterize(std::move(rasterize)) {}
StyleLayer::StyleLayer(const std::string &id, std::map<ClassID, ClassProperties> &&styles)
: id(id), styles(std::move(styles)) {}
bool StyleLayer::isBackground() const {
return type == StyleLayerType::Background;

31
src/style/style_parser.cpp
View File

@@ -493,10 +493,14 @@ std::shared_ptr<StyleLayer> StyleParser::createLayer(JSVal value) {
parseStyles(value, styles);
// Parse Rasterization options, as they can't be inherited anyway.
std::unique_ptr<const RasterizeProperties> rasterize;
// std::unique_ptr<const RasterizeProperties> rasterize;
// if (value.HasMember("rasterize")) {
// rasterize = parseRasterize(replaceConstant(value["rasterize"]));
// }
std::shared_ptr<StyleLayer> layer = std::make_shared<StyleLayer>(
layer_id, std::move(styles), std::move(rasterize));
layer_id, std::move(styles));
// layer_id, std::move(styles), std::move(rasterize));
if (value.HasMember("layers")) {
if (value.HasMember("type")) {
@@ -527,12 +531,6 @@ void StyleParser::parseLayer(std::pair<JSVal, std::shared_ptr<StyleLayer>> &pair
JSVal value = pair.first;
std::shared_ptr<StyleLayer> &layer = pair.second;
if (layer->bucket) {
// if (layer->bucket || layer->layers) {
// Skip parsing this again. We already have a valid layer definition.
return;
}
if (value.HasMember("type")) {
JSVal type = value["type"];
if (!type.IsString()) {
@@ -542,6 +540,11 @@ void StyleParser::parseLayer(std::pair<JSVal, std::shared_ptr<StyleLayer>> &pair
}
}
if (layer->bucket || (layer->layers && layer->type != StyleLayerType::Raster)) {
// Skip parsing this again. We already have a valid layer definition.
return;
}
// Make sure we have not previously attempted to parse this layer.
if (std::find(stack.begin(), stack.end(), layer.get()) != stack.end()) {
fprintf(stderr, "[WARNING] layer reference of '%s' is circular\n", layer->id.c_str());
@@ -917,19 +920,19 @@ void StyleParser::parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer) {
parseRenderProperty(value, render.text.ignore_placement, "text-ignore-placement");
parseRenderProperty(value, render.text.optional, "text-optional");
} break;
case StyleLayerType::Raster: {
StyleBucketRaster &render = bucket.render.get<StyleBucketRaster>();
auto rasterize = std::make_unique<RasterizedProperties>();
// auto rasterize = std::make_unique<RasterizedProperties>();
parseRenderProperty(value, render.raster_size, "raster-size");
parseRenderProperty(value, render.blur, "raster-blur");
parseRenderProperty(value, render.buffer, "raster-buffer");
// return rasterize;
if (layer->layers) {
render.prerendered = true;
}
} break;
default:
// There are no render properties for these layer types.
break;