ncca-ngl 0.3.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

ncca/ngl/shader_program.py

@@ -84,6 +84,7 @@ class ShaderProgram:
         For array uniforms, it also registers individual array elements.
         """
         uniform_count = gl.glGetProgramiv(self._id, gl.GL_ACTIVE_UNIFORMS)
+
         for i in range(uniform_count):
             name, size, shader_type = gl.glGetActiveUniform(self._id, i, 256)
 
@@ -92,9 +93,7 @@ class ShaderProgram:
 
             # Handle array uniforms - OpenGL returns name with [0] for arrays
             is_array = size > 1
-            base_name = name_str
-            if name_str.endswith("[0]"):
-                base_name = name_str[:-3]
+            base_name = name_str[:-3] if name_str.endswith("[0]") else name_str
 
             location = gl.glGetUniformLocation(self._id, name)
 
@@ -103,33 +102,31 @@ class ShaderProgram:
 
             # For arrays, also register individual elements
             if is_array:
-                for element_idx in range(size):
-                    element_name = f"{base_name}[{element_idx}]"
-                    element_location = gl.glGetUniformLocation(
-                        self._id, element_name.encode("utf-8")
-                    )
-                    if element_location != -1:
-                        # Store individual array element: (location, shader_type, 1, False)
-                        self._uniforms[element_name] = (
-                            element_location,
-                            shader_type,
-                            1,
-                            False,
-                        )
-
-            # Log array uniforms differently
-            if is_array:
+                self._register_array_elements(base_name, size, shader_type)
                 logger.info(
                     f"Registered array uniform: {base_name}[{size}] (type: {self.get_gl_type_string(shader_type)}, location: {location})"
                 )
-                logger.info(
-                    f"  Also registered individual elements: {base_name}[0] to {base_name}[{size - 1}]"
-                )
+                logger.info(f"  Also registered individual elements: {base_name}[0] to {base_name}[{size - 1}]")
             else:
                 logger.info(
                     f"Registered uniform: {base_name} (type: {self.get_gl_type_string(shader_type)}, location: {location})"
                 )
 
+    def _register_array_elements(self, base_name: str, size: int, shader_type) -> None:
+        """Register individual elements of an array uniform."""
+        for element_idx in range(size):
+            element_name = f"{base_name}[{element_idx}]"
+            element_location = gl.glGetUniformLocation(self._id, element_name.encode("utf-8"))
+
+            if element_location != -1:
+                # Store individual array element: (location, shader_type, 1, False)
+                self._uniforms[element_name] = (
+                    element_location,
+                    shader_type,
+                    1,
+                    False,
+                )
+
     def auto_register_uniform_blocks(self) -> None:
         """
         Automatically register uniform blocks for this shader program.
@@ -147,14 +144,8 @@ class ShaderProgram:
             name_buffer = (ctypes.c_char * 256)()
             length = ctypes.c_int()
 
