From 84e94f2a32bb490656ef5146f21cd7f465462b1d Mon Sep 17 00:00:00 2001 From: Magnus Norddahl Date: Sun, 26 Mar 2017 18:55:23 +0200 Subject: [PATCH 1/3] - change softpoly psprite drawing to do exactly what the software renderer does --- src/polyrenderer/scene/poly_playersprite.cpp | 727 ++++++++++++------- src/polyrenderer/scene/poly_playersprite.h | 94 ++- 2 files changed, 541 insertions(+), 280 deletions(-) diff --git a/src/polyrenderer/scene/poly_playersprite.cpp b/src/polyrenderer/scene/poly_playersprite.cpp index 21db4b7cd..9920d2dc9 100644 --- a/src/polyrenderer/scene/poly_playersprite.cpp +++ b/src/polyrenderer/scene/poly_playersprite.cpp @@ -28,7 +28,6 @@ #include "poly_playersprite.h" #include "polyrenderer/poly_renderer.h" #include "d_player.h" -#include "swrenderer/viewport/r_viewport.h" #include "polyrenderer/scene/poly_light.h" EXTERN_CVAR(Bool, r_drawplayersprites) @@ -44,6 +43,14 @@ void RenderPolyPlayerSprites::Render() const auto &viewpoint = PolyRenderer::Instance()->Viewpoint; + int i; + int lightnum; + DPSprite* psp; + DPSprite* weapon; + sector_t* sec = nullptr; + int floorlight, ceilinglight; + F3DFloor *rover; + if (!r_drawplayersprites || !viewpoint.camera || !viewpoint.camera->player || @@ -51,282 +58,427 @@ void RenderPolyPlayerSprites::Render() (r_deathcamera && viewpoint.camera->health <= 0)) return; - float bobx, boby; - P_BobWeapon(viewpoint.camera->player, &bobx, &boby, viewpoint.TicFrac); - - // Interpolate the main weapon layer once so as to be able to add it to other layers. - double wx, wy; - DPSprite *weapon = viewpoint.camera->player->FindPSprite(PSP_WEAPON); - if (weapon) + FDynamicColormap *basecolormap; + PolyCameraLight *cameraLight = PolyCameraLight::Instance(); + if (cameraLight->FixedLightLevel() < 0 && viewpoint.sector->e && viewpoint.sector->e->XFloor.lightlist.Size()) { - if (weapon->firstTic) + for (i = viewpoint.sector->e->XFloor.lightlist.Size() - 1; i >= 0; i--) { - wx = weapon->x; - wy = weapon->y; + if (viewpoint.Pos.Z <= viewpoint.sector->e->XFloor.lightlist[i].plane.Zat0()) + { + rover = viewpoint.sector->e->XFloor.lightlist[i].caster; + if (rover) + { + if (rover->flags & FF_DOUBLESHADOW && viewpoint.Pos.Z <= rover->bottom.plane->Zat0()) + break; + sec = rover->model; + if (rover->flags & FF_FADEWALLS) + basecolormap = GetColorTable(sec->Colormap, sec->SpecialColors[sector_t::sprites], true); + else + basecolormap = GetColorTable(viewpoint.sector->e->XFloor.lightlist[i].extra_colormap, sec->SpecialColors[sector_t::sprites], true); + } + break; + } + } + if (!sec) + { + sec = viewpoint.sector; + basecolormap = GetColorTable(sec->Colormap, sec->SpecialColors[sector_t::sprites], true); + } + floorlight = ceilinglight = sec->lightlevel; + } + else + { // This used to use camera->Sector but due to interpolation that can be incorrect + // when the interpolated viewpoint is in a different sector than the camera. + //sec = FakeFlat(viewpoint.sector, &tempsec, &floorlight, &ceilinglight, nullptr, 0, 0, 0, 0); + // Softpoly has no FakeFlat (its FAKE! Everything is FAKE in Doom. Sigh. Might as well call it FooFlat!) + sec = viewpoint.camera->Sector; + floorlight = ceilinglight = sec->lightlevel; + + // [RH] set basecolormap + basecolormap = GetColorTable(sec->Colormap, sec->SpecialColors[sector_t::sprites], true); + } + + // [RH] set foggy flag + bool foggy = (level.fadeto || basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE)); + + // get light level + lightnum = ((floorlight + ceilinglight) >> 1) + (foggy ? 0 : viewpoint.extralight << 4); + int spriteshade = LightLevelToShade(lightnum, foggy) - 24 * FRACUNIT; + + if (viewpoint.camera->player != nullptr) + { + double wx, wy; + float bobx, boby; + + P_BobWeapon(viewpoint.camera->player, &bobx, &boby, viewpoint.TicFrac); + + // Interpolate the main weapon layer once so as to be able to add it to other layers. + if ((weapon = viewpoint.camera->player->FindPSprite(PSP_WEAPON)) != nullptr) + { + if (weapon->firstTic) + { + wx = weapon->x; + wy = weapon->y; + } + else + { + wx = weapon->oldx + (weapon->x - weapon->oldx) * viewpoint.TicFrac; + wy = weapon->oldy + (weapon->y - weapon->oldy) * viewpoint.TicFrac; + } } else { - wx = weapon->oldx + (weapon->x - weapon->oldx) * viewpoint.TicFrac; - wy = weapon->oldy + (weapon->y - weapon->oldy) * viewpoint.TicFrac; + wx = 0; + wy = 0; } - } - else - { - wx = 0; - wy = 0; - } - for (DPSprite *sprite = viewpoint.camera->player->psprites; sprite != nullptr; sprite = sprite->GetNext()) - { - // [RH] Don't draw the targeter's crosshair if the player already has a crosshair set. - // It's possible this psprite's caller is now null but the layer itself hasn't been destroyed - // because it didn't tick yet (if we typed 'take all' while in the console for example). - // In this case let's simply not draw it to avoid crashing. - if ((sprite->GetID() != PSP_TARGETCENTER || CrosshairImage == nullptr) && sprite->GetCaller() != nullptr) + // add all active psprites + psp = viewpoint.camera->player->psprites; + while (psp) { - RenderSprite(sprite, viewpoint.camera, bobx, boby, wx, wy, viewpoint.TicFrac); + // [RH] Don't draw the targeter's crosshair if the player already has a crosshair set. + // It's possible this psprite's caller is now null but the layer itself hasn't been destroyed + // because it didn't tick yet (if we typed 'take all' while in the console for example). + // In this case let's simply not draw it to avoid crashing. + + if ((psp->GetID() != PSP_TARGETCENTER || CrosshairImage == nullptr) && psp->GetCaller() != nullptr) + { + RenderSprite(psp, viewpoint.camera, bobx, boby, wx, wy, viewpoint.TicFrac, spriteshade, basecolormap, foggy); + } + + psp = psp->GetNext(); } } } void RenderPolyPlayerSprites::RenderRemainingSprites() { - for (auto &sprite : ScreenSprites) - sprite.Render(); - ScreenSprites.clear(); + for (const PolyHWAccelPlayerSprite &sprite : AcceleratedSprites) + { + screen->DrawTexture(sprite.pic, + viewwindowx + sprite.x1, + viewwindowy + viewheight / 2 - sprite.texturemid * sprite.yscale - 0.5, + DTA_DestWidthF, FIXED2DBL(sprite.pic->GetWidth() * sprite.xscale), + DTA_DestHeightF, sprite.pic->GetHeight() * sprite.yscale, + DTA_TranslationIndex, sprite.Translation, + DTA_FlipX, sprite.flip, + DTA_TopOffset, 0, + DTA_LeftOffset, 0, + DTA_ClipLeft, viewwindowx, + DTA_ClipTop, viewwindowy, + DTA_ClipRight, viewwindowx + viewwidth, + DTA_ClipBottom, viewwindowy + viewheight, + DTA_Alpha, sprite.Alpha, + DTA_RenderStyle, sprite.RenderStyle, + DTA_FillColor, sprite.FillColor, + DTA_SpecialColormap, sprite.special, + DTA_ColorOverlay, sprite.overlay.d, + DTA_ColormapStyle, sprite.usecolormapstyle ? &sprite.colormapstyle : nullptr, + TAG_DONE); + } + + AcceleratedSprites.Clear(); } -void RenderPolyPlayerSprites::RenderSprite(DPSprite *sprite, AActor *owner, float bobx, float boby, double wx, double wy, double ticfrac) +void RenderPolyPlayerSprites::RenderSprite(DPSprite *pspr, AActor *owner, float bobx, float boby, double wx, double wy, double ticfrac, int spriteshade, FDynamicColormap *basecolormap, bool foggy) { + double tx; + int x1; + int x2; + double sx, sy; + spritedef_t* sprdef; + spriteframe_t* sprframe; + FTextureID picnum; + uint16_t flip; + FTexture* tex; + bool noaccel; + double alpha = owner->Alpha; + // decide which patch to use - if ((unsigned)sprite->GetSprite() >= (unsigned)sprites.Size()) + if ((unsigned)pspr->GetSprite() >= (unsigned)sprites.Size()) { - DPrintf(DMSG_ERROR, "RenderPlayerSprite: invalid sprite number %i\n", sprite->GetSprite()); + DPrintf(DMSG_ERROR, "R_DrawPSprite: invalid sprite number %i\n", pspr->GetSprite()); + return; + } + sprdef = &sprites[pspr->GetSprite()]; + if (pspr->GetFrame() >= sprdef->numframes) + { + DPrintf(DMSG_ERROR, "R_DrawPSprite: invalid sprite frame %i : %i\n", pspr->GetSprite(), pspr->GetFrame()); return; } - spritedef_t *def = &sprites[sprite->GetSprite()]; - if (sprite->GetFrame() >= def->numframes) - { - DPrintf(DMSG_ERROR, "RenderPlayerSprite: invalid sprite frame %i : %i\n", sprite->GetSprite(), sprite->GetFrame()); - return; - } + const auto &viewpoint = PolyRenderer::Instance()->Viewpoint; + const auto &viewwindow = PolyRenderer::Instance()->Viewwindow; + DCanvas *renderTarget = PolyRenderer::Instance()->RenderTarget; - spriteframe_t *frame = &SpriteFrames[def->spriteframes + sprite->GetFrame()]; - FTextureID picnum = frame->Texture[0]; - bool flip = (frame->Flip & 1) != 0; + sprframe = &SpriteFrames[sprdef->spriteframes + pspr->GetFrame()]; - FTexture *tex = TexMan(picnum); - if (tex->UseType == FTexture::TEX_Null) + picnum = sprframe->Texture[0]; + flip = sprframe->Flip & 1; + tex = TexMan(picnum); + + if (tex->UseType == FTexture::TEX_Null || pspr->RenderStyle == STYLE_None) return; - // Can't interpolate the first tic. - if (sprite->firstTic) - { - sprite->firstTic = false; - sprite->oldx = sprite->x; - sprite->oldy = sprite->y; + if (pspr->firstTic) + { // Can't interpolate the first tic. + pspr->firstTic = false; + pspr->oldx = pspr->x; + pspr->oldy = pspr->y; } - double sx = sprite->oldx + (sprite->x - sprite->oldx) * ticfrac; - double sy = sprite->oldy + (sprite->y - sprite->oldy) * ticfrac; + sx = pspr->oldx + (pspr->x - pspr->oldx) * ticfrac; + sy = pspr->oldy + (pspr->y - pspr->oldy) * ticfrac + WEAPON_FUDGE_Y; - if (sprite->Flags & PSPF_ADDBOB) + if (pspr->Flags & PSPF_ADDBOB) { sx += bobx; sy += boby; } - if (sprite->Flags & PSPF_ADDWEAPON && sprite->GetID() != PSP_WEAPON) + if (pspr->Flags & PSPF_ADDWEAPON && pspr->GetID() != PSP_WEAPON) { sx += wx; sy += wy; } - - const auto &viewpoint = PolyRenderer::Instance()->Viewpoint; - auto renderTarget = PolyRenderer::Instance()->RenderTarget; - double YaspectMul = 1.2f; - double pspritexscale = PolyRenderer::Instance()->Viewwindow.centerxwide / 160.0; - double pspriteyscale = pspritexscale * YaspectMul; + double yaspectMul = 1.2;// 320.0 * SCREENHEIGHT / (r_Yaspect * SCREENWIDTH); + + double pspritexscale = viewwindow.centerxwide / 160.0; + double pspriteyscale = pspritexscale * yaspectMul; double pspritexiscale = 1 / pspritexscale; // calculate edges of the shape - double tx = sx - BaseXCenter; + tx = sx - BASEXCENTER; tx -= tex->GetScaledLeftOffset(); - int x1 = xs_RoundToInt(renderTarget->GetWidth() * 0.5 + tx * pspritexscale); + x1 = xs_RoundToInt(viewwindow.centerx + tx * pspritexscale); // off the right side if (x1 > viewwidth) return; tx += tex->GetScaledWidth(); - int x2 = xs_RoundToInt(renderTarget->GetWidth() * 0.5 + tx * pspritexscale); + x2 = xs_RoundToInt(viewwindow.centerx + tx * pspritexscale); // off the left side if (x2 <= 0) return; - double texturemid = (BaseYCenter - sy) * tex->Scale.Y + tex->TopOffset; + // store information in a vissprite + PolyNoAccelPlayerSprite vis; - // Adjust PSprite for fullscreen views - if (viewpoint.camera->player && (renderTarget != screen || viewheight == renderTarget->GetHeight() || (renderTarget->GetWidth() > (BaseXCenter * 2) && !st_scale))) - { - AWeapon *weapon = dyn_cast(sprite->GetCaller()); + vis.renderflags = owner->renderflags; + + vis.texturemid = (BASEYCENTER - sy) * tex->Scale.Y + tex->TopOffset; + + if (viewpoint.camera->player && (renderTarget != screen || + viewheight == renderTarget->GetHeight() || + (renderTarget->GetWidth() > (BASEXCENTER * 2) && !st_scale))) + { // Adjust PSprite for fullscreen views + AWeapon *weapon = dyn_cast(pspr->GetCaller()); if (weapon != nullptr && weapon->YAdjust != 0) { if (renderTarget != screen || viewheight == renderTarget->GetHeight()) { - texturemid -= weapon->YAdjust; + vis.texturemid -= weapon->YAdjust; } else { - texturemid -= StatusBar->GetDisplacement() * weapon->YAdjust; + vis.texturemid -= StatusBar->GetDisplacement() * weapon->YAdjust; } } } - - // Move the weapon down for 1280x1024. - if (sprite->GetID() < PSP_TARGETCENTER) - { - texturemid -= AspectPspriteOffset(PolyRenderer::Instance()->Viewwindow.WidescreenRatio); + if (pspr->GetID() < PSP_TARGETCENTER) + { // Move the weapon down for 1280x1024. + vis.texturemid -= AspectPspriteOffset(viewwindow.WidescreenRatio); } + vis.x1 = x1 < 0 ? 0 : x1; + vis.x2 = x2 >= viewwidth ? viewwidth : x2; + vis.xscale = FLOAT2FIXED(pspritexscale / tex->Scale.X); + vis.yscale = float(pspriteyscale / tex->Scale.Y); + vis.pic = tex; - int clipped_x1 = MAX(x1, 0); - int clipped_x2 = MIN(x2, viewwidth); - double xscale = pspritexscale / tex->Scale.X; - double yscale = pspriteyscale / tex->Scale.Y; - uint32_t translation = 0; // [RH] Use default colors - - double xiscale, startfrac; - if (flip) + // If flip is used, provided that it's not already flipped (that would just invert itself) + // (It's an XOR...) + if (!(flip) != !(pspr->Flags & PSPF_FLIP)) { - xiscale = -pspritexiscale * tex->Scale.X; - startfrac = 1; + vis.xiscale = -FLOAT2FIXED(pspritexiscale * tex->Scale.X); + vis.startfrac = (tex->GetWidth() << FRACBITS) - 1; } else { - xiscale = pspritexiscale * tex->Scale.X; - startfrac = 0; + vis.xiscale = FLOAT2FIXED(pspritexiscale * tex->Scale.X); + vis.startfrac = 0; } - if (clipped_x1 > x1) - startfrac += xiscale * (clipped_x1 - x1); + if (vis.x1 > x1) + vis.startfrac += vis.xiscale*(vis.x1 - x1); - bool noaccel = false; - - FDynamicColormap *basecolormap = GetColorTable(viewpoint.sector->Colormap, viewpoint.sector->SpecialColors[sector_t::sprites], true); - FDynamicColormap *colormap_to_use = basecolormap; - - int ColormapNum = 0; - FSWColormap *BaseColormap = basecolormap; - float Alpha = 0; - FRenderStyle RenderStyle; - RenderStyle = STYLE_Normal; - - bool foggy = false; - int actualextralight = foggy ? 0 : viewpoint.extralight << 4; - int spriteshade = PolyLightVisibility::LightLevelToShade(owner->Sector->lightlevel + actualextralight, foggy); - double minz = double((2048 * 4) / double(1 << 20)); - ColormapNum = GETPALOOKUP(PolyRenderer::Instance()->Light.SpriteGlobVis(foggy) / minz, spriteshade); - - if (sprite->GetID() < PSP_TARGETCENTER) + noaccel = false; + FDynamicColormap *colormap_to_use = nullptr; + if (pspr->GetID() < PSP_TARGETCENTER) { - Alpha = float(owner->Alpha); - RenderStyle = owner->RenderStyle; + // [MC] Set the render style + + if (pspr->Flags & PSPF_RENDERSTYLE) + { + const int rs = clamp(pspr->RenderStyle, 0, STYLE_Count); + + if (pspr->Flags & PSPF_FORCESTYLE) + { + vis.RenderStyle = LegacyRenderStyles[rs]; + } + else if (owner->RenderStyle == LegacyRenderStyles[STYLE_Fuzzy]) + { + vis.RenderStyle = LegacyRenderStyles[STYLE_Fuzzy]; + } + else if (owner->RenderStyle == LegacyRenderStyles[STYLE_OptFuzzy]) + { + vis.RenderStyle = LegacyRenderStyles[STYLE_OptFuzzy]; + vis.RenderStyle.CheckFuzz(); + } + else if (owner->RenderStyle == LegacyRenderStyles[STYLE_Subtract]) + { + vis.RenderStyle = LegacyRenderStyles[STYLE_Subtract]; + } + else + { + vis.RenderStyle = LegacyRenderStyles[rs]; + } + } + else + { + vis.RenderStyle = owner->RenderStyle; + } + + // Set the alpha based on if using the overlay's own or not. Also adjust + // and override the alpha if not forced. + if (pspr->Flags & PSPF_ALPHA) + { + if (vis.RenderStyle == LegacyRenderStyles[STYLE_Fuzzy]) + { + alpha = owner->Alpha; + } + else if (vis.RenderStyle == LegacyRenderStyles[STYLE_OptFuzzy]) + { + FRenderStyle style = vis.RenderStyle; + style.CheckFuzz(); + switch (style.BlendOp) + { + default: + alpha = pspr->alpha * owner->Alpha; + break; + case STYLEOP_Fuzz: + case STYLEOP_Sub: + alpha = owner->Alpha; + break; + } + + } + else if (vis.RenderStyle == LegacyRenderStyles[STYLE_Subtract]) + { + alpha = owner->Alpha; + } + else if (vis.RenderStyle == LegacyRenderStyles[STYLE_Add] || + vis.RenderStyle == LegacyRenderStyles[STYLE_Translucent] || + vis.RenderStyle == LegacyRenderStyles[STYLE_TranslucentStencil] || + vis.RenderStyle == LegacyRenderStyles[STYLE_AddStencil] || + vis.RenderStyle == LegacyRenderStyles[STYLE_AddShaded]) + { + alpha = owner->Alpha * pspr->alpha; + } + else + { + alpha = owner->Alpha; + } + } + + // Should normal renderstyle come out on top at the end and we desire alpha, + // switch it to translucent. Normal never applies any sort of alpha. + if ((pspr->Flags & PSPF_ALPHA) && + vis.RenderStyle == LegacyRenderStyles[STYLE_Normal] && + vis.Alpha < 1.0) + { + vis.RenderStyle = LegacyRenderStyles[STYLE_Translucent]; + alpha = owner->Alpha * pspr->alpha; + } + + // ALWAYS take priority if asked for, except fuzz. Fuzz does absolutely nothing + // no matter what way it's changed. + if (pspr->Flags & PSPF_FORCEALPHA) + { + //Due to lack of != operators... + if (vis.RenderStyle == LegacyRenderStyles[STYLE_Fuzzy] || + vis.RenderStyle == LegacyRenderStyles[STYLE_SoulTrans] || + vis.RenderStyle == LegacyRenderStyles[STYLE_Stencil]) + { + } + else + { + alpha = pspr->alpha; + vis.RenderStyle.Flags |= STYLEF_ForceAlpha; + } + } + vis.Alpha = clamp(float(alpha), 0.f, 1.f); + + // Due to how some of the effects are handled, going to 0 or less causes some + // weirdness to display. There's no point rendering it anyway if it's 0. + if (vis.Alpha <= 0.) + return; + + //----------------------------------------------------------------------------- // The software renderer cannot invert the source without inverting the overlay // too. That means if the source is inverted, we need to do the reverse of what // the invert overlay flag says to do. - INTBOOL invertcolormap = (RenderStyle.Flags & STYLEF_InvertOverlay); + bool invertcolormap = (vis.RenderStyle.Flags & STYLEF_InvertOverlay) != 0; - if (RenderStyle.Flags & STYLEF_InvertSource) + if (vis.RenderStyle.Flags & STYLEF_InvertSource) { invertcolormap = !invertcolormap; } - FDynamicColormap *mybasecolormap = basecolormap; + bool fullbright = !foggy && pspr->GetState()->GetFullbright(); + bool fadeToBlack = (vis.RenderStyle.Flags & STYLEF_FadeToBlack) != 0; - if (RenderStyle.Flags & STYLEF_FadeToBlack) - { - if (invertcolormap) - { // Fade to white - mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(255, 255, 255), mybasecolormap->Desaturate); - invertcolormap = false; - } - else - { // Fade to black - mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(0, 0, 0), mybasecolormap->Desaturate); - } - } + vis.Light.SetColormap(0, spriteshade, basecolormap, fullbright, invertcolormap, fadeToBlack); - /* - if (realfixedcolormap != nullptr && (!r_swtruecolor || (r_shadercolormaps && screen->Accel2D))) - { // fixed color - BaseColormap = realfixedcolormap; - ColormapNum = 0; - } - else - { - if (invertcolormap) - { - mybasecolormap = GetSpecialLights(mybasecolormap->Color, mybasecolormap->Fade.InverseColor(), mybasecolormap->Desaturate); - } - if (fixedlightlev >= 0) - { - BaseColormap = (r_fullbrightignoresectorcolor) ? &FullNormalLight : mybasecolormap; - ColormapNum = fixedlightlev >> COLORMAPSHIFT; - } - else if (!foggy && sprite->GetState()->GetFullbright()) - { // full bright - BaseColormap = (r_fullbrightignoresectorcolor) ? &FullNormalLight : mybasecolormap; // [RH] use basecolormap - ColormapNum = 0; - } - else - { // local light - BaseColormap = mybasecolormap; - ColormapNum = GETPALOOKUP(0, spriteshade); - } - } - */ + colormap_to_use = (FDynamicColormap*)vis.Light.BaseColormap; if (viewpoint.camera->Inventory != nullptr) { visstyle_t visstyle; - visstyle.Alpha = Alpha; + visstyle.Alpha = vis.Alpha; visstyle.RenderStyle = STYLE_Count; visstyle.Invert = false; viewpoint.camera->Inventory->AlterWeaponSprite(&visstyle); - Alpha = visstyle.Alpha; + vis.Alpha = visstyle.Alpha; if (visstyle.RenderStyle != STYLE_Count) { - RenderStyle = visstyle.RenderStyle; + vis.RenderStyle = visstyle.RenderStyle; } if (visstyle.Invert) { - BaseColormap = &SpecialSWColormaps[INVERSECOLORMAP]; - ColormapNum = 0; - if (BaseColormap->Maps < mybasecolormap->Maps || BaseColormap->Maps >= mybasecolormap->Maps + NUMCOLORMAPS * 256) - { - noaccel = true; - } + vis.Light.BaseColormap = &SpecialSWColormaps[INVERSECOLORMAP]; + vis.Light.ColormapNum = 0; + noaccel = true; } } - // If we're drawing with a special colormap, but shaders for them are disabled, do // not accelerate. - if (!r_shadercolormaps && (BaseColormap >= &SpecialSWColormaps[0] && - BaseColormap <= &SpecialSWColormaps.Last())) + if (!r_shadercolormaps && (vis.Light.BaseColormap >= &SpecialSWColormaps[0] && + vis.Light.BaseColormap <= &SpecialSWColormaps.Last())) { noaccel = true; } // If drawing with a BOOM colormap, disable acceleration. - if (mybasecolormap == &NormalLight && NormalLight.Maps != realcolormaps.Maps) + if (vis.Light.BaseColormap == &NormalLight && NormalLight.Maps != realcolormaps.Maps) { noaccel = true; } @@ -334,116 +486,185 @@ void RenderPolyPlayerSprites::RenderSprite(DPSprite *sprite, AActor *owner, floa // colormap, disable acceleration so that the lights can remain fixed. PolyCameraLight *cameraLight = PolyCameraLight::Instance(); if (!noaccel && cameraLight->ShaderColormap() == nullptr && - NormalLightHasFixedLights && mybasecolormap == &NormalLight && - tex->UseBasePalette()) + NormalLightHasFixedLights && vis.Light.BaseColormap == &NormalLight && + vis.pic->UseBasePalette()) { noaccel = true; } - // [SP] If emulating GZDoom fullbright, disable acceleration - if (r_fullbrightignoresectorcolor && cameraLight->FixedLightLevel() >= 0) - mybasecolormap = &FullNormalLight; - if (r_fullbrightignoresectorcolor && !foggy && sprite->GetState()->GetFullbright()) - mybasecolormap = &FullNormalLight; - colormap_to_use = mybasecolormap; + } + else + { + colormap_to_use = basecolormap; + + vis.Light.BaseColormap = basecolormap; + vis.Light.ColormapNum = 0; } // Check for hardware-assisted 2D. If it's available, and this sprite is not // fuzzy, don't draw it until after the switch to 2D mode. if (!noaccel && renderTarget == screen && (DFrameBuffer *)screen->Accel2D) { - FRenderStyle style = RenderStyle; + FRenderStyle style = vis.RenderStyle; style.CheckFuzz(); if (style.BlendOp != STYLEOP_Fuzz) { - PolyScreenSprite screenSprite; - screenSprite.Pic = tex; - screenSprite.X1 = viewwindowx + x1; - screenSprite.Y1 = viewwindowy + viewheight / 2 - texturemid * yscale - 0.5; - screenSprite.Width = tex->GetWidth() * xscale; - screenSprite.Height = tex->GetHeight() * yscale; - screenSprite.Translation = TranslationToTable(translation); - //screenSprite.Translation = translation; - screenSprite.Flip = xiscale < 0; - screenSprite.Alpha = Alpha; - screenSprite.RenderStyle = RenderStyle; - screenSprite.BaseColormap = BaseColormap; - screenSprite.ColormapNum = ColormapNum; - screenSprite.Colormap = colormap_to_use; - ScreenSprites.push_back(screenSprite); + PolyHWAccelPlayerSprite accelSprite; + + accelSprite.pic = vis.pic; + accelSprite.texturemid = vis.texturemid; + accelSprite.yscale = vis.yscale; + accelSprite.xscale = vis.xscale; + + accelSprite.Alpha = vis.Alpha; + accelSprite.RenderStyle = vis.RenderStyle; + accelSprite.Translation = vis.Translation; + accelSprite.FillColor = vis.FillColor; + + accelSprite.basecolormap = colormap_to_use; + accelSprite.x1 = x1; + accelSprite.flip = vis.xiscale < 0; + + if (vis.Light.BaseColormap >= &SpecialSWColormaps[0] && + vis.Light.BaseColormap < &SpecialSWColormaps[SpecialColormaps.Size()]) + { + accelSprite.special = &SpecialColormaps[vis.Light.BaseColormap - &SpecialSWColormaps[0]]; + } + else if (PolyCameraLight::Instance()->ShaderColormap()) + { + accelSprite.special = PolyCameraLight::Instance()->ShaderColormap(); + } + else if (colormap_to_use->Color == PalEntry(255, 255, 255) && + colormap_to_use->Desaturate == 0) + { + accelSprite.overlay = colormap_to_use->Fade; + accelSprite.overlay.a = uint8_t(vis.Light.ColormapNum * 255 / NUMCOLORMAPS); + } + else + { + accelSprite.usecolormapstyle = true; + accelSprite.colormapstyle.Color = colormap_to_use->Color; + accelSprite.colormapstyle.Fade = colormap_to_use->Fade; + accelSprite.colormapstyle.Desaturate = colormap_to_use->Desaturate; + accelSprite.colormapstyle.FadeLevel = vis.Light.ColormapNum / float(NUMCOLORMAPS); + } + + AcceleratedSprites.Push(accelSprite); return; } } - // To do: draw sprite same way as R_DrawVisSprite(vis) here - - // Draw the fuzzy weapon: - FRenderStyle style = RenderStyle; - style.CheckFuzz(); - if (style.BlendOp == STYLEOP_Fuzz) - { - RenderStyle = LegacyRenderStyles[STYLE_Shadow]; - - PolyScreenSprite screenSprite; - screenSprite.Pic = tex; - screenSprite.X1 = viewwindowx + x1; - screenSprite.Y1 = viewwindowy + viewheight / 2 - texturemid * yscale - 0.5; - screenSprite.Width = tex->GetWidth() * xscale; - screenSprite.Height = tex->GetHeight() * yscale; - screenSprite.Translation = TranslationToTable(translation); - screenSprite.Flip = xiscale < 0; - screenSprite.Alpha = Alpha; - screenSprite.RenderStyle = RenderStyle; - screenSprite.BaseColormap = BaseColormap; - screenSprite.ColormapNum = ColormapNum; - screenSprite.Colormap = colormap_to_use; - ScreenSprites.push_back(screenSprite); - } + vis.Render(); } -void PolyScreenSprite::Render() +fixed_t RenderPolyPlayerSprites::LightLevelToShade(int lightlevel, bool foggy) { - FSpecialColormap *special = nullptr; - FColormapStyle colormapstyle; - PalEntry overlay = 0; - bool usecolormapstyle = false; - if (BaseColormap >= &SpecialSWColormaps[0] && - BaseColormap < &SpecialSWColormaps[SpecialColormaps.Size()]) + bool nolightfade = !foggy && ((level.flags3 & LEVEL3_NOLIGHTFADE)); + if (nolightfade) { - special = &SpecialColormaps[BaseColormap - &SpecialSWColormaps[0]]; - } - else if (Colormap->Color == PalEntry(255, 255, 255) && - Colormap->Desaturate == 0) - { - overlay = Colormap->Fade; - overlay.a = uint8_t(ColormapNum * 255 / NUMCOLORMAPS); + return (MAX(255 - lightlevel, 0) * NUMCOLORMAPS) << (FRACBITS - 8); } else { - usecolormapstyle = true; - colormapstyle.Color = Colormap->Color; - colormapstyle.Fade = Colormap->Fade; - colormapstyle.Desaturate = Colormap->Desaturate; - colormapstyle.FadeLevel = ColormapNum / float(NUMCOLORMAPS); + // Convert a light level into an unbounded colormap index (shade). Result is + // fixed point. Why the +12? I wish I knew, but experimentation indicates it + // is necessary in order to best reproduce Doom's original lighting. + return (NUMCOLORMAPS * 2 * FRACUNIT) - ((lightlevel + 12) * (FRACUNIT*NUMCOLORMAPS / 128)); + } +} + +///////////////////////////////////////////////////////////////////////// + +void PolyNoAccelPlayerSprite::Render() +{ +#if 0 + if (xscale == 0 || fabs(yscale) < (1.0f / 32000.0f)) + { // scaled to 0; can't see + return; } - screen->DrawTexture(Pic, - X1, - Y1, - DTA_DestWidthF, Width, - DTA_DestHeightF, Height, - DTA_TranslationIndex, Translation, - DTA_FlipX, Flip, - DTA_TopOffset, 0, - DTA_LeftOffset, 0, - DTA_ClipLeft, viewwindowx, - DTA_ClipTop, viewwindowy, - DTA_ClipRight, viewwindowx + viewwidth, - DTA_ClipBottom, viewwindowy + viewheight, - DTA_Alpha, Alpha, - DTA_RenderStyle, RenderStyle, - DTA_FillColor, FillColor, - DTA_SpecialColormap, special, - DTA_ColorOverlay, overlay.d, - DTA_ColormapStyle, usecolormapstyle ? &colormapstyle : nullptr, - TAG_DONE); + SpriteDrawerArgs drawerargs; + drawerargs.SetLight(Light.BaseColormap, 0, Light.ColormapNum << FRACBITS); + + FDynamicColormap *basecolormap = static_cast(Light.BaseColormap); + + bool visible = drawerargs.SetStyle(RenderStyle, Alpha, Translation, FillColor, basecolormap, Light.ColormapNum << FRACBITS); + if (!visible) + return; + + double spryscale = yscale; + bool sprflipvert = false; + fixed_t iscale = FLOAT2FIXED(1 / yscale); + + double centerY = viewheight / 2; + + double sprtopscreen; + if (renderflags & RF_YFLIP) + { + sprflipvert = true; + spryscale = -spryscale; + iscale = -iscale; + sprtopscreen = centerY + (texturemid - pic->GetHeight()) * spryscale; + } + else + { + sprflipvert = false; + sprtopscreen = centerY - texturemid * spryscale; + } + + // clip to screen bounds + short *mfloorclip = screenheightarray; + short *mceilingclip = zeroarray; + + fixed_t frac = startfrac; + for (int x = x1; x < x2; x++) + { + drawerargs.DrawMaskedColumn(x, iscale, pic, frac, spryscale, sprtopscreen, sprflipvert, mfloorclip, mceilingclip, false); + frac += xiscale; + } +#endif +} + +///////////////////////////////////////////////////////////////////////////// + +void PolyColormapLight::SetColormap(double visibility, int shade, FDynamicColormap *basecolormap, bool fullbright, bool invertColormap, bool fadeToBlack) +{ + if (fadeToBlack) + { + if (invertColormap) // Fade to white + { + basecolormap = GetSpecialLights(basecolormap->Color, MAKERGB(255, 255, 255), basecolormap->Desaturate); + invertColormap = false; + } + else // Fade to black + { + basecolormap = GetSpecialLights(basecolormap->Color, MAKERGB(0, 0, 0), basecolormap->Desaturate); + } + } + + if (invertColormap) + { + basecolormap = GetSpecialLights(basecolormap->Color, basecolormap->Fade.InverseColor(), basecolormap->Desaturate); + } + + PolyCameraLight *cameraLight = PolyCameraLight::Instance(); + if (cameraLight->FixedColormap()) + { + BaseColormap = cameraLight->FixedColormap(); + ColormapNum = 0; + } + else if (cameraLight->FixedLightLevel() >= 0) + { + BaseColormap = (r_fullbrightignoresectorcolor) ? &FullNormalLight : basecolormap; + ColormapNum = cameraLight->FixedLightLevel() >> COLORMAPSHIFT; + } + else if (fullbright) + { + BaseColormap = (r_fullbrightignoresectorcolor) ? &FullNormalLight : basecolormap; + ColormapNum = 0; + } + else + { + BaseColormap = basecolormap; + ColormapNum = GETPALOOKUP(visibility, shade); + } } diff --git a/src/polyrenderer/scene/poly_playersprite.h b/src/polyrenderer/scene/poly_playersprite.h index 97c6e6118..3f1260d48 100644 --- a/src/polyrenderer/scene/poly_playersprite.h +++ b/src/polyrenderer/scene/poly_playersprite.h @@ -24,9 +24,68 @@ #include "r_defs.h" -class PolyScreenSprite; class DPSprite; -struct FSWColormap; +struct FDynamicColormap; + +class PolyColormapLight +{ +public: + int ColormapNum = 0; + FSWColormap *BaseColormap = nullptr; + + void SetColormap(double visibility, int shade, FDynamicColormap *basecolormap, bool fullbright, bool invertColormap, bool fadeToBlack); +}; + +class PolyNoAccelPlayerSprite +{ +public: + short x1 = 0; + short x2 = 0; + + double texturemid = 0.0; + + fixed_t xscale = 0; + float yscale = 0.0f; + + FTexture *pic = nullptr; + + fixed_t xiscale = 0; + fixed_t startfrac = 0; + + float Alpha = 0.0f; + FRenderStyle RenderStyle; + uint32_t Translation = 0; + uint32_t FillColor = 0; + + PolyColormapLight Light; + + short renderflags = 0; + + void Render(); +}; + +class PolyHWAccelPlayerSprite +{ +public: + FTexture *pic = nullptr; + double texturemid = 0.0; + float yscale = 0.0f; + fixed_t xscale = 0; + + float Alpha = 0.0f; + FRenderStyle RenderStyle; + uint32_t Translation = 0; + uint32_t FillColor = 0; + + FDynamicColormap *basecolormap = nullptr; + int x1 = 0; + + bool flip = false; + FSpecialColormap *special = nullptr; + PalEntry overlay = 0; + FColormapStyle colormapstyle; + bool usecolormapstyle = false; +}; class RenderPolyPlayerSprites { @@ -35,31 +94,12 @@ public: void RenderRemainingSprites(); private: - void RenderSprite(DPSprite *sprite, AActor *owner, float bobx, float boby, double wx, double wy, double ticfrac); + void RenderSprite(DPSprite *pspr, AActor *owner, float bobx, float boby, double wx, double wy, double ticfrac, int spriteshade, FDynamicColormap *basecolormap, bool foggy); + static fixed_t LightLevelToShade(int lightlevel, bool foggy); - const int BaseXCenter = 160; - const int BaseYCenter = 100; + enum { BASEXCENTER = 160 }; + enum { BASEYCENTER = 100 }; - std::vector ScreenSprites; -}; - -// DScreen accelerated sprite to be rendered -class PolyScreenSprite -{ -public: - void Render(); - - FTexture *Pic = nullptr; - double X1 = 0.0; - double Y1 = 0.0; - double Width = 0.0; - double Height = 0.0; - FRemapTable *Translation = nullptr; - bool Flip = false; - float Alpha = 1; - FRenderStyle RenderStyle; - FSWColormap *BaseColormap = nullptr; - int ColormapNum = 0; - uint32_t FillColor = 0; - FDynamicColormap *Colormap = nullptr; + TArray AcceleratedSprites; + sector_t tempsec; }; From e5d4d9a36a78f22b354e241a3e1c8f00f96a0f0f Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Sun, 26 Mar 2017 22:09:34 +0300 Subject: [PATCH 2/3] Fixed compilation with GCC/Clang MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit src/swrenderer/line/r_walldraw.cpp:102:13: error: expected unqualified-id before ‘(’ token --- src/swrenderer/line/r_walldraw.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/swrenderer/line/r_walldraw.cpp b/src/swrenderer/line/r_walldraw.cpp index 00d5d4860..bf8d856e9 100644 --- a/src/swrenderer/line/r_walldraw.cpp +++ b/src/swrenderer/line/r_walldraw.cpp @@ -99,7 +99,7 @@ namespace swrenderer v = v - floor(v); double v_step = uv_stepd / texture->GetHeight(); - if (std::isnan(v) || std::isnan(v_step)) // this should never happen, but it apparently does.. + if (isnan(v) || isnan(v_step)) // this should never happen, but it apparently does.. { uv_stepd = 0.0; v = 0.0; From c8eabe57ff13f8b07591194f89c129bd6f5b9dc7 Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Sun, 26 Mar 2017 22:04:04 +0300 Subject: [PATCH 3/3] Fixed compilation warning reported by GCC/Clang src/v_draw.cpp:503:25: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] --- src/v_draw.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/v_draw.cpp b/src/v_draw.cpp index 291165239..d06628d43 100644 --- a/src/v_draw.cpp +++ b/src/v_draw.cpp @@ -500,7 +500,7 @@ bool DCanvas::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t t case DTA_FillColor: parms->fillcolor = ListGetInt(tags); - if (parms->fillcolor != -1) + if (parms->fillcolor != ~0u) { fillcolorset = true; }