/**
* \param type bit 0: render OSD, bit 1: render EOSD
*/
static void do_render_osd(int type) {
if (((type & 1) && osdtexCnt > 0) || ((type & 2) && eosdDispList)) {
// set special rendering parameters
if (!scaled_osd) {
MatrixMode(GL_PROJECTION);
PushMatrix();
LoadIdentity();
Ortho(0, vo_dwidth, vo_dheight, 0, -1, 1);
}
Enable(GL_BLEND);
if ((type & 2) && eosdDispList) {
BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
CallList(eosdDispList);
}
if ((type & 1) && osdtexCnt > 0) {
Color4ub((osd_color >> 16) & 0xff, (osd_color >> 8) & 0xff, osd_color & 0xff, 0xff - (osd_color >> 24));
// draw OSD
#ifndef FAST_OSD
BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
CallLists(osdtexCnt, GL_UNSIGNED_INT, osdaDispList);
#endif
BlendFunc(GL_SRC_ALPHA, GL_ONE);
CallLists(osdtexCnt, GL_UNSIGNED_INT, osdDispList);
}
// set rendering parameters back to defaults
Disable(GL_BLEND);
if (!scaled_osd)
PopMatrix();
BindTexture(gl_target, 0);
}
CMatrixGLES::CMatrixGLES()
{
for (int i=0; i<(int)MM_MATRIXSIZE; i++)
{
m_matrices[i].push_back(new GLfloat[16]);
MatrixMode((EMATRIXMODE)i);
LoadIdentity();
}
m_matrixMode = (EMATRIXMODE)-1;
m_pMatrix = NULL;
}
static void resize(int x,int y){
mp_msg(MSGT_VO, MSGL_V, "[gl] Resize: %dx%d\n",x,y);
if (WinID >= 0) {
int top = 0, left = 0, w = x, h = y;
geometry(&top, &left, &w, &h, vo_screenwidth, vo_screenheight);
Viewport(top, left, w, h);
} else
Viewport( 0, 0, x, y );
MatrixMode(GL_PROJECTION);
LoadIdentity();
ass_border_x = ass_border_y = 0;
if (aspect_scaling() && use_aspect) {
int new_w, new_h;
GLdouble scale_x, scale_y;
aspect(&new_w, &new_h, A_WINZOOM);
panscan_calc_windowed();
new_w += vo_panscan_x;
new_h += vo_panscan_y;
scale_x = (GLdouble)new_w / (GLdouble)x;
scale_y = (GLdouble)new_h / (GLdouble)y;
Scaled(scale_x, scale_y, 1);
ass_border_x = (vo_dwidth - new_w) / 2;
ass_border_y = (vo_dheight - new_h) / 2;
}
Ortho(0, image_width, image_height, 0, -1,1);
MatrixMode(GL_MODELVIEW);
LoadIdentity();
if (!scaled_osd) {
#ifdef CONFIG_FREETYPE
// adjust font size to display size
force_load_font = 1;
#endif
vo_osd_changed(OSDTYPE_OSD);
}
Clear(GL_COLOR_BUFFER_BIT);
redraw();
}
void RenderableTexture::Setup(bool useStencilBuffer){
glGenFramebuffers(1, &fbo);
if (fbo == 0){
DEBUG_LOG("failed to glGenFramebuffers\n");
return;
}
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex->GetID(), 0);
if (useStencilBuffer){
GLuint depth_stencil_rb;
glGenRenderbuffers(1, &depth_stencil_rb);
glBindRenderbuffer(GL_RENDERBUFFER, depth_stencil_rb);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, tex->GetWidth(), tex->GetHeight());
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
}
auto result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (result != GL_FRAMEBUFFER_COMPLETE){
DEBUG_LOG("FBO error!\n");
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
transform = make_shared<Transform>();
Begin();
Viewport(0, 0, tex->GetWidth(), tex->GetHeight());
MatrixMode(PROJECTION_MATRIX);
LoadIdentity();
Ortho(0, tex->GetWidth(), 0, tex->GetHeight(), -1, 1);
MatrixMode(MODELVIEW_MATRIX);
LoadIdentity();
End();
}
void GrGpuGLFixed::flushProjectionMatrix() {
float mat[16];
Gr_bzero(mat, sizeof(mat));
GrAssert(NULL != fCurrDrawState.fRenderTarget);
mat[0] = 2.f / fCurrDrawState.fRenderTarget->width();
mat[5] = -2.f / fCurrDrawState.fRenderTarget->height();
mat[10] = -1.f;
mat[15] = 1;
mat[12] = -1.f;
mat[13] = 1.f;
GR_GL(MatrixMode(GR_GL_PROJECTION));
GR_GL(LoadMatrixf(mat));
}
void GrGpuGL::flushViewMatrix(DrawType type) {
const GrGLRenderTarget* rt = static_cast<const GrGLRenderTarget*>(this->getDrawState().getRenderTarget());
SkISize viewportSize;
const GrGLIRect& viewport = rt->getViewport();
viewportSize.set(viewport.fWidth, viewport.fHeight);
const SkMatrix& vm = this->getDrawState().getViewMatrix();
if (kStencilPath_DrawType == type) {
if (fHWPathMatrixState.fViewMatrix != vm ||
fHWPathMatrixState.fRTSize != viewportSize) {
// rescale the coords from skia's "device" coords to GL's normalized coords,
// and perform a y-flip.
SkMatrix m;
m.setScale(SkIntToScalar(2) / rt->width(), SkIntToScalar(-2) / rt->height());
m.postTranslate(-SK_Scalar1, SK_Scalar1);
m.preConcat(vm);
// GL wants a column-major 4x4.
GrGLfloat mv[] = {
// col 0
SkScalarToFloat(m[SkMatrix::kMScaleX]),
SkScalarToFloat(m[SkMatrix::kMSkewY]),
0,
SkScalarToFloat(m[SkMatrix::kMPersp0]),
// col 1
SkScalarToFloat(m[SkMatrix::kMSkewX]),
SkScalarToFloat(m[SkMatrix::kMScaleY]),
0,
SkScalarToFloat(m[SkMatrix::kMPersp1]),
// col 2
0, 0, 0, 0,
// col3
SkScalarToFloat(m[SkMatrix::kMTransX]),
SkScalarToFloat(m[SkMatrix::kMTransY]),
0.0f,
SkScalarToFloat(m[SkMatrix::kMPersp2])
};
GL_CALL(MatrixMode(GR_GL_PROJECTION));
GL_CALL(LoadMatrixf(mv));
fHWPathMatrixState.fViewMatrix = vm;
fHWPathMatrixState.fRTSize = viewportSize;
}
} else if (!fCurrentProgram->fViewMatrix.cheapEqualTo(vm) ||
fCurrentProgram->fViewportSize != viewportSize) {
SkMatrix m;
m.setAll(
SkIntToScalar(2) / viewportSize.fWidth, 0, -SK_Scalar1,
0,-SkIntToScalar(2) / viewportSize.fHeight, SK_Scalar1,
0, 0, SkMatrix::I()[8]);
m.setConcat(m, vm);
// ES doesn't allow you to pass true to the transpose param,
// so do our own transpose
GrGLfloat mt[] = {
SkScalarToFloat(m[SkMatrix::kMScaleX]),
SkScalarToFloat(m[SkMatrix::kMSkewY]),
SkScalarToFloat(m[SkMatrix::kMPersp0]),
SkScalarToFloat(m[SkMatrix::kMSkewX]),
SkScalarToFloat(m[SkMatrix::kMScaleY]),
SkScalarToFloat(m[SkMatrix::kMPersp1]),
SkScalarToFloat(m[SkMatrix::kMTransX]),
SkScalarToFloat(m[SkMatrix::kMTransY]),
SkScalarToFloat(m[SkMatrix::kMPersp2])
};
fCurrentProgram->fUniformManager.setMatrix3f(
fCurrentProgram->fUniformHandles.fViewMatrixUni,
mt);
fCurrentProgram->fViewMatrix = vm;
fCurrentProgram->fViewportSize = viewportSize;
}
}
bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) {
bool usingTextures[kNumStages];
for (int s = 0; s < kNumStages; ++s) {
usingTextures[s] = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
if (usingTextures[s] && fCurrDrawState.fSamplerStates[s].isGradient()) {
unimpl("Fixed pipe doesn't support radial/sweep gradients");
return false;
}
}
if (GR_GL_SUPPORT_ES1) {
if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) ||
BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) {
unimpl("ES1 doesn't support blend constant");
return false;
}
}
if (!flushGLStateCommon(type)) {
return false;
}
if (fDirtyFlags.fRenderTargetChanged) {
flushProjectionMatrix();
}
for (int s = 0; s < kNumStages; ++s) {
bool wasUsingTexture = VertexUsesStage(s, fHWGeometryState.fVertexLayout);
if (usingTextures[s] != wasUsingTexture) {
setTextureUnit(s);
if (usingTextures[s]) {
GR_GL(Enable(GR_GL_TEXTURE_2D));
} else {
GR_GL(Disable(GR_GL_TEXTURE_2D));
}
}
}
uint32_t vertColor = (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit);
uint32_t prevVertColor = (fHWGeometryState.fVertexLayout &
kColor_VertexLayoutBit);
if (vertColor != prevVertColor) {
if (vertColor) {
GR_GL(ShadeModel(GR_GL_SMOOTH));
// invalidate the immediate mode color
fHWDrawState.fColor = GrColor_ILLEGAL;
} else {
GR_GL(ShadeModel(GR_GL_FLAT));
}
}
if (!vertColor && fHWDrawState.fColor != fCurrDrawState.fColor) {
GR_GL(Color4ub(GrColorUnpackR(fCurrDrawState.fColor),
GrColorUnpackG(fCurrDrawState.fColor),
GrColorUnpackB(fCurrDrawState.fColor),
GrColorUnpackA(fCurrDrawState.fColor)));
fHWDrawState.fColor = fCurrDrawState.fColor;
}
// set texture environment, decide whether we are modulating by RGB or A.
for (int s = 0; s < kNumStages; ++s) {
if (usingTextures[s]) {
GrGLTexture* texture = (GrGLTexture*)fCurrDrawState.fTextures[s];
if (NULL != texture) {
TextureEnvRGBOperands nextRGBOperand0 =
(GrPixelConfigIsAlphaOnly(texture->config())) ?
kAlpha_TextureEnvRGBOperand :
kColor_TextureEnvRGBOperand;
if (fHWRGBOperand0[s] != nextRGBOperand0) {
setTextureUnit(s);
GR_GL(TexEnvi(GR_GL_TEXTURE_ENV,
GR_GL_OPERAND0_RGB,
(nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ?
GR_GL_SRC_ALPHA :
GR_GL_SRC_COLOR));
fHWRGBOperand0[s] = nextRGBOperand0;
}
if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
(fHWDrawState.fSamplerStates[s].getMatrix() !=
getSamplerMatrix(s))) {
GrMatrix texMat = getSamplerMatrix(s);
AdjustTextureMatrix(texture,
GrSamplerState::kNormal_SampleMode,
&texMat);
GrGpuMatrix glm;
glm.set(texMat);
setTextureUnit(s);
GR_GL(MatrixMode(GR_GL_TEXTURE));
GR_GL(LoadMatrixf(glm.fMat));
recordHWSamplerMatrix(s, getSamplerMatrix(s));
}
} else {
GrAssert(!"Rendering with texture vert flag set but no bound texture");
return false;
}
}
}
if (fHWDrawState.fViewMatrix != fCurrDrawState.fViewMatrix) {
GrGpuMatrix glm;
glm.set(fCurrDrawState.fViewMatrix);
GR_GL(MatrixMode(GR_GL_MODELVIEW));
GR_GL(LoadMatrixf(glm.fMat));
fHWDrawState.fViewMatrix =
fCurrDrawState.fViewMatrix;
}
resetDirtyFlags();
return true;
}
void CShaderAPIOES2::ResetRenderState(bool bFullReset)
{
int i;
if (!IsDeactivated())
{
glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
// glCullFace(GL_BACK); // Never changed.
glDisable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_ALWAYS, 0, 0xffffffff);
glStencilMask(0xffffffff);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(0.0f, 0.0f);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// glBlendColor(1.0f, 1.0f, 1.0f, 1.0f); // Constant color blending modes are not used.
// glBlendEquation(GL_FUNC_ADD); // Never changed.
glActiveTexture(GL_TEXTURE0);
glClearDepthf(1.0f);
glClearStencil(0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
}
m_CurrentSnapshot = -1;
m_CachedFastClipProjectionMatrix.Identity();
m_SceneFogColor[0] = m_SceneFogColor[1] = m_SceneFogColor[2] = 0;
m_SceneFogMode = MATERIAL_FOG_NONE;
m_DynamicState.m_ClearColor[0] = m_DynamicState.m_ClearColor[1] =
m_DynamicState.m_ClearColor[2] = m_DynamicState.m_ClearColor[3] = 0;
m_ClearColorChanged = true;
m_ClearReverseDepth = false;
m_ClearStencil = 0;
m_ZWriteEnable = true;
StandardConstantChanged(OES2_SHADER_CONST_AMBIENT_LIGHT);
m_WorldSpaceCameraPosition.Init(0.0f, 0.0f, 0.0f);
m_DynamicState.m_PixelFogColor[0] = m_DynamicState.m_PixelFogColor[1] = m_DynamicState.m_PixelFogColor[2] = 0.0f;
m_DynamicState.m_FogStart = 0.0f;
m_DynamicState.m_FogEnd = 0.0f;
m_DynamicState.m_FogMaxDensity = 1.0f;
m_DynamicState.m_FogZ = 1.0f;
UpdateFogConstant();
// Shadow state applied in ShaderAPI.
m_DynamicState.m_CullEnabled = true;
m_DynamicState.m_FrontFace = GL_CW;
m_DynamicState.m_DepthBiasEnabled = false;
m_DynamicState.m_NumBones = 0;
for (i = HardwareConfig()->Caps().m_NumCombinedSamplers; i-- > 0; )
m_BoundTextures[i] = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_PixelShaderLightingChanged = true;
m_VertexShaderLightingChanged = true;
for (i = MAX_NUM_LIGHTS; i--; )
m_DynamicState.m_LightEnable[i] = false;
for (i = NUM_MATRIX_MODES; i--; )
m_DynamicState.m_TransformType[i] = TRANSFORM_IS_GENERAL;
StandardConstantChanged(OES2_SHADER_CONST_MODELVIEWPROJ);
StandardConstantChanged(OES2_SHADER_CONST_VIEWPROJ);
StandardConstantChanged(OES2_SHADER_CONST_MODEL);
m_TransitionTable.UseDefaultState();
SetDefaultState();
if (bFullReset)
{
SetAnisotropicLevel(1);
float *pBoneMatrix;
for (i = 16; i--; )
{
pBoneMatrix = m_BoneMatrix[i];
memset(pBoneMatrix, 0, sizeof(float) * 12);
pBoneMatrix[0] = 1.0f;
pBoneMatrix[5] = 1.0f;
pBoneMatrix[10] = 1.0f;
}
MatrixMode(MATERIAL_VIEW);
LoadIdentity();
MatrixMode(MATERIAL_PROJECTION);
LoadIdentity();
}
int width, height;
GetBackBufferDimensions(width, height);
m_Viewport.Init(0, 0, width, height);
m_ViewportChanged = true;
m_ViewportZChanged = true;
m_ScissorEnabled = m_DynamicState.m_ScissorEnabled = false;
m_DynamicState.m_ScissorRect.x = m_DynamicState.m_ScissorRect.y =
m_DynamicState.m_ScissorRect.width = m_DynamicState.m_ScissorRect.height = -1;
m_ScissorRectChanged = true;
EnableFastClip(false);
float fakePlane[4];
int fakePlaneVal = -1;
fakePlane[0] = fakePlane[1] = fakePlane[2] = fakePlane[3] = *((float *)(&fakePlaneVal));
SetFastClipPlane(fakePlane);
m_DynamicState.m_FastClipPlaneChanged = true;
m_pRenderMesh = NULL;
MeshMgr()->SetVertexDecl(VERTEX_FORMAT_UNKNOWN);
SetRenderTarget(SHADER_RENDERTARGET_BACKBUFFER, SHADER_RENDERTARGET_DEPTHBUFFER);
m_ActiveTexture = SHADER_SAMPLER0;
m_UnpackAlignment = 4;
}
void cRendererGLES2::SetShader( cShaderProgram * Shader ) {
if ( NULL == Shader ) {
Shader = mShaders[ EEGLES2_SHADER_BASE ];
}
if ( mCurShader == Shader ) {
return;
}
DisableClientState( GL_VERTEX_ARRAY );
DisableClientState( GL_TEXTURE_COORD_ARRAY );
DisableClientState( GL_COLOR_ARRAY );
mShaderPrev = mCurShader;
mCurShader = Shader;
CheckLocalShader();
mProjectionMatrix_id = mCurShader->UniformLocation( "dgl_ProjectionMatrix" );
mModelViewMatrix_id = mCurShader->UniformLocation( "dgl_ModelViewMatrix" );
mTexActiveLoc = mCurShader->UniformLocation( "dgl_TexActive" );
mClippingEnabledLoc = mCurShader->UniformLocation( "dgl_ClippingEnabled" );
mCurActiveTex = 0;
Uint32 i;
for ( i = 0; i < EEGL_ARRAY_STATES_COUNT; i++ ) {
mAttribsLoc[ i ] = mCurShader->AttributeLocation( EEGLES2_STATES_NAME[ i ] );
}
for ( i = 0; i < EE_MAX_PLANES; i++ ) {
if ( -1 != mClippingEnabledLoc ) {
mPlanes[ i ] = mCurShader->UniformLocation( EEGLES2_PLANES_NAMENABLED_NAME[ i ] );
} else {
mPlanes[ i ] = -1;
}
}
for ( i = 0; i < EE_MAX_TEXTURE_UNITS; i++ ) {
mTextureUnits[ i ] = mCurShader->AttributeLocation( EEGLES2_TEXTUREUNIT_NAMES[ i ] );
}
glUseProgram( mCurShader->Handler() );
if ( -1 != mAttribsLoc[ EEGL_VERTEX_ARRAY ] )
EnableClientState( GL_VERTEX_ARRAY );
if ( -1 != mAttribsLoc[ EEGL_COLOR_ARRAY ] )
EnableClientState( GL_COLOR_ARRAY );
if ( -1 != mTextureUnits[ mCurActiveTex ] )
EnableClientState( GL_TEXTURE_COORD_ARRAY );
GLenum CM = mCurrentMode;
MatrixMode( GL_PROJECTION );
UpdateMatrix();
MatrixMode( GL_MODELVIEW );
UpdateMatrix();
MatrixMode( CM );
if ( -1 != mTexActiveLoc ) {
mCurShader->SetUniform( mTexActiveLoc, mTexActive );
}
if ( -1 != mClippingEnabledLoc ) {
mCurShader->SetUniform( mClippingEnabledLoc, 0 );
}
for ( i = 0; i < EE_MAX_PLANES; i++ ) {
if ( -1 != mPlanes[ i ] ) {
mCurShader->SetUniform( EEGLES2_PLANES_ENABLED_NAME[ i ], 0 );
}
}
}