-            gl.glGetActiveUniformBlockName(
-                self._id, i, 256, ctypes.byref(length), name_buffer
-            )
-            name_str = (
-                name_buffer.value.decode("utf-8")
-                if name_buffer.value
-                else f"UniformBlock_{i}"
-            )
+            gl.glGetActiveUniformBlockName(self._id, i, 256, ctypes.byref(length), name_buffer)
+            name_str = name_buffer.value.decode("utf-8") if name_buffer.value else f"UniformBlock_{i}"
 
             # Create uniform block data structure
             data = {
@@ -252,9 +243,7 @@ class ShaderProgram:
             bool: True if successful, False otherwise
         """
         if uniform_block_name not in self._registered_uniform_blocks:
-            logger.error(
-                f"Uniform block '{uniform_block_name}' not found in shader '{self._name}'"
-            )
+            logger.error(f"Uniform block '{uniform_block_name}' not found in shader '{self._name}'")
             return False
 
         block = self._registered_uniform_blocks[uniform_block_name]
@@ -292,73 +281,75 @@ class ShaderProgram:
             *value: The value(s) to set
         """
         loc = self.get_uniform_location(name)
+
         if loc == -1:
             logger.warning(f"Uniform location not found for '{name}'")
             return
 
-        # Get uniform info for better type handling
-        uniform_info = self.get_uniform_info(name)
-        _, uniform_type, array_size, is_array = uniform_info
-
         if len(value) == 1:
-            val = value[0]
-            if isinstance(val, int):
-                gl.glUniform1i(loc, val)
-            elif isinstance(val, float):
-                gl.glUniform1f(loc, val)
-            elif isinstance(val, Mat2):
-                gl.glUniformMatrix2fv(
-                    loc, 1, gl.GL_FALSE, (ctypes.c_float * 4)(*val.get_matrix())
-                )
-            elif isinstance(val, Mat3):
-                gl.glUniformMatrix3fv(
-                    loc, 1, gl.GL_FALSE, (ctypes.c_float * 9)(*val.get_matrix())
-                )
-            elif isinstance(val, Mat4):
-                gl.glUniformMatrix4fv(
-                    loc, 1, gl.GL_FALSE, (ctypes.c_float * 16)(*val.get_matrix())
-                )
-            elif isinstance(val, Vec2):
-                gl.glUniform2f(loc, *val)
-            elif isinstance(val, Vec3):
-                gl.glUniform3f(loc, *val)
-            elif isinstance(val, Vec4):
-                gl.glUniform4f(loc, *val)
-            else:
-                try:
-                    val = list(value[0])
-                    if len(val) == 4:
-                        gl.glUniformMatrix2fv(
-                            loc, 1, gl.GL_FALSE, (ctypes.c_float * 4)(*val)
-                        )
-                    elif len(val) == 9:
-                        gl.glUniformMatrix3fv(
-                            loc, 1, gl.GL_FALSE, (ctypes.c_float * 9)(*val)
-                        )
-                    elif len(val) == 16:
-                        gl.glUniformMatrix4fv(
-                            loc, 1, gl.GL_FALSE, (ctypes.c_float * 16)(*val)
-                        )
-                except TypeError:
-                    logger.warning(
-                        f"Warning: uniform '{name}' has unknown type: {type(val)}"
-                    )
-
-        elif len(value) == 2:
-            if isinstance(value[0], int):
-                gl.glUniform2i(loc, *value)
-            else:
-                gl.glUniform2f(loc, *value)
-        elif len(value) == 3:
-            if isinstance(value[0], int):
-                gl.glUniform3i(loc, *value)
-            else:
-                gl.glUniform3f(loc, *value)
-        elif len(value) == 4:
-            if isinstance(value[0], int):
-                gl.glUniform4i(loc, *value)
-            else:
-                gl.glUniform4f(loc, *value)
+            self._set_single_value_uniform(loc, name, value[0])
+        else:
+            self._set_multi_value_uniform(loc, value)
+
+    def _set_single_value_uniform(self, loc: int, name: str, val: Any) -> None:
+        """Handle setting a uniform from a single value."""
+        if isinstance(val, int):
+            gl.glUniform1i(loc, val)
+        elif isinstance(val, float):
+            gl.glUniform1f(loc, val)
+        elif isinstance(val, (Mat2, Mat3, Mat4)):
+            self._set_matrix_uniform(loc, val)
+        elif isinstance(val, (Vec2, Vec3, Vec4)):
+            self._set_vector_uniform(loc, val)
+        else:
+            self._set_list_based_uniform(loc, name, val)
+
+    def _set_matrix_uniform(self, loc: int, matrix: Any) -> None:
+        """Set a matrix uniform value."""
+        matrix_configs = {
+            Mat2: (4, gl.glUniformMatrix2fv),
+            Mat3: (9, gl.glUniformMatrix3fv),
+            Mat4: (16, gl.glUniformMatrix4fv),
+        }
+
+        size, func = matrix_configs[type(matrix)]
+        data = (ctypes.c_float * size)(*matrix.get_matrix())
+        func(loc, 1, gl.GL_FALSE, data)
+
+    def _set_vector_uniform(self, loc: int, vector: Any) -> None:
+        """Set a vector uniform value."""
+        vector_funcs = {Vec2: gl.glUniform2f, Vec3: gl.glUniform3f, Vec4: gl.glUniform4f}
+
+        func = vector_funcs[type(vector)]
+        func(loc, *vector)
+
+    def _set_list_based_uniform(self, loc: int, name: str, val: Any) -> None:
+        """Handle setting uniform from list-like values (potential matrices)."""
+        try:
+            val_list = list(val)
+            matrix_sizes = {4: gl.glUniformMatrix2fv, 9: gl.glUniformMatrix3fv, 16: gl.glUniformMatrix4fv}
+
+            if len(val_list) in matrix_sizes:
+                func = matrix_sizes[len(val_list)]
+                data = (ctypes.c_float * len(val_list))(*val_list)
+                func(loc, 1, gl.GL_FALSE, data)
+        except TypeError:
+            logger.warning(f"Warning: uniform '{name}' has unknown type: {type(val)}")
+
+    def _set_multi_value_uniform(self, loc: int, value: tuple) -> None:
+        """Handle setting uniform from multiple values (vectors)."""
+        value_len = len(value)
+        is_int = isinstance(value[0], int)
+
+        uniform_funcs = {
+            2: (gl.glUniform2i if is_int else gl.glUniform2f),
+            3: (gl.glUniform3i if is_int else gl.glUniform3f),
+            4: (gl.glUniform4i if is_int else gl.glUniform4f),
+        }
+
+        if value_len in uniform_funcs:
+            func = uniform_funcs[value_len]
+            func(loc, *value)
 
     def set_uniform_1fv(self, name: str, values: List[float]) -> None:
         """
@@ -385,9 +376,7 @@ class ShaderProgram:
         loc = self.get_uniform_location(name)
         if loc != -1:
             flat_values = [item for vec in values for item in vec]
-            gl.glUniform2fv(
-                loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values)
-            )
+            gl.glUniform2fv(loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values))
 
     def set_uniform_3fv(self, name: str, values: List[List[float]]) -> None:
         """
@@ -401,9 +390,7 @@ class ShaderProgram:
         loc = self.get_uniform_location(name)
         if loc != -1:
             flat_values = [item for vec in values for item in vec]
-            gl.glUniform3fv(
-                loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values)
-            )
+            gl.glUniform3fv(loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values))
 
     def set_uniform_4fv(self, name: str, values: List[List[float]]) -> None:
         """
@@ -417,9 +404,7 @@ class ShaderProgram:
         loc = self.get_uniform_location(name)
         if loc != -1:
             flat_values = [item for vec in values for item in vec]
-            gl.glUniform4fv(
-                loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values)
-            )
+            gl.glUniform4fv(loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values))
 
     def set_uniform_1iv(self, name: str, values: List[int]) -> None:
         """
