lava 0.4.9

Rust wrapper to manipulate Vulkan more conveniently than with bindings.
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

const {
    toPascalCase,
    getRawVkTypeName,
    getWrappedVkTypeName,
    findEnumPrefix,
    documentType
} = require('./utils');

function generateVkEnumDefinition(cDef) {
    cDef.rawTypeName = getRawVkTypeName(cDef.name);
    cDef.wrappedTypeName = getWrappedVkTypeName(cDef.name);

    const prefix = findEnumPrefix(cDef.name);
    const extSuffix = `_${cDef.extension.toUpperCase()}`;

    for (let field of cDef.fields) {
        const suffix = field.name.endsWith(extSuffix) ? extSuffix : '';
        const strippedName = field.name.substring(prefix.length, field.name.length - suffix.length);
        
        field.rustName = formatEnumFieldName(strippedName);
    }

    return [
        genUses(),
        genWrappedType(cDef),
        genRawType(cDef),
        genImplVkWrappedType(cDef),
        genImplVkRawType(cDef),
        genImplDefault(cDef)
    ];
}


function genUses() {
    return [
        `utils::vk_traits::*`
    ].map(str => `use ${str};`);
}

function genRawType(def) {
    return [
        `#[doc(hidden)]`,
        `pub type ${def.rawTypeName} = i32;`
    ];
}

function genWrappedType(def) {
    return [
        documentType(def),
        `#[repr(i32)]`,
        `#[derive(Debug, PartialEq, Copy, Clone)]`,
        `pub enum ${def.wrappedTypeName}`,
        def.fields.map(({rustName, value}) => `${rustName} = ${value},`)
    ];
}

function genImplVkRawType(def) {
    return [
        `impl VkRawType<${def.wrappedTypeName}> for ${def.rawTypeName}`, [
            `fn vk_to_wrapped(src: &${def.rawTypeName}) -> ${def.wrappedTypeName}`, [
                `unsafe`, [
                    `*((src as *const i32) as *const ${def.wrappedTypeName})`
                ]
            ],
        ]
    ];
}

function genImplVkWrappedType(def) {
    return [
        `impl VkWrappedType<${def.rawTypeName}> for ${def.wrappedTypeName}`, [
            `fn vk_to_raw(src: &${def.wrappedTypeName}, dst: &mut ${def.rawTypeName})`, [
                `*dst = *src as i32`
            ]
        ]
    ];
}

function genImplDefault(def) {
    if (!def.fields[0]) {
        console.log(def.name)
    }

    return [
        `impl Default for ${def.wrappedTypeName}`, [
            `fn default() -> ${def.wrappedTypeName}`, [
                `${def.wrappedTypeName}::${def.fields[0].rustName}`
            ]
        ]
    ];
}

function formatEnumFieldName(name) {
    return toPascalCase(name)
        .replace(/^(\d)/, '_$1');
}

module.exports = {
    generateVkEnumDefinition
};