pmdsky-debug-py 10.1.4__py3-none-any.whl → 10.1.5__py3-none-any.whl

pmdsky_debug_py/_release.py

@@ -1 +1 @@
-RELEASE = "v0.10.1+e13bcd5f50"
+RELEASE = "v0.10.1+88dd0146e7"

pmdsky_debug_py/eu.py

@@ -752,7 +752,7 @@ class EuArm9Functions:
         [0x2003328],
         None,
         "TaskProcBoot",
-        "Probably related to booting the game?\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
+        "Boot the game and run the main loop. Use dynamic code dispatch to run code depending on the context (like dungeon mode, ground mode, menu mode, etc.).\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
         None,
     )
 
@@ -3697,6 +3697,24 @@ class EuArm9Functions:
         None,
     )
 
+    ExecuteCopyToFlatVramCommand = Symbol(
+        [0x1ABA8],
+        [0x201ABA8],
+        None,
+        "ExecuteCopyToFlatVramCommand",
+        "Immediately execute the command contained in a copy_to_obj_vram_order struct, copying content as described.\n\nr0: command",
+        None,
+    )
+
+    DecodeFragmentByteAssemblyTable = Symbol(
+        [0x1AC48],
+        [0x201AC48],
+        None,
+        "DecodeFragmentByteAssemblyTable",
+        "Decode the sprite texture stored in each fragment byte assembly entry into the dst output, until the final one is reached.\n\nr0: pointer to array of fragment byte assembly entry, final (otherwise unused) one should have byte_amount = 0\nr1: dst\nreturn: number of decoded bytes",
+        None,
+    )
+
     CopyAndInterleaveWrapper = Symbol(
         [0x1C08C],
         [0x201C08C],
@@ -3954,7 +3972,43 @@ class EuArm9Functions:
         [0x201E14C],
         None,
         "ProcessWte",
-        "Prepare a WTE data to be loaded into VRAM. Seems to need to be called with another undocumented function (at 0x0201e1d8 (EU))\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part\n\nThis may or may not be the function that adds to the queue so it can be added during VBlank.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        "Prepare and plan a WTE data to be loaded into VRAM.\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part.\nWill ensure it gets copied next time PerformPlannedTextureVramTransfer is called by the game.\nWill not automatically free the data once done. That can be done with DelayWteFree, which seems systematically called in the game’s code.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        None,
+    )
+
+    DelayWteFree = Symbol(
+        [0x1E1D8],
+        [0x201E1D8],
+        None,
+        "DelayWteFree",
+        "Add a command to free the input WTE handle once all previously registered commands that would edit the texture VRAM have been executed.\nAlso nullify the structure’s two pointers.\nThe error caused by the lack of place to store the command is ignored.\n\nr0: wte handle to eventually free",
+        None,
+    )
+
+    ResetPlannedVramTransfer = Symbol(
+        [0x1E270],
+        [0x201E270],
+        None,
+        "ResetPlannedVramTransfer",
+        "Reset the command array of input container\nDoes not reset its other field\n\nr0: the container to reset",
+        None,
+    )
+
+    PlanCopyTextureToTextureVram = Symbol(
+        [0x1E27C],
+        [0x201E27C],
+        None,
+        "PlanCopyTextureToTextureVram",
+        "Add a command in the container (r1) that will be executed later by PerformPlannedTextureVramTransfer to copy part of the RAM into the texture VRAM (or free the source allocated memory depending of the specified type of command).\nCheck for overflow. If an overflow would occur, do not add the command to the container, and return -1 instead.\n\nr0: Container that contain the command list to add to\nr1: pointer to the bytes to be copied in CPU-accessible RAM\nr2: offset to copy too in texture VRAM\nr3: number of bytes to copy\nstack[0]: type of command to perform",
+        None,
+    )
+
+    PerformPlannedTextureVramTransfer = Symbol(
+        [0x1E2CC],
+        [0x201E2CC],
+        None,
+        "PerformPlannedTextureVramTransfer",
+        "Execute the texture VRAM edition command of the input container. Does not reset it, or alter its state in any way.\n\nr0: container that contains the command list to execute",
         None,
     )
 
@@ -11129,7 +11183,16 @@ class EuItcmFunctions:
         [0x20B3CC0],
         None,
         "CopyAndInterleave",
