[UNOFFICIAL] Ishiiruka-Dolphin Custom Version

**Tino** · 05-14-2015, 06:53 AM **#2,241**

will take a look at the issues thannks for the report.

**Tino** · 05-17-2015, 12:14 AM **#2,242**

updated the latest folder with a new version. Added support for partial constant buffer updated in dx11 (dx11.1 and windows 8 only). Added Matsodof port, @ZeldaGamer23 will be really happy with this one.

rlaugh0095 · 05-17-2015, 12:47 AM **#2,243**

(05-17-2015, 12:14 AM)Tino Wrote: updated the latest folder with a new version. Added support for partial constant buffer updated in dx11 (dx11.1 and windows 8 only). Added Matsodof port, @ZeldaGamer23 will be really happy with this one.

Im reallly happy with it too. Notice me senpai! <3 :3

**Tino** · 05-17-2015, 12:48 AM **#2,244**

Good to know. Enjoy

Panchito · 05-17-2015, 01:12 AM **#2,245**

I'm getting some sort of geometry flickering in revision 360, check Luigi's mouth:

[Image: fbbasy.jpg]

I'm not using any post processing effect on that picture. This didn't happen in 357 and I'm not sure if other games are affected, haven't had the time to check more. And here is how MatsoDOF looks on Starfox Assault:

[Image: 2a76c6d.jpg]

That didn't happen on Luigi's Mansion, at least not so bad, in the intro it loses focus a lot but inside the mansion seems to be working fine, no noticeable dof effects though.

ZeldaGamer23 · 05-17-2015, 04:10 AM **#2,246**

This is amazing work! Currently trying to get SSAO with MATSO.

Here's my modification. Any help will be appreciated.

Code:

// Simple SSAO

