File aquamarine-0.3.3.obscpio of Package aquamarine

Overview Repositories Revisions Requests Users Attributes Meta

File aquamarine-0.3.3.obscpio of Package aquamarine

07070100000000000081A400000000000000000000000166C38D3F0000070E000000000000000000000000000000000000001F00000000aquamarine-0.3.3/.clang-format---
Language: Cpp
BasedOnStyle: LLVM

AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: true
AlignConsecutiveAssignments: true
AlignEscapedNewlines: Right
AlignOperands: false
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BreakBeforeBraces: Attach
BreakBeforeTernaryOperators: false
BreakConstructorInitializers: AfterColon
ColumnLimit: 180
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: false
IncludeBlocks: Preserve
IndentCaseLabels: true
IndentWidth: 4
PointerAlignment: Left
ReflowComments: false
SortIncludes: false
SortUsingDeclarations: false
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Auto
TabWidth: 4
UseTab: Never

AllowShortEnumsOnASingleLine: false

BraceWrapping:
  AfterEnum: false

AlignConsecutiveDeclarations: AcrossEmptyLines

NamespaceIndentation: All
07070100000001000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000001900000000aquamarine-0.3.3/.github07070100000002000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000002300000000aquamarine-0.3.3/.github/workflows07070100000003000081A400000000000000000000000166C38D3F0000025B000000000000000000000000000000000000002B00000000aquamarine-0.3.3/.github/workflows/nix.ymlname: Build & Test

on: [push, pull_request, workflow_dispatch]
jobs:
  nix:
    strategy:
      matrix:
        package:
          - aquamarine
          # - aquamarine-with-tests

runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

- uses: cachix/install-nix-action@v26
    - uses: DeterminateSystems/magic-nix-cache-action@main

# not needed (yet)
    # - uses: cachix/cachix-action@v12
    #   with:
    #     name: hyprland
    #     authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'

- name: Build & Test
      run: nix build .#${{ matrix.package }} --print-build-logs

07070100000004000081A400000000000000000000000166C38D3F00000147000000000000000000000000000000000000001C00000000aquamarine-0.3.3/.gitignore# Prerequisites
*.d

# Compiled Object files
*.slo
*.lo
*.o
*.obj

# Precompiled Headers
*.gch
*.pch

# Compiled Dynamic libraries
*.so
*.dylib
*.dll

# Fortran module files
*.mod
*.smod

# Compiled Static libraries
*.lai
*.la
*.a
*.lib

# Executables
*.exe
*.out
*.app

build/
.vscode/
.cache/