-        "Copies data from src to dst, placing the last 4 bits of val after every 4 bits copied.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nr0: [output] dst\nr1: src\nr2: len (in bytes)\nr3: val",
+        "Copies data from src to dst, interleaving the lower 4 bits of val with every 4 bits copied (if the copied bits are nonzero).\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary inputs (assuming little-endian byte order)\n  src[i] = {76543210 fedcba98}\n      {3210} != 0\n      {7654} != 0\n      {ba98} != 0\n      {fedc} != 0\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {vwxy7654 vwxy3210}\n  dst[2*i+1] = {vwxyfedc vwxyba98}\n\nIf any 4-bit nibble is 0, the corresponding byte written to dst is interleaved with 0 rather than the low bits of val. For example, if 'z' represents a 0 bit, given the inputs:\n  src[i] = {zzzz3210 fedczzzz}\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {zzzzzzzz vwxy3210}\n  dst[2*i+1] = {vwxyfedc zzzzzzzz}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)\nr3: val",
+        None,
+    )
+
+    CopyAndInterleave0 = Symbol(
+        [0xB0],
+        [0x20B3D70],
+        None,
+        "CopyAndInterleave0",
+        "Equivalent to CopyAndInterleave with an interleaved value of 0.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary input (assuming little-endian byte order):\n  src[i] = {76543210 fedcba98}\nThen the output written to dst will be (where 'z' is a 0 bit):\n  dst[2*i] = {zzzz7654 zzzz3210}\n  dst[2*i+1] = {zzzzfedc zzzzba98}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)",
         None,
     )
 

pmdsky_debug_py/eu_itcm.py

@@ -740,7 +740,7 @@ class EuItcmArm9Functions:
         None,
         None,
         "TaskProcBoot",
-        "Probably related to booting the game?\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
+        "Boot the game and run the main loop. Use dynamic code dispatch to run code depending on the context (like dungeon mode, ground mode, menu mode, etc.).\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
         None,
     )
 
@@ -3651,6 +3651,24 @@ class EuItcmArm9Functions:
         None,
     )
 
+    ExecuteCopyToFlatVramCommand = Symbol(
+        None,
+        None,
+        None,
+        "ExecuteCopyToFlatVramCommand",
+        "Immediately execute the command contained in a copy_to_obj_vram_order struct, copying content as described.\n\nr0: command",
+        None,
+    )
+
+    DecodeFragmentByteAssemblyTable = Symbol(
+        None,
+        None,
+        None,
+        "DecodeFragmentByteAssemblyTable",
+        "Decode the sprite texture stored in each fragment byte assembly entry into the dst output, until the final one is reached.\n\nr0: pointer to array of fragment byte assembly entry, final (otherwise unused) one should have byte_amount = 0\nr1: dst\nreturn: number of decoded bytes",
+        None,
+    )
+
     CopyAndInterleaveWrapper = Symbol(
         None,
         None,
@@ -3908,7 +3926,43 @@ class EuItcmArm9Functions:
         None,
         None,
         "ProcessWte",
-        "Prepare a WTE data to be loaded into VRAM. Seems to need to be called with another undocumented function (at 0x0201e1d8 (EU))\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part\n\nThis may or may not be the function that adds to the queue so it can be added during VBlank.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        "Prepare and plan a WTE data to be loaded into VRAM.\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part.\nWill ensure it gets copied next time PerformPlannedTextureVramTransfer is called by the game.\nWill not automatically free the data once done. That can be done with DelayWteFree, which seems systematically called in the game’s code.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        None,
+    )
+
+    DelayWteFree = Symbol(
+        None,
+        None,
+        None,
+        "DelayWteFree",
+        "Add a command to free the input WTE handle once all previously registered commands that would edit the texture VRAM have been executed.\nAlso nullify the structure’s two pointers.\nThe error caused by the lack of place to store the command is ignored.\n\nr0: wte handle to eventually free",
+        None,
+    )
+
+    ResetPlannedVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "ResetPlannedVramTransfer",
+        "Reset the command array of input container\nDoes not reset its other field\n\nr0: the container to reset",
+        None,
+    )
+
+    PlanCopyTextureToTextureVram = Symbol(
+        None,
+        None,
+        None,
+        "PlanCopyTextureToTextureVram",
+        "Add a command in the container (r1) that will be executed later by PerformPlannedTextureVramTransfer to copy part of the RAM into the texture VRAM (or free the source allocated memory depending of the specified type of command).\nCheck for overflow. If an overflow would occur, do not add the command to the container, and return -1 instead.\n\nr0: Container that contain the command list to add to\nr1: pointer to the bytes to be copied in CPU-accessible RAM\nr2: offset to copy too in texture VRAM\nr3: number of bytes to copy\nstack[0]: type of command to perform",
+        None,
+    )
+
+    PerformPlannedTextureVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "PerformPlannedTextureVramTransfer",
+        "Execute the texture VRAM edition command of the input container. Does not reset it, or alter its state in any way.\n\nr0: container that contains the command list to execute",
         None,
     )
 
@@ -11063,7 +11117,16 @@ class EuItcmItcmFunctions:
         [0x1FF8000],
         None,
         "CopyAndInterleave",
