diff --git a/src/d_net.cpp b/src/d_net.cpp
index e6ad65800..1659b72ac 100644
--- a/src/d_net.cpp
+++ b/src/d_net.cpp
@@ -2382,7 +2382,8 @@ void Net_DoCommand (int type, BYTE **stream, int player)
 			{
 				if (trace.HitType == TRACE_HitWall)
 				{
-					DImpactDecal::StaticCreate (s, trace.HitPos, trace.Line->sidedef[trace.Side], NULL);
+					DVector3 hp(FIXED2DBL(trace.HitPos.x), FIXED2DBL(trace.HitPos.y), FIXED2DBL(trace.HitPos.z));
+					DImpactDecal::StaticCreate (s, hp, trace.Line->sidedef[trace.Side], NULL);
 				}
 			}
 		}
diff --git a/src/decallib.cpp b/src/decallib.cpp
index 8f6678eff..fe8de4d0a 100644
--- a/src/decallib.cpp
+++ b/src/decallib.cpp
@@ -52,7 +52,7 @@
 
 FDecalLib DecalLibrary;
 
-static fixed_t ReadScale (FScanner &sc);
+static double ReadScale (FScanner &sc);
 static TArray<BYTE> DecalTranslations;
 
 // A decal group holds multiple decals and returns one randomly
@@ -148,7 +148,7 @@ public:
 
 	int TimeToStartDecay;
 	int TimeToEndDecay;
-	fixed_t StartTrans;
+	double StartTrans;
 private:
 	DDecalFader () {}
 };
@@ -186,7 +186,7 @@ struct FDecalStretcherAnim : public FDecalAnimator
 
 	int StretchStart;
 	int StretchTime;
-	fixed_t GoalX, GoalY;
+	double GoalX, GoalY;
 };
 
 class DDecalStretcher : public DDecalThinker
@@ -199,10 +199,10 @@ public:
 
 	int TimeToStart;
 	int TimeToStop;
-	fixed_t GoalX;
-	fixed_t StartX;
-	fixed_t GoalY;
-	fixed_t StartY;
+	double GoalX;
+	double StartX;
+	double GoalY;
+	double StartY;
 	bool bStretchX;
 	bool bStretchY;
 	bool bStarted;
@@ -217,7 +217,7 @@ struct FDecalSliderAnim : public FDecalAnimator
 
 	int SlideStart;
 	int SlideTime;
-	fixed_t /*DistX,*/ DistY;
+	double /*DistX,*/ DistY;
 };
 
 class DDecalSlider : public DDecalThinker
@@ -230,10 +230,10 @@ public:
 
 	int TimeToStart;
 	int TimeToStop;
-/*	fixed_t DistX; */
-	fixed_t DistY;
-	fixed_t StartX;
-	fixed_t StartY;
+/*	double DistX; */
+	double DistY;
+	double StartX;
+	double StartY;
 	bool bStarted;
 private:
 	DDecalSlider () {}
@@ -453,10 +453,10 @@ void FDecalLib::ParseDecal (FScanner &sc)
 
 	memset ((void *)&newdecal, 0, sizeof(newdecal));
 	newdecal.PicNum.SetInvalid();
-	newdecal.ScaleX = newdecal.ScaleY = FRACUNIT;
+	newdecal.ScaleX = newdecal.ScaleY = 1.;
 	newdecal.RenderFlags = RF_WALLSPRITE;
 	newdecal.RenderStyle = STYLE_Normal;
-	newdecal.Alpha = 0x8000;
+	newdecal.Alpha = 1.;
 
 	for (;;)
 	{
@@ -492,13 +492,13 @@ void FDecalLib::ParseDecal (FScanner &sc)
 
 		case DECAL_ADD:
 			sc.MustGetFloat ();
-			newdecal.Alpha = (WORD)(32768.f * sc.Float);
+			newdecal.Alpha = sc.Float;
 			newdecal.RenderStyle = STYLE_Add;
 			break;
 
 		case DECAL_TRANSLUCENT:
 			sc.MustGetFloat ();
-			newdecal.Alpha = (WORD)(32768.f * sc.Float);
+			newdecal.Alpha = sc.Float;
 			newdecal.RenderStyle = STYLE_Translucent;
 			break;
 
@@ -681,7 +681,7 @@ void FDecalLib::ParseFader (FScanner &sc)
 void FDecalLib::ParseStretcher (FScanner &sc)
 {
 	FString stretcherName;
-	fixed_t goalX = -1, goalY = -1;
+	double goalX = -1, goalY = -1;
 	int startTime = 0, takeTime = 0;
 
 	sc.MustGetString ();
@@ -732,7 +732,7 @@ void FDecalLib::ParseStretcher (FScanner &sc)
 void FDecalLib::ParseSlider (FScanner &sc)
 {
 	FString sliderName;
-	fixed_t distX = 0, distY = 0;
+	double distX = 0, distY = 0;
 	int startTime = 0, takeTime = 0;
 
 	sc.MustGetString ();
@@ -773,7 +773,7 @@ void FDecalLib::ParseSlider (FScanner &sc)
 		else if (sc.Compare ("DistY"))
 		{
 			sc.MustGetFloat ();
-			distY = (fixed_t)(sc.Float * FRACUNIT);
+			distY = sc.Float;
 		}
 		else
 		{
@@ -1046,7 +1046,7 @@ void FDecalTemplate::ApplyToDecal (DBaseDecal *decal, side_t *wall) const
 	decal->ScaleX = ScaleX;
 	decal->ScaleY = ScaleY;
 	decal->PicNum = PicNum;
-	decal->Alpha = Alpha << 1;
+	decal->Alpha = Alpha;
 	decal->RenderStyle = RenderStyle;
 	decal->RenderFlags = (RenderFlags & ~(DECAL_RandomFlipX|DECAL_RandomFlipY)) |
 		(decal->RenderFlags & (RF_RELMASK|RF_CLIPMASK|RF_INVISIBLE|RF_ONESIDED));
@@ -1184,7 +1184,7 @@ void DDecalFader::Tick ()
 
 		int distanceToEnd = TimeToEndDecay - level.maptime;
 		int fadeDistance = TimeToEndDecay - TimeToStartDecay;
-		TheDecal->Alpha = Scale (StartTrans, distanceToEnd, fadeDistance);
+		TheDecal->Alpha = StartTrans * distanceToEnd / fadeDistance;
 	}
 }
 
@@ -1278,11 +1278,11 @@ void DDecalStretcher::Tick ()
 	int maxDistance = TimeToStop - TimeToStart;
 	if (bStretchX)
 	{
-		TheDecal->ScaleX = StartX + Scale (GoalX - StartX, distance, maxDistance);
+		TheDecal->ScaleX = StartX + (GoalX - StartX) * distance / maxDistance;
 	}
 	if (bStretchY)
 	{
-		TheDecal->ScaleY = StartY + Scale (GoalY - StartY, distance, maxDistance);
+		TheDecal->ScaleY = StartY + (GoalY - StartY) * distance / maxDistance;
 	}
 }
 
@@ -1339,8 +1339,8 @@ void DDecalSlider::Tick ()
 
 	int distance = level.maptime - TimeToStart;
 	int maxDistance = TimeToStop - TimeToStart;
-	/*TheDecal->LeftDistance = StartX + Scale (DistX, distance, maxDistance);*/
-	TheDecal->Z = StartY + Scale (DistY, distance, maxDistance);
+	/*TheDecal->LeftDistance = StartX + DistX * distance / maxDistance);*/
+	TheDecal->Z = StartY + DistY * distance / maxDistance;
 }
 
 DThinker *FDecalCombinerAnim::CreateThinker (DBaseDecal *actor, side_t *wall) const
