CoCalc -- Scene3DLegacyv4.cpp

GitHub Repository: Rubberduckycooly/RSDKv5-Decompilation
Path: blob/master/RSDKv5/RSDK/Graphics/Legacy/v4/Scene3DLegacyv4.cpp
¹¹⁷⁰ views
1

2
RSDK::Legacy::Face RSDK::Legacy::v4::faceBuffer[LEGACY_v4_FACEBUFFER_SIZE];
3
RSDK::Legacy::Vertex RSDK::Legacy::v4::vertexBuffer[LEGACY_v4_VERTEXBUFFER_SIZE];
4
RSDK::Legacy::Vertex RSDK::Legacy::v4::vertexBufferT[LEGACY_v4_VERTEXBUFFER_SIZE];
5

6
RSDK::Legacy::DrawListEntry3D RSDK::Legacy::v4::drawList3D[LEGACY_v4_FACEBUFFER_SIZE];
7

8
int32 RSDK::Legacy::v4::fogColor    = 0;
9
int32 RSDK::Legacy::v4::fogStrength = 0;
10

11
void RSDK::Legacy::v4::SetIdentityMatrix(Matrix *matrix)
12
{
13
    matrix->values[0][0] = 0x100;
14
    matrix->values[0][1] = 0;
15
    matrix->values[0][2] = 0;
16
    matrix->values[0][3] = 0;
17

18
    matrix->values[1][0] = 0;
19
    matrix->values[1][1] = 0x100;
20
    matrix->values[1][2] = 0;
21
    matrix->values[1][3] = 0;
22

23
    matrix->values[2][0] = 0;
24
    matrix->values[2][1] = 0;
25
    matrix->values[2][2] = 0x100;
26
    matrix->values[2][3] = 0;
27

28
    matrix->values[3][0] = 0;
29
    matrix->values[3][1] = 0;
30
    matrix->values[3][2] = 0;
31
    matrix->values[3][3] = 0x100;
32
}
33
void RSDK::Legacy::v4::MatrixMultiply(Matrix *matrixA, Matrix *matrixB)
34
{
35
    int32 output[16];
36

37
    for (int32 i = 0; i < 0x10; ++i) {
38
        uint32 rowA = i / 4;
39
        uint32 rowB = i % 4;
40
        output[i]   = (matrixA->values[rowA][3] * matrixB->values[3][rowB] >> 8) + (matrixA->values[rowA][2] * matrixB->values[2][rowB] >> 8)
41
                    + (matrixA->values[rowA][1] * matrixB->values[1][rowB] >> 8) + (matrixA->values[rowA][0] * matrixB->values[0][rowB] >> 8);
42
    }
43

44
    for (int32 i = 0; i < 0x10; ++i) matrixA->values[i / 4][i % 4] = output[i];
45
}
46
void RSDK::Legacy::v4::MatrixTranslateXYZ(Matrix *matrix, int32 XPos, int32 YPos, int32 ZPos)
47
{
48
    matrix->values[0][0] = 0x100;
49
    matrix->values[0][1] = 0;
50
    matrix->values[0][2] = 0;
51
    matrix->values[0][3] = 0;
52

53
    matrix->values[1][0] = 0;
54
    matrix->values[1][1] = 0x100;
55
    matrix->values[1][2] = 0;
56
    matrix->values[1][3] = 0;
57

58
    matrix->values[2][0] = 0;
59
    matrix->values[2][1] = 0;
60
    matrix->values[2][2] = 0x100;
61
    matrix->values[2][3] = 0;
62

63
    matrix->values[3][0] = XPos;
64
    matrix->values[3][1] = YPos;
65
    matrix->values[3][2] = ZPos;
66
    matrix->values[3][3] = 0x100;
67
}
68
void RSDK::Legacy::v4::MatrixScaleXYZ(Matrix *matrix, int32 scaleX, int32 scaleY, int32 scaleZ)
69
{
70
    matrix->values[0][0] = scaleX;
71
    matrix->values[0][1] = 0;
72
    matrix->values[0][2] = 0;
73
    matrix->values[0][3] = 0;
74

75
    matrix->values[1][0] = 0;
76
    matrix->values[1][1] = scaleY;
77
    matrix->values[1][2] = 0;
78
    matrix->values[1][3] = 0;
79

80
    matrix->values[2][0] = 0;
81
    matrix->values[2][1] = 0;
82
    matrix->values[2][2] = scaleZ;
83
    matrix->values[2][3] = 0;
84

85
    matrix->values[3][0] = 0;
86
    matrix->values[3][1] = 0;
87
    matrix->values[3][2] = 0;
88
    matrix->values[3][3] = 0x100;
89
}
90
void RSDK::Legacy::v4::MatrixRotateX(Matrix *matrix, int32 rotationX)
91
{
92
    int32 sine   = sin512LookupTable[rotationX & 0x1FF] >> 1;
93
    int32 cosine = cos512LookupTable[rotationX & 0x1FF] >> 1;
94

95
    matrix->values[0][0] = 0x100;
96
    matrix->values[0][1] = 0;
97
    matrix->values[0][2] = 0;
98
    matrix->values[0][3] = 0;
99

100
    matrix->values[1][0] = 0;
101
    matrix->values[1][1] = cosine;
102
    matrix->values[1][2] = sine;
103
    matrix->values[1][3] = 0;
104

105
    matrix->values[2][0] = 0;
106
    matrix->values[2][1] = -sine;
107
    matrix->values[2][2] = cosine;
108
    matrix->values[2][3] = 0;
109

110
    matrix->values[3][0] = 0;
111
    matrix->values[3][1] = 0;
112
    matrix->values[3][2] = 0;
113
    matrix->values[3][3] = 0x100;
114
}
115
void RSDK::Legacy::v4::MatrixRotateY(Matrix *matrix, int32 rotationY)
116
{
117
    int32 sine   = sin512LookupTable[rotationY & 0x1FF] >> 1;
118
    int32 cosine = cos512LookupTable[rotationY & 0x1FF] >> 1;
119

120
    matrix->values[0][0] = cosine;
121
    matrix->values[0][1] = 0;
122
    matrix->values[0][2] = sine;
123
    matrix->values[0][3] = 0;
124

125
    matrix->values[1][0] = 0;
126
    matrix->values[1][1] = 0x100;
127
    matrix->values[1][2] = 0;
128
    matrix->values[1][3] = 0;
129

130
    matrix->values[2][0] = -sine;
131
    matrix->values[2][1] = 0;
132
    matrix->values[2][2] = cosine;
133
    matrix->values[2][3] = 0;
134

135
    matrix->values[3][0] = 0;
136
    matrix->values[3][1] = 0;
137
    matrix->values[3][2] = 0;
138
    matrix->values[3][3] = 0x100;
139
}
140
void RSDK::Legacy::v4::MatrixRotateZ(Matrix *matrix, int32 rotationZ)
141
{
142
    int32 sine           = sin512LookupTable[rotationZ & 0x1FF] >> 1;
143
    int32 cosine         = cos512LookupTable[rotationZ & 0x1FF] >> 1;
144
    matrix->values[0][0] = cosine;
145
    matrix->values[0][1] = 0;
146
    matrix->values[0][2] = sine;
147
    matrix->values[0][3] = 0;
148

149
    matrix->values[1][0] = 0;
150
    matrix->values[1][1] = 0x100;
151
    matrix->values[1][2] = 0;
152
    matrix->values[1][3] = 0;
153

154
    matrix->values[2][0] = -sine;
155
    matrix->values[2][1] = 0;
156
    matrix->values[2][2] = cosine;
157
    matrix->values[2][3] = 0;
158

159
    matrix->values[3][0] = 0;
160
    matrix->values[3][1] = 0;
161
    matrix->values[3][2] = 0;
162
    matrix->values[3][3] = 0x100;
163
}
164
void RSDK::Legacy::v4::MatrixRotateXYZ(Matrix *matrix, int16 rotationX, int16 rotationY, int16 rotationZ)
165
{
166
    int32 sinX = sin512LookupTable[rotationX & 0x1FF] >> 1;
167
    int32 cosX = cos512LookupTable[rotationX & 0x1FF] >> 1;
168
    int32 sinY = sin512LookupTable[rotationY & 0x1FF] >> 1;
169
    int32 cosY = cos512LookupTable[rotationY & 0x1FF] >> 1;
170
    int32 sinZ = sin512LookupTable[rotationZ & 0x1FF] >> 1;
171
    int32 cosZ = cos512LookupTable[rotationZ & 0x1FF] >> 1;
172

173
    matrix->values[0][0] = (cosZ * cosY >> 8) + (sinZ * (sinY * sinX >> 8) >> 8);
174
    matrix->values[0][1] = (sinZ * cosY >> 8) - (cosZ * (sinY * sinX >> 8) >> 8);
175
    matrix->values[0][2] = sinY * cosX >> 8;
176
    matrix->values[0][3] = 0;
177

178
    matrix->values[1][0] = sinZ * -cosX >> 8;
179
    matrix->values[1][1] = cosZ * cosX >> 8;
180
    matrix->values[1][2] = sinX;
181
    matrix->values[1][3] = 0;
182

183
    matrix->values[2][0] = (sinZ * (cosY * sinX >> 8) >> 8) - (cosZ * sinY >> 8);
184
    matrix->values[2][1] = (sinZ * -sinY >> 8) - (cosZ * (cosY * sinX >> 8) >> 8);
185
    matrix->values[2][2] = cosY * cosX >> 8;
186
    matrix->values[2][3] = 0;
187

188
    matrix->values[3][0] = 0;
189
    matrix->values[3][1] = 0;
190
    matrix->values[3][2] = 0;
191
    matrix->values[3][3] = 0x100;
192
}
193
void RSDK::Legacy::v4::MatrixInverse(Matrix *matrix)
194
{
195
    double inv[16], det;
196
    double m[16];
197
    for (int32 y = 0; y < 4; ++y) {
198
        for (int32 x = 0; x < 4; ++x) {
199
            m[(y << 2) + x] = matrix->values[y][x] / 256.0;
200
        }
201
    }
202

203
    inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
204

205
    inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
206

207
    inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
208

209
    inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
210

211
    inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
212

213
    inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
214

215
    inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
216

217
    inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
218

219
    inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
220

221
    inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
222

223
    inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
224

225
    inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
226

227
    inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
228

229
    inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
230

231
    inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
232

233
    inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
234

235
    det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
236

237
    if (det == 0)
238
        return;
239

240
    det = 1.0 / det;
241

242
    for (int32 i = 0; i < 0x10; ++i) inv[i] = (int32)((inv[i] * det) * 256);
243
    for (int32 i = 0; i < 0x10; ++i) matrix->values[i / 4][i % 4] = (int32)inv[i];
244
}
245
void RSDK::Legacy::v4::TransformVertexBuffer()
246
{
247
    matFinal.values[0][0] = matWorld.values[0][0];
248
    matFinal.values[0][1] = matWorld.values[0][1];
249
    matFinal.values[0][2] = matWorld.values[0][2];
250
    matFinal.values[0][3] = matWorld.values[0][3];
251

252
    matFinal.values[1][0] = matWorld.values[1][0];
253
    matFinal.values[1][1] = matWorld.values[1][1];
254
    matFinal.values[1][2] = matWorld.values[1][2];
255
    matFinal.values[1][3] = matWorld.values[1][3];
256

257
    matFinal.values[2][0] = matWorld.values[2][0];
258
    matFinal.values[2][1] = matWorld.values[2][1];
259
    matFinal.values[2][2] = matWorld.values[2][2];
260
    matFinal.values[2][3] = matWorld.values[2][3];
261

262
    matFinal.values[3][0] = matWorld.values[3][0];
263
    matFinal.values[3][1] = matWorld.values[3][1];
264
    matFinal.values[3][2] = matWorld.values[3][2];
265
    matFinal.values[3][3] = matWorld.values[3][3];
266
    MatrixMultiply(&matFinal, &matView);
267

268
    for (int32 v = 0; v < vertexCount; ++v) {
269
        int32 vx = vertexBuffer[v].x;
270
        int32 vy = vertexBuffer[v].y;
271
        int32 vz = vertexBuffer[v].z;
272

273
        vertexBufferT[v].x =
274
            (vx * matFinal.values[0][0] >> 8) + (vy * matFinal.values[1][0] >> 8) + (vz * matFinal.values[2][0] >> 8) + matFinal.values[3][0];
275
        vertexBufferT[v].y =
276
            (vx * matFinal.values[0][1] >> 8) + (vy * matFinal.values[1][1] >> 8) + (vz * matFinal.values[2][1] >> 8) + matFinal.values[3][1];
277
        vertexBufferT[v].z =
278
            (vx * matFinal.values[0][2] >> 8) + (vy * matFinal.values[1][2] >> 8) + (vz * matFinal.values[2][2] >> 8) + matFinal.values[3][2];
279
    }
280
}
281
void RSDK::Legacy::v4::TransformVertices(Matrix *matrix, int32 startIndex, int32 endIndex)
282
{
283
    for (int32 v = startIndex; v < endIndex; ++v) {
284
        int32 vx     = vertexBuffer[v].x;
285
        int32 vy     = vertexBuffer[v].y;
286
        int32 vz     = vertexBuffer[v].z;
287
        Vertex *vert = &vertexBuffer[v];
288
        vert->x      = (vx * matrix->values[0][0] >> 8) + (vy * matrix->values[1][0] >> 8) + (vz * matrix->values[2][0] >> 8) + matrix->values[3][0];
289
        vert->y      = (vx * matrix->values[0][1] >> 8) + (vy * matrix->values[1][1] >> 8) + (vz * matrix->values[2][1] >> 8) + matrix->values[3][1];
290
        vert->z      = (vx * matrix->values[0][2] >> 8) + (vy * matrix->values[1][2] >> 8) + (vz * matrix->values[2][2] >> 8) + matrix->values[3][2];
291
    }
292
}
293
void RSDK::Legacy::v4::Sort3DDrawList()
294
{
295
    for (int32 i = 0; i < faceCount; ++i) {
296
        drawList3D[i].depth = (vertexBufferT[faceBuffer[i].d].z + vertexBufferT[faceBuffer[i].c].z + vertexBufferT[faceBuffer[i].b].z
297
                               + vertexBufferT[faceBuffer[i].a].z)
298
                              >> 2;
299
        drawList3D[i].faceID = i;
300
    }
301

302
    for (int32 i = 0; i < faceCount; ++i) {
303
        for (int32 j = faceCount - 1; j > i; --j) {
304
            if (drawList3D[j].depth > drawList3D[j - 1].depth) {
305
                int32 faceID             = drawList3D[j].faceID;
306
                int32 depth              = drawList3D[j].depth;
307
                drawList3D[j].faceID     = drawList3D[j - 1].faceID;
308
                drawList3D[j].depth      = drawList3D[j - 1].depth;
309
                drawList3D[j - 1].faceID = faceID;
310
                drawList3D[j - 1].depth  = depth;
311
            }
312
        }
313
    }
314
}
315
void RSDK::Legacy::v4::Draw3DScene(int32 spriteSheetID)
316
{
317
    Vertex quad[4];
318
    for (int32 i = 0; i < faceCount; ++i) {
319
        Face *face = &faceBuffer[drawList3D[i].faceID];
320
        memset(quad, 0, 4 * sizeof(Vertex));
321
        switch (face->flag) {
322
            default: break;
323
            case FACE_FLAG_TEXTURED_3D:
324
                if (vertexBufferT[face->a].z > 0 && vertexBufferT[face->b].z > 0 && vertexBufferT[face->c].z > 0 && vertexBufferT[face->d].z > 0) {
325
                    quad[0].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->a].x / vertexBufferT[face->a].z;
326
                    quad[0].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->a].y / vertexBufferT[face->a].z;
327
                    quad[1].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->b].x / vertexBufferT[face->b].z;
328
                    quad[1].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->b].y / vertexBufferT[face->b].z;
