From df925fe0e5429085f0f443f4be1326c0616f6acc Mon Sep 17 00:00:00 2001 From: Lauren Budorick Date: Mon, 4 Aug 2014 17:24:22 -0700 Subject: nonworking prerendering attempts --- include/mbgl/map/map.hpp | 4 +- include/mbgl/renderer/painter.hpp | 3 + include/mbgl/style/rasterize_properties.hpp | 8 +-- include/mbgl/style/style_bucket.hpp | 3 + src/map/map.cpp | 20 ++++++- src/map/tile_parser.cpp | 7 ++- src/map/vector_tile_data.cpp | 3 + src/renderer/painter.cpp | 2 +- src/renderer/painter_fill.cpp | 53 +----------------- src/renderer/painter_prerender.cpp | 3 +- src/renderer/painter_raster.cpp | 87 ++++++++++++++++++++++++++++- src/style/style_parser.cpp | 40 +++++++------ 12 files changed, 149 insertions(+), 84 deletions(-) diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp index be01b456cc..c54b40d752 100644 --- a/include/mbgl/map/map.hpp +++ b/include/mbgl/map/map.hpp @@ -45,6 +45,8 @@ public: // Triggers a lazy rerender: only performs a render when the map is not clean. void rerender(); + void renderLayers(std::shared_ptr group); + // Forces a map update: always triggers a rerender. void update(); @@ -139,6 +141,7 @@ private: void updateTiles(); void updateRenderState(); + void updateRenderState(const mat4 vtxMatrix); size_t countLayers(const std::vector& layers); @@ -150,7 +153,6 @@ private: // Unconditionally performs a render with the current map state. void render(); - void renderLayers(std::shared_ptr group); void renderLayer(std::shared_ptr layer_desc, RenderPass pass); private: diff --git a/include/mbgl/renderer/painter.hpp b/include/mbgl/renderer/painter.hpp index b4023de167..82b71b6cb0 100644 --- a/include/mbgl/renderer/painter.hpp +++ b/include/mbgl/renderer/painter.hpp @@ -84,12 +84,15 @@ public: void renderLine(LineBucket& bucket, std::shared_ptr layer_desc, const Tile::ID& id); void renderSymbol(SymbolBucket& bucket, std::shared_ptr layer_desc, const Tile::ID& id); void renderRaster(RasterBucket& bucket, std::shared_ptr layer_desc, const Tile::ID& id); + void renderRaster(GLuint texture, const RasterizeProperties &properties); // do I want to save that? void preparePrerender(PrerenderedTexture &texture); void finishPrerender(PrerenderedTexture &texture); template void renderPrerenderedTexture(PrerenderedTexture &texture, const Properties &properties); + + void createPrerendered(RasterBucket& bucket, std::shared_ptr layer_desc, const Tile::ID& id, const RasterizeProperties& properties); void resize(); diff --git a/include/mbgl/style/rasterize_properties.hpp b/include/mbgl/style/rasterize_properties.hpp index aea90dfbdd..e1e56d6ec9 100644 --- a/include/mbgl/style/rasterize_properties.hpp +++ b/include/mbgl/style/rasterize_properties.hpp @@ -15,14 +15,14 @@ public: class RasterizeProperties { public: - Function enabled = ConstantFunction(false); +// Function enabled = ConstantFunction(false); // going to need to delete this? or keep ? Function buffer = ConstantFunction(1.0f / 32.0f); Function size = ConstantFunction(256); Function blur = ConstantFunction(0); - inline bool isEnabled(const int8_t z) const { - return util::apply_visitor(FunctionEvaluator(z), enabled); - } +// inline bool isEnabled(const int8_t z) const { +// return util::apply_visitor(FunctionEvaluator(z), enabled); +// } inline RasterizedProperties get(const int8_t z) const { RasterizedProperties properties; diff --git a/include/mbgl/style/style_bucket.hpp b/include/mbgl/style/style_bucket.hpp index 530e0c1259..25786720b1 100644 --- a/include/mbgl/style/style_bucket.hpp +++ b/include/mbgl/style/style_bucket.hpp @@ -82,6 +82,9 @@ public: class StyleBucketRaster { public: + uint16_t raster_size = 256; + float blur = 0.0f; + float buffer = 0.03125f; }; typedef util::variant ids; + + for (const std::shared_ptr &source : getActiveSources()) { + ids.splice_after(ids.before_begin(), source->source->getIDs()); + source->source->updateMatrices(vtxMatrix, state); + } + + const std::map clipIDs = computeClipIDs(ids); + + for (const std::shared_ptr &source : getActiveSources()) { + source->source->updateClipIDs(clipIDs); + } +} + void Map::prepare() { view.make_active(); @@ -634,8 +649,8 @@ void Map::renderLayers(std::shared_ptr group) { } void Map::renderLayer(std::shared_ptr layer_desc, RenderPass pass) { - if (layer_desc->layers) { - // This is a layer group. We render them during our translucent render 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(); if (properties.isVisible()) { @@ -716,7 +731,6 @@ void Map::renderLayer(std::shared_ptr layer_desc, RenderPass pass) { std::cout << std::string(indent * 4, ' ') << "- " << layer_desc->id << " (" << layer_desc->type << ")" << std::endl; } - style_source.source->render(painter, layer_desc); } } diff --git a/src/map/tile_parser.cpp b/src/map/tile_parser.cpp index 97b071a163..e32a6068fc 100644 --- a/src/map/tile_parser.cpp +++ b/src/map/tile_parser.cpp @@ -66,10 +66,11 @@ void TileParser::parseStyleLayers(std::shared_ptr group) { if (layer_desc->isBackground()) { // background is a special, fake bucket continue; - } else if (layer_desc->layers) { + } else if (layer_desc->layers && layer_desc->type != StyleLayerType::Raster) { // This is a layer group. parseStyleLayers(layer_desc->layers); - } else if (layer_desc->bucket) { + } + if (layer_desc->bucket) { // This is a singular layer. Check if this bucket already exists. If not, // parse this bucket. auto bucket_it = tile.buckets.find(layer_desc->bucket->name); @@ -157,4 +158,4 @@ std::unique_ptr TileParser::createSymbolBucket(const VectorTileLayer& la std::unique_ptr bucket = std::make_unique(symbol, collision); bucket->addFeatures(layer, filter, tile.id, *spriteAtlas, *sprite, *glyphAtlas, *glyphStore); return obsolete() ? nullptr : std::move(bucket); -} +} \ No newline at end of file diff --git a/src/map/vector_tile_data.cpp b/src/map/vector_tile_data.cpp index 2bf339b65f..f4a841b3f5 100644 --- a/src/map/vector_tile_data.cpp +++ b/src/map/vector_tile_data.cpp @@ -58,6 +58,9 @@ void VectorTileData::render(Painter &painter, std::shared_ptr layer_ if (databucket_it != buckets.end()) { assert(databucket_it->second); databucket_it->second->render(painter, layer_desc, id); + } else if (layer_desc->type == StyleLayerType::Raster && layer_desc->layers) { +// HELP + } } } diff --git a/src/renderer/painter.cpp b/src/renderer/painter.cpp index e6977171a4..6cdaf760ae 100644 --- a/src/renderer/painter.cpp +++ b/src/renderer/painter.cpp @@ -173,7 +173,7 @@ void Painter::prepareTile(const Tile& tile) { void Painter::renderTileLayer(const Tile& tile, std::shared_ptr layer_desc) { assert(tile.data); - if (tile.data->hasData(layer_desc)) { + if (tile.data->hasData(layer_desc) || layer_desc->type == StyleLayerType::Raster) { gl::group group(util::sprintf<32>("render %d/%d/%d\n", tile.id.z, tile.id.y, tile.id.z)); prepareTile(tile); tile.data->render(*this, layer_desc); diff --git a/src/renderer/painter_fill.cpp b/src/renderer/painter_fill.cpp index 29d77e05d9..d0bfcad83d 100644 --- a/src/renderer/painter_fill.cpp +++ b/src/renderer/painter_fill.cpp @@ -149,56 +149,7 @@ void Painter::renderFill(FillBucket& bucket, const FillProperties& properties, c void Painter::renderFill(FillBucket& bucket, std::shared_ptr layer_desc, const Tile::ID& id) { // Abort early. if (!bucket.hasData()) return; - const FillProperties &properties = layer_desc->getProperties(); - - 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(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); - } + const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor); + renderFill(bucket, properties, id, vtxMatrix); } diff --git a/src/renderer/painter_prerender.cpp b/src/renderer/painter_prerender.cpp index 5d61b95535..ad6b56b3cc 100644 --- a/src/renderer/painter_prerender.cpp +++ b/src/renderer/painter_prerender.cpp @@ -27,7 +27,7 @@ void Painter::finishPrerender(PrerenderedTexture &/*texture*/) { template void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Properties &properties) { const int buffer = texture.properties.buffer * 4096.0f; - + // draw the texture on a quad useProgram(rasterShader->program); rasterShader->setMatrix(matrix); @@ -45,3 +45,4 @@ void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Proper } template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const FillProperties &); +template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const RasterProperties &); diff --git a/src/renderer/painter_raster.cpp b/src/renderer/painter_raster.cpp index ef2eab2a6c..ea0688ced8 100644 --- a/src/renderer/painter_raster.cpp +++ b/src/renderer/painter_raster.cpp @@ -1,14 +1,92 @@ #include #include #include +#include #include using namespace mbgl; -void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr /*layer_desc*/, const Tile::ID& /*id*/) { +void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr layer_desc, const Tile::ID& id) { if (pass == Translucent) return; + + const RasterProperties &properties = layer_desc->getProperties(); + + if (layer_desc->rasterize) { + auto rasterize = std::make_unique(); + + if (pass == Translucent) { + // 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 + const RasterizedProperties rasterize = layer_desc->rasterize->get(id.z); + if (!bucket.prerendered) { + + bucket.prerendered = std::make_unique(rasterize); + bucket.prerendered->bindFramebuffer(); + + preparePrerender(*bucket.prerendered); + + const RasterProperties modifiedProperties = [&]{ + RasterProperties modifiedProperties = properties; + // modifiedProperties.opacity = 1; // figure out why this was here + 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); + + + + // resize(); + + // changeMatrix(); + + // map.updateRenderState(); + + // drawClippingMasks(getActiveSources()); + + // Actually render the layers + map.renderLayers(layer_desc->layers); + + // Finalize the rendering, e.g. by calling debug render calls per tile. + // This guarantees that we have at least one function per tile called. + // When only rendering layers via the stylesheet, it's possible that we don't + // ever visit a tile during rendering. + // for (const std::shared_ptr &source : getActiveSources()) { + // source->source->finishRender(painter); + // } + // + // // Schedule another rerender when we definitely need a next frame. + // if (transform.needsTransition() || style->hasTransitions()) { + // update(); + // } + + glFlush(); - // const RasterProperties &properties = layer_desc->getProperties(); + if (rasterize.blur > 0) { + bucket.prerendered->blur(*this, rasterize.blur); + } + + // RESET STATE + bucket.prerendered->unbindFramebuffer(); + finishPrerender(*bucket.prerendered); + } + + renderPrerenderedTexture(*bucket.prerendered, properties); + + } + + } depthMask(false); @@ -22,4 +100,9 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr /*l bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray); depthMask(true); + +} +void Painter::renderRaster(GLuint texture, const RasterizeProperties &properties){ +// TODO do I need this? +// map.renderLayers(layer_desc->layers); } diff --git a/src/style/style_parser.cpp b/src/style/style_parser.cpp index f72b47d1f5..3ca8742965 100644 --- a/src/style/style_parser.cpp +++ b/src/style/style_parser.cpp @@ -344,7 +344,7 @@ bool StyleParser::parseOptionalProperty(const char *property_name, PropertyKey k template bool StyleParser::parseOptionalProperty(const char *property_name, T &target, JSVal value) { if (!value.HasMember(property_name)) { - return false; + return false; } else { return setProperty(replaceConstant(value[property_name]), property_name, target); } @@ -494,14 +494,16 @@ std::shared_ptr StyleParser::createLayer(JSVal value) { // Parse Rasterization options, as they can't be inherited anyway. std::unique_ptr rasterize; - if (value.HasMember("rasterize")) { - rasterize = parseRasterize(replaceConstant(value["rasterize"])); - } std::shared_ptr layer = std::make_shared( layer_id, std::move(styles), std::move(rasterize)); if (value.HasMember("layers")) { + if (value.HasMember("type")) { + JSVal type = value["type"]; + if (std::string { type.GetString(), type.GetStringLength() } == "raster") { + } + } layer->layers = createLayers(value["layers"]); } @@ -525,7 +527,8 @@ void StyleParser::parseLayer(std::pair> &pair JSVal value = pair.first; std::shared_ptr &layer = pair.second; - if (layer->bucket || layer->layers) { + if (layer->bucket) { +// if (layer->bucket || layer->layers) { // Skip parsing this again. We already have a valid layer definition. return; } @@ -637,6 +640,7 @@ void StyleParser::parseStyle(JSVal value, ClassProperties &klass) { parseOptionalProperty>("composite-opacity", Key::CompositeOpacity, klass, value); parseOptionalProperty("transition-composite-opacity", Key::CompositeOpacity, klass, value); +// TODO edit these: parseOptionalProperty>("raster-opacity", Key::RasterOpacity, klass, value); parseOptionalProperty("transition-raster-opacity", Key::RasterOpacity, klass, value); parseOptionalProperty>("raster-spin", Key::RasterSpin, klass, value); @@ -655,19 +659,6 @@ void StyleParser::parseStyle(JSVal value, ClassProperties &klass) { parseOptionalProperty>("background-color", Key::BackgroundColor, klass, value); } -std::unique_ptr StyleParser::parseRasterize(JSVal value) { - auto rasterize = std::make_unique(); - - if (value.IsObject()) { - parseOptionalProperty("enabled", rasterize->enabled, value); - parseOptionalProperty("buffer", rasterize->buffer, value); - parseOptionalProperty("size", rasterize->size, value); - parseOptionalProperty("blur", rasterize->blur, value); - } - - return rasterize; -} - void StyleParser::parseReference(JSVal value, std::shared_ptr &layer) { if (!value.IsString()) { fprintf(stderr, "[WARNING] layer ref of '%s' must be a string\n", layer->id.c_str()); @@ -926,6 +917,19 @@ void StyleParser::parseRender(JSVal value, std::shared_ptr &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(); + + auto rasterize = std::make_unique(); + parseRenderProperty(value, render.raster_size, "raster-size"); + parseRenderProperty(value, render.blur, "raster-blur"); + parseRenderProperty(value, render.buffer, "raster-buffer"); + +// return rasterize; + + } break; + default: // There are no render properties for these layer types. break; -- cgit v1.2.1