protocols/*.cpp
protocols/*.hpp07070100000005000081A400000000000000000000000166C38D3F0000118B000000000000000000000000000000000000002000000000aquamarine-0.3.3/CMakeLists.txtcmake_minimum_required(VERSION 3.19)

file(READ "${CMAKE_SOURCE_DIR}/VERSION" VER_RAW)
string(STRIP ${VER_RAW} AQUAMARINE_VERSION)

add_compile_definitions(AQUAMARINE_VERSION="${AQUAMARINE_VERSION}")

project(
  aquamarine
  VERSION ${AQUAMARINE_VERSION}
  DESCRIPTION "A very light linux rendering backend library")

include(CTest)
include(CheckIncludeFile)
include(GNUInstallDirs)

set(PREFIX ${CMAKE_INSTALL_PREFIX})
set(INCLUDE ${CMAKE_INSTALL_FULL_INCLUDEDIR})
set(LIBDIR ${CMAKE_INSTALL_FULL_LIBDIR})

find_package(PkgConfig REQUIRED)
find_package(OpenGL REQUIRED COMPONENTS "GLES2")
find_package(hyprwayland-scanner 0.4.0 REQUIRED)
pkg_check_modules(
  deps
  REQUIRED
  IMPORTED_TARGET
  libseat>=0.8.0
  libinput>=1.26.0
  wayland-client
  wayland-protocols
  hyprutils>=0.1.5
  pixman-1
  libdrm
  gbm
  libudev
  libdisplay-info
  hwdata)

configure_file(aquamarine.pc.in aquamarine.pc @ONLY)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)

if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
  message(STATUS "Configuring aquamarine in Debug")
  add_compile_definitions(AQUAMARINE_DEBUG)
else()
  add_compile_options(-O3)
  message(STATUS "Configuring aquamarine in Release")
endif()

file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp" "include/*.hpp")
file(GLOB_RECURSE PUBLIC_HEADERS CONFIGURE_DEPENDS "include/*.hpp")

add_library(aquamarine SHARED ${SRCFILES})
target_include_directories(
  aquamarine
  PUBLIC "./include"
  PRIVATE "./src" "./src/include" "./protocols" "${CMAKE_BINARY_DIR}")
set_target_properties(aquamarine PROPERTIES VERSION ${AQUAMARINE_VERSION}
                                            SOVERSION 2)
target_link_libraries(aquamarine OpenGL::EGL OpenGL::OpenGL PkgConfig::deps)

check_include_file("sys/timerfd.h" HAS_TIMERFD)
pkg_check_modules(epoll IMPORTED_TARGET epoll-shim)
if(NOT HAS_TIMERFD AND epoll_FOUND)
  target_link_libraries(aquamarine PkgConfig::epoll)
endif()

# Protocols
pkg_get_variable(WAYLAND_PROTOCOLS_DIR wayland-protocols pkgdatadir)
message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}")
pkg_get_variable(WAYLAND_SCANNER_PKGDATA_DIR wayland-scanner pkgdatadir)
message(STATUS "Found wayland-scanner pkgdatadir at ${WAYLAND_SCANNER_PKGDATA_DIR}")

function(protocolNew protoPath protoName external)
  if(external)
    set(path ${CMAKE_SOURCE_DIR}/${protoPath})
  else()
    set(path ${WAYLAND_PROTOCOLS_DIR}/${protoPath})
  endif()
  add_custom_command(
    OUTPUT ${CMAKE_SOURCE_DIR}/protocols/${protoName}.cpp
           ${CMAKE_SOURCE_DIR}/protocols/${protoName}.hpp
    COMMAND hyprwayland-scanner --client ${path}/${protoName}.xml
            ${CMAKE_SOURCE_DIR}/protocols/
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
  target_sources(aquamarine PRIVATE protocols/${protoName}.cpp
                                    protocols/${protoName}.hpp)
endfunction()
function(protocolWayland)
  add_custom_command(
    OUTPUT ${CMAKE_SOURCE_DIR}/protocols/wayland.cpp
           ${CMAKE_SOURCE_DIR}/protocols/wayland.hpp
    COMMAND hyprwayland-scanner --wayland-enums --client
            ${WAYLAND_SCANNER_PKGDATA_DIR}/wayland.xml ${CMAKE_SOURCE_DIR}/protocols/
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
  target_sources(aquamarine PRIVATE protocols/wayland.cpp protocols/wayland.hpp)
endfunction()

protocolwayland()

protocolnew("stable/xdg-shell" "xdg-shell" false)
protocolnew("stable/linux-dmabuf" "linux-dmabuf-v1" false)

# Generate hwdata info
pkg_get_variable(HWDATA_DIR hwdata pkgdatadir)
message(
  STATUS "Running ${CMAKE_SOURCE_DIR}/data/hwdata.sh < ${HWDATA_DIR}/pnp.ids")
execute_process(
  COMMAND /bin/sh -c
          "${CMAKE_SOURCE_DIR}/data/hwdata.sh < ${HWDATA_DIR}/pnp.ids"
  RESULT_VARIABLE HWDATA_PNP_RESULT
  OUTPUT_VARIABLE HWDATA_PNP_IDS ENCODING UTF8)

if(NOT HWDATA_PNP_RESULT MATCHES 0)
  message(WARNING "hwdata gathering pnps failed")
endif()

configure_file(data/hwdata.hpp.in hwdata.hpp @ONLY)

# tests
add_custom_target(tests)

add_executable(simpleWindow "tests/SimpleWindow.cpp")
target_link_libraries(simpleWindow PRIVATE PkgConfig::deps aquamarine)
add_test(
  NAME "simpleWindow"
  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
  COMMAND simpleWindow "simpleWindow")
add_dependencies(tests simpleWindow)

# Installation
install(TARGETS aquamarine)
install(DIRECTORY "include/aquamarine" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
install(FILES ${CMAKE_BINARY_DIR}/aquamarine.pc
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
07070100000006000081A400000000000000000000000166C38D3F000005DF000000000000000000000000000000000000001900000000aquamarine-0.3.3/LICENSEBSD 3-Clause License

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its
   contributors may be used to endorse or promote products derived from
   this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
07070100000007000081A400000000000000000000000166C38D3F000003A2000000000000000000000000000000000000001B00000000aquamarine-0.3.3/README.md## Aquamarine

Aquamarine is a very light linux rendering backend library. It provides basic abstractions
for an application to render on a Wayland session (in a window) or a native DRM session.

It is agnostic of the rendering API (Vulkan/OpenGL) and designed to be lightweight, performant, and
minimal.

Aquamarine provides no bindings for other languages. It is C++-only.

## Stability

Aquamarine depends on the ABI stability of the stdlib implementation of your compiler. Sover bumps will be done only for aquamarine ABI breaks, not stdlib.

## Building

```sh
cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build
cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf _NPROCESSORS_CONF`
```

## TODOs

- [x] Wayland backend
 - [x] DRM backend (DRM / KMS / libinput)
 - [x] Virtual backend (aka. Headless)
 - [ ] Hardware plane support

07070100000008000081A400000000000000000000000166C38D3F00000006000000000000000000000000000000000000001900000000aquamarine-0.3.3/VERSION0.3.3
07070100000009000081A400000000000000000000000166C38D3F00000100000000000000000000000000000000000000002200000000aquamarine-0.3.3/aquamarine.pc.inprefix=@PREFIX@
includedir=@INCLUDE@
libdir=@LIBDIR@

Name: aquamarine
URL: https://github.com/hyprwm/aquamarine
Description: A very light linux rendering backend library
Version: @AQUAMARINE_VERSION@
Cflags: -I${includedir}
Libs: -L${libdir} -laquamarine
0707010000000A000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000001600000000aquamarine-0.3.3/data0707010000000B000081A400000000000000000000000166C38D3F000000C1000000000000000000000000000000000000002400000000aquamarine-0.3.3/data/hwdata.hpp.in#include <unordered_map>
#include <string>

#define __AQ_PNP_PROP(pnp, manu) {pnp, manu}
inline std::unordered_map<std::string, std::string> PNPIDS = {
@HWDATA_PNP_IDS@
};
#undef __AQ_PNP_PROP
0707010000000C000081ED00000000000000000000000166C38D3F00000087000000000000000000000000000000000000002000000000aquamarine-0.3.3/data/hwdata.sh#!/bin/sh

while read -r id vendor; do
	[ "${#id}" = 3 ] || exit 1

printf "\t__AQ_PNP_PROP(\"%s\", \"%s\"),\n" "$id" "$vendor"
done

0707010000000D000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000001600000000aquamarine-0.3.3/docs0707010000000E000081A400000000000000000000000166C38D3F000001E1000000000000000000000000000000000000001D00000000aquamarine-0.3.3/docs/env.md## Environment variables

Unless specified otherwise, a variable is enabled if and only if it's set to `1`

### DRM

`AQ_DRM_DEVICES` -> Set an explicit list of DRM devices (GPUs) to use. It's a colon-separated list of paths, with the first being the primary. E.g. `/dev/dri/card1:/dev/dri/card0`
`AQ_NO_ATOMIC` -> Disables drm atomic modesetting
`AQ_MGPU_NO_EXPLICIT` -> Disables explicit syncing on mgpu buffers

### Debugging

`AQ_TRACE` -> Enables trace (very verbose) logging
0707010000000F000081A400000000000000000000000166C38D3F000008B3000000000000000000000000000000000000001C00000000aquamarine-0.3.3/flake.lock{
  "nodes": {
    "hyprutils": {
      "inputs": {
        "nixpkgs": [
          "nixpkgs"
        ],
        "systems": [
          "systems"
        ]
      },
      "locked": {
        "lastModified": 1721324102,
        "narHash": "sha256-WAZ0X6yJW1hFG6otkHBfyJDKRpNP5stsRqdEuHrFRpk=",
        "owner": "hyprwm",
        "repo": "hyprutils",
        "rev": "962582a090bc233c4de9d9897f46794280288989",
        "type": "github"
      },
      "original": {
        "owner": "hyprwm",
        "repo": "hyprutils",
        "type": "github"
      }
    },
    "hyprwayland-scanner": {
      "inputs": {
        "nixpkgs": [
          "nixpkgs"
        ],
        "systems": [
          "systems"
        ]
      },
      "locked": {
        "lastModified": 1721324119,
        "narHash": "sha256-SOOqIT27/X792+vsLSeFdrNTF+OSRp5qXv6Te+fb2Qg=",
        "owner": "hyprwm",
        "repo": "hyprwayland-scanner",
        "rev": "a048a6cb015340bd82f97c1f40a4b595ca85cc30",
        "type": "github"
      },
      "original": {
        "owner": "hyprwm",
        "repo": "hyprwayland-scanner",
        "type": "github"
      }
    },
    "nixpkgs": {
      "locked": {
        "lastModified": 1721138476,
        "narHash": "sha256-+W5eZOhhemLQxelojLxETfbFbc19NWawsXBlapYpqIA=",
        "owner": "NixOS",
        "repo": "nixpkgs",
        "rev": "ad0b5eed1b6031efaed382844806550c3dcb4206",
        "type": "github"
      },
      "original": {
        "owner": "NixOS",
        "ref": "nixos-unstable",
        "repo": "nixpkgs",
        "type": "github"
      }
    },
    "root": {
      "inputs": {
        "hyprutils": "hyprutils",
        "hyprwayland-scanner": "hyprwayland-scanner",
        "nixpkgs": "nixpkgs",
        "systems": "systems"
      }
    },
    "systems": {
      "locked": {
        "lastModified": 1689347949,
        "narHash": "sha256-12tWmuL2zgBgZkdoB6qXZsgJEH9LR3oUgpaQq2RbI80=",
        "owner": "nix-systems",
        "repo": "default-linux",
        "rev": "31732fcf5e8fea42e59c2488ad31a0e651500f68",
        "type": "github"
      },
      "original": {
        "owner": "nix-systems",
        "repo": "default-linux",
        "type": "github"
      }
    }
  },
  "root": "root",
  "version": 7
}
07070100000010000081A400000000000000000000000166C38D3F00000A38000000000000000000000000000000000000001B00000000aquamarine-0.3.3/flake.nix{
  description = "A very light linux rendering backend library";

inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    systems.url = "github:nix-systems/default-linux";

hyprutils = {
      url = "github:hyprwm/hyprutils";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.systems.follows = "systems";
    };

hyprwayland-scanner = {
      url = "github:hyprwm/hyprwayland-scanner";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.systems.follows = "systems";
    };
  };

outputs = {
    self,
    nixpkgs,
    systems,
    ...
  } @ inputs: let
    inherit (nixpkgs) lib;
    eachSystem = lib.genAttrs (import systems);
    pkgsFor = eachSystem (system:
      import nixpkgs {
        localSystem.system = system;
        overlays = with self.overlays; [aquamarine];
      });
    pkgsCrossFor = eachSystem (system: crossSystem:
      import nixpkgs {
        localSystem = system;
        crossSystem = crossSystem;
        overlays = with self.overlays; [aquamarine];
      });
    mkDate = longDate: (lib.concatStringsSep "-" [
      (builtins.substring 0 4 longDate)
      (builtins.substring 4 2 longDate)
      (builtins.substring 6 2 longDate)
    ]);
    version = lib.removeSuffix "\n" (builtins.readFile ./VERSION);
  in {
    overlays = {
      default = self.overlays.aquamarine;

aquamarine = lib.composeManyExtensions [
        self.overlays.libinput
        inputs.hyprutils.overlays.default
        inputs.hyprwayland-scanner.overlays.default
        (final: prev: {
          aquamarine = final.callPackage ./nix/default.nix {
            stdenv = final.gcc13Stdenv;
            version = version + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
          };
          aquamarine-with-tests = final.aquamarine.override {doCheck = true;};
        })
      ];

libinput = final: prev: {
        libinput = prev.libinput.overrideAttrs (self: super: {
          version = "1.26.0";

src = final.fetchFromGitLab {
            domain = "gitlab.freedesktop.org";
            owner = "libinput";
            repo = "libinput";
            rev = self.version;
            hash = "sha256-mlxw4OUjaAdgRLFfPKMZDMOWosW9yKAkzDccwuLGCwQ=";
          };
        });
      };
    };

packages = eachSystem (system: {
      default = self.packages.${system}.aquamarine;
      inherit (pkgsFor.${system}) aquamarine aquamarine-with-tests;
      aquamarine-cross = (pkgsCrossFor.${system} "aarch64-linux").aquamarine;
    });

formatter = eachSystem (system: pkgsFor.${system}.alejandra);
  };
}
07070100000011000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000001900000000aquamarine-0.3.3/include07070100000012000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000002400000000aquamarine-0.3.3/include/aquamarine07070100000013000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000002E00000000aquamarine-0.3.3/include/aquamarine/allocator07070100000014000081A400000000000000000000000166C38D3F0000055E000000000000000000000000000000000000003C00000000aquamarine-0.3.3/include/aquamarine/allocator/Allocator.hpp#pragma once

#include <hyprutils/memory/SharedPtr.hpp>
#include "../buffer/Buffer.hpp"
#include <drm_fourcc.h>

namespace Aquamarine {
    class CBackend;
    class CSwapchain;

struct SAllocatorBufferParams {
        Hyprutils::Math::Vector2D size;
        uint32_t                  format  = DRM_FORMAT_INVALID;
        bool                      scanout = false, cursor = false, multigpu = false;
    };

enum eAllocatorType {
        AQ_ALLOCATOR_TYPE_GBM = 0,
    };

class IAllocator {
      public:
        virtual ~IAllocator()                                                                                                                                      = default;
        virtual Hyprutils::Memory::CSharedPointer<IBuffer>  acquire(const SAllocatorBufferParams& params, Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain) = 0;
        virtual Hyprutils::Memory::CSharedPointer<CBackend> getBackend()                                                                                           = 0;
        virtual int                                         drmFD()                                                                                                = 0;
        virtual eAllocatorType                              type()                                                                                                 = 0;
    };
};
07070100000015000081A400000000000000000000000166C38D3F00000A72000000000000000000000000000000000000003600000000aquamarine-0.3.3/include/aquamarine/allocator/GBM.hpp#pragma once

#include "Allocator.hpp"

struct gbm_device;
struct gbm_bo;

namespace Aquamarine {
    class CGBMAllocator;
    class CBackend;
    class CSwapchain;

class CGBMBuffer : public IBuffer {
      public:
        virtual ~CGBMBuffer();

virtual eBufferCapability                      caps();
        virtual eBufferType                            type();
        virtual void                                   update(const Hyprutils::Math::CRegion& damage);
        virtual bool                                   isSynchronous();
        virtual bool                                   good();
        virtual SDMABUFAttrs                           dmabuf();
        virtual std::tuple<uint8_t*, uint32_t, size_t> beginDataPtr(uint32_t flags);
        virtual void                                   endDataPtr();

private:
        CGBMBuffer(const SAllocatorBufferParams& params, Hyprutils::Memory::CWeakPointer<CGBMAllocator> allocator_, Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain);

Hyprutils::Memory::CWeakPointer<CGBMAllocator> allocator;

// gbm stuff
        gbm_bo*      bo         = nullptr;
        void*        boBuffer   = nullptr;
        void*        gboMapping = nullptr;
        SDMABUFAttrs attrs{.success = false};

friend class CGBMAllocator;
    };

class CGBMAllocator : public IAllocator {
      public:
        ~CGBMAllocator();
        static Hyprutils::Memory::CSharedPointer<CGBMAllocator> create(int drmfd_, Hyprutils::Memory::CWeakPointer<CBackend> backend_);

virtual Hyprutils::Memory::CSharedPointer<IBuffer>      acquire(const SAllocatorBufferParams& params, Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain_);
        virtual Hyprutils::Memory::CSharedPointer<CBackend>     getBackend();
        virtual int                                             drmFD();
        virtual eAllocatorType                                  type();

//
        Hyprutils::Memory::CWeakPointer<CGBMAllocator> self;

private:
        CGBMAllocator(int fd_, Hyprutils::Memory::CWeakPointer<CBackend> backend_);

// a vector purely for tracking (debugging) the buffers and nothing more
        std::vector<Hyprutils::Memory::CWeakPointer<CGBMBuffer>> buffers;

int                                                      fd = -1;
        Hyprutils::Memory::CWeakPointer<CBackend>                backend;

// gbm stuff
        gbm_device* gbmDevice            = nullptr;
        std::string gbmDeviceBackendName = "";
        std::string drmName              = "";

friend class CGBMBuffer;
        friend class CDRMRenderer;
    };
};
07070100000016000081A400000000000000000000000166C38D3F00000910000000000000000000000000000000000000003C00000000aquamarine-0.3.3/include/aquamarine/allocator/Swapchain.hpp#pragma once

#include "Allocator.hpp"

namespace Aquamarine {

class IBackendImplementation;

struct SSwapchainOptions {
        size_t                    length = 0;
        Hyprutils::Math::Vector2D size;
        uint32_t                  format  = DRM_FORMAT_INVALID; // if you leave this on invalid, the swapchain will choose an appropriate format (and modifier) for you.
        bool                      scanout = false, cursor = false /* requires scanout = true */, multigpu = false /* if true, will force linear */;
    };

