SkRuntimeEffectPriv Class Reference

#include <SkRuntimeEffectPriv.h>

Classes
struct	UniformsCallbackContext

Public Types
using	UniformsCallback = std::function< sk_sp< const SkData >(const UniformsCallbackContext &)>

Static Public Member Functions
static sk_sp< SkShader >	MakeDeferredShader (const SkRuntimeEffect *effect, UniformsCallback uniformsCallback, SkSpan< const SkRuntimeEffect::ChildPtr > children, const SkMatrix *localMatrix=nullptr)
static bool	SupportsConstantOutputForConstantInput (const SkRuntimeEffect *effect)
static uint32_t	Hash (const SkRuntimeEffect &effect)
static uint32_t	StableKey (const SkRuntimeEffect &effect)
static const SkSL::Program &	Program (const SkRuntimeEffect &effect)
static SkRuntimeEffect::Options	ES3Options ()
static void	AllowPrivateAccess (SkRuntimeEffect::Options *options)
static void	SetStableKey (SkRuntimeEffect::Options *options, uint32_t stableKey)
static SkRuntimeEffect::Uniform	VarAsUniform (const SkSL::Variable &, const SkSL::Context &, size_t *offset)
static SkRuntimeEffect::Child	VarAsChild (const SkSL::Variable &var, int index)
static const char *	ChildTypeToStr (SkRuntimeEffect::ChildType type)
static sk_sp< const SkData >	TransformUniforms (SkSpan< const SkRuntimeEffect::Uniform > uniforms, sk_sp< const SkData > originalData, const SkColorSpaceXformSteps &)
static sk_sp< const SkData >	TransformUniforms (SkSpan< const SkRuntimeEffect::Uniform > uniforms, sk_sp< const SkData > originalData, const SkColorSpace *dstCS)
static SkSpan< const float >	UniformsAsSpan (SkSpan< const SkRuntimeEffect::Uniform > uniforms, sk_sp< const SkData > originalData, bool alwaysCopyIntoAlloc, const SkColorSpace *destColorSpace, SkArenaAlloc *alloc)
static bool	CanDraw (const SkCapabilities *, const SkSL::Program *)
static bool	CanDraw (const SkCapabilities *, const SkRuntimeEffect *)
static bool	ReadChildEffects (SkReadBuffer &buffer, const SkRuntimeEffect *effect, skia_private::TArray< SkRuntimeEffect::ChildPtr > *children)
static void	WriteChildEffects (SkWriteBuffer &buffer, SkSpan< const SkRuntimeEffect::ChildPtr > children)
static bool	UsesColorTransform (const SkRuntimeEffect *effect)

Detailed Description

Definition at line 50 of file SkRuntimeEffectPriv.h.

Member Typedef Documentation

UniformsCallback

using SkRuntimeEffectPriv::UniformsCallback = std::function<sk_sp<const SkData>(const UniformsCallbackContext&)>

Definition at line 62 of file SkRuntimeEffectPriv.h.

Member Function Documentation

AllowPrivateAccess()

static void SkRuntimeEffectPriv::AllowPrivateAccess ( SkRuntimeEffect::Options *  options )

inlinestatic

Definition at line 96 of file SkRuntimeEffectPriv.h.

                                                                    {
        options->allowPrivateAccess = true;
    }

CanDraw() [1/2]

bool SkRuntimeEffectPriv::CanDraw ( const SkCapabilities *  caps, const SkRuntimeEffect *  effect  )

static

Definition at line 358 of file SkRuntimeEffect.cpp.

                                                                                           {
    SkASSERT(effect);
    return CanDraw(caps, effect->fBaseProgram.get());
}

CanDraw() [2/2]

bool SkRuntimeEffectPriv::CanDraw ( const SkCapabilities *  caps, const SkSL::Program *  program  )

static

Definition at line 352 of file SkRuntimeEffect.cpp.

                                                                                        {
    SkASSERT(caps && program);
    SkASSERT(program->fConfig->enforcesSkSLVersion());
    return program->fConfig->fRequiredSkSLVersion <= caps->skslVersion();
}

ChildTypeToStr()

const char * SkRuntimeEffectPriv::ChildTypeToStr ( SkRuntimeEffect::ChildType  type )

static

Definition at line 142 of file SkRuntimeEffect.cpp.

                                                              {
    switch (type) {
        case ChildType::kBlender:     return "blender";
        case ChildType::kColorFilter: return "color filter";
        case ChildType::kShader:      return "shader";
        default: SkUNREACHABLE;
    }
}

ES3Options()

static SkRuntimeEffect::Options SkRuntimeEffectPriv::ES3Options ( )

inlinestatic

Definition at line 90 of file SkRuntimeEffectPriv.h.

                                               {
        SkRuntimeEffect::Options options;
        options.maxVersionAllowed = SkSL::Version::k300;
        return options;
    }

Hash()

static uint32_t SkRuntimeEffectPriv::Hash ( const SkRuntimeEffect &  effect )

inlinestatic

