dolphin/Source/Core/VideoCommon/Src/PixelShaderManager.cpp

// Copyright (C) 2003 Dolphin Project.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License 2.0 for more details.

// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/

// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/

#include <cmath>

#include "Common.h"
#include "Profiler.h"
#include "Statistics.h"
#include "PixelShaderManager.h"
#include "VideoCommon.h"
#include "VideoConfig.h"

static int s_nColorsChanged[2]; // 0 - regular colors, 1 - k colors
static int s_nIndTexMtxChanged;
static bool s_bAlphaChanged;
static bool s_bZBiasChanged;
static bool s_bZTextureTypeChanged;
static bool s_bDepthRangeChanged;
static bool s_bFogColorChanged;
static bool s_bFogParamChanged;
static float lastDepthRange[2]; // 0 = far z, 1 = far - near
static float lastRGBAfull[2][4][4];
static u8 s_nTexDimsChanged;
static u8 s_nIndTexScaleChanged;
static u32 lastAlpha;
static u32 lastTexDims[8]; // width | height << 16 | wrap_s << 28 | wrap_t << 30
static u32 lastZBias;

void PixelShaderManager::Init()
{
	lastAlpha = 0;
	memset(lastTexDims, 0, sizeof(lastTexDims));
	lastZBias = 0;
	memset(lastRGBAfull, 0, sizeof(lastRGBAfull));
	Dirty();
}

void PixelShaderManager::Dirty()
{
	s_nColorsChanged[0] = s_nColorsChanged[1] = 15;
	s_nTexDimsChanged = 0xFF;
	s_nIndTexScaleChanged = 0xFF;
	s_nIndTexMtxChanged = 15;
	s_bAlphaChanged = s_bZBiasChanged = s_bZTextureTypeChanged = s_bDepthRangeChanged = true;
	s_bFogColorChanged = s_bFogParamChanged = true;
}

void PixelShaderManager::Shutdown()
{

}

