ncca-ngl 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

ncca/ngl/widgets/__init__.py

@@ -0,0 +1,12 @@
+__version__ = "0.1.0"
+
+
+from .lookatwidget import LookAtWidget
+from .rgbacolourwidget import RGBAColourWidget
+from .rgbcolourwidget import RGBColourWidget
+from .transformwidget import TransformWidget
+from .vec2widget import Vec2Widget
+from .vec3widget import Vec3Widget
+from .vec4widget import Vec4Widget
+
+__all__ = ["Vec2Widget", "Vec3Widget", "Vec4Widget", "TransformWidget", "LookAtWidget", "RGBColourWidget"]

ncca/ngl/widgets/__main__.py

@@ -0,0 +1,77 @@
+import sys
+
+from PySide6.QtWidgets import QApplication, QDialog, QGridLayout, QLabel
+
+from ncca.ngl import Vec2, Vec3, Vec4
+from ncca.ngl.widgets import (
+    LookAtWidget,
+    RGBAColourWidget,
+    RGBColourWidget,
+    TransformWidget,
+    Vec2Widget,
+    Vec3Widget,
+    Vec4Widget,
+)
+
+
+class SimpleDialog(QDialog):
+    def __init__(self, parent=None):
+        super(SimpleDialog, self).__init__(parent)
+        self.setWindowTitle("PyNGL ncca.widgets library ")
+        self.setMinimumWidth(200)
+        layout = QGridLayout()
+
+        self.vec2_widget = Vec2Widget("Vec2 Widget", Vec2(1, 2), self)
+        self.vec2_widget.set_x_range(-1, 1)
+        self.vec2_widget.set_y_range(-2, 2)
+        layout.addWidget(self.vec2_widget, 0, 0)
+        self.vec2_label = QLabel("[0.0,0.0]")
+        layout.addWidget(self.vec2_label, 0, 1)
+        self.vec2_widget.valueChanged.connect(self._update_vec2)
+
+        self.vec3_widget = Vec3Widget("Vec3 Widget", Vec3(1, 2, 3), self)
+        self.vec3_widget.set_y_range(-2, 2)
+        self.vec3_widget.set_z_range(-3, 3)
+        layout.addWidget(self.vec3_widget, 1, 0)
+        self.vec3_label = QLabel("[0.0,0.0,0.0]")
+        layout.addWidget(self.vec3_label, 1, 1)
+        self.vec3_widget.valueChanged.connect(self._update_vec3)
+
+        self.vec4_widget = Vec4Widget("Vec4 Widget", Vec4(1, 2, 3, 1.0), self)
+        self.vec4_widget.set_y_range(-2, 2)
+        self.vec4_widget.set_z_range(-3, 3)
+        layout.addWidget(self.vec4_widget, 2, 0)
+        self.vec4_label = QLabel("[0.0,0.0,0.0,1.0]")
+        layout.addWidget(self.vec4_label, 2, 1)
+        self.vec4_widget.valueChanged.connect(self._update_vec4)
+
+        self.transform_widget = TransformWidget("Transform Widget", self)
+        layout.addWidget(self.transform_widget, 3, 0)
+
+        self.lookat = LookAtWidget("Look At", parent=self)
+        layout.addWidget(self.lookat, 4, 0)
+
+        self.rgb_colour_widget = RGBColourWidget("RGB Colour Widget", 1.0, 0.0, 0.0, self)
+        layout.addWidget(self.rgb_colour_widget, 5, 0)
+        self.rgba_colour_widget = RGBAColourWidget("RGB Colour Widget", 1.0, 0.0, 0.0, 1.0, self)
+        layout.addWidget(self.rgba_colour_widget, 6, 0)
+
+        self.setLayout(layout)
+
+    def _update_vec3(self, value):
+        self.vec3_label.setText(f"[{value.x:0.2f}, {value.y:0.2f}, {value.z:0.2f}]")
+
+    def _update_vec2(self, value):
+        self.vec2_label.setText(f"[{value.x:0.2f}, {value.y:0.2f}]")
+
+    def _update_vec4(self, value):
+        self.vec4_label.setText(f"[{value.x:0.2f}, {value.y:0.2f}, {value.z:0.2f}, {value.w:0.2f}]")
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    print("NCCA Widgets")
+
+    dialog = SimpleDialog()
+    dialog.show()
+    app.exec()