329
                    quad[2].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->c].x / vertexBufferT[face->c].z;
330
                    quad[2].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->c].y / vertexBufferT[face->c].z;
331
                    quad[3].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->d].x / vertexBufferT[face->d].z;
332
                    quad[3].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->d].y / vertexBufferT[face->d].z;
333
                    quad[0].u = vertexBuffer[face->a].u;
334
                    quad[0].v = vertexBuffer[face->a].v;
335
                    quad[1].u = vertexBuffer[face->b].u;
336
                    quad[1].v = vertexBuffer[face->b].v;
337
                    quad[2].u = vertexBuffer[face->c].u;
338
                    quad[2].v = vertexBuffer[face->c].v;
339
                    quad[3].u = vertexBuffer[face->d].u;
340
                    quad[3].v = vertexBuffer[face->d].v;
341
                    DrawTexturedFace(quad, spriteSheetID);
342
                }
343
                break;
344
            case FACE_FLAG_TEXTURED_2D:
345
                if (vertexBufferT[face->a].z >= 0 && vertexBufferT[face->b].z >= 0 && vertexBufferT[face->c].z >= 0
346
                    && vertexBufferT[face->d].z >= 0) {
347
                    quad[0].x = vertexBufferT[face->a].x;
348
                    quad[0].y = vertexBufferT[face->a].y;
349
                    quad[1].x = vertexBufferT[face->b].x;
350
                    quad[1].y = vertexBufferT[face->b].y;
351
                    quad[2].x = vertexBufferT[face->c].x;
352
                    quad[2].y = vertexBufferT[face->c].y;
353
                    quad[3].x = vertexBufferT[face->d].x;
354
                    quad[3].y = vertexBufferT[face->d].y;
355
                    quad[0].u = vertexBuffer[face->a].u;
356
                    quad[0].v = vertexBuffer[face->a].v;
357
                    quad[1].u = vertexBuffer[face->b].u;
358
                    quad[1].v = vertexBuffer[face->b].v;
359
                    quad[2].u = vertexBuffer[face->c].u;
360
                    quad[2].v = vertexBuffer[face->c].v;
361
                    quad[3].u = vertexBuffer[face->d].u;
362
                    quad[3].v = vertexBuffer[face->d].v;
363
                    DrawTexturedFace(quad, spriteSheetID);
364
                }
