skgpu::graphite::UniformManager Class Reference

#include <UniformManager.h>

Public Member Functions
	UniformManager (Layout layout)
UniformDataBlock	finishUniformDataBlock ()
size_t	size () const
void	resetWithNewLayout (Layout layout)
void	reset ()
void	write (float f)
void	write (int32_t i)
void	writeHalf (float f)
void	write (const SkPMColor4f &c)
void	write (const SkRect &r)
void	write (const SkV4 &v)
void	write (const SkIRect &r)
void	writeHalf (const SkPMColor4f &c)
void	writeHalf (const SkRect &r)
void	writeHalf (const SkV4 &v)
void	writeArray (SkSpan< const SkV4 > v)
void	writeArray (SkSpan< const SkPMColor4f > c)
void	writeHalfArray (SkSpan< const SkPMColor4f > c)
void	write (const SkV3 &v)
void	write (const SkPoint3 &p)
void	writeHalf (const SkV3 &v)
void	writeHalf (const SkPoint3 &p)
void	write (const SkV2 &v)
void	write (const SkSize &s)
void	write (const SkPoint &p)
void	write (const SkISize &s)
void	writeHalf (const SkV2 &v)
void	writeHalf (const SkSize &s)
void	writeHalf (const SkPoint &p)
void	write (const SkM44 &m)
void	writeHalf (const SkM44 &m)
void	write (const SkMatrix &m)
void	writeHalf (const SkMatrix &m)
void	writePaintColor (const SkPMColor4f &color)
void	write (const Uniform &, const void *src)

Detailed Description

Definition at line 198 of file UniformManager.h.

Constructor & Destructor Documentation

UniformManager()

skgpu::graphite::UniformManager::UniformManager ( Layout  layout )

inline

Definition at line 200 of file UniformManager.h.

{ this->resetWithNewLayout(layout); }

Member Function Documentation

finishUniformDataBlock()

UniformDataBlock skgpu::graphite::UniformManager::finishUniformDataBlock

(

)

Definition at line 51 of file UniformManager.cpp.

                                                        {
    size_t size = SkAlignTo(fStorage.size(), fReqAlignment);
    size_t paddingSize = size - fStorage.size();
    if (paddingSize > 0) {
        char* padding = fStorage.append(paddingSize);
        memset(padding, 0, paddingSize);
    }
    return UniformDataBlock(SkSpan(fStorage.begin(), size));
}

reset()

void skgpu::graphite::UniformManager::reset ( )

inline

Definition at line 206 of file UniformManager.h.

{ this->resetWithNewLayout(fLayout); }

resetWithNewLayout()

void skgpu::graphite::UniformManager::resetWithNewLayout

(

Layout

layout

)

Definition at line 61 of file UniformManager.cpp.

                                                     {
    fStorage.clear();
    fLayout = layout;
    fReqAlignment = 0;
    fWrotePaintColor = false;
 
#ifdef SK_DEBUG
    fOffsetCalculator = UniformOffsetCalculator(layout, 0);
    fExpectedUniforms = {};
    fExpectedUniformIndex = 0;
#endif
}

size()

size_t skgpu::graphite::UniformManager::size ( ) const

inline

Definition at line 203 of file UniformManager.h.

{ return fStorage.size(); }

write() [1/15]

void skgpu::graphite::UniformManager::write ( const SkIRect &  r )

inline

Definition at line 218 of file UniformManager.h.

{ this->write<SkSLType::kInt4>(&r); }

write() [2/15]

void skgpu::graphite::UniformManager::write ( const SkISize &  s )

inline

Definition at line 248 of file UniformManager.h.

{ this->write<SkSLType::kInt2>(&s); }

write() [3/15]

void skgpu::graphite::UniformManager::write ( const SkM44 &  m )

inline

Definition at line 257 of file UniformManager.h.

                               {
        // All Layouts treat a 4x4 column-major matrix as an array of vec4's, which is exactly how
        // SkM44 already stores its data.
        this->writeArray<SkSLType::kFloat4>(SkMatrixPriv::M44ColMajor(m), 4);
    }

write() [4/15]

void skgpu::graphite::UniformManager::write ( const SkMatrix &  m )

inline