ncca/ngl/widgets/glsl/phong.frag

@@ -0,0 +1,27 @@
+#version 330 core
+out vec4 FragColor;
+in vec3 FragPos;
+in vec3 Normal;
+uniform vec3 light_pos;
+uniform vec3 view_pos;
+uniform vec3 light_color;
+uniform vec3 object_color;
+void main()
+{
+    // Ambient
+    float ambient_strength = 0.1;
+    vec3 ambient = ambient_strength * light_color;
+    // Diffuse
+    vec3 norm = normalize(Normal);
+    vec3 light_dir = normalize(light_pos - FragPos);
+    float diff = max(dot(norm, light_dir), 0.0);
+    vec3 diffuse = diff * light_color;
+    // Specular
+    float specular_strength = 0.5;
+    vec3 view_dir = normalize(view_pos - FragPos);
+    vec3 reflect_dir = reflect(-light_dir, norm);
+    float spec = pow(max(dot(view_dir, reflect_dir), 0.0), 32);
+    vec3 specular = specular_strength * spec * light_color;
+    vec3 result = (ambient + diffuse + specular) * object_color;
+    FragColor = vec4(result, 1.0);
+}

ncca/ngl/widgets/glsl/phong.vert

@@ -0,0 +1,14 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+out vec3 FragPos;
+out vec3 Normal;
+uniform mat4 model;
+uniform mat4 MVP;
+uniform mat3 normal_matrix;
+void main()
+{
+    FragPos = vec3(model * vec4(aPos, 1.0));
+    Normal = normal_matrix * aNormal;
+    gl_Position = MVP * vec4(aPos, 1.0);
+}

ncca/ngl/widgets/glsl/picking.frag

@@ -0,0 +1,7 @@
+#version 330 core
+out vec3 FragColor;
+uniform vec3 face_id;
+void main()
+{
+    FragColor = face_id;
+}

ncca/ngl/widgets/glsl/picking.vert

@@ -0,0 +1,7 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+uniform mat4 MVP;
+void main()
+{
+    gl_Position = MVP * vec4(aPos, 1.0);
+}

ncca/ngl/widgets/lookatwidget.py

