bool pathRenderingSupport() const { return fPathRenderingSupport; }
bool dstReadInShaderSupport() const { return fDstReadInShaderSupport; }
bool dualSourceBlendingSupport() const { return fDualSourceBlendingSupport; }
- bool programmableSampleLocationsSupport() const { return fProgrammableSampleLocationsSupport; }
/**
* Get the precision info for a variable of type kFloat_GrSLType, kVec2f_GrSLType, etc in a
bool fPathRenderingSupport : 1;
bool fDstReadInShaderSupport : 1;
bool fDualSourceBlendingSupport : 1;
- bool fProgrammableSampleLocationsSupport : 1;
bool fShaderPrecisionVaries;
PrecisionInfo fFloatPrecisions[kGrShaderTypeCount][kGrSLPrecisionCount];
typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLGetVertexArrayPointeri_vProc)(GrGLuint vaobj, GrGLuint index, GrGLenum pname, GrGLvoid **param);
typedef GrGLvoid* (GR_GL_FUNCTION_TYPE* GrGLMapNamedBufferRangeProc)(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr length, GrGLbitfield access);
typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLFlushMappedNamedBufferRangeProc)(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr length);
-// OpenGL 4.5
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLNamedFramebufferParameteriProc)(GrGLuint framebuffer, GrGLenum pname, GrGLint param);
/* KHR_debug */
typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLDebugMessageControlProc)(GrGLenum source, GrGLenum type, GrGLenum severity, GrGLsizei count, const GrGLuint* ids, GrGLboolean enabled);
GLPtr<GrGLGetVertexArrayPointeri_vProc> fGetVertexArrayPointeri_v;
GLPtr<GrGLMapNamedBufferRangeProc> fMapNamedBufferRange;
GLPtr<GrGLFlushMappedNamedBufferRangeProc> fFlushMappedNamedBufferRange;
- // OpenGL 4.5
- GLPtr<GrGLNamedFramebufferParameteriProc> fNamedFramebufferParameteri;
/* KHR_debug */
GLPtr<GrGLDebugMessageControlProc> fDebugMessageControl;
fPathRenderingSupport = false;
fDstReadInShaderSupport = false;
fDualSourceBlendingSupport = false;
- fProgrammableSampleLocationsSupport = false;
fShaderPrecisionVaries = false;
}
SkString GrShaderCaps::dump() const {
SkString r;
static const char* gNY[] = { "NO", "YES" };
- r.appendf("Shader Derivative Support : %s\n", gNY[fShaderDerivativeSupport]);
- r.appendf("Geometry Shader Support : %s\n", gNY[fGeometryShaderSupport]);
- r.appendf("Path Rendering Support : %s\n", gNY[fPathRenderingSupport]);
- r.appendf("Dst Read In Shader Support : %s\n", gNY[fDstReadInShaderSupport]);
- r.appendf("Dual Source Blending Support : %s\n", gNY[fDualSourceBlendingSupport]);
- r.appendf("Programmable Sample Locations Support : %s\n", gNY[fProgrammableSampleLocationsSupport]);
-
- r.appendf("Shader Float Precisions (varies: %s) :\n", gNY[fShaderPrecisionVaries]);
+ r.appendf("Shader Derivative Support : %s\n", gNY[fShaderDerivativeSupport]);
+ r.appendf("Geometry Shader Support : %s\n", gNY[fGeometryShaderSupport]);
+ r.appendf("Path Rendering Support : %s\n", gNY[fPathRenderingSupport]);
+ r.appendf("Dst Read In Shader Support : %s\n", gNY[fDstReadInShaderSupport]);
+ r.appendf("Dual Source Blending Support : %s\n", gNY[fDualSourceBlendingSupport]);
+
+ r.appendf("Shader Float Precisions (varies: %s):\n", gNY[fShaderPrecisionVaries]);
for (int s = 0; s < kGrShaderTypeCount; ++s) {
GrShaderType shaderType = static_cast<GrShaderType>(s);
}
// If MSAA is enabled we can do everything in the stencil buffer.
- if (0 == rt->numStencilSamples() && requiresAA) {
+ if (0 == rt->numColorSamples() && requiresAA) {
SkAutoTUnref<GrTexture> result;
// The top-left of the mask corresponds to the top-left corner of the bounds.
pipelineBuilder.setDisableColorXPFactory();
// if the target is MSAA then we want MSAA enabled when the clip is soft
- if (rt->isStencilBufferMultisampled()) {
+ if (rt->isUnifiedMultisampled()) {
pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, element->isAA());
}
}
}
- if (glVer >= GR_GL_VER(4,5)) {
- GET_PROC(NamedFramebufferParameteri);
- }
-
if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_KHR_debug")) {
// KHR_debug defines these methods to have no suffix in an OpenGL (not ES) context.
GET_PROC(DebugMessageControl);
ctxInfo.hasExtension("GL_OES_standard_derivatives");
}
- glslCaps->fProgrammableSampleLocationsSupport =
- ctxInfo.hasExtension("GL_NV_sample_locations") ||
- ctxInfo.hasExtension("GL_ARB_sample_locations");
-
/**************************************************************************
* GrCaps fields
**************************************************************************/
#define GR_GL_MULTISAMPLE_RASTERIZATION_ALLOWED 0x932B
#define GR_GL_EFFECTIVE_RASTER_SAMPLES 0x932C
-/* GL_NV_sample_locations and GL_ARB_sample_locations */
-#define GR_GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS 0x9342
-
/* GL_KHR_debug */
#define GR_GL_DEBUG_OUTPUT 0x92E0
#define GR_GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(pipeline.getRenderTarget());
this->flushStencil(pipeline.getStencil());
this->flushScissor(pipeline.getScissorState(), glRT->getViewport(), glRT->origin());
- this->flushHWAAState(glRT, pipeline.isHWAntialiasState(), !pipeline.getStencil().isDisabled());
+ this->flushHWAAState(glRT, pipeline.isHWAntialiasState());
// This must come after textures are flushed because a texture may need
// to be msaa-resolved (which will modify bound FBO state).
return true;
}
-void GrGLGpu::setColocatedSampleLocations(GrRenderTarget* rt, bool useColocatedSampleLocations) {
- GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(rt->asRenderTarget());
- SkASSERT(0 != target->renderFBOID());
-
- if (!rt->isStencilBufferMultisampled() ||
- useColocatedSampleLocations == target->usesColocatedSampleLocations()) {
- return;
- }
-
- GL_CALL(NamedFramebufferParameteri(target->renderFBOID(),
- GR_GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS,
- useColocatedSampleLocations));
-
- target->flagAsUsingColocatedSampleLocations(useColocatedSampleLocations);
-}
-
void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bound) {
SkASSERT(target);
}
}
-void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA, bool stencilEnabled) {
+void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA) {
SkASSERT(!useHWAA || rt->isStencilBufferMultisampled());
- if (rt->hasMixedSamples() && stencilEnabled &&
- this->glCaps().glslCaps()->programmableSampleLocationsSupport()) {
- if (useHWAA) {
- this->setColocatedSampleLocations(rt, false);
- } else {
- this->setColocatedSampleLocations(rt, true);
- }
- useHWAA = true;
- }
-
if (this->glCaps().multisampleDisableSupport()) {
if (useHWAA) {
if (kYes_TriState != fMSAAEnabled) {
this->flushBlend(blendInfo);
this->flushColorWrite(true);
this->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace);
- this->flushHWAAState(dstRT, false, false);
+ this->flushHWAAState(dstRT, false);
this->disableScissor();
GrStencilSettings stencil;
stencil.setDisabled();
// ensures that such operations don't negatively interact with tracking bound textures.
void setScratchTextureUnit();
- // colocates all samples at pixel center for render target, if MSAA.
- // allows drawing coverage based AA shapes in MSAA mode.
- void setColocatedSampleLocations(GrRenderTarget* rt, bool useColocatedSampleLocations);
-
// bounds is region that may be modified and therefore has to be resolved.
// nullptr means whole target. Can be an empty rect.
void flushRenderTarget(GrGLRenderTarget*, const SkIRect* bounds);
void flushStencil(const GrStencilSettings&);
- void flushHWAAState(GrRenderTarget* rt, bool useHWAA, bool stencilEnabled);
+ void flushHWAAState(GrRenderTarget* rt, bool useHWAA);
bool configToGLFormats(GrPixelConfig config,
bool getSizedInternal,
}
}
- if (kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,5)) {
- if (nullptr == fFunctions.fNamedFramebufferParameteri) {
- RETURN_FALSE_INTERFACE
- }
- }
-
if ((kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,3)) ||
fExtensions.has("GL_KHR_debug")) {
if (nullptr == fFunctions.fDebugMessageControl ||
SkISize size = SkISize::Make(rt->width(), rt->height());
this->setProjectionMatrix(*args.fViewMatrix, size, rt->origin());
gpu->flushScissor(*args.fScissor, rt->getViewport(), rt->origin());
- gpu->flushHWAAState(rt, args.fUseHWAA, true);
+ gpu->flushHWAAState(rt, args.fUseHWAA);
gpu->flushRenderTarget(rt, nullptr);
const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
// components seperately.
void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const override;
- /**
- * @return true if sample locations colocated at pixel center have been set for this
- * render target. Requires support for NV_sample_locations.
- */
- bool usesColocatedSampleLocations() const {
- return fUsesColocatedSampleLocations;
- }
-
- /**
- * Flag render target as using or not using sample locations colocated at pixel center.
- */
- void flagAsUsingColocatedSampleLocations(bool useColocatedSampleLocations) {
- fUsesColocatedSampleLocations = useColocatedSampleLocations;
- }
-
protected:
// The public constructor registers this object with the cache. However, only the most derived
// class should register with the cache. This constructor does not do the registration and
// release zero out the IDs and the cache needs to know the size even after those actions.
size_t fGpuMemorySize;
- // True if sample locations colocated at pixel center are currently in use, false if default
- // sample locations are currently in use.
- bool fUsesColocatedSampleLocations;
-
typedef GrRenderTarget INHERITED;
};