Subversion Repositories eduke32

Rev

Rev 5056 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5056 Rev 5075
Line 31... Line 31...
31
#endif
31
#endif
32
32
33
extern char textfont[2048], smalltextfont[2048];
33
extern char textfont[2048], smalltextfont[2048];
34
34
35
int32_t rendmode=0;
35
int32_t rendmode=0;
36
#ifdef __ANDROID__
36
#ifdef EDUKE32_GLES
37
int32_t usemodels=0;
37
int32_t usemodels=0;
38
#else
38
#else
39
int32_t usemodels=1;
39
int32_t usemodels=1;
40
#endif
40
#endif
41
int32_t usehightile=1;
41
int32_t usehightile=1;
Line 49... Line 49...
49
static vsptyp vsp[VSPMAX];
49
static vsptyp vsp[VSPMAX];
50
static int32_t gtag;
50
static int32_t gtag;
51
51
52
static float dxb1[MAXWALLSB], dxb2[MAXWALLSB];
52
static float dxb1[MAXWALLSB], dxb2[MAXWALLSB];
53
53
54
#define SCISDIST .9999f  //1.0: Close plane clipping distance
54
#define SCISDIST 1.0f  //1.0: Close plane clipping distance
55
55
56
float shadescale = 1.0f;
56
float shadescale = 1.0f;
57
int32_t shadescale_unbounded = 0;
57
int32_t shadescale_unbounded = 0;
58
58
59
int32_t r_usenewshading = 3;
59
int32_t r_usenewshading = 3;
Line 65... Line 65...
65
float gxyaspect;
65
float gxyaspect;
66
float gyxscale, ghalfx, grhalfxdown10, grhalfxdown10x;
66
float gyxscale, ghalfx, grhalfxdown10, grhalfxdown10x;
67
float gcosang, gsinang, gcosang2, gsinang2;
67
float gcosang, gsinang, gcosang2, gsinang2;
68
float gchang, gshang, gctang, gstang, gvisibility;
68
float gchang, gshang, gctang, gstang, gvisibility;
69
float gtang = 0.f;
69
float gtang = 0.f;
70
static double guo, gux, guy; //Screen-based texture mapping parameters
-
 
71
static double gvo, gvx, gvy;
-
 
-
 
70
72
static double gdo, gdx, gdy;
71
static vec3d_t xtex, ytex, otex;
-
 
72
73
float fcosglobalang, fsinglobalang;
73
float fcosglobalang, fsinglobalang;
74
float fxdim, fydim, fydimen, fviewingrange;
74
float fxdim, fydim, fydimen, fviewingrange;
75
static int32_t preview_mouseaim=0;  // when 1, displays a CROSSHAIR tsprite at the _real_ aimed position
75
static int32_t preview_mouseaim=0;  // when 1, displays a CROSSHAIR tsprite at the _real_ aimed position
76
76
77
#ifdef USE_OPENGL
-
 
78
static int32_t srepeat = 0, trepeat = 0;
77
static int32_t drawpoly_srepeat = 0, drawpoly_trepeat = 0;
79
78
80
#ifdef REDBLUEMODE
79
#ifdef REDBLUEMODE
81
int32_t glredbluemode = 0;
80
int32_t glredbluemode = 0;
82
static int32_t lastglredbluemode = 0, redblueclearcnt = 0;
81
static int32_t lastglredbluemode = 0, redblueclearcnt = 0;
83
#endif
82
#endif
Line 99... Line 98...
99
int32_t glusetexcompr = 0;
98
int32_t glusetexcompr = 0;
100
int32_t glusetexcache = 0, glusememcache = 0;
99
int32_t glusetexcache = 0, glusememcache = 0;
101
#else
100
#else
102
int32_t glusetexcompr = 1;
101
int32_t glusetexcompr = 1;
103
int32_t glusetexcache = 2, glusememcache = 1;
102
int32_t glusetexcache = 2, glusememcache = 1;
104
int32_t glpolygonmode = 0;     // 0:GL_FILL,1:GL_LINE,2:GL_POINT //FUK
103
int32_t r_polygonmode = 0;     // 0:GL_FILL,1:GL_LINE,2:GL_POINT //FUK
105
int32_t glmultisample = 0, glnvmultisamplehint = 0;
104
int32_t glmultisample = 0, glnvmultisamplehint = 0;
106
static int32_t lastglpolygonmode = 0; //FUK
105
static int32_t lastglpolygonmode = 0; //FUK
107
int32_t r_detailmapping = 1;
106
int32_t r_detailmapping = 1;
108
int32_t r_glowmapping = 1;
107
int32_t r_glowmapping = 1;
109
#endif
108
#endif
Line 114... Line 113...
114
static GLuint polymosttext = 0;
113
static GLuint polymosttext = 0;
115
int32_t glrendmode = REND_POLYMOST;
114
int32_t glrendmode = REND_POLYMOST;
116
115
117
// This variable, and 'shadeforfullbrightpass' control the drawing of
116
// This variable, and 'shadeforfullbrightpass' control the drawing of
118
// fullbright tiles.  Also see 'fullbrightloadingpass'.
117
// fullbright tiles.  Also see 'fullbrightloadingpass'.
119
static int32_t fullbrightdrawingpass = 0;
-
 
120
118
121
int32_t r_vertexarrays = 1;
119
int32_t r_vertexarrays = 1;
122
int32_t r_vbos = 1;
120
int32_t r_vbos = 1;
123
int32_t r_vbocount = 64;
121
int32_t r_vbocount = 64;
124
int32_t r_animsmoothing = 1;
122
int32_t r_animsmoothing = 1;
Line 126... Line 124...
126
int32_t r_downsize = 0;
124
int32_t r_downsize = 0;
127
int32_t r_downsizevar = -1;
125
int32_t r_downsizevar = -1;
128
126
129
// used for fogcalc
127
// used for fogcalc
130
static float fogresult, fogresult2, fogcol[4], fogtable[4*MAXPALOOKUPS];
128
static float fogresult, fogresult2, fogcol[4], fogtable[4*MAXPALOOKUPS];
131
#endif
-
 
132
129
133
static const float float_trans[4] = { 1.0f, 1.0f, 0.66f, 0.33f };
130
static const float float_trans[4] = { 1.0f, 1.0f, 0.66f, 0.33f };
134
131
135
char ptempbuf[MAXWALLSB<<1];
132
char ptempbuf[MAXWALLSB<<1];
136
133
Line 148... Line 145...
148
static inline float Bfabsf(float f) { return __int_as_float(__float_as_int(f)&0x7fffffff); }
145
static inline float Bfabsf(float f) { return __int_as_float(__float_as_int(f)&0x7fffffff); }
149
#else
146
#else
150
#define Bfabsf fabsf
147
#define Bfabsf fabsf
151
#endif
148
#endif
152
149
153
#ifdef USE_OPENGL
-
 
154
int32_t mdtims, omdtims;
150
int32_t mdtims, omdtims;
155
float alphahackarray[MAXTILES];
151
uint8_t alphahackarray[MAXTILES];
156
int32_t drawingskybox = 0;
152
int32_t drawingskybox = 0;
157
int32_t hicprecaching = 0;
153
int32_t hicprecaching = 0;
158
154
-
 
155
float r_wspr_variance = 0.000001f;
-
 
156
float r_wspr_offset = 0.005f;
-
 
157
float r_fspr_offset = 1.0f;
-
 