Definition at line 78 of file SkRuntimeEffectPriv.h.

                                                        {
        return effect.hash();
    }

MakeDeferredShader()

sk_sp< SkShader > SkRuntimeEffectPriv::MakeDeferredShader ( const SkRuntimeEffect *  effect, UniformsCallback  uniformsCallback, SkSpan< const SkRuntimeEffect::ChildPtr >  children, const SkMatrix *  localMatrix = nullptr  )

static

Definition at line 800 of file SkRuntimeEffect.cpp.

                                     {
    if (!effect->allowShader()) {
        return nullptr;
    }
    if (!verify_child_effects(effect->fChildren, children)) {
        return nullptr;
    }
    if (!uniformsCallback) {
        return nullptr;
    }
    return SkLocalMatrixShader::MakeWrapped<SkRuntimeShader>(localMatrix,
                                                             sk_ref_sp(effect),
                                                             /*debugTrace=*/nullptr,
                                                             std::move(uniformsCallback),
                                                             children);
}

Program()

static const SkSL::Program & SkRuntimeEffectPriv::Program ( const SkRuntimeEffect &  effect )

inlinestatic

Definition at line 86 of file SkRuntimeEffectPriv.h.

                                                                     {
        return *effect.fBaseProgram;
    }

ReadChildEffects()

bool SkRuntimeEffectPriv::ReadChildEffects ( SkReadBuffer &  buffer, const SkRuntimeEffect *  effect, skia_private::TArray< SkRuntimeEffect::ChildPtr > *  children  )

static

If effect is specified, then the number and type of child objects are validated against the children() of effect. If it's nullptr, this is skipped, allowing deserialization of children, even when the effect could not be constructed (ie, due to malformed SkSL).

Definition at line 403 of file SkRuntimeEffect.cpp.

                                                                                      {
    size_t childCount = buffer.read32();
    if (effect && !buffer.validate(childCount == effect->children().size())) {
        return false;
    }
 
    children->clear();
    children->reserve_exact(childCount);
 
    for (size_t i = 0; i < childCount; i++) {
        sk_sp<SkFlattenable> obj(buffer.readRawFlattenable());
        if (!flattenable_is_valid_as_child(obj.get())) {
            buffer.validate(false);
            return false;
        }
        children->push_back(std::move(obj));
    }
 
    // If we are validating against an effect, make sure any (non-null) children are the right type
    if (effect) {
        auto childInfo = effect->children();
        SkASSERT(childInfo.size() == SkToSizeT(children->size()));
        for (size_t i = 0; i < childCount; i++) {
            std::optional<ChildType> ct = (*children)[i].type();
            if (ct.has_value() && (*ct) != childInfo[i].type) {
                buffer.validate(false);
            }
        }
    }
 
    return buffer.isValid();
}

SetStableKey()

static void SkRuntimeEffectPriv::SetStableKey ( SkRuntimeEffect::Options *  options, uint32_t  stableKey  )

inlinestatic

Definition at line 100 of file SkRuntimeEffectPriv.h.

                                                                                  {
        options->fStableKey = stableKey;
    }

StableKey()

static uint32_t SkRuntimeEffectPriv::StableKey ( const SkRuntimeEffect &  effect )

inlinestatic

Definition at line 82 of file SkRuntimeEffectPriv.h.

                                                             {
        return effect.fStableKey;
    }

SupportsConstantOutputForConstantInput()

static bool SkRuntimeEffectPriv::SupportsConstantOutputForConstantInput ( const SkRuntimeEffect *  effect )

inlinestatic

Definition at line 70 of file SkRuntimeEffectPriv.h.

                                                                                      {
        // This optimization is only implemented for color filters without any children.
        if (!effect->allowColorFilter() || !effect->children().empty()) {
            return false;
        }
        return true;
    }

TransformUniforms() [1/2]

sk_sp< const SkData > SkRuntimeEffectPriv::TransformUniforms ( SkSpan< const SkRuntimeEffect::Uniform >  uniforms, sk_sp< const SkData >  originalData, const SkColorSpace *  dstCS  )

static

Definition at line 159 of file SkRuntimeEffect.cpp.

                                   {
    if (!dstCS) {
        // There's no destination color-space; we can early-out immediately.
        return originalData;
    }
    SkColorSpaceXformSteps steps(sk_srgb_singleton(), kUnpremul_SkAlphaType,
                                 dstCS,               kUnpremul_SkAlphaType);
    return TransformUniforms(uniforms, std::move(originalData), steps);
}

TransformUniforms() [2/2]

sk_sp< const SkData > SkRuntimeEffectPriv::TransformUniforms ( SkSpan< const SkRuntimeEffect::Uniform >  uniforms, sk_sp< const SkData >  originalData, const SkColorSpaceXformSteps &  steps  )

static

