zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-24 21:21:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

- renamed the texture coord variables in GLWall.

Browse source 
It makes no sense having them organized differently in this struct than what the rendering code needs. This saves one redundant copy operation and a function-local static variable.
This commit is contained in:
Christoph Oelckers 2016-05-05 11:48:39 +02:00
parent 51baa7d137
commit 2b92048a5b
6 changed files with 106 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/gl/compatibility/gl_20.cpp
View file

@ -526,6 +526,7 @@ bool GLFlat::PutFlatCompat(bool fog)
if (gltexture->tex->gl_info.Brightmap && gl.glslversion >= 0.f) list = GLLDL_FLATS_BRIGHT;
}
gl_drawinfo->dldrawlists[list].AddFlat(this);
return true;
}
@ -559,14 +560,14 @@ void GLWall::RenderFogBoundaryCompat()
glDepthFunc(GL_LEQUAL);
glColor4f(fc[0], fc[1], fc[2], fogd1);
glBegin(GL_TRIANGLE_FAN);
glTexCoord2f(lolft.u, lolft.v);
glTexCoord2f(tcs[LOLFT].u, tcs[LOLFT].v);
glVertex3f(glseg.x1, zbottom[0], glseg.y1);
glTexCoord2f(uplft.u, uplft.v);
glTexCoord2f(tcs[UPLFT].u, tcs[UPLFT].v);
glVertex3f(glseg.x1, ztop[0], glseg.y1);
glColor4f(fc[0], fc[1], fc[2], fogd2);
glTexCoord2f(uprgt.u, uprgt.v);
glTexCoord2f(tcs[UPRGT].u, tcs[UPRGT].v);
glVertex3f(glseg.x2, ztop[1], glseg.y2);
glTexCoord2f(lorgt.u, lorgt.v);
glTexCoord2f(tcs[LORGT].u, tcs[LORGT].v);
glVertex3f(glseg.x2, zbottom[1], glseg.y2);
glEnd();
glDepthFunc(GL_LESS);

10
src/gl/scene/gl_drawinfo.cpp
View file

@ -326,7 +326,7 @@ void GLDrawList::SortWallIntoPlane(SortNode * head,SortNode * sort)
GLWall * ws1;
ws1=&walls[walls.Size()-1];
ws=&walls[drawitems[sort->itemindex].index]; // may have been reallocated!
float newtexv = ws->uplft.v + ((ws->lolft.v - ws->uplft.v) / (ws->zbottom[0] - ws->ztop[0])) * (fh->z - ws->ztop[0]);
float newtexv = ws->tcs[GLWall::UPLFT].v + ((ws->tcs[GLWall::LOLFT].v - ws->tcs[GLWall::UPLFT].v) / (ws->zbottom[0] - ws->ztop[0])) * (fh->z - ws->ztop[0]);
// I make the very big assumption here that translucent walls in sloped sectors
// and 3D-floors never coexist in the same level. If that were the case this
@ -334,12 +334,12 @@ void GLDrawList::SortWallIntoPlane(SortNode * head,SortNode * sort)
if (!ceiling)
{
ws->ztop[1] = ws1->zbottom[1] = ws->ztop[0] = ws1->zbottom[0] = fh->z;
ws->uprgt.v = ws1->lorgt.v = ws->uplft.v = ws1->lolft.v = newtexv;
ws->tcs[GLWall::UPRGT].v = ws1->tcs[GLWall::LORGT].v = ws->tcs[GLWall::UPLFT].v = ws1->tcs[GLWall::LOLFT].v = newtexv;
}
else
{
ws1->ztop[1] = ws->zbottom[1] = ws1->ztop[0] = ws->zbottom[0] = fh->z;
ws1->uplft.v = ws->lolft.v = ws1->uprgt.v = ws->lorgt.v=newtexv;
ws1->tcs[GLWall::UPLFT].v = ws->tcs[GLWall::LOLFT].v = ws1->tcs[GLWall::UPRGT].v = ws->tcs[GLWall::LORGT].v=newtexv;
}
}
@ -462,7 +462,7 @@ void GLDrawList::SortWallIntoWall(SortNode * head,SortNode * sort)
float ix=(float)(ws->glseg.x1+r*(ws->glseg.x2-ws->glseg.x1));
float iy=(float)(ws->glseg.y1+r*(ws->glseg.y2-ws->glseg.y1));
float iu=(float)(ws->uplft.u + r * (ws->uprgt.u - ws->uplft.u));
float iu=(float)(ws->tcs[GLWall::UPLFT].u + r * (ws->tcs[GLWall::UPRGT].u - ws->tcs[GLWall::UPLFT].u));
float izt=(float)(ws->ztop[0]+r*(ws->ztop[1]-ws->ztop[0]));
float izb=(float)(ws->zbottom[0]+r*(ws->zbottom[1]-ws->zbottom[0]));
@ -475,7 +475,7 @@ void GLDrawList::SortWallIntoWall(SortNode * head,SortNode * sort)
ws1->glseg.y1=ws->glseg.y2=iy;
ws1->ztop[0]=ws->ztop[1]=izt;
ws1->zbottom[0]=ws->zbottom[1]=izb;
ws1->lolft.u = ws1->uplft.u = ws->lorgt.u = ws->uprgt.u = iu;
ws1->tcs[GLWall::LOLFT].u = ws1->tcs[GLWall::UPLFT].u = ws->tcs[GLWall::LORGT].u = ws->tcs[GLWall::UPRGT].u = iu;
SortNode * sort2=SortNodes.GetNew();
memset(sort2,0,sizeof(SortNode));