158
159
#if 0
159
#if 0
160
static inline int32_t gltexmayhavealpha(int32_t dapicnum, int32_t dapalnum)
160
static inline int32_t gltexmayhavealpha(int32_t dapicnum, int32_t dapalnum)
161
{
161
{
162
    const int32_t j = (dapicnum&(GLTEXCACHEADSIZ-1));
162
    const int32_t j = (dapicnum&(GLTEXCACHEADSIZ-1));
163
    pthtyp *pth;
163
    pthtyp *pth;
Line 170... Line 170...
170
}
170
}
171
#endif
171
#endif
172
172
173
void gltexinvalidate(int32_t dapicnum, int32_t dapalnum, int32_t dameth)
173
void gltexinvalidate(int32_t dapicnum, int32_t dapalnum, int32_t dameth)
174
{
174
{
175
    const int32_t j = (dapicnum&(GLTEXCACHEADSIZ-1));
175
    const int32_t pic = (dapicnum&(GLTEXCACHEADSIZ-1));
176
    pthtyp *pth;
-
 
177
176
178
    for (pth=texcache.list[j]; pth; pth=pth->next)
177
    for (pthtyp *pth=texcache.list[pic]; pth; pth=pth->next)
179
        if (pth->picnum == dapicnum && pth->palnum == dapalnum &&
178
        if (pth->picnum == dapicnum && pth->palnum == dapalnum &&
180
            (pth->flags & PTH_CLAMPED) == TO_PTH_CLAMPED(dameth))
179
            (pth->flags & PTH_CLAMPED) == TO_PTH_CLAMPED(dameth))
181
        {
180
        {
182
            pth->flags |= PTH_INVALIDATED;
181
            pth->flags |= PTH_INVALIDATED;
183
            if (pth->flags & PTH_HASFULLBRIGHT)
182
            if (pth->flags & PTH_HASFULLBRIGHT)
Line 188... Line 187...
188
//Make all textures "dirty" so they reload, but not re-allocate
187
//Make all textures "dirty" so they reload, but not re-allocate
189
//This should be much faster than polymost_glreset()
188
//This should be much faster than polymost_glreset()
190
//Use this for palette effects ... but not ones that change every frame!
189
//Use this for palette effects ... but not ones that change every frame!
191
void gltexinvalidatetype(int32_t type)
190
void gltexinvalidatetype(int32_t type)
192
{
191
{
193
    int32_t j;
-
 
194
    pthtyp *pth;
-
 
195
-
 
196
    for (j=0; j<=GLTEXCACHEADSIZ-1; j++)
192
    for (int j=0; j<=GLTEXCACHEADSIZ-1; j++)
197
    {
193
    {
198
        for (pth=texcache.list[j]; pth; pth=pth->next)
194
        for (pthtyp *pth=texcache.list[j]; pth; pth=pth->next)
199
        {
195
        {
200
            if (type == INVALIDATE_ALL || (type == INVALIDATE_ART && pth->hicr == NULL))
196
            if (type == INVALIDATE_ALL || (type == INVALIDATE_ART && pth->hicr == NULL))
201
            {
197
            {
202
                pth->flags |= PTH_INVALIDATED;
198
                pth->flags |= PTH_INVALIDATED;
203
                if (pth->flags & PTH_HASFULLBRIGHT)
199
                if (pth->flags & PTH_HASFULLBRIGHT)
Line 227... Line 223...
227
#endif
223
#endif
228
}
224
}
229
225
230
void gltexapplyprops(void)
226
void gltexapplyprops(void)
231
{
227
{
232
    int32_t i;
-
 
233
    pthtyp *pth;
-
 
234
-
 
235
    if (getrendermode() == REND_CLASSIC)
228
    if (getrendermode() == REND_CLASSIC)
236
        return;
229
        return;
237
230
238
    if (glinfo.maxanisotropy > 1.f)
231
    if (glinfo.maxanisotropy > 1.f)
239
    {
232
    {
Line 241... Line 234...
241
            glanisotropy = (int32_t)glinfo.maxanisotropy;
234
            glanisotropy = (int32_t)glinfo.maxanisotropy;
242
    }
235
    }
243
236
244
    gltexfiltermode = clamp(gltexfiltermode, 0, NUMGLFILTERMODES-1);
237
    gltexfiltermode = clamp(gltexfiltermode, 0, NUMGLFILTERMODES-1);
245
238
246
    for (i=0; i<=GLTEXCACHEADSIZ-1; i++)
239
    for (int i=0; i<=GLTEXCACHEADSIZ-1; i++)
247
    {
240
    {
248
        for (pth=texcache.list[i]; pth; pth=pth->next)
241
        for (pthtyp *pth=texcache.list[i]; pth; pth=pth->next)
249
        {
242
        {
250
#ifndef EDUKE32_TOUCH_DEVICES
243
#ifndef EDUKE32_TOUCH_DEVICES
251
            bind_2d_texture(pth->glpic, -1);
244
            bind_2d_texture(pth->glpic, -1);
252
245
253
            if (r_fullbrights && pth->flags & PTH_HASFULLBRIGHT)
246
            if (r_fullbrights && pth->flags & PTH_HASFULLBRIGHT)
Line 259... Line 252...
259
                bind_2d_texture(pth->ofb->glpic, pth->flags & PTH_HIGHTILE ? 5 : -1);
252
                bind_2d_texture(pth->ofb->glpic, pth->flags & PTH_HIGHTILE ? 5 : -1);
260
#endif
253
#endif
261
        }
254
        }
262
    }
255
    }
263
256
264
    int32_t j;
-
 
265
    mdskinmap_t *sk;
-
 
266
    md2model_t *m;
-
 
267
-
 
268
    for (i=0; i<nextmodelid; i++)
257
    for (int i=0; i<nextmodelid; i++)
269
    {
258
    {
270
        m = (md2model_t *)models[i];
259
        md2model_t *m = (md2model_t *)models[i];
-
 
260
271
        if (m->mdnum < 2) continue;
261
        if (m->mdnum < 2)
-
 
262
            continue;
-
 
263
272
        for (j=0; j<m->numskins*(HICEFFECTMASK+1); j++)
264
        for (int j = 0; j < m->numskins * (HICEFFECTMASK + 1); j++)
273
        {
265
        {
274
            if (!m->texid[j]) continue;
266
            if (!m->texid[j])
-
 
267
                continue;
275
            bind_2d_texture(m->texid[j], -1);
268
            bind_2d_texture(m->texid[j], -1);
276
        }
269
        }
277
270
278
        for (sk=m->skinmap; sk; sk=sk->next)
271
        for (mdskinmap_t *sk = m->skinmap; sk; sk = sk->next)
279
            for (j=0; j<(HICEFFECTMASK+1); j++)
272
            for (int j = 0; j < (HICEFFECTMASK + 1); j++)
280
            {
273
            {
281
                if (!sk->texid[j]) continue;
274
                if (!sk->texid[j])
-
 
275
                    continue;
282
                bind_2d_texture(sk->texid[j], -1);
276
                bind_2d_texture(sk->texid[j], -1);
283
            }
277
            }
284
    }
278
    }
285
}
279
}
286
280
Line 291... Line 285...
291
//Use this for both initialization and uninitialization of OpenGL.
285
//Use this for both initialization and uninitialization of OpenGL.
292
static int32_t gltexcacnum = -1;
286
static int32_t gltexcacnum = -1;
293
287
294
void polymost_glreset()
288
void polymost_glreset()
295
{
289
{
296
    int32_t i;
-
 
297
    pthtyp *pth, *next;
-
 
298
-
 
299
    for (i=0; i<=MAXPALOOKUPS-1; i++)
290
    for (int i=0; i<=MAXPALOOKUPS-1; i++)
300
    {
291
    {
301
        fogtable[i<<2] = palookupfog[i].r * (1.f/63.f);
292
        fogtable[i<<2] = palookupfog[i].r * (1.f/63.f);
302
        fogtable[(i<<2)+1] = palookupfog[i].g * (1.f/63.f);
293
        fogtable[(i<<2)+1] = palookupfog[i].g * (1.f/63.f);
303
        fogtable[(i<<2)+2] = palookupfog[i].b * (1.f/63.f);
294
        fogtable[(i<<2)+2] = palookupfog[i].b * (1.f/63.f);
304
        fogtable[(i<<2)+3] = 0;
295
        fogtable[(i<<2)+3] = 0;
Line 313... Line 304...
313
        gcosang = gcosang2 = 16384.f/262144.f;
304
        gcosang = gcosang2 = 16384.f/262144.f;
314
        gsinang = gsinang2 = 0.f/262144.f;
305
        gsinang = gsinang2 = 0.f/262144.f;
315
    }
306
    }
316
    else
307
    else
317
    {
308
    {
318
        for (i=0; i<=GLTEXCACHEADSIZ-1; i++)
309
        for (int i = 0; i <= GLTEXCACHEADSIZ-1; i++)
319
        {
310
        {
320
            for (pth=texcache.list[i]; pth;)
311
            for (pthtyp *pth = texcache.list[i]; pth;)
321
            {
312
            {
322
                next = pth->next;
313
                pthtyp *const next = pth->next;
-
 
314
323
                if (pth->flags & PTH_HASFULLBRIGHT)
315
                if (pth->flags & PTH_HASFULLBRIGHT)
324
                {
316
                {
325
                    bglDeleteTextures(1,&pth->ofb->glpic);
317
                    bglDeleteTextures(1, &pth->ofb->glpic);
326
                    Bfree(pth->ofb);
318
                    Bfree(pth->ofb);
327
                }
319
                }
Line 331... Line 323...
331
                pth = next;
323
                pth = next;
332
            }
324
            }
333
325
334
            texcache.list[i] = NULL;
326
            texcache.list[i] = NULL;
335
        }
327
        }
-
 
328
336
        clearskins();
329
        clearskins();
337
    }
330
    }
338
331
339
    if (polymosttext)
332
    if (polymosttext)
340
        bglDeleteTextures(1,&polymosttext);
333
        bglDeleteTextures(1,&polymosttext);
Line 448... Line 441...
448
        shade >>= 1;
441
        shade >>= 1;
449
442
450
    Bmemcpy(fogcol, &fogtable[pal<<2], sizeof(fogcol));
443
    Bmemcpy(fogcol, &fogtable[pal<<2], sizeof(fogcol));
451
444
452
    if (r_usenewshading < 2)
445
    if (r_usenewshading < 2)
453
        fogcalc_old(shade, vis);
-
 
454
    else
-
 
455
    {
446
    {
-
 
447
        fogcalc_old(shade, vis);
-
 
448
        return;
-
 
449
    }
-
 
450
456
        float combvis = (float) globalvisibility * (uint8_t) (vis+16);
451
    float combvis = (float) globalvisibility * (uint8_t) (vis+16);
457
452
458
        if (combvis == 0)
453
    if (combvis == 0)
459
        {
454
    {
460
            if (r_usenewshading == 2 && shade > 0)
455
        if (r_usenewshading == 2 && shade > 0)
Line 480... Line 475...
480
            combvis = 1.f/combvis;
475
        combvis = 1.f/combvis;
481
            fogresult = (r_usenewshading == 3 && shade > 0) ? 0 : -(FOGDISTCONST * shade) * combvis;
476
        fogresult = (r_usenewshading == 3 && shade > 0) ? 0 : -(FOGDISTCONST * shade) * combvis;
482
            fogresult2 = (FOGDISTCONST * (numshades-1-shade)) * combvis;
477
        fogresult2 = (FOGDISTCONST * (numshades-1-shade)) * combvis;
483
        }
478
    }
484
    }
479
}
485
}
-
 
486
480
487
void calc_and_apply_fog(int32_t tile, int32_t shade, int32_t vis, int32_t pal)
481
void calc_and_apply_fog(int32_t tile, int32_t shade, int32_t vis, int32_t pal)
488
{
482
{
489
    fogcalc(tile, shade, vis, pal);
483
    fogcalc(tile, shade, vis, pal);
490
    bglFogfv(GL_FOG_COLOR, fogcol);
484
    bglFogfv(GL_FOG_COLOR, fogcol);
Line 516... Line 510...
516
////////////////////
510
////////////////////
517
511
518
512
519
static float get_projhack_ratio(void)
513
static float get_projhack_ratio(void)
520
{
514
{
521
    float rv;
515
    float rv = 1.f;
522
516
523
    if (glprojectionhacks == 1)
517
    if (glprojectionhacks == 1)
524
    {
518
    {
525
        float const mul = (gshang * gshang);
519
        float const mul = (gshang * gshang);
526
        rv = 1.05f + mul * mul * mul * mul;
520
        rv = 1.05f + mul * mul * mul * mul;
Line 529... Line 523...
529
    {
523
    {
530
        float const abs_shang = Bfabsf(gshang);
524
        float const abs_shang = Bfabsf(gshang);
531
        rv = (abs_shang > 0.7f) ?
525
        rv = (abs_shang > 0.7f) ?
532
            1.05f + 4.f * (abs_shang - 0.7f) : 1.f;
526
            1.05f + 4.f * (abs_shang - 0.7f) : 1.f;
533
    }
527
    }
534
    else
-
 
535
        rv = 1.f;
-
 
536
528
537
    // No projection hacks (legacy or new-aspect)
529
    // No projection hacks (legacy or new-aspect)
538
    return rv;
530
    return rv;
539
}
531
}
540
532
Line 553... Line 545...
553
    lastglredbluemode = glredbluemode;
545
    lastglredbluemode = glredbluemode;
554
#endif
546
#endif
555
547
556
#ifndef EDUKE32_GLES
548
#ifndef EDUKE32_GLES
557
    //FUK
549
    //FUK
558
    if (lastglpolygonmode != glpolygonmode)
550
    if (lastglpolygonmode != r_polygonmode)
559
    {
551
    {
560
        lastglpolygonmode = glpolygonmode;
552
        lastglpolygonmode = r_polygonmode;
561
        switch (glpolygonmode)
553
        switch (r_polygonmode)
562
        {
554
        {
563
        default:
555
        default:
564
        case 0:
556
        case 0:
565
            bglPolygonMode(GL_FRONT_AND_BACK,GL_FILL); break;
557
            bglPolygonMode(GL_FRONT_AND_BACK,GL_FILL); break;
566
        case 1:
558
        case 1:
567
            bglPolygonMode(GL_FRONT_AND_BACK,GL_LINE); break;
559
            bglPolygonMode(GL_FRONT_AND_BACK,GL_LINE); break;
568
        case 2:
560
        case 2:
569
            bglPolygonMode(GL_FRONT_AND_BACK,GL_POINT); break;
561
            bglPolygonMode(GL_FRONT_AND_BACK,GL_POINT); break;
570
        }
562
        }
571
    }
563
    }
572
    if (glpolygonmode) //FUK
564
    if (r_polygonmode) //FUK
573
    {
565
    {
574
        bglClearColor(1.0,1.0,1.0,0.0);
566
        bglClearColor(1.0,1.0,1.0,0.0);
575
        bglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
567
        bglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
576
        bglDisable(GL_TEXTURE_2D);
568
        bglDisable(GL_TEXTURE_2D);
577
    }
569
    }
Line 582... Line 574...
582
    if ((glox1 != windowx1) || (gloy1 != windowy1) || (glox2 != windowx2) || (gloy2 != windowy2))
574
    if ((glox1 != windowx1) || (gloy1 != windowy1) || (glox2 != windowx2) || (gloy2 != windowy2))
583
    {
575
    {
584
        const int32_t ourxdimen = (windowx2-windowx1+1);
576
        const int32_t ourxdimen = (windowx2-windowx1+1);
585
        float ratio = get_projhack_ratio();
577
        float ratio = get_projhack_ratio();
586
        const int32_t fovcorrect = (ratio==0) ? 0 : (int32_t)(ourxdimen*ratio - ourxdimen);
578
        const int32_t fovcorrect = (ratio==0) ? 0 : (int32_t)(ourxdimen*ratio - ourxdimen);
-
 
579
587
        float m[4][4];
580
        ratio = 1.f/ratio;
588
581
589
        glox1 = (float)windowx1; gloy1 = (float)windowy1;
582
        glox1 = (float)windowx1; gloy1 = (float)windowy1;
590
        glox2 = (float)windowx2; gloy2 = (float)windowy2;
583
        glox2 = (float)windowx2; gloy2 = (float)windowy2;
591
584
592
        bglViewport(windowx1-(fovcorrect/2), yres-(windowy2+1),
585
        bglViewport(windowx1-(fovcorrect/2), yres-(windowy2+1),
593
                    ourxdimen+fovcorrect, windowy2-windowy1+1);
586
                    ourxdimen+fovcorrect, windowy2-windowy1+1);
594
587
595
        bglMatrixMode(GL_PROJECTION);
588
        bglMatrixMode(GL_PROJECTION);
-
 
589
-
 
590
        float m[4][4];
596
        Bmemset(m,0,sizeof(m));
591
        Bmemset(m,0,sizeof(m));
597
        ratio = 1.f/ratio;
-
 
-
 
592
-
 
593
598
        m[0][0] = fydimen * ratio; m[0][2] = 1.f;
594
        m[0][0] = fydimen * ratio; m[0][2] = 1.f;
599
        m[1][1] = fxdimen; m[1][2] = 1.f;
595
        m[1][1] = fxdimen; m[1][2] = 1.f;
600
        m[2][2] = 1.f; m[2][3] = fydimen * ratio;
596
        m[2][2] = 1.f; m[2][3] = fydimen * ratio;
601
        m[3][2] =-1.f;
597
        m[3][2] =-1.f;
602
        bglLoadMatrixf(&m[0][0]);
598
        bglLoadMatrixf(&m[0][0]);
603
599
604
        bglMatrixMode(GL_MODELVIEW);
600
        bglMatrixMode(GL_MODELVIEW);
605
        bglLoadIdentity();
601
        bglLoadIdentity();
606
602
607
#ifdef USE_OPENGL
-
 
608
        if (!nofog) bglEnable(GL_FOG);
603
        if (!nofog) bglEnable(GL_FOG);
609
#endif
-
 
610
604
611
        //bglEnable(GL_TEXTURE_2D);
605
        //bglEnable(GL_TEXTURE_2D);
612
    }
606
    }
613
}
607
}
614
608
615
static void fixtransparency(coltype *dapic, vec2_t dasiz, vec2_t dasiz2, int32_t dameth)
609
static void fixtransparency(coltype *dapic, vec2_t dasiz, vec2_t dasiz2, int32_t dameth)
616
{
610
{
617
    int32_t y, naxsiz2;
-
 
618
    vec2_t doxy = { dasiz2.x-1, dasiz2.y-1 };
611
    vec2_t doxy = { dasiz2.x-1, dasiz2.y-1 };
619
612
620
    if (dameth&4) { doxy.x = min(doxy.x, dasiz.x); doxy.y = min(doxy.y, dasiz.y); }
613
    if (dameth&4) { doxy.x = min(doxy.x, dasiz.x); doxy.y = min(doxy.y, dasiz.y); }
621
    else { dasiz = dasiz2; } //Make repeating textures duplicate top/left parts
614
    else { dasiz = dasiz2; } //Make repeating textures duplicate top/left parts
622
615
623
    dasiz.x--; dasiz.y--; naxsiz2 = -dasiz2.x; //Hacks for optimization inside loop
616
    dasiz.x--; dasiz.y--; //Hacks for optimization inside loop
-
 
617
    int32_t const naxsiz2 = -dasiz2.x;
624
618
625
    //Set transparent pixels to average color of neighboring opaque pixels
619
    //Set transparent pixels to average color of neighboring opaque pixels
626
    //Doing this makes bilinear filtering look much better for masked textures (I.E. sprites)
620
    //Doing this makes bilinear filtering look much better for masked textures (I.E. sprites)
627
    for (y=doxy.y; y>=0; y--)
621
    for (int y=doxy.y; y>=0; y--)
628
    {
622
    {
629
        int32_t x;
-
 
630
        coltype * wpptr = &dapic[y*dasiz2.x+doxy.x];
623
        coltype * wpptr = &dapic[y*dasiz2.x+doxy.x];
631
624
632
        for (x=doxy.x; x>=0; x--,wpptr--)
625
        for (int x=doxy.x; x>=0; x--,wpptr--)
633
        {
626
        {
634
            int32_t r=0, g=0, b=0, j=0;
-
 
635
-
 
636
            if (wpptr->a) continue;
627
            if (wpptr->a) continue;
637
628
638
            r = g = b = j = 0;
629
            int r = 0, g = 0, b = 0, j = 0;
-
 
630
639
            if ((x>     0) && (wpptr[     -1].a)) { r += wpptr[     -1].r; g += wpptr[     -1].g; b += wpptr[     -1].b; j++; }
631
            if ((x>     0) && (wpptr[     -1].a)) { r += wpptr[     -1].r; g += wpptr[     -1].g; b += wpptr[     -1].b; j++; }
640
            if ((x<dasiz.x) && (wpptr[     +1].a)) { r += wpptr[     +1].r; g += wpptr[     +1].g; b += wpptr[     +1].b; j++; }
632
            if ((x<dasiz.x) && (wpptr[     +1].a)) { r += wpptr[     +1].r; g += wpptr[     +1].g; b += wpptr[     +1].b; j++; }
641
            if ((y>     0) && (wpptr[naxsiz2].a)) { r += wpptr[naxsiz2].r; g += wpptr[naxsiz2].g; b += wpptr[naxsiz2].b; j++; }
633
            if ((y>     0) && (wpptr[naxsiz2].a)) { r += wpptr[naxsiz2].r; g += wpptr[naxsiz2].g; b += wpptr[naxsiz2].b; j++; }
642
            if ((y<dasiz.y) && (wpptr[dasiz2.x].a)) { r += wpptr[dasiz2.x].r; g += wpptr[dasiz2.x].g; b += wpptr[dasiz2.x].b; j++; }
634
            if ((y<dasiz.y) && (wpptr[dasiz2.x].a)) { r += wpptr[dasiz2.x].r; g += wpptr[dasiz2.x].g; b += wpptr[dasiz2.x].b; j++; }
-
 
635
643
            switch (j)
636
            switch (j)
644
            {
637
            {
645
            case 1:
638
            case 1:
646
                wpptr->r =   r            ; wpptr->g =   g            ; wpptr->b =   b            ; break;
639
                wpptr->r =   r            ; wpptr->g =   g            ; wpptr->b =   b            ; break;
647
            case 2:
640
            case 2:
Line 653... Line 646...
653
            }
646
            }
654
        }
647
        }
655
    }
648
    }
656
}
649
}
657
650
658
void uploadtexture(int32_t doalloc, int32_t xsiz, int32_t ysiz, int32_t intexfmt, int32_t texfmt,
651
void uploadtexture(int32_t doalloc, vec2_t siz, int32_t intexfmt, int32_t texfmt,
659
                   coltype *pic, int32_t tsizx, int32_t tsizy, int32_t dameth)
652
                   coltype *pic, vec2_t tsiz, int32_t dameth)
660
{
653
{
661
    int32_t x2, y2, j, js=0;
654
    const int hi = !!(dameth & DAMETH_HI);
662
    const int32_t hi = (dameth & DAMETH_HI) ? 1 : 0;
655
    const int nocompress = !!(dameth & DAMETH_NOCOMPRESS);
663
    const int32_t nocompress = (dameth & DAMETH_NOCOMPRESS) ? 1 : 0;
656
    const int nomiptransfix  = !!(dameth & DAMETH_NOFIX);
664
657
665
    dameth &= ~(DAMETH_HI|DAMETH_NOCOMPRESS);
658
    dameth &= ~(DAMETH_HI|DAMETH_NOCOMPRESS|DAMETH_NOFIX);
666
659
667
    if (gltexmaxsize <= 0)
660
    if (gltexmaxsize <= 0)
668
    {
661
    {
669
        GLint i = 0;
662
        GLint i = 0;
670
        bglGetIntegerv(GL_MAX_TEXTURE_SIZE, &i);
663
        bglGetIntegerv(GL_MAX_TEXTURE_SIZE, &i);
Line 674... Line 667...
674
            gltexmaxsize = 0;
667
            gltexmaxsize = 0;
675
            for (; i>1; i>>=1) gltexmaxsize++;
668
            for (; i>1; i>>=1) gltexmaxsize++;
676
        }
669
        }
677
    }
670
    }
678
671
679
    js = max(0,min(gltexmaxsize-1,gltexmiplevel));
672
    gltexmiplevel = max(0, min(gltexmaxsize-1, gltexmiplevel));
680
    gltexmiplevel = js;
-
 
681
    while ((xsiz>>js) > (1<<gltexmaxsize) || (ysiz>>js) > (1<<gltexmaxsize)) js++;
-
 
682
673
683
    if (hi && !nocompress) js = r_downsize;
674
    int miplevel = gltexmiplevel;
684
675
685
    /*
-
 
686
    OSD_Printf("Uploading %dx%d %s as %s\n", xsiz,ysiz,
676
    while ((siz.x >> miplevel) > (1 << gltexmaxsize) || (siz.y >> miplevel) > (1 << gltexmaxsize))
687
            (texfmt==GL_RGBA?"GL_RGBA":
-
 
688
             texfmt==GL_RGB?"GL_RGB":
-
 
689
             texfmt==GL_BGR?"GL_BGR":
677
        miplevel++;
690
             texfmt==GL_BGRA?"GL_BGRA":"other"),
-
 
691
            (intexfmt==GL_RGBA?"GL_RGBA":
-
 
692
             intexfmt==GL_RGB?"GL_RGB":
-
 
693
             intexfmt==GL_COMPRESSED_RGBA_ARB?"GL_COMPRESSED_RGBA_ARB":
-
 
694
             intexfmt==GL_COMPRESSED_RGB_ARB?"GL_COMPRESSED_RGB_ARB":"other"));
-
 
695
    */
-
 
696
678
-
 
679
    if (hi && !nocompress && r_downsize > miplevel)
-
 
680
        miplevel = r_downsize;
-
 
681
697
    if (js == 0)
682
    if (!miplevel)
698
    {
683
    {
699
        if (doalloc&1)
684
        if (doalloc&1)
700
            bglTexImage2D(GL_TEXTURE_2D,0,intexfmt,xsiz,ysiz,0,texfmt,GL_UNSIGNED_BYTE,pic); //loading 1st time
685
            bglTexImage2D(GL_TEXTURE_2D,0,intexfmt,siz.x,siz.y,0,texfmt,GL_UNSIGNED_BYTE,pic); //loading 1st time
701
        else
686
        else
702
            bglTexSubImage2D(GL_TEXTURE_2D,0,0,0,xsiz,ysiz,texfmt,GL_UNSIGNED_BYTE,pic); //overwrite old texture
687
            bglTexSubImage2D(GL_TEXTURE_2D,0,0,0,siz.x,siz.y,texfmt,GL_UNSIGNED_BYTE,pic); //overwrite old texture
703
    }
688
    }
704
689
705
#if 0
690
#if 0
706
    gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGBA8,xsiz,ysiz,texfmt,GL_UNSIGNED_BYTE,pic); //Needs C++ to link?
691
    gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGBA8,xsiz,ysiz,texfmt,GL_UNSIGNED_BYTE,pic); //Needs C++ to link?
707
#elif 1
692
#elif 1
708
    x2 = xsiz; y2 = ysiz;
693
    vec2_t siz2 = siz;
-
 
694
709
    for (j=1; (x2 > 1) || (y2 > 1); j++)
695
    for (int j=1; (siz2.x > 1) || (siz2.y > 1); j++)
710
    {
696
    {
711
        int32_t y;
-
 
712
        int32_t x3 = max(1, x2 >> 1), y3 = max(1, y2 >> 1);  // this came from the GL_ARB_texture_non_power_of_two spec
697
        vec2_t const siz3 = { max(1, siz2.x >> 1), max(1, siz2.y >> 1) };  // this came from the GL_ARB_texture_non_power_of_two spec
713
        //x3 = ((x2+1)>>1); y3 = ((y2+1)>>1);
698
        //x3 = ((x2+1)>>1); y3 = ((y2+1)>>1);
714
699
715
        for (y=0; y<y3; y++)
700
        for (int y=0; y<siz3.y; y++)
716
        {
701
        {
717
            int32_t x;
702
            coltype *wpptr = &pic[y*siz3.x];
718
            coltype *wpptr = &pic[y*x3], *rpptr = &pic[(y<<1)*x2];
703
            coltype const *rpptr = &pic[(y<<1)*siz2.x];
719
704
720
            for (x=0; x<x3; x++,wpptr++,rpptr+=2)
705
            for (int x=0; x<siz3.x; x++,wpptr++,rpptr+=2)
721
            {
706
            {
722
                int32_t r=0, g=0, b=0, a=0, k=0;
707
                int32_t r=0, g=0, b=0, a=0, k=0;
723
708
724
                if (rpptr[0].a)                  { r += rpptr[0].r; g += rpptr[0].g; b += rpptr[0].b; a += rpptr[0].a; k++; }
709
                if (rpptr[0].a)                  { r += rpptr[0].r; g += rpptr[0].g; b += rpptr[0].b; a += rpptr[0].a; k++; }
725
                if ((x+x+1 < x2) && (rpptr[1].a)) { r += rpptr[1].r; g += rpptr[1].g; b += rpptr[1].b; a += rpptr[1].a; k++; }
710
                if ((x+x+1 < siz2.x) && (rpptr[1].a)) { r += rpptr[1].r; g += rpptr[1].g; b += rpptr[1].b; a += rpptr[1].a; k++; }
726
                if (y+y+1 < y2)
711
                if (y+y+1 < siz2.y)
727
                {
712
                {
728
                    if ((rpptr[x2].a)) { r += rpptr[x2  ].r; g += rpptr[x2  ].g; b += rpptr[x2  ].b; a += rpptr[x2  ].a; k++; }
713
                    if ((rpptr[siz2.x].a)) { r += rpptr[siz2.x  ].r; g += rpptr[siz2.x  ].g; b += rpptr[siz2.x  ].b; a += rpptr[siz2.x  ].a; k++; }
729
                    if ((x+x+1 < x2) && (rpptr[x2+1].a)) { r += rpptr[x2+1].r; g += rpptr[x2+1].g; b += rpptr[x2+1].b; a += rpptr[x2+1].a; k++; }
714
                    if ((x+x+1 < siz2.x) && (rpptr[siz2.x+1].a)) { r += rpptr[siz2.x+1].r; g += rpptr[siz2.x+1].g; b += rpptr[siz2.x+1].b; a += rpptr[siz2.x+1].a; k++; }
730
                }
715
                }
731
                switch (k)
716
                switch (k)
732
                {
717
                {
733
                case 0:
718
                case 0:
734
                case 1:
719
                case 1:
Line 744... Line 729...
744
                }
729
                }
745
                //if (wpptr->a) wpptr->a = 255;
730
                //if (wpptr->a) wpptr->a = 255;
746
            }
731
            }
747
        }
732
        }
748
733
749
        if (tsizx >= 0)
734
        if (!nomiptransfix)
750
        {
735
        {
751
            vec2_t tsizzle;
736
            vec2_t const tsizzle = { (tsiz.x + (1 << j)-1) >> j, (tsiz.y + (1 << j)-1) >> j };
752
            vec2_t mnizzle = { x3, y3 };
737
            vec2_t const mnizzle = { siz3.x, siz3.y };
753
738
754
            tsizzle.x = (tsizx+(1<<j)-1)>>j;
-
 
755
            tsizzle.y = (tsizy+(1<<j)-1)>>j;
-
 
756
            fixtransparency(pic, tsizzle, mnizzle, dameth);
739
            fixtransparency(pic, tsizzle, mnizzle, dameth);
757
        }
740
        }
758
741
759
        if (j >= js)
742
        if (j >= miplevel)
760
        {
743
        {
761
            if (doalloc&1)
744
            if (doalloc & 1) // loading 1st time
762
                bglTexImage2D(GL_TEXTURE_2D,j-js,intexfmt,x3,y3,0,texfmt,GL_UNSIGNED_BYTE,pic); //loading 1st time
745
                bglTexImage2D(GL_TEXTURE_2D, j - miplevel, intexfmt, siz3.x, siz3.y, 0, texfmt, GL_UNSIGNED_BYTE, pic);  
763
            else
746
            else             // overwrite old texture
764
                bglTexSubImage2D(GL_TEXTURE_2D,j-js,0,0,x3,y3,texfmt,GL_UNSIGNED_BYTE,pic); //overwrite old texture
747
                bglTexSubImage2D(GL_TEXTURE_2D, j - miplevel, 0, 0, siz3.x, siz3.y, texfmt, GL_UNSIGNED_BYTE, pic);  
765
        }
748
        }
-
 
749
766
        x2 = x3; y2 = y3;
750
        siz2 = siz3;
767
    }
751
    }
768
#endif
752
#endif
769
}
753
}
770
754
771
755
Line 777... Line 761...
777
}
761
}
778
#else
762
#else
779
# define tile_is_sky(x) (0)
763
# define tile_is_sky(x) (0)
780
#endif
764
#endif
781
765
782
static void texture_setup(const int32_t dameth, int filter)
766
static void polymost_setuptexture(const int32_t dameth, int filter)
783
{
767
{
784
    const GLuint clamp_mode = glinfo.clamptoedge ? GL_CLAMP_TO_EDGE : GL_CLAMP;
768
    const GLuint clamp_mode = glinfo.clamptoedge ? GL_CLAMP_TO_EDGE : GL_CLAMP;
785
769
786
    if (filter == -1)
770
    if (filter == -1)
787
        filter = gltexfiltermode;
771
        filter = gltexfiltermode;
Line 912... Line 896...
912
896
913
    fixtransparency(pic,tsiz,siz,dameth);
897
    fixtransparency(pic,tsiz,siz,dameth);
914
898
915
    int32_t npoty = 0;
899
    int32_t npoty = 0;
916
900
917
    if (polymost_want_npotytex(dameth, siz.y) &&
901
    if (polymost_want_npotytex(dameth, siz.y) && tsiz.x == siz.x && tsiz.y == siz.y)  // XXX
918
            tsiz.x==siz.x && tsiz.y==siz.y)  // XXX
-
 
919
    {
902
    {
920
        const int32_t nextpoty = 1<<((picsiz[dapic]>>4)+1);
903
        const int32_t nextpoty = 1 << ((picsiz[dapic] >> 4) + 1);
921
        const int32_t ydif = nextpoty - siz.y;
904
        const int32_t ydif = nextpoty - siz.y;
922
        coltype *paddedpic;
905
        coltype *paddedpic;
923
906
924
        Bassert(ydif > 0 && ydif < siz.y);
907
        Bassert(ydif < siz.y);
925
908
926
        paddedpic = (coltype*) Xrealloc(pic, siz.x*nextpoty*sizeof(coltype));
909
        paddedpic = (coltype *)Xrealloc(pic, siz.x * nextpoty * sizeof(coltype));
927
910
928
        pic = paddedpic;
911
        pic = paddedpic;
929
        Bmemcpy(&pic[siz.x*siz.y], pic, siz.x*ydif*sizeof(coltype));
912
        Bmemcpy(&pic[siz.x * siz.y], pic, siz.x * ydif * sizeof(coltype));
930
        siz.y = tsiz.y = nextpoty;
913
        siz.y = tsiz.y = nextpoty;
931
914
932
        npoty = PTH_NPOTWALL;
915
        npoty = PTH_NPOTWALL;
933
    }
916
    }
934
917
935
    uploadtexture(doalloc, siz.x, siz.y, hasalpha ? GL_RGBA : GL_RGB, GL_RGBA, pic, tsiz.x, tsiz.y, dameth);
918
    uploadtexture(doalloc, siz, hasalpha ? GL_RGBA : GL_RGB, GL_RGBA, pic, tsiz, dameth);
936
919
937
    Bfree(pic);
920
    Bfree(pic);
938
921
939
    texture_setup(dameth, -1);
922
    polymost_setuptexture(dameth, -1);
940
923
941
    pth->picnum = dapic;
924
    pth->picnum = dapic;
942
    pth->palnum = dapal;
925
    pth->palnum = dapal;
943
    pth->shade = dashade;
926
    pth->shade = dashade;
944
    pth->effects = 0;
927
    pth->effects = 0;
Line 972... Line 955...
972
955
973
    int32_t startticks=0, willprint=0;
956
    int32_t startticks=0, willprint=0;
974
957
975
    if (facen > 0)
958
    if (facen > 0)
976
    {
959
    {
977
        if (!hicr->skybox) return -1;
960
        if (!hicr->skybox || facen > 6 || !hicr->skybox->face[facen-1])
978
        if (facen > 6) return -1;
961
            return -1;
979
        if (!hicr->skybox->face[facen-1]) return -1;
-
 
-
 
962
980
        fn = hicr->skybox->face[facen-1];
963
        fn = hicr->skybox->face[facen-1];
981
    }
964
    }
982
    else
965
    else
983
    {
966
    {
984
        if (!hicr->filename) return -1;
967
        if (!hicr->filename)
-
 
968
            return -1;
-
 
969
985
        fn = hicr->filename;
970
        fn = hicr->filename;
986
    }
971
    }
987
972
988
    if (EDUKE32_PREDICT_FALSE((filh = kopen4load(fn, 0)) < 0))
973
    if (EDUKE32_PREDICT_FALSE((filh = kopen4load(fn, 0)) < 0))
989
    {
974
    {
Line 1014... Line 999...
1014
        gotcache = 0;   // the compressed version will be saved to disk
999
        gotcache = 0;   // the compressed version will be saved to disk
1015
1000
1016
        if ((filh = kopen4load(fn, 0)) < 0) return -1;
1001
        if ((filh = kopen4load(fn, 0)) < 0) return -1;
1017
1002
1018
        picfil = (char *)Xmalloc(picfillen+1);
1003
        picfil = (char *)Xmalloc(picfillen+1);
-
 
1004
1019
        if (EDUKE32_PREDICT_FALSE(kread(filh, picfil, picfillen) != picfillen))
1005
        if (EDUKE32_PREDICT_FALSE(kread(filh, picfil, picfillen) != picfillen))
1020
            initprintf("warning: didn't fully read %s\n", fn);
1006
            initprintf("warning: didn't fully read %s\n", fn);
-
 
1007
1021
        // prevent
1008
        // prevent
1022
        // Conditional jump or move depends on uninitialised value(s)
1009
        // Conditional jump or move depends on uninitialised value(s)
1023
        //  at kpegrend (kplib.c:1655)
1010
        //  at kpegrend (kplib.c:1655)
1024
        picfil[picfillen] = 0;
1011
        picfil[picfillen] = 0;
1025
        kclose(filh);
1012
        kclose(filh);
Line 1028... Line 1015...
1028
        // xsiz/y = 2^x size of replacement
1015
        // xsiz/y = 2^x size of replacement
1029
1016
1030
        kpgetdim(picfil,picfillen,&tsiz.x,&tsiz.y);
1017
        kpgetdim(picfil,picfillen,&tsiz.x,&tsiz.y);
1031
        if (tsiz.x == 0 || tsiz.y == 0) { Bfree(picfil); return -1; }
1018
        if (tsiz.x == 0 || tsiz.y == 0) { Bfree(picfil); return -1; }
1032
1019
1033
        pth->siz.x = tsiz.x;
-
 
1034
        pth->siz.y = tsiz.y;
1020
        pth->siz = tsiz;
1035
1021
1036
        if (!glinfo.texnpot)
1022
        if (!glinfo.texnpot)
1037
        {
1023
        {
1038
            for (siz.x=1; siz.x<tsiz.x; siz.x+=siz.x);
1024
            for (siz.x=1; siz.x<tsiz.x; siz.x+=siz.x);
1039
            for (siz.y=1; siz.y<tsiz.y; siz.y+=siz.y);
1025
            for (siz.y=1; siz.y<tsiz.y; siz.y+=siz.y);
1040
        }
1026
        }
1041
        else
1027
        else
1042
        {
-
 
1043
            siz.x = tsiz.x;
-
 
1044
            siz.y = tsiz.y;
1028
            siz = tsiz;
1045
        }
1029
1046
        pic = (coltype *)Xcalloc(siz.x,siz.y*sizeof(coltype));
1030
        pic = (coltype *)Xcalloc(siz.x,siz.y*sizeof(coltype));
1047
1031
1048
        startticks = getticks();
1032
        startticks = getticks();
1049
1033
1050
        static coltype *lastpic = NULL;
1034
        static coltype *lastpic = NULL;
Line 1077... Line 1061...
1077
                if (lastpic)
1061
                if (lastpic)
1078
                    Bmemcpy(lastpic, pic, siz.x*siz.y*sizeof(coltype));
1062
                    Bmemcpy(lastpic, pic, siz.x*siz.y*sizeof(coltype));
1079
            }
1063
            }
1080
            else if (lastpic)
1064
            else if (lastpic)
1081
            {
1065
            {
1082
                Bfree(lastpic); lastpic=NULL;
1066
                DO_FREE_AND_NULL(lastpic);
1083
                lastfn = NULL;
1067
                lastfn = NULL;
1084
                lastsize = 0;
1068
                lastsize = 0;
1085
            }
1069
            }
1086
        }
1070
        }
1087
1071
1088
        r=(glinfo.bgra)?hictinting[dapalnum].r:hictinting[dapalnum].b;
1072
        r = (glinfo.bgra) ? hictinting[dapalnum].r : hictinting[dapalnum].b;
1089
        g=hictinting[dapalnum].g;
1073
        g = hictinting[dapalnum].g;
1090
        b=(glinfo.bgra)?hictinting[dapalnum].b:hictinting[dapalnum].r;
1074
        b = (glinfo.bgra) ? hictinting[dapalnum].b : hictinting[dapalnum].r;
-
 
1075
1091
        for (y=0,j=0; y<tsiz.y; y++,j+=siz.x)
1076
        for (y = 0, j = 0; y < tsiz.y; y++, j += siz.x)
1092
        {
1077
        {
1093
            coltype tcol;
1078
            coltype tcol;
1094
            char *cptr = britable[gammabrightness ? 0 : curbrightness];
1079
            char *cptr = britable[gammabrightness ? 0 : curbrightness];
1095
            coltype *rpptr = &pic[j];
1080
            coltype *rpptr = &pic[j];
Line 1104... Line 1089...
1104
                tcol.a = rpptr[x].a;
1089
                tcol.a = rpptr[x].a;
1105
                hasalpha &= rpptr[x].a;
1090
                hasalpha &= rpptr[x].a;
1106
1091
1107
                if (effect & HICTINT_GRAYSCALE)
1092
                if (effect & HICTINT_GRAYSCALE)
1108
                {
1093
                {
1109
                    tcol.g = tcol.r = tcol.b = (uint8_t) ((tcol.r * GRAYSCALE_COEFF_RED) + (tcol.g * GRAYSCALE_COEFF_GREEN) +
1094
                    tcol.g = tcol.r = tcol.b = (uint8_t) ((tcol.r * GRAYSCALE_COEFF_RED) +
-
 
1095
                                                          (tcol.g * GRAYSCALE_COEFF_GREEN) +
1110
                                                          (tcol.b * GRAYSCALE_COEFF_BLUE));
1096
                                                          (tcol.b * GRAYSCALE_COEFF_BLUE));
1111
                }
1097
                }
1112
1098
1113
                if (effect & HICTINT_INVERT)
1099
                if (effect & HICTINT_INVERT)
1114
                {
1100
                {
Line 1117... Line 1103...
1117
                    tcol.r = 255-tcol.r;
1103
                    tcol.r = 255 - tcol.r;
1118
                }
1104
                }
1119
1105
1120
                if (effect & HICTINT_COLORIZE)
1106
                if (effect & HICTINT_COLORIZE)
1121
                {
1107
                {
1122
                    tcol.b = min((int32_t)((tcol.b)*r)/64,255);
1108
                    tcol.b = min((int32_t)((tcol.b) * r) >> 6, 255);
1123
                    tcol.g = min((int32_t)((tcol.g)*g)/64,255);
1109
                    tcol.g = min((int32_t)((tcol.g) * g) >> 6, 255);
1124
                    tcol.r = min((int32_t)((tcol.r)*b)/64,255);
1110
                    tcol.r = min((int32_t)((tcol.r) * b) >> 6, 255);
1125
                }
1111
                }
1126
1112
1127
                rpptr[x] = tcol;
1113
                rpptr[x] = tcol;
1128
            }
1114
            }
1129
        }
1115
        }
Line 1131... Line 1117...
1131
        if ((!(dameth & DAMETH_CLAMPED)) || facen) //Duplicate texture pixels (wrapping tricks for non power of 2 texture sizes)
1117
        if ((!(dameth & DAMETH_CLAMPED)) || facen) //Duplicate texture pixels (wrapping tricks for non power of 2 texture sizes)
1132
        {
1118
        {
1133
            if (siz.x > tsiz.x) //Copy left to right
1119
            if (siz.x > tsiz.x)  // Copy left to right
1134
            {
1120
            {
1135
                int32_t *lptr = (int32_t *)pic;
1121
                int32_t *lptr = (int32_t *)pic;
-
 
1122
1136
                for (y=0; y<tsiz.y; y++,lptr+=siz.x)
1123
                for (y = 0; y < tsiz.y; y++, lptr += siz.x)
1137
                    Bmemcpy(&lptr[tsiz.x],lptr,(siz.x-tsiz.x)<<2);
1124
                    Bmemcpy(&lptr[tsiz.x], lptr, (siz.x - tsiz.x) << 2);
1138
            }
1125
            }
-
 
1126
1139
            if (siz.y > tsiz.y)  //Copy top to bottom
1127
            if (siz.y > tsiz.y)  // Copy top to bottom
1140
                Bmemcpy(&pic[siz.x*tsiz.y],pic,(siz.y-tsiz.y)*siz.x<<2);
1128
                Bmemcpy(&pic[siz.x * tsiz.y], pic, (siz.y - tsiz.y) * siz.x << 2);
1141
        }
1129
        }
1142
1130
1143
        int32_t texfmt;
1131
        int32_t texfmt;
Line 1163... Line 1151...
1163
        if ((doalloc&3)==1)
1151
        if ((doalloc&3)==1)
1164
            bglGenTextures(1, &pth->glpic); //# of textures (make OpenGL allocate structure)
1152
            bglGenTextures(1, &pth->glpic); //# of textures (make OpenGL allocate structure)
1165
        bglBindTexture(GL_TEXTURE_2D,pth->glpic);
1153
        bglBindTexture(GL_TEXTURE_2D,pth->glpic);
1166
1154
1167
        fixtransparency(pic,tsiz,siz,dameth);
1155
        fixtransparency(pic,tsiz,siz,dameth);
1168
        uploadtexture(doalloc,siz.x,siz.y,intexfmt,texfmt,pic,-1,tsiz.y,
1156
        uploadtexture(doalloc,siz,intexfmt,texfmt,pic,tsiz,
1169
                      dameth | DAMETH_HI | (hicr->flags & HICR_NOCOMPRESS ? DAMETH_NOCOMPRESS : 0));
1157
                      dameth | DAMETH_HI | DAMETH_NOFIX | (hicr->flags & HICR_NOCOMPRESS ? DAMETH_NOCOMPRESS : 0));
1170
    }
1158
    }
1171
1159
1172
    // precalculate scaling parameters for replacement
1160
    // precalculate scaling parameters for replacement
1173
    if (facen > 0)
1161
    if (facen > 0)
1174
    {
1162
    {
Line 1180... Line 1168...
1180
        pth->scale.x = (float)tsiz.x / (float)tilesiz[dapic].x;
1168
        pth->scale.x = (float)tsiz.x / (float)tilesiz[dapic].x;
1181
        pth->scale.y = (float)tsiz.y / (float)tilesiz[dapic].y;
1169
        pth->scale.y = (float)tsiz.y / (float)tilesiz[dapic].y;
1182
    }
1170
    }
1183
1171
1184
#ifdef EDUKE32_TOUCH_DEVICES
1172
#ifdef EDUKE32_TOUCH_DEVICES
1185
    texture_setup(dameth, 5);
1173
    polymost_setuptexture(dameth, 5);
1186
#else
1174
#else
1187
    texture_setup(dameth, -1);
1175
    polymost_setuptexture(dameth, -1);
1188
#endif
1176
#endif
1189
1177
1190
    DO_FREE_AND_NULL(pic);
1178
    DO_FREE_AND_NULL(pic);
1191
1179
1192
    if (tsiz.x>>r_downsize <= tilesiz[dapic].x || tsiz.y>>r_downsize <= tilesiz[dapic].y)
1180
    if (tsiz.x>>r_downsize <= tilesiz[dapic].x || tsiz.y>>r_downsize <= tilesiz[dapic].y)
Line 1287... Line 1275...
1287
    bglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
1275
    bglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
1288
1276
1289
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1277
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1290
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
1278
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
1291
}
1279
}
1292
#endif
1280
1293
1281
1294
//(dpx,dpy) specifies an n-sided polygon. The polygon must be a convex clockwise loop.
1282
//(dpx,dpy) specifies an n-sided polygon. The polygon must be a convex clockwise loop.
1295
//    n must be <= 8 (assume clipping can double number of vertices)
1283
//    n must be <= 8 (assume clipping can double number of vertices)
1296
//method: 0:solid, 1:masked(255 is transparent), 2:transluscent #1, 3:transluscent #2
1284
//method: 0:solid, 1:masked(255 is transparent), 2:transluscent #1, 3:transluscent #2
1297
//    +4 means it's a sprite, so wraparound isn't needed
1285
//    +4 means it's a sprite, so wraparound isn't needed
1298
1286
1299
// drawpoly's hack globals
1287
// drawpoly's hack globals
1300
static int32_t pow2xsplit = 0, skyclamphack = 0;
1288
static int32_t pow2xsplit = 0, skyclamphack = 0;
1301
static float alpha = 0.f;
1289
static float drawpoly_alpha = 0.f;
1302
1290
1303
static inline pthtyp *our_texcache_fetch(int32_t dameth)
1291
static inline pthtyp *our_texcache_fetch(int32_t dameth)
1304
{
1292
{
1305
    // r_usetileshades 1 is TX's method.
1293
    // r_usetileshades 1 is TX's method.
1306
    return texcache_fetch(globalpicnum, globalpal, getpalookup((r_usetileshades == 1 && !(globalflags & GLOBAL_NO_GL_TILESHADES)) ? globvis>>3 : 0, globalshade), dameth);
1294
    return texcache_fetch(globalpicnum, globalpal, getpalookup((r_usetileshades == 1 && !(globalflags & GLOBAL_NO_GL_TILESHADES)) ? globvis>>3 : 0, globalshade), dameth);
1307
}
1295
}
1308
1296
1309
static void drawpoly(vec2f_t *dpxy, int32_t n, int32_t method)
1297
static void drawpoly(vec2f_t const * const dpxy, int32_t const n, int32_t method)
1310
{
1298
{
1311
    const int32_t method_ = method;
-
 
1312
    int32_t i, j, k;
-
 
1313
    vec2_t tsiz;
-
 
1314
    float f, r, ox, oy, oz, ox2, oy2, oz2, dd[16], uu[16], vv[16], px[16], py[16];
-
 
1315
-
 
1316
#ifdef YAX_ENABLE
1299
#ifdef YAX_ENABLE
1317
    if (g_nodraw) return;
1300
    if (g_nodraw) return;
1318
#endif
1301
#endif
1319
1302
-
 
1303
#ifdef DEBUG
-
 
1304
    Bassert(n <= 8);
-
 
1305
#endif
-
 
1306
1320
    if (method == -1 || (uint32_t)globalpicnum >= MAXTILES) return;
1307
    if (method == -1 || (uint32_t)globalpicnum >= MAXTILES) return;
1321
1308
-
 
1309
    const int32_t method_ = method;
-
 
1310
1322
    if (n == 3)
1311
    if (n == 3)
1323
    {
1312
    {
1324
        if ((dpxy[0].x-dpxy[1].x) * (dpxy[2].y-dpxy[1].y) >=
1313
        if ((dpxy[0].x-dpxy[1].x) * (dpxy[2].y-dpxy[1].y) >=
1325
            (dpxy[2].x-dpxy[1].x) * (dpxy[0].y-dpxy[1].y)) return; //for triangle
1314
            (dpxy[2].x-dpxy[1].x) * (dpxy[0].y-dpxy[1].y)) return; //for triangle
1326
    }
1315
    }
1327
    else
1316
    else
1328
    {
1317
    {
1329
        f = 0; //f is area of polygon / 2
1318
        float f = 0; //f is area of polygon / 2
-
 
1319
1330
        for (i=n-2,j=n-1,k=0; k<n; i=j,j=k,k++)
1320
        for (int i=n-2, j=n-1,k=0; k<n; i=j,j=k,k++)
1331
            f += (dpxy[i].x-dpxy[k].x)*dpxy[j].y;
1321
            f += (dpxy[i].x-dpxy[k].x)*dpxy[j].y;
-
 
1322
1332
        if (f <= 0) return;
1323
        if (f <= 0) return;
1333
    }
1324
    }
1334
1325
-
 
1326
    if (palookup[globalpal] == NULL)
-
 
1327
        globalpal = 0;
-
 
1328
1335
    //Load texture (globalpicnum)
1329
    //Load texture (globalpicnum)
1336
    setgotpic(globalpicnum);
1330
    setgotpic(globalpicnum);
1337
    tsiz = tilesiz[globalpicnum];
1331
    vec2_t tsiz = tilesiz[globalpicnum];
1338
1332
1339
    if (palookup[globalpal] == NULL)
-
 
1340
        globalpal = 0;
-
 
1341
    if (!waloff[globalpicnum])
1333
    if (!waloff[globalpicnum])
1342
    {
1334
    {
1343
        loadtile(globalpicnum);
1335
        loadtile(globalpicnum);
-
 
1336
1344
        if (!waloff[globalpicnum])
1337
        if (!waloff[globalpicnum])
1345
        {
1338
        {
1346
            if (getrendermode() < REND_POLYMOST) return;
-
 
1347
            tsiz.x = tsiz.y = 1;
1339
            tsiz.x = tsiz.y = 1;
1348
            method = 1; //Hack to update Z-buffer for invalid mirror textures
1340
            method = 1; //Hack to update Z-buffer for invalid mirror textures
1349
        }
1341
        }
1350
    }
1342
    }
1351
1343
1352
    j = 0;
1344
    int j = 0;
-
 
1345
    float px[8], py[8], dd[8], uu[8], vv[8];
-
 
1346
    float const ozgs = ghalfx * gshang,
-
 
1347
                ozgc = ghalfx * gchang;
1353
1348
1354
    for (i=0; i<n; i++)
1349
    for (int i=0; i<n; ++i)
1355
    {
1350
    {
1356
        ox = dpxy[i].x-ghalfx;
-
 
1357
        oy = dpxy[i].y-ghoriz;
-
 
1358
        oz = ghalfx;
-
 
1359
-
 
1360
        //Up/down rotation
1351
        //Up/down rotation
1361
        ox2 = ox;
1352
        vec3f_t const orot = {   dpxy[i].x - ghalfx,
1362
        oy2 = oy*gchang - oz*gshang;
1353
                                (dpxy[i].y - ghoriz) * gchang - ozgs,
1363
        oz2 = oy*gshang + oz*gchang;
1354
                                (dpxy[i].y - ghoriz) * gshang + ozgc };
1364
1355
1365
        //Tilt rotation
1356
        // Tilt rotation
1366
        ox = ox2*gctang - oy2*gstang;
-
 
1367
        oy = ox2*gstang + oy2*gctang;
1357
        float const r = ghalfx / orot.z;
1368
        oz = oz2;
-
 
1369
1358
1370
        r = ghalfx / oz;
1359
        px[j] = ghalfx + (((orot.x * gctang) - (orot.y * gstang)) * r);
-
 
1360
        py[j] = ghoriz + (((orot.x * gstang) + (orot.y * gctang)) * r);
1371
1361
1372
        dd[j] = (dpxy[i].x*gdx + dpxy[i].y*gdy + gdo)*r;
1362
        dd[j] = (dpxy[i].x * xtex.d + dpxy[i].y * ytex.d + otex.d) * r;
1373
        uu[j] = (dpxy[i].x*gux + dpxy[i].y*guy + guo)*r;
1363
        uu[j] = (dpxy[i].x * xtex.u + dpxy[i].y * ytex.u + otex.u) * r;
1374
        vv[j] = (dpxy[i].x*gvx + dpxy[i].y*gvy + gvo)*r;
1364
        vv[j] = (dpxy[i].x * xtex.v + dpxy[i].y * ytex.v + otex.v) * r;
1375
1365
1376
        px[j] = ox*r + ghalfx;
1366
        if ((!j) || (px[j] != px[j-1]) || (py[j] != py[j-1]))
1377
        py[j] = oy*r + ghoriz;
1367
            j++;
1378
        if ((!j) || (px[j] != px[j-1]) || (py[j] != py[j-1])) j++;
-
 
1379
    }
1368
    }
1380
1369
1381
    while ((j >= 3) && (px[j-1] == px[0]) && (py[j-1] == py[0])) j--;
1370
    while ((j >= 3) && (px[j-1] == px[0]) && (py[j-1] == py[0])) j--;
1382
    if (j < 3) return;
-
 
1383
1371
1384
#ifdef USE_OPENGL
1372
    if (j < 3)
1385
    if (getrendermode() >= REND_POLYMOST)
-
 
1386
    {
-
 
1387
        float hackscx = 1.f, hackscy = 1.f;
-
 
1388
        int32_t texunits = GL_TEXTURE0_ARB;
-
 
1389
        int32_t xx, yy;
1373
        return;
1390
1374
1391
        int32_t jj = j;
1375
    int const npoints = j;
1392
1376
1393
        if (skyclamphack) method |= DAMETH_CLAMPED;
1377
    if (skyclamphack) method |= DAMETH_CLAMPED;
-
 
1378
1394
        pthtyp *pth = our_texcache_fetch(method&(~3));
1379
    pthtyp *pth = our_texcache_fetch(method&(~3));
1395
1380
1396
        if (!pth)
1381
    if (!pth)
1397
        {
1382
    {
1398
            if (editstatus)
1383
        if (editstatus)
Line 1401... Line 1386...
1401
                polymost_printext256(8,8, editorcolors[15],editorcolors[5], ptempbuf, 0);
1386
            polymost_printext256(8,8, editorcolors[15],editorcolors[5], ptempbuf, 0);
1402
            }
1387
        }
1403
            return;
1388
        return;
1404
        }
1389
    }
1405
1390
-
 
1391
    static int32_t fullbright_pass = 0;
-
 
1392
1406
        if (pth->flags & PTH_HASFULLBRIGHT && r_fullbrights && indrawroomsandmasks)
1393
    if (pth->flags & PTH_HASFULLBRIGHT && indrawroomsandmasks && r_fullbrights)
1407
        {
1394
    {
1408
            if (!fullbrightdrawingpass)
1395
        if (!fullbright_pass)
1409
                fullbrightdrawingpass = 1;
1396
            fullbright_pass = 1;
1410
            else if (fullbrightdrawingpass == 2)
1397
        else if (fullbright_pass == 2)
1411
                pth = pth->ofb;
1398
            pth = pth->ofb;
1412
        }
1399
    }
1413
1400
1414
        // If we aren't rendmode 3, we're in Polymer, which means this code is
1401
    // If we aren't rendmode 3, we're in Polymer, which means this code is
1415
        // used for rotatesprite only. Polymer handles all the material stuff,
1402
    // used for rotatesprite only. Polymer handles all the material stuff,
1416
        // just submit the geometry and don't mess with textures.
1403
    // just submit the geometry and don't mess with textures.
1417
        if (getrendermode() == REND_POLYMOST)
1404
    if (getrendermode() == REND_POLYMOST)
1418
        {
1405
    {
1419
            bglBindTexture(GL_TEXTURE_2D, pth ? pth->glpic : 0);
1406
        bglBindTexture(GL_TEXTURE_2D, pth ? pth->glpic : 0);
1420
1407
1421
            if (srepeat)
1408
        if (drawpoly_srepeat)
1422
                bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
1409
            bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
1423
            if (trepeat)
1410
        if (drawpoly_trepeat)
1424
                bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
1411
            bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
1425
        }
1412
    }
1426
1413
1427
        // texture scale by parkar request
1414
    // texture scale by parkar request
1428
        if (pth && pth->hicr && !drawingskybox && ((pth->hicr->scale.x != 1.0f) || (pth->hicr->scale.y != 1.0f)))
1415
    if (pth && pth->hicr && !drawingskybox && ((pth->hicr->scale.x != 1.0f) || (pth->hicr->scale.y != 1.0f)))
Line 1431... Line 1418...
1431
            bglLoadIdentity();
1418
        bglLoadIdentity();
1432
            bglScalef(pth->hicr->scale.x, pth->hicr->scale.y, 1.0f);
1419
        bglScalef(pth->hicr->scale.x, pth->hicr->scale.y, 1.0f);
1433
            bglMatrixMode(GL_MODELVIEW);
1420
        bglMatrixMode(GL_MODELVIEW);
1434
        }
