L L4D2node

DoAxisInterpBone

0x00b8d750 · 866 bytes · __cdecl

_Z16DoAxisInterpBoneP13mstudiobone_tiR13CBoneAccessor

Decompiled

undefined (3 params)

/* DoAxisInterpBone(mstudiobone_t*, int, CBoneAccessor&) */

void DoAxisInterpBone(mstudiobone_t *param_1,int param_2,CBoneAccessor *param_3)

{
  int iVar1;
  int iVar2;
  mstudiobone_t *pmVar3;
  Quaternion *pQVar4;
  mstudiobone_t *pmVar5;
  mstudiobone_t *pmVar6;
  mstudiobone_t *pmVar7;
  float fVar8;
  float fVar9;
  float fVar10;
  float fVar11;
  float fVar12;
  Quaternion *local_98;
  matrix3x4_t *local_94;
  Quaternion *local_90;
  float local_84;
  float local_80;
  float local_7c;
  float local_78;
  float local_74;
  float local_70;
  Quaternion local_6c [16];
  Quaternion local_5c [16];
  float local_4c;
  undefined4 local_48;
  undefined4 local_44;
  
  pmVar6 = (mstudiobone_t *)0x0;
  if (*(int *)(param_1 + param_2 * 0xd8 + 0xa8) != 0) {
    pmVar6 = param_1 + *(int *)(param_1 + param_2 * 0xd8 + 0xa8) + param_2 * 0xd8;
  }
  iVar2 = *(int *)pmVar6 * 0x30 + *(int *)(param_3 + 4);
  if (*(int *)(param_1 + *(int *)pmVar6 * 0xd8 + 4) == -1) {
    local_84 = *(float *)(iVar2 + *(int *)(pmVar6 + 4) * 4);
    iVar1 = *(int *)(pmVar6 + 4) * 4;
    local_80 = *(float *)(iVar2 + 0x10 + iVar1);
    local_7c = *(float *)(iVar2 + 0x20 + iVar1);
  }
  else {
    local_4c = *(float *)(iVar2 + *(int *)(pmVar6 + 4) * 4);
    local_48 = *(undefined4 *)(iVar2 + 0x10 + *(int *)(pmVar6 + 4) * 4);
    local_44 = *(undefined4 *)(iVar2 + 0x20 + *(int *)(pmVar6 + 4) * 4);
    VectorIRotate(&local_4c,
                  (matrix3x4_t *)
                  (*(int *)(param_3 + 4) + *(int *)(param_1 + *(int *)pmVar6 * 0xd8 + 4) * 0x30),
                  &local_84);
  }
  local_94 = (matrix3x4_t *)&local_4c;
  local_98 = (Quaternion *)(pmVar6 + 0x50);
  pmVar5 = pmVar6 + 8;
  fVar9 = local_84;
  if (local_84 < 0.0) {
    local_98 = (Quaternion *)(pmVar6 + 0x60);
    fVar9 = -local_84;
    pmVar5 = pmVar6 + 0x14;
  }
  pQVar4 = (Quaternion *)(pmVar6 + 0x70);
  pmVar3 = pmVar6 + 0x20;
  fVar10 = local_80;
  if (local_80 < 0.0) {
    pQVar4 = (Quaternion *)(pmVar6 + 0x80);
    fVar10 = -local_80;
    pmVar3 = pmVar6 + 0x2c;
  }
  local_90 = (Quaternion *)(pmVar6 + 0x90);
  pmVar7 = pmVar6 + 0x38;
  fVar11 = local_7c;
  if (local_7c < 0.0) {
    local_90 = (Quaternion *)(pmVar6 + 0xa0);
    fVar11 = -local_7c;
    pmVar7 = pmVar6 + 0x44;
  }
  fVar12 = fVar10 + fVar9;
  if (fVar12 <= 0.0) {
    QuaternionSlerp(local_90,local_90,0.0,local_6c);
    local_78 = *(float *)pmVar7;
    local_74 = *(float *)(pmVar7 + 4);
    local_70 = *(float *)(pmVar7 + 8);
  }
  else {
    fVar8 = 1.0 / (fVar11 + fVar12);
    QuaternionSlerp(pQVar4,local_98,fVar9 / fVar12,local_5c);
    fVar11 = fVar11 * fVar8;
    QuaternionSlerp(local_5c,local_90,fVar11,local_6c);
    fVar9 = fVar9 * fVar8;
    fVar10 = fVar10 * fVar8;
    local_78 = fVar10 * *(float *)pmVar3 + fVar9 * *(float *)pmVar5 + *(float *)pmVar7 * fVar11;
    local_74 = fVar10 * *(float *)(pmVar3 + 4) + fVar9 * *(float *)(pmVar5 + 4) +
               *(float *)(pmVar7 + 4) * fVar11;
    local_70 = *(float *)(pmVar3 + 8) * fVar10 + *(float *)(pmVar5 + 8) * fVar9 +
               fVar11 * *(float *)(pmVar7 + 8);
  }
  QuaternionMatrix(local_6c,(Vector *)&local_78,local_94);
  ConcatTransforms((matrix3x4_t *)
                   (*(int *)(param_1 + param_2 * 0xd8 + 4) * 0x30 + *(int *)(param_3 + 4)),local_94,
                   (matrix3x4_t *)(param_2 * 0x30 + *(int *)(param_3 + 4)));
  return;
}

SourceMod gamedata

paste into addons/sourcemod/gamedata/<your_plugin>.txt
used as the SourceMod key — change to fit your plugin's convention
SourceMod library name (server / engine / matchmaking)

Just a Signatures{} block, ready to drop into a gamedata file. Wire it up in your plugin however you like - SDKCall, DHooks, raw memory ops, or anything else.



        

        

          

Type inference is best-effort from the C signature - sanity-check the DHooks types before shipping.

Return-type handling cheatsheet (DHookReturn)