Definition at line 172 of file SkRuntimeEffect.cpp.

                                             {
    using Flags = SkRuntimeEffect::Uniform::Flags;
    using Type  = SkRuntimeEffect::Uniform::Type;
 
    sk_sp<SkData> data = nullptr;
    auto writableData = [&]() {
        if (!data) {
            data = SkData::MakeWithCopy(originalData->data(), originalData->size());
        }
        return data->writable_data();
    };
 
    for (const auto& u : uniforms) {
        if (u.flags & Flags::kColor_Flag) {
            SkASSERT(u.type == Type::kFloat3 || u.type == Type::kFloat4);
            if (steps.flags.mask()) {
                float* color = SkTAddOffset<float>(writableData(), u.offset);
                if (u.type == Type::kFloat4) {
                    // RGBA, easy case
                    for (int i = 0; i < u.count; ++i) {
                        steps.apply(color);
                        color += 4;
                    }
                } else {
                    // RGB, need to pad out to include alpha. Technically, this isn't necessary,
                    // because steps shouldn't include unpremul or premul, and thus shouldn't
                    // read or write the fourth element. But let's be safe.
                    float rgba[4];
                    for (int i = 0; i < u.count; ++i) {
                        memcpy(rgba, color, 3 * sizeof(float));
                        rgba[3] = 1.0f;
                        steps.apply(rgba);
                        memcpy(color, rgba, 3 * sizeof(float));
                        color += 3;
                    }
                }
            }
        }
    }
    return data ? data : originalData;
}

UniformsAsSpan()

SkSpan< const float > SkRuntimeEffectPriv::UniformsAsSpan ( SkSpan< const SkRuntimeEffect::Uniform >  uniforms, sk_sp< const SkData >  originalData, bool  alwaysCopyIntoAlloc, const SkColorSpace *  destColorSpace, SkArenaAlloc *  alloc  )

static

Definition at line 260 of file SkRuntimeEffect.cpp.

                             {
    // Transform the uniforms into the destination colorspace.
    sk_sp<const SkData> transformedData = SkRuntimeEffectPriv::TransformUniforms(uniforms,
                                                                                 originalData,
                                                                                 destColorSpace);
    if (alwaysCopyIntoAlloc || originalData != transformedData) {
        // The transformed uniform data's lifetime is not long enough to reuse; instead, we copy the
        // uniform data directly into the alloc.
        int numBytes = transformedData->size();
        int numFloats = numBytes / sizeof(float);
        float* uniformsInAlloc = alloc->makeArrayDefault<float>(numFloats);
        memcpy(uniformsInAlloc, transformedData->data(), numBytes);
        return SkSpan{uniformsInAlloc, numFloats};
    }
    // It's safe to return a pointer into existing data.
    return SkSpan{static_cast<const float*>(originalData->data()),
                  originalData->size() / sizeof(float)};
}

UsesColorTransform()

static bool SkRuntimeEffectPriv::UsesColorTransform ( const SkRuntimeEffect *  effect )

inlinestatic

Definition at line 137 of file SkRuntimeEffectPriv.h.

                                                                  {
        return effect->usesColorTransform();
    }

VarAsChild()

SkRuntimeEffect::Child SkRuntimeEffectPriv::VarAsChild ( const SkSL::Variable &  var, int  index  )

static

Definition at line 151 of file SkRuntimeEffect.cpp.

                                                                                       {
    SkRuntimeEffect::Child c;
    c.name  = var.name();
    c.type  = child_type(var.type());
    c.index = index;
    return c;
}

VarAsUniform()

SkRuntimeEffect::Uniform SkRuntimeEffectPriv::VarAsUniform ( const SkSL::Variable &  var, const SkSL::Context &  context, size_t *  offset  )

static

Definition at line 101 of file SkRuntimeEffect.cpp.

                                                                           {
    using Uniform = SkRuntimeEffect::Uniform;
    SkASSERT(var.modifierFlags().isUniform());
    Uniform uni;
    uni.name = var.name();
    uni.flags = 0;
    uni.count = 1;
 
    const SkSL::Type* type = &var.type();
    if (type->isArray()) {
        uni.flags |= Uniform::kArray_Flag;
        uni.count = type->columns();
        type = &type->componentType();
    }
 
    if (type->hasPrecision() && !type->highPrecision()) {
        uni.flags |= Uniform::kHalfPrecision_Flag;
    }
 
    SkAssertResult(init_uniform_type(context, type, &uni));
    if (var.layout().fFlags & SkSL::LayoutFlag::kColor) {
        uni.flags |= Uniform::kColor_Flag;
    }
 
    uni.offset = *offset;
    *offset += uni.sizeInBytes();
    SkASSERT(SkIsAlign4(*offset));
    return uni;
}

WriteChildEffects()

void SkRuntimeEffectPriv::WriteChildEffects ( SkWriteBuffer &  buffer, SkSpan< const SkRuntimeEffect::ChildPtr >  children  )

static

Definition at line 438 of file SkRuntimeEffect.cpp.

                                                                               {
    buffer.write32(children.size());
    for (const auto& child : children) {
        buffer.writeFlattenable(child.flattenable());
    }
}

---

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

• third_party/skia/src/core/SkRuntimeEffectPriv.h
• third_party/skia/src/core/SkRuntimeEffect.cpp