365
                break;
366
            case FACE_FLAG_COLORED_3D:
367
                if (vertexBufferT[face->a].z > 0 && vertexBufferT[face->b].z > 0 && vertexBufferT[face->c].z > 0 && vertexBufferT[face->d].z > 0) {
368
                    quad[0].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->a].x / vertexBufferT[face->a].z;
369
                    quad[0].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->a].y / vertexBufferT[face->a].z;
370
                    quad[1].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->b].x / vertexBufferT[face->b].z;
371
                    quad[1].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->b].y / vertexBufferT[face->b].z;
372
                    quad[2].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->c].x / vertexBufferT[face->c].z;
373
                    quad[2].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->c].y / vertexBufferT[face->c].z;
374
                    quad[3].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->d].x / vertexBufferT[face->d].z;
375
                    quad[3].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->d].y / vertexBufferT[face->d].z;
376
                    DrawFace(quad, face->color);
377
                }
378
                break;
379
            case FACE_FLAG_COLORED_2D:
380
                if (vertexBufferT[face->a].z >= 0 && vertexBufferT[face->b].z >= 0 && vertexBufferT[face->c].z >= 0
381
                    && vertexBufferT[face->d].z >= 0) {
382
                    quad[0].x = vertexBufferT[face->a].x;
383
                    quad[0].y = vertexBufferT[face->a].y;
384
                    quad[1].x = vertexBufferT[face->b].x;
385
                    quad[1].y = vertexBufferT[face->b].y;
386
                    quad[2].x = vertexBufferT[face->c].x;
387
                    quad[2].y = vertexBufferT[face->c].y;
388
                    quad[3].x = vertexBufferT[face->d].x;
389
                    quad[3].y = vertexBufferT[face->d].y;
390
                    DrawFace(quad, face->color);
391
                }