@@ -1428,8 +1428,8 @@ DThinker *FDecalColorerAnim::CreateThinker (DBaseDecal *actor, side_t *wall) con
 	return Colorer;
 }
 
-static fixed_t ReadScale (FScanner &sc)
+static double ReadScale (FScanner &sc)
 {
 	sc.MustGetFloat ();
-	return fixed_t(clamp (sc.Float * FRACUNIT, 256.0, 256.0*FRACUNIT));
+	return clamp (sc.Float, 1/256.0, 256.0);
 }
diff --git a/src/decallib.h b/src/decallib.h
index 6375c90ee..5f08bdfd1 100644
--- a/src/decallib.h
+++ b/src/decallib.h
@@ -74,13 +74,13 @@ public:
 	const FDecalTemplate *GetDecal () const;
 	void ReplaceDecalRef (FDecalBase *from, FDecalBase *to);
 
-	fixed_t ScaleX, ScaleY;
+	double ScaleX, ScaleY;
 	DWORD ShadeColor;
 	DWORD Translation;
 	FRenderStyle RenderStyle;
 	FTextureID PicNum;
 	WORD RenderFlags;
-	WORD Alpha;				// same as (actor->alpha >> 1)
+	double Alpha;				// same as actor->alpha
 	const FDecalAnimator *Animator;
 	const FDecalBase *LowerDecal;
 
diff --git a/src/g_shared/a_bridge.cpp b/src/g_shared/a_bridge.cpp
index e874bc58e..d8c2ccc9c 100644
--- a/src/g_shared/a_bridge.cpp
+++ b/src/g_shared/a_bridge.cpp
@@ -28,8 +28,8 @@ static FRandom pr_orbit ("Orbit");
 		233: -30° / seconds
 		244: -15° / seconds
 		This value only matters if args[2] is not zero.
-	args[4]: Rotation _f_radius() of bridge balls, in bridge _f_radius() %.
-		If 0, use Hexen default: ORBIT_RADIUS, regardless of bridge _f_radius().
+	args[4]: Rotation radius of bridge balls, in bridge radius %.
+		If 0, use Hexen default: ORBIT_RADIUS, regardless of bridge radius.
 		This value only matters if args[2] is not zero.
 */
 
@@ -102,17 +102,17 @@ DEFINE_ACTION_FUNCTION(AActor, A_BridgeOrbit)
 	// Set default values
 	// Every five tics, Hexen moved the ball 3/256th of a revolution.
 	DAngle rotationspeed  = 45./32*3/5;
-	int rotationradius = ORBIT_RADIUS;
+	double rotationradius = ORBIT_RADIUS;
 	// If the bridge is custom, set non-default values if any.
 
 	// Set angular speed; 1--128: counterclockwise rotation ~=1--180°; 129--255: clockwise rotation ~= 180--1°
 	if (self->target->args[3] > 128) rotationspeed = 45./32 * (self->target->args[3]-256) / TICRATE;
 	else if (self->target->args[3] > 0) rotationspeed = 45./32 * (self->target->args[3]) / TICRATE;
-	// Set rotation _f_radius()
-	if (self->target->args[4]) rotationradius = ((self->target->args[4] * self->target->_f_radius()) / 100);
+	// Set rotation radius
+	if (self->target->args[4]) rotationradius = ((self->target->args[4] * self->target->radius) / 100);
 
 	self->Angles.Yaw += rotationspeed;
-	self->SetOrigin(self->target->Vec3Angle(rotationradius*FRACUNIT, self->Angles.Yaw, 0), true);
+	self->SetOrigin(self->target->Vec3Angle(rotationradius, self->Angles.Yaw, 0), true);
 	self->floorz = self->target->floorz;
 	self->ceilingz = self->target->ceilingz;
 	return 0;
