marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merged alphafix into mesh

stable-5.2
Armin Burgmeier 2009-08-27 21:52:10 -04:00
parent 4fa029df2c 772ba197c9
commit 0137936211
31 changed files with 200 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
planet/System.c4g/Colors.c
View File

@ -10,7 +10,7 @@ static const RGBA_BLUE = 3;
global func HSL(int h, int s, int l) { return HSL2RGB(RGB(h,s,l)); }
global func HSLa(int h, int s, int l, int a) { return HSL2RGB(RGB(h,s,l)) | (a & 255)<<24; }
global func RGB(int r, int g, int b) { return (r & 255)<<16 | (g & 255)<<8 | (b & 255); }
global func RGB(int r, int g, int b) { return (255 << 24) | (r & 255)<<16 | (g & 255)<<8 | (b & 255); }
global func RGBa (int r, int g, int b, int a) { return (a & 255)<<24 | (r & 255)<<16 | (g & 255)<<8 | (b & 255); }
global func GetRGBaValue(int val, int sel) { return (val>>((3-sel)*8)&255); }

8
src/control/C4PlayerInfo.cpp
View File

@ -48,7 +48,7 @@ void C4PlayerInfo::Clear()
pRes = NULL;
ResCore.Clear();
// default fields
dwColor = dwOriginalColor = 0xffffff;
dwColor = dwOriginalColor = 0xffffffff;
dwAlternateColor = 0;
dwFlags = 0;
iID = idSavegamePlayer = idTeam = 0;
@ -91,8 +91,8 @@ bool C4PlayerInfo::LoadFromLocalFile(const char *szFilename)
eType = C4PT_User;
sName = C4P.PrefName;
this->szFilename = szFilename;
dwColor = dwOriginalColor = C4P.PrefColorDw & 0xffffff; // ignore alpha
dwAlternateColor = C4P.PrefColor2Dw & 0xffffff; // ignore alpha
dwColor = dwOriginalColor = 0xff000000 | (C4P.PrefColorDw & 0xffffff); // ignore alpha
dwAlternateColor = 0xff000000 | (C4P.PrefColor2Dw & 0xffffff); // ignore alpha
// network: ressource (not for replays, because everyone has the player files there...)
if (::Network.isEnabled() && !Game.C4S.Head.Replay)
{
@ -118,7 +118,7 @@ bool C4PlayerInfo::SetAsScriptPlayer(const char *szName, uint32_t dwColor, uint3
Clear();
// set parameters
eType = C4PT_Script;
dwColor = dwOriginalColor = dwColor & 0xffffff; // ignore alpha
dwColor = dwOriginalColor = 0xff000000 | (dwColor & 0xffffff); // ignore alpha
dwAlternateColor = 0;
this->sName.CopyValidated(szName);
idExtraData = idExtra;

4
src/control/C4PlayerInfo.h
View File

@ -105,8 +105,8 @@ class C4PlayerInfo
public:
C4PlayerInfo() // construct empty
: dwFlags(0), iID(0), pRes(0), szFilename(0), dwColor(0xffffff), sLeagueAccount(""),
dwOriginalColor(0xffffff), dwAlternateColor(0), idSavegamePlayer(0), idTeam(0),
: dwFlags(0), iID(0), pRes(0), szFilename(0), dwColor(0xffffffff), sLeagueAccount(""),
dwOriginalColor(0xffffffff), dwAlternateColor(0), idSavegamePlayer(0), idTeam(0),
iLeagueScore(0), iLeagueRank(0), iLeagueRankSymbol(0), iLeagueProjectedGain(-1),
iInGameNumber(-1), iInGameJoinFrame(-1), iInGamePartFrame(-1), eType(C4PT_User), idExtraData(C4ID_None) { }

26
src/editor/C4EditCursor.cpp
View File

@ -413,7 +413,7 @@ void C4EditCursor::Draw(C4TargetFacet &cgo, float Zoom)
{
uint32_t dwOldMod = cobj->ColorMod;
uint32_t dwOldBlitMode = cobj->BlitMode;
cobj->ColorMod = 0xffffff;
cobj->ColorMod = 0xffffffff;
cobj->BlitMode = C4GFXBLIT_CLRSFC_MOD2 | C4GFXBLIT_ADDITIVE;
cobj->Draw(cgo,-1);
cobj->DrawTopFace(cgo, -1);
@ -441,21 +441,21 @@ void C4EditCursor::DrawSelectMark(C4Facet &cgo, FLOAT_RECT frame)
if (!cgo.Surface) return;
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.top,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left+1,frame.top,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.top+1,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.top,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left+1,frame.top,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.top+1,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.bottom-1,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left+1,frame.bottom-1,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.bottom-2,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.bottom-1,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left+1,frame.bottom-1,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.left,frame.bottom-2,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.top,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-2,frame.top,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.top+1,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.top,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-2,frame.top,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.top+1,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.bottom-1,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-2,frame.bottom-1,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.bottom-2,0xFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.bottom-1,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-2,frame.bottom-1,0xFFFFFFFF);
Application.DDraw->DrawPix(cgo.Surface,frame.right-1,frame.bottom-2,0xFFFFFFFF);
}

9
src/game/landscape/C4Landscape.cpp
View File

@ -2491,6 +2491,11 @@ bool C4Landscape::ApplyLighting(C4Rect To)
// everything clipped?
if (To.Wdt<=0 || To.Hgt<=0) return true;
if (!Surface32->Lock()) return false;
// We clear the affected region here because ClearBoxDw allocates the
// main memory buffer for the box, so that only that box needs to be
// sent to the gpu, and not the whole texture, or every pixel
// separately. It's an important optimization.
Surface32->ClearBoxDw(To.x, To.y, To.Wdt, To.Hgt);
if(lpDDraw->IsShaderific() && Config.Graphics.HighResLandscape)
@ -2774,8 +2779,8 @@ bool C4Landscape::Mat2Pal()
= Surface8->pPal->Colors[(MatTex2PixCol(tex)+IFT)*3+rgb]
= dwPix >> ((2-rgb) * 8);
// alpha
Surface8->pPal->Alpha[MatTex2PixCol(tex)] = 0;
Surface8->pPal->Alpha[MatTex2PixCol(tex)+IFT] = 0;
Surface8->pPal->Alpha[MatTex2PixCol(tex)] = 0xff;
Surface8->pPal->Alpha[MatTex2PixCol(tex)+IFT] = 0xff;
}
// success
return true;

14
src/game/landscape/C4Particles.cpp
View File

@ -568,7 +568,7 @@ bool fxSmokeInit(C4Particle *pPrt, C4Object *pTarget)
// set kind - ydir is unused anyway; set last kind reeeaaally seldom
pPrt->ydir=(float) SafeRandom(15)+SafeRandom(300)/299;
// set color
if (!pPrt->b) pPrt->b=0xff4b4b4b; else pPrt->b|=0xff000000;
if (!pPrt->b) pPrt->b=0x004b4b4b; else pPrt->b&=~0xff000000;
// always OK
return true;
}
@ -584,14 +584,14 @@ bool fxSmokeExec(C4Particle *pPrt, C4Object *pTarget)
// decrease init-time
pPrt->life-=0x010000;
// increase color value
pPrt->b-=0x10000000;
pPrt->b+=0x10000000;
// if full-grown, adjust to lifetime
if (!(pPrt->life&0x7fff0000))
pPrt->b=(pPrt->b&0xffffff)|((255-pPrt->life)<<24);
pPrt->b=(pPrt->b&0xffffff)|((pPrt->life)<<24);
}
// color change
DWORD dwClr = pPrt->b;
pPrt->b = (LightenClrBy(dwClr, 1)&0xffffff) | Min<int32_t>((dwClr>>24)+1, 255)<<24;
pPrt->b = (LightenClrBy(dwClr, 1)&0xffffff) | Min<int32_t>((dwClr>>24)-1, 255)<<24;
// wind to float
if (!(pPrt->b%12) || fBuilding)
{
@ -645,7 +645,7 @@ bool fxStdInit(C4Particle *pPrt, C4Object *pTarget)
// init lifetime as phase
pPrt->life=SafeRandom(pPrt->pDef->Length);
// default color
if (!pPrt->b) pPrt->b=0xffffff;
if (!pPrt->b) pPrt->b=0xffffffff;
// always OK
return true;
}
@ -709,8 +709,8 @@ bool fxStdExec(C4Particle *pPrt, C4Object *pTarget)
{
DWORD dwClr=pPrt->b;
int32_t iAlpha=dwClr>>24;
iAlpha+=pPrt->pDef->AlphaFade;
if (iAlpha>=0xff) return false;
iAlpha-=pPrt->pDef->AlphaFade;
if (iAlpha<=0x00) return false;
pPrt->b=(dwClr&0xffffff) | (iAlpha<<24);
}
}

