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/CTRTextureFlat.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/CTRTextureFlat.cpp | 678 |
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 | ||
10 | namespace irr | 10 | namespace irr |
11 | { | 11 | { |
12 | namespace video | 12 | namespace video |
13 | { | 13 | { |
14 | 14 | ||
15 | class CTRTextureFlat : public CTRTextureGouraud | 15 | class CTRTextureFlat : public CTRTextureGouraud |
16 | { | 16 | { |
17 | public: | 17 | public: |
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 | ||
323 | namespace irr | 323 | namespace irr |
324 | { | 324 | { |
325 | namespace video | 325 | namespace video |
326 | { | 326 | { |
327 | 327 | ||
328 | //! creates a flat triangle renderer | 328 | //! creates a flat triangle renderer |
329 | ITriangleRenderer* createTriangleRendererTextureFlat(IZBuffer* zbuffer) | 329 | ITriangleRenderer* 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 |