diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/CTRTextureGouraudNoZ.cpp')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CTRTextureGouraudNoZ.cpp | 734 |
1 files changed, 367 insertions, 367 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureGouraudNoZ.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureGouraudNoZ.cpp index ea47277..8152896 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureGouraudNoZ.cpp +++ b/libraries/irrlicht-1.8/source/Irrlicht/CTRTextureGouraudNoZ.cpp | |||
@@ -1,367 +1,367 @@ | |||
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 | #include "SColor.h" | 7 | #include "SColor.h" |
8 | 8 | ||
9 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ | 9 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ |
10 | 10 | ||
11 | namespace irr | 11 | namespace irr |
12 | { | 12 | { |
13 | namespace video | 13 | namespace video |
14 | { | 14 | { |
15 | 15 | ||
16 | class CTRTextureGouraudNoZ : public CTRTextureGouraud | 16 | class CTRTextureGouraudNoZ : public CTRTextureGouraud |
17 | { | 17 | { |
18 | public: | 18 | public: |
19 | 19 | ||
20 | CTRTextureGouraudNoZ() | 20 | CTRTextureGouraudNoZ() |
21 | : CTRTextureGouraud(0) | 21 | : CTRTextureGouraud(0) |
22 | { | 22 | { |
23 | #ifdef _DEBUG | 23 | #ifdef _DEBUG |
24 | setDebugName("CTRGouraudWireNoZ"); | 24 | setDebugName("CTRGouraudWireNoZ"); |
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 | u16 color; | 33 | u16 color; |
34 | f32 tmpDiv; // temporary division factor | 34 | f32 tmpDiv; // temporary division factor |
35 | f32 longest; // saves the longest span | 35 | f32 longest; // saves the longest span |
36 | s32 height; // saves height of triangle | 36 | s32 height; // saves height of triangle |
37 | u16* targetSurface; // target pointer where to plot pixels | 37 | u16* targetSurface; // target pointer where to plot pixels |
38 | s32 spanEnd; // saves end of spans | 38 | s32 spanEnd; // saves end of spans |
39 | f32 leftdeltaxf; // amount of pixels to increase on left side of triangle | 39 | f32 leftdeltaxf; // amount of pixels to increase on left side of triangle |
40 | f32 rightdeltaxf; // amount of pixels to increase on right side of triangle | 40 | f32 rightdeltaxf; // amount of pixels to increase on right side of triangle |
41 | s32 leftx, rightx; // position where we are | 41 | s32 leftx, rightx; // position where we are |
42 | f32 leftxf, rightxf; // same as above, but as f32 values | 42 | f32 leftxf, rightxf; // same as above, but as f32 values |
43 | s32 span; // current span | 43 | s32 span; // current span |
44 | u16 *hSpanBegin, *hSpanEnd; // pointer used when plotting pixels | 44 | u16 *hSpanBegin, *hSpanEnd; // pointer used when plotting pixels |
45 | s32 leftR, leftG, leftB, rightR, rightG, rightB; // color values | 45 | s32 leftR, leftG, leftB, rightR, rightG, rightB; // color values |
46 | s32 leftStepR, leftStepG, leftStepB, | 46 | s32 leftStepR, leftStepG, leftStepB, |
47 | rightStepR, rightStepG, rightStepB; // color steps | 47 | rightStepR, rightStepG, rightStepB; // color steps |
48 | s32 spanR, spanG, spanB, spanStepR, spanStepG, spanStepB; // color interpolating values while drawing a span. | 48 | s32 spanR, spanG, spanB, spanStepR, spanStepG, spanStepB; // color interpolating values while drawing a span. |
49 | s32 leftTx, rightTx, leftTy, rightTy; // texture interpolating values | 49 | s32 leftTx, rightTx, leftTy, rightTy; // texture interpolating values |
50 | s32 leftTxStep, rightTxStep, leftTyStep, rightTyStep; // texture interpolating values | 50 | s32 leftTxStep, rightTxStep, leftTyStep, rightTyStep; // texture interpolating values |
51 | s32 spanTx, spanTy, spanTxStep, spanTyStep; // values of Texturecoords when drawing a span | 51 | s32 spanTx, spanTy, spanTxStep, spanTyStep; // values of Texturecoords when drawing a span |
52 | core::rect<s32> TriangleRect; | 52 | core::rect<s32> TriangleRect; |
53 | 53 | ||
54 | lockedSurface = (u16*)RenderTarget->lock(); | 54 | lockedSurface = (u16*)RenderTarget->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 | leftR = rightR = video::getRed(v1->Color)<<8; | 120 | leftR = rightR = video::getRed(v1->Color)<<8; |
121 | leftG = rightG = video::getGreen(v1->Color)<<8; | 121 | leftG = rightG = video::getGreen(v1->Color)<<8; |
122 | leftB = rightB = video::getBlue(v1->Color)<<8; | 122 | leftB = rightB = video::getBlue(v1->Color)<<8; |
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 | 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 | rightStepR = (s32)(((s32)(video::getRed(v2->Color)<<8) - rightR) * tmpDiv); | 132 | rightStepR = (s32)(((s32)(video::getRed(v2->Color)<<8) - rightR) * tmpDiv); |
133 | rightStepG = (s32)(((s32)(video::getGreen(v2->Color)<<8) - rightG) * tmpDiv); | 133 | rightStepG = (s32)(((s32)(video::getGreen(v2->Color)<<8) - rightG) * tmpDiv); |
134 | rightStepB = (s32)(((s32)(video::getBlue(v2->Color)<<8) - rightB) * tmpDiv); | 134 | rightStepB = (s32)(((s32)(video::getBlue(v2->Color)<<8) - rightB) * tmpDiv); |
135 | rightTxStep = (s32)((v2->TCoords.X - rightTx) * tmpDiv); | 135 | rightTxStep = (s32)((v2->TCoords.X - rightTx) * tmpDiv); |
136 | rightTyStep = (s32)((v2->TCoords.Y - rightTy) * tmpDiv); | 136 | rightTyStep = (s32)((v2->TCoords.Y - rightTy) * tmpDiv); |
137 | 137 | ||
138 | tmpDiv = 1.0f / (f32)height; | 138 | tmpDiv = 1.0f / (f32)height; |
139 | leftdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; | 139 | leftdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; |
140 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - leftR) * tmpDiv); | 140 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - leftR) * tmpDiv); |
141 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - leftG) * tmpDiv); | 141 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - leftG) * tmpDiv); |
142 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - leftB) * tmpDiv); | 142 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - leftB) * tmpDiv); |
143 | leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv); | 143 | leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv); |
144 | leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv); | 144 | leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv); |
145 | } | 145 | } |
146 | else | 146 | else |
147 | { | 147 | { |
148 | tmpDiv = 1.0f / (f32)height; | 148 | tmpDiv = 1.0f / (f32)height; |
149 | rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; | 149 | rightdeltaxf = (v3->Pos.X - v1->Pos.X) * tmpDiv; |
150 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - rightR) * tmpDiv); | 150 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - rightR) * tmpDiv); |
151 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - rightG) * tmpDiv); | 151 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - rightG) * tmpDiv); |
152 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - rightB) * tmpDiv); | 152 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - rightB) * tmpDiv); |
153 | rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv); | 153 | rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv); |
154 | rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv); | 154 | rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv); |
155 | 155 | ||
156 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); | 156 | tmpDiv = 1.0f / (f32)(v2->Pos.Y - v1->Pos.Y); |
157 | leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; | 157 | leftdeltaxf = (v2->Pos.X - v1->Pos.X) * tmpDiv; |
158 | leftStepR = (s32)(((s32)(video::getRed(v2->Color)<<8) - leftR) * tmpDiv); | 158 | leftStepR = (s32)(((s32)(video::getRed(v2->Color)<<8) - leftR) * tmpDiv); |
159 | leftStepG = (s32)(((s32)(video::getGreen(v2->Color)<<8) - leftG) * tmpDiv); | 159 | leftStepG = (s32)(((s32)(video::getGreen(v2->Color)<<8) - leftG) * tmpDiv); |
160 | leftStepB = (s32)(((s32)(video::getBlue(v2->Color)<<8) - leftB) * tmpDiv); | 160 | leftStepB = (s32)(((s32)(video::getBlue(v2->Color)<<8) - leftB) * tmpDiv); |
161 | leftTxStep = (s32)((v2->TCoords.X - leftTx) * tmpDiv); | 161 | leftTxStep = (s32)((v2->TCoords.X - leftTx) * tmpDiv); |
162 | leftTyStep = (s32)((v2->TCoords.Y - leftTy) * tmpDiv); | 162 | leftTyStep = (s32)((v2->TCoords.Y - leftTy) * 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 | 193 | ||
194 | leftR += leftStepR*leftx; | 194 | leftR += leftStepR*leftx; |
195 | leftG += leftStepG*leftx; | 195 | leftG += leftStepG*leftx; |
196 | leftB += leftStepB*leftx; | 196 | leftB += leftStepB*leftx; |
197 | rightR += rightStepR*leftx; | 197 | rightR += rightStepR*leftx; |
198 | rightG += rightStepG*leftx; | 198 | rightG += rightStepG*leftx; |
199 | rightB += rightStepB*leftx; | 199 | rightB += rightStepB*leftx; |
200 | 200 | ||
201 | leftTx += leftTxStep*leftx; | 201 | leftTx += leftTxStep*leftx; |
202 | leftTy += leftTyStep*leftx; | 202 | leftTy += leftTyStep*leftx; |
203 | rightTx += rightTxStep*leftx; | 203 | rightTx += rightTxStep*leftx; |
204 | rightTy += rightTyStep*leftx; | 204 | rightTy += rightTyStep*leftx; |
205 | } | 205 | } |
206 | 206 | ||
207 | 207 | ||
208 | // the main loop. Go through every span and draw it. | 208 | // the main loop. Go through every span and draw it. |
209 | 209 | ||
210 | while (span < spanEnd) | 210 | while (span < spanEnd) |
211 | { | 211 | { |
212 | leftx = (s32)(leftxf); | 212 | leftx = (s32)(leftxf); |
213 | rightx = (s32)(rightxf + 0.5f); | 213 | rightx = (s32)(rightxf + 0.5f); |
214 | 214 | ||
215 | // perform some clipping | 215 | // perform some clipping |
216 | // thanks to a correction by hybrid | 216 | // thanks to a correction by hybrid |
217 | // calculations delayed to correctly propagate to textures etc. | 217 | // calculations delayed to correctly propagate to textures etc. |
218 | s32 tDiffLeft=0, tDiffRight=0; | 218 | s32 tDiffLeft=0, tDiffRight=0; |
219 | if (leftx<ViewPortRect.UpperLeftCorner.X) | 219 | if (leftx<ViewPortRect.UpperLeftCorner.X) |
220 | tDiffLeft=ViewPortRect.UpperLeftCorner.X-leftx; | 220 | tDiffLeft=ViewPortRect.UpperLeftCorner.X-leftx; |
221 | else | 221 | else |
222 | if (leftx>ViewPortRect.LowerRightCorner.X) | 222 | if (leftx>ViewPortRect.LowerRightCorner.X) |
223 | tDiffLeft=ViewPortRect.LowerRightCorner.X-leftx; | 223 | tDiffLeft=ViewPortRect.LowerRightCorner.X-leftx; |
224 | 224 | ||
225 | if (rightx<ViewPortRect.UpperLeftCorner.X) | 225 | if (rightx<ViewPortRect.UpperLeftCorner.X) |
226 | tDiffRight=ViewPortRect.UpperLeftCorner.X-rightx; | 226 | tDiffRight=ViewPortRect.UpperLeftCorner.X-rightx; |
227 | else | 227 | else |
228 | if (rightx>ViewPortRect.LowerRightCorner.X) | 228 | if (rightx>ViewPortRect.LowerRightCorner.X) |
229 | tDiffRight=ViewPortRect.LowerRightCorner.X-rightx; | 229 | tDiffRight=ViewPortRect.LowerRightCorner.X-rightx; |
230 | 230 | ||
231 | // draw the span | 231 | // draw the span |
232 | if (rightx + tDiffRight - leftx - tDiffLeft) | 232 | if (rightx + tDiffRight - leftx - tDiffLeft) |
233 | { | 233 | { |
234 | tmpDiv = 1.0f / (f32)(rightx - leftx); | 234 | tmpDiv = 1.0f / (f32)(rightx - leftx); |
235 | 235 | ||
236 | spanStepR = (s32)((rightR - leftR) * tmpDiv); | 236 | spanStepR = (s32)((rightR - leftR) * tmpDiv); |
237 | spanR = leftR+tDiffLeft*spanStepR; | 237 | spanR = leftR+tDiffLeft*spanStepR; |
238 | spanStepG = (s32)((rightG - leftG) * tmpDiv); | 238 | spanStepG = (s32)((rightG - leftG) * tmpDiv); |
239 | spanG = leftG+tDiffLeft*spanStepG; | 239 | spanG = leftG+tDiffLeft*spanStepG; |
240 | spanStepB = (s32)((rightB - leftB) * tmpDiv); | 240 | spanStepB = (s32)((rightB - leftB) * tmpDiv); |
241 | spanB = leftB+tDiffLeft*spanStepB; | 241 | spanB = leftB+tDiffLeft*spanStepB; |
242 | 242 | ||
243 | spanTxStep = (s32)((rightTx - leftTx) * tmpDiv); | 243 | spanTxStep = (s32)((rightTx - leftTx) * tmpDiv); |
244 | spanTx = leftTx + tDiffLeft*spanTxStep; | 244 | spanTx = leftTx + tDiffLeft*spanTxStep; |
245 | spanTyStep = (s32)((rightTy - leftTy) * tmpDiv); | 245 | spanTyStep = (s32)((rightTy - leftTy) * tmpDiv); |
246 | spanTy = leftTy+tDiffLeft*spanTyStep; | 246 | spanTy = leftTy+tDiffLeft*spanTyStep; |
247 | 247 | ||
248 | hSpanBegin = targetSurface + leftx+tDiffLeft; | 248 | hSpanBegin = targetSurface + leftx+tDiffLeft; |
249 | hSpanEnd = targetSurface + rightx+tDiffRight; | 249 | hSpanEnd = targetSurface + rightx+tDiffRight; |
250 | 250 | ||
251 | while (hSpanBegin < hSpanEnd) | 251 | while (hSpanBegin < hSpanEnd) |
252 | { | 252 | { |
253 | color = lockedTexture[((spanTy>>8)&textureYMask) * lockedTextureWidth + ((spanTx>>8)&textureXMask)]; | 253 | color = lockedTexture[((spanTy>>8)&textureYMask) * lockedTextureWidth + ((spanTx>>8)&textureXMask)]; |
254 | *hSpanBegin = video::RGB16(video::getRed(color) * (spanR>>8) >>2, | 254 | *hSpanBegin = video::RGB16(video::getRed(color) * (spanR>>8) >>2, |
255 | video::getGreen(color) * (spanG>>8) >>2, | 255 | video::getGreen(color) * (spanG>>8) >>2, |
256 | video::getBlue(color) * (spanB>>8) >>2); | 256 | video::getBlue(color) * (spanB>>8) >>2); |
257 | 257 | ||
258 | spanR += spanStepR; | 258 | spanR += spanStepR; |
259 | spanG += spanStepG; | 259 | spanG += spanStepG; |
260 | spanB += spanStepB; | 260 | spanB += spanStepB; |
261 | 261 | ||
262 | spanTx += spanTxStep; | 262 | spanTx += spanTxStep; |
263 | spanTy += spanTyStep; | 263 | spanTy += spanTyStep; |
264 | 264 | ||
265 | ++hSpanBegin; | 265 | ++hSpanBegin; |
266 | } | 266 | } |
267 | } | 267 | } |
268 | 268 | ||
269 | leftxf += leftdeltaxf; | 269 | leftxf += leftdeltaxf; |
270 | rightxf += rightdeltaxf; | 270 | rightxf += rightdeltaxf; |
271 | ++span; | 271 | ++span; |
272 | targetSurface += SurfaceWidth; | 272 | targetSurface += SurfaceWidth; |
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 | leftTx += leftTxStep; | 281 | leftTx += leftTxStep; |
282 | leftTy += leftTyStep; | 282 | leftTy += leftTyStep; |
283 | rightTx += rightTxStep; | 283 | rightTx += rightTxStep; |
284 | rightTy += rightTyStep; | 284 | rightTy += rightTyStep; |
285 | } | 285 | } |
286 | 286 | ||
287 | if (triangleHalf>0) // break, we've gout only two halves | 287 | if (triangleHalf>0) // break, we've gout only two halves |
288 | break; | 288 | break; |
289 | 289 | ||
290 | 290 | ||
291 | // setup variables for second half of the triangle. | 291 | // setup variables for second half of the triangle. |
292 | 292 | ||
293 | if (longest < 0.0f) | 293 | if (longest < 0.0f) |
294 | { | 294 | { |
295 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); | 295 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); |
296 | 296 | ||
297 | rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; | 297 | rightdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; |
298 | rightxf = (f32)v2->Pos.X; | 298 | rightxf = (f32)v2->Pos.X; |
299 | 299 | ||
300 | rightR = video::getRed(v2->Color)<<8; | 300 | rightR = video::getRed(v2->Color)<<8; |
301 | rightG = video::getGreen(v2->Color)<<8; | 301 | rightG = video::getGreen(v2->Color)<<8; |
302 | rightB = video::getBlue(v2->Color)<<8; | 302 | rightB = video::getBlue(v2->Color)<<8; |
303 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - rightR) * tmpDiv); | 303 | rightStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - rightR) * tmpDiv); |
304 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - rightG) * tmpDiv); | 304 | rightStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - rightG) * tmpDiv); |
305 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - rightB) * tmpDiv); | 305 | rightStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - rightB) * tmpDiv); |
306 | 306 | ||
307 | rightTx = v2->TCoords.X; | 307 | rightTx = v2->TCoords.X; |
308 | rightTy = v2->TCoords.Y; | 308 | rightTy = v2->TCoords.Y; |
309 | rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv); | 309 | rightTxStep = (s32)((v3->TCoords.X - rightTx) * tmpDiv); |
310 | rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv); | 310 | rightTyStep = (s32)((v3->TCoords.Y - rightTy) * tmpDiv); |
311 | } | 311 | } |
312 | else | 312 | else |
313 | { | 313 | { |
314 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); | 314 | tmpDiv = 1.0f / (v3->Pos.Y - v2->Pos.Y); |
315 | 315 | ||
316 | leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; | 316 | leftdeltaxf = (v3->Pos.X - v2->Pos.X) * tmpDiv; |
317 | leftxf = (f32)v2->Pos.X; | 317 | leftxf = (f32)v2->Pos.X; |
318 | 318 | ||
319 | leftR = video::getRed(v2->Color)<<8; | 319 | leftR = video::getRed(v2->Color)<<8; |
320 | leftG = video::getGreen(v2->Color)<<8; | 320 | leftG = video::getGreen(v2->Color)<<8; |
321 | leftB = video::getBlue(v2->Color)<<8; | 321 | leftB = video::getBlue(v2->Color)<<8; |
322 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - leftR) * tmpDiv); | 322 | leftStepR = (s32)(((s32)(video::getRed(v3->Color)<<8) - leftR) * tmpDiv); |
323 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - leftG) * tmpDiv); | 323 | leftStepG = (s32)(((s32)(video::getGreen(v3->Color)<<8) - leftG) * tmpDiv); |
324 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - leftB) * tmpDiv); | 324 | leftStepB = (s32)(((s32)(video::getBlue(v3->Color)<<8) - leftB) * tmpDiv); |
325 | 325 | ||
326 | leftTx = v2->TCoords.X; | 326 | leftTx = v2->TCoords.X; |
327 | leftTy = v2->TCoords.Y; | 327 | leftTy = v2->TCoords.Y; |
328 | leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv); | 328 | leftTxStep = (s32)((v3->TCoords.X - leftTx) * tmpDiv); |
329 | leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv); | 329 | leftTyStep = (s32)((v3->TCoords.Y - leftTy) * tmpDiv); |
330 | } | 330 | } |
331 | 331 | ||
332 | 332 | ||
333 | spanEnd = v3->Pos.Y; | 333 | spanEnd = v3->Pos.Y; |
334 | } | 334 | } |
335 | 335 | ||
336 | } | 336 | } |
337 | 337 | ||
338 | RenderTarget->unlock(); | 338 | RenderTarget->unlock(); |
339 | Texture->unlock(); | 339 | Texture->unlock(); |
340 | } | 340 | } |
341 | 341 | ||
342 | }; | 342 | }; |
343 | 343 | ||
344 | } // end namespace video | 344 | } // end namespace video |
345 | } // end namespace irr | 345 | } // end namespace irr |
346 | 346 | ||
347 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ | 347 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ |
348 | 348 | ||
349 | namespace irr | 349 | namespace irr |
350 | { | 350 | { |
351 | namespace video | 351 | namespace video |
352 | { | 352 | { |
353 | 353 | ||
354 | //! creates a flat triangle renderer | 354 | //! creates a flat triangle renderer |
355 | ITriangleRenderer* createTriangleRendererTextureGouraudNoZ() | 355 | ITriangleRenderer* createTriangleRendererTextureGouraudNoZ() |
356 | { | 356 | { |
357 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ | 357 | #ifdef _IRR_COMPILE_WITH_SOFTWARE_ |
358 | return new CTRTextureGouraudNoZ(); | 358 | return new CTRTextureGouraudNoZ(); |
359 | #else | 359 | #else |
360 | return 0; | 360 | return 0; |
361 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ | 361 | #endif // _IRR_COMPILE_WITH_SOFTWARE_ |
362 | } | 362 | } |
363 | 363 | ||
364 | } // end namespace video | 364 | } // end namespace video |
365 | } // end namespace irr | 365 | } // end namespace irr |
366 | 366 | ||
367 | 367 | ||