diff options
author | David Walter Seikel | 2013-01-13 18:54:10 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 18:54:10 +1000 |
commit | 959831f4ef5a3e797f576c3de08cd65032c997ad (patch) | |
tree | e7351908be5995f0b325b2ebeaa02d5a34b82583 /libraries/irrlicht-1.8/source/Irrlicht/CTRFlat.cpp | |
parent | Add info about changes to Irrlicht. (diff) | |
download | SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.zip SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.gz SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.bz2 SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.xz |
Remove damned ancient DOS line endings from Irrlicht. Hopefully I did not go overboard.
Diffstat (limited to '')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CTRFlat.cpp | 600 |
1 files changed, 300 insertions, 300 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CTRFlat.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CTRFlat.cpp index 216e1a1..4a5c278 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/CTRFlat.cpp +++ b/libraries/irrlicht-1.8/source/Irrlicht/CTRFlat.cpp | |||
@@ -1,300 +1,300 @@ | |||
1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt | 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt |
2 | // This file is part of the "Irrlicht Engine". | 2 | // This file is part of the "Irrlicht Engine". |
3 | // For conditions of distribution and use, see copyright notice in irrlicht.h | 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h |
4 | 4 | ||
5 | #include "IrrCompileConfig.h" | 5 | #include "IrrCompileConfig.h" |
6 | #include "CTRTextureGouraud.h" | 6 | #include "CTRTextureGouraud.h" |
7 | 7 | ||
8 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ | 8 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ |
9 | 9 | ||
10 | namespace irr | 10 | namespace irr |
11 | { | 11 | { |
12 | namespace video | 12 | namespace video |
13 | { | 13 | { |
14 | 14 | ||
15 | class CTRFlat : public CTRTextureGouraud | 15 | class CTRFlat : public CTRTextureGouraud |
16 | { | 16 | { |
17 | public: | 17 | public: |
18 | 18 | ||
19 | CTRFlat(IZBuffer* zbuffer) | 19 | CTRFlat(IZBuffer* zbuffer) |
20 | : CTRTextureGouraud(zbuffer) | 20 | : CTRTextureGouraud(zbuffer) |
21 | { | 21 | { |
22 | #ifdef _DEBUG | 22 | #ifdef _DEBUG |
23 | setDebugName("CTRFlat"); | 23 | setDebugName("CTRFlat"); |
24 | #endif | 24 | #endif |
25 | } | 25 | } |
26 | 26 | ||
27 | //! draws an indexed triangle list | 27 | //! draws an indexed triangle list |
28 | virtual void drawIndexedTriangleList(S2DVertex* vertices, s32 vertexCount, const u16* indexList, s32 triangleCount) | 28 | virtual void drawIndexedTriangleList(S2DVertex* vertices, s32 vertexCount, const u16* indexList, s32 triangleCount) |
29 | { | 29 | { |
30 | const S2DVertex *v1, *v2, *v3; | 30 | const S2DVertex *v1, *v2, *v3; |
31 | 31 | ||
32 | u16 color; | 32 | u16 color; |
33 | f32 tmpDiv; // temporary division factor | 33 | f32 tmpDiv; // temporary division factor |
34 | f32 longest; // saves the longest span | 34 | f32 longest; // saves the longest span |
35 | s32 height; // saves height of triangle | 35 | s32 height; // saves height of triangle |
36 | u16* targetSurface; // target pointer where to plot pixels | 36 | u16* targetSurface; // target pointer where to plot pixels |
37 | s32 spanEnd; // saves end of spans | 37 | s32 spanEnd; // saves end of spans |
38 | f32 leftdeltaxf; // amount of pixels to increase on left side of triangle | 38 | f32 leftdeltaxf; // amount of pixels to increase on left side of triangle |
39 | f32 rightdeltaxf; // amount of pixels to increase on right side of triangle | 39 | f32 rightdeltaxf; // amount of pixels to increase on right side of triangle |
40 | s32 leftx, rightx; // position where we are | 40 | s32 leftx, rightx; // position where we are |
41 | f32 leftxf, rightxf; // same as above, but as f32 values | 41 | f32 leftxf, rightxf; // same as above, but as f32 values |
42 | s32 span; // current span | 42 | s32 span; // current span |
43 | u16 *hSpanBegin, *hSpanEnd; // pointer used when plotting pixels | 43 | u16 *hSpanBegin, *hSpanEnd; // pointer used when plotting pixels |
44 | core::rect<s32> TriangleRect; | 44 | core::rect<s32> TriangleRect; |
45 | 45 | ||
46 | s32 leftZValue, rightZValue; | 46 | s32 leftZValue, rightZValue; |
47 | s32 leftZStep, rightZStep; | 47 | s32 leftZStep, rightZStep; |
48 | s32 spanZValue, spanZStep; // ZValues when drawing a span | 48 | s32 spanZValue, spanZStep; // ZValues when drawing a span |
49 | TZBufferType* zTarget, *spanZTarget; // target of ZBuffer; | 49 | TZBufferType* zTarget, *spanZTarget; // target of ZBuffer; |
50 | 50 | ||
51 | lockedSurface = (u16*)RenderTarget->lock(); | 51 | lockedSurface = (u16*)RenderTarget->lock(); |
52 | lockedZBuffer = ZBuffer->lock(); | 52 | lockedZBuffer = ZBuffer->lock(); |
53 | 53 | ||
54 | for (s32 i=0; i<triangleCount; ++i) | 54 | for (s32 i=0; i<triangleCount; ++i) |
55 | { | 55 | { |
56 | v1 = &vertices[*indexList]; | 56 | v1 = &vertices[*indexList]; |
57 | ++indexList; | 57 | ++indexList; |
58 | v2 = &vertices[*indexList]; | 58 | v2 = &vertices[*indexList]; |
59 | ++indexList; | 59 | ++indexList; |
60 | v3 = &vertices[*indexList]; | 60 | v3 = &vertices[*indexList]; |
61 | ++indexList; | 61 | ++indexList; |
62 | 62 | ||
63 | // back face culling | 63 | // back face culling |
64 | 64 | ||
65 | if (BackFaceCullingEnabled) | 65 | if (BackFaceCullingEnabled) |
66 | { | 66 | { |
67 | s32 z = ((v3->Pos.X - v1->Pos.X) * (v3->Pos.Y - v2->Pos.Y)) - | 67 | s32 z = ((v3->Pos.X - v1->Pos.X) * (v3->Pos.Y - v2->Pos.Y)) - |
68 | ((v3->Pos.Y - v1->Pos.Y) * (v3->Pos.X - v2->Pos.X)); | 68 | ((v3->Pos.Y - v1->Pos.Y) * (v3->Pos.X - v2->Pos.X)); |
69 | 69 | ||
70 | if (z < 0) | 70 | if (z < 0) |
71 | continue; | 71 | continue; |
72 | } | 72 | } |
73 | 73 | ||
74 | //near plane clipping | 74 | //near plane clipping |
75 | 75 | ||
76 | if (v1->ZValue<0 && v2->ZValue<0 && v3->ZValue<0) | 76 | if (v1->ZValue<0 && v2->ZValue<0 && v3->ZValue<0) |
77 | continue; | 77 | continue; |
78 | 78 | ||
79 | // sort for width for inscreen clipping | 79 | // sort for width for inscreen clipping |
80 | 80 | ||
81 | if (v1->Pos.X > v2->Pos.X) swapVertices(&v1, &v2); | 81 | if (v1->Pos.X > v2->Pos.X) swapVertices(&v1, &v2); |
82 | if (v1->Pos.X > v3->Pos.X) swapVertices(&v1, &v3); | 82 | if (v1->Pos.X > v3->Pos.X) swapVertices(&v1, &v3); |
83 | if (v2->Pos.X > v3->Pos.X) swapVertices(&v2, &v3); | 83 | if (v2->Pos.X > v3->Pos.X) swapVertices(&v2, &v3); |
84 | 84 | ||
85 | if ((v1->Pos.X - v3->Pos.X) == 0) | 85 | if ((v1->Pos.X - v3->Pos.X) == 0) |
86 | continue; | 86 | continue; |
87 | 87 | ||
88 | TriangleRect.UpperLeftCorner.X = v1->Pos.X; | 88 | TriangleRect.UpperLeftCorner.X = v1->Pos.X; |
89 | TriangleRect.LowerRightCorner.X = v3->Pos.X; | 89 | TriangleRect.LowerRightCorner.X = v3->Pos.X; |
90 | 90 | ||
91 | // sort for height for faster drawing. | 91 | // sort for height for faster drawing. |
92 | 92 | ||
93 | if (v1->Pos.Y > v2->Pos.Y) swapVertices(&v1, &v2); | 93 | if (v1->Pos.Y > v2->Pos.Y) swapVertices(&v1, &v2); |
94 | if (v1->Pos.Y > v3->Pos.Y) swapVertices(&v1, &v3); | 94 | if (v1->Pos.Y > v3->Pos.Y) swapVertices(&v1, &v3); |
95 | if (v2->Pos.Y > v3->Pos.Y) swapVertices(&v2, &v3); | 95 | if (v2->Pos.Y > v3->Pos.Y) swapVertices(&v2, &v3); |
96 | 96 | ||
97 | TriangleRect.UpperLeftCorner.Y = v1->Pos.Y; | 97 | TriangleRect.UpperLeftCorner.Y = v1->Pos.Y; |
98 | TriangleRect.LowerRightCorner.Y = v3->Pos.Y; | 98 | TriangleRect.LowerRightCorner.Y = v3->Pos.Y; |
99 | 99 | ||
100 | if (!TriangleRect.isRectCollided(ViewPortRect)) | 100 | if (!TriangleRect.isRectCollided(ViewPortRect)) |
101 | continue; | 101 | continue; |
102 | 102 | ||
103 | // calculate height of triangle | 103 | // calculate height of triangle |
104 | height = v3->Pos.Y - v1->Pos.Y; | 104 | height = v3->Pos.Y - v1->Pos.Y; |
105 | if (!height) | 105 | if (!height) |
106 | continue; | 106 | continue; |
107 | 107 | ||
108 | // calculate longest span | 108 | // calculate longest span |
109 | 109 | ||
110 | longest = (v2->Pos.Y - v1->Pos.Y) / (f32)height * (v3->Pos.X - v1->Pos.X) + (v1->Pos.X - v2->Pos.X); | 110 | longest = (v2->Pos.Y - v1->Pos.Y) / (f32)height * (v3->Pos.X - v1->Pos.X) + (v1->Pos.X - v2->Pos.X); |
111 | 111 | ||
112 | spanEnd = v2->Pos.Y; | 112 | spanEnd = v2->Pos.Y; |
113 | span = v1->Pos.Y; | 113 | span = v1->Pos.Y; |
114 | leftxf = (f32)v1->Pos.X; | 114 | leftxf = (f32)v1->Pos.X; |
115 | rightxf = (f32)v1->Pos.X; | 115 | rightxf = (f32)v1->Pos.X; |
116 | 116 | ||
117 | leftZValue = v1->ZValue; | 117 | leftZValue = v1->ZValue; |
118 | rightZValue = v1->ZValue; | 118 | rightZValue = v1->ZValue; |
119 | 119 | ||
120 | color = v1->Color; | 120 | color = v1->Color; |
121 | 121 | ||
122 | targetSurface = lockedSurface + span * SurfaceWidth; | 122 | targetSurface = lockedSurface + span * SurfaceWidth; |
123 | zTarget = lockedZBuffer + span * SurfaceWidth; | 123 | zTarget = lockedZBuffer + span * SurfaceWidth; |
124 | 124 | ||
125 | if (longest < 0.0f) | 125 | if (longest < 0.0f) |
126 | { | 126 | { |
127 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); | 127 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); |
128 | rightdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; | 128 | rightdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; |
129 | rightZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); | 129 | rightZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); |
130 | 130 | ||
131 | tmpDiv = 1.0f / (f32)height; | 131 | tmpDiv = 1.0f / (f32)height; |
132 | leftdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; | 132 | leftdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; |
133 | leftZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); | 133 | leftZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); |
134 | } | 134 | } |
135 | else | 135 | else |
136 | { | 136 | { |
137 | tmpDiv = 1.0f / (f32)height; | 137 | tmpDiv = 1.0f / (f32)height; |
138 | rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; | 138 | rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; |
139 | rightZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); | 139 | rightZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); |
140 | 140 | ||
141 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); | 141 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); |
142 | leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; | 142 | leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; |
143 | leftZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); | 143 | leftZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); |
144 | } | 144 | } |
145 | 145 | ||
146 | 146 | ||
147 | // do it twice, once for the first half of the triangle, | 147 | // do it twice, once for the first half of the triangle, |
148 | // end then for the second half. | 148 | // end then for the second half. |
149 | 149 | ||
150 | for (s32 triangleHalf=0; triangleHalf<2; ++triangleHalf) | 150 | for (s32 triangleHalf=0; triangleHalf<2; ++triangleHalf) |
151 | { | 151 | { |
152 | if (spanEnd > ViewPortRect.LowerRightCorner.Y) | 152 | if (spanEnd > ViewPortRect.LowerRightCorner.Y) |
153 | spanEnd = ViewPortRect.LowerRightCorner.Y; | 153 | spanEnd = ViewPortRect.LowerRightCorner.Y; |
154 | 154 | ||
155 | // if the span <0, than we can skip these spans, | 155 | // if the span <0, than we can skip these spans, |
156 | // and proceed to the next spans which are really on the screen. | 156 | // and proceed to the next spans which are really on the screen. |
157 | if (span < ViewPortRect.UpperLeftCorner.Y) | 157 | if (span < ViewPortRect.UpperLeftCorner.Y) |
158 | { | 158 | { |
159 | // we'll use leftx as temp variable | 159 | // we'll use leftx as temp variable |
160 | if (spanEnd < ViewPortRect.UpperLeftCorner.Y) | 160 | if (spanEnd < ViewPortRect.UpperLeftCorner.Y) |
161 | { | 161 | { |
162 | leftx = spanEnd - span; | 162 | leftx = spanEnd - span; |
163 | span = spanEnd; | 163 | span = spanEnd; |
164 | } | 164 | } |
165 | else | 165 | else |
166 | { | 166 | { |
167 | leftx = ViewPortRect.UpperLeftCorner.Y - span; | 167 | leftx = ViewPortRect.UpperLeftCorner.Y - span; |
168 | span = ViewPortRect.UpperLeftCorner.Y; | 168 | span = ViewPortRect.UpperLeftCorner.Y; |
169 | } | 169 | } |
170 | 170 | ||
171 | leftxf += leftdeltaxf*leftx; | 171 | leftxf += leftdeltaxf*leftx; |
172 | rightxf += rightdeltaxf*leftx; | 172 | rightxf += rightdeltaxf*leftx; |
173 | targetSurface += SurfaceWidth*leftx; | 173 | targetSurface += SurfaceWidth*leftx; |
174 | zTarget += SurfaceWidth*leftx; | 174 | zTarget += SurfaceWidth*leftx; |
175 | leftZValue += leftZStep*leftx; | 175 | leftZValue += leftZStep*leftx; |
176 | rightZValue += rightZStep*leftx; | 176 | rightZValue += rightZStep*leftx; |
177 | } | 177 | } |
178 | 178 | ||
179 | 179 | ||
180 | // the main loop. Go through every span and draw it. | 180 | // the main loop. Go through every span and draw it. |
181 | 181 | ||
182 | while (span < spanEnd) | 182 | while (span < spanEnd) |
183 | { | 183 | { |
184 | leftx = (s32)(leftxf); | 184 | leftx = (s32)(leftxf); |
185 | rightx = (s32)(rightxf + 0.5f); | 185 | rightx = (s32)(rightxf + 0.5f); |
186 | 186 | ||
187 | // perform some clipping | 187 | // perform some clipping |
188 | 188 | ||
189 | // TODO: clipping is not correct when leftx is clipped. | 189 | // TODO: clipping is not correct when leftx is clipped. |
190 | 190 | ||
191 | if (leftx<ViewPortRect.UpperLeftCorner.X) | 191 | if (leftx<ViewPortRect.UpperLeftCorner.X) |
192 | leftx = ViewPortRect.UpperLeftCorner.X; | 192 | leftx = ViewPortRect.UpperLeftCorner.X; |
193 | else | 193 | else |
194 | if (leftx>ViewPortRect.LowerRightCorner.X) | 194 | if (leftx>ViewPortRect.LowerRightCorner.X) |
195 | leftx = ViewPortRect.LowerRightCorner.X; | 195 | leftx = ViewPortRect.LowerRightCorner.X; |
196 | 196 | ||
197 | if (rightx<ViewPortRect.UpperLeftCorner.X) | 197 | if (rightx<ViewPortRect.UpperLeftCorner.X) |
198 | rightx = ViewPortRect.UpperLeftCorner.X; | 198 | rightx = ViewPortRect.UpperLeftCorner.X; |
199 | else | 199 | else |
200 | if (rightx>ViewPortRect.LowerRightCorner.X) | 200 | if (rightx>ViewPortRect.LowerRightCorner.X) |
201 | rightx = ViewPortRect.LowerRightCorner.X; | 201 | rightx = ViewPortRect.LowerRightCorner.X; |
202 | 202 | ||
203 | // draw the span | 203 | // draw the span |
204 | 204 | ||
205 | if (rightx - leftx != 0) | 205 | if (rightx - leftx != 0) |
206 | { | 206 | { |
207 | tmpDiv = 1.0f / (rightx - leftx); | 207 | tmpDiv = 1.0f / (rightx - leftx); |
208 | spanZValue = leftZValue; | 208 | spanZValue = leftZValue; |
209 | spanZStep = (s32)((rightZValue - leftZValue) * tmpDiv); | 209 | spanZStep = (s32)((rightZValue - leftZValue) * tmpDiv); |
210 | 210 | ||
211 | hSpanBegin = targetSurface + leftx; | 211 | hSpanBegin = targetSurface + leftx; |
212 | spanZTarget = zTarget + leftx; | 212 | spanZTarget = zTarget + leftx; |
213 | hSpanEnd = targetSurface + rightx; | 213 | hSpanEnd = targetSurface + rightx; |
214 | 214 | ||
215 | while (hSpanBegin < hSpanEnd) | 215 | while (hSpanBegin < hSpanEnd) |
216 | { | 216 | { |
217 | if (spanZValue > *spanZTarget) | 217 | if (spanZValue > *spanZTarget) |
218 | { | 218 | { |
219 | *spanZTarget = spanZValue; | 219 | *spanZTarget = spanZValue; |
220 | *hSpanBegin = color; | 220 | *hSpanBegin = color; |
221 | } | 221 | } |
222 | 222 | ||
223 | spanZValue += spanZStep; | 223 | spanZValue += spanZStep; |
224 | ++hSpanBegin; | 224 | ++hSpanBegin; |
225 | ++spanZTarget; | 225 | ++spanZTarget; |
226 | } | 226 | } |
227 | } | 227 | } |
228 | 228 | ||
229 | leftxf += leftdeltaxf; | 229 | leftxf += leftdeltaxf; |
230 | rightxf += rightdeltaxf; | 230 | rightxf += rightdeltaxf; |
231 | ++span; | 231 | ++span; |
232 | targetSurface += SurfaceWidth; | 232 | targetSurface += SurfaceWidth; |
233 | zTarget += SurfaceWidth; | 233 | zTarget += SurfaceWidth; |
234 | leftZValue += leftZStep; | 234 | leftZValue += leftZStep; |
235 | rightZValue += rightZStep; | 235 | rightZValue += rightZStep; |
236 | } | 236 | } |
237 | 237 | ||
238 | if (triangleHalf>0) // break, we've gout only two halves | 238 | if (triangleHalf>0) // break, we've gout only two halves |
239 | break; | 239 | break; |
240 | 240 | ||
241 | 241 | ||
242 | // setup variables for second half of the triangle. | 242 | // setup variables for second half of the triangle. |
243 | 243 | ||
244 | if (longest < 0.0f) | 244 | if (longest < 0.0f) |
245 | { | 245 | { |
246 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); | 246 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); |
247 | 247 | ||
248 | rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; | 248 | rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; |
249 | rightxf = (f32)v2->Pos.X; | 249 | rightxf = (f32)v2->Pos.X; |
250 | 250 | ||
251 | rightZValue = v2->ZValue; | 251 | rightZValue = v2->ZValue; |
252 | rightZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); | 252 | rightZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); |
253 | } | 253 | } |
254 | else | 254 | else |
255 | { | 255 | { |
256 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); | 256 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); |
257 | 257 | ||
258 | leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; | 258 | leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; |
259 | leftxf = (f32)v2->Pos.X; | 259 | leftxf = (f32)v2->Pos.X; |
260 | 260 | ||
261 | leftZValue = v2->ZValue; | 261 | leftZValue = v2->ZValue; |
262 | leftZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); | 262 | leftZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); |
263 | } | 263 | } |
264 | 264 | ||
265 | 265 | ||
266 | spanEnd = v3->Pos.Y; | 266 | spanEnd = v3->Pos.Y; |
267 | } | 267 | } |
268 | 268 | ||
269 | } | 269 | } |
270 | 270 | ||
271 | RenderTarget->unlock(); | 271 | RenderTarget->unlock(); |
272 | ZBuffer->unlock(); | 272 | ZBuffer->unlock(); |
273 | } | 273 | } |
274 | }; | 274 | }; |
275 | 275 | ||
276 | } // end namespace video | 276 | } // end namespace video |
277 | } // end namespace irr | 277 | } // end namespace irr |
278 | 278 | ||
279 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ | 279 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ |
280 | 280 | ||
281 | namespace irr | 281 | namespace irr |
282 | { | 282 | { |
283 | namespace video | 283 | namespace video |
284 | { | 284 | { |
285 | 285 | ||
286 | //! creates a flat triangle renderer | 286 | //! creates a flat triangle renderer |
287 | ITriangleRenderer* createTriangleRendererFlat(IZBuffer* zbuffer) | 287 | ITriangleRenderer* createTriangleRendererFlat(IZBuffer* zbuffer) |
288 | { | 288 | { |
289 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ | 289 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ |
290 | return new CTRFlat(zbuffer); | 290 | return new CTRFlat(zbuffer); |
291 | #else | 291 | #else |
292 | return 0; | 292 | return 0; |
293 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ | 293 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ |
294 | } | 294 | } |
295 | 295 | ||
296 | } // end namespace video | 296 | } // end namespace video |
297 | } // end namespace irr | 297 | } // end namespace irr |
298 | 298 | ||
299 | 299 | ||
300 | 300 | ||