-        "Copies data from src to dst, placing the last 4 bits of val after every 4 bits copied.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nr0: [output] dst\nr1: src\nr2: len (in bytes)\nr3: val",
+        "Copies data from src to dst, interleaving the lower 4 bits of val with every 4 bits copied (if the copied bits are nonzero).\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary inputs (assuming little-endian byte order)\n  src[i] = {76543210 fedcba98}\n      {3210} != 0\n      {7654} != 0\n      {ba98} != 0\n      {fedc} != 0\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {vwxy7654 vwxy3210}\n  dst[2*i+1] = {vwxyfedc vwxyba98}\n\nIf any 4-bit nibble is 0, the corresponding byte written to dst is interleaved with 0 rather than the low bits of val. For example, if 'z' represents a 0 bit, given the inputs:\n  src[i] = {zzzz3210 fedczzzz}\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {zzzzzzzz vwxy3210}\n  dst[2*i+1] = {vwxyfedc zzzzzzzz}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)\nr3: val",
+        None,
+    )
+
+    CopyAndInterleave0 = Symbol(
+        [0xB0],
+        [0x1FF80B0],
+        None,
+        "CopyAndInterleave0",
+        "Equivalent to CopyAndInterleave with an interleaved value of 0.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary input (assuming little-endian byte order):\n  src[i] = {76543210 fedcba98}\nThen the output written to dst will be (where 'z' is a 0 bit):\n  dst[2*i] = {zzzz7654 zzzz3210}\n  dst[2*i+1] = {zzzzfedc zzzzba98}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)",
         None,
     )
 

pmdsky_debug_py/jp.py

@@ -752,7 +752,7 @@ class JpArm9Functions:
         [0x2003328],
         None,
         "TaskProcBoot",
-        "Probably related to booting the game?\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
+        "Boot the game and run the main loop. Use dynamic code dispatch to run code depending on the context (like dungeon mode, ground mode, menu mode, etc.).\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
         None,
     )
 
@@ -3697,6 +3697,24 @@ class JpArm9Functions:
         None,
     )
 
+    ExecuteCopyToFlatVramCommand = Symbol(
+        None,
+        None,
+        None,
+        "ExecuteCopyToFlatVramCommand",
+        "Immediately execute the command contained in a copy_to_obj_vram_order struct, copying content as described.\n\nr0: command",
+        None,
+    )
+
+    DecodeFragmentByteAssemblyTable = Symbol(
+        None,
+        None,
+        None,
+        "DecodeFragmentByteAssemblyTable",
+        "Decode the sprite texture stored in each fragment byte assembly entry into the dst output, until the final one is reached.\n\nr0: pointer to array of fragment byte assembly entry, final (otherwise unused) one should have byte_amount = 0\nr1: dst\nreturn: number of decoded bytes",
+        None,
+    )
+
     CopyAndInterleaveWrapper = Symbol(
         [0x1C048],
         [0x201C048],
@@ -3954,7 +3972,43 @@ class JpArm9Functions:
         [0x201E108],
         None,
         "ProcessWte",
-        "Prepare a WTE data to be loaded into VRAM. Seems to need to be called with another undocumented function (at 0x0201e1d8 (EU))\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part\n\nThis may or may not be the function that adds to the queue so it can be added during VBlank.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        "Prepare and plan a WTE data to be loaded into VRAM.\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part.\nWill ensure it gets copied next time PerformPlannedTextureVramTransfer is called by the game.\nWill not automatically free the data once done. That can be done with DelayWteFree, which seems systematically called in the game’s code.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        None,
+    )
+
+    DelayWteFree = Symbol(
+        None,
+        None,
+        None,
+        "DelayWteFree",
+        "Add a command to free the input WTE handle once all previously registered commands that would edit the texture VRAM have been executed.\nAlso nullify the structure’s two pointers.\nThe error caused by the lack of place to store the command is ignored.\n\nr0: wte handle to eventually free",
+        None,
+    )
+
+    ResetPlannedVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "ResetPlannedVramTransfer",
+        "Reset the command array of input container\nDoes not reset its other field\n\nr0: the container to reset",
+        None,
+    )
+
+    PlanCopyTextureToTextureVram = Symbol(
+        None,
+        None,
+        None,
+        "PlanCopyTextureToTextureVram",
+        "Add a command in the container (r1) that will be executed later by PerformPlannedTextureVramTransfer to copy part of the RAM into the texture VRAM (or free the source allocated memory depending of the specified type of command).\nCheck for overflow. If an overflow would occur, do not add the command to the container, and return -1 instead.\n\nr0: Container that contain the command list to add to\nr1: pointer to the bytes to be copied in CPU-accessible RAM\nr2: offset to copy too in texture VRAM\nr3: number of bytes to copy\nstack[0]: type of command to perform",
+        None,
+    )
+
+    PerformPlannedTextureVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "PerformPlannedTextureVramTransfer",
+        "Execute the texture VRAM edition command of the input container. Does not reset it, or alter its state in any way.\n\nr0: container that contains the command list to execute",
         None,
     )
 
