API tools faq
paste
ItsTotallyRSX

dgf

ItsTotallyRSX
Feb 8th, 2020
114
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 24.80 KB | None | 0 0
raw download clone embed print report
  1. #include "Common.hpp"
  2. #include "Main.hpp"
  3. #include "R_TextureCoords.hpp"
  4.  
  5. static GfxWorld *NiggerWorld;
  6.  
  7. static float __7f7fffff = 3.4028235e38;
  8. static float __ff7fffff = -3.4028235e38;
  9. static float __4b000000 = 8388608.0;
  10. static float __80000000 = -0.0;
  11. static float __3f000000 = 0.5;
  12. static float __3f800000 = 1;
  13.  
  14. static const int s_extraTexCoordCountForWorldVertexFormat[12] =
  15. {0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4};
  16.  
  17. static const int s_extraNormalMapCountForWorldVertexFormat[12] =
  18. {0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2};
  19.  
  20. static int g_worldVertexData1StrideDisk[12] =
  21. {0, 8, 12, 16, 20, 24, 24, 28, 32, 32, 36, 40};
  22.  
  23. static int R_GetSurfaceVertexLayerDataStride(GfxSurface * surface)
  24. {
  25.     auto material = GetZoneObject(surface->material);
  26.     auto result   = GetZoneObject(material->techniqueSet.localTechniqueSet);
  27.     if (result)
  28.     {
  29.         auto v2 = result->worldVertFormat;
  30.         if (v2 >= 0xCu)
  31.             SysPanic("invaild format");
  32.  
  33.         return g_worldVertexData1StrideDisk[v2];
  34.     }
  35.     return 0;
  36. }
  37.  
  38. static int GetVertType(GfxSurface * surface)
  39. {
  40.     auto material = GetZoneObject(surface->material);
  41.     auto result = GetZoneObject(material->techniqueSet.localTechniqueSet);
  42.     if (result)
  43.     {
  44.         auto v2 = result->worldVertFormat;
  45.         if (v2 >= 0xCu)
  46.             SysPanic("invaild format");
  47.  
  48.         return v2;
  49.     }
  50.     return 0;
  51. }
  52.  
  53. static void AsmError(int id)
  54. {
  55.     SysPanic("asm error, branch: %i", id);
  56. }
  57.  
  58. static int NoOpAsm()
  59. {
  60.     return 0;
  61. }
  62.  
  63. static void R_CalculateTriangleGroupTexCoordExtents(GfxSurface * surface, GfxWorldVertex * vertsMem, char *layerVertsMem, unsigned int vertLayerDataStride, unsigned int extraTexCoordCount, char *triUsed, char *vertUsed, int startTriIndex, vec3_t * mins, vec3_t * maxs)
  64. {
  65.     uint16_t *v10; // ecx
  66.     int v11; // eax
  67.     vec3_t *v12; // ebx
  68.     signed int v13; // esi
  69.     float v14; // xmm1_4
  70.     int v15; // eax
  71.     float v16; // xmm2_4
  72.     vec2_t *v17; // eax
  73.     float v18; // xmm1_4
  74.     int v19; // ecx
  75.     float v20; // xmm1_4
  76.     float v21; // xmm2_4
  77.     float v22; // xmm1_4
  78.     char *v23; // esi
  79.     unsigned int v24; // edi
  80.     float *v25; // ecx
  81.     float *v26; // edx
  82.     unsigned int v27; // esi
  83.     float *v28; // eax
  84.     char *v29; // ebx
  85.     float v30; // xmm1_4
  86.     float v31; // xmm1_4
  87.     float v32; // xmm1_4
  88.     float v33; // xmm1_4
  89.     float v34; // xmm1_4
  90.     float v35; // xmm1_4
  91.     float v36; // xmm1_4
  92.     float v37; // xmm1_4
  93.     float v38; // xmm1_4
  94.     float v39; // xmm1_4
  95.     float v40; // xmm1_4
  96.     float v41; // xmm1_4
  97.     float v42; // xmm1_4
  98.     float v43; // xmm1_4
  99.     float v44; // xmm1_4
  100.     float v45; // xmm1_4
  101.     vec3_t *v46; // ecx
  102.     int v47; // edx
  103.     float *v48; // eax
  104.     float v49; // xmm1_4
  105.     float v50; // xmm1_4
  106.     float v51; // xmm1_4
  107.     float v52; // xmm1_4
  108.     GfxSurface *v53; // ecx
  109.     int v54; // esi
  110.     int v55; // eax
  111.     int v56; // eax
  112.     int v57; // ecx
  113.     int v58; // edx
  114.     int v59; // eax
  115.     vec2_t *extraTexCoords; // [esp+0h] [ebp-18h]
  116.     int v61; // [esp+8h] [ebp-10h]
  117.     int startIndex2; // [esp+Ch] [ebp-Ch]
  118.     int startIndex0; // [esp+10h] [ebp-8h]
  119.     int startIndex1; // [esp+14h] [ebp-4h]
  120.     unsigned int triCorner; // [esp+3Ch] [ebp+24h]
  121.     unsigned int triCornera; // [esp+3Ch] [ebp+24h]
  122.  
  123.     triUsed[startTriIndex] = 1;
  124.     v10 = NiggerWorld->draw.indices;
  125.     v61 = 3 * startTriIndex;
  126.     v11 = surface->tris.baseIndex + 3 * startTriIndex;
  127.     v12 = maxs;
  128.     startIndex0 = NiggerWorld->draw.indices[v11];
  129.     startIndex1 = NiggerWorld->draw.indices[v11 + 1];
  130.     startIndex2 = NiggerWorld->draw.indices[v11 + 2];
  131.     triCorner = 0;
  132.     while (1)
  133.     {
  134.         v13 = v10[triCorner + v61 + surface->tris.baseIndex];
  135.         if (v13 >= surface->tris.vertexCount)
  136.             SysPanic("Fuck");
  137.         if (!vertUsed[v13])
  138.         {
  139.             vertUsed[v13] = 1;
  140.             v14 = mins->v[0];
  141.             v15 = v13 + surface->tris.firstVertex;
  142.             v16 = vertsMem[v15].texCoord.v[0];
  143.             v17 = &vertsMem[v15].texCoord;
  144.             if ((float)(mins->v[0] - v16) >= 0.0)
  145.                 v14 = v16;
  146.             mins->v[0] = v14;
  147.             v18 = mins->v[1];
  148.             if ((float)(mins->v[1] - v17->v[1]) >= 0.0)
  149.                 v18 = v17->v[1];
  150.             mins->v[1] = v18;
  151.             v19 = v13 + surface->tris.firstVertex;
  152.             v20 = vertsMem[v19].texCoord.v[0];
  153.             if ((float)(vertsMem[v19].texCoord.v[0] - v12->v[0]) < 0.0)
  154.                 v20 = v12->v[0];
  155.             v21 = v12->v[1];
  156.             v12->v[0] = v20;
  157.             v22 = vertsMem[v19].texCoord.v[1];
  158.             if ((float)(vertsMem[v19].texCoord.v[1] - v21) < 0.0)
  159.                 v22 = v21;
  160.             v12->v[1] = v22;
  161.             if (extraTexCoordCount)
  162.             {
  163.                 v23 = &layerVertsMem[vertLayerDataStride * v13];
  164.                 v24 = 0;
  165.                 extraTexCoords = (vec2_t *)v23;
  166.                 if ((signed int)extraTexCoordCount >= 4)
  167.                 {
  168.                     v25 = (float *)(v23 + 20);
  169.                     v26 = &mins[3].y;
  170.                     v27 = ((extraTexCoordCount - 4) >> 2) + 1;
  171.                     v28 = &v12[1].y;
  172.                     v29 = (char *)((char *)mins - (char *)v12);
  173.                     v24 = 4 * v27;
  174.                     do
  175.                     {
  176.                         v30 = *(v26 - 7);
  177.                         if ((float)(*(v26 - 7) - *(v25 - 5)) >= 0.0)
  178.                             v30 = *(v25 - 5);
  179.                         *(v26 - 7) = v30;
  180.                         v31 = *(float *)((char *)v28 + (DWORD)v29);
  181.                         if ((float)(*(float *)((char *)v28 + (DWORD)v29) - *(v25 - 4)) >= 0.0)
  182.                             v31 = *(v25 - 4);
  183.                         *(float *)((char *)v28 + (DWORD)v29) = v31;
  184.                         v32 = *(v25 - 5);
  185.                         if ((float)(*(v25 - 5) - *(v28 - 1)) < 0.0)
  186.                             v32 = *(v28 - 1);
  187.                         *(v28 - 1) = v32;
  188.                         v33 = *(v25 - 4);
  189.                         if ((float)(*(v25 - 4) - *v28) < 0.0)
  190.                             v33 = *v28;
  191.                         *v28 = v33;
  192.                         v34 = *(v26 - 4);
  193.                         if ((float)(*(v26 - 4) - *(v25 - 3)) >= 0.0)
  194.                             v34 = *(v25 - 3);
  195.                         *(v26 - 4) = v34;
  196.                         v35 = *(v26 - 3);
  197.                         if ((float)(*(v26 - 3) - *(v25 - 2)) >= 0.0)
  198.                             v35 = *(v25 - 2);
  199.                         *(v26 - 3) = v35;
  200.                         v36 = *(v25 - 3);
  201.                         if ((float)(*(v25 - 3) - v28[2]) < 0.0)
  202.                             v36 = v28[2];
  203.                         v28[2] = v36;
  204.                         v37 = *(v25 - 2);
  205.                         if ((float)(*(v25 - 2) - v28[3]) < 0.0)
  206.                             v37 = v28[3];
  207.                         v28[3] = v37;
  208.                         v38 = *(v26 - 1);
  209.                         if ((float)(*(v26 - 1) - *(v25 - 1)) >= 0.0)
  210.                             v38 = *(v25 - 1);
  211.                         *(v26 - 1) = v38;
  212.                         v39 = *v26;
  213.                         if ((float)(*v26 - *v25) >= 0.0)
  214.                             v39 = *v25;
  215.                         *v26 = v39;
  216.                         v40 = *(v25 - 1);
  217.                         if ((float)(*(v25 - 1) - v28[5]) < 0.0)
  218.                             v40 = v28[5];
  219.                         v28[5] = v40;
  220.                         v41 = *v25;
  221.                         if ((float)(*v25 - v28[6]) < 0.0)
  222.                             v41 = v28[6];
  223.                         v28[6] = v41;
  224.                         v42 = v26[2];
  225.                         if ((float)(v26[2] - v25[1]) >= 0.0)
  226.                             v42 = v25[1];
  227.                         v26[2] = v42;
  228.                         v43 = v26[3];
  229.                         if ((float)(v26[3] - v25[2]) >= 0.0)
  230.                             v43 = v25[2];
  231.                         v26[3] = v43;
  232.                         v44 = v25[1];
  233.                         if ((float)(v25[1] - v28[8]) < 0.0)
  234.                             v44 = v28[8];
  235.                         v28[8] = v44;
  236.                         v45 = v25[2];
  237.                         if ((float)(v25[2] - v28[9]) < 0.0)
  238.                             v45 = v28[9];
  239.                         v28[9] = v45;
  240.                         v28 += 12;
  241.                         v26 += 12;
  242.                         v25 += 8;
  243.                         --v27;
  244.                     } while (v27);
  245.                     v12 = maxs;
  246.                     v23 = (char *)extraTexCoords;
  247.                 }
  248.                 if (v24 < extraTexCoordCount)
  249.                 {
  250.                     v46 = &mins[v24 + 1];
  251.                     v47 = (char *)mins - (char *)maxs;
  252.                     v48 = &v12[v24 + 1].y;
  253.                     do
  254.                     {
  255.                         v49 = v46->v[0];
  256.                         if ((float)(v46->v[0] - *(float *)&v23[8 * v24]) >= 0.0)
  257.                             v49 = *(float *)&v23[8 * v24];
  258.                         v46->v[0] = v49;
  259.                         v50 = *(float *)((char *)v48 + v47);
  260.                         if ((float)(*(float *)((char *)v48 + v47) - *(float *)&v23[8 * v24 + 4]) >= 0.0)
  261.                             v50 = *(float *)&v23[8 * v24 + 4];
  262.                         *(float *)((char *)v48 + v47) = v50;
  263.                         v51 = *(float *)&v23[8 * v24];
  264.                         if ((float)(*(float *)&v23[8 * v24] - *(v48 - 1)) < 0.0)
  265.                             v51 = *(v48 - 1);
  266.                         *(v48 - 1) = v51;
  267.                         v52 = *(float *)&v23[8 * v24 + 4];
  268.                         if ((float)(*(float *)&v23[8 * v24 + 4] - *v48) < 0.0)
  269.                             v52 = *v48;
  270.                         *v48 = v52;
  271.                         ++v24;
  272.                         ++v46;
  273.                         v48 += 3;
  274.                     } while (v24 < extraTexCoordCount);
  275.                     v12 = maxs;
  276.                 }
  277.             }
  278.         }
  279.         if (++triCorner >= 3)
  280.             break;
  281.         v10 = NiggerWorld->draw.indices;
  282.     }
  283.     v53 = surface;
  284.     v54 = 0;
  285.     if (surface->tris.triCount > 0u)
  286.     {
  287.         v55 = 0;
  288.         triCornera = 0;
  289.         do
  290.         {
  291.             if (!triUsed[v54])
  292.             {
  293.                 v56 = v53->tris.baseIndex + v55;
  294.                 v57 = NiggerWorld->draw.indices[v56];
  295.                 v58 = NiggerWorld->draw.indices[v56 + 1];
  296.                 v59 = NiggerWorld->draw.indices[v56 + 2];
  297.                 if (v57 == startIndex0
  298.                     || v57 == startIndex1
  299.                     || v57 == startIndex2
  300.                     || v58 == startIndex0
  301.                     || v58 == startIndex1
  302.                     || v58 == startIndex2
  303.                     || v59 == startIndex0
  304.                     || v59 == startIndex1
  305.                     || v59 == startIndex2)
  306.                 {
  307.                     R_CalculateTriangleGroupTexCoordExtents(
  308.                         surface,
  309.                         vertsMem,
  310.                         layerVertsMem,
  311.                         vertLayerDataStride,
  312.                         extraTexCoordCount,
  313.                         triUsed,
  314.                         vertUsed,
  315.                         v54,
  316.                         mins,
  317.                         v12);
  318.                 }
  319.             }
  320.             v53 = surface;
  321.             ++v54;
  322.             v55 = triCornera + 3;
  323.             triCornera += 3;
  324.         } while (v54 < surface->tris.triCount);
  325.     }
  326. }
  327.  
  328.  
  329. void __declspec(naked) HandleTextCoords()  
  330. {
  331.     // IDA CANT DECOMPILE THIS FUNCTION TO REASONABLE OR EVEN UNSAFE C
  332.     __asm
  333.     {
  334.                     push    ebp
  335.                     mov      ebp, esp
  336.                     sub      esp, 0B4h
  337.                     xor      eax, ebp
  338.                     mov      [ebp-4], eax
  339.                     mov      eax, [ebp+8]
  340.                     mov      [ebp-0A4h], eax
  341.                    
  342.                     ; REMOVED NULL CHECK THAT DOESNT WORK WITH NV IDS
  343.                
  344.                  
  345.                     movzx    edx, word ptr [esi+2Ah]
  346.                     push     ebx
  347.                     push     edi
  348.                     push     17h             ; type
  349.                     push     420 ;
  350.                     push     edx             ; size
  351.                     call     ToolAllocate
  352.                     movzx    ecx, word ptr [esi+2Ah]
  353.                     push     ecx ; count
  354.                     push     0               ; value
  355.                     push     eax             ; dst
  356.                     mov      [ebp-98h], eax
  357.                     call     memset
  358.                     movzx    edx, word ptr [esi+28h]
  359.                     push     17h             ; type
  360.                     push     420 ;
  361.                     push     edx             ; size
  362.                     call     ToolAllocate
  363.                     mov      edi, eax
  364.                     movzx    eax, word ptr [esi+28h]
  365.                     push     17h             ; type
  366.                     push     420 ;
  367.                     push     eax             ; size
  368.                     mov      [ebp-0A8h], edi
  369.                     call     ToolAllocate
  370.                     movzx    ecx, word ptr [esi+28h]
  371.                     push     ecx ; count
  372.                     push     0               ; value
  373.                     push     eax             ; dst
  374.                     mov      [ebp-90h], eax
  375.                     call     memset
  376.        
  377.                     ; REMOVED BAD POINTER DEREFERENCE. USE NEVIS ZONES REFERENCE OR RAW OBJECT TO OBTAIN THE VERT TYPE
  378.                     push     esi; esi
  379.                     call GetVertType
  380.                     add esp, 4
  381.                     ; PATCH
  382.  
  383.                     movzx    ecx, eax
  384.                     mov      ebx, s_extraTexCoordCountForWorldVertexFormat[ecx*4]
  385.                     push     esi         ; esi
  386.                     mov       [ebp-0B4h] , ebx
  387.                     call     R_GetSurfaceVertexLayerDataStride
  388.                     mov      [ebp-0A0h], eax
  389.                     mov      eax, [esi+1Ch]
  390.                     add      eax, [ebp-8Ch]
  391.                     xor      edx, edx
  392.                     mov      [ebp-0ACh], eax
  393.                     xor      eax, eax
  394.                     add      esp, 40h
  395.                     mov      [ebp-94h], eax
  396.                     cmp      dx, [esi+2Ah]
  397.                     jnb      loc_A4CA1C
  398.                     movss    xmm0, __7f7fffff
  399.                     movss    xmm1, __ff7fffff
  400.                     jmp      short loc_A4C760
  401.     ; ---------------------------------------------------------------------------
  402.                
  403.    
  404.     loc_A4C760:                          
  405.                                          
  406.                     mov      ecx, [ebp-98h]
  407.                     cmp      byte ptr [eax+ecx], 0
  408.                     jnz      loc_A4CA03
  409.                     lea      ecx, [ebx+1]
  410.                     test     ecx, ecx
  411.                     jz       short loc_A4C7AA
  412.                     xor      eax, eax
  413.                     lea      esp, [esp+0]
  414.                              
  415.     loc_A4C780:                            
  416.                     movss    dword ptr [ebp+eax-40h], xmm0
  417.                     movss    dword ptr [ebp+eax-40h+4], xmm0
  418.                     movss    dword ptr [ebp+eax-40h+8], xmm0
  419.                     movss    dword ptr [ebp+eax-7Ch], xmm1
  420.                     movss    dword ptr [ebp+eax-7Ch+4], xmm1
  421.                     movss    dword ptr [ebp+eax-7Ch+8], xmm1
  422.                     add      eax, 0Ch
  423.                     dec      ecx
  424.                     jnz      short loc_A4C780
  425.                              
  426.     loc_A4C7AA:                          
  427.                     movzx    edx, word ptr [esi+28h]
  428.                     push     edx          
  429.                     push     0            
  430.                     push     edi          
  431.                     call     memset
  432.                     mov      edx, [ebp-94h]
  433.                     lea      eax, [ebp-7Ch]
  434.                     push     eax          
  435.                     mov      eax, [ebp-98h]
  436.                     lea      ecx, [ebp-40h]
  437.                     push     ecx ; mins
  438.                     mov      ecx, [ebp-0A0h]
  439.                     push     edx            
  440.                     mov      edx, [ebp-0ACh]
  441.                     push     edi            
  442.                     push     eax            
  443.                     mov      eax, [ebp-0A4h]
  444.                     push     ebx            
  445.                     push     ecx ; vertLayerDataStride
  446.                     push     edx            
  447.                     push     eax            
  448.                     push     esi        
  449.                     call     R_CalculateTriangleGroupTexCoordExtents
  450.                     xor      edx, edx
  451.                     lea      eax, [ebx+1]
  452.                     add      esp, 34h
  453.                     mov      [ebp-9Ch], edx
  454.                     test     eax, eax
  455.                     jz       loc_A4C9F3
  456.                              
  457.     loc_A4C800:                              
  458.                     movss    xmm2, __80000000
  459.                     movss    xmm3, __4b000000
  460.                     movss    xmm5, __3f800000
  461.                     lea      eax, [edx+edx*2]
  462.                     add      eax, eax
  463.                     add      eax, eax
  464.                     movss    xmm0, dword ptr [ebp+eax-40h]
  465.                     addss    xmm0, dword ptr [ebp+eax-7Ch]
  466.                     mulss    xmm0, __3f000000
  467.                     andps    xmm2, xmm0
  468.                     movss    xmm1, dword ptr [ebp+eax-40h+4]
  469.                     addss    xmm1, dword ptr [ebp+eax-7Ch+4]
  470.                     mulss    xmm1, __3f000000
  471.                     movaps   xmm4, xmm2
  472.                     lea      ecx, [ebp+eax-7Ch]
  473.                     movaps   xmm2, xmm0
  474.                     xorps    xmm2, xmm4
  475.                     cmpltss  xmm2, xmm3
  476.                     andps    xmm3, xmm2
  477.                     lea      eax, [ebp+eax-40h]
  478.                     movaps   xmm2, xmm0
  479.                     orps     xmm3, xmm4
  480.                     addss    xmm2, xmm3
  481.                     subss    xmm2, xmm3
  482.                     movaps   xmm3, xmm2
  483.                     subss    xmm3, xmm0
  484.                     movss    xmm0, __80000000
  485.                     andps    xmm0, xmm1
  486.                     cmpnless  xmm3, xmm4
  487.                     movss    xmm4, __3f800000
  488.                     andps    xmm3, xmm5
  489.                     subss    xmm2, xmm3
  490.                     movaps   xmm3, xmm0
  491.                     movaps   xmm5, xmm2
  492.                     movss    xmm2, __4b000000
  493.                     movaps   xmm0, xmm1
  494.                     xorps    xmm0, xmm3
  495.                     cmpltss  xmm0, xmm2
  496.                     andps    xmm2, xmm0
  497.                     orps     xmm2, xmm3
  498.                     movaps   xmm0, xmm1
  499.                     addss    xmm0, xmm2
  500.                     subss    xmm0, xmm2
  501.                     movaps   xmm2, xmm0
  502.                     subss    xmm2, xmm1
  503.                     cmpnless  xmm2, xmm3
  504.                     xor     ecx, ecx
  505.                     andps   xmm2, xmm4
  506.                     xor     edi, edi
  507.                     subss   xmm0, xmm2
  508.                     movss   dword ptr [ebp - 88h], xmm5
  509.                     movss   dword ptr [ebp - 88h +4], xmm0
  510.                     cmp     cx, [esi+28h]
  511.                     jnb     loc_A4C9DB
  512.                     mov     eax, [ebp-0A8h]
  513.                     sub     eax, [ebp-90h]
  514.                     mov     [ebp-8Ch] , ecx
  515.                     mov     [ebp-0B0h], eax
  516.                     jmp     short loc_A4C916
  517.     ; ---------------------------------------------------------------------------
  518.              
  519.    
  520.     loc_A4C910:                            
  521.                     mov       eax, [ebp-0B0h]
  522.                              
  523.     loc_A4C916:                              
  524.                     mov       ebx, [ebp-90h]
  525.                     add       ebx, edi
  526.                     cmp       byte ptr [eax+ebx], 0
  527.                     jz        loc_A4C9BC
  528.                     test      edx, edx
  529.                     jnz       short loc_A4C993
  530.                     cmp       [ebx], dl
  531.                     jz        short loc_A4C958
  532.                     push      420
  533.                     push      420
  534.                     push      edx            
  535.                     push      0B29h          
  536.                     push      1
  537.                     call      AsmError
  538.                     add       esp, 14h
  539.                     test      al, al
  540.                     jnz       short loc_A4C952
  541.                     int       3              
  542.                              
  543.     loc_A4C952:                              
  544.                     mov       edx, [ebp-9Ch]
  545.                              
  546.     loc_A4C958:                              
  547.                     mov       ecx, [ebp-0A4h]
  548.                     movss     xmm5, dword ptr [ebp - 88h]
  549.                     mov       byte ptr [ebx], 1
  550.                     mov       eax, [esi+20h]
  551.                     add       eax, edi
  552.                     imul      eax, 2Ch
  553.                     movss     xmm0, dword ptr [eax+ecx+14h]
  554.                     lea       eax, [eax+ecx+14h]
  555.                     mov       ecx, [ebp-8Ch]
  556.                     subss     xmm0, xmm5
  557.                     movss     dword ptr [eax], xmm0
  558.                     movss     xmm0, dword ptr [ebp - 88h +4]
  559.                     jmp       short loc_A4C9AE
  560.     ; ----------------------  -----------------------------------------------------
  561.                              
  562.     loc_A4C993:                              
  563.                     mov       ebx, [ebp-0ACh]
  564.                     lea       eax, [ecx+edx*8]
  565.                     movss     xmm1, dword ptr [eax+ebx-8]
  566.                     lea       eax, [eax+ebx-8]
  567.                     subss     xmm1, xmm5
  568.                     movss     dword ptr [eax], xmm1
  569.                              
  570.     loc_A4C9AE:                              
  571.                     movss     xmm1, dword ptr [eax+4]
  572.                     subss     xmm1, xmm0
  573.                     movss     dword ptr [eax+4], xmm1
  574.                              
  575.     loc_A4C9BC:                              
  576.                     movzx     eax, word ptr [esi+28h]
  577.                     add       ecx, [ebp-0A0h]
  578.                     inc       edi
  579.                     mov       [ebp-8Ch] , ecx
  580.                     cmp       edi, eax
  581.                     jb        loc_A4C910
  582.                     mov       ebx,  [ebp-0B4h]
  583.                              
  584.     loc_A4C9DB:                              
  585.                     inc       edx
  586.                     lea       eax, [ebx+1]
  587.                     mov       [ebp-9Ch], edx
  588.                     cmp       edx, eax
  589.                     jb        loc_A4C800
  590.                     mov       edi, [ebp-0A8h]
  591.                              
  592.     loc_A4C9F3:                              
  593.                     movss     xmm0, __7f7fffff
  594.                     movss     xmm1, __ff7fffff
  595.                              
  596.     loc_A4CA03:                              
  597.                     mov       eax, [ebp-94h]
  598.                     movzx     ecx, word ptr [esi+2Ah]
  599.                     inc       eax
  600.                     mov       [ebp-94h], eax
  601.                     cmp       eax, ecx
  602.                     jb        loc_A4C760
  603.                              
  604.     loc_A4CA1C:                              
  605.                     mov       edx, [ebp-98h]
  606.                     push      18h            
  607.                     push      edx            
  608.                     call      NoOpAsm
  609.                     push      18h            
  610.                     push      edi            
  611.                     call      NoOpAsm
  612.                     mov       eax, [ebp-90h]
  613.                     push      18h            
  614.                     push      eax            
  615.                     call      NoOpAsm
  616.                     add       esp, 18h
  617.                     pop       edi
  618.                     pop       ebx
  619.                              
  620.     loc_A4CA45:                              
  621.                                              
  622.                     mov       ecx, [ebp-4]
  623.                     xor       ecx, ebp ; cookie
  624.                     call      NoOpAsm ; __security_check_cookie(x)
  625.                     mov       esp, ebp
  626.                     pop       ebp
  627.                     retn
  628.     }
  629. }
  630.  
  631. void  R_RecenterSurfaceTexCoords(GfxWorld *world, GfxSurface *surface, char *vertLayerDataMem, GfxWorldVertex *vertsMem)
  632. {
  633.     NiggerWorld = world;
  634.     __asm
  635.     {
  636.         mov esi, surface
  637.         mov ecx, vertLayerDataMem
  638.         push vertsMem
  639.         call HandleTextCoords
  640.         add esp, 4
  641.     }
  642. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!