aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp
diff options
context:
space:
mode:
authorDavid Walter Seikel2013-01-13 18:54:10 +1000
committerDavid Walter Seikel2013-01-13 18:54:10 +1000
commit959831f4ef5a3e797f576c3de08cd65032c997ad (patch)
treee7351908be5995f0b325b2ebeaa02d5a34b82583 /libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp
parentAdd info about changes to Irrlicht. (diff)
downloadSledjHamr-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 'libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp678
1 files changed, 339 insertions, 339 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp
index d1c0c54..5b9ceb2 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp
+++ b/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureFlat.cpp
@@ -1,339 +1,339 @@
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
10namespace irr 10namespace irr
11{ 11{
12namespace video 12namespace video
13{ 13{
14 14
15class CTRTextureFlat : public CTRTextureGouraud 15class CTRTextureFlat : public CTRTextureGouraud
16{ 16{
17public: 17public:
18 18
19 CTRTextureFlat(IZBuffer* zbuffer) 19 CTRTextureFlat(IZBuffer* zbuffer)
20 : CTRTextureGouraud(zbuffer) 20 : CTRTextureGouraud(zbuffer)
21 { 21 {
22 #ifdef _DEBUG 22 #ifdef _DEBUG
23 setDebugName("CTRTextureFlat"); 23 setDebugName("CTRTextureFlat");
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 f32 tmpDiv; // temporary division factor 32 f32 tmpDiv; // temporary division factor
33 f32 longest; // saves the longest span 33 f32 longest; // saves the longest span
34 s32 height; // saves height of triangle 34 s32 height; // saves height of triangle
35 u16* targetSurface; // target pointer where to plot pixels 35 u16* targetSurface; // target pointer where to plot pixels
36 s32 spanEnd; // saves end of spans 36 s32 spanEnd; // saves end of spans
37 f32 leftdeltaxf; // amount of pixels to increase on left side of triangle 37 f32 leftdeltaxf; // amount of pixels to increase on left side of triangle
38 f32 rightdeltaxf; // amount of pixels to increase on right side of triangle 38 f32 rightdeltaxf; // amount of pixels to increase on right side of triangle
39 s32 leftx, rightx; // position where we are 39 s32 leftx, rightx; // position where we are
40 f32 leftxf, rightxf; // same as above, but as f32 values 40 f32 leftxf, rightxf; // same as above, but as f32 values
41 s32 span; // current span 41 s32 span; // current span
42 u16 *hSpanBegin, *hSpanEnd; // pointer used when plotting pixels 42 u16 *hSpanBegin, *hSpanEnd; // pointer used when plotting pixels
43 s32 leftTx, rightTx, leftTy, rightTy; // texture interpolating values 43 s32 leftTx, rightTx, leftTy, rightTy; // texture interpolating values
44 s32 leftTxStep, rightTxStep, leftTyStep, rightTyStep; // texture interpolating values 44 s32 leftTxStep, rightTxStep, leftTyStep, rightTyStep; // texture interpolating values
45 s32 spanTx, spanTy, spanTxStep, spanTyStep; // values of Texturecoords when drawing a span 45 s32 spanTx, spanTy, spanTxStep, spanTyStep; // values of Texturecoords when drawing a span
46 core::rect<s32> TriangleRect; 46 core::rect<s32> TriangleRect;
47 47
48 s32 leftZValue, rightZValue; 48 s32 leftZValue, rightZValue;
49 s32 leftZStep, rightZStep; 49 s32 leftZStep, rightZStep;
50 s32 spanZValue, spanZStep; // ZValues when drawing a span 50 s32 spanZValue, spanZStep; // ZValues when drawing a span
51 TZBufferType* zTarget, *spanZTarget; // target of ZBuffer; 51 TZBufferType* zTarget, *spanZTarget; // target of ZBuffer;
52 52
53 lockedSurface = (u16*)RenderTarget->lock(); 53 lockedSurface = (u16*)RenderTarget->lock();
54 lockedZBuffer = ZBuffer->lock(); 54 lockedZBuffer = ZBuffer->lock();
55 lockedTexture = (u16*)Texture->lock(); 55 lockedTexture = (u16*)Texture->lock();
56 56
57 for (s32 i=0; i<triangleCount; ++i) 57 for (s32 i=0; i<triangleCount; ++i)
58 { 58 {
59 v1 = &vertices[*indexList]; 59 v1 = &vertices[*indexList];
60 ++indexList; 60 ++indexList;
61 v2 = &vertices[*indexList]; 61 v2 = &vertices[*indexList];
62 ++indexList; 62 ++indexList;
63 v3 = &vertices[*indexList]; 63 v3 = &vertices[*indexList];
64 ++indexList; 64 ++indexList;
65 65
66 // back face culling 66 // back face culling
67 67
68 if (BackFaceCullingEnabled) 68 if (BackFaceCullingEnabled)
69 { 69 {
70 s32 z = ((v3->Pos.X - v1->Pos.X) * (v3->Pos.Y - v2->Pos.Y)) - 70 s32 z = ((v3->Pos.X - v1->Pos.X) * (v3->Pos.Y - v2->Pos.Y)) -
71 ((v3->Pos.Y - v1->Pos.Y) * (v3->Pos.X - v2->Pos.X)); 71 ((v3->Pos.Y - v1->Pos.Y) * (v3->Pos.X - v2->Pos.X));
72 72
73 if (z < 0) 73 if (z < 0)
74 continue; 74 continue;
75 } 75 }
76 76
77 //near plane clipping 77 //near plane clipping
78 78
79 if (v1->ZValue<0 && v2->ZValue<0 && v3->ZValue<0) 79 if (v1->ZValue<0 && v2->ZValue<0 && v3->ZValue<0)
80 continue; 80 continue;
81 81
82 // sort for width for inscreen clipping 82 // sort for width for inscreen clipping
83 83
84 if (v1->Pos.X > v2->Pos.X) swapVertices(&v1, &v2); 84 if (v1->Pos.X > v2->Pos.X) swapVertices(&v1, &v2);
85 if (v1->Pos.X > v3->Pos.X) swapVertices(&v1, &v3); 85 if (v1->Pos.X > v3->Pos.X) swapVertices(&v1, &v3);
86 if (v2->Pos.X > v3->Pos.X) swapVertices(&v2, &v3); 86 if (v2->Pos.X > v3->Pos.X) swapVertices(&v2, &v3);
87 87
88 if ((v1->Pos.X - v3->Pos.X) == 0) 88 if ((v1->Pos.X - v3->Pos.X) == 0)
89 continue; 89 continue;
90 90
91 TriangleRect.UpperLeftCorner.X = v1->Pos.X; 91 TriangleRect.UpperLeftCorner.X = v1->Pos.X;
92 TriangleRect.LowerRightCorner.X = v3->Pos.X; 92 TriangleRect.LowerRightCorner.X = v3->Pos.X;
93 93
94 // sort for height for faster drawing. 94 // sort for height for faster drawing.
95 95
96 if (v1->Pos.Y > v2->Pos.Y) swapVertices(&v1, &v2); 96 if (v1->Pos.Y > v2->Pos.Y) swapVertices(&v1, &v2);
97 if (v1->Pos.Y > v3->Pos.Y) swapVertices(&v1, &v3); 97 if (v1->Pos.Y > v3->Pos.Y) swapVertices(&v1, &v3);
98 if (v2->Pos.Y > v3->Pos.Y) swapVertices(&v2, &v3); 98 if (v2->Pos.Y > v3->Pos.Y) swapVertices(&v2, &v3);
99 99
100 TriangleRect.UpperLeftCorner.Y = v1->Pos.Y; 100 TriangleRect.UpperLeftCorner.Y = v1->Pos.Y;
101 TriangleRect.LowerRightCorner.Y = v3->Pos.Y; 101 TriangleRect.LowerRightCorner.Y = v3->Pos.Y;
102 102
103 if (!TriangleRect.isRectCollided(ViewPortRect)) 103 if (!TriangleRect.isRectCollided(ViewPortRect))
104 continue; 104 continue;
105 105
106 // calculate height of triangle 106 // calculate height of triangle
107 height = v3->Pos.Y - v1->Pos.Y; 107 height = v3->Pos.Y - v1->Pos.Y;
108 if (!height) 108 if (!height)
109 continue; 109 continue;
110 110
111 // calculate longest span 111 // calculate longest span
112 112
113 longest = (v2->Pos.Y - v1->Pos.Y) / (f32)height * (v3->Pos.X - v1->Pos.X) + (v1->Pos.X - v2->Pos.X); 113 longest = (v2->Pos.Y - v1->Pos.Y) / (f32)height * (v3->Pos.X - v1->Pos.X) + (v1->Pos.X - v2->Pos.X);
114 114
115 spanEnd = v2->Pos.Y; 115 spanEnd = v2->Pos.Y;
116 span = v1->Pos.Y; 116 span = v1->Pos.Y;
117 leftxf = (f32)v1->Pos.X; 117 leftxf = (f32)v1->Pos.X;
118 rightxf = (f32)v1->Pos.X; 118 rightxf = (f32)v1->Pos.X;
119 119
120 leftZValue = v1->ZValue; 120 leftZValue = v1->ZValue;
121 rightZValue = v1->ZValue; 121 rightZValue = v1->ZValue;
122 122
123 leftTx = rightTx = v1->TCoords.X; 123 leftTx = rightTx = v1->TCoords.X;
124 leftTy = rightTy = v1->TCoords.Y; 124 leftTy = rightTy = v1->TCoords.Y;
125 125
126 targetSurface = lockedSurface + span * SurfaceWidth; 126 targetSurface = lockedSurface + span * SurfaceWidth;
127 zTarget = lockedZBuffer + span * SurfaceWidth; 127 zTarget = lockedZBuffer + span * SurfaceWidth;
128 128
129 if (longest < 0.0f) 129 if (longest < 0.0f)
130 { 130 {
131 tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); 131 tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y);
132 rightdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; 132 rightdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv;
133 rightZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); 133 rightZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv);
134 rightTxStep = (s32)((v2->TCoords.X - rightTx) * tmpDiv); 134 rightTxStep = (s32)((v2->TCoords.X - rightTx) * tmpDiv);
135 rightTyStep = (s32)((v2->TCoords.Y - rightTy) * tmpDiv); 135 rightTyStep = (s32)((v2->TCoords.Y - rightTy) * tmpDiv);
136 136
137 tmpDiv = 1.0f / (f32)height; 137 tmpDiv = 1.0f / (f32)height;
138 leftdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; 138 leftdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv;
139 leftZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); 139 leftZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv);
140 leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv); 140 leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv);
141 leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv); 141 leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv);
142 } 142 }
143 else 143 else
144 { 144 {
145 tmpDiv = 1.0f / (f32)height; 145 tmpDiv = 1.0f / (f32)height;
146 rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; 146 rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv;
147 rightZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); 147 rightZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv);
148 rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv); 148 rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv);
149 rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv); 149 rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv);
150 150
151 tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); 151 tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y);
152 leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; 152 leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv;
153 leftZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); 153 leftZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv);
154 leftTxStep = (s32)((v2->TCoords.X - leftTx) * tmpDiv); 154 leftTxStep = (s32)((v2->TCoords.X - leftTx) * tmpDiv);
155 leftTyStep = (s32)((v2->TCoords.Y - leftTy) * tmpDiv); 155 leftTyStep = (s32)((v2->TCoords.Y - leftTy) * tmpDiv);
156 } 156 }
157 157
158 158
159 // do it twice, once for the first half of the triangle, 159 // do it twice, once for the first half of the triangle,
160 // end then for the second half. 160 // end then for the second half.
161 161
162 for (s32 triangleHalf=0; triangleHalf<2; ++triangleHalf) 162 for (s32 triangleHalf=0; triangleHalf<2; ++triangleHalf)
163 { 163 {
164 if (spanEnd > ViewPortRect.LowerRightCorner.Y) 164 if (spanEnd > ViewPortRect.LowerRightCorner.Y)
165 spanEnd = ViewPortRect.LowerRightCorner.Y; 165 spanEnd = ViewPortRect.LowerRightCorner.Y;
166 166
167 // if the span <0, than we can skip these spans, 167 // if the span <0, than we can skip these spans,
168 // and proceed to the next spans which are really on the screen. 168 // and proceed to the next spans which are really on the screen.
169 if (span < ViewPortRect.UpperLeftCorner.Y) 169 if (span < ViewPortRect.UpperLeftCorner.Y)
170 { 170 {
171 // we'll use leftx as temp variable 171 // we'll use leftx as temp variable
172 if (spanEnd < ViewPortRect.UpperLeftCorner.Y) 172 if (spanEnd < ViewPortRect.UpperLeftCorner.Y)
173 { 173 {
174 leftx = spanEnd - span; 174 leftx = spanEnd - span;
175 span = spanEnd; 175 span = spanEnd;
176 } 176 }
177 else 177 else
178 { 178 {
179 leftx = ViewPortRect.UpperLeftCorner.Y - span; 179 leftx = ViewPortRect.UpperLeftCorner.Y - span;
180 span = ViewPortRect.UpperLeftCorner.Y; 180 span = ViewPortRect.UpperLeftCorner.Y;
181 } 181 }
182 182
183 leftxf += leftdeltaxf*leftx; 183 leftxf += leftdeltaxf*leftx;
184 rightxf += rightdeltaxf*leftx; 184 rightxf += rightdeltaxf*leftx;
185 targetSurface += SurfaceWidth*leftx; 185 targetSurface += SurfaceWidth*leftx;
186 zTarget += SurfaceWidth*leftx; 186 zTarget += SurfaceWidth*leftx;
187 leftZValue += leftZStep*leftx; 187 leftZValue += leftZStep*leftx;
188 rightZValue += rightZStep*leftx; 188 rightZValue += rightZStep*leftx;
189 189
190 leftTx += leftTxStep*leftx; 190 leftTx += leftTxStep*leftx;
191 leftTy += leftTyStep*leftx; 191 leftTy += leftTyStep*leftx;
192 rightTx += rightTxStep*leftx; 192 rightTx += rightTxStep*leftx;
193 rightTy += rightTyStep*leftx; 193 rightTy += rightTyStep*leftx;
194 } 194 }
195 195
196 196
197 // the main loop. Go through every span and draw it. 197 // the main loop. Go through every span and draw it.
198 198
199 while (span < spanEnd) 199 while (span < spanEnd)
200 { 200 {
201 leftx = (s32)(leftxf); 201 leftx = (s32)(leftxf);
202 rightx = (s32)(rightxf + 0.5f); 202 rightx = (s32)(rightxf + 0.5f);
203 203
204 // perform some clipping 204 // perform some clipping
205 205
206 // TODO: clipping is not correct when leftx is clipped. 206 // TODO: clipping is not correct when leftx is clipped.
207 207
208 if (leftx<ViewPortRect.UpperLeftCorner.X) 208 if (leftx<ViewPortRect.UpperLeftCorner.X)
209 leftx = ViewPortRect.UpperLeftCorner.X; 209 leftx = ViewPortRect.UpperLeftCorner.X;
210 else 210 else
211 if (leftx>ViewPortRect.LowerRightCorner.X) 211 if (leftx>ViewPortRect.LowerRightCorner.X)
212 leftx = ViewPortRect.LowerRightCorner.X; 212 leftx = ViewPortRect.LowerRightCorner.X;
213 213
214 if (rightx<ViewPortRect.UpperLeftCorner.X) 214 if (rightx<ViewPortRect.UpperLeftCorner.X)
215 rightx = ViewPortRect.UpperLeftCorner.X; 215 rightx = ViewPortRect.UpperLeftCorner.X;
216 else 216 else
217 if (rightx>ViewPortRect.LowerRightCorner.X) 217 if (rightx>ViewPortRect.LowerRightCorner.X)
218 rightx = ViewPortRect.LowerRightCorner.X; 218 rightx = ViewPortRect.LowerRightCorner.X;
219 219
220 // draw the span 220 // draw the span
221 221
222 if (rightx - leftx != 0) 222 if (rightx - leftx != 0)
223 { 223 {
224 tmpDiv = 1.0f / (rightx - leftx); 224 tmpDiv = 1.0f / (rightx - leftx);
225 spanZValue = leftZValue; 225 spanZValue = leftZValue;
226 spanZStep = (s32)((rightZValue - leftZValue) * tmpDiv); 226 spanZStep = (s32)((rightZValue - leftZValue) * tmpDiv);
227 227
228 hSpanBegin = targetSurface + leftx; 228 hSpanBegin = targetSurface + leftx;
229 spanZTarget = zTarget + leftx; 229 spanZTarget = zTarget + leftx;
230 hSpanEnd = targetSurface + rightx; 230 hSpanEnd = targetSurface + rightx;
231 231
232 spanTx = leftTx; 232 spanTx = leftTx;
233 spanTy = leftTy; 233 spanTy = leftTy;
234 spanTxStep = (s32)((rightTx - leftTx) * tmpDiv); 234 spanTxStep = (s32)((rightTx - leftTx) * tmpDiv);
235 spanTyStep = (s32)((rightTy - leftTy) * tmpDiv); 235 spanTyStep = (s32)((rightTy - leftTy) * tmpDiv);
236 236
237 while (hSpanBegin < hSpanEnd) 237 while (hSpanBegin < hSpanEnd)
238 { 238 {
239 if (spanZValue > *spanZTarget) 239 if (spanZValue > *spanZTarget)
240 { 240 {
241 *spanZTarget = spanZValue; 241 *spanZTarget = spanZValue;
242 *hSpanBegin = lockedTexture[((spanTy>>8)&textureYMask) * lockedTextureWidth + ((spanTx>>8)&textureXMask)]; 242 *hSpanBegin = lockedTexture[((spanTy>>8)&textureYMask) * lockedTextureWidth + ((spanTx>>8)&textureXMask)];
243 } 243 }
244 244
245 spanTx += spanTxStep; 245 spanTx += spanTxStep;
246 spanTy += spanTyStep; 246 spanTy += spanTyStep;
247 247
248 spanZValue += spanZStep; 248 spanZValue += spanZStep;
249 ++hSpanBegin; 249 ++hSpanBegin;
250 ++spanZTarget; 250 ++spanZTarget;
251 } 251 }
252 } 252 }
253 253
254 leftxf += leftdeltaxf; 254 leftxf += leftdeltaxf;
255 rightxf += rightdeltaxf; 255 rightxf += rightdeltaxf;
256 ++span; 256 ++span;
257 targetSurface += SurfaceWidth; 257 targetSurface += SurfaceWidth;
258 zTarget += SurfaceWidth; 258 zTarget += SurfaceWidth;
259 leftZValue += leftZStep; 259 leftZValue += leftZStep;
260 rightZValue += rightZStep; 260 rightZValue += rightZStep;
261 261
262 leftTx += leftTxStep; 262 leftTx += leftTxStep;
263 leftTy += leftTyStep; 263 leftTy += leftTyStep;
264 rightTx += rightTxStep; 264 rightTx += rightTxStep;
265 rightTy += rightTyStep; 265 rightTy += rightTyStep;
266 } 266 }
267 267
268 if (triangleHalf>0) // break, we've gout only two halves 268 if (triangleHalf>0) // break, we've gout only two halves
269 break; 269 break;
270 270
271 271
272 // setup variables for second half of the triangle. 272 // setup variables for second half of the triangle.
273 273
274 if (longest < 0.0f) 274 if (longest < 0.0f)
275 { 275 {
276 tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); 276 tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y);
277 277
278 rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; 278 rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv;
279 rightxf = (f32)v2->Pos.X; 279 rightxf = (f32)v2->Pos.X;
280 280
281 rightZValue = v2->ZValue; 281 rightZValue = v2->ZValue;
282 rightZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); 282 rightZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv);
283 283
284 rightTx = v2->TCoords.X; 284 rightTx = v2->TCoords.X;
285 rightTy = v2->TCoords.Y; 285 rightTy = v2->TCoords.Y;
286 rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv); 286 rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv);
287 rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv); 287 rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv);
288 } 288 }
289 else 289 else
290 { 290 {
291 tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); 291 tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y);
292 292
293 leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; 293 leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv;
294 leftxf = (f32)v2->Pos.X; 294 leftxf = (f32)v2->Pos.X;
295 295
296 leftZValue = v2->ZValue; 296 leftZValue = v2->ZValue;
297 leftZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); 297 leftZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv);
298 298
299 leftTx = v2->TCoords.X; 299 leftTx = v2->TCoords.X;
300 leftTy = v2->TCoords.Y; 300 leftTy = v2->TCoords.Y;
301 leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv); 301 leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv);
302 leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv); 302 leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv);
303 } 303 }
304 304
305 305
306 spanEnd = v3->Pos.Y; 306 spanEnd = v3->Pos.Y;
307 } 307 }
308 308
309 } 309 }
310 310
311 RenderTarget->unlock(); 311 RenderTarget->unlock();
312 ZBuffer->unlock(); 312 ZBuffer->unlock();
313 Texture->unlock(); 313 Texture->unlock();
314 314
315 } 315 }
316}; 316};
317 317
318} // end namespace video 318} // end namespace video
319} // end namespace irr 319} // end namespace irr
320 320
321#endif // _IRR_COMPILE_WITH_SOFTWARE_ 321#endif // _IRR_COMPILE_WITH_SOFTWARE_
322 322
323namespace irr 323namespace irr
324{ 324{
325namespace video 325namespace video
326{ 326{
327 327
328//! creates a flat triangle renderer 328//! creates a flat triangle renderer
329ITriangleRenderer* createTriangleRendererTextureFlat(IZBuffer* zbuffer) 329ITriangleRenderer* createTriangleRendererTextureFlat(IZBuffer* zbuffer)
330{ 330{
331 #ifdef _IRR_COMPILE_WITH_SOFTWARE_ 331 #ifdef _IRR_COMPILE_WITH_SOFTWARE_
332 return new CTRTextureFlat(zbuffer); 332 return new CTRTextureFlat(zbuffer);
333 #else 333 #else
334 return 0; 334 return 0;
335 #endif // _IRR_COMPILE_WITH_SOFTWARE_ 335 #endif // _IRR_COMPILE_WITH_SOFTWARE_
336} 336}
337 337
338} // end namespace video 338} // end namespace video
339} // end namespace irr 339} // end namespace irr
generated by cgit v1.1 at 2024-08-03 12:53:25 +0000