40
src/gl/scene/gl_vertex.cpp
View file

@ -61,14 +61,14 @@ EXTERN_CVAR(Bool, gl_seamless)
//
//==========================================================================
void GLWall::SplitUpperEdge(texcoord * tcs, FFlatVertex *&ptr)
void GLWall::SplitUpperEdge(FFlatVertex *&ptr)
{
if (seg == NULL || seg->sidedef == NULL || (seg->sidedef->Flags & WALLF_POLYOBJ) || seg->sidedef->numsegs == 1) return;
side_t *sidedef = seg->sidedef;
float polyw = glseg.fracright - glseg.fracleft;
float facu = (tcs[2].u - tcs[1].u) / polyw;
float facv = (tcs[2].v - tcs[1].v) / polyw;
float facu = (tcs[UPRGT].u - tcs[UPLFT].u) / polyw;
float facv = (tcs[UPRGT].v - tcs[UPLFT].v) / polyw;
float fact = (ztop[1] - ztop[0]) / polyw;
float facc = (zceil[1] - zceil[0]) / polyw;
float facf = (zfloor[1] - zfloor[0]) / polyw;
@ -85,8 +85,8 @@ void GLWall::SplitUpperEdge(texcoord * tcs, FFlatVertex *&ptr)
ptr->x = cseg->v2->fX();
ptr->y = cseg->v2->fY();
ptr->z = ztop[0] + fact * fracfac;
ptr->u = tcs[1].u + facu * fracfac;
ptr->v = tcs[1].v + facv * fracfac;
ptr->u = tcs[UPLFT].u + facu * fracfac;
ptr->v = tcs[UPLFT].v + facv * fracfac;
ptr++;
}
}
@ -97,14 +97,14 @@ void GLWall::SplitUpperEdge(texcoord * tcs, FFlatVertex *&ptr)
//
//==========================================================================
void GLWall::SplitLowerEdge(texcoord * tcs, FFlatVertex *&ptr)
void GLWall::SplitLowerEdge(FFlatVertex *&ptr)
{
if (seg == NULL || seg->sidedef == NULL || (seg->sidedef->Flags & WALLF_POLYOBJ) || seg->sidedef->numsegs == 1) return;
side_t *sidedef = seg->sidedef;
float polyw = glseg.fracright - glseg.fracleft;
float facu = (tcs[3].u - tcs[0].u) / polyw;
float facv = (tcs[3].v - tcs[0].v) / polyw;
float facu = (tcs[LORGT].u - tcs[LOLFT].u) / polyw;
float facv = (tcs[LORGT].v - tcs[LOLFT].v) / polyw;
float facb = (zbottom[1] - zbottom[0]) / polyw;
float facc = (zceil[1] - zceil[0]) / polyw;
float facf = (zfloor[1] - zfloor[0]) / polyw;
@ -121,8 +121,8 @@ void GLWall::SplitLowerEdge(texcoord * tcs, FFlatVertex *&ptr)
ptr->x = cseg->v2->fX();
ptr->y = cseg->v2->fY();
ptr->z = zbottom[0] + facb * fracfac;
ptr->u = tcs[0].u + facu * fracfac;
ptr->v = tcs[0].v + facv * fracfac;
ptr->u = tcs[LOLFT].u + facu * fracfac;
ptr->v = tcs[LOLFT].v + facv * fracfac;
ptr++;
}
}
@ -133,7 +133,7 @@ void GLWall::SplitLowerEdge(texcoord * tcs, FFlatVertex *&ptr)
//
//==========================================================================
void GLWall::SplitLeftEdge(texcoord * tcs, FFlatVertex *&ptr)
void GLWall::SplitLeftEdge(FFlatVertex *&ptr)
{
if (vertexes[0] == NULL) return;
@ -144,8 +144,8 @@ void GLWall::SplitLeftEdge(texcoord * tcs, FFlatVertex *&ptr)
int i = 0;
float polyh1 = ztop[0] - zbottom[0];
float factv1 = polyh1 ? (tcs[1].v - tcs[0].v) / polyh1 : 0;
float factu1 = polyh1 ? (tcs[1].u - tcs[0].u) / polyh1 : 0;
float factv1 = polyh1 ? (tcs[UPLFT].v - tcs[LOLFT].v) / polyh1 : 0;
float factu1 = polyh1 ? (tcs[UPLFT].u - tcs[LOLFT].u) / polyh1 : 0;
while (i<vi->numheights && vi->heightlist[i] <= zbottom[0]) i++;
while (i<vi->numheights && vi->heightlist[i] < ztop[0])
@ -153,8 +153,8 @@ void GLWall::SplitLeftEdge(texcoord * tcs, FFlatVertex *&ptr)
ptr->x = glseg.x1;
ptr->y = glseg.y1;
ptr->z = vi->heightlist[i];
ptr->u = factu1*(vi->heightlist[i] - ztop[0]) + tcs[1].u;
ptr->v = factv1*(vi->heightlist[i] - ztop[0]) + tcs[1].v;
ptr->u = factu1*(vi->heightlist[i] - ztop[0]) + tcs[UPLFT].u;
ptr->v = factv1*(vi->heightlist[i] - ztop[0]) + tcs[UPLFT].v;
ptr++;
i++;
}
@ -167,7 +167,7 @@ void GLWall::SplitLeftEdge(texcoord * tcs, FFlatVertex *&ptr)
//
//==========================================================================
void GLWall::SplitRightEdge(texcoord * tcs, FFlatVertex *&ptr)
void GLWall::SplitRightEdge(FFlatVertex *&ptr)
{
if (vertexes[1] == NULL) return;
@ -178,8 +178,8 @@ void GLWall::SplitRightEdge(texcoord * tcs, FFlatVertex *&ptr)
int i = vi->numheights - 1;
float polyh2 = ztop[1] - zbottom[1];
float factv2 = polyh2 ? (tcs[2].v - tcs[3].v) / polyh2 : 0;
float factu2 = polyh2 ? (tcs[2].u - tcs[3].u) / polyh2 : 0;
float factv2 = polyh2 ? (tcs[UPRGT].v - tcs[LORGT].v) / polyh2 : 0;
float factu2 = polyh2 ? (tcs[UPRGT].u - tcs[LORGT].u) / polyh2 : 0;
while (i>0 && vi->heightlist[i] >= ztop[1]) i--;
while (i>0 && vi->heightlist[i] > zbottom[1])
@ -187,8 +187,8 @@ void GLWall::SplitRightEdge(texcoord * tcs, FFlatVertex *&ptr)
ptr->x = glseg.x2;
ptr->y = glseg.y2;
ptr->z = vi->heightlist[i];
ptr->u = factu2*(vi->heightlist[i] - ztop[1]) + tcs[2].u;
ptr->v = factv2*(vi->heightlist[i] - ztop[1]) + tcs[2].v;
ptr->u = factu2*(vi->heightlist[i] - ztop[1]) + tcs[UPRGT].u;
ptr->v = factv2*(vi->heightlist[i] - ztop[1]) + tcs[UPRGT].v;
ptr++;
i--;
}

