Mercurial > fife-parpg

comparison engine/core/view/renderers/genericrenderer.cpp @ 23:e5e2fec68834

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add generic renderer
author spq@33b003aa-7bff-0310-803a-e67f0ece8222
date Fri, 11 Jul 2008 10:42:31 +0000
parents
children cb87d40e9342
comparison
equal deleted inserted replaced
22:aa0aea2572c9 23:e5e2fec68834
1 /***************************************************************************
2 * Copyright (C) 2005-2008 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 modify *
7 * it under the terms of the GNU General Public License as published by *
8 * the Free Software Foundation; either version 2 of the License, or *
9 * (at your option) any later version. *
10 * *
11 * This program 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 *
14 * GNU General Public License for more details. *
15 * *
16 * You should have received a copy of the GNU General Public License *
17 * along with this program; if not, write to the *
18 * Free Software Foundation, Inc., *
19 * 51 Franklin St, 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 "util/math/fife_math.h"
32 #include "util/log/logger.h"
33 #include "model/metamodel/grids/cellgrid.h"
34 #include "model/structures/instance.h"
35 #include "model/structures/layer.h"
36 #include "model/structures/location.h"
37
38 #include "view/camera.h"
39 #include "genericrenderer.h"
40
41
42 namespace FIFE {
43 static Logger _log(LM_VIEWVIEW);
44
45 GenericRendererNode::GenericRendererNode(Instance* attached_instance, Location* relative_location, const Point &relative_point):
46 m_instance(attached_instance),
47 m_location(relative_location),
48 m_point(relative_point) {
49 }
50 GenericRendererNode::GenericRendererNode(Instance* attached_instance, const Point &relative_point):
51 m_instance(attached_instance),
52 m_location(NULL),
53 m_point(relative_point) {
54 }
55 GenericRendererNode::GenericRendererNode(Location* attached_location, const Point &relative_point):
56 m_instance(NULL),
57 m_location(attached_location),
58 m_point(relative_point) {
59 }
60 GenericRendererNode::GenericRendererNode(const Point &attached_point):
61 m_instance(NULL),
62 m_location(NULL),
63 m_point(attached_point) {
64 }
65 GenericRendererNode::~GenericRendererNode() {
66 }
67
68 void GenericRendererNode::setAttached(Instance* attached_instance, const Location &relative_location, const Point &relative_point) {
69 }
70 void GenericRendererNode::setAttached(Instance* attached_instance, const Location &relative_location) {
71 }
72 void GenericRendererNode::setAttached(Instance* attached_instance, const Point &relative_point) {
73 }
74 void GenericRendererNode::setAttached(Instance* attached_instance) {
75 }
76 void GenericRendererNode::setAttached(const Location &attached_location, const Point &relative_point) {
77 }
78 void GenericRendererNode::setAttached(const Location &attached_location) {
79 }
80 void GenericRendererNode::setAttached(const Point &attached_point) {
81 }
82
83 void GenericRendererNode::setRelative(const Location &relative_location) {
84 }
85 void GenericRendererNode::setRelative(const Location &relative_location, Point relative_point) {
86 }
87 void GenericRendererNode::setRelative(const Point &relative_point) {
88 }
89
90 Instance* GenericRendererNode::getAttachedInstance() {
91 if(m_instance == NULL) {
92 throw "asd";
93 }
94 return m_instance;
95 }
96 Location* GenericRendererNode::getAttachedLocation() {
97 if(m_instance != NULL or m_location == NULL) {
98 throw "asd";
99 }
100 return m_location;
101 }
102 Point GenericRendererNode::getAttachedPoint() {
103 if(m_instance != NULL or m_location != NULL) {
104 throw "asd";
105 }
106 return m_point;
107 }
108
109 Location* GenericRendererNode::getOffsetLocation() {
110 if(m_instance == NULL) {
111 throw "asd";
112 }
113 return m_location;
114 }
115 Point GenericRendererNode::getOffsetPoint() {
116 if(m_instance == NULL and m_location == NULL) {
117 throw "asd";
118 }
119 return m_point;
120 }
121
122 Instance* GenericRendererNode::getInstance() {
123 return m_instance;
124 }
125 Location* GenericRendererNode::getLocation() {
126 return m_location;
127 }
128 Point GenericRendererNode::getPoint() {
129 return m_point;
130 }
131
132 Point GenericRendererNode::getCalculatedPoint(Camera* cam, Layer* layer, std::vector<Instance*>& instances) {
133 ScreenPoint p;
134 if(m_instance != NULL) {
135 if(m_location != NULL) {
136 p = cam->toScreenCoordinates(m_instance->getLocationRef().getMapCoordinates() + m_location->getMapCoordinates());
137 }
138 else {
139 p = cam->toScreenCoordinates(m_instance->getLocation().getMapCoordinates());
140 }
141 }
142 else if(m_location != NULL) {
143 p = cam->toScreenCoordinates(m_location->getMapCoordinates());
144 }
145 else
146 return m_point;
147 return Point(m_point.x + p.x, m_point.y + p.y);
148 }
149
150 GenericRendererLineInfo::GenericRendererLineInfo(GenericRendererNode n1, GenericRendererNode n2, uint8_t r, uint8_t g, uint8_t b):
151 GenericRendererElementInfo(),
152 n1(n1),
153 n2(n2),
154 r(r),
155 g(g),
156 b(b) {
157 }
158 void GenericRendererLineInfo::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances, RenderBackend* renderbackend) {
159 Point p1 = n1.getCalculatedPoint(cam, layer, instances);
160 Point p2 = n2.getCalculatedPoint(cam, layer, instances);
161 renderbackend->drawLine(p1, p2, r, g, b);
162 }
163
164 GenericRendererPointInfo::GenericRendererPointInfo(GenericRendererNode n, uint8_t r, uint8_t g, uint8_t b):
165 GenericRendererElementInfo(),
166 n(n),
167 r(r),
168 g(g),
169 b(b) {
170 }
171 void GenericRendererPointInfo::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances, RenderBackend* renderbackend) {
172 Point p = n.getCalculatedPoint(cam, layer, instances);
173 renderbackend->putPixel(p.x, p.y, r, g, b);
174 }
175
176 GenericRendererQuadInfo::GenericRendererQuadInfo(GenericRendererNode n1, GenericRendererNode n2, GenericRendererNode n3, GenericRendererNode n4, uint8_t r, uint8_t g, uint8_t b):
177 GenericRendererElementInfo(),
178 n1(n1),
179 n2(n2),
180 n3(n3),
181 n4(n4),
182 r(r),
183 g(g),
184 b(b) {
185 }
186 void GenericRendererQuadInfo::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances, RenderBackend* renderbackend) {
187 Point p1 = n1.getCalculatedPoint(cam, layer, instances);
188 Point p2 = n2.getCalculatedPoint(cam, layer, instances);
189 Point p3 = n3.getCalculatedPoint(cam, layer, instances);
190 Point p4 = n4.getCalculatedPoint(cam, layer, instances);
191 renderbackend->drawQuad(p1, p2, p3, p4, r, g, b);
192 }
193
194 GenericRendererImageInfo::GenericRendererImageInfo(GenericRendererNode n, int image):
195 GenericRendererElementInfo(),
196 n(n),
197 image(image) {
198 }
199 void GenericRendererImageInfo::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances, RenderBackend* renderbackend) {
200 return;
201 }
202
203 GenericRendererAnimationInfo::GenericRendererAnimationInfo(GenericRendererNode n, int animation):
204 GenericRendererElementInfo(),
205 n(n),
206 animation(animation) {
207 }
208 void GenericRendererAnimationInfo::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances, RenderBackend* renderbackend) {
209 return;
210 }
211
212 GenericRendererTextInfo::GenericRendererTextInfo(GenericRendererNode n, AbstractFont* font, std::string text):
213 GenericRendererElementInfo(),
214 n(n),
215 font(font),
216 text(text) {
217 }
218 void GenericRendererTextInfo::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances, RenderBackend* renderbackend) {
219 return;
220 }
221
222 GenericRenderer* GenericRenderer::getInstance(IRendererContainer* cnt) {
223 return dynamic_cast<GenericRenderer*>(cnt->getRenderer("GenericRenderer"));
224 }
225
226 GenericRenderer::GenericRenderer(RenderBackend* renderbackend, int position):
227 RendererBase(renderbackend, position),
228 m_infos() {
229 setEnabled(false);
230 }
231
232 GenericRenderer::GenericRenderer(const GenericRenderer& old):
233 RendererBase(old) {
234 setEnabled(false);
235 }
236
237 RendererBase* GenericRenderer::clone() {
238 return new GenericRenderer(*this);
239 }
240
241 GenericRenderer::~GenericRenderer() {
242 }
243 void GenericRenderer::addLine(GenericRendererNode n1, GenericRendererNode n2, uint8_t r, uint8_t g, uint8_t b) {
244 GenericRendererElementInfo* info = new GenericRendererLineInfo(n1, n2, r, g, b);
245 m_infos.push_back(info);
246 }
247 void GenericRenderer::addPoint(GenericRendererNode n, uint8_t r, uint8_t g, uint8_t b) {
248 GenericRendererElementInfo* info = new GenericRendererPointInfo(n, r, g, b);
249 m_infos.push_back(info);
250 }
251 void GenericRenderer::addQuad(GenericRendererNode n1, GenericRendererNode n2, GenericRendererNode n3, GenericRendererNode n4, uint8_t r, uint8_t g, uint8_t b) {
252 GenericRendererElementInfo* info = new GenericRendererQuadInfo(n1, n2, n3, n4, r, g, b);
253 m_infos.push_back(info);
254 }
255 void GenericRenderer::addText(GenericRendererNode n, AbstractFont* font, std::string text) {
256 GenericRendererElementInfo* info = new GenericRendererTextInfo(n, font, text);
257 m_infos.push_back(info);
258 }
259 void GenericRenderer::addImage(GenericRendererNode n, int image) {
260 GenericRendererElementInfo* info = new GenericRendererImageInfo(n, image);
261 m_infos.push_back(info);
262 }
263 void GenericRenderer::addAnimation(GenericRendererNode n, int animation) {
264 GenericRendererElementInfo* info = new GenericRendererAnimationInfo(n, animation);
265 m_infos.push_back(info);
266 }
267 void GenericRenderer::removeAll() {
268 m_infos.clear();
269 }
270
271 void GenericRenderer::render(Camera* cam, Layer* layer, std::vector<Instance*>& instances) {
272 std::vector<GenericRendererElementInfo*>::const_iterator info_it = m_infos.begin();
273 for (;info_it != m_infos.end(); ++info_it) {
274 GenericRendererElementInfo* info = *info_it;
275 info->render(cam, layer, instances, m_renderbackend);
276 }
277 }
278 }