void PixelShaderManager::SetConstants()
{
    for (int i = 0; i < 2; ++i) 
	{
        if (s_nColorsChanged[i]) 
		{
            int baseind = i ? C_KCOLORS : C_COLORS;
            for (int j = 0; j < 4; ++j) 
			{
                if (s_nColorsChanged[i] & (1 << j)) 
                    SetPSConstant4fv(baseind+j, &lastRGBAfull[i][j][0]);
            }
            s_nColorsChanged[i] = 0;
        }
    }

    if (s_nTexDimsChanged) 
	{
        for (int i = 0; i < 8; ++i) 
		{
            if (s_nTexDimsChanged & (1<<i)) 
				SetPSTextureDims(i);         
        }
        s_nTexDimsChanged = 0;
    }

    if (s_bAlphaChanged) 
	{
        SetPSConstant4f(C_ALPHA, (lastAlpha&0xff)/255.0f, ((lastAlpha>>8)&0xff)/255.0f, 0, ((lastAlpha>>16)&0xff)/255.0f);
		s_bAlphaChanged = false;
    }

	if (s_bZTextureTypeChanged) 
	{    
        float ftemp[4];
        switch (bpmem.ztex2.type) 
		{
             case 0:
                // 8 bits                
                ftemp[0] = 0; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 255.0f/16777215.0f;
                break;
            case 1:
                // 16 bits
                ftemp[0] = 255.0f/16777215.0f; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 65280.0f/16777215.0f;
                break;
            case 2:
                // 24 bits
				ftemp[0] = 16711680.0f/16777215.0f; ftemp[1] = 65280.0f/16777215.0f; ftemp[2] = 255.0f/16777215.0f; ftemp[3] = 0;
                break;
        }
		SetPSConstant4fv(C_ZBIAS, ftemp);
		s_bZTextureTypeChanged = false;
	}

	if (s_bZBiasChanged || s_bDepthRangeChanged) 
	{
        //ERROR_LOG("pixel=%x,%x, bias=%x\n", bpmem.zcontrol.pixel_format, bpmem.ztex2.type, lastZBias);
        SetPSConstant4f(C_ZBIAS+1, lastDepthRange[0] / 16777216.0f, lastDepthRange[1] / 16777216.0f, 0, (float)(lastZBias)/16777215.0f);
		s_bZBiasChanged = s_bDepthRangeChanged = false;
    }

    // indirect incoming texture scales
    if (s_nIndTexScaleChanged) 
	{
		// set as two sets of vec4s, each containing S and T of two ind stages.
        float f[8];
        
        if (s_nIndTexScaleChanged & 0x03) 
		{
            for (u32 i = 0; i < 2; ++i) 
			{
                f[2 * i] = bpmem.texscale[0].getScaleS(i & 1);
                f[2 * i + 1] = bpmem.texscale[0].getScaleT(i & 1);
                PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
            }
            SetPSConstant4fv(C_INDTEXSCALE, f);
        }

        if (s_nIndTexScaleChanged & 0x0c) {
            for (u32 i = 2; i < 4; ++i) {
                f[2 * i] = bpmem.texscale[1].getScaleS(i & 1);
                f[2 * i + 1] = bpmem.texscale[1].getScaleT(i & 1);
                PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
            }            
            SetPSConstant4fv(C_INDTEXSCALE+1, &f[4]);
        }
       
        s_nIndTexScaleChanged = 0;
    }

    if (s_nIndTexMtxChanged) 
	{
        for (int i = 0; i < 3; ++i) 
		{
            if (s_nIndTexMtxChanged & (1 << i)) 
			{
                int scale = ((u32)bpmem.indmtx[i].col0.s0 << 0) |
					        ((u32)bpmem.indmtx[i].col1.s1 << 2) |
					        ((u32)bpmem.indmtx[i].col2.s2 << 4);
                float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f;

                // xyz - static matrix
                // TODO w - dynamic matrix scale / 256...... somehow / 4 works better
                // rev 2972 - now using / 256.... verify that this works
                SetPSConstant4f(C_INDTEXMTX + 2 * i,
                    bpmem.indmtx[i].col0.ma * fscale,
					bpmem.indmtx[i].col1.mc * fscale,
					bpmem.indmtx[i].col2.me * fscale,
					fscale * 4.0f);
                SetPSConstant4f(C_INDTEXMTX + 2 * i + 1,
                    bpmem.indmtx[i].col0.mb * fscale,
					bpmem.indmtx[i].col1.md * fscale,
					bpmem.indmtx[i].col2.mf * fscale,
					fscale * 4.0f);

                PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n", i,
                    1024.0f*fscale, bpmem.indmtx[i].col0.ma * fscale, bpmem.indmtx[i].col1.mc * fscale, bpmem.indmtx[i].col2.me * fscale,
                    bpmem.indmtx[i].col0.mb * fscale, bpmem.indmtx[i].col1.md * fscale, bpmem.indmtx[i].col2.mf * fscale, fscale);
            }
        }
        s_nIndTexMtxChanged = 0;
    }

    if (s_bFogColorChanged) 
	{
        SetPSConstant4f(C_FOG, bpmem.fog.color.r / 255.0f, bpmem.fog.color.g / 255.0f, bpmem.fog.color.b / 255.0f, 0);
        s_bFogColorChanged = false;
    }

    if (s_bFogParamChanged) 
	{
		if(!g_ActiveConfig.bDisableFog)
		{
			float a = bpmem.fog.a.GetA() * ((float)(1 << (bpmem.fog.b_shift - 1)));
			float b = ((float)bpmem.fog.b_magnitude / 8388638) * ((float)(1 << (bpmem.fog.b_shift - 1)));
			SetPSConstant4f(C_FOG + 1, a, b, bpmem.fog.c_proj_fsel.GetC(), 0);
		}
		else
		{
			SetPSConstant4f(C_FOG + 1, 0.0, 1.0, 1.0, 0);
		}
        s_bFogParamChanged = false;
    }
}

void PixelShaderManager::SetPSTextureDims(int texid)
{
    // texdims.xy are reciprocals of the real texture dimensions
    // texdims.zw are the scaled dimensions
    float fdims[4];

    TCoordInfo& tc = bpmem.texcoords[texid];
	fdims[0] = 1.0f / (float)(lastTexDims[texid] & 0xffff);
	fdims[1] = 1.0f / (float)((lastTexDims[texid] >> 16) & 0xfff);
	fdims[2] = (float)(tc.s.scale_minus_1 + 1);
	fdims[3] = (float)(tc.t.scale_minus_1 + 1);

	PRIM_LOG("texdims%d: %f %f %f %f\n", texid, fdims[0], fdims[1], fdims[2], fdims[3]);
	SetPSConstant4fv(C_TEXDIMS + texid, fdims);
}

