What are some things you would like to see in Dolphin 6.0?

[gamemasterplc]

Allow Searching of non MEM1 areas through cheat search. Gecko Codes would need to be created instead of AR Codes if the memory address is not within MEM1. Searching of MEM2 would also need to be deactivated for GameCube Games.

[masterotaku]

It's a pity that I can't make this work with Dolphin's 3D Vision mode (sky depth):

Spoiler: (Show Spoiler)

In 3D Vision Automatic mode (3D disabled in Dolphin), there are problems with the "StereoCutoff" setting in the Nvidia Profile Inspector. If I change that setting to 0x00000000, the HUD and other things are affected by convergence and separation but geometry is fixed. With the default setting, some geometry near the camera is affected and not rendering at the correct depth.

I can manually fix the HUD, sky, etc shaders that are badly affected by disabling "StereoCutoff", but it takes more time than the ideal solution of using Dophin's 3D Vision mode + just the sky shader modification.

For example, the sky vertex shader

Spoiler: (Show Spoiler)

Code:

//Sky mario 64.
// ---- Created with 3Dmigoto v1.2.43 on Sat Aug 27 12:01:05 2016

cbuffer VSBlock : register(b0)
{
  float4 cproj[4] : packoffset(c0);
  float4 cDepth : packoffset(c4);
  float4 cmtrl[4] : packoffset(c5);
  float4 clights[40] : packoffset(c9);
  float4 cphong[2] : packoffset(c49);
  float4 ctexmtx[24] : packoffset(c51);
  float4 ctrmtx[64] : packoffset(c75);
  float4 cnmtx[32] : packoffset(c139);
  float4 cpostmtx[64] : packoffset(c171);
  float4 cPLOffset[13] : packoffset(c235);
}



// 3Dmigoto declarations
#define cmp -
Texture1D<float4> IniParams : register(t120);
Texture2D<float4> StereoParams : register(t125);