class CSwapchain {
      public:
        static Hyprutils::Memory::CSharedPointer<CSwapchain> create(Hyprutils::Memory::CSharedPointer<IAllocator>             allocator_,
                                                                    Hyprutils::Memory::CSharedPointer<IBackendImplementation> backendImpl_);

bool                                                 reconfigure(const SSwapchainOptions& options_);

bool                                                 contains(Hyprutils::Memory::CSharedPointer<IBuffer> buffer);
        Hyprutils::Memory::CSharedPointer<IBuffer>           next(int* age);
        const SSwapchainOptions&                             currentOptions();
        Hyprutils::Memory::CSharedPointer<IAllocator>        getAllocator();

// rolls the buffers back, marking the last consumed as the next valid.
        // useful if e.g. a commit fails and we don't wanna write to the previous buffer that is
        // in use.
        void rollback();

private:
        CSwapchain(Hyprutils::Memory::CSharedPointer<IAllocator> allocator_, Hyprutils::Memory::CSharedPointer<IBackendImplementation> backendImpl_);

bool fullReconfigure(const SSwapchainOptions& options_);
        bool resize(size_t newSize);

//
        Hyprutils::Memory::CWeakPointer<CSwapchain>             self;
        SSwapchainOptions                                       options;
        Hyprutils::Memory::CSharedPointer<IAllocator>           allocator;
        Hyprutils::Memory::CWeakPointer<IBackendImplementation> backendImpl;
        std::vector<Hyprutils::Memory::CSharedPointer<IBuffer>> buffers;
        int                                                     lastAcquired = 0;

friend class CGBMBuffer;
    };
};
07070100000017000041ED00000000000000000000000266C38D3F00000000000000000000000000000000000000000000002C00000000aquamarine-0.3.3/include/aquamarine/backend07070100000018000081A400000000000000000000000166C38D3F000019AE000000000000000000000000000000000000003800000000aquamarine-0.3.3/include/aquamarine/backend/Backend.hpp#pragma once

