diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/CTRGouraudWire.cpp')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CTRGouraudWire.cpp | 652 |
1 files changed, 326 insertions, 326 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CTRGouraudWire.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CTRGouraudWire.cpp index 1d233a7..fd7b843 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/CTRGouraudWire.cpp +++ b/libraries/irrlicht-1.8/source/Irrlicht/CTRGouraudWire.cpp | |||
@@ -1,326 +1,326 @@ | |||
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 CTRGouraudWire : public CTRTextureGouraud | 15 | class CTRGouraudWire : public CTRTextureGouraud |
16 | { | 16 | { |
17 | public: | 17 | public: |
18 | 18 | ||
19 | CTRGouraudWire(IZBuffer* zbuffer) | 19 | CTRGouraudWire(IZBuffer* zbuffer) |
20 | : CTRTextureGouraud(zbuffer) | 20 | : CTRTextureGouraud(zbuffer) |
21 | { | 21 | { |
22 | #ifdef _DEBUG | 22 | #ifdef _DEBUG |
23 | setDebugName("CTRGouraudWire"); | 23 | setDebugName("CTRGouraudWire"); |
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 | s32 leftR, leftG, leftB, rightR, rightG, rightB; // color values | 42 | s32 leftR, leftG, leftB, rightR, rightG, rightB; // color values |
43 | s32 leftStepR, leftStepG, leftStepB, | 43 | s32 leftStepR, leftStepG, leftStepB, |
44 | rightStepR, rightStepG, rightStepB; // color steps | 44 | rightStepR, rightStepG, rightStepB; // color steps |
45 | 45 | ||
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 | TZBufferType* zTarget; // target of ZBuffer; | 50 | TZBufferType* zTarget; // target of ZBuffer; |
51 | 51 | ||
52 | lockedSurface = (u16*)RenderTarget->lock(); | 52 | lockedSurface = (u16*)RenderTarget->lock(); |
53 | lockedZBuffer = ZBuffer->lock(); | 53 | lockedZBuffer = ZBuffer->lock(); |
54 | 54 | ||
55 | for (s32 i=0; i<triangleCount; ++i) | 55 | for (s32 i=0; i<triangleCount; ++i) |
56 | { | 56 | { |
57 | v1 = &vertices[*indexList]; | 57 | v1 = &vertices[*indexList]; |
58 | ++indexList; | 58 | ++indexList; |
59 | v2 = &vertices[*indexList]; | 59 | v2 = &vertices[*indexList]; |
60 | ++indexList; | 60 | ++indexList; |
61 | v3 = &vertices[*indexList]; | 61 | v3 = &vertices[*indexList]; |
62 | ++indexList; | 62 | ++indexList; |
63 | 63 | ||
64 | // back face culling | 64 | // back face culling |
65 | 65 | ||
66 | if (BackFaceCullingEnabled) | 66 | if (BackFaceCullingEnabled) |
67 | { | 67 | { |
68 | s32 z = ((v3->Pos.X - v1->Pos.X) * (v3->Pos.Y - v2->Pos.Y)) - | 68 | s32 z = ((v3->Pos.X - v1->Pos.X) * (v3->Pos.Y - v2->Pos.Y)) - |
69 | ((v3->Pos.Y - v1->Pos.Y) * (v3->Pos.X - v2->Pos.X)); | 69 | ((v3->Pos.Y - v1->Pos.Y) * (v3->Pos.X - v2->Pos.X)); |
70 | 70 | ||
71 | if (z < 0) | 71 | if (z < 0) |
72 | continue; | 72 | continue; |
73 | } | 73 | } |
74 | 74 | ||
75 | //near plane clipping | 75 | //near plane clipping |
76 | 76 | ||
77 | if (v1->ZValue<0 && v2->ZValue<0 && v3->ZValue<0) | 77 | if (v1->ZValue<0 && v2->ZValue<0 && v3->ZValue<0) |
78 | continue; | 78 | continue; |
79 | 79 | ||
80 | // sort for width for inscreen clipping | 80 | // sort for width for inscreen clipping |
81 | 81 | ||
82 | if (v1->Pos.X > v2->Pos.X) swapVertices(&v1, &v2); | 82 | if (v1->Pos.X > v2->Pos.X) swapVertices(&v1, &v2); |
83 | if (v1->Pos.X > v3->Pos.X) swapVertices(&v1, &v3); | 83 | if (v1->Pos.X > v3->Pos.X) swapVertices(&v1, &v3); |
84 | if (v2->Pos.X > v3->Pos.X) swapVertices(&v2, &v3); | 84 | if (v2->Pos.X > v3->Pos.X) swapVertices(&v2, &v3); |
85 | 85 | ||
86 | if ((v1->Pos.X - v3->Pos.X) == 0) | 86 | if ((v1->Pos.X - v3->Pos.X) == 0) |
87 | continue; | 87 | continue; |
88 | 88 | ||
89 | TriangleRect.UpperLeftCorner.X = v1->Pos.X; | 89 | TriangleRect.UpperLeftCorner.X = v1->Pos.X; |
90 | TriangleRect.LowerRightCorner.X = v3->Pos.X; | 90 | TriangleRect.LowerRightCorner.X = v3->Pos.X; |
91 | 91 | ||
92 | // sort for height for faster drawing. | 92 | // sort for height for faster drawing. |
93 | 93 | ||
94 | if (v1->Pos.Y > v2->Pos.Y) swapVertices(&v1, &v2); | 94 | if (v1->Pos.Y > v2->Pos.Y) swapVertices(&v1, &v2); |
95 | if (v1->Pos.Y > v3->Pos.Y) swapVertices(&v1, &v3); | 95 | if (v1->Pos.Y > v3->Pos.Y) swapVertices(&v1, &v3); |
96 | if (v2->Pos.Y > v3->Pos.Y) swapVertices(&v2, &v3); | 96 | if (v2->Pos.Y > v3->Pos.Y) swapVertices(&v2, &v3); |
97 | 97 | ||
98 | TriangleRect.UpperLeftCorner.Y = v1->Pos.Y; | 98 | TriangleRect.UpperLeftCorner.Y = v1->Pos.Y; |
99 | TriangleRect.LowerRightCorner.Y = v3->Pos.Y; | 99 | TriangleRect.LowerRightCorner.Y = v3->Pos.Y; |
100 | 100 | ||
101 | if (!TriangleRect.isRectCollided(ViewPortRect)) | 101 | if (!TriangleRect.isRectCollided(ViewPortRect)) |
102 | continue; | 102 | continue; |
103 | 103 | ||
104 | // calculate height of triangle | 104 | // calculate height of triangle |
105 | height = v3->Pos.Y - v1->Pos.Y; | 105 | height = v3->Pos.Y - v1->Pos.Y; |
106 | if (!height) | 106 | if (!height) |
107 | continue; | 107 | continue; |
108 | 108 | ||
109 | // calculate longest span | 109 | // calculate longest span |
110 | 110 | ||
111 | longest = (v2->Pos.Y - v1->Pos.Y) / (f32)height * (v3->Pos.X - v1->Pos.X) + (v1->Pos.X - v2->Pos.X); | 111 | longest = (v2->Pos.Y - v1->Pos.Y) / (f32)height * (v3->Pos.X - v1->Pos.X) + (v1->Pos.X - v2->Pos.X); |
112 | 112 | ||
113 | spanEnd = v2->Pos.Y; | 113 | spanEnd = v2->Pos.Y; |
114 | span = v1->Pos.Y; | 114 | span = v1->Pos.Y; |
115 | leftxf = (f32)v1->Pos.X; | 115 | leftxf = (f32)v1->Pos.X; |
116 | rightxf = (f32)v1->Pos.X; | 116 | rightxf = (f32)v1->Pos.X; |
117 | 117 | ||
118 | leftZValue = v1->ZValue; | 118 | leftZValue = v1->ZValue; |
119 | rightZValue = v1->ZValue; | 119 | rightZValue = v1->ZValue; |
120 | 120 | ||
121 | leftR = rightR = video::getRed(v1->Color)<<11; | 121 | leftR = rightR = video::getRed(v1->Color)<<11; |
122 | leftG = rightG = video::getGreen(v1->Color)<<11; | 122 | leftG = rightG = video::getGreen(v1->Color)<<11; |
123 | leftB = rightB = video::getBlue(v1->Color)<<11; | 123 | leftB = rightB = video::getBlue(v1->Color)<<11; |
124 | 124 | ||
125 | targetSurface = lockedSurface + span * SurfaceWidth; | 125 | targetSurface = lockedSurface + span * SurfaceWidth; |
126 | zTarget = lockedZBuffer + span * SurfaceWidth; | 126 | zTarget = lockedZBuffer + span * SurfaceWidth; |
127 | 127 | ||
128 | if (longest < 0.0f) | 128 | if (longest < 0.0f) |
129 | { | 129 | { |
130 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); | 130 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); |
131 | rightdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; | 131 | rightdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; |
132 | rightZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); | 132 | rightZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); |
133 | rightStepR = (s32)(((s32)(video::getRed(v2->Color)<<11) - rightR) * tmpDiv); | 133 | rightStepR = (s32)(((s32)(video::getRed(v2->Color)<<11) - rightR) * tmpDiv); |
134 | rightStepG = (s32)(((s32)(video::getGreen(v2->Color)<<11) - rightG) * tmpDiv); | 134 | rightStepG = (s32)(((s32)(video::getGreen(v2->Color)<<11) - rightG) * tmpDiv); |
135 | rightStepB = (s32)(((s32)(video::getBlue(v2->Color)<<11) - rightB) * tmpDiv); | 135 | rightStepB = (s32)(((s32)(video::getBlue(v2->Color)<<11) - rightB) * 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 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - leftR) * tmpDiv); | 140 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - leftR) * tmpDiv); |
141 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - leftG) * tmpDiv); | 141 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - leftG) * tmpDiv); |
142 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - leftB) * tmpDiv); | 142 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - leftB) * tmpDiv); |
143 | } | 143 | } |
144 | else | 144 | else |
145 | { | 145 | { |
146 | tmpDiv = 1.0f / (f32)height; | 146 | tmpDiv = 1.0f / (f32)height; |
147 | rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; | 147 | rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; |
148 | rightZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); | 148 | rightZStep = (s32)((v3->ZValue - v1->ZValue) * tmpDiv); |
149 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - rightR) * tmpDiv); | 149 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - rightR) * tmpDiv); |
150 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - rightG) * tmpDiv); | 150 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - rightG) * tmpDiv); |
151 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - rightB) * tmpDiv); | 151 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - rightB) * tmpDiv); |
152 | 152 | ||
153 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); | 153 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); |
154 | leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; | 154 | leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; |
155 | leftZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); | 155 | leftZStep = (s32)((v2->ZValue - v1->ZValue) * tmpDiv); |
156 | leftStepR = (s32)(((s32)(video::getRed(v2->Color)<<11) - leftR) * tmpDiv); | 156 | leftStepR = (s32)(((s32)(video::getRed(v2->Color)<<11) - leftR) * tmpDiv); |
157 | leftStepG = (s32)(((s32)(video::getGreen(v2->Color)<<11) - leftG) * tmpDiv); | 157 | leftStepG = (s32)(((s32)(video::getGreen(v2->Color)<<11) - leftG) * tmpDiv); |
158 | leftStepB = (s32)(((s32)(video::getBlue(v2->Color)<<11) - leftB) * tmpDiv); | 158 | leftStepB = (s32)(((s32)(video::getBlue(v2->Color)<<11) - leftB) * tmpDiv); |
159 | } | 159 | } |
160 | 160 | ||
161 | 161 | ||
162 | // do it twice, once for the first half of the triangle, | 162 | // do it twice, once for the first half of the triangle, |
163 | // end then for the second half. | 163 | // end then for the second half. |
164 | 164 | ||
165 | for (s32 triangleHalf=0; triangleHalf<2; ++triangleHalf) | 165 | for (s32 triangleHalf=0; triangleHalf<2; ++triangleHalf) |
166 | { | 166 | { |
167 | if (spanEnd > ViewPortRect.LowerRightCorner.Y) | 167 | if (spanEnd > ViewPortRect.LowerRightCorner.Y) |
168 | spanEnd = ViewPortRect.LowerRightCorner.Y; | 168 | spanEnd = ViewPortRect.LowerRightCorner.Y; |
169 | 169 | ||
170 | // if the span <0, than we can skip these spans, | 170 | // if the span <0, than we can skip these spans, |
171 | // and proceed to the next spans which are really on the screen. | 171 | // and proceed to the next spans which are really on the screen. |
172 | if (span < ViewPortRect.UpperLeftCorner.Y) | 172 | if (span < ViewPortRect.UpperLeftCorner.Y) |
173 | { | 173 | { |
174 | // we'll use leftx as temp variable | 174 | // we'll use leftx as temp variable |
175 | if (spanEnd < ViewPortRect.UpperLeftCorner.Y) | 175 | if (spanEnd < ViewPortRect.UpperLeftCorner.Y) |
176 | { | 176 | { |
177 | leftx = spanEnd - span; | 177 | leftx = spanEnd - span; |
178 | span = spanEnd; | 178 | span = spanEnd; |
179 | } | 179 | } |
180 | else | 180 | else |
181 | { | 181 | { |
182 | leftx = ViewPortRect.UpperLeftCorner.Y - span; | 182 | leftx = ViewPortRect.UpperLeftCorner.Y - span; |
183 | span = ViewPortRect.UpperLeftCorner.Y; | 183 | span = ViewPortRect.UpperLeftCorner.Y; |
184 | } | 184 | } |
185 | 185 | ||
186 | leftxf += leftdeltaxf*leftx; | 186 | leftxf += leftdeltaxf*leftx; |
187 | rightxf += rightdeltaxf*leftx; | 187 | rightxf += rightdeltaxf*leftx; |
188 | targetSurface += SurfaceWidth*leftx; | 188 | targetSurface += SurfaceWidth*leftx; |
189 | zTarget += SurfaceWidth*leftx; | 189 | zTarget += SurfaceWidth*leftx; |
190 | leftZValue += leftZStep*leftx; | 190 | leftZValue += leftZStep*leftx; |
191 | rightZValue += rightZStep*leftx; | 191 | rightZValue += rightZStep*leftx; |
192 | 192 | ||
193 | leftR += leftStepR*leftx; | 193 | leftR += leftStepR*leftx; |
194 | leftG += leftStepG*leftx; | 194 | leftG += leftStepG*leftx; |
195 | leftB += leftStepB*leftx; | 195 | leftB += leftStepB*leftx; |
196 | rightR += rightStepR*leftx; | 196 | rightR += rightStepR*leftx; |
197 | rightG += rightStepG*leftx; | 197 | rightG += rightStepG*leftx; |
198 | rightB += rightStepB*leftx; | 198 | rightB += rightStepB*leftx; |
199 | } | 199 | } |
200 | 200 | ||
201 | 201 | ||
202 | // the main loop. Go through every span and draw it. | 202 | // the main loop. Go through every span and draw it. |
203 | 203 | ||
204 | while (span < spanEnd) | 204 | while (span < spanEnd) |
205 | { | 205 | { |
206 | leftx = (s32)(leftxf); | 206 | leftx = (s32)(leftxf); |
207 | rightx = (s32)(rightxf + 0.5f); | 207 | rightx = (s32)(rightxf + 0.5f); |
208 | 208 | ||
209 | // perform some clipping | 209 | // perform some clipping |
210 | 210 | ||
211 | if (leftx>=ViewPortRect.UpperLeftCorner.X && | 211 | if (leftx>=ViewPortRect.UpperLeftCorner.X && |
212 | leftx<=ViewPortRect.LowerRightCorner.X) | 212 | leftx<=ViewPortRect.LowerRightCorner.X) |
213 | { | 213 | { |
214 | if (leftZValue > *(zTarget + leftx)) | 214 | if (leftZValue > *(zTarget + leftx)) |
215 | { | 215 | { |
216 | *(zTarget + leftx) = leftZValue; | 216 | *(zTarget + leftx) = leftZValue; |
217 | *(targetSurface + leftx) = video::RGB16(leftR>>8, leftG>>8, leftB>>8); | 217 | *(targetSurface + leftx) = video::RGB16(leftR>>8, leftG>>8, leftB>>8); |
218 | } | 218 | } |
219 | } | 219 | } |
220 | 220 | ||
221 | 221 | ||
222 | if (rightx>=ViewPortRect.UpperLeftCorner.X && | 222 | if (rightx>=ViewPortRect.UpperLeftCorner.X && |
223 | rightx<=ViewPortRect.LowerRightCorner.X) | 223 | rightx<=ViewPortRect.LowerRightCorner.X) |
224 | { | 224 | { |
225 | if (rightZValue > *(zTarget + rightx)) | 225 | if (rightZValue > *(zTarget + rightx)) |
226 | { | 226 | { |
227 | *(zTarget + rightx) = rightZValue; | 227 | *(zTarget + rightx) = rightZValue; |
228 | *(targetSurface + rightx) = video::RGB16(rightR, rightG, rightB); | 228 | *(targetSurface + rightx) = video::RGB16(rightR, rightG, rightB); |
229 | } | 229 | } |
230 | 230 | ||
231 | } | 231 | } |
232 | 232 | ||
233 | leftxf += leftdeltaxf; | 233 | leftxf += leftdeltaxf; |
234 | rightxf += rightdeltaxf; | 234 | rightxf += rightdeltaxf; |
235 | ++span; | 235 | ++span; |
236 | targetSurface += SurfaceWidth; | 236 | targetSurface += SurfaceWidth; |
237 | zTarget += SurfaceWidth; | 237 | zTarget += SurfaceWidth; |
238 | leftZValue += leftZStep; | 238 | leftZValue += leftZStep; |
239 | rightZValue += rightZStep; | 239 | rightZValue += rightZStep; |
240 | 240 | ||
241 | leftR += leftStepR; | 241 | leftR += leftStepR; |
242 | leftG += leftStepG; | 242 | leftG += leftStepG; |
243 | leftB += leftStepB; | 243 | leftB += leftStepB; |
244 | rightR += rightStepR; | 244 | rightR += rightStepR; |
245 | rightG += rightStepG; | 245 | rightG += rightStepG; |
246 | rightB += rightStepB; | 246 | rightB += rightStepB; |
247 | } | 247 | } |
248 | 248 | ||
249 | if (triangleHalf>0) // break, we've gout only two halves | 249 | if (triangleHalf>0) // break, we've gout only two halves |
250 | break; | 250 | break; |
251 | 251 | ||
252 | 252 | ||
253 | // setup variables for second half of the triangle. | 253 | // setup variables for second half of the triangle. |
254 | 254 | ||
255 | if (longest < 0.0f) | 255 | if (longest < 0.0f) |
256 | { | 256 | { |
257 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); | 257 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); |
258 | 258 | ||
259 | rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; | 259 | rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; |
260 | rightxf = (f32)v2->Pos.X; | 260 | rightxf = (f32)v2->Pos.X; |
261 | 261 | ||
262 | rightZValue = v2->ZValue; | 262 | rightZValue = v2->ZValue; |
263 | rightZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); | 263 | rightZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); |
264 | 264 | ||
265 | rightR = video::getRed(v2->Color)<<11; | 265 | rightR = video::getRed(v2->Color)<<11; |
266 | rightG = video::getGreen(v2->Color)<<11; | 266 | rightG = video::getGreen(v2->Color)<<11; |
267 | rightB = video::getBlue(v2->Color)<<11; | 267 | rightB = video::getBlue(v2->Color)<<11; |
268 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - rightR) * tmpDiv); | 268 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - rightR) * tmpDiv); |
269 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - rightG) * tmpDiv); | 269 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - rightG) * tmpDiv); |
270 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - rightB) * tmpDiv); | 270 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - rightB) * tmpDiv); |
271 | } | 271 | } |
272 | else | 272 | else |
273 | { | 273 | { |
274 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); | 274 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); |
275 | 275 | ||
276 | leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; | 276 | leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; |
277 | leftxf = (f32)v2->Pos.X; | 277 | leftxf = (f32)v2->Pos.X; |
278 | 278 | ||
279 | leftZValue = v2->ZValue; | 279 | leftZValue = v2->ZValue; |
280 | leftZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); | 280 | leftZStep = (s32)((v3->ZValue - v2->ZValue) * tmpDiv); |
281 | 281 | ||
282 | leftR = video::getRed(v2->Color)<<11; | 282 | leftR = video::getRed(v2->Color)<<11; |
283 | leftG = video::getGreen(v2->Color)<<11; | 283 | leftG = video::getGreen(v2->Color)<<11; |
284 | leftB = video::getBlue(v2->Color)<<11; | 284 | leftB = video::getBlue(v2->Color)<<11; |
285 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - leftR) * tmpDiv); | 285 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<11) - leftR) * tmpDiv); |
286 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - leftG) * tmpDiv); | 286 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<11) - leftG) * tmpDiv); |
287 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - leftB) * tmpDiv); | 287 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<11) - leftB) * tmpDiv); |
288 | } | 288 | } |
289 | 289 | ||
290 | 290 | ||
291 | spanEnd = v3->Pos.Y; | 291 | spanEnd = v3->Pos.Y; |
292 | } | 292 | } |
293 | 293 | ||
294 | } | 294 | } |
295 | 295 | ||
296 | RenderTarget->unlock(); | 296 | RenderTarget->unlock(); |
297 | ZBuffer->unlock(); | 297 | ZBuffer->unlock(); |
298 | } | 298 | } |
299 | 299 | ||
300 | }; | 300 | }; |
301 | 301 | ||
302 | } // end namespace video | 302 | } // end namespace video |
303 | } // end namespace irr | 303 | } // end namespace irr |
304 | 304 | ||
305 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ | 305 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ |
306 | 306 | ||
307 | namespace irr | 307 | namespace irr |
308 | { | 308 | { |
309 | namespace video | 309 | namespace video |
310 | { | 310 | { |
311 | 311 | ||
312 | 312 | ||
313 | //! creates a flat triangle renderer | 313 | //! creates a flat triangle renderer |
314 | ITriangleRenderer* createTriangleRendererGouraudWire(IZBuffer* zbuffer) | 314 | ITriangleRenderer* createTriangleRendererGouraudWire(IZBuffer* zbuffer) |
315 | { | 315 | { |
316 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ | 316 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ |
317 | return new CTRGouraudWire(zbuffer); | 317 | return new CTRGouraudWire(zbuffer); |
318 | #else | 318 | #else |
319 | return 0; | 319 | return 0; |
320 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ | 320 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ |
321 | } | 321 | } |
322 | 322 | ||
323 | } // end namespace video | 323 | } // end namespace video |
324 | } // end namespace irr | 324 | } // end namespace irr |
325 | 325 | ||
326 | 326 | ||