void main(
  float4 v0 : COLOR0,
  float2 v1 : TEXCOORD0,
  float4 v2 : BLENDINDICES0,
  float4 v3 : POSITION0,
  out float4 o0 : SV_Position0,
  out float4 o1 : COLOR0,
  out float4 o2 : COLOR1,
  out float4 o3 : TEXCOORD0,
  out float4 o4 : TEXCOORD1)
{
  float4 r0,r1;
  uint4 bitmask, uiDest;
  float4 fDest;

  float4 stereo = StereoParams.Load(0);
  
  r0.x = 255 * v2.x;
  r0.x = round(r0.x);
  r0.x = (int)r0.x;
  r0.yz = (int2)r0.xx + int2(1,2);
  r1.x = dot(ctrmtx[r0.x].xyzw, v3.xyzw);
  r1.z = dot(ctrmtx[r0.z].xyzw, v3.xyzw);
  r1.y = dot(ctrmtx[r0.y].xyzw, v3.xyzw);
  r1.w = 1;
  r0.x = dot(cproj[0].xyzw, r1.xyzw);
  //r0.x+=stereo.x;
  r0.x-=stereo.x*(dot(cproj[2].xyzw, r1.xyzw)-stereo.y+0.35);
  r0.y = dot(cproj[1].xyzw, r1.xyzw);
  r0.z = dot(cproj[3].xyzw, r1.xyzw);
  r0.w = dot(cproj[2].xyzw, r1.xyzw);
  o4.xy = r1.xy;
  o0.xy = r0.zz * cDepth.zw + r0.xy;
  
  r0.x = cDepth.y * r0.w;
  r0.y = -1 + cDepth.x;
  r0.x = r0.y * r0.z + r0.x;
  o0.z = -r0.x;
  o0.w = r0.z;
  
  o4.zw = r0.wz;
  
  r0.xyzw = float4(255,255,255,255) * v0.xyzw;
  r0.xyzw = round(r0.xyzw);
  r0.xyzw = (int4)r0.xyzw;
  r0.xyzw = (int4(24,24,24,24) == 0 ? 0 : (int4(24,24,24,24) + int4(0,0,0,0) < 32 ? (((int4)r0.xyzw << (32 - int4(24,24,24,24) - int4(0,0,0,0))) >> (32 - int4(24,24,24,24))) : ((int4)r0.xyzw >> int4(0,0,0,0))));
  r0.xyzw = (int4)r0.xyzw;
  r0.xyzw = float4(0.00392156886,0.00392156886,0.00392156886,0.00392156886) * r0.xyzw;
  o1.xyzw = r0.xyzw;
  o2.xyzw = r0.xyzw;
  r0.xy = v1.xy;
  r0.zw = float2(1,1);
  r1.x = dot(r0.xyww, ctexmtx[0].xyzw);
  r1.y = dot(r0.xyzw, ctexmtx[1].xyzw);
  r1.z = 1;
  r0.x = dot(cpostmtx[61].xyz, r1.xyz);
  r0.x = cpostmtx[61].w + r0.x;
  r0.z = dot(cpostmtx[62].xyz, r1.xyz);
  r0.w = dot(cpostmtx[63].xyz, r1.xyz);
  r0.w = cpostmtx[63].w + r0.w;
  r0.y = cpostmtx[62].w + r0.z;
  r1.xy = float2(0.5,0.5) * r0.xy;
  r1.xy = max(float2(-1,-1), r1.xy);
  r1.xy = min(float2(1,1), r1.xy);
  r0.z = cmp(r0.w == 0.000000);
  o3.z = r0.w;
  o3.xy = r0.zz ? r1.xy : r0.xy;
  
  return;
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111
//
//   using 3Dmigoto v1.2.43 on Sat Aug 27 12:01:05 2016
//
//
// Buffer Definitions:
//
// cbuffer VSBlock
// {
//
//   float4 cproj[4];                   // Offset:    0 Size:    64
//   float4 cDepth;                     // Offset:   64 Size:    16
//   float4 cmtrl[4];                   // Offset:   80 Size:    64 [unused]
//   float4 clights[40];                // Offset:  144 Size:   640 [unused]
//   float4 cphong[2];                  // Offset:  784 Size:    32 [unused]
//   float4 ctexmtx[24];                // Offset:  816 Size:   384
//   float4 ctrmtx[64];                 // Offset: 1200 Size:  1024
//   float4 cnmtx[32];                  // Offset: 2224 Size:   512 [unused]
//   float4 cpostmtx[64];               // Offset: 2736 Size:  1024
//   float4 cPLOffset[13];              // Offset: 3760 Size:   208 [unused]
//
// }
//
//
// Resource Bindings:
//
// Name                                 Type  Format         Dim Slot Elements
// ------------------------------ ---------- ------- ----------- ---- --------
// VSBlock                           cbuffer      NA          NA    0        1
//
//
//
// Input signature:
//
// Name                 Index   Mask Register SysValue  Format   Used
// -------------------- ----- ------ -------- -------- ------- ------
// COLOR                    0   xyzw        0     NONE   float   xyzw
// TEXCOORD                 0   xy          1     NONE   float   xy  
// BLENDINDICES             0   xyzw        2     NONE   float   x  
// POSITION                 0   xyzw        3     NONE   float   xyzw
//
//
// Output signature:
//
// Name                 Index   Mask Register SysValue  Format   Used
// -------------------- ----- ------ -------- -------- ------- ------
// SV_Position              0   xyzw        0      POS   float   xyzw
// COLOR                    0   xyzw        1     NONE   float   xyzw
// COLOR                    1   xyzw        2     NONE   float   xyzw
// TEXCOORD                 0   xyz         3     NONE   float   xyz
// TEXCOORD                 1   xyzw        4     NONE   float   xyzw
//
vs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[235], dynamicIndexed
dcl_input v0.xyzw
dcl_input v1.xy
dcl_input v2.x
dcl_input v3.xyzw
dcl_output_siv o0.xyzw, position
dcl_output o1.xyzw
dcl_output o2.xyzw
dcl_output o3.xyz
dcl_output o4.xyzw
dcl_temps 2
mul r0.x, v2.x, l(255.000000)
round_ne r0.x, r0.x
ftoi r0.x, r0.x
iadd r0.yz, r0.xxxx, l(0, 1, 2, 0)
dp4 r1.x, cb0[r0.x + 75].xyzw, v3.xyzw
dp4 r1.z, cb0[r0.z + 75].xyzw, v3.xyzw
dp4 r1.y, cb0[r0.y + 75].xyzw, v3.xyzw
mov r1.w, l(1.000000)
dp4 r0.x, cb0[0].xyzw, r1.xyzw
dp4 r0.y, cb0[1].xyzw, r1.xyzw
dp4 r0.z, cb0[3].xyzw, r1.xyzw
dp4 r0.w, cb0[2].xyzw, r1.xyzw
mov o4.xy, r1.xyxx
mad o0.xy, r0.zzzz, cb0[4].zwzz, r0.xyxx
mul r0.x, r0.w, cb0[4].y
add r0.y, cb0[4].x, l(-1.000000)
mad r0.x, r0.y, r0.z, r0.x
mov o0.z, -r0.x
mov o0.w, r0.z
mov o4.zw, r0.wwwz
mul r0.xyzw, v0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000)
round_ne r0.xyzw, r0.xyzw
ftoi r0.xyzw, r0.xyzw
ibfe r0.xyzw, l(24, 24, 24, 24), l(0, 0, 0, 0), r0.xyzw
itof r0.xyzw, r0.xyzw
mul r0.xyzw, r0.xyzw, l(0.00392156886, 0.00392156886, 0.00392156886, 0.00392156886)
mov o1.xyzw, r0.xyzw
mov o2.xyzw, r0.xyzw
mov r0.xy, v1.xyxx
mov r0.zw, l(0,0,1.000000,1.000000)
dp4 r1.x, r0.xyww, cb0[51].xyzw
dp4 r1.y, r0.xyzw, cb0[52].xyzw
mov r1.z, l(1.000000)
dp3 r0.x, cb0[232].xyzx, r1.xyzx
add r0.x, r0.x, cb0[232].w
dp3 r0.z, cb0[233].xyzx, r1.xyzx
dp3 r0.w, cb0[234].xyzx, r1.xyzx
add r0.w, r0.w, cb0[234].w
add r0.y, r0.z, cb0[233].w
mul r1.xy, r0.xyxx, l(0.500000, 0.500000, 0.000000, 0.000000)
max r1.xy, r1.xyxx, l(-1.000000, -1.000000, 0.000000, 0.000000)
min r1.xy, r1.xyxx, l(1.000000, 1.000000, 0.000000, 0.000000)
eq r0.z, r0.w, l(0.000000)
mov o3.z, r0.w
movc o3.xy, r0.zzzz, r1.xyxx, r0.xyxx
ret
// Approximately 46 instruction slots used

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