@@ -11124,7 +11178,16 @@ class JpItcmFunctions:
         [0x20B4BE0],
         None,
         "CopyAndInterleave",
-        "Copies data from src to dst, placing the last 4 bits of val after every 4 bits copied.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nr0: [output] dst\nr1: src\nr2: len (in bytes)\nr3: val",
+        "Copies data from src to dst, interleaving the lower 4 bits of val with every 4 bits copied (if the copied bits are nonzero).\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary inputs (assuming little-endian byte order)\n  src[i] = {76543210 fedcba98}\n      {3210} != 0\n      {7654} != 0\n      {ba98} != 0\n      {fedc} != 0\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {vwxy7654 vwxy3210}\n  dst[2*i+1] = {vwxyfedc vwxyba98}\n\nIf any 4-bit nibble is 0, the corresponding byte written to dst is interleaved with 0 rather than the low bits of val. For example, if 'z' represents a 0 bit, given the inputs:\n  src[i] = {zzzz3210 fedczzzz}\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {zzzzzzzz vwxy3210}\n  dst[2*i+1] = {vwxyfedc zzzzzzzz}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)\nr3: val",
+        None,
+    )
+
+    CopyAndInterleave0 = Symbol(
+        None,
+        None,
+        None,
+        "CopyAndInterleave0",
+        "Equivalent to CopyAndInterleave with an interleaved value of 0.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary input (assuming little-endian byte order):\n  src[i] = {76543210 fedcba98}\nThen the output written to dst will be (where 'z' is a 0 bit):\n  dst[2*i] = {zzzz7654 zzzz3210}\n  dst[2*i+1] = {zzzzfedc zzzzba98}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)",
         None,
     )
 

pmdsky_debug_py/jp_itcm.py

@@ -740,7 +740,7 @@ class JpItcmArm9Functions:
         None,
         None,
         "TaskProcBoot",
-        "Probably related to booting the game?\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
+        "Boot the game and run the main loop. Use dynamic code dispatch to run code depending on the context (like dungeon mode, ground mode, menu mode, etc.).\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
         None,
     )
 
@@ -3651,6 +3651,24 @@ class JpItcmArm9Functions:
         None,
     )
 
+    ExecuteCopyToFlatVramCommand = Symbol(
+        None,
+        None,
+        None,
+        "ExecuteCopyToFlatVramCommand",
+        "Immediately execute the command contained in a copy_to_obj_vram_order struct, copying content as described.\n\nr0: command",
+        None,
+    )
+
+    DecodeFragmentByteAssemblyTable = Symbol(
+        None,
+        None,
+        None,
+        "DecodeFragmentByteAssemblyTable",
+        "Decode the sprite texture stored in each fragment byte assembly entry into the dst output, until the final one is reached.\n\nr0: pointer to array of fragment byte assembly entry, final (otherwise unused) one should have byte_amount = 0\nr1: dst\nreturn: number of decoded bytes",
+        None,
+    )
+
     CopyAndInterleaveWrapper = Symbol(
         None,
         None,
@@ -3908,7 +3926,43 @@ class JpItcmArm9Functions:
         None,
         None,
         "ProcessWte",
-        "Prepare a WTE data to be loaded into VRAM. Seems to need to be called with another undocumented function (at 0x0201e1d8 (EU))\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part\n\nThis may or may not be the function that adds to the queue so it can be added during VBlank.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        "Prepare and plan a WTE data to be loaded into VRAM.\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part.\nWill ensure it gets copied next time PerformPlannedTextureVramTransfer is called by the game.\nWill not automatically free the data once done. That can be done with DelayWteFree, which seems systematically called in the game’s code.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        None,
+    )
+
+    DelayWteFree = Symbol(
+        None,
+        None,
+        None,
+        "DelayWteFree",
+        "Add a command to free the input WTE handle once all previously registered commands that would edit the texture VRAM have been executed.\nAlso nullify the structure’s two pointers.\nThe error caused by the lack of place to store the command is ignored.\n\nr0: wte handle to eventually free",
+        None,
+    )
+
+    ResetPlannedVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "ResetPlannedVramTransfer",
+        "Reset the command array of input container\nDoes not reset its other field\n\nr0: the container to reset",
+        None,
+    )
+
+    PlanCopyTextureToTextureVram = Symbol(
+        None,
+        None,
+        None,
+        "PlanCopyTextureToTextureVram",
+        "Add a command in the container (r1) that will be executed later by PerformPlannedTextureVramTransfer to copy part of the RAM into the texture VRAM (or free the source allocated memory depending of the specified type of command).\nCheck for overflow. If an overflow would occur, do not add the command to the container, and return -1 instead.\n\nr0: Container that contain the command list to add to\nr1: pointer to the bytes to be copied in CPU-accessible RAM\nr2: offset to copy too in texture VRAM\nr3: number of bytes to copy\nstack[0]: type of command to perform",
+        None,
+    )
+
+    PerformPlannedTextureVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "PerformPlannedTextureVramTransfer",
+        "Execute the texture VRAM edition command of the input container. Does not reset it, or alter its state in any way.\n\nr0: container that contains the command list to execute",
         None,
     )
 