diff --git a/src/g_shared/a_camera.cpp b/src/g_shared/a_camera.cpp
index 5c2e24444..64868231b 100644
--- a/src/g_shared/a_camera.cpp
+++ b/src/g_shared/a_camera.cpp
@@ -173,9 +173,8 @@ void AAimingCamera::Tick ()
 		}
 		if (MaxPitchChange != 0)
 		{ // Aim camera's pitch; use floats for precision
-			fixedvec2 fv3 = tracer->_f_Vec2To(this);
-			DVector2 vect(fv3.x, fv3.y);
-			double dz = _f_Z() - tracer->_f_Z() - tracer->_f_height()/2;
+			DVector2 vect = tracer->Vec2To(this);
+			double dz = Z() - tracer->Z() - tracer->Height/2;
 			double dist = vect.Length();
 			DAngle desiredPitch = dist != 0.f ? VecToAngle(dist, dz) : 0.;
 			DAngle diff = deltaangle(Angles.Pitch, desiredPitch);
diff --git a/src/g_shared/a_decals.cpp b/src/g_shared/a_decals.cpp
index b480deb99..154347496 100644
--- a/src/g_shared/a_decals.cpp
+++ b/src/g_shared/a_decals.cpp
@@ -47,8 +47,8 @@
 #include "farchive.h"
 #include "doomdata.h"
 
-static fixed_t DecalWidth, DecalLeft, DecalRight;
-static fixed_t SpreadZ;
+static double DecalWidth, DecalLeft, DecalRight;
+static double SpreadZ;
 static const DBaseDecal *SpreadSource;
 static const FDecalTemplate *SpreadTemplate;
 static TArray<side_t *> SpreadStack;
@@ -65,25 +65,25 @@ IMPLEMENT_CLASS (DImpactDecal)
 
 DBaseDecal::DBaseDecal ()
 : DThinker(STAT_DECAL),
-  WallNext(0), WallPrev(0), LeftDistance(0), Z(0), ScaleX(FRACUNIT), ScaleY(FRACUNIT), Alpha(OPAQUE),
+  WallNext(0), WallPrev(0), LeftDistance(0), Z(0), ScaleX(1.), ScaleY(1.), Alpha(1.),
   AlphaColor(0), Translation(0), RenderFlags(0)
 {
 	RenderStyle = STYLE_None;
 	PicNum.SetInvalid();
 }
 
-DBaseDecal::DBaseDecal (fixed_t z)
+DBaseDecal::DBaseDecal (double z)
 : DThinker(STAT_DECAL),
-  WallNext(0), WallPrev(0), LeftDistance(0), Z(z), ScaleX(FRACUNIT), ScaleY(FRACUNIT), Alpha(OPAQUE),
+  WallNext(0), WallPrev(0), LeftDistance(0), Z(z), ScaleX(1.), ScaleY(1.), Alpha(1.),
   AlphaColor(0), Translation(0), RenderFlags(0)
 {
 	RenderStyle = STYLE_None;
 	PicNum.SetInvalid();
 }
 
-DBaseDecal::DBaseDecal (int statnum, fixed_t z)
+DBaseDecal::DBaseDecal (int statnum, double z)
 : DThinker(statnum),
-  WallNext(0), WallPrev(0), LeftDistance(0), Z(z), ScaleX(FRACUNIT), ScaleY(FRACUNIT), Alpha(OPAQUE),
+  WallNext(0), WallPrev(0), LeftDistance(0), Z(z), ScaleX(1.), ScaleY(1.), Alpha(1.),
   AlphaColor(0), Translation(0), RenderFlags(0)
 {
 	RenderStyle = STYLE_None;
@@ -92,8 +92,8 @@ DBaseDecal::DBaseDecal (int statnum, fixed_t z)
 
 DBaseDecal::DBaseDecal (const AActor *basis)
 : DThinker(STAT_DECAL),
-  WallNext(0), WallPrev(0), LeftDistance(0), Z(basis->_f_Z()), ScaleX(FLOAT2FIXED(basis->Scale.X)), ScaleY(FLOAT2FIXED(basis->Scale.Y)),
-  Alpha(FLOAT2FIXED(basis->Alpha)), AlphaColor(basis->fillcolor), Translation(basis->Translation), PicNum(basis->picnum),
+  WallNext(0), WallPrev(0), LeftDistance(0), Z(basis->Z()), ScaleX(basis->Scale.X), ScaleY(basis->Scale.Y),
+	Alpha(basis->Alpha), AlphaColor(basis->fillcolor), Translation(basis->Translation), PicNum(basis->picnum),
   RenderFlags(basis->renderflags), RenderStyle(basis->RenderStyle)
 {
 }
@@ -101,7 +101,7 @@ DBaseDecal::DBaseDecal (const AActor *basis)
 DBaseDecal::DBaseDecal (const DBaseDecal *basis)
 : DThinker(STAT_DECAL),
   WallNext(0), WallPrev(0), LeftDistance(basis->LeftDistance), Z(basis->Z), ScaleX(basis->ScaleX),
-  ScaleY(basis->ScaleY), Alpha(basis->Alpha), AlphaColor(basis->AlphaColor), Translation(basis->Translation),
+	ScaleY(basis->ScaleY), Alpha(basis->Alpha), AlphaColor(basis->AlphaColor), Translation(basis->Translation),
   PicNum(basis->PicNum), RenderFlags(basis->RenderFlags), RenderStyle(basis->RenderStyle)
 {
 }
@@ -174,7 +174,7 @@ void DBaseDecal::SerializeChain (FArchive &arc, DBaseDecal **first)
 	}
 }
 
-void DBaseDecal::GetXY (side_t *wall, fixed_t &ox, fixed_t &oy) const
+void DBaseDecal::GetXY (side_t *wall, double &ox, double &oy) const
 {
 	line_t *line = wall->linedef;
 	vertex_t *v1, *v2;
@@ -190,11 +190,11 @@ void DBaseDecal::GetXY (side_t *wall, fixed_t &ox, fixed_t &oy) const
 		v2 = line->v1;
 	}
 
-	fixed_t dx = v2->x - v1->x;
-	fixed_t dy = v2->y - v1->y;
+	double dx = v2->fX() - v1->fX();
+	double dy = v2->fY() - v1->fY();
 
-	ox = v1->x + MulScale30 (LeftDistance, dx);
-	oy = v1->y + MulScale30 (LeftDistance, dy);
+	ox = v1->fX() + LeftDistance * dx;
+	oy = v1->fY() + LeftDistance * dy;
 }
 
 void DBaseDecal::SetShade (DWORD rgb)
@@ -209,7 +209,7 @@ void DBaseDecal::SetShade (int r, int g, int b)
 }
 
 // Returns the texture the decal stuck to.