/*

[configuration]

[OptionRangeInteger]

GUIName = SSAO Mode

OptionName = A_SSAO_MODE

MinValue = 0

MaxValue = 2

StepAmount = 1

DefaultValue = 1

[OptionRangeInteger]

GUIName = SSAO Quality

OptionName = B_SSAO_SAMPLES

MinValue = 16

MaxValue = 64

StepAmount = 4

DefaultValue = 16

DependentOption = A_SSAO_MODE

[OptionRangeFloat]

GUIName = Sample Range

OptionName = C_SAMPLE_RANGE

MinValue = 0.001

MaxValue = 0.04

StepAmount = 0.0001

DefaultValue = 0.01

DependentOption = A_SSAO_MODE

[OptionRangeFloat]

GUIName = Filter Limit

OptionName = D_FILTER_LIMIT

MinValue = 0.001

MaxValue = 0.01

StepAmount = 0.0001

DefaultValue = 0.002

DependentOption = A_SSAO_MODE

[OptionRangeFloat]

GUIName = Max Depth

OptionName = E_MAX_DEPTH

MinValue = 0.0001

MaxValue = 0.02

StepAmount = 0.0001

DefaultValue = 0.015

DependentOption = A_SSAO_MODE

[OptionRangeFloat]

GUIName = Min Depth

OptionName = F_MIN_DEPTH

MinValue = 0.0

MaxValue = 0.02

StepAmount = 0.0001

DefaultValue = 0.0002

DependentOption = A_SSAO_MODE

[OptionBool]

GUIName = MATSO DOF

OptionName = MATSODOF

DefaultValue = false

[OptionRangeFloat]

GUIName = Focus Point

OptionName = DOF_FOCUSPOINT

MinValue = 0.0, 0.0

MaxValue = 1.0, 1.0

DefaultValue = 0.5, 0.5

StepAmount = 0.01, 0.01

DependentOption = MATSODOF

[OptionRangeFloat]

GUIName = Near Blue Curve

OptionName = DOF_NEARBLURCURVE

MinValue = 0.4

MaxValue = 2.0

DefaultValue = 0.7

StepAmount = 0.01

DependentOption = MATSODOF

[OptionRangeFloat]

GUIName = FarBlue Curve

OptionName = DOF_FARBLURCURVE

MinValue = 0.4

MaxValue = 2.0

DefaultValue = 1.5

StepAmount = 0.01

DependentOption = MATSODOF

[OptionRangeFloat]

GUIName = Blur Radius

OptionName = DOF_BLURRADIUS

MinValue = 5.0

MaxValue = 50.0

DefaultValue = 5.0

StepAmount = 1.0

DependentOption = MATSODOF

[OptionRangeInteger]

GUIName = Vignette

OptionName = DOF_VIGNETTE

MinValue = 0

MaxValue = 1000

DefaultValue = 400

StepAmount = 10

DependentOption = MATSODOF

[OptionBool]

GUIName = CROMA Enable

OptionName = bMatsoDOFChromaEnable

DefaultValue = True

DependentOption = MATSODOF

[OptionRangeFloat]

GUIName = Chroma Pow

OptionName = fMatsoDOFChromaPow

MinValue = 0.2

MaxValue = 3.0

DefaultValue = 1.4

StepAmount = 0.01

DependentOption = MATSODOF

[OptionRangeFloat]

GUIName = Bokeh Curve

OptionName = fMatsoDOFBokehCurve

MinValue = 0.5

MaxValue = 20.0

DefaultValue = 8.0

StepAmount = 0.01

DependentOption = MATSODOF

[OptionRangeFloat]

GUIName = Bokeh Light

OptionName = fMatsoDOFBokehLight

MinValue = 0.0

MaxValue = 2.0

DefaultValue = 0.012

StepAmount = 0.001

DependentOption = MATSODOF

[OptionRangeInteger]

GUIName = Bokeh Quality

OptionName = iMatsoDOFBokehQuality

MinValue = 1

MaxValue = 10

DefaultValue = 4

StepAmount = 1

DependentOption = MATSODOF

[OptionRangeInteger]

GUIName = Bokeh Angle

OptionName = fMatsoDOFBokehAngle

MinValue = 0

MaxValue = 360

DefaultValue = 0

StepAmount = 1

DependentOption = MATSODOF

[Stage]

EntryPoint = SSAO

[Stage]

EntryPoint = BlurH

[Stage]

EntryPoint = Merger

[Stage]

EntryPoint = DOF

[Stage]

EntryPoint = PS_DOF_MatsoDOF1

[Stage]

EntryPoint = PS_DOF_MatsoDOF2

[Stage]

EntryPoint = PS_DOF_MatsoDOF3

[Stage]

EntryPoint = PS_DOF_MatsoDOF4

[/configuration]

*/

float3 GetNormalFromDepth(float fDepth) 

{ 

      float depth1 = SampleDepthOffset(int2(0, 1));

      float depth2 = SampleDepthOffset(int2(1, 0));

    float2 invres = GetInvResolution();

      float3 p1 = float3(0,invres.y, depth1 - fDepth);

      float3 p2 = float3(invres.x, 0, depth2 - fDepth);

      float3 normal = cross(p1, p2);

      normal.z = -normal.z;

      return normalize(normal);

}

#define FILTER_RADIUS 4

float4 BlurPrev(int2 offsetmask, float depth)

{    

    float limit = GetOption(D_FILTER_LIMIT);

    float4 Weight = float4(1,1,1,1);

    float4 count = Weight;

    float4 value = SamplePrev();

    for(int i = 1; i < (FILTER_RADIUS + 1); i++)

    {

        int2 offset = offsetmask * i;

        Weight.w = min(sign(limit - abs(SampleDepthOffset(offset) - depth)) + 1.0, 1.0);

        value +=  SamplePrevOffset(offset) * Weight;

        count += Weight;

        offset = -offset;

        Weight.w = min(sign(limit - abs(SampleDepthOffset(offset) - depth)) + 1.0, 1.0);

        value +=  SamplePrevOffset(offset) * Weight;

        count += Weight;

    }

    return value / count;

}

void BlurH()

{

    SetOutput(BlurPrev(int2(1,0), SampleDepth()));

}

void Merger()