#include <hyprutils/memory/SharedPtr.hpp>
#include <hyprutils/signal/Signal.hpp>
#include <vector>
#include <functional>
#include <mutex>
#include <condition_variable>
#include "../allocator/Allocator.hpp"
#include "Misc.hpp"
#include "Session.hpp"

namespace Aquamarine {
    enum eBackendType : uint32_t {
        AQ_BACKEND_WAYLAND = 0,
        AQ_BACKEND_DRM,
        AQ_BACKEND_HEADLESS,
    };

enum eBackendRequestMode : uint32_t {
        /*
            Require the provided backend, will error out if it's not available.
        */
        AQ_BACKEND_REQUEST_MANDATORY = 0,
        /*
            Start the backend if it's available
        */
        AQ_BACKEND_REQUEST_IF_AVAILABLE,
        /*
            If any IF_AVAILABLE backend fails, use this one
        */
        AQ_BACKEND_REQUEST_FALLBACK,
    };

enum eBackendLogLevel : uint32_t {
        AQ_LOG_TRACE = 0,
        AQ_LOG_DEBUG,
        AQ_LOG_WARNING,
        AQ_LOG_ERROR,
        AQ_LOG_CRITICAL,
    };

struct SBackendImplementationOptions {
        explicit SBackendImplementationOptions();
        eBackendType        backendType;
        eBackendRequestMode backendRequestMode;
    };

struct SBackendOptions {
        explicit SBackendOptions();
        std::function<void(eBackendLogLevel, std::string)> logFunction;
    };

struct SPollFD {
        int                       fd = -1;
        std::function<void(void)> onSignal; /* call this when signaled */
    };

class IBackendImplementation {
      public:
        virtual ~IBackendImplementation() {
            ;
        }

enum eBackendCapabilities : uint32_t {
            AQ_BACKEND_CAPABILITY_POINTER = (1 << 0),
        };

virtual eBackendType                                            type()                                     = 0;
        virtual bool                                                    start()                                    = 0;
        virtual std::vector<Hyprutils::Memory::CSharedPointer<SPollFD>> pollFDs()                                  = 0;
        virtual int                                                     drmFD()                                    = 0;
        virtual bool                                                    dispatchEvents()                           = 0;
        virtual uint32_t                                                capabilities()                             = 0;
        virtual void                                                    onReady()                                  = 0;
        virtual std::vector<SDRMFormat>                                 getRenderFormats()                         = 0;
        virtual std::vector<SDRMFormat>                                 getCursorFormats()                         = 0;
        virtual bool                                                    createOutput(const std::string& name = "") = 0; // "" means auto
        virtual Hyprutils::Memory::CSharedPointer<IAllocator>           preferredAllocator()                       = 0;
        virtual std::vector<SDRMFormat>                                 getRenderableFormats(); // empty = use getRenderFormats
    };

class CBackend {
      public:
        /* Create a backend, with the provided options. May return a single or a multi-backend. */
        static Hyprutils::Memory::CSharedPointer<CBackend> create(const std::vector<SBackendImplementationOptions>& backends, const SBackendOptions& options);

~CBackend();

/* start the backend. Initializes all the stuff, and will return true on success, false on fail. */
        bool start();

void log(eBackendLogLevel level, const std::string& msg);

/* Gets all the FDs you have to poll. When any single one fires, call its onPoll */
        std::vector<Hyprutils::Memory::CSharedPointer<SPollFD>> getPollFDs();

/* Checks if the backend has a session - iow if it's a DRM backend */
        bool hasSession();

/* Get the primary DRM FD */
        int drmFD();

/* Get the render formats the primary backend supports */
        std::vector<SDRMFormat> getPrimaryRenderFormats();

/* get a vector of the backend implementations available */
        const std::vector<Hyprutils::Memory::CSharedPointer<IBackendImplementation>>& getImplementations();

/* push an idle event to the queue */
        void addIdleEvent(Hyprutils::Memory::CSharedPointer<std::function<void(void)>> fn);

/* remove an idle event from the queue */
        void removeIdleEvent(Hyprutils::Memory::CSharedPointer<std::function<void(void)>> pfn);

// utils
        int reopenDRMNode(int drmFD, bool allowRenderNode = true);

struct {
            Hyprutils::Signal::CSignal newOutput;
            Hyprutils::Signal::CSignal newPointer;
            Hyprutils::Signal::CSignal newKeyboard;
            Hyprutils::Signal::CSignal newTouch;
            Hyprutils::Signal::CSignal newSwitch;
            Hyprutils::Signal::CSignal newTablet;
            Hyprutils::Signal::CSignal newTabletTool;
            Hyprutils::Signal::CSignal newTabletPad;
        } events;

Hyprutils::Memory::CSharedPointer<IAllocator> primaryAllocator;
        bool                                          ready = false;
        Hyprutils::Memory::CSharedPointer<CSession>   session;

private:
        CBackend();

bool                                                                   terminate = false;

std::vector<SBackendImplementationOptions>                             implementationOptions;
        std::vector<Hyprutils::Memory::CSharedPointer<IBackendImplementation>> implementations;
        SBackendOptions                                                        options;
        Hyprutils::Memory::CWeakPointer<CBackend>                              self;
        std::vector<Hyprutils::Memory::CSharedPointer<SPollFD>>                sessionFDs;

struct {
            int                                                                       fd = -1;
            std::vector<Hyprutils::Memory::CSharedPointer<std::function<void(void)>>> pending;
        } idle;

void dispatchIdle();
        void updateIdleTimer();

//
        struct {
            std::condition_variable loopSignal;
            std::mutex              loopMutex;
            std::atomic<bool>       shouldProcess = false;
            std::mutex              loopRequestMutex;
            std::mutex              eventLock;
        } m_sEventLoopInternals;
    };
};
07070100000019000081A400000000000000000000000166C38D3F000047E1000000000000000000000000000000000000003400000000aquamarine-0.3.3/include/aquamarine/backend/DRM.hpp#pragma once