392
                break;
393
            case FACE_FLAG_FADED:
394
                if (vertexBufferT[face->a].z > 0 && vertexBufferT[face->b].z > 0 && vertexBufferT[face->c].z > 0 && vertexBufferT[face->d].z > 0) {
395
                    quad[0].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->a].x / vertexBufferT[face->a].z;
396
                    quad[0].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->a].y / vertexBufferT[face->a].z;
397
                    quad[1].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->b].x / vertexBufferT[face->b].z;
398
                    quad[1].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->b].y / vertexBufferT[face->b].z;
399
                    quad[2].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->c].x / vertexBufferT[face->c].z;
400
                    quad[2].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->c].y / vertexBufferT[face->c].z;
401
                    quad[3].x = SCREEN_CENTERX + projectionX * vertexBufferT[face->d].x / vertexBufferT[face->d].z;
402
                    quad[3].y = SCREEN_CENTERY - projectionY * vertexBufferT[face->d].y / vertexBufferT[face->d].z;
403

404
                    int32 fogStr = 0;
405
                    if ((drawList3D[i].depth - 0x8000) >> 8 >= 0)
406
                        fogStr = (drawList3D[i].depth - 0x8000) >> 8;
407
                    if (fogStr > fogStrength)
408
                        fogStr = fogStrength;