@@ -0,0 +1,77 @@
+from PySide6.QtCore import Property, QSignalBlocker, Qt, Signal, Slot
+from PySide6.QtWidgets import QComboBox, QFrame, QLabel, QToolButton, QVBoxLayout, QWidget
+
+from ncca.ngl import Mat4, Vec3, look_at
+
+from .vec3widget import Vec3Widget
+
+
+class LookAtWidget(QFrame):
+    """A widget for displaying and editing a Transform object, with foldable sections."""
+
+    valueChanged = Signal(Mat4)
+
+    def __init__(self, name: str, eye=Vec3(2, 2, 2), look=Vec3(0, 0, 0), parent: QWidget | None = None) -> None:
+        """
+        Args:
+            name: The name of the widget.
+            parent: The parent widget.
+        """
+        super().__init__(parent)
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self._name = name
+        self._view = Mat4()
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(2, 2, 2, 2)
+        main_layout.setSpacing(0)
+
+        self._toggle_button = QToolButton(self)
+        self._toggle_button.setText(self._name)
+        self._toggle_button.setCheckable(True)
+        self._toggle_button.setChecked(True)
+        self._toggle_button.setStyleSheet("QToolButton { border: none; }")
+        self._toggle_button.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
+        self._toggle_button.setArrowType(Qt.ArrowType.DownArrow)
+        self._toggle_button.clicked.connect(self.toggle_collapsed)
+
+        self._content_widget = QWidget(self)
+        content_layout = QVBoxLayout(self._content_widget)
+        content_layout.setContentsMargins(0, 0, 0, 0)
+
+        self._eye = Vec3Widget("Eye", eye, self)
+        self._look = Vec3Widget("Look", look, self)
+        self._up = QComboBox(self)
+        for v in ["y-up", "x-up", "z-up"]:
+            self._up.addItem(v)
+        self._eye.valueChanged.connect(self._update_matrix)
+        self._look.valueChanged.connect(self._update_matrix)
+        self._up.currentIndexChanged.connect(self._update_matrix)
+        content_layout.addWidget(self._eye)
+        content_layout.addWidget(self._look)
+        content_layout.addWidget(QLabel("World Up"))
+        content_layout.addWidget(self._up)
+        main_layout.addWidget(self._toggle_button)
+        main_layout.addWidget(self._content_widget)
+
+    def toggle_collapsed(self, checked: bool) -> None:
+        """Toggles the visibility of the content widget."""
+        if checked:
+            self._toggle_button.setArrowType(Qt.ArrowType.DownArrow)
+            self._content_widget.setVisible(True)
+        else:
+            self._toggle_button.setArrowType(Qt.ArrowType.RightArrow)
+            self._content_widget.setVisible(False)
+
+    def _update_matrix(self) -> None:
+        """Updates the view matrix based on the widget values."""
+        eye = self._eye.value
+        look = self._look.value
+        world_up = [Vec3(0, 1, 0), Vec3(1, 0, 0), Vec3(0, 0, 1)]
+        up = world_up[self._up.currentIndex()]
+
+        self._view = look_at(eye, look, up)
+        self.valueChanged.emit(self._view)
+
+    def view(self) -> Mat4:
+        """Returns the current view matrix."""
+        return self._view

ncca/ngl/widgets/mat4widget.py

@@ -0,0 +1,7 @@
+from PySide6.QtCore import Property, QSignalBlocker, Signal
+from PySide6.QtWidgets import QDoubleSpinBox, QFrame, QHBoxLayout, QLabel, QWidget
+
+from ncca.ngl import Mat4 
+
+
+class Mat4ViewWidget(QFrame):

ncca/ngl/widgets/rgbacolourwidget.py