@@ -11063,7 +11117,16 @@ class JpItcmItcmFunctions:
         [0x1FF8000],
         None,
         "CopyAndInterleave",
-        "Copies data from src to dst, placing the last 4 bits of val after every 4 bits copied.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nr0: [output] dst\nr1: src\nr2: len (in bytes)\nr3: val",
+        "Copies data from src to dst, interleaving the lower 4 bits of val with every 4 bits copied (if the copied bits are nonzero).\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary inputs (assuming little-endian byte order)\n  src[i] = {76543210 fedcba98}\n      {3210} != 0\n      {7654} != 0\n      {ba98} != 0\n      {fedc} != 0\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {vwxy7654 vwxy3210}\n  dst[2*i+1] = {vwxyfedc vwxyba98}\n\nIf any 4-bit nibble is 0, the corresponding byte written to dst is interleaved with 0 rather than the low bits of val. For example, if 'z' represents a 0 bit, given the inputs:\n  src[i] = {zzzz3210 fedczzzz}\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {zzzzzzzz vwxy3210}\n  dst[2*i+1] = {vwxyfedc zzzzzzzz}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)\nr3: val",
+        None,
+    )
+
+    CopyAndInterleave0 = Symbol(
+        None,
+        None,
+        None,
+        "CopyAndInterleave0",
+        "Equivalent to CopyAndInterleave with an interleaved value of 0.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary input (assuming little-endian byte order):\n  src[i] = {76543210 fedcba98}\nThen the output written to dst will be (where 'z' is a 0 bit):\n  dst[2*i] = {zzzz7654 zzzz3210}\n  dst[2*i+1] = {zzzzfedc zzzzba98}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)",
         None,
     )
 

pmdsky_debug_py/na.py

@@ -752,7 +752,7 @@ class NaArm9Functions:
         [0x2003328],
         None,
         "TaskProcBoot",
-        "Probably related to booting the game?\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
+        "Boot the game and run the main loop. Use dynamic code dispatch to run code depending on the context (like dungeon mode, ground mode, menu mode, etc.).\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
         None,
     )
 
@@ -3697,6 +3697,24 @@ class NaArm9Functions:
         None,
     )
 
+    ExecuteCopyToFlatVramCommand = Symbol(
+        None,
+        None,
+        None,
+        "ExecuteCopyToFlatVramCommand",
+        "Immediately execute the command contained in a copy_to_obj_vram_order struct, copying content as described.\n\nr0: command",
+        None,
+    )
+
+    DecodeFragmentByteAssemblyTable = Symbol(
+        None,
+        None,
+        None,
+        "DecodeFragmentByteAssemblyTable",
+        "Decode the sprite texture stored in each fragment byte assembly entry into the dst output, until the final one is reached.\n\nr0: pointer to array of fragment byte assembly entry, final (otherwise unused) one should have byte_amount = 0\nr1: dst\nreturn: number of decoded bytes",
+        None,
+    )
+
     CopyAndInterleaveWrapper = Symbol(
         [0x1BFF0],
         [0x201BFF0],
@@ -3954,7 +3972,43 @@ class NaArm9Functions:
         [0x201E0B0],
         None,
         "ProcessWte",
-        "Prepare a WTE data to be loaded into VRAM. Seems to need to be called with another undocumented function (at 0x0201e1d8 (EU))\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part\n\nThis may or may not be the function that adds to the queue so it can be added during VBlank.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        "Prepare and plan a WTE data to be loaded into VRAM.\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part.\nWill ensure it gets copied next time PerformPlannedTextureVramTransfer is called by the game.\nWill not automatically free the data once done. That can be done with DelayWteFree, which seems systematically called in the game’s code.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        None,
+    )
+
+    DelayWteFree = Symbol(
+        [0x1E13C],
+        [0x201E13C],
+        None,
+        "DelayWteFree",
+        "Add a command to free the input WTE handle once all previously registered commands that would edit the texture VRAM have been executed.\nAlso nullify the structure’s two pointers.\nThe error caused by the lack of place to store the command is ignored.\n\nr0: wte handle to eventually free",
+        None,
+    )
+
+    ResetPlannedVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "ResetPlannedVramTransfer",
+        "Reset the command array of input container\nDoes not reset its other field\n\nr0: the container to reset",
+        None,
+    )
+
+    PlanCopyTextureToTextureVram = Symbol(
+        None,
+        None,
+        None,
+        "PlanCopyTextureToTextureVram",
+        "Add a command in the container (r1) that will be executed later by PerformPlannedTextureVramTransfer to copy part of the RAM into the texture VRAM (or free the source allocated memory depending of the specified type of command).\nCheck for overflow. If an overflow would occur, do not add the command to the container, and return -1 instead.\n\nr0: Container that contain the command list to add to\nr1: pointer to the bytes to be copied in CPU-accessible RAM\nr2: offset to copy too in texture VRAM\nr3: number of bytes to copy\nstack[0]: type of command to perform",
+        None,
+    )
+
+    PerformPlannedTextureVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "PerformPlannedTextureVramTransfer",
+        "Execute the texture VRAM edition command of the input container. Does not reset it, or alter its state in any way.\n\nr0: container that contains the command list to execute",
         None,
     )
 