Definition at line 267 of file UniformManager.h.

                                  {
        // SkMatrix is row-major, so rewrite to column major. All Layouts treat a 3x3 column
        // major matrix as an array of vec3's.
        float colMajor[9] = {m[0], m[3], m[6],
                             m[1], m[4], m[7],
                             m[2], m[5], m[8]};
        this->writeArray<SkSLType::kFloat3>(colMajor, 3);
    }

write() [5/15]

void skgpu::graphite::UniformManager::write ( const SkPMColor4f &  c )

inline

Definition at line 214 of file UniformManager.h.

{ this->write<SkSLType::kFloat4>(c.vec()); }

write() [6/15]

void skgpu::graphite::UniformManager::write ( const SkPoint &  p )

inline

Definition at line 246 of file UniformManager.h.

{ this->write<SkSLType::kFloat2>(&p); }

write() [7/15]

void skgpu::graphite::UniformManager::write ( const SkPoint3 &  p )

inline

Definition at line 236 of file UniformManager.h.

{ this->write<SkSLType::kFloat3>(&p); }

write() [8/15]

void skgpu::graphite::UniformManager::write ( const SkRect &  r )

inline

Definition at line 215 of file UniformManager.h.

{ this->write<SkSLType::kFloat4>(r.asScalars()); }

write() [9/15]

void skgpu::graphite::UniformManager::write ( const SkSize &  s )

inline

Definition at line 245 of file UniformManager.h.

{ this->write<SkSLType::kFloat2>(&s); }

write() [10/15]

void skgpu::graphite::UniformManager::write ( const SkV2 &  v )

inline

Definition at line 244 of file UniformManager.h.

{ this->write<SkSLType::kFloat2>(v.ptr()); }

write() [11/15]

void skgpu::graphite::UniformManager::write ( const SkV3 &  v )

inline

Definition at line 235 of file UniformManager.h.

{ this->write<SkSLType::kFloat3>(v.ptr()); }

write() [12/15]

void skgpu::graphite::UniformManager::write ( const SkV4 &  v )

inline

Definition at line 216 of file UniformManager.h.

{ this->write<SkSLType::kFloat4>(v.ptr()); }

write() [13/15]

void skgpu::graphite::UniformManager::write	(	const Uniform &	u,
		const void *	src
	)

Definition at line 92 of file UniformManager.cpp.

                                                             {
    SkASSERT(SkSLTypeCanBeUniformValue(u.type()));
    SkASSERT(!u.isPaintColor()); // Must go through writePaintColor()
 
    auto [type, count] = adjust_for_matrix_type(u.type(), u.count());
    SkASSERT(SkSLTypeMatrixSize(type) < 0); // Matrix types should have been flattened
 
    const bool fullPrecision = LayoutRules::UseFullPrecision(fLayout) || !IsHalfVector(type);
    if (count == Uniform::kNonArray) {
        if (fullPrecision) {
            switch(SkSLTypeVecLength(type)) {
                case 1: this->write<1, /*Half=*/false>(data, type); break;
                case 2: this->write<2, /*Half=*/false>(data, type); break;
                case 3: this->write<3, /*Half=*/false>(data, type); break;
                case 4: this->write<4, /*Half=*/false>(data, type); break;
            }
        } else {
            switch(SkSLTypeVecLength(type)) {
                case 1: this->write<1, /*Half=*/true>(data, type); break;
                case 2: this->write<2, /*Half=*/true>(data, type); break;
                case 3: this->write<3, /*Half=*/true>(data, type); break;
                case 4: this->write<4, /*Half=*/true>(data, type); break;
            }
        }
    } else {
        if (fullPrecision) {
            switch(SkSLTypeVecLength(type)) {
                case 1: this->writeArray<1, /*Half=*/false>(data, count, type); break;
                case 2: this->writeArray<2, /*Half=*/false>(data, count, type); break;
                case 3: this->writeArray<3, /*Half=*/false>(data, count, type); break;
                case 4: this->writeArray<4, /*Half=*/false>(data, count, type); break;
            }
        } else {
            switch(SkSLTypeVecLength(type)) {
                case 1: this->writeArray<1, /*Half=*/true>(data, count, type); break;
                case 2: this->writeArray<2, /*Half=*/true>(data, count, type); break;
                case 3: this->writeArray<3, /*Half=*/true>(data, count, type); break;
                case 4: this->writeArray<4, /*Half=*/true>(data, count, type); break;
            }
        }
    }
}

