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