@@ -11129,7 +11183,16 @@ class NaItcmFunctions:
         [0x20B3380],
         None,
         "CopyAndInterleave",
-        "Copies data from src to dst, placing the last 4 bits of val after every 4 bits copied.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nr0: [output] dst\nr1: src\nr2: len (in bytes)\nr3: val",
+        "Copies data from src to dst, interleaving the lower 4 bits of val with every 4 bits copied (if the copied bits are nonzero).\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary inputs (assuming little-endian byte order)\n  src[i] = {76543210 fedcba98}\n      {3210} != 0\n      {7654} != 0\n      {ba98} != 0\n      {fedc} != 0\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {vwxy7654 vwxy3210}\n  dst[2*i+1] = {vwxyfedc vwxyba98}\n\nIf any 4-bit nibble is 0, the corresponding byte written to dst is interleaved with 0 rather than the low bits of val. For example, if 'z' represents a 0 bit, given the inputs:\n  src[i] = {zzzz3210 fedczzzz}\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {zzzzzzzz vwxy3210}\n  dst[2*i+1] = {vwxyfedc zzzzzzzz}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)\nr3: val",
+        None,
+    )
+
+    CopyAndInterleave0 = Symbol(
+        [0xB0],
+        [0x20B3430],
+        None,
+        "CopyAndInterleave0",
+        "Equivalent to CopyAndInterleave with an interleaved value of 0.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary input (assuming little-endian byte order):\n  src[i] = {76543210 fedcba98}\nThen the output written to dst will be (where 'z' is a 0 bit):\n  dst[2*i] = {zzzz7654 zzzz3210}\n  dst[2*i+1] = {zzzzfedc zzzzba98}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)",
         None,
     )
 

pmdsky_debug_py/na_itcm.py

@@ -740,7 +740,7 @@ class NaItcmArm9Functions:
         None,
         None,
         "TaskProcBoot",
-        "Probably related to booting the game?\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
+        "Boot the game and run the main loop. Use dynamic code dispatch to run code depending on the context (like dungeon mode, ground mode, menu mode, etc.).\n\nThis function prints the debug message 'task proc boot'.\n\nNo params.",
         None,
     )
 
@@ -3651,6 +3651,24 @@ class NaItcmArm9Functions:
         None,
     )
 