write() [14/15]

void skgpu::graphite::UniformManager::write ( float  f )

inline

Definition at line 209 of file UniformManager.h.

{ this->write<SkSLType::kFloat>(&f); }

write() [15/15]

void skgpu::graphite::UniformManager::write ( int32_t  i )

inline

Definition at line 210 of file UniformManager.h.

{ this->write<SkSLType::kInt  >(&i); }

writeArray() [1/2]

void skgpu::graphite::UniformManager::writeArray ( SkSpan< const SkPMColor4f >  c )

inline

Definition at line 227 of file UniformManager.h.

                                                 {
        this->writeArray<SkSLType::kFloat4>(c.data(), c.size());
    }

writeArray() [2/2]

void skgpu::graphite::UniformManager::writeArray ( SkSpan< const SkV4 >  v )

inline

Definition at line 224 of file UniformManager.h.

                                          {
        this->writeArray<SkSLType::kFloat4>(v.data(), v.size());
    }

writeHalf() [1/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkM44 &  m )

inline

Definition at line 263 of file UniformManager.h.

                                   {
        this->writeArray<SkSLType::kHalf4>(SkMatrixPriv::M44ColMajor(m), 4);
    }

writeHalf() [2/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkMatrix &  m )

inline

Definition at line 275 of file UniformManager.h.

                                      {
        float colMajor[9] = {m[0], m[3], m[6],
                             m[1], m[4], m[7],
                             m[2], m[5], m[8]};
        this->writeArray<SkSLType::kHalf3>(colMajor, 3);
    }

writeHalf() [3/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkPMColor4f &  c )

inline

Definition at line 220 of file UniformManager.h.

{ this->write<SkSLType::kHalf4>(c.vec()); }

writeHalf() [4/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkPoint &  p )

inline

Definition at line 252 of file UniformManager.h.

{ this->write<SkSLType::kHalf2>(&p); }

writeHalf() [5/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkPoint3 &  p )

inline

Definition at line 239 of file UniformManager.h.

{ this->write<SkSLType::kHalf3>(&p); }

writeHalf() [6/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkRect &  r )

inline

Definition at line 221 of file UniformManager.h.

{ this->write<SkSLType::kHalf4>(r.asScalars()); }

writeHalf() [7/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkSize &  s )

inline

Definition at line 251 of file UniformManager.h.

{ this->write<SkSLType::kHalf2>(&s); }

writeHalf() [8/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkV2 &  v )

inline

Definition at line 250 of file UniformManager.h.

{ this->write<SkSLType::kHalf2>(v.ptr()); }

writeHalf() [9/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkV3 &  v )

inline

Definition at line 238 of file UniformManager.h.

{ this->write<SkSLType::kHalf3>(v.ptr()); }

writeHalf() [10/11]

void skgpu::graphite::UniformManager::writeHalf ( const SkV4 &  v )

inline

Definition at line 222 of file UniformManager.h.

{ this->write<SkSLType::kHalf4>(v.ptr()); }

writeHalf() [11/11]

void skgpu::graphite::UniformManager::writeHalf ( float  f )

inline

Definition at line 211 of file UniformManager.h.

{ this->write<SkSLType::kHalf >(&f); }

writeHalfArray()

void skgpu::graphite::UniformManager::writeHalfArray ( SkSpan< const SkPMColor4f >  c )

inline

Definition at line 230 of file UniformManager.h.

                                                     {
        this->writeArray<SkSLType::kHalf4>(c.data(), c.size());
    }

writePaintColor()

void skgpu::graphite::UniformManager::writePaintColor ( const SkPMColor4f &  color )

inline

Definition at line 287 of file UniformManager.h.

                                                   {
        if (fWrotePaintColor) {
            // Validate expected uniforms, but don't write a second copy since the paint color
            // uniform can only ever be declared once in the final SkSL program.
            SkASSERT(this->checkExpected(/*dst=*/nullptr, SkSLType::kFloat4, Uniform::kNonArray));
        } else {
            this->write<SkSLType::kFloat4>(&color);
            fWrotePaintColor = true;
        }
    }

---

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

• third_party/skia/src/gpu/graphite/UniformManager.h
• third_party/skia/src/gpu/graphite/UniformManager.cpp