GrGLGpu::SamplerObjectCache Class Reference

Public Member Functions
	SamplerObjectCache (GrGLGpu *gpu)
	~SamplerObjectCache ()
void	bindSampler (int unitIdx, GrSamplerState state)
void	unbindSampler (int unitIdx)
void	invalidateBindings ()
void	abandon ()
void	release ()

Detailed Description

Definition at line 277 of file GrGLGpu.cpp.

Constructor & Destructor Documentation

SamplerObjectCache()

GrGLGpu::SamplerObjectCache::SamplerObjectCache ( GrGLGpu *  gpu )

inline

Definition at line 279 of file GrGLGpu.cpp.

                                     : fGpu(gpu) {
        fNumTextureUnits = fGpu->glCaps().shaderCaps()->fMaxFragmentSamplers;
        fTextureUnitStates = std::make_unique<UnitState[]>(fNumTextureUnits);
    }

~SamplerObjectCache()

GrGLGpu::SamplerObjectCache::~SamplerObjectCache ( )

inline

Definition at line 284 of file GrGLGpu.cpp.

                          {
        if (!fNumTextureUnits) {
            // We've already been abandoned.
            return;
        }
    }

Member Function Documentation

abandon()

void GrGLGpu::SamplerObjectCache::abandon ( )

inline

Definition at line 347 of file GrGLGpu.cpp.

                   {
        fSamplers.foreach([](uint32_t* key, Sampler* sampler) { sampler->abandon(); });
        fTextureUnitStates.reset();
        fNumTextureUnits = 0;
    }

bindSampler()

void GrGLGpu::SamplerObjectCache::bindSampler ( int  unitIdx, GrSamplerState  state  )

inline

Definition at line 291 of file GrGLGpu.cpp.

                                                        {
        if (unitIdx >= fNumTextureUnits) {
            return;
        }
        // In GL the max aniso value is specified in addition to min/mag filters and the driver
        // is encouraged to consider the other filter settings when doing aniso.
        uint32_t key = state.asKey(/*anisoIsOrthogonal=*/true);
        const Sampler* sampler = fSamplers.find(key);
        if (!sampler) {
            GrGLuint s;
            GR_GL_CALL(fGpu->glInterface(), GenSamplers(1, &s));
            if (!s) {
                return;
            }
            sampler = fSamplers.insert(key, Sampler(s, fGpu->glInterface()));
            GrGLenum minFilter = filter_to_gl_min_filter(state.filter(), state.mipmapMode());
            GrGLenum magFilter = filter_to_gl_mag_filter(state.filter());
            GrGLenum wrapX = wrap_mode_to_gl_wrap(state.wrapModeX(), fGpu->glCaps());
            GrGLenum wrapY = wrap_mode_to_gl_wrap(state.wrapModeY(), fGpu->glCaps());
            GR_GL_CALL(fGpu->glInterface(),
                       SamplerParameteri(s, GR_GL_TEXTURE_MIN_FILTER, minFilter));
            GR_GL_CALL(fGpu->glInterface(),
                       SamplerParameteri(s, GR_GL_TEXTURE_MAG_FILTER, magFilter));
            GR_GL_CALL(fGpu->glInterface(), SamplerParameteri(s, GR_GL_TEXTURE_WRAP_S, wrapX));
            GR_GL_CALL(fGpu->glInterface(), SamplerParameteri(s, GR_GL_TEXTURE_WRAP_T, wrapY));
            SkASSERT(fGpu->glCaps().anisoSupport() || !state.isAniso());
            if (fGpu->glCaps().anisoSupport()) {
                float maxAniso = std::min(static_cast<GrGLfloat>(state.maxAniso()),
                                          fGpu->glCaps().maxTextureMaxAnisotropy());
                GR_GL_CALL(fGpu->glInterface(), SamplerParameterf(s,
                                                                  GR_GL_TEXTURE_MAX_ANISOTROPY,
                                                                  maxAniso));
            }
        }
        SkASSERT(sampler && sampler->id());
        if (!fTextureUnitStates[unitIdx].fKnown ||
            fTextureUnitStates[unitIdx].fSamplerIDIfKnown != sampler->id()) {
            GR_GL_CALL(fGpu->glInterface(), BindSampler(unitIdx, sampler->id()));
            fTextureUnitStates[unitIdx].fSamplerIDIfKnown = sampler->id();
            fTextureUnitStates[unitIdx].fKnown = true;
        }
    }

invalidateBindings()

void GrGLGpu::SamplerObjectCache::invalidateBindings ( )

inline

Definition at line 343 of file GrGLGpu.cpp.

                              {
        std::fill_n(fTextureUnitStates.get(), fNumTextureUnits, UnitState{});
    }

release()

void GrGLGpu::SamplerObjectCache::release ( )

inline

Definition at line 353 of file GrGLGpu.cpp.

                   {
        if (!fNumTextureUnits) {
            // We've already been abandoned.
            return;
        }
        fSamplers.reset();
        // Deleting a bound sampler implicitly binds sampler 0. We just invalidate all of our
        // knowledge.
        std::fill_n(fTextureUnitStates.get(), fNumTextureUnits, UnitState{});
    }

unbindSampler()

void GrGLGpu::SamplerObjectCache::unbindSampler ( int  unitIdx )

inline

Definition at line 334 of file GrGLGpu.cpp.

                                    {
        if (!fTextureUnitStates[unitIdx].fKnown ||
            fTextureUnitStates[unitIdx].fSamplerIDIfKnown != 0) {
            GR_GL_CALL(fGpu->glInterface(), BindSampler(unitIdx, 0));
            fTextureUnitStates[unitIdx].fSamplerIDIfKnown = 0;
            fTextureUnitStates[unitIdx].fKnown = true;
        }
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/src/gpu/ganesh/gl/GrGLGpu.cpp