+    ExecuteCopyToFlatVramCommand = Symbol(
+        None,
+        None,
+        None,
+        "ExecuteCopyToFlatVramCommand",
+        "Immediately execute the command contained in a copy_to_obj_vram_order struct, copying content as described.\n\nr0: command",
+        None,
+    )
+
+    DecodeFragmentByteAssemblyTable = Symbol(
+        None,
+        None,
+        None,
+        "DecodeFragmentByteAssemblyTable",
+        "Decode the sprite texture stored in each fragment byte assembly entry into the dst output, until the final one is reached.\n\nr0: pointer to array of fragment byte assembly entry, final (otherwise unused) one should have byte_amount = 0\nr1: dst\nreturn: number of decoded bytes",
+        None,
+    )
+
     CopyAndInterleaveWrapper = Symbol(
         None,
         None,
@@ -3908,7 +3926,43 @@ class NaItcmArm9Functions:
         None,
         None,
         "ProcessWte",
-        "Prepare a WTE data to be loaded into VRAM. Seems to need to be called with another undocumented function (at 0x0201e1d8 (EU))\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part\n\nThis may or may not be the function that adds to the queue so it can be added during VBlank.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        "Prepare and plan a WTE data to be loaded into VRAM.\nIt skips the texture and/or the palette if missing from the file. The texture VRAM has 128KiB of space, and palette has 16KiB.\nThe true palette VRAM offset will be upper_part*0x100+lower_part.\nWill ensure it gets copied next time PerformPlannedTextureVramTransfer is called by the game.\nWill not automatically free the data once done. That can be done with DelayWteFree, which seems systematically called in the game’s code.\n\nr0: pointer to the WTE file header loaded in memory\nr1: where the WTE texture will be loaded in the VRAM (from 0 to 0x1FFFF)\nr2: upper part of the palette VRAM\nr3: lower part of the palette VRAM",
+        None,
+    )
+
+    DelayWteFree = Symbol(
+        None,
+        None,
+        None,
+        "DelayWteFree",
+        "Add a command to free the input WTE handle once all previously registered commands that would edit the texture VRAM have been executed.\nAlso nullify the structure’s two pointers.\nThe error caused by the lack of place to store the command is ignored.\n\nr0: wte handle to eventually free",
+        None,
+    )
+
+    ResetPlannedVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "ResetPlannedVramTransfer",
+        "Reset the command array of input container\nDoes not reset its other field\n\nr0: the container to reset",
+        None,
+    )
+
+    PlanCopyTextureToTextureVram = Symbol(
+        None,
+        None,
+        None,
+        "PlanCopyTextureToTextureVram",
+        "Add a command in the container (r1) that will be executed later by PerformPlannedTextureVramTransfer to copy part of the RAM into the texture VRAM (or free the source allocated memory depending of the specified type of command).\nCheck for overflow. If an overflow would occur, do not add the command to the container, and return -1 instead.\n\nr0: Container that contain the command list to add to\nr1: pointer to the bytes to be copied in CPU-accessible RAM\nr2: offset to copy too in texture VRAM\nr3: number of bytes to copy\nstack[0]: type of command to perform",
+        None,
+    )
+
+    PerformPlannedTextureVramTransfer = Symbol(
+        None,
+        None,
+        None,
+        "PerformPlannedTextureVramTransfer",
+        "Execute the texture VRAM edition command of the input container. Does not reset it, or alter its state in any way.\n\nr0: container that contains the command list to execute",
         None,
     )
 
@@ -11063,7 +11117,16 @@ class NaItcmItcmFunctions:
         [0x1FF8000],
         None,
         "CopyAndInterleave",
-        "Copies data from src to dst, placing the last 4 bits of val after every 4 bits copied.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nr0: [output] dst\nr1: src\nr2: len (in bytes)\nr3: val",
+        "Copies data from src to dst, interleaving the lower 4 bits of val with every 4 bits copied (if the copied bits are nonzero).\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary inputs (assuming little-endian byte order)\n  src[i] = {76543210 fedcba98}\n      {3210} != 0\n      {7654} != 0\n      {ba98} != 0\n      {fedc} != 0\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {vwxy7654 vwxy3210}\n  dst[2*i+1] = {vwxyfedc vwxyba98}\n\nIf any 4-bit nibble is 0, the corresponding byte written to dst is interleaved with 0 rather than the low bits of val. For example, if 'z' represents a 0 bit, given the inputs:\n  src[i] = {zzzz3210 fedczzzz}\n  val & 0xF = {vwxy}\nThe output written to dst will be:\n  dst[2*i] = {zzzzzzzz vwxy3210}\n  dst[2*i+1] = {vwxyfedc zzzzzzzz}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)\nr3: val",
+        None,
+    )
+
+    CopyAndInterleave0 = Symbol(
+        [0xB0],
+        [0x1FF80B0],
+        None,
+        "CopyAndInterleave0",
+        "Equivalent to CopyAndInterleave with an interleaved value of 0.\n\nIn total, the number of bytes copied from src will be len, while the number of bytes pasted will be 2 * len.\n\nFor example, for arbitrary input (assuming little-endian byte order):\n  src[i] = {76543210 fedcba98}\nThen the output written to dst will be (where 'z' is a 0 bit):\n  dst[2*i] = {zzzz7654 zzzz3210}\n  dst[2*i+1] = {zzzzfedc zzzzba98}\n\nr0: [output] dst (2 * len bytes long)\nr1: src (len bytes long)\nr2: len (in bytes, must be even)",
         None,
     )
 

pmdsky_debug_py/protocol.py

@@ -2097,6 +2097,16 @@ class Arm9FunctionsProtocol(Protocol):
         None,
     ]
 
+    ExecuteCopyToFlatVramCommand: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
+    DecodeFragmentByteAssemblyTable: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
     CopyAndInterleaveWrapper: Symbol[
         Optional[list[int]],
         None,
@@ -2242,6 +2252,26 @@ class Arm9FunctionsProtocol(Protocol):
         None,
     ]
 
+    DelayWteFree: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
+    ResetPlannedVramTransfer: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
+    PlanCopyTextureToTextureVram: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
+    PerformPlannedTextureVramTransfer: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
     GeomSetTexImageParam: Symbol[
         Optional[list[int]],
         None,
@@ -6250,6 +6280,11 @@ class ItcmFunctionsProtocol(Protocol):
         None,
     ]
 