1421
    }
1435
1422
-
 
1423
    int32_t texunits = GL_TEXTURE0_ARB;
-
 
1424
1436
#ifndef EDUKE32_GLES
1425
#ifndef EDUKE32_GLES
1437
        // detail texture
1426
    // detail texture
1438
        pthtyp *detailpth = NULL;
1427
    pthtyp *detailpth = NULL;
1439
        if (r_detailmapping && usehightile && !drawingskybox && hicfindsubst(globalpicnum, DETAILPAL))
-
 
1440
            detailpth = texcache_fetch(globalpicnum, DETAILPAL, 0, method&(~3));
-
 
1441
1428
-
 
1429
    if (r_detailmapping)
-
 
1430
    {
-
 
1431
        if (usehightile && !drawingskybox && hicfindsubst(globalpicnum, DETAILPAL) &&
-
 
1432
            (detailpth = texcache_fetch(globalpicnum, DETAILPAL, 0, method & (~3))) &&
1442
        if (detailpth && detailpth->hicr && (detailpth->hicr->palnum == DETAILPAL))
1433
            detailpth->hicr && detailpth->hicr->palnum == DETAILPAL)
1443
        {
1434
        {
1444
            polymost_setupdetailtexture(++texunits, detailpth ? detailpth->glpic : 0);
1435
            polymost_setupdetailtexture(++texunits, detailpth ? detailpth->glpic : 0);
1445
1436
1446
            f = detailpth ? detailpth->hicr->scale.x : 1.f;
-
 
1447
-
 
1448
            bglMatrixMode(GL_TEXTURE);
1437
            bglMatrixMode(GL_TEXTURE);
1449
            bglLoadIdentity();
1438
            bglLoadIdentity();
1450
1439
1451
            if (pth && pth->hicr && ((pth->hicr->scale.x != 1.0f) || (pth->hicr->scale.y != 1.0f)))
1440
            if (pth && pth->hicr && ((pth->hicr->scale.x != 1.0f) || (pth->hicr->scale.y != 1.0f)))
1452
                bglScalef(pth->hicr->scale.x, pth->hicr->scale.y, 1.0f);
1441
                bglScalef(pth->hicr->scale.x, pth->hicr->scale.y, 1.0f);
Line 1454... Line 1443...
1454
            if (detailpth && detailpth->hicr && ((detailpth->hicr->scale.x != 1.0f) || (detailpth->hicr->scale.y != 1.0f)))
1443
            if (detailpth && detailpth->hicr && ((detailpth->hicr->scale.x != 1.0f) || (detailpth->hicr->scale.y != 1.0f)))
1455
                bglScalef(detailpth->hicr->scale.x, detailpth->hicr->scale.y, 1.0f);
1444
                bglScalef(detailpth->hicr->scale.x, detailpth->hicr->scale.y, 1.0f);
1456
1445
1457
            bglMatrixMode(GL_MODELVIEW);
1446
            bglMatrixMode(GL_MODELVIEW);
1458
        }
1447
        }
-
 
1448
    }