-FTextureID DBaseDecal::StickToWall (side_t *wall, fixed_t x, fixed_t y, F3DFloor *ffloor)
+FTextureID DBaseDecal::StickToWall (side_t *wall, double x, double y, F3DFloor *ffloor)
 {
 	// Stick the decal at the end of the chain so it appears on top
 	DBaseDecal *next, **prev;
@@ -250,27 +250,27 @@ FTextureID DBaseDecal::StickToWall (side_t *wall, fixed_t x, fixed_t y, F3DFloor
 	{
 		RenderFlags |= RF_RELMID;
 		if (line->flags & ML_DONTPEGBOTTOM)
-			Z -= front->GetPlaneTexZ(sector_t::floor);
+			Z -= front->GetPlaneTexZF(sector_t::floor);
 		else
-			Z -= front->GetPlaneTexZ(sector_t::ceiling);
+			Z -= front->GetPlaneTexZF(sector_t::ceiling);
 		tex = wall->GetTexture(side_t::mid);
 	}
 	else if (back->floorplane.ZatPoint (x, y) >= Z)
 	{
 		RenderFlags |= RF_RELLOWER|RF_CLIPLOWER;
 		if (line->flags & ML_DONTPEGBOTTOM)
-			Z -= front->GetPlaneTexZ(sector_t::ceiling);
+			Z -= front->GetPlaneTexZF(sector_t::ceiling);
 		else
-			Z -= back->GetPlaneTexZ(sector_t::floor);
+			Z -= back->GetPlaneTexZF(sector_t::floor);
 		tex = wall->GetTexture(side_t::bottom);
 	}
 	else if (back->ceilingplane.ZatPoint (x, y) <= Z)
 	{
 		RenderFlags |= RF_RELUPPER|RF_CLIPUPPER;
 		if (line->flags & ML_DONTPEGTOP)
-			Z -= front->GetPlaneTexZ(sector_t::ceiling);
+			Z -= front->GetPlaneTexZF(sector_t::ceiling);
 		else
-			Z -= back->GetPlaneTexZ(sector_t::ceiling);
+			Z -= back->GetPlaneTexZF(sector_t::ceiling);
 		tex = wall->GetTexture(side_t::top);
 	}
 	else if (ffloor) // this is a 3d-floor segment - do this only if we know which one!
@@ -278,9 +278,9 @@ FTextureID DBaseDecal::StickToWall (side_t *wall, fixed_t x, fixed_t y, F3DFloor
 		Sector=ffloor->model;
 		RenderFlags |= RF_RELMID|RF_CLIPMID;
 		if (line->flags & ML_DONTPEGBOTTOM)
-			Z -= Sector->GetPlaneTexZ(sector_t::floor);
+			Z -= Sector->GetPlaneTexZF(sector_t::floor);
 		else
-			Z -= Sector->GetPlaneTexZ(sector_t::ceiling);
+			Z -= Sector->GetPlaneTexZF(sector_t::ceiling);
 
 		if (ffloor->flags & FF_UPPERTEXTURE)
 		{
@@ -308,7 +308,7 @@ FTextureID DBaseDecal::StickToWall (side_t *wall, fixed_t x, fixed_t y, F3DFloor
 	return tex;
 }
 
-fixed_t DBaseDecal::GetRealZ (const side_t *wall) const
+double DBaseDecal::GetRealZ (const side_t *wall) const
 {
 	const line_t *line = wall->linedef;
 	const sector_t *front, *back;
@@ -335,34 +335,34 @@ fixed_t DBaseDecal::GetRealZ (const side_t *wall) const
 	case RF_RELUPPER:
 		if (line->flags & ML_DONTPEGTOP)
 		{
-			return Z + front->GetPlaneTexZ(sector_t::ceiling);
+			return Z + front->GetPlaneTexZF(sector_t::ceiling);
 		}
 		else
 		{
-			return Z + back->GetPlaneTexZ(sector_t::ceiling);
+			return Z + back->GetPlaneTexZF(sector_t::ceiling);
 		}
 	case RF_RELLOWER:
 		if (line->flags & ML_DONTPEGBOTTOM)
 		{
-			return Z + front->GetPlaneTexZ(sector_t::ceiling);
+			return Z + front->GetPlaneTexZF(sector_t::ceiling);
 		}
 		else
 		{
-			return Z + back->GetPlaneTexZ(sector_t::floor);
+			return Z + back->GetPlaneTexZF(sector_t::floor);
 		}
 	case RF_RELMID:
 		if (line->flags & ML_DONTPEGBOTTOM)
 		{
-			return Z + front->GetPlaneTexZ(sector_t::floor);
+			return Z + front->GetPlaneTexZF(sector_t::floor);
 		}
 		else
 		{
-			return Z + front->GetPlaneTexZ(sector_t::ceiling);
+			return Z + front->GetPlaneTexZF(sector_t::ceiling);
 		}
 	}
 }
 
-void DBaseDecal::CalcFracPos (side_t *wall, fixed_t x, fixed_t y)
+void DBaseDecal::CalcFracPos (side_t *wall, double x, double y)
 {
 	line_t *line = wall->linedef;
 	vertex_t *v1, *v2;
@@ -378,16 +378,16 @@ void DBaseDecal::CalcFracPos (side_t *wall, fixed_t x, fixed_t y)
 		v2 = line->v1;
 	}
 
-	fixed_t dx = v2->x - v1->x;
-	fixed_t dy = v2->y - v1->y;
+	double dx = v2->fX() - v1->fX();
+	double dy = v2->fY() - v1->fY();
 
-	if (abs(dx) > abs(dy))
+	if (fabs(dx) > fabs(dy))
 	{
-		LeftDistance = SafeDivScale30 (x - v1->x, dx);
+		LeftDistance = (x - v1->fX()) / dx;
 	}
 	else if (dy != 0)
 	{
-		LeftDistance = SafeDivScale30 (y - v1->y, dy);
+		LeftDistance = (y - v1->fY()) / dy;
 	}
 	else
 	{
@@ -395,26 +395,26 @@ void DBaseDecal::CalcFracPos (side_t *wall, fixed_t x, fixed_t y)
 	}
 }
 
-static void GetWallStuff (side_t *wall, vertex_t *&v1, fixed_t &ldx, fixed_t &ldy)
+static void GetWallStuff (side_t *wall, vertex_t *&v1, double &ldx, double &ldy)
 {
 	line_t *line = wall->linedef;
 	if (line->sidedef[0] == wall)
 	{
 		v1 = line->v1;
-		ldx = line->dx;
-		ldy = line->dy;
+		ldx = line->Delta().X;
+		ldy = line->Delta().Y;
 	}
 	else
 	{
 		v1 = line->v2;
-		ldx = -line->dx;
-		ldy = -line->dy;
+		ldx = -line->Delta().X;
+		ldy = -line->Delta().Y;
 	}
 }
 
-static fixed_t Length (fixed_t dx, fixed_t dy)
+static double Length (double dx, double dy)
 {
-	return (fixed_t)g_sqrt ((double)dx*(double)dx+(double)dy*(double)dy);
+	return DVector2(dx, dy).Length();
 }
 
 static side_t *NextWall (const side_t *wall)
@@ -435,25 +435,25 @@ static side_t *NextWall (const side_t *wall)
 	return NULL;
 }
 
-void DBaseDecal::SpreadLeft (fixed_t r, vertex_t *v1, side_t *feelwall, F3DFloor *ffloor)
+void DBaseDecal::SpreadLeft (double r, vertex_t *v1, side_t *feelwall, F3DFloor *ffloor)
 {
-	fixed_t ldx, ldy;
+	double ldx, ldy;
 
 	SpreadStack.Push (feelwall);
 
 	while (r < 0 && feelwall->LeftSide != NO_SIDE)
 	{
-		fixed_t startr = r;
+		double startr = r;
 
-		fixed_t x = v1->x;
-		fixed_t y = v1->y;
+		double x = v1->fX();
+		double y = v1->fY();
 
 		feelwall = &sides[feelwall->LeftSide];
 		GetWallStuff (feelwall, v1, ldx, ldy);
-		fixed_t wallsize = Length (ldx, ldy);
+		double wallsize = Length (ldx, ldy);
 		r += DecalLeft;
-		x += Scale (r, ldx, wallsize);
-		y += Scale (r, ldy, wallsize);
+		x += r*ldx / wallsize;
+		y += r*ldy / wallsize;
 		r = wallsize + startr;
 		SpreadSource->CloneSelf (SpreadTemplate, x, y, SpreadZ, feelwall, ffloor);
 		SpreadStack.Push (feelwall);
@@ -479,10 +479,10 @@ void DBaseDecal::SpreadLeft (fixed_t r, vertex_t *v1, side_t *feelwall, F3DFloor
 	}
 }
 
-void DBaseDecal::SpreadRight (fixed_t r, side_t *feelwall, fixed_t wallsize, F3DFloor *ffloor)
+void DBaseDecal::SpreadRight (double r, side_t *feelwall, double wallsize, F3DFloor *ffloor)
 {
 	vertex_t *v1;
-	fixed_t x, y, ldx, ldy;
+	double x, y, ldx, ldy;
 
 	SpreadStack.Push (feelwall);
 
@@ -508,25 +508,25 @@ void DBaseDecal::SpreadRight (fixed_t r, side_t *feelwall, fixed_t wallsize, F3D
 
 		r = DecalWidth - r + wallsize - DecalLeft;
 		GetWallStuff (feelwall, v1, ldx, ldy);
-		x = v1->x;
-		y = v1->y;
+		x = v1->fX();
+		y = v1->fY();
 		wallsize = Length (ldx, ldy);
-		x -= Scale (r, ldx, wallsize);
-		y -= Scale (r, ldy, wallsize);
+		x -= r*ldx / wallsize;
+		y -= r*ldy / wallsize;
 		r = DecalRight - r;
 		SpreadSource->CloneSelf (SpreadTemplate, x, y, SpreadZ, feelwall, ffloor);
 		SpreadStack.Push (feelwall);
 	}
 }
 
-void DBaseDecal::Spread (const FDecalTemplate *tpl, side_t *wall, fixed_t x, fixed_t y, fixed_t z, F3DFloor * ffloor)
+void DBaseDecal::Spread (const FDecalTemplate *tpl, side_t *wall, double x, double y, double z, F3DFloor * ffloor)
 {
 	FTexture *tex;
 	vertex_t *v1;
-	fixed_t rorg, ldx, ldy;
+	double rorg, ldx, ldy;
 
 	GetWallStuff (wall, v1, ldx, ldy);
-	rorg = Length (x - v1->x, y - v1->y);
+	rorg = Length (x - v1->fX(), y - v1->fY());
 
 	if ((tex = TexMan[PicNum]) == NULL)
 	{
@@ -548,11 +548,11 @@ void DBaseDecal::Spread (const FDecalTemplate *tpl, side_t *wall, fixed_t x, fix
 
 	// Then try spreading right
 	SpreadRight (rorg + DecalRight, wall,
-			Length (wall->linedef->dx, wall->linedef->dy), ffloor);
+			Length (wall->linedef->Delta().X, wall->linedef->Delta().Y), ffloor);
 	SpreadStack.Clear ();
 }
 
-DBaseDecal *DBaseDecal::CloneSelf (const FDecalTemplate *tpl, fixed_t ix, fixed_t iy, fixed_t iz, side_t *wall, F3DFloor * ffloor) const
+DBaseDecal *DBaseDecal::CloneSelf (const FDecalTemplate *tpl, double ix, double iy, double iz, side_t *wall, F3DFloor * ffloor) const
 {
 	DBaseDecal *decal = new DBaseDecal(iz);
 	if (decal != NULL)
@@ -615,12 +615,12 @@ void DImpactDecal::Serialize (FArchive &arc)
 }
 
 DImpactDecal::DImpactDecal ()
-: DBaseDecal (STAT_AUTODECAL, 0)
+: DBaseDecal (STAT_AUTODECAL, 0.)
 {
 	ImpactCount++;
 }
 
-DImpactDecal::DImpactDecal (fixed_t z)
+DImpactDecal::DImpactDecal (double z)
 : DBaseDecal (STAT_AUTODECAL, z)
 {
 	ImpactCount++;
@@ -638,7 +638,7 @@ void DImpactDecal::CheckMax ()
 	}
 }
 
-DImpactDecal *DImpactDecal::StaticCreate (const char *name, const fixedvec3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color)
+DImpactDecal *DImpactDecal::StaticCreate (const char *name, const DVector3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color)
 {
 	if (cl_maxdecals > 0)
 	{
@@ -652,7 +652,7 @@ DImpactDecal *DImpactDecal::StaticCreate (const char *name, const fixedvec3 &pos
 	return NULL;
 }
 
-DImpactDecal *DImpactDecal::StaticCreate (const FDecalTemplate *tpl, const fixedvec3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color)
+DImpactDecal *DImpactDecal::StaticCreate (const FDecalTemplate *tpl, const DVector3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color)
 {
 	DImpactDecal *decal = NULL;
 	if (tpl != NULL && cl_maxdecals > 0 && !(wall->Flags & WALLF_NOAUTODECALS))
@@ -669,13 +669,13 @@ DImpactDecal *DImpactDecal::StaticCreate (const FDecalTemplate *tpl, const fixed
 			StaticCreate (tpl_low, pos, wall, ffloor, lowercolor);
 		}
 		DImpactDecal::CheckMax();
-		decal = new DImpactDecal (pos.z);
+		decal = new DImpactDecal (pos.Z);
 		if (decal == NULL)
 		{
 			return NULL;
 		}
 
-		if (!decal->StickToWall (wall, pos.x, pos.y, ffloor).isValid())
+		if (!decal->StickToWall (wall, pos.X, pos.Y, ffloor).isValid())
 		{
 			return NULL;
 		}
@@ -692,12 +692,12 @@ DImpactDecal *DImpactDecal::StaticCreate (const FDecalTemplate *tpl, const fixed
 		}
 
 		// Spread decal to nearby walls if it does not all fit on this one
-		decal->Spread (tpl, wall, pos.x, pos.y, pos.z, ffloor);
+		decal->Spread (tpl, wall, pos.X, pos.Y, pos.Z, ffloor);
 	}
 	return decal;
 }
 
-DBaseDecal *DImpactDecal::CloneSelf (const FDecalTemplate *tpl, fixed_t ix, fixed_t iy, fixed_t iz, side_t *wall, F3DFloor * ffloor) const
+DBaseDecal *DImpactDecal::CloneSelf (const FDecalTemplate *tpl, double ix, double iy, double iz, side_t *wall, F3DFloor * ffloor) const
 {
 	if (wall->Flags & WALLF_NOAUTODECALS)
 	{
@@ -758,7 +758,7 @@ CCMD (spray)
 	Net_WriteString (argv[1]);
 }
 
-DBaseDecal *ShootDecal(const FDecalTemplate *tpl, AActor *basisactor, sector_t *sec, fixed_t x, fixed_t y, fixed_t z, angle_t angle, fixed_t tracedist, bool permanent)
+DBaseDecal *ShootDecal(const FDecalTemplate *tpl, AActor *basisactor, sector_t *sec, double x, double y, double z, DAngle angle, double tracedist, bool permanent)
 {
 	if (tpl == NULL || (tpl = tpl->GetDecal()) == NULL)
 	{
@@ -769,30 +769,28 @@ DBaseDecal *ShootDecal(const FDecalTemplate *tpl, AActor *basisactor, sector_t *
 	DBaseDecal *decal;
 	side_t *wall;
 
-	angle >>= ANGLETOFINESHIFT;
-
-	Trace(x, y, z, sec,
-		finecosine[angle], finesine[angle], 0,
-		tracedist, 0, 0, NULL, trace, TRACE_NoSky);
+	Trace(FLOAT2FIXED(x), FLOAT2FIXED(y), FLOAT2FIXED(z), sec,
+		FLOAT2FIXED(angle.Cos()), FLOAT2FIXED(angle.Sin()), 0,
+		FLOAT2FIXED(tracedist), 0, 0, NULL, trace, TRACE_NoSky);
 
 	if (trace.HitType == TRACE_HitWall)
 	{
 		if (permanent)
 		{
-			decal = new DBaseDecal(trace.HitPos.z);
+			decal = new DBaseDecal(FIXED2DBL(trace.HitPos.z));
 			wall = trace.Line->sidedef[trace.Side];
-			decal->StickToWall(wall, trace.HitPos.x, trace.HitPos.y, trace.ffloor);
+			decal->StickToWall(wall, FIXED2DBL(trace.HitPos.x), FIXED2DBL(trace.HitPos.y), trace.ffloor);
 			tpl->ApplyToDecal(decal, wall);
 			// Spread decal to nearby walls if it does not all fit on this one
 			if (cl_spreaddecals)
 			{
-				decal->Spread(tpl, wall, trace.HitPos.x, trace.HitPos.y, trace.HitPos.z, trace.ffloor);
+				decal->Spread(tpl, wall, FIXED2DBL(trace.HitPos.x), FIXED2DBL(trace.HitPos.y), FIXED2DBL(trace.HitPos.z), trace.ffloor);
 			}
 			return decal;
 		}
 		else
 		{
-			return DImpactDecal::StaticCreate(tpl, trace.HitPos, trace.Line->sidedef[trace.Side], NULL);
+			return DImpactDecal::StaticCreate(tpl, DVector3(FIXED2DBL(trace.HitPos.x), FIXED2DBL(trace.HitPos.y), FIXED2DBL(trace.HitPos.z)), trace.Line->sidedef[trace.Side], NULL);
 		}
 	}
 	return NULL;
@@ -827,7 +825,7 @@ void ADecal::BeginPlay ()
 			// Look for a wall within 64 units behind the actor. If none can be
 			// found, then no decal is created, and this actor is destroyed
 			// without effectively doing anything.
-			if (NULL == ShootDecal(tpl, this, Sector, _f_X(), _f_Y(), _f_Z(), FLOAT2ANGLE(Angles.Yaw.Degrees) + ANGLE_180, 64*FRACUNIT, true))
+			if (NULL == ShootDecal(tpl, this, Sector, X(), Y(), Z(), Angles.Yaw + 180, 64., true))
 			{
 				DPrintf ("Could not find a wall to stick decal to at (%f,%f)\n", X(), Y());
 			}
diff --git a/src/g_shared/a_sharedglobal.h b/src/g_shared/a_sharedglobal.h
index ff08a04d9..a4f743460 100644
--- a/src/g_shared/a_sharedglobal.h
+++ b/src/g_shared/a_sharedglobal.h
@@ -8,9 +8,10 @@ class FDecalTemplate;
 struct vertex_t;
 struct side_t;
 struct F3DFloor;
+class DBaseDecal;
 
 void P_SpawnDirt (AActor *actor, double radius);
-class DBaseDecal *ShootDecal(const FDecalTemplate *tpl, AActor *basisactor, sector_t *sec, fixed_t x, fixed_t y, fixed_t z, angle_t angle, fixed_t tracedist, bool permanent);
+class DBaseDecal *ShootDecal(const FDecalTemplate *tpl, AActor *basisactor, sector_t *sec, double x, double y, double z, DAngle angle, double tracedist, bool permanent);
 
 class DBaseDecal : public DThinker
 {
@@ -18,28 +19,28 @@ class DBaseDecal : public DThinker
 	HAS_OBJECT_POINTERS
 public:
 	DBaseDecal ();
-	DBaseDecal (fixed_t z);
-	DBaseDecal (int statnum, fixed_t z);
+	DBaseDecal(double z);
+	DBaseDecal(int statnum, double z);
 	DBaseDecal (const AActor *actor);
 	DBaseDecal (const DBaseDecal *basis);
 
 	void Serialize (FArchive &arc);
 	void Destroy ();
-	FTextureID StickToWall (side_t *wall, fixed_t x, fixed_t y, F3DFloor * ffloor);
-	fixed_t GetRealZ (const side_t *wall) const;
+	FTextureID StickToWall(side_t *wall, double x, double y, F3DFloor * ffloor);
+	double GetRealZ (const side_t *wall) const;
 	void SetShade (DWORD rgb);
 	void SetShade (int r, int g, int b);
-	void Spread (const FDecalTemplate *tpl, side_t *wall, fixed_t x, fixed_t y, fixed_t z, F3DFloor * ffloor);
-	void GetXY (side_t *side, fixed_t &x, fixed_t &y) const;
+	void Spread (const FDecalTemplate *tpl, side_t *wall, double x, double y, double z, F3DFloor * ffloor);
+	void GetXY (side_t *side, double &x, double &y) const;
 
 	static void SerializeChain (FArchive &arc, DBaseDecal **firstptr);
 
 	DBaseDecal *WallNext, **WallPrev;
 
-	fixed_t LeftDistance;
-	fixed_t Z;
-	fixed_t ScaleX, ScaleY;
-	fixed_t Alpha;
+	double LeftDistance;
+	double Z;
+	double ScaleX, ScaleY;
+	double Alpha;
 	DWORD AlphaColor;
 	int Translation;
 	FTextureID PicNum;
@@ -48,23 +49,23 @@ public:
 	sector_t * Sector;	// required for 3D floors
 
 protected:
-	virtual DBaseDecal *CloneSelf (const FDecalTemplate *tpl, fixed_t x, fixed_t y, fixed_t z, side_t *wall, F3DFloor * ffloor) const;
-	void CalcFracPos (side_t *wall, fixed_t x, fixed_t y);
+	virtual DBaseDecal *CloneSelf(const FDecalTemplate *tpl, double x, double y, double z, side_t *wall, F3DFloor * ffloor) const;
+	void CalcFracPos(side_t *wall, double x, double y);
 	void Remove ();
 
-	static void SpreadLeft (fixed_t r, vertex_t *v1, side_t *feelwall, F3DFloor *ffloor);
-	static void SpreadRight (fixed_t r, side_t *feelwall, fixed_t wallsize, F3DFloor *ffloor);
+	static void SpreadLeft (double r, vertex_t *v1, side_t *feelwall, F3DFloor *ffloor);
+	static void SpreadRight (double r, side_t *feelwall, double wallsize, F3DFloor *ffloor);
 };
 
 class DImpactDecal : public DBaseDecal
 {
 	DECLARE_CLASS (DImpactDecal, DBaseDecal)
 public:
-	DImpactDecal (fixed_t z);
+	DImpactDecal(double z);
 	DImpactDecal (side_t *wall, const FDecalTemplate *templ);
 
-	static DImpactDecal *StaticCreate (const char *name, const fixedvec3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color=0);
-	static DImpactDecal *StaticCreate (const FDecalTemplate *tpl, const fixedvec3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color=0);
+	static DImpactDecal *StaticCreate(const char *name, const DVector3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color = 0);
+	static DImpactDecal *StaticCreate(const FDecalTemplate *tpl, const DVector3 &pos, side_t *wall, F3DFloor * ffloor, PalEntry color = 0);
 
 	void BeginPlay ();
 	void Destroy ();
@@ -73,7 +74,7 @@ public:
 	static void SerializeTime (FArchive &arc);
 
 protected:
-	DBaseDecal *CloneSelf (const FDecalTemplate *tpl, fixed_t x, fixed_t y, fixed_t z, side_t *wall, F3DFloor * ffloor) const;
+	DBaseDecal *CloneSelf(const FDecalTemplate *tpl, double x, double y, double z, side_t *wall, F3DFloor * ffloor) const;
 	static void CheckMax ();
 
 private:
diff --git a/src/p_acs.cpp b/src/p_acs.cpp
index 8d6802eae..7a1062975 100644
--- a/src/p_acs.cpp
+++ b/src/p_acs.cpp
@@ -4768,9 +4768,9 @@ static bool DoSpawnDecal(AActor *actor, const FDecalTemplate *tpl, int flags, an
 	{
 		angle += actor->_f_angle();
 	}
-	return NULL != ShootDecal(tpl, actor, actor->Sector, actor->_f_X(), actor->_f_Y(),
-		actor->_f_Z() + (actor->_f_height()>>1) - actor->_f_floorclip() + actor->GetBobOffset() + zofs,
-		angle, distance, !!(flags & SDF_PERMANENT));
+	return NULL != ShootDecal(tpl, actor, actor->Sector, actor->X(), actor->Y(),
+		actor->Center() - actor->Floorclip + actor->GetBobOffset() + FIXED2DBL(zofs),
+		DAngle(ANGLE2DBL(angle)), FIXED2DBL(distance), !!(flags & SDF_PERMANENT));
 }
 
 static void SetActorAngle(AActor *activator, int tid, int angle, bool interpolate)
diff --git a/src/p_map.cpp b/src/p_map.cpp
index b36517507..7e6902697 100644
--- a/src/p_map.cpp
+++ b/src/p_map.cpp
@@ -4540,7 +4540,8 @@ void P_TraceBleed(int damage, fixed_t x, fixed_t y, fixed_t z, AActor *actor, an
 					bloodcolor.a = 1;
 				}
 
-				DImpactDecal::StaticCreate(bloodType, bleedtrace.HitPos, 
+				DVector3 hp(FIXED2DBL(bleedtrace.HitPos.x), FIXED2DBL(bleedtrace.HitPos.y), FIXED2DBL(bleedtrace.HitPos.z));
+				DImpactDecal::StaticCreate(bloodType, hp,
 					bleedtrace.Line->sidedef[bleedtrace.Side], bleedtrace.ffloor, bloodcolor);
 			}
 		}
@@ -6418,8 +6419,9 @@ void SpawnShootDecal(AActor *t1, const FTraceResults &trace)
 	}
 	if (decalbase != NULL)
 	{
+		DVector3 hp(FIXED2DBL(trace.HitPos.x), FIXED2DBL(trace.HitPos.y), FIXED2DBL(trace.HitPos.z));
 		DImpactDecal::StaticCreate(decalbase->GetDecal(),
-			trace.HitPos, trace.Line->sidedef[trace.Side], trace.ffloor);
+			hp, trace.Line->sidedef[trace.Side], trace.ffloor);
 	}
 }
 
diff --git a/src/p_mobj.cpp b/src/p_mobj.cpp
index c62498c13..6c3e0adef 100644
--- a/src/p_mobj.cpp
+++ b/src/p_mobj.cpp
@@ -1445,7 +1445,7 @@ void P_ExplodeMissile (AActor *mo, line_t *line, AActor *target)
 						}
 					}
 
-					DImpactDecal::StaticCreate(base->GetDecal(), { x, y, z }, line->sidedef[side], ffloor);
+					DImpactDecal::StaticCreate(base->GetDecal(), DVector3(FIXED2DBL(x), FIXED2DBL(y), FIXED2DBL(z)), line->sidedef[side], ffloor);
 				}
 			}
 		}
