zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-11-11 07:11:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

- use the same formula for calculating 3DMidTex offsets as the renderer when per-sidedef scaling is used.

Browse source 
This reuses the FTexCoordInfo class the hardware renderer had been using to calculate wall texture offsetting.
The software renderers still need this sorted out to bring them in line with the rest of the code, though, but they do not have this code sufficiently well organized to make this a straightforward task.
This commit is contained in:
Christoph Oelckers 2018-11-17 18:24:14 +01:00
parent 701b793f24
commit 08fe9c375b
5 changed files with 145 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
src/hwrenderer/textures/hw_material.cpp
View file

@ -128,70 +128,6 @@ void IHardwareTexture::Resize(int swidth, int sheight, int width, int height, un
}
}
//===========================================================================
//
//
//
//===========================================================================
float FTexCoordInfo::RowOffset(float rowoffset) const
{
float tscale = fabs(mTempScale.Y);
float scale = fabs(mScale.Y);
if (tscale == 1.f)
{
if (scale == 1.f || mWorldPanning) return rowoffset;
else return rowoffset / scale;
}
else
{
if (mWorldPanning) return rowoffset / tscale;
else return rowoffset / scale;
}
}
//===========================================================================
//
//
//
//===========================================================================
float FTexCoordInfo::TextureOffset(float textureoffset) const
{
float tscale = fabs(mTempScale.X);
float scale = fabs(mScale.X);
if (tscale == 1.f)
{
if (scale == 1.f || mWorldPanning) return textureoffset;
else return textureoffset / scale;
}
else
{
if (mWorldPanning) return textureoffset / tscale;
else return textureoffset / scale;
}
}
//===========================================================================
//
// Returns the size for which texture offset coordinates are used.
//
//===========================================================================
float FTexCoordInfo::TextureAdjustWidth() const
{
if (mWorldPanning)
{
float tscale = fabs(mTempScale.X);
if (tscale == 1.f) return (float)mRenderWidth;
else return mWidth / fabs(tscale);
}
else return (float)mWidth;
}
//===========================================================================
//
//
@ -522,50 +458,6 @@ void FMaterial::PrecacheList(SpriteHits &translations)
while(it.NextPair(pair)) screen->PrecacheMaterial(this, pair->Key);
}
//===========================================================================
//
// Retrieve texture coordinate info for per-wall scaling
//
//===========================================================================
void FMaterial::GetTexCoordInfo(FTexCoordInfo *tci, float x, float y) const
{
if (x == 1.f)
{
tci->mRenderWidth = mRenderWidth;
tci->mScale.X = (float)tex->Scale.X;
tci->mTempScale.X = 1.f;
}
else
{
float scale_x = x * (float)tex->Scale.X;
tci->mRenderWidth = xs_CeilToInt(mWidth / scale_x);
tci->mScale.X = scale_x;
tci->mTempScale.X = x;
}
if (y == 1.f)
{
tci->mRenderHeight = mRenderHeight;
tci->mScale.Y = (float)tex->Scale.Y;
tci->mTempScale.Y = 1.f;
}
else
{
float scale_y = y * (float)tex->Scale.Y;
tci->mRenderHeight = xs_CeilToInt(mHeight / scale_y);
tci->mScale.Y = scale_y;
tci->mTempScale.Y = y;
}
if (tex->bHasCanvas)
{
tci->mScale.Y = -tci->mScale.Y;
tci->mRenderHeight = -tci->mRenderHeight;
}
tci->mWorldPanning = tex->bWorldPanning;
tci->mWidth = mWidth;
}
//===========================================================================
//
//

22
src/hwrenderer/textures/hw_material.h
View file