17
src/gl/scene/gl_wall.h
View file

@ -119,6 +119,13 @@ public:
RWF_NORENDER = 8,
};
enum
{
LOLFT,
UPLFT,
UPRGT,
LORGT,
};
friend struct GLDrawList;
friend class GLPortal;
@ -126,7 +133,7 @@ public:
GLSeg glseg;
vertex_t * vertexes[2]; // required for polygon splitting
float ztop[2],zbottom[2];
texcoord uplft, uprgt, lolft, lorgt;
texcoord tcs[4];
float alpha;
FMaterial *gltexture;
@ -236,10 +243,10 @@ private:
void RenderMirrorSurface();
void RenderTranslucentWall();
void SplitLeftEdge(texcoord * tcs, FFlatVertex *&ptr);
void SplitRightEdge(texcoord * tcs, FFlatVertex *&ptr);
void SplitUpperEdge(texcoord * tcs, FFlatVertex *&ptr);
void SplitLowerEdge(texcoord * tcs, FFlatVertex *&ptr);
void SplitLeftEdge (FFlatVertex *&ptr);
void SplitRightEdge(FFlatVertex *&ptr);
void SplitUpperEdge(FFlatVertex *&ptr);
void SplitLowerEdge(FFlatVertex *&ptr);
public:

108
src/gl/scene/gl_walls.cpp
View file

