void CGUITextureD3D::Begin(color_t color)
{
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
LPDIRECT3DDEVICE9 p3DDevice = g_Windowing.Get3DDevice();
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
// Set state to render the image
p3DDevice->SetTexture( 0, texture->GetTextureObject() );
p3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
p3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
p3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
p3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
p3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
p3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
p3DDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
p3DDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
if (m_diffuse.size())
{
p3DDevice->SetTexture( 1, m_diffuse.m_textures[0]->GetTextureObject() );
p3DDevice->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
p3DDevice->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
p3DDevice->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
p3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
p3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_CURRENT );
p3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
p3DDevice->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
p3DDevice->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
p3DDevice->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
p3DDevice->SetTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
else
{
p3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
p3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
p3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
p3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
p3DDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
p3DDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
p3DDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
p3DDevice->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
p3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
p3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
p3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
p3DDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
p3DDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
p3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE);
p3DDevice->SetFVF( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX2 );
m_col = color;
}
void CGUITextureGL::Begin(color_t color)
{
m_col[0] = (GLubyte)GET_R(color);
m_col[1] = (GLubyte)GET_G(color);
m_col[2] = (GLubyte)GET_B(color);
m_col[3] = (GLubyte)GET_A(color);
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
glActiveTextureARB(GL_TEXTURE0_ARB);
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// diffuse coloring
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
VerifyGLState();
if (m_diffuse.size())
{
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, m_diffuse.m_textures[0]->GetTextureObject());
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE1);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
VerifyGLState();
}
//glDisable(GL_TEXTURE_2D); // uncomment these 2 lines to switch to wireframe rendering
//glBegin(GL_LINE_LOOP);
glBegin(GL_QUADS);
}
void CGUITextureGLES::Begin(color_t color)
{
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
glActiveTexture(GL_TEXTURE0);
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
// Setup Colors
for (int i = 0; i < 4; i++)
{
m_col[i][0] = (GLubyte)GET_R(color);
m_col[i][1] = (GLubyte)GET_G(color);
m_col[i][2] = (GLubyte)GET_B(color);
m_col[i][3] = (GLubyte)GET_A(color);
}
bool hasAlpha = m_texture.m_textures[m_currentFrame]->HasAlpha() || m_col[0][3] < 255;
if (m_diffuse.size())
{
if (m_col[0][0] == 255 && m_col[0][1] == 255 && m_col[0][2] == 255 && m_col[0][3] == 255 )
{
g_Windowing.EnableGUIShader(SM_MULTI);
}
else
{
g_Windowing.EnableGUIShader(SM_MULTI_BLENDCOLOR);
}
hasAlpha |= m_diffuse.m_textures[0]->HasAlpha();
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, m_diffuse.m_textures[0]->GetTextureObject());
GLint tex1Loc = g_Windowing.GUIShaderGetCoord1();
glVertexAttribPointer(tex1Loc, 2, GL_FLOAT, 0, 0, m_tex1);
glEnableVertexAttribArray(tex1Loc);
hasAlpha = true;
}
else
{
if ( hasAlpha )
{
g_Windowing.EnableGUIShader(SM_TEXTURE);
}
else
{
g_Windowing.EnableGUIShader(SM_TEXTURE_NOBLEND);
}
}
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, m_vert);
if(colLoc >= 0)
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, m_col);
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, m_tex0);
glEnableVertexAttribArray(posLoc);
if(colLoc >= 0)
glEnableVertexAttribArray(colLoc);
glEnableVertexAttribArray(tex0Loc);
if ( hasAlpha )
{
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable( GL_BLEND );
}
else
{
glDisable(GL_BLEND);
}
}
CBaseTexture* CGUIFontTTFDX::ReallocTexture(unsigned int& newHeight)
{
CBaseTexture* pNewTexture = new CDXTexture(m_textureWidth, newHeight, XB_FMT_A8);
pNewTexture->CreateTextureObject();
LPDIRECT3DTEXTURE9 newTexture = pNewTexture->GetTextureObject();
if (newTexture == NULL)
{
CLog::Log(LOGERROR, __FUNCTION__" - failed to create the new texture h=%d w=%d", m_textureWidth, newHeight);
SAFE_DELETE(pNewTexture);
return NULL;
}
// Use a speedup texture in system memory when main texture in default pool+dynamic
// Otherwise the texture would have to be copied from vid mem to sys mem, which is too slow for subs while playing video.
CD3DTexture* newSpeedupTexture = NULL;
if (g_Windowing.DefaultD3DPool() == D3DPOOL_DEFAULT && g_Windowing.DefaultD3DUsage() == D3DUSAGE_DYNAMIC)
{
newSpeedupTexture = new CD3DTexture();
if (!newSpeedupTexture->Create(m_textureWidth, newHeight, 1, 0, D3DFMT_A8, D3DPOOL_SYSTEMMEM))
{
SAFE_DELETE(newSpeedupTexture);
SAFE_DELETE(pNewTexture);
return NULL;
}
}
LPDIRECT3DSURFACE9 pSource, pTarget;
HRESULT hr;
// There might be data to copy from the previous texture
if ((newSpeedupTexture && m_speedupTexture) || (newTexture && m_texture))
{
if (m_speedupTexture)
{
m_speedupTexture->GetSurfaceLevel(0, &pSource);
newSpeedupTexture->GetSurfaceLevel(0, &pTarget);
}
else
{
m_texture->GetTextureObject()->GetSurfaceLevel(0, &pSource);
newTexture->GetSurfaceLevel(0, &pTarget);
}
D3DLOCKED_RECT srclr, dstlr;
if(FAILED(pSource->LockRect( &srclr, NULL, 0 ))
|| FAILED(pTarget->LockRect( &dstlr, NULL, 0 )))
{
CLog::Log(LOGERROR, __FUNCTION__" - failed to lock surfaces");
SAFE_DELETE(newSpeedupTexture);
SAFE_DELETE(pNewTexture);
pSource->Release();
pTarget->Release();
return NULL;
}
unsigned char *dst = (unsigned char *)dstlr.pBits;
unsigned char *src = (unsigned char *)srclr.pBits;
unsigned int dstPitch = dstlr.Pitch;
unsigned int srcPitch = srclr.Pitch;
unsigned int minPitch = std::min(srcPitch, dstPitch);
if (srcPitch == dstPitch)
{
memcpy(dst, src, srcPitch * m_textureHeight);
}
else
{
for (unsigned int y = 0; y < m_textureHeight; y++)
{
memcpy(dst, src, minPitch);
src += srcPitch;
dst += dstPitch;
}
}
pSource->UnlockRect();
pTarget->UnlockRect();
pSource->Release();
pTarget->Release();
}
// Upload from speedup texture to main texture
if (newSpeedupTexture && m_speedupTexture)
{
LPDIRECT3DSURFACE9 pSource, pTarget;
newSpeedupTexture->GetSurfaceLevel(0, &pSource);
newTexture->GetSurfaceLevel(0, &pTarget);
const RECT rect = { 0, 0, m_textureWidth, m_textureHeight };
const POINT point = { 0, 0 };
hr = g_Windowing.Get3DDevice()->UpdateSurface(pSource, &rect, pTarget, &point);
SAFE_RELEASE(pSource);
SAFE_RELEASE(pTarget);
if (FAILED(hr))
{
CLog::Log(LOGERROR, __FUNCTION__": Failed to upload from sysmem to vidmem (0x%08X)", hr);
SAFE_DELETE(newSpeedupTexture);
SAFE_DELETE(pNewTexture);
return NULL;
}
}
SAFE_DELETE(m_texture);
SAFE_DELETE(m_speedupTexture);
m_textureHeight = newHeight;
m_speedupTexture = newSpeedupTexture;
return pNewTexture;
}