L L4D2node

R_DecalComputeBasis

0x0012fac0 · 940 bytes · __cdecl

_Z19R_DecalComputeBasisRK6VectorPS0_PS_

Decompiled

undefined (3 params)

/* R_DecalComputeBasis(Vector const&, Vector const*, Vector*) */

void R_DecalComputeBasis(Vector *param_1,Vector *param_2,Vector *param_3)

{
  float fVar1;
  float fVar2;
  float fVar3;
  float fVar4;
  float fVar5;
  float fVar6;
  float fVar7;
  float fVar8;
  undefined1 auVar9 [16];
  float fVar10;
  float local_20;
  float local_1c;
  float local_18;
  float local_10;
  
  fVar1 = *(float *)param_1;
  *(float *)(param_3 + 0x18) = fVar1;
  local_1c = *(float *)(param_1 + 4);
  *(float *)(param_3 + 0x1c) = local_1c;
  fVar5 = *(float *)(param_1 + 8);
  *(float *)(param_3 + 0x20) = fVar5;
  if (param_2 != (Vector *)0x0) {
    fVar6 = *(float *)(param_2 + 4) * fVar5 - *(float *)(param_2 + 8) * local_1c;
    *(float *)(param_3 + 0xc) = fVar6;
    fVar4 = *(float *)(param_2 + 8) * fVar1 - *(float *)param_2 * fVar5;
    *(float *)(param_3 + 0x10) = fVar4;
    fVar3 = *(float *)param_2 * local_1c - *(float *)(param_2 + 4) * fVar1;
    *(float *)(param_3 + 0x14) = fVar3;
    fVar7 = fVar6 * fVar6 + fVar4 * fVar4;
    if (1e-06 < fVar3 * fVar3 + fVar7) {
      fVar8 = fVar3 * local_1c - fVar4 * fVar5;
      fVar10 = fVar5 * fVar6 - fVar3 * fVar1;
      fVar1 = fVar1 * fVar4 - local_1c * fVar6;
      fVar5 = fVar8 * fVar8 + fVar10 * fVar10 + 1.1920929e-07 + fVar1 * fVar1;
      auVar9 = rsqrtss(ZEXT416((uint)fVar5),ZEXT416((uint)fVar5));
      fVar2 = auVar9._0_4_;
      fVar5 = fVar2 * 0.5 * (3.0 - fVar2 * fVar2 * fVar5);
      *(float *)param_3 = fVar8 * fVar5;
      *(float *)(param_3 + 4) = fVar10 * fVar5;
      *(float *)(param_3 + 8) = fVar5 * fVar1;
      fVar7 = fVar3 * fVar3 + 1.1920929e-07 + fVar7;
      auVar9 = rsqrtss(ZEXT416((uint)fVar7),ZEXT416((uint)fVar7));
      fVar1 = auVar9._0_4_;
      fVar1 = fVar1 * 0.5 * (3.0 - fVar1 * fVar1 * fVar7);
      *(float *)(param_3 + 0xc) = fVar6 * fVar1;
      *(float *)(param_3 + 0x10) = fVar4 * fVar1;
      *(float *)(param_3 + 0x14) = fVar3 * fVar1;
      return;
    }
  }
  if (0.70710677 < ABS(*(float *)(param_1 + 8))) {
    local_10 = local_1c * local_1c;
    fVar2 = -fVar5;
    fVar3 = 0.0;
    *(undefined4 *)(param_3 + 4) = 0;
    local_18 = fVar1 * fVar2;
    *(undefined4 *)param_3 = 0x3f800000;
    *(undefined4 *)(param_3 + 8) = 0;
    fVar1 = -(local_1c * fVar1);
    fVar6 = fVar1 * fVar1;
    fVar4 = local_18 * local_18;
    local_20 = 0.0;
    fVar7 = local_10 - fVar5 * fVar2;
  }
  else {
    fVar7 = -local_1c;
    fVar3 = fVar5 * fVar1;
    fVar4 = 0.0;
    *(undefined4 *)(param_3 + 0x14) = 0xbf800000;
    *(undefined4 *)(param_3 + 0xc) = 0;
    *(undefined4 *)(param_3 + 0x10) = 0;
    fVar2 = -(fVar5 * fVar7);
    local_18 = 0.0;
    fVar6 = fVar1 * fVar1;
    local_20 = fVar3 * fVar3;
    local_1c = local_1c * fVar7 - fVar6;
    local_10 = local_1c * local_1c;
  }
  fVar5 = fVar4 + fVar6 + 1.1920929e-07 + fVar7 * fVar7;
  auVar9 = rsqrtss(ZEXT416((uint)fVar5),ZEXT416((uint)fVar5));
  fVar4 = auVar9._0_4_;
  fVar5 = fVar4 * 0.5 * (3.0 - fVar4 * fVar4 * fVar5);
  *(float *)(param_3 + 8) = local_18 * fVar5;
  *(float *)(param_3 + 4) = fVar1 * fVar5;
  *(float *)param_3 = fVar7 * fVar5;
  fVar1 = local_20 + local_10 + 1.1920929e-07 + fVar2 * fVar2;
  auVar9 = rsqrtss(ZEXT416((uint)fVar1),ZEXT416((uint)fVar1));
  fVar5 = auVar9._0_4_;
  fVar1 = fVar5 * 0.5 * (3.0 - fVar5 * fVar5 * fVar1);
  *(float *)(param_3 + 0xc) = fVar3 * fVar1;
  *(float *)(param_3 + 0x10) = fVar2 * fVar1;
  *(float *)(param_3 + 0x14) = fVar1 * local_1c;
  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)