#include "./Backend.hpp"
#include "../allocator/Swapchain.hpp"
#include "../output/Output.hpp"
#include "../input/Input.hpp"
#include <hyprutils/memory/WeakPtr.hpp>
#include <wayland-client.h>
#include <xf86drmMode.h>

namespace Aquamarine {
    class CDRMBackend;
    class CDRMFB;
    class CDRMOutput;
    struct SDRMConnector;
    class CDRMRenderer;

typedef std::function<void(void)> FIdleCallback;

class CDRMBufferAttachment : public IAttachment {
      public:
        CDRMBufferAttachment(Hyprutils::Memory::CSharedPointer<CDRMFB> fb_);
        virtual ~CDRMBufferAttachment() {
            ;
        }
        virtual eAttachmentType type() {
            return AQ_ATTACHMENT_DRM_BUFFER;
        }

Hyprutils::Memory::CSharedPointer<CDRMFB> fb;
    };

class CDRMBufferUnimportable : public IAttachment {
      public:
        CDRMBufferUnimportable() {
            ;
        }
        virtual ~CDRMBufferUnimportable() {
            ;
        }
        virtual eAttachmentType type() {
            return AQ_ATTACHMENT_DRM_KMS_UNIMPORTABLE;
        }
    };

class CDRMLease {
      public:
        static Hyprutils::Memory::CSharedPointer<CDRMLease> create(std::vector<Hyprutils::Memory::CSharedPointer<IOutput>> outputs);
        ~CDRMLease();

void                                                     terminate();

int                                                      leaseFD  = -1;
        uint32_t                                                 lesseeID = 0;
        Hyprutils::Memory::CWeakPointer<CDRMBackend>             backend;
        std::vector<Hyprutils::Memory::CWeakPointer<CDRMOutput>> outputs;
        bool                                                     active = true;

struct {
            Hyprutils::Signal::CSignal destroy;
        } events;

private:
        CDRMLease() = default;

void destroy();

friend class CDRMBackend;
    };

class CDRMFB {
      public:
        ~CDRMFB();

static Hyprutils::Memory::CSharedPointer<CDRMFB> create(Hyprutils::Memory::CSharedPointer<IBuffer> buffer_, Hyprutils::Memory::CWeakPointer<CDRMBackend> backend_,
                                                                bool* isNew = nullptr);

void                                             closeHandles();
        // drops the buffer from KMS
        void drop();

// re-imports the buffer into KMS. Essentially drop and import.
        void                                         reimport();

uint32_t                                     id = 0;
        Hyprutils::Memory::CWeakPointer<IBuffer>     buffer;
        Hyprutils::Memory::CWeakPointer<CDRMBackend> backend;
        std::array<uint32_t, 4>                      boHandles = {0, 0, 0, 0};

// true if the original buffer is gone and this has been released.
        bool dead = false;

private:
        CDRMFB(Hyprutils::Memory::CSharedPointer<IBuffer> buffer_, Hyprutils::Memory::CWeakPointer<CDRMBackend> backend_);
        uint32_t submitBuffer();
        void     import();

bool     dropped = false, handlesClosed = false;

struct {
            Hyprutils::Signal::CHyprSignalListener destroyBuffer;
        } listeners;
    };

struct SDRMLayer {
        // we expect the consumers to use double-buffering, so we keep the 2 last FBs around. If any of these goes out of
        // scope, the DRM FB will be destroyed, but the IBuffer will stay, as long as it's ref'd somewhere.
        Hyprutils::Memory::CSharedPointer<CDRMFB>    front /* currently displaying */, back /* submitted */, last /* keep just in case */;
        Hyprutils::Memory::CWeakPointer<CDRMBackend> backend;
    };

struct SDRMPlane {
        bool                                         init(drmModePlane* plane);

uint64_t                                     type      = 0;
        uint32_t                                     id        = 0;
        uint32_t                                     initialID = 0;

Hyprutils::Memory::CSharedPointer<CDRMFB>    front /* currently displaying */, back /* submitted */, last /* keep just in case */;
        Hyprutils::Memory::CWeakPointer<CDRMBackend> backend;
        Hyprutils::Memory::CWeakPointer<SDRMPlane>   self;
        std::vector<SDRMFormat>                      formats;

union UDRMPlaneProps {
            struct {
                uint32_t type;
                uint32_t rotation;   // Not guaranteed to exist
                uint32_t in_formats; // Not guaranteed to exist

// atomic-modesetting only

uint32_t src_x;
                uint32_t src_y;
                uint32_t src_w;
                uint32_t src_h;
                uint32_t crtc_x;
                uint32_t crtc_y;
                uint32_t crtc_w;
                uint32_t crtc_h;
                uint32_t fb_id;
                uint32_t crtc_id;
                uint32_t fb_damage_clips;
                uint32_t hotspot_x;
                uint32_t hotspot_y;
                uint32_t in_fence_fd;
            };
            uint32_t props[17] = {0};
        };
        UDRMPlaneProps props;
    };

struct SDRMCRTC {
        uint32_t               id = 0;
        std::vector<SDRMLayer> layers;
        int32_t                refresh = 0; // unused

struct {
            int gammaSize = 0;
        } legacy;

struct {
            bool     ownModeID = false;
            uint32_t modeID    = 0;
            uint32_t gammaLut  = 0;
        } atomic;

Hyprutils::Memory::CSharedPointer<SDRMPlane> primary;
        Hyprutils::Memory::CSharedPointer<SDRMPlane> cursor;
        Hyprutils::Memory::CWeakPointer<CDRMBackend> backend;
        Hyprutils::Memory::CSharedPointer<CDRMFB>    pendingCursor;

union UDRMCRTCProps {
            struct {
                // None of these are guaranteed to exist
                uint32_t vrr_enabled;
                uint32_t gamma_lut;
                uint32_t gamma_lut_size;

// atomic-modesetting only

uint32_t active;
                uint32_t mode_id;
                uint32_t out_fence_ptr;
            };
            uint32_t props[7] = {0};
        };
        UDRMCRTCProps props;
    };

class CDRMOutput : public IOutput {
      public:
        virtual ~CDRMOutput();
        virtual bool                                                      commit();
        virtual bool                                                      test();
        virtual Hyprutils::Memory::CSharedPointer<IBackendImplementation> getBackend();
        virtual bool                                                      setCursor(Hyprutils::Memory::CSharedPointer<IBuffer> buffer, const Hyprutils::Math::Vector2D& hotspot);
        virtual void                                                      moveCursor(const Hyprutils::Math::Vector2D& coord, bool skipShedule = false);
        virtual void                                                      scheduleFrame(const scheduleFrameReason reason = AQ_SCHEDULE_UNKNOWN);
        virtual void                                                      setCursorVisible(bool visible);
        virtual Hyprutils::Math::Vector2D                                 cursorPlaneSize();
        virtual size_t                                                    getGammaSize();
        virtual std::vector<SDRMFormat>                                   getRenderFormats();

int                                                               getConnectorID();

Hyprutils::Memory::CWeakPointer<CDRMOutput>                       self;
        Hyprutils::Memory::CWeakPointer<CDRMLease>                        lease;
        bool                                                              cursorVisible = true;
        Hyprutils::Math::Vector2D                                         cursorPos; // without hotspot
        Hyprutils::Math::Vector2D                                         cursorHotspot;

bool enabledState = true; // actual enabled state. Should be synced with state->state().enabled after a new frame

private:
        CDRMOutput(const std::string& name_, Hyprutils::Memory::CWeakPointer<CDRMBackend> backend_, Hyprutils::Memory::CSharedPointer<SDRMConnector> connector_);

bool                                                         commitState(bool onlyTest = false);

Hyprutils::Memory::CWeakPointer<CDRMBackend>                 backend;
        Hyprutils::Memory::CSharedPointer<SDRMConnector>             connector;
        Hyprutils::Memory::CSharedPointer<std::function<void(void)>> frameIdle;

struct {
            Hyprutils::Memory::CSharedPointer<CSwapchain> swapchain;
            Hyprutils::Memory::CSharedPointer<CSwapchain> cursorSwapchain;
        } mgpu;

bool lastCommitNoBuffer = true;

friend struct SDRMConnector;
        friend class CDRMLease;
    };

struct SDRMPageFlip {
        Hyprutils::Memory::CWeakPointer<SDRMConnector> connector;
    };

struct SDRMConnectorCommitData {
        Hyprutils::Memory::CSharedPointer<CDRMFB> mainFB, cursorFB;
        bool                                      modeset  = false;
        bool                                      blocking = false;
        uint32_t                                  flags    = 0;
        bool                                      test     = false;
        drmModeModeInfo                           modeInfo;

struct {
            uint32_t gammaLut = 0;
            uint32_t fbDamage = 0;
            uint32_t modeBlob = 0;
            bool     blobbed  = false;
            bool     gammad   = false;
        } atomic;

void calculateMode(Hyprutils::Memory::CSharedPointer<SDRMConnector> connector);
    };

struct SDRMConnector {
        ~SDRMConnector();

bool                                           init(drmModeConnector* connector);
        void                                           connect(drmModeConnector* connector);
        void                                           disconnect();
        Hyprutils::Memory::CSharedPointer<SDRMCRTC>    getCurrentCRTC(const drmModeConnector* connector);
        drmModeModeInfo*                               getCurrentMode();
        void                                           parseEDID(std::vector<uint8_t> data);
        bool                                           commitState(SDRMConnectorCommitData& data);
        void                                           applyCommit(const SDRMConnectorCommitData& data);
        void                                           rollbackCommit(const SDRMConnectorCommitData& data);
        void                                           onPresent();
        void                                           recheckCRTCProps();

Hyprutils::Memory::CSharedPointer<CDRMOutput>  output;
        Hyprutils::Memory::CWeakPointer<CDRMBackend>   backend;
        Hyprutils::Memory::CWeakPointer<SDRMConnector> self;
        std::string                                    szName;
        drmModeConnection                              status       = DRM_MODE_DISCONNECTED;
        uint32_t                                       id           = 0;
        std::array<uint64_t, 2>                        maxBpcBounds = {0, 0};
        Hyprutils::Memory::CSharedPointer<SDRMCRTC>    crtc;
        int32_t                                        refresh       = 0;
        uint32_t                                       possibleCrtcs = 0;
        std::string                                    make, serial, model;
        bool                                           canDoVrr = false;

bool                                           cursorEnabled = false;
        Hyprutils::Math::Vector2D                      cursorPos, cursorSize, cursorHotspot;
        Hyprutils::Memory::CSharedPointer<CDRMFB>      pendingCursorFB;

bool                                           isPageFlipPending = false;
        SDRMPageFlip                                   pendingPageFlip;
        bool                                           frameEventScheduled = false;

// the current state is invalid and won't commit, don't try to modeset.
        bool                                           commitTainted = false;

Hyprutils::Memory::CSharedPointer<SOutputMode> fallbackMode;

struct {
            bool vrrEnabled = false;
        } atomic;

union UDRMConnectorProps {
            struct {
                uint32_t edid;
                uint32_t dpms;
                uint32_t link_status; // not guaranteed to exist
                uint32_t path;
                uint32_t vrr_capable;  // not guaranteed to exist
                uint32_t subconnector; // not guaranteed to exist
                uint32_t non_desktop;
                uint32_t panel_orientation; // not guaranteed to exist
                uint32_t content_type;      // not guaranteed to exist
                uint32_t max_bpc;           // not guaranteed to exist

// atomic-modesetting only

uint32_t crtc_id;
            };
            uint32_t props[4] = {0};
        };
        UDRMConnectorProps props;
    };

class IDRMImplementation {
      public:
        virtual bool commit(Hyprutils::Memory::CSharedPointer<SDRMConnector> connector, SDRMConnectorCommitData& data) = 0;
        virtual bool reset()                                                                                           = 0;

// moving a cursor IIRC is almost instant on most hardware so we don't have to wait for a commit.
        virtual bool moveCursor(Hyprutils::Memory::CSharedPointer<SDRMConnector> connector, bool skipShedule = false) = 0;
    };

class CDRMBackend : public IBackendImplementation {
      public:
        virtual ~CDRMBackend();
        virtual eBackendType                                            type();
        virtual bool                                                    start();
        virtual std::vector<Hyprutils::Memory::CSharedPointer<SPollFD>> pollFDs();
        virtual int                                                     drmFD();
        virtual bool                                                    dispatchEvents();
        virtual uint32_t                                                capabilities();
        virtual bool                                                    setCursor(Hyprutils::Memory::CSharedPointer<IBuffer> buffer, const Hyprutils::Math::Vector2D& hotspot);
        virtual void                                                    onReady();
        virtual std::vector<SDRMFormat>                                 getRenderFormats();
        virtual std::vector<SDRMFormat>                                 getCursorFormats();
        virtual bool                                                    createOutput(const std::string& name = "");
        virtual Hyprutils::Memory::CSharedPointer<IAllocator>           preferredAllocator();
        virtual std::vector<SDRMFormat>                                 getRenderableFormats();

Hyprutils::Memory::CWeakPointer<CDRMBackend>                    self;

void                                                            log(eBackendLogLevel, const std::string&);
        bool                                                            sessionActive();
        int                                                             getNonMasterFD();

std::vector<FIdleCallback>                                      idleCallbacks;
        std::string                                                     gpuName;

private:
        CDRMBackend(Hyprutils::Memory::CSharedPointer<CBackend> backend);

static std::vector<Hyprutils::Memory::CSharedPointer<CDRMBackend>> attempt(Hyprutils::Memory::CSharedPointer<CBackend> backend);
        bool registerGPU(Hyprutils::Memory::CSharedPointer<CSessionDevice> gpu_, Hyprutils::Memory::CSharedPointer<CDRMBackend> primary_ = {});
        bool checkFeatures();
        bool initResources();
        bool initMgpu();
        bool grabFormats();
        bool shouldBlit();
        void scanConnectors();
        void scanLeases();
        void restoreAfterVT();
        void recheckCRTCs();
        void buildGlFormats(const std::vector<SGLFormat>& fmts);

Hyprutils::Memory::CSharedPointer<CSessionDevice>     gpu;
        Hyprutils::Memory::CSharedPointer<IDRMImplementation> impl;
        Hyprutils::Memory::CWeakPointer<CDRMBackend>          primary;

struct {
            Hyprutils::Memory::CSharedPointer<IAllocator>   allocator;
            Hyprutils::Memory::CSharedPointer<CDRMRenderer> renderer; // may be null if creation fails
        } rendererState;

Hyprutils::Memory::CWeakPointer<CBackend>                     backend;

std::vector<Hyprutils::Memory::CSharedPointer<SDRMCRTC>>      crtcs;
        std::vector<Hyprutils::Memory::CSharedPointer<SDRMPlane>>     planes;
        std::vector<Hyprutils::Memory::CSharedPointer<SDRMConnector>> connectors;
        std::vector<SDRMFormat>                                       formats;
        std::vector<SDRMFormat>                                       glFormats;

bool                                                          atomic = false;

struct {
            Hyprutils::Math::Vector2D cursorSize;
            bool                      supportsAsyncCommit     = false;
            bool                      supportsAddFb2Modifiers = false;
            bool                      supportsTimelines       = false;
        } drmProps;

struct {
            Hyprutils::Signal::CHyprSignalListener sessionActivate;
            Hyprutils::Signal::CHyprSignalListener gpuChange;
            Hyprutils::Signal::CHyprSignalListener gpuRemove;
        } listeners;

friend class CBackend;
        friend class CDRMFB;
        friend class CDRMFBAttachment;
        friend struct SDRMConnector;
        friend struct SDRMCRTC;
        friend struct SDRMPlane;
        friend class CDRMOutput;
        friend struct SDRMPageFlip;
        friend class CDRMLegacyImpl;
        friend class CDRMAtomicImpl;
        friend class CDRMAtomicRequest;
        friend class CDRMLease;
        friend class CGBMBuffer;
    };
};
0707010000001A000081A400000000000000000000000166C38D3F00000DFC000000000000000000000000000000000000003900000000aquamarine-0.3.3/include/aquamarine/backend/Headless.hpp#pragma once