{

    float depth = SampleDepth();

    float4 blur = BlurPrev(int2(0,1), depth);

    float4 value = float4(blur.wwww);

    if(GetOption(A_SSAO_MODE) < 2)

    {

        float4 color = Sample();

        if(GetOption(A_SSAO_MODE) == 0)

        {

            value = color;

        }

        else

        {

            value *= color;

        }

    }    

    SetOutput(value);

}

void SSAO()

{

    float3 PoissonDisc[] = {

        float3(-0.367046f, 0.692618f, 0.0136723f),

        float3(0.262978f, -0.363506f, 0.231819f),

        float3(-0.734306f, -0.451643f, 0.264779f),

        float3(-0.532456f, 0.683096f, 0.552049f),

        float3(0.672536f, 0.283731f, 0.0694296f),

        float3(-0.194678f, 0.548204f, 0.56859f),

        float3(-0.87347f, -0.572741f, 0.923795f),

        float3(0.548936f, -0.717277f, 0.0201727f),

        float3(0.48381f, 0.691397f, 0.699088f),

        float3(-0.592273f, 0.41966f, 0.413953f),

        float3(-0.448042f, -0.957396f, 0.123234f),

        float3(-0.618458f, 0.112949f, 0.412946f),

        float3(-0.412763f, 0.122227f, 0.732078f),

        float3(0.816462f, -0.900815f, 0.741417f),

        float3(-0.0381787f, 0.511521f, 0.799768f),

        float3(-0.688284f, 0.310099f, 0.472732f),

        float3(-0.368023f, 0.720572f, 0.544206f),

        float3(-0.379192f, -0.55504f, 0.035371f),

        float3(0.15482f, 0.0353709f, 0.543779f),

        float3(0.153417f, -0.521409f, 0.943724f),

        float3(-0.168371f, -0.702933f, 0.145665f),

        float3(-0.673391f, -0.925657f, 0.61391f),

        float3(-0.479171f, -0.131993f, 0.659932f),

        float3(0.0549638f, -0.470809f, 0.420759f),

        float3(0.899594f, 0.955077f, 0.54857f),

        float3(-0.230689f, 0.660573f, 0.548112f),

        float3(0.0421461f, -0.19895f, 0.121799f),

        float3(-0.229774f, -0.30137f, 0.507492f),

        float3(-0.983642f, 0.468551f, 0.0393994f),

        float3(-0.00857568f, 0.440657f, 0.337046f),

        float3(0.730461f, -0.283914f, 0.789941f),

        float3(0.271828f, -0.226356f, 0.317026f),

        float3(-0.178869f, -0.946837f, 0.073336f),

        float3(0.389813f, -0.110508f, 0.0549944f),

        float3(0.0242622f, 0.893613f, 0.26957f),

        float3(-0.857601f, 0.0219429f, 0.45146f),

        float3(-0.15659f, 0.550401f, 3.05185e-005f),

        float3(0.0555742f, -0.354656f, 0.573412f),

        float3(-0.267373f, 0.117466f, 0.488571f),

        float3(-0.533799f, -0.431928f, 0.226661f),

        float3(0.49852f, -0.750908f, 0.412427f),

        float3(-0.300882f, 0.366314f, 0.558245f),

        float3(-0.176f, 0.511521f, 0.722465f),

        float3(-0.0514847f, -0.703543f, 0.180273f),

        float3(-0.429914f, 0.0774255f, 0.161534f),

        float3(-0.416791f, -0.788385f, 0.328135f),

        float3(0.127293f, -0.115146f, 0.958586f),

        float3(-0.34959f, -0.278481f, 0.168706f),

        float3(-0.645192f, 0.168798f, 0.577105f),

        float3(-0.190771f, -0.622669f, 0.257851f),

        float3(0.718986f, -0.275369f, 0.602039f),

        float3(-0.444258f, -0.872982f, 0.0275582f),

        float3(0.793512f, 0.0511185f, 0.33964f),

        float3(-0.143651f, 0.155614f, 0.368877f),

        float3(-0.777093f, 0.246864f, 0.290628f),

        float3(0.202979f, -0.61742f, 0.233802f),

        float3(0.198523f, 0.425153f, 0.409162f),

        float3(-0.629688f, 0.597461f, 0.120212f),

        float3(0.0448316f, -0.689566f, 0.0241707f),

        float3(-0.190039f, 0.426496f, 0.254463f),

        float3(-0.255776f, 0.722831f, 0.527451f),

        float3(-0.821528f, 0.303751f, 0.140172f),

        float3(0.696646f, 0.168981f, 0.404492f),

        float3(-0.240211f, -0.109653f, 0.463301f),

    };

    const float2 rndNorm[] =

    {

         float2(0.505277f, 0.862957f),

         float2(-0.554562f, 0.832142f),

         float2(0.663051f, 0.748574f),

         float2(-0.584629f, -0.811301f),

         float2(-0.702343f, 0.711838f),

         float2(0.843108f, -0.537744f),

         float2(0.85856f, 0.512713f),

         float2(0.506966f, -0.861966f),

         float2(0.614758f, -0.788716f),

         float2(0.993426f, -0.114472f),

         float2(-0.676375f, 0.736558f),

         float2(-0.891668f, 0.45269f),

         float2(0.226367f, 0.974042f),

         float2(-0.853615f, -0.520904f),

         float2(0.467359f, 0.884067f),

         float2(-0.997111f, 0.0759529f),

    };

    float2 coords = GetCoordinates();

    float fCurrDepth = SampleDepth();

    float Occlusion = 1.0;

    if(fCurrDepth<0.9999) 

    {

        float3 vViewNormal = GetNormalFromDepth(fCurrDepth);

        Randomize();

        uint2 fragcoord = uint2(GetFragmentCoord()) & 3;

        uint rndidx = fragcoord.y * 4 + fragcoord.x;

        float3 vRandom = float3(rndNorm[rndidx], 0);

        float fAO = 0;

        const int NUMSAMPLES = GetOption(B_SSAO_SAMPLES);

        for(int s = 0; s < NUMSAMPLES; s++) 

        {

            float3 offset = PoissonDisc[s];

            float3 vReflRay = reflect(offset, vRandom);

            float fFlip = sign(dot(vViewNormal,vReflRay));

            vReflRay   *= fFlip;

            float sD = fCurrDepth - (vReflRay.z * GetOption(C_SAMPLE_RANGE));

            float fSampleDepth = SampleDepthLocation(saturate(coords + (GetOption(C_SAMPLE_RANGE) * vReflRay.xy / fCurrDepth)));

            float fDepthDelta = saturate(sD - fSampleDepth);

            fDepthDelta *= 1-smoothstep(0,GetOption(E_MAX_DEPTH),fDepthDelta);

            if ( fDepthDelta > GetOption(F_MIN_DEPTH) && fDepthDelta < GetOption(E_MAX_DEPTH))

                fAO += pow(1 - fDepthDelta, 2.5);

        }

        Occlusion = saturate(1 - (fAO / float(NUMSAMPLES)) + GetOption(C_SAMPLE_RANGE));

    }

    SetOutput(float4(Occlusion,Occlusion,Occlusion,Occlusion));

}