@@ -0,0 +1,157 @@
+from PySide6.QtCore import Property, QSignalBlocker, Signal
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
+    QColorDialog,
+    QDoubleSpinBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QWidget,
+)
+
+from ncca.ngl import Vec4
+
+
+class RGBAColourWidget(QFrame):
+    """A widget for displaying and editing a Vec4 object."""
+
+    colourChanged = Signal(Vec4)
+    rValueChanged = Signal(float)
+    gValueChanged = Signal(float)
+    bValueChanged = Signal(float)
+    aValueChanged = Signal(float)
+
+    def __init__(self, name: str, r: float, g: float, b: float, a: float, parent: QWidget | None = None) -> None:
+        """
+        Args:
+            name: The name of the widget.
+            r: The initial red component of the colour.
+            g: The initial green component of the colour.
+            b: The initial blue component of the colour.
+            a: The initial alpha component of the colour.
+            parent: The parent widget.
+        """
+        super().__init__(parent)
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self._colour = Vec4(r, g, b, a)
+        self._name = name
+        layout = QHBoxLayout()
+
+        self.r_spinbox = self._create_spinbox(self._colour.x)
+        self.g_spinbox = self._create_spinbox(self._colour.y)
+        self.b_spinbox = self._create_spinbox(self._colour.z)
+        self.a_spinbox = self._create_spinbox(self._colour.w)
+        self._label = QLabel(self._name)
+        self._color_button = QPushButton()
+        self._color_button.setFixedSize(20, 20)
+        self._color_button.clicked.connect(self._show_color_dialog)
+        self._update_button_color()
+
+        layout.addWidget(self._label)
+        layout.addWidget(self.r_spinbox)
+        layout.addWidget(self.g_spinbox)
+        layout.addWidget(self.b_spinbox)
+        layout.addWidget(self.a_spinbox)
+        layout.addWidget(self._color_button)
+        self.setLayout(layout)
+
+    def _create_spinbox(self, value: float) -> QDoubleSpinBox:
+        """Helper method to create and configure a QDoubleSpinBox.
+
+        Args:
+            value: The initial value of the spinbox.
+
+        Returns:
+            A configured QDoubleSpinBox.
+        """
+        spinbox = QDoubleSpinBox()
+        spinbox.setValue(value)
+        spinbox.setRange(0.0, 1.0)
+        spinbox.setSingleStep(0.01)
+        spinbox.valueChanged.connect(self._on_value_changed)
+        return spinbox
+
+    def colour(self) -> Vec4:
+        """
+        Returns:
+            The current value of the widget.
+        """
+        return self._colour
+
+    def _on_value_changed(self, value: float) -> None:
+        """This slot is called when the value of a spinbox changes.
+
+        Args:
+            value: The new value of the spinbox.
+        """
+        sender = self.sender()
+        if sender == self.r_spinbox:
+            self._colour.x = value
+            self.rValueChanged.emit(value)
+        elif sender == self.g_spinbox:
+            self._colour.y = value
+            self.gValueChanged.emit(value)
+        elif sender == self.b_spinbox:
+            self._colour.z = value
+            self.bValueChanged.emit(value)
+        elif sender == self.a_spinbox:
+            self._colour.w = value
+            self.aValueChanged.emit(value)
+        # emit the Vec4 value changed signal
+        self.colourChanged.emit(self._colour)
+        self._update_button_color()
+
+    def set_colour(self, value: Vec4) -> None:
+        """Sets the value of the widget.
+
+        Args:
+            value: The new value of the widget.
+        """
+        with (
+            QSignalBlocker(self.r_spinbox),
+            QSignalBlocker(self.g_spinbox),
+            QSignalBlocker(self.b_spinbox),
+            QSignalBlocker(self.a_spinbox),
+        ):
+            self.r_spinbox.setValue(value.x)
+            self.g_spinbox.setValue(value.y)
+            self.b_spinbox.setValue(value.z)
+            self.a_spinbox.setValue(value.w)
+        self._colour = value
+        self.colourChanged.emit(self._colour)
+        self._update_button_color()
+
+    def _update_button_color(self) -> None:
+        """Updates the background color of the color button."""
+        color = QColor.fromRgbF(self._colour.x, self._colour.y, self._colour.z, self._colour.w)
+        self._color_button.setStyleSheet(f"background-color: {color.name(QColor.NameFormat.HexArgb)}")
+
+    def _show_color_dialog(self) -> None:
+        """Shows a QColorDialog to select a new color."""
+        current_color = QColor.fromRgbF(self._colour.x, self._colour.y, self._colour.z, self._colour.w)
+        color = QColorDialog.getColor(
+            current_color, self, "Select Color", options=QColorDialog.ColorDialogOption.ShowAlphaChannel
+        )
+        if color.isValid():
+            new_colour = Vec4(color.redF(), color.greenF(), color.blueF(), color.alphaF())
+            self.set_colour(new_colour)
+
+    def name(self) -> str:
+        """
+        Returns:
+            The name of the widget.
+        """
+        return self._name
+
+    def set_name(self, name: str) -> None:
+        """Sets the name of the widget.
+
+        Args:
+            name: The new name of the widget.
+        """
+        self._name = name
+        self._label.setText(name)
+
+    value = Property(Vec4, colour, set_colour)
+    name = Property(str, name, set_name)

ncca/ngl/widgets/rgbcolourwidget.py

