VertexEngine 1.2rc4__4-py3-none-any.whl

VertexEngine/Vertex/__init__.py

@@ -0,0 +1,224 @@
+"""VertexEngine.Vertex: VWidget, Layouts, Dialogs, App Management"""
+
+import sys
+from PyQt6.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QHBoxLayout,
+    QDialog, QLabel, QPushButton, QLineEdit
+)
+from PyQt6.QtCore import Qt
+
+# ------------------------
+# Base widget wrapper
+# ------------------------
+class VWidget(QWidget):
+    """Base widget wrapper. Handles dark mode and size; no layout by default."""
+
+    def __init__(self, parent=None, width=None, height=None, dark_mode=False):
+        super().__init__(parent)
+        if width and height:
+            self.setFixedSize(width, height)
+        self.dark_mode = dark_mode
+        if dark_mode:
+            self.set_dark_mode(True)
+
+    def set_dark_mode(self, enabled=True):
+        self.dark_mode = enabled
+        if enabled:
+            self.setStyleSheet("""
+                QWidget {
+                    background-color: #2c3e50;
+                    color: #ecf0f1;
+                }
+                QPushButton {
+                    background-color: #2980b9;
+                    color: white;
+                }
+            """)
+        else:
+            self.setStyleSheet("")
+
+
+# ------------------------
+# Layout wrappers
+# ------------------------
+class VBox(VWidget):
+    """Vertical layout wrapper."""
+
+    def __init__(self, *args, padding=10, margin=10, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.layout = QVBoxLayout()
+        self.layout.setContentsMargins(margin, margin, margin, margin)
+        self.layout.setSpacing(padding)
+        self.setLayout(self.layout)
+
+    def add(self, widget):
+        self.layout.addWidget(widget)
+
+    def clear(self):
+        while self.layout.count():
+            child = self.layout.takeAt(0)
+            if child.widget():
+                child.widget().deleteLater()
+
+
+class HBox(VWidget):
+    """Horizontal layout wrapper."""
+
+    def __init__(self, *args, padding=10, margin=10, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.layout = QHBoxLayout()
+        self.layout.setContentsMargins(margin, margin, margin, margin)
+        self.layout.setSpacing(padding)
+        self.setLayout(self.layout)
+
+    def add(self, widget):
+        self.layout.addWidget(widget)
+
+    def clear(self):
+        while self.layout.count():
+            child = self.layout.takeAt(0)
+            if child.widget():
+                child.widget().deleteLater()
+
+
+# ------------------------
+# Application wrapper
+# ------------------------
+class App(QApplication):
+    def __init__(self):
+        super().__init__(sys.argv)
+
+    def run(self):
+        sys.exit(self.exec())
+
+
+# ------------------------
+# Dialog base class
+# ------------------------
+class Dialog(QDialog):
+    def __init__(self, parent=None, title="Dialog", size=(400, 200), modal=True):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.resize(*size)
+        self.setModal(modal)
+        self.setWindowFlags(self.windowFlags() | Qt.WindowType.Window)
+
+    def open_dialog(self):
+        self.exec()
+
+    def close_dialog(self):
+        self.close()
+
+
+# ------------------------
+# Message dialog
+# ------------------------
+class MessageDialog(Dialog):
+    def __init__(self, parent=None, message="", title="Message"):
+        super().__init__(parent, title, (300, 150))
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        label = QLabel(message)
+        layout.addWidget(label)
+
+        ok = QPushButton("OK")
+        ok.clicked.connect(self.accept)
+        layout.addWidget(ok)
+
+
+# ------------------------
+# Confirm dialog
+# ------------------------
+class ConfirmDialog(Dialog):
+    def __init__(self, parent=None, message="", title="Confirm"):
+        super().__init__(parent, title, (350, 160))
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        layout.addWidget(QLabel(message))
+
+        buttons = QHBoxLayout()
+        yes = QPushButton("Yes")
+        no = QPushButton("No")
+        yes.clicked.connect(self.accept)
+        no.clicked.connect(self.reject)
+        buttons.addWidget(yes)
+        buttons.addWidget(no)
+        layout.addLayout(buttons)
+
+    @staticmethod
+    def ask(parent=None, message="", title="Confirm"):
+        dlg = ConfirmDialog(parent, message, title)
+        return dlg.exec() == QDialog.DialogCode.Accepted
+
+
+# ------------------------
+# Input dialog
+# ------------------------
+class InputDialog(Dialog):
+    def __init__(self, parent=None, label="Enter:", title="Input"):
+        super().__init__(parent, title, (350, 180))
+        self.input = QLineEdit()
+
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        layout.addWidget(QLabel(label))
+        layout.addWidget(self.input)
+
+        ok = QPushButton("OK")
+        ok.clicked.connect(self.accept)
+        layout.addWidget(ok)
+
+    def value(self):
+        return self.input.text()
+
+    @staticmethod
+    def get(parent=None, label="Enter:", title="Input"):
+        dlg = InputDialog(parent, label, title)
+        if dlg.exec():
+            return dlg.value()
+        return None
+
+
+# ------------------------
+# Static dialog helper
+# ------------------------
+class Dialogs:
+    @staticmethod
+    def message(parent=None, text=""):
+        MessageDialog(parent, text).open_dialog()
+
+    @staticmethod
+    def confirm(parent=None, text=""):
+        return ConfirmDialog.ask(parent, text)
+
+    @staticmethod
+    def input(parent=None, text=""):
+        return InputDialog.get(parent, text)
+
+
+# ------------------------
+# Example usage
+# ------------------------
+if __name__ == "__main__":
+    app = App()
+
+    main = VBox(dark_mode=True, width=500, height=400)
+    main.add(QLabel("Welcome to the VWidget wrapper!"))
+
+    btn_msg = QPushButton("Show Message")
+    btn_msg.clicked.connect(lambda: Dialogs.message(main, "Hello!"))
+    main.add(btn_msg)
+
+    btn_confirm = QPushButton("Ask Confirm")
+    btn_confirm.clicked.connect(lambda: print(Dialogs.confirm(main, "Are you sure?")))
+    main.add(btn_confirm)
+
+    btn_input = QPushButton("Ask Input")
+    btn_input.clicked.connect(lambda: print(Dialogs.input(main, "Enter your name:")))
+    main.add(btn_input)
+
+    main.show()
+    app.run()

VertexEngine/VertexScreenModifiers.py

@@ -0,0 +1,70 @@
+"""WARNING: This library of Vertex is not made for games, if you want to make a game window, use the `GameEngine` Class instead."""
+from PyQt6.QtWidgets import QMainWindow, QVBoxLayout, QWidget, QApplication
+import sys
+from VertexEngine import VertexUI
+# ===== Base window class =====
+class BaseWindow(QMainWindow):
+    def __init__(self, title="Base Window", width=400, height=300):
+        super().__init__()
+        self.setWindowTitle(title)
+        self.setGeometry(100, 100, width, height)
+        self.central_widget = QWidget()
+        self.setCentralWidget(self.central_widget)
+        self.layout = QVBoxLayout()
+        self.central_widget.setLayout(self.layout)
+        print(f"[DEBUG] Initialized window '{title}' with size {width}x{height}")
+
+    def add_label(self, text):
+        label = VertexUI.Text(text)
+        self.layout.addWidget(label)
+        print(f"[DEBUG] Added label: '{text}'")
+
+    def add_button(self, text, callback=None):
+        button = VertexUI.FancyButton(text)
+        if callback:
+            button.clicked.connect(callback)
+        self.layout.addWidget(button)
+        print(f"[DEBUG] Added button: '{text}'")
+
+# ===== Fancy themed window =====
+class FancyWindow(BaseWindow):
+    def __init__(self, title="Fancy Window", width=500, height=400, theme_color="#FF69B4"):
+        super().__init__(title, width, height)
+        self.theme_color = theme_color
+        self.apply_theme()
+
+    def apply_theme(self):
+        self.setStyleSheet(f"""
+            QMainWindow {{
+                background-color: {self.theme_color};
+            }}
+            QLabel {{
+                color: white;
+                font-size: 18px;
+            }}
+            QPushButton {{
+                background-color: white;
+                color: {self.theme_color};
+                border-radius: 5px;
+                padding: 5px 10px;
+            }}
+        """)
+        print(f"[DEBUG] Applied theme color: {self.theme_color}")
+
+# ===== Random fun window with auto-close button =====
+class FunWindow(BaseWindow):
+    def __init__(self, title="Fun Window"):
+        super().__init__(title)
+        self.add_label("Welcome to FunWindow! 🎉")
+        self.add_button("Close me", self.close)
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+
+    # Choose your boredom mode
+    window = FancyWindow(theme_color="#8A2BE2")
+    window.add_label("This is super fancy 💎")
+    window.add_button("Click me!", lambda: print("You clicked the fancy button!"))
+
+    window.show()
+    sys.exit(app.exec())

VertexEngine/__init__.py

@@ -0,0 +1,322 @@
+# VertexEngine/__init__.py
+# Copyright (C) 2025
+# This library/SDK is free. You can redistribute it.
+# Tyrel Gomez (email as annbasilan)
+# annbasilan0828@gmail.com
+"""Vertex 3 is an SDK for RainOS GameDev. It's also supported by many others.
+
+Supported OSes 
+--------------
+- RainOS 
+- Windows 
+- MacOS, 
+- OS X 
+- BeOS 
+- FreeBSD 
+- IRIX  
+- and Linux
+
+It is written on top of the excellent Pygame library which is ran on the even more excellent SDL library which runs on every Desktop OS with SDL."""
+import pygame
+from .engine import GameEngine
+from .scenes import Scene, SceneManager
+from .assets import AssetManager
+from .audio import AudioManager
+from pygame.base import *  # pylint: disable=wildcard-import; lgtm[py/polluting-import]
+from pygame import *  # pylint: disable=wildcard-import; lgtm[py/polluting-import]
+import sys
+from PyQt6.QtWidgets import QPushButton, QLineEdit
+from PyQt6.QtGui import QFont
+from PyQt6.QtWidgets import QPushButton
+from PyQt6.QtGui import QCursor
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QLabel
+from typing_extensions import deprecated as dep
+
+class VertexScreen():
+    """Draw on VertexEngine's Screen."""
+    def __init__(self):
+        pass
+    class Draw():
+        "The Draw class to draw on VertexEngine"
+        def __init__(self):
+            pass
+        def rect(self, surface, color, rect=None):
+            """Draw a Rectangle of a solid color."""
+            pygame.draw.rect(surface, color, rect)
+        def polygon(self, surface, color, points, width):
+            "Draw a polygon by marking points on the screen to make an n-gon"
+            pygame.draw.polygon(surface, color, points, width)
+        def circle(self, circle_surface, color, center, radius, width, draw_top_right, draw_top_left, draw_bottom_right, draw_bottom_left):
+            """Draw a Circle with radius, color, etc."""
+            pygame.draw.circle(circle_surface, color, center, radius, width, draw_top_right, draw_top_left, draw_bottom_left, draw_bottom_right)
+        def ellipse(self, surface, color, rect, width):
+            """Draw an elipse with surface, color, rect and width""" 
+            pygame.draw.ellipse(surface, color, rect, width)
+        def arc(self, surface, color, rect, start_angle, stop_angle, width):
+            "Draw an arc with a lot of values"
+            pygame.draw.arc(surface, color, rect, start_angle, stop_angle, width)
+        def line(self, surface, color, start_pos, end_pos, width):
+            """Draw a line"""
+            pygame.draw.line(surface, color, start_pos, end_pos, width)
+        def lines(self, surface, color, closed, points, width):
+            '''Draw a pair of lines'''
+            pygame.draw.lines(surface, color, closed, points, width)
+        def aaline(
+            self,
+            surface,
+            color,
+            start_pos,
+            end_pos,
+            blend,
+        ):
+            '''Draw an aaline'''
+            pygame.draw.aaline(surface, color, start_pos, end_pos, blend)
+        def aalines(
+            self,
+            surface,
+            color,
+            closed,
+            points,
+            blend
+        ):
+            '''Draw a set of aalines'''
+            pygame.draw.aalines(surface, color, closed, points, blend)
+    class Font():
+        """VertexEngine's offical Font Engine"""
+        def __init__(self, path=None, size=24, antialias=True):
+            self.font = pygame.font.Font(path, size)
+            self.size = size
+            self.antialias = antialias
+        
+        def draw(
+                self,
+                surface,
+                text,
+                pos,
+                color=(255, 255, 255),
+                align="topleft",
+                center=False,
+                shadow=False,
+                shadow_color=(0, 0, 0),
+                shadow_offset=(2, 2),
+                outline=False,
+                outline_color=(0, 0, 0),
+                outline_thickness=1
+            ):      
+                text_surf = self.font.render(text, self.antialias, color)
+                rect = text_surf.get_rect()
+
+                if center:
+                    rect.center = pos
+                else:
+                    setattr(rect, align, pos)
+
+                # 🔲 Outline
+                if outline:
+                    for dx in range(-outline_thickness, outline_thickness + 1):
+                        for dy in range(-outline_thickness, outline_thickness + 1):
+                            if dx == 0 and dy == 0:
+                                continue
+                            outline_surf = self.font.render(text, self.antialias, outline_color)
+                            surface.blit(outline_surf, rect.move(dx, dy))
+
+                # 🌑 Shadow
+                if shadow:
+                    shadow_surf = self.font.render(text, self.antialias, shadow_color)
+                    shadow_rect = rect.move(shadow_offset)
+                    surface.blit(shadow_surf, shadow_rect)
+
+                surface.blit(text_surf, rect)
+
+        @dep("Unlike internal APIs, this one is fully deprecated, NEVER USE THIS. EVER :)")
+        def draw_text(
+            surface,
+            text,
+            font,
+            color,
+            pos,
+            align="topleft",
+            shadow=False,
+            shadow_color=(0, 0, 0),
+            shadow_offset=(2, 2)
+        ):
+            text_surf = font.render(text, True, color)
+            text_rect = text_surf.get_rect()
+
+            setattr(text_rect, align, pos)
+
+            if shadow:
+                shadow_surf = font.render(text, True, shadow_color)
+                shadow_rect = shadow_surf.get_rect()
+                setattr(shadow_rect, align, (pos[0] + shadow_offset[0], pos[1] + shadow_offset[1]))
+                surface.blit(shadow_surf, shadow_rect)
+
+            surface.blit(text_surf, text_rect)
+class Rect():
+    '''Define a rect to pass into VertexScreen.Draw.rect()'''
+    def __init__(self, left, top, width, height):
+        pygame.Rect(left, top, width, height)
+
+class VertexUI():
+    # QPushButton *button = new QPushButton(tr("Ro&ck && Roll"), this)
+    def __init__(self):
+        pass
+
+    class FancyButton(QPushButton):
+        def __init__(
+            self,
+            text="Button",
+            width=120,
+            height=40,
+            bg_color="#4CAF50",
+            hover_color="#45A049",
+            text_color="white",
+            border_radius=10,
+            border_color="#388E3C",
+            border_width=2,
+            font_name="Arial",
+            font_size=12,
+            font_weight=QFont.Weight.Bold,
+            parent=None
+        ):
+            super().__init__(text, parent)
+
+            # Store params
+            self.bg_color = bg_color
+            self.hover_color = hover_color
+            self.text_color = text_color
+            self.border_radius = border_radius
+            self.border_color = border_color
+            self.border_width = border_width
+            self.setFont(QFont(font_name, font_size, font_weight))
+            self.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+            self.setMinimumSize(width, height)
+
+            # Apply default style
+            self.setStyleSheet(self.default_style())
+
+        def enterEvent(self, event):
+            self.setStyleSheet(self.hover_style())
+            super().enterEvent(event)
+
+        def leaveEvent(self, event):
+            self.setStyleSheet(self.default_style())
+            super().leaveEvent(event)
+
+        def default_style(self):
+            return f"""
+                QPushButton {{
+                    background-color: {self.bg_color};
+                    color: {self.text_color};
+                    border-radius: {self.border_radius}px;
+                    border: {self.border_width}px solid {self.border_color};
+                }}
+            """
+
+        def hover_style(self):
+            return f"""
+                QPushButton {{
+                    background-color: {self.hover_color};
+                    color: {self.text_color};
+                    border-radius: {self.border_radius}px;
+                    border: {self.border_width}px solid {self.border_color};
+                }}
+            """
+
+    class Text(QLabel):
+        def __init__(
+            self,
+            text="Text",
+            font_name="Arial",
+            font_size=14,
+            font_weight=QFont.Weight.Normal,
+            text_color="#FFFFFF",
+            bg_color=None,
+            padding=8,
+            border_radius=8,
+            alignment=Qt.AlignmentFlag.AlignCenter,
+            parent=None
+        ):
+            super().__init__(text, parent)
+
+            self.setFont(QFont(font_name, font_size, font_weight))
+            self.setAlignment(alignment)
+
+            bg = "transparent" if bg_color is None else bg_color
+
+            self.setStyleSheet(f"""
+                QLabel {{
+                    color: {text_color};
+                    background-color: {bg};
+                    padding: {padding}px;
+                    border-radius: {border_radius}px;
+                }}
+            """)
+
+        def set_text(self, text):
+            self.setText(text)
+
+        def set_color(self, color):
+            self.setStyleSheet(self.styleSheet() + f"color: {color};")
+
+    class InputField(QLineEdit):
+        def __init__(
+            self,
+            placeholder="Enter text...",
+            width=240,
+            height=36,
+            font_name="Arial",
+            font_size=12,
+            text_color="#FFFFFF",
+            bg_color="#1E1E1E",
+            border_color="#555555",
+            focus_color="#00E5FF",
+            border_radius=8,
+            padding=8,
+            parent=None
+        ):
+            super().__init__(parent)
+
+            self.setPlaceholderText(placeholder)
+            self.setFont(QFont(font_name, font_size))
+            self.setMinimumSize(width, height)
+
+            self.text_color = text_color
+            self.bg_color = bg_color
+            self.border_color = border_color
+            self.focus_color = focus_color
+            self.border_radius = border_radius
+            self.padding = padding
+
+            self.apply_style(focused=False)
+
+        def apply_style(self, focused=False):
+            border = self.focus_color if focused else self.border_color
+
+            self.setStyleSheet(f"""
+                QLineEdit {{
+                    color: {self.text_color};
+                    background-color: {self.bg_color};
+                    border: 2px solid {border};
+                    border-radius: {self.border_radius}px;
+                    padding: {self.padding}px;
+                }}
+                QLineEdit::placeholder {{
+                    color: #888888;
+                }}
+            """)
+
+        def focusInEvent(self, event):
+            self.apply_style(focused=True)
+            super().focusInEvent(event)
+
+        def focusOutEvent(self, event):
+            self.apply_style(focused=False)
+            super().focusOutEvent(event)
+
+        def get_value(self):
+            return self.text()
+
+        def set_value(self, value):
+            self.setText(value)

VertexEngine/assets.py

@@ -0,0 +1,63 @@
+import pygame
+from PyQt6.QtGui import QImage
+import typing_extensions as typing
+
+@typing.deprecated('This is not a public API, use AssetManager pls :D')
+class QtRenderer:
+    def create_texture(self, image_asset):
+        surf = image_asset.surface
+        width, height = surf.get_size()
+
+        # Ensure predictable format
+        surf = surf.convert_alpha() if surf.get_alpha() else surf.convert()
+
+        # pygame → raw RGBA
+        pixel_data = pygame.image.tostring(surf, "RGBA", False)
+
+        # Create REAL QImage (no OpenGL required)
+        qimage = QImage(
+            pixel_data,
+            width,
+            height,
+            QImage.Format.Format_RGBA8888
+        )
+
+        # IMPORTANT: deep copy so data survives after function returns
+        qimage = qimage.copy()
+
+        return Texture(qimage)
+
+@typing.deprecated('This is not a public API, use AssetManager pls :D')
+class Texture:
+    def __init__(self, qimage: QImage):
+        self.image = qimage
+        self.width = qimage.width()
+        self.height = qimage.height()
+
+    def __repr__(self):
+        return f"<Texture {self.width}x{self.height} (QImage)>"
+
+@typing.deprecated('This is not a public API, use AssetManager pls :D')
+class ImageAsset:
+    def __init__(self, surface):
+        self.surface = surface  # pygame.Surface
+
+class AssetManager:
+    def __init__(self):
+        self.images = {}
+
+    def load_image(self, name: str, path: str):
+        if name in self.images:
+            return self.images[name]
+
+        try:
+            surface = pygame.image.load(path).convert_alpha()
+            self.images[name] = surface
+            return surface
+
+        except FileNotFoundError:
+            print(f"[Warning] Image '{path}' not found!")
+            return None
+
+    def get_image(self, name: str):
+        return self.images.get(name)

VertexEngine/audio.py

@@ -0,0 +1,25 @@
+import pygame
+
+class AudioManager:
+    def __init__(self):
+        pygame.mixer.init()
+        self.sounds = {}
+        self.music = None
+
+    def load_sound(self, name, path):
+        self.sounds[name] = pygame.mixer.Sound(path)
+
+    def play_sound(self, name, loops=0):
+        if name in self.sounds:
+            self.sounds[name].play(loops=loops)
+
+    def load_music(self, path):
+        self.music = path
+        pygame.mixer.music.load(path)
+
+    def play_music(self, loops=-1):
+        if self.music:
+            pygame.mixer.music.play(loops=loops)
+
+    def stop_music(self):
+        pygame.mixer.music.stop()