diff --git a/src/r_defs.h b/src/r_defs.h
index 241f66f61..01150afd0 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -95,6 +95,16 @@ struct vertex_t
 {
 	fixed_t x, y;
 
+	double fX() const
+	{
+		return FIXED2DBL(x);
+	}
+
+	double fY() const
+	{
+		return FIXED2DBL(y);
+	}
+
 	bool operator== (const vertex_t &other)
 	{
 		return x == other.x && y == other.y;
@@ -724,6 +734,11 @@ struct sector_t
 		return planes[pos].TexZ;
 	}
 
+	double GetPlaneTexZF(int pos) const
+	{
+		return FIXED2DBL(planes[pos].TexZ);
+	}
+
 	void SetPlaneTexZ(int pos, fixed_t val)
 	{
 		planes[pos].TexZ = val;
diff --git a/src/r_segs.cpp b/src/r_segs.cpp
index 8d2c3767b..d31c233d5 100644
--- a/src/r_segs.cpp
+++ b/src/r_segs.cpp
@@ -3022,7 +3022,7 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 	fixed_t xscale, yscale;
 	fixed_t topoff;
 	BYTE flipx;
-	fixed_t zpos;
+	double zpos;
 	int needrepeat = 0;
 	sector_t *front, *back;
 	bool calclighting;
@@ -3044,36 +3044,36 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 	case RF_RELUPPER:
 		if (curline->linedef->flags & ML_DONTPEGTOP)
 		{
-			zpos = decal->Z + front->GetPlaneTexZ(sector_t::ceiling);
+			zpos = decal->Z + front->GetPlaneTexZF(sector_t::ceiling);
 		}
 		else
 		{
-			zpos = decal->Z + back->GetPlaneTexZ(sector_t::ceiling);
+			zpos = decal->Z + back->GetPlaneTexZF(sector_t::ceiling);
 		}
 		break;
 	case RF_RELLOWER:
 		if (curline->linedef->flags & ML_DONTPEGBOTTOM)
 		{
-			zpos = decal->Z + front->GetPlaneTexZ(sector_t::ceiling);
+			zpos = decal->Z + front->GetPlaneTexZF(sector_t::ceiling);
 		}
 		else
 		{
-			zpos = decal->Z + back->GetPlaneTexZ(sector_t::floor);
+			zpos = decal->Z + back->GetPlaneTexZF(sector_t::floor);
 		}
 		break;
 	case RF_RELMID:
 		if (curline->linedef->flags & ML_DONTPEGBOTTOM)
 		{
-			zpos = decal->Z + front->GetPlaneTexZ(sector_t::floor);
+			zpos = decal->Z + front->GetPlaneTexZF(sector_t::floor);
 		}
 		else
 		{
-			zpos = decal->Z + front->GetPlaneTexZ(sector_t::ceiling);
+			zpos = decal->Z + front->GetPlaneTexZF(sector_t::ceiling);
 		}
 	}
 
-	xscale = decal->ScaleX;
-	yscale = decal->ScaleY;
+	xscale = FLOAT2FIXED(decal->ScaleX);
+	yscale = FLOAT2FIXED(decal->ScaleY);
 
 	WallSpriteTile = TexMan(decal->PicNum, true);
 	flipx = (BYTE)(decal->RenderFlags & RF_XFLIP);
@@ -3096,7 +3096,10 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 	x1 *= xscale;
 	x2 *= xscale;
 
-	decal->GetXY (wall, decalx, decaly);
+	double dcx, dcy;
+	decal->GetXY(wall, dcx, dcy);
+	decalx = FLOAT2FIXED(dcx);
+	decaly = FLOAT2FIXED(dcy);
 
 	angle_t ang = R_PointToAngle2 (curline->v1->x, curline->v1->y, curline->v2->x, curline->v2->y) >> ANGLETOFINESHIFT;
 	lx  = decalx - FixedMul (x1, finecosine[ang]) - viewx;
@@ -3169,8 +3172,9 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 		break;
 	}
 
+	fixed_t fzpos = FLOAT2FIXED(zpos);
 	topoff = WallSpriteTile->TopOffset << FRACBITS;
-	dc_texturemid = topoff + FixedDiv (zpos - viewz, yscale);
+	dc_texturemid = topoff + FixedDiv (fzpos - viewz, yscale);
 
 	// Clip sprite to drawseg
 	x1 = MAX<int>(clipper->x1, x1);
@@ -3235,7 +3239,7 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 		dc_x = x1;
 		ESPSResult mode;
 
-		mode = R_SetPatchStyle (decal->RenderStyle, decal->Alpha, decal->Translation, decal->AlphaColor);
+		mode = R_SetPatchStyle (decal->RenderStyle, (float)decal->Alpha, decal->Translation, decal->AlphaColor);
 
 		// R_SetPatchStyle can modify basecolormap.
 		if (rereadcolormap)