expo-gl/build/GLUtils.js

import GLErrors from './GLErrors';
import { GLLoggingOption } from './GLView.types';
/**
 * Maximum length of the strings printed to the console.
 */
const MAX_STRING_LENGTH = 20;
/**
 * Sets up `__expoSetLogging` method providing some logging options useful when debugging GL calls.
 */
export function configureLogging(gl) {
    // Enable/disable logging of all GL function calls
    let loggingOption = GLLoggingOption.DISABLED;
    gl.__expoSetLogging = (option) => {
        // If boolean values are the same, just change the internal value,
        // there is no need to wrap/unwrap functions in this case.
        if (!loggingOption === !option) {
            loggingOption = option;
            return;
        }
        // Turn off logging.
        if (!option || option === GLLoggingOption.DISABLED) {
            Object.entries(gl).forEach(([key, value]) => {
                if (typeof value === 'function' && value.original) {
                    gl[key] = value.original;
                }
            });
            loggingOption = option;
            return;
        }
        // Turn on logging.
        Object.entries(gl).forEach(([key, originalValue]) => {
            if (typeof originalValue !== 'function' || key === '__expoSetLogging') {
                return;
            }
            gl[key] = (...args) => {
                if (loggingOption & GLLoggingOption.METHOD_CALLS) {
                    const params = args.map(arg => {
                        // If the type is `number`, then try to find name of the constant that has such value,
                        // so it's easier to read these logs. In some cases it might be misleading
                        // if the parameter is for example a width or height, so the number is still logged.
                        if (loggingOption & GLLoggingOption.RESOLVE_CONSTANTS && typeof arg === 'number') {
                            for (const prop in gl) {
                                if (gl[prop] === arg) {
                                    return `${arg} (${prop})`;
                                }
                            }
                        }
                        // Truncate strings so they don't produce too much output and don't block the bridge.
                        // It mostly applies to shaders which might be very long...
                        if (loggingOption & GLLoggingOption.TRUNCATE_STRINGS && typeof arg === 'string') {
                            if (arg.length > MAX_STRING_LENGTH) {
                                const lastIndex = arg.lastIndexOf(' ', MAX_STRING_LENGTH);
                                return arg.substr(0, lastIndex >= 0 ? lastIndex : MAX_STRING_LENGTH) + '...';
                            }
                        }
                        // Just return the parameter as a string.
                        return '' + arg;
                    });
                    console.log(`ExpoGL: ${key}(${params.join(', ')})`);
                }
                const result = originalValue.apply(gl, args);
                if (loggingOption & GLLoggingOption.METHOD_CALLS) {
                    console.log(`ExpoGL:   = ${result}`);
                }
                if (loggingOption & GLLoggingOption.GET_ERRORS && key !== 'getError') {
                    // @ts-ignore We need to call into the original `getError`.
                    const error = gl.getError.original.call(gl);
                    if (error && error !== gl.NO_ERROR) {
                        // `console.error` would cause a red screen, so let's just log with red color.
                        console.log(`\x1b[31mExpoGL: Error ${GLErrors[error]}\x1b[0m`);
                    }
                }
                return result;
            };
            gl[key].original = originalValue;
        });
        loggingOption = option;
    };
}
//# sourceMappingURL=GLUtils.js.map