| // Copyright 2018 Google LLC | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // https://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "tools/render/text.h" | |
| #include "absl/strings/str_cat.h" | |
| #include "tools/render/font_data.h" | |
| namespace quic_trace { | |
| namespace render { | |
| namespace { | |
| // The following shader renders the text as specified in window coordinates and | |
| // assigns appropriate texture | |
| const char* kVertexShader = R"( | |
| uniform float texture_w; | |
| uniform float texture_h; | |
| in vec2 coord; | |
| out vec2 texcoord; | |
| void main(void) { | |
| gl_Position = windowToGl(coord); | |
| // Textures the squares based on the following assumed ordering of vertices: | |
| // 0 1 | |
| // 2 3 | |
| texcoord = vec2((gl_VertexID % 2) * texture_w, (gl_VertexID % 4) < 2 ? 0 : texture_h); | |
| } | |
| )"; | |
| const char* kFragmentShader = R"( | |
| in vec2 texcoord; | |
| out vec4 color; | |
| uniform sampler2D tex; | |
| void main(void) { | |
| color = texture(tex, texcoord); | |
| } | |
| )"; | |
| } // namespace | |
| TextRenderer::TextRenderer(const ProgramState* state) | |
| : state_(state), shader_(kVertexShader, kFragmentShader) { | |
| CHECK_EQ(TTF_Init(), 0) << "Failed to initialize SDL_ttf: " << TTF_GetError(); | |
| SDL_RWops* font_data = | |
| SDL_RWFromConstMem(::kDroidSansBlob.data(), ::kDroidSansBlob.size()); | |
| font_ = TTF_OpenFontRW(font_data, /*freesrc=*/1, state->ScaleForDpi(14)); | |
| CHECK(font_ != nullptr) << "Failed to load regular font"; | |
| } | |
| TextRenderer::~TextRenderer() { | |
| if (font_ != nullptr) { | |
| TTF_CloseFont(font_); | |
| } | |
| TTF_Quit(); | |
| } | |
| static size_t NearestPowerOfTwo(size_t x) { | |
| size_t result = 1; | |
| while (result < x) { | |
| result *= 2; | |
| } | |
| return result; | |
| } | |
| void TextRenderer::AddText(std::shared_ptr<const Text> text, int x, int y) { | |
| texts_to_draw_.push_back(TextToDraw{ | |
| .text = std::move(text), | |
| .x = x, | |
| .y = y, | |
| }); | |
| } | |
| void TextRenderer::DrawAll() { | |
| // Common setup for drawing text. | |
| glUseProgram(*shader_); | |
| state_->Bind(shader_); | |
| for (const TextToDraw& text_to_draw : texts_to_draw_) { | |
| text_to_draw.text->Draw(text_to_draw.x, text_to_draw.y); | |
| } | |
| texts_to_draw_.clear(); | |
| // Clean up the cache. | |
| for (auto it = cache_.begin(); it != cache_.end();) { | |
| if (it->second.live) { | |
| it->second.live = false; | |
| it++; | |
| } else { | |
| cache_.erase(it++); | |
| } | |
| } | |
| DCHECK(cache_.size() < 4096) << "The text cache is too big, which indicates " | |
| "that it's most likely leaking"; | |
| } | |
| std::shared_ptr<const Text> TextRenderer::RenderTextInner( | |
| const std::string& text, | |
| int style) { | |
| // Check if we have the text in the cache. | |
| std::string cache_key = absl::StrCat(style, "/", text); | |
| auto cache_it = cache_.find(cache_key); | |
| if (cache_it != cache_.end()) { | |
| cache_it->second.live = true; | |
| return cache_it->second.text; | |
| } | |
| if (TTF_GetFontStyle(font_) != style) { | |
| TTF_SetFontStyle(font_, style); | |
| } | |
| // Render the text. | |
| ScopedSdlSurface surface; | |
| if (text.empty()) { | |
| // SDL2_ttf returns error when asked to render an empty string. Return a | |
| // 1x1 white square instead. | |
| surface = ScopedSdlSurface( | |
| SDL_CreateRGBSurfaceWithFormat(0, 1, 1, 32, SDL_PIXELFORMAT_RGBA32)); | |
| CHECK(!SDL_MUSTLOCK(*surface)); | |
| memset(surface->pixels, 0xff, surface->h * surface->pitch); | |
| } else { | |
| surface = TTF_RenderUTF8_Blended(font_, text.c_str(), SDL_Color{0, 0, 0}); | |
| } | |
| if (*surface == nullptr) { | |
| LOG(FATAL) << "Failed to render text: \"" << text.size() << "\""; | |
| } | |
| std::unique_ptr<Text> result(new Text(this)); | |
| // Find the correct size for the texture, which is required to be a power of | |
| // two. | |
| size_t size = | |
| std::max(NearestPowerOfTwo(surface->w), NearestPowerOfTwo(surface->h)); | |
| result->width_ = surface->w; | |
| result->height_ = surface->h; | |
| result->texture_size_ = size; | |
| // Create a |size|x|size| texture buffer in RAM, and move the texture there. | |
| ScopedSdlSurface scaled_surface(SDL_CreateRGBSurfaceWithFormat( | |
| 0, size, size, 32, SDL_PIXELFORMAT_RGBA32)); | |
| SDL_Rect target{0, 0, surface->w, surface->h}; | |
| SDL_BlitSurface(*surface, nullptr, *scaled_surface, &target); | |
| CHECK_EQ(scaled_surface->format->format, SDL_PIXELFORMAT_RGBA32); | |
| CHECK_EQ(scaled_surface->pitch, size * 4); | |
| CHECK(!SDL_MUSTLOCK(*scaled_surface)); | |
| // Upload the texture onto the GPU. | |
| glBindTexture(GL_TEXTURE_2D, *result->texture_); | |
| glPixelStorei(GL_UNPACK_ALIGNMENT, 4); | |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size, size, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, scaled_surface->pixels); | |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
| std::shared_ptr<const Text> cached_result(result.release()); | |
| cache_.emplace(cache_key, CacheEntry{cached_result, true}); | |
| return cached_result; | |
| } | |
| void Text::Draw(int x, int y) const { | |
| const float fx = x, fy = y, fw = width_, fh = height_; | |
| const float vertices[] = { | |
| fx, fy + fh, // upper left | |
| fx + fw, fy + fh, // upper right | |
| fx, fy, // lower left | |
| fx + fw, fy, // lower right | |
| }; | |
| GlVertexBuffer buffer; | |
| glBindBuffer(GL_ARRAY_BUFFER, *buffer); | |
| glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STREAM_DRAW); | |
| GlVertexArray array; | |
| glBindVertexArray(*array); | |
| glBindTexture(GL_TEXTURE_2D, *texture_); | |
| factory_->shader_.SetUniform("texture_w", width_ / texture_size_); | |
| factory_->shader_.SetUniform("texture_h", height_ / texture_size_); | |
| GlVertexArrayAttrib coord(factory_->shader_, "coord"); | |
| glVertexAttribPointer(*coord, 2, GL_FLOAT, GL_FALSE, 0, 0); | |
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); | |
| } | |
| } // namespace render | |
| } // namespace quic_trace |