@@ -0,0 +1,143 @@
+from PySide6.QtCore import Property, QSignalBlocker, Signal
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
+    QColorDialog,
+    QDoubleSpinBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QWidget,
+)
+
+from ncca.ngl import Vec3
+
+
+class RGBColourWidget(QFrame):
+    """A widget for displaying and editing a Vec3 object."""
+
+    colourChanged = Signal(Vec3)
+    rValueChanged = Signal(float)
+    gValueChanged = Signal(float)
+    bValueChanged = Signal(float)
+
+    def __init__(self, name: str, r: float, g: float, b: float, parent: QWidget | None = None) -> None:
+        """
+        Args:
+            name: The name of the widget.
+            r: The initial red component of the colour.
+            g: The initial green component of the colour.
+            b: The initial blue component of the colour.
+            parent: The parent widget.
+        """
+        super().__init__(parent)
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self._colour = Vec3(r, g, b)
+        self._name = name
+        layout = QHBoxLayout()
+
+        self.r_spinbox = self._create_spinbox(self._colour.x)
+        self.g_spinbox = self._create_spinbox(self._colour.y)
+        self.b_spinbox = self._create_spinbox(self._colour.z)
+
+        self._label = QLabel(self._name)
+        self._color_button = QPushButton()
+        self._color_button.setFixedSize(20, 20)
+        self._color_button.clicked.connect(self._show_color_dialog)
+        self._update_button_color()
+
+        layout.addWidget(self._label)
+        layout.addWidget(self.r_spinbox)
+        layout.addWidget(self.g_spinbox)
+        layout.addWidget(self.b_spinbox)
+        layout.addWidget(self._color_button)
+        self.setLayout(layout)
+
+    def _create_spinbox(self, value: float) -> QDoubleSpinBox:
+        """Helper method to create and configure a QDoubleSpinBox.
+
+        Args:
+            value: The initial value of the spinbox.
+
+        Returns:
+            A configured QDoubleSpinBox.
+        """
+        spinbox = QDoubleSpinBox()
+        spinbox.setValue(value)
+        spinbox.setRange(0.0, 1.0)
+        spinbox.setSingleStep(0.01)
+        spinbox.valueChanged.connect(self._on_value_changed)
+        return spinbox
+
+    def colour(self) -> Vec3:
+        """
+        Returns:
+            The current value of the widget.
+        """
+        return self._colour
+
+    def _on_value_changed(self, value: float) -> None:
+        """This slot is called when the value of a spinbox changes.
+
+        Args:
+            value: The new value of the spinbox.
+        """
+        sender = self.sender()
+        if sender == self.r_spinbox:
+            self._colour.x = value
+            self.rValueChanged.emit(value)
+        elif sender == self.g_spinbox:
+            self._colour.y = value
+            self.gValueChanged.emit(value)
+        elif sender == self.b_spinbox:
+            self._colour.z = value
+            self.bValueChanged.emit(value)
+        # emit the Vec3 value changed signal
+        self.colourChanged.emit(self._colour)
+        self._update_button_color()
+
+    def set_colour(self, value: Vec3) -> None:
+        """Sets the value of the widget.
+
+        Args:
+            value: The new value of the widget.
+        """
+        with QSignalBlocker(self.r_spinbox), QSignalBlocker(self.g_spinbox), QSignalBlocker(self.b_spinbox):
+            self.r_spinbox.setValue(value.x)
+            self.g_spinbox.setValue(value.y)
+            self.b_spinbox.setValue(value.z)
+        self._colour = value
+        self.colourChanged.emit(self._colour)
+        self._update_button_color()
+
+    def _update_button_color(self) -> None:
+        """Updates the background color of the color button."""
+        color = QColor.fromRgbF(self._colour.x, self._colour.y, self._colour.z)
+        self._color_button.setStyleSheet(f"background-color: {color.name()}")
+
+    def _show_color_dialog(self) -> None:
+        """Shows a QColorDialog to select a new color."""
+        current_color = QColor.fromRgbF(self._colour.x, self._colour.y, self._colour.z)
+        color = QColorDialog.getColor(current_color, self, "Select Color")
+        if color.isValid():
+            new_colour = Vec3(color.redF(), color.greenF(), color.blueF())
+            self.set_colour(new_colour)
+
+    def name(self) -> str:
+        """
+        Returns:
+            The name of the widget.
+        """
+        return self._name
+
+    def set_name(self, name: str) -> None:
+        """Sets the name of the widget.
+
+        Args:
+            name: The new name of the widget.
+        """
+        self._name = name
+        self._label.setText(name)
+
+    value = Property(Vec3, colour, set_colour)
+    name = Property(str, name, set_name)