@ -25,23 +25,6 @@ enum
};
struct FTexCoordInfo
{
int mRenderWidth;
int mRenderHeight;
int mWidth;
FVector2 mScale;
FVector2 mTempScale;
bool mWorldPanning;
float FloatToTexU(float v) const { return v / mRenderWidth; }
float FloatToTexV(float v) const { return v / mRenderHeight; }
float RowOffset(float ofs) const;
float TextureOffset(float ofs) const;
float TextureAdjustWidth() const;
};
//===========================================================================
//
// this is the material class for OpenGL.
@ -130,7 +113,10 @@ public:
*r = mSpriteRect;
}
void GetTexCoordInfo(FTexCoordInfo *tci, float x, float y) const;
void GetTexCoordInfo(FTexCoordInfo *tci, float x, float y) const
{
tci->GetFromTexture(tex, x, y);
}
void GetTexCoordInfo(FTexCoordInfo *tci, side_t *side, int texpos) const
{

13
src/p_3dmidtex.cpp
View file

@ -232,13 +232,12 @@ bool P_GetMidTexturePosition(const line_t *line, int sideno, double *ptextop, do
FTexture * tex= TexMan(texnum);
if (!tex) return false;
double totalscale = fabs(side->GetTextureYScale(side_t::mid)) * tex->GetScaleY();
double y_offset = side->GetTextureYOffset(side_t::mid);
double textureheight = tex->GetHeight() / totalscale;
if (totalscale != 1. && !tex->bWorldPanning)
{
y_offset /= totalscale;
}
FTexCoordInfo tci;
// We only need the vertical positioning info here.
tci.GetFromTexture(tex, 1., (float)side->GetTextureYScale(side_t::mid));
double y_offset = tci.RowOffset((float)side->GetTextureYOffset(side_t::mid));
double textureheight = tci.mRenderHeight;
if(line->flags & ML_DONTPEGBOTTOM)
{

116
src/textures/texture.cpp
View file

@ -1543,3 +1543,119 @@ CCMD (printspans)
#endif
//===========================================================================
//
// Coordinate helper.
// The only reason this is even needed is that many years ago someone
// was convinced that having per-texel panning on walls was a good idea.
// If it wasn't for this relatively useless feature the entire positioning
// code for wall textures could be a lot simpler.
//
//===========================================================================
//===========================================================================
//
//
//
//===========================================================================
float FTexCoordInfo::RowOffset(float rowoffset) const
{
float tscale = fabs(mTempScale.Y);
float scale = fabs(mScale.Y);
if (tscale == 1.f)
{
if (scale == 1.f || mWorldPanning) return rowoffset;
else return rowoffset / scale;
}
else
{
if (mWorldPanning) return rowoffset / tscale;
else return rowoffset / scale;
}
}
//===========================================================================
//
//
//
//===========================================================================
float FTexCoordInfo::TextureOffset(float textureoffset) const
{
float tscale = fabs(mTempScale.X);
float scale = fabs(mScale.X);
if (tscale == 1.f)
{
if (scale == 1.f || mWorldPanning) return textureoffset;
else return textureoffset / scale;
}
else
{
if (mWorldPanning) return textureoffset / tscale;
else return textureoffset / scale;
}
}
//===========================================================================
//
// Returns the size for which texture offset coordinates are used.
//
//===========================================================================
float FTexCoordInfo::TextureAdjustWidth() const
{
if (mWorldPanning)
{
float tscale = fabs(mTempScale.X);
if (tscale == 1.f) return (float)mRenderWidth;
else return mWidth / fabs(tscale);
}
else return (float)mWidth;
}
//===========================================================================
//
// Retrieve texture coordinate info for per-wall scaling
//
//===========================================================================
void FTexCoordInfo::GetFromTexture(FTexture *tex, float x, float y)
{
if (x == 1.f)
{
mRenderWidth = tex->GetScaledWidth();
mScale.X = (float)tex->Scale.X;
mTempScale.X = 1.f;
}
else
{
float scale_x = x * (float)tex->Scale.X;
mRenderWidth = xs_CeilToInt(tex->GetWidth() / scale_x);
mScale.X = scale_x;
mTempScale.X = x;
}
if (y == 1.f)
{
mRenderHeight = tex->GetScaledHeight();
mScale.Y = (float)tex->Scale.Y;
mTempScale.Y = 1.f;
}
else
{
float scale_y = y * (float)tex->Scale.Y;
mRenderHeight = xs_CeilToInt(tex->GetHeight() / scale_y);
mScale.Y = scale_y;
mTempScale.Y = y;
}
if (tex->bHasCanvas)
{
mScale.Y = -mScale.Y;
mRenderHeight = -mRenderHeight;
}
mWorldPanning = tex->bWorldPanning;
mWidth = tex->GetWidth();
}

19
src/textures/textures.h
View file

@ -211,6 +211,7 @@ enum FTextureFormat : uint32_t
TEX_Count
};
// Base texture class
class FTexture
{
@ -802,6 +803,24 @@ public:
extern FTextureManager TexMan;
struct FTexCoordInfo
{
int mRenderWidth;
int mRenderHeight;
int mWidth;
FVector2 mScale;
FVector2 mTempScale;
bool mWorldPanning;
float FloatToTexU(float v) const { return v / mRenderWidth; }
float FloatToTexV(float v) const { return v / mRenderHeight; }
float RowOffset(float ofs) const;
float TextureOffset(float ofs) const;
float TextureAdjustWidth() const;
void GetFromTexture(FTexture *tex, float x, float y);
};
#endif