+    CopyAndInterleave0: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
     Render3dSetTextureParams: Symbol[
         list[int],
         None,

{pmdsky_debug_py-10.1.4.dist-info → pmdsky_debug_py-10.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmdsky-debug-py
-Version: 10.1.4
+Version: 10.1.5
 Summary: pmdsky-debug symbols for Python.
 Author-email: Marco 'Capypara' Köpcke <hello@capypara.de>
 License: MIT

pmdsky_debug_py-10.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+pmdsky_debug_py/__init__.py,sha256=xvXjdxEqeoQaaS6ssZYVI9jARzv5M4q6FNwA3Z6fOw4,1831
+pmdsky_debug_py/_release.py,sha256=jRl9pnNwkd9oLfrNEUZV7-GN7yZRlyDtJaxjaUrrMIk,31
+pmdsky_debug_py/eu.py,sha256=hCMUJ1FL9vEbxdzfaXMLysFNYrTzBNWq3u47XAS2RHI,1162179
+pmdsky_debug_py/eu_itcm.py,sha256=ZPvjx_favgv6i1kCkNi5eEH10GuAuzTFewgBkei7ROg,1110278
+pmdsky_debug_py/jp.py,sha256=BMgxmZLrlNMQRvB-gyPj8P0nB-80h3QOKrY69b9Qbrs,1158816
+pmdsky_debug_py/jp_itcm.py,sha256=xhgxaiegl6rfg2Wy2xaMZ1NmzltVat0nFMS2-tiaVoo,1110259
+pmdsky_debug_py/na.py,sha256=G9C3TnglAN4CA2RLeVYJVp3ErB5pcnm4xYg8O8YXGKk,1163076
+pmdsky_debug_py/na_itcm.py,sha256=MbvV7wKufIczStsR4zb8b0scV9wij15wu9djPJC3azI,1110278
+pmdsky_debug_py/protocol.py,sha256=6DjeIGarTz7BPv-fM_bOk8NRBJe4KA237mGs4vXAcds,340468
+pmdsky_debug_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pmdsky_debug_py-10.1.5.dist-info/METADATA,sha256=G9iY_-qHwaP9N1GaGQOOwKB2cqm92iR737Z3InyPyyg,1375
+pmdsky_debug_py-10.1.5.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+pmdsky_debug_py-10.1.5.dist-info/top_level.txt,sha256=cqvpcJbud2s8IyBAc1MfCySwniko_6qO5LWSSxNIoXI,16
+pmdsky_debug_py-10.1.5.dist-info/RECORD,,

{pmdsky_debug_py-10.1.4.dist-info → pmdsky_debug_py-10.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pmdsky_debug_py-10.1.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-pmdsky_debug_py/__init__.py,sha256=xvXjdxEqeoQaaS6ssZYVI9jARzv5M4q6FNwA3Z6fOw4,1831
-pmdsky_debug_py/_release.py,sha256=8F2h9CgfGZVKysY57dtrggdbfbpRIMmOpXsAt3WQjYc,31
-pmdsky_debug_py/eu.py,sha256=1AaBIVyZAK01U_mv9W4h4VojJf-WLlV05BOUTcRpCPY,1158069
-pmdsky_debug_py/eu_itcm.py,sha256=f2zloY1eLDwIAMivQPh_JQ3yzk7NsulsyGkagwCwyvw,1106240
-pmdsky_debug_py/jp.py,sha256=i30i-j2epjOZpPNyEj7tZUzzFR1ObwFGlKC66K0D3bg,1154787
-pmdsky_debug_py/jp_itcm.py,sha256=TrUvu0pGdx8OhVEzCHkNRLiWt3NXY1_cqfKmzvnlevY,1106230
-pmdsky_debug_py/na.py,sha256=GeqnC2A_QRGQWnX7qEWKU6F0NwAoPcK6997ukcB-44Y,1159026
-pmdsky_debug_py/na_itcm.py,sha256=deHgpgNFg7hDweGl1TyIN0jVDoF_OWDW0UwLg4ZEHQk,1106240
-pmdsky_debug_py/protocol.py,sha256=BPehfaS9gfefIHvKCfqBpRn6Epvj-srg-igmVIFAAm8,339846
-pmdsky_debug_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pmdsky_debug_py-10.1.4.dist-info/METADATA,sha256=bl2WgcEW5v_h15pfaku67wU0Ym-1-qrAwk1NK1yADBk,1375
-pmdsky_debug_py-10.1.4.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
-pmdsky_debug_py-10.1.4.dist-info/top_level.txt,sha256=cqvpcJbud2s8IyBAc1MfCySwniko_6qO5LWSSxNIoXI,16
-pmdsky_debug_py-10.1.4.dist-info/RECORD,,