OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // Data structures for representing parts of Chromium's composited layer tree | |
6 // and a function to load it from the JSON configuration file | |
7 | |
8 #ifndef GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_ | |
9 #define GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_ | |
10 | |
11 #include <string> | |
12 #include <vector> | |
13 | |
14 #include "base/compiler_specific.h" | |
15 #include "base/memory/scoped_vector.h" | |
16 #include "gpu/tools/compositor_model_bench/shaders.h" | |
17 #include "ui/gfx/gl/gl_bindings.h" | |
18 #include "ui/gfx/gl/gl_implementation.h" | |
19 | |
20 // These are fairly arbitrary values based on how big my actual browser | |
21 // window was. | |
22 const int WINDOW_WIDTH = 1609; | |
23 const int WINDOW_HEIGHT = 993; | |
24 | |
25 struct Tile { | |
26 int x; | |
27 int y; | |
28 int texID; | |
29 }; | |
30 | |
31 struct Texture { | |
32 int texID; | |
33 int height; | |
34 int width; | |
35 GLenum format; | |
36 }; | |
37 | |
38 GLenum TextureFormatFromString(std::string format); | |
39 const char* TextureFormatName(GLenum format); | |
40 int FormatBytesPerPixel(GLenum format); | |
41 | |
42 struct RenderNodeVisitor; | |
43 | |
44 class RenderNode { | |
45 public: | |
46 RenderNode() {} | |
47 virtual ~RenderNode() {} | |
48 virtual void Accept(RenderNodeVisitor* v); | |
49 | |
50 int layerID() { | |
51 return layerID_; | |
52 } | |
53 | |
54 void set_layerID(int id) { | |
55 layerID_ = id; | |
56 } | |
57 | |
58 int width() { | |
59 return width_; | |
60 } | |
61 | |
62 void set_width(int width) { | |
63 width_ = width; | |
64 } | |
65 | |
66 int height() { | |
67 return height_; | |
68 } | |
69 | |
70 void set_height(int height) { | |
71 height_ = height; | |
72 } | |
73 | |
74 bool drawsContent() { | |
75 return drawsContent_; | |
76 } | |
77 | |
78 void set_drawsContent(bool draws) { | |
79 drawsContent_ = draws; | |
80 } | |
81 | |
82 void set_targetSurface(int surface) { | |
83 targetSurface_ = surface; | |
84 } | |
85 | |
86 float* transform() { | |
87 return transform_; | |
88 } | |
89 | |
90 void set_transform(float* mat) { | |
91 memcpy(reinterpret_cast<void*>(transform_), | |
92 reinterpret_cast<void*>(mat), | |
93 16 * sizeof(transform_[0])); | |
94 } | |
95 | |
96 void add_tile(Tile t) { | |
97 tiles_.push_back(t); | |
98 } | |
99 | |
100 size_t num_tiles() { | |
101 return tiles_.size(); | |
102 } | |
103 | |
104 Tile* tile(size_t index) { | |
105 return &tiles_[index]; | |
106 } | |
107 | |
108 int tile_width() { | |
109 return tile_width_; | |
110 } | |
111 | |
112 void set_tile_width(int width) { | |
113 tile_width_ = width; | |
114 } | |
115 | |
116 int tile_height() { | |
117 return tile_height_; | |
118 } | |
119 | |
120 void set_tile_height(int height) { | |
121 tile_height_ = height; | |
122 } | |
123 | |
124 private: | |
125 int layerID_; | |
126 int width_; | |
127 int height_; | |
128 bool drawsContent_; | |
129 int targetSurface_; | |
130 float transform_[16]; | |
131 std::vector<Tile> tiles_; | |
132 int tile_width_; | |
133 int tile_height_; | |
134 }; | |
135 | |
136 class ContentLayerNode : public RenderNode { | |
137 public: | |
138 ContentLayerNode() {} | |
139 virtual void Accept(RenderNodeVisitor* v) OVERRIDE; | |
140 | |
141 void set_skipsDraw(bool skips) { | |
142 skipsDraw_ = skips; | |
143 } | |
144 | |
145 void add_child(RenderNode* child) { | |
146 children_.push_back(child); | |
147 } | |
148 | |
149 private: | |
150 ScopedVector<RenderNode> children_; | |
151 bool skipsDraw_; | |
152 }; | |
153 | |
154 class CCNode : public RenderNode { | |
155 public: | |
156 CCNode() {} | |
157 | |
158 virtual void Accept(RenderNodeVisitor* v) OVERRIDE; | |
159 | |
160 ShaderID vertex_shader() { | |
161 return vertex_shader_; | |
162 } | |
163 | |
164 void set_vertex_shader(ShaderID shader) { | |
165 vertex_shader_ = shader; | |
166 } | |
167 | |
168 ShaderID fragment_shader() { | |
169 return fragment_shader_; | |
170 } | |
171 | |
172 void set_fragment_shader(ShaderID shader) { | |
173 fragment_shader_ = shader; | |
174 } | |
175 | |
176 void add_texture(Texture t) { | |
177 textures_.push_back(t); | |
178 } | |
179 | |
180 size_t num_textures() { | |
181 return textures_.size(); | |
182 } | |
183 | |
184 Texture* texture(size_t index) { | |
185 return &textures_[index]; | |
186 } | |
187 | |
188 private: | |
189 ShaderID vertex_shader_; | |
190 ShaderID fragment_shader_; | |
191 std::vector<Texture> textures_; | |
192 }; | |
193 | |
194 class RenderNodeVisitor { | |
195 public: | |
196 virtual ~RenderNodeVisitor() {} | |
197 | |
198 virtual void BeginVisitRenderNode(RenderNode* v) = 0; | |
199 virtual void BeginVisitContentLayerNode(ContentLayerNode* v) { | |
200 this->BeginVisitRenderNode(v); | |
201 } | |
202 virtual void BeginVisitCCNode(CCNode* v) { | |
203 this->BeginVisitRenderNode(v); | |
204 } | |
205 | |
206 virtual void EndVisitRenderNode(RenderNode* v) {} | |
207 virtual void EndVisitContentLayerNode(ContentLayerNode* v) { | |
208 this->EndVisitRenderNode(v); | |
209 } | |
210 virtual void EndVisitCCNode(CCNode* v) { | |
211 this->EndVisitRenderNode(v); | |
212 } | |
213 }; | |
214 | |
215 RenderNode* BuildRenderTreeFromFile(const FilePath& path); | |
216 | |
217 #endif // GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_ | |
218 | |
OLD | NEW |