#include "./Backend.hpp"
#include "../allocator/Swapchain.hpp"
#include "../output/Output.hpp"
#include <hyprutils/memory/WeakPtr.hpp>

namespace Aquamarine {
    class CBackend;
    class CHeadlessBackend;

class CHeadlessOutput : public IOutput {
      public:
        virtual ~CHeadlessOutput();
        virtual bool                                                      commit();
        virtual bool                                                      test();
        virtual Hyprutils::Memory::CSharedPointer<IBackendImplementation> getBackend();
        virtual void                                                      scheduleFrame(const scheduleFrameReason reason = AQ_SCHEDULE_UNKNOWN);
        virtual bool                                                      destroy();
        virtual std::vector<SDRMFormat>                                   getRenderFormats();

Hyprutils::Memory::CWeakPointer<CHeadlessOutput>                  self;

private:
        CHeadlessOutput(const std::string& name_, Hyprutils::Memory::CWeakPointer<CHeadlessBackend> backend_);

Hyprutils::Memory::CWeakPointer<CHeadlessBackend>        backend;

Hyprutils::Memory::CSharedPointer<std::function<void()>> framecb;
        bool                                                     frameScheduled = false;

friend class CHeadlessBackend;
    };

class CHeadlessBackend : public IBackendImplementation {
      public:
        virtual ~CHeadlessBackend();
        virtual eBackendType                                            type();
        virtual bool                                                    start();
        virtual std::vector<Hyprutils::Memory::CSharedPointer<SPollFD>> pollFDs();
        virtual int                                                     drmFD();
        virtual bool                                                    dispatchEvents();
        virtual uint32_t                                                capabilities();
        virtual bool                                                    setCursor(Hyprutils::Memory::CSharedPointer<IBuffer> buffer, const Hyprutils::Math::Vector2D& hotspot);
        virtual void                                                    onReady();
        virtual std::vector<SDRMFormat>                                 getRenderFormats();
        virtual std::vector<SDRMFormat>                                 getCursorFormats();
        virtual bool                                                    createOutput(const std::string& name = "");
        virtual Hyprutils::Memory::CSharedPointer<IAllocator>           preferredAllocator();

Hyprutils::Memory::CWeakPointer<CHeadlessBackend>               self;

private:
        CHeadlessBackend(Hyprutils::Memory::CSharedPointer<CBackend> backend_);

Hyprutils::Memory::CWeakPointer<CBackend>                       backend;
        std::vector<Hyprutils::Memory::CSharedPointer<CHeadlessOutput>> outputs;

size_t                                                          outputIDCounter = 0;

class CTimer {
          public:
            std::chrono::steady_clock::time_point when;
            std::function<void(void)>             what;
            bool                                  expired();
        };

struct {
            int                 timerfd = -1;
            std::vector<CTimer> timers;
        } timers;

void dispatchTimers();
        void updateTimerFD();

friend class CBackend;
        friend class CHeadlessOutput;
    };
};
0707010000001B000081A400000000000000000000000166C38D3F0000015F000000000000000000000000000000000000003500000000aquamarine-0.3.3/include/aquamarine/backend/Misc.hpp#pragma once