requires

Code:

r0.x-=stereo.x*(dot(cproj[2].xyzw, r1.xyzw)-stereo.y+0.35);

, which corrects the very high effect of convergence, instead of just

Code:

r0.x+=stereo.x;

, which just makes it go from screen depth to 100% depth.

In both cases, for this game I have to assign that vertex shader fix to just one pixel shader (or a small selection). N64 games shader vertex shaders for too many effects and geometry.

[gamemasterplc]

The sky in Super Mario 64 is drawn with Orthographic Projection.

[masterotaku]

(08-27-2016, 10:10 PM)gamemasterplc Wrote: The sky in Super Mario 64 is drawn with Orthographic Projection.

Still, it's possible to put it at depth. I've been fixing the HUD and other things for an hour successfully. I think it's done. I needed to make different fixing formulas in the vertex shaders to different pixel shaders, using shader overrides in the d3dx.ini. All is working perfectly except for the life and oxygen bar and that Mario icon at the start of the levels (they share the pixel shader with trees, which render correctly, so I can't modify this shader). I think I would be able to release fixes like this, with correct geometry and HUD. The problem is the shader filenames, that can change with graphics settings, builds, etc. But for something to use at just myself (or telling other people to use certain builds and settings, and what to change in the Nvidia profile), it's good enough.

[retroben]

Thank you all for your thoughts,I can name two big issues/limitations with Cheat Engine in my experience struggling to use it efficiently.

1. Byte endian order is frustratingly the opposite ordering,making 3F 80 00 00 look like 00 00 80 3F and require searching in that order,this kept scrambling my brain on my previous attempts to use it for searching.

2. Locations change drastically on each boot session for many exe programs,making things really complicated having to search for a common value in order to figure out the new location on each session.

(Despite those,I found some cool codes for Sonic Heroes on PC a long while back,such as freezing time for specific elements and several stats/physics/action mods,too bad Sonic Retro noped my wiki edits adding them in even though they actually work.)

