FIFE  2008.0
 All Classes Namespaces Functions Variables Enumerations Enumerator Pages
genericrenderer.cpp
1 /***************************************************************************
2  * Copyright (C) 2005-2011 by the FIFE team *
3  * http://www.fifengine.de *
4  * This file is part of FIFE. *
5  * *
6  * FIFE is free software; you can redistribute it and/or *
7  * modify it under the terms of the GNU Lesser General Public *
8  * License as published by the Free Software Foundation; either *
9  * version 2.1 of the License, or (at your option) any later version. *
10  * *
11  * This library is distributed in the hope that it will be useful, *
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * Lesser General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU Lesser General Public *
17  * License along with this library; if not, write to the *
18  * Free Software Foundation, Inc., *
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
20  ***************************************************************************/
21 
22 // Standard C++ library includes
23 
24 // 3rd party library includes
25 
26 // FIFE includes
27 // These includes are split up in two parts, separated by one empty line
28 // First block: files included from the FIFE root src directory
29 // Second block: files included from the same folder
30 #include "video/renderbackend.h"
31 #include "video/animation.h"
32 #include "video/fonts/ifont.h"
33 #include "video/image.h"
34 #include "video/imagemanager.h"
35 #include "util/math/fife_math.h"
36 #include "util/log/logger.h"
37 #include "util/time/timemanager.h"
38 #include "model/metamodel/grids/cellgrid.h"
39 #include "model/metamodel/timeprovider.h"
40 #include "model/structures/instance.h"
41 #include "model/structures/layer.h"
42 #include "model/structures/location.h"
43 
44 #include "view/camera.h"
45 #include "genericrenderer.h"
46 
47 
48 namespace FIFE {
49  static Logger _log(LM_VIEWVIEW);
50 
51  GenericRendererLineInfo::GenericRendererLineInfo(RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
52  GenericRendererElementInfo(),
53  m_edge1(n1),
54  m_edge2(n2),
55  m_red(r),
56  m_green(g),
57  m_blue(b),
58  m_alpha(a) {
59  }
60  void GenericRendererLineInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
61  Point p1 = m_edge1.getCalculatedPoint(cam, layer);
62  Point p2 = m_edge2.getCalculatedPoint(cam, layer);
63  if(m_edge1.getLayer() == layer) {
64  renderbackend->drawLine(p1, p2, m_red, m_green, m_blue, m_alpha);
65  }
66  }
67 
68  GenericRendererPointInfo::GenericRendererPointInfo(RendererNode anchor, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
69  GenericRendererElementInfo(),
70  m_anchor(anchor),
71  m_red(r),
72  m_green(g),
73  m_blue(b),
74  m_alpha(a) {
75  }
76  void GenericRendererPointInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
77  Point p = m_anchor.getCalculatedPoint(cam, layer);
78  if(m_anchor.getLayer() == layer) {
79  renderbackend->putPixel(p.x, p.y, m_red, m_green, m_blue, m_alpha);
80  }
81  }
82 
83  GenericRendererTriangleInfo::GenericRendererTriangleInfo(RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
84  GenericRendererElementInfo(),
85  m_edge1(n1),
86  m_edge2(n2),
87  m_edge3(n3),
88  m_red(r),
89  m_green(g),
90  m_blue(b),
91  m_alpha(a) {
92  }
93  void GenericRendererTriangleInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
94  Point p1 = m_edge1.getCalculatedPoint(cam, layer);
95  Point p2 = m_edge2.getCalculatedPoint(cam, layer);
96  Point p3 = m_edge3.getCalculatedPoint(cam, layer);
97  if(m_edge1.getLayer() == layer) {
98  renderbackend->drawTriangle(p1, p2, p3, m_red, m_green, m_blue, m_alpha);
99  }
100  }
101 
102  GenericRendererQuadInfo::GenericRendererQuadInfo(RendererNode n1, RendererNode n2, RendererNode n3, RendererNode n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
103  GenericRendererElementInfo(),
104  m_edge1(n1),
105  m_edge2(n2),
106  m_edge3(n3),
107  m_edge4(n4),
108  m_red(r),
109  m_green(g),
110  m_blue(b),
111  m_alpha(a) {
112  }
113  void GenericRendererQuadInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
114  Point p1 = m_edge1.getCalculatedPoint(cam, layer);
115  Point p2 = m_edge2.getCalculatedPoint(cam, layer);
116  Point p3 = m_edge3.getCalculatedPoint(cam, layer);
117  Point p4 = m_edge4.getCalculatedPoint(cam, layer);
118  if(m_edge1.getLayer() == layer) {
119  renderbackend->drawQuad(p1, p2, p3, p4, m_red, m_green, m_blue, m_alpha);
120  }
121  }
122 
123  GenericRendererVertexInfo::GenericRendererVertexInfo(RendererNode center, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
124  GenericRendererElementInfo(),
125  m_center(center),
126  m_size(size),
127  m_red(r),
128  m_green(g),
129  m_blue(b),
130  m_alpha(a) {
131  }
132  void GenericRendererVertexInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
133  Point p = m_center.getCalculatedPoint(cam, layer);
134  if(m_center.getLayer() == layer) {
135  renderbackend->drawVertex(p, m_size, m_red, m_green, m_blue, m_alpha);
136  }
137  }
138 
139  GenericRendererImageInfo::GenericRendererImageInfo(RendererNode anchor, ImagePtr image, bool zoomed):
140  GenericRendererElementInfo(),
141  m_anchor(anchor),
142  m_image(image),
143  m_zoomed(zoomed) {
144  }
145  void GenericRendererImageInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
146  Point p = m_anchor.getCalculatedPoint(cam, layer, m_zoomed);
147  if(m_anchor.getLayer() == layer) {
148  Rect r;
149  Rect viewport = cam->getViewPort();
150  uint32_t width, height;
151  if(m_zoomed) {
152  width = static_cast<uint32_t>(round(m_image->getWidth() * cam->getZoom()));
153  height = static_cast<uint32_t>(round(m_image->getHeight() * cam->getZoom()));
154  }
155  else {
156  width = m_image->getWidth();
157  height = m_image->getHeight();
158  }
159  r.x = p.x-width/2;
160  r.y = p.y-height/2;
161  r.w = width;
162  r.h = height;
163  if(r.intersects(viewport)) {
164  m_image->render(r);
165  }
166  }
167  }
168 
169  GenericRendererAnimationInfo::GenericRendererAnimationInfo(RendererNode anchor, AnimationPtr animation, bool zoomed):
170  GenericRendererElementInfo(),
171  m_anchor(anchor),
172  m_animation(animation),
173  m_start_time(TimeManager::instance()->getTime()),
174  m_time_scale(1.0),
175  m_zoomed(zoomed) {
176  }
177  void GenericRendererAnimationInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
178  Point p = m_anchor.getCalculatedPoint(cam, layer, m_zoomed);
179  if(m_anchor.getLayer() == layer) {
180  int32_t animtime = scaleTime(m_time_scale, TimeManager::instance()->getTime() - m_start_time) % m_animation->getDuration();
181  ImagePtr img = m_animation->getFrameByTimestamp(animtime);
182  Rect r;
183  Rect viewport = cam->getViewPort();
184  uint32_t width, height;
185  if(m_zoomed) {
186  width = static_cast<uint32_t>(round(img->getWidth() * cam->getZoom()));
187  height = static_cast<uint32_t>(round(img->getHeight() * cam->getZoom()));
188  } else {
189  width = img->getWidth();
190  height = img->getHeight();
191  }
192  r.x = p.x-width/2;
193  r.y = p.y-height/2;
194  r.w = width;
195  r.h = height;
196  if(r.intersects(viewport)) {
197  img->render(r);
198  }
199  }
200  }
201 
202  GenericRendererTextInfo::GenericRendererTextInfo(RendererNode anchor, IFont* font, std::string text):
203  GenericRendererElementInfo(),
204  m_anchor(anchor),
205  m_font(font),
206  m_text(text) {
207  }
208  void GenericRendererTextInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
209  Point p = m_anchor.getCalculatedPoint(cam, layer);
210  if(m_anchor.getLayer() == layer) {
211  Image* img = m_font->getAsImageMultiline(m_text);
212  Rect r;
213  Rect viewport = cam->getViewPort();
214  r.x = p.x-img->getWidth()/2;
215  r.y = p.y-img->getHeight()/2;
216  r.w = img->getWidth();
217  r.h = img->getHeight();
218  if(r.intersects(viewport)) {
219  img->render(r);
220  if (renderbackend->getLightingModel() > 0) {
221  renderbackend->changeRenderInfos(1, 4, 5, false, false, 0, KEEP, ALWAYS);
222  }
223  }
224  }
225  }
226 
227  GenericRendererResizeInfo::GenericRendererResizeInfo(RendererNode anchor, ImagePtr image, int32_t width, int32_t height, bool zoomed):
228  GenericRendererElementInfo(),
229  m_anchor(anchor),
230  m_image(image),
231  m_width(width),
232  m_height(height),
233  m_zoomed(zoomed) {
234  }
235  void GenericRendererResizeInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {
236  Point p = m_anchor.getCalculatedPoint(cam, layer, m_zoomed);
237  if(m_anchor.getLayer() == layer) {
238  Rect r;
239  Rect viewport = cam->getViewPort();
240  uint32_t width, height;
241  if(m_zoomed) {
242  width = static_cast<uint32_t>(round(m_width * cam->getZoom()));
243  height = static_cast<uint32_t>(round(m_height * cam->getZoom()));
244  } else {
245  width = m_width;
246  height = m_height;
247  }
248  r.x = p.x-width/2;
249  r.y = p.y-height/2;
250  r.w = width;
251  r.h = height;
252  if(r.intersects(viewport)) {
253  m_image->render(r);
254  }
255  }
256  }
257 
258  GenericRenderer* GenericRenderer::getInstance(IRendererContainer* cnt) {
259  return dynamic_cast<GenericRenderer*>(cnt->getRenderer("GenericRenderer"));
260  }
261 
262  GenericRenderer::GenericRenderer(RenderBackend* renderbackend, int32_t position):
263  RendererBase(renderbackend, position),
264  m_groups() {
265  setEnabled(false);
266  }
267 
268  GenericRenderer::GenericRenderer(const GenericRenderer& old):
269  RendererBase(old),
270  m_groups() {
271  setEnabled(false);
272  }
273 
274  RendererBase* GenericRenderer::clone() {
275  return new GenericRenderer(*this);
276  }
277 
278  GenericRenderer::~GenericRenderer() {
279  }
280  void GenericRenderer::addLine(const std::string &group, RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
281  GenericRendererElementInfo* info = new GenericRendererLineInfo(n1, n2, r, g, b, a);
282  m_groups[group].push_back(info);
283  }
284  void GenericRenderer::addPoint(const std::string &group, RendererNode n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
285  GenericRendererElementInfo* info = new GenericRendererPointInfo(n, r, g, b, a);
286  m_groups[group].push_back(info);
287  }
288  void GenericRenderer::addTriangle(const std::string &group, RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
289  GenericRendererElementInfo* info = new GenericRendererTriangleInfo(n1, n2, n3, r, g, b, a);
290  m_groups[group].push_back(info);
291  }
292  void GenericRenderer::addQuad(const std::string &group, RendererNode n1, RendererNode n2, RendererNode n3, RendererNode n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
293  GenericRendererElementInfo* info = new GenericRendererQuadInfo(n1, n2, n3, n4, r, g, b, a);
294  m_groups[group].push_back(info);
295  }
296  void GenericRenderer::addVertex(const std::string &group, RendererNode n, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
297  GenericRendererElementInfo* info = new GenericRendererVertexInfo(n, size, r, g, b, a);
298  m_groups[group].push_back(info);
299  }
300  void GenericRenderer::addText(const std::string &group, RendererNode n, IFont* font, const std::string &text) {
301  GenericRendererElementInfo* info = new GenericRendererTextInfo(n, font, text);
302  m_groups[group].push_back(info);
303  }
304  void GenericRenderer::addImage(const std::string &group, RendererNode n, ImagePtr image, bool zoomed) {
305  GenericRendererElementInfo* info = new GenericRendererImageInfo(n, image, zoomed);
306  m_groups[group].push_back(info);
307  }
308  void GenericRenderer::addAnimation(const std::string &group, RendererNode n, AnimationPtr animation, bool zoomed) {
309  GenericRendererElementInfo* info = new GenericRendererAnimationInfo(n, animation, zoomed);
310  m_groups[group].push_back(info);
311  }
312  void GenericRenderer::resizeImage(const std::string &group, RendererNode n, ImagePtr image, int32_t width, int32_t height, bool zoomed) {
313  GenericRendererElementInfo* info = new GenericRendererResizeInfo(n, image, width, height, zoomed);
314  m_groups[group].push_back(info);
315  }
316  void GenericRenderer::removeAll(const std::string &group) {
317  std::vector<GenericRendererElementInfo*>::const_iterator info_it = m_groups[group].begin();
318  for (;info_it != m_groups[group].end(); ++info_it) {
319  delete *info_it;
320  }
321  m_groups[group].clear();
322  m_groups.erase(group);
323  }
324  // Remove all groups
325  void GenericRenderer::removeAll() {
326  m_groups.clear();
327  }
328  // Clear all groups
329  void GenericRenderer::reset() {
330  removeAll();
331  }
332 
333  void GenericRenderer::render(Camera* cam, Layer* layer, RenderList& instances) {
334  std::map<std::string, std::vector<GenericRendererElementInfo*> >::iterator group_it = m_groups.begin();
335  for(; group_it != m_groups.end(); ++group_it) {
336  std::vector<GenericRendererElementInfo*>::const_iterator info_it = group_it->second.begin();
337  for (;info_it != group_it->second.end(); ++info_it) {
338  (*info_it)->render(cam, layer, instances, m_renderbackend);
339  }
340  }
341  }
342 }
virtual void setEnabled(bool enabled)
uint32_t scaleTime(float multiplier, uint32_t ticks)