FSoftwareTexture *RenderPolySprite::GetSpriteTexture(AActor *thing, /*out*/ bool &flipX)
{
const auto &viewpoint = PolyRenderer::Instance()->Viewpoint;
flipX = false;
if (thing->renderflags & RF_FLATSPRITE)
return nullptr; // do not draw flat sprites.
if (thing->picnum.isValid())
{
FTexture *ttex = TexMan.GetPalettedTexture(thing->picnum, true);
if (!ttex || !ttex->isValid())
{
return nullptr;
}
FSoftwareTexture *tex = ttex->GetSoftwareTexture();
if (ttex->GetRotations() != 0xFFFF)
{
// choose a different rotation based on player view
spriteframe_t *sprframe = &SpriteFrames[ttex->GetRotations()];
DVector3 pos = thing->InterpolatedPosition(viewpoint.TicFrac);
pos.Z += thing->GetBobOffset(viewpoint.TicFrac);
DAngle ang = (pos - viewpoint.Pos).Angle();
angle_t rot;
if (sprframe->Texture[0] == sprframe->Texture[1])
{
rot = (ang - thing->Angles.Yaw + 45.0 / 2 * 9).BAMs() >> 28;
}
void DBaseDecal::Spread (const FDecalTemplate *tpl, side_t *wall, fixed_t x, fixed_t y, fixed_t z, F3DFloor * ffloor)
{
FTexture *tex;
vertex_t *v1;
fixed_t rorg, ldx, ldy;
GetWallStuff (wall, v1, ldx, ldy);
rorg = Length (x - v1->x, y - v1->y);
tex = TexMan[PicNum];
int dwidth = tex->GetWidth ();
DecalWidth = dwidth * ScaleX;
DecalLeft = tex->LeftOffset * ScaleX;
DecalRight = DecalWidth - DecalLeft;
SpreadSource = this;
SpreadTemplate = tpl;
SpreadZ = z;
// Try spreading left first
SpreadLeft (rorg - DecalLeft, v1, wall, ffloor);
SpreadStack.Clear ();
// Then try spreading right
SpreadRight (rorg + DecalRight, wall,
Length (wall->linedef->dx, wall->linedef->dy), ffloor);
SpreadStack.Clear ();
}
static void DrawHudText(FFont *font, int color, char * text, int x, int y, int trans=0xc000)
{
int zerowidth;
FTexture *tex_zero = font->GetChar('0', &zerowidth);
x+=zerowidth/2;
for(int i=0;text[i];i++)
{
int width;
FTexture *texc = font->GetChar(text[i], &width);
if (texc != NULL)
{
double offset = texc->GetScaledTopOffsetDouble()
- tex_zero->GetScaledTopOffsetDouble()
+ tex_zero->GetScaledHeightDouble();
screen->DrawChar(font, color, x, y, text[i],
DTA_KeepRatio, true,
DTA_VirtualWidth, hudwidth, DTA_VirtualHeight, hudheight, DTA_Alpha, trans,
DTA_LeftOffset, width/2, DTA_TopOffsetF, offset,
/*DTA_CenterBottomOffset, 1,*/ TAG_DONE);
}
x += zerowidth;
}
}
static void DrawOneWeapon(player_t * CPlayer, int x, int & y, AWeapon * weapon)
{
int trans;
// Powered up weapons and inherited sister weapons are not displayed.
if (weapon->WeaponFlags & WIF_POWERED_UP) return;
if (weapon->SisterWeapon && weapon->IsKindOf(weapon->SisterWeapon->GetClass())) return;
trans=0x6666;
if (CPlayer->ReadyWeapon)
{
if (weapon==CPlayer->ReadyWeapon || weapon==CPlayer->ReadyWeapon->SisterWeapon) trans=0xd999;
}
FTextureID picnum = GetInventoryIcon(weapon, DI_ALTICONFIRST);
if (picnum.isValid())
{
FTexture * tex = TexMan[picnum];
int w = tex->GetWidth();
int h = tex->GetHeight();
int rh;
if (w>h) rh=8;
else rh=16,y-=8; // don't draw tall sprites too small!
DrawImageToBox(tex, x-24, y, 20, rh, trans);
y-=10;
}
}
FTexture* FResourceGroup::CreateTexture(const std::string& Name, int Width, int Height, void* Data, DXGI_FORMAT TextureFormat /*= DXGI_FORMAT_R8G8B8A8_UNORM*/, int bytesPerPixel /*= 4*/)
{
FTexture* Texture = new FTexture(GraphicsContext, Width, Height, Data, TextureFormat, bytesPerPixel);
Textures.AddResource(Name, Texture);
Texture->SetName(Name);
return Texture;
}
void DBaseDecal::Spread (const FDecalTemplate *tpl, side_t *wall, double x, double y, double z, F3DFloor * ffloor)
{
FTexture *tex;
vertex_t *v1;
double rorg, ldx, ldy;
GetWallStuff (wall, v1, ldx, ldy);
rorg = Length (x - v1->fX(), y - v1->fY());
if ((tex = TexMan[PicNum]) == NULL)
{
return;
}
int dwidth = tex->GetWidth ();
DecalWidth = dwidth * ScaleX;
DecalLeft = tex->LeftOffset * ScaleX;
DecalRight = DecalWidth - DecalLeft;
SpreadSource = this;
SpreadTemplate = tpl;
SpreadZ = z;
// Try spreading left first
SpreadLeft (rorg - DecalLeft, v1, wall, ffloor);
SpreadStack.Clear ();
// Then try spreading right
SpreadRight (rorg + DecalRight, wall,
Length (wall->linedef->Delta().X, wall->linedef->Delta().Y), ffloor);
SpreadStack.Clear ();
}
void FTextureManager::ParseCameraTexture(FScanner &sc)
{
const BITFIELD texflags = TEXMAN_Overridable | TEXMAN_TryAny | TEXMAN_ShortNameOnly;
int width, height;
int fitwidth, fitheight;
FString picname;
sc.MustGetString ();
picname = sc.String;
sc.MustGetNumber ();
width = sc.Number;
sc.MustGetNumber ();
height = sc.Number;
FTextureID picnum = CheckForTexture (picname, FTexture::TEX_Flat, texflags);
FTexture *viewer = new FCanvasTexture (picname, width, height);
if (picnum.Exists())
{
FTexture *oldtex = Texture(picnum);
fitwidth = oldtex->GetScaledWidth ();
fitheight = oldtex->GetScaledHeight ();
viewer->UseType = oldtex->UseType;
ReplaceTexture (picnum, viewer, true);
}
else
{
fitwidth = width;
fitheight = height;
// [GRB] No need for oldtex
viewer->UseType = FTexture::TEX_Wall;
AddTexture (viewer);
}
if (sc.GetString())
{
if (sc.Compare ("fit"))
{
sc.MustGetNumber ();
fitwidth = sc.Number;
sc.MustGetNumber ();
fitheight = sc.Number;
}
else
{
sc.UnGet ();
}
}
if (sc.GetString())
{
if (sc.Compare("WorldPanning"))
{
viewer->bWorldPanning = true;
}
else
{
sc.UnGet();
}
}
viewer->SetScaledSize(fitwidth, fitheight);
}
DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay, FDoorAnimation *anim, DAnimatedDoor::EADType type)
: DMovingCeiling (sec, false)
{
double topdist;
FTextureID picnum;
m_DoorAnim = anim;
m_Line1 = line;
m_Line2 = line;
for (auto l : sec->Lines)
{
if (l == line)
continue;
if (l->sidedef[0]->GetTexture(side_t::top) == line->sidedef[0]->GetTexture(side_t::top))
{
m_Line2 = l;
break;
}
}
auto &tex1 = m_Line1->sidedef[0]->textures;
tex1[side_t::mid].InitFrom(tex1[side_t::top]);
auto &tex2 = m_Line2->sidedef[0]->textures;
tex2[side_t::mid].InitFrom(tex2[side_t::top]);
picnum = tex1[side_t::top].texture;
// don't forget texture scaling here!
FTexture *tex = TexMan[picnum];
topdist = tex ? tex->GetScaledHeight() : 64;
topdist = m_Sector->ceilingplane.fD() - topdist * m_Sector->ceilingplane.fC();
m_Type = type;
m_Status = type == adClose? Waiting : Opening;
m_Speed = speed;
m_Delay = delay;
m_Timer = m_Speed;
m_Frame = 0;
m_SetBlocking1 = !!(m_Line1->flags & ML_BLOCKING);
m_SetBlocking2 = !!(m_Line2->flags & ML_BLOCKING);
m_Line1->flags |= ML_BLOCKING;
m_Line2->flags |= ML_BLOCKING;
m_BotDist = m_Sector->ceilingplane.fD();
m_Sector->MoveCeiling (2048., topdist, 1);
if (type == adOpenClose)
{
if (m_DoorAnim->OpenSound != NAME_None)
{
SN_StartSequence(m_Sector, CHAN_INTERIOR, m_DoorAnim->OpenSound, 1);
}
}
}
DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay)
: DMovingCeiling (sec)
{
fixed_t topdist;
FTextureID picnum;
// The DMovingCeiling constructor automatically sets up an interpolation for us.
// Stop it, since the ceiling is moving instantly here.
StopInterpolation();
m_WhichDoorIndex = P_FindSlidingDoorType (line->sidedef[0]->GetTexture(side_t::top));
if (m_WhichDoorIndex < 0)
{
Printf ("EV_SlidingDoor: Textures are not defined for sliding door!");
m_Status = Dead;
return;
}
m_Line1 = line;
m_Line2 = line;
for (int i = 0; i < sec->linecount; ++i)
{
if (sec->lines[i] == line)
continue;
if (sec->lines[i]->sidedef[0]->GetTexture(side_t::top) == line->sidedef[0]->GetTexture(side_t::top))
{
m_Line2 = sec->lines[i];
break;
}
}
picnum = m_Line1->sidedef[0]->GetTexture(side_t::top);
m_Line1->sidedef[0]->SetTexture(side_t::mid, picnum);
m_Line2->sidedef[0]->SetTexture(side_t::mid, picnum);
// don't forget texture scaling here!
FTexture *tex = TexMan[picnum];
topdist = tex ? tex->GetScaledHeight() : 64;
topdist = m_Sector->ceilingplane.d - topdist * m_Sector->ceilingplane.c;
m_Status = Opening;
m_Speed = speed;
m_Delay = delay;
m_Timer = m_Speed;
m_Frame = 0;
m_Line1->flags |= ML_BLOCKING;
m_Line2->flags |= ML_BLOCKING;
m_BotDist = m_Sector->ceilingplane.d;
MoveCeiling (2048*FRACUNIT, topdist, 1);
if (DoorAnimations[m_WhichDoorIndex].OpenSound != NAME_None)
{
SN_StartSequence (m_Sector, CHAN_INTERIOR, DoorAnimations[m_WhichDoorIndex].OpenSound, 1);
}
}
double GetBottomAlignOffset(FFont *font, int c)
{
int w;
FTexture *tex_zero = font->GetChar('0', CR_UNDEFINED, &w);
FTexture *texc = font->GetChar(c, CR_UNDEFINED, &w);
double offset = 0;
if (texc) offset += texc->GetDisplayTopOffsetDouble();
if (tex_zero) offset += -tex_zero->GetDisplayTopOffsetDouble() + tex_zero->GetDisplayHeightDouble();
return offset;
}
void DIntermissionScreenScroller::Drawer ()
{
FTexture *tex = TexMan[mFirstPic];
FTexture *tex2 = TexMan[mSecondPic];
if (mTicker >= mScrollDelay && mTicker < mScrollDelay + mScrollTime && tex != NULL && tex2 != NULL)
{
int fwidth = tex->GetScaledWidth();
int fheight = tex->GetScaledHeight();
double xpos1 = 0, ypos1 = 0, xpos2 = 0, ypos2 = 0;
switch (mScrollDir)
{
case SCROLL_Up:
ypos1 = double(mTicker - mScrollDelay) * fheight / mScrollTime;
ypos2 = ypos1 - fheight;
break;
case SCROLL_Down:
ypos1 = -double(mTicker - mScrollDelay) * fheight / mScrollTime;
ypos2 = ypos1 + fheight;
break;
case SCROLL_Left:
default:
xpos1 = double(mTicker - mScrollDelay) * fwidth / mScrollTime;
xpos2 = xpos1 - fwidth;
break;
case SCROLL_Right:
xpos1 = -double(mTicker - mScrollDelay) * fwidth / mScrollTime;
xpos2 = xpos1 + fwidth;
break;
}
screen->DrawTexture (tex, xpos1, ypos1,
DTA_VirtualWidth, fwidth,
DTA_VirtualHeight, fheight,
DTA_Masked, false,
TAG_DONE);
screen->DrawTexture (tex2, xpos2, ypos2,
DTA_VirtualWidth, fwidth,
DTA_VirtualHeight, fheight,
DTA_Masked, false,
TAG_DONE);
screen->FillBorder (NULL);
mBackground = mSecondPic;
}
else
{
Super::Drawer();
}
}
int WI_drawNum (int x, int y, int n, int digits, bool leadingzeros = true)
{
// if non-number, do not draw it
if (n == 1994)
return 0;
int fontwidth = num[3]->GetWidth();
int xofs;
char text[8];
char *text_p;
if (leadingzeros)
{
sprintf (text, "%07d", n);
}
else
{
sprintf (text, "%7d", n);
if (digits < 0)
{
text_p = strrchr (text, ' ');
digits = (text_p == NULL) ? 7 : 6 - (int)(text_p - text);
x -= digits * fontwidth;
}
}
text_p = strchr (text, '-');
if (text_p == NULL || text_p - text > 7 - digits)
{
text_p = text + 7 - digits;
}
xofs = x;
if (*text_p == '-')
{
x -= fontwidth;
WI_DrawCharPatch (wiminus, x, y);
}
// draw the new number
while (*text_p)
{
if (*text_p >= '0' && *text_p <= '9')
{
FTexture *p = num[*text_p - '0'];
WI_DrawCharPatch (p, xofs + (fontwidth - p->GetWidth())/2, y);
}
text_p++;
xofs += fontwidth;
}
return x;
}
// Examines the lump contents to decide what type of texture to create,
// and creates the texture.
FTexture * FTexture::CreateTexture (int lumpnum, int usetype)
{
static TexCreateInfo CreateInfo[]={
{ IMGZTexture_TryCreate, TEX_Any },
{ PNGTexture_TryCreate, TEX_Any },
{ JPEGTexture_TryCreate, TEX_Any },
{ DDSTexture_TryCreate, TEX_Any },
{ PCXTexture_TryCreate, TEX_Any },
{ TGATexture_TryCreate, TEX_Any },
{ RawPageTexture_TryCreate, TEX_MiscPatch },
{ FlatTexture_TryCreate, TEX_Flat },
{ PatchTexture_TryCreate, TEX_Any },
{ EmptyTexture_TryCreate, TEX_Any },
{ AutomapTexture_TryCreate, TEX_MiscPatch },
};
if (lumpnum == -1) return NULL;
FWadLump data = Wads.OpenLumpNum (lumpnum);
for(size_t i = 0; i < countof(CreateInfo); i++)
{
if ((CreateInfo[i].usetype == usetype || CreateInfo[i].usetype == TEX_Any))
{
FTexture * tex = CreateInfo[i].TryCreate(data, lumpnum);
if (tex != NULL)
{
tex->UseType = usetype;
if (usetype == FTexture::TEX_Flat)
{
int w = tex->GetWidth();
int h = tex->GetHeight();
// Auto-scale flats with dimensions 128x128 and 256x256.
// In hindsight, a bad idea, but RandomLag made it sound better than it really is.
// Now we're stuck with this stupid behaviour.
if (w==128 && h==128)
{
tex->xScale = tex->yScale = 2*FRACUNIT;
tex->bWorldPanning = true;
}
else if (w==256 && h==256)
{
tex->xScale = tex->yScale = 4*FRACUNIT;
tex->bWorldPanning = true;
}
}
return tex;
}
}
}
return NULL;
}
DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay, FDoorAnimation *anim)
: DMovingCeiling (sec)
{
fixed_t topdist;
FTextureID picnum;
// The DMovingCeiling constructor automatically sets up an interpolation for us.
// Stop it, since the ceiling is moving instantly here.
StopInterpolation();
m_DoorAnim = anim;
m_Line1 = line;
m_Line2 = line;
for (int i = 0; i < sec->linecount; ++i)
{
if (sec->lines[i] == line)
continue;
if (sec->lines[i]->sidedef[0]->GetTexture(side_t::top) == line->sidedef[0]->GetTexture(side_t::top))
{
m_Line2 = sec->lines[i];
break;
}
}
picnum = m_Line1->sidedef[0]->GetTexture(side_t::top);
m_Line1->sidedef[0]->SetTexture(side_t::mid, picnum);
m_Line2->sidedef[0]->SetTexture(side_t::mid, picnum);
// don't forget texture scaling here!
FTexture *tex = TexMan[picnum];
topdist = tex ? tex->GetScaledHeight() : 64;
topdist = m_Sector->ceilingplane.d - topdist * m_Sector->ceilingplane.c;
m_Status = Opening;
m_Speed = speed;
m_Delay = delay;
m_Timer = m_Speed;
m_Frame = 0;
m_SetBlocking1 = !!(m_Line1->flags & ML_BLOCKING);
m_SetBlocking2 = !!(m_Line2->flags & ML_BLOCKING);
m_Line1->flags |= ML_BLOCKING;
m_Line2->flags |= ML_BLOCKING;
m_BotDist = m_Sector->ceilingplane.d;
MoveCeiling (2048*FRACUNIT, topdist, 1);
if (m_DoorAnim->OpenSound != NAME_None)
{
SN_StartSequence (m_Sector, CHAN_INTERIOR, m_DoorAnim->OpenSound, 1);
}
}
static void DrawOneWeapon(player_t * CPlayer, int x, int & y, AWeapon * weapon)
{
int trans;
FTextureID picnum;
// Powered up weapons and inherited sister weapons are not displayed.
if (weapon->WeaponFlags & WIF_POWERED_UP) return;
if (weapon->SisterWeapon && weapon->IsKindOf(RUNTIME_TYPE(weapon->SisterWeapon))) return;
trans=0x6666;
if (CPlayer->ReadyWeapon)
{
if (weapon==CPlayer->ReadyWeapon || weapon==CPlayer->ReadyWeapon->SisterWeapon) trans=0xd999;
}
FState * state=NULL, *ReadyState;
FTextureID AltIcon = GetHUDIcon(weapon->GetClass());
picnum = !AltIcon.isNull()? AltIcon : weapon->Icon;
if (picnum.isNull())
{
if (weapon->SpawnState && weapon->SpawnState->sprite!=0)
{
state = weapon->SpawnState;
}
// no spawn state - now try the ready state
else if ((ReadyState = weapon->FindState(NAME_Ready)) && ReadyState->sprite!=0)
{
state = ReadyState;
}
if (state && (unsigned)state->sprite < (unsigned)sprites.Size ())
{
spritedef_t * sprdef = &sprites[state->sprite];
spriteframe_t * sprframe = &SpriteFrames[sprdef->spriteframes + state->GetFrame()];
picnum = sprframe->Texture[0];
}
}
if (picnum.isValid())
{
FTexture * tex = TexMan[picnum];
int w = tex->GetWidth();
int h = tex->GetHeight();
int rh;
if (w>h) rh=8;
else rh=16,y-=8; // don't draw tall sprites too small!
DrawImageToBox(tex, x-24, y, 20, rh, trans);
y-=10;
}
}
//==========================================================================
//
//
//
//==========================================================================
bool HWDrawInfo::DoOneSectorLower(subsector_t * subsec, float Planez, area_t in_area)
{
// Is there a one-sided wall in this subsector?
// Do this first to avoid unnecessary recursion
for (uint32_t i = 0; i < subsec->numlines; i++)
{
if (subsec->firstline[i].backsector == NULL) return false;
if (subsec->firstline[i].PartnerSeg == NULL) return false;
}
for (uint32_t i = 0; i < subsec->numlines; i++)
{
seg_t * seg = subsec->firstline + i;
subsector_t * backsub = seg->PartnerSeg->Subsector;
// already checked?
if (backsub->validcount == validcount) continue;
backsub->validcount = validcount;
if (seg->frontsector != seg->backsector && seg->linedef)
{
// Note: if this is a real line between sectors
// we can be sure that render_sector is the real sector!
sector_t * sec = hw_FakeFlat(seg->backsector, in_area, true);
// Don't bother with slopes
if (sec->floorplane.isSlope()) return false;
// Is the neighboring floor higher than the desired height?
if (sec->GetPlaneTexZ(sector_t::floor) > Planez)
{
// todo: check for missing textures.
return false;
}
// This is an exact height match which means we don't have to do any further checks for this sector
if (sec->GetPlaneTexZ(sector_t::floor) == Planez)
{
// If there's a texture abort
FTexture * tex = TexMan.GetTexture(seg->sidedef->GetTexture(side_t::bottom));
if (!tex || !tex->isValid()) continue;
else return false;
}
}
if (!DoOneSectorLower(backsub, Planez, in_area)) return false;
}
// all checked ok. This sector is part of the current fake plane
HandledSubsectors.Push(subsec);
return 1;
}
//==========================================================================
//
// Checks whether a sprite should be affected by a glow
//
//==========================================================================
int gl_CheckSpriteGlow(FTextureID floorpic, int lightlevel, fixed_t floordiff)
{
FTexture *tex = TexMan[floorpic];
if (tex != NULL && tex->isGlowing())
{
if (floordiff < tex->gl_info.GlowHeight*FRACUNIT && tex->gl_info.GlowHeight != 0)
{
int maxlight=(255+lightlevel)>>1;
fixed_t lightfrac = floordiff / tex->gl_info.GlowHeight;
if (lightfrac<0) lightfrac=0;
lightlevel= (lightfrac*lightlevel + maxlight*(FRACUNIT-lightfrac))>>FRACBITS;
}
}
//==========================================================================
//
// Checks whether a sprite should be affected by a glow
//
//==========================================================================
int gl_CheckSpriteGlow(sector_t *sec, int lightlevel, int x, int y, int z)
{
FTextureID floorpic = sec->GetTexture(sector_t::floor);
FTexture *tex = TexMan[floorpic];
if (tex != NULL && tex->isGlowing())
{
fixed_t floordiff = z - sec->floorplane.ZatPoint(x, y);
if (floordiff < tex->gl_info.GlowHeight*FRACUNIT && tex->gl_info.GlowHeight != 0)
{
int maxlight = (255+lightlevel)>>1;
fixed_t lightfrac = floordiff / tex->gl_info.GlowHeight;
if (lightfrac<0) lightfrac=0;
lightlevel= (lightfrac*lightlevel + maxlight*(FRACUNIT-lightfrac))>>FRACBITS;
}
static inline void CheckShortestTex (FTextureID texnum, fixed_t &minsize)
{
if (texnum.isValid() || (texnum.isNull() && (i_compatflags & COMPATF_SHORTTEX)))
{
FTexture *tex = TexMan[texnum];
if (tex != NULL)
{
fixed_t h = tex->GetScaledHeight()<<FRACBITS;
if (h < minsize)
{
minsize = h;
}
}
}
}
void FSingleLumpFont::CreateFontFromPic (int picnum)
{
FTexture *pic = TexMan[picnum];
FontHeight = pic->GetHeight ();
SpaceWidth = pic->GetWidth ();
GlobalKerning = 0;
FirstChar = LastChar = 'A';
Chars = new CharData[1];
Chars->Pic = pic;
// Only one color range. Don't bother with the others.
ActiveColors = 0;
}
void FManaBar::Unload ()
{
if (VialPic != 0)
{
VialPic->Unload ();
}
}
void FTextureManager::AddHiresTextures (int wadnum)
{
int firsttx = Wads.GetFirstLump(wadnum);
int lasttx = Wads.GetLastLump(wadnum);
char name[9];
TArray<FTextureID> tlist;
if (firsttx == -1 || lasttx == -1)
{
return;
}
name[8] = 0;
for (;firsttx <= lasttx; ++firsttx)
{
if (Wads.GetLumpNamespace(firsttx) == ns_hires)
{
Wads.GetLumpName (name, firsttx);
if (Wads.CheckNumForName (name, ns_hires) == firsttx)
{
tlist.Clear();
int amount = ListTextures(name, tlist);
if (amount == 0)
{
// A texture with this name does not yet exist
FTexture * newtex = FTexture::CreateTexture (firsttx, FTexture::TEX_Any);
if (newtex != NULL)
{
newtex->UseType=FTexture::TEX_Override;
AddTexture(newtex);
}
}
else
{
for(unsigned int i = 0; i < tlist.Size(); i++)
{
FTexture * newtex = FTexture::CreateTexture (firsttx, FTexture::TEX_Any);
if (newtex != NULL)
{
FTexture * oldtex = Textures[tlist[i].GetIndex()].Texture;
// Replace the entire texture and adjust the scaling and offset factors.
newtex->bWorldPanning = true;
newtex->SetScaledSize(oldtex->GetScaledWidth(), oldtex->GetScaledHeight());
newtex->LeftOffset = FixedMul(oldtex->GetScaledLeftOffset(), newtex->xScale);
newtex->TopOffset = FixedMul(oldtex->GetScaledTopOffset(), newtex->yScale);
ReplaceTexture(tlist[i], newtex, true);
}
}
}
//StartScreen->Progress();
}
}
}
}
void DMenu::Drawer ()
{
if (this == DMenu::CurrentMenu && BackbuttonAlpha > 0 && m_show_backbutton >= 0 && m_use_mouse)
{
FTexture *tex = TexMan(gameinfo.mBackButton);
int w = tex->GetScaledWidth() * CleanXfac;
int h = tex->GetScaledHeight() * CleanYfac;
int x = (!(m_show_backbutton&1))? 0:screen->GetWidth() - w;
int y = (!(m_show_backbutton&2))? 0:screen->GetHeight() - h;
if (mBackbuttonSelected && (mMouseCapture || m_use_mouse == 1))
{
screen->DrawTexture(tex, x, y, DTA_CleanNoMove, true, DTA_ColorOverlay, MAKEARGB(40, 255,255,255), TAG_DONE);
}
else
{
screen->DrawTexture(tex, x, y, DTA_CleanNoMove, true, DTA_AlphaF, BackbuttonAlpha, TAG_DONE);
}
}
}
const BYTE *FFontChar1::GetColumn (unsigned int column, const Span **spans_out)
{
if (Pixels == NULL)
{
MakeTexture ();
}
BaseTexture->GetColumn(column, spans_out);
return Pixels + column*Height;
}
VulkanDescriptorSet *VkHardwareTexture::GetDescriptorSet(const FMaterialState &state)
{
FMaterial *mat = state.mMaterial;
FTexture *tex = state.mMaterial->tex;
int clampmode = state.mClampMode;
int translation = state.mTranslation;
if (tex->UseType == ETextureType::SWCanvas) clampmode = CLAMP_NOFILTER;
if (tex->isHardwareCanvas()) clampmode = CLAMP_CAMTEX;
else if ((tex->isWarped() || tex->shaderindex >= FIRST_USER_SHADER) && clampmode <= CLAMP_XY) clampmode = CLAMP_NONE;
// Textures that are already scaled in the texture lump will not get replaced by hires textures.
int flags = state.mMaterial->isExpanded() ? CTF_Expand : (gl_texture_usehires && !tex->isScaled() && clampmode <= CLAMP_XY) ? CTF_CheckHires : 0;
if (tex->isHardwareCanvas()) static_cast<FCanvasTexture*>(tex)->NeedUpdate();
for (auto &set : mDescriptorSets)
{
if (set.descriptor && set.clampmode == clampmode && set.flags == flags) return set.descriptor.get();
}
int numLayers = mat->GetLayers();
auto fb = GetVulkanFrameBuffer();
auto descriptor = fb->GetRenderPassManager()->AllocateTextureDescriptorSet(numLayers);
descriptor->SetDebugName("VkHardwareTexture.mDescriptorSets");
VulkanSampler *sampler = fb->GetSamplerManager()->Get(clampmode);
WriteDescriptors update;
update.addCombinedImageSampler(descriptor.get(), 0, GetImage(tex, translation, flags)->View.get(), sampler, mImage.Layout);
for (int i = 1; i < numLayers; i++)
{
FTexture *layer;
auto systex = static_cast<VkHardwareTexture*>(mat->GetLayer(i, 0, &layer));
update.addCombinedImageSampler(descriptor.get(), i, systex->GetImage(layer, 0, mat->isExpanded() ? CTF_Expand : 0)->View.get(), sampler, systex->mImage.Layout);
}
update.updateSets(fb->device);
mDescriptorSets.emplace_back(clampmode, flags, std::move(descriptor));
return mDescriptorSets.back().descriptor.get();
}
void FManaBar::MakeTexture ()
{
int run = 22 - VialLevel;
BYTE color0 = GPalette.Remap[0];
NeedRefresh = false;
VialPic->CopyToBlock (Pixels, 5, 24, 0, 0);
memset (Pixels + 25, color0, run);
memset (Pixels + 25+24, color0, run);
memset (Pixels + 25+24+24, color0, run);
}
void FFontChar1::MakeTexture ()
{
// Make the texture as normal, then remap it so that all the colors
// are at the low end of the palette
Pixels = new BYTE[Width*Height];
const BYTE *pix = BaseTexture->GetPixels();
for (int x = 0; x < Width*Height; ++x)
{
Pixels[x] = SourceRemap[pix[x]];
}
}
bool DMenu::MouseEventBack(int type, int x, int y)
{
if (m_show_backbutton >= 0)
{
FTexture *tex = TexMan(gameinfo.mBackButton);
if (tex != NULL)
{
if (m_show_backbutton&1) x -= screen->GetWidth() - tex->GetScaledWidth() * CleanXfac;
if (m_show_backbutton&2) y -= screen->GetHeight() - tex->GetScaledHeight() * CleanYfac;
mBackbuttonSelected = ( x >= 0 && x < tex->GetScaledWidth() * CleanXfac &&
y >= 0 && y < tex->GetScaledHeight() * CleanYfac);
if (mBackbuttonSelected && type == MOUSE_Release)
{
if (m_use_mouse == 2) mBackbuttonSelected = false;
MenuEvent(MKEY_Back, true);
}
return mBackbuttonSelected;
}
}
return false;
}
bool RenderPolySprite::GetLine(AActor *thing, DVector2 &left, DVector2 &right)
{
const auto &viewpoint = PolyRenderer::Instance()->Viewpoint;
DVector3 pos = thing->InterpolatedPosition(viewpoint.TicFrac);
bool flipTextureX = false;
FTexture *tex = GetSpriteTexture(thing, flipTextureX);
if (tex == nullptr)
return false;
DVector2 spriteScale = thing->Scale;
double thingxscalemul = spriteScale.X / tex->Scale.X;
double thingyscalemul = spriteScale.Y / tex->Scale.Y;
double spriteWidth = thingxscalemul * tex->GetWidth();
double spriteHeight = thingyscalemul * tex->GetHeight();
double offsetX;
if (flipTextureX)
offsetX = (tex->GetWidth() - tex->GetLeftOffsetPo()) * thingxscalemul;
else
offsetX = tex->GetLeftOffsetPo() * thingxscalemul;
left = DVector2(pos.X - viewpoint.Sin * offsetX, pos.Y + viewpoint.Cos * offsetX);
right = DVector2(left.X + viewpoint.Sin * spriteWidth, left.Y - viewpoint.Cos * spriteWidth);
return true;
}
void DrawFullScreenStuff ()
{
// Draw health
DrINumberOuter (CPlayer->health, 4, -10, false, 7);
screen->DrawTexture (Images[imgMEDI], 14, -17,
DTA_HUDRules, HUD_Normal,
DTA_CenterBottomOffset, true,
TAG_DONE);
// Draw armor
ABasicArmor *armor = CPlayer->mo->FindInventory<ABasicArmor>();
if (armor != NULL && armor->Amount != 0)
{
DrINumberOuter (armor->Amount, 35, -10, false, 7);
screen->DrawTexture (TexMan(armor->Icon), 45, -17,
DTA_HUDRules, HUD_Normal,
DTA_CenterBottomOffset, true,
TAG_DONE);
}
// Draw ammo
AAmmo *ammo1, *ammo2;
int ammocount1, ammocount2;
GetCurrentAmmo (ammo1, ammo2, ammocount1, ammocount2);
if (ammo1 != NULL)
{
// Draw primary ammo in the bottom-right corner
DrINumberOuter (ammo1->Amount, -23, -10, false, 7);
screen->DrawTexture (TexMan(ammo1->Icon), -14, -17,
DTA_HUDRules, HUD_Normal,
DTA_CenterBottomOffset, true,
TAG_DONE);
if (ammo2 != NULL)
{
// Draw secondary ammo just above the primary ammo
DrINumberOuter (ammo2->Amount, -23, -48, false, 7);
screen->DrawTexture (TexMan(ammo2->Icon), -14, -55,
DTA_HUDRules, HUD_Normal,
DTA_CenterBottomOffset, true,
TAG_DONE);
}
}
if (deathmatch)
{ // Draw frags (in DM)
DrBNumberOuterFont (CPlayer->fragcount, -44, 1);
}
// Draw inventory
if (CPlayer->inventorytics == 0)
{
if (CPlayer->InvSel != 0)
{
if (ItemFlash > 0)
{
FTexture *cursor = Images[CursorImage];
screen->DrawTexture (cursor, -28, -15,
DTA_HUDRules, HUD_Normal,
DTA_LeftOffset, cursor->GetWidth(),
DTA_TopOffset, cursor->GetHeight(),
DTA_Alpha, ItemFlash,
TAG_DONE);
}
DrINumberOuter (CPlayer->InvSel->Amount, -51, -10, false, 7);
screen->DrawTexture (TexMan(CPlayer->InvSel->Icon), -42, -17,
DTA_HUDRules, HUD_Normal,
DTA_CenterBottomOffset, true,
TAG_DONE);
}
}
else
{
CPlayer->InvFirst = ValidateInvFirst (6);
int i = 0;
AInventory *item;
if (CPlayer->InvFirst != NULL)
{
for (item = CPlayer->InvFirst; item != NULL && i < 6; item = item->NextInv(), ++i)
{
if (item == CPlayer->InvSel)
{
screen->DrawTexture (Images[CursorImage], -100+i*35, -21,
DTA_HUDRules, HUD_HorizCenter,
DTA_Alpha, TRANSLUC75,
TAG_DONE);
}
if (item->Icon != 0)
{
screen->DrawTexture (TexMan(item->Icon), -94 + i*35, -19,
DTA_HUDRules, HUD_HorizCenter,
TAG_DONE);
}
DrINumberOuter (item->Amount, -89 + i*35, -10, true, 7);
}
}
}
// Draw pop screen (log, keys, and status)
if (CurrentPop != POP_None && PopHeight < 0)
{
DrawPopScreen (screen->GetHeight());
}
}