/*******************/

/*MATSO BEGINS HERE*/

/*******************/

#define PI         3.1415972

#define PIOVER180     0.017453292

float4 GetMatsoDOFCA(float2 tex, float CoC)

{

    float3 ChromaPOW = float3(1,1,1) * GetOption(fMatsoDOFChromaPow) * CoC;

    float3 chroma = pow(float3(0.5, 1.0, 1.5), ChromaPOW) * 0.5;

    tex = (2.0 * tex - 1.0);

    float2 tr = (tex * chroma.r) + 0.5;

    float2 tg = (tex * chroma.g) + 0.5;

    float2 tb = (tex * chroma.b) + 0.5;

    float3 color = float3(SamplePrevLocation(tr).r, SamplePrevLocation(tg).g, SamplePrevLocation(tb).b) * (1.0 - CoC);

    return float4(color, 1.0);

}

float4 GetMatsoDOFBlur(int axis, float2 coord)

{

    float4 tcol = SamplePrevLocation(coord);

    float scenedepth = SampleDepth();

    float scenefocus =  SampleDepthLocation(GetOption(DOF_FOCUSPOINT));

    float depthdiff = abs(scenedepth-scenefocus);

    depthdiff = (scenedepth < scenefocus) ? pow(depthdiff, GetOption(DOF_NEARBLURCURVE))*(1.0f+pow(abs(0.5f-coord.x)*depthdiff+0.1f,2.0)*GetOption(DOF_VIGNETTE)) : depthdiff;

    depthdiff = (scenedepth > scenefocus) ? pow(depthdiff, GetOption(DOF_FARBLURCURVE)) : depthdiff;    

    float2 discRadius = depthdiff * GetOption(DOF_BLURRADIUS)*GetInvResolution()*0.5/GetOption(iMatsoDOFBokehQuality);

    int passnumber=1;

    float sf = 0;

    float2 tdirs[4] = { float2(-0.306, 0.739), float2(0.306, 0.739), float2(-0.739, 0.306), float2(-0.739, -0.306) };

    float wValue = (1.0 + pow(length(tcol.rgb) + 0.1, GetOption(fMatsoDOFBokehCurve))) * (1.0 - GetOption(fMatsoDOFBokehLight));    // special recipe from papa Matso ;)

    for(int i = -GetOption(iMatsoDOFBokehQuality); i < GetOption(iMatsoDOFBokehQuality); i++)

    {

        float2 taxis =  tdirs[axis];

        taxis.x = cos(GetOption(fMatsoDOFBokehAngle)*PIOVER180)*taxis.x-sin(GetOption(fMatsoDOFBokehAngle)*PIOVER180)*taxis.y;

        taxis.y = sin(GetOption(fMatsoDOFBokehAngle)*PIOVER180)*taxis.x+cos(GetOption(fMatsoDOFBokehAngle)*PIOVER180)*taxis.y;

        float2 tdir = float(i) * taxis * discRadius;

        float2 tcoord = coord.xy + tdir.xy;

        float4 ct;

        if(GetOption(bMatsoDOFChromaEnable) == 1)

        {

            ct = GetMatsoDOFCA(tcoord.xy, discRadius.x);

        }

        else

        {

            ct = SamplePrevLocation(tcoord.xy);

        }

        float w = 0.0;

        float b = dot(ct.rgb,float3(0.333,0.333,0.333)) + length(ct.rgb) + 0.1;

        w = pow(b, GetOption(fMatsoDOFBokehCurve)) + abs(float(i));

        tcol += ct * w;

        wValue += w;

    }

    tcol /= wValue;

    return float4(tcol.xyz, 1.0);

}

