Tutorial:CodeInjection Floats - Revision history

Dark Byte: Reverted edits by This content is not available (Talk) to last revision by TheyCallMeTim13

2019-03-18T19:10:30Z

Reverted edits by This content is not available (Talk) to last revision by TheyCallMeTim13

Show changes

This content is not available: Replaced content with 'Sorry! Content not available.'

2019-03-16T16:26:59Z

Replaced content with 'Sorry! Content not available.'

Show changes

TheyCallMeTim13: /* Working with the FPU registry */

2018-05-12T03:05:54Z

‎Working with the FPU registry

TheyCallMeTim13 at 02:56, 12 May 2018

2018-05-12T02:56:44Z

TheyCallMeTim13: /* Working with packed instructions */

2018-05-12T02:23:31Z

‎Working with packed instructions

TheyCallMeTim13: /* Calculate a value for packed instruction */

2018-05-12T02:19:39Z

‎Calculate a value for packed instruction

TheyCallMeTim13 at 02:16, 12 May 2018

2018-05-12T02:16:23Z

TheyCallMeTim13 at 12:42, 7 May 2018

2018-05-07T12:42:56Z

TheyCallMeTim13: Created page with ' Category:Tutorial Category:Auto Assembler {{DISPLAYTITLE:Code Injection - Working with Floats}} This tutorial builds on the topic o…'

2018-05-07T03:58:40Z

Created page with ' Category:Tutorial Category:Auto Assembler {{DISPLAYTITLE:Code Injection - Working with Floats}} This tutorial builds on the topic o…'

New page

[[Category:Tutorial]]
[[Category:Auto Assembler]]
{{DISPLAYTITLE:Code Injection - Working with Floats}}
This tutorial builds on the topic of Code Injection:
{{TutorialsCodeInjection}}

 
Let's say you have a float and some code that increases the value.
<pre>
addss [eax+10],xmm0
</pre>
:Note: '''SS''' is for singles and '''SD''' is for doubles.
<blockquote>
What if what writes to the value is only a [[Assembler:Commands:MOVSS|MOVSS]]. Try to find a spot above the write instruction that has an [[Assembler:Commands:ADDSS|ADDSS]] (or a [[Assembler:Commands:SUBSS|SUBSS]] depending on what you want to do).
<pre>
addss xmm0,xmm1
//...
movss [eax+10],xmm0
</pre>
</blockquote>

 
== Editable value ==
We could use a [[Auto Assembler:label|label]], giving it some memory. And optionally [[Auto_Assembler:registerSymbol|register]] it so the label can be used on the table as an address.
<pre>
//...
alloc(someMem, 0x400)
//...
label(someSymbol)
registerSymbol(someSymbol)
//...
someMem:
//...
mov xmm0,[someSymbol]
addss [eax+10],xmm0
//...
jmp return
//...
someSymbol:
dd (float)100
//...
</pre>

 
== Adding a Multiplier ==
We could add an editable value like above but use [[Assembler:Commands:MULSS|MULSS]] to add a multiplier to the script.
<pre>
//...
alloc(someMem, 0x400)
//...
label(someSymbol)
registerSymbol(someSymbol)
//...
someMem:
//...
mulss xmm0,[someSymbol]
addss [eax+10],xmm0
//...
jmp return
//...
someSymbol:
dd (float)100
//...
</pre>

 
== Calculate a value for a Multiplier ==
Let's say we just can't find an [[Assembler:Commands:ADDSS|ADDSS]] or a [[Assembler:Commands:SUBSS|SUBSS]], and all we have is a [[Assembler:Commands:MOVSS|MOVSS]].
<pre>
movss [eax+10],xmm0
</pre>

We can just do some math in the script, to calculate a value for a multiplier.
<pre>
//...
alloc(someMem, 0x400)
//...
label(someSymbol)
registerSymbol(someSymbol)
//...
someMem:
//...
subss xmm0,[eax+10]
mulss xmm0,[someSymbol]
addss xmm0,[eax+10]
movss [eax+10],xmm0
//...
jmp return
//...
someSymbol:
dd (float)10
//...
</pre>

 
== Working with doubles ==
Let's say the game use doubles, we can use [[Assembler:Commands:ADDSD|ADDSD]], [[Assembler:Commands:SUBSD|SUBSD]], [[Assembler:Commands:MULSD|MULSD]], and [[Assembler:Commands:MOVSD|MOVSD]] instead. We just need to also make our scripts value a double.
<pre>
movsd [eax+10],xmm0
</pre>

