mozangle 0.5.3

Mozilla's fork of Google ANGLE, repackaged as a Rust crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#include "GLSLANG/ShaderLang.h"
#include "common/utilities.h"

extern "C" int GLSLangInitialize()
{
    if (sh::Initialize())
        return 1;
    return 0;
}

extern "C" int GLSLangFinalize()
{
    if (sh::Finalize())
        return 1;
    return 0;
}

extern "C" void GLSLangInitBuiltInResources(ShBuiltInResources *resources)
{
    sh::InitBuiltInResources(resources);
}

extern "C" const char *GLSLangGetBuiltInResourcesString(const ShHandle handle)
{
    return sh::GetBuiltInResourcesString(handle).c_str();
}

extern "C" ShHandle GLSLangConstructCompiler(unsigned int type,
                                             unsigned int spec,
                                             unsigned int output,
                                             const ShBuiltInResources *resources)
{
    return sh::ConstructCompiler(static_cast<sh::GLenum>(type),
                                 static_cast<ShShaderSpec>(spec),
                                 static_cast<ShShaderOutput>(output),
                                 resources);
}

extern "C" void GLSLangDestructCompiler(ShHandle handle)
{
    sh::Destruct(handle);
}

extern "C" int GLSLangCompile(const ShHandle handle,
                              const char *const shaderStrings[],
                              size_t numStrings,
                              const ShCompileOptions &compileOptions)
{
    if (sh::Compile(handle, shaderStrings, numStrings, compileOptions))
        return 1;

    return 0;
}

extern "C" void GLSLangClearResults(const ShHandle handle)
{
    sh::ClearResults(handle);
}

extern "C" int GLSLangGetShaderVersion(const ShHandle handle)
{
    return sh::GetShaderVersion(handle);
}

extern "C" int GLSLangGetShaderOutputType(const ShHandle handle)
{
    return sh::GetShaderOutputType(handle);
}

extern "C" const char *GLSLangGetInfoLog(const ShHandle handle)
{
    return sh::GetInfoLog(handle).c_str();
}

// Returns null-terminated object code for a compiled shader.
// Parameters:
// handle: Specifies the compiler
extern "C" const char *GLSLangGetObjectCode(const ShHandle handle)
{
    return sh::GetObjectCode(handle).c_str();
}

using StrPairFunction = void (*)(void *, const char *, size_t, const char *, size_t);

extern "C" void GLSLangIterUniformNameMapping(const ShHandle handle, StrPairFunction each, void *closure_each)
{
    for (auto &uniform : *sh::GetUniforms(handle))
    {
        each(
            closure_each,
            uniform.name.data(), uniform.name.length(),
            uniform.mappedName.data(), uniform.mappedName.length());
    }
}

// Returns the number of vectors that the shader's active varyings fit
// in to without additional packing. Can be used to test whether a
// shader will compile on drivers that do not perform spec-compliant
// packing. This contrasts with sh::CheckVariablesWithinPackingLimits
// which does pack the varyings in accordance with the spec.
extern "C" int GLSLangGetNumUnpackedVaryingVectors(const ShHandle handle)
{
    int total_rows = 0;
    const std::vector<sh::Varying> *varyings = sh::GetVaryings(handle);

    if (varyings)
    {
        for (const auto &varying : *varyings)
        {
            if (varying.active)
            {
                total_rows += gl::VariableRowCount(varying.type) * varying.getArraySizeProduct();
            }
        }
    }

    return total_rows;
}