void PS_DOF_MatsoDOF1()

{

    SetOutput(GetMatsoDOFBlur(2, ToSRCCoords(GetCoordinates())));

}

void PS_DOF_MatsoDOF2()

{

    SetOutput(GetMatsoDOFBlur(3, GetCoordinates()));

}

void PS_DOF_MatsoDOF3()

{

    SetOutput(GetMatsoDOFBlur(0, GetCoordinates()));    

}

void PS_DOF_MatsoDOF4()

{

    SetOutput(GetMatsoDOFBlur(1, GetCoordinates()));    

}

/*****************/

/*MATSO ENDS HERE*/

/*****************/

ZeldaGamer23 · 05-17-2015, 05:19 AM **#2,247**

This is the result of my modification. It seems the DoF is offsetting the game.

[Image: 2bb425aefb.png]

**Tino** · 05-17-2015, 06:08 AM **#2,248**

change
void PS_DOF_MatsoDOF1()
{
SetOutput(GetMatsoDOFBlur(2, ToSRCCoords(GetCoordinates())));
}
to
void PS_DOF_MatsoDOF1()
{
SetOutput(GetMatsoDOFBlur(2, GetCoordinates()));
}

and you will fix that

ZeldaGamer23 · 05-17-2015, 06:32 AM **#2,249**

WOOT! Thanks, dude! It works!

[Image: 6ec8f1e0c2.png]

misterdean · (This post was last modified: 05-18-2015, 11:08 AM by misterdean.)

i started using this version and the predictive FIFO and full async shader compilation makes games run so much smoother. was wondering if there are any other settings i should play with for better performance / quality?