409

410
                    DrawFadedFace(quad, face->color, fogColor, 0xFF - fogStr);
411
                }
412
                break;
413
            case FACE_FLAG_TEXTURED_C:
414
                if (vertexBufferT[face->a].z > 0) {
415
                    // [face->a].uv == sprite center
416
                    // [face->b].uv == ???
417
                    // [face->c].uv == sprite extend (how far to each edge X & Y)
418
                    // [face->d].uv == unused
419

420
                    quad[0].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x - vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
421
                    quad[0].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y + vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
422
                    quad[1].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x + vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
423
                    quad[1].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y + vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
424
                    quad[2].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x - vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
425
                    quad[2].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y - vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
426
                    quad[3].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x + vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
427
                    quad[3].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y - vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
428

429
                    quad[0].u = vertexBuffer[face->a].u - vertexBuffer[face->c].u;
430
                    quad[0].v = vertexBuffer[face->a].v - vertexBuffer[face->c].v;
431
                    quad[1].u = vertexBuffer[face->a].u + vertexBuffer[face->c].u;
432
                    quad[1].v = vertexBuffer[face->a].v - vertexBuffer[face->c].v;
433
                    quad[2].u = vertexBuffer[face->a].u - vertexBuffer[face->c].u;
434
                    quad[2].v = vertexBuffer[face->a].v + vertexBuffer[face->c].v;
435
                    quad[3].u = vertexBuffer[face->a].u + vertexBuffer[face->c].u;
436
                    quad[3].v = vertexBuffer[face->a].v + vertexBuffer[face->c].v;
437

438
                    DrawTexturedFace(quad, spriteSheetID);
439
                }