1459
1449
1460
        // glow texture
1450
    // glow texture
1461
        pthtyp *glowpth = NULL;
1451
    pthtyp *glowpth = NULL;
1462
        if (r_glowmapping && usehightile && !drawingskybox && hicfindsubst(globalpicnum, GLOWPAL))
-
 
1463
            glowpth = texcache_fetch(globalpicnum, GLOWPAL, 0, method&(~3));
-
 
1464
1452
-
 
1453
    if (r_glowmapping)
-
 
1454
    {
-
 
1455
        if (usehightile && !drawingskybox && hicfindsubst(globalpicnum, GLOWPAL) &&
-
 
1456
            (glowpth = texcache_fetch(globalpicnum, GLOWPAL, 0, method&(~3))) &&
1465
        if (glowpth && glowpth->hicr && (glowpth->hicr->palnum == GLOWPAL))
1457
            glowpth->hicr && (glowpth->hicr->palnum == GLOWPAL))
1466
            polymost_setupglowtexture(++texunits, glowpth ? glowpth->glpic : 0);
1458
            polymost_setupglowtexture(++texunits, glowpth ? glowpth->glpic : 0);
-
 
1459
    }
1467
#endif
1460
#endif
1468
1461
-
 
1462
    vec2f_t hacksc = { 1.f, 1.f };