So to calculate a value for a multiplier.
<pre>
//...
alloc(someMem, 0x400)
//...
label(someSymbol)
registerSymbol(someSymbol)
//...
someMem:
//...
subsd xmm0,[eax+10]
mulsd xmm0,[someSymbol]
addsd xmm0,[eax+10]
movsd [eax+10],xmm0
//...
jmp return
//...
someSymbol:
dq (double)10
//...
</pre>

 
== See Also ==
{{TutorialsAA}}

@@ Line 220: / Line 220: @@
 <br>
 == Working with the FPU registry ==
-Some times you'll find some opcode that uses the FPU registry. These include [[Assembler:Commands:FLD|FLD]], [[Assembler:Commands:FMUL|FMUL]], [[Assembler:Commands:FADD|FADD]], [[Assembler:Commands:FSUB|FSUB]], [[Assembler:Commands:FST|FST]], [[Assembler:Commands:FSTP|FSTP]].
+Some times you'll find some opcode that uses the [https://en.wikibooks.org/wiki/X86_Assembly/Floating_Point FPU] registry. These include [[Assembler:Commands:FLD|FLD]], [[Assembler:Commands:FMUL|FMUL]], [[Assembler:Commands:FADD|FADD]], [[Assembler:Commands:FSUB|FSUB]], [[Assembler:Commands:FST|FST]], [[Assembler:Commands:FSTP|FSTP]].
 So with singles it might look like this.
@@ Line 270: / Line 270: @@
 <br>
 == See Also ==
 {{TutorialsAA}}

@@ Line 156: / Line 156: @@
 <br>
 == Calculate a value for packed instruction ==
 Let's say we just can't find an [[Assembler:Commands:ADDPS|ADDPS]] or a [[Assembler:Commands:SUBPS|SUBPS]], and all we have is a [[Assembler:Commands:MOVUPS|MOVUPS]] or a [[Assembler:Commands:MOVAPS|MOVAPS]].
@@ Line 190: / Line 189: @@
 We could use the [[Auto_Assembler:align|align]] command and then be able to use aligned instructions. So if the injection point looks like this.
 <pre>
-movaps [eax+10],xmm0
+movups [eax+10],xmm0
 </pre>
@@ Line 219: / Line 218: @@
 </pre>
 <br>
 == See Also ==
 {{TutorialsAA}}

@@ Line 125: / Line 125: @@
 <br>
 == Working with packed instructions ==
-So some times (especially with vectors) you'll see packed instructions, like [[Assembler:Commands:MOVAPS|MOVAPS]], [[Assembler:Commands:MOVUPS|MOVUPS]], [[Assembler:Commands:ADDPS|ADDPS]], [[Assembler:Commands:SUBPS|SUBPS]], [[Assembler:Commands:MULPS|MULPS]]. These type of instructions work on 16 bytes at a time.
+Some times (especially with vectors) you'll see packed instructions, like [[Assembler:Commands:MOVAPS|MOVAPS]], [[Assembler:Commands:MOVUPS|MOVUPS]], [[Assembler:Commands:ADDPS|ADDPS]], [[Assembler:Commands:SUBPS|SUBPS]], [[Assembler:Commands:MULPS|MULPS]]. These type of instructions work on 16 bytes at a time.
-SO let's say you have some code accessing the player coordinate deltas, and it's using packed instructions.
+So let's say you have some code accessing the player coordinate deltas, and it's using packed instructions.
 <pre>
 addps [eax+10],xmm0
@@ Line 156: / Line 156: @@
 <br>
 == Calculate a value for packed instruction ==
 Let's say we just can't find an [[Assembler:Commands:ADDPS|ADDPS]] or a [[Assembler:Commands:SUBPS|SUBPS]], and all we have is a [[Assembler:Commands:MOVUPS|MOVUPS]] or a [[Assembler:Commands:MOVAPS|MOVAPS]].

@@ Line 189: / Line 189: @@
 We could use the [[Auto_Assembler:align|align]] command and then be able to use aligned instructions. So if the injection point looks like this.
 <pre>
-movups [eax+10],xmm0
+movaps [eax+10],xmm0
 </pre>
@@ Line 220: / Line 220: @@
 <br>
 == See Also ==
 {{TutorialsAA}}

@@ Line 33: / Line 33: @@
 someMem:
    //...
-   mov xmm0,[someSymbol]
+   movss xmm0,[someSymbol]
    addss [eax+10],xmm0
    //...