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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

const {
    getFieldsInformation
} = require('./utils');

const { EXTENSIONS } = require('./data');

function generateFunctionTableDefinition(functions) {
    for (let func of functions) {
        if (!func.argsInfo) {
            func.argsInfo = getFieldsInformation(func.args);
        }
    }

    return [
        `#![allow(non_snake_case)]`,
        genUses(functions),
        genDefinition(functions),
        genFromMethods(functions),
        genNullFunctions(functions),
        genExterns(functions)
    ];
}

const FUNCTION_TABLE_NAME = 'VkFunctionTable';

function genUses() {
    return [
        `std::os::raw::c_char`,
        `std::mem`,
        `utils::c_bindings::*`,
        `utils::vk_convert::{get_vk_instance_function_pointer, get_vk_device_function_pointer}`,
        'vulkan::vk::*',
        `vulkan::{${EXTENSIONS.map(str => str.toLowerCase()).join(',')}}`
    ].map(x => `use ${x};`);
}

function genDefinition(functions) {
    return [
        `#[doc(hidden)]`,
        `pub struct ${FUNCTION_TABLE_NAME}`, [
            `pub instance: RawVkInstance,`,
            `pub device: RawVkDevice,`,
            ...functions.map(func => `pub ${func.name}: ${functionToDeclaration(func)},`)
        ]
    ];
}

function getArgType(arg) {
    let type = arg.rawType;

    if (arg.extension) {
        type = type.replace(arg.rawTypeName, `${arg.extension}::${arg.rawTypeName}`)
    }

    return type;
}

function functionToDeclaration(func) {
    const args = func.argsInfo.map(getArgType);
    const returnType = func.type === 'VkResult' ? ' -> RawVkResult' : '';

    return `unsafe extern fn(${args.join(', ')})${returnType}`;
}

function getVkFunctionPrototype(func) {
    const args = func.argsInfo.map(arg => `${arg.varName}: ${getArgType(arg)}`);
    const returnType = func.type === 'VkResult' ? ' -> RawVkResult' : '';

    return `(${args.join(', ')})${returnType}`;
}

function genNullFunctions(functions) {
    return genNullFunctionsForParent(functions, 'instance').concat(genNullFunctionsForParent(functions, 'device'));
}

function genNullFunctionsForParent(functions, parent) {
    return functions.filter(func => func.name.startsWith('vk')).map(func => {
        const funcName = `null_${parent}_${func.name}`;

        return [
            `unsafe extern fn ${funcName}${getVkFunctionPrototype(func)}`, [
                `panic!("\\"vkGet${parent.capitalize()}ProcAddr\\" returned NULL for \\"${func.name}\\"");`
            ]
        ];
    }).reduce((acc, value) => acc.concat(value), []);
}

function getFunctionPointer(func, parent) {
    if (func.name.startsWith('vk')) {
        return `{ let fn_ptr = get_vk_${parent}_function_pointer(${parent}, "${func.name}"); if fn_ptr.is_null() { null_${parent}_${func.name} } else { mem::transmute(fn_ptr) } }`;
    } else {
        return func.name;
    }
}

function genFromMethods(functions) {
    return [
        `impl ${FUNCTION_TABLE_NAME}`, [
            `pub fn from_instance(instance: RawVkInstance) -> Self`, [
                `unsafe`, [
                    `Self`, [
                        `instance: instance,`,
                        `device: 0,`,
                        ...functions.map(func => `${func.name}: ${getFunctionPointer(func, 'instance')},`)
                    ]
                ]
            ],
            `pub fn from_device(device: RawVkDevice) -> Self`, [
                `unsafe`, [
                    `Self`, [
                        `instance: 0,`,
                        `device: device,`,
                        ...functions.map(func => `${func.name}: ${getFunctionPointer(func, 'device')},`)
                    ]
                ]
            ]
        ]
    ]
}

function genExterns(functions) {
    const externs = functions.filter(func => !func.name.startsWith('vk'));

    if (externs.length) {
        return [
            `extern`,
            externs.map(func => `fn ${func.name}${getVkFunctionPrototype(func)};`)
        ]
    }
}

module.exports = {
    generateFunctionTableDefinition,
    getVkFunctionPrototype
};