Backups/GTASource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c971d568a112e5bec2e45ab389375b07c6914a6e
GTASource/rage/scaleform/Src/GFxPlayer/GFxStyles.cpp

1425 lines
43 KiB
C++
Raw Normal View History

init
2025-02-23 17:40:52 +08:00
/**********************************************************************
Filename : GFxStyles.cpp
Content :
Created :
Authors :
Copyright : (c) 2001-2006 Scaleform Corp. All Rights Reserved.
Notes :
Licensees may use this file in accordance with the valid Scaleform
Commercial License Agreement provided with the software.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR ANY PURPOSE.
**********************************************************************/
#include "GRenderer.h"
#include "GImage.h"
#include "GFxStyles.h"
#include "GFxLog.h"
#include "GFxStream.h"
#include "GFxFontResource.h"
#include "GFxLoaderImpl.h"
#include "GFxPlayerImpl.h"
#include "GFxSprite.h"
#include "GFxImageResource.h"
#include "GFxLoadProcess.h"
#include "GFxDisplayContext.h"
#include "GFxAmpServer.h"
#include "AMP/GFxAmpViewStats.h"
#ifdef GFC_ASSERT_ON_GRADIENT_BITMAP_GEN
#define GASSERT_ON_GRADIENT_BITMAP_GEN GASSERT(0)
#else
#define GASSERT_ON_GRADIENT_BITMAP_GEN ((void)0)
#endif //GFC_ASSERT_ON_GRADIENT_BITMAP_GEN
//
// *** GFxGradientRecord
//
GFxGradientRecord::GFxGradientRecord()
: Ratio(0)
{
}
void GFxGradientRecord::Read(GFxLoadProcess* p, GFxTagType tagType)
{
Ratio = p->ReadU8();
p->ReadRgbaTag(&Color, tagType);
}
//
// *** GFxGradientData
//
GFxGradientData::GFxGradientData(GFxFillType type, UInt16 recordCount, bool linearRgb)
{
GASSERT(((int)type < 256) && (type & GFxFill_Gradient_TestBit));
Type = (UByte) type;
pRecords = 0;
RecordCount = 0;
SetRecordCount(recordCount);
LinearRGB = linearRgb;
FocalRatio = 0.0f;
}
GFxGradientData::~GFxGradientData()
{
if (pRecords)
GFREE(pRecords);
}
bool GFxGradientData::SetRecordCount(UInt16 count)
{
if (count == RecordCount)
return 1;
GFxGradientRecord* pnewRecords = 0;
if (count)
if ((pnewRecords = (GFxGradientRecord*)GALLOC(sizeof(GFxGradientRecord)*count, GFxStatMD_CharDefs_Mem)) == 0)
return 0;
if (pRecords)
{
UInt copyCount = G_Min(count, RecordCount);
for (UInt i=0; i<copyCount; i++)
pnewRecords[i] = pRecords[i];
GFREE(pRecords);
}
pRecords = pnewRecords;
RecordCount = count;
return 1;
}
UPInt GFxGradientData::GetHashCode() const
{
UInt i;
UPInt hashCode = Type;
for (i = 0; i< RecordCount; i++)
hashCode ^= pRecords[i].GetHashCode();
return hashCode;
}
bool GFxGradientData::operator == (const GFxGradientData& other) const
{
// if both are NaNs then operator != returns true. (!AB)
GASSERT(!(GASNumberUtil::IsNaN(FocalRatio) && GASNumberUtil::IsNaN(other.FocalRatio)));
if ((RecordCount != other.RecordCount) ||
(Type != other.Type) ||
(FocalRatio != other.FocalRatio) ||
(LinearRGB != other.LinearRGB))
return 0;
UInt i;
for (i=0; i< RecordCount; i++)
if (pRecords[i] != other.pRecords[i])
return 0;
return 1;
}
// Creates an image resource from gradient.
GFxImageResource* GFxGradientData::CreateImageResource(
GFxResourceWeakLib *plib,
GFxGradientParams *pparams,
GFxImageCreator *pimageCreator,
GFxRenderConfig* prconfig,
GFxLog* plog,
bool threadedLoading)
{
// Gradient data must live in a global heap since it is used as a key in ResourceLib.
GASSERT(GMemory::GetHeapByAddress(this) == GMemory::GetGlobalHeap());
// Create a key and check it against library.
GFxResourceKey gradientKey = CreateGradientKey();
GFxImageResource * pres = 0;
GFxResourceLib::BindHandle bh;
if (plib->BindResourceKey(&bh, gradientKey) == GFxResourceLib::RS_NeedsResolve)
{
// If resource does not exist, create it and resolve it in library.
GPtr<GImage> pimage = *CreateGradientImage(pparams, plib->GetImageHeap());
if (pimage)
{
GFxImageCreateInfo ico(pimage, GFxResource::Use_Gradient);
ico.SetStates(0, prconfig, plog, 0, 0);
ico.ThreadedLoading = threadedLoading;
ico.pHeap = plib->GetImageHeap();
GPtr<GImageInfoBase> pimageInfo;
if (pimageCreator)
pimageInfo = *pimageCreator->CreateImage(ico);
else
{
GFC_DEBUG_WARNING(1, "GFxGradientData::CreateImageResource failed - GFxImageCreator not installed");
}
// Add bitmap resource, if image was created; otherwise, it will
// be added by loader.
pres = GHEAP_NEW(ico.pHeap) GFxImageResource(pimageInfo, gradientKey,
GFxResource::Use_Gradient);
if (pres)
bh.ResolveResource(pres);
}
if (!pres)
bh.CancelResolve("Failed to create gradient");
}
else
{
// WaitForResolve AddRefs, so we are ok to return result.
pres = (GFxImageResource*) bh.WaitForResolve();
}
return pres;
}
class GFxGradientImageResourceKey : public GFxResourceKey::KeyInterface
{
public:
typedef GFxResourceKey::KeyHandle KeyHandle;
virtual void AddRef(KeyHandle hdata)
{
GASSERT(hdata); ((GFxGradientData*) hdata)->AddRef();
}
virtual void Release(KeyHandle hdata)
{
GASSERT(hdata); ((GFxGradientData*) hdata)->Release();
}
// Key/Hash code implementation.
virtual GFxResourceKey::KeyType GetKeyType(KeyHandle hdata) const
{
GUNUSED(hdata);
return GFxResourceKey::Key_Gradient;
}
virtual UPInt GetHashCode(KeyHandle hdata) const
{
GASSERT(hdata);
return ((GFxGradientData*) hdata)->GetHashCode();
}
virtual bool KeyEquals(KeyHandle hdata, const GFxResourceKey& other)
{
if (this != other.GetKeyInterface())
return 0;
return *((GFxGradientData*) hdata) == *((GFxGradientData*) other.GetKeyData());
}
};
class GFxGradientImageResourceCreator : public GFxResourceData::DataInterface
{
// Creates/Loads resource based on data and loading process
virtual bool CreateResource(GFxResourceData::DataHandle hdata, GFxResourceBindData *pbindData,
GFxLoadStates *pls, GMemoryHeap*) const
{
GFxGradientData *pgd = (GFxGradientData*) hdata;
GASSERT(pgd);
pbindData->pResource = *pgd->CreateImageResource(pls->GetLib(),
pls->GetBindStates()->pGradientParams,
pls->GetBindStates()->pImageCreator,
pls->GetRenderConfig(), pls->GetLog(),
pls->IsThreadedLoading());
return pbindData->pResource ? 1 : 0;
}
};
static GFxGradientImageResourceCreator static_inst_data;
static GFxGradientImageResourceKey static_inst_key;
// Creates a GFxResourceData object from this GFxGradientData;
// this object can be used to create a resource.
GFxResourceData GFxGradientData::CreateGradientResourceData()
{
return GFxResourceData(&static_inst_data, this);
}
GFxResourceKey GFxGradientData::CreateGradientKey()
{
return GFxResourceKey(&static_inst_key, this);
}
//=========================================================================
// The code of this class was taken from the Anti-Grain Geometry
// Project and modified for the use by Scaleform.
// Permission to use without restrictions is hereby granted to
// Scaleform Corporation by the author of Anti-Grain Geometry Project.
//=========================================================================
// This class is called G..., not GFx... because it's independent and
// actually belongs to the renderer.
//=========================================================================
class GFocalRadialGradient
{
public:
//---------------------------------------------------------------------
GFocalRadialGradient() :
Radius(100),
FocusX(0),
FocusY(0)
{
updateValues();
}
//---------------------------------------------------------------------
GFocalRadialGradient(Float r, Float fx, Float fy) :
Radius(r),
FocusX(fx),
FocusY(fy)
{
updateValues();
}
//---------------------------------------------------------------------
void Init(Float r, Float fx, Float fy)
{
Radius = r;
FocusX = fx;
FocusY = fy;
updateValues();
}
Float Calculate(Float x, Float y) const;
private:
void updateValues();
Float Radius;
Float FocusX;
Float FocusY;
Float Radius2;
Float Multiplier;
};
//---------------------------------------------------------------------
Float GFocalRadialGradient::Calculate(Float x, Float y) const
{
Float dx = x - FocusX;
Float dy = y - FocusY;
Float d2 = dx * FocusY - dy * FocusX;
Float d3 = Radius2 * (dx * dx + dy * dy) - d2 * d2;
return (dx * FocusX + dy * FocusY + sqrtf(fabsf(d3))) * Multiplier;
}
//---------------------------------------------------------------------
void GFocalRadialGradient::updateValues()
{
// Calculate the invariant values. In case the focal center
// lies exactly on the gradient circle the divisor degenerates
// into zero. In this case we just move the focal center by
// one subpixel unit possibly in the direction to the origin (0,0)
// and calculate the values again.
//-------------------------
Float fx2 = FocusX * FocusX;
Float fy2 = FocusY * FocusY;
Radius2 = Radius * Radius;
Float d = Radius2 - (fx2 + fy2);
if(d == 0)
{
if(FocusX != 0) { if(FocusX < 0) FocusX += 1; else FocusX -= 1; }
if(FocusY != 0) { if(FocusY < 0) FocusY += 1; else FocusY -= 1; }
fx2 = FocusX * FocusX;
fy2 = FocusY * FocusY;
d = Radius2 - (fx2 + fy2);
}
Multiplier = Radius / d;
}
//---------------------------------------------------------------------
class GFxGradientRamp
{
public:
enum { RampSize = 256 };
GFxGradientRamp() {}
GFxGradientRamp(const GFxGradientRecord* colorStops,
unsigned numColors,
Float gamma=1)
{
Init(colorStops, numColors, gamma);
}
void Init(const GFxGradientRecord* colorStops,
unsigned numColors,
Float gamma=1);
const GColor& GetColor(unsigned i) const
{
return Ramp[(i < RampSize) ? i : RampSize-1];
}
private:
struct ColorType
{
UInt16 r,g,b,a;
ColorType() {}
ColorType(UInt16 r_, UInt16 g_, UInt16 b_, UInt16 a_) :
r(r_), g(g_), b(b_), a(a_) {}
};
static ColorType applyGamma(const GColor& c, const UInt16* gammaLut)
{
int a = c.GetAlpha();
return ColorType(gammaLut[c.GetRed() ],
gammaLut[c.GetGreen()],
gammaLut[c.GetBlue() ],
UInt16((a << 8) | a));
}
static UByte applyGamma(UInt16 v, Float gamma)
{
return (UByte)floor(pow(v / 65535.0f, gamma) * 255.0f + 0.5f);
}
static GColor blendColors(const ColorType& c1, const ColorType& c2,
int ratio, int maxRatio,
Float gamma)
{
int alphaDiv = (maxRatio << 8) | maxRatio;
return GColor(applyGamma(UInt16(c1.r + int(c2.r - c1.r) * ratio / maxRatio), gamma),
applyGamma(UInt16(c1.g + int(c2.g - c1.g) * ratio / maxRatio), gamma),
applyGamma(UInt16(c1.b + int(c2.b - c1.b) * ratio / maxRatio), gamma),
UByte(c1.a + int(c2.a - c1.a) * ratio / alphaDiv));
}
static GColor blendColors(const ColorType& c1, const ColorType& c2,
int ratio, int maxRatio)
{
maxRatio = (maxRatio << 8) | maxRatio;
return GColor(UByte(c1.r + int(c2.r - c1.r) * ratio / maxRatio),
UByte(c1.g + int(c2.g - c1.g) * ratio / maxRatio),
UByte(c1.b + int(c2.b - c1.b) * ratio / maxRatio),
UByte(c1.a + int(c2.a - c1.a) * ratio / maxRatio));
}
GColor Ramp[RampSize];
};
//---------------------------------------------------------------------
void GFxGradientRamp::Init(const GFxGradientRecord* colorStops,
unsigned numColors,
Float gamma)
{
unsigned i;
if (numColors == 0 || colorStops == 0)
{
GFxGradientRecord fakeColor;
fakeColor.Ratio = 0;
fakeColor.Color = 0xFF000000;
numColors = 1;
colorStops = &fakeColor;
}
if(numColors > 1)
{
UInt16 gammaDir[256];
Float gammaInv = 1;
if(gamma == 1)
{
for(i = 0; i < 256; i++)
{
gammaDir[i] = UInt16( (i << 8) | i );
}
}
else
{
// It's a simplified calculation of the linear color gradient LUT
// Replace this LUT with sRGB if necessary
for(i = 0; i < 256; i++)
{
gammaDir[i] = (UInt16)floor(pow(i / 255.0f, gamma) * 65535.0f + 0.5f);
}
gammaInv = 1/gamma;
}
unsigned start = colorStops[0].Ratio;
unsigned end = 0;
GColor c = colorStops[0].Color;
for(i = 0; i < start; i++)
{
Ramp[i] = c;
}
for(i = 1; i < numColors; i++)
{
end = colorStops[i].Ratio;
if(end < start) end = start;
ColorType c1 = applyGamma(colorStops[i-1].Color, gammaDir);
ColorType c2 = applyGamma(colorStops[i].Color, gammaDir);
unsigned x0 = start;
unsigned dx = end - start;
if(gamma == 1)
{
while(start < end)
{
c = Ramp[start] = blendColors(c1, c2, start-x0+1, dx);
++start;
}
}
else
{
while(start < end)
{
c = Ramp[start] = blendColors(c1, c2, start-x0+1, dx, gammaInv);
++start;
}
}
}
for(; end < RampSize; end++)
{
Ramp[end] = c;
}
}
else
{
for(i = 0; i < RampSize; i++)
{
Ramp[i] = colorStops[0].Color;
}
}
}
#ifdef GFX_ADAPTIVE_GRADIENT_SIZE
const UInt GFxGradientData_RadialGradientSizeTable[] =
{
16, 16, 32, 32, 64, 64, 64, 128, 128, 128, 128, 128, 128, 256, 256, 256, 256, 256
};
#endif
UInt GFxGradientData::ComputeRadialGradientImageSize(GFxGradientParams *pparams) const
{
UInt radialGradientImageSize = 0;
if (pparams && !pparams->IsAdaptive())
{
radialGradientImageSize = pparams->GetRadialImageSize() ?
pparams->GetRadialImageSize() :
GFX_GRADIENT_SIZE_DEFAULT;
}
#ifdef GFX_ADAPTIVE_GRADIENT_SIZE
if (radialGradientImageSize == 0)
{
// Adaptive gradient size. The function heuristically
// computes the optimal gradient size depending on the
// maximal slope in the color ramp, focal point, and
// linearRGB flag. See also RadialGradientSizeTable that may
// be modified to improve the result. This table and all other
// coefficients are defined empirically, on the basis of
// the visual result in typical cases. It's a kind of magic...
//----------------------------------
UInt i;
Float maxSlope = 0;
for (i = 1; i < GetRecordCount(); ++i)
{
Float slope;
const GFxGradientRecord& g1 = pRecords[i - 1];
const GFxGradientRecord& g2 = pRecords[i];
Float dx = (Float)g2.Ratio - (Float)g1.Ratio;
if (dx > 0)
{
slope = abs((int)g1.Color.GetRed() - (int)g2.Color.GetRed()) / dx;
if (slope > maxSlope) maxSlope = slope;
slope = abs((int)g1.Color.GetGreen() - (int)g2.Color.GetGreen()) / dx;
if (slope > maxSlope) maxSlope = slope;
slope = abs((int)g1.Color.GetBlue() - (int)g2.Color.GetBlue()) / dx;
if (slope > maxSlope) maxSlope = slope;
slope = abs((int)g1.Color.GetAlpha() - (int)g2.Color.GetAlpha()) / dx;
if (slope > maxSlope) maxSlope = slope;
}
}
if (maxSlope == 0)
return GFX_GRADIENT_SIZE_DEFAULT;
if (LinearRGB)
maxSlope *= 1.5f;
if (Type == GFxFill_FocalPointGradient)
{
Float r = fabsf(FocalRatio);
if (r > 0.5f)
maxSlope /= 1.01f - r;
}
if (maxSlope < 0)
maxSlope = 0;
maxSlope = sqrtf((maxSlope + 0.18f) * 5);
UInt idx = (UInt)maxSlope;
if (idx >= sizeof(GFxGradientData_RadialGradientSizeTable) / sizeof(UInt))
idx = sizeof(GFxGradientData_RadialGradientSizeTable) / sizeof(UInt) - 1;
return GFxGradientData_RadialGradientSizeTable[idx];
}
else
return radialGradientImageSize;
#else
return radialGradientImageSize ? radialGradientImageSize : GFX_GRADIENT_SIZE_DEFAULT;
#endif // GFX_ADAPTIVE_GRADIENT_SIZE
}
// Make a GTexture* corresponding to our gradient.
// We can use this to set the gradient fill style.
GImage* GFxGradientData::CreateGradientImage(GFxGradientParams *pparams,
GMemoryHeap* pimageHeap) const
{
GUNUSED(pimageHeap);
GUNUSED(pparams);
#ifndef GFC_NO_GRADIENT_GEN
GASSERT(Type == GFxFill_LinearGradient ||
Type == GFxFill_RadialGradient ||
Type == GFxFill_FocalPointGradient);
GASSERT_ON_GRADIENT_BITMAP_GEN;
GImage *pim = 0;
UInt i, j, size;
int ratio;
Float center, radius;
GColor sample;
UByte r, g, b, a;
Float x, y;
UInt imgSize;
// Gamma=2.17 is the closest approximation of the sRGB curve.
//--------------------
GFxGradientRamp ramp(pRecords, RecordCount, LinearRGB ? 2.17f : 1.0f);
switch(Type)
{
case GFxFill_LinearGradient: // Linear gradient.
if ((pim = GImage::CreateImage(GImage::Image_ARGB_8888, 256, 1, pimageHeap))!=0)
{
for (i = 0; i < pim->Width; i++)
{
sample = ramp.GetColor(i);
pim->SetPixelRGBA(i, 0,
sample.GetRed(),
sample.GetGreen(),
sample.GetBlue(),
sample.GetAlpha());
}
}
break;
case GFxFill_RadialGradient: // Radial gradient.
imgSize = ComputeRadialGradientImageSize(pparams);
if ((pim = GImage::CreateImage(GImage::Image_ARGB_8888, imgSize, imgSize, pimageHeap))!=0)
{
center = pim->Height / 2.0f;
radius = center - 1;
size = imgSize - 1;
for (j = 1; j < size; j++)
{
for (i = 1; i < size; i++)
{
y = j - center + 0.5f;
x = i - center + 0.5f;
ratio = (int)floorf((float)sqrt(x * x + y * y) * 256 / radius + 0.5f);
if (ratio > 255)
{
ratio = 255;
}
sample = ramp.GetColor(ratio);
pim->SetPixelRGBA(i, j,
sample.GetRed(),
sample.GetGreen(),
sample.GetBlue(),
sample.GetAlpha());
}
}
sample = ramp.GetColor(255);
r = sample.GetRed();
g = sample.GetGreen();
b = sample.GetBlue();
a = sample.GetAlpha();
for(i = 1; i < imgSize; i++)
{
pim->SetPixelRGBA(i, 0, r, g, b, a);
pim->SetPixelRGBA(pim->Width-1, i, r, g, b, a);
pim->SetPixelRGBA(pim->Width-i-1, pim->Height-1, r, g, b, a);
pim->SetPixelRGBA(0, pim->Height-i-1, r, g, b, a);
}
}
break;
case GFxFill_FocalPointGradient: // Radial gradient with focal point.
imgSize = ComputeRadialGradientImageSize(pparams);
if ((pim = GImage::CreateImage(GImage::Image_ARGB_8888, imgSize, imgSize, pimageHeap))!=0)
{
center = pim->Height / 2.0f;
radius = center - 1;
size = imgSize - 1;
GFocalRadialGradient gr(radius, FocalRatio * radius, 0);
for (j = 1; j < size; j++)
{
for (i = 1; i < size; i++)
{
y = j - center + 0.5f;
x = i - center + 0.5f;
ratio = (int)floorf(gr.Calculate(x, y) * 256 / radius + 0.5f);
if (ratio > 255)
{
ratio = 255;
}
sample = ramp.GetColor(ratio);
pim->SetPixelRGBA(i, j,
sample.GetRed(),
sample.GetGreen(),
sample.GetBlue(),
sample.GetAlpha());
}
}
sample = ramp.GetColor(255);
r = sample.GetRed();
g = sample.GetGreen();
b = sample.GetBlue();
a = sample.GetAlpha();
for(i = 1; i < imgSize; i++)
{
pim->SetPixelRGBA(i, 0, r, g, b, a);
pim->SetPixelRGBA(pim->Width-1, i, r, g, b, a);
pim->SetPixelRGBA(pim->Width-i-1, pim->Height-1, r, g, b, a);
pim->SetPixelRGBA(0, pim->Height-i-1, r, g, b, a);
}
}
break;
}
return pim;
#else //GFC_NO_GRADIENT_GEN
return 0;
#endif //GFC_NO_GRADIENT_GEN
}
//
// *** GFxFillStyle
//
GFxFillStyle::GFxFillStyle()
{
Type = GFxFill_Solid;
FillFlags = FF_HasAlpha;
pGradientData = 0;
}
GFxFillStyle::GFxFillStyle(const GFxFillStyle& other)
{
Type = GFxFill_Solid;
// We need to take care of gradient assignment, etc;
// so just call operator ==.
*this = other;
}
GFxFillStyle::~GFxFillStyle()
{
if (IsGradientFill())
{
if (pGradientData)
pGradientData->Release();
}
}
void GFxFillStyle::Read(GFxLoadProcess* p, GFxTagType tagType)
{
Type = p->ReadU8();
FillFlags = 0;
p->LogParse(" FillStyle read type = 0x%X\n", Type);
if (Type == GFxFill_Solid)
{
// Read solid fill color.
GColor color;
p->ReadRgbaTag(&color, tagType);
p->LogParse(" color: ");
p->GetStream()->LogParseClass(color);
if (color.GetAlpha() < 255)
FillFlags |= FF_HasAlpha;
RawColor = color.Raw;
}
else if (IsGradientFill())
{
// 0x10: linear gradient fill
// 0x12: radial gradient fill
// 0x13: focal-point gradient fill for SWF 8
p->GetStream()->ReadMatrix(&ImageMatrix);
// GRADIENT
UInt16 numGradients = p->ReadU8();
// For DefineShape5 gradient records are interpreted differently.
// Note that Flash 8 can include these extra bits even for old tag types.
if (numGradients & 0x10)
FillFlags |= FF_LinearRGB;
// TBD: Other bits may be set here, such as 0x80 for focal point
// Do they need custom processing?
numGradients &= 0xF;
// SWF 8 allows up to 15 points.
GASSERT(numGradients >= 1 && numGradients <= 15);
// Allocate gradients.
pGradientData = GNEW GFxGradientData((GFxFillType)Type, numGradients, IsLinearRGB());
if (!pGradientData ||
pGradientData->GetRecordCount() != numGradients)
{
// Memory error...
if (pGradientData)
pGradientData->Release();
RawColor = 0;
Type = GFxFill_Solid;
return;
}
for (int i = 0; i < numGradients; i++)
{
(*pGradientData)[i].Read(p, tagType);
// Flag if the gradient has alpha channel.
if ((*pGradientData)[i].Color.GetAlpha() < 255)
FillFlags |= FF_HasAlpha;
}
p->LogParse(" gradients: numGradients = %d\n", numGradients);
// Record focal point.
if (Type == GFxFill_FocalPointGradient)
pGradientData->SetFocalRatio((float) (p->ReadS16()) / 256.0f);
// The image gradient must be replaced by gradient data,
// which controls how it will be generated during binding.
// 1. Get gradient id.
GFxResourceId charId = p->GetNextGradientId();
// If the gradient corresponds to an image in a file,
// cache it. Otherwise get the corresponding handle
const GFxExporterInfo* pexporterInfo = p->GetExporterInfo();
bool imageFromFile = pexporterInfo &&
(pexporterInfo->ExportFlags & GFxExporterInfo::EXF_GradientTexturesExported);
if (imageFromFile)
{
// We do not have to use bitmap lookup table any longer since
// gradient file loading is matched through GFxResourceLib.
GFxResourceHandle rh;
if (p->GetResourceHandle(&rh, charId))
pImage.SetFromHandle(rh);
}
else
{
// 2. Create an image handle for gradient
GFxResourceData resData = pGradientData->CreateGradientResourceData();
GFxResourceHandle rh = p->AddDataResource(charId, resData);
if (!rh.IsNull())
pImage.SetFromHandle(rh);
}
// for 'planeta.swf' loading
// GASSERT(!(pImage.IsIndex() && pImage.GetBindIndex() == 1));
// We used to pre-compute parts of image matrices here, so that inversion
// did not need to happen in GetTexture. However, two reasons caused this
// logic to be moved to rendering side:
// - the original matrix has to be lerped for correct gradient morph results
// - with ResourceLibn we don't know image sizes are they are computed later
// based on GFxGradientParams, so those sizes can not be factored into the
// image matrix.
}
else if (IsImageFill())
{
// 0x40: tiled bitmap fill
// 0x41: clipped bitmap fill
// 0x42: non-smoothed tiled fill
// 0x43: non-smoothed clipped bitmap fill
GFxResourceId bitmapResourceId = GFxResourceId(p->ReadU16());
p->LogParse(" BitmapChar = %d\n", bitmapResourceId.GetIdIndex());
//
if (!p->GetResourceHandle(&pImage, bitmapResourceId))
{
// Should not happen..
// New image ??
}
else
{
GFxTempBindData* bd = p->GetTempBindData();
if (bd && (Type == GFxFill_TiledImage || Type == GFxFill_TiledSmoothImage))
bd->FillStyleImageWrap.Add(pImage.GetBindIndex());
}
// Look up the bitmap character.
/*
pBitmap = md->GetBitmapResource(bitmapResourceId);
if (!pBitmap && bitmapResourceId != 0xFFFF)
{
// probably, this bitmap will be imported later.
// we need to create an empty bitmap resource that will be
// filled in the ImportResolve.
pBitmap = *new GFxBitmapResource(0);
md->AddBitmapResource(bitmapResourceId, pBitmap);
}
*/
p->GetStream()->ReadMatrix(&ImageMatrix);
// Always 1 for now, should probably check formats in the future.
FillFlags |= FF_HasAlpha;
p->GetStream()->LogParseClass(ImageMatrix);
}
}
// Push our style parameters into the renderer.
void GFxFillStyle::Apply(const GFxDisplayContext& dc,
Float scaleMultiplier,
const GRenderer::Matrix* s9gImgAdjust) const
{
GRenderer *prenderer = dc.GetRenderer();
if (Type == GFxFill_Solid)
{
// 0x00: solid fill
prenderer->FillStyleColor(GColor(RawColor));
}
else
{
GRenderer::FillTexture ft;
ft.pTexture = 0;
// Get the texture for gradient/bitmap fill and use it.
GetFillTexture(&ft, dc, scaleMultiplier, s9gImgAdjust);
if (ft.pTexture)
prenderer->FillStyleBitmap(&ft);
}
}
// Creates a FillTexture for a style
bool GFxFillStyle::GetFillTexture(GRenderer::FillTexture *pftexture,
const GFxDisplayContext& dc,
Float scaleMultiplier,
const GRenderer::Matrix* s9gImgAdjust) const
{
if (IsGradientFill())
{
return GetGradientFillTexture(pftexture, dc, scaleMultiplier, s9gImgAdjust);
}
else if (IsImageFill())
{
return GetImageFillTexture(pftexture, dc, scaleMultiplier, s9gImgAdjust);
}
return 0;
}
bool GFxFillStyle::GetGradientFillTexture(GRenderer::FillTexture *pftexture,
const GFxDisplayContext& dc,
Float scaleMultiplier,
const GRenderer::Matrix* s9gImgAdjust) const
{
#ifdef GFX_AMP_SERVER
ScopeFunctionTimer fillTimer(dc.pStats, NativeCodeSwdHandle, Func_GFxFillStyle_GetGradientFillTexture, Amp_Profile_Level_Low);
#endif
GRenderer *prenderer = dc.GetRenderer();
GRenderer::Matrix imgMtx;
GASSERT(prenderer);
GASSERT(dc.pResourceBinding);
// Type == GFxFill_LinearGradient ||
// Type == GFxFill_RadialGradient ||
// Type == GFxFill_FocalPointGradient (SWF 8)
GFxImageResource* pimageRes = (*dc.pResourceBinding)[pImage];
GASSERT(!pimageRes || (pimageRes->GetResourceType() == GFxResource::RT_Image));
if (!pimageRes)
{
// If our gradient image IS an index and is NOT valid it means that
// it is being rendered before being properly resolved at bind time.
if (pImage.IsIndex())
{
GASSERT(0);
return 0;
}
// We can get here when morphing gradient styles.
// TBD: May need to do locking here!
pimageRes = pGradientData->CreateImageResource(
dc.pWeakLib, dc.pGradientParams, dc.pImageCreator,
dc.GetRenderConfig(),dc.pLog, false);
if (pimageRes)
{
// TBD: Bad because we shouldn't we storing temporary
// instance - related data in fill style.
// Threading - the fact that we can only display in one thread
// may help us.
GFxFillStyle* thisNonConst = const_cast<GFxFillStyle*>(this);
thisNonConst->pImage = pimageRes;
// Release the extra gradient reference created above.
pimageRes->Release();
}
}
if (pimageRes)
{
GImageInfoBase* pimageInfo = pimageRes->GetImageInfo();
if (pimageInfo)
{
pftexture->pTexture = pimageInfo->GetTexture(prenderer);
pftexture->WrapMode = GRenderer::Wrap_Clamp;
pftexture->SampleMode = GRenderer::Sample_Linear;
pftexture->TextureMatrix.SetIdentity();
if (Type == GFxFill_LinearGradient)
{
pftexture->TextureMatrix.AppendScaling(1.0f / 32768.F);
pftexture->TextureMatrix.AppendTranslation(0.5F, 0.F);
}
else
{
// TBD: Some of these matrix computations could have been pre-computed;
// however, that is hard to do since we don't know the image size at load time.
// Furthermore, morphing requires original matrices to be used.
pftexture->TextureMatrix.AppendScaling(1.0f / 32768.F);
pftexture->TextureMatrix.AppendTranslation(0.5F, 0.5F);
// gradient's square size is 32768x32768 (-16,384 - 16,384)
}
// When using scale9grid with gradients or images,
// the image matrix has to be adjusted according to the
// "logical difference" between the world matrix and the
// central part of the scale9grid. The s9gImgAdjust (if not null)
// represents this adjustment matrix.
imgMtx = ImageMatrix;
if (s9gImgAdjust)
imgMtx.Append(*s9gImgAdjust);
pftexture->TextureMatrix.Prepend(imgMtx.GetInverse());
pftexture->TextureMatrix.PrependScaling(scaleMultiplier);
return 1;
}
}
return 0;
}
// Bitmap Fill (either tiled or clipped)
bool GFxFillStyle::GetImageFillTexture(GRenderer::FillTexture *pftexture,
const GFxDisplayContext& dc,
Float scaleMultiplier,
const GRenderer::Matrix* s9gImgAdjust) const
{
#ifdef GFX_AMP_SERVER
ScopeFunctionTimer fillTimer(dc.pStats, NativeCodeSwdHandle, Func_GFxFillStyle_GetImageFillTexture, Amp_Profile_Level_Low);
#endif
GRenderer *prenderer = dc.GetRenderer();
GRenderer::Matrix imgMtx;
GASSERT(prenderer);
GFxImageResource* pimageRes = static_cast<GFxImageResource*>(pImage.GetResourcePtr());
if (!pimageRes)
{
GASSERT(dc.pResourceBinding);
pimageRes = (*dc.pResourceBinding)[pImage];
}
GImageInfoBase* pimageInfo = pimageRes ? pimageRes->GetImageInfo() : 0;
if (pimageInfo)
{
GTexture* ptexture = pimageInfo->GetTexture(prenderer);
if (ptexture)
{
GRenderer::BitmapWrapMode wm = GRenderer::Wrap_Repeat;
GRenderer::BitmapSampleMode sm = GRenderer::Sample_Linear;
switch(Type)
{
case GFxFill_TiledSmoothImage: wm = GRenderer::Wrap_Repeat; sm = GRenderer::Sample_Linear; break;
case GFxFill_ClippedSmoothImage: wm = GRenderer::Wrap_Clamp; sm = GRenderer::Sample_Linear; break;
case GFxFill_TiledImage: wm = GRenderer::Wrap_Repeat; sm = GRenderer::Sample_Point; break;
case GFxFill_ClippedImage: wm = GRenderer::Wrap_Clamp; sm = GRenderer::Sample_Point; break;
default:
GASSERT(0);
}
// When using scale9grid with gradients or images,
// the image matrix has to be adjusted according to the
// "logical difference" between the world matrix and the
// central part of the scale9grid. The s9gImgAdjust (if not null)
// represents this adjustment matrix.
imgMtx = ImageMatrix;
if (s9gImgAdjust)
imgMtx.Append(*s9gImgAdjust);
GRect<SInt> rect = pimageInfo->GetRect();
pftexture->pTexture = ptexture;
pftexture->TextureMatrix.SetInverse(imgMtx);
pftexture->TextureMatrix.PrependScaling(scaleMultiplier);
pftexture->TextureMatrix.AppendTranslation(Float(rect.Left), Float(rect.Top));
pftexture->TextureMatrix.AppendScaling(1.0f/pimageInfo->GetWidth(), 1.0f/pimageInfo->GetHeight());
pftexture->WrapMode = wm;
pftexture->SampleMode= sm;
return 1;
}
}
return 0;
}
GImageInfoBase* GFxFillStyle::GetImageInfo(const GFxDisplayContext& dc) const
{
if (IsImageFill() || IsGradientFill())
{
GFxImageResource* pimageRes = (*dc.pResourceBinding)[pImage];
if (pimageRes)
return pimageRes->GetImageInfo();
}
return 0;
}
// Sets this style to a blend of a and b. t = [0,1]
void GFxFillStyle::SetLerp(const GFxFillStyle& a, const GFxFillStyle& b, Float t)
{
GASSERT(t >= 0 && t <= 1);
// fill style type
Type = (UByte)a.GetType();
GASSERT(Type == b.GetType());
if (Type == GFxFill_Solid)
{
// Fill style color
RawColor = GColor::Blend(a.GetColor(), b.GetColor(), t).Raw;
return;
}
else if (IsGradientFill())
{
GASSERT(a.pGradientData && b.pGradientData);
GASSERT(a.pGradientData->GetRecordCount() == b.pGradientData->GetRecordCount());
GFxGradientData &agd = *a.pGradientData,
&bgd = *b.pGradientData;
// We have to create a new GradientData object here because
// gradient data objects are used as keys when generating gradient
// image resources and thus can not be modified!!
if (pGradientData)
pGradientData->Release();
pGradientData = GNEW GFxGradientData(a.GetType(),
agd.GetRecordCount(),
a.IsLinearRGB());
if (pGradientData)
{
for (UInt j=0; j < pGradientData->GetRecordCount(); j++)
{
(*pGradientData)[j].Ratio =
(UByte) gfrnd(gflerp(agd[j].Ratio, bgd[j].Ratio, t));
(*pGradientData)[j].Color = GColor::Blend(agd[j].Color,
bgd[j].Color, t);
}
}
pGradientData->SetFocalRatio(gflerp(agd.GetFocalRatio(),
bgd.GetFocalRatio(), t));
// Reset image handle ??? So that it is cached??
// Need to test gradient morphing
// NULL Handle -> uninitialized image pointer ??
pImage = 0;
// We will need to do this in thread safe manner
// and coordinate with the library...
}
else if (IsImageFill())
{
pImage = a.pImage;
GASSERT(pImage == b.pImage);
}
// fill style bitmap GRenderer::Matrix
ImageMatrix.SetLerp(a.ImageMatrix, b.ImageMatrix, t);
}
GFxFillStyle& GFxFillStyle::operator = (const GFxFillStyle& src)
{
// Implement correct ref-counting for pGradientData.
if (src.IsGradientFill() && src.pGradientData)
src.pGradientData->AddRef();
if (IsGradientFill() && pGradientData)
pGradientData->Release();
Type = src.Type;
FillFlags = src.FillFlags;
pGradientData = src.pGradientData;
GCOMPILER_ASSERT(sizeof(GFxGradientData*) >= sizeof(RawColor));
pImage = src.pImage;
ImageMatrix = src.ImageMatrix;
return *this;
}
void GFxFillStyle::SetFillType(GFxFillType type)
{
if (IsGradientFill() && pGradientData)
pGradientData->Release();
GASSERT((int)type <= 255);
Type = (UByte)type;
}
// Sets fill style to an image, used to support externally loaded images.
void GFxFillStyle::SetImageFill(GFxFillType fillType,
GFxImageResource *pimage,
const GRenderer::Matrix& mtx)
{
SetFillType(fillType);
GASSERT(IsImageFill());
/*
if (bilinear)
{
if (tiled) Type = (UByte) GFxFill_TiledSmoothImage;
else Type = (UByte) GFxFill_ClippedSmoothImage;
}
else
{
if (tiled) Type = (UByte) GFxFill_TiledImage;
else Type = (UByte) GFxFill_ClippedImage;
}
*/
FillFlags = FF_HasAlpha;
ImageMatrix = mtx;
ImageMatrix.AppendScaling(20);
pImage = pimage;
}
void GFxFillStyle::SetGradientFill(GFxFillType fillType,
GFxGradientData *pgradientData,
const GRenderer::Matrix& mtx)
{
if (!(IsGradientFill() && pgradientData == pGradientData))
{
SetFillType(fillType);
GASSERT(pgradientData->GetFillType() == fillType);
GASSERT(IsGradientFill());
// Gradient data must live in a global heap since it is used as a key in ResourceLib.
GASSERT(GMemory::GetHeapByAddress(pgradientData) == GMemory::GetGlobalHeap());
pGradientData = pgradientData;
if (pGradientData)
pGradientData->AddRef();
}
ImageMatrix = mtx;
ImageMatrix.M_[0][2] = PixelsToTwips(ImageMatrix.M_[0][2]);
ImageMatrix.M_[1][2] = PixelsToTwips(ImageMatrix.M_[1][2]);
}
//
// GFxLineStyle
//
GFxLineStyle::GFxLineStyle()
{
Width = 0;
pComplexFill= 0;
StyleFlags = 0;
#ifndef GFC_NO_FXPLAYER_STROKER
MiterSize = 1.0f; // Must be 1.0 for GetStrokeExtent() to work correctly.
#endif
}
GFxLineStyle::GFxLineStyle(const GFxLineStyle& other)
{
pComplexFill = 0;
*this = other;
}
GFxLineStyle::~GFxLineStyle()
{
if (pComplexFill)
delete pComplexFill;
}
// Line styles are stored in an array, so implement =
// for safety of data structures on assignment.
GFxLineStyle& GFxLineStyle::operator = (const GFxLineStyle& src)
{
Width = src.Width;
Color = src.Color;
#ifndef GFC_NO_FXPLAYER_STROKER
StyleFlags = src.StyleFlags;
MiterSize = src.MiterSize;
#endif
if (pComplexFill)
{
delete pComplexFill;
pComplexFill = 0;
}
if (src.pComplexFill)
pComplexFill = GNEW GFxFillStyle(*src.pComplexFill);
return *this;
}
void GFxLineStyle::SetComplexFill(const GFxFillStyle& f)
{
if (pComplexFill)
delete pComplexFill;
pComplexFill = GNEW GFxFillStyle(f);
}
GFxFillStyle* GFxLineStyle::CreateComplexFill()
{
if (pComplexFill == 0)
pComplexFill = GNEW GFxFillStyle;
return pComplexFill;
}
void GFxLineStyle::Read(GFxLoadProcess* p, GFxTagType tagType)
{
Width = p->ReadU16();
UInt16 styleFlags = 0;
// Extra values come here for DefineShape5.
if (tagType == GFxTag_DefineShape4)
{
styleFlags = p->ReadU16();
StyleFlags = styleFlags;
// Miter is followed by a special 16.16 value
if (styleFlags & LineJoin_Miter)
{
#ifndef GFC_NO_FXPLAYER_STROKER
MiterSize = (Float)(p->ReadU16()) / 256.0f;
#else
p->ReadU16();
#endif
}
}
// If we have complex SWF 8 fill style, read it in.
if (styleFlags & LineFlag_ComplexFill)
{
GFxFillStyle fs, *pfill;
if ((pComplexFill = GHEAP_NEW(p->GetLoadHeap()) GFxFillStyle)!=0)
pfill = pComplexFill;
else
pfill = &fs;
pfill->Read(p, tagType);
// Avoid ASSERT in GetColor() for gradient strokes.
if (pfill->IsSolidFill())
Color = pfill->GetColor();
else if (pfill->IsGradientFill())
{
GFxGradientData *pgdata = pfill->GetGradientData();
if (pgdata && pgdata->GetRecordCount() > 0)
Color = (*pgdata)[0].Color;
}
}
else
{
// Usual case: solid color line.
p->ReadRgbaTag(&Color, tagType);
}
}
void GFxLineStyle::Apply(GRenderer *prenderer) const
{
prenderer->LineStyleColor(Color);
//prenderer->LineStyleWidth(Width);
}
Reference in New Issue Copy Permalink