-
 
1463
1469
        if (pth && (pth->flags & PTH_HIGHTILE))
1464
    if (pth && (pth->flags & PTH_HIGHTILE))
1470
        {
1465
    {
1471
            hackscx = pth->scale.x;
-
 
1472
            hackscy = pth->scale.y;
1466
        hacksc = pth->scale;
1473
            tsiz.x = pth->siz.x;
-
 
1474
            tsiz.y = pth->siz.y;
1467
        tsiz = pth->siz;
1475
        }
1468
    }
1476
1469
1477
        xx = tsiz.x;
-
 
1478
        yy = tsiz.y;
1470
    vec2_t tsiz2 = tsiz;
1479
1471
1480
        if (!glinfo.texnpot)
1472
    if (!glinfo.texnpot)
1481
        {
1473
    {
1482
            for (xx=1; xx<tsiz.x; xx+=xx)
1474
        for (tsiz2.x = 1; tsiz2.x < tsiz.x; tsiz2.x += tsiz2.x)
1483
            {
-
 
1484
                /* do nothing */
1475
            ; /* do nothing */
1485
            }
-
 
1486
            for (yy=1; yy<tsiz.y; yy+=yy)
1476
        for (tsiz2.y = 1; tsiz2.y < tsiz.y; tsiz2.y += tsiz2.y)
1487
            {
-
 
1488
                /* do nothing */
1477
            ; /* do nothing */
1489
            }
-
 
1490
        }
1478
    }
1491
1479
1492
        ox2 = 1.0f/xx;
-
 
1493
        oy2 = 1.0f/yy;
-
 
1494
-
 
1495
        if ((!(method&3)) && (!fullbrightdrawingpass))
1480
    if ((!(method&3)) && (!fullbright_pass))
1496
        {
1481
    {
1497
            bglDisable(GL_BLEND);
1482
        bglDisable(GL_BLEND);
1498
            bglDisable(GL_ALPHA_TEST);
1483
        bglDisable(GL_ALPHA_TEST);
1499
        }
1484
    }
1500
        else
1485
    else
1501
        {
1486
    {
1502
            float al = 0.f; // PLAG : default alphacut was 0.32 before goodalpha
1487
        float const al = waloff[globalpicnum] ? alphahackarray[globalpicnum] * (1.f/255.f) ? alphahackarray[globalpicnum] * (1.f/255.f):
1503
            if (pth && pth->hicr && pth->hicr->alphacut >= 0.f) al = pth->hicr->alphacut;
1488
                         (pth && pth->hicr && pth->hicr->alphacut >= 0.f ? pth->hicr->alphacut : 0.f) : 0.f;
1504
            if (alphahackarray[globalpicnum])
-
 
-
 
1489
1505
                al=alphahackarray[globalpicnum];
1490
        bglAlphaFunc(GL_GREATER, al);
1506
            if (!waloff[globalpicnum]) al = 0.f;        // invalid textures ignore the alpha cutoff settings
-
 
1507
            bglEnable(GL_BLEND);
1491
        bglEnable(GL_BLEND);
1508
            bglEnable(GL_ALPHA_TEST);
1492
        bglEnable(GL_ALPHA_TEST);
1509
            bglAlphaFunc(GL_GREATER,al);
-
 
1510
        }
1493
    }
