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"
44 #include "view/camera.h"
45 #include "genericrenderer.h"
49 static Logger _log(LM_VIEWVIEW);
51 GenericRendererLineInfo::GenericRendererLineInfo(RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
52 GenericRendererElementInfo(),
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);
68 GenericRendererPointInfo::GenericRendererPointInfo(RendererNode anchor, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
69 GenericRendererElementInfo(),
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);
83 GenericRendererTriangleInfo::GenericRendererTriangleInfo(RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
84 GenericRendererElementInfo(),
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);
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(),
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);
123 GenericRendererVertexInfo::GenericRendererVertexInfo(RendererNode center, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a):
124 GenericRendererElementInfo(),
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);
139 GenericRendererImageInfo::GenericRendererImageInfo(RendererNode anchor, ImagePtr image,
bool zoomed):
140 GenericRendererElementInfo(),
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) {
149 Rect viewport = cam->getViewPort();
150 uint32_t width, height;
152 width =
static_cast<uint32_t
>(round(m_image->getWidth() * cam->getZoom()));
153 height =
static_cast<uint32_t
>(round(m_image->getHeight() * cam->getZoom()));
156 width = m_image->getWidth();
157 height = m_image->getHeight();
163 if(r.intersects(viewport)) {
169 GenericRendererAnimationInfo::GenericRendererAnimationInfo(RendererNode anchor, AnimationPtr animation,
bool zoomed):
170 GenericRendererElementInfo(),
172 m_animation(animation),
173 m_start_time(TimeManager::instance()->getTime()),
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);
183 Rect viewport = cam->getViewPort();
184 uint32_t width, height;
186 width =
static_cast<uint32_t
>(round(img->getWidth() * cam->getZoom()));
187 height =
static_cast<uint32_t
>(round(img->getHeight() * cam->getZoom()));
189 width = img->getWidth();
190 height = img->getHeight();
196 if(r.intersects(viewport)) {
202 GenericRendererTextInfo::GenericRendererTextInfo(RendererNode anchor, IFont* font, std::string text):
203 GenericRendererElementInfo(),
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);
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)) {
220 if (renderbackend->getLightingModel() > 0) {
221 renderbackend->changeRenderInfos(1, 4, 5,
false,
false, 0, KEEP, ALWAYS);
227 GenericRendererResizeInfo::GenericRendererResizeInfo(RendererNode anchor, ImagePtr image, int32_t width, int32_t height,
bool zoomed):
228 GenericRendererElementInfo(),
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) {
239 Rect viewport = cam->getViewPort();
240 uint32_t width, height;
242 width =
static_cast<uint32_t
>(round(m_width * cam->getZoom()));
243 height =
static_cast<uint32_t
>(round(m_height * cam->getZoom()));
252 if(r.intersects(viewport)) {
258 GenericRenderer* GenericRenderer::getInstance(IRendererContainer* cnt) {
259 return dynamic_cast<GenericRenderer*
>(cnt->getRenderer(
"GenericRenderer"));
262 GenericRenderer::GenericRenderer(RenderBackend* renderbackend, int32_t position):
263 RendererBase(renderbackend, position),
268 GenericRenderer::GenericRenderer(
const GenericRenderer& old):
274 RendererBase* GenericRenderer::clone() {
275 return new GenericRenderer(*
this);
278 GenericRenderer::~GenericRenderer() {
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);
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);
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);
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);
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);
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);
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);
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);
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);
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) {
321 m_groups[group].clear();
322 m_groups.erase(group);
325 void GenericRenderer::removeAll() {
329 void GenericRenderer::reset() {
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);
virtual void setEnabled(bool enabled)
uint32_t scaleTime(float multiplier, uint32_t ticks)
credit to phoku for his NodeDisplay example which the visitor code is adapted from ( he coded the qua...