14
src/game/landscape/C4Sky.cpp
View File

@ -123,7 +123,7 @@ bool C4Sky::Init(bool fSavegame)
FadeClr2=Surface->pPal->GetClr(19);
}
else*/
FadeClr1=FadeClr2=0xffffff;
FadeClr1=FadeClr2=0xffffffff;
// enlarge surface to avoid slow 1*1-px-skies
if (!SurfaceEnsureSize(&Surface, 128, 128)) return false;
@ -175,7 +175,7 @@ void C4Sky::Default()
Width=Height=0;
Surface=NULL;
x=y=xdir=ydir=0;
Modulation=0x00ffffff;
Modulation=0xffffffff;
ParX=ParY=10;
ParallaxMode=C4SkyPM_Fixed;
BackClr=0;
@ -190,7 +190,7 @@ C4Sky::~C4Sky()
void C4Sky::Clear()
{
delete Surface; Surface=NULL;
Modulation=0x00ffffff;
Modulation=0xffffffff;
}
bool C4Sky::Save(C4Group &hGroup)
@ -227,7 +227,7 @@ void C4Sky::Draw(C4TargetFacet &cgo)
// background color?
if (BackClrEnabled) Application.DDraw->DrawBoxDw(cgo.Surface, cgo.X, cgo.Y, cgo.X+cgo.Wdt, cgo.Y+cgo.Hgt, BackClr);
// sky surface?
if (Modulation != 0xffffff) Application.DDraw->ActivateBlitModulation(Modulation);
if (Modulation != 0xffffffff) Application.DDraw->ActivateBlitModulation(Modulation);
if (Surface)
{
// blit parallax sky
@ -242,7 +242,7 @@ void C4Sky::Draw(C4TargetFacet &cgo)
DWORD dwClr2=GetSkyFadeClr(cgo.TargetY+cgo.Hgt);
Application.DDraw->DrawBoxFade(cgo.Surface, cgo.X, cgo.Y, cgo.Wdt, cgo.Hgt, dwClr1, dwClr1, dwClr2, dwClr2, cgo.TargetX, cgo.TargetY);
}
if (Modulation != 0xffffff) Application.DDraw->DeactivateBlitModulation();
if (Modulation != 0xffffffff) Application.DDraw->DeactivateBlitModulation();
// done
}
@ -258,7 +258,7 @@ bool C4Sky::SetModulation(DWORD dwWithClr, DWORD dwBackClr)
{
Modulation=dwWithClr;
BackClr=dwBackClr;
BackClrEnabled=(Modulation>>24) ? true : false;
BackClrEnabled=(Modulation>>24 != 0xff) ? true : false;
return true;
}
@ -268,7 +268,7 @@ void C4Sky::CompileFunc(StdCompiler *pComp)
pComp->Value(mkNamingAdapt(mkCastIntAdapt(y), "Y", Fix0));
pComp->Value(mkNamingAdapt(mkCastIntAdapt(xdir),"XDir", Fix0));
pComp->Value(mkNamingAdapt(mkCastIntAdapt(ydir),"YDir", Fix0));
pComp->Value(mkNamingAdapt(Modulation, "Modulation", 0x00ffffffU));
pComp->Value(mkNamingAdapt(Modulation, "Modulation", 0xffffffffU));
pComp->Value(mkNamingAdapt(ParX, "ParX", 10));
pComp->Value(mkNamingAdapt(ParY, "ParY", 10));
pComp->Value(mkNamingAdapt(ParallaxMode, "ParMode", C4SkyPM_Fixed));

15
src/game/object/C4Object.cpp
View File

