142 lines
5.0 KiB
C++
142 lines
5.0 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "core/texture_parm.h"
|
|
#include "core/render_data.h"
|
|
#include "picture/pict.h"
|
|
#include "metafile/nml.h"
|
|
#include "metafile/nml_object.h"
|
|
#include "reflection/c_refl.h"
|
|
#include "log/log.h"
|
|
|
|
using namespace GS;
|
|
using namespace GS::Render;
|
|
using namespace GS::Reflection;
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
const char *TextureParm::GetSwizzleFlags(Swizzle swizzle)
|
|
{
|
|
static char RGBA[4] = { 0, 1, 2, 3 };
|
|
static char BGRA[4] = { 2, 1, 0, 3 };
|
|
static char ARGB[4] = { 3, 0, 1, 2 };
|
|
static char ABGR[4] = { 3, 2, 1, 0 };
|
|
static char XYZ[4] = { 0, 1, 2, 3 };
|
|
static char XZY[4] = { 0, 2, 1, 3 };
|
|
static char YXZ[4] = { 1, 0, 2, 3 };
|
|
static char YZX[4] = { 1, 2, 0, 3 };
|
|
static char ZXY[4] = { 2, 0, 1, 3 };
|
|
static char ZYX[4] = { 2, 1, 0, 3 };
|
|
|
|
switch (swizzle)
|
|
{
|
|
default:
|
|
break;
|
|
|
|
case SwizzleRGBA: return RGBA;
|
|
case SwizzleBGRA: return BGRA;
|
|
case SwizzleARGB: return ARGB;
|
|
case SwizzleABGR: return ABGR;
|
|
case SwizzleXYZ: return XYZ;
|
|
case SwizzleXZY: return XZY;
|
|
case SwizzleYXZ: return YXZ;
|
|
case SwizzleYZX: return YZX;
|
|
case SwizzleZXY: return ZXY;
|
|
case SwizzleZYX: return ZYX;
|
|
}
|
|
return RGBA;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
void TextureParm::Apply(Picture &p) const
|
|
{
|
|
const char *f = GetSwizzleFlags(swizzle);
|
|
p.Swizzle(f[0], f[1], f[2], f[3]);
|
|
p.Negative(invert[0], invert[1], invert[2], invert[3]);
|
|
p.Flip(flip[0], flip[1]);
|
|
}
|
|
void TextureParm::Apply(Texture &t) const
|
|
{
|
|
t.SetFiltering(filtering);
|
|
t.SetAnisotropy(anisotropy);
|
|
t.SetWrapping(wrap_u, wrap_v);
|
|
|
|
// Note: LOD bias is done per texture stage.
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
Enum::Dict TextureParm::filtering_dict[] =
|
|
{
|
|
{ TextureParm::FilterDefault, "Default" },
|
|
{ TextureParm::FilterNearest, "Nearest" },
|
|
{ TextureParm::FilterBilinear, "Bilinear" },
|
|
{ TextureParm::FilterTrilinear, "Trilinear" },
|
|
{ 0, 0 }
|
|
};
|
|
Enum::Dict TextureParm::anisotropic_dict[] =
|
|
{
|
|
{ TextureParm::AnisotropyDefault, "Default" },
|
|
{ TextureParm::AnisotropyNone, "None" },
|
|
{ TextureParm::Anisotropy2x, "2x" },
|
|
{ TextureParm::Anisotropy4x, "4x" },
|
|
{ TextureParm::Anisotropy8x, "8x" },
|
|
{ TextureParm::Anisotropy16x, "16x" },
|
|
{ 0, 0 }
|
|
};
|
|
Enum::Dict TextureParm::wrap_dict[] =
|
|
{
|
|
{ TextureParm::WrapDefault, "Default" },
|
|
{ TextureParm::WrapRepeat, "Repeat" },
|
|
{ TextureParm::WrapClamp, "Clamp" },
|
|
{ 0, 0 }
|
|
};
|
|
Enum::Dict TextureParm::swizzle_dict[] =
|
|
{
|
|
{ TextureParm::SwizzleRGBA, "RGBA" },
|
|
{ TextureParm::SwizzleBGRA, "BGRA" },
|
|
{ TextureParm::SwizzleARGB, "ARGB" },
|
|
{ TextureParm::SwizzleABGR, "ABGR" },
|
|
{ TextureParm::SwizzleXYZ, "XYZ" },
|
|
{ TextureParm::SwizzleXZY, "XZY" },
|
|
{ TextureParm::SwizzleYXZ, "YXZ" },
|
|
{ TextureParm::SwizzleYZX, "YZX" },
|
|
{ TextureParm::SwizzleZXY, "ZXY" },
|
|
{ TextureParm::SwizzleZYX, "ZYX" },
|
|
{ 0, 0 }
|
|
};
|
|
Property TextureParm::serializable[] =
|
|
{
|
|
{ Property::EnumProp, "WrapU", offsetof(TextureParm, wrap_u), wrap_dict },
|
|
{ Property::EnumProp, "WrapV", offsetof(TextureParm, wrap_v), wrap_dict },
|
|
{ Property::EnumProp, "Filtering", offsetof(TextureParm, filtering), filtering_dict },
|
|
{ Property::EnumProp, "Anisotropy", offsetof(TextureParm, anisotropy), anisotropic_dict },
|
|
{ Property::EnumProp, "Swizzle", offsetof(TextureParm, swizzle), swizzle_dict },
|
|
{ Property::BoolProp, "InvertR", offsetof(TextureParm, invert[0]), NULL },
|
|
{ Property::BoolProp, "InvertG", offsetof(TextureParm, invert[1]), NULL },
|
|
{ Property::BoolProp, "InvertB", offsetof(TextureParm, invert[2]), NULL },
|
|
{ Property::BoolProp, "InvertA", offsetof(TextureParm, invert[3]), NULL },
|
|
{ Property::BoolProp, "FlipU", offsetof(TextureParm, flip[0]), NULL },
|
|
{ Property::BoolProp, "FlipV", offsetof(TextureParm, flip[1]), NULL },
|
|
{ Property::FloatProp, "LODBias", offsetof(TextureParm, lod_bias), NULL },
|
|
|
|
{ Property::InvalidProp, 0, 0 }
|
|
};
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
String TextureParm::GetParmFileName(const char *uri)
|
|
{ return String::Format("%s.parm", uri); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool TextureParm::FromMetaTag(NML::Tag &t)
|
|
{ return t.name == "TextureParm" ? GenericObjectFromMetaTag(t, this, serializable) : false; }
|
|
NML::Tag *TextureParm::AsMetaTag() const
|
|
{ return NML::GenericObjectToMetaTag(new NML::Tag("TextureParm"), this, serializable); }
|
|
//------------------------------------------------------------------------------
|