@ -297,10 +297,10 @@ void GLWall::SplitWallComplex(sector_t * frontsector, bool translucent, float ma
copyWall1.ztop[1] = copyWall2.ztop[0] = ztop[0] + coeff * (ztop[1] - ztop[0]);
copyWall1.zbottom[1] = copyWall2.zbottom[0] = zbottom[0] + coeff * (zbottom[1] - zbottom[0]);
copyWall1.glseg.fracright = copyWall2.glseg.fracleft = glseg.fracleft + coeff * (glseg.fracright - glseg.fracleft);
copyWall1.uprgt.u = copyWall2.uplft.u = uplft.u + coeff * (uprgt.u - uplft.u);
copyWall1.uprgt.v = copyWall2.uplft.v = uplft.v + coeff * (uprgt.v - uplft.v);
copyWall1.lorgt.u = copyWall2.lolft.u = lolft.u + coeff * (lorgt.u - lolft.u);
copyWall1.lorgt.v = copyWall2.lolft.v = lolft.v + coeff * (lorgt.v - lolft.v);
copyWall1.tcs[UPRGT].u = copyWall2.tcs[UPLFT].u = tcs[UPLFT].u + coeff * (tcs[UPRGT].u - tcs[UPLFT].u);
copyWall1.tcs[UPRGT].v = copyWall2.tcs[UPLFT].v = tcs[UPLFT].v + coeff * (tcs[UPRGT].v - tcs[UPLFT].v);
copyWall1.tcs[LORGT].u = copyWall2.tcs[LOLFT].u = tcs[LOLFT].u + coeff * (tcs[LORGT].u - tcs[LOLFT].u);
copyWall1.tcs[LORGT].v = copyWall2.tcs[LOLFT].v = tcs[LOLFT].v + coeff * (tcs[LORGT].v - tcs[LOLFT].v);
copyWall1.SplitWall(frontsector, translucent);
copyWall2.SplitWall(frontsector, translucent);
@ -338,10 +338,10 @@ void GLWall::SplitWallComplex(sector_t * frontsector, bool translucent, float ma
copyWall1.ztop[1] = copyWall2.ztop[0] = ztop[0] + coeff * (ztop[1] - ztop[0]);
copyWall1.zbottom[1] = copyWall2.zbottom[0] = zbottom[0] + coeff * (zbottom[1] - zbottom[0]);
copyWall1.glseg.fracright = copyWall2.glseg.fracleft = glseg.fracleft + coeff * (glseg.fracright - glseg.fracleft);
copyWall1.uprgt.u = copyWall2.uplft.u = uplft.u + coeff * (uprgt.u - uplft.u);
copyWall1.uprgt.v = copyWall2.uplft.v = uplft.v + coeff * (uprgt.v - uplft.v);
copyWall1.lorgt.u = copyWall2.lolft.u = lolft.u + coeff * (lorgt.u - lolft.u);
copyWall1.lorgt.v = copyWall2.lolft.v = lolft.v + coeff * (lorgt.v - lolft.v);
copyWall1.tcs[UPRGT].u = copyWall2.tcs[UPLFT].u = tcs[UPLFT].u + coeff * (tcs[UPRGT].u - tcs[UPLFT].u);
copyWall1.tcs[UPRGT].v = copyWall2.tcs[UPLFT].v = tcs[UPLFT].v + coeff * (tcs[UPRGT].v - tcs[UPLFT].v);
copyWall1.tcs[LORGT].u = copyWall2.tcs[LOLFT].u = tcs[LOLFT].u + coeff * (tcs[LORGT].u - tcs[LOLFT].u);
copyWall1.tcs[LORGT].v = copyWall2.tcs[LOLFT].v = tcs[LOLFT].v + coeff * (tcs[LORGT].v - tcs[LOLFT].v);
copyWall1.SplitWall(frontsector, translucent);
copyWall2.SplitWall(frontsector, translucent);
@ -432,10 +432,10 @@ void GLWall::SplitWall(sector_t * frontsector, bool translucent)
flags |= GLWF_NOSPLITUPPER;
ztop[0]=copyWall1.zbottom[0]=maplightbottomleft;
ztop[1]=copyWall1.zbottom[1]=maplightbottomright;
uplft.v=copyWall1.lolft.v=copyWall1.uplft.v+
(maplightbottomleft-copyWall1.ztop[0])*(copyWall1.lolft.v-copyWall1.uplft.v)/(zbottom[0]-copyWall1.ztop[0]);
uprgt.v=copyWall1.lorgt.v=copyWall1.uprgt.v+
(maplightbottomright-copyWall1.ztop[1])*(copyWall1.lorgt.v-copyWall1.uprgt.v)/(zbottom[1]-copyWall1.ztop[1]);
tcs[UPLFT].v=copyWall1.tcs[LOLFT].v=copyWall1.tcs[UPLFT].v+
(maplightbottomleft-copyWall1.ztop[0])*(copyWall1.tcs[LOLFT].v-copyWall1.tcs[UPLFT].v)/(zbottom[0]-copyWall1.ztop[0]);
tcs[UPRGT].v=copyWall1.tcs[LORGT].v=copyWall1.tcs[UPRGT].v+
(maplightbottomright-copyWall1.ztop[1])*(copyWall1.tcs[LORGT].v-copyWall1.tcs[UPRGT].v)/(zbottom[1]-copyWall1.ztop[1]);
copyWall1.Put3DWall(&lightlist[i], translucent);
}
if (ztop[0]==zbottom[0] && ztop[1]==zbottom[1])
@ -574,8 +574,8 @@ bool GLWall::SetWallCoordinates(seg_t * seg, FTexCoordInfo *tci, float textureto
if (tci)
{
uplft.v = tci->FloatToTexV(-ztop[0] + texturetop);
lolft.v = tci->FloatToTexV(-zbottom[0] + texturetop);
tcs[UPLFT].v = tci->FloatToTexV(-ztop[0] + texturetop);
tcs[LOLFT].v = tci->FloatToTexV(-zbottom[0] + texturetop);
}
}
else
@ -595,7 +595,7 @@ bool GLWall::SetWallCoordinates(seg_t * seg, FTexCoordInfo *tci, float textureto
if (tci)
{
lolft.v = uplft.v = tci->FloatToTexV(-ztop[0] + texturetop);
tcs[LOLFT].v = tcs[UPLFT].v = tci->FloatToTexV(-ztop[0] + texturetop);
}
}
@ -612,8 +612,8 @@ bool GLWall::SetWallCoordinates(seg_t * seg, FTexCoordInfo *tci, float textureto
if (tci)
{
uprgt.v = tci->FloatToTexV(-ztop[1] + texturetop);
lorgt.v = tci->FloatToTexV(-zbottom[1] + texturetop);
tcs[UPRGT].v = tci->FloatToTexV(-ztop[1] + texturetop);
tcs[LORGT].v = tci->FloatToTexV(-zbottom[1] + texturetop);
}
}
else
@ -632,12 +632,12 @@ bool GLWall::SetWallCoordinates(seg_t * seg, FTexCoordInfo *tci, float textureto
zbottom[1] = ztop[1] = inter_y;
if (tci)
{
lorgt.v = uprgt.v = tci->FloatToTexV(-ztop[1] + texturetop);
tcs[LORGT].v = tcs[UPRGT].v = tci->FloatToTexV(-ztop[1] + texturetop);
}
}
uplft.u = lolft.u = l_ul + texlength * glseg.fracleft;
uprgt.u = lorgt.u = l_ul + texlength * glseg.fracright;
tcs[UPLFT].u = tcs[LOLFT].u = l_ul + texlength * glseg.fracleft;
tcs[UPRGT].u = tcs[LORGT].u = l_ul + texlength * glseg.fracright;
if (gltexture != NULL)
{
@ -646,15 +646,15 @@ bool GLWall::SetWallCoordinates(seg_t * seg, FTexCoordInfo *tci, float textureto
else if (flags & GLT_CLAMPY)
{
// for negative scales we can get negative coordinates here.
normalize = (uplft.v > lolft.v || uprgt.v > lorgt.v);
normalize = (tcs[UPLFT].v > tcs[LOLFT].v || tcs[UPRGT].v > tcs[LORGT].v);
}
if (normalize)
{
// we have to shift the y-coordinate from [-1..0] to [0..1] when using texture clamping with a negative scale
uplft.v += 1.f;
uprgt.v += 1.f;
lolft.v += 1.f;
lorgt.v += 1.f;
tcs[UPLFT].v += 1.f;
tcs[UPRGT].v += 1.f;
tcs[LOLFT].v += 1.f;
tcs[LORGT].v += 1.f;
}
}
@ -675,21 +675,21 @@ void GLWall::CheckTexturePosition()
// clamp texture coordinates to a reasonable range.
// Extremely large values can cause visual problems
if (uplft.v < uprgt.v)
if (tcs[UPLFT].v < tcs[UPRGT].v)
{
sub = float(xs_FloorToInt(uplft.v));
sub = float(xs_FloorToInt(tcs[UPLFT].v));
}
else
{
sub = float(xs_FloorToInt(uprgt.v));
sub = float(xs_FloorToInt(tcs[UPRGT].v));
}
uplft.v -= sub;
uprgt.v -= sub;
lolft.v -= sub;
lorgt.v -= sub;
tcs[UPLFT].v -= sub;
tcs[UPRGT].v -= sub;
tcs[LOLFT].v -= sub;
tcs[LORGT].v -= sub;
if ((uplft.v == 0.f && uprgt.v == 0.f && lolft.v <= 1.f && lorgt.v <= 1.f) ||
(uplft.v >= 0.f && uprgt.v >= 0.f && lolft.v == 1.f && lorgt.v == 1.f))
if ((tcs[UPLFT].v == 0.f && tcs[UPRGT].v == 0.f && tcs[LOLFT].v <= 1.f && tcs[LORGT].v <= 1.f) ||
(tcs[UPLFT].v >= 0.f && tcs[UPRGT].v >= 0.f && tcs[LOLFT].v == 1.f && tcs[LORGT].v == 1.f))
{
flags |= GLT_CLAMPY;
}
@ -698,13 +698,13 @@ void GLWall::CheckTexturePosition()
// This intentionally only tests the seg's frontsector.
if (seg->frontsector->special == GLSector_Skybox)
{
sub = (float)xs_FloorToInt(uplft.u);
uplft.u -= sub;
uprgt.u -= sub;
lolft.u -= sub;
lorgt.u -= sub;
if ((uplft.u == 0.f && lolft.u == 0.f && uprgt.u <= 1.f && lorgt.u <= 1.f) ||
(uplft.u >= 0.f && lolft.u >= 0.f && uprgt.u == 1.f && lorgt.u == 1.f))
sub = (float)xs_FloorToInt(tcs[UPLFT].u);
tcs[UPLFT].u -= sub;
tcs[UPRGT].u -= sub;
tcs[LOLFT].u -= sub;
tcs[LORGT].u -= sub;
if ((tcs[UPLFT].u == 0.f && tcs[LOLFT].u == 0.f && tcs[UPRGT].u <= 1.f && tcs[LORGT].u <= 1.f) ||
(tcs[UPLFT].u >= 0.f && tcs[LOLFT].u >= 0.f && tcs[UPRGT].u == 1.f && tcs[LORGT].u == 1.f))
{
flags |= GLT_CLAMPX;
}
@ -1039,10 +1039,10 @@ void GLWall::DoMidTexture(seg_t * seg, bool drawfogboundary,
// split the poly!
GLWall split;
int i,t=0;
float v_factor=(zbottom[0]-ztop[0])/(lolft.v-uplft.v);
float v_factor=(zbottom[0]-ztop[0])/(tcs[LOLFT].v-tcs[UPLFT].v);
// only split the vertical area of the polygon that does not contain slopes.
float splittopv = MAX(uplft.v, uprgt.v);
float splitbotv = MIN(lolft.v, lorgt.v);
float splittopv = MAX(tcs[UPLFT].v, tcs[UPRGT].v);
float splitbotv = MIN(tcs[LOLFT].v, tcs[LORGT].v);
// this is split vertically into sections.
for(i=0;i<v;i++)
@ -1063,16 +1063,16 @@ void GLWall::DoMidTexture(seg_t * seg, bool drawfogboundary,
// if not use the top of the remaining polygon
if (splitrect[i].top>splittopv)
{
split.ztop[0]=split.ztop[1]= ztop[0]+v_factor*(splitrect[i].top-uplft.v);
split.uplft.v=split.uprgt.v=splitrect[i].top;
split.ztop[0]=split.ztop[1]= ztop[0]+v_factor*(splitrect[i].top-tcs[UPLFT].v);
split.tcs[UPLFT].v=split.tcs[UPRGT].v=splitrect[i].top;
}
// the bottom line of the current segment is inside the splittable area
// use the splitrect's bottom as bottom of this segment
// if not use the bottom of the remaining polygon
if (splitbot<=splitbotv)
{
split.zbottom[0]=split.zbottom[1]=ztop[0]+v_factor*(splitbot-uplft.v);
split.lolft.v=split.lorgt.v=splitbot;
split.zbottom[0]=split.zbottom[1]=ztop[0]+v_factor*(splitbot-tcs[UPLFT].v);
split.tcs[LOLFT].v=split.tcs[LORGT].v=splitbot;
}
//
//
@ -1166,8 +1166,8 @@ void GLWall::BuildFFBlock(seg_t * seg, F3DFloor * rover,
texlength = tci.FloatToTexU(seg->sidedef->TexelLength);
uplft.u = lolft.u = ul + texlength * glseg.fracleft;
uprgt.u = lorgt.u = ul + texlength * glseg.fracright;
tcs[UPLFT].u = tcs[LOLFT].u = ul + texlength * glseg.fracleft;
tcs[UPRGT].u = tcs[LORGT].u = ul + texlength * glseg.fracright;
float rowoffset = tci.RowOffset(seg->sidedef->GetTextureYOffset(side_t::mid));
to = (rover->flags&(FF_UPPERTEXTURE | FF_LOWERTEXTURE)) ?
@ -1175,10 +1175,10 @@ void GLWall::BuildFFBlock(seg_t * seg, F3DFloor * rover,
to += rowoffset + rover->top.model->GetPlaneTexZ(rover->top.isceiling);
uplft.v = tci.FloatToTexV(to - ff_topleft);
uprgt.v = tci.FloatToTexV(to - ff_topright);
lolft.v = tci.FloatToTexV(to - ff_bottomleft);
lorgt.v = tci.FloatToTexV(to - ff_bottomright);
tcs[UPLFT].v = tci.FloatToTexV(to - ff_topleft);
tcs[UPRGT].v = tci.FloatToTexV(to - ff_topright);
tcs[LOLFT].v = tci.FloatToTexV(to - ff_bottomleft);
tcs[LORGT].v = tci.FloatToTexV(to - ff_bottomright);
type = RENDERWALL_FFBLOCK;
CheckTexturePosition();
}

26
src/gl/scene/gl_walls_draw.cpp
View file

@ -175,14 +175,8 @@ void GLWall::SetupLights()
void GLWall::RenderWall(int textured, unsigned int *store)
{
static texcoord tcs[4]; // making this variable static saves us a relatively costly stack integrity check.
bool split = (gl_seamless && !(textured&RWF_NOSPLIT) && seg->sidedef != NULL && !(seg->sidedef->Flags & WALLF_POLYOBJ) && !(flags & GLWF_NOSPLIT));
tcs[0]=lolft;
tcs[1]=uplft;
tcs[2]=uprgt;
tcs[3]=lorgt;
if (!(textured & RWF_NORENDER))
{
gl_RenderState.Apply();
@ -193,18 +187,18 @@ void GLWall::RenderWall(int textured, unsigned int *store)
FFlatVertex *ptr = GLRenderer->mVBO->GetBuffer();
unsigned int count, offset;
ptr->Set(glseg.x1, zbottom[0], glseg.y1, tcs[0].u, tcs[0].v);
ptr->Set(glseg.x1, zbottom[0], glseg.y1, tcs[LOLFT].u, tcs[LOLFT].v);
ptr++;
if (split && glseg.fracleft == 0) SplitLeftEdge(tcs, ptr);
ptr->Set(glseg.x1, ztop[0], glseg.y1, tcs[1].u, tcs[1].v);
if (split && glseg.fracleft == 0) SplitLeftEdge(ptr);
ptr->Set(glseg.x1, ztop[0], glseg.y1, tcs[UPLFT].u, tcs[UPLFT].v);
ptr++;
if (split && !(flags & GLWF_NOSPLITUPPER)) SplitUpperEdge(tcs, ptr);
ptr->Set(glseg.x2, ztop[1], glseg.y2, tcs[2].u, tcs[2].v);
if (split && !(flags & GLWF_NOSPLITUPPER)) SplitUpperEdge(ptr);
ptr->Set(glseg.x2, ztop[1], glseg.y2, tcs[UPRGT].u, tcs[UPRGT].v);
ptr++;
if (split && glseg.fracright == 1) SplitRightEdge(tcs, ptr);
ptr->Set(glseg.x2, zbottom[1], glseg.y2, tcs[3].u, tcs[3].v);
if (split && glseg.fracright == 1) SplitRightEdge(ptr);
ptr->Set(glseg.x2, zbottom[1], glseg.y2, tcs[LORGT].u, tcs[LORGT].v);
ptr++;
if (split && !(flags & GLWF_NOSPLITLOWER)) SplitLowerEdge(tcs, ptr);
if (split && !(flags & GLWF_NOSPLITLOWER)) SplitLowerEdge(ptr);
count = GLRenderer->mVBO->GetCount(ptr, &offset);
if (!(textured & RWF_NORENDER))
{
@ -265,8 +259,8 @@ void GLWall::RenderMirrorSurface()
if (gl.glslversion >= 0.f)
{
// we use texture coordinates and texture matrix to pass the normal stuff to the shader so that the default vertex buffer format can be used as is.
lolft.u = lorgt.u = uplft.u = uprgt.u = v.X();
lolft.v = lorgt.v = uplft.v = uprgt.v = v.Z();
tcs[LOLFT].u = tcs[LORGT].u = tcs[UPLFT].u = tcs[UPRGT].u = v.X();
tcs[LOLFT].v = tcs[LORGT].v = tcs[UPLFT].v = tcs[UPRGT].v = v.Z();
gl_RenderState.EnableTextureMatrix(true);
gl_RenderState.mTextureMatrix.computeNormalMatrix(gl_RenderState.mViewMatrix);