blob: 996a2d1e4e4fac0b4013ef56d00cb453a7e327de [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Data structures for representing parts of Chromium's composited layer tree
// and a function to load it from the JSON configuration file
#ifndef GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_
#define GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_
#include <stddef.h>
#include <memory>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "base/memory/ptr_util.h"
#include "gpu/tools/compositor_model_bench/shaders.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/gl_implementation.h"
// These are fairly arbitrary values based on how big my actual browser
// window was.
const int WINDOW_WIDTH = 1609;
const int WINDOW_HEIGHT = 993;
struct Tile {
int x;
int y;
int texID;
};
struct Texture {
int texID;
int height;
int width;
GLenum format;
};
GLenum TextureFormatFromString(const std::string& format);
const char* TextureFormatName(GLenum format);
int FormatBytesPerPixel(GLenum format);
class RenderNodeVisitor;
class RenderNode {
public:
RenderNode();
virtual ~RenderNode();
virtual void Accept(RenderNodeVisitor* v);
int layerID() {
return layerID_;
}
void set_layerID(int id) {
layerID_ = id;
}
int width() {
return width_;
}
void set_width(int width) {
width_ = width;
}
int height() {
return height_;
}
void set_height(int height) {
height_ = height;
}
bool drawsContent() {
return drawsContent_;
}
void set_drawsContent(bool draws) {
drawsContent_ = draws;
}
void set_targetSurface(int surface) {
targetSurface_ = surface;
}
float* transform() {
return transform_;
}
void set_transform(float* mat) {
memcpy(reinterpret_cast<void*>(transform_),
reinterpret_cast<void*>(mat),
16 * sizeof(transform_[0]));
}
void add_tile(Tile t) {
tiles_.push_back(t);
}
size_t num_tiles() {
return tiles_.size();
}
Tile* tile(size_t index) {
return &tiles_[index];
}
int tile_width() {
return tile_width_;
}
void set_tile_width(int width) {
tile_width_ = width;
}
int tile_height() {
return tile_height_;
}
void set_tile_height(int height) {
tile_height_ = height;
}
private:
int layerID_;
int width_;
int height_;
bool drawsContent_;
int targetSurface_;
float transform_[16];
std::vector<Tile> tiles_;
int tile_width_;
int tile_height_;
};
class ContentLayerNode : public RenderNode {
public:
ContentLayerNode();
~ContentLayerNode() override;
void Accept(RenderNodeVisitor* v) override;
void set_skipsDraw(bool skips) {
skipsDraw_ = skips;
}
void add_child(RenderNode* child) {
children_.push_back(base::WrapUnique(child));
}
private:
std::vector<std::unique_ptr<RenderNode>> children_;
bool skipsDraw_;
};
class CCNode : public RenderNode {
public:
CCNode();
~CCNode() override;
void Accept(RenderNodeVisitor* v) override;
ShaderID vertex_shader() {
return vertex_shader_;
}
void set_vertex_shader(ShaderID shader) {
vertex_shader_ = shader;
}
ShaderID fragment_shader() {
return fragment_shader_;
}
void set_fragment_shader(ShaderID shader) {
fragment_shader_ = shader;
}
void add_texture(Texture t) {
textures_.push_back(t);
}
size_t num_textures() {
return textures_.size();
}
Texture* texture(size_t index) {
return &textures_[index];
}
private:
ShaderID vertex_shader_;
ShaderID fragment_shader_;
std::vector<Texture> textures_;
};
class RenderNodeVisitor {
public:
virtual ~RenderNodeVisitor();
virtual void BeginVisitRenderNode(RenderNode* v) = 0;
virtual void BeginVisitContentLayerNode(ContentLayerNode* v);
virtual void BeginVisitCCNode(CCNode* v);
virtual void EndVisitRenderNode(RenderNode* v);
virtual void EndVisitContentLayerNode(ContentLayerNode* v);
virtual void EndVisitCCNode(CCNode* v);
};
std::unique_ptr<RenderNode> BuildRenderTreeFromFile(const base::FilePath& path);
#endif // GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_