// This one is high in profiles (0.5%). TODO: Move conversion out, only store the raw color value
// and update it when the shader constant is set, only.
void PixelShaderManager::SetColorChanged(int type, int num)
{
    int r = bpmem.tevregs[num].low.a;
	int a = bpmem.tevregs[num].low.b;
    int b = bpmem.tevregs[num].high.a;
	int g = bpmem.tevregs[num].high.b;
    float *pf = &lastRGBAfull[type][num][0];
    pf[0] = (float)r * (1.0f / 255.0f);
    pf[1] = (float)g * (1.0f / 255.0f);
    pf[2] = (float)b * (1.0f / 255.0f);
    pf[3] = (float)a * (1.0f / 255.0f);
    s_nColorsChanged[type] |= 1 << num;
    PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, pf[0], pf[1], pf[2], pf[3]);
}

void PixelShaderManager::SetAlpha(const AlphaFunc& alpha)
{
    if ((alpha.hex & 0xffff) != lastAlpha)
	{
        lastAlpha = (lastAlpha & ~0xffff) | (alpha.hex & 0xffff);
        s_bAlphaChanged = true;
    }
}

void PixelShaderManager::SetDestAlpha(const ConstantAlpha& alpha)
{
    if (alpha.alpha != (lastAlpha >> 16))
	{
        lastAlpha = (lastAlpha & ~0xff0000) | ((alpha.hex & 0xff) << 16);
        s_bAlphaChanged = true;
    }
}

void PixelShaderManager::SetTexDims(int texmapid, u32 width, u32 height, u32 wraps, u32 wrapt)
{
    u32 wh = width | (height << 16) | (wraps << 28) | (wrapt << 30);
    if (lastTexDims[texmapid] != wh)
	{
        lastTexDims[texmapid] = wh;
		s_nTexDimsChanged |= 1 << texmapid;        
    }
}

void PixelShaderManager::SetZTextureBias(u32 bias)
{
    if (lastZBias != bias)
	{
        s_bZBiasChanged = true;
        lastZBias = bias;
    }
}

void PixelShaderManager::SetViewport(float* viewport,int VIndex)
{
	// reversed gxsetviewport(xorig, yorig, width, height, nearz, farz)
    // [0] = width/2
    // [1] = height/2
    // [2] = 16777215 * (farz - nearz)
    // [3] = xorig + width/2 + 342
    // [4] = yorig + height/2 + 342
    // [5] = 16777215 * farz

	if(VIndex <= 0)
	{
		if (lastDepthRange[0] != viewport[5] || lastDepthRange[1] != viewport[2])
		{
			lastDepthRange[0] = viewport[5];
			lastDepthRange[1] = viewport[2];

			s_bDepthRangeChanged = true;
		}
	}
	else
	{
		if (VIndex == 2 && lastDepthRange[1] != viewport[0])
		{
			lastDepthRange[1] = viewport[0];
			s_bDepthRangeChanged = true;
		}
		else if(VIndex == 5 && lastDepthRange[0] != viewport[0])
		{
			lastDepthRange[0] = viewport[0];
			s_bDepthRangeChanged = true;
		}
	}
}

void PixelShaderManager::SetIndTexScaleChanged(u8 stagemask)
{
    s_nIndTexScaleChanged |= stagemask;
}

void PixelShaderManager::SetIndMatrixChanged(int matrixidx)
{
    s_nIndTexMtxChanged |= 1 << matrixidx;
}

void PixelShaderManager::SetZTextureTypeChanged()
{
	s_bZTextureTypeChanged = true;
}

void PixelShaderManager::SetTexCoordChanged(u8 texmapid)
{
    s_nTexDimsChanged |= 1 << texmapid;
}

void PixelShaderManager::SetFogColorChanged()
{
    s_bFogColorChanged = true;
}

void PixelShaderManager::SetFogParamChanged()
{
    s_bFogParamChanged = true;
}

void PixelShaderManager::SetColorMatrix(const float* pmatrix, const float* pfConstAdd)
{
	SetMultiPSConstant4fv(C_COLORMATRIX,4,pmatrix);
    SetPSConstant4fv(C_COLORMATRIX+4, pfConstAdd);
}