1511
1494
1512
        {
-
 
1513
            float pc[4];
1495
    float pc[4];
1514
1496
1515
#ifdef POLYMER
1497
#ifdef POLYMER
1516
            if (getrendermode() == REND_POLYMER && pr_artmapping && !(globalflags & GLOBAL_NO_GL_TILESHADES) && polymer_eligible_for_artmap(globalpicnum, pth))
1498
    if (getrendermode() == REND_POLYMER && pr_artmapping && !(globalflags & GLOBAL_NO_GL_TILESHADES) && polymer_eligible_for_artmap(globalpicnum, pth))
1517
                pc[0] = pc[1] = pc[2] = 1.0f;
1499
        pc[0] = pc[1] = pc[2] = 1.0f;
1518
            else
1500
    else
1519
#endif
1501
#endif
1520
                pc[0] = pc[1] = pc[2] = getshadefactor(globalshade);
1502
        pc[0] = pc[1] = pc[2] = getshadefactor(globalshade);
1521
1503
1522
            // spriteext full alpha control
1504
    // spriteext full alpha control
1523
            pc[3] = float_trans[method&3] * (1.f - alpha);
1505
    pc[3] = float_trans[method & 3] * (1.f - drawpoly_alpha);
1524
1506
1525
            // tinting happens only to hightile textures, and only if the texture we're
1507
    // tinting happens only to hightile textures, and only if the texture we're
1526
            // rendering isn't for the same palette as what we asked for
1508
    // rendering isn't for the same palette as what we asked for
-
 
1509
1527
            if (!(hictinting[globalpal].f & HICTINT_COLORIZE))
1510
    if (!(hictinting[globalpal].f & HICTINT_COLORIZE))
1528
            {
1511
    {
1529
                if (pth && (pth->flags & PTH_HIGHTILE))
1512
        if (pth && (pth->flags & PTH_HIGHTILE))
1530
                {
1513
        {
1531
                    if (pth->palnum != globalpal || (hictinting[globalpal].f & HICTINT_APPLYOVERALTPAL))
1514
            if (pth->palnum != globalpal || (hictinting[globalpal].f & HICTINT_APPLYOVERALTPAL))
Line 1538... Line 1521...
1538
                else if (hictinting[globalpal].f & HICTINT_USEONART)
1521
        else if (hictinting[globalpal].f & HICTINT_USEONART)
1539
                    hictinting_apply(pc, globalpal);
1522
            hictinting_apply(pc, globalpal);
1540
            }
1523
    }
1541
1524
1542
            bglColor4f(pc[0],pc[1],pc[2],pc[3]);
1525
    bglColor4f(pc[0], pc[1], pc[2], pc[3]);
1543
        }
-
 
1544
1526
1545
        //Hack for walls&masked walls which use textures that are not a power of 2
1527
    //Hack for walls&masked walls which use textures that are not a power of 2
1546
        if ((pow2xsplit) && (tsiz.x != xx))
1528
    if ((pow2xsplit) && (tsiz.x != tsiz2.x))
1547
        {
1529
    {
-
 
1530
        vec3f_t const opxy[3] = { { py[1] - py[2], py[2] - py[0], py[0] - py[1] },
-
 
1531
                                  { px[2] - px[1], px[0] - px[2], px[1] - px[0] },
1548
            int32_t nn, ix0, ix1;
1532
                                  { px[0] - .5f, py[0] - .5f, 0 } };
-
 
1533
-
 
1534
        float const r = 1.f / (opxy[0].x*px[0] + opxy[0].y*px[1] + opxy[0].z*px[2]);
1549
1535
1550
            float ngdx = 0.f, ngdy = 0.f, ngdo = 0.f, ngux = 0.f, nguy = 0.f, nguo = 0.f, uoffs;
1536
        float ngdx = (opxy[0].x*dd[0] + opxy[0].y*dd[1] + opxy[0].z*dd[2])*r,
-
 
1537
              ngux = (opxy[0].x*uu[0] + opxy[0].y*uu[1] + opxy[0].z*uu[2])*r,
1551
            float ngvx = 0.f, ngvy = 0.f, ngvo = 0.f, dp, up, vp, du0 = 0.f, du1 = 0.f, dui, duj;
1538
              ngvx = (opxy[0].x*vv[0] + opxy[0].y*vv[1] + opxy[0].z*vv[2])*r;
-
 
1539
-
 
1540
        float ngdy = (opxy[1].x*dd[0] + opxy[1].y*dd[1] + opxy[1].z*dd[2])*r,
-
 
1541
              nguy = (opxy[1].x*uu[0] + opxy[1].y*uu[1] + opxy[1].z*uu[2])*r,
-
 
1542
              ngvy = (opxy[1].x*vv[0] + opxy[1].y*vv[1] + opxy[1].z*vv[2])*r;
-
 
1543
-
 
1544
        ngux *= hacksc.x; nguy *= hacksc.x; nguo *= hacksc.x;
-
 
1545
        ngvx *= hacksc.y; ngvy *= hacksc.y; ngvo *= hacksc.y;
-
 
1546
-
 
1547
        float const uoffs = ((float)(tsiz2.x - tsiz.x) * 0.5f);
1552
1548
1553
            ox = py[1]-py[2]; oy = py[2]-py[0]; oz = py[0]-py[1];
-
 
1554
            r = 1.f / (ox*px[0] + oy*px[1] + oz*px[2]);
-
 
1555
            ngdx = (ox*dd[0] + oy*dd[1] + oz*dd[2])*r;
-
 
1556
            ngux = (ox*uu[0] + oy*uu[1] + oz*uu[2])*r;
-
 
1557
            ngvx = (ox*vv[0] + oy*vv[1] + oz*vv[2])*r;
-
 
1558
            ox = px[2]-px[1]; oy = px[0]-px[2]; oz = px[1]-px[0];
-
 
1559
            ngdy = (ox*dd[0] + oy*dd[1] + oz*dd[2])*r;
-
 
1560
            nguy = (ox*uu[0] + oy*uu[1] + oz*uu[2])*r;
-
 
1561
            ngvy = (ox*vv[0] + oy*vv[1] + oz*vv[2])*r;
-
 
1562
            ox = px[0]-0.5f; oy = py[0]-0.5f; //.5 centers texture nicely
-
 
1563
            ngdo = dd[0] - ox*ngdx - oy*ngdy;
-
 
1564
            nguo = uu[0] - ox*ngux - oy*nguy;
-
 
1565
            ngvo = vv[0] - ox*ngvx - oy*ngvy;
-
 
1566
-
 
1567
            ngux *= hackscx; nguy *= hackscx; nguo *= hackscx;
-
 
1568
            ngvx *= hackscy; ngvy *= hackscy; ngvo *= hackscy;
-
 
1569
            uoffs = ((float)(xx-tsiz.x)*0.5f);
-
 
1570
            ngux -= ngdx*uoffs;
1549
        ngux -= ngdx * uoffs;
1571
            nguy -= ngdy*uoffs;
1550
        nguy -= ngdy * uoffs;
1572
            nguo -= ngdo*uoffs;
1551
        nguo -= ngdo * uoffs;
1573
1552
-
 
1553
        float du0, du1;
-
 
1554
1574
            //Find min&max u coordinates (du0...du1)
1555
        //Find min&max u coordinates (du0...du1)
1575
            for (i=0; i<jj; i++)
1556
        for (int i=0; i<npoints; ++i)
1576
            {
1557
        {
1577
                ox = px[i]; oy = py[i];
1558
            vec2f_t const o = { px[i], py[i] };
1578
                f = (ox*ngux + oy*nguy + nguo) / (ox*ngdx + oy*ngdy + ngdo);
1559
            float const f = (o.x*ngux + o.y*nguy + nguo) / (o.x*ngdx + o.y*ngdy + ngdo);
1579
                if (!i) { du0 = du1 = f; continue; }
1560
            if (!i) { du0 = du1 = f; continue; }
1580
                if (f < du0) du0 = f;
1561
            if (f < du0) du0 = f;
1581
                else if (f > du1) du1 = f;
1562
            else if (f > du1) du1 = f;
1582
            }
1563
        }
1583
1564
1584
            f = 1.0f/tsiz.x;
1565
        float const rf = 1.0f / tsiz.x;
-
 
1566
1585
            ix0 = Blrintf(floorf(du0*f));
1567
        int32_t ix0 = (int)floorf(du0 * rf);
1586
            ix1 = Blrintf(floorf(du1*f));
1568
        int32_t const ix1 = (int)floorf(du1 * rf);
-
 
1569
1587
            for (; ix0<=ix1; ix0++)
1570
        for (; ix0<=ix1; ++ix0)
1588
            {
1571
        {
1589
                du0 = (float)(ix0*tsiz.x);   // + uoffs;
1572
            du0 = (float)(ix0 * tsiz.x);        // + uoffs;
1590
                du1 = (float)((ix0+1)*tsiz.x); // + uoffs;
1573
            du1 = (float)((ix0 + 1) * tsiz.x);  // + uoffs;
1591
1574
1592
                i = 0; nn = 0;
-
 
1593
                duj = (px[i]*ngux + py[i]*nguy + nguo) / (px[i]*ngdx + py[i]*ngdy + ngdo);
1575
            float duj = (px[0]*ngux + py[0]*nguy + nguo) / (px[0]*ngdx + py[0]*ngdy + ngdo);
-
 
1576
            int i = 0, nn = 0;
-
 
1577
1594
                do
1578
            do
1595
                {
1579
            {
-
 
1580
                j = i + 1;
-
 
1581
1596
                    j = i+1; if (j == jj) j = 0;
1582
                if (j == npoints)
-
 
1583
                    j = 0;
-
 
1584
-
 
1585
                float const dui = duj;
1597
1586
1598
                    dui = duj;
-
 
1599
                    duj = (px[j]*ngux + py[j]*nguy + nguo) / (px[j]*ngdx + py[j]*ngdy + ngdo);
1587
                duj = (px[j]*ngux + py[j]*nguy + nguo) / (px[j]*ngdx + py[j]*ngdy + ngdo);
1600
1588
1601
                    if ((du0 <= dui) && (dui <= du1))
1589
                if ((du0 <= dui) && (dui <= du1))
1602
                    {
1590
                {
1603
                        uu[nn] = px[i];
1591
                    uu[nn] = px[i];
Line 1611... Line 1599...
1611
1599
1612
                    ///Solve for f
1600
                ///Solve for f
1613
                    //((px[j]-px[i])*f + px[i])*(ngux-ngdx*du1) +
1601
                //((px[j]-px[i])*f + px[i])*(ngux-ngdx*du1) +
1614
                    //((py[j]-py[i])*f + py[i])*(nguy-ngdy*du1) + (nguo-ngdo*du1) = 0
1602
                //((py[j]-py[i])*f + py[i])*(nguy-ngdy*du1) + (nguo-ngdo*du1) = 0
1615
1603
-
 
1604
#define DRAWPOLY_MATH_BULLSHIT(XXX)                                                                                \
-
 
1605
do                                                                                                                 \
-
 
1606
{                                                                                                                  \
1616
#define DRAWPOLY_MATH_BULLSHIT(X) do { f = -(px[i] *(ngux-ngdx*X) + py[i] *(nguy-ngdy*X) + (nguo-ngdo*X)) / ((px[j]-px[i])*(ngux-ngdx*X) + (py[j]-py[i])*(nguy-ngdy*X)); \
1607
    float const f = -(px[i] * (ngux - ngdx * XXX) + py[i] * (nguy - ngdy * XXX) + (nguo - ngdo * XXX)) /           \
-
 
1608
        ((px[j] - px[i]) * (ngux - ngdx * XXX) + (py[j] - py[i]) * (nguy - ngdy * XXX));                           \
-
 
1609
    uu[nn] = (px[j] - px[i]) * f + px[i];                                                                          \
-
 
1610
    vv[nn] = (py[j] - py[i]) * f + py[i];                                                                          \
1617
                                        uu[nn] = (px[j]-px[i])*f + px[i]; vv[nn] = (py[j]-py[i])*f + py[i]; nn++; } while (0)
1611
    nn++;                                                                                                          \
-
 
1612
} while (0)
1618
1613
1619
                    if (duj <= dui)
1614
                if (duj <= dui)
1620
                    {
1615
                {
1621
                        if ((du1 < duj) != (du1 < dui))
-
 
1622
                            DRAWPOLY_MATH_BULLSHIT(du1);
1616
                    if ((du1 < duj) != (du1 < dui)) DRAWPOLY_MATH_BULLSHIT(du1);
1623
                        if ((du0 < duj) != (du0 < dui))
-
 
1624
                            DRAWPOLY_MATH_BULLSHIT(du0);
1617
                    if ((du0 < duj) != (du0 < dui)) DRAWPOLY_MATH_BULLSHIT(du0);
1625
                    }
1618
                }
1626
                    else
1619
                else
1627
                    {
1620
                {
1628
                        if ((du0 < duj) != (du0 < dui))
-
 
1629
                            DRAWPOLY_MATH_BULLSHIT(du0);
1621
                    if ((du0 < duj) != (du0 < dui)) DRAWPOLY_MATH_BULLSHIT(du0);
1630
                        if ((du1 < duj) != (du1 < dui))
-
 
1631
                            DRAWPOLY_MATH_BULLSHIT(du1);
1622
                    if ((du1 < duj) != (du1 < dui)) DRAWPOLY_MATH_BULLSHIT(du1);
1632
                    }
1623
                }
1633
                    i = j;
-
 
1634
1624
1635
#undef DRAWPOLY_MATH_BULLSHIT
1625
#undef DRAWPOLY_MATH_BULLSHIT
1636
1626
-
 
1627
                i = j;
1637
                }
1628
            }
1638
                while (i);
1629
            while (i);
1639
1630
1640
                if (nn < 3) continue;
1631
            if (nn < 3) continue;
1641
1632
-
 
1633
            vec2f_t const invtsiz2 ={ 1.f / tsiz2.x, 1.f / tsiz2.y };
-
 
1634
1642
                bglBegin(GL_TRIANGLE_FAN);
1635
            bglBegin(GL_TRIANGLE_FAN);
-
 
1636
1643
                for (i=0; i<nn; i++)
1637
            for (i=0; i<nn; i++)
1644
                {
1638
            {
1645
                    ox = uu[i]; oy = vv[i];
1639
                vec2f_t const o = { uu[i], vv[i] };
-
 
1640
1646
                    dp = ox*ngdx + oy*ngdy + ngdo;
1641
                float const dp = o.x*ngdx + o.y*ngdy + ngdo,
1647
                    up = ox*ngux + oy*nguy + nguo;
1642
                            up = o.x*ngux + o.y*nguy + nguo,
1648
                    vp = ox*ngvx + oy*ngvy + ngvo;
1643
                            vp = o.x*ngvx + o.y*ngvy + ngvo;
-
 
1644
1649
                    r = 1.f/dp;
1645
                float const r = 1.f/dp;
-
 
1646
1650
                    if (texunits > GL_TEXTURE0_ARB)
1647
                if (texunits > GL_TEXTURE0_ARB)
1651
                    {
1648
                {
1652
                        j = GL_TEXTURE0_ARB;
1649
                    j = GL_TEXTURE0_ARB;
1653
                        while (j <= texunits)
1650
                    while (j <= texunits)
1654
                            bglMultiTexCoord2fARB(j++, (up*r-du0+uoffs)*ox2,vp*r*oy2);
1651
                        bglMultiTexCoord2fARB(j++, (up * r - du0 + uoffs) * invtsiz2.x, vp * r * invtsiz2.y);
1655
                    }
1652
                }
1656
                    else
1653
                else
1657
                        bglTexCoord2f((up*r-du0+uoffs)*ox2,vp*r*oy2);
1654
                    bglTexCoord2f((up * r - du0 + uoffs) * invtsiz2.x, vp * r * invtsiz2.y);
-
 
1655
1658
                    bglVertex3f((ox-ghalfx)*r*grhalfxdown10x,(ghoriz-oy)*r*grhalfxdown10,r*(1.f/1024.f));
1656
                bglVertex3f((o.x - ghalfx) * r * grhalfxdown10x,
-
 
1657
                            (ghoriz - o.y) * r * grhalfxdown10,
-
 
1658
                            r * (1.f / 1024.f));
1659
                }
1659
            }
1660
                bglEnd();
1660
            bglEnd();
1661
            }
1661
        }
1662
        }
1662
    }
1663
        else
1663
    else
1664
        {
1664
    {
1665
            ox2 *= hackscx; oy2 *= hackscy;
1665
        vec2f_t const scale ={ 1.f / tsiz2.x * hacksc.x, 1.f / tsiz2.y * hacksc.y };
-
 
1666
1666
            bglBegin(GL_TRIANGLE_FAN);
1667
        bglBegin(GL_TRIANGLE_FAN);
-
 
1668
1667
            for (i=0; i<jj; i++)
1669
        for (int i = 0; i < npoints; i++)
1668
            {
1670
        {
1669
                r = 1.f/dd[i];
1671
            float const r = 1.f / dd[i];
-
 
1672
1670
                if (texunits > GL_TEXTURE0_ARB)
1673
            if (texunits > GL_TEXTURE0_ARB)
1671
                {
1674
            {
1672
                    j = GL_TEXTURE0_ARB;
1675
                j = GL_TEXTURE0_ARB;
1673
                    while (j <= texunits)
-
 
1674
                        bglMultiTexCoord2fARB(j++, uu[i]*r*ox2,vv[i]*r*oy2);
1676
                while (j <= texunits) bglMultiTexCoord2fARB(j++, uu[i] * r * scale.x, vv[i] * r * scale.y);
1675
                }
1677
            }
1676
                else
1678
            else
1677
                    bglTexCoord2f(uu[i]*r*ox2,vv[i]*r*oy2);
1679
                bglTexCoord2f(uu[i] * r * scale.x, vv[i] * r * scale.y);
-
 
1680
1678
                bglVertex3f((px[i]-ghalfx)*r*grhalfxdown10x,(ghoriz-py[i])*r*grhalfxdown10,r*(1.f/1024.f));
1681
            bglVertex3f((px[i] - ghalfx) * r * grhalfxdown10x,
-
 
1682
                        (ghoriz - py[i]) * r * grhalfxdown10,
-
 
1683
                        r * (1.f / 1024.f));
1679
            }
1684
        }
1680
            bglEnd();
1685
        bglEnd();
1681
        }
1686
    }
1682
1687
1683
        while (texunits >= GL_TEXTURE0_ARB)
1688
    do
1684
        {
1689
    {
1685
            bglActiveTextureARB(texunits);
1690
        bglActiveTextureARB(texunits);
1686
            bglMatrixMode(GL_TEXTURE);
1691
        bglMatrixMode(GL_TEXTURE);
1687
            bglLoadIdentity();
1692
        bglLoadIdentity();
1688
            bglMatrixMode(GL_MODELVIEW);
1693
        bglMatrixMode(GL_MODELVIEW);
-
 
1694
1689
            if (texunits > GL_TEXTURE0_ARB)
1695
        if (texunits > GL_TEXTURE0_ARB)
1690
            {
1696
        {
1691
                bglTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0f);
1697
            bglTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0f);
1692
                bglDisable(GL_TEXTURE_2D);
1698
            bglDisable(GL_TEXTURE_2D);
1693
            }
1699
        }
1694
            texunits--;
-
 
1695
        }
1700
    }
-
 
1701
    while (--texunits >= GL_TEXTURE0_ARB);
1696
1702
1697
        if (getrendermode() == REND_POLYMOST)
1703
    if (getrendermode() == REND_POLYMOST)
1698
        {
1704
    {
-
 
1705
        int const clamp_mode = glinfo.clamptoedge ? GL_CLAMP_TO_EDGE : GL_CLAMP;
-
 
1706
1699
            if (srepeat)
1707
        if (drawpoly_srepeat)
1700
                bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,glinfo.clamptoedge?GL_CLAMP_TO_EDGE:GL_CLAMP);
1708
            bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp_mode);
-
 
1709
1701
            if (trepeat)
1710
        if (drawpoly_trepeat)
1702
                bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,glinfo.clamptoedge?GL_CLAMP_TO_EDGE:GL_CLAMP);
1711
            bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp_mode);
1703
        }
1712
    }
1704
1713
1705
        if (fullbrightdrawingpass == 1) // tile has fullbright colors ?
1714
    if (fullbright_pass == 1)
1706
        {
1715
    {
1707
            int32_t shadeforfullbrightpass = globalshade; // save the current shade
1716
        int32_t const shade = globalshade;
-
 
1717
1708
            fullbrightdrawingpass = 2;
1718
        globalshade = -128;
1709
            globalshade = -128; // fullbright
1719
        fullbright_pass = 2;
-
 
1720
1710
            bglDisable(GL_FOG);
1721
        bglDisable(GL_FOG);
-
 
1722
1711
            drawpoly(dpxy, n, method_); // draw them afterwards, then. :)
1723
        drawpoly(dpxy, n, method_);
-
 
1724
-
 
1725
        if (!nofog)
1712
            if (!nofog) bglEnable(GL_FOG);
1726
            bglEnable(GL_FOG);
-
 
1727
1713
            globalshade = shadeforfullbrightpass;
1728
        globalshade = shade;
1714
            fullbrightdrawingpass = 0;
1729
        fullbright_pass = 0;
1715
        }
-
 
1716
        return;
-
 
1717
    }
1730
    }
1718
#endif
-
 
