QDSpy_core_shader.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
QDSpy module - GLSL shader related class

'ShaderManager'
  Class to manage available user-defined shaders
  This class is a graphics API independent.

Copyright (c) 2013-2024 Thomas Euler
All rights reserved.

2024-06-29 - Reformatted (using Ruff)
"""
# ---------------------------------------------------------------------
__author__ = "code@eulerlab.de"

import os
import QDSpy_global as glo
import QDSpy_file_support as fsu
import Libraries.log_helper as _log
from Graphics.shader_opengl import Shader

# ---------------------------------------------------------------------
class ShaderFileCmd:
    ShaderName = "shadername"
    ShaderParamNames = "shaderparamnames"
    ShaderParamLengths = "shaderparamlengths"
    ShaderParamDefaults = "shaderparamdefaults"
    ShaderVertexStart = "shadervertexstart"
    ShaderVertexEnd = "shadervertexend"
    ShaderFragmentStart = "shaderfragmentstart"
    ShaderFragmentEnd = "shaderfragmentend"

# ---------------------------------------------------------------------
# Shader manager class
# ---------------------------------------------------------------------
class ShaderManager:
    def __init__(self, _Conf, _path: str):
        # Initializing
        self.Conf = _Conf
        self.ShFileList = []
        self.ShDesc = []
        self.ShTypes = []
        self.ShVertCode = []
        self.ShFragCode = []
        pshader = self.Conf.pathShader

        # Make a list of the available shader files ...
        f = []
        for dirpath, dirnames, filenames in os.walk(pshader):
            f.extend(filenames)
            break
        for fName in f:
            if (os.path.splitext(fName)[1]).lower() == glo.QDSpy_shaderFileExt:
                #self.ShFileList.append(pshader + fName)
                self.ShFileList.append(fsu.getJoinedPath(pshader, fName))

        # Parse each shader file ...
        isInVert = False
        isInFrag = False
        for fName in self.ShFileList:
            shName = ""
            shPara = []
            shParaLen = []
            shParaDef = []
            strShVert = []
            strShFrag = []

            with open(fName, "r") as fRef:
                for line in fRef:
                    pos = line.lower().find(glo.QDSpy_shaderFileCmdTok)
                    if pos >= 0:
                        # QDS command token found, get parameters into a list ...
                        tmp = (
                            (line[pos + len(glo.QDSpy_shaderFileCmdTok) :])
                            .strip()
                            .split("=")
                        )
                        cmd = [tmp[0].strip()]
                        if len(tmp) > 1:
                            tmp = tmp[1].split(";")
                            for par in tmp:
                                cmd.append(par.strip())

                        # Interpret command ...
                        if cmd[0].lower() == ShaderFileCmd.ShaderName:
                            shName = cmd[1]
                        elif cmd[0].lower() == ShaderFileCmd.ShaderParamNames:
                            shPara = cmd[1:]
                        elif cmd[0].lower() == ShaderFileCmd.ShaderParamLengths:
                            for tmp in cmd[1:]:
                                shParaLen.append(int(tmp))
                        elif cmd[0].lower() == ShaderFileCmd.ShaderParamDefaults:
                            shParaDef = cmd[1:]
                        elif cmd[0].lower() == ShaderFileCmd.ShaderVertexStart:
                            isInVert = True
                        elif cmd[0].lower() == ShaderFileCmd.ShaderVertexEnd:
                            isInVert = False
                        elif cmd[0].lower() == ShaderFileCmd.ShaderFragmentStart:
                            isInFrag = True
                        elif cmd[0].lower() == ShaderFileCmd.ShaderFragmentEnd:
                            isInFrag = False

                    else:
                        if isInVert:
                            strShVert.append(line)
                        elif isInFrag:
                            strShFrag.append(line)

            # Close file and append shader description and code to the lists
            fRef.close()
            self.ShDesc.append([shName, shPara, shParaLen, shParaDef])
            self.ShVertCode.append(strShVert)
            self.ShFragCode.append(strShFrag)
            self.ShTypes.append(shName)

        _log.Log.write(
            "{0:8}".format(" WARNING" if len(self.ShTypes) == 0 else " "),
            "{0} shader type(s) found".format(len(self.ShTypes)),
        )

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    def getShaderTypes(self):
        """ Returns list of loaded shader types
        """
        return self.ShTypes

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    def getShaderTypeIndex(self, _shType):
        """ Returns index of shader type
        """
        try:
            return self.ShTypes.index(_shType)
        except ValueError:
            return -1

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    def getDefaultParams(self, _shType):
        """ Returns list of default parameter vales for the shader type
        """
        res = []
        try:
            iShD = self.ShTypes.index(_shType)
            for i, par in enumerate(self.ShDesc[iShD][3]):
                if self.ShDesc[iShD][2][i] == 1:
                    # Is singular value
                    res.append(float(par))

                else:
                    # Multiple values, add as tuple
                    tmp = par.strip("()").split(",")
                    sub = []
                    for elem in tmp:
                        sub.append(float(elem))
                    res.append(tuple(sub))
        except ValueError:
            pass

        return res

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    def createShader(self, _shType):
        """ Load a pair of vertex and fragment shader from the standard
        folder, create a shader program, compile and link the shader
        code and return reference
        """
        shader = None
        try:
            iShD = self.ShTypes.index(_shType)
            shader = Shader(self.ShVertCode[iShD], self.ShFragCode[iShD])
        except ValueError:
            pass

        if shader.nErrors > 0:
            _log.Log.write("ERROR", "Creating shader(s) failed:")
            for msg in shader.errStrs:
                _log.Log.write(" ", msg)
            return None

        return shader


# ---------------------------------------------------------------------