mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-23 06:09:50 -06:00
Merge pull request #10808 from Pokechu22/vertex-loader-direct-normals-with-index3
VideoCommon: Fix direct normal+tangent+binormal with index3 set
This commit is contained in:
JMC47
@ -485,13 +485,22 @@ void ARM64XEmitter::EncodeLoadStorePairedInst(u32 op, ARM64Reg Rt, ARM64Reg Rt2,
|
||||
bool bVec = IsVector(Rt);
|
||||
|
||||
if (b128Bit)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0xf) == 0, "128-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 4;
|
||||
}
|
||||
else if (b64Bit)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 2;
|
||||
}
|
||||
|
||||
ASSERT_MSG(DYNA_REC, !(imm & ~0xF), "offset too large {}", imm);
|
||||
ASSERT_MSG(DYNA_REC, (imm & ~0xF) == 0, "offset too large {}", imm);
|
||||
|
||||
u32 opc = 0;
|
||||
if (b128Bit)
|
||||
@ -524,11 +533,20 @@ void ARM64XEmitter::EncodeLoadStoreIndexedInst(u32 op, ARM64Reg Rt, ARM64Reg Rn,
|
||||
bool bVec = IsVector(Rt);
|
||||
|
||||
if (size == 64)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 3;
|
||||
}
|
||||
else if (size == 32)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 2;
|
||||
}
|
||||
else if (size == 16)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x1) == 0, "16-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 1;
|
||||
}
|
||||
|
||||
ASSERT_MSG(DYNA_REC, imm >= 0, "(IndexType::Unsigned): offset must be positive {}", imm);
|
||||
ASSERT_MSG(DYNA_REC, !(imm & ~0xFFF), "(IndexType::Unsigned): offset too large {}", imm);
|
||||
@ -615,10 +633,12 @@ void ARM64XEmitter::EncodeLoadStorePair(u32 op, u32 load, IndexType type, ARM64R
|
||||
if (b64Bit)
|
||||
{
|
||||
op |= 0b10;
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 2;
|
||||
}
|
||||
|
||||
@ -2072,19 +2092,29 @@ void ARM64FloatEmitter::EmitLoadStoreImmediate(u8 size, u32 opc, IndexType type,
|
||||
|
||||
if (type == IndexType::Unsigned)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, !(imm & ((size - 1) >> 3)),
|
||||
"(IndexType::Unsigned) immediate offset must be aligned to size! ({}) ({})", imm,
|
||||
fmt::ptr(m_emit->GetCodePtr()));
|
||||
ASSERT_MSG(DYNA_REC, imm >= 0, "(IndexType::Unsigned) immediate offset must be positive! ({})",
|
||||
imm);
|
||||
if (size == 16)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x1) == 0, "16-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 1;
|
||||
}
|
||||
else if (size == 32)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 2;
|
||||
}
|
||||
else if (size == 64)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 3;
|
||||
}
|
||||
else if (size == 128)
|
||||
{
|
||||
ASSERT_MSG(DYNA_REC, (imm & 0xf) == 0, "128-bit load/store must use aligned offset: {}", imm);
|
||||
imm >>= 4;
|
||||
}
|
||||
ASSERT_MSG(DYNA_REC, imm <= 0xFFF, "Immediate value is too big: {}", imm);
|
||||
encoded_imm = (imm & 0xFFF);
|
||||
}
|
||||
else
|
||||
|
||||
@ -60,38 +60,22 @@ VertexLoaderARM64::VertexLoaderARM64(const TVtxDesc& vtx_desc, const VAT& vtx_at
|
||||
WriteProtect();
|
||||
}
|
||||
|
||||
void VertexLoaderARM64::GetVertexAddr(CPArray array, VertexComponentFormat attribute, ARM64Reg reg)
|
||||
// Returns the register to use as the base and an offset from that register.
|
||||
// For indexed attributes, the index is read into scratch1_reg, and then scratch1_reg with no offset
|
||||
// is returned. For direct attributes, an offset from src_reg is returned.
|
||||
std::pair<Arm64Gen::ARM64Reg, u32> VertexLoaderARM64::GetVertexAddr(CPArray array,
|
||||
VertexComponentFormat attribute)
|
||||
{
|
||||
if (IsIndexed(attribute))
|
||||
{
|
||||
if (attribute == VertexComponentFormat::Index8)
|
||||
{
|
||||
if (m_src_ofs < 4096)
|
||||
{
|
||||
LDRB(IndexType::Unsigned, scratch1_reg, src_reg, m_src_ofs);
|
||||
}
|
||||
else
|
||||
{
|
||||
ADD(reg, src_reg, m_src_ofs);
|
||||
LDRB(IndexType::Unsigned, scratch1_reg, reg, 0);
|
||||
}
|
||||
LDURB(scratch1_reg, src_reg, m_src_ofs);
|
||||
m_src_ofs += 1;
|
||||
}
|
||||
else
|
||||
else // Index16
|
||||
{
|
||||
if (m_src_ofs < 256)
|
||||
{
|
||||
LDURH(scratch1_reg, src_reg, m_src_ofs);
|
||||
}
|
||||
else if (m_src_ofs <= 8190 && !(m_src_ofs & 1))
|
||||
{
|
||||
LDRH(IndexType::Unsigned, scratch1_reg, src_reg, m_src_ofs);
|
||||
}
|
||||
else
|
||||
{
|
||||
ADD(reg, src_reg, m_src_ofs);
|
||||
LDRH(IndexType::Unsigned, scratch1_reg, reg, 0);
|
||||
}
|
||||
LDURH(scratch1_reg, src_reg, m_src_ofs);
|
||||
m_src_ofs += 2;
|
||||
REV16(scratch1_reg, scratch1_reg);
|
||||
}
|
||||
@ -109,25 +93,19 @@ void VertexLoaderARM64::GetVertexAddr(CPArray array, VertexComponentFormat attri
|
||||
|
||||
LDR(IndexType::Unsigned, EncodeRegTo64(scratch2_reg), arraybase_reg,
|
||||
static_cast<u8>(array) * 8);
|
||||
ADD(EncodeRegTo64(reg), EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch2_reg));
|
||||
ADD(EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch2_reg));
|
||||
return {EncodeRegTo64(scratch1_reg), 0};
|
||||
}
|
||||
else
|
||||
ADD(reg, src_reg, m_src_ofs);
|
||||
{
|
||||
return {src_reg, m_src_ofs};
|
||||
}
|
||||
}
|
||||
|
||||
s32 VertexLoaderARM64::GetAddressImm(CPArray array, VertexComponentFormat attribute,
|
||||
Arm64Gen::ARM64Reg reg, u32 align)
|
||||
{
|
||||
if (IsIndexed(attribute) || (m_src_ofs > 255 && (m_src_ofs & (align - 1))))
|
||||
GetVertexAddr(array, attribute, reg);
|
||||
else
|
||||
return m_src_ofs;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentFormat format,
|
||||
int count_in, int count_out, bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format, s32 offset)
|
||||
void VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentFormat format,
|
||||
int count_in, int count_out, bool dequantize,
|
||||
u8 scaling_exponent, AttributeFormat* native_format,
|
||||
ARM64Reg reg, u32 offset)
|
||||
{
|
||||
ARM64Reg coords = count_in == 3 ? ARM64Reg::Q31 : ARM64Reg::D31;
|
||||
ARM64Reg scale = count_in == 3 ? ARM64Reg::Q30 : ARM64Reg::D30;
|
||||
@ -136,23 +114,8 @@ int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentForm
|
||||
int load_bytes = elem_size * count_in;
|
||||
int load_size = GetLoadSize(load_bytes);
|
||||
load_size <<= 3;
|
||||
elem_size <<= 3;
|
||||
|
||||
if (offset == -1)
|
||||
{
|
||||
if (count_in == 1)
|
||||
m_float_emit.LDR(elem_size, IndexType::Unsigned, coords, EncodeRegTo64(scratch1_reg), 0);
|
||||
else
|
||||
m_float_emit.LD1(elem_size, 1, coords, EncodeRegTo64(scratch1_reg));
|
||||
}
|
||||
else if (offset & (load_size - 1)) // Not aligned - unscaled
|
||||
{
|
||||
m_float_emit.LDUR(load_size, coords, src_reg, offset);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_float_emit.LDR(load_size, IndexType::Unsigned, coords, src_reg, offset);
|
||||
}
|
||||
m_float_emit.LDUR(load_size, coords, reg, offset);
|
||||
|
||||
if (format != ComponentFormat::Float)
|
||||
{
|
||||
@ -191,20 +154,7 @@ int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentForm
|
||||
}
|
||||
|
||||
const u32 write_size = count_out == 3 ? 128 : count_out * 32;
|
||||
const u32 mask = count_out == 3 ? 0xF : count_out == 2 ? 0x7 : 0x3;
|
||||
if (m_dst_ofs < 256)
|
||||
{
|
||||
m_float_emit.STUR(write_size, coords, dst_reg, m_dst_ofs);
|
||||
}
|
||||
else if (!(m_dst_ofs & mask))
|
||||
{
|
||||
m_float_emit.STR(write_size, IndexType::Unsigned, coords, dst_reg, m_dst_ofs);
|
||||
}
|
||||
else
|
||||
{
|
||||
ADD(EncodeRegTo64(scratch2_reg), dst_reg, m_dst_ofs);
|
||||
m_float_emit.ST1(32, 1, coords, EncodeRegTo64(scratch2_reg));
|
||||
}
|
||||
m_float_emit.STUR(write_size, coords, dst_reg, m_dst_ofs);
|
||||
|
||||
// Z-Freeze
|
||||
if (native_format == &m_native_vtx_decl.position)
|
||||
@ -239,11 +189,10 @@ int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentForm
|
||||
|
||||
if (attribute == VertexComponentFormat::Direct)
|
||||
m_src_ofs += load_bytes;
|
||||
|
||||
return load_bytes;
|
||||
}
|
||||
|
||||
void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat format, s32 offset)
|
||||
void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat format, ARM64Reg reg,
|
||||
u32 offset)
|
||||
{
|
||||
int load_bytes = 0;
|
||||
switch (format)
|
||||
@ -251,12 +200,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
|
||||
case ColorFormat::RGB888:
|
||||
case ColorFormat::RGB888x:
|
||||
case ColorFormat::RGBA8888:
|
||||
if (offset == -1)
|
||||
LDR(IndexType::Unsigned, scratch2_reg, EncodeRegTo64(scratch1_reg), 0);
|
||||
else if (offset & 3) // Not aligned - unscaled
|
||||
LDUR(scratch2_reg, src_reg, offset);
|
||||
else
|
||||
LDR(IndexType::Unsigned, scratch2_reg, src_reg, offset);
|
||||
LDUR(scratch2_reg, reg, offset);
|
||||
|
||||
if (format != ColorFormat::RGBA8888)
|
||||
ORR(scratch2_reg, scratch2_reg, LogicalImm(0xFF000000, 32));
|
||||
@ -267,12 +211,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
|
||||
case ColorFormat::RGB565:
|
||||
// RRRRRGGG GGGBBBBB
|
||||
// AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR
|
||||
if (offset == -1)
|
||||
LDRH(IndexType::Unsigned, scratch3_reg, EncodeRegTo64(scratch1_reg), 0);
|
||||
else if (offset & 1) // Not aligned - unscaled
|
||||
LDURH(scratch3_reg, src_reg, offset);
|
||||
else
|
||||
LDRH(IndexType::Unsigned, scratch3_reg, src_reg, offset);
|
||||
LDURH(scratch3_reg, reg, offset);
|
||||
|
||||
REV16(scratch3_reg, scratch3_reg);
|
||||
|
||||
@ -304,12 +243,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
|
||||
// BBBBAAAA RRRRGGGG
|
||||
// REV16 - RRRRGGGG BBBBAAAA
|
||||
// AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR
|
||||
if (offset == -1)
|
||||
LDRH(IndexType::Unsigned, scratch3_reg, EncodeRegTo64(scratch1_reg), 0);
|
||||
else if (offset & 1) // Not aligned - unscaled
|
||||
LDURH(scratch3_reg, src_reg, offset);
|
||||
else
|
||||
LDRH(IndexType::Unsigned, scratch3_reg, src_reg, offset);
|
||||
LDURH(scratch3_reg, reg, offset);
|
||||
|
||||
// R
|
||||
UBFM(scratch1_reg, scratch3_reg, 4, 7);
|
||||
@ -336,18 +270,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
|
||||
case ColorFormat::RGBA6666:
|
||||
// RRRRRRGG GGGGBBBB BBAAAAAA
|
||||
// AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR
|
||||
if (offset == -1)
|
||||
{
|
||||
LDUR(scratch3_reg, EncodeRegTo64(scratch1_reg), -1);
|
||||
}
|
||||
else
|
||||
{
|
||||
offset -= 1;
|
||||
if (offset & 3) // Not aligned - unscaled
|
||||
LDUR(scratch3_reg, src_reg, offset);
|
||||
else
|
||||
LDR(IndexType::Unsigned, scratch3_reg, src_reg, offset);
|
||||
}
|
||||
LDUR(scratch3_reg, reg, offset - 1);
|
||||
|
||||
REV32(scratch3_reg, scratch3_reg);
|
||||
|
||||
@ -385,6 +308,12 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
|
||||
|
||||
void VertexLoaderARM64::GenerateVertexLoader()
|
||||
{
|
||||
// The largest input vertex (with the position matrix index and all texture matrix indices
|
||||
// enabled, and all components set as direct) is 129 bytes (corresponding to a 156-byte
|
||||
// output). This is small enough that we can always use the unscaled load/store instructions
|
||||
// (which allow an offset from -256 to +255).
|
||||
ASSERT(m_vertex_size <= 255);
|
||||
|
||||
// R0 - Source pointer
|
||||
// R1 - Destination pointer
|
||||
// R2 - Count
|
||||
@ -456,49 +385,45 @@ void VertexLoaderARM64::GenerateVertexLoader()
|
||||
|
||||
// Position
|
||||
{
|
||||
int elem_size = GetElementSize(m_VtxAttr.g0.PosFormat);
|
||||
int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
|
||||
int load_bytes = elem_size * pos_elements;
|
||||
int load_size = GetLoadSize(load_bytes);
|
||||
load_size <<= 3;
|
||||
const int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
|
||||
|
||||
s32 offset = GetAddressImm(CPArray::Position, m_VtxDesc.low.Position,
|
||||
EncodeRegTo64(scratch1_reg), load_size);
|
||||
const auto [reg, offset] = GetVertexAddr(CPArray::Position, m_VtxDesc.low.Position);
|
||||
ReadVertex(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, pos_elements, pos_elements,
|
||||
m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position, offset);
|
||||
m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position, reg,
|
||||
offset);
|
||||
}
|
||||
|
||||
if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
|
||||
{
|
||||
static const u8 map[8] = {7, 6, 15, 14};
|
||||
const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())];
|
||||
const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB ? 3 : 1;
|
||||
static constexpr Common::EnumMap<u8, static_cast<ComponentFormat>(7)> SCALE_MAP = {7, 6, 15, 14,
|
||||
0, 0, 0, 0};
|
||||
const u8 scaling_exponent = SCALE_MAP[m_VtxAttr.g0.NormalFormat];
|
||||
|
||||
s32 offset = -1;
|
||||
for (int i = 0; i < limit; i++)
|
||||
// Normal
|
||||
auto [reg, offset] = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
|
||||
ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
|
||||
&m_native_vtx_decl.normals[0], reg, offset);
|
||||
|
||||
if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB)
|
||||
{
|
||||
if (!i || m_VtxAttr.g0.NormalIndex3)
|
||||
{
|
||||
int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
|
||||
const bool index3 = IsIndexed(m_VtxDesc.low.Normal) && m_VtxAttr.g0.NormalIndex3;
|
||||
const int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
|
||||
const int load_bytes = elem_size * 3;
|
||||
|
||||
int load_bytes = elem_size * 3;
|
||||
int load_size = GetLoadSize(load_bytes);
|
||||
|
||||
offset = GetAddressImm(CPArray::Normal, m_VtxDesc.low.Normal, EncodeRegTo64(scratch1_reg),
|
||||
load_size << 3);
|
||||
|
||||
if (offset == -1)
|
||||
ADD(EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch1_reg), i * elem_size * 3);
|
||||
else
|
||||
offset += i * elem_size * 3;
|
||||
}
|
||||
int bytes_read = ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
|
||||
scaling_exponent, &m_native_vtx_decl.normals[i], offset);
|
||||
|
||||
if (offset == -1)
|
||||
ADD(EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch1_reg), bytes_read);
|
||||
else
|
||||
offset += bytes_read;
|
||||
// Tangent
|
||||
// If in Index3 mode, and indexed components are used, replace the index with a new index.
|
||||
if (index3)
|
||||
std::tie(reg, offset) = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
|
||||
// The tangent comes after the normal; even in index3 mode, an extra offset of load_bytes is
|
||||
// applied. Note that this is different from adding 1 to the index, as the stride for indices
|
||||
// may be different from the size of the tangent itself.
|
||||
ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
|
||||
&m_native_vtx_decl.normals[1], reg, offset + load_bytes);
|
||||
// Binormal
|
||||
if (index3)
|
||||
std::tie(reg, offset) = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
|
||||
ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
|
||||
&m_native_vtx_decl.normals[2], reg, offset + load_bytes * 2);
|
||||
}
|
||||
}
|
||||
|
||||
@ -510,14 +435,8 @@ void VertexLoaderARM64::GenerateVertexLoader()
|
||||
|
||||
if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent)
|
||||
{
|
||||
u32 align = 4;
|
||||
if (m_VtxAttr.GetColorFormat(i) == ColorFormat::RGB565 ||
|
||||
m_VtxAttr.GetColorFormat(i) == ColorFormat::RGBA4444)
|
||||
align = 2;
|
||||
|
||||
s32 offset = GetAddressImm(CPArray::Color0 + i, m_VtxDesc.low.Color[i],
|
||||
EncodeRegTo64(scratch1_reg), align);
|
||||
ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), offset);
|
||||
const auto [reg, offset] = GetVertexAddr(CPArray::Color0 + i, m_VtxDesc.low.Color[i]);
|
||||
ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), reg, offset);
|
||||
m_native_vtx_decl.colors[i].components = 4;
|
||||
m_native_vtx_decl.colors[i].enable = true;
|
||||
m_native_vtx_decl.colors[i].offset = m_dst_ofs;
|
||||
@ -533,20 +452,14 @@ void VertexLoaderARM64::GenerateVertexLoader()
|
||||
m_native_vtx_decl.texcoords[i].type = ComponentFormat::Float;
|
||||
m_native_vtx_decl.texcoords[i].integer = false;
|
||||
|
||||
int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::S ? 1 : 2;
|
||||
const int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::S ? 1 : 2;
|
||||
if (m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent)
|
||||
{
|
||||
int elem_size = GetElementSize(m_VtxAttr.GetTexFormat(i));
|
||||
int load_bytes = elem_size * (elements + 2);
|
||||
int load_size = GetLoadSize(load_bytes);
|
||||
load_size <<= 3;
|
||||
|
||||
s32 offset = GetAddressImm(CPArray::TexCoord0 + i, m_VtxDesc.high.TexCoord[i],
|
||||
EncodeRegTo64(scratch1_reg), load_size);
|
||||
const auto [reg, offset] = GetVertexAddr(CPArray::TexCoord0 + i, m_VtxDesc.high.TexCoord[i]);
|
||||
u8 scaling_exponent = m_VtxAttr.GetTexFrac(i);
|
||||
ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements,
|
||||
m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.g0.ByteDequant,
|
||||
scaling_exponent, &m_native_vtx_decl.texcoords[i], offset);
|
||||
scaling_exponent, &m_native_vtx_decl.texcoords[i], reg, offset);
|
||||
}
|
||||
if (m_VtxDesc.low.TexMatIdx[i])
|
||||
{
|
||||
@ -567,22 +480,7 @@ void VertexLoaderARM64::GenerateVertexLoader()
|
||||
{
|
||||
m_native_vtx_decl.texcoords[i].offset = m_dst_ofs;
|
||||
|
||||
if (m_dst_ofs < 256)
|
||||
{
|
||||
STUR(ARM64Reg::SP, dst_reg, m_dst_ofs);
|
||||
}
|
||||
else if (!(m_dst_ofs & 7))
|
||||
{
|
||||
// If m_dst_ofs isn't 8byte aligned we can't store an 8byte zero register
|
||||
// So store two 4byte zero registers
|
||||
// The destination is always 4byte aligned
|
||||
STR(IndexType::Unsigned, ARM64Reg::WSP, dst_reg, m_dst_ofs);
|
||||
STR(IndexType::Unsigned, ARM64Reg::WSP, dst_reg, m_dst_ofs + 4);
|
||||
}
|
||||
else
|
||||
{
|
||||
STR(IndexType::Unsigned, ARM64Reg::SP, dst_reg, m_dst_ofs);
|
||||
}
|
||||
STUR(ARM64Reg::SP, dst_reg, m_dst_ofs);
|
||||
m_float_emit.STR(32, IndexType::Unsigned, ARM64Reg::D31, dst_reg, m_dst_ofs + 8);
|
||||
|
||||
m_dst_ofs += sizeof(float) * 3;
|
||||
|
||||
@ -3,6 +3,8 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include "Common/Arm64Emitter.h"
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "VideoCommon/VertexLoaderBase.h"
|
||||
@ -26,12 +28,11 @@ private:
|
||||
u32 m_dst_ofs = 0;
|
||||
Arm64Gen::FixupBranch m_skip_vertex;
|
||||
Arm64Gen::ARM64FloatEmitter m_float_emit;
|
||||
void GetVertexAddr(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg);
|
||||
s32 GetAddressImm(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg,
|
||||
u32 align);
|
||||
int ReadVertex(VertexComponentFormat attribute, ComponentFormat format, int count_in,
|
||||
int count_out, bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format, s32 offset = -1);
|
||||
void ReadColor(VertexComponentFormat attribute, ColorFormat format, s32 offset);
|
||||
std::pair<Arm64Gen::ARM64Reg, u32> GetVertexAddr(CPArray array, VertexComponentFormat attribute);
|
||||
void ReadVertex(VertexComponentFormat attribute, ComponentFormat format, int count_in,
|
||||
int count_out, bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format, Arm64Gen::ARM64Reg reg, u32 offset);
|
||||
void ReadColor(VertexComponentFormat attribute, ColorFormat format, Arm64Gen::ARM64Reg reg,
|
||||
u32 offset);
|
||||
void GenerateVertexLoader();
|
||||
};
|
||||
|
||||
@ -79,9 +79,10 @@ OpArg VertexLoaderX64::GetVertexAddr(CPArray array, VertexComponentFormat attrib
|
||||
}
|
||||
}
|
||||
|
||||
int VertexLoaderX64::ReadVertex(OpArg data, VertexComponentFormat attribute, ComponentFormat format,
|
||||
int count_in, int count_out, bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format)
|
||||
void VertexLoaderX64::ReadVertex(OpArg data, VertexComponentFormat attribute,
|
||||
ComponentFormat format, int count_in, int count_out,
|
||||
bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format)
|
||||
{
|
||||
static const __m128i shuffle_lut[5][3] = {
|
||||
{_mm_set_epi32(0xFFFFFFFFL, 0xFFFFFFFFL, 0xFFFFFFFFL, 0xFFFFFF00L), // 1x u8
|
||||
@ -276,8 +277,6 @@ int VertexLoaderX64::ReadVertex(OpArg data, VertexComponentFormat attribute, Com
|
||||
}
|
||||
|
||||
write_zfreeze();
|
||||
|
||||
return load_bytes;
|
||||
}
|
||||
|
||||
void VertexLoaderX64::ReadColor(OpArg data, VertexComponentFormat attribute, ColorFormat format)
|
||||
@ -459,20 +458,45 @@ void VertexLoaderX64::GenerateVertexLoader()
|
||||
|
||||
if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
|
||||
{
|
||||
static const u8 map[8] = {7, 6, 15, 14};
|
||||
const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())];
|
||||
const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB ? 3 : 1;
|
||||
static constexpr Common::EnumMap<u8, static_cast<ComponentFormat>(7)> SCALE_MAP = {7, 6, 15, 14,
|
||||
0, 0, 0, 0};
|
||||
const u8 scaling_exponent = SCALE_MAP[m_VtxAttr.g0.NormalFormat];
|
||||
|
||||
for (int i = 0; i < limit; i++)
|
||||
// Normal
|
||||
data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
|
||||
ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
|
||||
&m_native_vtx_decl.normals[0]);
|
||||
|
||||
if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB)
|
||||
{
|
||||
if (!i || m_VtxAttr.g0.NormalIndex3)
|
||||
{
|
||||
const bool index3 = IsIndexed(m_VtxDesc.low.Normal) && m_VtxAttr.g0.NormalIndex3;
|
||||
const int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
|
||||
const int load_bytes = elem_size * 3;
|
||||
|
||||
// Tangent
|
||||
// If in Index3 mode, and indexed components are used, replace the index with a new index.
|
||||
if (index3)
|
||||
data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
|
||||
int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
|
||||
data.AddMemOffset(i * elem_size * 3);
|
||||
}
|
||||
data.AddMemOffset(ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3,
|
||||
true, scaling_exponent, &m_native_vtx_decl.normals[i]));
|
||||
// The tangent comes after the normal; even in index3 mode, this offset is applied.
|
||||
// Note that this is different from adding 1 to the index, as the stride for indices may be
|
||||
// different from the size of the tangent itself.
|
||||
data.AddMemOffset(load_bytes);
|
||||
|
||||
ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
|
||||
scaling_exponent, &m_native_vtx_decl.normals[1]);
|
||||
|
||||
// Undo the offset above so that data points to the normal instead of the tangent.
|
||||
// This way, we can add 2*elem_size below to always point to the binormal, even if we replace
|
||||
// data with a new index (which would point to the normal).
|
||||
data.AddMemOffset(-load_bytes);
|
||||
|
||||
// Binormal
|
||||
if (index3)
|
||||
data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
|
||||
data.AddMemOffset(load_bytes * 2);
|
||||
|
||||
ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
|
||||
scaling_exponent, &m_native_vtx_decl.normals[2]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -25,9 +25,9 @@ private:
|
||||
u32 m_dst_ofs = 0;
|
||||
Gen::FixupBranch m_skip_vertex;
|
||||
Gen::OpArg GetVertexAddr(CPArray array, VertexComponentFormat attribute);
|
||||
int ReadVertex(Gen::OpArg data, VertexComponentFormat attribute, ComponentFormat format,
|
||||
int count_in, int count_out, bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format);
|
||||
void ReadVertex(Gen::OpArg data, VertexComponentFormat attribute, ComponentFormat format,
|
||||
int count_in, int count_out, bool dequantize, u8 scaling_exponent,
|
||||
AttributeFormat* native_format);
|
||||
void ReadColor(Gen::OpArg data, VertexComponentFormat attribute, ColorFormat format);
|
||||
void GenerateVertexLoader();
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user