You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1609 lines
53 KiB
1609 lines
53 KiB
//========= Copyright c 1996-2008, Valve Corporation, All rights reserved. ============//
|
|
#include "studiorender.h"
|
|
#include "studio.h"
|
|
#include "materialsystem/imesh.h"
|
|
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
|
#include "materialsystem/imaterialvar.h"
|
|
#include "materialsystem/imorph.h"
|
|
#include "materialsystem/itexture.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "optimize.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "mathlib/vector.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "studiorendercontext.h"
|
|
#include "tier2/tier2.h"
|
|
#include "tier0/vprof.h"
|
|
#include "tier0/miniprofiler.h"
|
|
#include <algorithm>
|
|
#include "filesystem.h"
|
|
|
|
#define PROFILE_THIS_FILE 0
|
|
|
|
|
|
DLL_IMPORT CLinkedMiniProfiler *g_pOtherMiniProfilers;
|
|
#if PROFILE_THIS_FILE
|
|
|
|
#if !ENABLE_HARDWARE_PROFILER
|
|
#error "can't profile without profiler enabled"
|
|
#endif
|
|
|
|
CLinkedMiniProfiler g_mp_morph_Vx("morph_Vx", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_Vw("morph_Vw", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_lower_bound("morph_lower_bound", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph("morph", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V1("morph_V1", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V2("morph_V2", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V3("morph_V3", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V4("morph_V4", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V5("morph_V5", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V6("morph_V6", &g_pOtherMiniProfilers);
|
|
CLinkedMiniProfiler g_mp_morph_V7("morph_V7", &g_pOtherMiniProfilers);
|
|
|
|
CLinkedMiniProfiler* g_mp_ComputeFlexedVertex_StreamOffset[8] =
|
|
{
|
|
NULL,
|
|
&g_mp_morph_V1,
|
|
&g_mp_morph_V2,
|
|
&g_mp_morph_V3,
|
|
&g_mp_morph_V4,
|
|
&g_mp_morph_V5,
|
|
&g_mp_morph_V6,
|
|
&g_mp_morph_V7
|
|
};
|
|
#else
|
|
uint32 g_mp_morph_Vx[2];
|
|
uint32 g_mp_morph_Vw[2];
|
|
#endif
|
|
|
|
ConVar g_cv_morph_path("morph_path", "7");
|
|
ConVar g_cv_morph_debug("morph_debug", "0");
|
|
|
|
|
|
#ifdef _X360
|
|
const ALIGN16 int32 g_perm_speed_side[4] = {0x12, 0x13, 0x12, 0x13};
|
|
const ALIGN16 int32 g_perm_delta[4] = {0x14150000, 0x16170000, 0x18190000, 0};
|
|
const ALIGN16 int32 g_perm_delta_wrinkle[4] = {0x14150000, 0x16170000, 0x18190000, 0x10110000}; // includes the f3PreDelta's W that's in the X component
|
|
const ALIGN16 int32 g_perm_ndelta[4] = {0x1A1B0000, 0x1C1D0000, 0x1E1F0000, 0};
|
|
//const ALIGN16 int32 g_perm_w0[4] = {0x00010203,0x08090A0B,0x00010203,0x08090A0B};
|
|
const ALIGN16 int32 g_perm_w1[4] = {0x0C0D0E0F,0x0C0D0E0F,0x04050607,0x04050607};
|
|
const fltx4 g_sc256_255_special = {256.0f/255.0f,256.0f/255.0f,-256.0f/255.0f,-256.0f/255.0f};
|
|
const fltx4 g_f40011 = {0,0,1,1};
|
|
fltx4 g_dummy2[2];
|
|
|
|
int g_nStreamOffset_prefetch = 256;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// V4 rolled - latency of x4, manually scheduled for nearly optimal dual-issue and no automatic stalls
|
|
// the ~15 nops mean 1 instruction is issued at that cycle, instead of theoretically possible 2 per cycle
|
|
//
|
|
__declspec(naked) int ComputeFlexedVertex_StreamOffset_V7(
|
|
int nThinFlexVertexCount, //r3
|
|
CachedPosNorm_t *pThinFlexVerts,//r4
|
|
int32 *pFirstThinFlexIndex, //r5
|
|
mstudiovertanim_t * pVert, //r6
|
|
uint32 nCurrentTag, //r7
|
|
uint32 numVertsToProcess, //r8
|
|
fltx4 w1234 //vr1
|
|
)
|
|
{
|
|
__asm
|
|
{
|
|
std r14, -0x08(r1)
|
|
std r15, -0x10(r1)
|
|
std r16, -0x18(r1)
|
|
std r17, -0x20(r1)
|
|
std r18, -0x28(r1)
|
|
std r19, -0x30(r1)
|
|
std r20, -0x38(r1)
|
|
std r21, -0x40(r1)
|
|
std r22, -0x48(r1)
|
|
std r23, -0x50(r1)
|
|
std r24, -0x58(r1)
|
|
std r25, -0x60(r1)
|
|
|
|
// let the compiler schedule the instructions, just use several registers to avoid dependencies
|
|
lau r14, g_sc256_255_special
|
|
lal r14, r14, g_sc256_255_special
|
|
lvx vr2, r0,r14
|
|
|
|
lau r15, g_f40011
|
|
lal r15, r15, g_f40011
|
|
lvx vr3, r0,r15
|
|
|
|
lau r16, g_perm_speed_side
|
|
lal r16, r16, g_perm_speed_side
|
|
lvx vr4, r0,r16
|
|
|
|
lau r17, g_perm_delta
|
|
lal r17, r17, g_perm_delta
|
|
lvx vr5, r0,r17
|
|
|
|
lau r18, g_perm_ndelta
|
|
lal r18, r18, g_perm_ndelta
|
|
lvx vr6, r0,r18
|
|
|
|
lau r20, g_dummy2
|
|
lal r20,r20, g_dummy2
|
|
mr r21, r20
|
|
mr r22, r21
|
|
mr r23, r22
|
|
|
|
li r10, -1
|
|
rldicl r7,r7,0,32 // currentTag &= 0xFFFFFFFF ; just to make sure we don't mess up isCacheInvalid computation
|
|
rldicl r10,r10,0,48 // r10 = 0x0000FFFF
|
|
|
|
vxor vr8,vr8,vr8
|
|
|
|
li r15, 16
|
|
|
|
li r11,0x100
|
|
li r24, MAXSTUDIOFLEXVERTS - 4
|
|
|
|
mtctr r8
|
|
mftb r25
|
|
vxor vr19,vr19,vr19
|
|
vxor vr20,vr20,vr20
|
|
nop // align!
|
|
nop
|
|
nop
|
|
|
|
label_start_V7: // 52 instructions run in 45 cycles, although compiler predicts 38 cycles
|
|
////////////////
|
|
// IMPORTANT: DO NOT REMOVE NOPS UNLESS YOU KNOW WHAT YOU ARE DOING AND WHY!
|
|
// nops are essential here, removing them will make the code about 2% slower because dual-issue will be broken
|
|
////////////////
|
|
lhz r14, 0(r6) // int n = pVert->index;
|
|
addi r16, r3, 2
|
|
dcbt r11,r6
|
|
cmpw r3, r24 // compare nThinFlexVertexCount to MAXSTUDIOFLEXVERTS - 2
|
|
lvlx vr9,r0,r6
|
|
rldicl r14, r14, 2, 0 // r14 = n*4
|
|
lvrx vr10,r15,r6
|
|
rldicl r16, r16, 5, 0 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
vor vr9,vr9,vr10 // vr9 = packedVert = LoadUnalignedSIMD(pVert)
|
|
addi r31,r31,0//vpermwi128 vr40,vr40,0x1B //mr r31,r31
|
|
add r16, r16, r4
|
|
vpermwi128 vr40,vr40,0x1B //mr r30,r30
|
|
addi r6, r6, 0x10 // pVert++
|
|
vpermwi128 vr41,vr41,0x1B//nop
|
|
lwzx r17, r14, r5 // r17 = oldCache
|
|
//addi r30,r30,0//nop
|
|
vperm vr10, vr8, vr9, vr4
|
|
//addi r29,r29,0//nop
|
|
xor r18, r17, r7 // cacheVertexIndex = oldCache^nCurrentTag
|
|
vperm vr11, vr8, vr9, vr5
|
|
stvx vr8, r0,r16
|
|
/*S:2*/ vmsum4fp128 vr29,vr19, vr1 // vr29 = scWeight
|
|
subf r18,r18,r10 // (0xFFFF-cacheVertexIndex) >> 32
|
|
/*S:1*/ vpermwi128 vr25, vr20, 0x22 // depends on vmadd vr20 = f4sb
|
|
stvx vr8, r15,r16
|
|
/*S:1*/ vpermwi128 vr26, vr20, 0xF5
|
|
vcsxwfp vr10,vr10,8
|
|
or r19,r3,r7
|
|
vperm vr12, vr8, vr9, vr6
|
|
sradi r18,r18,32 // r18 = isCacheInvalid : form mask
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
//nop
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
//nop
|
|
andc r17, r17, r18 // r17 = oldCache & ~isCacheInvalid
|
|
//nop
|
|
subf r3, r18, r3 // nThinFlexVertexCount = nThinFlexVertexCount + (isCacheInvalid&1);
|
|
//nop
|
|
and r19,r19,r18 // r19 = newCache & isCacheInvalid
|
|
//nop
|
|
/*S:2*/mr r23,r22
|
|
//nop
|
|
or r19, r19, r17 // r19 = updateCache
|
|
/*S:2*/ lvx vr13, r0,r22 // vr13 = vfPosition
|
|
/*S:2*/ lvx vr14, r15,r22 // vr14 = vfNormal
|
|
//nop
|
|
rldicl r17, r19, 5,43 // r17 = (updateCache & 0xFFFF) * 32 = nVertexIndex * 32
|
|
//nop
|
|
/*S:1*/ vmulfp128 vr19, vr25, vr26
|
|
/*S:1*/mr r22, r21
|
|
vmaddfp vr20, vr10, vr2, vr3 // vr20 = f4sb
|
|
add r21, r17, r4 // r21 = pFlexedVertex, goes to Stage:1
|
|
/*S:2*/ vmaddfp vr30, vr29, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
stwx r19, r14, r5
|
|
/*S:2*/ vmaddfp vr31, vr29, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
/*S:1*/ vpermwi128 vr21, vr32, 0x1B
|
|
/*S:1*/ vpermwi128 vr22, vr33, 0x1B
|
|
vcsxwfp128 vr32, vr11, 28
|
|
//nop
|
|
vcsxwfp128 vr33, vr12, 28
|
|
bgt label_end_V7
|
|
dcbt r11, r21
|
|
bdnz label_start_V7
|
|
label_end_V7:
|
|
|
|
/*S:2*/ vmsum4fp128 vr29,vr19, vr1 // vr29 = scWeight
|
|
/*S:1*/ vpermwi128 vr25, vr20, 0x22 // depends on vmadd vr20 = f4sb
|
|
/*S:1*/ vpermwi128 vr26, vr20, 0xF5
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
/*S:2*/mr r23,r22
|
|
/*S:2*/ lvx vr13, r0,r22 // vr13 = vfPosition
|
|
/*S:2*/ lvx vr14, r15,r22 // vr14 = vfNormal
|
|
/*S:1*/ vmulfp128 vr19, vr25, vr26
|
|
/*S:1*/mr r22, r21
|
|
/*S:2*/ vmaddfp vr30, vr29, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
/*S:2*/ vmaddfp vr31, vr29, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
/*S:1*/ vpermwi128 vr21, vr32, 0x1B
|
|
/*S:1*/ vpermwi128 vr22, vr33, 0x1B
|
|
|
|
|
|
/*S:2*/ vmsum4fp128 vr29,vr19, vr1 // vr29 = scWeight
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
/*S:2*/mr r23,r22
|
|
/*S:2*/ lvx vr13, r0,r22 // vr13 = vfPosition
|
|
/*S:2*/ lvx vr14, r15,r22 // vr14 = vfNormal
|
|
/*S:2*/ vmaddfp vr30, vr29, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
/*S:2*/ vmaddfp vr31, vr29, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
|
|
mftb r17
|
|
subf r17, r25, r17
|
|
lau r18, g_mp_morph_Vx
|
|
lal r18, r18, g_mp_morph_Vx
|
|
lwz r23, 0(r18)
|
|
add r23,r23,r17
|
|
stw r23, 0(r18)
|
|
lwz r23, 4(r18)
|
|
add r23,r23,r8
|
|
stw r23, 4(r18)
|
|
|
|
ld r14, -0x08(r1)
|
|
ld r15, -0x10(r1)
|
|
ld r16, -0x18(r1)
|
|
ld r17, -0x20(r1)
|
|
ld r18, -0x28(r1)
|
|
ld r19, -0x30(r1)
|
|
ld r20, -0x38(r1)
|
|
ld r21, -0x40(r1)
|
|
ld r22, -0x48(r1)
|
|
ld r23, -0x50(r1)
|
|
ld r24, -0x58(r1)
|
|
ld r25, -0x60(r1)
|
|
|
|
blr
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
__declspec(naked) int ComputeFlexedVertexWrinkle_StreamOffset_V7(
|
|
int nThinFlexVertexCount, //r3
|
|
CachedPosNorm_t *pThinFlexVerts,//r4
|
|
int32 *pFirstThinFlexIndex, //r5
|
|
mstudiovertanim_wrinkle_t * pVert, //r6
|
|
uint32 nCurrentTag, //r7
|
|
uint32 numVertsToProcess, //r8
|
|
fltx4 w1234 //vr1
|
|
)
|
|
{
|
|
__asm
|
|
{
|
|
std r14, -0x08(r1)
|
|
std r15, -0x10(r1)
|
|
std r16, -0x18(r1)
|
|
std r17, -0x20(r1)
|
|
std r18, -0x28(r1)
|
|
std r19, -0x30(r1)
|
|
std r20, -0x38(r1)
|
|
std r21, -0x40(r1)
|
|
std r22, -0x48(r1)
|
|
std r23, -0x50(r1)
|
|
std r24, -0x58(r1)
|
|
std r25, -0x60(r1)
|
|
|
|
// let the compiler schedule the instructions, just use several registers to avoid dependencies
|
|
lau r14, g_sc256_255_special
|
|
lal r14, r14, g_sc256_255_special
|
|
lvx vr2, r0,r14
|
|
|
|
lau r15, g_f40011
|
|
lal r15, r15, g_f40011
|
|
lvx vr3, r0,r15
|
|
|
|
lau r16, g_perm_speed_side
|
|
lal r16, r16, g_perm_speed_side
|
|
lvx vr4, r0,r16
|
|
|
|
lau r17, g_perm_delta_wrinkle
|
|
lal r17, r17, g_perm_delta_wrinkle
|
|
lvx vr5, r0,r17
|
|
|
|
lau r18, g_perm_ndelta
|
|
lal r18, r18, g_perm_ndelta
|
|
lvx vr6, r0,r18
|
|
|
|
lau r20, g_dummy2
|
|
lal r20,r20, g_dummy2
|
|
mr r21, r20
|
|
mr r22, r21
|
|
mr r23, r22
|
|
|
|
li r10, -1
|
|
rldicl r7,r7,0,32 // currentTag &= 0xFFFFFFFF ; just to make sure we don't mess up isCacheInvalid computation
|
|
rldicl r10,r10,0,48 // r10 = 0x0000FFFF
|
|
|
|
vxor vr8,vr8,vr8
|
|
|
|
li r15, 16
|
|
|
|
li r11,0x100
|
|
li r24, MAXSTUDIOFLEXVERTS - 4
|
|
|
|
mtctr r8
|
|
mftb r25
|
|
vxor vr19,vr19,vr19
|
|
vxor vr20,vr20,vr20
|
|
nop // align!
|
|
nop
|
|
nop
|
|
|
|
label_start_V7: // 52 instructions run in 45 cycles, although compiler predicts 38 cycles
|
|
////////////////
|
|
// IMPORTANT: DO NOT REMOVE NOPS UNLESS YOU KNOW WHAT YOU ARE DOING AND WHY!
|
|
// nops are essential here, removing them will make the code about 2% slower because dual-issue will be broken
|
|
////////////////
|
|
lhz r14, 0(r6) // int n = pVert->index;
|
|
addi r16, r3, 2
|
|
dcbt r11,r6
|
|
cmpw r3, r24 // compare nThinFlexVertexCount to MAXSTUDIOFLEXVERTS - 2
|
|
lvlx vr9,r0,r6
|
|
rldicl r14, r14, 2, 0 // r14 = n*4
|
|
lvrx vr10,r15,r6
|
|
rldicl r16, r16, 5, 0 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
lvlx vr27,r15,r6 // f3PreDelta
|
|
vor vr9,vr9,vr10 // vr9 = packedVert = LoadUnalignedSIMD(pVert)
|
|
addi r31,r31,0//vpermwi128 vr40,vr40,0x1B //mr r31,r31
|
|
add r16, r16, r4
|
|
vpermwi128 vr40,vr40,0x1B //mr r30,r30
|
|
addi r6, r6, 0x12 // pVert++
|
|
vpermwi128 vr41,vr41,0x1B//nop
|
|
lwzx r17, r14, r5 // r17 = oldCache
|
|
//addi r30,r30,0//nop
|
|
vperm vr10, vr8, vr9, vr4 //__vperm(f4Zero, packedVert, permuteSpeedSide)
|
|
vrlimi128 vr27,vr9,7,0// f3PreDelta
|
|
xor r18, r17, r7 // cacheVertexIndex = oldCache^nCurrentTag
|
|
vperm vr12, vr8, vr9, vr6 //f3NDelta = __vperm(f4Zero, packedVert, permuteNDelta)
|
|
stvx vr8, r0,r16
|
|
/*S:2*/ vmsum4fp128 vr29,vr19, vr1 // vr29 = scWeight
|
|
subf r18,r18,r10 // (0xFFFF-cacheVertexIndex) >> 32
|
|
/*S:1*/ vpermwi128 vr25, vr20, 0x22 // depends on vmadd vr20 = f4sb
|
|
stvx vr8, r15,r16
|
|
/*S:1*/ vpermwi128 vr26, vr20, 0xF5
|
|
vcsxwfp vr10,vr10,8
|
|
or r19,r3,r7
|
|
vperm vr11, vr8, vr27, vr5 //f3Delta = __vperm(f4Zero, f3PreDelta, permuteDelta)
|
|
sradi r18,r18,32 // r18 = isCacheInvalid : form mask
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
//nop
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
//nop
|
|
andc r17, r17, r18 // r17 = oldCache & ~isCacheInvalid
|
|
//nop
|
|
subf r3, r18, r3 // nThinFlexVertexCount = nThinFlexVertexCount + (isCacheInvalid&1);
|
|
//nop
|
|
and r19,r19,r18 // r19 = newCache & isCacheInvalid
|
|
//nop
|
|
/*S:2*/mr r23,r22
|
|
//nop
|
|
or r19, r19, r17 // r19 = updateCache
|
|
/*S:2*/ lvx vr13, r0,r22 // vr13 = vfPosition
|
|
/*S:2*/ lvx vr14, r15,r22 // vr14 = vfNormal
|
|
//nop
|
|
rldicl r17, r19, 5,43 // r17 = (updateCache & 0xFFFF) * 32 = nVertexIndex * 32
|
|
//nop
|
|
/*S:1*/ vmulfp128 vr19, vr25, vr26
|
|
/*S:1*/mr r22, r21
|
|
vmaddfp vr20, vr10, vr2, vr3 // vr20 = f4sb
|
|
add r21, r17, r4 // r21 = pFlexedVertex, goes to Stage:1
|
|
/*S:2*/ vmaddfp vr30, vr29, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
stwx r19, r14, r5
|
|
/*S:2*/ vmaddfp vr31, vr29, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
/*S:1*/ vpermwi128 vr21, vr32, 0x1B
|
|
/*S:1*/ vpermwi128 vr22, vr33, 0x1B
|
|
vcsxwfp128 vr32, vr11, 28
|
|
//nop
|
|
vcsxwfp128 vr33, vr12, 28
|
|
bgt label_end_V7
|
|
dcbt r11, r21
|
|
bdnz label_start_V7
|
|
label_end_V7:
|
|
|
|
/*S:2*/ vmsum4fp128 vr29,vr19, vr1 // vr29 = scWeight
|
|
/*S:1*/ vpermwi128 vr25, vr20, 0x22 // depends on vmadd vr20 = f4sb
|
|
/*S:1*/ vpermwi128 vr26, vr20, 0xF5
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
/*S:2*/mr r23,r22
|
|
/*S:2*/ lvx vr13, r0,r22 // vr13 = vfPosition
|
|
/*S:2*/ lvx vr14, r15,r22 // vr14 = vfNormal
|
|
/*S:1*/ vmulfp128 vr19, vr25, vr26
|
|
/*S:1*/mr r22, r21
|
|
/*S:2*/ vmaddfp vr30, vr29, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
/*S:2*/ vmaddfp vr31, vr29, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
/*S:1*/ vpermwi128 vr21, vr32, 0x1B
|
|
/*S:1*/ vpermwi128 vr22, vr33, 0x1B
|
|
|
|
|
|
/*S:2*/ vmsum4fp128 vr29,vr19, vr1 // vr29 = scWeight
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
/*S:2*/mr r23,r22
|
|
/*S:2*/ lvx vr13, r0,r22 // vr13 = vfPosition
|
|
/*S:2*/ lvx vr14, r15,r22 // vr14 = vfNormal
|
|
/*S:2*/ vmaddfp vr30, vr29, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
/*S:2*/ vmaddfp vr31, vr29, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
|
|
/*S:3*/ stvx vr30, r0,r23
|
|
/*S:3*/ stvx vr31, r15,r23
|
|
|
|
mftb r17
|
|
subf r17, r25, r17
|
|
lau r18, g_mp_morph_Vw
|
|
lal r18, r18, g_mp_morph_Vw
|
|
lwz r23, 0(r18)
|
|
add r23,r23,r17
|
|
stw r23, 0(r18)
|
|
lwz r23, 4(r18)
|
|
add r23,r23,r8
|
|
stw r23, 4(r18)
|
|
|
|
ld r14, -0x08(r1)
|
|
ld r15, -0x10(r1)
|
|
ld r16, -0x18(r1)
|
|
ld r17, -0x20(r1)
|
|
ld r18, -0x28(r1)
|
|
ld r19, -0x30(r1)
|
|
ld r20, -0x38(r1)
|
|
ld r21, -0x40(r1)
|
|
ld r22, -0x48(r1)
|
|
ld r23, -0x50(r1)
|
|
ld r24, -0x58(r1)
|
|
ld r25, -0x60(r1)
|
|
|
|
blr
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// V4 rolled - latency of x3
|
|
__declspec(naked) int ComputeFlexedVertex_StreamOffset_V6(
|
|
int nThinFlexVertexCount, //r3
|
|
CachedPosNorm_t *pThinFlexVerts,//r4
|
|
int32 *pFirstThinFlexIndex, //r5
|
|
mstudiovertanim_t * pVert, //r6
|
|
uint32 nCurrentTag, //r7
|
|
uint32 numVertsToProcess, //r8
|
|
fltx4 w1234 //vr1
|
|
)
|
|
{
|
|
__asm
|
|
{
|
|
std r14, -0x08(r1)
|
|
std r15, -0x10(r1)
|
|
std r16, -0x18(r1)
|
|
std r17, -0x20(r1)
|
|
std r18, -0x28(r1)
|
|
std r19, -0x30(r1)
|
|
std r20, -0x38(r1)
|
|
std r21, -0x40(r1)
|
|
std r22, -0x48(r1)
|
|
std r23, -0x50(r1)
|
|
std r24, -0x58(r1)
|
|
|
|
// let the compiler schedule the instructions, just use several registers to avoid dependencies
|
|
lau r14, g_sc256_255_special
|
|
lal r14, r14, g_sc256_255_special
|
|
lvx vr2, r0,r14
|
|
|
|
lau r15, g_f40011
|
|
lal r15, r15, g_f40011
|
|
lvx vr3, r0,r15
|
|
|
|
lau r16, g_perm_speed_side
|
|
lal r16, r16, g_perm_speed_side
|
|
lvx vr4, r0,r16
|
|
|
|
lau r17, g_perm_delta
|
|
lal r17, r17, g_perm_delta
|
|
lvx vr5, r0,r17
|
|
|
|
lau r18, g_perm_ndelta
|
|
lal r18, r18, g_perm_ndelta
|
|
lvx vr6, r0,r18
|
|
|
|
lau r20, g_dummy2
|
|
lal r20,r20, g_dummy2
|
|
mr r21, r20
|
|
mr r22, r21
|
|
|
|
li r10, -1
|
|
rldicl r7,r7,0,32 // currentTag &= 0xFFFFFFFF ; just to make sure we don't mess up isCacheInvalid computation
|
|
rldicl r10,r10,0,48 // r10 = 0x0000FFFF
|
|
|
|
vxor vr8,vr8,vr8
|
|
|
|
li r15, 16
|
|
|
|
lau r14,g_nStreamOffset_prefetch
|
|
lal r14,r14,g_nStreamOffset_prefetch
|
|
lwz r11,0(r14)
|
|
|
|
li r24, MAXSTUDIOFLEXVERTS - 2
|
|
|
|
mtctr r8
|
|
mftb r23
|
|
|
|
label_start:
|
|
lhz r14, 0(r6) // int n = pVert->index;
|
|
dcbt r11,r6
|
|
addi r16, r3, 2
|
|
cmpw r3, r24 // compare nThinFlexVertexCount to MAXSTUDIOFLEXVERTS - 2
|
|
lvlx vr9,r0,r6
|
|
lvrx vr10,r15,r6
|
|
rldicl r14, r14, 2, 0 // r14 = n*4
|
|
rldicl r16, r16, 5, 0 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
add r16, r16, r4
|
|
vor vr9,vr9,vr10 // vr9 = packedVert = LoadUnalignedSIMD(pVert)
|
|
stvx vr8, r0,r16
|
|
lwzx r17, r14, r5 // r17 = oldCache
|
|
stvx vr8, r15,r16
|
|
vmsum4fp128 vr19,vr19, vr1 // vr15 = scWeight
|
|
vperm vr10, vr8, vr9, vr4
|
|
xor r18, r17, r7 // cacheVertexIndex = oldCache^nCurrentTag
|
|
vperm vr11, vr8, vr9, vr5
|
|
subf r18,r18,r10 // (0xFFFF-cacheVertexIndex) >> 32
|
|
vcsxwfp vr10,vr10,8
|
|
vperm vr12, vr8, vr9, vr6
|
|
stvx vr23, r0,r22
|
|
sradi r18,r18,32 // r18 = isCacheInvalid : form mask
|
|
vmaddfp vr10, vr10, vr2, vr3 // vr10 = f4sb
|
|
stvx vr24, r15,r22
|
|
or r19,r3,r7
|
|
andc r17, r17, r18 // r17 = oldCache & ~isCacheInvalid
|
|
and r19,r19,r18 // r19 = newCache & isCacheInvalid
|
|
vpermwi128 vr15, vr10, 0x22
|
|
or r19, r19, r17 // r19 = updateCache
|
|
vpermwi128 vr16, vr10, 0xF5
|
|
rldicl r17, r19, 5,43 // r17 = (updateCache & 0xFFFF) * 32 = nVertexIndex * 32
|
|
vmaddfp vr24, vr19, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
vmaddfp vr23, vr19, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
vmulfp128 vr19, vr15, vr16
|
|
add r17, r17, r4 // r17 = pFlexedVertex
|
|
stwx r19, r14, r5
|
|
subf r3, r18, r3// nThinFlexVertexCount = nThinFlexVertexCount + (isCacheInvalid&1);
|
|
lvx vr13, r0,r17 // vr13 = vfPosition
|
|
addi r6, r6, 0x10 // pVert++
|
|
lvx vr14, r15,r17 // vr14 = vfNormal
|
|
vcsxwfp vr21, vr11, 28
|
|
mr r22,r21
|
|
vcsxwfp vr22, vr12, 28
|
|
mr r21,r17
|
|
bgt label_end
|
|
dcbt r11, r17
|
|
|
|
bdnz label_start
|
|
label_end:
|
|
|
|
mftb r17
|
|
subf r17, r23, r17
|
|
lau r18, g_mp_morph_Vx
|
|
lal r18, r18, g_mp_morph_Vx
|
|
lwz r23, 0(r18)
|
|
add r23,r23,r17
|
|
stw r23, 0(r18)
|
|
lwz r23, 4(r18)
|
|
add r23,r23,r8
|
|
stw r23, 4(r18)
|
|
|
|
|
|
vmsum4fp128 vr19,vr19, vr1 // vr15 = scWeight
|
|
stvx vr23, r0,r22
|
|
stvx vr24, r15,r22
|
|
vmaddfp vr24, vr19, vr22, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
vmaddfp vr23, vr19, vr21, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
stvx vr23, r0,r21
|
|
stvx vr24, r15,r21
|
|
|
|
ld r14, -0x08(r1)
|
|
ld r15, -0x10(r1)
|
|
ld r16, -0x18(r1)
|
|
ld r17, -0x20(r1)
|
|
ld r18, -0x28(r1)
|
|
ld r19, -0x30(r1)
|
|
ld r20, -0x38(r1)
|
|
ld r21, -0x40(r1)
|
|
ld r22, -0x48(r1)
|
|
ld r23, -0x50(r1)
|
|
ld r24, -0x58(r1)
|
|
|
|
blr
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// 2-stages
|
|
__declspec(naked) int ComputeFlexedVertex_StreamOffset_V5(
|
|
int nThinFlexVertexCount, //r3
|
|
CachedPosNorm_t *pThinFlexVerts,//r4
|
|
int32 *pFirstThinFlexIndex, //r5
|
|
mstudiovertanim_t * pVert, //r6
|
|
uint32 nCurrentTag, //r7
|
|
uint32 numVertsToProcess, //r8
|
|
fltx4 w1234 //vr1
|
|
)
|
|
{
|
|
__asm
|
|
{
|
|
std r14, -0x08(r1)
|
|
std r15, -0x10(r1)
|
|
std r16, -0x18(r1)
|
|
std r17, -0x20(r1)
|
|
std r18, -0x28(r1)
|
|
std r19, -0x30(r1)
|
|
std r20, -0x38(r1)
|
|
|
|
// let the compiler schedule the instructions, just use several registers to avoid dependencies
|
|
lau r14, g_sc256_255_special
|
|
lal r14, r14, g_sc256_255_special
|
|
lvx vr2, r0,r14
|
|
|
|
lau r15, g_f40011
|
|
lal r15, r15, g_f40011
|
|
lvx vr3, r0,r15
|
|
|
|
lau r16, g_perm_speed_side
|
|
lal r16, r16, g_perm_speed_side
|
|
lvx vr4, r0,r16
|
|
|
|
lau r17, g_perm_delta
|
|
lal r17, r17, g_perm_delta
|
|
lvx vr5, r0,r17
|
|
|
|
lau r18, g_perm_ndelta
|
|
lal r18, r18, g_perm_ndelta
|
|
lvx vr6, r0,r18
|
|
|
|
lau r20, g_dummy2
|
|
lal r20,r20, g_dummy2
|
|
|
|
vxor vr8,vr8,vr8
|
|
li r10, -1
|
|
rldicl r7,r7,0,32 // currentTag &= 0xFFFFFFFF ; just to make sure we don't mess up isCacheInvalid computation
|
|
rldicl r10,r10,0,48 // r10 = 0x0000FFFF
|
|
mtctr r8
|
|
|
|
li r15, 16
|
|
|
|
label_start_schlp:
|
|
lhz r14, 0(r6) // int n = pVert->index;
|
|
addi r16, r3, 2 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
lvlx vr9,r0,r6
|
|
rldicl r14, r14, 2, 0 // r14 = n*4
|
|
lvrx vr10,r15,r6
|
|
rldicl r16, r16, 5, 0 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
|
|
vor vr9,vr9,vr10 // vr9 = packedVert = LoadUnalignedSIMD(pVert)
|
|
|
|
add r16, r16, r4
|
|
|
|
vperm vr10, vr8, vr9, vr4 //__vperm(f4Zero, packedVert, permuteSpeedSide)
|
|
addi r6, r6, 0x10 // pVert++
|
|
vcsxwfp vr10,vr10,8
|
|
|
|
vmaddfp vr17, vr15, vr11, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition) - stage 1
|
|
vmaddfp vr18, vr15, vr12, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal) - stage 1
|
|
|
|
vperm vr11, vr8, vr9, vr5 //f3Delta = __vperm(f4Zero, packedVert, permuteDelta)
|
|
vcsxwfp vr11, vr11, 28
|
|
vperm vr12, vr8, vr9, vr6 //f3NDelta = __vperm(f4Zero, packedVert, permuteNDelta)
|
|
vcsxwfp vr12, vr12, 28
|
|
|
|
vmaddfp vr10, vr10, vr2, vr3 // vr10 = f4sb
|
|
|
|
lwzx r17, r14, r5 // r17 = oldCache
|
|
xor r18, r17, r7 // cacheVertexIndex = oldCache^nCurrentTag
|
|
subf r18,r18,r10 // (0xFFFF-cacheVertexIndex) >> 32
|
|
|
|
or r19,r3,r7 // newCache = nCurrentTag | nThinFlexVertexCount
|
|
sradi r18,r18,32 // r18 = isCacheInvalid : form mask
|
|
vpermwi128 vr15, vr10, 0x22
|
|
and r19,r19,r18 // r19 = newCache & isCacheInvalid
|
|
vpermwi128 vr16, vr10, 0xF5
|
|
andc r17, r17, r18 // r17 = oldCache & ~isCacheInvalid
|
|
stvx vr8, r0, r16
|
|
or r19, r19, r17 // r19 = updateCache
|
|
stvx vr8, r15, r16
|
|
|
|
rldicl r17, r19, 5,43 // r17 = (updateCache & 0xFFFF) * 32 = nVertexIndex * 32
|
|
add r17, r17, r4 // r17 = pFlexedVertex
|
|
vmulfp128 vr15, vr15, vr16
|
|
lvx vr13, r0,r17 // vr13 = vfPosition
|
|
lvx vr14, r15,r17 // vr14 = vfNormal
|
|
|
|
vmsum4fp128 vr15,vr15, vr1 // vr15 = scWeight
|
|
|
|
stwx r19, r14, r5 // pFirstThinFlexIndex[n] = updateCache
|
|
subf r3, r18, r3// nThinFlexVertexCount = nThinFlexVertexCount + (isCacheInvalid&1);
|
|
|
|
stvx vr17, r0,r20 // stage 1
|
|
stvx vr18, r15,r20 // stage 1
|
|
|
|
mr r20, r17
|
|
|
|
bdnz label_start_schlp
|
|
|
|
vmaddfp vr17, vr15, vr11, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition) - stage 1
|
|
vmaddfp vr18, vr15, vr12, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal) - stage 1
|
|
stvx vr17, r0,r20 // stage 1; deferred storing saves 15 cycles (10%!)
|
|
stvx vr18, r15,r20
|
|
|
|
ld r14, -0x08(r1)
|
|
ld r15, -0x10(r1)
|
|
ld r16, -0x18(r1)
|
|
ld r17, -0x20(r1)
|
|
ld r18, -0x28(r1)
|
|
ld r19, -0x30(r1)
|
|
ld r20, -0x38(r1)
|
|
|
|
blr
|
|
}
|
|
}
|
|
|
|
// V3 in asm
|
|
__declspec(naked) int ComputeFlexedVertex_StreamOffset_V4(
|
|
int nThinFlexVertexCount, //r3
|
|
CachedPosNorm_t *pThinFlexVerts,//r4
|
|
int32 *pFirstThinFlexIndex, //r5
|
|
mstudiovertanim_t * pVert, //r6
|
|
uint32 nCurrentTag, //r7
|
|
uint32 numVertsToProcess, //r8
|
|
fltx4 w1234 //vr1
|
|
)
|
|
{
|
|
__asm
|
|
{
|
|
std r14, -0x08(r1)
|
|
std r15, -0x10(r1)
|
|
std r16, -0x18(r1)
|
|
std r17, -0x20(r1)
|
|
std r18, -0x28(r1)
|
|
std r19, -0x30(r1)
|
|
|
|
// let the compiler schedule the instructions, just use several registers to avoid dependencies
|
|
lau r14, g_sc256_255_special
|
|
lal r14, r14, g_sc256_255_special
|
|
lvx vr2, r0,r14
|
|
|
|
lau r15, g_f40011
|
|
lal r15, r15, g_f40011
|
|
lvx vr3, r0,r15
|
|
|
|
lau r16, g_perm_speed_side
|
|
lal r16, r16, g_perm_speed_side
|
|
lvx vr4, r0,r16
|
|
|
|
lau r17, g_perm_delta
|
|
lal r17, r17, g_perm_delta
|
|
lvx vr5, r0,r17
|
|
|
|
lau r18, g_perm_ndelta
|
|
lal r18, r18, g_perm_ndelta
|
|
lvx vr6, r0,r18
|
|
|
|
li r10, -1
|
|
rldicl r7,r7,0,32 // currentTag &= 0xFFFFFFFF ; just to make sure we don't mess up isCacheInvalid computation
|
|
rldicl r10,r10,0,48 // r10 = 0x0000FFFF
|
|
|
|
lau r14,g_nStreamOffset_prefetch
|
|
lal r14,r14,g_nStreamOffset_prefetch
|
|
lwz r11,0(r14)
|
|
|
|
vxor vr8,vr8,vr8
|
|
|
|
li r15, 16
|
|
li r24, MAXSTUDIOFLEXVERTS - 3 // critical number at which to stop processing
|
|
|
|
mtctr r8
|
|
label_start:
|
|
lhz r14, 0(r6) // int n = pVert->index;
|
|
dcbt r11,r16
|
|
rldicl r14, r14, 2, 0 // r14 = n*4
|
|
|
|
|
|
addi r16, r3, 2
|
|
rldicl r16, r16, 5, 0 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
add r16, r16, r4
|
|
stvx vr8, r0,r16
|
|
stvx vr8, r15,r16
|
|
|
|
lvlx vr9,r0,r6
|
|
lvrx vr10,r15,r6
|
|
vor vr9,vr9,vr10 // vr9 = packedVert = LoadUnalignedSIMD(pVert)
|
|
|
|
vperm vr10, vr8, vr9, vr4 //__vperm(f4Zero, packedVert, permuteSpeedSide)
|
|
vcsxwfp vr10,vr10,8
|
|
vmaddfp vr10, vr10, vr2, vr3 // vr10 = f4sb
|
|
|
|
vperm vr11, vr8, vr9, vr5 //f3Delta = __vperm(f4Zero, packedVert, permuteDelta)
|
|
vcsxwfp vr11, vr11, 28
|
|
vperm vr12, vr8, vr9, vr6 //f3NDelta = __vperm(f4Zero, packedVert, permuteNDelta)
|
|
vcsxwfp vr12, vr12, 28
|
|
|
|
lwzx r17, r14, r5 // r17 = oldCache
|
|
xor r18, r17, r7 // cacheVertexIndex = oldCache^nCurrentTag
|
|
subf r18,r18,r10 // (0xFFFF-cacheVertexIndex) >> 32
|
|
sradi r18,r18,32 // r18 = isCacheInvalid : form mask
|
|
|
|
or r19,r3,r7 // newCache = nCurrentTag | nThinFlexVertexCount
|
|
and r19,r19,r18 // r19 = newCache & isCacheInvalid
|
|
andc r17, r17, r18 // r17 = oldCache & ~isCacheInvalid
|
|
or r19, r19, r17 // r19 = updateCache
|
|
|
|
rldicl r17, r19, 5,43 // r17 = (updateCache & 0xFFFF) * 32 = nVertexIndex * 32
|
|
add r17, r17, r4 // r17 = pFlexedVertex
|
|
lvx vr13, r0,r17 // vr13 = vfPosition
|
|
lvx vr14, r15,r17 // vr14 = vfNormal
|
|
dcbt r11,r17
|
|
|
|
vpermwi128 vr15, vr10, 0x22
|
|
vpermwi128 vr16, vr10, 0xF5
|
|
vmulfp128 vr15, vr15, vr16
|
|
vmsum4fp128 vr15,vr15, vr1 // vr15 = scWeight
|
|
|
|
stwx r19, r14, r5 // pFirstThinFlexIndex[n] = updateCache
|
|
subf r3, r18, r3 // nThinFlexVertexCount = nThinFlexVertexCount + (isCacheInvalid&1);
|
|
|
|
vmaddfp vr14, vr15, vr12, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
vmaddfp vr13, vr15, vr11, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
|
|
stvx vr13, r0,r17
|
|
stvx vr14, r15,r17
|
|
|
|
cmpw r3, r24
|
|
bgt label_end
|
|
|
|
addi r6, r6, 0x10 // pVert++
|
|
bdnz label_start
|
|
label_end:
|
|
|
|
ld r14, -0x08(r1)
|
|
ld r15, -0x10(r1)
|
|
ld r16, -0x18(r1)
|
|
ld r17, -0x20(r1)
|
|
ld r18, -0x28(r1)
|
|
ld r19, -0x30(r1)
|
|
|
|
blr
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// V3 in asm
|
|
__declspec(naked) int ComputeFlexedVertexWrinkle_StreamOffset_V4(
|
|
int nThinFlexVertexCount, //r3
|
|
CachedPosNorm_t *pThinFlexVerts,//r4
|
|
int32 *pFirstThinFlexIndex, //r5
|
|
mstudiovertanim_wrinkle_t * pVert,//r6
|
|
uint32 nCurrentTag, //r7
|
|
uint32 numVertsToProcess, //r8
|
|
fltx4 w1234 //vr1
|
|
)
|
|
{
|
|
__asm
|
|
{
|
|
std r14, -0x08(r1)
|
|
std r15, -0x10(r1)
|
|
std r16, -0x18(r1)
|
|
std r17, -0x20(r1)
|
|
std r18, -0x28(r1)
|
|
std r19, -0x30(r1)
|
|
|
|
// let the compiler schedule the instructions, just use several registers to avoid dependencies
|
|
lau r14, g_sc256_255_special
|
|
lal r14, r14, g_sc256_255_special
|
|
lvx vr2, r0,r14
|
|
|
|
lau r15, g_f40011
|
|
lal r15, r15, g_f40011
|
|
lvx vr3, r0,r15
|
|
|
|
lau r16, g_perm_speed_side
|
|
lal r16, r16, g_perm_speed_side
|
|
lvx vr4, r0,r16
|
|
|
|
lau r17, g_perm_delta_wrinkle
|
|
lal r17, r17, g_perm_delta_wrinkle
|
|
lvx vr5, r0,r17
|
|
|
|
lau r18, g_perm_ndelta
|
|
lal r18, r18, g_perm_ndelta
|
|
lvx vr6, r0,r18
|
|
|
|
li r10, -1
|
|
rldicl r7,r7,0,32 // currentTag &= 0xFFFFFFFF ; just to make sure we don't mess up isCacheInvalid computation
|
|
rldicl r10,r10,0,48 // r10 = 0x0000FFFF
|
|
|
|
lau r14,g_nStreamOffset_prefetch
|
|
lal r14,r14,g_nStreamOffset_prefetch
|
|
lwz r11,0(r14)
|
|
|
|
vxor vr8,vr8,vr8
|
|
|
|
li r15, 16
|
|
li r24, MAXSTUDIOFLEXVERTS - 3 // critical number at which to stop processing
|
|
|
|
mtctr r8
|
|
label_start:
|
|
lhz r14, 0(r6) // int n = pVert->index;
|
|
dcbt r11,r16
|
|
rldicl r14, r14, 2, 0 // r14 = n*4
|
|
|
|
|
|
addi r16, r3, 2
|
|
rldicl r16, r16, 5, 0 // r16 = (nThinFlexVertexCount+2) * 32 + pThinFlexVerts
|
|
add r16, r16, r4
|
|
stvx vr8, r0,r16
|
|
stvx vr8, r15,r16
|
|
|
|
lvlx vr27,r15,r6 // f3PreDelta
|
|
lvlx vr9,r0,r6
|
|
lvrx vr10,r15,r6
|
|
vor vr9,vr9,vr10 // vr9 = packedVert = LoadUnalignedSIMD(pVert)
|
|
vrlimi128 vr27,vr9,7,0// f3PreDelta
|
|
|
|
vperm vr10, vr8, vr9, vr4 //__vperm(f4Zero, packedVert, permuteSpeedSide)
|
|
vcsxwfp vr10,vr10,8
|
|
vmaddfp vr10, vr10, vr2, vr3 // vr10 = f4sb
|
|
|
|
vperm vr11, vr8, vr27, vr5 //f3Delta = __vperm(f4Zero, f3PreDelta, permuteDelta)
|
|
vcsxwfp vr11, vr11, 28
|
|
vperm vr12, vr8, vr9, vr6 //f3NDelta = __vperm(f4Zero, packedVert, permuteNDelta)
|
|
vcsxwfp vr12, vr12, 28
|
|
|
|
lwzx r17, r14, r5 // r17 = oldCache
|
|
xor r18, r17, r7 // cacheVertexIndex = oldCache^nCurrentTag
|
|
subf r18,r18,r10 // (0xFFFF-cacheVertexIndex) >> 32
|
|
sradi r18,r18,32 // r18 = isCacheInvalid : form mask
|
|
|
|
or r19,r3,r7 // newCache = nCurrentTag | nThinFlexVertexCount
|
|
and r19,r19,r18 // r19 = newCache & isCacheInvalid
|
|
andc r17, r17, r18 // r17 = oldCache & ~isCacheInvalid
|
|
or r19, r19, r17 // r19 = updateCache
|
|
|
|
rldicl r17, r19, 5,43 // r17 = (updateCache & 0xFFFF) * 32 = nVertexIndex * 32
|
|
add r17, r17, r4 // r17 = pFlexedVertex
|
|
lvx vr13, r0,r17 // vr13 = vfPosition
|
|
lvx vr14, r15,r17 // vr14 = vfNormal
|
|
dcbt r11,r17
|
|
|
|
vpermwi128 vr15, vr10, 0x22
|
|
vpermwi128 vr16, vr10, 0xF5
|
|
vmulfp128 vr15, vr15, vr16
|
|
vmsum4fp128 vr15,vr15, vr1 // vr15 = scWeight
|
|
|
|
stwx r19, r14, r5 // pFirstThinFlexIndex[n] = updateCache
|
|
subf r3, r18, r3 // nThinFlexVertexCount = nThinFlexVertexCount + (isCacheInvalid&1);
|
|
|
|
vmaddfp vr14, vr15, vr12, vr14 // MaddSIMD(scWeight,f3NDelta, vfNormal)
|
|
vmaddfp vr13, vr15, vr11, vr13 // MaddSIMD(scWeight,f3Delta, vfPosition)
|
|
|
|
stvx vr13, r0,r17
|
|
stvx vr14, r15,r17
|
|
|
|
cmpw r3, r24
|
|
bgt label_end
|
|
|
|
addi r6, r6, 0x12 // pVert++
|
|
bdnz label_start
|
|
label_end:
|
|
|
|
ld r14, -0x08(r1)
|
|
ld r15, -0x10(r1)
|
|
ld r16, -0x18(r1)
|
|
ld r17, -0x20(r1)
|
|
ld r18, -0x28(r1)
|
|
ld r19, -0x30(r1)
|
|
|
|
blr
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// base for asm
|
|
int ComputeFlexedVertex_StreamOffset_V3(int nThinFlexVertexCount, CachedPosNorm_t *pThinFlexVerts, int32 *pFirstThinFlexIndex, mstudiovertanim_t * pVert, uint32 nCurrentTag, uint32 numVertsToProcess, fltx4 w1234)
|
|
{
|
|
fltx4 sc256_255_special = g_sc256_255_special;
|
|
fltx4 f40011 = g_f40011;
|
|
fltx4 permuteSpeedSide = LoadAlignedSIMD((const float*)g_perm_speed_side);
|
|
fltx4 permuteDelta = LoadAlignedSIMD((const float*)g_perm_delta);
|
|
fltx4 permuteNDelta = LoadAlignedSIMD((const float*)g_perm_ndelta);
|
|
//fltx4 permuteW0 = LoadAlignedSIMD((const float*)g_perm_w0);
|
|
//fltx4 permuteW1 = LoadAlignedSIMD((const float*)g_perm_w1);
|
|
fltx4 f4Zero = Four_Zeros;
|
|
|
|
do
|
|
{
|
|
int n = pVert->index;
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Normal.InitZero();
|
|
fltx4 packedVert = LoadUnalignedSIMD((const float*)pVert);
|
|
fltx4 f4sb = MaddSIMD(__vcfsx(__vperm(f4Zero, packedVert, permuteSpeedSide), 8), sc256_255_special, f40011);
|
|
// f4sb = {s,b,1-s,1-b}
|
|
|
|
fltx4 f3Delta = __vcfsx(__vperm(f4Zero, packedVert, permuteDelta), 12+16);
|
|
fltx4 f3NDelta = __vcfsx(__vperm(f4Zero, packedVert, permuteNDelta), 12+16);
|
|
uint64 oldCache = uint32(pFirstThinFlexIndex[n]);
|
|
uint64 cacheVertexIndex = oldCache^nCurrentTag; // if there is trash in high (2^16) bits, we need to update the cache
|
|
int64 isCacheInvalid = int64(0xFFFF-cacheVertexIndex)>>32; // the second shift must be arithmetic to form a valid mask
|
|
int64 isCacheValid = ~isCacheInvalid;
|
|
|
|
int64 newCache = nCurrentTag | nThinFlexVertexCount;
|
|
int64 updateCache = (newCache & isCacheInvalid) | (oldCache & isCacheValid);
|
|
nThinFlexVertexCount = nThinFlexVertexCount - isCacheInvalid;
|
|
|
|
int nVertexIndex = updateCache & 0xFFFF;
|
|
|
|
CachedPosNorm_t *pFlexedVertex = pThinFlexVerts + nVertexIndex; // will be overridden
|
|
fltx4 vfNormal = LoadAlignedSIMD((float*)&pFlexedVertex->m_Normal);
|
|
fltx4 vfPosition = LoadAlignedSIMD((float*)&pFlexedVertex->m_Position);
|
|
|
|
// here we need to form the following vector to compute final w:
|
|
// {s(1-b), (1-s)(1-b), sb, (1-s)b}
|
|
//fltx4 f4sbProd = MulSIMD(__vperm(f4sb,f4sb,permuteW0), __vperm(f4sb,f4sb,permuteW1));
|
|
fltx4 f4sbProd = MulSIMD(__vpermwi(f4sb,0x22), __vpermwi(f4sb,0xF5));
|
|
fltx4 scWeight = __vmsum4fp(f4sbProd,w1234);
|
|
|
|
pFirstThinFlexIndex[n] = updateCache;
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Normal, MaddSIMD(scWeight,f3NDelta, vfNormal));
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Position, MaddSIMD(scWeight,f3Delta, vfPosition));
|
|
|
|
pVert ++;
|
|
}
|
|
while(--numVertsToProcess); // why doesn't this use bdnz??
|
|
|
|
return nThinFlexVertexCount;
|
|
}
|
|
|
|
|
|
// base for asm
|
|
int ComputeFlexedVertexWrinkle_StreamOffset_V3(int nThinFlexVertexCount, CachedPosNorm_t *pThinFlexVerts, int32 *pFirstThinFlexIndex, mstudiovertanim_wrinkle_t * pVert, uint32 nCurrentTag, uint32 numVertsToProcess, fltx4 w1234)
|
|
{
|
|
fltx4 sc256_255_special = g_sc256_255_special;
|
|
fltx4 f40011 = g_f40011;
|
|
fltx4 permuteSpeedSide = LoadAlignedSIMD((const float*)g_perm_speed_side);
|
|
fltx4 permuteDelta = LoadAlignedSIMD((const float*)g_perm_delta_wrinkle);
|
|
fltx4 permuteNDelta = LoadAlignedSIMD((const float*)g_perm_ndelta);
|
|
//fltx4 permuteW0 = LoadAlignedSIMD((const float*)g_perm_w0);
|
|
//fltx4 permuteW1 = LoadAlignedSIMD((const float*)g_perm_w1);
|
|
fltx4 f4Zero = Four_Zeros;
|
|
|
|
do
|
|
{
|
|
int n = pVert->index;
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Normal.InitZero();
|
|
fltx4 packedVert = LoadUnalignedSIMD((const float*)pVert);
|
|
fltx4 f3PreDelta = __lvlx(pVert, 16); // f3Delta now contains only packed W component in high X halfword...
|
|
fltx4 f4sb = MaddSIMD(__vcfsx(__vperm(f4Zero, packedVert, permuteSpeedSide), 8), sc256_255_special, f40011);
|
|
// f4sb = {s,b,1-s,1-b}
|
|
|
|
|
|
f3PreDelta = __vrlimi(f3PreDelta, packedVert, 7, 0); // don't rotate and move bytes 4..15 from packed vert to f3PreDelta
|
|
fltx4 f3NDelta = __vcfsx(__vperm(f4Zero, packedVert, permuteNDelta), 12+16);
|
|
fltx4 f3Delta = __vcfsx(__vperm(f4Zero, f3PreDelta, permuteDelta), 12+16);
|
|
uint64 oldCache = uint32(pFirstThinFlexIndex[n]);
|
|
uint64 cacheVertexIndex = oldCache^nCurrentTag; // if there is trash in high (2^16) bits, we need to update the cache
|
|
int64 isCacheInvalid = int64(0xFFFF-cacheVertexIndex)>>32; // the second shift must be arithmetic to form a valid mask
|
|
int64 isCacheValid = ~isCacheInvalid;
|
|
|
|
int64 newCache = nCurrentTag | nThinFlexVertexCount;
|
|
int64 updateCache = (newCache & isCacheInvalid) | (oldCache & isCacheValid);
|
|
nThinFlexVertexCount = nThinFlexVertexCount - isCacheInvalid;
|
|
|
|
int nVertexIndex = updateCache & 0xFFFF;
|
|
|
|
CachedPosNorm_t *pFlexedVertex = pThinFlexVerts + nVertexIndex; // will be overridden
|
|
fltx4 vfNormal = LoadAlignedSIMD((float*)&pFlexedVertex->m_Normal);
|
|
fltx4 vfPosition = LoadAlignedSIMD((float*)&pFlexedVertex->m_Position);
|
|
|
|
// here we need to form the following vector to compute final w:
|
|
// {s(1-b), (1-s)(1-b), sb, (1-s)b}
|
|
//fltx4 f4sbProd = MulSIMD(__vperm(f4sb,f4sb,permuteW0), __vperm(f4sb,f4sb,permuteW1));
|
|
fltx4 f4sbProd = MulSIMD(__vpermwi(f4sb,0x22), __vpermwi(f4sb,0xF5));
|
|
fltx4 scWeight = __vmsum4fp(f4sbProd,w1234);
|
|
|
|
pFirstThinFlexIndex[n] = updateCache;
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Normal, MaddSIMD(scWeight,f3NDelta, vfNormal));
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Position, MaddSIMD(scWeight,f3Delta, vfPosition));
|
|
|
|
pVert ++;
|
|
}
|
|
while(--numVertsToProcess); // why doesn't this use bdnz??
|
|
|
|
return nThinFlexVertexCount;
|
|
}
|
|
|
|
// tried to pipeline in C++
|
|
int ComputeFlexedVertex_StreamOffset_V2(int nThinFlexVertexCount, CachedPosNorm_t *pThinFlexVerts, int32 *pFirstThinFlexIndex, mstudiovertanim_t * pVert, uint32 nCurrentTag, uint32 numVertsToProcess, fltx4 w1234)
|
|
{
|
|
Assert(0 == (uint32(pVert) & 0xF));
|
|
fltx4 sc256_255_special = g_sc256_255_special;
|
|
fltx4 f40011 = g_f40011;
|
|
fltx4 permuteSpeedSide = LoadAlignedSIMD((const float*)g_perm_speed_side);
|
|
fltx4 permuteDelta = LoadAlignedSIMD((const float*)g_perm_delta);
|
|
fltx4 permuteNDelta = LoadAlignedSIMD((const float*)g_perm_ndelta);
|
|
//fltx4 permuteW0 = LoadAlignedSIMD((const float*)g_perm_w0);
|
|
//fltx4 permuteW1 = LoadAlignedSIMD((const float*)g_perm_w1);
|
|
fltx4 f4Zero = Four_Zeros;
|
|
|
|
fltx4 f4sb_st1, f3Delta_st1, f3NDelta_st1;
|
|
int32 updateCache_st1;
|
|
mstudiovertanim_t *pVertEnd = pVert + numVertsToProcess;
|
|
{
|
|
// stage 0
|
|
int n = pVert->index;
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Normal.InitZero();
|
|
fltx4 packedVert = LoadUnalignedSIMD((const float*)pVert);
|
|
fltx4 f4sb = MaddSIMD(__vcfsx(__vperm(f4Zero, packedVert, permuteSpeedSide), 8), sc256_255_special, f40011); // to be completely correct, we'll ned to multiply this with 256/255
|
|
// f4sb = {s,b,1-s,1-b}
|
|
|
|
fltx4 f3Delta = __vcfsx(__vperm(f4Zero, packedVert, permuteDelta), 12+16);
|
|
fltx4 f3NDelta = __vcfsx(__vperm(f4Zero, packedVert, permuteNDelta), 12+16);
|
|
uint64 oldCache = uint32(pFirstThinFlexIndex[n]);
|
|
uint64 cacheVertexIndex = oldCache^nCurrentTag; // if there is trash in high (2^16) bits, we need to update the cache
|
|
int64 isCacheInvalid = int64(0xFFFF-cacheVertexIndex)>>32; // the second shift must be arithmetic to form a valid mask
|
|
int64 isCacheValid = ~isCacheInvalid;
|
|
|
|
int64 newCache = nCurrentTag | nThinFlexVertexCount;
|
|
int64 updateCache = (newCache & isCacheInvalid) | (oldCache & isCacheValid);
|
|
nThinFlexVertexCount = nThinFlexVertexCount - isCacheInvalid;
|
|
|
|
pFirstThinFlexIndex[n] = updateCache;
|
|
|
|
// prime next stage 1
|
|
f4sb_st1 = f4sb;
|
|
f3Delta_st1 = f3Delta;
|
|
f3NDelta_st1 = f3NDelta;
|
|
updateCache_st1 = updateCache;
|
|
|
|
pVert ++;
|
|
}
|
|
|
|
while(pVert < pVertEnd)
|
|
{
|
|
// stage 1
|
|
{
|
|
int nVertexIndex = updateCache_st1 & 0xFFFF;
|
|
|
|
CachedPosNorm_t *pFlexedVertex = pThinFlexVerts + nVertexIndex; // will be overridden
|
|
|
|
fltx4 vfNormal = LoadAlignedSIMD((float*)&pFlexedVertex->m_Normal);
|
|
fltx4 vfPosition = LoadAlignedSIMD((float*)&pFlexedVertex->m_Position);
|
|
|
|
// here we need to form the following vector to compute final w:
|
|
// {s(1-b), (1-s)(1-b), sb, (1-s)b}
|
|
//fltx4 f4sbProd = MulSIMD(__vperm(f4sb_st1,f4sb_st1,permuteW0), __vperm(f4sb_st1,f4sb_st1,permuteW1));
|
|
fltx4 f4sbProd = MulSIMD(__vpermwi(f4sb_st1,0x22), __vpermwi(f4sb_st1,0xF5));
|
|
fltx4 scWeight = __vmsum4fp(f4sbProd,w1234);
|
|
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Normal, MaddSIMD(scWeight,f3NDelta_st1, vfNormal));
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Position, MaddSIMD(scWeight,f3Delta_st1, vfPosition));
|
|
}
|
|
|
|
// stage 0
|
|
{
|
|
int n = pVert->index;
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+2].m_Normal.InitZero();
|
|
fltx4 packedVert = LoadUnalignedSIMD((const float*)pVert);
|
|
fltx4 f4sb = MaddSIMD(__vcfsx(__vperm(f4Zero, packedVert, permuteSpeedSide), 8), sc256_255_special, f40011); // to be completely correct, we'll ned to multiply this with 256/255
|
|
// f4sb = {s,b,1-s,1-b}
|
|
|
|
fltx4 f3Delta = __vcfsx(__vperm(f4Zero, packedVert, permuteDelta), 12+16);
|
|
fltx4 f3NDelta = __vcfsx(__vperm(f4Zero, packedVert, permuteNDelta), 12+16);
|
|
uint64 oldCache = uint32(pFirstThinFlexIndex[n]);
|
|
uint64 cacheVertexIndex = oldCache^nCurrentTag; // if there is trash in high (2^16) bits, we need to update the cache
|
|
int64 isCacheInvalid = int64(0xFFFF-cacheVertexIndex)>>32; // the second shift must be arithmetic to form a valid mask
|
|
int64 isCacheValid = ~isCacheInvalid;
|
|
|
|
int64 newCache = nCurrentTag | nThinFlexVertexCount;
|
|
int64 updateCache = (newCache & isCacheInvalid) | (oldCache & isCacheValid);
|
|
nThinFlexVertexCount = nThinFlexVertexCount - isCacheInvalid;
|
|
|
|
pFirstThinFlexIndex[n] = updateCache; // this may be put wherever it doesn't mess up the other stores
|
|
|
|
// prime next stage 1
|
|
f4sb_st1 = f4sb;
|
|
updateCache_st1 = updateCache;
|
|
f3Delta_st1 = f3Delta;
|
|
f3NDelta_st1 = f3NDelta;
|
|
}
|
|
|
|
pVert ++;
|
|
}
|
|
|
|
// stage 1
|
|
{
|
|
int nVertexIndex = updateCache_st1 & 0xFFFF;
|
|
|
|
CachedPosNorm_t *pFlexedVertex = pThinFlexVerts + nVertexIndex; // will be overridden
|
|
|
|
fltx4 vfNormal = LoadAlignedSIMD((float*)&pFlexedVertex->m_Normal);
|
|
fltx4 vfPosition = LoadAlignedSIMD((float*)&pFlexedVertex->m_Position);
|
|
|
|
// here we need to form the following vector to compute final w:
|
|
// {s(1-b), (1-s)(1-b), sb, (1-s)b}
|
|
//fltx4 f4sbProd = MulSIMD(__vperm(f4sb_st1,f4sb_st1,permuteW0), __vperm(f4sb_st1,f4sb_st1,permuteW1));
|
|
fltx4 f4sbProd = MulSIMD(__vpermwi(f4sb_st1,0x22), __vpermwi(f4sb_st1,0xF5));
|
|
fltx4 scWeight = __vmsum4fp(f4sbProd,w1234);
|
|
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Normal, MaddSIMD(scWeight,f3NDelta_st1, vfNormal));
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Position, MaddSIMD(scWeight,f3Delta_st1, vfPosition));
|
|
}
|
|
return nThinFlexVertexCount;
|
|
}
|
|
|
|
// branchless
|
|
int ComputeFlexedVertex_StreamOffset_V1(int nThinFlexVertexCount, CachedPosNorm_t *pThinFlexVerts, int32 *pFirstThinFlexIndex, mstudiovertanim_t * pVert, uint32 nCurrentTag, uint32 numVertsToProcess, fltx4 w1234)
|
|
{
|
|
Assert(0 == (uint32(pVert) & 0xF));
|
|
fltx4 sc256_255_special = g_sc256_255_special;
|
|
fltx4 f40011 = g_f40011;
|
|
fltx4 permuteSpeedSide = LoadAlignedSIMD((const float*)g_perm_speed_side);
|
|
fltx4 permuteDelta = LoadAlignedSIMD((const float*)g_perm_delta);
|
|
fltx4 permuteNDelta = LoadAlignedSIMD((const float*)g_perm_ndelta);
|
|
//fltx4 permuteW0 = LoadAlignedSIMD((const float*)g_perm_w0);
|
|
//fltx4 permuteW1 = LoadAlignedSIMD((const float*)g_perm_w1);
|
|
fltx4 f4Zero = Four_Zeros;
|
|
mstudiovertanim_t *pVertEnd = pVert + numVertsToProcess;
|
|
do
|
|
{
|
|
int n = pVert->index;
|
|
pThinFlexVerts[nThinFlexVertexCount].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount].m_Normal.InitZero();
|
|
fltx4 packedVert = LoadUnalignedSIMD((const float*)pVert);
|
|
fltx4 f4sb = MaddSIMD(__vcfsx(__vperm(f4Zero, packedVert, permuteSpeedSide), 8), sc256_255_special, f40011);
|
|
// f4sb = {s,b,1-s,1-b}
|
|
|
|
fltx4 f3Delta = __vcfsx(__vperm(f4Zero, packedVert, permuteDelta), 12+16);
|
|
fltx4 f3NDelta = __vcfsx(__vperm(f4Zero, packedVert, permuteNDelta), 12+16);
|
|
uint64 oldCache = uint32(pFirstThinFlexIndex[n]);
|
|
uint64 cacheVertexIndex = oldCache^nCurrentTag; // if there is trash in high (2^16) bits, we need to update the cache
|
|
int64 isCacheInvalid = int64(0xFFFF-cacheVertexIndex)>>32; // the second shift must be arithmetic to form a valid mask
|
|
int32 isCacheValid = ~isCacheInvalid;
|
|
|
|
int32 newCache = nCurrentTag | nThinFlexVertexCount;
|
|
int32 updateCache = (newCache & isCacheInvalid) | (oldCache & isCacheValid);
|
|
nThinFlexVertexCount = nThinFlexVertexCount - isCacheInvalid;
|
|
|
|
int nVertexIndex = updateCache & 0xFFFF;
|
|
|
|
CachedPosNorm_t *pFlexedVertex = pThinFlexVerts + nVertexIndex; // will be overridden
|
|
fltx4 vfNormal = LoadAlignedSIMD((float*)&pFlexedVertex->m_Normal);
|
|
fltx4 vfPosition = LoadAlignedSIMD((float*)&pFlexedVertex->m_Position);
|
|
|
|
// here we need to form the following vector to compute final w:
|
|
// {s(1-b), (1-s)(1-b), sb, (1-s)b}
|
|
//fltx4 f4sbProd = MulSIMD(__vperm(f4sb,f4sb,permuteW0), __vperm(f4sb,f4sb,permuteW1));
|
|
fltx4 f4sbProd = MulSIMD(__vpermwi(f4sb,0x22), __vpermwi(f4sb,0xF5));
|
|
fltx4 scWeight = __vmsum4fp(f4sbProd,w1234);
|
|
|
|
pFirstThinFlexIndex[n] = updateCache;
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Normal, MaddSIMD(scWeight,f3NDelta, vfNormal));
|
|
StoreAlignedSIMD((float*)&pFlexedVertex->m_Position, MaddSIMD(scWeight,f3Delta, vfPosition));
|
|
|
|
pVert ++;
|
|
}
|
|
while(pVert < pVertEnd); // why doesn't this use CTR??
|
|
|
|
return nThinFlexVertexCount;
|
|
}
|
|
|
|
|
|
typedef int (*Fn_ComputeFlexedVertex_StreamOffset)(int nThinFlexVertexCount, CachedPosNorm_t *pThinFlexVerts, int32 *pFirstThinFlexIndex, mstudiovertanim_t * pVert, uint32 nCurrentTag, uint32 numVertsToProcess, fltx4 w1234);
|
|
Fn_ComputeFlexedVertex_StreamOffset g_fn_ComputeFlexedVertex_StreamOffset[8] =
|
|
{
|
|
NULL,
|
|
ComputeFlexedVertex_StreamOffset_V1,
|
|
ComputeFlexedVertex_StreamOffset_V2,
|
|
ComputeFlexedVertex_StreamOffset_V3,
|
|
ComputeFlexedVertex_StreamOffset_V4,
|
|
ComputeFlexedVertex_StreamOffset_V5,
|
|
ComputeFlexedVertex_StreamOffset_V6,
|
|
ComputeFlexedVertex_StreamOffset_V7
|
|
};
|
|
|
|
typedef int (*Fn_ComputeFlexedVertexWrinkle_StreamOffset)(int nThinFlexVertexCount, CachedPosNorm_t *pThinFlexVerts, int32 *pFirstThinFlexIndex, mstudiovertanim_wrinkle_t * pVert, uint32 nCurrentTag, uint32 numVertsToProcess, fltx4 w1234);
|
|
Fn_ComputeFlexedVertexWrinkle_StreamOffset g_fn_ComputeFlexedVertexWrinkle_StreamOffset[8] =
|
|
{
|
|
NULL,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V3,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V3,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V3,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V4,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V4,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V4,
|
|
ComputeFlexedVertexWrinkle_StreamOffset_V7
|
|
};
|
|
|
|
|
|
inline float Diff(const CachedPosNorm_t&a, const CachedPosNorm_t&b)
|
|
{
|
|
return a.m_Position.DistTo(b.m_Position) + a.m_Normal.DistTo(b.m_Normal);
|
|
}
|
|
|
|
bool g_bBreakOnAssert = true;
|
|
void AlwaysAssert(bool mustBeTrue)
|
|
{
|
|
if(!mustBeTrue)
|
|
{
|
|
Plat_DebugString("AlwaysAssert\n");
|
|
if(g_bBreakOnAssert)
|
|
DebugBreak();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
template
|
|
void CCachedRenderData::ComputeFlexedVertex_StreamOffset<mstudiovertanim_t>( studiohdr_t *pStudioHdr, mstudioflex_t *pflex,
|
|
mstudiovertanim_t *pvanim, int vertCount, float w1, float w2, float w3, float w4 );
|
|
template
|
|
void CCachedRenderData::ComputeFlexedVertex_StreamOffset<mstudiovertanim_wrinkle_t>( studiohdr_t *pStudioHdr, mstudioflex_t *pflex,
|
|
mstudiovertanim_wrinkle_t *pvanim, int vertCount, float w1, float w2, float w3, float w4 );
|
|
|
|
// vectorized
|
|
void CCachedRenderData::ComputeFlexedVertex_StreamOffset_Optimized( studiohdr_t *pStudioHdr, mstudioflex_t *pflex, mstudiovertanim_t *pvanim, int vertCount, float w1, float w2, float w3, float w4 )
|
|
{
|
|
#if PROFILE_THIS_FILE
|
|
CMiniProfilerGuard mpguard(&g_mp_morph);
|
|
#endif
|
|
#ifdef _X360
|
|
int nMorphPath = g_cv_morph_path.GetInt();
|
|
if(nMorphPath)
|
|
{
|
|
mstudiovertanim_t vertCountStruct;
|
|
vertCountStruct.index = vertCount;
|
|
/*for(uint32 i = 1; i< pflex->numverts; ++i)
|
|
if(pvanim[i-1].index > pvanim[i].index)
|
|
DebugBreak();*/
|
|
|
|
mstudiovertanim_t * pVertEnd;
|
|
{
|
|
#if PROFILE_THIS_FILE
|
|
CMiniProfilerGuard mpguard_lower_bound(&g_mp_morph_lower_bound);
|
|
#endif
|
|
pVertEnd = std::lower_bound(pvanim, pvanim + pflex->numverts, vertCountStruct, mstudiovertanim_t::CSortByIndex());
|
|
}
|
|
|
|
if(pvanim < pVertEnd)
|
|
{
|
|
union
|
|
{
|
|
fltx4 f4;
|
|
float f1[4];
|
|
} weights;
|
|
weights.f1[0] = w1;
|
|
weights.f1[1] = w2;
|
|
weights.f1[2] = w3;
|
|
weights.f1[3] = w4;
|
|
uint32 nCurrentTag = uint32(m_CurrentTag)<<16;
|
|
int nThinFlexVertexCount = m_ThinFlexVertexCount;
|
|
int32 *pFirstThinFlexIndex = (int32*)m_pFirstThinFlexIndex;
|
|
CachedPosNorm_t *pThinFlexVerts = m_pThinFlexVerts;
|
|
uint64 numVertsToProcess = pVertEnd - pvanim;
|
|
nMorphPath = MIN(7,nMorphPath);
|
|
|
|
/*static int maxVertsSaved = 0;
|
|
if(numVertsToProcess > maxVertsSaved)
|
|
{
|
|
maxVertsSaved = numVertsToProcess;
|
|
|
|
FileHandle_t fh = g_pFullFileSystem->Open( "vertices.bin", "wb" );
|
|
if(fh != FILESYSTEM_INVALID_HANDLE)
|
|
{
|
|
g_pFullFileSystem->Write(pvanim, sizeof(*pvanim) * numVertsToProcess, fh);
|
|
g_pFullFileSystem->Close(fh);
|
|
}
|
|
}*/
|
|
|
|
|
|
#ifdef _DEBUG
|
|
if(0 == g_cv_morph_debug.GetInt())
|
|
#endif
|
|
{
|
|
for(uint32 i = 0; i < 2; ++i) // reset the first 2 positions here as it's required by the algorithm..
|
|
{
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Normal.InitZero();
|
|
}
|
|
nThinFlexVertexCount = g_fn_ComputeFlexedVertex_StreamOffset[nMorphPath](nThinFlexVertexCount,pThinFlexVerts,pFirstThinFlexIndex,pvanim,nCurrentTag, numVertsToProcess, weights.f4);
|
|
}
|
|
#ifdef _DEBUG
|
|
else // Validation path inactive in release, since these static arrays consume 1MB
|
|
{
|
|
bool repeat = false;
|
|
static CachedPosNorm_t backupThinFlexVerts[MAXSTUDIOFLEXVERTS+1], checkThinFlexVerts[MAXSTUDIOFLEXVERTS+1];
|
|
static CacheIndex_t backupFirstThinFlexIndex[MAXSTUDIOVERTS+1],checkFirstThinFlexIndex[MAXSTUDIOVERTS+1];
|
|
int newThinFlexVertexCount ;
|
|
static int numRuns = 0;
|
|
++numRuns;
|
|
memcpy(backupThinFlexVerts, m_pThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(backupFirstThinFlexIndex, m_pThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
do
|
|
{
|
|
for(uint32 i = 0; i < 2; ++i) // reset the first 2 positions here as it's required by the algorithm..
|
|
{
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Normal.InitZero();
|
|
}
|
|
|
|
newThinFlexVertexCount = g_fn_ComputeFlexedVertex_StreamOffset[nMorphPath](nThinFlexVertexCount,pThinFlexVerts,pFirstThinFlexIndex,pvanim,nCurrentTag, numVertsToProcess, weights.f4);
|
|
memcpy(checkThinFlexVerts, m_pThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(checkFirstThinFlexIndex, m_pThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
memcpy(m_pThinFlexVerts, backupThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(m_pThinFlexIndex, backupFirstThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
|
|
ComputeFlexedVertex_StreamOffset( pStudioHdr, pflex, pvanim, vertCount, w1, w2, w3, w4);
|
|
AlwaysAssert(m_ThinFlexVertexCount == newThinFlexVertexCount);
|
|
for(int i = 0; i < newThinFlexVertexCount; ++i)
|
|
AlwaysAssert(Diff(checkThinFlexVerts[i], m_pThinFlexVerts[i]) < 1e-5f);
|
|
int indexOffset = m_pFirstThinFlexIndex - m_pThinFlexIndex;
|
|
for(int i = 0; i < numVertsToProcess; ++i)
|
|
AlwaysAssert(*(int*)&checkFirstThinFlexIndex[indexOffset + pvanim[i].index] == *(int*)&m_pThinFlexIndex[indexOffset + pvanim[i].index]);
|
|
|
|
if(repeat)
|
|
{
|
|
m_ThinFlexVertexCount = nThinFlexVertexCount;
|
|
memcpy(m_pThinFlexVerts, backupThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(m_pThinFlexIndex, backupFirstThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
}
|
|
}
|
|
while(repeat);
|
|
nThinFlexVertexCount = newThinFlexVertexCount;
|
|
}
|
|
#endif
|
|
m_ThinFlexVertexCount = nThinFlexVertexCount;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
ComputeFlexedVertex_StreamOffset( pStudioHdr, pflex, pvanim, vertCount, w1, w2, w3, w4);
|
|
}
|
|
}
|
|
|
|
|
|
void CCachedRenderData::ComputeFlexedVertexWrinkle_StreamOffset_Optimized( studiohdr_t *pStudioHdr, mstudioflex_t *pflex, mstudiovertanim_wrinkle_t *pvanim, int vertCount, float w1, float w2, float w3, float w4)
|
|
{
|
|
#if PROFILE_THIS_FILE
|
|
CMiniProfilerGuard mpguard(&g_mp_morph);
|
|
#endif
|
|
|
|
#ifdef _X360
|
|
int nMorphPath = g_cv_morph_path.GetInt();
|
|
if(nMorphPath)
|
|
{
|
|
mstudiovertanim_wrinkle_t vertCountStruct;
|
|
vertCountStruct.index = vertCount;
|
|
|
|
mstudiovertanim_wrinkle_t * pVertEnd;
|
|
{
|
|
#if PROFILE_THIS_FILE
|
|
CMiniProfilerGuard mpguard_lower_bound(&g_mp_morph_lower_bound);
|
|
#endif
|
|
pVertEnd = std::lower_bound(pvanim, pvanim + pflex->numverts, vertCountStruct, mstudiovertanim_wrinkle_t::CSortByIndex());
|
|
}
|
|
|
|
if(pvanim < pVertEnd)
|
|
{
|
|
union
|
|
{
|
|
fltx4 f4;
|
|
float f1[4];
|
|
} weights;
|
|
weights.f1[0] = w1;
|
|
weights.f1[1] = w2;
|
|
weights.f1[2] = w3;
|
|
weights.f1[3] = w4;
|
|
uint32 nCurrentTag = uint32(m_CurrentTag)<<16;
|
|
int nThinFlexVertexCount = m_ThinFlexVertexCount;
|
|
int32 *pFirstThinFlexIndex = (int32*)m_pFirstThinFlexIndex;
|
|
CachedPosNorm_t *pThinFlexVerts = m_pThinFlexVerts;
|
|
uint64 numVertsToProcess = pVertEnd - pvanim;
|
|
nMorphPath = MIN(7,nMorphPath);
|
|
|
|
#ifdef _DEBUG
|
|
if(0 == g_cv_morph_debug.GetInt())
|
|
#endif
|
|
{
|
|
for(uint32 i = 0; i < 2; ++i) // reset the first 2 positions here as it's required by the algorithm..
|
|
{
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Normal.InitZero();
|
|
}
|
|
nThinFlexVertexCount = g_fn_ComputeFlexedVertexWrinkle_StreamOffset[nMorphPath](nThinFlexVertexCount,pThinFlexVerts,pFirstThinFlexIndex,pvanim,nCurrentTag, numVertsToProcess, weights.f4);
|
|
}
|
|
#ifdef _DEBUG
|
|
else // Validation path inactive in release, since these static arrays consume 1MB
|
|
{
|
|
bool repeat = false;
|
|
static CachedPosNorm_t backupThinFlexVerts[MAXSTUDIOFLEXVERTS+1], checkThinFlexVerts[MAXSTUDIOFLEXVERTS+1];
|
|
static CacheIndex_t backupFirstThinFlexIndex[MAXSTUDIOVERTS+1],checkFirstThinFlexIndex[MAXSTUDIOVERTS+1];
|
|
int newThinFlexVertexCount ;
|
|
static int numRuns = 0;
|
|
++numRuns;
|
|
memcpy(backupThinFlexVerts, m_pThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(backupFirstThinFlexIndex, m_pThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
do
|
|
{
|
|
for(uint32 i = 0; i < 2; ++i) // reset the first 2 positions here as it's required by the algorithm..
|
|
{
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Position.InitZero();
|
|
pThinFlexVerts[nThinFlexVertexCount+i].m_Normal.InitZero();
|
|
}
|
|
|
|
newThinFlexVertexCount = g_fn_ComputeFlexedVertexWrinkle_StreamOffset[nMorphPath](nThinFlexVertexCount,pThinFlexVerts,pFirstThinFlexIndex,pvanim,nCurrentTag, numVertsToProcess, weights.f4);
|
|
memcpy(checkThinFlexVerts, m_pThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(checkFirstThinFlexIndex, m_pThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
memcpy(m_pThinFlexVerts, backupThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(m_pThinFlexIndex, backupFirstThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
|
|
ComputeFlexedVertex_StreamOffset( pStudioHdr, pflex, pvanim, vertCount, w1, w2, w3, w4);
|
|
AlwaysAssert(m_ThinFlexVertexCount == newThinFlexVertexCount);
|
|
for(int i = 0; i < newThinFlexVertexCount; ++i)
|
|
AlwaysAssert(Diff(checkThinFlexVerts[i], m_pThinFlexVerts[i]) < 1e-5f);
|
|
int indexOffset = m_pFirstThinFlexIndex - m_pThinFlexIndex;
|
|
for(int i = 0; i < numVertsToProcess; ++i)
|
|
AlwaysAssert(*(int*)&checkFirstThinFlexIndex[indexOffset + pvanim[i].index] == *(int*)&m_pThinFlexIndex[indexOffset + pvanim[i].index]);
|
|
|
|
if(repeat)
|
|
{
|
|
m_ThinFlexVertexCount = nThinFlexVertexCount;
|
|
memcpy(m_pThinFlexVerts, backupThinFlexVerts, sizeof(m_pThinFlexVerts));
|
|
memcpy(m_pThinFlexIndex, backupFirstThinFlexIndex, sizeof(m_pThinFlexIndex));
|
|
}
|
|
}
|
|
while(repeat);
|
|
nThinFlexVertexCount = newThinFlexVertexCount;
|
|
}
|
|
#endif
|
|
m_ThinFlexVertexCount = nThinFlexVertexCount;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
ComputeFlexedVertex_StreamOffset( pStudioHdr, pflex, pvanim, vertCount, w1, w2, w3, w4);
|
|
}
|
|
}
|