@@ -861,9 +846,7 @@ class ShaderProgram:
                 base_name = name.split("[")[0]
                 if base_name not in array_elements:
                     array_elements[base_name] = []
-                array_elements[base_name].append(
-                    (name, location, uniform_type, size, is_array)
-                )
+                array_elements[base_name].append((name, location, uniform_type, size, is_array))
             else:
                 base_uniforms[name] = (location, uniform_type, size, is_array)
 
@@ -871,20 +854,16 @@ class ShaderProgram:
         for name, (location, uniform_type, size, is_array) in base_uniforms.items():
             type_str = self.get_gl_type_string(uniform_type)
             if is_array:
-                logger.info(
-                    f"  {name}[{size}] (type: {type_str}, location: {location})"
-                )
+                logger.info(f"  {name}[{size}] (type: {type_str}, location: {location})")
             else:
                 logger.info(f"  {name} (type: {type_str}, location: {location})")
 
         # Print array elements grouped by base name
         for base_name, elements in array_elements.items():
             logger.info(f"  Array elements for {base_name}:")
-            for element_name, location, uniform_type, size, is_array in elements:
+            for element_name, location, uniform_type, _, _ in elements:
                 type_str = self.get_gl_type_string(uniform_type)
-                logger.info(
-                    f"    {element_name} (type: {type_str}, location: {location})"
-                )
+                logger.info(f"    {element_name} (type: {type_str}, location: {location})")
 
     def print_registered_uniform_blocks(self) -> None:
         """
@@ -922,6 +901,4 @@ class ShaderProgram:
         if self._registered_uniform_blocks:
             logger.info("  Registered uniform blocks:")
             for name, data in self._registered_uniform_blocks.items():
-                logger.info(
-                    f"    {name} (index: {data['loc']}, buffer: {data['buffer']})"
-                )
+                logger.info(f"    {name} (index: {data['loc']}, buffer: {data['buffer']})")

ncca/ngl/texture.py

@@ -50,6 +50,10 @@ class Texture:
         return self._image.get_pixels().tobytes()
 
     def set_texture_gl(self) -> int:
+        """ "
+        Generate a texture ID and set the texture parameters, if the image is valid if not return 0
+        which is the default texture ID for not active in OpenGL
+        """
         if self._image.width > 0 and self._image.height > 0:
             self._texture_id = gl.glGenTextures(1)
             gl.glActiveTexture(gl.GL_TEXTURE0 + self._multi_texture_id)
@@ -68,8 +72,7 @@ class Texture:
                 self.get_pixels(),
             )
             gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
-            return self._texture_id
-        return 0
+        return self._texture_id
 
     def set_multi_texture(self, id: int) -> None:
         self._multi_texture_id = id

ncca/ngl/util.py

@@ -161,5 +161,3 @@ def hash_combine(seed, h):
     seed = (seed + 0x9E3779B9 + ((seed << 6) & 0xFFFFFFFFFFFFFFFF) + (seed >> 2)) & 0xFFFFFFFFFFFFFFFF
     seed ^= h
     return seed
-
-