SkSL::RP::Program Class Reference

#include <SkSLRasterPipelineBuilder.h>

Classes
class	Dumper

Public Member Functions
	Program (skia_private::TArray< Instruction > instrs, int numValueSlots, int numUniformSlots, int numImmutableSlots, int numLabels, DebugTracePriv *debugTrace)
	~Program ()
bool	appendStages (SkRasterPipeline *pipeline, SkArenaAlloc *alloc, Callbacks *callbacks, SkSpan< const float > uniforms) const
void	dump (SkWStream *out, bool writeInstructionCount=false) const
int	numUniforms () const

Friends
class	Dumper

Detailed Description

Definition at line 152 of file SkSLRasterPipelineBuilder.h.

Constructor & Destructor Documentation

Program()

SkSL::RP::Program::Program	(	skia_private::TArray< Instruction >	instrs,
		int	numValueSlots,
		int	numUniformSlots,
		int	numImmutableSlots,
		int	numLabels,
		DebugTracePriv *	debugTrace
	)

Definition at line 1390 of file SkSLRasterPipelineBuilder.cpp.

        : fInstructions(std::move(instrs))
        , fNumValueSlots(numValueSlots)
        , fNumUniformSlots(numUniformSlots)
        , fNumImmutableSlots(numImmutableSlots)
        , fNumLabels(numLabels)
        , fDebugTrace(debugTrace) {
    this->optimize();
 
    fTempStackMaxDepths = this->tempStackMaxDepths();
 
    fNumTempStackSlots = 0;
    for (const int depth : fTempStackMaxDepths) {
        fNumTempStackSlots += depth;
    }
 
    if (fDebugTrace) {
        fTraceHook = SkSL::Tracer::Make(&fDebugTrace->fTraceInfo);
    }
}

~Program()

SkSL::RP::Program::~Program ( )

default

Member Function Documentation

appendStages()

bool SkSL::RP::Program::appendStages	(	SkRasterPipeline *	pipeline,
		SkArenaAlloc *	alloc,
		RP::Callbacks *	callbacks,
		SkSpan< const float >	uniforms
	)		const

Definition at line 1652 of file SkSLRasterPipelineBuilder.cpp.

                                                               {
#if defined(SKSL_STANDALONE)
    return false;
#else
    // Convert our Instruction list to an array of ProgramOps.
    TArray<Stage> stages;
    SlotData slotData = this->allocateSlotData(alloc);
    this->makeStages(&stages, alloc, uniforms, slotData);
 
    // Allocate buffers for branch targets and labels; these are needed to convert labels into
    // actual offsets into the pipeline and fix up branches.
    TArray<SkRasterPipeline_BranchCtx*> branchContexts;
    branchContexts.reserve_exact(fNumLabels);
    TArray<int> labelOffsets;
    labelOffsets.push_back_n(fNumLabels, -1);
    TArray<int> branchGoesToLabel;
    branchGoesToLabel.reserve_exact(fNumLabels);
 
    auto resetBasePointer = [&]() {
        // Whenever we hand off control to another shader, we have to assume that it might overwrite
        // the base pointer (if it uses SkSL, it will!), so we reset it on return.
        pipeline->append(SkRasterPipelineOp::set_base_pointer, slotData.values.data());
    };
 
    resetBasePointer();
 
    for (const Stage& stage : stages) {
        switch (stage.op) {
            case ProgramOp::stack_rewind:
                pipeline->appendStackRewind();
                break;
 
            case ProgramOp::invoke_shader:
                if (!callbacks || !callbacks->appendShader(sk_bit_cast<intptr_t>(stage.ctx))) {
                    return false;
                }
                resetBasePointer();
                break;
 
            case ProgramOp::invoke_color_filter:
                if (!callbacks || !callbacks->appendColorFilter(sk_bit_cast<intptr_t>(stage.ctx))) {
                    return false;
                }
                resetBasePointer();
                break;
 
            case ProgramOp::invoke_blender:
                if (!callbacks || !callbacks->appendBlender(sk_bit_cast<intptr_t>(stage.ctx))) {
                    return false;
                }
                resetBasePointer();
                break;
 
            case ProgramOp::invoke_to_linear_srgb:
                if (!callbacks) {
                    return false;
                }
                callbacks->toLinearSrgb(stage.ctx);
                // A ColorSpaceXform shouldn't ever alter the base pointer, so we don't need to call
                // resetBasePointer here.
                break;
 
            case ProgramOp::invoke_from_linear_srgb:
                if (!callbacks) {
                    return false;
                }
                callbacks->fromLinearSrgb(stage.ctx);
                // A ColorSpaceXform shouldn't ever alter the base pointer, so we don't need to call
                // resetBasePointer here.
                break;
 
            case ProgramOp::label: {
                // Remember the absolute pipeline position of this label.
                int labelID = sk_bit_cast<intptr_t>(stage.ctx);
                SkASSERT(labelID >= 0 && labelID < fNumLabels);
                labelOffsets[labelID] = pipeline->getNumStages();
                break;
            }
            case ProgramOp::jump:
            case ProgramOp::branch_if_all_lanes_active:
            case ProgramOp::branch_if_any_lanes_active:
            case ProgramOp::branch_if_no_lanes_active:
            case ProgramOp::branch_if_no_active_lanes_eq: {
                // The branch context contain a valid label ID at this point.
                auto* branchCtx = static_cast<SkRasterPipeline_BranchCtx*>(stage.ctx);
                int labelID = branchCtx->offset;
                SkASSERT(labelID >= 0 && labelID < fNumLabels);
 
                // Replace the label ID in the branch context with the absolute pipeline position.
                // We will go back over the branch targets at the end and fix them up.
                branchCtx->offset = pipeline->getNumStages();
 
                SkASSERT(branchContexts.size() == branchGoesToLabel.size());
                branchContexts.push_back(branchCtx);
                branchGoesToLabel.push_back(labelID);
                [[fallthrough]];
            }
            default:
                // Append a regular op to the program.
                SkASSERT((int)stage.op < kNumRasterPipelineHighpOps);
                pipeline->append((SkRasterPipelineOp)stage.op, stage.ctx);
                break;
        }
    }
 
    // Now that we have assembled the program and know the pipeline positions of each label and
    // branch, fix up every branch target.
    SkASSERT(branchContexts.size() == branchGoesToLabel.size());
    for (int index = 0; index < branchContexts.size(); ++index) {
        int branchFromIdx = branchContexts[index]->offset;
        int branchToIdx = labelOffsets[branchGoesToLabel[index]];
        branchContexts[index]->offset = branchToIdx - branchFromIdx;
    }
 
    return true;
#endif
}

dump()

void SkSL::RP::Program::dump	(	SkWStream *	out,
		bool	writeInstructionCount = false
	)		const

Definition at line 3771 of file SkSLRasterPipelineBuilder.cpp.

                                                                   {
    Dumper(*this).dump(out, writeInstructionCount);
}

numUniforms()

int SkSL::RP::Program::numUniforms ( ) const

inline

Definition at line 169 of file SkSLRasterPipelineBuilder.h.

{ return fNumUniformSlots; }

Friends And Related Function Documentation

Dumper

friend class Dumper

friend

Definition at line 281 of file SkSLRasterPipelineBuilder.h.

---

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

• third_party/skia/src/sksl/codegen/SkSLRasterPipelineBuilder.h
• third_party/skia/src/sksl/codegen/SkSLRasterPipelineBuilder.cpp