@ -148,7 +148,8 @@ void C4Object::Default()
MaterialContents=NULL;
LocalNamed.Reset();
Marker=0;
ColorMod=BlitMode=0;
ColorMod=0xffffffff;
BlitMode=0;
CrewDisabled=false;
pLayer=NULL;
pSolidMaskData=NULL;
@ -2439,7 +2440,7 @@ void C4Object::Draw(C4TargetFacet &cgo, int32_t iByPlayer, DrawMode eDrawMode)
}
// color modulation (including construction sign...)
if (ColorMod || BlitMode) if (!eDrawMode) PrepareDrawing();
if (ColorMod != 0xffffffff || BlitMode) if (!eDrawMode) PrepareDrawing();
// Not active or rotated: BaseFace only
if (!Action.pActionDef)
@ -2470,7 +2471,7 @@ void C4Object::Draw(C4TargetFacet &cgo, int32_t iByPlayer, DrawMode eDrawMode)
}
// end of color modulation
if (ColorMod || BlitMode) if (!eDrawMode) FinishedDrawing();
if (ColorMod != 0xffffffff || BlitMode) if (!eDrawMode) FinishedDrawing();
// draw overlays - after blit mode changes, because overlay gfx set their own
if (pGfxOverlay) if (eDrawMode!=ODM_BaseOnly)
@ -2661,7 +2662,7 @@ void C4Object::DrawLine(C4TargetFacet &cgo)
// Draw line segments
C4Value colorsV; GetProperty(Strings.P[P_LineColors], colorsV);
C4ValueArray *colors = colorsV.getArray();
int32_t color0 = 0x00FF00FF, color1 = 0x00FF00FF; // use bright colors so author notices
int32_t color0 = 0xFFFF00FF, color1 = 0xFFFF00FF; // use bright colors so author notices
if (colors)
{
color0 = colors->GetItem(0).getInt(); color1 = colors->GetItem(1).getInt();
@ -2787,7 +2788,7 @@ void C4Object::CompileFunc(StdCompiler *pComp)
pComp->Value(mkNamingAdapt( Contents, "Contents" ));
pComp->Value(mkNamingAdapt( PlrViewRange, "PlrViewRange", 0 ));
pComp->Value(mkNamingAdapt( LocalNamed, "LocalNamed" ));
pComp->Value(mkNamingAdapt( ColorMod, "ColorMod", 0u ));
pComp->Value(mkNamingAdapt( ColorMod, "ColorMod", 0xffffffffu ));
pComp->Value(mkNamingAdapt( BlitMode, "BlitMode", 0u ));
pComp->Value(mkNamingAdapt( CrewDisabled, "CrewDisabled", false ));
pComp->Value(mkNamingAdapt( nLayer, "Layer", 0 ));
@ -3131,7 +3132,7 @@ void C4Object::Picture2Facet(C4FacetSurface &cgo)
fctPicture.Set(GetGraphics()->GetBitmap(Color),fctPicRect.x,fctPicRect.y,fctPicRect.Wdt,fctPicRect.Hgt);
// use direct facet w/o own data if possible
if (!ColorMod && BlitMode == C4GFXBLIT_NORMAL && !pGfxOverlay)
if (ColorMod == 0xffffffff && BlitMode == C4GFXBLIT_NORMAL && !pGfxOverlay)
{
cgo.Set(fctPicture);
return;
@ -5566,7 +5567,7 @@ void C4Object::SetRotation(int32_t nr)
void C4Object::PrepareDrawing()
{
// color modulation
if (ColorMod || (BlitMode & (C4GFXBLIT_MOD2 | C4GFXBLIT_CLRSFC_MOD2))) Application.DDraw->ActivateBlitModulation(ColorMod);
if (ColorMod != 0xffffffff || (BlitMode & (C4GFXBLIT_MOD2 | C4GFXBLIT_CLRSFC_MOD2))) Application.DDraw->ActivateBlitModulation(ColorMod);
// other blit modes
Application.DDraw->SetBlitMode(BlitMode);
}

4
src/game/player/C4Player.cpp
View File

@ -661,7 +661,7 @@ void C4Player::PlaceReadyMaterial(int32_t tx1, int32_t tx2, int32_t ty, C4Object
DWORD RandomPlayerColor() // generate a random player color
{
return RGB(Min(SafeRandom(302), 256), Min(SafeRandom(302), 256), Min(SafeRandom(302), 256));
return 0xff<<24 | RGB(Min(SafeRandom(302), 256), Min(SafeRandom(302), 256), Min(SafeRandom(302), 256));
}
bool C4Player::ScenarioInit()
@ -1972,7 +1972,7 @@ bool C4Player::FoWIsVisible(int32_t x, int32_t y)
if (Distance(cobj->GetX(), cobj->GetY(), x, y) < Abs(iRange))
if (iRange < 0)
{
if (!(cobj->ColorMod & 0xff000000)) // faded generators generate darkness only; no FoW blocking
if ((cobj->ColorMod & 0xff000000) != 0xff000000) // faded generators generate darkness only; no FoW blocking
return false; // shadowed by FoW-generator
}
else

3
src/game/script/C4Script.cpp
View File

@ -5390,8 +5390,7 @@ static bool FnCustomMessage(C4AulContext *ctx, C4String *pMsg, C4Object *pObj, l
throw new C4AulExecError(ctx->Obj, "CustomMessage: Only one vertical positioning flag allowed!");
}
// message color
if (!dwClr) dwClr = 0xffffff;
dwClr = InvertRGBAAlpha(dwClr);
if (!dwClr) dwClr = 0xffffffff;
// message type
int32_t iType;
if (pObj)

20
src/gui/C4Gui.h
View File

@ -69,31 +69,31 @@ class C4GroupSet;
#define C4GUI_GfxTabCaptInactiveClr 0xff000000
// other colors
#define C4GUI_ImportantBGColor 0xcf00007f
#define C4GUI_ProgressBarColor 0xafffffff
#define C4GUI_ListBoxSelColor 0xafaf0000
#define C4GUI_ListBoxInactSelColor 0xaf7f7f7f
#define C4GUI_ContextSelColor 0xafaf0000
#define C4GUI_ContextBGColor 0x4f3f1a00
#define C4GUI_StandardBGColor 0x5f000000
#define C4GUI_ImportantBGColor 0x2f00007f
#define C4GUI_ProgressBarColor 0x4fffffff
#define C4GUI_ListBoxSelColor 0x4faf0000
#define C4GUI_ListBoxInactSelColor 0x4f7f7f7f
#define C4GUI_ContextSelColor 0x4faf0000
#define C4GUI_ContextBGColor 0xaf3f1a00
#define C4GUI_StandardBGColor 0x9f000000
#define C4GUI_ActiveTabBGColor C4GUI_StandardBGColor
#define C4GUI_ListBoxBarColor 0x7f772200
#define C4GUI_EditBGColor 0x7f000000
#define C4GUI_EditFontColor 0xffffffff
#define C4GUI_ToolTipBGColor 0x00F1EA78
#define C4GUI_ToolTipBGColor 0xFFF1EA78
#define C4GUI_ToolTipFrameColor 0x7f000000
#define C4GUI_ToolTipColor 0xFF483222
// winner/loser color marking
#define C4GUI_WinningTextColor 0xffffdf00
#define C4GUI_WinningBackgroundColor 0x4faf7a00
#define C4GUI_WinningBackgroundColor 0xafaf7a00
#define C4GUI_LosingTextColor 0xffffffff
#define C4GUI_LosingBackgroundColor 0x7fafafaf
// border colors for 3D-frames
#define C4GUI_BorderAlpha 0xaf
#define C4GUI_BorderAlpha 0x4f
#define C4GUI_BorderColor1 0x772200
#define C4GUI_BorderColor2 0x331100
#define C4GUI_BorderColor3 0xaa4400

4
src/gui/C4GuiDialogs.cpp
View File

@ -545,11 +545,11 @@ void Dialog::Draw(C4TargetFacet &cgo)
if (iFade < 100)
{
if (iFade <= 0) return;
lpDDraw->ActivateBlitModulation(((100-iFade)*255/100)<<24 | 0xffffff);
lpDDraw->ActivateBlitModulation((iFade*255/100)<<24 | 0xffffff);
}
// seperate window: Clear background
if (pWindow)
lpDDraw->DrawBoxDw(cgo.Surface, rcBounds.x, rcBounds.y, rcBounds.Wdt-1, rcBounds.Hgt-1, C4GUI_StandardBGColor & 0xffffff);
lpDDraw->DrawBoxDw(cgo.Surface, rcBounds.x, rcBounds.y, rcBounds.Wdt-1, rcBounds.Hgt-1, (0xff << 24) | (C4GUI_StandardBGColor & 0xffffff) );
// draw window + contents (evaluates IsVisible)
Window::Draw(cgo);
// reset blit modulation

4
src/gui/C4LoaderScreen.cpp
View File

@ -185,7 +185,7 @@ void C4LoaderScreen::Draw(C4Facet &cgo, int iProgress, C4LogBuffer *pLog, int Pr
Application.DDraw->TextOutDw(szInfo, cgo.Surface, cgo.Wdt/2, cgo.Hgt/2+20);*/
//
// draw progress bar
Application.DDraw->DrawBoxDw(cgo.Surface, iHIndent, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-iProgressBarHgt, cgo.Wdt-iHIndent, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin, 0x4f000000);
Application.DDraw->DrawBoxDw(cgo.Surface, iHIndent, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-iProgressBarHgt, cgo.Wdt-iHIndent, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin, 0xb0000000);
int iProgressBarWdt=cgo.Wdt-iHIndent*2-2;
if (C4GUI::IsGUIValid())
{
@ -193,7 +193,7 @@ void C4LoaderScreen::Draw(C4Facet &cgo, int iProgress, C4LogBuffer *pLog, int Pr
}
else
{
Application.DDraw->DrawBoxDw(cgo.Surface, iHIndent+1, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-iProgressBarHgt+1, iHIndent+1+iProgressBarWdt*iProgress/100, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-1, 0x4fff0000);
Application.DDraw->DrawBoxDw(cgo.Surface, iHIndent+1, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-iProgressBarHgt+1, iHIndent+1+iProgressBarWdt*iProgress/100, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-1, 0xb0ff0000);
}
Application.DDraw->StringOut(FormatString("%i%%", iProgress).getData(), rProgressBarFont, 1.0f, cgo.Surface,
cgo.Wdt/2, cgo.Hgt-iVIndent-iLogBoxHgt-iVMargin-rProgressBarFont.iLineHgt/2-iProgressBarHgt/2, 0xffffffff,

8
src/gui/C4Startup.h
View File

@ -28,11 +28,11 @@
// special colors for startup designs
const int32_t C4StartupFontClr = 0xff000000,
C4StartupFontClrDisabled = 0xff7f7f7f,
C4StartupEditBGColor = 0xff000000,
C4StartupEditBorderColor = 0x00a4947a,
C4StartupEditBGColor = 0x00000000,
C4StartupEditBorderColor = 0xffa4947a,
C4StartupBtnFontClr = 0xff202020,
C4StartupBtnBorderColor1 = 0x00ccc3b4,
C4StartupBtnBorderColor2 = 0x0094846a;
C4StartupBtnBorderColor1 = 0xffccc3b4,
C4StartupBtnBorderColor2 = 0xff94846a;
// graphics needed only by startup
class C4StartupGraphics

4
src/gui/C4StartupOptionsDlg.cpp
View File

@ -213,10 +213,10 @@ void C4StartupOptionsDlg::KeySelButton::DrawElement(C4TargetFacet &cgo)
cgoDraw.Y += iKeyIndent*3/4; cgoDraw.Hgt -= 2*iKeyIndent;
if (fDown) cgoDraw.Y += iKeyIndent/2;
bool fDoHightlight = fHighlight || HasDrawFocus() || (fMouseOver && IsInActiveDlg(false));
bool fHadBlitMod=false; DWORD dwOldBlitModClr=0xffffff;
bool fHadBlitMod=false; DWORD dwOldBlitModClr=0xffffffff;
if (!fDoHightlight)
{
DWORD dwModClr = 0x7f7f7f;
DWORD dwModClr = 0xff7f7f7f;
if (fHadBlitMod = lpDDraw->GetBlitModulation(dwOldBlitModClr))
ModulateClr(dwModClr, dwOldBlitModClr);
lpDDraw->ActivateBlitModulation(dwModClr);

4
src/gui/C4StartupScenSelDlg.cpp
View File

@ -362,7 +362,7 @@ void C4MapFolderData::CreateGUIElements(C4StartupScenSelDlg *pMainDlg, C4GUI::Wi
if (pScen->sTitle.getLength()>0)
{
pBtn->SetText(pScen->sTitle.getData());
pBtn->SetTextColors(InvertRGBAAlpha(pScen->dwTitleInactClr), InvertRGBAAlpha(pScen->dwTitleActClr));
pBtn->SetTextColors(pScen->dwTitleInactClr, pScen->dwTitleActClr);
pBtn->SetTextPos(pScen->iTitleOffX, pScen->iTitleOffY, pScen->byTitleAlign);
CStdFont *pUseFont; float fFontZoom=1.0f;
if (pScen->fTitleBookFont)
@ -500,7 +500,7 @@ bool C4ScenarioListLoader::Entry::Load(C4Group *pFromGrp, const StdStrBuf *psFil
if (Inside<uint8_t>(dwPix & 0xff, 0xb8, 0xff))
if (Inside<uint8_t>((dwPix>>0x08) & 0xff, 0x00, 0x0f))
if (Inside<uint8_t>((dwPix>>0x10) & 0xff, 0xb8, 0xff))
fctTemp.Surface->SetPixDw(x,y,0xffffffff);
fctTemp.Surface->SetPixDw(x,y,0x00ffffff);
}
fctTemp.Surface->Unlock();
int iIconSize = C4Startup::Get()->Graphics.fctScenSelIcons.Hgt;

2
src/gui/C4Viewport.cpp
View File

@ -1002,7 +1002,7 @@ void C4Viewport::DrawMenu(C4TargetFacet &cgo)
if (::MouseControl.IsDragging() && ::MouseControl.IsViewport(this))
{
fDragging = true;
lpDDraw->ActivateBlitModulation(0xafffffff);
lpDDraw->ActivateBlitModulation(0x4fffffff);
}
// draw menu
pPlr->Cursor->Menu->Draw(cgo);

2
src/lib/Standard.h
View File

@ -169,7 +169,7 @@ bool LogF(const char *strMessage, ...) GNUC_FORMAT_ATTRIBUTE;
bool LogSilentF(const char *strMessage, ...) GNUC_FORMAT_ATTRIBUTE;
// Color triplets
#define C4RGB(r, g, b) ((((DWORD)(r)&0xff)<<16)|(((DWORD)(g)&0xff)<<8)|((b)&0xff))
#define C4RGB(r, g, b) (((DWORD)(0xff)<<24)|(((DWORD)(r)&0xff)<<16)|(((DWORD)(g)&0xff)<<8)|((b)&0xff))
// Small helpers
template <class T> inline T Max(T val1, T val2) { return val1 > val2 ? val1 : val2; }

76
src/lib/StdColors.h
View File

@ -36,23 +36,23 @@ extern const BYTE FColors [];
inline void BltAlpha(DWORD &dwDst, DWORD dwSrc)
{
// blit one color value w/alpha on another
if (dwDst>>24 == 0xff) { dwDst=dwSrc; return; }
BYTE byAlphaDst=BYTE(dwSrc>>24); BYTE byAlphaSrc=255-byAlphaDst;
if (dwDst>>24 == 0x00) { dwDst=dwSrc; return; }
BYTE byAlphaSrc=BYTE(dwSrc>>24); BYTE byAlphaDst=255-byAlphaSrc;
dwDst = Min<uint32_t>((int(dwDst & 0xff ) * byAlphaDst + int(dwSrc & 0xff ) * byAlphaSrc) >>8, 0xff) | // blue
Min<uint32_t>((int(dwDst & 0xff00) * byAlphaDst + int(dwSrc & 0xff00 ) * byAlphaSrc) >>8 & 0xff00, 0xff00) | // green
Min<uint32_t>((int(dwDst & 0xff0000) * byAlphaDst + int(dwSrc & 0xff0000) * byAlphaSrc) >>8 & 0xff0000, 0xff0000) | // red
uint32_t(Max((int) (dwDst >> 24) - byAlphaSrc, 0)) << 24; // alpha
Min<uint32_t>( (dwDst >> 24) + byAlphaSrc, 255) << 24; // alpha
}
inline void BltAlphaAdd(DWORD &dwDst, DWORD dwSrc)
{
// blit one color value w/alpha on another in additive mode
if (dwDst>>24 == 0xff) { dwDst=dwSrc; return; }
BYTE byAlphaSrc=255-BYTE(dwSrc>>24);
if (dwDst>>24 == 0x00) { dwDst=dwSrc; return; }
BYTE byAlphaSrc=BYTE(dwSrc>>24);
dwDst = Min<uint32_t>((dwDst & 0xff ) + ((int(dwSrc & 0xff ) * byAlphaSrc) >>8) , 0xff) | // blue
Min<uint32_t>((dwDst & 0xff00) + (int(dwSrc>>8 & 0xff ) * byAlphaSrc) & 0x00ffff00, 0xff00) | // green
Min<uint32_t>((dwDst & 0xff0000) + (int(dwSrc>>8 & 0xff00) * byAlphaSrc) & 0xffff0000, 0xff0000) | // red
uint32_t(Max((int) (dwDst >> 24) - byAlphaSrc, 0)) << 24; // alpha
Min<uint32_t>( (dwDst >> 24) + byAlphaSrc, 255) << 24; // alpha
}
inline void ModulateClr(DWORD &dwDst, DWORD dwMod) // modulate two color values
@ -61,46 +61,77 @@ inline void ModulateClr(DWORD &dwDst, DWORD dwMod) // modulate two color values
// get alpha
int iA1=dwDst>>24, iA2=dwMod>>24;
// modulate color values; mod alpha upwards
#if 0
dwDst = ((dwDst & 0xff) * (dwMod & 0xff)) >> 8 | // blue
((dwDst>> 8 & 0xff) * (dwMod>>8 & 0xff)) & 0xff00 | // green
((dwDst>>16 & 0xff) * (dwMod>>8 & 0xff00)) & 0xff0000 | // red
uint32_t(Min(iA1+iA2 - ((iA1*iA2)>>8), 255)) << 24 ; // alpha (=255-(255*iA1)(255*iA2)/255)
((dwDst>>16 & 0xff) * (dwMod>>8 & 0xff00)) & 0xff0000 | // red
Min(iA1*iA2>>8, 255) << 24; // alpha (TODO: We don't need Min() here, do we?)
#else
// More exact calculation, but might be slightly slower:
dwDst = ((dwDst & 0xff) * (dwMod & 0xff) / 0xff) | // blue
((dwDst>> 8 & 0xff) * (dwMod>> 8 & 0xff) / 0xff) << 8 | // green
((dwDst>>16 & 0xff) * (dwMod>>16 & 0xff) / 0xff) << 16| // red
Min(iA1*iA2/0xff, 255) << 24; // alpha (TODO: We don't need Min() here, do we?)
#endif
}
inline void ModulateClrA(DWORD &dwDst, DWORD dwMod) // modulate two color values and add alpha value
{
// modulate two color values and add alpha value
#if 0
dwDst = (((dwDst&0xff)*(dwMod&0xff))>>8) | // B
(((dwDst>>8&0xff)*(dwMod>>8&0xff))&0xff00) | // G
(((dwDst>>16&0xff)*(dwMod>>8&0xff00))&0xff0000) | // R
Min<uint32_t>((dwDst>>24)+(dwMod>>24), 0xff)<<24;
(((dwDst>>8&0xff)*(dwMod>>8&0xff))&0xff00) | // G
(((dwDst>>16&0xff)*(dwMod>>8&0xff00))&0xff0000) | // R
(Max<uint32_t>((dwDst>>24)+(dwMod>>24), 0xff) - 0xff)<<24;
#else
// More exact calculation, but might be slightly slower:
dwDst = ((dwDst & 0xff) * (dwMod & 0xff) / 0xff) | // B
((dwDst>> 8 & 0xff) * (dwMod>> 8 & 0xff) / 0xff) << 8 | // G
((dwDst>>16 & 0xff) * (dwMod>>16 & 0xff) / 0xff) << 16| // R
(Max<uint32_t>((dwDst>>24)+(dwMod>>24), 0xff) - 0xff)<<24;
#endif
}
inline void ModulateClrMOD2(DWORD &dwDst, DWORD dwMod) // clr1+clr2-0.5
{
// signed color addition
dwDst = (BoundBy<int>(((int)(dwDst&0xff)+(dwMod&0xff)-0x7f)<<1,0,0xff)&0xff) | // B
(BoundBy<int>(((int)(dwDst&0xff00)+(dwMod&0xff00)-0x7f00)<<1,0,0xff00)&0xff00) | // G
(BoundBy<int>(((int)(dwDst&0xff0000)+(dwMod&0xff0000)-0x7f0000)<<1,0,0xff0000)&0xff0000) | // R
Min<uint32_t>((dwDst>>24)+(dwMod>>24), 0xff)<<24;
(BoundBy<int>(((int)(dwDst&0xff00)+(dwMod&0xff00)-0x7f00)<<1,0,0xff00)&0xff00) | // G
(BoundBy<int>(((int)(dwDst&0xff0000)+(dwMod&0xff0000)-0x7f0000)<<1,0,0xff0000)&0xff0000) | // R
(Max<uint32_t>((dwDst>>24)+(dwMod>>24), 0xff) - 0xff)<<24;
}
inline void ModulateClrMono(DWORD &dwDst, BYTE byMod)
{
// darken a color value by constant modulation
#if 0
dwDst = ((dwDst & 0xff) * byMod) >> 8 | // blue
((dwDst>> 8 & 0xff) * byMod) & 0xff00 | // green
((dwDst>> 8 & 0xff00) * byMod) & 0xff0000 | // red
(dwDst & 0xff000000); // alpha
#else
// More exact calculation, but might be slightly slower:
dwDst = ((dwDst & 0xff) * byMod / 0xff) | // blue
((dwDst>> 8 & 0xff) * byMod / 0xff) << 8 | // green
((dwDst>>16 & 0xff) * byMod / 0xff) << 16| // red
(dwDst & 0xff000000); // alpha
#endif
}
inline void ModulateClrMonoA(DWORD &dwDst, BYTE byMod, BYTE byA)
{
// darken a color value by constant modulation and add an alpha value
#if 0
dwDst = ((dwDst & 0xff) * byMod) >> 8 | // blue
((dwDst>> 8 & 0xff) * byMod) & 0xff00 | // green
((dwDst>> 8 & 0xff00) * byMod) & 0xff0000 | // red
Min<uint32_t>((dwDst>>24) + byA, 255) << 24; // alpha
(Max<uint32_t>((dwDst>>24) + byA, 0xff) - 0xff) << 24; // alpha
#else
// More exact calculation, but might be slightly slower:
dwDst = ((dwDst & 0xff) * byMod / 0xff) | // blue
((dwDst>> 8 & 0xff) * byMod / 0xff) << 8 | // green
((dwDst>>16 & 0xff) * byMod / 0xff) << 16| // red
(Max<uint32_t>((dwDst>>24) + byA, 0xff) - 0xff) << 24; // alpha
#endif
}
@ -179,10 +210,10 @@ inline DWORD GetClrModulation(DWORD dwSrcClr, DWORD dwDstClr, DWORD &dwBack)
int bR=sR+(cR*255)/diffN;
int bG=sG+(cG*255)/diffN;
int bB=sB+(cB*255)/diffN;
dwBack=RGBA(bR, bG, bB, 0);
dwBack=RGBA(bR, bG, bB, 255);
}
if (!sR) sR=1; if (!sG) sG=1; if (!sB) sB=1;
return RGBA(Min((int)dR*256/sR, 255), Min((int)dG*256/sG, 255), Min((int)dB*256/sB, 255), diffN);
return RGBA(Min((int)dR*256/sR, 255), Min((int)dG*256/sG, 255), Min((int)dB*256/sB, 255), 255-diffN);
}
inline DWORD NormalizeColors(DWORD &dwClr1, DWORD &dwClr2, DWORD &dwClr3, DWORD &dwClr4)
@ -198,11 +229,6 @@ inline DWORD NormalizeColors(DWORD &dwClr1, DWORD &dwClr2, DWORD &dwClr3, DWORD
return dwClr2=dwClr3=dwClr4=dwClr1;
}
inline DWORD InvertRGBAAlpha(DWORD dwFromClr)
{
return (dwFromClr&0xffffff) | (255-(dwFromClr>>24))<<24;
}
inline WORD ClrDw2W(DWORD dwClr)
{
return
@ -270,14 +296,14 @@ inline bool RGB2rgb(int R, int G, int B, double *pr, double *pg, double *pb, dou
struct CStdPalette
{
BYTE Colors[3*256];
BYTE Alpha[3*256];
BYTE Alpha[3*256]; // TODO: alphapal: Why 3*? Isn't Alpha[256] enough?
DWORD GetClr(BYTE byCol)
{ return RGB(Colors[byCol*3+2], Colors[byCol*3+1], Colors[byCol*3])+(Alpha[byCol]<<24); }
void EnforceC0Transparency()
{
Colors[0]=Colors[1]=Colors[2]=0; Alpha[0]=255;
Colors[0]=Colors[1]=Colors[2]=0; Alpha[0]=0;
}
};

1
src/lib/StdMarkup.cpp
View File

@ -87,7 +87,6 @@ bool CMarkup::Read(const char **ppText, bool fSkip)
}
// adjust alpha if not given
if (iParLen<=6) dwClr|=0xff000000;
dwClr = InvertRGBAAlpha(dwClr);
// create color tag
pNewTag=new CMarkupTagColor(dwClr);
}

4
src/lib/texture/C4Facet.cpp
View File

@ -150,8 +150,8 @@ void C4Facet::DrawFullScreen(C4Facet &cgo)
// stretched fullscreen blit: make sure right and lower side are cleared, because this may be missed due to stretching
if (cgo.Wdt > Wdt+2 || cgo.Hgt > Wdt+2)
{
lpDDraw->DrawBoxDw(cgo.Surface, cgo.X, cgo.Y+cgo.Hgt-1, cgo.X+cgo.Wdt+2, cgo.Y+cgo.Hgt+2, 0x00000000);
lpDDraw->DrawBoxDw(cgo.Surface, cgo.X+cgo.Wdt-1, cgo.Y, cgo.X+cgo.Wdt+2, cgo.Y+cgo.Hgt+2, 0x00000000);
lpDDraw->DrawBoxDw(cgo.Surface, cgo.X, cgo.Y+cgo.Hgt-1, cgo.X+cgo.Wdt+2, cgo.Y+cgo.Hgt+2, 0xff000000);
lpDDraw->DrawBoxDw(cgo.Surface, cgo.X+cgo.Wdt-1, cgo.Y, cgo.X+cgo.Wdt+2, cgo.Y+cgo.Hgt+2, 0xff000000);
}
// normal blit OK
Draw(cgo, false);

6
src/lib/texture/C4GraphicsResource.cpp
View File

@ -187,15 +187,15 @@ bool C4GraphicsResource::Init(bool fInitGUI)
if (!pPalGrp->AccessEntry("C4.pal")) { LogFatal("Pal error!"); return false; }
if (!pPalGrp->Read(GamePalette,256*3)) { LogFatal("Pal error!"); return false; }
for (int32_t cnt=0; cnt<256*3; cnt++) GamePalette[cnt]<<=2;
ZeroMemory(&AlphaPalette, 256);
for (int32_t cnt=0; cnt<256; cnt++) AlphaPalette[cnt]=0xff;
// Set default force field color
GamePalette[191*3+0]=0;
GamePalette[191*3+1]=0;
GamePalette[191*3+2]=255;
AlphaPalette[191]=127;
// color 0 is transparent
GamePalette[0]=GamePalette[1]=GamePalette[2]=0;
AlphaPalette[0]=255;
AlphaPalette[191]=127;
AlphaPalette[0]=0;
// update game pal
if (!::GraphicsSystem.SetPalette()) { LogFatal("Pal error (2)!"); return false; }
idPalGrp = idNewPalGrp;

2
src/lib/texture/C4GraphicsResource.h
View File

@ -47,7 +47,7 @@ class C4GraphicsResource
public:
C4GroupSet Files;
BYTE GamePalette[256*3];
BYTE AlphaPalette[256*3];
BYTE AlphaPalette[256*3]; // TODO: alphapal: Why *3?
C4FacetID fctPlayer;
C4FacetID fctFlag;
C4FacetID fctCrew;

4
src/lib/texture/C4Surface.cpp
View File

@ -191,7 +191,7 @@ bool C4Surface::ReadPNG(CStdStream &hGroup)
DWORD *pPix=(DWORD *) (((char *) pTexRef->texLock.pBits) + iY * pTexRef->texLock.Pitch);
memcpy (pPix, png.GetRow(rY) + tX * iTexSize, maxX * 4);
int iX = maxX;
while (iX--) { if (((BYTE *)pPix)[3] == 0xff) *pPix = 0xff000000; ++pPix; }
while (iX--) { if (((BYTE *)pPix)[3] == 0x00) *pPix = 0x00000000; ++pPix; }
}
else
#endif
@ -201,7 +201,7 @@ bool C4Surface::ReadPNG(CStdStream &hGroup)
{
uint32_t dwCol = png.GetPix(iX + tX * iTexSize, rY);
// if color is fully transparent, ensure it's black
if (dwCol>>24 == 0xff) dwCol=0xff000000;
if (dwCol>>24 == 0x00) dwCol=0x00000000;
// set pix in surface
if (byBytesPP == 4)
{

6
src/lib/texture/StdPNG.cpp
View File

@ -59,8 +59,6 @@ bool CPNGFile::DoLoad()
if (setjmp(png_ptr->jmpbuf)) return false;
// set file-reading proc
png_set_read_fn(png_ptr, png_get_io_ptr(png_ptr), &CPNGReadFn);
// invert alpha
png_set_invert_alpha(png_ptr);
// read info
png_read_info(png_ptr, info_ptr);
// assign local vars
@ -186,7 +184,7 @@ DWORD CPNGFile::GetPix(int iX, int iY)
switch (iClrType)
{
case PNG_COLOR_TYPE_RGB:
return RGB(pPix[0], pPix[1], pPix[2]);
return 0xff << 24 | RGB(pPix[0], pPix[1], pPix[2]);
case PNG_COLOR_TYPE_RGB_ALPHA:
return pPix[3] << 24 | RGB(pPix[0], pPix[1], pPix[2]);
}
@ -272,8 +270,6 @@ bool CPNGFile::Save(const char *szFilename)
// this won't go well, so better abort
Clear(); return false;
}
// write inverted alpha channel
png_set_invert_alpha(png_ptr);
// write png header
png_write_info(png_ptr, info_ptr);
// image data is given as bgr...

13
src/platform/StdDDraw2.cpp
View File

@ -205,7 +205,7 @@ void CGammaControl::Set(DWORD dwClr1, DWORD dwClr2, DWORD dwClr3)
DWORD CGammaControl::ApplyTo(DWORD dwClr)
{
// apply to reg, green and blue color component
// apply to red, green and blue color component
return RGBA(ramp.red[GetBValue(dwClr)]>>8, ramp.green[GetGValue(dwClr)]>>8, ramp.blue[GetRValue(dwClr)]>>8, dwClr>>24);
}
@ -333,14 +333,15 @@ uint32_t CClrModAddMap::GetModAt(int x, int y) const
int tx2 = Min(tx + 1, Wdt-1);
int ty2 = Min(ty + 1, Hgt-1);
// TODO: Alphafixed. Correct?
unsigned char Vis = pMap[ty*Wdt+tx];
uint32_t c1 = FadeTransparent ? 0xffffff | ((255u - Vis) << 24) : RGB(Vis, Vis, Vis);
uint32_t c1 = FadeTransparent ? 0xffffff | (Vis << 24) : 0xff000000|RGB(Vis, Vis, Vis);
Vis = pMap[ty*Wdt+tx2];
uint32_t c2 = FadeTransparent ? 0xffffff | ((255u - Vis) << 24) : RGB(Vis, Vis, Vis);
uint32_t c2 = FadeTransparent ? 0xffffff | (Vis << 24) : 0xff000000|RGB(Vis, Vis, Vis);
Vis = pMap[ty2*Wdt+tx];
uint32_t c3 = FadeTransparent ? 0xffffff | ((255u -Vis) << 24) : RGB(Vis, Vis, Vis);
uint32_t c3 = FadeTransparent ? 0xffffff | (Vis << 24) : 0xff000000|RGB(Vis, Vis, Vis);
Vis = pMap[ty2*Wdt+tx2];
uint32_t c4 = FadeTransparent ? 0xffffff | ((255u - Vis) << 24) : RGB(Vis, Vis, Vis);
uint32_t c4 = FadeTransparent ? 0xffffff | (Vis << 24) : 0xff000000|RGB(Vis, Vis, Vis);
CColorFadeMatrix clrs(tx*ResolutionX, ty*ResolutionY, ResolutionX, ResolutionY, c1, c2, c3, c4);
return clrs.GetColorAt(x, y);
#endif
@ -1011,7 +1012,7 @@ bool CStdDDraw::Blit(SURFACE sfcSource, float fx, float fy, float fwdt, float fh
pBaseTex = *(sfcSource->pMainSfc->ppTex + iY * sfcSource->iTexX + iX);
}
// base blit
PerformBlt(BltData, pBaseTex, BlitModulated ? BlitModulateClr : 0xffffff, !!(dwBlitMode & C4GFXBLIT_MOD2), fExact);
PerformBlt(BltData, pBaseTex, BlitModulated ? BlitModulateClr : 0xffffffff, !!(dwBlitMode & C4GFXBLIT_MOD2), fExact);
// overlay
if (fBaseSfc)
{

22
src/platform/StdFont.cpp
View File

@ -222,12 +222,12 @@ bool CStdFont::AddRenderedChar(uint32_t dwChar, CFacet *pfctTarget)
for (int y=0; y<size.cy; ++y) for (int x=0; x<size.cx; ++x)
{
// get value; determine shadow value by pos moved 1px to upper left
BYTE bAlpha = 255 - (BYTE)(pBitmapBits[iBitmapSize*y + x] & 0xff);
BYTE bAlpha = (BYTE)(pBitmapBits[iBitmapSize*y + x] & 0xff);
BYTE bAlphaShadow;
if (x&&y && fDoShadow)
bAlphaShadow = 255 - (BYTE)((pBitmapBits[iBitmapSize*(y-1) + x-1] & 0xff)*1/1);
bAlphaShadow = (BYTE)((pBitmapBits[iBitmapSize*(y-1) + x-1] & 0xff)*1/1);
else
bAlphaShadow = 255;
bAlphaShadow = 0;
// calc pixel value: white char on black shadow (if shadow is desired)
DWORD dwPixVal = bAlphaShadow << 24;
BltAlpha(dwPixVal, bAlpha << 24 | 0xffffff);
@ -282,12 +282,12 @@ bool CStdFont::AddRenderedChar(uint32_t dwChar, CFacet *pfctTarget)
{
unsigned char bAlpha, bAlphaShadow;
if (x < slot->bitmap.width && y < slot->bitmap.rows)
bAlpha = 255 - (unsigned char)(slot->bitmap.buffer[slot->bitmap.width * y + x]);
bAlpha = (unsigned char)(slot->bitmap.buffer[slot->bitmap.width * y + x]);
else
bAlpha = 255;
bAlpha = 0;
// Make a shadow from the upper-left pixel, and blur with the eight neighbors
DWORD dwPixVal = 0u;
bAlphaShadow = 255;
bAlphaShadow = 0;
if ((x || y) && fDoShadow)
{
int iShadow = 0;
@ -300,10 +300,10 @@ bool CStdFont::AddRenderedChar(uint32_t dwChar, CFacet *pfctTarget)
if (x < slot->bitmap.width && y > 0 ) iShadow += slot->bitmap.buffer[(x - 0) + slot->bitmap.width * (y - 1)];
if (x > 1 && y > 0 ) iShadow += slot->bitmap.buffer[(x - 2) + slot->bitmap.width * (y - 1)];
if (x > 0 && y > 0 ) iShadow += slot->bitmap.buffer[(x - 1) + slot->bitmap.width * (y - 1)]*8;
bAlphaShadow -= iShadow / 16;
bAlphaShadow += iShadow / 16;
// because blitting on a black pixel reduces luminosity as compared to shadowless font,
// assume luminosity as if blitting shadowless font on a 50% gray background
unsigned char cBack = (255-bAlpha);
unsigned char cBack = bAlpha;
dwPixVal = RGB(cBack/2, cBack/2, cBack/2);
}
dwPixVal += bAlphaShadow << 24;
@ -1027,12 +1027,12 @@ void CStdFont::DrawText(SURFACE sfcDest, float iX, float iY, DWORD dwColor, cons
{
CBltTransform bt, *pbt=NULL;
// set blit color
dwColor = InvertRGBAAlpha(dwColor);
DWORD dwOldModClr;
bool fWasModulated = lpDDraw->GetBlitModulation(dwOldModClr);
if (fWasModulated) ModulateClr(dwColor, dwOldModClr);
// get alpha fade percentage
DWORD dwAlphaMod = BoundBy<int>((((int)(dwColor>>0x18)-0x50)*0xff)/0xaf, 0, 255)<<0x18 | 0xffffff;
DWORD dwAlphaMod = Min<uint32_t>(((dwColor>>0x18)*0xff)/0xaf, 255)<<0x18 | 0xffffff;
/* char TEXT[8192];
sprintf(TEXT, "%s(%x-%x-%x)", szText, dwAlphaMod>>0x18, dwColor>>0x15, (((int)(dwColor>>0x15)-0x50)*0xff)/0xaf); szText=TEXT;*/
// adjust text starting position (horizontal only)
@ -1104,7 +1104,7 @@ void CStdFont::DrawText(SURFACE sfcDest, float iX, float iY, DWORD dwColor, cons
continue;
}
//normal: not modulated, unless done by transform or alpha fadeout
if ((dwColor>>0x18) <= 0x50)
if ((dwColor>>0x18) >= 0xaf)
lpDDraw->DeactivateBlitModulation();
else
lpDDraw->ActivateBlitModulation((dwColor&0xff000000) | 0xffffff);

20
src/platform/StdGL.cpp
View File

@ -102,7 +102,7 @@ bool CStdGL::PageFlip(RECT *pSrcRt, RECT *pDstRt, CStdWindow * pWindow)
void CStdGL::FillBG(DWORD dwClr)
{
if (!pCurrCtx) if (!MainCtx.Select()) return;
glClearColor((float)GetBValue(dwClr)/255.0f, (float)GetGValue(dwClr)/255.0f, (float)GetRValue(dwClr)/255.0f, 1.0f);
glClearColor((float)GetBValue(dwClr)/255.0f, (float)GetGValue(dwClr)/255.0f, (float)GetRValue(dwClr)/255.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
@ -184,7 +184,7 @@ void CStdGL::SetupTextureEnv(bool fMod2, bool landscape)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, fMod2 ? GL_ADD_SIGNED : GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, fMod2 ? 2.0f : 1.0f);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_ADD);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE); // TODO: This was GL_ADD. Is GL_MODULATE correct for inverted alpha? Others seem to break things... - ModulateClrA was changed to do a+b-1, but there is no GL_-constant for this...
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
@ -204,8 +204,8 @@ void CStdGL::PerformBlt(CBltData &rBltData, CTexRef *pTex, DWORD dwModClr, bool
if (DDrawCfg.ClipManually && rBltData.pTransform) ClipPoly(rBltData);
// global modulation map
int i;
bool fAnyModNotBlack = !!dwModClr;
if (!shaders[0] && fUseClrModMap && dwModClr)
bool fAnyModNotBlack = (dwModClr != 0xff000000);
if (!shaders[0] && fUseClrModMap && dwModClr != 0xff000000)
{
fAnyModNotBlack = false;
for (i=0; i<rBltData.byNumVertices; ++i)
@ -218,7 +218,7 @@ void CStdGL::PerformBlt(CBltData &rBltData, CTexRef *pTex, DWORD dwModClr, bool
}
DWORD c = pClrModMap->GetModAt(int(x), int(y));
ModulateClr(c, dwModClr);
if (c) fAnyModNotBlack = true;
if (c != 0xff000000) fAnyModNotBlack = true;
DwTo4UB(c, rBltData.vtVtx[i].color);
}
}
@ -548,7 +548,7 @@ void CStdGL::BlitLandscape(SURFACE sfcSource, float fx, float fy,
for (int iX=iTexX; iX<iTexX2; ++iX)
{
// blit
DWORD dwModClr = BlitModulated ? BlitModulateClr : 0xffffff;
DWORD dwModClr = BlitModulated ? BlitModulateClr : 0xffffffff;
glActiveTexture(GL_TEXTURE0);
CTexRef *pTex = *(sfcSource->ppTex + iY * sfcSource->iTexX + iX);
@ -758,7 +758,7 @@ bool CStdGL::CreatePrimarySurfaces(bool Playermode, unsigned int iXRes, unsigned
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
const char * linedata = byByteCnt == 2 ? "\xff\xff\xff\xf0" : "\xff\xff\xff\xff\xff\xff\xff\x00";
const char * linedata = byByteCnt == 2 ? "\xff\xf0\xff\xff" : "\xff\xff\xff\x00\xff\xff\xff\xff";
glTexImage2D(GL_TEXTURE_2D, 0, 4, 1, 2, 0, GL_BGRA, byByteCnt == 2 ? GL_UNSIGNED_SHORT_4_4_4_4_REV : GL_UNSIGNED_INT_8_8_8_8_REV, linedata);
return RestoreDeviceObjects();
}
@ -790,7 +790,7 @@ void CStdGL::DrawQuadDw(SURFACE sfcTarget, float *ipVtx, DWORD dwClr1, DWORD dwC
glShadeModel((dwClr1 == dwClr2 && dwClr1 == dwClr3 && dwClr1 == dwClr4) ? GL_FLAT : GL_SMOOTH);
// set blitting state
int iAdditive = dwBlitMode & C4GFXBLIT_ADDITIVE;
glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, iAdditive ? GL_ONE : GL_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, iAdditive ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);
// draw two triangles
glInterleavedArrays(GL_V2F, sizeof(float)*2, ipVtx);
GLubyte colors[4][4];
@ -903,7 +903,7 @@ void CStdGL::PerformPix(SURFACE sfcTarget, float tx, float ty, DWORD dwClr)
glBlendFunc(GL_SRC_ALPHA, iAdditive ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);
// convert the alpha value for that blendfunc
glBegin(GL_POINTS);
glColorDw(InvertRGBAAlpha(dwClr));
glColorDw(dwClr);
glVertex2f(tx + 0.5f, ty + 0.5f);
glEnd();
}
@ -1043,7 +1043,7 @@ bool CStdGL::InvalidateDeviceObjects()
void CStdGL::SetTexture()
{
glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, (dwBlitMode & C4GFXBLIT_ADDITIVE) ? GL_ONE : GL_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, (dwBlitMode & C4GFXBLIT_ADDITIVE) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);
if (shaders[0] && fUseClrModMap)
{
glEnable(GL_FRAGMENT_PROGRAM_ARB);

16
src/platform/StdMeshMaterial.cpp
View File

@ -260,10 +260,10 @@ void StdMeshMaterialTextureUnit::Load(StdMeshMaterialParserCtx& ctx)
StdMeshMaterialPass::StdMeshMaterialPass()
{
Ambient[0] = Ambient[1] = Ambient[2] = 1.0f; Ambient[3] = 0.0f;
Diffuse[0] = Diffuse[1] = Diffuse[2] = 1.0f; Diffuse[3] = 0.0f;
Specular[0] = Specular[1] = Specular[2] = 0.0f; Specular[3] = 1.0f;
Emissive[0] = Emissive[1] = Emissive[2] = 0.0f; Emissive[3] = 1.0f;
Ambient[0] = Ambient[1] = Ambient[2] = 1.0f; Ambient[3] = 1.0f;
Diffuse[0] = Diffuse[1] = Diffuse[2] = 1.0f; Diffuse[3] = 1.0f;
Specular[0] = Specular[1] = Specular[2] = 0.0f; Specular[3] = 0.0f;
Emissive[0] = Emissive[1] = Emissive[2] = 0.0f; Emissive[3] = 0.0f;
Shininess = 0.0f;
}
@ -286,7 +286,7 @@ void StdMeshMaterialPass::Load(StdMeshMaterialParserCtx& ctx)
Ambient[1] = ctx.AdvanceFloat();
Ambient[2] = ctx.AdvanceFloat();
if(ctx.AdvanceFloatOptional(Ambient[3]))
Ambient[3] = 1 - Ambient[3];
Ambient[3] = Ambient[3];
}
else if(token_name == "diffuse")
{
@ -294,7 +294,7 @@ void StdMeshMaterialPass::Load(StdMeshMaterialParserCtx& ctx)
Diffuse[1] = ctx.AdvanceFloat();
Diffuse[2] = ctx.AdvanceFloat();
if(ctx.AdvanceFloatOptional(Diffuse[3]))
Diffuse[3] = 1 - Diffuse[3];
Diffuse[3] = Diffuse[3];
}
else if(token_name == "specular")
{
@ -308,7 +308,7 @@ void StdMeshMaterialPass::Load(StdMeshMaterialParserCtx& ctx)
float shininess;
if(ctx.AdvanceFloatOptional(shininess))
{
Specular[3] = 1 - specular3;
Specular[3] = specular3;
Shininess = shininess;
}
else
@ -322,7 +322,7 @@ void StdMeshMaterialPass::Load(StdMeshMaterialParserCtx& ctx)
Emissive[1] = ctx.AdvanceFloat();
Emissive[2] = ctx.AdvanceFloat();
if(ctx.AdvanceFloatOptional(Emissive[3]))
Emissive[3] = 1 - Emissive[3];
Emissive[3] = Emissive[3];
}
else
ctx.ErrorUnexpectedIdentifier(token_name);

37
src/platform/StdSurface2.cpp
View File

@ -399,7 +399,7 @@ bool CSurface::CreateColorByOwner(CSurface *pBySurface)
// set in this surface
SetPixDw(iX, iY, dwPix);
// clear in the other
pMainSfc->SetPixDw(iX, iY, 0xffffffff);
pMainSfc->SetPixDw(iX, iY, 0x00ffffff);
}
// unlock
Unlock();
@ -708,7 +708,7 @@ bool CSurface::Wipe()
if (!fIsBackground)
SetPix(i%Wdt, i/Wdt, 0);
else
SetPixDw(i%Wdt, i/Wdt, 0x00000000);
SetPixDw(i%Wdt, i/Wdt, 0xff000000);
Unlock();
// success
return true;
@ -944,7 +944,7 @@ DWORD CSurface::GetPixDw(int iX, int iY, bool fApplyModulation)
{
BYTE byAlpha=BYTE(dwPix>>24);
// pix is fully transparent?
if (byAlpha==0xff)
if (byAlpha==0x00)
// then get the main surfaces's pixel
dwPix = pMainSfc->GetPixDw(iX2, iY2, fApplyModulation);
else
@ -1056,7 +1056,7 @@ bool CSurface::SetPixDw(int iX, int iY, DWORD dwClr)
// get+lock affected texture
if (!ppTex) return false;
// if color is fully transparent, ensure it's black
if (dwClr>>24 == 0xff) dwClr=0xff000000;
if (dwClr>>24 == 0x00) dwClr=0x00000000;
CTexRef *pTexRef;
#ifdef USE_GL
// openGL: use glTexSubImage2D
@ -1296,7 +1296,7 @@ CTexRef::CTexRef(int iSize, bool fSingle)
}
// empty texture
if (!Lock()) return;
FillMemory(texLock.pBits, texLock.Pitch*iSize, 0xff);
FillMemory(texLock.pBits, texLock.Pitch*iSize, 0x00);
Unlock();
}
else
@ -1308,7 +1308,7 @@ CTexRef::CTexRef(int iSize, bool fSingle)
// create mem array for texture creation
texLock.pBits = new unsigned char[iSize*iSize*pGL->byByteCnt];
texLock.Pitch = iSize*pGL->byByteCnt;
memset(texLock.pBits, 0xff, texLock.Pitch*iSize);
memset(texLock.pBits, 0x00, texLock.Pitch*iSize);
// turn mem array into texture
Unlock();
}
@ -1317,7 +1317,7 @@ CTexRef::CTexRef(int iSize, bool fSingle)
if (lpDDraw) {
texLock.pBits = new unsigned char[iSize*iSize*lpDDraw->byByteCnt];
texLock.Pitch = iSize*lpDDraw->byByteCnt;
memset(texLock.pBits, 0xff, texLock.Pitch*iSize);
memset(texLock.pBits, 0x00, texLock.Pitch*iSize);
// Always locked
LockSize.left = LockSize.top = 0;
LockSize.right = LockSize.bottom = iSize;
@ -1497,14 +1497,14 @@ bool CTexRef::ClearRect(RECT &rtClear)
for (y=rtClear.top; y<rtClear.bottom; ++y)
{
for (int x = rtClear.left; x < rtClear.right; ++x)
SetPix2(x, y, 0xf000);
SetPix2(x, y, 0x0000);
}
break;
case 4:
for (y=rtClear.top; y<rtClear.bottom; ++y)
{
for (int x = rtClear.left; x < rtClear.right; ++x)
SetPix4(x, y, 0xff000000);
SetPix4(x, y, 0x00000000);
}
break;
}
@ -1517,7 +1517,24 @@ bool CTexRef::FillBlack()
// ensure locked
if (!Lock()) return false;
// clear pixels
ZeroMemory(texLock.pBits, lpDDraw->byByteCnt*iSize*iSize);
int y;
switch (lpDDraw->byByteCnt)
{
case 2:
for (y=0; y<iSize; ++y)
{
for (int x = 0; x < iSize; ++x)
SetPix2(x, y, 0xf000);
}
break;
case 4:
for (y=0; y<iSize; ++y)
{
for (int x = 0; x < iSize; ++x)
SetPix4(x, y, 0xff000000);
}
break;
}
// success
return true;
}

2
src/platform/StdSurface8.cpp
View File

@ -146,7 +146,7 @@ bool CSurface8::Read(CStdStream &hGroup, bool fOwnPal)
pPal->Colors[cnt*3+0]=BitmapInfo.Colors[cnt].rgbRed;
pPal->Colors[cnt*3+1]=BitmapInfo.Colors[cnt].rgbGreen;
pPal->Colors[cnt*3+2]=BitmapInfo.Colors[cnt].rgbBlue;
pPal->Alpha[cnt]=0;
pPal->Alpha[cnt]=0xff;
}
}
}