440
                break;
441
            case FACE_FLAG_TEXTURED_C_BLEND:
442
                if (vertexBufferT[face->a].z > 0) {
443
                    // See above, its the same just blended
444

445
                    quad[0].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x - vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
446
                    quad[0].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y + vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
447
                    quad[1].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x + vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
448
                    quad[1].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y + vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
449
                    quad[2].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x - vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
450
                    quad[2].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y - vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
451
                    quad[3].x = SCREEN_CENTERX + projectionX * (vertexBufferT[face->a].x + vertexBuffer[face->b].u) / vertexBufferT[face->a].z;
452
                    quad[3].y = SCREEN_CENTERY - projectionY * (vertexBufferT[face->a].y - vertexBuffer[face->b].v) / vertexBufferT[face->a].z;
453

454
                    quad[0].u = vertexBuffer[face->a].u - vertexBuffer[face->c].u;
455
                    quad[0].v = vertexBuffer[face->a].v - vertexBuffer[face->c].v;
456
                    quad[1].u = vertexBuffer[face->a].u + vertexBuffer[face->c].u;
457
                    quad[1].v = vertexBuffer[face->a].v - vertexBuffer[face->c].v;
458
                    quad[2].u = vertexBuffer[face->a].u - vertexBuffer[face->c].u;
459
                    quad[2].v = vertexBuffer[face->a].v + vertexBuffer[face->c].v;
460
                    quad[3].u = vertexBuffer[face->a].u + vertexBuffer[face->c].u;
461
                    quad[3].v = vertexBuffer[face->a].v + vertexBuffer[face->c].v;
462

463
                    DrawTexturedFaceBlended(quad, spriteSheetID);
464
                }
465
                break;
466
            case FACE_FLAG_3DSPRITE:
467
                if (vertexBufferT[face->a].z > 0) {
468
                    int32 xpos = SCREEN_CENTERX + projectionX * vertexBufferT[face->a].x / vertexBufferT[face->a].z;
469
                    int32 ypos = SCREEN_CENTERY - projectionY * vertexBufferT[face->a].y / vertexBufferT[face->a].z;
470

471
                    ObjectScript *scriptInfo = &objectScriptList[vertexBuffer[face->a].u];
472
                    SpriteFrame *frame       = &scriptFrames[scriptInfo->frameListOffset + vertexBuffer[face->b].u];
473

474
                    switch (vertexBuffer[face->a].v) {
475
                        case FX_SCALE:
476
                            DrawSpriteScaled(vertexBuffer[face->b].v, xpos, ypos, -frame->pivotX, -frame->pivotY, vertexBuffer[face->c].u,
477
                                             vertexBuffer[face->c].u, frame->width, frame->height, frame->sprX, frame->sprY,
478
                                             scriptInfo->spriteSheetID);
479
                            break;
480
                        case FX_ROTATE:
481
                            DrawSpriteRotated(vertexBuffer[face->b].v, xpos, ypos, -frame->pivotX, -frame->pivotY, frame->sprX, frame->sprY,
482
                                              frame->width, frame->height, vertexBuffer[face->c].v, scriptInfo->spriteSheetID);
483
                            break;
484
                        case FX_ROTOZOOM:
485
                            DrawSpriteRotozoom(vertexBuffer[face->b].v, xpos, ypos, -frame->pivotX, -frame->pivotY, frame->sprX, frame->sprY,
486
                                               frame->width, frame->height, vertexBuffer[face->c].v, vertexBuffer[face->c].u,
487
                                               scriptInfo->spriteSheetID);
488
                            break;
489
                    }
490
                }
491
                break;
492
        }
493
    }
494
}
495

496
Product

Resources

Company
