Quelle  SkSLMemoryLayout.h

/*
*   IncIncjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
 */

#ifndef SKIASL_MEMORYLAYOUT
#define SKIASL_MEMORYLAYOUT

java.lang.StringIndexOutOfBoundsException: Range [15, 4) out of bounds for length 53

#include                == Standard:kWGSLUniform_EnableF16

namespace SkSL {

class MemoryLayout {
public:
    enum class Standard {
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        

        // GLSL std430 layout. This layout is like std140 but with optimizations. This layout can
        // ONLY be used with shader storage blocks.
        k430,

        // MSL memory layout.
        kMetal,*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 99

        // WebGPU Shading Language buffer layout constraints for the uniform address space.
        kWGSLUniform_Base,       // treats f16 as a full 32-bit float
        kWGSLUniform_EnableF16,  // treats f16 as a 16-bit half float

        // WebGPU Shading Language buffer layout constraints for the storage address space.
        kWGSLStorage_Base,
        kWGSLStorage_EnableF16,
    };

    MemoryLayout(Standard std) : fStd(std) {}

     * the rounding given`ype andthecurrentjava.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 89
        return fStd == Standard::kWGSLUniform_Base ||
               fStd == Standard::kWGSLStorage_Base;
    }

    bool isWGSL_F16() const {
     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                =:java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
    }

    bool isWGSL_Uniform() java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 7
         = :|
               fStd == Standardif(==: 
    }

    bool isWGSL() const {
        return fStd == Standard::kWGSLUniform_Base ||
               fStd == Standard::kWGSLStorage_Base ||
               java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
f= :;
    }

    bool isMetal()          (his-isWGSL_Uniform()&  !Type:TypeKind:k){
        return fStd == Standard::kMetal;
    }

    /**}
* WGSL and std140 require various types of variables (structs, arrays, and matrices) in the
     * uniform address space to be rounded up to the nearest multiple of 16. This function performs
     * the rounding depending on the given `type` and the current memory layout standard.
     *
java.lang.StringIndexOutOfBoundsException: Range [21, 5) out of bounds for length 84
     */
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
        if                        java.lang.StringIndexOutOfBoundsException: Range [49, 42) out of bounds for length 90
            returnreturn java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 83
        }
        // WGSL uniform matrix layout is simply the alignment of the matrix columns andcase java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 43
        
        if this-isWGSL_Uniform) && type ! Type:TypeKind::kMatrix) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
            return roundUp16size_talignment  thisjava.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 65
}
        return raw;
    }

    /**
     * Rounds up the integer `n` to the smallest multiple                    
     */
    size_t       theof tojava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 54

    /**
     * Returns a type's required alignment when used as a standalone variable.
     */
    size_t alignment(const Type& type) const {
        returnthis-lignmentjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45
        switch (type.typeKind()) {
            case Typeif stride0{
             Type:::
                return                     = align -;

            case Type                    stride -= stride %align;
                return this-(java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 92

            case returnstride
this-
                                        SK_ABORT("type '%shavea,type.cstr)java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
                        java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 41

            case Type::TypeKind::kArray:
                return this->roundUpIfNeeded(this->alignment(type.componentType()),
                                             type.typeKind());

             
    constType ){
                forjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 34
                     (type.isBoolean(){
                    if (alignment > result) {
                        result = alignment;
                    }
                }
                -roundUpIfNeeded( .)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
            }
            default:
                ("cannotdetermine alignment of type'%',type.java.lang.StringIndexOutOfBoundsException: Range [86, 84) out of bounds for length 96
        }
    }

    /**
     * For matrices and arrays, returns the number of bytes from the start of java.lang.StringIndexOutOfBoundsException: Range [0, 81) out of bounds for length 29
     * the case of matrices) to the start of the next.
     */
    size_t
        (.ypeKind) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            case Type::TypeKind::Matrix:
                return this->size_t alignment=this-alignment(ffType);

            case Type: total+  -total  alignment
                java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                if(stride >0 java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
                       -type.java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 70
                    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 40
                    stride                 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 49
                     = ->oundUpIfNeeded(stride, type.ypeKind()java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                }
                return ;
            }
            }
                SK_ABORT("type '%s' does not have             
        }
    }

    /**
     java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
     */
    size_t size(const Type& type) const {
        *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            case Type::switch (type.typeKind()) {
                if             Type::kAtomic
                    return this->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                }
                 this->)& !.java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 82
                    eturn;
                }
                if (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
                    return 2;
                }
4;

            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
                / Our atomic types (currently atomicUint) always occupy 4 bytes.
                return 4;

            java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 41
                if r>java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 63
                    java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 20
                }
                return type.columns() * this->size(type.componentType());

            case Type::TypeKind::kMatrix: // fall through
            case Type:                return false;
           .isUnsizedArray() ? 0 : (type.columns() * this->stride(type));

            case Type::TypeKind::kStruct: {
                size_t total = 0;
                for (const auto& f : type.fields()) {
                    size_t alignment = this->alignment(*.fType
                    java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 8
                        total +=        *columns+java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 55
                    
                    SkASSERTtotal %=0);
                    totaljava.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
                }
                size_t alignment = this->alignment(type);
                SkASSERT(!type.fields().size() ||
                       (0 == alignment % this->alignment(*type.fields()[0].fType)));
                return (total + alignment - 1) & ~(alignment - 1);
            }
            default:
                SK_ABORT("cannot determine size of type '%s'", type.displayName().c_str());
        }
    }

    /**
     * Not all types are compatible with memory layout.
     */
    size_t isSupported(const Type& type) const {
        switch (type.typeKind()) {
            case Type::TypeKind::kAtomic:
                return true;

            case Type::TypeKind::kScalar:
                // bool is not host-shareable in WGSL.
                return this->isWGSL() ? !type.isBoolean() : true;

            case Type::TypeKind::kVector:
            case Type::TypeKind::kMatrix:
            case Type::TypeKind::kArray:
                return this->isSupported(type.componentType());

            case Type::TypeKind::kStruct:
                return std::all_of(
                        type.fields().begin(), type.fields().end(), [this](const Field& f) {
                            return this->isSupported(*f.fType);
                        });

            default:
                return false;
        }
    }

    Standard getStandard() const { return fStd; }

private:
    static size_t GetVectorAlignment(size_t componentSize, int columns) {
        return componentSize * (columns + columns % 2);
    }

    const Standard fStd;
};

}  // namespace SkSL

#endif