As I already mentioned for the in-built Dolphin memory debugger,its really unstable with the frequent risks of crashing and random errors from how it constantly refreshes the memory if you try to scroll down or sometimes even when typing to a specific location in search.
A simple fix for this alone is to stop the frequent refreshing and add a button to press for it to be refreshed manually.
Also,only refresh the bytes that are changed,as it very clearly stands out that the entire memory refreshes rather than just the modified bytes,this most likely is the leading cause of the instability/errors/crashes and lost value results when using it.
Many times I find that some of the values of addresses go missing with hyphens indicating a blank value result instead of the actual value.

Hopefully these extra details that I forgot to mention and outright didn't think of earlier will help in fixing those problems.

Summary: Please make memory refreshing manual via a button on the UI,and make it only refresh the modified bytes instead of everything.

[Aleron Ives]

@retroben

Do you have a recent Dolphin build with full debugger functionality enabled? I've been told that you can't set memory breakpoints in the regular builds and have to compile Dolphin with a special option to enable breakpoints.

[retroben]

I found a page that says its called DebugFast,but I am currently on a slightly old Vulkan pr build because Vulkan crashes less to my experience at least on Android,having this on Ishiiruka would be great,but not much I can do about the Nvidia driver 372.54 flickering issues,Wind Waker runs okay for the most part.
I used the command to enable the debugger via a shortcut trick so I can quickly access either one.

I wouldn't have much or any benefit with breakpoints unless I knew how to do that kind of stuff,I only know the basic searching trial and error and some scooped up knowledge over time.
I don't think it would need it for the potential 60fps code I want to find,as that's mainly for ASM and pointer location codes while the byte that controls fps should be a static address.
If the searching wasn't so complicated,I could maybe try to find a single object's value and figure out how to find a certain object/NPC that I am looking for.

[djneo]

Guys, do you think there could be code that would control/improve LOD?

[retroben]

What's an example of LOD working poorly?
I saw it working pretty well in a games repainted stream video switching between different repainted textures by distance.

Another thought on memory search (attempts for 60fps codes,TP idling video hits 60fps),Desmume has a really technologically impressive RAM search that is shared by a Genesis emulator as well with the entire memory updating in realtime causing slowdown but allowing you to search for if the number of changes is less than 2 to clear out the frequently changing ones and then hitting clear change count and searching for greater than 0 once you reach what you know changes to remove tons more results and then searching for values in the remaining ones with less than 03 to end up with addresses at 00-02 as values,and after all of that,you can browse the entirety of results that are left to deduce what addresses you are looking for and weeding out remaining stragglers above 02 or changing values when the fps hasn't changed yet.
I know that it would run several times worse with up to a whopping 128MB RAM vs. NDS' tiny 4MB RAM but it can be helped by pausing emulation when the RAM search window is in focus.

How did AdderDee find that multiple-lined 60fps code for Sonic Colors though with such limitations,did he happen to use cheat engine despite reversed endian byte order?

The main thing to help for finding new cheats on Dolphin would be having a better fully fledged memory viewer in a seperate window to avoid those instabilities of having it attached to the main one and being displayed vertically,instead displaying it with 16 bytes horizontally x 16 rows vertically with a manual refresh button that colors changed bytes red much like what PJ64's memory viewer does.
(I already had a few more searches ruined by random hanging with errors crashing it between window focus switching)
I could get a better look at where the asm starts and mess around with various things until finding amazing visual corruptions and other really fun and interesting things,the only downside being that Gamecube ASM is pretty different from N64 MIPS and unfamiliar to me currently.

[Kratzy974]

Something completly different: I would like to see a per game controller setting.
I prefer keyboard / mouse control in some games, and wiimote in other games. There are already presets useable, I would like to see them as setting value in game settings.

Changing the visible title of the game in the gui. Right now I need to step into titles.txt everytime I don't like the name of a game. i.e. the names of the Guitar Hero fanchise are different from game to game (GH or Guitar Hero).

As already written: A gui interface for all / most of the config settings, which are to be set in a text file right now. Maybe even an external config edit app.

Some kind of benchmark tool, with various situations to get a hint, which part of the computer is too slow. But this is more of a difficult part, cause this need to be done as gc / wii software with all of the dirty tricks working on the gc / wii.