diff --git a/garnet/bin/ui/root_presenter/presentation.cc b/garnet/bin/ui/root_presenter/presentation.cc
index cfc89ea848f935cdd9a223af04bf89aef5d2df8f..191808c6e2cfe104c59111cdfff6606addc6396f 100644
--- a/garnet/bin/ui/root_presenter/presentation.cc
+++ b/garnet/bin/ui/root_presenter/presentation.cc
@@ -85,7 +85,7 @@ Presentation::Presentation(
// only one of them to be active at a time. This logic is implicit in
// EngineRenderer, since no shadow-mode supports both directional and point
// lights (either one or the other). When directional light support is added
- // to PaperRenderer2, the code here will result in over-brightening, and will
+ // to PaperRenderer, the code here will result in over-brightening, and will
// need to be adjusted at that time.
scene_.AddLight(ambient_light_);
scene_.AddLight(directional_light_);
diff --git a/garnet/bin/ui/tests/performance/scenic_processing_helpers.go b/garnet/bin/ui/tests/performance/scenic_processing_helpers.go
index f9a9a7cf63d83cb8595746c0af3a15eeabd9ba11..38999e09ece1f573e0c566b27185d6d8b45d856c 100644
--- a/garnet/bin/ui/tests/performance/scenic_processing_helpers.go
+++ b/garnet/bin/ui/tests/performance/scenic_processing_helpers.go
@@ -63,8 +63,9 @@ func reportAverageEventTimes(model benchmarking.Model, testSuite string, testRes
Label string
}
- // TODO(SCN-1268): The following events are based on PaperRenderer, as we transition
- // to PaperRenderer2 is rolled out they need to be updated to reflect this.
+ // TODO(SCN-1268): The following events are based on the old/deleted
+ // PaperRenderer; now that we are transitioning to the new version (formerly
+ // known as PaperRenderer2) they need to be updated to reflect this.
// TODO(PT-102): Events that appear to happen simultaneously are lumped together in
// the same trace event as primary and secondary events. Because of this some
diff --git a/garnet/examples/escher/waterfall/scenes/demo_scene.cc b/garnet/examples/escher/waterfall/scenes/demo_scene.cc
index 11ee9127fcbe96595832c08ef6ce8e4f0f28e2d8..6549cbc61959304356a87b92bdf30779d9597386 100644
--- a/garnet/examples/escher/waterfall/scenes/demo_scene.cc
+++ b/garnet/examples/escher/waterfall/scenes/demo_scene.cc
@@ -39,7 +39,7 @@ DemoScene::~DemoScene() {}
escher::Model* DemoScene::Update(const escher::Stopwatch& stopwatch,
uint64_t frame_count, escher::Stage* stage,
- escher::PaperRenderer2* renderer) {
+ escher::PaperRenderer* renderer) {
stage->set_clear_color(vec3(0.f, 0.f, 0.f));
float current_time_sec = stopwatch.GetElapsedSeconds();
float t = sin(current_time_sec);
diff --git a/garnet/examples/escher/waterfall/scenes/demo_scene.h b/garnet/examples/escher/waterfall/scenes/demo_scene.h
index 81e1c86ecd1eb83d4707a53ee7656480a426269b..220dfc6352c45556c2a2733abd51ba08d3366b03 100644
--- a/garnet/examples/escher/waterfall/scenes/demo_scene.h
+++ b/garnet/examples/escher/waterfall/scenes/demo_scene.h
@@ -17,7 +17,7 @@ class DemoScene : public Scene {
escher::Model* Update(const escher::Stopwatch& stopwatch,
uint64_t frame_count, escher::Stage* stage,
- escher::PaperRenderer2* renderer) override;
+ escher::PaperRenderer* renderer) override;
private:
std::unique_ptr<escher::Model> model_;
diff --git a/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.cc b/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.cc
index fa49001e84b519aa4fad6707509592c9e823d40d..9749316ea2ac4fbeeaa2ea6eb6957cf63dfdc493 100644
--- a/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.cc
+++ b/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.cc
@@ -40,7 +40,7 @@ void PaperDemoScene1::Init(escher::Stage* stage) {
escher::Model* PaperDemoScene1::Update(const escher::Stopwatch& stopwatch,
uint64_t frame_count,
escher::Stage* stage,
- escher::PaperRenderer2* renderer) {
+ escher::PaperRenderer* renderer) {
FXL_DCHECK(false) << "Use PaperScene* version instead.";
return nullptr;
}
@@ -100,7 +100,7 @@ PaperDemoScene1::~PaperDemoScene1() {}
void PaperDemoScene1::Update(const escher::Stopwatch& stopwatch,
uint64_t frame_count, escher::PaperScene* scene,
- escher::PaperRenderer2* renderer) {
+ escher::PaperRenderer* renderer) {
const float current_time_sec = stopwatch.GetElapsedSeconds();
const float screen_width = scene->bounding_box.width();
const float screen_height = scene->bounding_box.height();
diff --git a/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.h b/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.h
index e5f02b615af586b3e2c89fd000eeb8fa813eea7a..ddc196e5ad34c334d57c7d37c3a696ca8b642883 100644
--- a/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.h
+++ b/garnet/examples/escher/waterfall/scenes/paper_demo_scene1.h
@@ -24,12 +24,12 @@ class PaperDemoScene1 : public Scene {
// Illegal, use the PaperScene version instead.
escher::Model* Update(const escher::Stopwatch& stopwatch,
uint64_t frame_count, escher::Stage* stage,
- escher::PaperRenderer2* renderer) override;
+ escher::PaperRenderer* renderer) override;
void Init(escher::PaperScene* scene) override;
void Update(const escher::Stopwatch& stopwatch, uint64_t frame_count,
escher::PaperScene* scene,
- escher::PaperRenderer2* renderer) override;
+ escher::PaperRenderer* renderer) override;
private:
struct AnimatedState {
diff --git a/garnet/examples/escher/waterfall/scenes/scene.cc b/garnet/examples/escher/waterfall/scenes/scene.cc
index b059e13d09f9fdd9b6c501ebbae4bd06a137702c..f72a0edc3076da3a6948c7adcdc5703221fed429 100644
--- a/garnet/examples/escher/waterfall/scenes/scene.cc
+++ b/garnet/examples/escher/waterfall/scenes/scene.cc
@@ -24,7 +24,7 @@ void Scene::Init(escher::PaperScene* scene) {
void Scene::Update(const escher::Stopwatch& stopwatch, uint64_t frame_count,
escher::PaperScene* scene,
- escher::PaperRenderer2* renderer) {
+ escher::PaperRenderer* renderer) {
const auto& box = scene->bounding_box;
FXL_DCHECK(!box.is_empty());
diff --git a/garnet/examples/escher/waterfall/scenes/scene.h b/garnet/examples/escher/waterfall/scenes/scene.h
index 75ad5db69b37f578cdb126da165991f292aec1d4..3578ec3e4e027d30d9157ebf890c7ca08535c056 100644
--- a/garnet/examples/escher/waterfall/scenes/scene.h
+++ b/garnet/examples/escher/waterfall/scenes/scene.h
@@ -7,7 +7,7 @@
#include "garnet/examples/escher/common/demo.h"
#include "lib/escher/escher.h"
-#include "lib/escher/paper/paper_renderer2.h"
+#include "lib/escher/paper/paper_renderer.h"
namespace escher {
class Stopwatch;
@@ -41,13 +41,13 @@ class Scene {
// TODO(ES-155): deprecated, use PaperScene instead.
virtual escher::Model* Update(const escher::Stopwatch& stopwatch,
uint64_t frame_count, escher::Stage* stage,
- escher::PaperRenderer2* renderer = nullptr) = 0;
+ escher::PaperRenderer* renderer = nullptr) = 0;
// Default implementation delegates to the escher::Stage version.
// TODO(ES-155): make this pure virtual when Init(Stage*) dies.
virtual void Update(const escher::Stopwatch& stopwatch, uint64_t frame_count,
escher::PaperScene* scene,
- escher::PaperRenderer2* renderer);
+ escher::PaperRenderer* renderer);
// Optionally returns a |Model| for the specified time, frame_count, and
// screen dimensions. The returned Model only needs to be valid for the
diff --git a/garnet/examples/escher/waterfall/waterfall_demo.cc b/garnet/examples/escher/waterfall/waterfall_demo.cc
index 568a7621b09f65e523a46aa6b0dab1fbcfcaa8e0..c4ab7a932e9e2c4a2c6307cce4054620b8518d32 100644
--- a/garnet/examples/escher/waterfall/waterfall_demo.cc
+++ b/garnet/examples/escher/waterfall/waterfall_demo.cc
@@ -43,7 +43,7 @@ WaterfallDemo::WaterfallDemo(DemoHarness* harness, int argc, char** argv)
"shaders/paper/vert/main_shadow_volume_extrude.vert",
"shaders/paper/vert/vertex_attributes.vert"});
- renderer_ = escher::PaperRenderer2::New(GetEscherWeakPtr());
+ renderer_ = escher::PaperRenderer::New(GetEscherWeakPtr());
renderer_config_.shadow_type = PaperRendererShadowType::kShadowVolume;
renderer_config_.msaa_sample_count = 2;
@@ -224,7 +224,7 @@ static std::vector<escher::Camera> GenerateCameras(
} break;
// Stereo/Perspective from tilted viewpoint (from corner). This also
// demonstrates the ability to provide the view-projection matrix in a
- // buffer instead of having the PaperRenderer2 upload the vp-matrix itself.
+ // buffer instead of having the PaperRenderer upload the vp-matrix itself.
// This is typically used with a "pose buffer" in HMD applications.
// NOTE: the camera's transform must be fairly close to what will be read
// from the pose buffer, because the camera's position is used for z-sorting
@@ -252,7 +252,7 @@ static std::vector<escher::Camera> GenerateCameras(
// Both cameras use the same buffer, but index into it using a different
// eye index. NOTE: if you comment these lines out, there will be no
- // visible difference, because PaperRenderer2 will compute/upload the same
+ // visible difference, because PaperRenderer will compute/upload the same
// project * transform matrix. What would happen if you swap the kLeft
// and kRight?
left_camera.SetLatchedPoseBuffer(latched_pose_buffer,
diff --git a/garnet/examples/escher/waterfall/waterfall_demo.h b/garnet/examples/escher/waterfall/waterfall_demo.h
index e09860b265938cde41c076cf3d89c95dc3ea4baa..f004e4160004a168599c6d76d99b3f8d19f6dcb6 100644
--- a/garnet/examples/escher/waterfall/waterfall_demo.h
+++ b/garnet/examples/escher/waterfall/waterfall_demo.h
@@ -16,7 +16,7 @@
#include "lib/escher/escher.h"
#include "lib/escher/forward_declarations.h"
#include "lib/escher/fs/hack_filesystem.h"
-#include "lib/escher/paper/paper_renderer2.h"
+#include "lib/escher/paper/paper_renderer.h"
#include "lib/escher/util/stopwatch.h"
#include "src/lib/fxl/logging.h"
@@ -49,7 +49,7 @@ class WaterfallDemo : public Demo {
double ComputeFps();
escher::PaperRendererConfig renderer_config_;
- escher::PaperRenderer2Ptr renderer_;
+ escher::PaperRendererPtr renderer_;
escher::PaperScenePtr paper_scene_;
diff --git a/garnet/lib/ui/gfx/engine/engine_renderer.cc b/garnet/lib/ui/gfx/engine/engine_renderer.cc
index 6224802e21c6463fb6544f90ecf66cc1f0c0fe5c..7cab3f9cee4314a46bdbe52f39e35d19cc1c426a 100644
--- a/garnet/lib/ui/gfx/engine/engine_renderer.cc
+++ b/garnet/lib/ui/gfx/engine/engine_renderer.cc
@@ -40,7 +40,7 @@ EngineRenderer::EngineRenderer(escher::EscherWeakPtr weak_escher)
: escher_(std::move(weak_escher)),
// We use two depth buffers so that we can render multiple Layers without
// introducing a GPU stall.
- paper_renderer2_(escher::PaperRenderer2::New(
+ paper_renderer_(escher::PaperRenderer::New(
escher_, {.shadow_type = escher::PaperRendererShadowType::kNone,
.num_depth_buffers = 2})),
pose_buffer_latching_shader_(
@@ -62,10 +62,7 @@ void EngineRenderer::RenderLayers(const escher::FramePtr& frame,
// layer.
// TODO(SCN-1254): the efficiency of this GPU compositing could be
// improved on tile-based GPUs by generating each layer in a subpass and
- // compositing it into |output_image| in another subpass. This is currently
- // infeasible because we're rendering some layers with PaperRenderer and
- // others with PaperRenderer2; it will be much easier once PaperRenderer is
- // deleted.
+ // compositing it into |output_image| in another subpass.
std::vector<escher::Object> overlay_objects;
if (layers.size() > 1) {
overlay_objects.reserve(layers.size() - 1);
@@ -148,7 +145,7 @@ void EngineRenderer::DrawLayer(const escher::FramePtr& frame,
}
// TODO(SCN-1273): add pixel tests for various shadow modes (particularly
- // those implemented by PaperRenderer2).
+ // those implemented by PaperRenderer).
escher::PaperRendererShadowType shadow_type =
GetPaperRendererShadowType(layer->renderer()->shadow_technique());
switch (shadow_type) {
@@ -162,7 +159,7 @@ void EngineRenderer::DrawLayer(const escher::FramePtr& frame,
shadow_type = escher::PaperRendererShadowType::kNone;
}
- DrawLayerWithPaperRenderer2(frame, target_presentation_time, layer,
+ DrawLayerWithPaperRenderer(frame, target_presentation_time, layer,
shadow_type, output_image, overlay_model);
}
@@ -204,11 +201,11 @@ EngineRenderer::GenerateEscherCamerasForPaperRenderer(
}
}
-void EngineRenderer::DrawLayerWithPaperRenderer2(
+void EngineRenderer::DrawLayerWithPaperRenderer(
const escher::FramePtr& frame, zx_time_t target_presentation_time,
Layer* layer, const escher::PaperRendererShadowType shadow_type,
const escher::ImagePtr& output_image, const escher::Model& overlay_model) {
- TRACE_DURATION("gfx", "EngineRenderer::DrawLayerWithPaperRenderer2");
+ TRACE_DURATION("gfx", "EngineRenderer::DrawLayerWithPaperRenderer");
frame->command_buffer()->TransitionImageLayout(
output_image, vk::ImageLayout::eUndefined,
@@ -218,7 +215,7 @@ void EngineRenderer::DrawLayerWithPaperRenderer2(
auto camera = renderer->camera();
auto& scene = camera->scene();
- paper_renderer2_->SetConfig(escher::PaperRendererConfig{
+ paper_renderer_->SetConfig(escher::PaperRendererConfig{
.shadow_type = shadow_type,
.debug = renderer->enable_debugging(),
});
@@ -246,7 +243,7 @@ void EngineRenderer::DrawLayerWithPaperRenderer2(
});
}
- paper_renderer2_->BeginFrame(
+ paper_renderer_->BeginFrame(
frame, paper_scene,
GenerateEscherCamerasForPaperRenderer(
frame, camera, layer->GetViewingVolume(), target_presentation_time),
@@ -255,7 +252,7 @@ void EngineRenderer::DrawLayerWithPaperRenderer2(
// TODO(SCN-1256): scene-visitation should generate cameras, collect
// lights, etc.
escher::BatchGpuUploader gpu_uploader(escher_, frame->frame_number());
- EngineRendererVisitor visitor(paper_renderer2_.get(), &gpu_uploader);
+ EngineRendererVisitor visitor(paper_renderer_.get(), &gpu_uploader);
visitor.Visit(camera->scene().get());
gpu_uploader.Submit();
@@ -263,7 +260,7 @@ void EngineRenderer::DrawLayerWithPaperRenderer2(
// TODO(SCN-1270): support for multiple layers.
FXL_DCHECK(overlay_model.objects().empty());
- paper_renderer2_->EndFrame();
+ paper_renderer_->EndFrame();
}
escher::ImagePtr EngineRenderer::GetLayerFramebufferImage(uint32_t width,
diff --git a/garnet/lib/ui/gfx/engine/engine_renderer.h b/garnet/lib/ui/gfx/engine/engine_renderer.h
index 15acf40aaf46f093b48f5416a5a997c0c9aac957..dca9b5b178053264309b4dccaca991ca1e11dd49 100644
--- a/garnet/lib/ui/gfx/engine/engine_renderer.h
+++ b/garnet/lib/ui/gfx/engine/engine_renderer.h
@@ -6,7 +6,7 @@
#define GARNET_LIB_UI_GFX_ENGINE_ENGINE_RENDERER_H_
#include "lib/escher/escher.h"
-#include "lib/escher/paper/paper_renderer2.h"
+#include "lib/escher/paper/paper_renderer.h"
#include "lib/escher/paper/paper_renderer_config.h"
namespace scenic_impl {
@@ -15,8 +15,7 @@ namespace gfx {
class Layer;
class Camera;
-// EngineRenderer knows how to render Scenic layers using escher::PaperRenderer
-// and PaperRenderer2.
+// EngineRenderer knows how to render Scenic layers using escher::PaperRenderer.
class EngineRenderer {
public:
explicit EngineRenderer(escher::EscherWeakPtr weak_escher);
@@ -35,7 +34,7 @@ class EngineRenderer {
const escher::ImagePtr& output_image,
const escher::Model& overlay_model);
- void DrawLayerWithPaperRenderer2(const escher::FramePtr& frame,
+ void DrawLayerWithPaperRenderer(const escher::FramePtr& frame,
zx_time_t target_presentation_time,
Layer* layer,
escher::PaperRendererShadowType shadow_type,
@@ -49,7 +48,7 @@ class EngineRenderer {
escher::ViewingVolume viewing_volume, zx_time_t target_presentation_time);
const escher::EscherWeakPtr escher_;
- escher::PaperRenderer2Ptr paper_renderer2_;
+ escher::PaperRendererPtr paper_renderer_;
std::unique_ptr<escher::hmd::PoseBufferLatchingShader>
pose_buffer_latching_shader_;
};
diff --git a/garnet/lib/ui/gfx/engine/engine_renderer_visitor.cc b/garnet/lib/ui/gfx/engine/engine_renderer_visitor.cc
index eec285f098f9e071a8024bd9e5b2110ebb50deb7..637678bf0f2877ab919bfb64e20706d431d06a0c 100644
--- a/garnet/lib/ui/gfx/engine/engine_renderer_visitor.cc
+++ b/garnet/lib/ui/gfx/engine/engine_renderer_visitor.cc
@@ -4,7 +4,7 @@
#include "garnet/lib/ui/gfx/engine/engine_renderer_visitor.h"
-#include "lib/escher/paper/paper_renderer2.h"
+#include "lib/escher/paper/paper_renderer.h"
#include "src/lib/fxl/logging.h"
#include "garnet/lib/ui/gfx/resources/camera.h"
@@ -27,7 +27,7 @@ namespace scenic_impl {
namespace gfx {
EngineRendererVisitor::EngineRendererVisitor(
- escher::PaperRenderer2* renderer, escher::BatchGpuUploader* gpu_uploader)
+ escher::PaperRenderer* renderer, escher::BatchGpuUploader* gpu_uploader)
: renderer_(renderer), gpu_uploader_(gpu_uploader) {}
void EngineRendererVisitor::Visit(Memory* r) { FXL_CHECK(false); }
diff --git a/garnet/lib/ui/gfx/engine/engine_renderer_visitor.h b/garnet/lib/ui/gfx/engine/engine_renderer_visitor.h
index 5cf605add59a921674a713e7108b62654067272e..6099049522361de961c5897df5e7e61215f9ae49 100644
--- a/garnet/lib/ui/gfx/engine/engine_renderer_visitor.h
+++ b/garnet/lib/ui/gfx/engine/engine_renderer_visitor.h
@@ -15,18 +15,18 @@ namespace gfx {
class Node;
// EngineRendererVisitor is used by EngineRender to traverse a Scene, drawing it
-// via PaperRenderer2.
+// via PaperRenderer.
//
// EngineRendererVisitor's user is responsible for guaranteeing the lifetime of
// the |renderer| and |gpu_uploader|, as well as for invoking
-// PaperRenderer2::Begin/EndFrame() and BatchGpuUploader::Submit().
+// PaperRenderer::Begin/EndFrame() and BatchGpuUploader::Submit().
//
// This class is currently designed for one-time use, and is typically destroyed
// immediately afterward.
class EngineRendererVisitor : public ResourceVisitor {
public:
// Both the renderer and gpu_uploader must outlive this visitor.
- EngineRendererVisitor(escher::PaperRenderer2* renderer,
+ EngineRendererVisitor(escher::PaperRenderer* renderer,
escher::BatchGpuUploader* gpu_uploader);
// Main entry point.
@@ -73,7 +73,7 @@ class EngineRendererVisitor : public ResourceVisitor {
// Number of times that PaperRenderer::Draw*() methods were invoked.
size_t draw_call_count_ = 0;
- escher::PaperRenderer2* const renderer_;
+ escher::PaperRenderer* const renderer_;
escher::BatchGpuUploader* const gpu_uploader_;
};
diff --git a/garnet/lib/ui/gfx/resources/renderers/renderer.h b/garnet/lib/ui/gfx/resources/renderers/renderer.h
index 6ba3b951c5d81d9ef89341db45f7c4286c480bdb..bd0ffa885d579fe87927e548969e3471e1556fe2 100644
--- a/garnet/lib/ui/gfx/resources/renderers/renderer.h
+++ b/garnet/lib/ui/gfx/resources/renderers/renderer.h
@@ -28,10 +28,6 @@ class Renderer : public Resource {
public:
static const ResourceTypeInfo kTypeInfo;
- // Any swapchain that uses PaperRenderer must be a multiple of this many
- // pixels.
- static const uint32_t kRequiredSwapchainPixelMultiple;
-
Renderer(Session* session, ResourceId id);
~Renderer();
diff --git a/garnet/public/lib/escher/BUILD.gn b/garnet/public/lib/escher/BUILD.gn
index 5786c448700fbde0cc6cfdd28ed0a553815b150a..df36ebe7d5d57eade17647d8959f9b06f4e728c7 100644
--- a/garnet/public/lib/escher/BUILD.gn
+++ b/garnet/public/lib/escher/BUILD.gn
@@ -323,8 +323,8 @@ source_set("escher") {
"paper/paper_render_queue_context.cc",
"paper/paper_render_queue_context.h",
"paper/paper_render_queue_flags.h",
- "paper/paper_renderer2.cc",
- "paper/paper_renderer2.h",
+ "paper/paper_renderer.cc",
+ "paper/paper_renderer.h",
"paper/paper_renderer_config.h",
"paper/paper_scene.h",
"paper/paper_shader_structs.h",
diff --git a/garnet/public/lib/escher/forward_declarations.h b/garnet/public/lib/escher/forward_declarations.h
index 769ed7958d4fd12ba5ac013b8579d755f70cb4e7..ee5d98eede2183c723a2d976c5257e8e50f712e1 100644
--- a/garnet/public/lib/escher/forward_declarations.h
+++ b/garnet/public/lib/escher/forward_declarations.h
@@ -38,7 +38,6 @@ class Object;
// a PipelineLayout in impl/vk.
class PipelineLayout;
class PaperRenderer;
-class PaperRenderer2;
class PaperRenderQueue;
class PaperShapeCache;
class Resource;
diff --git a/garnet/public/lib/escher/paper/paper_draw_call_factory.h b/garnet/public/lib/escher/paper/paper_draw_call_factory.h
index 4f762e28b918aae4c86afcfbe85a6b0eda180ea5..065e6afd8d573c71a6c6f78434e057570ae995b2 100644
--- a/garnet/public/lib/escher/paper/paper_draw_call_factory.h
+++ b/garnet/public/lib/escher/paper/paper_draw_call_factory.h
@@ -18,7 +18,7 @@ struct RoundedRectSpec;
// |PaperDrawCallFactory| is responsible for generating |PaperDrawCalls| and
// enqueuing them on a |PaperRenderQueue|. It is hidden from clients of
-// |PaperRenderer2|, except for those who implement their own subclasses of
+// |PaperRenderer|, except for those who implement their own subclasses of
// |PaperDrawable|.
class PaperDrawCallFactory final {
public:
@@ -65,7 +65,7 @@ class PaperDrawCallFactory final {
};
private:
- friend class PaperRenderer2;
+ friend class PaperRenderer;
friend class PaperTester;
// Called by |PaperRenderer::SetConfig()|.
@@ -74,7 +74,7 @@ class PaperDrawCallFactory final {
// shader variations.
void SetConfig(const PaperRendererConfig& config);
- // Called by |PaperRenderer2::BeginFrame()|. Returns a vector of
+ // Called by |PaperRenderer::BeginFrame()|. Returns a vector of
// UniformBindings; PaperRenderer should bind these before directing the
// PaperRenderQueue to emit commands into a CommandBuffer.
//
@@ -83,7 +83,7 @@ class PaperDrawCallFactory final {
// |scene| and |camera| are used to generate the |UniformBindings| that are
// returned from this method, which contain camera and lighting parameters
// that are shared between multiple draw calls. This data is opaque to
- // |PaperRenderer2|; the precise format is specific to the configuration set
+ // |PaperRenderer|; the precise format is specific to the configuration set
// by |SetConfig()|.
//
// |transform_stack| is used to obtain the model-to-world matrix that is part
diff --git a/garnet/public/lib/escher/paper/paper_drawable.h b/garnet/public/lib/escher/paper/paper_drawable.h
index 71195f8a1cf9ba897fa8edc6642eee2d5f78809e..832160cbef94fb708f599aac710d366454facf0c 100644
--- a/garnet/public/lib/escher/paper/paper_drawable.h
+++ b/garnet/public/lib/escher/paper/paper_drawable.h
@@ -12,7 +12,7 @@
namespace escher {
// |PaperDrawable| is an abstract drawable object which can be rendered by
-// |PaperRenderer2|, or anything that passes the right args to |DrawInScene()|.
+// |PaperRenderer|, or anything that passes the right args to |DrawInScene()|.
//
// There are three levels of sophistication for users of |PaperDrawable|:
// 1) Use pre-existing subclasses of |PaperDrawable|.
diff --git a/garnet/public/lib/escher/paper/paper_drawable_flags.h b/garnet/public/lib/escher/paper/paper_drawable_flags.h
index c039662bd3076098bb3cf72f016f8fced3491826..ab4c3034780f731eec56ab71f77429b021435728 100644
--- a/garnet/public/lib/escher/paper/paper_drawable_flags.h
+++ b/garnet/public/lib/escher/paper/paper_drawable_flags.h
@@ -9,7 +9,7 @@
namespace escher {
-// These flags modify how |PaperDrawables| are rendered by |PaperRenderer2|.
+// These flags modify how |PaperDrawables| are rendered by |PaperRenderer|.
// They become part of the |PaperDrawCalls| generated from the |PaperDrawable|
// by |PaperDrawCallFactory|.
enum class PaperDrawableFlagBits : uint8_t {
diff --git a/garnet/public/lib/escher/paper/paper_legacy_drawable.h b/garnet/public/lib/escher/paper/paper_legacy_drawable.h
index 432d9ca28b0349b6e7e9efbeefd03eb61c415e66..fba9066d8177481e2e77f3e9df76b41f522e2379 100644
--- a/garnet/public/lib/escher/paper/paper_legacy_drawable.h
+++ b/garnet/public/lib/escher/paper/paper_legacy_drawable.h
@@ -10,8 +10,8 @@
namespace escher {
-// Wrapper which allows PaperRenderer2 to draw legacy escher::Objects.
-// NOTE: see PaperRenderer2::DrawLegacyObject(), which spares clients the
+// Wrapper which allows PaperRenderer to draw legacy escher::Objects.
+// NOTE: see PaperRenderer::DrawLegacyObject(), which spares clients the
// inconvenience of explicitly wrapping each object in a PaperLegacyDrawable.
class PaperLegacyDrawable : public PaperDrawable {
public:
diff --git a/garnet/public/lib/escher/paper/paper_readme.h b/garnet/public/lib/escher/paper/paper_readme.h
index 64ba6e807dc9ff71cb637c29fbd139a683fc3231..8b9978670306e0a4b5adb3e3ac9cd4ed1e17681a 100644
--- a/garnet/public/lib/escher/paper/paper_readme.h
+++ b/garnet/public/lib/escher/paper/paper_readme.h
@@ -18,21 +18,21 @@
namespace escher {
-// PaperRenderer2 knows how to render PaperDrawables to an output framebuffer.
+// PaperRenderer knows how to render PaperDrawables to an output framebuffer.
// Clients configure the renderer's behavior by setting a config object.
-class PaperRenderer2;
+class PaperRenderer;
struct PaperRendererConfig;
// PaperDrawable is a pure virtual interface with a single DrawInScene() method
-// that is invoked by PaperRenderer2::Draw(). Clients may use pre-existing
+// that is invoked by PaperRenderer::Draw(). Clients may use pre-existing
// implementations of PaperDrawable, or roll their own.
//
// Currently, PaperLegacyDrawable is the only standard implementation of
-// PaperDrawable. It allows PaperRenderer2 to draw "legacy" escher::Objects.
+// PaperDrawable. It allows PaperRenderer to draw "legacy" escher::Objects.
class PaperDrawable;
class PaperLegacyDrawable;
-// PaperTransformStack is a helper class to be used along with PaperRenderer2
+// PaperTransformStack is a helper class to be used along with PaperRenderer
// when rendering hierarchical scenes. It maintains a stack where each item has
// two fields:
// - a 4x4 model-to-world transform matrix
@@ -47,21 +47,21 @@ class PaperScene;
using PaperMaterial = Material;
// RefPtr forward declarations.
-using PaperRenderer2Ptr = fxl::RefPtr<PaperRenderer2>;
+using PaperRendererPtr = fxl::RefPtr<PaperRenderer>;
using PaperScenePtr = fxl::RefPtr<PaperScene>;
using PaperMaterialPtr = MaterialPtr;
-// The following types are not relevant to clients who use PaperRenderer2 only
+// The following types are not relevant to clients who use PaperRenderer only
// with existing subclasses of PaperDrawable, only to clients who implement
// their own subclasses.
// PaperDrawCallFactory generates PaperDrawCalls and enqueues them into a
// PaperRenderQueue. The number of draw-calls and the precise details of each
// depend on the factory's configuration (e.g. the current shadow algorithm),
-// which is controlled by PaperRenderer2 that owns the factory.
+// which is controlled by PaperRenderer that owns the factory.
class PaperDrawCallFactory;
-// The following types are implementation details of PaperRenderer2, which are
+// The following types are implementation details of PaperRenderer, which are
// invisible to clients.
// PaperDrawCall encapsulates a RenderQueueItem along with flags that specify
@@ -71,7 +71,7 @@ struct PaperDrawCall;
// PaperRenderQueue accepts enqueued PaperDrawCalls from PaperDrawCallFactory,
// adding each encapsulated RenderQueueItem to the proper internal RenderQueue.
//
-// PaperRenderer2 first calls Sort() to sort these RenderQueueItems, then calls
+// PaperRenderer first calls Sort() to sort these RenderQueueItems, then calls
// GenerateCommands() to generate Vulkan commands from them. The latter accepts
// a PaperRenderQueueContext (a subclass of RenderQueueContext); this is passed
// to each RenderQueueItem, and affects the resulting Vulkan commands.
diff --git a/garnet/public/lib/escher/paper/paper_renderer2.cc b/garnet/public/lib/escher/paper/paper_renderer.cc
similarity index 92%
rename from garnet/public/lib/escher/paper/paper_renderer2.cc
rename to garnet/public/lib/escher/paper/paper_renderer.cc
index a0011ac431f20cdfa24cb2754fc51bb777a830f4..eb185bf5256f015b3470c7838707a50da20e51e0 100644
--- a/garnet/public/lib/escher/paper/paper_renderer2.cc
+++ b/garnet/public/lib/escher/paper/paper_renderer.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "lib/escher/paper/paper_renderer2.h"
+#include "lib/escher/paper/paper_renderer.h"
#include <glm/gtc/matrix_access.hpp>
@@ -27,12 +27,12 @@
namespace escher {
-PaperRenderer2Ptr PaperRenderer2::New(EscherWeakPtr escher,
+PaperRendererPtr PaperRenderer::New(EscherWeakPtr escher,
const PaperRendererConfig& config) {
- return fxl::AdoptRef(new PaperRenderer2(std::move(escher), config));
+ return fxl::AdoptRef(new PaperRenderer(std::move(escher), config));
}
-PaperRenderer2::PaperRenderer2(EscherWeakPtr weak_escher,
+PaperRenderer::PaperRenderer(EscherWeakPtr weak_escher,
const PaperRendererConfig& config)
: Renderer(weak_escher),
config_(config),
@@ -89,9 +89,9 @@ PaperRenderer2::PaperRenderer2(EscherWeakPtr weak_escher,
msaa_buffers_.resize(config.num_depth_buffers);
}
-PaperRenderer2::~PaperRenderer2() { escher()->Cleanup(); }
+PaperRenderer::~PaperRenderer() { escher()->Cleanup(); }
-PaperRenderer2::FrameData::FrameData(
+PaperRenderer::FrameData::FrameData(
const FramePtr& frame_in, const PaperScenePtr& scene_in,
const ImagePtr& output_image_in,
std::pair<TexturePtr, TexturePtr> depth_and_msaa_textures,
@@ -164,9 +164,9 @@ PaperRenderer2::FrameData::FrameData(
}
}
-PaperRenderer2::FrameData::~FrameData() = default;
+PaperRenderer::FrameData::~FrameData() = default;
-void PaperRenderer2::SetConfig(const PaperRendererConfig& config) {
+void PaperRenderer::SetConfig(const PaperRendererConfig& config) {
FXL_DCHECK(!frame_data_) << "Illegal call to SetConfig() during a frame.";
FXL_DCHECK(SupportsShadowType(config.shadow_type))
<< "Unsupported shadow type: " << config.shadow_type;
@@ -175,7 +175,7 @@ void PaperRenderer2::SetConfig(const PaperRendererConfig& config) {
config.msaa_sample_count == 4);
if (config.msaa_sample_count != config_.msaa_sample_count) {
- FXL_VLOG(1) << "PaperRenderer2: MSAA sample count set to: "
+ FXL_VLOG(1) << "PaperRenderer: MSAA sample count set to: "
<< config.msaa_sample_count
<< " (was: " << config_.msaa_sample_count << ")";
depth_buffers_.clear();
@@ -183,7 +183,7 @@ void PaperRenderer2::SetConfig(const PaperRendererConfig& config) {
}
if (config.num_depth_buffers != config_.num_depth_buffers) {
- FXL_VLOG(1) << "PaperRenderer2: num_depth_buffers set to: "
+ FXL_VLOG(1) << "PaperRenderer: num_depth_buffers set to: "
<< config.num_depth_buffers
<< " (was: " << config_.num_depth_buffers << ")";
}
@@ -198,17 +198,17 @@ void PaperRenderer2::SetConfig(const PaperRendererConfig& config) {
shape_cache_.SetConfig(config_);
}
-bool PaperRenderer2::SupportsShadowType(
+bool PaperRenderer::SupportsShadowType(
PaperRendererShadowType shadow_type) const {
return shadow_type == PaperRendererShadowType::kNone ||
shadow_type == PaperRendererShadowType::kShadowVolume;
}
-void PaperRenderer2::BeginFrame(const FramePtr& frame,
+void PaperRenderer::BeginFrame(const FramePtr& frame,
const PaperScenePtr& scene,
const std::vector<Camera>& cameras,
const ImagePtr& output_image) {
- TRACE_DURATION("gfx", "PaperRenderer2::BeginFrame");
+ TRACE_DURATION("gfx", "PaperRenderer::BeginFrame");
FXL_DCHECK(!frame_data_ && !cameras.empty());
frame_data_ = std::make_unique<FrameData>(
@@ -246,8 +246,8 @@ void PaperRenderer2::BeginFrame(const FramePtr& frame,
}
}
-void PaperRenderer2::EndFrame() {
- TRACE_DURATION("gfx", "PaperRenderer2::EndFrame");
+void PaperRenderer::EndFrame() {
+ TRACE_DURATION("gfx", "PaperRenderer::EndFrame");
FXL_DCHECK(frame_data_);
frame_data_->gpu_uploader->Submit();
@@ -278,7 +278,7 @@ void PaperRenderer2::EndFrame() {
draw_call_factory_.EndFrame();
}
-void PaperRenderer2::BindSceneAndCameraUniforms(uint32_t camera_index) {
+void PaperRenderer::BindSceneAndCameraUniforms(uint32_t camera_index) {
auto* cmd_buf = frame_data_->frame->cmds();
for (UniformBinding& binding : frame_data_->scene_uniform_bindings) {
binding.Bind(cmd_buf);
@@ -286,9 +286,9 @@ void PaperRenderer2::BindSceneAndCameraUniforms(uint32_t camera_index) {
frame_data_->cameras[camera_index].binding.Bind(cmd_buf);
}
-void PaperRenderer2::Draw(PaperDrawable* drawable, PaperDrawableFlags flags,
+void PaperRenderer::Draw(PaperDrawable* drawable, PaperDrawableFlags flags,
mat4* matrix) {
- TRACE_DURATION("gfx", "PaperRenderer2::Draw");
+ TRACE_DURATION("gfx", "PaperRenderer::Draw");
// For restoring state afterward.
size_t transform_stack_size = transform_stack_.size();
@@ -304,9 +304,9 @@ void PaperRenderer2::Draw(PaperDrawable* drawable, PaperDrawableFlags flags,
transform_stack_.Clear({transform_stack_size, num_clip_planes});
}
-void PaperRenderer2::DrawCircle(float radius, const PaperMaterialPtr& material,
+void PaperRenderer::DrawCircle(float radius, const PaperMaterialPtr& material,
PaperDrawableFlags flags, mat4* matrix) {
- TRACE_DURATION("gfx", "PaperRenderer2::DrawCircle");
+ TRACE_DURATION("gfx", "PaperRenderer::DrawCircle");
if (!material)
return;
@@ -323,10 +323,10 @@ void PaperRenderer2::DrawCircle(float radius, const PaperMaterialPtr& material,
}
}
-void PaperRenderer2::DrawRect(vec2 min, vec2 max,
+void PaperRenderer::DrawRect(vec2 min, vec2 max,
const PaperMaterialPtr& material,
PaperDrawableFlags flags, mat4* matrix) {
- TRACE_DURATION("gfx", "PaperRenderer2::DrawRect");
+ TRACE_DURATION("gfx", "PaperRenderer::DrawRect");
if (!material)
return;
@@ -340,10 +340,10 @@ void PaperRenderer2::DrawRect(vec2 min, vec2 max,
}
}
-void PaperRenderer2::DrawRoundedRect(const RoundedRectSpec& spec,
+void PaperRenderer::DrawRoundedRect(const RoundedRectSpec& spec,
const PaperMaterialPtr& material,
PaperDrawableFlags flags, mat4* matrix) {
- TRACE_DURATION("gfx", "PaperRenderer2::DrawRoundedRect");
+ TRACE_DURATION("gfx", "PaperRenderer::DrawRoundedRect");
if (!material)
return;
@@ -357,7 +357,7 @@ void PaperRenderer2::DrawRoundedRect(const RoundedRectSpec& spec,
}
}
-void PaperRenderer2::DrawLegacyObject(const Object& obj,
+void PaperRenderer::DrawLegacyObject(const Object& obj,
PaperDrawableFlags flags) {
FXL_DCHECK(frame_data_);
@@ -365,7 +365,7 @@ void PaperRenderer2::DrawLegacyObject(const Object& obj,
Draw(&drawable, flags);
}
-void PaperRenderer2::InitRenderPassInfo(RenderPassInfo* rp,
+void PaperRenderer::InitRenderPassInfo(RenderPassInfo* rp,
ResourceRecycler* recycler,
const FrameData& frame_data,
uint32_t camera_index) {
@@ -429,8 +429,8 @@ void PaperRenderer2::InitRenderPassInfo(RenderPassInfo* rp,
// - still use the lights, allowing a BRDF, distance-based-falloff etc.
// The right answer is probably to separate the shadow algorithm from the
// lighting model.
-void PaperRenderer2::GenerateCommandsForNoShadows(uint32_t camera_index) {
- TRACE_DURATION("gfx", "PaperRenderer2::GenerateCommandsForNoShadows");
+void PaperRenderer::GenerateCommandsForNoShadows(uint32_t camera_index) {
+ TRACE_DURATION("gfx", "PaperRenderer::GenerateCommandsForNoShadows");
const FramePtr& frame = frame_data_->frame;
CommandBuffer* cmd_buf = frame->cmds();
@@ -464,8 +464,8 @@ void PaperRenderer2::GenerateCommandsForNoShadows(uint32_t camera_index) {
frame->AddTimestamp("finished no-shadows render pass");
}
-void PaperRenderer2::GenerateCommandsForShadowVolumes(uint32_t camera_index) {
- TRACE_DURATION("gfx", "PaperRenderer2::GenerateCommandsForShadowVolumes");
+void PaperRenderer::GenerateCommandsForShadowVolumes(uint32_t camera_index) {
+ TRACE_DURATION("gfx", "PaperRenderer::GenerateCommandsForShadowVolumes");
const uint32_t width = frame_data_->output_image->width();
const uint32_t height = frame_data_->output_image->height();
@@ -604,7 +604,7 @@ void PaperRenderer2::GenerateCommandsForShadowVolumes(uint32_t camera_index) {
frame->AddTimestamp("finished shadow_volume render pass");
}
-std::pair<TexturePtr, TexturePtr> PaperRenderer2::ObtainDepthAndMsaaTextures(
+std::pair<TexturePtr, TexturePtr> PaperRenderer::ObtainDepthAndMsaaTextures(
const FramePtr& frame, const ImageInfo& info) {
FXL_DCHECK(!depth_buffers_.empty());
@@ -622,7 +622,7 @@ std::pair<TexturePtr, TexturePtr> PaperRenderer2::ObtainDepthAndMsaaTextures(
// Need to generate a new depth buffer.
{
TRACE_DURATION("gfx",
- "PaperRenderer2::ObtainDepthAndMsaaTextures (new depth)");
+ "PaperRenderer::ObtainDepthAndMsaaTextures (new depth)");
depth_texture = escher()->NewAttachmentTexture(
vk::Format::eD24UnormS8Uint, info.width, info.height,
config_.msaa_sample_count, vk::Filter::eLinear);
@@ -632,7 +632,7 @@ std::pair<TexturePtr, TexturePtr> PaperRenderer2::ObtainDepthAndMsaaTextures(
msaa_texture = nullptr;
} else {
TRACE_DURATION("gfx",
- "PaperRenderer2::ObtainDepthAndMsaaTextures (new msaa)");
+ "PaperRenderer::ObtainDepthAndMsaaTextures (new msaa)");
// TODO(SCN-634): use lazy memory allocation and transient attachments
// when available.
msaa_texture = escher()->NewAttachmentTexture(
diff --git a/garnet/public/lib/escher/paper/paper_renderer2.h b/garnet/public/lib/escher/paper/paper_renderer.h
similarity index 94%
rename from garnet/public/lib/escher/paper/paper_renderer2.h
rename to garnet/public/lib/escher/paper/paper_renderer.h
index fa7fcb07d1187a517117b6f717302b0ed225c0ca..e29084cbf780091cc3de8ce2a7ffed09866b667f 100644
--- a/garnet/public/lib/escher/paper/paper_renderer2.h
+++ b/garnet/public/lib/escher/paper/paper_renderer.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef LIB_ESCHER_PAPER_PAPER_RENDERER2_H_
-#define LIB_ESCHER_PAPER_PAPER_RENDERER2_H_
+#ifndef LIB_ESCHER_PAPER_PAPER_RENDERER_H_
+#define LIB_ESCHER_PAPER_PAPER_RENDERER_H_
#include "lib/escher/paper/paper_readme.h"
@@ -20,7 +20,7 @@
namespace escher {
-// |PaperRenderer2| provides a convenient and flexible interface for rendering
+// |PaperRenderer| provides a convenient and flexible interface for rendering
// shapes in a 3D space, as required by Scenic. Clients achieve this primarily
// by passing instances of |PaperDrawable| to the |Draw()| method, using either
// pre-existing drawable types or their own subclasses. For convenience, other
@@ -38,7 +38,7 @@ namespace escher {
//
// Implementation details follow...
//
-// |PaperRenderer2| is responsible for coordinating its sub-components:
+// |PaperRenderer| is responsible for coordinating its sub-components:
// - |PaperDrawCallFactory|
// - |PaperShapeCache|
// - |PaperRenderQueue|
@@ -63,12 +63,12 @@ namespace escher {
// controlled by two parameters passed to the queue:
// - |PaperRenderQueueFlags|, to control iteration over draw calls.
// - |PaperRenderQueueContext|, used by draw calls to emit Vulkan commands.
-class PaperRenderer2 final : public Renderer {
+class PaperRenderer final : public Renderer {
public:
- static PaperRenderer2Ptr New(
+ static PaperRendererPtr New(
EscherWeakPtr escher, const PaperRendererConfig& config = {
.shadow_type = PaperRendererShadowType::kNone});
- ~PaperRenderer2() override;
+ ~PaperRenderer() override;
// Set configuration parameters which affect how the renderer will render
// subsequent frames.
@@ -136,9 +136,9 @@ class PaperRenderer2 final : public Renderer {
void DrawLegacyObject(const Object& obj, PaperDrawableFlags flags = {});
private:
- explicit PaperRenderer2(EscherWeakPtr escher,
+ explicit PaperRenderer(EscherWeakPtr escher,
const PaperRendererConfig& config);
- PaperRenderer2(const PaperRenderer2&) = delete;
+ PaperRenderer(const PaperRenderer&) = delete;
// Store relevant info from cameras passed to BeginFrame().
struct CameraData {
@@ -211,4 +211,4 @@ class PaperRenderer2 final : public Renderer {
} // namespace escher
-#endif // LIB_ESCHER_PAPER_PAPER_RENDERER2_H_
+#endif // LIB_ESCHER_PAPER_PAPER_RENDERER_H_
diff --git a/garnet/public/lib/escher/paper/paper_renderer_config.h b/garnet/public/lib/escher/paper/paper_renderer_config.h
index b2354c11691ad5d327d96d12ef32b44c19917efe..d7f36aa8a625eebb2f58766feceeecfec33d1229 100644
--- a/garnet/public/lib/escher/paper/paper_renderer_config.h
+++ b/garnet/public/lib/escher/paper/paper_renderer_config.h
@@ -11,7 +11,7 @@
namespace escher {
-// A list of shadow types which may be supported by |PaperRenderer2|. Some
+// A list of shadow types which may be supported by |PaperRenderer|. Some
// shadow techniques will not be supported on some target devices.
enum class PaperRendererShadowType {
kNone = 0,
@@ -25,7 +25,7 @@ enum class PaperRendererShadowType {
};
ESCHER_DEBUG_PRINTABLE(PaperRendererShadowType);
-// Allows clients to configure the behavior of a |PaperRenderer2| by calling
+// Allows clients to configure the behavior of a |PaperRenderer| by calling
// |SetConfig()| at any time except in the middle of a frame.
struct PaperRendererConfig {
// Choose a shadow algorithm.
diff --git a/garnet/public/lib/escher/paper/paper_scene.h b/garnet/public/lib/escher/paper/paper_scene.h
index 46720b2ae7cf8fd601085a3592b509a4b4305459..934eb994e1865042f72c59f86554e94ccc8cfd7d 100644
--- a/garnet/public/lib/escher/paper/paper_scene.h
+++ b/garnet/public/lib/escher/paper/paper_scene.h
@@ -18,7 +18,7 @@ namespace escher {
//
// NOTE: this is a placeholder; we may want to be more elaborate here. Should
// this provide virtual methods? Or should it become dumber: a non-reffable
-// struct that is copied into PaperRenderer2::FrameData.
+// struct that is copied into PaperRenderer::FrameData.
class PaperScene : public Reffable {
public:
BoundingBox bounding_box;
diff --git a/garnet/public/lib/escher/paper/paper_shape_cache.h b/garnet/public/lib/escher/paper/paper_shape_cache.h
index 32a7e04727a7747eade5bb2a0d4e3a017a8b8e02..dce8ac0d48bc620774f16b5d674d4562cef8bdcf 100644
--- a/garnet/public/lib/escher/paper/paper_shape_cache.h
+++ b/garnet/public/lib/escher/paper/paper_shape_cache.h
@@ -24,7 +24,7 @@ struct RoundedRectSpec;
// as a way to get access to both |num_indices| and |num_shadow_volume_indices|.
// This allows us to use the same mesh for two different purposes ("regular"
// geometry and extruded shadow volume geometry).
-// NOTE: messy-ish but OK for now because encapsulated in |PaperRenderer2|.
+// NOTE: messy-ish but OK for now because encapsulated in |PaperRenderer|.
struct PaperShapeCacheEntry {
uint64_t last_touched_frame = 0;
MeshPtr mesh;
@@ -48,7 +48,7 @@ class PaperShapeCache {
// look up the mesh, a hash is computed from the shape parameters along with
// the list of clip planes. If the mesh is not found, a new mesh is generated
// from the shape parameters, clipped by the list of planes, and
- // post-processed in whatever way is required by the current |PaperRenderer2|
+ // post-processed in whatever way is required by the current |PaperRenderer|
// configuration (e.g. perhaps adding a vertex attribute to allow
// shadow-volume extrusion in the vertex shader).
const PaperShapeCacheEntry& GetRoundedRectMesh(const RoundedRectSpec& spec,
diff --git a/garnet/public/lib/escher/test/vk/shader_program_unittest.cc b/garnet/public/lib/escher/test/vk/shader_program_unittest.cc
index 492c8a01f915e18176bca0d9db2fb6d7a6ae186c..1496c3679665ea3b5940d1f10700e529af3445dc 100644
--- a/garnet/public/lib/escher/test/vk/shader_program_unittest.cc
+++ b/garnet/public/lib/escher/test/vk/shader_program_unittest.cc
@@ -31,7 +31,7 @@ class ShaderProgramTest : public ::testing::Test, public VulkanTester {
auto escher = test::GetEscher();
EXPECT_TRUE(escher->Cleanup());
- // TODO(ES-183): remove PaperRenderer2 shader dependency.
+ // TODO(ES-183): remove PaperRenderer shader dependency.
auto factory = escher->shader_program_factory();
bool success = factory->filesystem()->InitializeWithRealFiles({
"shaders/model_renderer/default_position.vert",
@@ -73,7 +73,7 @@ class ShaderProgramTest : public ::testing::Test, public VulkanTester {
VK_TEST_F(ShaderProgramTest, CachedVariants) {
auto escher = test::GetEscher();
- // TODO(ES-183): remove PaperRenderer2 shader dependency.
+ // TODO(ES-183): remove PaperRenderer shader dependency.
ShaderVariantArgs variant1({{"NO_SHADOW_LIGHTING_PASS", "1"},
{"USE_ATTRIBUTE_UV", "1"},
{"USE_PAPER_SHADER_PUSH_CONSTANTS", "1"}});
@@ -103,7 +103,7 @@ VK_TEST_F(ShaderProgramTest, CachedVariants) {
VK_TEST_F(ShaderProgramTest, GeneratePipelines) {
auto escher = test::GetEscher();
- // TODO(ES-183): remove PaperRenderer2 shader dependency.
+ // TODO(ES-183): remove PaperRenderer shader dependency.
ShaderVariantArgs variant({{"NO_SHADOW_LIGHTING_PASS", "1"},
{"USE_ATTRIBUTE_UV", "1"},
{"USE_PAPER_SHADER_PUSH_CONSTANTS", "1"}});