#include <cstdint>
#include <vector>

namespace Aquamarine {
    struct SGLFormat {
        uint32_t drmFormat = 0;
        uint64_t modifier  = 0;
        bool     external  = false;
    };

struct SDRMFormat {
        uint32_t              drmFormat = 0; /* DRM_FORMAT_INVALID */
        std::vector<uint64_t> modifiers;
    };
};
0707010000001C000081A400000000000000000000000166C38D3F0000228F000000000000000000000000000000000000003800000000aquamarine-0.3.3/include/aquamarine/backend/Session.hpp#pragma once

#include <sys/types.h>
#include <hyprutils/signal/Signal.hpp>
#include <hyprutils/memory/SharedPtr.hpp>
#include "../input/Input.hpp"
#include <vector>

struct udev;
struct udev_monitor;
struct udev_device;
struct libseat;
struct libinput;
struct libinput_event;
struct libinput_device;
struct libinput_tablet_tool;

namespace Aquamarine {
    class CBackend;
    class CSession;
    class CLibinputDevice;
    struct SPollFD;

class CSessionDevice {
      public:
        CSessionDevice(Hyprutils::Memory::CSharedPointer<CSession> session_, const std::string& path_);
        ~CSessionDevice();

static Hyprutils::Memory::CSharedPointer<CSessionDevice> openIfKMS(Hyprutils::Memory::CSharedPointer<CSession> session_, const std::string& path_);

bool                                                     supportsKMS();

int                                                      fd       = -1;
        int                                                      deviceID = -1;
        dev_t                                                    dev;
        std::string                                              path;

enum eChangeEventType : uint32_t {
            AQ_SESSION_EVENT_CHANGE_HOTPLUG = 0,
            AQ_SESSION_EVENT_CHANGE_LEASE,
        };

struct SChangeEvent {
            eChangeEventType type = AQ_SESSION_EVENT_CHANGE_HOTPLUG;

struct {
                uint32_t connectorID = 0, propID = 0;
            } hotplug;
        };

struct {
            Hyprutils::Signal::CSignal change;
            Hyprutils::Signal::CSignal remove;
        } events;

private:
        Hyprutils::Memory::CWeakPointer<CSession> session;
    };

class CLibinputKeyboard : public IKeyboard {
      public:
        CLibinputKeyboard(Hyprutils::Memory::CSharedPointer<CLibinputDevice> dev);
        virtual ~CLibinputKeyboard() {
            ;
        }

virtual libinput_device*   getLibinputHandle();
        virtual const std::string& getName();
        virtual void               updateLEDs(uint32_t leds);

private:
        Hyprutils::Memory::CWeakPointer<CLibinputDevice> device;