1719
}
1731
}
1720
1732
1721
1733
1722
static inline void vsp_finalize_init(vsptyp *vsp, int32_t vcnt)
1734
static inline void vsp_finalize_init(vsptyp * const vsp, int32_t const vcnt)
1723
{
1735
{
1724
    int32_t i;
-
 
1725
-
 
1726
    for (i=0; i<vcnt; i++)
1736
    for (int i=0; i<vcnt; i++)
1727
    {
1737
    {
1728
        vsp[i].cy[1] = vsp[i+1].cy[0]; vsp[i].ctag = i;
1738
        vsp[i].cy[1] = vsp[i+1].cy[0]; vsp[i].ctag = i;
1729
        vsp[i].fy[1] = vsp[i+1].fy[0]; vsp[i].ftag = i;
1739
        vsp[i].fy[1] = vsp[i+1].fy[0]; vsp[i].ftag = i;
1730
        vsp[i].n = i+1; vsp[i].p = i-1;
1740
        vsp[i].n = i+1; vsp[i].p = i-1;
1731
//        vsp[i].tag = -1;
1741
//        vsp[i].tag = -1;
1732
    }
1742
    }
1733
    vsp[vcnt-1].n = 0; vsp[0].p = vcnt-1;
1743
    vsp[vcnt-1].n = 0; vsp[0].p = vcnt-1;
1734
1744
1735
    //VSPMAX-1 is dummy empty node
1745
    //VSPMAX-1 is dummy empty node
1736
    for (i=vcnt; i<VSPMAX; i++) { vsp[i].n = i+1; vsp[i].p = i-1; }
1746
    for (int i=vcnt; i<VSPMAX; i++) { vsp[i].n = i+1; vsp[i].p = i-1; }
1737
    vsp[VSPMAX-1].n = vcnt; vsp[vcnt].p = VSPMAX-1;
1747
    vsp[VSPMAX-1].n = vcnt; vsp[vcnt].p = VSPMAX-1;
1738
}
1748
}
1739
1749
1740
static inline void vsdel(vsptyp *vsp, int32_t i)
1750
static inline void vsdel(vsptyp * const vsp, int32_t const i)
1741
{
1751
{
1742
    //Delete i
1752
    //Delete i
1743
    vsp[vsp[i].n].p = vsp[i].p;
1753
    vsp[vsp[i].n].p = vsp[i].p;
1744
    vsp[vsp[i].p].n = vsp[i].n;
1754
    vsp[vsp[i].p].n = vsp[i].n;
1745
1755
Line 1748... Line 1758...
1748
    vsp[i].p = VSPMAX-1;
1758
    vsp[i].p = VSPMAX-1;
1749
    vsp[vsp[VSPMAX-1].n].p = i;
1759
    vsp[vsp[VSPMAX-1].n].p = i;
1750
    vsp[VSPMAX-1].n = i;
1760
    vsp[VSPMAX-1].n = i;
1751
}
1761
}
1752
1762
1753
static inline int32_t vsinsaft(vsptyp *vsp, int32_t i)
1763
static inline int32_t vsinsaft(vsptyp * const vsp, int32_t const i)
1754
{
1764
{
1755
    //i = next element from empty list
1765
    //i = next element from empty list
1756
    int32_t r = vsp[VSPMAX-1].n;
1766
    int32_t const r = vsp[VSPMAX-1].n;
1757
    vsp[vsp[r].n].p = VSPMAX-1;
1767
    vsp[vsp[r].n].p = VSPMAX-1;
1758
    vsp[VSPMAX-1].n = vsp[r].n;
1768
    vsp[VSPMAX-1].n = vsp[r].n;
1759
1769
1760
    vsp[r] = vsp[i]; //copy i to r
1770
    vsp[r] = vsp[i]; //copy i to r
1761
1771
1762
    //insert r after i
1772
    //insert r after i
1763
    vsp[r].p = i; vsp[r].n = vsp[i].n;
1773
    vsp[r].p = i; vsp[r].n = vsp[i].n;
1764
    vsp[vsp[i].n].p = r; vsp[i].n = r;
1774
    vsp[vsp[i].n].p = r; vsp[i].n = r;
1765
1775
1766
    return(r);
1776
    return r;
1767
}
1777
}
1768
1778
1769
static int32_t domostpolymethod = 0;
1779
static int32_t domostpolymethod = 0;
1770
1780
1771
void domost(float x0, float y0, float x1, float y1)
1781
void domost(float x0, float y0, float x1, float y1)
1772
{
1782
{
1773
    vec2f_t dpxy[4], n0, n1;
1783
    int32_t const dir = (x0 < x1);
1774
    float slop, dx;
-
 
1775
    float spx[4], /*spy[4],*/ cy[2], cv[2];
-
 
1776
    int32_t i, k, z, vcnt = 0, scnt, newi, dir = 0, spt[4];
-
 
1777
-
 
1778
    alpha = 0.f;
-
 
1779
1784
1780
    if (x0 < x1)
1785
    if (dir) //clip dmost (floor)
1781
    {
1786
    {
1782
        dir = 1; //clip dmost (floor)
-
 
1783
        y0 -= .01f;
1787
        y0 -= .01f;
1784
        y1 -= .01f;
1788
        y1 -= .01f;
1785
    }
1789
    }
1786
    else
1790
    else //clip umost (ceiling)
1787
    {
1791
    {
1788
        if (x0 == x1) return;
1792
        if (x0 == x1) return;
1789
        swapfloat(&x0, &x1);
1793
        swapfloat(&x0, &x1);
1790
        swapfloat(&y0, &y1);
1794
        swapfloat(&y0, &y1);
1791
        //dir = 0; //clip umost (ceiling)
-
 
1792
        //y0 += .01; y1 += .01; //necessary?
1795
        //y0 += .01; y1 += .01; //necessary?
1793
    }
1796
    }
1794
1797
1795
    slop = (y1-y0)/(x1-x0);
1798
    float const slop = (y1 - y0) / (x1 - x0);
-
 
1799
-
 
1800
    drawpoly_alpha = 0.f;
-
 
1801
-
 
1802
    vec2f_t n0, n1;
-
 
1803
    float spx[4] /*spy[4],*/;
-
 
1804
    int32_t  spt[4];
-
 
1805
1796
    for (i=vsp[0].n; i; i=newi)
1806
    for (int newi, i=vsp[0].n; i; i=newi)
1797
    {
1807
    {
1798
        newi = vsp[i].n; n0.x = vsp[i].x; n1.x = vsp[newi].x;
1808
        newi = vsp[i].n; n0.x = vsp[i].x; n1.x = vsp[newi].x;
-
 
1809
1799
        if ((x0 >= n1.x) || (n0.x >= x1) || (vsp[i].ctag <= 0)) continue;
1810
        if ((x0 >= n1.x) || (n0.x >= x1) || (vsp[i].ctag <= 0)) continue;
1800
        dx = n1.x-n0.x;
-
 
1801
        cy[0] = vsp[i].cy[0]; cv[0] = vsp[i].cy[1]-cy[0];
-
 
1802
        cy[1] = vsp[i].fy[0]; cv[1] = vsp[i].fy[1]-cy[1];
-
 
1803
1811
-
 
1812
        float const dx = n1.x-n0.x;
-
 
1813
        float const cy[2] = { vsp[i].cy[0], vsp[i].fy[0] },
-
 
1814
                    cv[2] = { vsp[i].cy[1]-cy[0], vsp[i].fy[1]-cy[1] };
-
 
1815
1804
        scnt = 0;
1816
        int scnt = 0;
1805
1817
1806
        //Test if left edge requires split (x0,y0) (nx0,cy(0)),<dx,cv(0)>
1818
        //Test if left edge requires split (x0,y0) (nx0,cy(0)),<dx,cv(0)>
1807
        if ((x0 > n0.x) && (x0 < n1.x))
1819
        if ((x0 > n0.x) && (x0 < n1.x))
1808
        {
1820
        {
1809
            const float t = (x0-n0.x)*cv[dir] - (y0-cy[dir])*dx;
1821
            float const t = (x0-n0.x)*cv[dir] - (y0-cy[dir])*dx;
1810
            if (((!dir) && (t < 0.f)) || ((dir) && (t > 0.f)))
1822
            if (((!dir) && (t < 0.f)) || ((dir) && (t > 0.f)))
1811
                { spx[scnt] = x0; /*spy[scnt] = y0;*/ spt[scnt] = -1; scnt++; }
1823
                { spx[scnt] = x0; /*spy[scnt] = y0;*/ spt[scnt] = -1; scnt++; }
1812
        }
1824
        }
1813
1825
1814
        //Test for intersection on umost (0) and dmost (1)
1826
        //Test for intersection on umost (0) and dmost (1)
1815
1827
1816
        {
-
 
1817
            const float d[2] ={
-
 
1818
                ((y0-y1) * dx) - ((x0-x1) * cv[0]),
1828
        float const d[2] = { ((y0 - y1) * dx) - ((x0 - x1) * cv[0]),
1819
                ((y0-y1) * dx) - ((x0-x1) * cv[1])
1829
                             ((y0 - y1) * dx) - ((x0 - x1) * cv[1]) };
1820
            };
-
 
1821
1830
1822
            const float n[2] ={
-
 
1823
                ((y0-cy[0]) * dx) - ((x0-n0.x) * cv[0]),
1831
        float const n[2] = { ((y0 - cy[0]) * dx) - ((x0 - n0.x) * cv[0]),
1824
                ((y0-cy[1]) * dx) - ((x0-n0.x) * cv[1])
1832
                             ((y0 - cy[1]) * dx) - ((x0 - n0.x) * cv[1]) };
1825
            };
-
 
1826
1833
1827
            const float fnx[2] ={
-
 
1828
                x0 + ((n[0]/d[0]) * (x1-x0)),
1834
        float const fnx[2] = { x0 + ((n[0] / d[0]) * (x1 - x0)),
1829
                x0 + ((n[1]/d[1]) * (x1-x0))
1835
                               x0 + ((n[1] / d[1]) * (x1 - x0)) };
1830
            };
-
 
1831
1836
1832
            if ((Bfabsf(d[0]) > Bfabsf(n[0])) && (d[0] * n[0] >= 0.f) && (fnx[0] > n0.x) && (fnx[0] < n1.x))
1837
        if ((Bfabsf(d[0]) > Bfabsf(n[0])) && (d[0] * n[0] >= 0.f) && (fnx[0] > n0.x) && (fnx[0] < n1.x))
1833
                spx[scnt] = fnx[0], spt[scnt++] = 0;
1838
            spx[scnt] = fnx[0], spt[scnt++] = 0;
1834
1839
1835
            if ((Bfabsf(d[1]) > Bfabsf(n[1])) && (d[1] * n[1] >= 0.f) && (fnx[1] > n0.x) && (fnx[1] < n1.x))
1840
        if ((Bfabsf(d[1]) > Bfabsf(n[1])) && (d[1] * n[1] >= 0.f) && (fnx[1] > n0.x) && (fnx[1] < n1.x))
1836
                spx[scnt] = fnx[1], spt[scnt++] = 1;
1841
            spx[scnt] = fnx[1], spt[scnt++] = 1;
1837
        }
-
 
1838
1842
1839
        //Nice hack to avoid full sort later :)
1843
        //Nice hack to avoid full sort later :)
1840
        if ((scnt >= 2) && (spx[scnt-1] < spx[scnt-2]))
1844
        if ((scnt >= 2) && (spx[scnt-1] < spx[scnt-2]))
1841
        {
1845
        {
1842
            swapfloat(&spx[scnt-1], &spx[scnt-2]);
1846
            swapfloat(&spx[scnt-1], &spx[scnt-2]);
Line 1852... Line 1856...
1852
                { spx[scnt] = x1; /* spy[scnt] = y1; */ spt[scnt] = -1; scnt++; }
1856
                { spx[scnt] = x1; /* spy[scnt] = y1; */ spt[scnt] = -1; scnt++; }
1853
        }
1857
        }
1854
1858
1855
        vsp[i].tag = vsp[newi].tag = -1;
1859
        vsp[i].tag = vsp[newi].tag = -1;
1856
1860
1857
        dx = 1.f/dx;
1861
        float const rdx = 1.f/dx;
1858
1862
1859
        for (z=0; z<=scnt; z++,i=vcnt)
1863
        for (int z=0, vcnt=0; z<=scnt; z++,i=vcnt)
1860
        {
1864
        {
1861
            float t;
1865
            float t;
1862
1866
1863
            if (z == scnt)
1867
            if (z == scnt)
1864
                goto skip;
1868
                goto skip;
1865
1869
1866
            t = (spx[z]-n0.x)*dx;
1870
            t = (spx[z]-n0.x)*rdx;
1867
            vcnt = vsinsaft(vsp, i);
1871
            vcnt = vsinsaft(vsp, i);
1868
            vsp[i].cy[1] = t*cv[0] + cy[0];
1872
            vsp[i].cy[1] = t*cv[0] + cy[0];
1869
            vsp[i].fy[1] = t*cv[1] + cy[1];
1873
            vsp[i].fy[1] = t*cv[1] + cy[1];
1870
            vsp[vcnt].x = spx[z];
1874
            vsp[vcnt].x = spx[z];
1871
            vsp[vcnt].cy[0] = vsp[i].cy[1];
1875
            vsp[vcnt].cy[0] = vsp[i].cy[1];
1872
            vsp[vcnt].fy[0] = vsp[i].fy[1];
1876
            vsp[vcnt].fy[0] = vsp[i].fy[1];
1873
            vsp[vcnt].tag = spt[z];
1877
            vsp[vcnt].tag = spt[z];
1874
1878
1875
skip: ;
1879
skip: ;
1876
            int32_t ni = vsp[i].n; if (!ni) continue; //this 'if' fixes many bugs!
1880
            int32_t const ni = vsp[i].n; if (!ni) continue; //this 'if' fixes many bugs!
1877
            float dx0 = vsp[i].x; if (x0 > dx0) continue;
1881
            float const dx0 = vsp[i].x; if (x0 > dx0) continue;
1878
            float dx1 = vsp[ni].x; if (x1 < dx1) continue;
1882
            float const dx1 = vsp[ni].x; if (x1 < dx1) continue;
1879
            n0.y = (dx0-x0)*slop + y0;
1883
            n0.y = (dx0-x0)*slop + y0;
1880
            n1.y = (dx1-x0)*slop + y0;
1884
            n1.y = (dx1-x0)*slop + y0;
1881
1885
1882
            //      dx0           dx1
1886
            //      dx0           dx1
1883
            //       ~             ~
1887
            //       ~             ~
Line 1890... Line 1894...
1890
            //   vsp[i].fy[0]    vsp[i].fy[1]
1894
            //   vsp[i].fy[0]    vsp[i].fy[1]
1891
            //     t0+=2         t1+=6
1895
            //     t0+=2         t1+=6
1892
            //
1896
            //
1893
            //     ny0 ?         ny1 ?
1897
            //     ny0 ?         ny1 ?
1894
1898
1895
            k = 1+3;
1899
            int k = 4;
-
 
1900
1896
            if ((vsp[i].tag == 0) || (n0.y <= vsp[i].cy[0]+.01f)) k--;
1901
            if ((vsp[i].tag == 0) || (n0.y <= vsp[i].cy[0]+.01f)) k--;
1897
            if ((vsp[i].tag == 1) || (n0.y >= vsp[i].fy[0]-.01f)) k++;
1902
            if ((vsp[i].tag == 1) || (n0.y >= vsp[i].fy[0]-.01f)) k++;
1898
            if ((vsp[ni].tag == 0) || (n1.y <= vsp[i].cy[1]+.01f)) k -= 3;
1903
            if ((vsp[ni].tag == 0) || (n1.y <= vsp[i].cy[1]+.01f)) k -= 3;
1899
            if ((vsp[ni].tag == 1) || (n1.y >= vsp[i].fy[1]-.01f)) k += 3;
1904
            if ((vsp[ni].tag == 1) || (n1.y >= vsp[i].fy[1]-.01f)) k += 3;
1900
1905
1901
            dpxy[0].x = dx0;
-
 
1902
            dpxy[1].x = dx1;
-
 
1903
-
 
1904
            if (!dir)
1906
            if (!dir)
1905
            {
1907
            {
1906
                dpxy[0].y = vsp[i].cy[0];
-
 
1907
                dpxy[1].y = vsp[i].cy[1];
-
 
1908
-
 
1909
                switch (k)
1908
                switch (k)
1910
                {
1909
                {
1911
                case 4:
1910
                    case 4:
1912
                case 5:
1911
                    case 5:
1913
                case 7:
1912
                    case 7:
-
 
1913
                    {
1914
                    dpxy[2].x = dx1; dpxy[3].x = dx0;
1914
                        vec2f_t const dpxy[4] = {
-
 
1915
                            { dx0, vsp[i].cy[0] }, { dx1, vsp[i].cy[1] }, { dx1, n1.y }, { dx0, n0.y }
-
 
1916
                        };
-
 
1917
1915
                    dpxy[2].y = n1.y; dpxy[3].y = n0.y;
1918
                        vsp[i].cy[0] = n0.y;
1916
                    vsp[i].cy[0] = n0.y; vsp[i].cy[1] = n1.y; vsp[i].ctag = gtag;
1919
                        vsp[i].cy[1] = n1.y;
-
 
1920
                        vsp[i].ctag = gtag;
1917
                    drawpoly(dpxy, 4, domostpolymethod);
1921
                        drawpoly(dpxy, 4, domostpolymethod);
-
 
1922
                    }
1918
                    break;
1923
                    break;
1919
                case 1:
1924
                    case 1:
1920
                case 2:
1925
                    case 2:
1921
                    dpxy[2].x = dx0;
1926
                    {
-
 
1927
                        vec2f_t const dpxy[3] = { { dx0, vsp[i].cy[0] }, { dx1, vsp[i].cy[1] }, { dx0, n0.y } };
-
 
1928
1922
                    dpxy[2].y = n0.y;
1929
                        vsp[i].cy[0] = n0.y;
1923
                    vsp[i].cy[0] = n0.y; vsp[i].ctag = gtag;
1930
                        vsp[i].ctag = gtag;
1924
                    drawpoly(dpxy, 3, domostpolymethod);
1931
                        drawpoly(dpxy, 3, domostpolymethod);
-
 
1932
                    }
1925
                    break;
1933
                    break;
1926
                case 3:
1934
                    case 3:
1927
                case 6:
1935
                    case 6:
1928
                    dpxy[2].x = dx1;
1936
                    {
-
 
1937
                        vec2f_t const dpxy[3] = { { dx0, vsp[i].cy[0] }, { dx1, vsp[i].cy[1] }, { dx1, n1.y } };
-
 
1938
1929
                    dpxy[2].y = n1.y;
1939
                        vsp[i].cy[1] = n1.y;
1930
                    vsp[i].cy[1] = n1.y; vsp[i].ctag = gtag;
1940
                        vsp[i].ctag = gtag;
1931
                    drawpoly(dpxy, 3, domostpolymethod);
1941
                        drawpoly(dpxy, 3, domostpolymethod);
-
 
1942
                    }
1932
                    break;
1943
                    break;
1933
                case 8:
1944
                    case 8:
-
 
1945
                    {
1934
                    dpxy[2].x = dx1; dpxy[2].y = vsp[i].fy[1];
1946
                        vec2f_t const dpxy[4] = {
1935
                    dpxy[3].x = dx0; dpxy[3].y = vsp[i].fy[0];
1947
                            { dx0, vsp[i].cy[0] }, { dx1, vsp[i].cy[1] }, { dx1, vsp[i].fy[1] }, { dx0, vsp[i].fy[0] }
-
 
1948
                        };
-
 
1949
1936
                    vsp[i].ctag = vsp[i].ftag = -1;
1950
                        vsp[i].ctag = vsp[i].ftag = -1;
1937
                    drawpoly(dpxy, 4, domostpolymethod);
1951
                        drawpoly(dpxy, 4, domostpolymethod);
1938
                default:
1952
                    }
1939
                    break;
1953
                    default: break;
1940
                }
1954
                }
1941
            }
1955
            }
1942
            else
1956
            else
1943
            {
1957
            {
1944
                switch (k)
1958
                switch (k)
1945
                {
1959
                {
1946
                case 4:
1960
                case 4:
1947
                case 3:
1961
                case 3:
1948
                case 1:
1962
                case 1:
-
 
1963
                {
1949
                    dpxy[2].x = dx1; dpxy[3].x = dx0;
1964
                    vec2f_t const dpxy[4] ={
1950
                    dpxy[0].y = n0.y; dpxy[1].y = n1.y; dpxy[2].y = vsp[i].fy[1]; dpxy[3].y = vsp[i].fy[0];
1965
                        { dx0, n0.y }, { dx1, n1.y }, { dx1, vsp[i].fy[1] }, { dx0, vsp[i].fy[0] }
-
 
1966
                    };
-
 
1967
-
 
1968
                    vsp[i].fy[0] = n0.y;
1951
                    vsp[i].fy[0] = n0.y; vsp[i].fy[1] = n1.y; vsp[i].ftag = gtag;
1969
                    vsp[i].fy[1] = n1.y;
-
 
1970
                    vsp[i].ftag = gtag;
1952
                    drawpoly(dpxy, 4, domostpolymethod);
1971
                    drawpoly(dpxy, 4, domostpolymethod);
-
 
1972
                }
1953
                    break;
1973
                    break;
1954
                case 7:
1974
                case 7:
1955
                case 6:
1975
                case 6:
1956
                    dpxy[2].x = dx0;
1976
                {
1957
                    dpxy[0].y = n0.y; dpxy[1].y = vsp[i].fy[1]; dpxy[2].y = vsp[i].fy[0];
1977
                    vec2f_t const dpxy[3] = { { dx0, n0.y }, { dx1, vsp[i].fy[1] }, { dx0, vsp[i].fy[0] } };
-
 
1978
1958
                    vsp[i].fy[0] = n0.y; vsp[i].ftag = gtag;
1979
                    vsp[i].fy[0] = n0.y;
-
 
1980
                    vsp[i].ftag = gtag;
1959
                    drawpoly(dpxy, 3, domostpolymethod);
1981
                    drawpoly(dpxy, 3, domostpolymethod);
-
 
1982
                }
1960
                    break;
1983
                    break;
1961
                case 5:
1984
                case 5:
1962
                case 2:
1985
                case 2:
1963
                    dpxy[2].x = dx1;
1986
                {
1964
                    dpxy[0].y = vsp[i].fy[0]; dpxy[1].y = n1.y; dpxy[2].y = vsp[i].fy[1];
1987
                    vec2f_t const dpxy[3] ={ { dx0, vsp[i].fy[0] }, { dx1, n1.y }, { dx1, vsp[i].fy[1] } };
-
 
1988
1965
                    vsp[i].fy[1] = n1.y; vsp[i].ftag = gtag;
1989
                    vsp[i].fy[1] = n1.y;
-
 
1990
                    vsp[i].ftag = gtag;
1966
                    drawpoly(dpxy, 3, domostpolymethod);
1991
                    drawpoly(dpxy, 3, domostpolymethod);
-
 
1992
                }
1967
                    break;
1993
                    break;
1968
                case 0:
1994
                case 0:
1969
                    dpxy[2].x = dx1; dpxy[3].x = dx0;
1995
                {
1970
                    dpxy[0].y = vsp[i].cy[0]; dpxy[1].y = vsp[i].cy[1]; dpxy[2].y = vsp[i].fy[1]; dpxy[3].y = vsp[i].fy[0];
1996
                    vec2f_t const dpxy[4] ={ { dx0, vsp[i].cy[0] }, { dx1, vsp[i].cy[1] }, { dx1, vsp[i].fy[1] }, { dx0, vsp[i].fy[0] } };
1971
                    vsp[i].ctag = vsp[i].ftag = -1;
1997
                    vsp[i].ctag = vsp[i].ftag = -1;
1972
                    drawpoly(dpxy, 4, domostpolymethod);
1998
                    drawpoly(dpxy, 4, domostpolymethod);
-
 
1999
                }
1973
                default:
2000
                default:
1974
                    break;
2001
                    break;
1975
                }
2002
                }
1976
            }
2003
            }
1977
        }
2004
        }
Line 1979... Line 2006...
1979
2006
1980
    gtag++;
2007
    gtag++;
1981
2008
1982
    //Combine neighboring vertical strips with matching collinear top&bottom edges
2009
    //Combine neighboring vertical strips with matching collinear top&bottom edges
1983
    //This prevents x-splits from propagating through the entire scan
2010
    //This prevents x-splits from propagating through the entire scan
1984
    i = vsp[0].n;
2011
    int i = vsp[0].n;
1985
2012
1986
    while (i)
2013
    while (i)
1987
    {
2014
    {
1988
        int32_t ni = vsp[i].n;
-
 
1989
-
 
1990
        if ((vsp[i].cy[0] >= vsp[i].fy[0]) && (vsp[i].cy[1] >= vsp[i].fy[1]))
2015
        if ((vsp[i].cy[0] >= vsp[i].fy[0]) && (vsp[i].cy[1] >= vsp[i].fy[1]))
1991
            vsp[i].ctag = vsp[i].ftag = -1;
2016
            vsp[i].ctag = vsp[i].ftag = -1;
1992
2017
-
 
2018
        int const ni = vsp[i].n;
-
 
2019
1993
        if ((vsp[i].ctag == vsp[ni].ctag) && (vsp[i].ftag == vsp[ni].ftag))
2020
        if ((vsp[i].ctag == vsp[ni].ctag) && (vsp[i].ftag == vsp[ni].ftag))
1994
        {
2021
        {
1995
            vsp[i].cy[1] = vsp[ni].cy[1];
2022
            vsp[i].cy[1] = vsp[ni].cy[1];
1996
            vsp[i].fy[1] = vsp[ni].fy[1];
2023
            vsp[i].fy[1] = vsp[ni].fy[1];
1997
            vsdel(vsp, ni);
2024
            vsdel(vsp, ni);
Line 2146... Line 2173...
2146
2173
2147
static void polymost_internal_nonparallaxed(float nx0, float ny0, float nx1, float ny1, float ryp0, float ryp1,
2174
static void polymost_internal_nonparallaxed(float nx0, float ny0, float nx1, float ny1, float ryp0, float ryp1,
2148
                                            float x0, float x1, float cf_y0, float cf_y1, int32_t have_floor,
2175
                                            float x0, float x1, float cf_y0, float cf_y1, int32_t have_floor,
2149
                                            int32_t sectnum)
2176
                                            int32_t sectnum)
2150
{
2177
{
2151
    float ft[4], fx, fy, ox, oy, oz, ox2, oy2;
-
 
2152
    int32_t i;
-
 
2153
-
 
2154
    const sectortype *sec = &sector[sectnum];
2178
    tsectortype const * const sec = (tsectortype *)&sector[sectnum];
2155
2179
2156
    // comments from floor code:
2180
    // comments from floor code:
2157
            //(singlobalang/-16384*(sx-ghalfx) + 0*(sy-ghoriz) + (cosviewingrangeglobalang/16384)*ghalfx)*d + globalposx    = u*16
2181
            //(singlobalang/-16384*(sx-ghalfx) + 0*(sy-ghoriz) + (cosviewingrangeglobalang/16384)*ghalfx)*d + globalposx    = u*16
2158
            //(cosglobalang/ 16384*(sx-ghalfx) + 0*(sy-ghoriz) + (sinviewingrangeglobalang/16384)*ghalfx)*d + globalposy    = v*16
2182
            //(cosglobalang/ 16384*(sx-ghalfx) + 0*(sy-ghoriz) + (sinviewingrangeglobalang/16384)*ghalfx)*d + globalposy    = v*16
2159
            //(                  0*(sx-ghalfx) + 1*(sy-ghoriz) + (                             0)*ghalfx)*d + globalposz/16 = (sec->floorz/16)
2183
            //(                  0*(sx-ghalfx) + 1*(sy-ghoriz) + (                             0)*ghalfx)*d + globalposz/16 = (sec->floorz/16)
-
 
2184
-
 
2185
    float ft[4];
2160
    if (!(globalorientation&64))
2186
    if (!(globalorientation&64))
2161
        { ft[0] = fglobalposx; ft[1] = fglobalposy; ft[2] = fcosglobalang; ft[3] = fsinglobalang; }
2187
        { ft[0] = fglobalposx; ft[1] = fglobalposy; ft[2] = fcosglobalang; ft[3] = fsinglobalang; }
2162
    else
2188
    else
2163
    {
2189
    {
2164
        float r;
-
 
2165
        //relative alignment
2190
        //relative alignment
2166
        fx = (float)(wall[wall[sec->wallptr].point2].x-wall[sec->wallptr].x);
2191
        vec2f_t fxy = { (float)(wall[wall[sec->wallptr].point2].x - wall[sec->wallptr].x),
2167
        fy = (float)(wall[wall[sec->wallptr].point2].y-wall[sec->wallptr].y);
2192
                        (float)(wall[wall[sec->wallptr].point2].y - wall[sec->wallptr].y) };
2168
        r = polymost_invsqrt(fx*fx+fy*fy); fx *= r; fy *= r;
2193
        float r = polymost_invsqrt_approximation(fxy.x * fxy.x + fxy.y * fxy.y);
-
 
2194
        fxy.x *= r; fxy.y *= r;
2169
        ft[2] = fcosglobalang*fx + fsinglobalang*fy;
2195
        ft[2] = fcosglobalang * fxy.x + fsinglobalang * fxy.y;
2170
        ft[3] = fsinglobalang*fx - fcosglobalang*fy;
2196
        ft[3] = fsinglobalang*fxy.x - fcosglobalang*fxy.y;
2171
        ft[0] = ((float)(globalposx-wall[sec->wallptr].x))*fx + ((float)(globalposy-wall[sec->wallptr].y))*fy;
2197
        ft[0] = ((float)(globalposx-wall[sec->wallptr].x))*fxy.x + ((float)(globalposy-wall[sec->wallptr].y))*fxy.y;
2172
        ft[1] = ((float)(globalposy-wall[sec->wallptr].y))*fx - ((float)(globalposx-wall[sec->wallptr].x))*fy;
2198
        ft[1] = ((float)(globalposy-wall[sec->wallptr].y))*fxy.x - ((float)(globalposx-wall[sec->wallptr].x))*fxy.y;
2173
        if (!(globalorientation&4)) globalorientation ^= 32; else globalorientation ^= 16;
2199
        globalorientation ^= (!(globalorientation & 4)) ? 32 : 16;
2174
    }
2200
    }
-
 
2201
2175
    gdx = 0;
2202
    xtex.d = 0;
2176
    gdy = gxyaspect;
2203
    ytex.d = gxyaspect;
2177
    if (!(globalorientation&2))
-
 
-
 
2204
2178
        if (global_cf_z-globalposz)  // PK 2012: don't allow div by zero
2205
    if (!(globalorientation&2) && global_cf_z-globalposz)  // PK 2012: don't allow div by zero
2179
            gdy /= (double)(global_cf_z-globalposz);
2206
            ytex.d /= (double)(global_cf_z-globalposz);
-
 
2207
2180
    gdo = -ghoriz*gdy;
2208
    otex.d = -ghoriz*ytex.d;
2181
    if (globalorientation&8) { ft[0] *= (1.f/8.f); ft[1] *= (-1.f/8.f); ft[2] *= (1.f/2097152.f); ft[3] *= (1.0f/2097152.f); }
2209
    if (globalorientation&8) { ft[0] *= (1.f/8.f); ft[1] *= (-1.f/8.f); ft[2] *= (1.f/2097152.f); ft[3] *= (1.0f/2097152.f); }
2182
    else { ft[0] *= (1.0f/16.f); ft[1] *= (-1.0f/16.f); ft[2] *= (1.0f/4194304.f); ft[3] *= (1.0f/4194304.f); }
2210
    else { ft[0] *= (1.0f/16.f); ft[1] *= (-1.0f/16.f); ft[2] *= (1.0f/4194304.f); ft[3] *= (1.0f/4194304.f); }
2183
    gux = ft[3]*((double)viewingrange)*(-1.0/65536.0);
2211
    xtex.u = ft[3]*((double)viewingrange)*(-1.0/65536.0);
2184
    gvx = ft[2]*((double)viewingrange)*(-1.0/65536.0);
2212
    xtex.v = ft[2]*((double)viewingrange)*(-1.0/65536.0);
2185
    guy = ft[0]*gdy; gvy = ft[1]*gdy;
2213
    ytex.u = ft[0]*ytex.d; ytex.v = ft[1]*ytex.d;
2186
    guo = ft[0]