L L4D2node

EnumerateLeavesAlongExtrudedRay_R

0x00167150 · 762 bytes · __regparm3

_ZL33EnumerateLeavesAlongExtrudedRay_RP7mnode_tRK5Ray_tffP22ISpatialLeafEnumeratori

Decompiled

undefined (6 params)

/* EnumerateLeavesAlongExtrudedRay_R(mnode_t*, Ray_t const&, float, float, ISpatialLeafEnumerator*,
   int) */

bool __regparm3
EnumerateLeavesAlongExtrudedRay_R
          (mnode_t *param_1,Ray_t *param_2,float param_3,float param_4,
          ISpatialLeafEnumerator *param_5,int param_6)

{
  float fVar1;
  byte bVar2;
  float *pfVar3;
  bool bVar4;
  char cVar5;
  undefined1 uVar6;
  int iVar7;
  uint uVar8;
  float in_XMM0_Da;
  float fVar9;
  float in_XMM1_Da;
  float fVar10;
  float fVar11;
  float fVar12;
  ISpatialLeafEnumerator *in_stack_ffffff98;
  int in_stack_ffffff9c;
  
  while( true ) {
    while( true ) {
      while( true ) {
        iVar7 = *(int *)param_1;
        if (iVar7 == 1) {
          return true;
        }
        while( true ) {
          if (-1 < iVar7) {
            uVar6 = (*(code *)**(undefined4 **)param_3)
                              (param_3,(int)param_1 - *(int *)(DAT_003a172c + 0x10) >> 6,param_4);
            return (bool)uVar6;
          }
          pfVar3 = *(float **)(param_1 + 0x30);
          bVar2 = *(byte *)(pfVar3 + 4);
          if (bVar2 < 3) {
            iVar7 = (uint)bVar2 * 4;
            fVar10 = *(float *)(param_2 + (uint)bVar2 * 4);
            fVar12 = *(float *)(param_2 + iVar7 + 0x30) + 0.03125;
            fVar9 = *(float *)(param_2 + iVar7 + 0x10);
          }
          else {
            fVar12 = *pfVar3;
            fVar11 = pfVar3[1];
            fVar1 = pfVar3[2];
            fVar10 = *(float *)(param_2 + 4) * fVar11 + *(float *)param_2 * fVar12 +
                     *(float *)(param_2 + 8) * fVar1;
            fVar9 = *(float *)(param_2 + 0x14) * fVar11 + *(float *)(param_2 + 0x10) * fVar12 +
                    *(float *)(param_2 + 0x18) * fVar1;
            fVar12 = ABS(fVar12 * *(float *)(param_2 + 0x30)) +
                     ABS(fVar11 * *(float *)(param_2 + 0x34)) + 0.03125 +
                     ABS(fVar1 * *(float *)(param_2 + 0x38));
          }
          fVar11 = fVar9 * in_XMM1_Da + (fVar10 - pfVar3[3]);
          fVar10 = fVar9 * in_XMM0_Da + (fVar10 - pfVar3[3]);
          bVar4 = fVar12 < fVar11 && fVar12 < fVar10;
          if (fVar12 >= fVar11 || fVar12 >= fVar10) break;
          param_1 = *(mnode_t **)(param_1 + 0x34);
          iVar7 = *(int *)param_1;
          if (iVar7 == 1) {
            return true;
          }
        }
        if ((-fVar12 <= fVar10) || (-fVar12 <= fVar11)) break;
        param_1 = *(mnode_t **)(param_1 + 0x38);
      }
      fVar9 = fVar10 - fVar11;
      if (0.03125 <= ABS(fVar9)) break;
      cVar5 = EnumerateLeavesAlongExtrudedRay_R
                        (*(mnode_t **)(param_1 + 0x34),param_2,param_3,param_4,in_stack_ffffff98,
                         in_stack_ffffff9c);
      if (cVar5 == '\0') {
        return bVar4;
      }
      param_1 = *(mnode_t **)(param_1 + 0x38);
    }
    if (fVar11 <= fVar10) {
      if (fVar10 <= fVar11) {
        uVar8 = 0;
        fVar10 = 0.0;
      }
      else {
        uVar8 = 0;
        fVar10 = (fVar10 - fVar12) * (1.0 / fVar9);
      }
    }
    else {
      uVar8 = 1;
      fVar10 = (fVar10 + fVar12) * (1.0 / fVar9);
    }
    cVar5 = EnumerateLeavesAlongExtrudedRay_R
                      (*(mnode_t **)(param_1 + (uVar8 + 0xc) * 4 + 4),param_2,param_3,param_4,
                       in_stack_ffffff98,in_stack_ffffff9c);
    if (cVar5 == '\0') break;
    if (fVar10 <= 0.0) {
      fVar10 = 0.0;
    }
    param_1 = *(mnode_t **)(param_1 + ((uVar8 ^ 1) + 0xc) * 4 + 4);
    if (1.0 <= fVar10) {
      fVar10 = 1.0;
    }
    in_XMM0_Da = in_XMM0_Da + fVar10 * (in_XMM1_Da - in_XMM0_Da);
  }
  return bVar4;
}

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)