AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Start wiring up wgpu+winit

This commit is contained in:
Luke Street 2022-01-31 19:06:54 -05:00
parent 5491fd75cf
commit e48435f11e
209 changed files with 24234 additions and 8085 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
.vscode/launch.json vendored Normal file
View File

@ -0,0 +1,36 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "Launch",
"type": "cppdbg",
"request": "launch",
// Resolved by CMake Tools:
"program": "${command:cmake.launchTargetPath}",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [
{
// add the directory where our target was built to the PATHs
// it gets resolved by CMake Tools:
"name": "PATH",
"value": "$PATH:${command:cmake.launchTargetDirectory}"
},
{
"name": "OTHER_VALUE",
"value": "Something something"
}
],
"externalConsole": true,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
]
}

39
CMakeLists.txt
View File

@ -469,7 +469,7 @@ function(shaderc out)
endfunction()
include(hecl/ApplicationTools.cmake)
add_subdirectory(Shaders)
#add_subdirectory(Shaders)
add_subdirectory(imgui)
add_subdirectory(extern/libSquish EXCLUDE_FROM_ALL)
add_subdirectory(extern/libpng EXCLUDE_FROM_ALL)
@ -481,21 +481,21 @@ target_include_directories(hecl-light PRIVATE ${CMAKE_SOURCE_DIR})
target_link_libraries(hecl-full PRIVATE zeus nod)
target_link_libraries(hecl-light PRIVATE zeus nod)
bintoc(CModelShaders.common.glsl.cpp Shaders/CModelShaders.common.glsl CMODELSHADERS_COMMON_GLSL)
bintoc(CModelShaders.vert.glsl.cpp Shaders/CModelShaders.vert.glsl CMODELSHADERS_VERT_GLSL)
bintoc(CModelShaders.frag.glsl.cpp Shaders/CModelShaders.frag.glsl CMODELSHADERS_FRAG_GLSL)
bintoc(CModelShaders.common.hlsl.cpp Shaders/CModelShaders.common.hlsl CMODELSHADERS_COMMON_HLSL)
bintoc(CModelShaders.vert.hlsl.cpp Shaders/CModelShaders.vert.hlsl CMODELSHADERS_VERT_HLSL)
bintoc(CModelShaders.frag.hlsl.cpp Shaders/CModelShaders.frag.hlsl CMODELSHADERS_FRAG_HLSL)
bintoc(CModelShaders.common.metal.cpp Shaders/CModelShaders.common.metal CMODELSHADERS_COMMON_METAL)
bintoc(CModelShaders.vert.metal.cpp Shaders/CModelShaders.vert.metal CMODELSHADERS_VERT_METAL)
bintoc(CModelShaders.frag.metal.cpp Shaders/CModelShaders.frag.metal CMODELSHADERS_FRAG_METAL)
add_library(CModelShaders
CModelShaders.common.glsl.cpp CModelShaders.vert.glsl.cpp CModelShaders.frag.glsl.cpp
CModelShaders.common.hlsl.cpp CModelShaders.vert.hlsl.cpp CModelShaders.frag.hlsl.cpp
CModelShaders.common.metal.cpp CModelShaders.vert.metal.cpp CModelShaders.frag.metal.cpp)
target_link_libraries(CModelShaders PUBLIC zeus)
target_link_libraries(shader_CModelShaders PUBLIC CModelShaders)
#bintoc(CModelShaders.common.glsl.cpp Shaders/CModelShaders.common.glsl CMODELSHADERS_COMMON_GLSL)
#bintoc(CModelShaders.vert.glsl.cpp Shaders/CModelShaders.vert.glsl CMODELSHADERS_VERT_GLSL)
#bintoc(CModelShaders.frag.glsl.cpp Shaders/CModelShaders.frag.glsl CMODELSHADERS_FRAG_GLSL)
#bintoc(CModelShaders.common.hlsl.cpp Shaders/CModelShaders.common.hlsl CMODELSHADERS_COMMON_HLSL)
#bintoc(CModelShaders.vert.hlsl.cpp Shaders/CModelShaders.vert.hlsl CMODELSHADERS_VERT_HLSL)
#bintoc(CModelShaders.frag.hlsl.cpp Shaders/CModelShaders.frag.hlsl CMODELSHADERS_FRAG_HLSL)
#bintoc(CModelShaders.common.metal.cpp Shaders/CModelShaders.common.metal CMODELSHADERS_COMMON_METAL)
#bintoc(CModelShaders.vert.metal.cpp Shaders/CModelShaders.vert.metal CMODELSHADERS_VERT_METAL)
#bintoc(CModelShaders.frag.metal.cpp Shaders/CModelShaders.frag.metal CMODELSHADERS_FRAG_METAL)
#add_library(CModelShaders
# CModelShaders.common.glsl.cpp CModelShaders.vert.glsl.cpp CModelShaders.frag.glsl.cpp
# CModelShaders.common.hlsl.cpp CModelShaders.vert.hlsl.cpp CModelShaders.frag.hlsl.cpp
# CModelShaders.common.metal.cpp CModelShaders.vert.metal.cpp CModelShaders.frag.metal.cpp)
#target_link_libraries(CModelShaders PUBLIC zeus)
#target_link_libraries(shader_CModelShaders PUBLIC CModelShaders)
if(NOT TARGET atdna)
# Import native atdna if cross-compiling
@ -517,12 +517,13 @@ add_subdirectory(extern/jbus EXCLUDE_FROM_ALL)
set(JBUS_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/extern/jbus/include)
add_subdirectory(NESEmulator EXCLUDE_FROM_ALL)
add_subdirectory(Graphics)
add_subdirectory(Runtime)
add_subdirectory(mpcksum EXCLUDE_FROM_ALL)
add_subdirectory(gbalink EXCLUDE_FROM_ALL)
add_subdirectory(visigen)
#add_subdirectory(visigen)
add_dependencies(hecl visigen)
#add_dependencies(hecl visigen)
if (NOT WINDOWS_STORE AND NOT NX)
if (APPLE AND EXISTS /opt/local/libexec/qt5)
@ -552,7 +553,7 @@ endif()
configure_file(${CMAKE_SOURCE_DIR}/version.h.in ${CMAKE_BINARY_DIR}/version.h)
# Packaging logic
list(APPEND BINARY_TARGETS metaforce hecl visigen)
list(APPEND BINARY_TARGETS metaforce hecl) # visigen
set(DSYM_ONLY_TARGETS "")
if (TARGET crashpad_handler)
list(APPEND BINARY_TARGETS crashpad_handler)

2
DataSpec/CMakeLists.txt
View File

@ -74,7 +74,7 @@ add_library(AssetNameMapNull
get_target_property(HECL_INCLUDES hecl-full INCLUDE_DIRECTORIES)
target_include_directories(RetroDataSpec PUBLIC ${HECL_INCLUDES} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR})
target_link_libraries(RetroDataSpec PUBLIC amuse zeus nod squish ${PNG_LIBRARIES} ${ZLIB_LIBRARIES} lzokay logvisor)
target_link_libraries(RetroDataSpec PUBLIC amuse zeus nod squish ${PNG_LIBRARIES} ${ZLIB_LIBRARIES} lzokay logvisor aurora)
if (COMMAND add_sanitizers)
add_sanitizers(RetroDataSpec)
endif ()

17
Graphics/.gitignore vendored Normal file
View File

@ -0,0 +1,17 @@
# Rust
target/
**/*.rs.bk
generated/
# cargo-mobile
.cargo/
/gen
# macOS
.DS_Store
# JetBrains
.idea
# Generated SPIR-V
*.spv

42
Graphics/CMakeLists.txt Normal file
View File

@ -0,0 +1,42 @@
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
set(CARGO_CMD cargo build --verbose)
set(TARGET_DIR "debug")
else ()
set(CARGO_CMD cargo build --release --verbose)
set(TARGET_DIR "release")
endif ()
if(USE_LTO)
set(RUST_FLAGS "-Clinker-plugin-lto" "-Clinker=clang" "-Clink-arg=-fuse-ld=lld")
endif()
set(AURORA_LIB "${CMAKE_CURRENT_BINARY_DIR}/${TARGET_DIR}/libaurora.a")
set(AURORA_CXX "${CMAKE_CURRENT_BINARY_DIR}/aurora.cpp")
set(AURORA_SHADERS_CXX "${CMAKE_CURRENT_BINARY_DIR}/aurora_shaders.cpp")
set(AURORA_IMGUI_CXX "${CMAKE_CURRENT_BINARY_DIR}/aurora_imgui.cpp")
add_library(aurora STATIC ${AURORA_CXX} ${AURORA_SHADERS_CXX})
target_include_directories(aurora PRIVATE ../Runtime)
target_include_directories(aurora PUBLIC include ${CMAKE_CURRENT_BINARY_DIR})
add_custom_command(
OUTPUT ${AURORA_CXX} ${AURORA_SHADERS_CXX} ${AURORA_IMGUI_CXX} ${AURORA_LIB} #__no_exist
COMMAND CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR} RUSTFLAGS="${RUST_FLAGS}" ${CARGO_CMD}
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/cxxbridge/aurora/src/lib.rs.cc ${AURORA_CXX}
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/cxxbridge/aurora/src/lib.rs.h ${CMAKE_CURRENT_BINARY_DIR}/aurora.h
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/cxxbridge/aurora/src/shaders/mod.rs.cc ${AURORA_SHADERS_CXX}
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/cxxbridge/aurora/src/shaders/mod.rs.h ${CMAKE_CURRENT_BINARY_DIR}/aurora_shaders.h
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/cxxbridge/aurora/src/imgui.rs.cc ${AURORA_IMGUI_CXX}
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/cxxbridge/aurora/src/imgui.rs.h ${CMAKE_CURRENT_BINARY_DIR}/aurora_imgui.h
DEPENDS src/lib.rs
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
add_custom_target(
always_run ALL
DEPENDS __no_exist
)
target_link_libraries(aurora pthread dl ${AURORA_LIB} zeus)
add_test(NAME aurora_test
COMMAND cargo test
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

2076
Graphics/Cargo.lock generated Normal file
View File

File diff suppressed because it is too large Load Diff

75
Graphics/Cargo.toml Normal file
View File

@ -0,0 +1,75 @@
[package]
name = "aurora"
version = "0.0.1"
authors = ["Luke Street <luke@street.dev>"]
edition = "2021"
license = "MIT"
[lib]
crate-type = ["staticlib"]
#[[bin]]
#name = "metaforce"
#path = "src/main.rs"
[dependencies]
cxx = "1.0.60"
web-sys = "0.3.55"
env_logger = "0.9.0"
mobile-entry-point = "0.1.1"
pollster = "0.2.4"
binread = { version = "2.2.0", features = ['const_generics'] }
modular-bitfield = "0.11.2"
num-traits = "0.2.14"
num_enum = "0.5.5"
bytemuck = "1.7.3"
bytemuck_derive = "1.0.1"
log = "0.4.14"
log-panics = "2.0.0"
cgmath = "0.18.0"
smallvec = "1.7.0"
scopeguard = "1.1.0"
twox-hash = "1.6.2"
winit = "0.26.0"
[dependencies.imgui]
git = "https://github.com/imgui-rs/imgui-rs"
rev = "55a76370466953d5c044afc123330d0262b50e17"
[dependencies.imgui-winit-support]
git = "https://github.com/imgui-rs/imgui-rs"
rev = "55a76370466953d5c044afc123330d0262b50e17"
default-features = false
features = ["winit-26"]
[patch.'https://github.com/imgui-rs/imgui-rs']
imgui-sys = { path = "../imgui-sys" }
[patch.crates-io]
imgui-sys = { path = "../imgui-sys" }
[dependencies.wgpu]
#path = "../../wgpu/wgpu"
git = "https://github.com/gfx-rs/wgpu"
rev = "39b7a8a202c21da43035ec8dd5570a58cf4e8ef1"
features = ["spirv"]
#[patch.'https://github.com/gfx-rs/naga']
#naga = { path = "../../naga" }
[build-dependencies]
#naga = { path = "../../naga", features = ['spv-out', 'wgsl-in'] }
naga = { git = "https://github.com/gfx-rs/naga", rev = "8df5421", features = ['spv-out', 'wgsl-in'] }
bytemuck = "1.7.3"
cxx-build = "1.0.60"
bindgen = "0.59.2"
[target.'cfg(target_os = "android")'.dependencies]
android_logger = "0.10.1"
ndk-glue = "0.5.0"
[target.'cfg(not(target_os = "android"))'.dependencies]
wgpu-subscriber = "0.1.0"
[target.'cfg(target_family = "wasm")'.dependencies]
console_error_panic_hook = "0.1.7"
console_log = "0.2.0"
wasm-bindgen-futures = "0.4.28"
#features = ["web-sys"]

47
Graphics/build.rs Normal file
View File

@ -0,0 +1,47 @@
fn main() {
let zeus_include = std::path::PathBuf::from(format!(
"{}/../extern/zeus/include",
std::env::var("CARGO_MANIFEST_DIR").unwrap()
))
.canonicalize()
.unwrap();
let imgui_include = std::path::PathBuf::from(format!(
"{}/../extern/imgui",
std::env::var("CARGO_MANIFEST_DIR").unwrap()
))
.canonicalize()
.unwrap();
let imgui_engine_include = std::path::PathBuf::from(format!(
"{}/../imgui",
std::env::var("CARGO_MANIFEST_DIR").unwrap()
))
.canonicalize()
.unwrap();
// let include_dir = include_path.to_string_lossy();
// let bindings = bindgen::Builder::default()
// .header(format!("{}/zeus/CVector3f.hpp", include_dir))
// .clang_arg(format!("-I{}", include_dir))
// .parse_callbacks(Box::new(bindgen::CargoCallbacks))
// .generate()
// .expect("Unable to generate bindings");
// let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
// bindings.write_to_file(out_path.join("zeus.rs")).expect("Couldn't write bindings!");
cxx_build::bridge("src/lib.rs")
.include("include")
.include(zeus_include.clone())
.compile("aurora");
println!("cargo:rerun-if-changed=src/lib.rs");
cxx_build::bridge("src/shaders/mod.rs")
.include("include")
.include(zeus_include.clone())
.compile("aurora_shaders");
println!("cargo:rerun-if-changed=src/shaders/mod.rs");
cxx_build::bridge("src/imgui.rs")
.include("include")
.include(zeus_include.clone())
.include(imgui_include.clone())
.include(imgui_engine_include.clone())
.compile("aurora_imgui");
println!("cargo:rerun-if-changed=src/imgui.rs");
}

48
Graphics/include/aurora.hpp Normal file
View File

@ -0,0 +1,48 @@
#pragma once
#include <array>
#include <type_traits>
#include <vector>
namespace aurora {
struct WindowSize;
struct App;
struct AppDelegate {
AppDelegate() = default;
virtual ~AppDelegate() noexcept = default;
AppDelegate(const AppDelegate&) = delete;
AppDelegate& operator=(const AppDelegate&) = delete;
AppDelegate(AppDelegate&&) = delete;
AppDelegate& operator=(AppDelegate&&) = delete;
virtual void onAppLaunched() noexcept = 0;
virtual bool onAppIdle(float dt) noexcept = 0;
virtual void onAppDraw() noexcept = 0;
virtual void onAppPostDraw() noexcept = 0;
virtual void onAppExiting() noexcept = 0;
// virtual void resized([[maybe_unused]] const WindowSize& rect, [[maybe_unused]] bool sync) noexcept {}
// virtual void mouseDown([[maybe_unused]] const SWindowCoord& coord, [[maybe_unused]] EMouseButton button,
// [[maybe_unused]] EModifierKey mods) noexcept {}
// virtual void mouseUp([[maybe_unused]] const SWindowCoord& coord, [[maybe_unused]] EMouseButton button,
// [[maybe_unused]] EModifierKey mods) noexcept {}
// virtual void mouseMove([[maybe_unused]] const SWindowCoord& coord) noexcept {}
// virtual void mouseEnter([[maybe_unused]] const SWindowCoord& coord) noexcept {}
// virtual void mouseLeave([[maybe_unused]] const SWindowCoord& coord) noexcept {}
// virtual void scroll([[maybe_unused]] const SWindowCoord& coord, [[maybe_unused]] const SScrollDelta& scroll) noexcept {}
//
// virtual void touchDown([[maybe_unused]] const STouchCoord& coord, [[maybe_unused]] uintptr_t tid) noexcept {}
// virtual void touchUp([[maybe_unused]] const STouchCoord& coord, [[maybe_unused]] uintptr_t tid) noexcept {}
// virtual void touchMove([[maybe_unused]] const STouchCoord& coord, [[maybe_unused]] uintptr_t tid) noexcept {}
//
// virtual void charKeyDown([[maybe_unused]] unsigned long charCode, [[maybe_unused]] EModifierKey mods,
// [[maybe_unused]] bool isRepeat) noexcept {}
// virtual void charKeyUp([[maybe_unused]] unsigned long charCode, [[maybe_unused]] EModifierKey mods) noexcept {}
// virtual void specialKeyDown([[maybe_unused]] ESpecialKey key, [[maybe_unused]] EModifierKey mods,
// [[maybe_unused]] bool isRepeat) noexcept {}
// virtual void specialKeyUp([[maybe_unused]] ESpecialKey key, [[maybe_unused]] EModifierKey mods) noexcept {}
// virtual void modKeyDown([[maybe_unused]] EModifierKey mod, [[maybe_unused]] bool isRepeat) noexcept {}
// virtual void modKeyUp([[maybe_unused]] EModifierKey mod) noexcept {}
};
} // namespace aurora

9
Graphics/include/lib.hpp Normal file
View File

@ -0,0 +1,9 @@
#include "aurora.hpp"
namespace aurora {
void App_onAppLaunched(AppDelegate& cb) noexcept;
bool App_onAppIdle(AppDelegate& cb, float dt) noexcept;
void App_onAppDraw(AppDelegate& cb) noexcept;
void App_onAppPostDraw(AppDelegate& cb) noexcept;
void App_onAppExiting(AppDelegate& cb) noexcept;
} // namespace aurora

9
Graphics/lib.cpp Normal file
View File

@ -0,0 +1,9 @@
#include "include/lib.hpp"
namespace aurora {
void App_onAppLaunched(AppDelegate& cb) noexcept { return cb.onAppLaunched(); }
bool App_onAppIdle(AppDelegate& cb, float dt) noexcept { return cb.onAppIdle(dt); }
void App_onAppDraw(AppDelegate& cb) noexcept { cb.onAppDraw(); }
void App_onAppPostDraw(AppDelegate& cb) noexcept { cb.onAppPostDraw(); }
void App_onAppExiting(AppDelegate& cb) noexcept { cb.onAppExiting(); }
} // namespace aurora

8
Graphics/rustfmt.toml Normal file
View File

@ -0,0 +1,8 @@
fn_single_line = true
group_imports = "StdExternalCrate"
imports_granularity = "Crate"
overflow_delimited_expr = true
reorder_impl_items = true
use_field_init_shorthand = true
use_small_heuristics = "Max"
where_single_line = true

194
Graphics/src/gpu.rs Normal file
View File

@ -0,0 +1,194 @@
use std::{num::NonZeroU8, sync::Arc};
use pollster::block_on;
#[derive(Clone)]
pub(crate) struct GraphicsConfig {
pub(crate) color_format: wgpu::TextureFormat,
pub(crate) depth_format: wgpu::TextureFormat,
pub(crate) texture_anistropy: Option<NonZeroU8>,
pub(crate) msaa_samples: u32,
}
pub struct DeviceHolder {
pub(crate) instance: wgpu::Instance,
pub(crate) surface: wgpu::Surface,
pub(crate) adapter: wgpu::Adapter,
pub(crate) backend: wgpu::Backend,
pub(crate) device: Arc<wgpu::Device>,
pub(crate) queue: Arc<wgpu::Queue>,
pub(crate) config: GraphicsConfig,
pub(crate) surface_config: wgpu::SurfaceConfiguration,
pub(crate) framebuffer: TextureWithSampler,
pub(crate) depth: TextureWithSampler,
}
pub(crate) struct TextureWithSampler {
pub(crate) texture: wgpu::Texture,
pub(crate) view: wgpu::TextureView,
pub(crate) sampler: wgpu::Sampler,
}
pub(crate) fn create_render_texture(
device: &wgpu::Device,
config: &wgpu::SurfaceConfiguration,
graphics_config: &GraphicsConfig,
) -> TextureWithSampler {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("Render texture"),
size: wgpu::Extent3d {
width: config.width,
height: config.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: graphics_config.msaa_samples,
dimension: wgpu::TextureDimension::D2,
format: graphics_config.color_format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
});
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Render sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: 0.0,
lod_max_clamp: f32::MAX,
compare: None,
anisotropy_clamp: None,
border_color: None,
});
TextureWithSampler { texture, view, sampler }
}
pub(crate) fn create_depth_texture(
device: &wgpu::Device,
config: &wgpu::SurfaceConfiguration,
graphics_config: &GraphicsConfig,
) -> TextureWithSampler {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("Depth texture"),
size: wgpu::Extent3d {
width: config.width,
height: config.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: graphics_config.msaa_samples,
dimension: wgpu::TextureDimension::D2,
format: graphics_config.depth_format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
});
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Depth sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: 0.0,
lod_max_clamp: f32::MAX,
compare: None,
anisotropy_clamp: None,
border_color: None,
});
TextureWithSampler { texture, view, sampler }
}
pub(crate) fn initialize_gpu(window: &winit::window::Window) -> DeviceHolder {
log::info!("Creating wgpu instance");
let instance = wgpu::Instance::new(wgpu::Backends::all());
let surface = unsafe { instance.create_surface(window) };
let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: Some(&surface),
force_fallback_adapter: false,
}))
.expect("Failed to find an appropriate adapter");
let best_limits = adapter.limits();
let backend = adapter.get_info().backend;
#[cfg(any(target_os = "android", target_os = "ios"))]
let needs_denorm = true;
#[cfg(not(any(target_os = "android", target_os = "ios")))]
let _needs_denorm = backend == wgpu::Backend::Gl;
let required_features = if backend == wgpu::Backend::Vulkan {
wgpu::Features::SPIRV_SHADER_PASSTHROUGH
} else {
wgpu::Features::empty()
};
let optional_features = wgpu::Features::TEXTURE_COMPRESSION_BC
| wgpu::Features::ADDRESS_MODE_CLAMP_TO_BORDER
| required_features;
log::info!("Requesting device with features: {:?}", optional_features);
let limits = wgpu::Limits::downlevel_defaults()
.using_resolution(best_limits.clone())
.using_alignment(best_limits);
let (device, queue) = block_on(adapter.request_device(
&wgpu::DeviceDescriptor {
label: Some("Device with optional features"),
features: optional_features,
limits: limits.clone(),
},
None,
))
.unwrap_or_else(|_| {
log::warn!("Failed... requesting device with no features");
block_on(adapter.request_device(
&wgpu::DeviceDescriptor {
label: Some("Device without optional features"),
features: required_features,
limits,
},
None,
))
.expect("Failed to create device")
});
log::info!("Successfully created device");
let mut swapchain_format = surface.get_preferred_format(&adapter).unwrap();
if backend != wgpu::Backend::Gl {
swapchain_format = match swapchain_format {
wgpu::TextureFormat::Rgba8UnormSrgb => wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Bgra8UnormSrgb => wgpu::TextureFormat::Bgra8Unorm,
_ => swapchain_format,
};
}
let graphics_config = GraphicsConfig {
color_format: swapchain_format,
depth_format: wgpu::TextureFormat::Depth32Float,
texture_anistropy: NonZeroU8::new(16),
msaa_samples: 4,
};
let size = window.inner_size();
let surface_config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: swapchain_format,
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
};
surface.configure(&device, &surface_config);
let depth = create_depth_texture(&device, &surface_config, &graphics_config);
let framebuffer = create_render_texture(&device, &surface_config, &graphics_config);
DeviceHolder {
instance,
surface,
adapter,
backend,
device: Arc::new(device),
queue: Arc::new(queue),
config: graphics_config,
surface_config,
framebuffer,
depth,
}
}

80
Graphics/src/imgui.rs Normal file
View File

@ -0,0 +1,80 @@
use crate::{gpu::DeviceHolder, imgui_backend};
#[cxx::bridge(namespace = "metaforce")]
mod ffi {
unsafe extern "C++" {
include!("ImGuiEngine.hpp");
pub(crate) fn ImGuiEngine_Initialize(scale: f32);
pub(crate) fn ImGuiEngine_AddTextures(state: &mut ImGuiState, device: &DeviceHolder);
}
extern "Rust" {
type ImGuiState;
type DeviceHolder;
fn ImGuiEngine_AddTexture(
state: &mut ImGuiState,
device: &DeviceHolder,
width: u32,
height: u32,
data: &[u8],
) -> usize;
}
}
pub struct ImGuiState {
pub(crate) context: imgui::Context,
pub(crate) platform: imgui_winit_support::WinitPlatform,
pub(crate) backend: imgui_backend::Renderer,
}
pub(crate) fn initialize_imgui(window: &winit::window::Window, gpu: &DeviceHolder) -> ImGuiState {
let hidpi_factor = window.scale_factor();
let mut imgui = imgui::Context::create();
let mut platform = imgui_winit_support::WinitPlatform::init(&mut imgui);
platform.attach_window(imgui.io_mut(), &window, imgui_winit_support::HiDpiMode::Default);
imgui.set_ini_filename(None);
imgui.io_mut().font_global_scale = (1.0 / hidpi_factor) as f32;
unsafe {
ffi::ImGuiEngine_Initialize(hidpi_factor as f32);
}
let renderer_config = if gpu.backend == wgpu::Backend::Vulkan {
imgui_backend::RendererConfig::new_spv_srgb()
} else {
imgui_backend::RendererConfig::new_srgb()
};
let imgui_backend = imgui_backend::Renderer::new(
&mut imgui,
&gpu.device,
&gpu.queue,
imgui_backend::RendererConfig {
texture_format: gpu.config.color_format,
depth_format: Some(gpu.config.depth_format),
sample_count: gpu.config.msaa_samples,
..renderer_config
},
);
let mut state = ImGuiState { context: imgui, platform, backend: imgui_backend };
unsafe {
ffi::ImGuiEngine_AddTextures(&mut state, &gpu);
}
state
}
fn ImGuiEngine_AddTexture(
state: &mut ImGuiState,
gpu: &DeviceHolder,
width: u32,
height: u32,
data: &[u8],
) -> usize {
let texture =
imgui_backend::Texture::new(&gpu.device, &state.backend, imgui_backend::TextureConfig {
size: wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
format: Some(wgpu::TextureFormat::Rgba8Unorm),
..Default::default()
});
texture.write(&gpu.queue, data, width, height);
state.backend.textures.insert(texture).id()
}

53
Graphics/src/imgui_backend/imgui.wgsl Normal file
View File

@ -0,0 +1,53 @@
struct Uniforms {
u_Matrix: mat4x4<f32>;
};
struct VertexInput {
[[location(0)]] a_Pos: vec2<f32>;
[[location(1)]] a_UV: vec2<f32>;
[[location(2)]] a_Color: vec4<f32>;
};
struct VertexOutput {
[[location(0)]] v_UV: vec2<f32>;
[[location(1)]] v_Color: vec4<f32>;
[[builtin(position)]] v_Position: vec4<f32>;
};
[[group(0), binding(0)]]
var<uniform> uniforms: Uniforms;
[[stage(vertex)]]
fn vs_main(in: VertexInput) -> VertexOutput {
var out: VertexOutput;
out.v_UV = in.a_UV;
out.v_Color = in.a_Color;
out.v_Position = uniforms.u_Matrix * vec4<f32>(in.a_Pos.xy, 0.0, 1.0);
return out;
}
[[group(1), binding(0)]]
var u_Texture: texture_2d<f32>;
[[group(1), binding(1)]]
var u_Sampler: sampler;
fn srgb_to_linear(srgb: vec4<f32>) -> vec4<f32> {
let color_srgb = srgb.rgb;
let selector = ceil(color_srgb - 0.04045); // 0 if under value, 1 if over
let under = color_srgb / 12.92;
let over = pow((color_srgb + 0.055) / 1.055, vec3<f32>(2.4));
let result = mix(under, over, selector);
return vec4<f32>(result, srgb.a);
}
[[stage(fragment)]]
fn fs_main_linear(in: VertexOutput) -> [[location(0)]] vec4<f32> {
let color = srgb_to_linear(in.v_Color);
return color * textureSample(u_Texture, u_Sampler, in.v_UV);
}
[[stage(fragment)]]
fn fs_main_srgb(in: VertexOutput) -> [[location(0)]] vec4<f32> {
let color = in.v_Color;
return color * textureSample(u_Texture, u_Sampler, in.v_UV);
}

659
Graphics/src/imgui_backend/mod.rs Normal file
View File

@ -0,0 +1,659 @@
use std::{borrow::BorrowMut, error::Error, fmt, mem::size_of, num::NonZeroU32};
use imgui::{
Context, DrawCmd::Elements, DrawData, DrawIdx, DrawList, DrawVert, TextureId, Textures,
};
use smallvec::SmallVec;
use wgpu::{
util::{BufferInitDescriptor, DeviceExt},
*,
};
static VS_ENTRY_POINT: &str = "vs_main";
static FS_ENTRY_POINT_LINEAR: &str = "fs_main_linear";
static FS_ENTRY_POINT_SRGB: &str = "fs_main_srgb";
pub type RendererResult<T> = Result<T, RendererError>;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
struct DrawVertPod(DrawVert);
unsafe impl bytemuck::Zeroable for DrawVertPod {}
unsafe impl bytemuck::Pod for DrawVertPod {}
#[derive(Clone, Debug)]
pub enum RendererError {
BadTexture(TextureId),
}
impl fmt::Display for RendererError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
RendererError::BadTexture(id) => {
write!(f, "imgui render error: bad texture id '{}'", id.id())
}
}
}
}
impl Error for RendererError {}
#[allow(dead_code)]
enum ShaderStage {
Vertex,
Fragment,
Compute,
}
/// Config for creating a texture.
///
/// Uses the builder pattern.
#[derive(Clone)]
pub struct TextureConfig<'a> {
/// The size of the texture.
pub size: Extent3d,
/// An optional label for the texture used for debugging.
pub label: Option<&'a str>,
/// The format of the texture, if not set uses the format from the renderer.
pub format: Option<TextureFormat>,
/// The usage of the texture.
pub usage: TextureUsages,
/// The mip level of the texture.
pub mip_level_count: u32,
/// The sample count of the texture.
pub sample_count: u32,
/// The dimension of the texture.
pub dimension: TextureDimension,
}
impl<'a> Default for TextureConfig<'a> {
/// Create a new texture config.
fn default() -> Self {
Self {
size: Extent3d { width: 0, height: 0, depth_or_array_layers: 1 },
label: None,
format: None,
usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
mip_level_count: 1,
sample_count: 1,
dimension: TextureDimension::D2,
}
}
}
/// A container for a bindable texture.
pub struct Texture {
texture: wgpu::Texture,
view: wgpu::TextureView,
bind_group: BindGroup,
size: Extent3d,
}
impl Texture {
/// Create a `Texture` from its raw parts.
pub fn from_raw_parts(
texture: wgpu::Texture,
view: wgpu::TextureView,
bind_group: BindGroup,
size: Extent3d,
) -> Self {
Self { texture, view, bind_group, size }
}
/// Create a new GPU texture width the specified `config`.
pub fn new(device: &Device, renderer: &Renderer, config: TextureConfig) -> Self {
// Create the wgpu texture.
let texture = device.create_texture(&TextureDescriptor {
label: config.label,
size: config.size,
mip_level_count: config.mip_level_count,
sample_count: config.sample_count,
dimension: config.dimension,
format: config.format.unwrap_or(renderer.config.texture_format),
usage: config.usage,
});
// Extract the texture view.
let view = texture.create_view(&TextureViewDescriptor::default());
// Create the texture sampler.
let sampler = device.create_sampler(&SamplerDescriptor {
label: Some("imgui-wgpu sampler"),
address_mode_u: AddressMode::ClampToEdge,
address_mode_v: AddressMode::ClampToEdge,
address_mode_w: AddressMode::ClampToEdge,
mag_filter: FilterMode::Linear,
min_filter: FilterMode::Linear,
mipmap_filter: FilterMode::Linear,
lod_min_clamp: 0.0,
lod_max_clamp: f32::MAX,
compare: None,
anisotropy_clamp: None,
border_color: None,
});
// Create the texture bind group from the layout.
let bind_group = device.create_bind_group(&BindGroupDescriptor {
label: config.label,
layout: &renderer.texture_layout,
entries: &[
BindGroupEntry { binding: 0, resource: BindingResource::TextureView(&view) },
BindGroupEntry { binding: 1, resource: BindingResource::Sampler(&sampler) },
],
});
Self { texture, view, bind_group, size: config.size }
}
/// Write `data` to the texture.
///
/// - `data`: 32-bit RGBA bitmap data.
/// - `width`: The width of the source bitmap (`data`) in pixels.
/// - `height`: The height of the source bitmap (`data`) in pixels.
pub fn write(&self, queue: &Queue, data: &[u8], width: u32, height: u32) {
queue.write_texture(
// destination (sub)texture
ImageCopyTexture {
texture: &self.texture,
mip_level: 0,
origin: Origin3d { x: 0, y: 0, z: 0 },
aspect: TextureAspect::All,
},
// source bitmap data
data,
// layout of the source bitmap
ImageDataLayout {
offset: 0,
bytes_per_row: NonZeroU32::new(width * 4),
rows_per_image: NonZeroU32::new(height),
},
// size of the source bitmap
Extent3d { width, height, depth_or_array_layers: 1 },
);
}
/// The width of the texture in pixels.
pub fn width(&self) -> u32 { self.size.width }
/// The height of the texture in pixels.
pub fn height(&self) -> u32 { self.size.height }
/// The depth of the texture.
pub fn depth(&self) -> u32 { self.size.depth_or_array_layers }
/// The size of the texture in pixels.
pub fn size(&self) -> Extent3d { self.size }
/// The underlying `wgpu::Texture`.
pub fn texture(&self) -> &wgpu::Texture { &self.texture }
/// The `wgpu::TextureView` of the underlying texture.
pub fn view(&self) -> &wgpu::TextureView { &self.view }
}
pub struct CombinedShader<'s> {
pub shader: ShaderModuleDescriptor<'s>,
}
pub struct SeparateShaders<'s> {
pub vertex_shader: ShaderModuleDescriptorSpirV<'s>,
pub fragment_shader: ShaderModuleDescriptorSpirV<'s>,
}
pub enum ShaderType<'s> {
None,
Combined(CombinedShader<'s>),
Separate(SeparateShaders<'s>),
}
/// Configuration for the renderer.
pub struct RendererConfig<'s> {
pub texture_format: TextureFormat,
pub depth_format: Option<TextureFormat>,
pub sample_count: u32,
pub shader: ShaderType<'s>,
pub vertex_shader_entry_point: String,
pub fragment_shader_entry_point: String,
}
impl RendererConfig<'_> {
/// Create a new renderer config with custom shaders.
pub fn with_combined_shaders<'s>(
shader: ShaderModuleDescriptor<'s>,
fragment_shader_entry_point: &str,
) -> RendererConfig<'s> {
RendererConfig {
texture_format: TextureFormat::Rgba8Unorm,
depth_format: None,
sample_count: 1,
shader: ShaderType::Combined(CombinedShader { shader }),
vertex_shader_entry_point: VS_ENTRY_POINT.to_string(),
fragment_shader_entry_point: fragment_shader_entry_point.to_string(),
}
}
/// Create a new renderer config with custom shaders.
pub fn with_separate_shaders<'s>(
vertex_shader: ShaderModuleDescriptorSpirV<'s>,
fragment_shader: ShaderModuleDescriptorSpirV<'s>,
fragment_shader_entry_point: &str,
) -> RendererConfig<'s> {
RendererConfig {
texture_format: TextureFormat::Rgba8Unorm,
depth_format: None,
sample_count: 1,
shader: ShaderType::Separate(SeparateShaders { vertex_shader, fragment_shader }),
vertex_shader_entry_point: VS_ENTRY_POINT.to_string(),
fragment_shader_entry_point: fragment_shader_entry_point.to_string(),
}
}
}
impl Default for RendererConfig<'_> {
/// Create a new renderer config with precompiled default shaders outputting linear color.
///
/// If you write to a Bgra8UnormSrgb framebuffer, this is what you want.
fn default() -> Self { Self::new() }
}
impl RendererConfig<'_> {
/// Create a new renderer config with precompiled default shaders outputting linear color.
///
/// If you write to a Bgra8UnormSrgb framebuffer, this is what you want.
pub fn new() -> Self {
Self::with_combined_shaders(include_wgsl!("imgui.wgsl"), FS_ENTRY_POINT_LINEAR)
}
/// Create a new renderer config with precompiled default shaders outputting srgb color.
///
/// If you write to a Bgra8Unorm framebuffer, this is what you want.
pub fn new_srgb() -> Self {
Self::with_combined_shaders(include_wgsl!("imgui.wgsl"), FS_ENTRY_POINT_SRGB)
}
/// Create a new renderer config with precompiled default shaders outputting linear color.
///
/// If you write to a Bgra8UnormSrgb framebuffer, this is what you want.
pub fn new_spv() -> Self {
Self::with_separate_shaders(
include_spirv_raw!("imgui_vs_main.spv"),
include_spirv_raw!("imgui_fs_main_linear.spv"),
FS_ENTRY_POINT_LINEAR,
)
}
/// Create a new renderer config with precompiled default shaders outputting srgb color.
///
/// If you write to a Bgra8Unorm framebuffer, this is what you want.
pub fn new_spv_srgb() -> Self {
Self::with_separate_shaders(
include_spirv_raw!("imgui_vs_main.spv"),
include_spirv_raw!("imgui_fs_main_srgb.spv"),
FS_ENTRY_POINT_SRGB,
)
}
}
pub struct Renderer {
pipeline: RenderPipeline,
uniform_buffer: Buffer,
uniform_bind_group: BindGroup,
/// Textures of the font atlas and all images.
pub textures: Textures<Texture>,
texture_layout: BindGroupLayout,
index_buffers: SmallVec<[Buffer; 4]>,
vertex_buffers: SmallVec<[Buffer; 4]>,
config: RendererConfig<'static>,
}
impl Renderer {
/// Create an entirely new imgui wgpu renderer.
pub fn new(
imgui: &mut Context,
device: &Device,
queue: &Queue,
config: RendererConfig,
) -> Self {
let RendererConfig {
texture_format,
depth_format,
sample_count,
shader,
vertex_shader_entry_point,
fragment_shader_entry_point,
} = config;
// Load shaders.
let shader1: Option<wgpu::ShaderModule>;
let shader2: Option<wgpu::ShaderModule>;
let (vs, fs) = match shader {
ShaderType::Combined(d) => {
shader1 = Some(device.create_shader_module(&d.shader));
let r = shader1.as_ref().unwrap();
(r, r)
}
ShaderType::Separate(d) => unsafe {
shader1 = Some(device.create_shader_module_spirv(&d.vertex_shader));
shader2 = Some(device.create_shader_module_spirv(&d.fragment_shader));
(shader1.as_ref().unwrap(), shader2.as_ref().unwrap())
},
ShaderType::None => panic!(),
};
// Create the uniform matrix buffer.
let size = 64;
let uniform_buffer = device.create_buffer(&BufferDescriptor {
label: Some("imgui-wgpu uniform buffer"),
size,
usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
mapped_at_creation: false,
});
// Create the uniform matrix buffer bind group layout.
let uniform_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
label: None,
entries: &[BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: BindingType::Buffer {
ty: BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
// Create the uniform matrix buffer bind group.
let uniform_bind_group = device.create_bind_group(&BindGroupDescriptor {
label: Some("imgui-wgpu bind group"),
layout: &uniform_layout,
entries: &[BindGroupEntry { binding: 0, resource: uniform_buffer.as_entire_binding() }],
});
// Create the texture layout for further usage.
let texture_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
label: Some("imgui-wgpu bind group layout"),
entries: &[
BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: BindingType::Texture {
multisampled: false,
sample_type: TextureSampleType::Float { filterable: true },
view_dimension: TextureViewDimension::D2,
},
count: None,
},
BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
// Create the render pipeline layout.
let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
label: Some("imgui-wgpu pipeline layout"),
bind_group_layouts: &[&uniform_layout, &texture_layout],
push_constant_ranges: &[],
});
// Create the render pipeline.
// Create the render pipeline.
let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("imgui-wgpu pipeline"),
layout: Some(&pipeline_layout),
vertex: VertexState {
module: vs,
entry_point: &vertex_shader_entry_point,
buffers: &[VertexBufferLayout {
array_stride: size_of::<DrawVert>() as BufferAddress,
step_mode: VertexStepMode::Vertex,
attributes: &vertex_attr_array![0 => Float32x2, 1 => Float32x2, 2 => Unorm8x4],
}],
},
primitive: PrimitiveState {
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: FrontFace::Cw,
cull_mode: None,
polygon_mode: PolygonMode::Fill,
unclipped_depth: false,
conservative: false,
},
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
depth_write_enabled: false,
depth_compare: wgpu::CompareFunction::Always,
stencil: wgpu::StencilState::default(),
bias: DepthBiasState::default(),
}),
multisample: MultisampleState { count: sample_count, ..Default::default() },
fragment: Some(FragmentState {
module: fs,
entry_point: &fragment_shader_entry_point,
targets: &[ColorTargetState {
format: texture_format,
blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha: BlendComponent {
src_factor: BlendFactor::OneMinusDstAlpha,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
}),
write_mask: ColorWrites::ALL,
}],
}),
multiview: None,
});
let mut renderer = Self {
pipeline,
uniform_buffer,
uniform_bind_group,
textures: Textures::new(),
texture_layout,
vertex_buffers: SmallVec::new(),
index_buffers: SmallVec::new(),
config: RendererConfig {
texture_format,
depth_format,
sample_count,
shader: ShaderType::None,
vertex_shader_entry_point,
fragment_shader_entry_point,
},
};
// Immediately load the font texture to the GPU.
renderer.reload_font_texture(imgui, device, queue);
renderer
}
/// Render the current imgui frame.
pub fn render<'r>(
&'r mut self,
draw_data: &DrawData,
queue: &Queue,
device: &Device,
rpass: &mut RenderPass<'r>,
) -> RendererResult<()> {
rpass.push_debug_group("imgui-wgpu");
let mut rpass = scopeguard::guard(rpass, |rpass| {
rpass.pop_debug_group();
});
let fb_width = draw_data.display_size[0] * draw_data.framebuffer_scale[0];
let fb_height = draw_data.display_size[1] * draw_data.framebuffer_scale[1];
// If the render area is <= 0, exit here and now.
if !(fb_width > 0.0 && fb_height > 0.0) {
return Ok(());
}
let width = draw_data.display_size[0];
let height = draw_data.display_size[1];
let offset_x = draw_data.display_pos[0] / width;
let offset_y = draw_data.display_pos[1] / height;
// Create and update the transform matrix for the current frame.
// This is required to adapt to vulkan coordinates.
// let matrix = [
// [2.0 / width, 0.0, 0.0, 0.0],
// [0.0, 2.0 / height as f32, 0.0, 0.0],
// [0.0, 0.0, -1.0, 0.0],
// [-1.0, -1.0, 0.0, 1.0],
// ];
let matrix = [
[2.0 / width, 0.0, 0.0, 0.0],
[0.0, 2.0 / -height as f32, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[-1.0 - offset_x * 2.0, 1.0 + offset_y * 2.0, 0.0, 1.0],
];
self.update_uniform_buffer(queue, &matrix);
rpass.set_pipeline(&self.pipeline);
rpass.set_bind_group(0, &self.uniform_bind_group, &[]);
self.vertex_buffers.clear();
self.index_buffers.clear();
for draw_list in draw_data.draw_lists() {
self.vertex_buffers.push(self.upload_vertex_buffer(device, draw_list.vtx_buffer()));
self.index_buffers.push(self.upload_index_buffer(device, draw_list.idx_buffer()));
}
// Execute all the imgui render work.
for (draw_list_buffers_index, draw_list) in draw_data.draw_lists().enumerate() {
self.render_draw_list(
rpass.borrow_mut(),
draw_list,
draw_data.display_pos,
draw_data.framebuffer_scale,
draw_list_buffers_index,
)?;
}
Ok(())
}
/// Render a given `DrawList` from imgui onto a wgpu frame.
fn render_draw_list<'render>(
&'render self,
rpass: &mut RenderPass<'render>,
draw_list: &DrawList,
clip_off: [f32; 2],
clip_scale: [f32; 2],
draw_list_buffers_index: usize,
) -> RendererResult<()> {
let mut start = 0;
let index_buffer = &self.index_buffers[draw_list_buffers_index];
let vertex_buffer = &self.vertex_buffers[draw_list_buffers_index];
// Make sure the current buffers are attached to the render pass.
rpass.set_index_buffer(index_buffer.slice(..), IndexFormat::Uint16);
rpass.set_vertex_buffer(0, vertex_buffer.slice(..));
for cmd in draw_list.commands() {
if let Elements { count, cmd_params } = cmd {
let clip_rect = [
(cmd_params.clip_rect[0] - clip_off[0]) * clip_scale[0],
(cmd_params.clip_rect[1] - clip_off[1]) * clip_scale[1],
(cmd_params.clip_rect[2] - clip_off[0]) * clip_scale[0],
(cmd_params.clip_rect[3] - clip_off[1]) * clip_scale[1],
];
// Set the current texture bind group on the renderpass.
let texture_id = cmd_params.texture_id;
let tex =
self.textures.get(texture_id).ok_or(RendererError::BadTexture(texture_id))?;
rpass.set_bind_group(1, &tex.bind_group, &[]);
// Set scissors on the renderpass.
let scissors = (
clip_rect[0].max(0.0).floor() as u32,
clip_rect[1].max(0.0).floor() as u32,
(clip_rect[2] - clip_rect[0]).abs().ceil() as u32,
(clip_rect[3] - clip_rect[1]).abs().ceil() as u32,
);
rpass.set_scissor_rect(scissors.0, scissors.1, scissors.2, scissors.3);
// Draw the current batch of vertices with the renderpass.
let end = start + count as u32;
rpass.draw_indexed(start..end, 0, 0..1);
start = end;
}
}
Ok(())
}
/// Updates the current uniform buffer containing the transform matrix.
fn update_uniform_buffer(&mut self, queue: &Queue, matrix: &[[f32; 4]; 4]) {
let data = bytemuck::bytes_of(matrix);
queue.write_buffer(&self.uniform_buffer, 0, data);
}
/// Upload the vertex buffer to the GPU.
fn upload_vertex_buffer(&self, device: &Device, vertices: &[DrawVert]) -> Buffer {
// Safety: DrawVertPod is #[repr(transparent)] over DrawVert and DrawVert _should_ be Pod.
let vertices = unsafe {
std::slice::from_raw_parts(vertices.as_ptr() as *mut DrawVertPod, vertices.len())
};
let data = bytemuck::cast_slice(vertices);
device.create_buffer_init(&BufferInitDescriptor {
label: Some("imgui-wgpu vertex buffer"),
contents: data,
usage: BufferUsages::VERTEX,
})
}
/// Upload the index buffer to the GPU.
fn upload_index_buffer(&self, device: &Device, indices: &[DrawIdx]) -> Buffer {
let data = bytemuck::cast_slice(indices);
device.create_buffer_init(&BufferInitDescriptor {
label: Some("imgui-wgpu index buffer"),
contents: data,
usage: BufferUsages::INDEX,
})
}
/// Updates the texture on the GPU corresponding to the current imgui font atlas.
///
/// This has to be called after loading a font.
pub fn reload_font_texture(&mut self, imgui: &mut Context, device: &Device, queue: &Queue) {
let mut fonts = imgui.fonts();
// Remove possible font atlas texture.
self.textures.remove(fonts.tex_id);
// Create font texture and upload it.
let handle = fonts.build_rgba32_texture();
let font_texture_cnfig = TextureConfig {
label: Some("imgui-wgpu font atlas"),
size: Extent3d { width: handle.width, height: handle.height, ..Default::default() },
format: Some(wgpu::TextureFormat::Rgba8Unorm),
..Default::default()
};
let font_texture = Texture::new(device, self, font_texture_cnfig);
font_texture.write(queue, handle.data, handle.width, handle.height);
fonts.tex_id = self.textures.insert(font_texture);
// Clear imgui texture data to save memory.
fonts.clear_tex_data();
}
}

345
Graphics/src/lib.rs Normal file
View File

@ -0,0 +1,345 @@
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]
#![allow(unused_unsafe)]
use std::{num::NonZeroU8, time::Instant};
use wgpu::Backend;
use winit::{
event::{Event, WindowEvent},
event_loop::ControlFlow,
};
use crate::{
gpu::{create_depth_texture, create_render_texture, initialize_gpu, DeviceHolder},
imgui::{initialize_imgui, ImGuiState},
shaders::render_into_pass,
};
mod gpu;
mod imgui;
mod imgui_backend;
mod shaders;
mod zeus;
#[cxx::bridge(namespace = "aurora")]
mod ffi {
unsafe extern "C++" {
include!("aurora.hpp");
pub(crate) type AppDelegate;
}
unsafe extern "C++" {
include!("lib.hpp");
pub(crate) fn App_onAppLaunched(cb: Pin<&mut AppDelegate>);
pub(crate) fn App_onAppIdle(cb: Pin<&mut AppDelegate>, dt: f32) -> bool;
pub(crate) fn App_onAppDraw(cb: Pin<&mut AppDelegate>);
pub(crate) fn App_onAppPostDraw(cb: Pin<&mut AppDelegate>);
pub(crate) fn App_onAppExiting(cb: Pin<&mut AppDelegate>);
}
pub struct Window {
pub(crate) inner: Box<WindowContext>,
}
pub struct WindowSize {
pub width: u32,
pub height: u32,
}
#[derive(Debug)]
pub enum Backend {
Invalid,
Vulkan,
Metal,
D3D12,
D3D11,
OpenGL,
WebGPU,
}
pub enum ElementState {
Pressed,
Released,
}
pub enum MouseButton {
Left,
Right,
Middle,
Other,
}
pub enum SpecialKey {
None = 0,
F1 = 1,
F2 = 2,
F3 = 3,
F4 = 4,
F5 = 5,
F6 = 6,
F7 = 7,
F8 = 8,
F9 = 9,
F10 = 10,
F11 = 11,
F12 = 12,
Esc = 13,
Enter = 14,
Backspace = 15,
Insert = 16,
Delete = 17,
Home = 18,
End = 19,
PgUp = 20,
PgDown = 21,
Left = 22,
Right = 23,
Up = 24,
Down = 25,
Tab = 26,
}
pub struct KeyboardInput {
pub scancode: u32,
pub state: ElementState,
// pub
}
extern "Rust" {
type WindowContext;
type App;
fn app_run(mut delegate: UniquePtr<AppDelegate>);
fn get_args() -> Vec<String>;
fn get_window_size() -> WindowSize;
fn set_window_title(title: &CxxString);
fn get_backend() -> Backend;
fn get_backend_string() -> &'static str;
fn set_fullscreen(v: bool);
}
}
pub struct App {
window: ffi::Window,
gpu: DeviceHolder,
imgui: ImGuiState,
}
pub struct WindowContext {
window: winit::window::Window,
}
static mut APP: Option<App> = None;
fn app_run(mut delegate: cxx::UniquePtr<ffi::AppDelegate>) {
if delegate.is_null() {
return;
}
env_logger::init();
log::info!("Running app");
let event_loop = winit::event_loop::EventLoop::new();
let window = winit::window::WindowBuilder::new().build(&event_loop).unwrap();
let gpu = initialize_gpu(&window);
let imgui = initialize_imgui(&window, &gpu);
shaders::construct_state(gpu.device.clone(), gpu.queue.clone(), &gpu.config);
let app = App { window: ffi::Window { inner: Box::new(WindowContext { window }) }, gpu, imgui };
unsafe {
APP.replace(app);
ffi::App_onAppLaunched(delegate.as_mut().unwrap());
};
event_loop.run(move |event, _, control_flow| {
// Have the closure take ownership of the resources.
// `event_loop.run` never returns, therefore we must do this to ensure
// the resources are properly cleaned up.
let _ = &delegate;
let app = get_app();
let imgui = &mut app.imgui;
let window_ctx = get_window_context();
let gpu = &mut app.gpu;
let mut last_frame: Option<Instant> = None;
*control_flow = ControlFlow::Poll;
match event {
Event::NewEvents(_) => {}
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
*control_flow = ControlFlow::Exit;
return;
}
Event::WindowEvent { event: WindowEvent::Resized(size), .. } => {
// Reconfigure the surface with the new size
app.gpu.surface_config.width = size.width;
app.gpu.surface_config.height = size.height;
app.gpu.surface.configure(&app.gpu.device, &app.gpu.surface_config);
app.gpu.depth =
create_depth_texture(&app.gpu.device, &app.gpu.surface_config, &app.gpu.config);
app.gpu.framebuffer = create_render_texture(
&app.gpu.device,
&app.gpu.surface_config,
&app.gpu.config,
);
// TODO resize callback
}
Event::WindowEvent { event: WindowEvent::KeyboardInput { .. }, .. } => {}
Event::WindowEvent { .. } => {}
Event::DeviceEvent { .. } => {}
Event::UserEvent(_) => {}
Event::Suspended => {}
Event::Resumed => {}
Event::MainEventsCleared => {
log::info!("Requesting redraw");
window_ctx.window.request_redraw();
}
Event::RedrawRequested(_) => {
let io = imgui.context.io_mut();
let mut dt: f32 = 1.0 / 60.0;
if let Some(last_frame) = last_frame {
let duration = last_frame.elapsed();
dt = duration.as_secs_f32();
io.update_delta_time(duration);
}
last_frame = Some(Instant::now());
imgui
.platform
.prepare_frame(io, &window_ctx.window)
.expect("Failed to prepare frame");
let ui = imgui.context.frame();
#[allow(unused_unsafe)] // rust bug?
if !unsafe { ffi::App_onAppIdle(delegate.as_mut().unwrap(), dt) } {
*control_flow = ControlFlow::Exit;
return;
}
log::info!("Redrawing");
let frame_result = gpu.surface.get_current_texture();
if let Err(err) = frame_result {
log::warn!("Failed to acquire frame {}", err);
return;
}
let frame = frame_result.unwrap();
#[allow(unused_unsafe)] // rust bug?
unsafe {
ffi::App_onAppDraw(delegate.as_mut().unwrap());
}
let fb_view =
gpu.framebuffer.texture.create_view(&wgpu::TextureViewDescriptor::default());
let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder =
gpu.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Redraw Encoder"),
});
{
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: None,
color_attachments: &[if gpu.config.msaa_samples > 1 {
wgpu::RenderPassColorAttachment {
view: &fb_view,
resolve_target: Some(&view),
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: true,
},
}
} else {
wgpu::RenderPassColorAttachment {
view: &view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: true,
},
}
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &gpu.depth.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,
}),
stencil_ops: None,
}),
});
render_into_pass(&mut rpass);
imgui.platform.prepare_render(&ui, &window_ctx.window);
imgui
.backend
.render(ui.render(), &gpu.queue, &gpu.device, &mut rpass)
.expect("Rendering failed");
}
gpu.queue.submit(Some(encoder.finish()));
frame.present();
#[allow(unused_unsafe)] // rust bug?
unsafe {
ffi::App_onAppPostDraw(delegate.as_mut().unwrap());
}
}
Event::RedrawEventsCleared => {}
Event::LoopDestroyed => unsafe {
ffi::App_onAppExiting(delegate.as_mut().unwrap());
APP.take();
return;
},
}
imgui.platform.handle_event(imgui.context.io_mut(), &window_ctx.window, &event);
});
}
fn get_app() -> &'static mut App {
unsafe {
if let Some(ref mut app) = APP {
app
} else {
panic!("Application not initialized");
}
}
}
fn get_window_context() -> &'static mut WindowContext { &mut get_app().window.inner }
fn get_args() -> Vec<String> { std::env::args().skip(1).collect() }
fn get_window_size() -> ffi::WindowSize {
let size = get_window_context().window.inner_size();
ffi::WindowSize { width: size.width, height: size.height }
}
fn set_window_title(title: &cxx::CxxString) {
get_window_context().window.set_title(&title.to_string_lossy());
}
fn get_backend() -> ffi::Backend {
match get_app().gpu.backend {
Backend::Vulkan => ffi::Backend::Vulkan,
Backend::Metal => ffi::Backend::Metal,
Backend::Dx12 => ffi::Backend::D3D12,
Backend::Dx11 => ffi::Backend::D3D11,
Backend::Gl => ffi::Backend::OpenGL,
Backend::BrowserWebGpu => ffi::Backend::WebGPU,
Backend::Empty => ffi::Backend::Invalid,
}
}
fn get_backend_string() -> &'static str {
match get_app().gpu.backend {
Backend::Vulkan => "Vulkan",
Backend::Metal => "Metal",
Backend::Dx12 => "D3D12",
Backend::Dx11 => "D3D11",
Backend::Gl => "OpenGL ES",
Backend::BrowserWebGpu => "WebGPU",
Backend::Empty => "Invalid",
}
}
fn set_fullscreen(v: bool) {
get_window_context().window.set_fullscreen(if v {
Some(winit::window::Fullscreen::Borderless(None))
} else {
None
});
}

203
Graphics/src/shaders/aabb.rs Normal file
View File

@ -0,0 +1,203 @@
use std::{hash::Hash, ops::Range};
use bytemuck_derive::{Pod, Zeroable};
use wgpu::{include_wgsl, vertex_attr_array};
use crate::{
gpu::GraphicsConfig,
shaders::{
bind_pipeline, get_combined_matrix, pipeline_ref, push_draw_command, push_uniform,
push_verts, BuiltBuffers, PipelineCreateCommand, PipelineHolder, PipelineRef,
ShaderDrawCommand,
},
zeus::{CAABox, CColor, CMatrix4f, CVector3f},
};
#[derive(Debug, Clone)]
pub(crate) struct DrawData {
pipeline: PipelineRef,
vert_range: Range<u64>,
uniform_range: Range<u64>,
}
#[derive(Hash)]
pub(crate) struct PipelineConfig {
z_only: bool,
}
pub(crate) const INITIAL_PIPELINES: &[PipelineConfig] =
&[PipelineConfig { z_only: false }, PipelineConfig { z_only: true }];
pub(crate) struct State {
shader: wgpu::ShaderModule,
uniform_layout: wgpu::BindGroupLayout,
uniform_bind_group: wgpu::BindGroup,
pipeline_layout: wgpu::PipelineLayout,
}
pub(crate) fn construct_state(
device: &wgpu::Device,
_queue: &wgpu::Queue,
buffers: &BuiltBuffers,
) -> State {
let shader = device.create_shader_module(&include_wgsl!("aabb.wgsl"));
let uniform_size = wgpu::BufferSize::new(std::mem::size_of::<Uniform>() as u64);
let uniform_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("AABB Bind Group Layout"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
min_binding_size: uniform_size,
},
count: None,
}],
});
let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("AABB Bind Group"),
layout: &uniform_layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &buffers.uniform_buffer,
offset: 0, // dynamic
size: uniform_size,
}),
}],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("AABB Pipeline Layout"),
bind_group_layouts: &[&uniform_layout],
push_constant_ranges: &[],
});
State { shader, uniform_layout, uniform_bind_group, pipeline_layout }
}
pub(crate) fn construct_pipeline(
device: &wgpu::Device,
graphics: &GraphicsConfig,
state: &State,
config: &PipelineConfig,
) -> PipelineHolder {
PipelineHolder {
pipeline: device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("AABB Pipeline"),
layout: Some(&state.pipeline_layout),
vertex: wgpu::VertexState {
module: &state.shader,
entry_point: "vs_main",
buffers: &[wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<CVector3f>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &vertex_attr_array![0 => Float32x3],
}],
},
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleStrip,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: graphics.depth_format,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::LessEqual,
stencil: Default::default(),
bias: Default::default(),
}),
multisample: wgpu::MultisampleState {
count: graphics.msaa_samples,
..Default::default()
},
fragment: Some(wgpu::FragmentState {
module: &state.shader,
entry_point: "fs_main",
targets: &[wgpu::ColorTargetState {
format: graphics.color_format,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: if config.z_only {
wgpu::ColorWrites::empty()
} else {
wgpu::ColorWrites::ALL
},
}],
}),
multiview: None,
}),
}
}
#[derive(Pod, Zeroable, Copy, Clone, Default, Debug)]
#[repr(C)]
struct Uniform {
xf: CMatrix4f,
color: CColor,
}
pub(crate) fn queue_aabb(aabb: CAABox, color: CColor, z_only: bool) {
let pipeline = pipeline_ref(PipelineCreateCommand::Aabb(PipelineConfig { z_only }));
let vert_range = push_verts(&[
CVector3f::new(aabb.max.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.max.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.max.x, aabb.min.y, aabb.min.z),
CVector3f::new(aabb.min.x, aabb.max.y, aabb.min.z),
CVector3f::new(aabb.max.x, aabb.max.y, aabb.min.z),
]);
let uniform_range = push_uniform(&Uniform { xf: get_combined_matrix(), color });
push_draw_command(ShaderDrawCommand::Aabb(DrawData { pipeline, vert_range, uniform_range }));
}
pub(crate) fn draw_aabb<'a>(
data: &DrawData,
state: &'a State,
pass: &mut wgpu::RenderPass<'a>,
buffers: &'a BuiltBuffers,
) {
if !bind_pipeline(data.pipeline, pass) {
return;
}
pass.set_bind_group(0, &state.uniform_bind_group, &[
data.uniform_range.start as wgpu::DynamicOffset
]);
pass.set_vertex_buffer(0, buffers.vertex_buffer.slice(data.vert_range.clone()));
pass.draw(0..34, 0..1);
}

16
Graphics/src/shaders/aabb.wgsl Normal file
View File

@ -0,0 +1,16 @@
struct Uniform {
xf: mat4x4<f32>;
color: vec4<f32>;
};
[[group(0), binding(0)]]
var<uniform> ubuf: Uniform;
[[stage(vertex)]]
fn vs_main([[location(0)]] in_pos: vec3<f32>) -> [[builtin(position)]] vec4<f32> {
return ubuf.xf * vec4<f32>(in_pos, 1.0);
}
[[stage(fragment)]]
fn fs_main() -> [[location(0)]] vec4<f32> {
return ubuf.color;
}

3
Graphics/src/shaders/fog_volume_filter.rs Normal file
View File

@ -0,0 +1,3 @@
use crate::zeus::CColor;
pub(crate) fn queue_fog_volume_filter(color: CColor, two_way: bool) {}

5
Graphics/src/shaders/fog_volume_plane.rs Normal file
View File

@ -0,0 +1,5 @@
use cxx::CxxVector;
use crate::zeus::CVector4f;
pub(crate) fn queue_fog_volume_plane(verts: &CxxVector<CVector4f>, pass: u8) {}

574
Graphics/src/shaders/mod.rs Normal file
View File

@ -0,0 +1,574 @@
use std::{
collections::{HashMap, VecDeque},
hash::{Hash, Hasher},
num::NonZeroU8,
ops::Range,
sync::Arc,
};
use aabb::queue_aabb;
use bytemuck::Pod;
use bytemuck_derive::{Pod, Zeroable};
use cxx::{type_id, ExternType};
use fog_volume_filter::queue_fog_volume_filter;
use fog_volume_plane::queue_fog_volume_plane;
use model::{add_material_set, add_model};
use texture::{create_render_texture, create_static_texture_2d, drop_texture};
use twox_hash::Xxh3Hash64;
use wgpu::RenderPipeline;
use crate::{
gpu::GraphicsConfig,
zeus::{CColor, CMatrix4f, CRectangle, CVector2f, CVector3f, IDENTITY_MATRIX4F},
};
mod aabb;
mod fog_volume_filter;
mod fog_volume_plane;
mod model;
mod texture;
#[cxx::bridge]
mod ffi {
unsafe extern "C++" {
include!("zeus/CVector2f.hpp");
include!("zeus/CVector3f.hpp");
include!("zeus/CVector4f.hpp");
include!("zeus/CMatrix4f.hpp");
include!("zeus/CColor.hpp");
include!("zeus/CRectangle.hpp");
include!("zeus/CAABox.hpp");
#[namespace = "zeus"]
type CVector2f = crate::zeus::CVector2f;
#[namespace = "zeus"]
type CVector3f = crate::zeus::CVector3f;
#[namespace = "zeus"]
type CVector4f = crate::zeus::CVector4f;
#[namespace = "zeus"]
type CMatrix4f = crate::zeus::CMatrix4f;
#[namespace = "zeus"]
type CColor = crate::zeus::CColor;
#[namespace = "zeus"]
type CRectangle = crate::zeus::CRectangle;
#[namespace = "zeus"]
type CAABox = crate::zeus::CAABox;
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) enum CameraFilterType {
Passthru,
Multiply,
Invert,
Add,
Subtract,
Blend,
Widescreen,
SceneAdd,
NoColor,
InvDstMultiply,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) enum ZTest {
None,
LEqual,
GEqual,
GEqualZWrite,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) enum TextureFormat {
RGBA8,
R8,
R32Float,
DXT1,
DXT3,
DXT5,
BPTC,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) enum TextureClampMode {
Repeat,
ClampToEdge,
ClampToWhite,
ClampToBlack,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) struct TextureRef {
pub(crate) id: u32,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
#[repr(u32)]
pub(crate) enum FogMode {
None = 0x00,
PerspLin = 0x02,
PerspExp = 0x04,
PerspExp2 = 0x05,
PerspRevExp = 0x06,
PerspRevExp2 = 0x07,
OrthoLin = 0x0A,
OrthoExp = 0x0C,
OrthoExp2 = 0x0D,
OrthoRevExp = 0x0E,
OrthoRevExp2 = 0x0F,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) struct FogState {
#[cxx_name = "m_color"]
pub(crate) color: CColor,
#[cxx_name = "m_A"]
pub(crate) a: f32,
#[cxx_name = "m_B"]
pub(crate) b: f32,
#[cxx_name = "m_C"]
pub(crate) c: f32,
#[cxx_name = "m_mode"]
pub(crate) mode: FogMode,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) struct ClipRect {
x: i32,
y: i32,
width: i32,
height: i32,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Copy, Clone)]
pub(crate) struct MaterialPassInfo {
tex_idx: u32,
constant_color: CColor,
has_constant_color: bool, // would love to use Option...
uv_source: u8,
uv_anim_type: u8,
uv_anim_params: [f32; 9],
normalize: bool, // TODO might be static based on uv type?
sample_alpha: bool,
}
#[namespace = "aurora::shaders"]
#[derive(Debug, Clone)]
pub(crate) struct MaterialInfo {
pass_info: [MaterialPassInfo; 8],
texture_ids: Vec<TextureRef>,
shader_type: u8,
blend_mode: u8,
}
#[namespace = "aurora::shaders"]
extern "Rust" {
fn update_model_view(mv: CMatrix4f, mv_inv: CMatrix4f);
fn update_projection(proj: CMatrix4f);
fn update_fog_state(state: FogState);
fn set_viewport(rect: CRectangle, znear: f32, zfar: f32);
fn set_scissor(x: u32, y: u32, w: u32, h: u32);
fn resolve_color(rect: ClipRect, bind: u32, clear_depth: bool);
fn resolve_depth(rect: ClipRect, bind: u32);
fn add_material_set(materials: Vec<MaterialInfo>) -> u32;
fn add_model(verts: &[u8], indices: &[u8]) -> u32;
fn queue_aabb(aabb: CAABox, color: CColor, z_only: bool);
fn queue_fog_volume_plane(verts: &CxxVector<CVector4f>, pass: u8);
fn queue_fog_volume_filter(color: CColor, two_way: bool);
fn create_static_texture_2d(
width: u32,
height: u32,
mips: u32,
format: TextureFormat,
data: &[u8],
label: &str,
) -> TextureRef;
fn create_render_texture(
width: u32,
height: u32,
// clamp_mode: TextureClampMode,
color_bind_count: u32,
depth_bind_count: u32,
label: &str,
) -> TextureRef;
fn drop_texture(handle: TextureRef);
}
}
unsafe impl bytemuck::Zeroable for ffi::FogMode {}
unsafe impl bytemuck::Pod for ffi::FogMode {}
unsafe impl bytemuck::Zeroable for ffi::FogState {}
unsafe impl bytemuck::Pod for ffi::FogState {}
impl Default for ffi::FogState {
fn default() -> Self {
Self { color: Default::default(), a: 0.0, b: 0.5, c: 0.0, mode: ffi::FogMode::None }
}
}
#[derive(Debug, Copy, Clone)]
enum ColoredStripMode {
Alpha,
Additive,
FullAdditive,
Subtractive,
}
#[derive(Debug, Copy, Clone)]
struct ColoredStripVert {
position: CVector3f,
color: CColor,
uv: CVector2f,
}
#[derive(Debug, Clone)]
enum Command {
SetViewport(CRectangle, f32, f32),
SetScissor(u32, u32, u32, u32),
Draw(ShaderDrawCommand),
}
#[derive(Debug, Clone)]
enum ShaderDrawCommand {
Aabb(aabb::DrawData),
CameraBlurFilter {
amount: f32,
clear_depth: bool,
},
ColoredQuadFilter {
filter_type: ffi::CameraFilterType,
color: CColor,
rect: CRectangle,
},
ColoredStripFilter {
mode: ColoredStripMode,
verts: Vec<ColoredStripVert>,
color: CColor,
},
Decal {/* TODO */},
ElementGen {/* TODO */},
EnergyBar {/* TODO */},
EnvFx {/* TODO */},
FluidPlane {/* TODO */},
FogVolumeFilter {
two_way: bool,
color: CColor,
},
FogVolumePlane {
pass: u8,
verts: Vec<CVector3f>,
},
LineRenderer {/* TODO */},
MapSurface {/* TODO */},
Model {
pipeline_id: u32,
material_id: u32,
ambient_color: CColor,
lights: u32,
post_type: u32,
game_blend_mode: u32,
model_flags: u32,
},
MoviePlayer {/* TODO */},
NES {/* TODO */},
ParticleSwoosh {/* TODO */},
PhazonSuitFilter {/* TODO */},
RadarPaint {/* TODO */},
RandomStaticFilter {/* TODO */},
ScanLinesFilter {/* TODO */},
TextSupport {/* TODO */},
TexturedQuad {
filter_type: ffi::CameraFilterType,
z_test: ffi::ZTest,
tex: u32, /* TODO */
/* draw, cropped, verts, filter? */
},
ThermalCold,
ThermalHot,
WorldShadow {
width: u32,
height: u32,
extent: f32,
},
XRayBlur {
palette_tex: u32, /* TODO */
amount: f32,
},
}
struct RenderState {
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
graphics_config: GraphicsConfig,
pipelines: HashMap<u64, PipelineHolder>,
current_pipeline: u64,
uniform_alignment: usize,
storage_alignment: usize,
buffers: BuiltBuffers,
commands: VecDeque<Command>,
// Shader states
aabb: aabb::State,
}
pub(crate) fn construct_state(
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
graphics_config: &GraphicsConfig,
) {
let limits = device.limits();
let mut buffers = BuiltBuffers {
uniform_buffer: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shared Uniform Buffer"),
size: 134_217_728, // 128mb
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}),
vertex_buffer: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shared Vertex Buffer"),
size: 16_777_216, // 16mb
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}),
};
let aabb = aabb::construct_state(&device, &queue, &buffers);
let mut state = RenderState {
device: device.clone(),
queue: queue.clone(),
graphics_config: graphics_config.clone(),
pipelines: Default::default(),
current_pipeline: u64::MAX,
uniform_alignment: limits.min_uniform_buffer_offset_alignment as usize,
storage_alignment: limits.min_storage_buffer_offset_alignment as usize,
buffers,
commands: Default::default(),
aabb,
};
for config in aabb::INITIAL_PIPELINES {
let hash = hash_with_seed(config, 0xAABB);
let pipeline = aabb::construct_pipeline(&device, graphics_config, &state.aabb, config);
state.pipelines.insert(hash, pipeline);
}
unsafe {
STATE = Some(state);
}
}
static mut STATE: Option<RenderState> = None;
#[derive(Default, Pod, Zeroable, Copy, Clone)]
#[repr(C)]
struct GlobalUniform {
mv: CMatrix4f,
mv_inv: CMatrix4f,
proj: CMatrix4f,
ambient: CColor, // TODO can this be combined with model?
lightmap_mul: CColor,
fog: ffi::FogState,
}
#[derive(Default)]
struct GlobalBuffers {
uniforms: Vec<u8>,
verts: Vec<u8>,
global_current: GlobalUniform,
global_dirty: bool,
last_global: Option<Range<u64>>,
}
static mut GLOBAL_BUFFERS: GlobalBuffers = GlobalBuffers {
uniforms: vec![],
verts: vec![],
global_current: GlobalUniform {
mv: IDENTITY_MATRIX4F,
mv_inv: IDENTITY_MATRIX4F,
proj: IDENTITY_MATRIX4F,
ambient: CColor::new(0.0, 0.0, 0.0, 1.0),
lightmap_mul: CColor::new(0.0, 0.0, 0.0, 1.0),
fog: ffi::FogState {
color: CColor::new(0.0, 0.0, 0.0, 0.0),
a: 0.0,
b: 0.5,
c: 0.0,
mode: ffi::FogMode::None,
},
},
global_dirty: false,
last_global: None,
};
pub(crate) struct PipelineHolder {
pipeline: wgpu::RenderPipeline,
}
pub(crate) struct BuiltBuffers {
uniform_buffer: wgpu::Buffer,
vertex_buffer: wgpu::Buffer,
}
const EMPTY_SLICE: &[u8] = &[0u8; 256];
fn push_value<T: Pod>(target: &mut Vec<u8>, buf: &T, alignment: usize) -> Range<u64> {
let size_of = std::mem::size_of::<T>();
let padding = if alignment == 0 { 0 } else { alignment - size_of % alignment };
let begin = target.len() as u64;
target.extend_from_slice(bytemuck::bytes_of(buf));
if padding > 0 {
target.extend_from_slice(&EMPTY_SLICE[..padding]);
}
begin..begin + size_of as u64
}
fn push_slice<T: Pod>(target: &mut Vec<u8>, buf: &[T], alignment: usize) -> Range<u64> {
let size_of = std::mem::size_of::<T>();
let padding = if alignment == 0 { 0 } else { alignment - size_of % alignment };
let begin = target.len() as u64;
target.extend_from_slice(bytemuck::cast_slice(buf));
if padding > 0 {
target.extend_from_slice(&EMPTY_SLICE[..padding]);
}
begin..begin + size_of as u64 * buf.len() as u64
}
fn push_verts<T: Pod>(buf: &[T]) -> Range<u64> {
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
push_slice(&mut global_buffers.verts, buf, 0 /* TODO? */)
}
fn push_uniform<T: Pod>(buf: &T) -> Range<u64> {
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
push_value(&mut global_buffers.uniforms, buf, unsafe {
STATE.as_ref().unwrap().uniform_alignment
})
}
#[derive(Debug, Copy, Clone)]
struct PipelineRef {
id: u64,
}
enum PipelineCreateCommand {
Aabb(aabb::PipelineConfig),
}
#[inline(always)]
fn hash_with_seed<T: Hash>(value: &T, seed: u64) -> u64 {
let mut state = Xxh3Hash64::with_seed(seed);
value.hash(&mut state);
state.finish()
}
fn pipeline_ref(cmd: PipelineCreateCommand) -> PipelineRef {
let state = unsafe { STATE.as_mut().unwrap() };
let id = match cmd {
PipelineCreateCommand::Aabb(ref config) => hash_with_seed(config, 0xAABB),
};
// TODO queue for creation if not found
if !state.pipelines.contains_key(&id) {
let pipeline = match cmd {
PipelineCreateCommand::Aabb(ref config) => aabb::construct_pipeline(
state.device.as_ref(),
&state.graphics_config,
&state.aabb,
config,
),
};
state.pipelines.insert(id, pipeline);
}
PipelineRef { id }
}
fn bind_pipeline(pipeline_ref: PipelineRef, pass: &mut wgpu::RenderPass) -> bool {
let state = unsafe { STATE.as_ref().unwrap() };
if pipeline_ref.id == state.current_pipeline {
return true;
}
if let Some(PipelineHolder { pipeline }) = state.pipelines.get(&pipeline_ref.id) {
pass.set_pipeline(pipeline);
return true;
}
return false;
}
pub(crate) fn render_into_pass(pass: &mut wgpu::RenderPass) {
let state = unsafe { STATE.as_mut().unwrap() };
{
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
state.queue.write_buffer(&state.buffers.vertex_buffer, 0, &global_buffers.verts);
state.queue.write_buffer(&state.buffers.uniform_buffer, 0, &global_buffers.uniforms);
global_buffers.verts.clear();
global_buffers.uniforms.clear();
global_buffers.global_dirty = true;
}
for cmd in &state.commands {
match cmd {
Command::SetViewport(rect, znear, zfar) => {
pass.set_viewport(
rect.position.x,
rect.position.y,
rect.size.x,
rect.size.y,
*znear,
*zfar,
);
}
Command::SetScissor(x, y, w, h) => {
pass.set_scissor_rect(*x, *y, *w, *h);
}
Command::Draw(cmd) => match cmd {
ShaderDrawCommand::Aabb(data) => {
aabb::draw_aabb(data, &state.aabb, pass, &state.buffers);
}
_ => todo!(),
},
}
}
state.commands.clear();
}
fn update_model_view(mv: CMatrix4f, mv_inv: CMatrix4f) {
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
global_buffers.global_current.mv = mv;
global_buffers.global_current.mv_inv = mv_inv;
global_buffers.global_dirty = true;
}
fn update_projection(proj: CMatrix4f) {
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
global_buffers.global_current.proj = proj;
global_buffers.global_dirty = true;
}
fn update_fog_state(state: ffi::FogState) {
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
global_buffers.global_current.fog = state;
global_buffers.global_dirty = true;
}
fn get_combined_matrix() -> CMatrix4f {
let global_buffers = unsafe { &GLOBAL_BUFFERS };
CMatrix4f::from(
cgmath::Matrix4::from(global_buffers.global_current.mv)
* cgmath::Matrix4::from(global_buffers.global_current.proj),
)
}
fn finalize_global_uniform() -> Range<u64> {
let global_buffers = unsafe { &mut GLOBAL_BUFFERS };
if global_buffers.global_dirty || global_buffers.last_global.is_none() {
global_buffers.last_global = Some(push_uniform(&global_buffers.global_current));
global_buffers.global_dirty = false;
}
global_buffers.last_global.as_ref().unwrap().clone()
}
fn push_draw_command(cmd: ShaderDrawCommand) {
let state = unsafe { STATE.as_mut().unwrap() };
state.commands.push_back(Command::Draw(cmd));
}
fn set_viewport(rect: CRectangle, znear: f32, zfar: f32) {
let state = unsafe { STATE.as_mut().unwrap() };
state.commands.push_back(Command::SetViewport(rect, znear, zfar));
}
fn set_scissor(x: u32, y: u32, w: u32, h: u32) {
let state = unsafe { STATE.as_mut().unwrap() };
state.commands.push_back(Command::SetScissor(x, y, w, h));
}
fn resolve_color(rect: ffi::ClipRect, bind: u32, clear_depth: bool) {
// TODO
}
fn resolve_depth(rect: ffi::ClipRect, bind: u32) {
// TODO
}

41
Graphics/src/shaders/model.rs Normal file
View File

@ -0,0 +1,41 @@
use std::hash::Hash;
use crate::shaders::ffi::MaterialInfo;
struct MaterialShaderData {
shader_type: u32, // 5 values (incl. Invalid)
world_shadow: u32, // bool
alpha_discard: u32, // bool
samus_reflection: u32, // bool
}
struct MaterialPassData {
constant_color: [f32; 4],
has_constant_color: u32, // bool
uv_source: i32, // 8 values
normalize: u32, // bool
sample_alpha: u32, // bool
}
struct ModelRenderData {
// position: [f32; 3], // for UV anims
ambient_color: [f32; 4],
lights: [f32; 8], // TODO
post_type: u32,
game_blend_mode: u32,
// model_flags: u32, TODO only needed for render
}
#[derive(Debug, Hash)]
struct ModelPipelineConfig {
material_blend_mode: u32,
material_depth_write: bool,
render_blend_mode: u32,
render_model_flags: u32,
render_cull_mode: u32,
render_dst_alpha: bool,
render_color_update: bool,
render_alpha_update: bool,
}
pub(crate) fn add_material_set(materials: Vec<MaterialInfo>) -> u32 { return u32::MAX; }
pub(crate) fn add_model(verts: &[u8], indices: &[u8]) -> u32 { return u32::MAX; }

129
Graphics/src/shaders/texture.rs Normal file
View File

@ -0,0 +1,129 @@
use std::ptr::null;
use cxx::SharedPtr;
use wgpu::util::DeviceExt;
use crate::{
get_app,
gpu::TextureWithSampler,
shaders::ffi::{TextureClampMode, TextureFormat, TextureRef},
};
pub(crate) struct TextureWithView {
texture: wgpu::Texture,
view: wgpu::TextureView,
}
impl TextureWithView {
fn new(texture: wgpu::Texture) -> Self {
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
Self { texture, view }
}
}
pub(crate) struct RenderTexture {
color_texture: Option<TextureWithView>,
depth_texture: Option<TextureWithView>,
}
pub(crate) struct Texture {
texture: wgpu::Texture,
}
pub(crate) fn create_static_texture_2d(
width: u32,
height: u32,
mips: u32,
format: TextureFormat,
data: &[u8],
label: &str,
) -> TextureRef {
let gpu = &get_app().gpu;
let texture = gpu.device.create_texture_with_data(
&gpu.queue,
&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
mip_level_count: mips,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: match format {
TextureFormat::RGBA8 => wgpu::TextureFormat::Rgba8Unorm,
TextureFormat::R8 => wgpu::TextureFormat::R8Unorm,
TextureFormat::R32Float => wgpu::TextureFormat::R32Float,
TextureFormat::DXT1 => wgpu::TextureFormat::Bc1RgbaUnorm,
TextureFormat::DXT3 => wgpu::TextureFormat::Bc3RgbaUnorm,
TextureFormat::DXT5 => wgpu::TextureFormat::Bc5RgUnorm,
TextureFormat::BPTC => wgpu::TextureFormat::Bc7RgbaUnorm,
_ => todo!(),
},
usage: wgpu::TextureUsages::TEXTURE_BINDING,
},
data,
);
TextureRef { id: u32::MAX }
}
pub(crate) fn create_render_texture(
width: u32,
height: u32,
// clamp_mode: TextureClampMode,
color_bind_count: u32,
depth_bind_count: u32,
label: &str,
) -> TextureRef {
let gpu = &get_app().gpu;
let color_texture = if color_bind_count > 0 {
Some(TextureWithView::new(gpu.device.create_texture(&wgpu::TextureDescriptor {
label: Some(format!("{} Color", label).as_str()),
size: wgpu::Extent3d { width, height, depth_or_array_layers: color_bind_count },
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: gpu.config.color_format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
})))
} else {
None
};
let depth_texture = if depth_bind_count > 0 {
Some(TextureWithView::new(gpu.device.create_texture(&wgpu::TextureDescriptor {
label: Some(format!("{} Depth", label).as_str()),
size: wgpu::Extent3d { width, height, depth_or_array_layers: depth_bind_count },
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: gpu.config.depth_format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
})))
} else {
None
};
// let (clamp_mode, border_color) = match clamp_mode {
// TextureClampMode::Repeat => (wgpu::AddressMode::Repeat, None),
// TextureClampMode::ClampToWhite => {
// (wgpu::AddressMode::ClampToBorder, Some(wgpu::SamplerBorderColor::OpaqueWhite))
// }
// TextureClampMode::ClampToBlack => {
// (wgpu::AddressMode::ClampToBorder, Some(wgpu::SamplerBorderColor::OpaqueBlack))
// }
// TextureClampMode::ClampToEdge => (wgpu::AddressMode::ClampToEdge, None),
// };
// let sampler = gpu.device.create_sampler(&wgpu::SamplerDescriptor {
// label: Some(format!("{} Color Sampler", label).as_str()),
// address_mode_u: clamp_mode,
// address_mode_v: clamp_mode,
// address_mode_w: clamp_mode,
// mag_filter: wgpu::FilterMode::Linear,
// min_filter: wgpu::FilterMode::Linear,
// mipmap_filter: wgpu::FilterMode::Linear,
// lod_min_clamp: 0.0,
// lod_max_clamp: f32::MAX,
// compare: None,
// anisotropy_clamp: None,
// border_color,
// });
RenderTexture { color_texture, depth_texture };
TextureRef { id: u32::MAX }
}
pub(crate) fn drop_texture(handle: TextureRef) {}

171
Graphics/src/zeus.rs Normal file
View File

@ -0,0 +1,171 @@
use bytemuck_derive::{Pod, Zeroable};
use cxx::{type_id, ExternType};
#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
#[repr(C)]
pub struct CVector2f {
pub x: f32,
pub y: f32,
_p1: f32,
_p2: f32,
}
impl CVector2f {
pub const fn new(x: f32, y: f32) -> Self { Self { x, y, _p1: 0.0, _p2: 0.0 } }
}
unsafe impl ExternType for CVector2f {
type Id = type_id!("zeus::CVector2f");
type Kind = cxx::kind::Trivial;
}
#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
#[repr(C)]
pub struct CVector3f {
pub x: f32,
pub y: f32,
pub z: f32,
_p: f32,
}
impl CVector3f {
pub const fn new(x: f32, y: f32, z: f32) -> Self { Self { x, y, z, _p: 0.0 } }
}
unsafe impl ExternType for CVector3f {
type Id = type_id!("zeus::CVector3f");
type Kind = cxx::kind::Trivial;
}
#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
#[repr(C)]
pub struct CVector4f {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
impl CVector4f {
pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self { Self { x, y, z, w } }
}
unsafe impl ExternType for CVector4f {
type Id = type_id!("zeus::CVector4f");
type Kind = cxx::kind::Trivial;
}
#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
#[repr(C)]
pub struct CColor {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
impl CColor {
pub const fn new(r: f32, g: f32, b: f32, a: f32) -> Self { Self { r, g, b, a } }
}
unsafe impl ExternType for CColor {
type Id = type_id!("zeus::CColor");
type Kind = cxx::kind::Trivial;
}
#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
#[repr(C)]
pub struct CRectangle {
pub position: CVector2f,
pub size: CVector2f,
}
impl CRectangle {
pub const fn new(x: f32, y: f32, w: f32, h: f32) -> Self {
Self { position: CVector2f::new(x, y), size: CVector2f::new(w, h) }
}
}
unsafe impl ExternType for CRectangle {
type Id = type_id!("zeus::CRectangle");
type Kind = cxx::kind::Trivial;
}
#[derive(Debug, Copy, Clone, Pod, Zeroable, Default)]
#[repr(C)]
pub struct CAABox {
pub min: CVector3f,
pub max: CVector3f,
}
impl CAABox {
pub const fn new(min: CVector3f, max: CVector3f) -> Self { Self { min, max } }
}
unsafe impl ExternType for CAABox {
type Id = type_id!("zeus::CAABox");
type Kind = cxx::kind::Trivial;
}
pub const IDENTITY_MATRIX4F: CMatrix4f = CMatrix4f {
x: CVector4f::new(1.0, 0.0, 0.0, 0.0),
y: CVector4f::new(0.0, 1.0, 0.0, 0.0),
z: CVector4f::new(0.0, 0.0, 1.0, 0.0),
w: CVector4f::new(0.0, 0.0, 0.0, 1.0),
};
#[derive(Debug, Copy, Clone, Pod, Zeroable)]
#[repr(C)]
pub struct CMatrix4f {
pub x: CVector4f,
pub y: CVector4f,
pub z: CVector4f,
pub w: CVector4f,
}
impl CMatrix4f {
pub const fn new(x: CVector4f, y: CVector4f, z: CVector4f, w: CVector4f) -> Self {
Self { x, y, z, w }
}
}
impl Default for CMatrix4f {
fn default() -> Self { IDENTITY_MATRIX4F }
}
unsafe impl ExternType for CMatrix4f {
type Id = type_id!("zeus::CMatrix4f");
type Kind = cxx::kind::Trivial;
}
#[cxx::bridge(namespace = "zeus")]
mod ffi {
unsafe extern "C++" {
include!("zeus/CVector2f.hpp");
include!("zeus/CVector3f.hpp");
include!("zeus/CVector4f.hpp");
include!("zeus/CMatrix4f.hpp");
include!("zeus/CColor.hpp");
include!("zeus/CRectangle.hpp");
include!("zeus/CAABox.hpp");
type CVector2f = crate::zeus::CVector2f;
type CVector3f = crate::zeus::CVector3f;
type CVector4f = crate::zeus::CVector4f;
type CMatrix4f = crate::zeus::CMatrix4f;
type CColor = crate::zeus::CColor;
type CRectangle = crate::zeus::CRectangle;
type CAABox = crate::zeus::CAABox;
}
}
impl From<cgmath::Vector4<f32>> for CVector4f {
fn from(v: cgmath::Vector4<f32>) -> Self { Self { x: v.x, y: v.y, z: v.z, w: v.w } }
}
impl From<CVector4f> for cgmath::Vector4<f32> {
fn from(v: CVector4f) -> Self { Self { x: v.x, y: v.y, z: v.z, w: v.w } }
}
impl From<cgmath::Matrix4<f32>> for CMatrix4f {
fn from(m: cgmath::Matrix4<f32>) -> Self {
Self {
x: CVector4f::from(m.x),
y: CVector4f::from(m.y),
z: CVector4f::from(m.z),
w: CVector4f::from(m.w),
}
}
}
impl From<CMatrix4f> for cgmath::Matrix4<f32> {
fn from(m: CMatrix4f) -> Self {
Self {
x: cgmath::Vector4::from(m.x),
y: cgmath::Vector4::from(m.y),
z: cgmath::Vector4::from(m.z),
w: cgmath::Vector4::from(m.w),
}
}
}

61
NESEmulator/CNESEmulator.cpp
View File

@ -260,31 +260,31 @@ void CNESEmulator::InitializeEmulator() {
// mainLoopRuns = nesPAL ? DOTS*ppuCycleTimer : DOTS*ppuCycleTimer;
// mainLoopPos = mainLoopRuns;
CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
// Nearest-neighbor FTW!
m_texture = ctx.newDynamicTexture(VISIBLE_DOTS, linesToDraw, boo::TextureFormat::RGBA8,
boo::TextureClampMode::ClampToEdgeNearest);
if (ctx.platform() == boo::IGraphicsDataFactory::Platform::OpenGL) {
Vert verts[4] = {
{{-1.f, -1.f, 0.f}, {0.f, 1.f}},
{{-1.f, 1.f, 0.f}, {0.f, 0.f}},
{{1.f, -1.f, 0.f}, {1.f, 1.f}},
{{1.f, 1.f, 0.f}, {1.f, 0.f}},
};
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts, sizeof(Vert), 4);
} else {
Vert verts[4] = {
{{-1.f, 1.f, 0.f}, {0.f, 1.f}},
{{-1.f, -1.f, 0.f}, {0.f, 0.f}},
{{1.f, 1.f, 0.f}, {1.f, 1.f}},
{{1.f, -1.f, 0.f}, {1.f, 0.f}},
};
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts, sizeof(Vert), 4);
}
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
m_shadBind = CNESShader::BuildShaderDataBinding(ctx, m_vbo, m_uniBuf, m_texture);
return true;
} BooTrace);
// CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
// // Nearest-neighbor FTW!
// m_texture = ctx.newDynamicTexture(VISIBLE_DOTS, linesToDraw, boo::TextureFormat::RGBA8,
// boo::TextureClampMode::ClampToEdgeNearest);
// if (ctx.platform() == boo::IGraphicsDataFactory::Platform::OpenGL) {
// Vert verts[4] = {
// {{-1.f, -1.f, 0.f}, {0.f, 1.f}},
// {{-1.f, 1.f, 0.f}, {0.f, 0.f}},
// {{1.f, -1.f, 0.f}, {1.f, 1.f}},
// {{1.f, 1.f, 0.f}, {1.f, 0.f}},
// };
// m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts, sizeof(Vert), 4);
// } else {
// Vert verts[4] = {
// {{-1.f, 1.f, 0.f}, {0.f, 1.f}},
// {{-1.f, -1.f, 0.f}, {0.f, 0.f}},
// {{1.f, 1.f, 0.f}, {1.f, 1.f}},
// {{1.f, -1.f, 0.f}, {1.f, 0.f}},
// };
// m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts, sizeof(Vert), 4);
// }
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
// m_shadBind = CNESShader::BuildShaderDataBinding(ctx, m_vbo, m_uniBuf, m_texture);
// return true;
// } BooTrace);
// double useFreq = 223740;
double useFreq = apuGetFrequency();
@ -413,7 +413,8 @@ void CNESEmulator::NesEmuMainLoop(bool forceDraw) {
emuMainTimesSkipped++;
#endif
// printf("LC RENDER: %d\n", loopCount);
m_texture->load(textureImage, visibleImg);
// TODO TODO
// m_texture->load(textureImage, visibleImg);
emuRenderFrame = false;
break;
}
@ -770,10 +771,10 @@ void CNESEmulator::Draw(const zeus::CColor& mulColor, bool filtering) {
Uniform uniform = {zeus::CMatrix4f{}, mulColor};
uniform.m_matrix[0][0] = widthFac;
m_uniBuf->load(&uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_shadBind);
CGraphics::DrawArray(0, 4);
// m_uniBuf->load(&uniform, sizeof(Uniform));
//
// CGraphics::SetShaderDataBinding(m_shadBind);
// CGraphics::DrawArray(0, 4);
}
void CNESEmulator::LoadPassword(const u8* state) {

11
NESEmulator/CNESEmulator.hpp
View File

@ -2,9 +2,10 @@
#include "RetroTypes.hpp"
#include "zeus/CColor.hpp"
#include "boo/graphicsdev/IGraphicsDataFactory.hpp"
//#include "boo/graphicsdev/IGraphicsDataFactory.hpp"
#include "boo/audiodev/IAudioVoice.hpp"
#include "zeus/CMatrix4f.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
namespace metaforce {
struct CFinalInput;
@ -34,10 +35,10 @@ private:
zeus::CColor m_color;
};
boo::ObjToken<boo::ITextureD> m_texture;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
boo::ObjToken<boo::IShaderDataBinding> m_shadBind;
std::shared_ptr<aurora::TextureHandle> m_texture;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
// boo::ObjToken<boo::IShaderDataBinding> m_shadBind;
std::unique_ptr<u8[]> m_audioBufBlock;
u8* m_audioBufs[NUM_AUDIO_BUFFERS];

32
NESEmulator/CNESShader.cpp
View File

@ -1,24 +1,28 @@
#include "CNESShader.hpp"
#include "Graphics/CGraphics.hpp"
#include "hecl/Pipeline.hpp"
//#include "hecl/Pipeline.hpp"
namespace metaforce::MP1 {
boo::ObjToken<boo::IShaderPipeline> CNESShader::g_Pipeline;
//boo::ObjToken<boo::IShaderPipeline> CNESShader::g_Pipeline;
void CNESShader::Initialize() { g_Pipeline = hecl::conv->convert(Shader_CNESShader{}); }
boo::ObjToken<boo::IShaderDataBinding> CNESShader::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
boo::ObjToken<boo::IGraphicsBufferS> vbo,
boo::ObjToken<boo::IGraphicsBufferD> uniBuf,
boo::ObjToken<boo::ITextureD> tex) {
boo::ObjToken<boo::IGraphicsBuffer> bufs[] = {uniBuf.get()};
boo::PipelineStage stages[] = {boo::PipelineStage::Vertex};
boo::ObjToken<boo::ITexture> texs[] = {tex.get()};
return ctx.newShaderDataBinding(g_Pipeline, vbo.get(), nullptr, nullptr, 1, bufs, stages, nullptr, nullptr, 1, texs,
nullptr, nullptr);
void CNESShader::Initialize() {
// g_Pipeline = hecl::conv->convert(Shader_CNESShader{});
}
void CNESShader::Shutdown() { g_Pipeline.reset(); }
//boo::ObjToken<boo::IShaderDataBinding> CNESShader::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
// boo::ObjToken<boo::IGraphicsBufferS> vbo,
// boo::ObjToken<boo::IGraphicsBufferD> uniBuf,
// boo::ObjToken<boo::ITextureD> tex) {
// boo::ObjToken<boo::IGraphicsBuffer> bufs[] = {uniBuf.get()};
// boo::PipelineStage stages[] = {boo::PipelineStage::Vertex};
// boo::ObjToken<boo::ITexture> texs[] = {tex.get()};
// return ctx.newShaderDataBinding(g_Pipeline, vbo.get(), nullptr, nullptr, 1, bufs, stages, nullptr, nullptr, 1, texs,
// nullptr, nullptr);
//}
void CNESShader::Shutdown() {
// g_Pipeline.reset();
}
} // namespace metaforce::MP1

14
NESEmulator/CNESShader.hpp
View File

@ -1,6 +1,6 @@
#pragma once
#include "boo/graphicsdev/IGraphicsDataFactory.hpp"
//#include "boo/graphicsdev/IGraphicsDataFactory.hpp"
namespace metaforce::MP1 {
@ -9,12 +9,12 @@ public:
static void Initialize();
static void Shutdown();
static boo::ObjToken<boo::IShaderDataBinding> BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
boo::ObjToken<boo::IGraphicsBufferS> vbo,
boo::ObjToken<boo::IGraphicsBufferD> uniBuf,
boo::ObjToken<boo::ITextureD> tex);
static boo::ObjToken<boo::IShaderPipeline> g_Pipeline;
// static boo::ObjToken<boo::IShaderDataBinding> BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
// boo::ObjToken<boo::IGraphicsBufferS> vbo,
// boo::ObjToken<boo::IGraphicsBufferD> uniBuf,
// boo::ObjToken<boo::ITextureD> tex);
//
// static boo::ObjToken<boo::IShaderPipeline> g_Pipeline;
};
} // namespace metaforce::MP1

76
Runtime/AutoMapper/CMapArea.cpp
View File

@ -3,11 +3,9 @@
#include <array>
#include <cstring>
#include "Runtime/CResFactory.hpp"
#include "Runtime/CToken.hpp"
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/AutoMapper/CMappableObject.hpp"
#include "Runtime/World/CGameArea.hpp"
#include "Runtime/World/CWorld.hpp"
namespace metaforce {
@ -108,43 +106,43 @@ void CMapArea::PostConstruct() {
m_surfaces.emplace_back(x40_surfaceStart + j).PostConstruct(x44_buf.get(), index);
}
CGraphics::CommitResources([this, &index](boo::IGraphicsDataFactory::Context& ctx) {
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, m_verts.data(), 16, m_verts.size());
m_ibo = ctx.newStaticBuffer(boo::BufferUse::Index, index.data(), 4, index.size());
/* Only the map universe specifies Always; it draws a maximum of 1016 instances */
size_t instCount = (xc_visibilityMode == EVisMode::Always) ? 1024 : 1;
for (u32 i = 0; i < x30_surfaceCount; ++i) {
CMapAreaSurface& surf = m_surfaces[i];
surf.m_instances.reserve(instCount);
for (u32 inst = 0; inst < instCount; ++inst) {
CMapAreaSurface::Instance& instance = surf.m_instances.emplace_back(ctx, m_vbo, m_ibo);
athena::io::MemoryReader r(surf.x1c_outlineOffset, INT_MAX);
u32 outlineCount = r.readUint32Big();
std::vector<CLineRenderer>& linePrims = instance.m_linePrims;
linePrims.reserve(outlineCount * 2);
for (u32 j = 0; j < 2; ++j) {
r.seek(4, athena::SeekOrigin::Begin);
for (u32 k = 0; k < outlineCount; ++k) {
const u32 count = r.readUint32Big();
r.seek(count);
r.seekAlign4();
linePrims.emplace_back(ctx, CLineRenderer::EPrimitiveMode::LineStrip, count, nullptr, false, false, true);
}
}
}
}
for (u32 i = 0; i < x28_mappableObjCount; ++i) {
CMappableObject& mapObj = m_mappableObjects[i];
if (CMappableObject::IsDoorType(mapObj.GetType()))
mapObj.CreateDoorSurface(ctx);
}
return true;
} BooTrace);
// CGraphics::CommitResources([this, &index](boo::IGraphicsDataFactory::Context& ctx) {
// m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, m_verts.data(), 16, m_verts.size());
// m_ibo = ctx.newStaticBuffer(boo::BufferUse::Index, index.data(), 4, index.size());
//
// /* Only the map universe specifies Always; it draws a maximum of 1016 instances */
// size_t instCount = (xc_visibilityMode == EVisMode::Always) ? 1024 : 1;
//
// for (u32 i = 0; i < x30_surfaceCount; ++i) {
// CMapAreaSurface& surf = m_surfaces[i];
// surf.m_instances.reserve(instCount);
// for (u32 inst = 0; inst < instCount; ++inst) {
// CMapAreaSurface::Instance& instance = surf.m_instances.emplace_back(ctx, m_vbo, m_ibo);
//
// athena::io::MemoryReader r(surf.x1c_outlineOffset, INT_MAX);
// u32 outlineCount = r.readUint32Big();
//
// std::vector<CLineRenderer>& linePrims = instance.m_linePrims;
// linePrims.reserve(outlineCount * 2);
// for (u32 j = 0; j < 2; ++j) {
// r.seek(4, athena::SeekOrigin::Begin);
// for (u32 k = 0; k < outlineCount; ++k) {
// const u32 count = r.readUint32Big();
// r.seek(count);
// r.seekAlign4();
// linePrims.emplace_back(ctx, CLineRenderer::EPrimitiveMode::LineStrip, count, nullptr, false, false, true);
// }
// }
// }
// }
//
// for (u32 i = 0; i < x28_mappableObjCount; ++i) {
// CMappableObject& mapObj = m_mappableObjects[i];
// if (CMappableObject::IsDoorType(mapObj.GetType()))
// mapObj.CreateDoorSurface(ctx);
// }
// return true;
// } BooTrace);
}
bool CMapArea::GetIsVisibleToAutoMapper(bool worldVis, bool areaVis) const {

16
Runtime/AutoMapper/CMapArea.hpp
View File

@ -3,13 +3,13 @@
#include <memory>
#include <vector>
#include "Runtime/CResFactory.hpp"
#include "Runtime/RetroTypes.hpp"
#include "Runtime/AutoMapper/CMappableObject.hpp"
#include "Runtime/CResFactory.hpp"
#include "Runtime/Graphics/CLineRenderer.hpp"
#include "Runtime/Graphics/Shaders/CMapSurfaceShader.hpp"
#include "Runtime/RetroTypes.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CAABox.hpp>
#include <zeus/CVector3f.hpp>
@ -29,9 +29,9 @@ public:
struct Instance {
CMapSurfaceShader m_surfacePrims;
std::vector<CLineRenderer> m_linePrims;
Instance(boo::IGraphicsDataFactory::Context& ctx, const boo::ObjToken<boo::IGraphicsBufferS>& vbo,
const boo::ObjToken<boo::IGraphicsBufferS>& ibo)
: m_surfacePrims(ctx, vbo, ibo) {}
Instance(aurora::ArrayRef<zeus::CVector3f> vbo,
aurora::ArrayRef<u16> ibo)
: m_surfacePrims(vbo, ibo) {}
Instance(Instance&&) = default;
Instance& operator=(Instance&&) = default;
};
@ -65,8 +65,8 @@ private:
u8* x40_surfaceStart;
std::vector<CMapAreaSurface> m_surfaces;
std::unique_ptr<u8[]> x44_buf;
boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
boo::ObjToken<boo::IGraphicsBufferS> m_ibo;
// boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferS> m_ibo;
public:
explicit CMapArea(CInputStream& in, u32 size);

25
Runtime/AutoMapper/CMappableObject.cpp
View File

@ -1,8 +1,8 @@
#include "Runtime/AutoMapper/CMappableObject.hpp"
#include "Runtime/AutoMapper/CMapWorldInfo.hpp"
#include "Runtime/CSimplePool.hpp"
#include "Runtime/CToken.hpp"
#include "Runtime/AutoMapper/CMapWorldInfo.hpp"
#include "Runtime/Camera/CCameraFilter.hpp"
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/Graphics/CTexture.hpp"
@ -10,7 +10,7 @@
namespace metaforce {
std::array<zeus::CVector3f, 8> CMappableObject::skDoorVerts{};
constexpr std::array<u32, 24> DoorIndices{
std::array<u16, 24> CMappableObject::skDoorIndices{
6, 4, 2, 0, 3, 1, 7, 5, 1, 0, 5, 4, 7, 6, 3, 2, 3, 2, 1, 0, 5, 4, 7, 6,
};
@ -116,7 +116,7 @@ void CMappableObject::Draw(int curArea, const CMapWorldInfo& mwInfo, float alpha
DoorSurface& ds = *m_doorSurface;
ds.m_surface.draw(colors.first, s * 4, 4);
CLineRenderer& line = ds.m_outline;
const u32* baseIdx = &DoorIndices[s * 4];
const u16* baseIdx = &skDoorIndices[s * 4];
line.Reset();
line.AddVertex(skDoorVerts[baseIdx[0]], colors.second, 1.f);
line.AddVertex(skDoorVerts[baseIdx[1]], colors.second, 1.f);
@ -186,7 +186,7 @@ void CMappableObject::DrawDoorSurface(int curArea, const CMapWorldInfo& mwInfo,
DoorSurface& ds = *m_doorSurface;
ds.m_surface.draw(colors.first, surfIdx * 4, 4);
CLineRenderer& line = ds.m_outline;
const u32* baseIdx = &DoorIndices[surfIdx * 4];
const u16* baseIdx = &skDoorIndices[surfIdx * 4];
line.Reset();
line.AddVertex(skDoorVerts[baseIdx[0]], colors.second, 1.f);
line.AddVertex(skDoorVerts[baseIdx[1]], colors.second, 1.f);
@ -236,9 +236,6 @@ bool CMappableObject::IsVisibleToAutoMapper(bool worldVis, const CMapWorldInfo&
}
}
boo::ObjToken<boo::IGraphicsBufferS> CMappableObject::g_doorVbo;
boo::ObjToken<boo::IGraphicsBufferS> CMappableObject::g_doorIbo;
void CMappableObject::ReadAutoMapperTweaks(const ITweakAutoMapper& tweaks) {
const zeus::CVector3f& center = tweaks.GetDoorCenter();
const zeus::simd_floats centerF(center.mSimd);
@ -254,15 +251,15 @@ void CMappableObject::ReadAutoMapperTweaks(const ITweakAutoMapper& tweaks) {
doorVerts[6].assign(.2f * -centerF[2], centerF[1], 0.f);
doorVerts[7].assign(.2f * -centerF[2], centerF[1], 2.f * centerF[0]);
CGraphics::CommitResources([](boo::IGraphicsDataFactory::Context& ctx) {
g_doorVbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, skDoorVerts.data(), 16, skDoorVerts.size());
g_doorIbo = ctx.newStaticBuffer(boo::BufferUse::Index, DoorIndices.data(), 4, DoorIndices.size());
return true;
} BooTrace);
// CGraphics::CommitResources([](boo::IGraphicsDataFactory::Context& ctx) {
// g_doorVbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, skDoorVerts.data(), 16, skDoorVerts.size());
// g_doorIbo = ctx.newStaticBuffer(boo::BufferUse::Index, DoorIndices.data(), 4, DoorIndices.size());
// return true;
// } BooTrace);
}
void CMappableObject::Shutdown() {
g_doorVbo.reset();
g_doorIbo.reset();
// g_doorVbo.reset();
// g_doorIbo.reset();
}
} // namespace metaforce

14
Runtime/AutoMapper/CMappableObject.hpp
View File

@ -5,10 +5,10 @@
#include <utility>
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/RetroTypes.hpp"
#include "Runtime/Graphics/CLineRenderer.hpp"
#include "Runtime/Graphics/Shaders/CMapSurfaceShader.hpp"
#include "Runtime/Graphics/Shaders/CTexturedQuadFilter.hpp"
#include "Runtime/RetroTypes.hpp"
#include <zeus/CAABox.hpp>
#include <zeus/CTransform.hpp>
@ -18,9 +18,6 @@ class CMapWorldInfo;
class CStateManager;
class CMappableObject {
static boo::ObjToken<boo::IGraphicsBufferS> g_doorVbo;
static boo::ObjToken<boo::IGraphicsBufferS> g_doorIbo;
public:
enum class EMappableObjectType {
BlueDoor = 0,
@ -54,6 +51,7 @@ public:
private:
static std::array<zeus::CVector3f, 8> skDoorVerts;
static std::array<u16, 24> skDoorIndices;
EMappableObjectType x0_type;
EVisMode x4_visibilityMode;
@ -64,9 +62,9 @@ private:
struct DoorSurface {
CMapSurfaceShader m_surface;
CLineRenderer m_outline;
explicit DoorSurface(boo::IGraphicsDataFactory::Context& ctx)
: m_surface(ctx, g_doorVbo, g_doorIbo)
, m_outline(ctx, CLineRenderer::EPrimitiveMode::LineLoop, 5, nullptr, false, false, true) {}
explicit DoorSurface()
: m_surface(aurora::ArrayRef{skDoorVerts}, aurora::ArrayRef{skDoorIndices})
, m_outline(CLineRenderer::EPrimitiveMode::LineLoop, 5, nullptr, false, false, true) {}
};
std::optional<DoorSurface> m_doorSurface;
std::optional<CTexturedQuadFilter> m_texQuadFilter;
@ -87,7 +85,7 @@ public:
bool IsDoorConnectedToVisitedArea(const CStateManager&) const;
bool IsVisibleToAutoMapper(bool worldVis, const CMapWorldInfo& mwInfo) const;
bool GetIsSeen() const;
void CreateDoorSurface(boo::IGraphicsDataFactory::Context& ctx) { m_doorSurface.emplace(ctx); }
void CreateDoorSurface() { m_doorSurface.emplace(); }
static void ReadAutoMapperTweaks(const ITweakAutoMapper&);
static bool GetTweakIsMapVisibilityCheat();

129
Runtime/CDvdFile.cpp
View File

@ -7,11 +7,14 @@
namespace metaforce {
hecl::ProjectPath CDvdFile::m_DvdRoot;
std::unordered_map<std::string, std::string> CDvdFile::m_caseInsensitiveMap;
std::unique_ptr<nod::DiscBase> CDvdFile::m_DvdRoot;
// std::unordered_map<std::string, std::string> CDvdFile::m_caseInsensitiveMap;
class CFileDvdRequest : public IDvdRequest {
std::shared_ptr<athena::io::FileReader> m_reader;
std::shared_ptr<nod::IPartReadStream> m_reader;
uint64_t m_begin;
uint64_t m_size;
void* m_buf;
u32 m_len;
ESeekOrigin m_whence;
@ -40,18 +43,43 @@ public:
[[nodiscard]] EMediaType GetMediaType() const override { return EMediaType::File; }
CFileDvdRequest(CDvdFile& file, void* buf, u32 len, ESeekOrigin whence, int off, std::function<void(u32)>&& cb)
: m_reader(file.m_reader), m_buf(buf), m_len(len), m_whence(whence), m_offset(off), m_callback(std::move(cb)) {}
: m_reader(file.m_reader)
, m_begin(file.m_begin)
, m_size(file.m_size)
, m_buf(buf)
, m_len(len)
, m_whence(whence)
, m_offset(off)
, m_callback(std::move(cb)) {}
void DoRequest() {
if (m_cancel.load()) {
return;
}
u32 readLen;
u32 readLen = 0;
if (m_whence == ESeekOrigin::Cur && m_offset == 0) {
readLen = m_reader->readBytesToBuf(m_buf, m_len);
readLen = m_reader->read(m_buf, m_len);
} else {
m_reader->seek(m_offset, athena::SeekOrigin(m_whence));
readLen = m_reader->readBytesToBuf(m_buf, m_len);
int seek = 0;
int64_t offset = m_offset;
switch (m_whence) {
case ESeekOrigin::Begin: {
seek = SEEK_SET;
offset += int64_t(m_begin);
break;
}
case ESeekOrigin::End: {
seek = SEEK_SET;
offset += int64_t(m_begin) + int64_t(m_size);
break;
}
case ESeekOrigin::Cur: {
seek = SEEK_CUR;
break;
}
};
m_reader->seek(offset, seek);
readLen = m_reader->read(m_buf, m_len);
}
if (m_callback) {
m_callback(readLen);
@ -67,6 +95,15 @@ std::mutex CDvdFile::m_WaitMutex;
std::atomic_bool CDvdFile::m_WorkerRun = {false};
std::vector<std::shared_ptr<IDvdRequest>> CDvdFile::m_RequestQueue;
CDvdFile::CDvdFile(std::string_view path) : x18_path(path) {
auto* node = ResolvePath(path);
if (node != nullptr && node->getKind() == nod::Node::Kind::File) {
m_reader = node->beginReadStream();
m_begin = m_reader->position();
m_size = node->size();
}
}
void CDvdFile::WorkerProc() {
logvisor::RegisterThreadName("CDvdFile");
OPTICK_THREAD("CDvdFile");
@ -103,42 +140,72 @@ std::shared_ptr<IDvdRequest> CDvdFile::AsyncSeekRead(void* buf, u32 len, ESeekOr
return ret;
}
hecl::ProjectPath CDvdFile::ResolvePath(std::string_view path) {
auto start = path.begin();
while (*start == '/') {
++start;
u32 CDvdFile::SyncSeekRead(void* buf, u32 len, ESeekOrigin whence, int offset) {
int seek = 0;
switch (whence) {
case ESeekOrigin::Begin: {
seek = SEEK_SET;
offset += int64_t(m_begin);
break;
}
std::string lowerChStr(start, path.end());
std::transform(lowerChStr.begin(), lowerChStr.end(), lowerChStr.begin(), ::tolower);
auto search = m_caseInsensitiveMap.find(lowerChStr);
if (search == m_caseInsensitiveMap.end()) {
return {};
case ESeekOrigin::End: {
seek = SEEK_SET;
offset += int64_t(m_begin) + int64_t(m_size);
break;
}
return hecl::ProjectPath(m_DvdRoot, search->second);
case ESeekOrigin::Cur: {
seek = SEEK_CUR;
break;
}
};
m_reader->seek(offset, seek);
return m_reader->read(buf, len);
}
void CDvdFile::RecursiveBuildCaseInsensitiveMap(const hecl::ProjectPath& path, std::string::size_type prefixLen) {
for (const auto& p : path.enumerateDir()) {
if (p.m_isDir) {
RecursiveBuildCaseInsensitiveMap(hecl::ProjectPath(path, p.m_name), prefixLen);
nod::Node* CDvdFile::ResolvePath(std::string_view path) {
if (!m_DvdRoot) {
return nullptr;
}
if (path.starts_with('/')) {
path.remove_prefix(1);
}
auto* node = &m_DvdRoot->getDataPartition()->getFSTRoot();
while (node != nullptr && !path.empty()) {
std::string component;
auto end = path.find('/');
if (end != std::string_view::npos) {
component = path.substr(0, end);
path.remove_prefix(component.size() + 1);
} else {
hecl::ProjectPath ch(path, p.m_name);
std::string chStr(ch.getAbsolutePath().begin() + prefixLen, ch.getAbsolutePath().end());
std::string lowerChStr(chStr);
hecl::ToLower(lowerChStr);
m_caseInsensitiveMap[lowerChStr] = chStr;
component = path;
path.remove_prefix(component.size());
}
std::transform(component.begin(), component.end(), component.begin(), ::tolower);
auto* tmpNode = node;
node = nullptr;
for (auto& item : *tmpNode) {
const auto name = item.getName();
if (std::equal(component.begin(), component.end(), name.begin(), name.end(),
[](char a, char b) { return a == tolower(b); })) {
node = &item;
break;
}
}
}
return node;
}
void CDvdFile::Initialize(const hecl::ProjectPath& path) {
m_DvdRoot = path;
RecursiveBuildCaseInsensitiveMap(path, path.getAbsolutePath().length() + 1);
bool CDvdFile::Initialize(const std::string_view& path) {
if (m_WorkerRun.load()) {
return;
return true;
}
m_DvdRoot = nod::OpenDiscFromImage(path);
if (!m_DvdRoot) {
return false;
}
m_WorkerRun.store(true);
m_WorkerThread = std::thread(WorkerProc);
return true;
}
void CDvdFile::Shutdown() {

39
Runtime/CDvdFile.hpp
View File

@ -12,6 +12,8 @@
#include "Runtime/RetroTypes.hpp"
#include <athena/FileReader.hpp>
#include <nod/nod.hpp>
#include <nod/DiscBase.hpp>
namespace metaforce {
@ -23,8 +25,8 @@ class IDvdRequest;
class CDvdFile {
friend class CResLoader;
friend class CFileDvdRequest;
static hecl::ProjectPath m_DvdRoot;
static std::unordered_map<std::string, std::string> m_caseInsensitiveMap;
static std::unique_ptr<nod::DiscBase> m_DvdRoot;
// static std::unordered_map<std::string, std::string> m_caseInsensitiveMap;
static std::thread m_WorkerThread;
static std::mutex m_WorkerMutex;
static std::condition_variable m_WorkerCV;
@ -34,32 +36,33 @@ class CDvdFile {
static void WorkerProc();
std::string x18_path;
std::shared_ptr<athena::io::FileReader> m_reader;
std::shared_ptr<nod::IPartReadStream> m_reader;
uint64_t m_begin;
uint64_t m_size;
static hecl::ProjectPath ResolvePath(std::string_view path);
static void RecursiveBuildCaseInsensitiveMap(const hecl::ProjectPath& path, std::string::size_type prefixLen);
static nod::Node* ResolvePath(std::string_view path);
// static void RecursiveBuildCaseInsensitiveMap(const hecl::ProjectPath& path, std::string::size_type prefixLen);
public:
static void Initialize(const hecl::ProjectPath& path);
static bool Initialize(const std::string_view& path);
static void Shutdown();
CDvdFile(std::string_view path)
: x18_path(path), m_reader(std::make_shared<athena::io::FileReader>(ResolvePath(path).getAbsolutePath())) {}
operator bool() const { return m_reader->isOpen(); }
void UpdateFilePos(int pos) { m_reader->seek(pos, athena::SeekOrigin::Begin); }
static bool FileExists(std::string_view path) { return ResolvePath(path).isFile(); }
void CloseFile() { m_reader->close(); }
CDvdFile(std::string_view path);
operator bool() const { return m_reader.operator bool(); }
void UpdateFilePos(int pos) { m_reader->seek(pos, SEEK_SET); }
static bool FileExists(std::string_view path) {
nod::Node* node = ResolvePath(path);
return node != nullptr && node->getKind() == nod::Node::Kind::File;
}
void CloseFile() { m_reader.reset(); }
std::shared_ptr<IDvdRequest> AsyncSeekRead(void* buf, u32 len, ESeekOrigin whence, int off,
std::function<void(u32)>&& cb = {});
u32 SyncSeekRead(void* buf, u32 len, ESeekOrigin whence, int offset) {
m_reader->seek(offset, athena::SeekOrigin(whence));
return m_reader->readBytesToBuf(buf, len);
}
u32 SyncSeekRead(void* buf, u32 len, ESeekOrigin whence, int offset);
std::shared_ptr<IDvdRequest> AsyncRead(void* buf, u32 len, std::function<void(u32)>&& cb = {}) {
return AsyncSeekRead(buf, len, ESeekOrigin::Cur, 0, std::move(cb));
}
u32 SyncRead(void* buf, u32 len) { return m_reader->readBytesToBuf(buf, len); }
u64 Length() const { return m_reader->length(); }
u32 SyncRead(void* buf, u32 len) { return m_reader->read(buf, len); }
u64 Length() const { return m_size; }
std::string_view GetPath() const { return x18_path; }
};
} // namespace metaforce

2
Runtime/CGameOptions.cpp
View File

@ -287,7 +287,7 @@ void CGameOptions::ApplyGamma() {
gammaT = gammaT * 0.5f + 0.5f;
if (zeus::close_enough(gammaT, 1.f, 0.05f))
gammaT = 1.f;
CGraphics::g_BooFactory->setDisplayGamma(gammaT);
// CGraphics::g_BooFactory->setDisplayGamma(gammaT);
}
void CGameOptions::SetGamma(s32 value, bool apply) {

345
Runtime/CMain.cpp
View File

@ -1,7 +1,7 @@
#include <string>
#include <string_view>
#include <numeric>
#include <hecl/Pipeline.hpp>
#include <iostream>
#include "boo/boo.hpp"
#include "logvisor/logvisor.hpp"
@ -20,6 +20,10 @@
* (used by MSVC to definitively link DataSpecs) */
#include "DataSpecRegistry.hpp"
#include "Graphics/include/aurora.hpp"
#include "aurora.h"
#include "aurora_shaders.h"
using namespace std::literals;
static logvisor::Module AthenaLog("Athena");
@ -151,21 +155,21 @@ private:
boo::SWindowRect m_lastRect;
bool m_rectDirty = false;
bool m_windowInvalid = false;
ImGuiWindowCallback m_imguiCallback;
// ImGuiWindowCallback m_imguiCallback;
void resized(const boo::SWindowRect& rect, bool sync) override {
m_lastRect = rect;
m_rectDirty = true;
m_imguiCallback.resized(rect, sync);
// m_imguiCallback.resized(rect, sync);
}
void mouseDown(const boo::SWindowCoord& coord, boo::EMouseButton button, boo::EModifierKey mods) override {
if (!ImGuiWindowCallback::m_mouseCaptured && g_mainMP1) {
if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
as->mouseDown(coord, button, mods);
}
}
m_imguiCallback.mouseDown(coord, button, mods);
// if (!ImGuiWindowCallback::m_mouseCaptured && g_mainMP1) {
// if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
// as->mouseDown(coord, button, mods);
// }
// }
// m_imguiCallback.mouseDown(coord, button, mods);
}
void mouseUp(const boo::SWindowCoord& coord, boo::EMouseButton button, boo::EModifierKey mods) override {
@ -174,38 +178,38 @@ private:
as->mouseUp(coord, button, mods);
}
}
m_imguiCallback.mouseUp(coord, button, mods);
// m_imguiCallback.mouseUp(coord, button, mods);
}
void mouseMove(const boo::SWindowCoord& coord) override {
if (!ImGuiWindowCallback::m_mouseCaptured && g_mainMP1) {
if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
as->mouseMove(coord);
}
}
m_imguiCallback.mouseMove(coord);
// if (!ImGuiWindowCallback::m_mouseCaptured && g_mainMP1) {
// if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
// as->mouseMove(coord);
// }
// }
// m_imguiCallback.mouseMove(coord);
}
void mouseEnter(const boo::SWindowCoord& coord) override { m_imguiCallback.mouseEnter(coord); }
// void mouseEnter(const boo::SWindowCoord& coord) override { m_imguiCallback.mouseEnter(coord); }
void mouseLeave(const boo::SWindowCoord& coord) override { m_imguiCallback.mouseLeave(coord); }
// void mouseLeave(const boo::SWindowCoord& coord) override { m_imguiCallback.mouseLeave(coord); }
void scroll(const boo::SWindowCoord& coord, const boo::SScrollDelta& scroll) override {
if (!ImGuiWindowCallback::m_mouseCaptured && g_mainMP1) {
if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
as->scroll(coord, scroll);
}
}
m_imguiCallback.scroll(coord, scroll);
// if (!ImGuiWindowCallback::m_mouseCaptured && g_mainMP1) {
// if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
// as->scroll(coord, scroll);
// }
// }
// m_imguiCallback.scroll(coord, scroll);
}
void charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat) override {
if (!ImGuiWindowCallback::m_keyboardCaptured && g_mainMP1) {
if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
as->charKeyDown(charCode, mods, isRepeat);
}
}
m_imguiCallback.charKeyDown(charCode, mods, isRepeat);
// if (!ImGuiWindowCallback::m_keyboardCaptured && g_mainMP1) {
// if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
// as->charKeyDown(charCode, mods, isRepeat);
// }
// }
// m_imguiCallback.charKeyDown(charCode, mods, isRepeat);
}
void charKeyUp(unsigned long charCode, boo::EModifierKey mods) override {
@ -214,40 +218,39 @@ private:
as->charKeyUp(charCode, mods);
}
}
m_imguiCallback.charKeyUp(charCode, mods);
// m_imguiCallback.charKeyUp(charCode, mods);
}
void specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat) override {
if (!ImGuiWindowCallback::m_keyboardCaptured && g_mainMP1) {
if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
as->specialKeyDown(key, mods, isRepeat);
}
}
if (True(mods & boo::EModifierKey::Alt)) {
if (key == boo::ESpecialKey::Enter) {
m_fullscreenToggleRequested = true;
} else if (key == boo::ESpecialKey::F4) {
m_windowInvalid = true;
}
}
m_imguiCallback.specialKeyDown(key, mods, isRepeat);
// if (!ImGuiWindowCallback::m_keyboardCaptured && g_mainMP1) {
// if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
// as->specialKeyDown(key, mods, isRepeat);
// }
// }
// if (True(mods & boo::EModifierKey::Alt)) {
// if (key == boo::ESpecialKey::Enter) {
// m_fullscreenToggleRequested = true;
// } else if (key == boo::ESpecialKey::F4) {
// m_windowInvalid = true;
// }
// }
// m_imguiCallback.specialKeyDown(key, mods, isRepeat);
}
void specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods) override {
if (g_mainMP1) {
if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
as->specialKeyUp(key, mods);
}
}
m_imguiCallback.specialKeyUp(key, mods);
// if (g_mainMP1) {
// if (MP1::CGameArchitectureSupport* as = g_mainMP1->GetArchSupport()) {
// as->specialKeyUp(key, mods);
// }
// }
// m_imguiCallback.specialKeyUp(key, mods);
}
void destroyed() override { m_windowInvalid = true; }
};
struct Application : boo::IApplicationCallback {
struct Application : aurora::AppDelegate {
private:
std::shared_ptr<boo::IWindow> m_window;
WindowCallback m_windowCallback;
hecl::Runtime::FileStoreManager& m_fileMgr;
hecl::CVarManager& m_cvarManager;
@ -255,17 +258,16 @@ private:
ImGuiConsole m_imGuiConsole;
std::string m_errorString;
boo::ObjToken<boo::ITextureR> m_renderTex;
// boo::ObjToken<boo::ITextureR> m_renderTex;
std::string m_deferredProject;
std::unique_ptr<hecl::Database::Project> m_proj;
bool m_projectInitialized = false;
// std::unique_ptr<hecl::Database::Project> m_proj;
std::optional<amuse::BooBackendVoiceAllocator> m_amuseAllocWrapper;
std::unique_ptr<boo::IAudioVoiceEngine> m_voiceEngine;
std::unique_ptr<hecl::PipelineConverterBase> m_pipelineConv;
// std::unique_ptr<hecl::PipelineConverterBase> m_pipelineConv;
Limiter m_limiter{};
std::atomic_bool m_running = {true};
bool m_noShaderWarmup = false;
bool m_imGuiInitialized = false;
bool m_firstFrame = true;
using delta_clock = std::chrono::high_resolution_clock;
@ -275,41 +277,25 @@ public:
Application(hecl::Runtime::FileStoreManager& fileMgr, hecl::CVarManager& cvarMgr, hecl::CVarCommons& cvarCmns)
: m_fileMgr(fileMgr), m_cvarManager(cvarMgr), m_cvarCommons(cvarCmns), m_imGuiConsole(cvarMgr, cvarCmns) {}
int appMain(boo::IApplication* app) override {
initialize(app);
void onAppLaunched() override {
initialize();
m_window = app->newWindow("Metaforce"sv);
if (!m_window) {
return 1;
}
m_window->setCallback(&m_windowCallback);
m_window->showWindow();
auto backend = static_cast<std::string>(aurora::get_backend_string());
aurora::set_window_title(fmt::format(FMT_STRING("Metaforce {} [{}]"), METAFORCE_WC_DESCRIBE, backend));
boo::IGraphicsDataFactory* gfxF = m_window->getMainContextDataFactory();
m_window->setTitle(fmt::format(FMT_STRING("Metaforce {} [{}]"), METAFORCE_WC_DESCRIBE, gfxF->platformName()));
boo::SWindowRect rect = m_window->getWindowFrame();
m_windowCallback.m_lastRect = rect;
gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) {
m_renderTex = ctx.newRenderTexture(rect.size[0], rect.size[1], boo::TextureClampMode::ClampToEdge, 3, 3);
return true;
} BooTrace);
m_pipelineConv = hecl::NewPipelineConverter(gfxF);
hecl::conv = m_pipelineConv.get();
m_voiceEngine = boo::NewAudioVoiceEngine();
m_voiceEngine = boo::NewAudioVoiceEngine("metaforce", "Metaforce");
m_voiceEngine->setVolume(0.7f);
m_amuseAllocWrapper.emplace(*m_voiceEngine);
hecl::ProjectPath projectPath;
for (const auto& arg : app->getArgs()) {
hecl::Sstat theStat;
if (!hecl::Stat((arg + "/out").c_str(), &theStat) && S_ISDIR(theStat.st_mode)) {
hecl::ProjectRootPath rootPath(arg);
hecl::Database::Project tmp(rootPath); // Force project creation
}
if (m_deferredProject.empty() && hecl::SearchForProject(arg))
// hecl::ProjectPath projectPath;
for (const auto& str : aurora::get_args()) {
auto arg = static_cast<std::string>(str);
// hecl::Sstat theStat;
// if (hecl::Stat((arg + "/out").c_str(), &theStat) == 0 && S_ISDIR(theStat.st_mode)) {
// hecl::ProjectRootPath rootPath(arg);
// hecl::Database::Project tmp(rootPath); // Force project creation
// }
if (m_deferredProject.empty() && !arg.starts_with('-') && !arg.starts_with('+'))
m_deferredProject = arg;
if (arg == "--no-shader-warmup")
m_noShaderWarmup = true;
@ -317,45 +303,23 @@ public:
m_voiceEngine->setVolume(0.f);
}
if (m_deferredProject.empty()) {
/* Default behavior - search upwards for packaged project containing the program */
if (hecl::ProjectRootPath projRoot = hecl::SearchForProject(ExeDir)) {
std::string rootPath(projRoot.getAbsolutePath());
hecl::Sstat theStat;
if (hecl::Stat((rootPath + "/out/files/MP1/Metroid1.upak").c_str(), &theStat) == 0 && S_ISREG(theStat.st_mode))
m_deferredProject = rootPath + "/out";
}
// if (m_deferredProject.empty()) {
// /* Default behavior - search upwards for packaged project containing the program */
// if (hecl::ProjectRootPath projRoot = hecl::SearchForProject(ExeDir)) {
// std::string rootPath(projRoot.getAbsolutePath());
// hecl::Sstat theStat;
// if (hecl::Stat((rootPath + "/out/files/MP1/Metroid1.upak").c_str(), &theStat) == 0 && S_ISREG(theStat.st_mode))
// m_deferredProject = rootPath + "/out";
// }
// }
}
while (m_running) {
onAppIdle();
}
if (m_imGuiInitialized) {
m_imGuiConsole.Shutdown();
ImGuiEngine::Shutdown();
}
if (g_mainMP1) {
g_mainMP1->Shutdown();
}
g_mainMP1.reset();
m_renderTex.reset();
m_pipelineConv.reset();
if (m_window) {
m_window->getCommandQueue()->stopRenderer();
}
m_cvarManager.serialize();
m_voiceEngine.reset();
m_amuseAllocWrapper.reset();
CDvdFile::Shutdown();
return 0;
}
void initialize(boo::IApplication* app) {
void initialize() {
zeus::detectCPU();
for (const auto& arg : app->getArgs()) {
if (arg.find("--verbosity=") == 0 || arg.find("-v=") == 0) {
for (const auto& str : aurora::get_args()) {
auto arg = static_cast<std::string>(str);
if (arg.starts_with("--verbosity=") || arg.starts_with("-v=")) {
hecl::VerbosityLevel = atoi(arg.substr(arg.find_last_of('=') + 1).c_str());
hecl::LogModule.report(logvisor::Info, FMT_STRING("Set verbosity level to {}"), hecl::VerbosityLevel);
}
@ -367,30 +331,20 @@ public:
Log.report(logvisor::Info, FMT_STRING("CPU Features: {}"), CPUFeatureString(cpuInf));
}
void onAppIdle() noexcept {
if (!m_deferredProject.empty()) {
std::string subPath;
hecl::ProjectRootPath projPath = hecl::SearchForProject(m_deferredProject, subPath);
if (projPath) {
m_proj = std::make_unique<hecl::Database::Project>(projPath);
m_deferredProject.clear();
hecl::ProjectPath projectPath{m_proj->getProjectWorkingPath(), "out/files/MP1"};
CDvdFile::Initialize(projectPath);
bool onAppIdle(float realDt) noexcept override {
if (!m_projectInitialized && !m_deferredProject.empty()) {
if (CDvdFile::Initialize(m_deferredProject)) {
m_projectInitialized = true;
} else {
Log.report(logvisor::Error, FMT_STRING("Project doesn't exist at '{}'"), m_deferredProject);
m_errorString = fmt::format(FMT_STRING("Project not found at '{}'"), m_deferredProject);
m_deferredProject.clear();
}
}
if (!m_proj && m_errorString.empty()) {
if (!m_projectInitialized && m_errorString.empty()) {
m_errorString = "Project directory not specified"s;
}
if (m_windowCallback.m_windowInvalid) {
m_running.store(false);
return;
}
const auto targetFrameTime = getTargetFrameTime();
bool skipRetrace = false;
if (g_ResFactory != nullptr) {
@ -404,10 +358,6 @@ public:
m_limiter.Reset();
} else {
// No more to load, and we're under frame time
{
OPTICK_EVENT("Wait for Retrace");
m_window->waitForRetrace();
}
{
OPTICK_EVENT("Sleep");
m_limiter.Sleep(targetFrameTime);
@ -415,18 +365,20 @@ public:
}
OPTICK_FRAME("MainThread");
CGraphics::SetCommitResourcesAsLazy(m_cvarCommons.m_lazyCommitResources->toBoolean());
// CGraphics::SetCommitResourcesAsLazy(m_cvarCommons.m_lazyCommitResources->toBoolean());
boo::SWindowRect rect = m_windowCallback.m_lastRect;
rect.location = {0, 0};
boo::IGraphicsCommandQueue* gfxQ = m_window->getCommandQueue();
if (m_windowCallback.m_rectDirty) {
gfxQ->resizeRenderTexture(m_renderTex, rect.size[0], rect.size[1]);
CGraphics::SetViewportResolution({rect.size[0], rect.size[1]});
m_windowCallback.m_rectDirty = false;
} else if (m_firstFrame) {
CGraphics::SetViewportResolution({rect.size[0], rect.size[1]});
}
// TODO
// boo::SWindowRect rect = m_windowCallback.m_lastRect;
// rect.location = {0, 0};
// boo::IGraphicsCommandQueue* gfxQ = m_window->getCommandQueue();
// if (m_windowCallback.m_rectDirty) {
// gfxQ->resizeRenderTexture(m_renderTex, rect.size[0], rect.size[1]);
// CGraphics::SetViewportResolution({rect.size[0], rect.size[1]});
// m_windowCallback.m_rectDirty = false;
// } else if (m_firstFrame) {
auto rect = aurora::get_window_size();
CGraphics::SetViewportResolution({static_cast<int32_t>(rect.width), static_cast<int32_t>(rect.height)});
// }
// Check if fullscreen has been toggled, if so set the fullscreen cvar accordingly
if (m_windowCallback.m_fullscreenToggleRequested) {
@ -436,88 +388,63 @@ public:
// Check if the user has modified the fullscreen CVar, if so set fullscreen state accordingly
if (m_cvarCommons.m_fullscreen->isModified()) {
m_window->setFullscreen(m_cvarCommons.getFullscreen());
aurora::set_fullscreen(m_cvarCommons.getFullscreen());
}
// Let CVarManager inform all CVar listeners of the CVar's state and clear all mdoified flags if necessary
m_cvarManager.proc();
boo::IGraphicsDataFactory* gfxF = m_window->getMainContextDataFactory();
float scale = std::floor(m_window->getVirtualPixelFactor() * 4.f) / 4.f;
if (!g_mainMP1 && m_proj) {
g_mainMP1.emplace(nullptr, nullptr, gfxF, gfxQ, m_renderTex.get());
g_mainMP1->Init(m_fileMgr, &m_cvarManager, m_window.get(), m_voiceEngine.get(), *m_amuseAllocWrapper);
// TODO
// boo::IGraphicsDataFactory* gfxF = m_window->getMainContextDataFactory();
// float scale = std::floor(m_window->getVirtualPixelFactor() * 4.f) / 4.f;
if (!g_mainMP1 && m_projectInitialized) {
g_mainMP1.emplace(nullptr, nullptr);
g_mainMP1->Init(m_fileMgr, &m_cvarManager, m_voiceEngine.get(), *m_amuseAllocWrapper);
if (!m_noShaderWarmup) {
g_mainMP1->WarmupShaders();
}
}
if (!m_imGuiInitialized) {
ImGuiEngine::Initialize(gfxF, m_window.get(), scale, m_fileMgr.getStoreRoot());
m_imGuiInitialized = true;
}
// if (!m_imGuiInitialized) {
// ImGuiEngine::Initialize(gfxF, m_window.get(), scale, m_fileMgr.getStoreRoot());
// m_imGuiInitialized = true;
// }
float dt = 1 / 60.f;
float realDt = dt;
auto now = delta_clock::now();
if (m_firstFrame) {
m_firstFrame = false;
} else {
using delta_duration = std::chrono::duration<float, std::ratio<1>>;
realDt = std::chrono::duration_cast<delta_duration>(now - m_prevFrameTime).count();
if (m_cvarCommons.m_variableDt->toBoolean()) {
dt = std::min(realDt, 1 / 30.f);
}
}
m_prevFrameTime = now;
ImGuiEngine::Begin(realDt, scale);
if (g_mainMP1) {
m_imGuiConsole.PreUpdate();
if (g_mainMP1->Proc(dt)) {
m_running.store(false);
return;
return false;
}
m_imGuiConsole.PostUpdate();
} else {
m_imGuiConsole.ShowAboutWindow(false, m_errorString);
}
{
OPTICK_EVENT("Flush");
CGraphics::SetCommitResourcesAsLazy(false);
// {
// OPTICK_EVENT("Flush");
// CGraphics::SetCommitResourcesAsLazy(false);
// }
return true;
}
{
void onAppDraw() noexcept override {
OPTICK_EVENT("Draw");
gfxQ->setRenderTarget(m_renderTex);
gfxQ->clearTarget();
gfxQ->setViewport(rect);
gfxQ->setScissor(rect);
if (g_Renderer != nullptr) {
g_Renderer->BeginScene();
}
if (g_mainMP1) {
g_mainMP1->Draw();
}
if (g_Renderer != nullptr) {
g_Renderer->EndScene();
}
}
{
OPTICK_EVENT("ImGui Draw");
ImGuiEngine::End();
ImGuiEngine::Draw(gfxQ);
}
{
OPTICK_EVENT("Execute");
gfxQ->execute();
}
gfxQ->resolveDisplay(m_renderTex);
void onAppPostDraw() noexcept override {
OPTICK_EVENT("PostDraw");
if (m_voiceEngine) {
m_voiceEngine->pumpAndMixVoices();
}
@ -526,7 +453,19 @@ public:
++logvisor::FrameIndex;
}
void appQuitting(boo::IApplication* /*unused*/) override { m_running.store(false); }
void onAppExiting() noexcept override {
m_imGuiConsole.Shutdown();
if (g_mainMP1) {
g_mainMP1->Shutdown();
}
g_mainMP1.reset();
// m_renderTex.reset();
// m_pipelineConv.reset();
m_cvarManager.serialize();
m_voiceEngine.reset();
m_amuseAllocWrapper.reset();
CDvdFile::Shutdown();
}
[[nodiscard]] std::string getGraphicsApi() const { return m_cvarCommons.getGraphicsApi(); }
@ -626,11 +565,9 @@ int main(int argc, char** argv) {
/* Handle -j argument */
hecl::SetCpuCountOverride(argc, argv);
metaforce::Application appCb(fileMgr, cvarMgr, cvarCmns);
int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto, appCb, "metaforce", "Metaforce", argv[0], args,
appCb.getGraphicsApi(), appCb.getSamples(), appCb.getAnisotropy(), appCb.getDeepColor(),
false);
return ret;
auto app = std::make_unique<metaforce::Application>(fileMgr, cvarMgr, cvarCmns);
aurora::app_run(std::move(app));
return 0;
}
#endif

6
Runtime/CMakeLists.txt
View File

@ -136,7 +136,7 @@ endfunction()
set(RUNTIME_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
set(RUNTIME_LIBRARIES ${HECL_APPLICATION_REPS_TARGETS_LIST} RetroDataSpec AssetNameMapNull NESEmulator
libjpeg-turbo jbus kabufuda discord-rpc logvisor OptickCore imgui)
libjpeg-turbo jbus kabufuda discord-rpc logvisor OptickCore imgui aurora)
add_runtime_common_library(RuntimeCommon ${RUNTIME_SOURCES_A})
target_include_directories(RuntimeCommon PUBLIC ${RUNTIME_INCLUDES})
@ -205,7 +205,7 @@ elseif (UNIX)
set(PLAT_LIBS rt)
endif ()
add_executable(metaforce CMain.cpp ${PLAT_SRCS} ImGuiConsole.hpp ImGuiConsole.cpp ImGuiEntitySupport.hpp ImGuiEntitySupport.cpp) # ImGuiPlayerLoadouts.hpp
add_executable(metaforce CMain.cpp ${PLAT_SRCS} ImGuiConsole.hpp ImGuiConsole.cpp ImGuiEntitySupport.hpp ImGuiEntitySupport.cpp ../Graphics/lib.cpp) # ImGuiPlayerLoadouts.hpp
# target_atdna(metaforce atdna_ImGuiPlayerLoadouts.cpp ImGuiPlayerLoadouts.hpp)
# RUNTIME_LIBRARIES repeated here for link ordering
target_link_libraries(metaforce PUBLIC RuntimeCommon RuntimeCommonB ${RUNTIME_LIBRARIES} ${PLAT_LIBS})
@ -215,7 +215,7 @@ if (COMMAND add_sanitizers)
endif ()
if (NOT WINDOWS_STORE)
add_dependencies(metaforce visigen hecl)
add_dependencies(metaforce hecl) # visigen
else ()
set_property(TARGET metaforce PROPERTY VS_WINRT_COMPONENT TRUE)
# This should match the Package.appxmanifest

4
Runtime/CPakFile.cpp
View File

@ -63,10 +63,10 @@ void CPakFile::InitialHeaderLoad() {
athena::io::MemoryReader r(x38_headerData.data(), x38_headerData.size());
x30_dvdReq.reset();
u32 version = r.readUint32Big();
if (version != 0x80030005) {
if (version != 0x00030005) {
Log.report(logvisor::Fatal,
FMT_STRING("{}: Incompatible pak file version -- Current version is {:08X}, you're using {:08X}"),
GetPath(), 0x80030005, version);
GetPath(), 0x00030005, version);
return;
}

6
Runtime/CResLoader.cpp
View File

@ -8,7 +8,7 @@ static logvisor::Module Log("CResLoader");
CResLoader::CResLoader() { x48_curPak = x18_pakLoadedList.end(); }
const std::vector<CAssetId>* CResLoader::GetTagListForFile(std::string_view name) const {
const std::string namePak = std::string(name).append(".upak");
const std::string namePak = std::string(name).append(".pak");
for (const std::unique_ptr<CPakFile>& pak : x18_pakLoadedList) {
if (CStringExtras::CompareCaseInsensitive(namePak, pak->x18_path)) {
return &pak->GetDepList();
@ -18,7 +18,7 @@ const std::vector<CAssetId>* CResLoader::GetTagListForFile(std::string_view name
}
void CResLoader::AddPakFileAsync(std::string_view name, bool buildDepList, bool worldPak, bool override) {
const std::string namePak = std::string(name).append(".upak");
const std::string namePak = std::string(name).append(".pak");
if (CDvdFile::FileExists(namePak)) {
x30_pakLoadingList.emplace_back(std::make_unique<CPakFile>(namePak, buildDepList, worldPak, override));
++x44_pakLoadingCount;
@ -116,7 +116,7 @@ std::unique_ptr<u8[]> CResLoader::LoadNewResourcePartSync(const metaforce::SObje
}
void CResLoader::GetTagListForFile(const char* pakName, std::vector<SObjectTag>& out) const {
std::string path = std::string(pakName) + ".upak";
std::string path = std::string(pakName) + ".pak";
for (const std::unique_ptr<CPakFile>& file : m_overridePakList) {
if (_GetTagListForFile(out, path, file))

168
Runtime/CStateManager.cpp
View File

@ -985,90 +985,90 @@ void CStateManager::DrawWorld() {
}
void CStateManager::DrawActorCubeFaces(CActor& actor, int& cubeInst) const {
if (!actor.m_reflectionCube ||
(!TCastToPtr<CPlayer>(actor) && (!actor.GetActive() || !actor.IsDrawEnabled() || actor.xe4_30_outOfFrustum)))
return;
const TAreaId visAreaId = actor.GetAreaIdAlways();
const SViewport backupVp = g_Viewport;
int areaCount = 0;
std::array<const CGameArea*, 10> areaArr;
for (const CGameArea& area : *x850_world) {
if (areaCount == 10) {
break;
}
auto occState = CGameArea::EOcclusionState::Occluded;
if (area.IsPostConstructed()) {
occState = area.GetOcclusionState();
}
if (occState == CGameArea::EOcclusionState::Visible) {
areaArr[areaCount++] = &area;
}
}
for (int f = 0; f < 6; ++f) {
SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(FMT_STRING("CStateManager::DrawActorCubeFaces [{}] {} {} {}"), f,
actor.GetUniqueId(), actor.GetEditorId(), actor.GetName())
.c_str(),
zeus::skOrange);
CGraphics::g_BooMainCommandQueue->setRenderTarget(actor.m_reflectionCube, f);
SetupViewForCubeFaceDraw(actor.GetRenderBounds().center(), f);
CGraphics::g_BooMainCommandQueue->clearTarget();
std::sort(areaArr.begin(), areaArr.begin() + areaCount, [visAreaId](const CGameArea* a, const CGameArea* b) {
if (a->x4_selfIdx == b->x4_selfIdx) {
return false;
}
if (visAreaId == a->x4_selfIdx) {
return false;
}
if (visAreaId == b->x4_selfIdx) {
return true;
}
return CGraphics::g_ViewPoint.dot(a->GetAABB().center()) > CGraphics::g_ViewPoint.dot(b->GetAABB().center());
});
int pvsCount = 0;
std::array<CPVSVisSet, 10> pvsArr;
for (auto area = areaArr.cbegin(); area != areaArr.cbegin() + areaCount; ++area) {
const CGameArea* areaPtr = *area;
CPVSVisSet& pvsSet = pvsArr[pvsCount++];
pvsSet.Reset(EPVSVisSetState::OutOfBounds);
GetVisSetForArea(areaPtr->x4_selfIdx, visAreaId, pvsSet);
}
for (int i = areaCount - 1; i >= 0; --i) {
const CGameArea& area = *areaArr[i];
SetupFogForArea(area);
g_Renderer->EnablePVS(pvsArr[i], area.x4_selfIdx);
g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
g_Renderer->UpdateAreaUniforms(area.x4_selfIdx, EWorldShadowMode::None, true, cubeInst * 6 + f);
g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, 0x2, 0x0);
}
if (!SetupFogForDraw()) {
g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::skBlack);
}
x850_world->DrawSky(zeus::CTransform::Translate(CGraphics::g_ViewPoint));
for (int i = 0; i < areaCount; ++i) {
const CGameArea& area = *areaArr[i];
CPVSVisSet& pvs = pvsArr[i];
SetupFogForArea(area);
g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
g_Renderer->EnablePVS(pvs, area.x4_selfIdx);
g_Renderer->DrawSortedGeometry(area.x4_selfIdx, 0x2, 0x0);
}
}
CGraphics::g_BooMainCommandQueue->generateMipmaps(actor.m_reflectionCube);
CBooRenderer::BindMainDrawTarget();
g_Renderer->SetViewport(backupVp.x0_left, backupVp.x4_top, backupVp.x8_width, backupVp.xc_height);
++cubeInst;
// if (!actor.m_reflectionCube ||
// (!TCastToPtr<CPlayer>(actor) && (!actor.GetActive() || !actor.IsDrawEnabled() || actor.xe4_30_outOfFrustum)))
// return;
//
// const TAreaId visAreaId = actor.GetAreaIdAlways();
// const SViewport backupVp = g_Viewport;
//
// int areaCount = 0;
// std::array<const CGameArea*, 10> areaArr;
// for (const CGameArea& area : *x850_world) {
// if (areaCount == 10) {
// break;
// }
// auto occState = CGameArea::EOcclusionState::Occluded;
// if (area.IsPostConstructed()) {
// occState = area.GetOcclusionState();
// }
// if (occState == CGameArea::EOcclusionState::Visible) {
// areaArr[areaCount++] = &area;
// }
// }
//
// for (int f = 0; f < 6; ++f) {
// SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(FMT_STRING("CStateManager::DrawActorCubeFaces [{}] {} {} {}"), f,
// actor.GetUniqueId(), actor.GetEditorId(), actor.GetName())
// .c_str(),
// zeus::skOrange);
// CGraphics::g_BooMainCommandQueue->setRenderTarget(actor.m_reflectionCube, f);
// SetupViewForCubeFaceDraw(actor.GetRenderBounds().center(), f);
// CGraphics::g_BooMainCommandQueue->clearTarget();
//
// std::sort(areaArr.begin(), areaArr.begin() + areaCount, [visAreaId](const CGameArea* a, const CGameArea* b) {
// if (a->x4_selfIdx == b->x4_selfIdx) {
// return false;
// }
// if (visAreaId == a->x4_selfIdx) {
// return false;
// }
// if (visAreaId == b->x4_selfIdx) {
// return true;
// }
// return CGraphics::g_ViewPoint.dot(a->GetAABB().center()) > CGraphics::g_ViewPoint.dot(b->GetAABB().center());
// });
//
// int pvsCount = 0;
// std::array<CPVSVisSet, 10> pvsArr;
// for (auto area = areaArr.cbegin(); area != areaArr.cbegin() + areaCount; ++area) {
// const CGameArea* areaPtr = *area;
// CPVSVisSet& pvsSet = pvsArr[pvsCount++];
// pvsSet.Reset(EPVSVisSetState::OutOfBounds);
// GetVisSetForArea(areaPtr->x4_selfIdx, visAreaId, pvsSet);
// }
//
// for (int i = areaCount - 1; i >= 0; --i) {
// const CGameArea& area = *areaArr[i];
// SetupFogForArea(area);
// g_Renderer->EnablePVS(pvsArr[i], area.x4_selfIdx);
// g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
// g_Renderer->UpdateAreaUniforms(area.x4_selfIdx, EWorldShadowMode::None, true, cubeInst * 6 + f);
// g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, 0x2, 0x0);
// }
//
// if (!SetupFogForDraw()) {
// g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::skBlack);
// }
//
// x850_world->DrawSky(zeus::CTransform::Translate(CGraphics::g_ViewPoint));
//
// for (int i = 0; i < areaCount; ++i) {
// const CGameArea& area = *areaArr[i];
// CPVSVisSet& pvs = pvsArr[i];
// SetupFogForArea(area);
// g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
// g_Renderer->EnablePVS(pvs, area.x4_selfIdx);
// g_Renderer->DrawSortedGeometry(area.x4_selfIdx, 0x2, 0x0);
// }
// }
//
// CGraphics::g_BooMainCommandQueue->generateMipmaps(actor.m_reflectionCube);
//
// CBooRenderer::BindMainDrawTarget();
// g_Renderer->SetViewport(backupVp.x0_left, backupVp.x4_top, backupVp.x8_width, backupVp.xc_height);
//
// ++cubeInst;
}
void CStateManager::DrawWorldCubeFaces() const {

11
Runtime/Character/CAnimData.cpp
View File

@ -43,8 +43,7 @@ CAnimData::CAnimData(CAssetId id, const CCharacterInfo& character, int defaultAn
TLockedToken<CCharLayoutInfo> layout, TToken<CSkinnedModel> model,
const std::optional<TToken<CMorphableSkinnedModel>>& iceModel,
const std::weak_ptr<CAnimSysContext>& ctx, std::shared_ptr<CAnimationManager> animMgr,
std::shared_ptr<CTransitionManager> transMgr, TLockedToken<CCharacterFactory> charFactory,
int drawInstCount)
std::shared_ptr<CTransitionManager> transMgr, TLockedToken<CCharacterFactory> charFactory)
: x0_charFactory(charFactory)
, xc_charInfo(character)
, xcc_layoutData(layout)
@ -56,8 +55,7 @@ CAnimData::CAnimData(CAssetId id, const CCharacterInfo& character, int defaultAn
, x204_charIdx(charIdx)
, x208_defaultAnim(defaultAnim)
, x224_pose(layout->GetSegIdList().GetList().size())
, x2fc_poseBuilder(CLayoutDescription{layout})
, m_drawInstCount(drawInstCount) {
, x2fc_poseBuilder(CLayoutDescription{layout}) {
x220_25_loop = loop;
if (iceModel)
@ -797,12 +795,11 @@ void CAnimData::AdvanceAnim(CCharAnimTime& time, zeus::CVector3f& offset, zeus::
}
void CAnimData::SetXRayModel(const TLockedToken<CModel>& model, const TLockedToken<CSkinRules>& skinRules) {
xf4_xrayModel = std::make_shared<CSkinnedModel>(model, skinRules, xd8_modelData->GetLayoutInfo(), 0, m_drawInstCount);
xf4_xrayModel = std::make_shared<CSkinnedModel>(model, skinRules, xd8_modelData->GetLayoutInfo(), 0);
}
void CAnimData::SetInfraModel(const TLockedToken<CModel>& model, const TLockedToken<CSkinRules>& skinRules) {
xf8_infraModel =
std::make_shared<CSkinnedModel>(model, skinRules, xd8_modelData->GetLayoutInfo(), 0, m_drawInstCount);
xf8_infraModel = std::make_shared<CSkinnedModel>(model, skinRules, xd8_modelData->GetLayoutInfo(), 0);
}
void CAnimData::PoseSkinnedModel(CSkinnedModel& model, const CPoseAsTransforms& pose, const CModelFlags& drawFlags,

4
Runtime/Character/CAnimData.hpp
View File

@ -144,14 +144,12 @@ private:
static rstl::reserved_vector<CSoundPOINode, 20> g_SoundPOINodes;
static rstl::reserved_vector<CInt32POINode, 16> g_TransientInt32POINodes;
int m_drawInstCount;
public:
CAnimData(CAssetId, const CCharacterInfo& character, int defaultAnim, int charIdx, bool loop,
TLockedToken<CCharLayoutInfo> layout, TToken<CSkinnedModel> model,
const std::optional<TToken<CMorphableSkinnedModel>>& iceModel, const std::weak_ptr<CAnimSysContext>& ctx,
std::shared_ptr<CAnimationManager> animMgr, std::shared_ptr<CTransitionManager> transMgr,
TLockedToken<CCharacterFactory> charFactory, int drawInstCount);
TLockedToken<CCharacterFactory> charFactory);
void SetParticleEffectState(std::string_view effectName, bool active, CStateManager& mgr);
void InitializeEffects(CStateManager& mgr, TAreaId aId, const zeus::CVector3f& scale);

24
Runtime/Character/CCharacterFactory.cpp
View File

@ -24,13 +24,11 @@ CFactoryFnReturn CCharacterFactory::CDummyFactory::Build(const SObjectTag& tag,
switch (tag.type.toUint32() & 0x1) {
case 0:
return TToken<CSkinnedModel>::GetIObjObjectFor(
std::make_unique<CSkinnedModel>(*g_SimplePool, charInfo.GetModelId(), charInfo.GetSkinRulesId(),
charInfo.GetCharLayoutInfoId(), 0, tag.type.toUint32() >> 16));
return TToken<CSkinnedModel>::GetIObjObjectFor(std::make_unique<CSkinnedModel>(
*g_SimplePool, charInfo.GetModelId(), charInfo.GetSkinRulesId(), charInfo.GetCharLayoutInfoId(), 0));
case 1:
return TToken<CSkinnedModel>::GetIObjObjectFor(
std::make_unique<CMorphableSkinnedModel>(*g_SimplePool, charInfo.GetIceModelId(), charInfo.GetIceSkinRulesId(),
charInfo.GetCharLayoutInfoId(), 0, tag.type.toUint32() >> 16));
return TToken<CSkinnedModel>::GetIObjObjectFor(std::make_unique<CMorphableSkinnedModel>(
*g_SimplePool, charInfo.GetIceModelId(), charInfo.GetIceSkinRulesId(), charInfo.GetCharLayoutInfoId(), 0));
default:
break;
}
@ -78,21 +76,20 @@ std::unique_ptr<u8[]> CCharacterFactory::CDummyFactory::LoadNewResourcePartSync(
std::unique_ptr<CAnimData> CCharacterFactory::CreateCharacter(int charIdx, bool loop,
const TLockedToken<CCharacterFactory>& factory,
int defaultAnim, int drawInsts) {
int defaultAnim) {
const CCharacterInfo& charInfo = x4_charInfoDB[charIdx];
const CVParamTransfer charParm(new TObjOwnerParam<const CCharacterInfo*>(&charInfo));
TToken<CSkinnedModel> skinnedModel =
x70_cacheResPool.GetObj({FourCC(drawInsts << 16), charInfo.GetModelId()}, charParm);
TToken<CSkinnedModel> skinnedModel = x70_cacheResPool.GetObj({FourCC(0u), charInfo.GetModelId()}, charParm);
std::optional<TToken<CMorphableSkinnedModel>> iceModel;
if (charInfo.GetIceModelId().IsValid() && charInfo.GetIceSkinRulesId().IsValid()) {
iceModel.emplace(x70_cacheResPool.GetObj({FourCC((drawInsts << 16) | 1), charInfo.GetIceModelId()}, charParm));
iceModel.emplace(x70_cacheResPool.GetObj({FourCC(1u), charInfo.GetIceModelId()}, charParm));
}
return std::make_unique<CAnimData>(x68_selfId, charInfo, defaultAnim, charIdx, loop, x14_charLayoutInfoDB[charIdx],
std::move(skinnedModel), iceModel, x24_sysContext, x28_animMgr, x2c_transMgr,
factory, drawInsts);
factory);
}
CAssetId CCharacterFactory::GetEventResourceIdForAnimResourceId(CAssetId id) const {
@ -156,8 +153,9 @@ CCharacterFactory::CCharacterFactory(CSimplePool& store, const CAnimCharacterSet
std::vector<CPrimitive> primitives;
x28_animMgr->GetAnimationDatabase()->GetAllUniquePrimitives(primitives);
x30_animSourceDB.reserve(primitives.size());
for (const CPrimitive& prim : primitives)
x30_animSourceDB.push_back(store.GetObj({SBIG('ANIM'), prim.GetAnimResId()}));
for (const CPrimitive& prim : primitives) {
x30_animSourceDB.emplace_back(store.GetObj({SBIG('ANIM'), prim.GetAnimResId()}));
}
}
} // namespace metaforce

2
Runtime/Character/CCharacterFactory.hpp
View File

@ -68,7 +68,7 @@ public:
CCharacterFactory(CSimplePool& store, const CAnimCharacterSet& ancs, CAssetId);
std::unique_ptr<CAnimData> CreateCharacter(int charIdx, bool loop, const TLockedToken<CCharacterFactory>& factory,
int defaultAnim, int drawInsts);
int defaultAnim);
CAssetId GetEventResourceIdForAnimResourceId(CAssetId animId) const;
const CCharacterInfo& GetCharInfo(int charIdx) const { return x4_charInfoDB[charIdx]; }

14
Runtime/Character/CModelData.cpp
View File

@ -23,17 +23,17 @@ CModelData::~CModelData() = default;
CModelData::CModelData() {}
CModelData CModelData::CModelDataNull() { return CModelData(); }
CModelData::CModelData(const CStaticRes& res, int instCount) : x0_scale(res.GetScale()), m_drawInstCount(instCount) {
CModelData::CModelData(const CStaticRes& res) : x0_scale(res.GetScale()) {
x1c_normalModel = g_SimplePool->GetObj({SBIG('CMDL'), res.GetId()});
if (!x1c_normalModel)
Log.report(logvisor::Fatal, FMT_STRING("unable to find CMDL {}"), res.GetId());
m_normalModelInst = x1c_normalModel->MakeNewInstance(0, instCount);
m_normalModelInst = x1c_normalModel->MakeNewInstance(0);
}
CModelData::CModelData(const CAnimRes& res, int instCount) : x0_scale(res.GetScale()), m_drawInstCount(instCount) {
CModelData::CModelData(const CAnimRes& res) : x0_scale(res.GetScale()) {
TToken<CCharacterFactory> factory = g_CharFactoryBuilder->GetFactory(res);
x10_animData =
factory->CreateCharacter(res.GetCharacterNodeId(), res.CanLoop(), factory, res.GetDefaultAnim(), instCount);
factory->CreateCharacter(res.GetCharacterNodeId(), res.CanLoop(), factory, res.GetDefaultAnim());
}
SAdvancementDeltas CModelData::GetAdvancementDeltas(const CCharAnimTime& a, const CCharAnimTime& b) const {
@ -143,7 +143,7 @@ void CModelData::SetXRayModel(const std::pair<CAssetId, CAssetId>& modelSkin) {
x2c_xrayModel = g_SimplePool->GetObj({SBIG('CMDL'), modelSkin.first});
if (!x2c_xrayModel)
Log.report(logvisor::Fatal, FMT_STRING("unable to find CMDL {}"), modelSkin.first);
m_xrayModelInst = x2c_xrayModel->MakeNewInstance(0, m_drawInstCount);
m_xrayModelInst = x2c_xrayModel->MakeNewInstance(0);
}
}
}
@ -160,7 +160,7 @@ void CModelData::SetInfraModel(const std::pair<CAssetId, CAssetId>& modelSkin) {
x3c_infraModel = g_SimplePool->GetObj({SBIG('CMDL'), modelSkin.first});
if (!x3c_infraModel)
Log.report(logvisor::Fatal, FMT_STRING("unable to find CMDL {}"), modelSkin.first);
m_infraModelInst = x3c_infraModel->MakeNewInstance(0, m_drawInstCount);
m_infraModelInst = x3c_infraModel->MakeNewInstance(0);
}
}
}
@ -431,7 +431,7 @@ void CModelData::DisintegrateDraw(EWhichModel which, const zeus::CTransform& xf,
zeus::CTransform scaledXf = xf * zeus::CTransform::Scale(x0_scale);
CGraphics::SetModelMatrix(scaledXf);
CBooModel::SetDisintegrateTexture(tex.GetBooTexture());
CBooModel::SetDisintegrateTexture(tex.GetTexture());
CModelFlags flags(5, 0, 3, zeus::skWhite);
flags.m_extendedShader = EExtendedShader::Disintegrate;
flags.addColor = addColor;

6
Runtime/Character/CModelData.hpp
View File

@ -75,8 +75,6 @@ class CModelData {
std::unique_ptr<CBooModel> m_xrayModelInst;
std::unique_ptr<CBooModel> m_infraModelInst;
int m_drawInstCount = 0;
public:
enum class EWhichModel { Normal, XRay, Thermal, ThermalHot };
@ -84,8 +82,8 @@ public:
bool GetSortThermal() const { return x14_25_sortThermal; }
~CModelData();
explicit CModelData(const CStaticRes& res, int instCount = 1);
explicit CModelData(const CAnimRes& res, int instCount = 1);
explicit CModelData(const CStaticRes& res);
explicit CModelData(const CAnimRes& res);
CModelData(CModelData&&) = default;
CModelData& operator=(CModelData&&) = default;
CModelData();

80
Runtime/Character/CSkinRules.cpp
View File

@ -6,45 +6,61 @@
namespace metaforce {
static u32 ReadCount(CInputStream& in) {
u32 result = in.readUint32Big();
if (result == UINT32_MAX) {
return in.readUint32Big();
}
in.seek(s64(result) * 3);
return result;
}
CSkinRules::CSkinRules(CInputStream& in) {
u32 bankCount = in.readUint32Big();
x0_skinBanks.reserve(bankCount);
for (u32 i = 0; i < bankCount; ++i)
x0_skinBanks.emplace_back(in);
u32 virtualBoneCount = in.readUint32Big();
m_virtualBones.reserve(virtualBoneCount);
for (u32 i = 0; i < virtualBoneCount; ++i)
m_virtualBones.emplace_back(in);
u32 poolSz = in.readUint32Big();
m_poolToSkinIdx.reserve(poolSz);
for (u32 i = 0; i < poolSz; ++i)
m_poolToSkinIdx.push_back(in.readUint32Big());
u32 weightCount = in.readUint32Big();
x0_bones.reserve(weightCount);
for (int i = 0; i < weightCount; ++i) {
x0_bones.emplace_back(in);
}
x10_vertexCount = ReadCount(in);
x14_normalCount = ReadCount(in);
}
void CSkinRules::TransformVerticesCPU(std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vnOut,
const CPoseAsTransforms& pose, const CModel& model) const {
OPTICK_EVENT();
vnOut.resize(m_poolToSkinIdx.size());
for (size_t i = 0; i < m_poolToSkinIdx.size(); ++i) {
const CVirtualBone& vb = m_virtualBones[m_poolToSkinIdx[i]];
zeus::CVector3f origVertex = model.GetPoolVertex(i);
zeus::CVector3f vertex;
zeus::CVector3f origNormal = model.GetPoolNormal(i);
zeus::CVector3f normal;
for (const SSkinWeighting& w : vb.GetWeights()) {
const zeus::CTransform& xf = pose.GetRestToAccumTransform(w.m_id);
vertex += (xf * origVertex) * w.m_weight;
normal += (xf.basis.inverted().transposed() * origNormal) * w.m_weight;
}
vnOut[i] = std::make_pair(vertex, normal.normalized());
}
}
// void CSkinRules::TransformVerticesCPU(std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vnOut,
// const CPoseAsTransforms& pose, const CModel& model) const {
// OPTICK_EVENT();
// vnOut.resize(m_poolToSkinIdx.size());
// for (size_t i = 0; i < m_poolToSkinIdx.size(); ++i) {
// const CVirtualBone& vb = m_virtualBones[m_poolToSkinIdx[i]];
// zeus::CVector3f origVertex = model.GetPoolVertex(i);
// zeus::CVector3f vertex;
// zeus::CVector3f origNormal = model.GetPoolNormal(i);
// zeus::CVector3f normal;
// for (const SSkinWeighting& w : vb.GetWeights()) {
// const zeus::CTransform& xf = pose.GetRestToAccumTransform(w.m_id);
// vertex += (xf * origVertex) * w.m_weight;
// normal += (xf.basis.inverted().transposed() * origNormal) * w.m_weight;
// }
// vnOut[i] = std::make_pair(vertex, normal.normalized());
// }
// }
CFactoryFnReturn FSkinRulesFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer& params,
CObjectReference* selfRef) {
return TToken<CSkinRules>::GetIObjObjectFor(std::make_unique<CSkinRules>(in));
}
auto StreamInSkinWeighting(CInputStream& in) {
rstl::reserved_vector<SSkinWeighting, 3> weights;
u32 weightCount = in.readUint32Big();
for (int i = 0; i < std::min(3u, weightCount); ++i) {
weights.emplace_back(in);
}
for (int i = 3; i < weightCount; ++i) {
SSkinWeighting{in};
}
return weights;
}
CVirtualBone::CVirtualBone(CInputStream& in)
: x0_weights(StreamInSkinWeighting(in)), x1c_vertexCount(in.readUint32Big()) {}
} // namespace metaforce

51
Runtime/Character/CSkinRules.hpp
View File

@ -3,10 +3,9 @@
#include <vector>
#include "Runtime/CFactoryMgr.hpp"
#include "Runtime/RetroTypes.hpp"
#include "Runtime/Character/CSkinBank.hpp"
#include "Runtime/RetroTypes.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CVector3f.hpp>
namespace metaforce {
@ -14,46 +13,42 @@ class CPoseAsTransforms;
class CModel;
struct SSkinWeighting {
CSegId m_id;
float m_weight;
explicit SSkinWeighting(CInputStream& in) : m_id(in), m_weight(in.readFloatBig()) {}
CSegId x0_id;
float x4_weight;
explicit SSkinWeighting(CInputStream& in) : x0_id(in), x4_weight(in.readFloatBig()) {}
};
class CVirtualBone {
std::vector<SSkinWeighting> m_weights;
rstl::reserved_vector<SSkinWeighting, 3> x0_weights;
u32 x1c_vertexCount;
zeus::CTransform x20_xf;
zeus::CMatrix3f x50_mtx;
public:
explicit CVirtualBone(CInputStream& in) {
u32 weightCount = in.readUint32Big();
m_weights.reserve(weightCount);
for (u32 i = 0; i < weightCount; ++i)
m_weights.emplace_back(in);
}
explicit CVirtualBone(CInputStream& in);
const std::vector<SSkinWeighting>& GetWeights() const { return m_weights; }
[[nodiscard]] const rstl::reserved_vector<SSkinWeighting, 3>& GetWeights() const { return x0_weights; }
};
class CSkinRules {
std::vector<CSkinBank> x0_skinBanks;
// u32 x10_vertexCount;
// u32 x14_normalCount;
std::vector<CVirtualBone> m_virtualBones;
std::vector<u32> m_poolToSkinIdx;
std::vector<CVirtualBone> x0_bones;
u32 x10_vertexCount;
u32 x14_normalCount;
public:
explicit CSkinRules(CInputStream& in);
void GetBankTransforms(std::vector<const zeus::CTransform*>& out, const CPoseAsTransforms& pose,
int skinBankIdx) const {
// FIXME: This is definitely not proper behavior, this is here to fix the phazon suit crashing
if (x0_skinBanks.size() <= skinBankIdx) {
return;
}
x0_skinBanks[skinBankIdx].GetBankTransforms(out, pose);
}
// void GetBankTransforms(std::vector<const zeus::CTransform*>& out, const CPoseAsTransforms& pose,
// int skinBankIdx) const {
// // FIXME: This is definitely not proper behavior, this is here to fix the phazon suit crashing
// if (x0_skinBanks.size() <= skinBankIdx) {
// return;
// }
// x0_skinBanks[skinBankIdx].GetBankTransforms(out, pose);
// }
void TransformVerticesCPU(std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vnOut,
const CPoseAsTransforms& pose, const CModel& model) const;
// void TransformVerticesCPU(std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vnOut,
// const CPoseAsTransforms& pose, const CModel& model) const;
};
CFactoryFnReturn FSkinRulesFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer& params,

298
Runtime/Graphics/CBooRenderer.cpp
View File

@ -410,8 +410,7 @@ void CBooRenderer::DrawFogSlices(const zeus::CPlane* planes, size_t numPlanes, s
}
void CBooRenderer::RenderFogVolumeModel(const zeus::CAABox& aabb, const CModel* model, const zeus::CTransform& modelMtx,
const zeus::CTransform& viewMtx, const CSkinnedModel* sModel, int pass,
CFogVolumePlaneShader* fvs) {
const zeus::CTransform& viewMtx, const CSkinnedModel* sModel, int pass) {
if (!model && !sModel) {
if (pass == 0) {
zeus::CAABox xfAABB = aabb.getTransformedAABox(modelMtx);
@ -432,13 +431,14 @@ void CBooRenderer::RenderFogVolumeModel(const zeus::CAABox& aabb, const CModel*
xfAABB.max.z() - xfAABB.min.z()) *
2.f;
fvs->reset(7 * 6);
CFogVolumePlaneShader fvs;
fvs.reset(7 * 6);
for (size_t i = 0; i < planes.size(); ++i) {
DrawFogSlices(planes.data(), planes.size(), i, xfAABB.center(), longestAxis, *fvs);
DrawFogSlices(planes.data(), planes.size(), i, xfAABB.center(), longestAxis, fvs);
}
fvs->draw(0);
aurora::shaders::queue_fog_volume_plane(fvs.m_verts, 0);
} else {
fvs->draw(pass);
aurora::shaders::queue_fog_volume_plane({}, pass);
}
} else {
CModelFlags flags;
@ -547,140 +547,132 @@ void CBooRenderer::ReallyRenderFogVolume(const zeus::CColor& color, const zeus::
zeus::CAABox marginAABB((CGraphics::g_GXModelView * aabb.min) - 1.f, (CGraphics::g_GXModelView * aabb.max) + 1.f);
bool camInModel = marginAABB.pointInside(CGraphics::g_ViewMatrix.origin) && (model || sModel);
CFogVolumePlaneShader* fvs;
if (!model && !sModel) {
fvs = &*((m_nextFogVolumePlaneShader == m_fogVolumePlaneShaders.end())
? m_fogVolumePlaneShaders.insert(m_fogVolumePlaneShaders.end(), CFogVolumePlaneShader())
: m_nextFogVolumePlaneShader++);
} else {
fvs = nullptr;
}
// CFogVolumePlaneShader* fvs;
// if (!model && !sModel) {
// fvs = &*((m_nextFogVolumePlaneShader == m_fogVolumePlaneShaders.end())
// ? m_fogVolumePlaneShaders.insert(m_fogVolumePlaneShaders.end(), CFogVolumePlaneShader())
// : m_nextFogVolumePlaneShader++);
// } else {
// fvs = nullptr;
// }
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 0, fvs);
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 0);
if (camInModel)
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 1, fvs);
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 1);
CGraphics::ResolveSpareDepth(rect, 0);
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 2, fvs);
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 2);
if (camInModel)
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 3, fvs);
RenderFogVolumeModel(aabb, model, CGraphics::g_GXModelMatrix, CGraphics::g_ViewMatrix, sModel, 3);
CGraphics::ResolveSpareDepth(rect, 1);
auto fvf = (m_nextFogVolumeFilter == m_fogVolumeFilters.end())
? m_fogVolumeFilters.insert(m_fogVolumeFilters.end(), CFogVolumeFilter())
: m_nextFogVolumeFilter++;
fvf->draw2WayPass(color);
aurora::shaders::queue_fog_volume_filter(color, true);
if (camInModel)
fvf->draw1WayPass(color);
aurora::shaders::queue_fog_volume_filter(color, false);
// CGraphics::SetScissor(g_Viewport.x0_left, g_Viewport.x4_top, g_Viewport.x8_width, g_Viewport.xc_height);
}
void CBooRenderer::GenerateFogVolumeRampTex(boo::IGraphicsDataFactory::Context& ctx) {
std::array<std::array<u16, FOGVOL_RAMP_RES>, FOGVOL_RAMP_RES> data{};
for (size_t y = 0; y < data.size(); ++y) {
for (size_t x = 0; x < data[y].size(); ++x) {
const int tmp = int(y << 16 | x << 8 | 0x7f);
const double a =
zeus::clamp(0.0,
(-150.0 / (tmp / double(0xffffff) * (FOGVOL_FAR - FOGVOL_NEAR) - FOGVOL_FAR) - FOGVOL_NEAR) *
3.0 / (FOGVOL_FAR - FOGVOL_NEAR),
1.0);
data[y][x] = u16((a * a + a) / 2.0 * 65535);
}
}
x1b8_fogVolumeRamp =
ctx.newStaticTexture(FOGVOL_RAMP_RES, FOGVOL_RAMP_RES, 1, boo::TextureFormat::I16, boo::TextureClampMode::Repeat,
data[0].data(), FOGVOL_RAMP_RES * FOGVOL_RAMP_RES * 2);
}
//void CBooRenderer::GenerateFogVolumeRampTex() {
// std::array<std::array<float, FOGVOL_RAMP_RES>, FOGVOL_RAMP_RES> data{};
// for (size_t y = 0; y < data.size(); ++y) {
// for (size_t x = 0; x < data[y].size(); ++x) {
// const int tmp = int(y << 16 | x << 8 | 0x7f);
// const double a =
// zeus::clamp(0.0,
// (-150.0 / (tmp / double(0xffffff) * (FOGVOL_FAR - FOGVOL_NEAR) - FOGVOL_FAR) - FOGVOL_NEAR) *
// 3.0 / (FOGVOL_FAR - FOGVOL_NEAR),
// 1.0);
// data[y][x] = (a * a + a) / 2.0;
// }
// }
// x1b8_fogVolumeRamp =
// aurora::new_static_texture_2d(FOGVOL_RAMP_RES, FOGVOL_RAMP_RES, 1, aurora::shaders::TextureFormat::R32Float,
// {data[0].data(), FOGVOL_RAMP_RES * FOGVOL_RAMP_RES * 2});
//}
//
//void CBooRenderer::GenerateSphereRampTex() {
// std::array<std::array<u8, SPHERE_RAMP_RES>, SPHERE_RAMP_RES> data{};
// constexpr float halfRes = SPHERE_RAMP_RES / 2.f;
// for (size_t y = 0; y < data.size(); ++y) {
// for (size_t x = 0; x < data[y].size(); ++x) {
// const zeus::CVector2f vec((float(x) - halfRes) / halfRes, (float(y) - halfRes) / halfRes);
// data[y][x] = 255 - zeus::clamp(0.f, vec.canBeNormalized() ? vec.magnitude() : 0.f, 1.f) * 255;
// }
// }
// x220_sphereRamp =
// aurora::new_static_texture_2d(SPHERE_RAMP_RES, SPHERE_RAMP_RES, 1, aurora::shaders::TextureFormat::R8,
// {data[0].data(), SPHERE_RAMP_RES * SPHERE_RAMP_RES});
//}
//
//void CBooRenderer::GenerateScanLinesVBO() {
// std::vector<zeus::CVector3f> verts;
// verts.reserve(670);
//
// for (int i = 0; i < 112; ++i) {
// verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
// if (i != 0) {
// verts.emplace_back(verts.back());
// }
// verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) - (1.f / 448.f)) * 2.f - 1.f, 0.f);
// verts.emplace_back(1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
// verts.emplace_back(1.f, (float(i) * (4.f / 448.f) - (1.f / 448.f)) * 2.f - 1.f, 0.f);
// if (i != 111) {
// verts.emplace_back(verts.back());
// }
// }
//
// m_scanLinesEvenVBO = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(zeus::CVector3f), verts.size());
//
// verts.clear();
//
// for (int i = 0; i < 112; ++i) {
// verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) + (3.f / 448.f)) * 2.f - 1.f, 0.f);
// if (i != 0) {
// verts.emplace_back(verts.back());
// }
// verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
// verts.emplace_back(1.f, (float(i) * (4.f / 448.f) + (3.f / 448.f)) * 2.f - 1.f, 0.f);
// verts.emplace_back(1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
// if (i != 111) {
// verts.emplace_back(verts.back());
// }
// }
//
// m_scanLinesOddVBO = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(zeus::CVector3f), verts.size());
//}
void CBooRenderer::GenerateSphereRampTex(boo::IGraphicsDataFactory::Context& ctx) {
std::array<std::array<u8, SPHERE_RAMP_RES>, SPHERE_RAMP_RES> data{};
constexpr float halfRes = SPHERE_RAMP_RES / 2.f;
for (size_t y = 0; y < data.size(); ++y) {
for (size_t x = 0; x < data[y].size(); ++x) {
const zeus::CVector2f vec((float(x) - halfRes) / halfRes, (float(y) - halfRes) / halfRes);
data[y][x] = 255 - zeus::clamp(0.f, vec.canBeNormalized() ? vec.magnitude() : 0.f, 1.f) * 255;
}
}
x220_sphereRamp =
ctx.newStaticTexture(SPHERE_RAMP_RES, SPHERE_RAMP_RES, 1, boo::TextureFormat::I8,
boo::TextureClampMode::ClampToEdge, data[0].data(), SPHERE_RAMP_RES * SPHERE_RAMP_RES);
}
void CBooRenderer::GenerateScanLinesVBO(boo::IGraphicsDataFactory::Context& ctx) {
std::vector<zeus::CVector3f> verts;
verts.reserve(670);
for (int i = 0; i < 112; ++i) {
verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
if (i != 0) {
verts.emplace_back(verts.back());
}
verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) - (1.f / 448.f)) * 2.f - 1.f, 0.f);
verts.emplace_back(1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
verts.emplace_back(1.f, (float(i) * (4.f / 448.f) - (1.f / 448.f)) * 2.f - 1.f, 0.f);
if (i != 111) {
verts.emplace_back(verts.back());
}
}
m_scanLinesEvenVBO = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(zeus::CVector3f), verts.size());
verts.clear();
for (int i = 0; i < 112; ++i) {
verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) + (3.f / 448.f)) * 2.f - 1.f, 0.f);
if (i != 0) {
verts.emplace_back(verts.back());
}
verts.emplace_back(-1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
verts.emplace_back(1.f, (float(i) * (4.f / 448.f) + (3.f / 448.f)) * 2.f - 1.f, 0.f);
verts.emplace_back(1.f, (float(i) * (4.f / 448.f) + (1.f / 448.f)) * 2.f - 1.f, 0.f);
if (i != 111) {
verts.emplace_back(verts.back());
}
}
m_scanLinesOddVBO = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(zeus::CVector3f), verts.size());
}
boo::ObjToken<boo::ITexture> CBooRenderer::GetColorTexture(const zeus::CColor& color) {
std::shared_ptr<aurora::TextureHandle> CBooRenderer::GetColorTexture(const zeus::CColor& color) {
const auto search = m_colorTextures.find(color);
if (search != m_colorTextures.end()) {
return search->second;
}
std::array<u8, 4> pixel;
std::array<u8, 4> pixel{};
color.toRGBA8(pixel[0], pixel[1], pixel[2], pixel[3]);
boo::ObjToken<boo::ITexture> tex;
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
tex = ctx.newStaticTexture(1, 1, 1, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat, pixel.data(),
pixel.size())
.get();
return true;
} BooTrace);
auto tex = aurora::new_static_texture_2d(1, 1, 1, aurora::shaders::TextureFormat::RGBA8, {pixel.data(), pixel.size()},
"Color Texture"sv);
m_colorTextures.emplace(color, tex);
return tex;
}
void CBooRenderer::LoadThermoPalette() {
m_thermoPaletteTex = xc_store.GetObj("TXTR_ThermoPalette");
CTexture* thermoTexObj = m_thermoPaletteTex.GetObj();
if (thermoTexObj)
x288_thermoPalette = thermoTexObj->GetPaletteTexture();
}
void CBooRenderer::LoadBallFade() {
m_ballFadeTex = xc_store.GetObj("TXTR_BallFade");
CTexture* ballFadeTexObj = m_ballFadeTex.GetObj();
if (ballFadeTexObj) {
m_ballFade = ballFadeTexObj->GetBooTexture();
m_ballFade->setClampMode(boo::TextureClampMode::ClampToEdge);
}
}
//void CBooRenderer::LoadThermoPalette() {
// m_thermoPaletteTex = xc_store.GetObj("TXTR_ThermoPalette");
// CTexture* thermoTexObj = m_thermoPaletteTex.GetObj();
// if (thermoTexObj)
// x288_thermoPalette = thermoTexObj->GetPaletteTexture();
//}
//
//void CBooRenderer::LoadBallFade() {
// m_ballFadeTex = xc_store.GetObj("TXTR_BallFade");
// CTexture* ballFadeTexObj = m_ballFadeTex.GetObj();
// if (ballFadeTexObj) {
// m_ballFade = ballFadeTexObj->GetBooTexture();
// m_ballFade->setClampMode(boo::TextureClampMode::ClampToEdge);
// }
//}
CBooRenderer::CBooRenderer(IObjectStore& store, IFactory& resFac)
: x8_factory(resFac), xc_store(store), x2a8_thermalRand(20) {
@ -688,36 +680,32 @@ CBooRenderer::CBooRenderer(IObjectStore& store, IFactory& resFac)
m_staticEntropy = store.GetObj("RandomStaticEntropy");
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
constexpr std::array<u8, 4> clearPixel{0, 0, 0, 0};
m_clearTexture = ctx.newStaticTexture(1, 1, 1, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
clearPixel.data(), clearPixel.size())
.get();
m_clearTexture = aurora::new_static_texture_2d(1, 1, 1, aurora::shaders::TextureFormat::RGBA8,
{clearPixel.data(), clearPixel.size()}, "Clear Texture"sv);
constexpr std::array<u8, 4> blackPixel{0, 0, 0, 255};
m_blackTexture = ctx.newStaticTexture(1, 1, 1, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
blackPixel.data(), blackPixel.size())
.get();
m_blackTexture = aurora::new_static_texture_2d(1, 1, 1, aurora::shaders::TextureFormat::RGBA8,
{blackPixel.data(), blackPixel.size()}, "Black Texture"sv);
constexpr std::array<u8, 4> whitePixel{255, 255, 255, 255};
m_whiteTexture = ctx.newStaticTexture(1, 1, 1, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
whitePixel.data(), whitePixel.size())
.get();
m_whiteTexture = aurora::new_static_texture_2d(1, 1, 1, aurora::shaders::TextureFormat::RGBA8,
{whitePixel.data(), whitePixel.size()}, "White Texture"sv);
GenerateFogVolumeRampTex(ctx);
GenerateSphereRampTex(ctx);
m_ballShadowId = ctx.newRenderTexture(m_ballShadowIdW, m_ballShadowIdH, boo::TextureClampMode::Repeat, 1, 0);
x14c_reflectionTex = ctx.newRenderTexture(256, 256, boo::TextureClampMode::ClampToBlack, 1, 0);
GenerateScanLinesVBO(ctx);
return true;
} BooTrace);
LoadThermoPalette();
LoadBallFade();
// GenerateFogVolumeRampTex();
// GenerateSphereRampTex();
m_ballShadowId = aurora::new_render_texture(m_ballShadowIdW, m_ballShadowIdH, 1, 0, "Ball Shadow");
// m_ballShadowId = ctx.newRenderTexture(m_ballShadowIdW, m_ballShadowIdH, boo::TextureClampMode::Repeat, 1, 0);
x14c_reflectionTex = aurora::new_render_texture(256, 256, 1, 0, "Reflection");
// x14c_reflectionTex = ctx.newRenderTexture(256, 256, boo::TextureClampMode::ClampToBlack, 1, 0);
// GenerateScanLinesVBO();
// LoadThermoPalette();
// LoadBallFade();
m_thermColdFilter.emplace();
m_thermHotFilter.emplace();
Buckets::Init();
m_nextFogVolumePlaneShader = m_fogVolumePlaneShaders.end();
m_nextFogVolumeFilter = m_fogVolumeFilters.end();
// m_nextFogVolumePlaneShader = m_fogVolumePlaneShaders.end();
// m_nextFogVolumeFilter = m_fogVolumeFilters.end();
}
CBooRenderer::~CBooRenderer() { g_Renderer = nullptr; }
@ -792,23 +780,20 @@ void CBooRenderer::UpdateAreaUniforms(int areaIdx, EWorldShadowMode shadowMode,
if (areaIdx != -1 && item.x18_areaIdx != areaIdx)
continue;
item.m_shaderSet->m_geomLayout->Update(flags, nullptr, nullptr, &item.m_shaderSet->m_matSet,
item.m_shaderSet->m_geomLayout->GetSharedBuffer(bufIdx), nullptr);
// item.m_shaderSet->m_geomLayout->Update(flags, nullptr, nullptr, &item.m_shaderSet->m_matSet,
// item.m_shaderSet->m_geomLayout->GetSharedBuffer(bufIdx), nullptr);
if (shadowMode == EWorldShadowMode::BallOnWorldShadow || shadowMode == EWorldShadowMode::BallOnWorldIds)
continue;
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
for (auto it = item.x10_models.begin(); it != item.x10_models.end(); ++it) {
CBooModel* model = *it;
if (model->TryLockTextures()) {
if (activateLights)
ActivateLightsForModel(&item, *model);
model->UpdateUniformData(flags, nullptr, nullptr, bufIdx, &ctx);
// model->UpdateUniformData(flags, nullptr, nullptr, bufIdx);
}
}
return true;
} BooTrace);
}
}
@ -1084,8 +1069,8 @@ void CBooRenderer::BeginScene() {
x318_26_requestRGBA6 = false;
// GXSetPixelFmt(x318_27_currentRGBA6);
CGraphics::BeginScene();
m_nextFogVolumePlaneShader = m_fogVolumePlaneShaders.begin();
m_nextFogVolumeFilter = m_fogVolumeFilters.begin();
// m_nextFogVolumePlaneShader = m_fogVolumePlaneShaders.begin();
// m_nextFogVolumeFilter = m_fogVolumeFilters.begin();
}
void CBooRenderer::EndScene() {
@ -1111,15 +1096,16 @@ void CBooRenderer::CacheReflection(TReflectionCallback cb, void* ctx, bool clear
x318_24_refectionDirty = false;
x2dc_reflectionAge = 0;
BindReflectionDrawTarget();
SViewport backupVp = g_Viewport;
SetViewport(0, 0, 256, 256);
CGraphics::g_BooMainCommandQueue->clearTarget();
cb(ctx, CBooModel::g_ReflectViewPos);
boo::SWindowRect rect(0, 0, 256, 256);
CGraphics::g_BooMainCommandQueue->resolveBindTexture(x14c_reflectionTex, rect, false, 0, true, false);
BindMainDrawTarget();
SetViewport(backupVp.x0_left, backupVp.x4_top, backupVp.x8_width, backupVp.xc_height);
// TODO
// BindReflectionDrawTarget();
// SViewport backupVp = g_Viewport;
// SetViewport(0, 0, 256, 256);
// CGraphics::g_BooMainCommandQueue->clearTarget();
// cb(ctx, CBooModel::g_ReflectViewPos);
// boo::SWindowRect rect(0, 0, 256, 256);
// CGraphics::g_BooMainCommandQueue->resolveBindTexture(x14c_reflectionTex, rect, false, 0, true, false);
// BindMainDrawTarget();
// SetViewport(backupVp.x0_left, backupVp.x4_top, backupVp.x8_width, backupVp.xc_height);
}
void CBooRenderer::DrawSpaceWarp(const zeus::CVector3f& pt, float strength) {
@ -1152,7 +1138,7 @@ void CBooRenderer::DrawXRayOutline(const zeus::CAABox& aabb) {
for (u32 b = 0; b < 32; ++b) {
if ((bitmap[c] & (1U << b)) != 0) {
CBooModel* model = item.x10_models[c * 32 + b];
model->UpdateUniformData(flags, nullptr, nullptr);
// model->UpdateUniformData(flags, nullptr, nullptr);
const CBooSurface* surf = model->x38_firstUnsortedSurface;
while (surf) {
if (surf->GetBounds().intersects(aabb))
@ -1362,7 +1348,7 @@ int CBooRenderer::DrawOverlappingWorldModelIDs(int alphaVal, const std::vector<u
flags.x4_color.a() = static_cast<float>(alphaVal) / 255.f;
CBooModel& model = *item.x10_models[wordModel + j];
model.UpdateUniformData(flags, nullptr, nullptr, 3);
// model.UpdateUniformData(flags, nullptr, nullptr, 3);
model.VerifyCurrentShader(0);
for (const CBooSurface* surf = model.x38_firstUnsortedSurface; surf; surf = surf->m_next) {
if (surf->GetBounds().intersects(aabb)) {
@ -1409,7 +1395,7 @@ void CBooRenderer::DrawOverlappingWorldModelShadows(int alphaVal, const std::vec
flags.x4_color.r() = static_cast<float>(alphaVal) / 255.f;
CBooModel& model = *item.x10_models[wordModel + j];
model.UpdateUniformData(flags, nullptr, nullptr, 2);
// model.UpdateUniformData(flags, nullptr, nullptr, 2);
model.VerifyCurrentShader(0);
for (const CBooSurface* surf = model.x38_firstUnsortedSurface; surf; surf = surf->m_next)
if (surf->GetBounds().intersects(aabb))

81
Runtime/Graphics/CBooRenderer.hpp
View File

@ -101,31 +101,31 @@ class CBooRenderer final : public IRenderer {
// boo::ITextureS* xe4_blackTex = nullptr;
bool xee_24_ : 1 = true;
boo::ObjToken<boo::ITexture> m_clearTexture;
boo::ObjToken<boo::ITexture> m_blackTexture;
boo::ObjToken<boo::ITexture> m_whiteTexture;
std::unordered_map<zeus::CColor, boo::ObjToken<boo::ITexture>> m_colorTextures;
std::shared_ptr<aurora::TextureHandle> m_clearTexture;
std::shared_ptr<aurora::TextureHandle> m_blackTexture;
std::shared_ptr<aurora::TextureHandle> m_whiteTexture;
std::unordered_map<zeus::CColor, std::shared_ptr<aurora::TextureHandle>> m_colorTextures;
boo::ObjToken<boo::ITextureR> x14c_reflectionTex;
std::shared_ptr<aurora::TextureHandle> x14c_reflectionTex;
// boo::ITextureS* x150_mirrorRamp = nullptr;
boo::ObjToken<boo::ITextureS> x1b8_fogVolumeRamp;
boo::ObjToken<boo::ITextureS> x220_sphereRamp;
TLockedToken<CTexture> m_thermoPaletteTex;
boo::ObjToken<boo::ITexture> x288_thermoPalette;
TLockedToken<CTexture> m_ballFadeTex;
boo::ObjToken<boo::ITexture> m_ballFade;
boo::ObjToken<boo::ITextureR> m_ballShadowId;
boo::ObjToken<boo::IGraphicsBufferS> m_scanLinesEvenVBO;
boo::ObjToken<boo::IGraphicsBufferS> m_scanLinesOddVBO;
// std::shared_ptr<aurora::TextureHandle> x1b8_fogVolumeRamp;
std::shared_ptr<aurora::TextureHandle> x220_sphereRamp;
// TLockedToken<CTexture> m_thermoPaletteTex;
// std::shared_ptr<aurora::TextureHandle> x288_thermoPalette;
// TLockedToken<CTexture> m_ballFadeTex;
std::shared_ptr<aurora::TextureHandle> m_ballFade;
std::shared_ptr<aurora::TextureHandle> m_ballShadowId;
// boo::ObjToken<boo::IGraphicsBufferS> m_scanLinesEvenVBO;
// boo::ObjToken<boo::IGraphicsBufferS> m_scanLinesOddVBO;
int m_ballShadowIdW = 64;
int m_ballShadowIdH = 64;
CRandom16 x2a8_thermalRand;
std::list<CFogVolumeListItem> x2ac_fogVolumes;
std::list<CFogVolumePlaneShader> m_fogVolumePlaneShaders;
std::list<CFogVolumePlaneShader>::iterator m_nextFogVolumePlaneShader;
std::list<CFogVolumeFilter> m_fogVolumeFilters;
std::list<CFogVolumeFilter>::iterator m_nextFogVolumeFilter;
// std::list<CFogVolumePlaneShader> m_fogVolumePlaneShaders;
// std::list<CFogVolumePlaneShader>::iterator m_nextFogVolumePlaneShader;
// std::list<CFogVolumeFilter> m_fogVolumeFilters;
// std::list<CFogVolumeFilter>::iterator m_nextFogVolumeFilter;
std::list<std::pair<zeus::CVector3f, float>> x2c4_spaceWarps;
u32 x2dc_reflectionAge = 2;
zeus::CColor x2e0_ = zeus::skWhite;
@ -156,11 +156,11 @@ class CBooRenderer final : public IRenderer {
bool x318_31_persistRGBA6 : 1 = false;
bool m_thermalHotPass : 1 = false;
void GenerateFogVolumeRampTex(boo::IGraphicsDataFactory::Context& ctx);
void GenerateSphereRampTex(boo::IGraphicsDataFactory::Context& ctx);
void GenerateScanLinesVBO(boo::IGraphicsDataFactory::Context& ctx);
void LoadThermoPalette();
void LoadBallFade();
// void GenerateFogVolumeRampTex();
// void GenerateSphereRampTex();
// void GenerateScanLinesVBO();
// void LoadThermoPalette();
// void LoadBallFade();
void ActivateLightsForModel(CAreaListItem* item, CBooModel& model);
void RenderBucketItems(CAreaListItem* item);
@ -170,8 +170,7 @@ class CBooRenderer final : public IRenderer {
static void DrawFogSlices(const zeus::CPlane* planes, size_t numPlanes, size_t iteration,
const zeus::CVector3f& center, float delta, CFogVolumePlaneShader& fogVol);
static void RenderFogVolumeModel(const zeus::CAABox& aabb, const CModel* model, const zeus::CTransform& modelMtx,
const zeus::CTransform& viewMtx, const CSkinnedModel* sModel, int pass,
CFogVolumePlaneShader* fvs);
const zeus::CTransform& viewMtx, const CSkinnedModel* sModel, int pass);
void SetupRendererStates() const;
void ReallyDrawPhazonSuitIndirectEffect(const zeus::CColor& vertColor, /*const CTexture& maskTex,*/
@ -264,27 +263,31 @@ public:
void ReallyRenderFogVolume(const zeus::CColor& color, const zeus::CAABox& aabb, const CModel* model,
const CSkinnedModel* sModel);
const boo::ObjToken<boo::ITexture>& GetThermoPalette() const { return x288_thermoPalette; }
const boo::ObjToken<boo::ITextureS>& GetFogRampTex() const { return x1b8_fogVolumeRamp; }
const boo::ObjToken<boo::ITexture>& GetRandomStaticEntropyTex() const { return m_staticEntropy->GetBooTexture(); }
const boo::ObjToken<boo::IGraphicsBufferS>& GetScanLinesEvenVBO() const { return m_scanLinesEvenVBO; }
const boo::ObjToken<boo::IGraphicsBufferS>& GetScanLinesOddVBO() const { return m_scanLinesOddVBO; }
// const boo::ObjToken<boo::ITexture>& GetThermoPalette() const { return x288_thermoPalette; }
// const boo::ObjToken<boo::ITextureS>& GetFogRampTex() const { return x1b8_fogVolumeRamp; }
// const boo::ObjToken<boo::ITexture>& GetRandomStaticEntropyTex() const { return m_staticEntropy->GetBooTexture(); }
// const boo::ObjToken<boo::IGraphicsBufferS>& GetScanLinesEvenVBO() const { return m_scanLinesEvenVBO; }
// const boo::ObjToken<boo::IGraphicsBufferS>& GetScanLinesOddVBO() const { return m_scanLinesOddVBO; }
const boo::ObjToken<boo::ITexture>& GetClearTexture() const { return m_clearTexture; }
const boo::ObjToken<boo::ITexture>& GetBlackTexture() const { return m_blackTexture; }
const boo::ObjToken<boo::ITexture>& GetWhiteTexture() const { return m_whiteTexture; }
const std::shared_ptr<aurora::TextureHandle>& GetClearTexture() const { return m_clearTexture; }
const std::shared_ptr<aurora::TextureHandle>& GetBlackTexture() const { return m_blackTexture; }
const std::shared_ptr<aurora::TextureHandle>& GetWhiteTexture() const { return m_whiteTexture; }
boo::ObjToken<boo::ITexture> GetColorTexture(const zeus::CColor& color);
std::shared_ptr<aurora::TextureHandle> GetColorTexture(const zeus::CColor& color);
static void BindMainDrawTarget() { CGraphics::g_BooMainCommandQueue->setRenderTarget(CGraphics::g_SpareTexture); }
void BindReflectionDrawTarget() { CGraphics::g_BooMainCommandQueue->setRenderTarget(x14c_reflectionTex); }
static void BindMainDrawTarget() {
// CGraphics::g_BooMainCommandQueue->setRenderTarget(CGraphics::g_SpareTexture);
}
void BindReflectionDrawTarget() {
// CGraphics::g_BooMainCommandQueue->setRenderTarget(x14c_reflectionTex);
}
void BindBallShadowIdTarget() {
CGraphics::g_BooMainCommandQueue->setRenderTarget(m_ballShadowId);
// CGraphics::g_BooMainCommandQueue->setRenderTarget(m_ballShadowId);
SetViewport(0, 0, m_ballShadowIdW, m_ballShadowIdH);
}
void ResolveBallShadowIdTarget() {
CGraphics::g_BooMainCommandQueue->resolveBindTexture(
m_ballShadowId, boo::SWindowRect(0, 0, m_ballShadowIdW, m_ballShadowIdH), false, 0, true, false);
// CGraphics::g_BooMainCommandQueue->resolveBindTexture(
// m_ballShadowId, boo::SWindowRect(0, 0, m_ballShadowIdW, m_ballShadowIdH), false, 0, true, false);
}
void FindOverlappingWorldModels(std::vector<u32>& modelBits, const zeus::CAABox& aabb) const;

36
Runtime/Graphics/CCubeModel.cpp Normal file
View File

@ -0,0 +1,36 @@
#include "CCubeModel.hpp"
#include "CGraphics.hpp"
namespace metaforce {
static const u8* MemoryFromPartData(const u8*& dataCur, const u32*& secSizeCur) {
const u8* ret = nullptr;
if (*secSizeCur != 0) {
ret = dataCur;
}
dataCur += hecl::SBig(*secSizeCur);
++secSizeCur;
return ret;
}
CModel::CModel(std::unique_ptr<u8[]> in, u32 dataLen, IObjectStore* store)
: x0_data(std::move(in)), x4_dataLen(dataLen), x38_lastFrame(CGraphics::GetFrameCounter() - 2) {
const u8* data = reinterpret_cast<const u8*>(x0_data.get());
u32 uVar1 = *reinterpret_cast<const u32*>(data + 8);
u32 sectionSizeStart = 0x2c;
if (*reinterpret_cast<const u32*>(data + 4) == 1) {
sectionSizeStart = 0x28;
}
const u32* secSizeCur = reinterpret_cast<const u32*>(data + sectionSizeStart);
s32 numMatSets = 1;
if (*reinterpret_cast<const u32*>(data + 4) > 1) {
numMatSets = *reinterpret_cast<const s32*>(data + 0x28);
}
const auto* dataCur = data + (sectionSizeStart + *reinterpret_cast<const s32*>(data + 0x24) * 4 + 0x1f & 0xffffffe0);
x18_matSets.reserve(numMatSets);
for (int i = 0; i < numMatSets; i += 1) {
x18_matSets.emplace_back(
const_cast<CCubeModel*>(reinterpret_cast<const CCubeModel*>(MemoryFromPartData(dataCur, secSizeCur))));
}
}
} // namespace metaforce

37
Runtime/Graphics/CCubeModel.hpp Normal file
View File

@ -0,0 +1,37 @@
#pragma once
#include <memory>
#include <vector>
#include "GCNTypes.hpp"
#include "IObjectStore.hpp"
#include "CTexture.hpp"
#include "CToken.hpp"
namespace metaforce {
class CCubeSurface;
class CCubeModel;
struct SShader {
std::vector<TCachedToken<CTexture>> x0_textures;
CCubeModel* x10_model;
SShader(CCubeModel* model) : x10_model(model) {}
};
class CModel {
std::unique_ptr<u8[]> x0_data;
u32 x4_dataLen;
std::vector<CCubeSurface*> x8_surfaces;
std::vector<SShader> x18_matSets;
CCubeModel* x28_modelInst;
u16 x2c_;
u16 x2e_;
CModel* x30_next;
CModel* x34_prev;
u32 x38_lastFrame;
public:
CModel(std::unique_ptr<u8[]> in, u32 dataLen, IObjectStore* store);
};
} // namespace metaforce

123
Runtime/Graphics/CGraphics.cpp
View File

@ -37,7 +37,7 @@ u32 CGraphics::g_FrameCounter = 0;
u32 CGraphics::g_Framerate = 0;
u32 CGraphics::g_FramesPast = 0;
frame_clock::time_point CGraphics::g_FrameStartTime = frame_clock::now();
bool CGraphics::g_commitAsLazy = false;
//bool CGraphics::g_commitAsLazy = false;
const std::array<zeus::CMatrix3f, 6> CGraphics::skCubeBasisMats{{
/* Right */
@ -127,7 +127,7 @@ void CGraphics::EndScene() {
CTextSupportShader::UpdateBuffers();
/* Same with line renderer */
CLineRenderer::UpdateBuffers();
// CLineRenderer::UpdateBuffers();
++g_FrameCounter;
@ -156,6 +156,7 @@ void CGraphics::SetViewMatrix() {
g_GXModelViewInvXpose.origin.zeroOut();
g_GXModelViewInvXpose.basis.transpose();
/* Load normal matrix */
aurora::shaders::update_model_view(g_GXModelView.toMatrix4f(), g_GXModelViewInvXpose.toMatrix4f());
}
void CGraphics::SetModelMatrix(const zeus::CTransform& xf) {
@ -192,24 +193,24 @@ zeus::CMatrix4f CGraphics::CalculatePerspectiveMatrix(float fovy, float aspect,
0.f, 0.f, -fpn / fmn, -2.f * st.x18_far * st.x14_near / fmn, 0.f, 0.f, -1.f, 0.f);
}
switch (g_BooPlatform) {
case boo::IGraphicsDataFactory::Platform::OpenGL:
default: {
return zeus::CMatrix4f(2.f * st.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * st.x14_near / tmb, tpb / tmb, 0.f,
0.f, 0.f, -fpn / fmn, -2.f * st.x18_far * st.x14_near / fmn, 0.f, 0.f, -1.f, 0.f);
}
case boo::IGraphicsDataFactory::Platform::D3D11:
case boo::IGraphicsDataFactory::Platform::Metal: {
// switch (g_BooPlatform) {
// case boo::IGraphicsDataFactory::Platform::OpenGL:
// default: {
// return zeus::CMatrix4f(2.f * st.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * st.x14_near / tmb, tpb / tmb, 0.f,
// 0.f, 0.f, -fpn / fmn, -2.f * st.x18_far * st.x14_near / fmn, 0.f, 0.f, -1.f, 0.f);
// }
// case boo::IGraphicsDataFactory::Platform::D3D11:
// case boo::IGraphicsDataFactory::Platform::Metal: {
zeus::CMatrix4f mat2(2.f * st.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * st.x14_near / tmb, tpb / tmb, 0.f,
0.f, 0.f, st.x18_far / fmn, st.x14_near * st.x18_far / fmn, 0.f, 0.f, -1.f, 0.f);
return PlusOneZ * mat2;
}
case boo::IGraphicsDataFactory::Platform::Vulkan: {
zeus::CMatrix4f mat2(2.f * st.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * st.x14_near / tmb, tpb / tmb, 0.f,
0.f, 0.f, -fpn / fmn, -2.f * st.x18_far * st.x14_near / fmn, 0.f, 0.f, -1.f, 0.f);
return VulkanCorrect * mat2;
}
}
// }
// case boo::IGraphicsDataFactory::Platform::Vulkan: {
// zeus::CMatrix4f mat2(2.f * st.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * st.x14_near / tmb, tpb / tmb, 0.f,
// 0.f, 0.f, -fpn / fmn, -2.f * st.x18_far * st.x14_near / fmn, 0.f, 0.f, -1.f, 0.f);
// return VulkanCorrect * mat2;
// }
// }
}
zeus::CMatrix4f CGraphics::GetPerspectiveProjectionMatrix(bool forRenderer) {
@ -227,27 +228,27 @@ zeus::CMatrix4f CGraphics::GetPerspectiveProjectionMatrix(bool forRenderer) {
0.f, -1.f, 0.f);
}
switch (g_BooPlatform) {
case boo::IGraphicsDataFactory::Platform::OpenGL:
default: {
return zeus::CMatrix4f(2.f * g_Proj.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * g_Proj.x14_near / tmb,
tpb / tmb, 0.f, 0.f, 0.f, -fpn / fmn, -2.f * g_Proj.x18_far * g_Proj.x14_near / fmn, 0.f,
0.f, -1.f, 0.f);
}
case boo::IGraphicsDataFactory::Platform::D3D11:
case boo::IGraphicsDataFactory::Platform::Metal: {
// switch (g_BooPlatform) {
// case boo::IGraphicsDataFactory::Platform::OpenGL:
// default: {
// return zeus::CMatrix4f(2.f * g_Proj.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * g_Proj.x14_near / tmb,
// tpb / tmb, 0.f, 0.f, 0.f, -fpn / fmn, -2.f * g_Proj.x18_far * g_Proj.x14_near / fmn, 0.f,
// 0.f, -1.f, 0.f);
// }
// case boo::IGraphicsDataFactory::Platform::D3D11:
// case boo::IGraphicsDataFactory::Platform::Metal: {
zeus::CMatrix4f mat2(2.f * g_Proj.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * g_Proj.x14_near / tmb,
tpb / tmb, 0.f, 0.f, 0.f, g_Proj.x18_far / fmn, g_Proj.x14_near * g_Proj.x18_far / fmn, 0.f,
0.f, -1.f, 0.f);
return PlusOneZ * mat2;
}
case boo::IGraphicsDataFactory::Platform::Vulkan: {
zeus::CMatrix4f mat2(2.f * g_Proj.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * g_Proj.x14_near / tmb,
tpb / tmb, 0.f, 0.f, 0.f, -fpn / fmn, -2.f * g_Proj.x18_far * g_Proj.x14_near / fmn, 0.f,
0.f, -1.f, 0.f);
return VulkanCorrect * mat2;
}
}
// }
// case boo::IGraphicsDataFactory::Platform::Vulkan: {
// zeus::CMatrix4f mat2(2.f * g_Proj.x14_near / rml, 0.f, rpl / rml, 0.f, 0.f, 2.f * g_Proj.x14_near / tmb,
// tpb / tmb, 0.f, 0.f, 0.f, -fpn / fmn, -2.f * g_Proj.x18_far * g_Proj.x14_near / fmn, 0.f,
// 0.f, -1.f, 0.f);
// return VulkanCorrect * mat2;
// }
// }
} else {
float rml = g_Proj.x8_right - g_Proj.x4_left;
float rpl = g_Proj.x8_right + g_Proj.x4_left;
@ -261,24 +262,24 @@ zeus::CMatrix4f CGraphics::GetPerspectiveProjectionMatrix(bool forRenderer) {
-fpn / fmn, 0.f, 0.f, 0.f, 1.f);
}
switch (g_BooPlatform) {
case boo::IGraphicsDataFactory::Platform::OpenGL:
default: {
return zeus::CMatrix4f(2.f / rml, 0.f, 0.f, -rpl / rml, 0.f, 2.f / tmb, 0.f, -tpb / tmb, 0.f, 0.f, -2.f / fmn,
-fpn / fmn, 0.f, 0.f, 0.f, 1.f);
}
case boo::IGraphicsDataFactory::Platform::D3D11:
case boo::IGraphicsDataFactory::Platform::Metal: {
// switch (g_BooPlatform) {
// case boo::IGraphicsDataFactory::Platform::OpenGL:
// default: {
// return zeus::CMatrix4f(2.f / rml, 0.f, 0.f, -rpl / rml, 0.f, 2.f / tmb, 0.f, -tpb / tmb, 0.f, 0.f, -2.f / fmn,
// -fpn / fmn, 0.f, 0.f, 0.f, 1.f);
// }
// case boo::IGraphicsDataFactory::Platform::D3D11:
// case boo::IGraphicsDataFactory::Platform::Metal: {
zeus::CMatrix4f mat2(2.f / rml, 0.f, 0.f, -rpl / rml, 0.f, 2.f / tmb, 0.f, -tpb / tmb, 0.f, 0.f, 1.f / fmn,
g_Proj.x14_near / fmn, 0.f, 0.f, 0.f, 1.f);
return PlusOneZ * mat2;
}
case boo::IGraphicsDataFactory::Platform::Vulkan: {
zeus::CMatrix4f mat2(2.f / rml, 0.f, 0.f, -rpl / rml, 0.f, 2.f / tmb, 0.f, -tpb / tmb, 0.f, 0.f, -2.f / fmn,
-fpn / fmn, 0.f, 0.f, 0.f, 1.f);
return VulkanCorrect * mat2;
}
}
// }
// case boo::IGraphicsDataFactory::Platform::Vulkan: {
// zeus::CMatrix4f mat2(2.f / rml, 0.f, 0.f, -rpl / rml, 0.f, 2.f / tmb, 0.f, -tpb / tmb, 0.f, 0.f, -2.f / fmn,
// -fpn / fmn, 0.f, 0.f, 0.f, 1.f);
// return VulkanCorrect * mat2;
// }
// }
}
}
@ -322,6 +323,7 @@ void CGraphics::FlushProjection() {
} else {
// Convert and load ortho
}
aurora::shaders::update_projection(GetPerspectiveProjectionMatrix(true));
}
zeus::CVector2i CGraphics::ProjectPoint(const zeus::CVector3f& point) {
@ -413,26 +415,25 @@ void CGraphics::SetViewportResolution(const zeus::CVector2i& res) {
g_GuiSys->OnViewportResize();
}
static boo::SWindowRect CachedVP;
static zeus::CRectangle CachedVP;
zeus::CVector2f CGraphics::g_CachedDepthRange = {0.f, 1.f};
void CGraphics::SetViewport(int leftOff, int bottomOff, int width, int height) {
CachedVP.location[0] = leftOff;
CachedVP.location[1] = bottomOff;
CachedVP.position[0] = leftOff;
CachedVP.position[1] = bottomOff;
CachedVP.size[0] = width;
CachedVP.size[1] = height;
g_BooMainCommandQueue->setViewport(CachedVP, g_CachedDepthRange[0], g_CachedDepthRange[1]);
aurora::shaders::set_viewport(CachedVP, g_CachedDepthRange[0], g_CachedDepthRange[1]);
}
void CGraphics::SetScissor(int leftOff, int bottomOff, int width, int height) {
boo::SWindowRect rect(leftOff, bottomOff, width, height);
g_BooMainCommandQueue->setScissor(rect);
aurora::shaders::set_scissor(leftOff, bottomOff, width, height);
}
void CGraphics::SetDepthRange(float znear, float zfar) {
g_CachedDepthRange[0] = znear;
g_CachedDepthRange[1] = zfar;
g_BooMainCommandQueue->setViewport(CachedVP, g_CachedDepthRange[0], g_CachedDepthRange[1]);
aurora::shaders::set_viewport(CachedVP, g_CachedDepthRange[0], g_CachedDepthRange[1]);
}
CTimeProvider* CGraphics::g_ExternalTimeProvider = nullptr;
@ -463,11 +464,11 @@ void CGraphics::UpdateFPSCounter() {
}
}
boo::IGraphicsDataFactory::Platform CGraphics::g_BooPlatform = boo::IGraphicsDataFactory::Platform::Null;
boo::IGraphicsDataFactory* CGraphics::g_BooFactory = nullptr;
boo::IGraphicsCommandQueue* CGraphics::g_BooMainCommandQueue = nullptr;
boo::ObjToken<boo::ITextureR> CGraphics::g_SpareTexture;
const char* CGraphics::g_BooPlatformName = nullptr;
//boo::IGraphicsDataFactory::Platform CGraphics::g_BooPlatform = boo::IGraphicsDataFactory::Platform::Null;
//boo::IGraphicsDataFactory* CGraphics::g_BooFactory = nullptr;
//boo::IGraphicsCommandQueue* CGraphics::g_BooMainCommandQueue = nullptr;
//boo::ObjToken<boo::ITextureR> CGraphics::g_SpareTexture;
//const char* CGraphics::g_BooPlatformName = nullptr;
const CTevCombiners::CTevPass CGraphics::sTevPass805a564c({GX::TevColorArg::CC_ZERO, GX::TevColorArg::CC_ZERO,
GX::TevColorArg::CC_ZERO, GX::TevColorArg::CC_RASC},

232
Runtime/Graphics/CGraphics.hpp
View File

@ -9,8 +9,8 @@
#include "DataSpec/DNACommon/GX.hpp"
#include <boo/graphicsdev/IGraphicsCommandQueue.hpp>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsCommandQueue.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <hecl/CVar.hpp>
#include <hecl/Runtime.hpp>
@ -20,8 +20,70 @@
#include <zeus/CVector2i.hpp>
#include <zeus/CVector2f.hpp>
#include "aurora.h"
#include "aurora_shaders.h"
using frame_clock = std::chrono::high_resolution_clock;
namespace aurora {
using TextureRef = aurora::shaders::TextureRef;
template <typename T>
struct RustDrop {};
template <>
struct RustDrop<TextureRef> {
TextureRef ref;
explicit RustDrop(TextureRef ref) : ref(ref) {}
~RustDrop() { aurora::shaders::drop_texture(ref); }
RustDrop(const RustDrop&) = delete;
RustDrop& operator=(const RustDrop&) = delete;
};
using TextureHandle = RustDrop<TextureRef>;
inline std::shared_ptr<TextureHandle> new_static_texture_2d(uint32_t width, uint32_t height, uint32_t mips,
aurora::shaders::TextureFormat format,
rust::Slice<const uint8_t> data,
std::string_view label) {
rust::Str rlabel{label.data(), label.size()};
auto ref = aurora::shaders::create_static_texture_2d(width, height, mips, format, data, rlabel);
return std::make_shared<TextureHandle>(ref);
}
inline std::shared_ptr<TextureHandle> new_render_texture(uint32_t width, uint32_t height,
uint32_t color_bind_count, uint32_t depth_bind_count,
std::string_view label) {
rust::Str rlabel{label.data(), label.size()};
auto ref = aurora::shaders::create_render_texture(width, height, color_bind_count, depth_bind_count, rlabel);
return std::make_shared<TextureHandle>(ref);
}
template <typename T>
class ArrayRef {
public:
using value_type = std::remove_cvref_t<T>;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using iterator = const_pointer;
using const_iterator = const_pointer;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
ArrayRef() = default;
explicit ArrayRef(T& one) : data(&one), length(1) {}
ArrayRef(T* data, size_t length) : data(data), length(length) {}
ArrayRef(T* begin, T* end) : data(begin), length(end - begin) {}
template <size_t N>
constexpr explicit ArrayRef(T (&arr)[N]) : data(arr), length(N) {}
template <size_t N>
constexpr explicit ArrayRef(std::array<T, N> arr) : data(arr.data()), length(arr.size()) {}
explicit ArrayRef(std::vector<T> vec) : data(vec.data()), length(vec.size()) {}
private:
T* data = nullptr;
size_t length = 0;
};
} // namespace aurora
namespace metaforce {
extern hecl::CVar* g_disableLighting;
class CLight;
@ -91,21 +153,7 @@ enum class ERglAlphaFunc {
enum class ERglAlphaOp { And = 0, Or = 1, Xor = 2, XNor = 3 };
enum class ERglFogMode : uint32_t {
None = 0x00,
PerspLin = 0x02,
PerspExp = 0x04,
PerspExp2 = 0x05,
PerspRevExp = 0x06,
PerspRevExp2 = 0x07,
OrthoLin = 0x0A,
OrthoExp = 0x0C,
OrthoExp2 = 0x0D,
OrthoRevExp = 0x0E,
OrthoRevExp2 = 0x0F
};
using ERglFogMode = aurora::shaders::FogMode;
struct SViewport {
u32 x0_left;
@ -145,12 +193,12 @@ struct SClipScreenRect {
, x20_uvYMin(uvYMin)
, x24_uvYMax(uvYMax) {}
SClipScreenRect(const boo::SWindowRect& rect) {
x4_left = rect.location[0];
x8_top = rect.location[1];
xc_width = rect.size[0];
x10_height = rect.size[1];
x14_dstWidth = rect.size[0];
SClipScreenRect(const aurora::shaders::ClipRect& rect) {
x4_left = rect.x;
x8_top = rect.y;
xc_width = rect.width;
x10_height = rect.height;
x14_dstWidth = rect.width;
}
SClipScreenRect(const SViewport& vp) {
@ -243,13 +291,14 @@ public:
float x18_far;
};
struct CFogState {
zeus::CColor m_color;
float m_A = 0.f;
float m_B = 0.5f;
float m_C = 0.f;
ERglFogMode m_mode;
};
using CFogState = aurora::shaders::FogState;
// struct CFogState {
// zeus::CColor m_color;
// float m_A = 0.f;
// float m_B = 0.5f;
// float m_C = 0.f;
// ERglFogMode m_mode;
// };
static CProjectionState g_Proj;
static zeus::CVector2f g_CachedDepthRange;
@ -321,73 +370,78 @@ public:
static u32 GetFPS() { return g_Framerate; }
static void UpdateFPSCounter();
static boo::IGraphicsDataFactory::Platform g_BooPlatform;
static const char* g_BooPlatformName;
static boo::IGraphicsDataFactory* g_BooFactory;
static boo::IGraphicsCommandQueue* g_BooMainCommandQueue;
static boo::ObjToken<boo::ITextureR> g_SpareTexture;
// static boo::IGraphicsDataFactory::Platform g_BooPlatform;
// static const char* g_BooPlatformName;
// static boo::IGraphicsDataFactory* g_BooFactory;
// static boo::IGraphicsCommandQueue* g_BooMainCommandQueue;
// static boo::ObjToken<boo::ITextureR> g_SpareTexture;
static const std::array<zeus::CMatrix3f, 6> skCubeBasisMats;
static void InitializeBoo(boo::IGraphicsDataFactory* factory, boo::IGraphicsCommandQueue* cc,
const boo::ObjToken<boo::ITextureR>& spareTex) {
g_BooPlatform = factory->platform();
g_BooPlatformName = factory->platformName();
g_BooFactory = factory;
g_BooMainCommandQueue = cc;
g_SpareTexture = spareTex;
}
// static void InitializeBoo(boo::IGraphicsDataFactory* factory, boo::IGraphicsCommandQueue* cc,
// const boo::ObjToken<boo::ITextureR>& spareTex) {
// g_BooPlatform = factory->platform();
// g_BooPlatformName = factory->platformName();
// g_BooFactory = factory;
// g_BooMainCommandQueue = cc;
// g_SpareTexture = spareTex;
// }
//
// static void ShutdownBoo() {
// g_BooFactory = nullptr;
// g_BooMainCommandQueue = nullptr;
// g_SpareTexture.reset();
// }
//
// static const char* PlatformName() { return g_BooPlatformName; }
static void ShutdownBoo() {
g_BooFactory = nullptr;
g_BooMainCommandQueue = nullptr;
g_SpareTexture.reset();
}
// static void CommitResources(const boo::FactoryCommitFunc& commitFunc __BooTraceArgs) {
// g_BooFactory->commitTransaction(commitFunc __BooTraceArgsUse);
// }
static const char* PlatformName() { return g_BooPlatformName; }
static bool g_commitAsLazy;
static void SetCommitResourcesAsLazy(bool newStatus) {
if (newStatus != g_commitAsLazy) {
g_commitAsLazy = newStatus;
if (!newStatus && g_BooFactory) {
g_BooFactory->commitPendingTransaction();
}
}
}
static void CommitResources(const boo::FactoryCommitFunc& commitFunc __BooTraceArgs) {
CommitResources(commitFunc __BooTraceArgsUse, g_commitAsLazy);
}
static void CommitResources(const boo::FactoryCommitFunc& commitFunc __BooTraceArgs, bool lazy) {
if (!g_BooFactory) {
return;
}
if (lazy) {
g_BooFactory->lazyCommitTransaction(commitFunc __BooTraceArgsUse);
} else {
g_BooFactory->commitTransaction(commitFunc __BooTraceArgsUse);
}
}
static void SetShaderDataBinding(const boo::ObjToken<boo::IShaderDataBinding>& binding) {
g_BooMainCommandQueue->setShaderDataBinding(binding);
}
// static bool g_commitAsLazy;
// static void SetCommitResourcesAsLazy(bool newStatus) {
// if (newStatus != g_commitAsLazy) {
// g_commitAsLazy = newStatus;
// if (!newStatus && g_BooFactory) {
// g_BooFactory->commitPendingTransaction();
// }
// }
// }
//
// static void CommitResources(const boo::FactoryCommitFunc& commitFunc __BooTraceArgs) {
// CommitResources(commitFunc __BooTraceArgsUse, g_commitAsLazy);
// }
//
// static void CommitResources(const boo::FactoryCommitFunc& commitFunc __BooTraceArgs, bool lazy) {
// if (!g_BooFactory) {
// return;
// }
// if (lazy) {
// g_BooFactory->lazyCommitTransaction(commitFunc __BooTraceArgsUse);
// } else {
// g_BooFactory->commitTransaction(commitFunc __BooTraceArgsUse);
// }
// }
//
// static void SetShaderDataBinding(const boo::ObjToken<boo::IShaderDataBinding>& binding) {
// g_BooMainCommandQueue->setShaderDataBinding(binding);
// }
static void ResolveSpareTexture(const SClipScreenRect& rect, int bindIdx = 0, bool clearDepth = false) {
boo::SWindowRect wrect = {rect.x4_left, rect.x8_top, rect.xc_width, rect.x10_height};
g_BooMainCommandQueue->resolveBindTexture(g_SpareTexture, wrect, true, bindIdx, true, false, clearDepth);
aurora::shaders::resolve_color({rect.x4_left, rect.x8_top, rect.xc_width, rect.x10_height}, bindIdx, clearDepth);
// boo::SWindowRect wrect = {rect.x4_left, rect.x8_top, rect.xc_width, rect.x10_height};
// g_BooMainCommandQueue->resolveBindTexture(g_SpareTexture, wrect, true, bindIdx, true, false, clearDepth);
}
static void ResolveSpareDepth(const SClipScreenRect& rect, int bindIdx = 0) {
boo::SWindowRect wrect = {rect.x4_left, rect.x8_top, rect.xc_width, rect.x10_height};
g_BooMainCommandQueue->resolveBindTexture(g_SpareTexture, wrect, true, bindIdx, false, true);
aurora::shaders::resolve_depth({rect.x4_left, rect.x8_top, rect.xc_width, rect.x10_height}, bindIdx);
// boo::SWindowRect wrect = {rect.x4_left, rect.x8_top, rect.xc_width, rect.x10_height};
// g_BooMainCommandQueue->resolveBindTexture(g_SpareTexture, wrect, true, bindIdx, false, true);
}
static void DrawInstances(size_t start, size_t count, size_t instCount, size_t startInst = 0) {
g_BooMainCommandQueue->drawInstances(start, count, instCount, startInst);
}
static void DrawArray(size_t start, size_t count) { g_BooMainCommandQueue->draw(start, count); }
static void DrawArrayIndexed(size_t start, size_t count) { g_BooMainCommandQueue->drawIndexed(start, count); }
// static void DrawInstances(size_t start, size_t count, size_t instCount, size_t startInst = 0) {
// g_BooMainCommandQueue->drawInstances(start, count, instCount, startInst);
// }
// static void DrawArray(size_t start, size_t count) { g_BooMainCommandQueue->draw(start, count); }
// static void DrawArrayIndexed(size_t start, size_t count) { g_BooMainCommandQueue->drawIndexed(start, count); }
static const CTevCombiners::CTevPass sTevPass805a564c;
static const CTevCombiners::CTevPass sTevPass805a5698;
@ -441,7 +495,7 @@ public:
m_vec.emplace_back(std::forward<_Args>(args)...);
}
void Draw() const { CGraphics::DrawArray(m_start, m_vec.size() - m_start); }
// void Draw() const { CGraphics::DrawArray(m_start, m_vec.size() - m_start); }
};
#ifdef BOO_GRAPHICS_DEBUG_GROUPS

226
Runtime/Graphics/CLineRenderer.cpp
View File

@ -11,48 +11,16 @@ void CLineRenderer::Initialize() { CLineRendererShaders::Initialize(); }
void CLineRenderer::Shutdown() {
CLineRendererShaders::Shutdown();
s_vertPoolTex.doDestroy();
s_vertPoolNoTex.doDestroy();
s_uniformPool.doDestroy();
// s_vertPoolTex.doDestroy();
// s_vertPoolNoTex.doDestroy();
// s_uniformPool.doDestroy();
}
hecl::VertexBufferPool<CLineRenderer::SDrawVertTex> CLineRenderer::s_vertPoolTex = {};
hecl::VertexBufferPool<CLineRenderer::SDrawVertNoTex> CLineRenderer::s_vertPoolNoTex = {};
hecl::UniformBufferPool<CLineRenderer::SDrawUniform> CLineRenderer::s_uniformPool = {};
//hecl::VertexBufferPool<CLineRenderer::SDrawVertTex> CLineRenderer::s_vertPoolTex = {};
//hecl::VertexBufferPool<CLineRenderer::SDrawVertNoTex> CLineRenderer::s_vertPoolNoTex = {};
//hecl::UniformBufferPool<CLineRenderer::SDrawUniform> CLineRenderer::s_uniformPool = {};
CLineRenderer::CLineRenderer(boo::IGraphicsDataFactory::Context& ctx, EPrimitiveMode mode, u32 maxVerts,
const boo::ObjToken<boo::ITexture>& texture, bool additive, bool zTest, bool zGEqual)
: m_mode(mode), m_maxVerts(maxVerts) {
OPTICK_EVENT();
if (maxVerts < 2) {
LineRendererLog.report(logvisor::Fatal, FMT_STRING("maxVerts < 2, maxVerts = {}"), maxVerts);
return;
}
m_textured = bool(texture);
u32 maxTriVerts = 0;
switch (mode) {
case EPrimitiveMode::Lines:
case EPrimitiveMode::LineStrip:
maxTriVerts = maxVerts * 4;
break;
case EPrimitiveMode::LineLoop:
maxTriVerts = maxVerts * 4 + 4;
break;
}
if (texture) {
m_vertBufTex = s_vertPoolTex.allocateBlock(CGraphics::g_BooFactory, maxTriVerts);
} else {
m_vertBufNoTex = s_vertPoolNoTex.allocateBlock(CGraphics::g_BooFactory, maxTriVerts);
}
m_uniformBuf = s_uniformPool.allocateBlock(CGraphics::g_BooFactory);
CLineRendererShaders::BuildShaderDataBinding(ctx, *this, texture, additive, zTest, zGEqual);
}
CLineRenderer::CLineRenderer(EPrimitiveMode mode, u32 maxVerts, const boo::ObjToken<boo::ITexture>& texture,
CLineRenderer::CLineRenderer(EPrimitiveMode mode, u32 maxVerts, const std::shared_ptr<aurora::TextureHandle>& texture,
bool additive, bool zTest, bool zGEqual)
: m_mode(mode), m_maxVerts(maxVerts) {
OPTICK_EVENT();
@ -73,22 +41,22 @@ CLineRenderer::CLineRenderer(EPrimitiveMode mode, u32 maxVerts, const boo::ObjTo
break;
}
if (texture) {
m_vertBufTex = s_vertPoolTex.allocateBlock(CGraphics::g_BooFactory, maxTriVerts);
} else {
m_vertBufNoTex = s_vertPoolNoTex.allocateBlock(CGraphics::g_BooFactory, maxTriVerts);
}
m_uniformBuf = s_uniformPool.allocateBlock(CGraphics::g_BooFactory);
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
CLineRendererShaders::BuildShaderDataBinding(ctx, *this, texture, additive, zTest, zGEqual);
return true;
} BooTrace);
// if (texture) {
// m_vertBufTex = s_vertPoolTex.allocateBlock(CGraphics::g_BooFactory, maxTriVerts);
// } else {
// m_vertBufNoTex = s_vertPoolNoTex.allocateBlock(CGraphics::g_BooFactory, maxTriVerts);
// }
//
// m_uniformBuf = s_uniformPool.allocateBlock(CGraphics::g_BooFactory);
//
// CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
// CLineRendererShaders::BuildShaderDataBinding(ctx, *this, texture, additive, zTest, zGEqual);
// return true;
// } BooTrace);
}
rstl::reserved_vector<CLineRenderer::SDrawVertTex, 1024> CLineRenderer::g_StaticLineVertsTex = {};
rstl::reserved_vector<CLineRenderer::SDrawVertNoTex, 1024> CLineRenderer::g_StaticLineVertsNoTex = {};
//rstl::reserved_vector<CLineRenderer::SDrawVertTex, 1024> CLineRenderer::g_StaticLineVertsTex = {};
//rstl::reserved_vector<CLineRenderer::SDrawVertNoTex, 1024> CLineRenderer::g_StaticLineVertsNoTex = {};
static bool IntersectLines(const zeus::CVector2f& pa1, const zeus::CVector2f& pa2, const zeus::CVector2f& pb1,
const zeus::CVector2f& pb2, zeus::CVector3f& intersect) {
@ -106,15 +74,15 @@ static bool IntersectLines(const zeus::CVector2f& pa1, const zeus::CVector2f& pa
void CLineRenderer::Reset() {
m_nextVert = 0;
m_final = false;
if (m_textured)
g_StaticLineVertsTex.clear();
else
g_StaticLineVertsNoTex.clear();
// if (m_textured)
// g_StaticLineVertsTex.clear();
// else
// g_StaticLineVertsNoTex.clear();
}
void CLineRenderer::AddVertex(const zeus::CVector3f& position, const zeus::CColor& color, float width,
const zeus::CVector2f& uv) {
if (m_final || !m_shaderBind[0] || m_nextVert >= m_maxVerts)
if (m_final /*|| !m_shaderBind[0]*/ || m_nextVert >= m_maxVerts)
return;
float adjWidth = width / 480.f;
@ -150,13 +118,13 @@ void CLineRenderer::AddVertex(const zeus::CVector3f& position, const zeus::CColo
if (m_textured) {
if (m_mode == EPrimitiveMode::Lines) {
if (m_nextVert & 1) {
g_StaticLineVertsTex.push_back(g_StaticLineVertsTex.back());
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back(g_StaticLineVertsTex.back());
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back(g_StaticLineVertsTex.back());
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back(g_StaticLineVertsTex.back());
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor, m_lastUV});
} else {
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor, m_lastUV});
}
} else {
zeus::CVector3f intersect1;
@ -174,25 +142,25 @@ void CLineRenderer::AddVertex(const zeus::CVector3f& position, const zeus::CColo
if (good1 && good2) {
intersect1.z() = float(m_lastPos.z());
intersect2.z() = float(m_lastPos.z());
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor, m_lastUV});
} else {
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor, m_lastUV});
}
}
} else {
if (m_mode == EPrimitiveMode::Lines) {
if (m_nextVert & 1) {
g_StaticLineVertsNoTex.push_back(g_StaticLineVertsNoTex.back());
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back(g_StaticLineVertsNoTex.back());
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back(g_StaticLineVertsNoTex.back());
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back(g_StaticLineVertsNoTex.back());
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor});
} else {
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor});
}
} else {
zeus::CVector3f intersect1;
@ -210,13 +178,13 @@ void CLineRenderer::AddVertex(const zeus::CVector3f& position, const zeus::CColo
if (good1 && good2) {
intersect1.z() = float(m_lastPos.z());
intersect2.z() = float(m_lastPos.z());
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor});
} else {
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor});
}
}
}
@ -227,11 +195,11 @@ void CLineRenderer::AddVertex(const zeus::CVector3f& position, const zeus::CColo
dv = dv.normalized().perpendicularVector() * m_lastWidth;
dv.x() /= CGraphics::g_ProjAspect;
if (m_textured) {
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor, m_lastUV});
} else {
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor});
}
}
@ -278,25 +246,25 @@ void CLineRenderer::Render(bool alphaWrite, const zeus::CColor& moduColor) {
if (good1 && good2) {
intersect1.z() = float(m_lastPos.z());
intersect2.z() = float(m_lastPos.z());
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor, m_lastUV});
} else {
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor, m_lastUV});
}
} else {
if (good1 && good2) {
intersect1.z() = float(m_lastPos.z());
intersect2.z() = float(m_lastPos.z());
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor});
} else {
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dvb, m_lastW), m_lastColor});
}
}
}
@ -329,25 +297,25 @@ void CLineRenderer::Render(bool alphaWrite, const zeus::CColor& moduColor) {
if (good1 && good2) {
intersect1.z() = float(m_firstPos.z());
intersect2.z() = float(m_firstPos.z());
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor, m_lastUV});
} else {
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dva, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dvb, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dva, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dvb, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dvb, m_lastW), m_lastColor, m_lastUV});
}
} else {
if (good1 && good2) {
intersect1.z() = float(m_firstPos.z());
intersect2.z() = float(m_firstPos.z());
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect1, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(intersect2, m_lastW), m_lastColor});
} else {
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dva, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dvb, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dva, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos + dvb, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_firstPos - dvb, m_lastW), m_lastColor});
}
}
}
@ -360,14 +328,14 @@ void CLineRenderer::Render(bool alphaWrite, const zeus::CColor& moduColor) {
if (m_textured) {
if (m_mode == EPrimitiveMode::Lines && (m_nextVert & 1)) {
} else {
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor, m_lastUV});
g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor, m_lastUV});
// g_StaticLineVertsTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor, m_lastUV});
}
} else {
if (m_mode == EPrimitiveMode::Lines && (m_nextVert & 1)) {
} else {
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor});
g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos + dv, m_lastW), m_lastColor});
// g_StaticLineVertsNoTex.push_back({zeus::CVector4f::ToClip(m_lastPos - dv, m_lastW), m_lastColor});
}
}
}
@ -375,21 +343,21 @@ void CLineRenderer::Render(bool alphaWrite, const zeus::CColor& moduColor) {
m_final = true;
}
m_uniformBuf.access() = SDrawUniform{moduColor, CGraphics::g_Fog};
if (m_textured) {
if (!g_StaticLineVertsTex.empty()) {
memmove(m_vertBufTex.access(), g_StaticLineVertsTex.data(), sizeof(SDrawVertTex) * g_StaticLineVertsTex.size());
CGraphics::SetShaderDataBinding(m_shaderBind[alphaWrite]);
CGraphics::DrawArray(0, g_StaticLineVertsTex.size());
}
} else {
if (!g_StaticLineVertsNoTex.empty()) {
memmove(m_vertBufNoTex.access(), g_StaticLineVertsNoTex.data(),
sizeof(SDrawVertNoTex) * g_StaticLineVertsNoTex.size());
CGraphics::SetShaderDataBinding(m_shaderBind[alphaWrite]);
CGraphics::DrawArray(0, g_StaticLineVertsNoTex.size());
}
}
// m_uniformBuf.access() = SDrawUniform{moduColor, CGraphics::g_Fog};
// if (m_textured) {
// if (!g_StaticLineVertsTex.empty()) {
// memmove(m_vertBufTex.access(), g_StaticLineVertsTex.data(), sizeof(SDrawVertTex) * g_StaticLineVertsTex.size());
// CGraphics::SetShaderDataBinding(m_shaderBind[alphaWrite]);
// CGraphics::DrawArray(0, g_StaticLineVertsTex.size());
// }
// } else {
// if (!g_StaticLineVertsNoTex.empty()) {
// memmove(m_vertBufNoTex.access(), g_StaticLineVertsNoTex.data(),
// sizeof(SDrawVertNoTex) * g_StaticLineVertsNoTex.size());
// CGraphics::SetShaderDataBinding(m_shaderBind[alphaWrite]);
// CGraphics::DrawArray(0, g_StaticLineVertsNoTex.size());
// }
// }
}
} // namespace metaforce

38
Runtime/Graphics/CLineRenderer.hpp
View File

@ -6,10 +6,10 @@
#include "Runtime/rstl.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <hecl/UniformBufferPool.hpp>
#include <hecl/VertexBufferPool.hpp>
//#include <hecl/UniformBufferPool.hpp>
//#include <hecl/VertexBufferPool.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CVector2f.hpp>
@ -59,22 +59,20 @@ private:
float m_lastWidth;
float m_lastW;
static rstl::reserved_vector<SDrawVertTex, 1024> g_StaticLineVertsTex;
static rstl::reserved_vector<SDrawVertNoTex, 1024> g_StaticLineVertsNoTex;
// static rstl::reserved_vector<SDrawVertTex, 1024> g_StaticLineVertsTex;
// static rstl::reserved_vector<SDrawVertNoTex, 1024> g_StaticLineVertsNoTex;
static hecl::VertexBufferPool<SDrawVertTex> s_vertPoolTex;
static hecl::VertexBufferPool<SDrawVertNoTex> s_vertPoolNoTex;
static hecl::UniformBufferPool<SDrawUniform> s_uniformPool;
// static hecl::VertexBufferPool<SDrawVertTex> s_vertPoolTex;
// static hecl::VertexBufferPool<SDrawVertNoTex> s_vertPoolNoTex;
// static hecl::UniformBufferPool<SDrawUniform> s_uniformPool;
public:
hecl::VertexBufferPool<SDrawVertTex>::Token m_vertBufTex;
hecl::VertexBufferPool<SDrawVertNoTex>::Token m_vertBufNoTex;
hecl::UniformBufferPool<SDrawUniform>::Token m_uniformBuf;
std::array<boo::ObjToken<boo::IShaderDataBinding>, 2> m_shaderBind;
// hecl::VertexBufferPool<SDrawVertTex>::Token m_vertBufTex;
// hecl::VertexBufferPool<SDrawVertNoTex>::Token m_vertBufNoTex;
// hecl::UniformBufferPool<SDrawUniform>::Token m_uniformBuf;
// std::array<boo::ObjToken<boo::IShaderDataBinding>, 2> m_shaderBind;
CLineRenderer(boo::IGraphicsDataFactory::Context& ctx, EPrimitiveMode mode, u32 maxVerts,
const boo::ObjToken<boo::ITexture>& texture, bool additive, bool zTest = false, bool zGEqual = false);
CLineRenderer(EPrimitiveMode mode, u32 maxVerts, const boo::ObjToken<boo::ITexture>& texture, bool additive,
CLineRenderer(EPrimitiveMode mode, u32 maxVerts, const std::shared_ptr<aurora::TextureHandle>& texture, bool additive,
bool zTest = false, bool zGEqual = false);
CLineRenderer(CLineRenderer&&) = default;
@ -83,11 +81,11 @@ public:
const zeus::CVector2f& uv = zeus::skZero2f);
void Render(bool alphaWrite = false, const zeus::CColor& moduColor = zeus::skWhite);
static void UpdateBuffers() {
s_vertPoolTex.updateBuffers();
s_vertPoolNoTex.updateBuffers();
s_uniformPool.updateBuffers();
}
// static void UpdateBuffers() {
// s_vertPoolTex.updateBuffers();
// s_vertPoolNoTex.updateBuffers();
// s_uniformPool.updateBuffers();
// }
static void Initialize();
static void Shutdown();

1
Runtime/Graphics/CMakeLists.txt
View File

@ -1,6 +1,7 @@
set(GRAPHICS_SOURCES
IRenderer.hpp
IWeaponRenderer.hpp IWeaponRenderer.cpp
CCubeModel.cpp CCubeModel.hpp
CBooRenderer.hpp CBooRenderer.cpp
CDrawable.hpp
CDrawablePlaneObject.hpp

4
Runtime/Graphics/CMetroidModelInstance.hpp
View File

@ -27,7 +27,7 @@ class CMetroidModelInstance {
std::vector<CBooSurface> m_surfaces;
std::unique_ptr<CBooModel> m_instance;
hecl::HMDLMeta m_hmdlMeta;
std::unordered_map<int, CModelShaders::ShaderPipelines> m_shaders;
// std::unordered_map<int, CModelShaders::ShaderPipelines> m_shaders;
public:
CMetroidModelInstance() = default;
@ -39,7 +39,7 @@ public:
m_surfaces.clear();
m_instance.reset();
m_hmdlMeta = {};
m_shaders.clear();
// m_shaders.clear();
}
};

132
Runtime/Graphics/CModel.hpp
View File

@ -9,11 +9,10 @@
#include "DataSpec/DNAMP1/CMDLMaterials.hpp"
#include "Runtime/CFactoryMgr.hpp"
#include "Runtime/CToken.hpp"
#include "Runtime/RetroTypes.hpp"
#include "Runtime/Graphics/CTexture.hpp"
#include "Runtime/Graphics/Shaders/CModelShaders.hpp"
#include "Runtime/RetroTypes.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <hecl/HMDLMeta.hpp>
#include <zeus/CAABox.hpp>
#include <zeus/CColor.hpp>
@ -80,42 +79,42 @@ struct CBooSurface {
using MaterialSet = DataSpec::DNAMP1::HMDLMaterialSet;
struct GeometryUniformLayout {
mutable std::vector<boo::ObjToken<boo::IGraphicsBufferD>> m_sharedBuffer;
size_t m_geomBufferSize = 0;
size_t m_skinBankCount = 0;
size_t m_weightVecCount = 0;
std::vector<size_t> m_skinOffs;
std::vector<size_t> m_skinSizes;
std::vector<size_t> m_uvOffs;
std::vector<size_t> m_uvSizes;
GeometryUniformLayout(const CModel* model, const MaterialSet* matSet);
void Update(const CModelFlags& flags, const CSkinRules* cskr, const CPoseAsTransforms* pose,
const MaterialSet* matSet, const boo::ObjToken<boo::IGraphicsBufferD>& buf,
const CBooModel* parent) const;
void ReserveSharedBuffers(boo::IGraphicsDataFactory::Context& ctx, int size);
boo::ObjToken<boo::IGraphicsBufferD> GetSharedBuffer(int idx) const;
};
//struct GeometryUniformLayout {
// mutable std::vector<boo::ObjToken<boo::IGraphicsBufferD>> m_sharedBuffer;
// size_t m_geomBufferSize = 0;
// size_t m_skinBankCount = 0;
// size_t m_weightVecCount = 0;
//
// std::vector<size_t> m_skinOffs;
// std::vector<size_t> m_skinSizes;
//
// std::vector<size_t> m_uvOffs;
// std::vector<size_t> m_uvSizes;
//
// GeometryUniformLayout(const CModel* model, const MaterialSet* matSet);
// void Update(const CModelFlags& flags, const CSkinRules* cskr, const CPoseAsTransforms* pose,
// const MaterialSet* matSet, const boo::ObjToken<boo::IGraphicsBufferD>& buf,
// const CBooModel* parent) const;
//
// void ReserveSharedBuffers(boo::IGraphicsDataFactory::Context& ctx, int size);
// boo::ObjToken<boo::IGraphicsBufferD> GetSharedBuffer(int idx) const;
//};
struct SShader {
std::unordered_map<CAssetId, TCachedToken<CTexture>> x0_textures;
std::unordered_map<int, CModelShaders::ShaderPipelines> m_shaders;
// std::unordered_map<int, CModelShaders::ShaderPipelines> m_shaders;
MaterialSet m_matSet;
std::optional<GeometryUniformLayout> m_geomLayout;
// std::optional<GeometryUniformLayout> m_geomLayout;
int m_matSetIdx;
explicit SShader(int idx) : m_matSetIdx(idx) {
x0_textures.clear();
m_shaders.clear();
// m_shaders.clear();
}
void InitializeLayout(const CModel* model) { m_geomLayout.emplace(model, &m_matSet); }
// void InitializeLayout(const CModel* model) { m_geomLayout.emplace(model, &m_matSet); }
void UnlockTextures();
CModelShaders::ShaderPipelines BuildShader(const hecl::HMDLMeta& meta, const MaterialSet::Material& mat);
void BuildShaders(const hecl::HMDLMeta& meta, std::unordered_map<int, CModelShaders::ShaderPipelines>& shaders);
void BuildShaders(const hecl::HMDLMeta& meta) { BuildShaders(meta, m_shaders); }
// CModelShaders::ShaderPipelines BuildShader(const hecl::HMDLMeta& meta, const MaterialSet::Material& mat);
// void BuildShaders(const hecl::HMDLMeta& meta, std::unordered_map<int, CModelShaders::ShaderPipelines>& shaders);
// void BuildShaders(const hecl::HMDLMeta& meta) { BuildShaders(meta, m_shaders); }
};
class CBooModel {
@ -137,9 +136,9 @@ private:
CModel* m_model;
std::vector<CBooSurface>* x0_surfaces;
const MaterialSet* x4_matSet;
const GeometryUniformLayout* m_geomLayout;
// const GeometryUniformLayout* m_geomLayout;
int m_matSetIdx = -1;
const std::unordered_map<int, CModelShaders::ShaderPipelines>* m_pipelines;
// const std::unordered_map<int, CModelShaders::ShaderPipelines>* m_pipelines;
std::unordered_map<CAssetId, TCachedToken<CTexture>> x1c_textures;
zeus::CAABox x20_aabb;
CBooSurface* x38_firstUnsortedSurface = nullptr;
@ -158,26 +157,26 @@ private:
CModelShaders::LightingUniform m_lightingData;
/* metaforce addition: boo! */
size_t m_uniformDataSize = 0;
struct ModelInstance {
boo::ObjToken<boo::IGraphicsBufferD> m_geomUniformBuffer;
boo::ObjToken<boo::IGraphicsBufferD> m_uniformBuffer;
std::vector<std::vector<boo::ObjToken<boo::IShaderDataBinding>>> m_shaderDataBindings;
boo::ObjToken<boo::IGraphicsBufferD> m_dynamicVbo;
// size_t m_uniformDataSize = 0;
// struct ModelInstance {
// boo::ObjToken<boo::IGraphicsBufferD> m_geomUniformBuffer;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniformBuffer;
// std::vector<std::vector<boo::ObjToken<boo::IShaderDataBinding>>> m_shaderDataBindings;
// boo::ObjToken<boo::IGraphicsBufferD> m_dynamicVbo;
//
// boo::ObjToken<boo::IGraphicsBuffer> GetBooVBO(const CBooModel& model, boo::IGraphicsDataFactory::Context& ctx);
// };
// std::vector<ModelInstance> m_instances;
// ModelInstance m_ballShadowInstance;
boo::ObjToken<boo::IGraphicsBuffer> GetBooVBO(const CBooModel& model, boo::IGraphicsDataFactory::Context& ctx);
};
std::vector<ModelInstance> m_instances;
ModelInstance m_ballShadowInstance;
// boo::ObjToken<boo::IGraphicsBufferS> m_staticVbo;
// boo::ObjToken<boo::IGraphicsBufferS> m_staticIbo;
//
// boo::ObjToken<boo::ITexture> m_lastDrawnShadowMap;
// boo::ObjToken<boo::ITexture> m_lastDrawnOneTexture;
// boo::ObjToken<boo::ITextureCubeR> m_lastDrawnReflectionCube;
boo::ObjToken<boo::IGraphicsBufferS> m_staticVbo;
boo::ObjToken<boo::IGraphicsBufferS> m_staticIbo;
boo::ObjToken<boo::ITexture> m_lastDrawnShadowMap;
boo::ObjToken<boo::ITexture> m_lastDrawnOneTexture;
boo::ObjToken<boo::ITextureCubeR> m_lastDrawnReflectionCube;
ModelInstance* PushNewModelInstance(int sharedLayoutBuf = -1, boo::IGraphicsDataFactory::Context* ctx = nullptr);
// ModelInstance* PushNewModelInstance(int sharedLayoutBuf = -1, boo::IGraphicsDataFactory::Context* ctx = nullptr);
void DrawAlphaSurfaces(const CModelFlags& flags) const;
void DrawNormalSurfaces(const CModelFlags& flags) const;
void DrawSurfaces(const CModelFlags& flags) const;
@ -197,8 +196,9 @@ private:
public:
~CBooModel();
CBooModel(TToken<CModel>& token, CModel* parent, std::vector<CBooSurface>* surfaces, SShader& shader,
const boo::ObjToken<boo::IGraphicsBufferS>& vbo, const boo::ObjToken<boo::IGraphicsBufferS>& ibo,
const zeus::CAABox& aabb, u8 renderMask, int numInsts);
// TODO
// boo::ObjToken<boo::IGraphicsBufferS> vbo, boo::ObjToken<boo::IGraphicsBufferS> ibo,
const zeus::CAABox& aabb, u8 renderMask);
static void MakeTexturesFromMats(const MaterialSet& matSet,
std::unordered_map<CAssetId, TCachedToken<CTexture>>& toksOut, IObjectStore& store);
@ -209,15 +209,13 @@ public:
void SetAmbientColor(const zeus::CColor& color) { m_lightingData.ambient = color; }
void DisableAllLights();
void RemapMaterialData(SShader& shader);
void RemapMaterialData(SShader& shader, const std::unordered_map<int, CModelShaders::ShaderPipelines>& pipelines);
bool TryLockTextures();
void UnlockTextures();
void SyncLoadTextures();
void Touch(int shaderIdx);
void VerifyCurrentShader(int shaderIdx);
boo::ObjToken<boo::IGraphicsBufferD> UpdateUniformData(const CModelFlags& flags, const CSkinRules* cskr,
const CPoseAsTransforms* pose, int sharedLayoutBuf = -1,
boo::IGraphicsDataFactory::Context* ctx = nullptr);
// boo::ObjToken<boo::IGraphicsBufferD> UpdateUniformData(const CModelFlags& flags, const CSkinRules* cskr,
// const CPoseAsTransforms* pose, int sharedLayoutBuf = -1);
void DrawAlpha(const CModelFlags& flags, const CSkinRules* cskr, const CPoseAsTransforms* pose);
void DrawNormal(const CModelFlags& flags, const CSkinRules* cskr, const CPoseAsTransforms* pose);
void Draw(const CModelFlags& flags, const CSkinRules* cskr, const CPoseAsTransforms* pose);
@ -241,16 +239,16 @@ public:
static void EnsureViewDepStateCached(const CBooModel& model, const CBooSurface* surf, zeus::CMatrix4f* mtxsOut,
float& alphaOut);
static inline boo::ObjToken<boo::ITexture> g_shadowMap;
static inline std::shared_ptr<aurora::TextureHandle> g_shadowMap;
static inline zeus::CTransform g_shadowTexXf;
static void EnableShadowMaps(const boo::ObjToken<boo::ITexture>& map, const zeus::CTransform& texXf);
static void EnableShadowMaps(const std::shared_ptr<aurora::TextureHandle>& map, const zeus::CTransform& texXf);
static void DisableShadowMaps();
static inline boo::ObjToken<boo::ITexture> g_disintegrateTexture;
static void SetDisintegrateTexture(const boo::ObjToken<boo::ITexture>& map) { g_disintegrateTexture = map; }
static inline std::shared_ptr<aurora::TextureHandle> g_disintegrateTexture;
static void SetDisintegrateTexture(const std::shared_ptr<aurora::TextureHandle>& map) { g_disintegrateTexture = map; }
static inline boo::ObjToken<boo::ITextureCubeR> g_reflectionCube;
static void SetReflectionCube(const boo::ObjToken<boo::ITextureCubeR>& map) { g_reflectionCube = map; }
static inline std::shared_ptr<aurora::TextureHandle> g_reflectionCube;
static void SetReflectionCube(const std::shared_ptr<aurora::TextureHandle>& map) { g_reflectionCube = map; }
static void SetDummyTextures(bool b) { g_DummyTextures = b; }
static void SetRenderModelBlack(bool b) { g_RenderModelBlack = b; }
@ -276,10 +274,10 @@ class CModel {
int x38_lastFrame;
/* metaforce addition: boo! */
boo::ObjToken<boo::IGraphicsBufferS> m_staticVbo;
// boo::ObjToken<boo::IGraphicsBufferS> m_staticVbo;
hecl::HMDLMeta m_hmdlMeta;
std::unique_ptr<uint8_t[]> m_dynamicVertexData;
boo::ObjToken<boo::IGraphicsBufferS> m_ibo;
// boo::ObjToken<boo::IGraphicsBufferS> m_ibo;
public:
using MaterialSet = DataSpec::DNAMP1::HMDLMaterialSet;
@ -294,7 +292,7 @@ public:
const zeus::CAABox& GetAABB() const { return m_aabb; }
CBooModel& GetInstance() { return *x28_modelInst; }
const CBooModel& GetInstance() const { return *x28_modelInst; }
std::unique_ptr<CBooModel> MakeNewInstance(int shaderIdx, int subInsts, bool lockParent = true);
std::unique_ptr<CBooModel> MakeNewInstance(int shaderIdx, bool lockParent = true);
void UpdateLastFrame() const { const_cast<CModel&>(*this).x38_lastFrame = CGraphics::GetFrameCounter(); }
u32 GetNumMaterialSets() const { return x18_matSets.size(); }
@ -302,9 +300,9 @@ public:
zeus::CVector3f GetPoolVertex(size_t idx) const;
size_t GetPoolNormalOffset(size_t idx) const;
zeus::CVector3f GetPoolNormal(size_t idx) const;
void ApplyVerticesCPU(const boo::ObjToken<boo::IGraphicsBufferD>& vertBuf,
const std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vn) const;
void RestoreVerticesCPU(const boo::ObjToken<boo::IGraphicsBufferD>& vertBuf) const;
// void ApplyVerticesCPU(const boo::ObjToken<boo::IGraphicsBufferD>& vertBuf,
// const std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vn) const;
// void RestoreVerticesCPU(const boo::ObjToken<boo::IGraphicsBufferD>& vertBuf) const;
void _WarmupShaders();
static void WarmupShaders(const SObjectTag& cmdlTag);

1184
Runtime/Graphics/CModelBoo.cpp
View File

File diff suppressed because it is too large Load Diff

158
Runtime/Graphics/CMoviePlayer.cpp
View File

@ -5,7 +5,7 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include <amuse/DSPCodec.hpp>
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
#include <turbojpeg.h>
namespace metaforce {
@ -27,7 +27,7 @@ static const u16 StaticVolumeLookup[] = {
0x6CA2, 0x6E80, 0x7061, 0x7247, 0x7430, 0x761E, 0x7810, 0x7A06, 0x7C00, 0x7DFE, 0x8000};
/* shared boo resources */
static boo::ObjToken<boo::IShaderPipeline> YUVShaderPipeline;
//static boo::ObjToken<boo::IShaderPipeline> YUVShaderPipeline;
static tjhandle TjHandle = nullptr;
/* RSF audio state */
@ -46,20 +46,20 @@ static float SfxVolume = 1.f;
static const char* BlockNames[] = {"SpecterViewBlock"};
static const char* TexNames[] = {"texY", "texU", "texV"};
void CMoviePlayer::Initialize(boo::IGraphicsDataFactory* factory) {
switch (factory->platform()) {
case boo::IGraphicsDataFactory::Platform::Vulkan:
g_PlatformMatrix.m[1][1] = -1.f;
break;
default:
break;
}
YUVShaderPipeline = hecl::conv->convert(Shader_CMoviePlayerShader{});
void CMoviePlayer::Initialize() {
// switch (factory->platform()) {
// case boo::IGraphicsDataFactory::Platform::Vulkan:
// g_PlatformMatrix.m[1][1] = -1.f;
// break;
// default:
// break;
// }
// YUVShaderPipeline = hecl::conv->convert(Shader_CMoviePlayerShader{});
TjHandle = tjInitDecompress();
}
void CMoviePlayer::Shutdown() {
YUVShaderPipeline.reset();
// YUVShaderPipeline.reset();
tjDestroy(TjHandle);
}
@ -202,50 +202,50 @@ CMoviePlayer::CMoviePlayer(const char* path, float preLoadSeconds, bool loop, bo
xa0_bufferQueue.reserve(xf0_preLoadFrames);
/* All set for GPU resources */
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_blockBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(m_viewVertBlock), 1);
m_vertBuf = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(TexShaderVert), 4);
/* Allocate textures here (rather than at decode time) */
x80_textures.reserve(3);
for (int i = 0; i < 3; ++i) {
CTHPTextureSet& set = x80_textures.emplace_back();
if (deinterlace) {
/* metaforce addition: this way interlaced THPs don't look horrible */
set.Y[0] = ctx.newDynamicTexture(x6c_videoInfo.width, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
set.Y[1] = ctx.newDynamicTexture(x6c_videoInfo.width, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
set.U = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
set.V = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
boo::ObjToken<boo::IGraphicsBuffer> bufs[] = {m_blockBuf.get()};
for (int j = 0; j < 2; ++j) {
boo::ObjToken<boo::ITexture> texs[] = {set.Y[j].get(), set.U.get(), set.V.get()};
set.binding[j] = ctx.newShaderDataBinding(YUVShaderPipeline, m_vertBuf.get(), nullptr, nullptr, 1, bufs,
nullptr, 3, texs, nullptr, nullptr);
}
} else {
/* normal progressive presentation */
set.Y[0] = ctx.newDynamicTexture(x6c_videoInfo.width, x6c_videoInfo.height, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
set.U = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
set.V = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
boo::TextureClampMode::Repeat);
boo::ObjToken<boo::IGraphicsBuffer> bufs[] = {m_blockBuf.get()};
boo::ObjToken<boo::ITexture> texs[] = {set.Y[0].get(), set.U.get(), set.V.get()};
set.binding[0] = ctx.newShaderDataBinding(YUVShaderPipeline, m_vertBuf.get(), nullptr, nullptr, 1, bufs,
nullptr, 3, texs, nullptr, nullptr);
}
if (xf4_25_hasAudio)
set.audioBuf.reset(new s16[x28_thpHead.maxAudioSamples * 2]);
}
return true;
} BooTrace);
// CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
// m_blockBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(m_viewVertBlock), 1);
// m_vertBuf = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(TexShaderVert), 4);
//
// /* Allocate textures here (rather than at decode time) */
// x80_textures.reserve(3);
// for (int i = 0; i < 3; ++i) {
// CTHPTextureSet& set = x80_textures.emplace_back();
// if (deinterlace) {
// /* metaforce addition: this way interlaced THPs don't look horrible */
// set.Y[0] = ctx.newDynamicTexture(x6c_videoInfo.width, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
// set.Y[1] = ctx.newDynamicTexture(x6c_videoInfo.width, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
// set.U = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
// set.V = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
//
// boo::ObjToken<boo::IGraphicsBuffer> bufs[] = {m_blockBuf.get()};
// for (int j = 0; j < 2; ++j) {
// boo::ObjToken<boo::ITexture> texs[] = {set.Y[j].get(), set.U.get(), set.V.get()};
// set.binding[j] = ctx.newShaderDataBinding(YUVShaderPipeline, m_vertBuf.get(), nullptr, nullptr, 1, bufs,
// nullptr, 3, texs, nullptr, nullptr);
// }
// } else {
// /* normal progressive presentation */
// set.Y[0] = ctx.newDynamicTexture(x6c_videoInfo.width, x6c_videoInfo.height, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
// set.U = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
// set.V = ctx.newDynamicTexture(x6c_videoInfo.width / 2, x6c_videoInfo.height / 2, boo::TextureFormat::I8,
// boo::TextureClampMode::Repeat);
//
// boo::ObjToken<boo::IGraphicsBuffer> bufs[] = {m_blockBuf.get()};
// boo::ObjToken<boo::ITexture> texs[] = {set.Y[0].get(), set.U.get(), set.V.get()};
// set.binding[0] = ctx.newShaderDataBinding(YUVShaderPipeline, m_vertBuf.get(), nullptr, nullptr, 1, bufs,
// nullptr, 3, texs, nullptr, nullptr);
// }
// if (xf4_25_hasAudio)
// set.audioBuf.reset(new s16[x28_thpHead.maxAudioSamples * 2]);
// }
// return true;
// } BooTrace);
/* Temporary planar YUV decode buffer, resulting planes copied to Boo */
m_yuvBuf.reset(new uint8_t[tjBufSizeYUV(x6c_videoInfo.width, x6c_videoInfo.height, TJ_420)]);
@ -260,7 +260,7 @@ CMoviePlayer::CMoviePlayer(const char* path, float preLoadSeconds, bool loop, bo
SetFrame({-0.5f, 0.5f, 0.f}, {-0.5f, -0.5f, 0.f}, {0.5f, -0.5f, 0.f}, {0.5f, 0.5f, 0.f});
m_viewVertBlock.finalAssign(m_viewVertBlock);
m_blockBuf->load(&m_viewVertBlock, sizeof(m_viewVertBlock));
// m_blockBuf->load(&m_viewVertBlock, sizeof(m_viewVertBlock));
}
void CMoviePlayer::SetStaticAudioVolume(int vol) {
@ -405,7 +405,7 @@ void CMoviePlayer::SetFrame(const zeus::CVector3f& a, const zeus::CVector3f& b,
m_frame[1].m_pos = b;
m_frame[2].m_pos = d;
m_frame[3].m_pos = c;
m_vertBuf->load(m_frame, sizeof(m_frame));
// m_vertBuf->load(m_frame, sizeof(m_frame));
}
void CMoviePlayer::DrawFrame() {
@ -415,8 +415,8 @@ void CMoviePlayer::DrawFrame() {
/* draw appropriate field */
CTHPTextureSet& tex = x80_textures[xd0_drawTexSlot];
CGraphics::SetShaderDataBinding(tex.binding[m_deinterlace ? (xfc_fieldIndex != 0) : 0]);
CGraphics::DrawArray(0, 4);
// CGraphics::SetShaderDataBinding(tex.binding[m_deinterlace ? (xfc_fieldIndex != 0) : 0]);
// CGraphics::DrawArray(0, 4);
/* ensure second field is being displayed by VI to signal advance
* (faked in metaforce with continuous xor) */
@ -532,27 +532,27 @@ void CMoviePlayer::DecodeFromRead(const void* data) {
if (m_deinterlace) {
/* Deinterlace into 2 discrete 60-fps half-res textures */
u8* mappedData = (u8*)tex.Y[0]->map(planeSizeHalf);
for (unsigned y = 0; y < x6c_videoInfo.height / 2; ++y) {
memmove(mappedData + x6c_videoInfo.width * y, m_yuvBuf.get() + x6c_videoInfo.width * (y * 2),
x6c_videoInfo.width);
}
tex.Y[0]->unmap();
mappedData = (u8*)tex.Y[1]->map(planeSizeHalf);
for (unsigned y = 0; y < x6c_videoInfo.height / 2; ++y) {
memmove(mappedData + x6c_videoInfo.width * y, m_yuvBuf.get() + x6c_videoInfo.width * (y * 2 + 1),
x6c_videoInfo.width);
}
tex.Y[1]->unmap();
tex.U->load(m_yuvBuf.get() + planeSize, planeSizeQuarter);
tex.V->load(m_yuvBuf.get() + planeSize + planeSizeQuarter, planeSizeQuarter);
// u8* mappedData = (u8*)tex.Y[0]->map(planeSizeHalf);
// for (unsigned y = 0; y < x6c_videoInfo.height / 2; ++y) {
// memmove(mappedData + x6c_videoInfo.width * y, m_yuvBuf.get() + x6c_videoInfo.width * (y * 2),
// x6c_videoInfo.width);
// }
// tex.Y[0]->unmap();
//
// mappedData = (u8*)tex.Y[1]->map(planeSizeHalf);
// for (unsigned y = 0; y < x6c_videoInfo.height / 2; ++y) {
// memmove(mappedData + x6c_videoInfo.width * y, m_yuvBuf.get() + x6c_videoInfo.width * (y * 2 + 1),
// x6c_videoInfo.width);
// }
// tex.Y[1]->unmap();
//
// tex.U->load(m_yuvBuf.get() + planeSize, planeSizeQuarter);
// tex.V->load(m_yuvBuf.get() + planeSize + planeSizeQuarter, planeSizeQuarter);
} else {
/* Direct planar load */
tex.Y[0]->load(m_yuvBuf.get(), planeSize);
tex.U->load(m_yuvBuf.get() + planeSize, planeSizeQuarter);
tex.V->load(m_yuvBuf.get() + planeSize + planeSizeQuarter, planeSizeQuarter);
// tex.Y[0]->load(m_yuvBuf.get(), planeSize);
// tex.U->load(m_yuvBuf.get() + planeSize, planeSizeQuarter);
// tex.V->load(m_yuvBuf.get() + planeSize + planeSizeQuarter, planeSizeQuarter);
}
break;

27
Runtime/Graphics/CMoviePlayer.hpp
View File

@ -5,9 +5,8 @@
#include "Runtime/CDvdFile.hpp"
#include "Runtime/RetroTypes.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include <boo/IWindow.hpp>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CVector3f.hpp>
@ -72,13 +71,13 @@ private:
};
struct CTHPTextureSet {
boo::ObjToken<boo::ITextureD> Y[2];
boo::ObjToken<boo::ITextureD> U;
boo::ObjToken<boo::ITextureD> V;
std::shared_ptr<aurora::TextureHandle> Y[2];
std::shared_ptr<aurora::TextureHandle> U;
std::shared_ptr<aurora::TextureHandle> V;
u32 playedSamples = 0;
u32 audioSamples = 0;
std::unique_ptr<s16[]> audioBuf;
boo::ObjToken<boo::IShaderDataBinding> binding[2];
// boo::ObjToken<boo::IShaderDataBinding> binding[2];
};
std::vector<CTHPTextureSet> x80_textures;
std::unique_ptr<uint8_t[]> x90_requestBuf;
@ -118,11 +117,11 @@ private:
struct ViewBlock {
zeus::CMatrix4f m_mv;
zeus::CColor m_color = zeus::skWhite;
void setViewRect(const boo::SWindowRect& root, const boo::SWindowRect& sub) {
m_mv[0][0] = 2.0f / root.size[0];
m_mv[1][1] = 2.0f / root.size[1];
m_mv[3][0] = sub.location[0] * m_mv[0][0] - 1.0f;
m_mv[3][1] = sub.location[1] * m_mv[1][1] - 1.0f;
void setViewRect(const aurora::shaders::ClipRect& root, const aurora::shaders::ClipRect& sub) {
m_mv[0][0] = 2.0f / root.width;
m_mv[1][1] = 2.0f / root.height;
m_mv[3][0] = sub.x * m_mv[0][0] - 1.0f;
m_mv[3][1] = sub.y * m_mv[1][1] - 1.0f;
}
void finalAssign(const ViewBlock& other) {
m_mv = g_PlatformMatrix * other.m_mv;
@ -131,8 +130,8 @@ private:
};
ViewBlock m_viewVertBlock;
boo::ObjToken<boo::IGraphicsBufferD> m_blockBuf;
boo::ObjToken<boo::IGraphicsBufferD> m_vertBuf;
// boo::ObjToken<boo::IGraphicsBufferD> m_blockBuf;
// boo::ObjToken<boo::IGraphicsBufferD> m_vertBuf;
TexShaderVert m_frame[4];
@ -167,7 +166,7 @@ public:
void Update(float dt);
std::pair<u32, u32> GetVideoDimensions() const { return {x6c_videoInfo.width, x6c_videoInfo.height}; }
static void Initialize(boo::IGraphicsDataFactory* factory);
static void Initialize();
static void Shutdown();
};

13
Runtime/Graphics/CRainSplashGenerator.cpp
View File

@ -13,11 +13,8 @@ CRainSplashGenerator::CRainSplashGenerator(const zeus::CVector3f& scale, u32 max
x30_alpha = std::min(1.f, alpha);
x44_genRate = std::min(maxSplashes, genRate);
x0_rainSplashes.reserve(maxSplashes);
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
for (u32 i = 0; i < maxSplashes; ++i)
x0_rainSplashes.emplace_back(ctx);
return true;
} BooTrace);
x0_rainSplashes.emplace_back();
}
void CRainSplashGenerator::SSplashLine::Draw(float alpha, float dt, const zeus::CVector3f& pos) {
@ -73,12 +70,12 @@ void CRainSplashGenerator::Draw(const zeus::CTransform& xf) {
DoDraw(xf);
}
CRainSplashGenerator::SSplashLine::SSplashLine(boo::IGraphicsDataFactory::Context& ctx)
: m_renderer(ctx, CLineRenderer::EPrimitiveMode::LineStrip, 3, nullptr, false) {}
CRainSplashGenerator::SSplashLine::SSplashLine()
: m_renderer(CLineRenderer::EPrimitiveMode::LineStrip, 3, nullptr, false) {}
CRainSplashGenerator::SRainSplash::SRainSplash(boo::IGraphicsDataFactory::Context& ctx) {
CRainSplashGenerator::SRainSplash::SRainSplash() {
for (size_t i = 0; i < x0_lines.capacity(); ++i) {
x0_lines.emplace_back(ctx);
x0_lines.emplace_back();
}
}

4
Runtime/Graphics/CRainSplashGenerator.hpp
View File

@ -24,7 +24,7 @@ class CRainSplashGenerator {
u8 x15_length = 1;
bool x16_active = true; // used to be one-bit bitfield
CLineRenderer m_renderer;
explicit SSplashLine(boo::IGraphicsDataFactory::Context& ctx);
explicit SSplashLine();
void Update(float dt, CStateManager& mgr);
void Draw(float alpha, float dt, const zeus::CVector3f& pos);
void SetActive() { x16_active = true; }
@ -33,7 +33,7 @@ class CRainSplashGenerator {
rstl::reserved_vector<SSplashLine, 4> x0_lines;
zeus::CVector3f x64_pos;
float x70_ = 0.f;
explicit SRainSplash(boo::IGraphicsDataFactory::Context& ctx);
explicit SRainSplash();
SRainSplash(const SRainSplash&) = delete;
SRainSplash& operator=(const SRainSplash&) = delete;
SRainSplash(SRainSplash&&) = default;

51
Runtime/Graphics/CSkinnedModel.cpp
View File

@ -9,7 +9,7 @@ namespace metaforce {
static logvisor::Module Log("metaforce::CSkinnedModel");
CSkinnedModel::CSkinnedModel(TLockedToken<CModel> model, TLockedToken<CSkinRules> skinRules,
TLockedToken<CCharLayoutInfo> layoutInfo, int shaderIdx, int drawInsts)
TLockedToken<CCharLayoutInfo> layoutInfo, int shaderIdx)
: x4_model(std::move(model)), x10_skinRules(std::move(skinRules)), x1c_layoutInfo(std::move(layoutInfo)) {
if (!x4_model) {
Log.report(logvisor::Fatal, FMT_STRING("bad model token provided to CSkinnedModel"));
@ -20,35 +20,36 @@ CSkinnedModel::CSkinnedModel(TLockedToken<CModel> model, TLockedToken<CSkinRules
if (!x1c_layoutInfo) {
Log.report(logvisor::Fatal, FMT_STRING("bad character layout token provided to CSkinnedModel"));
}
m_modelInst = x4_model->MakeNewInstance(shaderIdx, drawInsts);
m_modelInst = x4_model->MakeNewInstance(shaderIdx);
}
CSkinnedModel::CSkinnedModel(IObjectStore& store, CAssetId model, CAssetId skinRules, CAssetId layoutInfo,
int shaderIdx, int drawInsts)
int shaderIdx)
: CSkinnedModel(store.GetObj(SObjectTag{FOURCC('CMDL'), model}), store.GetObj(SObjectTag{FOURCC('CSKR'), skinRules}),
store.GetObj(SObjectTag{FOURCC('CINF'), layoutInfo}), shaderIdx, drawInsts) {}
store.GetObj(SObjectTag{FOURCC('CINF'), layoutInfo}), shaderIdx) {}
void CSkinnedModel::Calculate(const CPoseAsTransforms& pose, const CModelFlags& drawFlags,
const std::optional<CVertexMorphEffect>& morphEffect, const float* morphMagnitudes) {
if (morphEffect || g_PointGenFunc) {
if (boo::ObjToken<boo::IGraphicsBufferD> vertBuf = m_modelInst->UpdateUniformData(drawFlags, nullptr, nullptr)) {
x10_skinRules->TransformVerticesCPU(m_vertWorkspace, pose, *x4_model);
if (morphEffect)
morphEffect->MorphVertices(m_vertWorkspace, morphMagnitudes, x10_skinRules, pose);
if (g_PointGenFunc)
g_PointGenFunc(g_PointGenCtx, m_vertWorkspace);
x4_model->ApplyVerticesCPU(vertBuf, m_vertWorkspace);
m_modifiedVBO = true;
}
} else {
if (boo::ObjToken<boo::IGraphicsBufferD> vertBuf =
m_modelInst->UpdateUniformData(drawFlags, x10_skinRules.GetObj(), &pose)) {
if (m_modifiedVBO) {
x4_model->RestoreVerticesCPU(vertBuf);
m_modifiedVBO = false;
}
}
}
// TODO
// if (morphEffect || g_PointGenFunc) {
// if (boo::ObjToken<boo::IGraphicsBufferD> vertBuf = m_modelInst->UpdateUniformData(drawFlags, nullptr, nullptr)) {
// x10_skinRules->TransformVerticesCPU(m_vertWorkspace, pose, *x4_model);
// if (morphEffect)
// morphEffect->MorphVertices(m_vertWorkspace, morphMagnitudes, x10_skinRules, pose);
// if (g_PointGenFunc)
// g_PointGenFunc(g_PointGenCtx, m_vertWorkspace);
// x4_model->ApplyVerticesCPU(vertBuf, m_vertWorkspace);
// m_modifiedVBO = true;
// }
// } else {
// if (boo::ObjToken<boo::IGraphicsBufferD> vertBuf =
// m_modelInst->UpdateUniformData(drawFlags, x10_skinRules.GetObj(), &pose)) {
// if (m_modifiedVBO) {
// x4_model->RestoreVerticesCPU(vertBuf);
// m_modifiedVBO = false;
// }
// }
// }
}
void CSkinnedModel::Draw(const CModelFlags& drawFlags) const {
@ -58,8 +59,8 @@ void CSkinnedModel::Draw(const CModelFlags& drawFlags) const {
}
CMorphableSkinnedModel::CMorphableSkinnedModel(IObjectStore& store, CAssetId model, CAssetId skinRules,
CAssetId layoutInfo, int shaderIdx, int drawInsts)
: CSkinnedModel(store, model, skinRules, layoutInfo, shaderIdx, drawInsts) {}
CAssetId layoutInfo, int shaderIdx)
: CSkinnedModel(store, model, skinRules, layoutInfo, shaderIdx) {}
CSkinnedModel::FPointGenerator CSkinnedModel::g_PointGenFunc = nullptr;
void* CSkinnedModel::g_PointGenCtx = nullptr;

12
Runtime/Graphics/CSkinnedModel.hpp
View File

@ -30,11 +30,10 @@ class CSkinnedModel {
public:
enum class EDataOwnership { Zero, One };
CSkinnedModel(TLockedToken<CModel> model, TLockedToken<CSkinRules> skinRules,
TLockedToken<CCharLayoutInfo> layoutInfo, int shaderIdx, int drawInsts);
CSkinnedModel(IObjectStore& store, CAssetId model, CAssetId skinRules, CAssetId layoutInfo, int shaderIdx,
int drawInsts);
std::unique_ptr<CSkinnedModel> Clone(int shaderIdx = 0, int drawInsts = 1) const {
return std::make_unique<CSkinnedModel>(x4_model, x10_skinRules, x1c_layoutInfo, shaderIdx, drawInsts);
TLockedToken<CCharLayoutInfo> layoutInfo, int shaderIdx);
CSkinnedModel(IObjectStore& store, CAssetId model, CAssetId skinRules, CAssetId layoutInfo, int shaderIdx);
std::unique_ptr<CSkinnedModel> Clone(int shaderIdx = 0) const {
return std::make_unique<CSkinnedModel>(x4_model, x10_skinRules, x1c_layoutInfo, shaderIdx);
}
const TLockedToken<CModel>& GetModel() const { return x4_model; }
@ -61,8 +60,7 @@ class CMorphableSkinnedModel : public CSkinnedModel {
std::unique_ptr<float[]> x40_morphMagnitudes;
public:
CMorphableSkinnedModel(IObjectStore& store, CAssetId model, CAssetId skinRules, CAssetId layoutInfo, int shaderIdx,
int drawInsts);
CMorphableSkinnedModel(IObjectStore& store, CAssetId model, CAssetId skinRules, CAssetId layoutInfo, int shaderIdx);
const float* GetMorphMagnitudes() const { return x40_morphMagnitudes.get(); }
};

48
Runtime/Graphics/CTexture.hpp
View File

@ -9,7 +9,7 @@
#include "Runtime/IOStreams.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
namespace metaforce {
class CVParamTransfer;
@ -32,34 +32,35 @@ private:
u16 x4_w;
u16 x6_h;
u32 x8_mips;
boo::ObjToken<boo::ITexture> m_booTex;
boo::ObjToken<boo::ITexture> m_paletteTex;
// boo::ObjToken<boo::ITexture> m_booTex;
std::shared_ptr<aurora::TextureHandle> m_tex;
std::shared_ptr<aurora::TextureHandle> m_paletteTex;
std::unique_ptr<u8[]> m_otex;
EFontType m_ftype = EFontType::None;
const CTextureInfo* m_textureInfo;
size_t ComputeMippedTexelCount() const;
size_t ComputeMippedBlockCountDXT1() const;
void BuildI4FromGCN(CInputStream& in);
void BuildI8FromGCN(CInputStream& in);
void BuildIA4FromGCN(CInputStream& in);
void BuildIA8FromGCN(CInputStream& in);
void BuildC4FromGCN(CInputStream& in);
void BuildC8FromGCN(CInputStream& in);
void BuildC14X2FromGCN(CInputStream& in);
void BuildRGB565FromGCN(CInputStream& in);
void BuildRGB5A3FromGCN(CInputStream& in);
void BuildRGBA8FromGCN(CInputStream& in);
void BuildDXT1FromGCN(CInputStream& in);
void BuildRGBA8(const void* data, size_t length);
void BuildC8(const void* data, size_t length);
void BuildC8Font(const void* data, EFontType ftype);
void BuildDXT1(const void* data, size_t length);
void BuildDXT3(const void* data, size_t length);
void BuildI4FromGCN(CInputStream& in, std::string_view label);
void BuildI8FromGCN(CInputStream& in, std::string_view label);
void BuildIA4FromGCN(CInputStream& in, std::string_view label);
void BuildIA8FromGCN(CInputStream& in, std::string_view label);
void BuildC4FromGCN(CInputStream& in, std::string_view label);
void BuildC8FromGCN(CInputStream& in, std::string_view label);
void BuildC14X2FromGCN(CInputStream& in, std::string_view label);
void BuildRGB565FromGCN(CInputStream& in, std::string_view label);
void BuildRGB5A3FromGCN(CInputStream& in, std::string_view label);
void BuildRGBA8FromGCN(CInputStream& in, std::string_view label);
void BuildDXT1FromGCN(CInputStream& in, std::string_view label);
void BuildRGBA8(const void* data, size_t length, std::string_view label);
void BuildC8(const void* data, size_t length, std::string_view label);
void BuildC8Font(const void* data, EFontType ftype, std::string_view label);
void BuildDXT1(const void* data, size_t length, std::string_view label);
void BuildDXT3(const void* data, size_t length, std::string_view label);
public:
CTexture(ETexelFormat, s16, s16, s32);
CTexture(std::unique_ptr<u8[]>&& in, u32 length, bool otex, const CTextureInfo* inf);
CTexture(std::unique_ptr<u8[]>&& in, u32 length, bool otex, const CTextureInfo* inf, CAssetId id);
enum class EClampMode { None, One };
ETexelFormat GetTexelFormat() const { return x0_fmt; }
ETexelFormat GetMemoryCardTexelFormat() const {
@ -69,10 +70,11 @@ public:
u16 GetHeight() const { return x6_h; }
u32 GetNumMips() const { return x8_mips; }
void Load(int slot, EClampMode clamp) const;
const boo::ObjToken<boo::ITexture>& GetBooTexture() const { return m_booTex; }
const boo::ObjToken<boo::ITexture>& GetPaletteTexture() const { return m_paletteTex; }
const std::shared_ptr<aurora::TextureHandle>& GetTexture() const { return m_tex; }
// const boo::ObjToken<boo::ITexture>& GetBooTexture() const { return m_booTex; }
const std::shared_ptr<aurora::TextureHandle>& GetPaletteTexture() const { return m_paletteTex; }
std::unique_ptr<u8[]> BuildMemoryCardTex(u32& sizeOut, ETexelFormat& fmtOut, std::unique_ptr<u8[]>& paletteOut) const;
const boo::ObjToken<boo::ITexture>& GetFontTexture(EFontType tp);
const std::shared_ptr<aurora::TextureHandle>& GetFontTexture(EFontType tp);
const CTextureInfo* GetTextureInfo() const { return m_textureInfo; }
};

248
Runtime/Graphics/CTextureBoo.cpp
View File

@ -75,7 +75,7 @@ size_t CTexture::ComputeMippedBlockCountDXT1() const {
return ret;
}
void CTexture::BuildI4FromGCN(CInputStream& in) {
void CTexture::BuildI4FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -89,11 +89,11 @@ void CTexture::BuildI4FromGCN(CInputStream& in) {
const int baseY = by * 8;
for (int bx = 0; bx < bwidth; ++bx) {
const int baseX = bx * 8;
for (int y = 0; y < 8; ++y) {
for (int y = 0; y < std::min(h, 8); ++y) {
RGBA8* target = targetMip + (baseY + y) * w + baseX;
std::array<u8, 4> source;
in.readBytesToBuf(source.data(), source.size());
for (size_t x = 0; x < 8; ++x) {
in.readBytesToBuf(source.data(), std::min(size_t(w) / 4, source.size()));
for (size_t x = 0; x < std::min(w, 8); ++x) {
target[x].r = Convert4To8(source[x / 2] >> ((x & 1) ? 0 : 4) & 0xf);
target[x].g = target[x].r;
target[x].b = target[x].r;
@ -111,15 +111,11 @@ void CTexture::BuildI4FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildI8FromGCN(CInputStream& in) {
void CTexture::BuildI8FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -155,15 +151,11 @@ void CTexture::BuildI8FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildIA4FromGCN(CInputStream& in) {
void CTexture::BuildIA4FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -200,15 +192,11 @@ void CTexture::BuildIA4FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildIA8FromGCN(CInputStream& in) {
void CTexture::BuildIA8FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -245,12 +233,8 @@ void CTexture::BuildIA8FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
static std::vector<RGBA8> DecodePalette(int numEntries, CInputStream& in) {
@ -294,7 +278,7 @@ static std::vector<RGBA8> DecodePalette(int numEntries, CInputStream& in) {
return ret;
}
void CTexture::BuildC4FromGCN(CInputStream& in) {
void CTexture::BuildC4FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
std::vector<RGBA8> palette = DecodePalette(16, in);
@ -328,15 +312,11 @@ void CTexture::BuildC4FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildC8FromGCN(CInputStream& in) {
void CTexture::BuildC8FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
std::vector<RGBA8> palette = DecodePalette(256, in);
@ -370,17 +350,15 @@ void CTexture::BuildC8FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildC14X2FromGCN(CInputStream& in) {}
void CTexture::BuildC14X2FromGCN(CInputStream& in, std::string_view label) {
Log.report(logvisor::Fatal, FMT_STRING("C14X2 not implemented"));
}
void CTexture::BuildRGB565FromGCN(CInputStream& in) {
void CTexture::BuildRGB565FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -415,15 +393,11 @@ void CTexture::BuildRGB565FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildRGB5A3FromGCN(CInputStream& in) {
void CTexture::BuildRGB5A3FromGCN(CInputStream& in, std::string_view label) {
size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -465,15 +439,11 @@ void CTexture::BuildRGB5A3FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildRGBA8FromGCN(CInputStream& in) {
void CTexture::BuildRGBA8FromGCN(CInputStream& in, std::string_view label) {
const size_t texelCount = ComputeMippedTexelCount();
std::unique_ptr<RGBA8[]> buf(new RGBA8[texelCount]);
@ -514,15 +484,11 @@ void CTexture::BuildRGBA8FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
buf.get(), texelCount * 4)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(buf.get()), texelCount * 4}, label);
}
void CTexture::BuildDXT1FromGCN(CInputStream& in) {
void CTexture::BuildDXT1FromGCN(CInputStream& in, std::string_view label) {
const size_t blockCount = ComputeMippedBlockCountDXT1();
std::unique_ptr<DXT1Block[]> buf(new DXT1Block[blockCount]);
@ -566,48 +532,35 @@ void CTexture::BuildDXT1FromGCN(CInputStream& in) {
}
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::DXT1, boo::TextureClampMode::Repeat,
buf.get(), blockCount * 8)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::DXT1,
{reinterpret_cast<const uint8_t*>(buf.get()), blockCount * 8}, label);
}
void CTexture::BuildRGBA8(const void* data, size_t length) {
void CTexture::BuildRGBA8(const void* data, size_t length, std::string_view label) {
size_t texelCount = ComputeMippedTexelCount();
size_t expectedSize = texelCount * 4;
if (expectedSize > length)
Log.report(logvisor::Fatal, FMT_STRING("insufficient TXTR length ({}/{})"), length, expectedSize);
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat, data,
expectedSize)
.get();
return true;
} BooTrace);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::RGBA8,
{reinterpret_cast<const uint8_t*>(data), expectedSize}, label);
}
void CTexture::BuildC8(const void* data, size_t length) {
void CTexture::BuildC8(const void* data, size_t length, std::string_view label) {
size_t texelCount = ComputeMippedTexelCount();
if (texelCount > length)
Log.report(logvisor::Fatal, FMT_STRING("insufficient TXTR length ({}/{})"), length, texelCount);
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
uint32_t nentries = hecl::SBig(*reinterpret_cast<const uint32_t*>(data));
const u8* paletteTexels = reinterpret_cast<const u8*>(data) + 4;
const u8* texels = reinterpret_cast<const u8*>(data) + 4 + nentries * 4;
m_paletteTex = ctx.newStaticTexture(nentries, 1, 1, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat,
paletteTexels, nentries * 4)
.get();
m_booTex = ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::I8, boo::TextureClampMode::Repeat, texels,
texelCount)
.get();
return true;
} BooTrace);
m_paletteTex = aurora::new_static_texture_2d(nentries, 1, 1, aurora::shaders::TextureFormat::RGBA8,
{paletteTexels, nentries * 4}, label);
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::R8, {texels, texelCount},
label);
}
void CTexture::BuildC8Font(const void* data, EFontType ftype) {
void CTexture::BuildC8Font(const void* data, EFontType ftype, std::string_view label) {
size_t texelCount = ComputeMippedTexelCount();
size_t layerCount = 1;
@ -697,30 +650,58 @@ void CTexture::BuildC8Font(const void* data, EFontType ftype) {
h /= 2;
}
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex = ctx.newStaticArrayTexture(x4_w, x6_h, layerCount, x8_mips, boo::TextureFormat::RGBA8,
boo::TextureClampMode::Repeat, buf.get(), texelCount * layerCount * 4)
.get();
return true;
} BooTrace);
// TODO array tex
// CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
// m_booTex = ctx.newStaticArrayTexture(x4_w, x6_h, layerCount, x8_mips, boo::TextureFormat::RGBA8,
// boo::TextureClampMode::Repeat, buf.get(), texelCount * layerCount * 4)
// .get();
// return true;
// } BooTrace);
}
void CTexture::BuildDXT1(const void* data, size_t length) {
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex =
ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::DXT1, boo::TextureClampMode::Repeat, data, length)
.get();
return true;
} BooTrace);
void CTexture::BuildDXT1(const void* data, size_t length, std::string_view label) {
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::DXT1,
{reinterpret_cast<const uint8_t*>(data), length}, label);
}
void CTexture::BuildDXT3(const void* data, size_t length) {
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_booTex =
ctx.newStaticTexture(x4_w, x6_h, x8_mips, boo::TextureFormat::DXT3, boo::TextureClampMode::Repeat, data, length)
.get();
return true;
} BooTrace);
void CTexture::BuildDXT3(const void* data, size_t length, std::string_view label) {
m_tex = aurora::new_static_texture_2d(x4_w, x6_h, x8_mips, aurora::shaders::TextureFormat::DXT3,
{reinterpret_cast<const uint8_t*>(data), length}, label);
}
static std::string_view TextureFormatString(ETexelFormat format) {
switch (format) {
case ETexelFormat::I4:
return "I4"sv;
case ETexelFormat::I8:
return "I8"sv;
case ETexelFormat::IA4:
return "IA4"sv;
case ETexelFormat::IA8:
return "IA8"sv;
case ETexelFormat::C4:
return "C4"sv;
case ETexelFormat::C8:
return "C8"sv;
case ETexelFormat::C14X2:
return "C14X2"sv;
case ETexelFormat::RGB565:
return "RGB565"sv;
case ETexelFormat::RGB5A3:
return "RGB5A3"sv;
case ETexelFormat::RGBA8:
return "RGBA8"sv;
case ETexelFormat::CMPR:
return "CMPR"sv;
case ETexelFormat::RGBA8PC:
return "RGBA8PC"sv;
case ETexelFormat::C8PC:
return "C8PC"sv;
case ETexelFormat::CMPRPC:
return "CMPRPC"sv;
case ETexelFormat::CMPRPCA:
return "CMPRPCA"sv;
}
}
CTexture::CTexture(ETexelFormat fmt, s16 w, s16 h, s32 mips) : x0_fmt(fmt), x4_w(w), x6_h(h), x8_mips(mips) {
@ -731,8 +712,8 @@ CTexture::CTexture(ETexelFormat fmt, s16 w, s16 h, s32 mips) : x0_fmt(fmt), x4_w
*/
}
CTexture::CTexture(std::unique_ptr<u8[]>&& in, u32 length, bool otex, const CTextureInfo* inf) {
m_textureInfo = inf;
CTexture::CTexture(std::unique_ptr<u8[]>&& in, u32 length, bool otex, const CTextureInfo* inf, CAssetId id)
: m_textureInfo(inf) {
std::unique_ptr<u8[]> owned = std::move(in);
athena::io::MemoryReader r(owned.get(), length);
x0_fmt = ETexelFormat(r.readUint32Big());
@ -740,52 +721,53 @@ CTexture::CTexture(std::unique_ptr<u8[]>&& in, u32 length, bool otex, const CTex
x6_h = r.readUint16Big();
x8_mips = r.readUint32Big();
auto label = fmt::format(FMT_STRING("TXTR {:08X} ({})"), id.Value(), TextureFormatString(x0_fmt));
switch (x0_fmt) {
case ETexelFormat::I4:
BuildI4FromGCN(r);
BuildI4FromGCN(r, label);
break;
case ETexelFormat::I8:
BuildI8FromGCN(r);
BuildI8FromGCN(r, label);
break;
case ETexelFormat::IA4:
BuildIA4FromGCN(r);
BuildIA4FromGCN(r, label);
break;
case ETexelFormat::IA8:
BuildIA8FromGCN(r);
BuildIA8FromGCN(r, label);
break;
case ETexelFormat::C4:
BuildC4FromGCN(r);
BuildC4FromGCN(r, label);
break;
case ETexelFormat::C8:
BuildC8FromGCN(r);
BuildC8FromGCN(r, label);
break;
case ETexelFormat::C14X2:
BuildC14X2FromGCN(r);
BuildC14X2FromGCN(r, label);
break;
case ETexelFormat::RGB565:
BuildRGB565FromGCN(r);
BuildRGB565FromGCN(r, label);
break;
case ETexelFormat::RGB5A3:
BuildRGB5A3FromGCN(r);
BuildRGB5A3FromGCN(r, label);
break;
case ETexelFormat::RGBA8:
BuildRGBA8FromGCN(r);
BuildRGBA8FromGCN(r, label);
break;
case ETexelFormat::CMPR:
BuildDXT1FromGCN(r);
BuildDXT1FromGCN(r, label);
break;
case ETexelFormat::RGBA8PC:
BuildRGBA8(owned.get() + 12, length - 12);
BuildRGBA8(owned.get() + 12, length - 12, label);
break;
case ETexelFormat::C8PC:
BuildC8(owned.get() + 12, length - 12);
BuildC8(owned.get() + 12, length - 12, label);
otex = true;
break;
case ETexelFormat::CMPRPC:
BuildDXT1(owned.get() + 12, length - 12);
BuildDXT1(owned.get() + 12, length - 12, label);
break;
case ETexelFormat::CMPRPCA:
BuildDXT3(owned.get() + 12, length - 12);
BuildDXT3(owned.get() + 12, length - 12, label);
break;
default:
Log.report(logvisor::Fatal, FMT_STRING("invalid texture type {} for boo"), int(x0_fmt));
@ -881,12 +863,12 @@ std::unique_ptr<u8[]> CTexture::BuildMemoryCardTex(u32& sizeOut, ETexelFormat& f
return ret;
}
const boo::ObjToken<boo::ITexture>& CTexture::GetFontTexture(EFontType tp) {
const std::shared_ptr<aurora::TextureHandle>& CTexture::GetFontTexture(EFontType tp) {
if (m_ftype != tp && x0_fmt == ETexelFormat::C8PC) {
m_ftype = tp;
BuildC8Font(m_otex.get() + 12, m_ftype);
BuildC8Font(m_otex.get() + 12, m_ftype, "Font (TODO)"sv);
}
return m_booTex;
return m_tex;
}
CFactoryFnReturn FTextureFactory(const metaforce::SObjectTag& tag, std::unique_ptr<u8[]>&& in, u32 len,
@ -896,7 +878,7 @@ CFactoryFnReturn FTextureFactory(const metaforce::SObjectTag& tag, std::unique_p
if (g_TextureCache)
inf = g_TextureCache->GetTextureInfo(tag.id);
return TToken<CTexture>::GetIObjObjectFor(
std::make_unique<CTexture>(std::move(in), len, u32Owned == SBIG('OTEX'), inf));
std::make_unique<CTexture>(std::move(in), len, u32Owned == SBIG('OTEX'), inf, tag.id));
}
} // namespace metaforce

44
Runtime/Graphics/Shaders/CAABoxShader.cpp
View File

@ -4,35 +4,35 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
#include <zeus/CAABox.hpp>
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
static boo::ObjToken<boo::IShaderPipeline> s_zOnlyPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_zOnlyPipeline;
void CAABoxShader::Initialize() {
s_Pipeline = hecl::conv->convert(Shader_CAABoxShader{});
s_zOnlyPipeline = hecl::conv->convert(Shader_CAABoxShaderZOnly{});
// s_Pipeline = hecl::conv->convert(Shader_CAABoxShader{});
// s_zOnlyPipeline = hecl::conv->convert(Shader_CAABoxShaderZOnly{});
}
void CAABoxShader::Shutdown() {
s_Pipeline.reset();
s_zOnlyPipeline.reset();
// s_Pipeline.reset();
// s_zOnlyPipeline.reset();
}
CAABoxShader::CAABoxShader(bool zOnly) {
CGraphics::CommitResources([this, zOnly](boo::IGraphicsDataFactory::Context& ctx) {
m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(zeus::CVector3f), 34);
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
m_dataBind =
ctx.newShaderDataBinding(zOnly ? s_zOnlyPipeline : s_Pipeline, m_vbo.get(), nullptr, nullptr, bufs.size(),
bufs.data(), stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
return true;
} BooTrace);
// CGraphics::CommitResources([this, zOnly](boo::IGraphicsDataFactory::Context& ctx) {
// m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(zeus::CVector3f), 34);
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// m_dataBind =
// ctx.newShaderDataBinding(zOnly ? s_zOnlyPipeline : s_Pipeline, m_vbo.get(), nullptr, nullptr, bufs.size(),
// bufs.data(), stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
// return true;
// } BooTrace);
}
void CAABoxShader::setAABB(const zeus::CAABox& aabb) {
@ -62,7 +62,7 @@ void CAABoxShader::setAABB(const zeus::CAABox& aabb) {
{aabb.max.x(), aabb.max.y(), aabb.min.z()},
}};
m_vbo->load(vboData.data(), sizeof(vboData));
// m_vbo->load(vboData.data(), sizeof(vboData));
}
void CAABoxShader::draw(const zeus::CColor& color) {
@ -70,10 +70,10 @@ void CAABoxShader::draw(const zeus::CColor& color) {
m_uniform.m_xf = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
m_uniform.m_color = color;
m_uniBuf->load(&m_uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_dataBind);
CGraphics::DrawArray(0, 34);
// m_uniBuf->load(&m_uniform, sizeof(Uniform));
//
// CGraphics::SetShaderDataBinding(m_dataBind);
// CGraphics::DrawArray(0, 34);
}
} // namespace metaforce

8
Runtime/Graphics/Shaders/CAABoxShader.hpp
View File

@ -1,6 +1,6 @@
#pragma once
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -16,9 +16,9 @@ class CAABoxShader {
zeus::CMatrix4f m_xf;
zeus::CColor m_color;
};
boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
// boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
Uniform m_uniform;
public:

40
Runtime/Graphics/Shaders/CCameraBlurFilter.cpp
View File

@ -6,7 +6,7 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
#include <zeus/CVector2f.hpp>
namespace metaforce {
@ -16,24 +16,28 @@ struct Vert {
zeus::CVector2f m_uv;
};
boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
//boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
} // Anonymous namespace
void CCameraBlurFilter::Initialize() { s_Pipeline = hecl::conv->convert(Shader_CCameraBlurFilter{}); }
void CCameraBlurFilter::Initialize() {
// s_Pipeline = hecl::conv->convert(Shader_CCameraBlurFilter{});
}
void CCameraBlurFilter::Shutdown() { s_Pipeline.reset(); }
void CCameraBlurFilter::Shutdown() {
// s_Pipeline.reset();
}
CCameraBlurFilter::CCameraBlurFilter() {
CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, 32, 4);
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
constexpr std::array stages{boo::PipelineStage::Vertex};
const std::array<boo::ObjToken<boo::ITexture>, 1> texs{CGraphics::g_SpareTexture.get()};
m_dataBind = ctx.newShaderDataBinding(s_Pipeline, m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
stages.data(), nullptr, nullptr, texs.size(), texs.data(), nullptr, nullptr);
return true;
} BooTrace);
// CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
// m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, 32, 4);
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
// constexpr std::array stages{boo::PipelineStage::Vertex};
// const std::array<boo::ObjToken<boo::ITexture>, 1> texs{CGraphics::g_SpareTexture.get()};
// m_dataBind = ctx.newShaderDataBinding(s_Pipeline, m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
// stages.data(), nullptr, nullptr, texs.size(), texs.data(), nullptr, nullptr);
// return true;
// } BooTrace);
}
void CCameraBlurFilter::draw(float amount, bool clearDepth) {
@ -58,7 +62,7 @@ void CCameraBlurFilter::draw(float amount, bool clearDepth) {
{{1.0, -1.0}, {xBias + xFac, yBias}},
{{1.0, 1.0}, {xBias + xFac, yBias + yFac}},
}};
m_vbo->load(verts.data(), sizeof(verts));
// m_vbo->load(verts.data(), sizeof(verts));
for (size_t i = 0; i < m_uniform.m_uv.size(); ++i) {
auto tmp = static_cast<float>(i);
@ -75,10 +79,10 @@ void CCameraBlurFilter::draw(float amount, bool clearDepth) {
m_uniform.m_uv[i][1] = amtY * yFac;
}
m_uniform.m_opacity = std::min(amount / 2.f, 1.f);
m_uniBuf->load(&m_uniform, sizeof(m_uniform));
// m_uniBuf->load(&m_uniform, sizeof(m_uniform));
CGraphics::SetShaderDataBinding(m_dataBind);
CGraphics::DrawArray(0, 4);
// CGraphics::SetShaderDataBinding(m_dataBind);
// CGraphics::DrawArray(0, 4);
}
} // namespace metaforce

8
Runtime/Graphics/Shaders/CCameraBlurFilter.hpp
View File

@ -1,7 +1,7 @@
#pragma once
#include <array>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CVector4f.hpp>
namespace metaforce {
@ -12,9 +12,9 @@ class CCameraBlurFilter {
float m_opacity = 1.f;
};
boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
// boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
Uniform m_uniform;
public:

116
Runtime/Graphics/Shaders/CColoredQuadFilter.cpp
View File

@ -5,61 +5,61 @@
#include "Runtime/Camera/CCameraFilter.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_AlphaPipeline;
static boo::ObjToken<boo::IShaderPipeline> s_AddPipeline;
static boo::ObjToken<boo::IShaderPipeline> s_MultPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_AlphaPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_AddPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_MultPipeline;
void CColoredQuadFilter::Initialize() {
s_AlphaPipeline = hecl::conv->convert(Shader_CColoredQuadFilter{});
s_AddPipeline = hecl::conv->convert(Shader_CColoredQuadFilterAdd{});
s_MultPipeline = hecl::conv->convert(Shader_CColoredQuadFilterMul{});
// s_AlphaPipeline = hecl::conv->convert(Shader_CColoredQuadFilter{});
// s_AddPipeline = hecl::conv->convert(Shader_CColoredQuadFilterAdd{});
// s_MultPipeline = hecl::conv->convert(Shader_CColoredQuadFilterMul{});
}
void CColoredQuadFilter::Shutdown() {
s_AlphaPipeline.reset();
s_AddPipeline.reset();
s_MultPipeline.reset();
// s_AlphaPipeline.reset();
// s_AddPipeline.reset();
// s_MultPipeline.reset();
}
static boo::ObjToken<boo::IShaderPipeline> SelectPipeline(EFilterType type) {
switch (type) {
case EFilterType::Blend:
return s_AlphaPipeline;
case EFilterType::Add:
return s_AddPipeline;
case EFilterType::Multiply:
return s_MultPipeline;
default:
return s_AlphaPipeline;
}
}
//static boo::ObjToken<boo::IShaderPipeline> SelectPipeline(EFilterType type) {
// switch (type) {
// case EFilterType::Blend:
// return s_AlphaPipeline;
// case EFilterType::Add:
// return s_AddPipeline;
// case EFilterType::Multiply:
// return s_MultPipeline;
// default:
// return s_AlphaPipeline;
// }
//}
CColoredQuadFilter::CColoredQuadFilter(EFilterType type) {
CGraphics::CommitResources([this, type](boo::IGraphicsDataFactory::Context& ctx) {
struct Vert {
zeus::CVector2f m_pos;
};
const std::array<Vert, 4> verts{{
{{0.0, 0.0}},
{{0.0, 1.0}},
{{1.0, 0.0}},
{{1.0, 1.0}},
}};
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), 16, verts.size());
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
m_dataBind = ctx.newShaderDataBinding(SelectPipeline(type), m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
return true;
} BooTrace);
// CGraphics::CommitResources([this, type](boo::IGraphicsDataFactory::Context& ctx) {
// struct Vert {
// zeus::CVector2f m_pos;
// };
//
// const std::array<Vert, 4> verts{{
// {{0.0, 0.0}},
// {{0.0, 1.0}},
// {{1.0, 0.0}},
// {{1.0, 1.0}},
// }};
//
// m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), 16, verts.size());
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
//
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// m_dataBind = ctx.newShaderDataBinding(SelectPipeline(type), m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
// stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
// return true;
// } BooTrace);
}
void CColoredQuadFilter::draw(const zeus::CColor& color, const zeus::CRectangle& rect) {
@ -70,10 +70,10 @@ void CColoredQuadFilter::draw(const zeus::CColor& color, const zeus::CRectangle&
m_uniform.m_matrix[3][0] = rect.position.x() * 2.f - 1.f;
m_uniform.m_matrix[3][1] = rect.position.y() * 2.f - 1.f;
m_uniform.m_color = color;
m_uniBuf->load(&m_uniform, sizeof(m_uniform));
CGraphics::SetShaderDataBinding(m_dataBind);
CGraphics::DrawArray(0, 4);
// m_uniBuf->load(&m_uniform, sizeof(m_uniform));
//
// CGraphics::SetShaderDataBinding(m_dataBind);
// CGraphics::DrawArray(0, 4);
}
void CWideScreenFilter::draw(const zeus::CColor& color, float t) {
@ -92,12 +92,12 @@ float CWideScreenFilter::SetViewportToMatch(float t) {
if (g_Viewport.aspect < 1.7777f) {
float targetHeight = g_Viewport.x8_width / 1.7777f;
float delta = (g_Viewport.xc_height - targetHeight) * t / 2.f;
boo::SWindowRect rect = {};
rect.size[0] = g_Viewport.x8_width;
rect.size[1] = g_Viewport.xc_height - delta * 2.f;
rect.location[1] = delta;
CGraphics::g_CroppedViewport = rect;
CGraphics::g_BooMainCommandQueue->setViewport(rect);
// boo::SWindowRect rect = {};
// rect.size[0] = g_Viewport.x8_width;
// rect.size[1] = g_Viewport.xc_height - delta * 2.f;
// rect.location[1] = delta;
// CGraphics::g_CroppedViewport = rect;
// CGraphics::g_BooMainCommandQueue->setViewport(rect);
return 1.7777f;
} else {
SetViewportToFull();
@ -106,11 +106,11 @@ float CWideScreenFilter::SetViewportToMatch(float t) {
}
void CWideScreenFilter::SetViewportToFull() {
boo::SWindowRect rect = {};
rect.size[0] = g_Viewport.x8_width;
rect.size[1] = g_Viewport.xc_height;
CGraphics::g_CroppedViewport = rect;
CGraphics::g_BooMainCommandQueue->setViewport(rect);
// boo::SWindowRect rect = {};
// rect.size[0] = g_Viewport.x8_width;
// rect.size[1] = g_Viewport.xc_height;
// CGraphics::g_CroppedViewport = rect;
// CGraphics::g_BooMainCommandQueue->setViewport(rect);
}
} // namespace metaforce

8
Runtime/Graphics/Shaders/CColoredQuadFilter.hpp
View File

@ -2,7 +2,7 @@
#include "Runtime/CToken.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -19,9 +19,9 @@ class CColoredQuadFilter {
zeus::CMatrix4f m_matrix;
zeus::CColor m_color;
};
boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
// boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
Uniform m_uniform;
public:

113
Runtime/Graphics/Shaders/CColoredStripShader.cpp
View File

@ -6,84 +6,79 @@
#include "Runtime/Graphics/CBooRenderer.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
static boo::ObjToken<boo::IShaderPipeline> s_AdditivePipeline;
static boo::ObjToken<boo::IShaderPipeline> s_FullAdditivePipeline;
static boo::ObjToken<boo::IShaderPipeline> s_SubtractivePipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_AdditivePipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_FullAdditivePipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_SubtractivePipeline;
void CColoredStripShader::Initialize() {
s_Pipeline = hecl::conv->convert(Shader_CColoredStripShader{});
s_AdditivePipeline = hecl::conv->convert(Shader_CColoredStripShaderAdditive{});
s_FullAdditivePipeline = hecl::conv->convert(Shader_CColoredStripShaderFullAdditive{});
s_SubtractivePipeline = hecl::conv->convert(Shader_CColoredStripShaderSubtractive{});
// s_Pipeline = hecl::conv->convert(Shader_CColoredStripShader{});
// s_AdditivePipeline = hecl::conv->convert(Shader_CColoredStripShaderAdditive{});
// s_FullAdditivePipeline = hecl::conv->convert(Shader_CColoredStripShaderFullAdditive{});
// s_SubtractivePipeline = hecl::conv->convert(Shader_CColoredStripShaderSubtractive{});
}
void CColoredStripShader::Shutdown() {
s_Pipeline.reset();
s_AdditivePipeline.reset();
s_FullAdditivePipeline.reset();
s_SubtractivePipeline.reset();
// s_Pipeline.reset();
// s_AdditivePipeline.reset();
// s_FullAdditivePipeline.reset();
// s_SubtractivePipeline.reset();
}
static const boo::ObjToken<boo::IShaderPipeline>& SelectPipeline(CColoredStripShader::Mode mode) {
switch (mode) {
case CColoredStripShader::Mode::Alpha:
default:
return s_Pipeline;
case CColoredStripShader::Mode::Additive:
return s_AdditivePipeline;
case CColoredStripShader::Mode::FullAdditive:
return s_FullAdditivePipeline;
case CColoredStripShader::Mode::Subtractive:
return s_SubtractivePipeline;
}
}
//static const boo::ObjToken<boo::IShaderPipeline>& SelectPipeline(CColoredStripShader::Mode mode) {
// switch (mode) {
// case CColoredStripShader::Mode::Alpha:
// default:
// return s_Pipeline;
// case CColoredStripShader::Mode::Additive:
// return s_AdditivePipeline;
// case CColoredStripShader::Mode::FullAdditive:
// return s_FullAdditivePipeline;
// case CColoredStripShader::Mode::Subtractive:
// return s_SubtractivePipeline;
// }
//}
//
//void CColoredStripShader::BuildResources(boo::IGraphicsDataFactory::Context& ctx, size_t maxVerts, Mode mode,
// boo::ObjToken<boo::ITexture> tex) {
// m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(Vert), maxVerts);
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
//
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// std::array<boo::ObjToken<boo::ITexture>, 1> texs;
// if (tex) {
// texs[0] = tex;
// } else {
// texs[0] = g_Renderer->GetWhiteTexture();
// }
//
// m_dataBind = ctx.newShaderDataBinding(SelectPipeline(mode), m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
// stages.data(), nullptr, nullptr, texs.size(), texs.data(), nullptr, nullptr);
//}
void CColoredStripShader::BuildResources(boo::IGraphicsDataFactory::Context& ctx, size_t maxVerts, Mode mode,
boo::ObjToken<boo::ITexture> tex) {
m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(Vert), maxVerts);
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
std::array<boo::ObjToken<boo::ITexture>, 1> texs;
if (tex) {
texs[0] = tex;
} else {
texs[0] = g_Renderer->GetWhiteTexture();
}
m_dataBind = ctx.newShaderDataBinding(SelectPipeline(mode), m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
stages.data(), nullptr, nullptr, texs.size(), texs.data(), nullptr, nullptr);
}
CColoredStripShader::CColoredStripShader(size_t maxVerts, Mode mode, boo::ObjToken<boo::ITexture> tex) {
CGraphics::CommitResources([this, maxVerts, mode, tex](boo::IGraphicsDataFactory::Context& ctx) {
BuildResources(ctx, maxVerts, mode, tex);
return true;
} BooTrace);
}
CColoredStripShader::CColoredStripShader(boo::IGraphicsDataFactory::Context& ctx, size_t maxVerts, Mode mode,
boo::ObjToken<boo::ITexture> tex) {
BuildResources(ctx, maxVerts, mode, tex);
CColoredStripShader::CColoredStripShader(size_t maxVerts, Mode mode, std::shared_ptr<aurora::TextureHandle> tex) {
// CGraphics::CommitResources([this, maxVerts, mode, tex](boo::IGraphicsDataFactory::Context& ctx) {
// BuildResources(ctx, maxVerts, mode, tex);
// return true;
// } BooTrace);
}
void CColoredStripShader::draw(const zeus::CColor& color, size_t numVerts, const Vert* verts) {
SCOPED_GRAPHICS_DEBUG_GROUP("CColoredStripShader::draw", zeus::skMagenta);
m_vbo->load(verts, sizeof(Vert) * numVerts);
// m_vbo->load(verts, sizeof(Vert) * numVerts);
m_uniform.m_matrix = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
m_uniform.m_color = color;
m_uniBuf->load(&m_uniform, sizeof(m_uniform));
CGraphics::SetShaderDataBinding(m_dataBind);
CGraphics::DrawArray(0, numVerts);
// m_uniBuf->load(&m_uniform, sizeof(m_uniform));
//
// CGraphics::SetShaderDataBinding(m_dataBind);
// CGraphics::DrawArray(0, numVerts);
}
} // namespace metaforce

16
Runtime/Graphics/Shaders/CColoredStripShader.hpp
View File

@ -1,6 +1,6 @@
#pragma once
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include "Runtime/Graphics/CGraphics.hpp"
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -16,13 +16,13 @@ private:
zeus::CMatrix4f m_matrix;
zeus::CColor m_color;
};
boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
// boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
Uniform m_uniform;
void BuildResources(boo::IGraphicsDataFactory::Context& ctx, size_t maxVerts, Mode mode,
boo::ObjToken<boo::ITexture> tex);
// void BuildResources(boo::IGraphicsDataFactory::Context& ctx, size_t maxVerts, Mode mode,
// boo::ObjToken<boo::ITexture> tex);
public:
struct Vert {
@ -32,9 +32,7 @@ public:
};
static void Initialize();
static void Shutdown();
CColoredStripShader(size_t maxVerts, Mode mode, boo::ObjToken<boo::ITexture> tex);
CColoredStripShader(boo::IGraphicsDataFactory::Context& ctx, size_t maxVerts, Mode mode,
boo::ObjToken<boo::ITexture> tex);
CColoredStripShader(size_t maxVerts, Mode mode, std::shared_ptr<aurora::TextureHandle> tex);
void draw(const zeus::CColor& color, size_t numVerts, const Vert* verts);
};

106
Runtime/Graphics/Shaders/CDecalShaders.cpp
View File

@ -4,69 +4,69 @@
#include "Runtime/Particle/CDecal.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
void CDecalShaders::Initialize() {
m_texZTestNoZWrite = hecl::conv->convert(Shader_CDecalShaderTexZTest{});
m_texAdditiveZTest = hecl::conv->convert(Shader_CDecalShaderTexAdditiveZTest{});
m_texRedToAlphaZTest = hecl::conv->convert(Shader_CDecalShaderTexRedToAlphaZTest{});
m_noTexZTestNoZWrite = hecl::conv->convert(Shader_CDecalShaderNoTexZTest{});
m_noTexAdditiveZTest = hecl::conv->convert(Shader_CDecalShaderNoTexAdditiveZTest{});
// m_texZTestNoZWrite = hecl::conv->convert(Shader_CDecalShaderTexZTest{});
// m_texAdditiveZTest = hecl::conv->convert(Shader_CDecalShaderTexAdditiveZTest{});
// m_texRedToAlphaZTest = hecl::conv->convert(Shader_CDecalShaderTexRedToAlphaZTest{});
// m_noTexZTestNoZWrite = hecl::conv->convert(Shader_CDecalShaderNoTexZTest{});
// m_noTexAdditiveZTest = hecl::conv->convert(Shader_CDecalShaderNoTexAdditiveZTest{});
}
void CDecalShaders::Shutdown() {
m_texZTestNoZWrite.reset();
m_texAdditiveZTest.reset();
m_texRedToAlphaZTest.reset();
m_noTexZTestNoZWrite.reset();
m_noTexAdditiveZTest.reset();
// m_texZTestNoZWrite.reset();
// m_texAdditiveZTest.reset();
// m_texRedToAlphaZTest.reset();
// m_noTexZTestNoZWrite.reset();
// m_noTexAdditiveZTest.reset();
}
void CDecalShaders::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CQuadDecal& decal) {
boo::ObjToken<boo::IShaderPipeline> regPipeline;
boo::ObjToken<boo::IShaderPipeline> redToAlphaPipeline;
void CDecalShaders::BuildShaderDataBinding(CQuadDecal& decal) {
// boo::ObjToken<boo::IShaderPipeline> regPipeline;
// boo::ObjToken<boo::IShaderPipeline> redToAlphaPipeline;
if (decal.m_desc->x14_TEX) {
if (decal.m_desc->x18_ADD)
regPipeline = m_texAdditiveZTest;
else
regPipeline = m_texZTestNoZWrite;
redToAlphaPipeline = m_texRedToAlphaZTest;
} else {
if (decal.m_desc->x18_ADD)
regPipeline = m_noTexAdditiveZTest;
else
regPipeline = m_noTexZTestNoZWrite;
}
const SQuadDescr* const desc = decal.m_desc;
const CUVElement* const texr = desc->x14_TEX.get();
size_t texCount = 0;
std::array<boo::ObjToken<boo::ITexture>, 1> textures;
if (texr != nullptr) {
textures[0] = texr->GetValueTexture(0).GetObj()->GetBooTexture();
texCount = 1;
}
if (!decal.m_instBuf) {
return;
}
std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{decal.m_uniformBuf.get()};
if (regPipeline) {
decal.m_normalDataBind =
ctx.newShaderDataBinding(regPipeline, nullptr, decal.m_instBuf.get(), nullptr, uniforms.size(), uniforms.data(),
nullptr, texCount, textures.data(), nullptr, nullptr);
}
if (redToAlphaPipeline) {
decal.m_redToAlphaDataBind =
ctx.newShaderDataBinding(redToAlphaPipeline, nullptr, decal.m_instBuf.get(), nullptr, uniforms.size(),
uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
}
// if (decal.m_desc->x14_TEX) {
// if (decal.m_desc->x18_ADD)
// regPipeline = m_texAdditiveZTest;
// else
// regPipeline = m_texZTestNoZWrite;
// redToAlphaPipeline = m_texRedToAlphaZTest;
// } else {
// if (decal.m_desc->x18_ADD)
// regPipeline = m_noTexAdditiveZTest;
// else
// regPipeline = m_noTexZTestNoZWrite;
// }
//
// const SQuadDescr* const desc = decal.m_desc;
// const CUVElement* const texr = desc->x14_TEX.get();
// size_t texCount = 0;
// std::array<boo::ObjToken<boo::ITexture>, 1> textures;
//
// if (texr != nullptr) {
// textures[0] = texr->GetValueTexture(0).GetObj()->GetBooTexture();
// texCount = 1;
// }
//
// if (!decal.m_instBuf) {
// return;
// }
//
// std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{decal.m_uniformBuf.get()};
//
// if (regPipeline) {
// decal.m_normalDataBind =
// ctx.newShaderDataBinding(regPipeline, nullptr, decal.m_instBuf.get(), nullptr, uniforms.size(), uniforms.data(),
// nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// if (redToAlphaPipeline) {
// decal.m_redToAlphaDataBind =
// ctx.newShaderDataBinding(redToAlphaPipeline, nullptr, decal.m_instBuf.get(), nullptr, uniforms.size(),
// uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
// }
}
} // namespace metaforce

16
Runtime/Graphics/Shaders/CDecalShaders.hpp
View File

@ -1,23 +1,23 @@
#pragma once
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
namespace metaforce {
struct CQuadDecal;
class CDecalShaders {
private:
static inline boo::ObjToken<boo::IShaderPipeline> m_texZTestNoZWrite;
static inline boo::ObjToken<boo::IShaderPipeline> m_texAdditiveZTest;
static inline boo::ObjToken<boo::IShaderPipeline> m_texRedToAlphaZTest;
static inline boo::ObjToken<boo::IShaderPipeline> m_noTexZTestNoZWrite;
static inline boo::ObjToken<boo::IShaderPipeline> m_noTexAdditiveZTest;
// static inline boo::ObjToken<boo::IShaderPipeline> m_texZTestNoZWrite;
// static inline boo::ObjToken<boo::IShaderPipeline> m_texAdditiveZTest;
// static inline boo::ObjToken<boo::IShaderPipeline> m_texRedToAlphaZTest;
//
// static inline boo::ObjToken<boo::IShaderPipeline> m_noTexZTestNoZWrite;
// static inline boo::ObjToken<boo::IShaderPipeline> m_noTexAdditiveZTest;
public:
static void Initialize();
static void Shutdown();
static void BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CQuadDecal& decal);
static void BuildShaderDataBinding(CQuadDecal& decal);
};
} // namespace metaforce

534
Runtime/Graphics/Shaders/CElementGenShaders.cpp
View File

@ -4,116 +4,116 @@
#include "Runtime/Particle/CElementGen.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
void CElementGenShaders::Initialize() {
m_texZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexZTestZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderTexZTestZWrite{})};
m_texNoZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexNoZTestZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderTexNoZTestZWriteAWrite{})};
m_texZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWriteAWrite{})};
m_texNoZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWriteAWrite{})};
m_texAdditiveZTest = {hecl::conv->convert(Shader_CElementGenShaderTexAdditiveZTest{}),
hecl::conv->convert(Shader_CElementGenShaderTexAdditiveZTestAWrite{})};
m_texAdditiveNoZTest = {hecl::conv->convert(Shader_CElementGenShaderTexAdditiveNoZTest{}),
hecl::conv->convert(Shader_CElementGenShaderTexAdditiveNoZTestAWrite{})};
m_texRedToAlphaZTest = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTest{}),
hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTestAWrite{})};
m_texRedToAlphaNoZTest = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTest{}),
hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTestAWrite{})};
m_texZTestNoZWriteSub = {hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWriteSub{}),
hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWriteSubAWrite{})};
m_texNoZTestNoZWriteSub = {hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWriteSub{}),
hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWriteSubAWrite{})};
m_texRedToAlphaZTestSub = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTestSub{}),
hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTestSubAWrite{})};
m_texRedToAlphaNoZTestSub = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTestSub{}),
hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTestSubAWrite{})};
m_indTexZWrite = {hecl::conv->convert(Shader_CElementGenShaderIndTexZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderIndTexZWriteAWrite{})};
m_indTexNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderIndTexNoZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderIndTexNoZWriteAWrite{})};
m_indTexAdditive = {hecl::conv->convert(Shader_CElementGenShaderIndTexAdditive{}),
hecl::conv->convert(Shader_CElementGenShaderIndTexAdditiveAWrite{})};
m_cindTexZWrite = {hecl::conv->convert(Shader_CElementGenShaderCindTexZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderCindTexZWriteAWrite{})};
m_cindTexNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderCindTexNoZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderCindTexNoZWriteAWrite{})};
m_cindTexAdditive = {hecl::conv->convert(Shader_CElementGenShaderCindTexAdditive{}),
hecl::conv->convert(Shader_CElementGenShaderCindTexAdditiveAWrite{})};
m_noTexZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexZTestZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderNoTexZTestZWriteAWrite{})};
m_noTexNoZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestZWriteAWrite{})};
m_noTexZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexZTestNoZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderNoTexZTestNoZWriteAWrite{})};
m_noTexNoZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestNoZWrite{}),
hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestNoZWriteAWrite{})};
m_noTexAdditiveZTest = {hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveZTest{}),
hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveZTestAWrite{})};
m_noTexAdditiveNoZTest = {hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveNoZTest{}),
hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveNoZTestAWrite{})};
// m_texZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexZTestZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderTexZTestZWrite{})};
// m_texNoZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexNoZTestZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderTexNoZTestZWriteAWrite{})};
// m_texZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWriteAWrite{})};
// m_texNoZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWriteAWrite{})};
// m_texAdditiveZTest = {hecl::conv->convert(Shader_CElementGenShaderTexAdditiveZTest{}),
// hecl::conv->convert(Shader_CElementGenShaderTexAdditiveZTestAWrite{})};
// m_texAdditiveNoZTest = {hecl::conv->convert(Shader_CElementGenShaderTexAdditiveNoZTest{}),
// hecl::conv->convert(Shader_CElementGenShaderTexAdditiveNoZTestAWrite{})};
// m_texRedToAlphaZTest = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTest{}),
// hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTestAWrite{})};
// m_texRedToAlphaNoZTest = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTest{}),
// hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTestAWrite{})};
// m_texZTestNoZWriteSub = {hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWriteSub{}),
// hecl::conv->convert(Shader_CElementGenShaderTexZTestNoZWriteSubAWrite{})};
// m_texNoZTestNoZWriteSub = {hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWriteSub{}),
// hecl::conv->convert(Shader_CElementGenShaderTexNoZTestNoZWriteSubAWrite{})};
// m_texRedToAlphaZTestSub = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTestSub{}),
// hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaZTestSubAWrite{})};
// m_texRedToAlphaNoZTestSub = {hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTestSub{}),
// hecl::conv->convert(Shader_CElementGenShaderTexRedToAlphaNoZTestSubAWrite{})};
//
// m_indTexZWrite = {hecl::conv->convert(Shader_CElementGenShaderIndTexZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderIndTexZWriteAWrite{})};
// m_indTexNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderIndTexNoZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderIndTexNoZWriteAWrite{})};
// m_indTexAdditive = {hecl::conv->convert(Shader_CElementGenShaderIndTexAdditive{}),
// hecl::conv->convert(Shader_CElementGenShaderIndTexAdditiveAWrite{})};
//
// m_cindTexZWrite = {hecl::conv->convert(Shader_CElementGenShaderCindTexZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderCindTexZWriteAWrite{})};
// m_cindTexNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderCindTexNoZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderCindTexNoZWriteAWrite{})};
// m_cindTexAdditive = {hecl::conv->convert(Shader_CElementGenShaderCindTexAdditive{}),
// hecl::conv->convert(Shader_CElementGenShaderCindTexAdditiveAWrite{})};
//
// m_noTexZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexZTestZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderNoTexZTestZWriteAWrite{})};
// m_noTexNoZTestZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestZWriteAWrite{})};
// m_noTexZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexZTestNoZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderNoTexZTestNoZWriteAWrite{})};
// m_noTexNoZTestNoZWrite = {hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestNoZWrite{}),
// hecl::conv->convert(Shader_CElementGenShaderNoTexNoZTestNoZWriteAWrite{})};
// m_noTexAdditiveZTest = {hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveZTest{}),
// hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveZTestAWrite{})};
// m_noTexAdditiveNoZTest = {hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveNoZTest{}),
// hecl::conv->convert(Shader_CElementGenShaderNoTexAdditiveNoZTestAWrite{})};
}
void CElementGenShaders::Shutdown() {
for (auto& s : m_texZTestZWrite)
s.reset();
for (auto& s : m_texNoZTestZWrite)
s.reset();
for (auto& s : m_texZTestNoZWrite)
s.reset();
for (auto& s : m_texNoZTestNoZWrite)
s.reset();
for (auto& s : m_texAdditiveZTest)
s.reset();
for (auto& s : m_texAdditiveNoZTest)
s.reset();
for (auto& s : m_texRedToAlphaZTest)
s.reset();
for (auto& s : m_texRedToAlphaNoZTest)
s.reset();
for (auto& s : m_texZTestNoZWriteSub)
s.reset();
for (auto& s : m_texNoZTestNoZWriteSub)
s.reset();
for (auto& s : m_texRedToAlphaZTestSub)
s.reset();
for (auto& s : m_texRedToAlphaNoZTestSub)
s.reset();
for (auto& s : m_indTexZWrite)
s.reset();
for (auto& s : m_indTexNoZWrite)
s.reset();
for (auto& s : m_indTexAdditive)
s.reset();
for (auto& s : m_cindTexZWrite)
s.reset();
for (auto& s : m_cindTexNoZWrite)
s.reset();
for (auto& s : m_cindTexAdditive)
s.reset();
for (auto& s : m_noTexZTestZWrite)
s.reset();
for (auto& s : m_noTexNoZTestZWrite)
s.reset();
for (auto& s : m_noTexZTestNoZWrite)
s.reset();
for (auto& s : m_noTexNoZTestNoZWrite)
s.reset();
for (auto& s : m_noTexAdditiveZTest)
s.reset();
for (auto& s : m_noTexAdditiveNoZTest)
s.reset();
// for (auto& s : m_texZTestZWrite)
// s.reset();
// for (auto& s : m_texNoZTestZWrite)
// s.reset();
// for (auto& s : m_texZTestNoZWrite)
// s.reset();
// for (auto& s : m_texNoZTestNoZWrite)
// s.reset();
// for (auto& s : m_texAdditiveZTest)
// s.reset();
// for (auto& s : m_texAdditiveNoZTest)
// s.reset();
// for (auto& s : m_texRedToAlphaZTest)
// s.reset();
// for (auto& s : m_texRedToAlphaNoZTest)
// s.reset();
// for (auto& s : m_texZTestNoZWriteSub)
// s.reset();
// for (auto& s : m_texNoZTestNoZWriteSub)
// s.reset();
// for (auto& s : m_texRedToAlphaZTestSub)
// s.reset();
// for (auto& s : m_texRedToAlphaNoZTestSub)
// s.reset();
//
// for (auto& s : m_indTexZWrite)
// s.reset();
// for (auto& s : m_indTexNoZWrite)
// s.reset();
// for (auto& s : m_indTexAdditive)
// s.reset();
//
// for (auto& s : m_cindTexZWrite)
// s.reset();
// for (auto& s : m_cindTexNoZWrite)
// s.reset();
// for (auto& s : m_cindTexAdditive)
// s.reset();
//
// for (auto& s : m_noTexZTestZWrite)
// s.reset();
// for (auto& s : m_noTexNoZTestZWrite)
// s.reset();
// for (auto& s : m_noTexZTestNoZWrite)
// s.reset();
// for (auto& s : m_noTexNoZTestNoZWrite)
// s.reset();
// for (auto& s : m_noTexAdditiveZTest)
// s.reset();
// for (auto& s : m_noTexAdditiveNoZTest)
// s.reset();
}
CElementGenShaders::EShaderClass CElementGenShaders::GetShaderClass(CElementGen& gen) {
@ -128,171 +128,171 @@ CElementGenShaders::EShaderClass CElementGenShaders::GetShaderClass(CElementGen&
return EShaderClass::NoTex;
}
void CElementGenShaders::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CElementGen& gen) {
void CElementGenShaders::BuildShaderDataBinding(CElementGen& gen) {
CGenDescription* desc = gen.x1c_genDesc.GetObj();
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* regPipeline = nullptr;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* regPipelineSub = nullptr;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* redToAlphaPipeline = nullptr;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* redToAlphaPipelineSub = nullptr;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* regPipelinePmus = nullptr;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* redToAlphaPipelinePmus = nullptr;
if (gen.x26c_28_zTest) {
redToAlphaPipeline = &m_texRedToAlphaZTest;
regPipelineSub = &m_texZTestNoZWriteSub;
redToAlphaPipelineSub = &m_texRedToAlphaZTestSub;
} else {
redToAlphaPipeline = &m_texRedToAlphaNoZTest;
regPipelineSub = &m_texNoZTestNoZWriteSub;
redToAlphaPipelineSub = &m_texRedToAlphaNoZTestSub;
}
if (desc->x54_x40_TEXR) {
if (desc->x58_x44_TIND) {
if (desc->x45_30_x32_24_CIND) {
if (gen.x26c_26_AAPH)
regPipeline = &m_cindTexAdditive;
else {
if (gen.x26c_27_ZBUF)
regPipeline = &m_cindTexZWrite;
else
regPipeline = &m_cindTexNoZWrite;
}
} else {
if (gen.x26c_26_AAPH)
regPipeline = &m_indTexAdditive;
else {
if (gen.x26c_27_ZBUF)
regPipeline = &m_indTexZWrite;
else
regPipeline = &m_indTexNoZWrite;
}
}
} else {
if (gen.x26c_26_AAPH) {
if (gen.x26c_28_zTest)
regPipeline = &m_texAdditiveZTest;
else
regPipeline = &m_texAdditiveNoZTest;
} else {
if (gen.x26c_28_zTest) {
if (gen.x26c_27_ZBUF)
regPipeline = &m_texZTestZWrite;
else
regPipeline = &m_texZTestNoZWrite;
} else {
if (gen.x26c_27_ZBUF)
regPipeline = &m_texNoZTestZWrite;
else
regPipeline = &m_texNoZTestNoZWrite;
}
}
}
} else {
if (gen.x26c_26_AAPH) {
if (gen.x26c_28_zTest)
regPipeline = &m_noTexAdditiveZTest;
else
regPipeline = &m_noTexAdditiveNoZTest;
} else {
if (gen.x26c_28_zTest) {
if (gen.x26c_27_ZBUF)
regPipeline = &m_noTexZTestZWrite;
else
regPipeline = &m_noTexZTestNoZWrite;
} else {
if (gen.x26c_27_ZBUF)
regPipeline = &m_noTexNoZTestZWrite;
else
regPipeline = &m_noTexNoZTestNoZWrite;
}
}
}
if (desc->x45_24_x31_26_PMUS) {
if (desc->x54_x40_TEXR) {
redToAlphaPipelinePmus = &m_texRedToAlphaZTest;
if (desc->x44_31_x31_25_PMAB)
regPipelinePmus = &m_texAdditiveZTest;
else
regPipelinePmus = &m_texZTestZWrite;
} else {
if (desc->x44_31_x31_25_PMAB)
regPipelinePmus = &m_noTexAdditiveZTest;
else
regPipelinePmus = &m_noTexZTestZWrite;
}
}
const CUVElement* const texr = desc->x54_x40_TEXR.get();
const CUVElement* const tind = desc->x58_x44_TIND.get();
int texCount = 0;
std::array<boo::ObjToken<boo::ITexture>, 3> textures;
if (texr) {
textures[0] = texr->GetValueTexture(0).GetObj()->GetBooTexture();
texCount = 1;
if (gen.m_instBuf) {
if (tind) {
textures[1] = CGraphics::g_SpareTexture.get();
textures[2] = tind->GetValueTexture(0).GetObj()->GetBooTexture();
texCount = 3;
}
}
}
if (gen.m_instBuf) {
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{gen.m_uniformBuf.get()};
if (regPipeline != nullptr) {
for (size_t i = 0; i < gen.m_normalDataBind.size(); ++i) {
gen.m_normalDataBind[i] =
ctx.newShaderDataBinding((*regPipeline)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(),
uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
}
}
if (regPipelineSub != nullptr) {
for (size_t i = 0; i < gen.m_normalSubDataBind.size(); ++i) {
gen.m_normalSubDataBind[i] =
ctx.newShaderDataBinding((*regPipelineSub)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(),
uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
}
}
if (redToAlphaPipeline != nullptr) {
for (size_t i = 0; i < gen.m_redToAlphaDataBind.size(); ++i) {
gen.m_redToAlphaDataBind[i] =
ctx.newShaderDataBinding((*redToAlphaPipeline)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(),
uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
}
}
if (redToAlphaPipelineSub != nullptr) {
for (size_t i = 0; i < gen.m_redToAlphaSubDataBind.size(); ++i) {
gen.m_redToAlphaSubDataBind[i] = ctx.newShaderDataBinding(
(*redToAlphaPipelineSub)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(), uniforms.data(),
nullptr, texCount, textures.data(), nullptr, nullptr);
}
}
}
if (gen.m_instBufPmus) {
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{gen.m_uniformBufPmus.get()};
texCount = std::min(texCount, 1);
if (regPipelinePmus != nullptr) {
for (size_t i = 0; i < gen.m_normalDataBindPmus.size(); ++i) {
gen.m_normalDataBindPmus[i] =
ctx.newShaderDataBinding((*regPipelinePmus)[i], nullptr, gen.m_instBufPmus.get(), nullptr, uniforms.size(),
uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
}
}
if (redToAlphaPipelinePmus != nullptr) {
for (size_t i = 0; i < gen.m_redToAlphaDataBindPmus.size(); ++i) {
gen.m_redToAlphaDataBindPmus[i] = ctx.newShaderDataBinding(
(*redToAlphaPipelinePmus)[i], nullptr, gen.m_instBufPmus.get(), nullptr, uniforms.size(), uniforms.data(),
nullptr, texCount, textures.data(), nullptr, nullptr);
}
}
}
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* regPipeline = nullptr;
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* regPipelineSub = nullptr;
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* redToAlphaPipeline = nullptr;
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* redToAlphaPipelineSub = nullptr;
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* regPipelinePmus = nullptr;
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* redToAlphaPipelinePmus = nullptr;
//
// if (gen.x26c_28_zTest) {
// redToAlphaPipeline = &m_texRedToAlphaZTest;
// regPipelineSub = &m_texZTestNoZWriteSub;
// redToAlphaPipelineSub = &m_texRedToAlphaZTestSub;
// } else {
// redToAlphaPipeline = &m_texRedToAlphaNoZTest;
// regPipelineSub = &m_texNoZTestNoZWriteSub;
// redToAlphaPipelineSub = &m_texRedToAlphaNoZTestSub;
// }
//
// if (desc->x54_x40_TEXR) {
// if (desc->x58_x44_TIND) {
// if (desc->x45_30_x32_24_CIND) {
// if (gen.x26c_26_AAPH)
// regPipeline = &m_cindTexAdditive;
// else {
// if (gen.x26c_27_ZBUF)
// regPipeline = &m_cindTexZWrite;
// else
// regPipeline = &m_cindTexNoZWrite;
// }
// } else {
// if (gen.x26c_26_AAPH)
// regPipeline = &m_indTexAdditive;
// else {
// if (gen.x26c_27_ZBUF)
// regPipeline = &m_indTexZWrite;
// else
// regPipeline = &m_indTexNoZWrite;
// }
// }
// } else {
// if (gen.x26c_26_AAPH) {
// if (gen.x26c_28_zTest)
// regPipeline = &m_texAdditiveZTest;
// else
// regPipeline = &m_texAdditiveNoZTest;
// } else {
// if (gen.x26c_28_zTest) {
// if (gen.x26c_27_ZBUF)
// regPipeline = &m_texZTestZWrite;
// else
// regPipeline = &m_texZTestNoZWrite;
// } else {
// if (gen.x26c_27_ZBUF)
// regPipeline = &m_texNoZTestZWrite;
// else
// regPipeline = &m_texNoZTestNoZWrite;
// }
// }
// }
// } else {
// if (gen.x26c_26_AAPH) {
// if (gen.x26c_28_zTest)
// regPipeline = &m_noTexAdditiveZTest;
// else
// regPipeline = &m_noTexAdditiveNoZTest;
// } else {
// if (gen.x26c_28_zTest) {
// if (gen.x26c_27_ZBUF)
// regPipeline = &m_noTexZTestZWrite;
// else
// regPipeline = &m_noTexZTestNoZWrite;
// } else {
// if (gen.x26c_27_ZBUF)
// regPipeline = &m_noTexNoZTestZWrite;
// else
// regPipeline = &m_noTexNoZTestNoZWrite;
// }
// }
// }
//
// if (desc->x45_24_x31_26_PMUS) {
// if (desc->x54_x40_TEXR) {
// redToAlphaPipelinePmus = &m_texRedToAlphaZTest;
// if (desc->x44_31_x31_25_PMAB)
// regPipelinePmus = &m_texAdditiveZTest;
// else
// regPipelinePmus = &m_texZTestZWrite;
// } else {
// if (desc->x44_31_x31_25_PMAB)
// regPipelinePmus = &m_noTexAdditiveZTest;
// else
// regPipelinePmus = &m_noTexZTestZWrite;
// }
// }
//
// const CUVElement* const texr = desc->x54_x40_TEXR.get();
// const CUVElement* const tind = desc->x58_x44_TIND.get();
// int texCount = 0;
// std::array<boo::ObjToken<boo::ITexture>, 3> textures;
//
// if (texr) {
// textures[0] = texr->GetValueTexture(0).GetObj()->GetBooTexture();
// texCount = 1;
// if (gen.m_instBuf) {
// if (tind) {
// textures[1] = CGraphics::g_SpareTexture.get();
// textures[2] = tind->GetValueTexture(0).GetObj()->GetBooTexture();
// texCount = 3;
// }
// }
// }
//
// if (gen.m_instBuf) {
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{gen.m_uniformBuf.get()};
//
// if (regPipeline != nullptr) {
// for (size_t i = 0; i < gen.m_normalDataBind.size(); ++i) {
// gen.m_normalDataBind[i] =
// ctx.newShaderDataBinding((*regPipeline)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(),
// uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// }
// if (regPipelineSub != nullptr) {
// for (size_t i = 0; i < gen.m_normalSubDataBind.size(); ++i) {
// gen.m_normalSubDataBind[i] =
// ctx.newShaderDataBinding((*regPipelineSub)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(),
// uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// }
// if (redToAlphaPipeline != nullptr) {
// for (size_t i = 0; i < gen.m_redToAlphaDataBind.size(); ++i) {
// gen.m_redToAlphaDataBind[i] =
// ctx.newShaderDataBinding((*redToAlphaPipeline)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(),
// uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// }
// if (redToAlphaPipelineSub != nullptr) {
// for (size_t i = 0; i < gen.m_redToAlphaSubDataBind.size(); ++i) {
// gen.m_redToAlphaSubDataBind[i] = ctx.newShaderDataBinding(
// (*redToAlphaPipelineSub)[i], nullptr, gen.m_instBuf.get(), nullptr, uniforms.size(), uniforms.data(),
// nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// }
// }
//
// if (gen.m_instBufPmus) {
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{gen.m_uniformBufPmus.get()};
// texCount = std::min(texCount, 1);
//
// if (regPipelinePmus != nullptr) {
// for (size_t i = 0; i < gen.m_normalDataBindPmus.size(); ++i) {
// gen.m_normalDataBindPmus[i] =
// ctx.newShaderDataBinding((*regPipelinePmus)[i], nullptr, gen.m_instBufPmus.get(), nullptr, uniforms.size(),
// uniforms.data(), nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// }
// if (redToAlphaPipelinePmus != nullptr) {
// for (size_t i = 0; i < gen.m_redToAlphaDataBindPmus.size(); ++i) {
// gen.m_redToAlphaDataBindPmus[i] = ctx.newShaderDataBinding(
// (*redToAlphaPipelinePmus)[i], nullptr, gen.m_instBufPmus.get(), nullptr, uniforms.size(), uniforms.data(),
// nullptr, texCount, textures.data(), nullptr, nullptr);
// }
// }
// }
}
} // namespace metaforce

58
Runtime/Graphics/Shaders/CElementGenShaders.hpp
View File

@ -2,7 +2,7 @@
#include <array>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
namespace metaforce {
class CElementGen;
@ -12,39 +12,39 @@ public:
enum class EShaderClass { Tex, IndTex, NoTex };
private:
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZTestZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZTestZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZTestNoZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZTestNoZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveZTest;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveNoZTest;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaZTest;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaNoZTest;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZTestNoZWriteSub;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZTestNoZWriteSub;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaZTestSub;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaNoZTestSub;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_indTexZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_indTexNoZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_indTexAdditive;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_cindTexZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_cindTexNoZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_cindTexAdditive;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexZTestZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexNoZTestZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexZTestNoZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexNoZTestNoZWrite;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveZTest;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveNoZTest;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZTestZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZTestZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZTestNoZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZTestNoZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveZTest;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveNoZTest;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaZTest;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaNoZTest;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZTestNoZWriteSub;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZTestNoZWriteSub;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaZTestSub;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texRedToAlphaNoZTestSub;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_indTexZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_indTexNoZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_indTexAdditive;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_cindTexZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_cindTexNoZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_cindTexAdditive;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexZTestZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexNoZTestZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexZTestNoZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexNoZTestNoZWrite;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveZTest;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveNoZTest;
public:
static void Initialize();
static void Shutdown();
static EShaderClass GetShaderClass(CElementGen& gen);
static void BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CElementGen& gen);
static void BuildShaderDataBinding(CElementGen& gen);
};
} // namespace metaforce

90
Runtime/Graphics/Shaders/CEnergyBarShader.cpp
View File

@ -5,15 +5,19 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include "Runtime/Graphics/CTexture.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
void CEnergyBarShader::Initialize() { s_Pipeline = hecl::conv->convert(Shader_CEnergyBarShader{}); }
void CEnergyBarShader::Initialize() {
// s_Pipeline = hecl::conv->convert(Shader_CEnergyBarShader{});
}
void CEnergyBarShader::Shutdown() { s_Pipeline.reset(); }
void CEnergyBarShader::Shutdown() {
// s_Pipeline.reset();
}
void CEnergyBarShader::updateModelMatrix() {
m_uniform.m_matrix = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
@ -31,60 +35,60 @@ void CEnergyBarShader::draw(const zeus::CColor& color0, const std::vector<Vertex
if (totalVerts > m_maxVerts) {
m_maxVerts = totalVerts;
m_tex = tex;
CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(Vertex), m_maxVerts);
std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs;
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
const std::array<boo::ObjToken<boo::ITexture>, 1> texs{m_tex->GetBooTexture()};
for (size_t i = 0; i < m_uniBuf.size(); ++i) {
m_uniBuf[i] = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
bufs[0] = m_uniBuf[i].get();
m_dataBind[i] =
ctx.newShaderDataBinding(s_Pipeline, m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(), stages.data(),
nullptr, nullptr, texs.size(), texs.data(), nullptr, nullptr);
}
return true;
} BooTrace);
// CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
// m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(Vertex), m_maxVerts);
//
// std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs;
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// const std::array<boo::ObjToken<boo::ITexture>, 1> texs{m_tex->GetBooTexture()};
//
// for (size_t i = 0; i < m_uniBuf.size(); ++i) {
// m_uniBuf[i] = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
// bufs[0] = m_uniBuf[i].get();
// m_dataBind[i] =
// ctx.newShaderDataBinding(s_Pipeline, m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(), stages.data(),
// nullptr, nullptr, texs.size(), texs.data(), nullptr, nullptr);
// }
//
// return true;
// } BooTrace);
}
size_t vertIter = 0;
Vertex* verts = reinterpret_cast<Vertex*>(m_vbo->map(sizeof(Vertex) * totalVerts));
if (verts0.size()) {
memmove(verts, verts0.data(), sizeof(Vertex) * verts0.size());
vertIter += verts0.size();
}
if (verts1.size()) {
memmove(verts + vertIter, verts1.data(), sizeof(Vertex) * verts1.size());
vertIter += verts1.size();
}
if (verts2.size()) {
memmove(verts + vertIter, verts2.data(), sizeof(Vertex) * verts2.size());
}
m_vbo->unmap();
// Vertex* verts = reinterpret_cast<Vertex*>(m_vbo->map(sizeof(Vertex) * totalVerts));
// if (verts0.size()) {
// memmove(verts, verts0.data(), sizeof(Vertex) * verts0.size());
// vertIter += verts0.size();
// }
// if (verts1.size()) {
// memmove(verts + vertIter, verts1.data(), sizeof(Vertex) * verts1.size());
// vertIter += verts1.size();
// }
// if (verts2.size()) {
// memmove(verts + vertIter, verts2.data(), sizeof(Vertex) * verts2.size());
// }
// m_vbo->unmap();
vertIter = 0;
if (verts0.size()) {
m_uniform.m_color = color0;
m_uniBuf[0]->load(&m_uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_dataBind[0]);
CGraphics::DrawArray(0, verts0.size());
// m_uniBuf[0]->load(&m_uniform, sizeof(Uniform));
// CGraphics::SetShaderDataBinding(m_dataBind[0]);
// CGraphics::DrawArray(0, verts0.size());
vertIter += verts0.size();
}
if (verts1.size()) {
m_uniform.m_color = color1;
m_uniBuf[1]->load(&m_uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_dataBind[1]);
CGraphics::DrawArray(vertIter, verts1.size());
// m_uniBuf[1]->load(&m_uniform, sizeof(Uniform));
// CGraphics::SetShaderDataBinding(m_dataBind[1]);
// CGraphics::DrawArray(vertIter, verts1.size());
vertIter += verts1.size();
}
if (verts2.size()) {
m_uniform.m_color = color2;
m_uniBuf[2]->load(&m_uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_dataBind[2]);
CGraphics::DrawArray(vertIter, verts2.size());
// m_uniBuf[2]->load(&m_uniform, sizeof(Uniform));
// CGraphics::SetShaderDataBinding(m_dataBind[2]);
// CGraphics::DrawArray(vertIter, verts2.size());
}
}

8
Runtime/Graphics/Shaders/CEnergyBarShader.hpp
View File

@ -3,7 +3,7 @@
#include <array>
#include <vector>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -25,9 +25,9 @@ private:
zeus::CMatrix4f m_matrix;
zeus::CColor m_color;
};
boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
std::array<boo::ObjToken<boo::IGraphicsBufferD>, 3> m_uniBuf;
std::array<boo::ObjToken<boo::IShaderDataBinding>, 3> m_dataBind;
// boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
// std::array<boo::ObjToken<boo::IGraphicsBufferD>, 3> m_uniBuf;
// std::array<boo::ObjToken<boo::IShaderDataBinding>, 3> m_dataBind;
Uniform m_uniform;
const CTexture* m_tex = nullptr;
size_t m_maxVerts = 0;

78
Runtime/Graphics/Shaders/CEnvFxShaders.cpp
View File

@ -2,56 +2,56 @@
#include "Runtime/World/CEnvFxManager.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
boo::ObjToken<boo::IShaderPipeline> CEnvFxShaders::m_snowPipeline;
boo::ObjToken<boo::IShaderPipeline> CEnvFxShaders::m_underwaterPipeline;
//boo::ObjToken<boo::IShaderPipeline> CEnvFxShaders::m_snowPipeline;
//boo::ObjToken<boo::IShaderPipeline> CEnvFxShaders::m_underwaterPipeline;
void CEnvFxShaders::Initialize() {
m_snowPipeline = hecl::conv->convert(Shader_CEnvFxSnowShader{});
m_underwaterPipeline = hecl::conv->convert(Shader_CEnvFxUnderwaterShader{});
// m_snowPipeline = hecl::conv->convert(Shader_CEnvFxSnowShader{});
// m_underwaterPipeline = hecl::conv->convert(Shader_CEnvFxUnderwaterShader{});
}
void CEnvFxShaders::Shutdown() {
m_snowPipeline.reset();
m_underwaterPipeline.reset();
// m_snowPipeline.reset();
// m_underwaterPipeline.reset();
}
void CEnvFxShaders::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CEnvFxManager& fxMgr,
void CEnvFxShaders::BuildShaderDataBinding(CEnvFxManager& fxMgr,
CEnvFxManagerGrid& grid) {
const auto uBufInfo = grid.m_uniformBuf.getBufferInfo();
const auto iBufInfo = grid.m_instBuf.getBufferInfo();
// const auto uBufInfo = grid.m_uniformBuf.getBufferInfo();
// const auto iBufInfo = grid.m_instBuf.getBufferInfo();
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 2> uniforms{{
uBufInfo.first.get(),
fxMgr.m_fogUniformBuf.get(),
}};
const std::array<size_t, 2> ubufOffsets{
size_t(uBufInfo.second),
0,
};
constexpr std::array<size_t, 2> ubufSizes{
sizeof(CEnvFxShaders::Uniform),
sizeof(CGraphics::g_Fog),
};
constexpr std::array<boo::PipelineStage, 2> uniformStages{
boo::PipelineStage::Vertex,
boo::PipelineStage::Fragment,
};
std::array<boo::ObjToken<boo::ITexture>, 2> textures{
fxMgr.xb74_txtrSnowFlake->GetBooTexture(),
fxMgr.x40_txtrEnvGradient->GetBooTexture(),
};
grid.m_snowBinding = ctx.newShaderDataBinding(
m_snowPipeline, nullptr, iBufInfo.first.get(), nullptr, uniforms.size(), uniforms.data(), uniformStages.data(),
ubufOffsets.data(), ubufSizes.data(), textures.size(), textures.data(), nullptr, nullptr, 0, iBufInfo.second);
textures[0] = fxMgr.xc48_underwaterFlake->GetBooTexture();
grid.m_underwaterBinding =
ctx.newShaderDataBinding(m_underwaterPipeline, nullptr, iBufInfo.first.get(), nullptr, uniforms.size(),
uniforms.data(), uniformStages.data(), ubufOffsets.data(), ubufSizes.data(),
textures.size(), textures.data(), nullptr, nullptr, 0, iBufInfo.second);
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 2> uniforms{{
// uBufInfo.first.get(),
// fxMgr.m_fogUniformBuf.get(),
// }};
// const std::array<size_t, 2> ubufOffsets{
// size_t(uBufInfo.second),
// 0,
// };
// constexpr std::array<size_t, 2> ubufSizes{
// sizeof(CEnvFxShaders::Uniform),
// sizeof(CGraphics::g_Fog),
// };
// constexpr std::array<boo::PipelineStage, 2> uniformStages{
// boo::PipelineStage::Vertex,
// boo::PipelineStage::Fragment,
// };
// std::array<boo::ObjToken<boo::ITexture>, 2> textures{
// fxMgr.xb74_txtrSnowFlake->GetBooTexture(),
// fxMgr.x40_txtrEnvGradient->GetBooTexture(),
// };
//
// grid.m_snowBinding = ctx.newShaderDataBinding(
// m_snowPipeline, nullptr, iBufInfo.first.get(), nullptr, uniforms.size(), uniforms.data(), uniformStages.data(),
// ubufOffsets.data(), ubufSizes.data(), textures.size(), textures.data(), nullptr, nullptr, 0, iBufInfo.second);
// textures[0] = fxMgr.xc48_underwaterFlake->GetBooTexture();
// grid.m_underwaterBinding =
// ctx.newShaderDataBinding(m_underwaterPipeline, nullptr, iBufInfo.first.get(), nullptr, uniforms.size(),
// uniforms.data(), uniformStages.data(), ubufOffsets.data(), ubufSizes.data(),
// textures.size(), textures.data(), nullptr, nullptr, 0, iBufInfo.second);
}
} // namespace metaforce

8
Runtime/Graphics/Shaders/CEnvFxShaders.hpp
View File

@ -2,7 +2,7 @@
#include <array>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -28,13 +28,13 @@ public:
};
private:
static boo::ObjToken<boo::IShaderPipeline> m_snowPipeline;
static boo::ObjToken<boo::IShaderPipeline> m_underwaterPipeline;
// static boo::ObjToken<boo::IShaderPipeline> m_snowPipeline;
// static boo::ObjToken<boo::IShaderPipeline> m_underwaterPipeline;
public:
static void Initialize();
static void Shutdown();
static void BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CEnvFxManager& fxMgr,
static void BuildShaderDataBinding(CEnvFxManager& fxMgr,
CEnvFxManagerGrid& grid);
};

472
Runtime/Graphics/Shaders/CFluidPlaneShader.cpp
View File

@ -3,200 +3,202 @@
#include "Runtime/World/CRipple.hpp"
#include "Runtime/World/CRippleManager.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
CFluidPlaneShader::Cache CFluidPlaneShader::_cache = {};
u16 CFluidPlaneShader::Cache::MakeCacheKey(const SFluidPlaneShaderInfo& info) {
u16 ret = 0;
switch (info.m_type) {
case EFluidType::NormalWater:
case EFluidType::PhazonFluid:
case EFluidType::Four:
if (info.m_hasLightmap) {
ret |= 1 << 2;
if (info.m_doubleLightmapBlend)
ret |= 1 << 3;
}
if (!info.m_hasEnvMap && info.m_hasEnvBumpMap)
ret |= 1 << 4;
if (info.m_hasEnvMap)
ret |= 1 << 5;
break;
case EFluidType::PoisonWater:
ret |= 1;
if (info.m_hasLightmap) {
ret |= 1 << 2;
if (info.m_doubleLightmapBlend)
ret |= 1 << 3;
}
if (info.m_hasEnvBumpMap)
ret |= 1 << 4;
break;
case EFluidType::Lava:
ret |= 2;
if (info.m_hasBumpMap)
ret |= 1 << 2;
break;
case EFluidType::ThickLava:
ret |= 3;
if (info.m_hasBumpMap)
ret |= 1 << 2;
break;
}
if (info.m_hasPatternTex1)
ret |= 1 << 6;
if (info.m_hasPatternTex2)
ret |= 1 << 7;
if (info.m_hasColorTex)
ret |= 1 << 8;
if (info.m_additive)
ret |= 1 << 9;
return ret;
}
u16 CFluidPlaneShader::Cache::MakeCacheKey(const SFluidPlaneDoorShaderInfo& info) {
u16 ret = 0;
if (info.m_hasPatternTex1)
ret |= 1 << 0;
if (info.m_hasPatternTex2)
ret |= 1 << 1;
if (info.m_hasColorTex)
ret |= 1 << 2;
return ret;
}
template <>
CFluidPlaneShader::ShaderPair
CFluidPlaneShader::Cache::GetOrBuildShader<SFluidPlaneShaderInfo>(const SFluidPlaneShaderInfo& info) {
OPTICK_EVENT();
u16 key = MakeCacheKey(info);
auto& slot = CacheSlot(info, key);
if (slot.m_regular)
return slot;
slot.m_regular = hecl::conv->convert(Shader_CFluidPlaneShader{info, false});
if (info.m_tessellation)
slot.m_tessellation = hecl::conv->convert(Shader_CFluidPlaneShader{info, true});
return slot;
}
template <>
CFluidPlaneShader::ShaderPair
CFluidPlaneShader::Cache::GetOrBuildShader<SFluidPlaneDoorShaderInfo>(const SFluidPlaneDoorShaderInfo& info) {
OPTICK_EVENT();
u16 key = MakeCacheKey(info);
auto& slot = CacheSlot(info, key);
if (slot.m_regular)
return slot;
slot.m_regular = hecl::conv->convert(Shader_CFluidPlaneDoorShader{info});
return slot;
}
void CFluidPlaneShader::Cache::Clear() {
for (auto& p : m_cache)
p.reset();
for (auto& p : m_doorCache)
p.reset();
}
//CFluidPlaneShader::Cache CFluidPlaneShader::_cache = {};
//
//u16 CFluidPlaneShader::Cache::MakeCacheKey(const SFluidPlaneShaderInfo& info) {
// u16 ret = 0;
//
// switch (info.m_type) {
// case EFluidType::NormalWater:
// case EFluidType::PhazonFluid:
// case EFluidType::Four:
// if (info.m_hasLightmap) {
// ret |= 1 << 2;
// if (info.m_doubleLightmapBlend)
// ret |= 1 << 3;
// }
//
// if (!info.m_hasEnvMap && info.m_hasEnvBumpMap)
// ret |= 1 << 4;
//
// if (info.m_hasEnvMap)
// ret |= 1 << 5;
//
// break;
//
// case EFluidType::PoisonWater:
// ret |= 1;
//
// if (info.m_hasLightmap) {
// ret |= 1 << 2;
// if (info.m_doubleLightmapBlend)
// ret |= 1 << 3;
// }
//
// if (info.m_hasEnvBumpMap)
// ret |= 1 << 4;
//
// break;
//
// case EFluidType::Lava:
// ret |= 2;
//
// if (info.m_hasBumpMap)
// ret |= 1 << 2;
//
// break;
//
// case EFluidType::ThickLava:
// ret |= 3;
//
// if (info.m_hasBumpMap)
// ret |= 1 << 2;
//
// break;
// }
//
// if (info.m_hasPatternTex1)
// ret |= 1 << 6;
// if (info.m_hasPatternTex2)
// ret |= 1 << 7;
// if (info.m_hasColorTex)
// ret |= 1 << 8;
//
// if (info.m_additive)
// ret |= 1 << 9;
//
// return ret;
//}
//
//u16 CFluidPlaneShader::Cache::MakeCacheKey(const SFluidPlaneDoorShaderInfo& info) {
// u16 ret = 0;
//
// if (info.m_hasPatternTex1)
// ret |= 1 << 0;
// if (info.m_hasPatternTex2)
// ret |= 1 << 1;
// if (info.m_hasColorTex)
// ret |= 1 << 2;
//
// return ret;
//}
//
//template <>
//CFluidPlaneShader::ShaderPair
//CFluidPlaneShader::Cache::GetOrBuildShader<SFluidPlaneShaderInfo>(const SFluidPlaneShaderInfo& info) {
// OPTICK_EVENT();
// u16 key = MakeCacheKey(info);
// auto& slot = CacheSlot(info, key);
// if (slot.m_regular)
// return slot;
//
// slot.m_regular = hecl::conv->convert(Shader_CFluidPlaneShader{info, false});
// if (info.m_tessellation)
// slot.m_tessellation = hecl::conv->convert(Shader_CFluidPlaneShader{info, true});
//
// return slot;
//}
//template <>
//CFluidPlaneShader::ShaderPair
//CFluidPlaneShader::Cache::GetOrBuildShader<SFluidPlaneDoorShaderInfo>(const SFluidPlaneDoorShaderInfo& info) {
// OPTICK_EVENT();
// u16 key = MakeCacheKey(info);
// auto& slot = CacheSlot(info, key);
// if (slot.m_regular)
// return slot;
//
// slot.m_regular = hecl::conv->convert(Shader_CFluidPlaneDoorShader{info});
//
// return slot;
//}
//
//void CFluidPlaneShader::Cache::Clear() {
// for (auto& p : m_cache)
// p.reset();
// for (auto& p : m_doorCache)
// p.reset();
//}
void CFluidPlaneShader::PrepareBinding(u32 maxVertCount) {
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(Vertex), maxVertCount);
if (m_pipelines.m_tessellation) {
m_pvbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(PatchVertex), maxVertCount);
}
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 3> ubufs{{
m_uniBuf.get(),
m_uniBuf.get(),
m_uniBuf.get(),
}};
constexpr std::array<boo::PipelineStage, 3> ubufStages{
boo::PipelineStage::Vertex,
boo::PipelineStage::Vertex,
boo::PipelineStage::Fragment,
};
constexpr std::array<size_t, 3> ubufOffs{
0,
0,
1280,
};
constexpr std::array<size_t, 3> ubufSizes{
1280,
1280,
sizeof(CModelShaders::LightingUniform),
};
size_t texCount = 0;
std::array<boo::ObjToken<boo::ITexture>, 8> texs;
if (m_patternTex1) {
texs[texCount++] = m_patternTex1->GetBooTexture();
}
if (m_patternTex2) {
texs[texCount++] = m_patternTex2->GetBooTexture();
}
if (m_colorTex) {
texs[texCount++] = m_colorTex->GetBooTexture();
}
if (m_bumpMap) {
texs[texCount++] = m_bumpMap->GetBooTexture();
}
if (m_envMap) {
texs[texCount++] = m_envMap->GetBooTexture();
}
if (m_envBumpMap) {
texs[texCount++] = m_envBumpMap->GetBooTexture();
}
if (m_lightmap) {
texs[texCount++] = m_lightmap->GetBooTexture();
}
auto regular = ctx.newShaderDataBinding(m_pipelines.m_regular, m_vbo.get(), nullptr, nullptr, ubufs.size(),
ubufs.data(), ubufStages.data(), ubufOffs.data(), ubufSizes.data(),
texCount, texs.data(), nullptr, nullptr);
boo::ObjToken<boo::IShaderDataBinding> tessellation;
if (m_pipelines.m_tessellation) {
texs[texCount++] = m_rippleMap.get();
tessellation = ctx.newShaderDataBinding(m_pipelines.m_tessellation, m_pvbo.get(), nullptr, nullptr, ubufs.size(),
ubufs.data(), ubufStages.data(), ubufOffs.data(), ubufSizes.data(),
texCount, texs.data(), nullptr, nullptr);
}
m_dataBind = {regular, tessellation};
return true;
} BooTrace);
// CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
// m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(Vertex), maxVertCount);
// if (m_pipelines.m_tessellation) {
// m_pvbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(PatchVertex), maxVertCount);
// }
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
//
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 3> ubufs{{
// m_uniBuf.get(),
// m_uniBuf.get(),
// m_uniBuf.get(),
// }};
// constexpr std::array<boo::PipelineStage, 3> ubufStages{
// boo::PipelineStage::Vertex,
// boo::PipelineStage::Vertex,
// boo::PipelineStage::Fragment,
// };
// constexpr std::array<size_t, 3> ubufOffs{
// 0,
// 0,
// 1280,
// };
// constexpr std::array<size_t, 3> ubufSizes{
// 1280,
// 1280,
// sizeof(CModelShaders::LightingUniform),
// };
//
// size_t texCount = 0;
// std::array<boo::ObjToken<boo::ITexture>, 8> texs;
// if (m_patternTex1) {
// texs[texCount++] = m_patternTex1->GetBooTexture();
// }
// if (m_patternTex2) {
// texs[texCount++] = m_patternTex2->GetBooTexture();
// }
// if (m_colorTex) {
// texs[texCount++] = m_colorTex->GetBooTexture();
// }
// if (m_bumpMap) {
// texs[texCount++] = m_bumpMap->GetBooTexture();
// }
// if (m_envMap) {
// texs[texCount++] = m_envMap->GetBooTexture();
// }
// if (m_envBumpMap) {
// texs[texCount++] = m_envBumpMap->GetBooTexture();
// }
// if (m_lightmap) {
// texs[texCount++] = m_lightmap->GetBooTexture();
// }
// auto regular = ctx.newShaderDataBinding(m_pipelines.m_regular, m_vbo.get(), nullptr, nullptr, ubufs.size(),
// ubufs.data(), ubufStages.data(), ubufOffs.data(), ubufSizes.data(),
// texCount, texs.data(), nullptr, nullptr);
// boo::ObjToken<boo::IShaderDataBinding> tessellation;
// if (m_pipelines.m_tessellation) {
// texs[texCount++] = m_rippleMap.get();
// tessellation = ctx.newShaderDataBinding(m_pipelines.m_tessellation, m_pvbo.get(), nullptr, nullptr, ubufs.size(),
// ubufs.data(), ubufStages.data(), ubufOffs.data(), ubufSizes.data(),
// texCount, texs.data(), nullptr, nullptr);
// }
// m_dataBind = {regular, tessellation};
// return true;
// } BooTrace);
}
void CFluidPlaneShader::Shutdown() { _cache.Clear(); }
void CFluidPlaneShader::Shutdown() {
// _cache.Clear();
}
CFluidPlaneShader::CFluidPlaneShader(EFluidType type, const TLockedToken<CTexture>& patternTex1,
const TLockedToken<CTexture>& patternTex2, const TLockedToken<CTexture>& colorTex,
const TLockedToken<CTexture>& bumpMap, const TLockedToken<CTexture>& envMap,
const TLockedToken<CTexture>& envBumpMap, const TLockedToken<CTexture>& lightmap,
const boo::ObjToken<boo::ITextureS>& rippleMap, bool doubleLightmapBlend,
const std::shared_ptr<aurora::TextureHandle>& rippleMap, bool doubleLightmapBlend,
bool additive, u32 maxVertCount)
: m_patternTex1(patternTex1)
, m_patternTex2(patternTex2)
@ -210,7 +212,7 @@ CFluidPlaneShader::CFluidPlaneShader(EFluidType type, const TLockedToken<CTextur
m_colorTex.HasReference(), m_bumpMap.HasReference(), m_envMap.HasReference(),
m_envBumpMap.HasReference(), m_lightmap.HasReference(), m_rippleMap.operator bool(),
doubleLightmapBlend, additive);
m_pipelines = _cache.GetOrBuildShader(shaderInfo);
// m_pipelines = _cache.GetOrBuildShader(shaderInfo);
PrepareBinding(maxVertCount);
}
@ -220,70 +222,70 @@ CFluidPlaneShader::CFluidPlaneShader(const TLockedToken<CTexture>& patternTex1,
: m_patternTex1(patternTex1), m_patternTex2(patternTex2), m_colorTex(colorTex) {
SFluidPlaneDoorShaderInfo shaderInfo(m_patternTex1.HasReference(), m_patternTex2.HasReference(),
m_colorTex.HasReference());
m_pipelines = _cache.GetOrBuildShader(shaderInfo);
// m_pipelines = _cache.GetOrBuildShader(shaderInfo);
PrepareBinding(maxVertCount);
}
void CFluidPlaneShader::prepareDraw(const RenderSetupInfo& info) {
Uniform& uni = *reinterpret_cast<Uniform*>(m_uniBuf->map(sizeof(Uniform)));
uni.m_mv = CGraphics::g_GXModelView.toMatrix4f();
uni.m_mvNorm = info.normMtx;
uni.m_proj = CGraphics::GetPerspectiveProjectionMatrix(true);
uni.m_texMtxs = info.texMtxs;
uni.m_lighting.ActivateLights(info.lights);
for (size_t i = 0; i < uni.m_lighting.colorRegs.size(); ++i) {
uni.m_lighting.colorRegs[i] = info.kColors[i];
}
uni.m_lighting.mulColor = info.kColors[3];
uni.m_lighting.fog = CGraphics::g_Fog;
uni.m_pad2.x() = info.indScale;
m_uniBuf->unmap();
// Uniform& uni = *reinterpret_cast<Uniform*>(m_uniBuf->map(sizeof(Uniform)));
// uni.m_mv = CGraphics::g_GXModelView.toMatrix4f();
// uni.m_mvNorm = info.normMtx;
// uni.m_proj = CGraphics::GetPerspectiveProjectionMatrix(true);
// uni.m_texMtxs = info.texMtxs;
// uni.m_lighting.ActivateLights(info.lights);
// for (size_t i = 0; i < uni.m_lighting.colorRegs.size(); ++i) {
// uni.m_lighting.colorRegs[i] = info.kColors[i];
// }
// uni.m_lighting.mulColor = info.kColors[3];
// uni.m_lighting.fog = CGraphics::g_Fog;
// uni.m_pad2.x() = info.indScale;
// m_uniBuf->unmap();
}
void CFluidPlaneShader::prepareDraw(const RenderSetupInfo& info, const zeus::CVector3f& waterCenter,
const CRippleManager& rippleManager, const zeus::CColor& colorMul,
float rippleNormResolution) {
Uniform& uni = *reinterpret_cast<Uniform*>(m_uniBuf->map(sizeof(Uniform)));
uni.m_mv = CGraphics::g_GXModelView.toMatrix4f();
uni.m_mvNorm = info.normMtx;
uni.m_proj = CGraphics::GetPerspectiveProjectionMatrix(true);
uni.m_texMtxs = info.texMtxs;
size_t i = 0;
for (const CRipple& ripple : rippleManager.GetRipples()) {
assert(i < uni.m_ripple.size() && "Too many ripples");
Ripple& rOut = uni.m_ripple[i++];
if (ripple.GetTime() >= ripple.GetTimeFalloff()) {
rOut.center.zeroOut();
rOut.params.zeroOut();
continue;
}
zeus::CVector3f localPos = ripple.GetCenter() - waterCenter;
rOut.center.x() = float(localPos.x());
rOut.center.y() = float(localPos.y());
rOut.center.z() = ripple.GetTime() * ripple.GetOOTimeFalloff();
rOut.center.w() = ripple.GetOODistanceFalloff();
rOut.params.x() = ripple.GetAmplitude();
rOut.params.y() = ripple.GetPhase();
rOut.params.z() =
(1.f - ripple.GetTime() * ripple.GetOOTimeFalloff() * ripple.GetOOTimeFalloff()) * ripple.GetFrequency();
}
uni.m_colorMul = colorMul;
uni.m_pad[0].x() = rippleNormResolution;
uni.m_lighting.ActivateLights(info.lights);
for (i = 0; i < uni.m_lighting.colorRegs.size(); ++i) {
uni.m_lighting.colorRegs[i] = info.kColors[i];
}
uni.m_lighting.mulColor = info.kColors[3];
uni.m_lighting.fog = CGraphics::g_Fog;
uni.m_pad2.x() = info.indScale;
m_uniBuf->unmap();
// Uniform& uni = *reinterpret_cast<Uniform*>(m_uniBuf->map(sizeof(Uniform)));
// uni.m_mv = CGraphics::g_GXModelView.toMatrix4f();
// uni.m_mvNorm = info.normMtx;
// uni.m_proj = CGraphics::GetPerspectiveProjectionMatrix(true);
// uni.m_texMtxs = info.texMtxs;
//
// size_t i = 0;
// for (const CRipple& ripple : rippleManager.GetRipples()) {
// assert(i < uni.m_ripple.size() && "Too many ripples");
// Ripple& rOut = uni.m_ripple[i++];
// if (ripple.GetTime() >= ripple.GetTimeFalloff()) {
// rOut.center.zeroOut();
// rOut.params.zeroOut();
// continue;
// }
// zeus::CVector3f localPos = ripple.GetCenter() - waterCenter;
// rOut.center.x() = float(localPos.x());
// rOut.center.y() = float(localPos.y());
// rOut.center.z() = ripple.GetTime() * ripple.GetOOTimeFalloff();
// rOut.center.w() = ripple.GetOODistanceFalloff();
// rOut.params.x() = ripple.GetAmplitude();
// rOut.params.y() = ripple.GetPhase();
// rOut.params.z() =
// (1.f - ripple.GetTime() * ripple.GetOOTimeFalloff() * ripple.GetOOTimeFalloff()) * ripple.GetFrequency();
// }
// uni.m_colorMul = colorMul;
// uni.m_pad[0].x() = rippleNormResolution;
// uni.m_lighting.ActivateLights(info.lights);
// for (i = 0; i < uni.m_lighting.colorRegs.size(); ++i) {
// uni.m_lighting.colorRegs[i] = info.kColors[i];
// }
// uni.m_lighting.mulColor = info.kColors[3];
// uni.m_lighting.fog = CGraphics::g_Fog;
// uni.m_pad2.x() = info.indScale;
// m_uniBuf->unmap();
}
void CFluidPlaneShader::loadVerts(const std::vector<Vertex>& verts, const std::vector<PatchVertex>& pVerts) {
m_vbo->load(verts.data(), verts.size() * sizeof(Vertex));
if (m_pvbo)
m_pvbo->load(pVerts.data(), pVerts.size() * sizeof(PatchVertex));
// m_vbo->load(verts.data(), verts.size() * sizeof(Vertex));
// if (m_pvbo)
// m_pvbo->load(pVerts.data(), pVerts.size() * sizeof(PatchVertex));
}
} // namespace metaforce

117
Runtime/Graphics/Shaders/CFluidPlaneShader.hpp
View File

@ -10,7 +10,7 @@
#include "Shaders/shader_CFluidPlaneShader.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -53,34 +53,34 @@ public:
};
private:
struct ShaderPair {
boo::ObjToken<boo::IShaderPipeline> m_regular;
boo::ObjToken<boo::IShaderPipeline> m_tessellation;
void reset() {
m_regular.reset();
m_tessellation.reset();
}
};
// struct ShaderPair {
// boo::ObjToken<boo::IShaderPipeline> m_regular;
// boo::ObjToken<boo::IShaderPipeline> m_tessellation;
// void reset() {
// m_regular.reset();
// m_tessellation.reset();
// }
// };
//
// struct BindingPair {
// boo::ObjToken<boo::IShaderDataBinding> m_regular;
// boo::ObjToken<boo::IShaderDataBinding> m_tessellation;
// };
struct BindingPair {
boo::ObjToken<boo::IShaderDataBinding> m_regular;
boo::ObjToken<boo::IShaderDataBinding> m_tessellation;
};
class Cache {
std::array<ShaderPair, 1024> m_cache{};
std::array<ShaderPair, 8> m_doorCache{};
ShaderPair& CacheSlot(const SFluidPlaneShaderInfo& info, int i) { return m_cache[i]; }
ShaderPair& CacheSlot(const SFluidPlaneDoorShaderInfo& info, int i) { return m_doorCache[i]; }
static u16 MakeCacheKey(const SFluidPlaneShaderInfo& info);
static u16 MakeCacheKey(const SFluidPlaneDoorShaderInfo& info);
public:
template <class T>
ShaderPair GetOrBuildShader(const T& info);
void Clear();
};
static Cache _cache;
// class Cache {
// std::array<ShaderPair, 1024> m_cache{};
// std::array<ShaderPair, 8> m_doorCache{};
// ShaderPair& CacheSlot(const SFluidPlaneShaderInfo& info, int i) { return m_cache[i]; }
// ShaderPair& CacheSlot(const SFluidPlaneDoorShaderInfo& info, int i) { return m_doorCache[i]; }
// static u16 MakeCacheKey(const SFluidPlaneShaderInfo& info);
// static u16 MakeCacheKey(const SFluidPlaneDoorShaderInfo& info);
//
// public:
// template <class T>
// ShaderPair GetOrBuildShader(const T& info);
// void Clear();
// };
// static Cache _cache;
struct Ripple {
zeus::CVector4f center; // time, distFalloff
@ -106,34 +106,34 @@ private:
TLockedToken<CTexture> m_envMap;
TLockedToken<CTexture> m_envBumpMap;
TLockedToken<CTexture> m_lightmap;
boo::ObjToken<boo::ITextureS> m_rippleMap;
boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
boo::ObjToken<boo::IGraphicsBufferD> m_pvbo;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
ShaderPair m_pipelines;
BindingPair m_dataBind;
std::shared_ptr<aurora::TextureHandle> m_rippleMap;
// boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_pvbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// ShaderPair m_pipelines;
// BindingPair m_dataBind;
int m_lastBind = -1;
#if BOO_HAS_GL
static ShaderPair BuildShader(boo::GLDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
static ShaderPair BuildShader(boo::GLDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
BindingPair BuildBinding(boo::GLDataFactory::Context& ctx, const ShaderPair& pipeline);
#endif
#if _WIN32
static ShaderPair BuildShader(boo::D3D11DataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
static ShaderPair BuildShader(boo::D3D11DataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
BindingPair BuildBinding(boo::D3D11DataFactory::Context& ctx, const ShaderPair& pipeline);
#endif
#if BOO_HAS_METAL
static ShaderPair BuildShader(boo::MetalDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
static ShaderPair BuildShader(boo::MetalDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
BindingPair BuildBinding(boo::MetalDataFactory::Context& ctx, const ShaderPair& pipeline);
#endif
#if BOO_HAS_VULKAN
static ShaderPair BuildShader(boo::VulkanDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
static ShaderPair BuildShader(boo::VulkanDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
BindingPair BuildBinding(boo::VulkanDataFactory::Context& ctx, const ShaderPair& pipeline);
#endif
//#if BOO_HAS_GL
// static ShaderPair BuildShader(boo::GLDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
// static ShaderPair BuildShader(boo::GLDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
// BindingPair BuildBinding(boo::GLDataFactory::Context& ctx, const ShaderPair& pipeline);
//#endif
//#if _WIN32
// static ShaderPair BuildShader(boo::D3D11DataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
// static ShaderPair BuildShader(boo::D3D11DataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
// BindingPair BuildBinding(boo::D3D11DataFactory::Context& ctx, const ShaderPair& pipeline);
//#endif
//#if BOO_HAS_METAL
// static ShaderPair BuildShader(boo::MetalDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
// static ShaderPair BuildShader(boo::MetalDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
// BindingPair BuildBinding(boo::MetalDataFactory::Context& ctx, const ShaderPair& pipeline);
//#endif
//#if BOO_HAS_VULKAN
// static ShaderPair BuildShader(boo::VulkanDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info);
// static ShaderPair BuildShader(boo::VulkanDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info);
// BindingPair BuildBinding(boo::VulkanDataFactory::Context& ctx, const ShaderPair& pipeline);
//#endif
template <class F>
static void _Shutdown();
@ -145,7 +145,7 @@ public:
const TLockedToken<CTexture>& patternTex2, const TLockedToken<CTexture>& colorTex,
const TLockedToken<CTexture>& bumpMap, const TLockedToken<CTexture>& envMap,
const TLockedToken<CTexture>& envBumpMap, const TLockedToken<CTexture>& lightmap,
const boo::ObjToken<boo::ITextureS>& rippleMap, bool doubleLightmapBlend, bool additive,
const std::shared_ptr<aurora::TextureHandle>& rippleMap, bool doubleLightmapBlend, bool additive,
u32 maxVertCount);
CFluidPlaneShader(const TLockedToken<CTexture>& patternTex1, const TLockedToken<CTexture>& patternTex2,
const TLockedToken<CTexture>& colorTex, u32 maxVertCount);
@ -154,13 +154,13 @@ public:
const zeus::CColor& colorMul, float rippleNormResolution);
void bindRegular() {
if (m_lastBind != 0) {
CGraphics::SetShaderDataBinding(m_dataBind.m_regular);
// CGraphics::SetShaderDataBinding(m_dataBind.m_regular);
m_lastBind = 0;
}
}
bool bindTessellation() {
if (m_lastBind != 1) {
CGraphics::SetShaderDataBinding(m_dataBind.m_tessellation);
// CGraphics::SetShaderDataBinding(m_dataBind.m_tessellation);
m_lastBind = 1;
}
return true;
@ -168,7 +168,8 @@ public:
void doneDrawing() { m_lastBind = -1; }
void loadVerts(const std::vector<Vertex>& verts, const std::vector<PatchVertex>& pVerts);
bool isReady() const {
return m_pipelines.m_regular->isReady() && (!m_pipelines.m_tessellation || m_pipelines.m_tessellation->isReady());
// return m_pipelines.m_regular->isReady() && (!m_pipelines.m_tessellation || m_pipelines.m_tessellation->isReady());
return false;
}
static void Shutdown();

88
Runtime/Graphics/Shaders/CFogVolumeFilter.cpp
View File

@ -6,72 +6,72 @@
#include "Runtime/Graphics/CBooRenderer.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <hecl/Pipeline.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <hecl/Pipeline.hpp>
#include <zeus/CColor.hpp>
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_1WayPipeline;
static boo::ObjToken<boo::IShaderPipeline> s_2WayPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_1WayPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_2WayPipeline;
void CFogVolumeFilter::Initialize() {
s_1WayPipeline = hecl::conv->convert(Shader_CFogVolumeFilter1Way{});
s_2WayPipeline = hecl::conv->convert(Shader_CFogVolumeFilter2Way{});
// s_1WayPipeline = hecl::conv->convert(Shader_CFogVolumeFilter1Way{});
// s_2WayPipeline = hecl::conv->convert(Shader_CFogVolumeFilter2Way{});
}
void CFogVolumeFilter::Shutdown() {
s_1WayPipeline.reset();
s_2WayPipeline.reset();
// s_1WayPipeline.reset();
// s_2WayPipeline.reset();
}
CFogVolumeFilter::CFogVolumeFilter() {
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
struct Vert {
zeus::CVector2f m_pos;
zeus::CVector2f m_uv;
};
constexpr std::array<Vert, 4> verts{{
{{-1.0, -1.0}, {0.0, 0.0}},
{{-1.0, 1.0}, {0.0, 1.0}},
{{1.0, -1.0}, {1.0, 0.0}},
{{1.0, 1.0}, {1.0, 1.0}},
}};
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(Vert), verts.size());
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CColor), 1);
const std::array<boo::ObjToken<boo::ITexture>, 3> texs{
CGraphics::g_SpareTexture.get(),
CGraphics::g_SpareTexture.get(),
g_Renderer->GetFogRampTex().get(),
};
constexpr std::array bindIdxs{0, 1, 0};
constexpr std::array bindDepth{true, true, false};
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> ubufs{m_uniBuf.get()};
m_dataBind1Way =
ctx.newShaderDataBinding(s_1WayPipeline, m_vbo.get(), nullptr, nullptr, ubufs.size(), ubufs.data(), nullptr,
nullptr, nullptr, texs.size(), texs.data(), bindIdxs.data(), bindDepth.data());
m_dataBind2Way =
ctx.newShaderDataBinding(s_2WayPipeline, m_vbo.get(), nullptr, nullptr, ubufs.size(), ubufs.data(), nullptr,
nullptr, nullptr, texs.size(), texs.data(), bindIdxs.data(), bindDepth.data());
return true;
} BooTrace);
// CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
// struct Vert {
// zeus::CVector2f m_pos;
// zeus::CVector2f m_uv;
// };
// constexpr std::array<Vert, 4> verts{{
// {{-1.0, -1.0}, {0.0, 0.0}},
// {{-1.0, 1.0}, {0.0, 1.0}},
// {{1.0, -1.0}, {1.0, 0.0}},
// {{1.0, 1.0}, {1.0, 1.0}},
// }};
// m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(Vert), verts.size());
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CColor), 1);
// const std::array<boo::ObjToken<boo::ITexture>, 3> texs{
// CGraphics::g_SpareTexture.get(),
// CGraphics::g_SpareTexture.get(),
// g_Renderer->GetFogRampTex().get(),
// };
// constexpr std::array bindIdxs{0, 1, 0};
// constexpr std::array bindDepth{true, true, false};
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> ubufs{m_uniBuf.get()};
//
// m_dataBind1Way =
// ctx.newShaderDataBinding(s_1WayPipeline, m_vbo.get(), nullptr, nullptr, ubufs.size(), ubufs.data(), nullptr,
// nullptr, nullptr, texs.size(), texs.data(), bindIdxs.data(), bindDepth.data());
// m_dataBind2Way =
// ctx.newShaderDataBinding(s_2WayPipeline, m_vbo.get(), nullptr, nullptr, ubufs.size(), ubufs.data(), nullptr,
// nullptr, nullptr, texs.size(), texs.data(), bindIdxs.data(), bindDepth.data());
// return true;
// } BooTrace);
}
void CFogVolumeFilter::draw2WayPass(const zeus::CColor& color) {
SCOPED_GRAPHICS_DEBUG_GROUP("CFogVolumeFilter::draw2WayPass", zeus::skMagenta);
m_uniBuf->load(&color, sizeof(zeus::CColor));
CGraphics::SetShaderDataBinding(m_dataBind2Way);
CGraphics::DrawArray(0, 4);
// m_uniBuf->load(&color, sizeof(zeus::CColor));
// CGraphics::SetShaderDataBinding(m_dataBind2Way);
// CGraphics::DrawArray(0, 4);
}
void CFogVolumeFilter::draw1WayPass(const zeus::CColor& color) {
SCOPED_GRAPHICS_DEBUG_GROUP("CFogVolumeFilter::draw1WayPass", zeus::skMagenta);
m_uniBuf->load(&color, sizeof(zeus::CColor));
CGraphics::SetShaderDataBinding(m_dataBind1Way);
CGraphics::DrawArray(0, 4);
// m_uniBuf->load(&color, sizeof(zeus::CColor));
// CGraphics::SetShaderDataBinding(m_dataBind1Way);
// CGraphics::DrawArray(0, 4);
}
} // namespace metaforce

18
Runtime/Graphics/Shaders/CFogVolumeFilter.hpp
View File

@ -1,24 +1,16 @@
#pragma once
#include <boo/BooObject.hpp>
namespace boo {
struct IGraphicsBufferD;
struct IGraphicsBufferS;
struct IShaderDataBinding;
} // namespace boo
namespace zeus {
class CColor;
}
} // namespace zeus
namespace metaforce {
class CFogVolumeFilter {
boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind1Way;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind2Way;
// boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind1Way;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind2Way;
public:
static void Initialize();

72
Runtime/Graphics/Shaders/CFogVolumePlaneShader.cpp
View File

@ -2,42 +2,42 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
static std::array<boo::ObjToken<boo::IShaderPipeline>, 4> s_Pipelines;
void CFogVolumePlaneShader::Initialize() {
s_Pipelines[0] = hecl::conv->convert(Shader_CFogVolumePlaneShader0{});
s_Pipelines[1] = hecl::conv->convert(Shader_CFogVolumePlaneShader1{});
s_Pipelines[2] = hecl::conv->convert(Shader_CFogVolumePlaneShader2{});
s_Pipelines[3] = hecl::conv->convert(Shader_CFogVolumePlaneShader3{});
}
void CFogVolumePlaneShader::Shutdown() {
s_Pipelines[0].reset();
s_Pipelines[1].reset();
s_Pipelines[2].reset();
s_Pipelines[3].reset();
}
void CFogVolumePlaneShader::CommitResources(size_t capacity) {
m_vertCapacity = capacity;
CGraphics::CommitResources([this, capacity](boo::IGraphicsDataFactory::Context& ctx) {
m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(zeus::CVector4f), capacity);
for (size_t i = 0; i < m_dataBinds.size(); ++i) {
m_dataBinds[i] = ctx.newShaderDataBinding(s_Pipelines[i], m_vbo.get(), nullptr, nullptr, 0, nullptr, nullptr,
nullptr, nullptr, 0, nullptr, nullptr, nullptr);
}
return true;
} BooTrace);
}
//static std::array<boo::ObjToken<boo::IShaderPipeline>, 4> s_Pipelines;
//
//void CFogVolumePlaneShader::Initialize() {
// s_Pipelines[0] = hecl::conv->convert(Shader_CFogVolumePlaneShader0{});
// s_Pipelines[1] = hecl::conv->convert(Shader_CFogVolumePlaneShader1{});
// s_Pipelines[2] = hecl::conv->convert(Shader_CFogVolumePlaneShader2{});
// s_Pipelines[3] = hecl::conv->convert(Shader_CFogVolumePlaneShader3{});
//}
//
//void CFogVolumePlaneShader::Shutdown() {
// s_Pipelines[0].reset();
// s_Pipelines[1].reset();
// s_Pipelines[2].reset();
// s_Pipelines[3].reset();
//}
//
//void CFogVolumePlaneShader::CommitResources(size_t capacity) {
// m_vertCapacity = capacity;
// CGraphics::CommitResources([this, capacity](boo::IGraphicsDataFactory::Context& ctx) {
// m_vbo = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(zeus::CVector4f), capacity);
// for (size_t i = 0; i < m_dataBinds.size(); ++i) {
// m_dataBinds[i] = ctx.newShaderDataBinding(s_Pipelines[i], m_vbo.get(), nullptr, nullptr, 0, nullptr, nullptr,
// nullptr, nullptr, 0, nullptr, nullptr, nullptr);
// }
// return true;
// } BooTrace);
//}
void CFogVolumePlaneShader::addFan(const zeus::CVector3f* verts, int numVerts) {
zeus::CMatrix4f proj = CGraphics::GetPerspectiveProjectionMatrix(true);
zeus::CVector4f vert0 = proj * zeus::CVector4f(CGraphics::g_GXModelView * verts[0]);
if (m_verts.size()) {
if (!m_verts.empty()) {
m_verts.push_back(m_verts.back());
m_verts.push_back(vert0);
if (m_verts.size() & 1)
@ -53,13 +53,13 @@ void CFogVolumePlaneShader::draw(int pass) {
if (m_verts.empty())
return;
SCOPED_GRAPHICS_DEBUG_GROUP("CFogVolumePlaneShader::draw", zeus::skMagenta);
if (pass == 0) {
if (m_vertCapacity < m_verts.size())
CommitResources(m_verts.size());
m_vbo->load(m_verts.data(), m_verts.size() * sizeof(zeus::CVector4f));
}
CGraphics::SetShaderDataBinding(m_dataBinds[pass]);
CGraphics::DrawArray(0, m_verts.size());
// if (pass == 0) {
// if (m_vertCapacity < m_verts.size())
// CommitResources(m_verts.size());
// m_vbo->load(m_verts.data(), m_verts.size() * sizeof(zeus::CVector4f));
// }
// CGraphics::SetShaderDataBinding(m_dataBinds[pass]);
// CGraphics::DrawArray(0, m_verts.size());
}
} // namespace metaforce

15
Runtime/Graphics/Shaders/CFogVolumePlaneShader.hpp
View File

@ -4,28 +4,25 @@
#include <cstddef>
#include <vector>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CRectangle.hpp>
#include <zeus/CVector4f.hpp>
namespace zeus {
class CVector3f;
}
} // namespace zeus
namespace metaforce {
class CFogVolumePlaneShader {
boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
std::array<boo::ObjToken<boo::IShaderDataBinding>, 4> m_dataBinds;
std::vector<zeus::CVector4f> m_verts;
// boo::ObjToken<boo::IGraphicsBufferD> m_vbo;
// std::array<boo::ObjToken<boo::IShaderDataBinding>, 4> m_dataBinds;
size_t m_vertCapacity = 0;
void CommitResources(size_t capacity);
public:
std::vector<zeus::CVector4f> m_verts;
public:
static void Initialize();
static void Shutdown();
static const zeus::CRectangle DefaultRect;
void reset(int numVerts) {
m_verts.clear();

194
Runtime/Graphics/Shaders/CLineRendererShaders.cpp
View File

@ -4,113 +4,113 @@
#include "Runtime/Graphics/CLineRenderer.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
void CLineRendererShaders::Initialize() {
CGraphics::CommitResources([](boo::IGraphicsDataFactory::Context& ctx) {
m_texAlpha = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlpha{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlphaAWrite{})};
m_texAdditive = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditive{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditiveAWrite{})};
m_noTexAlpha = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlpha{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaAWrite{})};
m_noTexAdditive = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditive{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditiveAWrite{})};
m_texAlphaZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlphaZ{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlphaZAWrite{})};
m_texAdditiveZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditiveZ{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditiveZAWrite{})};
m_noTexAlphaZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZ{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZAWrite{})};
m_noTexAdditiveZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditiveZ{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditiveZAWrite{})};
m_noTexAlphaZGEqual = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZGEqual{}),
hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZGEqualAWrite{})};
return true;
} BooTrace);
// CGraphics::CommitResources([](boo::IGraphicsDataFactory::Context& ctx) {
// m_texAlpha = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlpha{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlphaAWrite{})};
// m_texAdditive = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditive{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditiveAWrite{})};
// m_noTexAlpha = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlpha{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaAWrite{})};
// m_noTexAdditive = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditive{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditiveAWrite{})};
// m_texAlphaZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlphaZ{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAlphaZAWrite{})};
// m_texAdditiveZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditiveZ{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderTexAdditiveZAWrite{})};
// m_noTexAlphaZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZ{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZAWrite{})};
// m_noTexAdditiveZ = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditiveZ{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAdditiveZAWrite{})};
// m_noTexAlphaZGEqual = {hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZGEqual{}),
// hecl::conv->convert(ctx, Shader_CLineRendererShaderNoTexAlphaZGEqualAWrite{})};
// return true;
// } BooTrace);
}
void CLineRendererShaders::Shutdown() {
for (auto& s : m_texAlpha)
s.reset();
for (auto& s : m_texAdditive)
s.reset();
for (auto& s : m_noTexAlpha)
s.reset();
for (auto& s : m_noTexAdditive)
s.reset();
for (auto& s : m_texAlphaZ)
s.reset();
for (auto& s : m_texAdditiveZ)
s.reset();
for (auto& s : m_noTexAlphaZ)
s.reset();
for (auto& s : m_noTexAdditiveZ)
s.reset();
for (auto& s : m_noTexAlphaZGEqual)
s.reset();
// for (auto& s : m_texAlpha)
// s.reset();
// for (auto& s : m_texAdditive)
// s.reset();
// for (auto& s : m_noTexAlpha)
// s.reset();
// for (auto& s : m_noTexAdditive)
// s.reset();
// for (auto& s : m_texAlphaZ)
// s.reset();
// for (auto& s : m_texAdditiveZ)
// s.reset();
// for (auto& s : m_noTexAlphaZ)
// s.reset();
// for (auto& s : m_noTexAdditiveZ)
// s.reset();
// for (auto& s : m_noTexAlphaZGEqual)
// s.reset();
}
void CLineRendererShaders::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CLineRenderer& renderer,
const boo::ObjToken<boo::ITexture>& texture, bool additive,
void CLineRendererShaders::BuildShaderDataBinding(CLineRenderer& renderer,
const std::shared_ptr<aurora::TextureHandle>& texture, bool additive,
bool zTest, bool zGEqual) {
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* pipeline = nullptr;
if (zGEqual) {
pipeline = &m_noTexAlphaZGEqual;
} else if (zTest) {
if (texture) {
if (additive)
pipeline = &m_texAdditiveZ;
else
pipeline = &m_texAlphaZ;
} else {
if (additive)
pipeline = &m_noTexAdditiveZ;
else
pipeline = &m_noTexAlphaZ;
}
} else {
if (texture) {
if (additive)
pipeline = &m_texAdditive;
else
pipeline = &m_texAlpha;
} else {
if (additive)
pipeline = &m_noTexAdditive;
else
pipeline = &m_noTexAlpha;
}
}
size_t texCount = 0;
std::array<boo::ObjToken<boo::ITexture>, 1> textures;
std::pair<boo::ObjToken<boo::IGraphicsBufferD>, hecl::VertexBufferPool<CLineRenderer::SDrawVertTex>::IndexTp>
vbufInfo;
std::pair<boo::ObjToken<boo::IGraphicsBufferD>, hecl::UniformBufferPool<CLineRenderer::SDrawUniform>::IndexTp>
ubufInfo = renderer.m_uniformBuf.getBufferInfo();
if (texture) {
vbufInfo = renderer.m_vertBufTex.getBufferInfo();
textures[0] = texture;
texCount = 1;
} else {
vbufInfo = renderer.m_vertBufNoTex.getBufferInfo();
}
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{ubufInfo.first.get()};
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Fragment};
const std::array<size_t, 1> ubufOffs{size_t(ubufInfo.second)};
const std::array<size_t, 1> ubufSizes{sizeof(CLineRenderer::SDrawUniform)};
for (size_t i = 0; i < renderer.m_shaderBind.size(); ++i) {
renderer.m_shaderBind[i] = ctx.newShaderDataBinding(
(*pipeline)[i], vbufInfo.first.get(), nullptr, nullptr, uniforms.size(), uniforms.data(), stages.data(),
ubufOffs.data(), ubufSizes.data(), texCount, textures.data(), nullptr, nullptr, vbufInfo.second);
}
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* pipeline = nullptr;
//
// if (zGEqual) {
// pipeline = &m_noTexAlphaZGEqual;
// } else if (zTest) {
// if (texture) {
// if (additive)
// pipeline = &m_texAdditiveZ;
// else
// pipeline = &m_texAlphaZ;
// } else {
// if (additive)
// pipeline = &m_noTexAdditiveZ;
// else
// pipeline = &m_noTexAlphaZ;
// }
// } else {
// if (texture) {
// if (additive)
// pipeline = &m_texAdditive;
// else
// pipeline = &m_texAlpha;
// } else {
// if (additive)
// pipeline = &m_noTexAdditive;
// else
// pipeline = &m_noTexAlpha;
// }
// }
//
// size_t texCount = 0;
// std::array<boo::ObjToken<boo::ITexture>, 1> textures;
//
// std::pair<boo::ObjToken<boo::IGraphicsBufferD>, hecl::VertexBufferPool<CLineRenderer::SDrawVertTex>::IndexTp>
// vbufInfo;
// std::pair<boo::ObjToken<boo::IGraphicsBufferD>, hecl::UniformBufferPool<CLineRenderer::SDrawUniform>::IndexTp>
// ubufInfo = renderer.m_uniformBuf.getBufferInfo();
// if (texture) {
// vbufInfo = renderer.m_vertBufTex.getBufferInfo();
// textures[0] = texture;
// texCount = 1;
// } else {
// vbufInfo = renderer.m_vertBufNoTex.getBufferInfo();
// }
//
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{ubufInfo.first.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Fragment};
// const std::array<size_t, 1> ubufOffs{size_t(ubufInfo.second)};
// const std::array<size_t, 1> ubufSizes{sizeof(CLineRenderer::SDrawUniform)};
//
// for (size_t i = 0; i < renderer.m_shaderBind.size(); ++i) {
// renderer.m_shaderBind[i] = ctx.newShaderDataBinding(
// (*pipeline)[i], vbufInfo.first.get(), nullptr, nullptr, uniforms.size(), uniforms.data(), stages.data(),
// ubufOffs.data(), ubufSizes.data(), texCount, textures.data(), nullptr, nullptr, vbufInfo.second);
// }
}
} // namespace metaforce

32
Runtime/Graphics/Shaders/CLineRendererShaders.hpp
View File

@ -2,31 +2,31 @@
#include <array>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include "Runtime/Graphics/CGraphics.hpp"
namespace metaforce {
class CLineRenderer;
class CLineRendererShaders {
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAlpha;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditive;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAlpha;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditive;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAlphaZ;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveZ;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAlphaZ;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveZ;
static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAlphaZGEqual;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAlpha;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditive;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAlpha;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditive;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAlphaZ;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveZ;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAlphaZ;
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveZ;
//
// static inline std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAlphaZGEqual;
public:
static void Initialize();
static void Shutdown();
static void BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CLineRenderer& renderer,
const boo::ObjToken<boo::ITexture>& texture, bool additive, bool zTest,
static void BuildShaderDataBinding(CLineRenderer& renderer,
const std::shared_ptr<aurora::TextureHandle>& texture, bool additive, bool zTest,
bool zGEqual);
};

36
Runtime/Graphics/Shaders/CMapSurfaceShader.cpp
View File

@ -4,33 +4,37 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
void CMapSurfaceShader::Initialize() { s_Pipeline = hecl::conv->convert(Shader_CMapSurfaceShader{}); }
void CMapSurfaceShader::Initialize() {
// s_Pipeline = hecl::conv->convert(Shader_CMapSurfaceShader{});
}
void CMapSurfaceShader::Shutdown() { s_Pipeline.reset(); }
void CMapSurfaceShader::Shutdown() {
// s_Pipeline.reset();
}
CMapSurfaceShader::CMapSurfaceShader(boo::IGraphicsDataFactory::Context& ctx,
const boo::ObjToken<boo::IGraphicsBufferS>& vbo,
const boo::ObjToken<boo::IGraphicsBufferS>& ibo)
: m_vbo(vbo), m_ibo(ibo) {
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
m_dataBind = ctx.newShaderDataBinding(s_Pipeline, m_vbo.get(), nullptr, m_ibo.get(), bufs.size(), bufs.data(),
stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
CMapSurfaceShader::CMapSurfaceShader(aurora::ArrayRef<zeus::CVector3f> vbo,
aurora::ArrayRef<uint16_t> ibo)
//: m_vbo(vbo), m_ibo(ibo)
{
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// m_dataBind = ctx.newShaderDataBinding(s_Pipeline, m_vbo.get(), nullptr, m_ibo.get(), bufs.size(), bufs.data(),
// stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
}
void CMapSurfaceShader::draw(const zeus::CColor& color, u32 start, u32 count) {
SCOPED_GRAPHICS_DEBUG_GROUP("CMapSurfaceShader::draw", zeus::skMagenta);
Uniform uniform = {CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f(), color};
m_uniBuf->load(&uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_dataBind);
CGraphics::DrawArrayIndexed(start, count);
// m_uniBuf->load(&uniform, sizeof(Uniform));
// CGraphics::SetShaderDataBinding(m_dataBind);
// CGraphics::DrawArrayIndexed(start, count);
}
} // namespace metaforce

15
Runtime/Graphics/Shaders/CMapSurfaceShader.hpp
View File

@ -1,8 +1,7 @@
#pragma once
#include "Runtime/GCNTypes.hpp"
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include "Runtime/Graphics/CGraphics.hpp"
#include <zeus/CColor.hpp>
#include <zeus/CMatrix4f.hpp>
@ -15,16 +14,16 @@ class CMapSurfaceShader {
zeus::CColor color;
};
boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
boo::ObjToken<boo::IGraphicsBufferS> m_ibo;
boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
// boo::ObjToken<boo::IGraphicsBufferD> m_uniBuf;
// boo::ObjToken<boo::IGraphicsBufferS> m_vbo;
// boo::ObjToken<boo::IGraphicsBufferS> m_ibo;
// boo::ObjToken<boo::IShaderDataBinding> m_dataBind;
public:
static void Initialize();
static void Shutdown();
CMapSurfaceShader(boo::IGraphicsDataFactory::Context& ctx, const boo::ObjToken<boo::IGraphicsBufferS>& vbo,
const boo::ObjToken<boo::IGraphicsBufferS>& ibo);
CMapSurfaceShader(aurora::ArrayRef<zeus::CVector3f> vbo,
aurora::ArrayRef<uint16_t> ibo);
void draw(const zeus::CColor& color, u32 start, u32 count);
};

292
Runtime/Graphics/Shaders/CModelShaders.cpp
View File

@ -4,11 +4,11 @@
#include "Runtime/Graphics/CLight.hpp"
#include <hecl/Backend.hpp>
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
std::unordered_map<uint64_t, CModelShaders::ShaderPipelines> CModelShaders::g_ShaderPipelines;
//std::unordered_map<uint64_t, CModelShaders::ShaderPipelines> CModelShaders::g_ShaderPipelines;
void CModelShaders::LightingUniform::ActivateLights(const std::vector<CLight>& lts) {
ambient = zeus::skClear;
@ -80,154 +80,156 @@ constexpr std::array<hecl::Backend::TextureInfo, 2> DisintegrateTextures{{
{TexCoordSource::Position, 1, false}, // Ashy tex
}};
static std::array<hecl::Backend::ExtensionSlot, size_t(EExtendedShader::MAX)> g_ExtensionSlots{{
/* Default solid shading */
{},
/* Normal lit shading */
{0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
/* Thermal model shading */
{1, ThermalTextures.data(), hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, false, true},
/* Thermal model shading without Z-test or Z-write */
{1, ThermalTextures.data(), hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One,
hecl::Backend::ZTest::None, hecl::Backend::CullMode::Backface, true, false, false, true},
/* Thermal static shading */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
hecl::Backend::CullMode::Backface, false, false, false, true, false, false, true},
/* Thermal static shading without Z-write */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
hecl::Backend::CullMode::Backface, true, false, false, true, false, false, false},
/* Forced alpha shading */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
/* Forced additive shading */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
hecl::Backend::CullMode::Backface, false, false, true},
/* Solid color */
{0, nullptr, hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::Zero, hecl::Backend::ZTest::LEqual,
hecl::Backend::CullMode::Backface, false, false, false},
/* Solid color additive */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
hecl::Backend::CullMode::Backface, true, false, true},
/* Alpha-only Solid color frontface cull, LEqual */
{0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
hecl::Backend::CullMode::Frontface, false, true, false},
/* Alpha-only Solid color frontface cull, Always, No Z-write */
{0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::None,
hecl::Backend::CullMode::Frontface, true, true, false},
/* Alpha-only Solid color backface cull, LEqual */
{0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
hecl::Backend::CullMode::Backface, false, true, false},
/* Alpha-only Solid color backface cull, Greater, No Z-write */
{0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Greater,
hecl::Backend::CullMode::Backface, true, true, false},
/* MorphBall shadow shading */
{3, BallFadeTextures.data(), hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::Equal, hecl::Backend::CullMode::Backface, false, false, true, false, true},
/* World shadow shading (modified lighting) */
{1, WorldShadowTextures.data(), hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
/* Forced alpha shading without culling */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::None, false, false, true},
/* Forced additive shading without culling */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
hecl::Backend::CullMode::None, false, false, true},
/* Forced alpha shading without Z-write */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Original, true, false, true},
/* Forced additive shading without Z-write */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
hecl::Backend::CullMode::Original, true, false, true},
/* Forced alpha shading without culling or Z-write */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::None, true, false, true},
/* Forced additive shading without culling or Z-write */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
hecl::Backend::CullMode::None, true, false, true},
/* Depth GEqual no Z-write */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::GEqual, hecl::Backend::CullMode::Backface, true, false, true},
/* Disintegration */
{2, DisintegrateTextures.data(), hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
hecl::Backend::ZTest::LEqual, hecl::Backend::CullMode::Original, false, false, true, false, false, true},
/* Forced additive shading without culling or Z-write and greater depth test */
{0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Greater,
hecl::Backend::CullMode::None, true, false, true},
/* Thermal cold shading */
{0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Original, false, false, true, false, false, false, true},
/* Normal lit shading with alpha */
{0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface},
/* Normal lit shading with alpha without Z-write or depth test */
{0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original, hecl::Backend::ZTest::None,
hecl::Backend::CullMode::Backface, true},
/* Normal lit shading with cube reflection */
{0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
/* Normal lit shading with cube reflection and world shadow */
{1, WorldShadowTextures.data(), hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
}};
//static std::array<hecl::Backend::ExtensionSlot, size_t(EExtendedShader::MAX)> g_ExtensionSlots{{
// /* Default solid shading */
// {},
// /* Normal lit shading */
// {0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
// /* Thermal model shading */
// {1, ThermalTextures.data(), hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, false, true},
// /* Thermal model shading without Z-test or Z-write */
// {1, ThermalTextures.data(), hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::One,
// hecl::Backend::ZTest::None, hecl::Backend::CullMode::Backface, true, false, false, true},
// /* Thermal static shading */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
// hecl::Backend::CullMode::Backface, false, false, false, true, false, false, true},
// /* Thermal static shading without Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
// hecl::Backend::CullMode::Backface, true, false, false, true, false, false, false},
// /* Forced alpha shading */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
// /* Forced additive shading */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
// hecl::Backend::CullMode::Backface, false, false, true},
// /* Solid color */
// {0, nullptr, hecl::Backend::BlendFactor::One, hecl::Backend::BlendFactor::Zero, hecl::Backend::ZTest::LEqual,
// hecl::Backend::CullMode::Backface, false, false, false},
// /* Solid color additive */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
// hecl::Backend::CullMode::Backface, true, false, true},
// /* Alpha-only Solid color frontface cull, LEqual */
// {0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
// hecl::Backend::CullMode::Frontface, false, true, false},
// /* Alpha-only Solid color frontface cull, Always, No Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::None,
// hecl::Backend::CullMode::Frontface, true, true, false},
// /* Alpha-only Solid color backface cull, LEqual */
// {0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
// hecl::Backend::CullMode::Backface, false, true, false},
// /* Alpha-only Solid color backface cull, Greater, No Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::Zero, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Greater,
// hecl::Backend::CullMode::Backface, true, true, false},
// /* MorphBall shadow shading */
// {3, BallFadeTextures.data(), hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::Equal, hecl::Backend::CullMode::Backface, false, false, true, false, true},
// /* World shadow shading (modified lighting) */
// {1, WorldShadowTextures.data(), hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
// /* Forced alpha shading without culling */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::None, false, false, true},
// /* Forced additive shading without culling */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
// hecl::Backend::CullMode::None, false, false, true},
// /* Forced alpha shading without Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Original, true, false, true},
// /* Forced additive shading without Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
// hecl::Backend::CullMode::Original, true, false, true},
// /* Forced alpha shading without culling or Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::None, true, false, true},
// /* Forced additive shading without culling or Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
// hecl::Backend::CullMode::None, true, false, true},
// /* Depth GEqual no Z-write */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::GEqual, hecl::Backend::CullMode::Backface, true, false, true},
// /* Disintegration */
// {2, DisintegrateTextures.data(), hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::InvSrcAlpha,
// hecl::Backend::ZTest::LEqual, hecl::Backend::CullMode::Original, false, false, true, false, false, true},
// /* Forced additive shading without culling or Z-write and greater depth test */
// {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha, hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Greater,
// hecl::Backend::CullMode::None, true, false, true},
// /* Thermal cold shading */
// {0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Original, false, false, true, false, false, false, true},
// /* Normal lit shading with alpha */
// {0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface},
// /* Normal lit shading with alpha without Z-write or depth test */
// {0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original, hecl::Backend::ZTest::None,
// hecl::Backend::CullMode::Backface, true},
// /* Normal lit shading with cube reflection */
// {0, nullptr, hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
// /* Normal lit shading with cube reflection and world shadow */
// {1, WorldShadowTextures.data(), hecl::Backend::BlendFactor::Original, hecl::Backend::BlendFactor::Original,
// hecl::Backend::ZTest::Original, hecl::Backend::CullMode::Backface, false, false, true},
//}};
constexpr std::array<const char*, size_t(EExtendedShader::MAX)> ShaderMacros{
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_THERMAL_MODEL",
"URDE_THERMAL_MODEL",
"URDE_THERMAL_STATIC",
"URDE_THERMAL_STATIC",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_SOLID",
"URDE_SOLID",
"URDE_SOLID",
"URDE_SOLID",
"URDE_SOLID",
"URDE_SOLID",
"URDE_MB_SHADOW",
"URDE_LIGHTING_SHADOW",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_DISINTEGRATE",
"URDE_LIGHTING",
"URDE_THERMAL_COLD",
"URDE_LIGHTING",
"URDE_LIGHTING",
"URDE_LIGHTING_CUBE_REFLECTION",
"URDE_LIGHTING_CUBE_REFLECTION_SHADOW",
};
//constexpr std::array<const char*, size_t(EExtendedShader::MAX)> ShaderMacros{
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_THERMAL_MODEL",
// "URDE_THERMAL_MODEL",
// "URDE_THERMAL_STATIC",
// "URDE_THERMAL_STATIC",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_SOLID",
// "URDE_SOLID",
// "URDE_SOLID",
// "URDE_SOLID",
// "URDE_SOLID",
// "URDE_SOLID",
// "URDE_MB_SHADOW",
// "URDE_LIGHTING_SHADOW",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_DISINTEGRATE",
// "URDE_LIGHTING",
// "URDE_THERMAL_COLD",
// "URDE_LIGHTING",
// "URDE_LIGHTING",
// "URDE_LIGHTING_CUBE_REFLECTION",
// "URDE_LIGHTING_CUBE_REFLECTION_SHADOW",
//};
void CModelShaders::Initialize() {
for (size_t i = 0; i < g_ExtensionSlots.size(); i++) {
g_ExtensionSlots[i].shaderMacro = ShaderMacros[i];
}
// for (size_t i = 0; i < g_ExtensionSlots.size(); i++) {
// g_ExtensionSlots[i].shaderMacro = ShaderMacros[i];
// }
}
void CModelShaders::Shutdown() { g_ShaderPipelines.clear(); }
CModelShaders::ShaderPipelines CModelShaders::BuildExtendedShader(const hecl::Backend::ShaderTag& tag,
const Material& material) {
auto search = g_ShaderPipelines.find(tag.val64());
if (search != g_ShaderPipelines.cend())
return search->second;
ShaderPipelines& newPipelines = g_ShaderPipelines[tag.val64()];
newPipelines = std::make_shared<ShaderPipelinesData>();
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
size_t idx = 0;
for (const auto& ext : g_ExtensionSlots)
(*newPipelines)[idx++] = hecl::conv->convert(ctx, Shader_CModelShaders(SModelShadersInfo(material, tag, ext)));
return true;
} BooTrace);
return newPipelines;
void CModelShaders::Shutdown() {
// g_ShaderPipelines.clear();
}
//CModelShaders::ShaderPipelines CModelShaders::BuildExtendedShader(const hecl::Backend::ShaderTag& tag,
// const Material& material) {
// auto search = g_ShaderPipelines.find(tag.val64());
// if (search != g_ShaderPipelines.cend())
// return search->second;
//
// ShaderPipelines& newPipelines = g_ShaderPipelines[tag.val64()];
// newPipelines = std::make_shared<ShaderPipelinesData>();
// CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
// size_t idx = 0;
// for (const auto& ext : g_ExtensionSlots)
// (*newPipelines)[idx++] = hecl::conv->convert(ctx, Shader_CModelShaders(SModelShadersInfo(material, tag, ext)));
// return true;
// } BooTrace);
// return newPipelines;
//}
} // namespace metaforce

12
Runtime/Graphics/Shaders/CModelShaders.hpp
View File

@ -4,7 +4,7 @@
#include <cstdint>
#include <memory>
#include "DataSpec/DNAMP1/CMDLMaterials.hpp"
//#include "DataSpec/DNAMP1/CMDLMaterials.hpp"
#include "Runtime/Graphics/CGraphics.hpp"
@ -100,14 +100,14 @@ public:
static void Initialize();
static void Shutdown();
using ShaderPipelinesData = std::array<boo::ObjToken<boo::IShaderPipeline>, size_t(EExtendedShader::MAX)>;
using ShaderPipelines = std::shared_ptr<ShaderPipelinesData>;
// using ShaderPipelinesData = std::array<boo::ObjToken<boo::IShaderPipeline>, size_t(EExtendedShader::MAX)>;
// using ShaderPipelines = std::shared_ptr<ShaderPipelinesData>;
using Material = DataSpec::DNAMP1::HMDLMaterialSet::Material;
static ShaderPipelines BuildExtendedShader(const hecl::Backend::ShaderTag& tag, const Material& material);
// using Material = DataSpec::DNAMP1::HMDLMaterialSet::Material;
// static ShaderPipelines BuildExtendedShader(const hecl::Backend::ShaderTag& tag, const Material& material);
private:
static std::unordered_map<uint64_t, ShaderPipelines> g_ShaderPipelines;
// static std::unordered_map<uint64_t, ShaderPipelines> g_ShaderPipelines;
};
} // namespace metaforce

164
Runtime/Graphics/Shaders/CParticleSwooshShaders.cpp
View File

@ -5,56 +5,56 @@
#include "Runtime/Particle/CParticleSwoosh.hpp"
#include "Runtime/Particle/CSwooshDescription.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
namespace metaforce {
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texNoZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texAdditiveZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texAdditiveNoZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexNoZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexAdditiveZWrite;
std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexAdditiveNoZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texNoZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texAdditiveZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_texAdditiveNoZWrite;
//
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexNoZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexAdditiveZWrite;
//std::array<boo::ObjToken<boo::IShaderPipeline>, 2> CParticleSwooshShaders::m_noTexAdditiveNoZWrite;
void CParticleSwooshShaders::Initialize() {
m_texZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderTexZWriteAWrite{})};
m_texNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexNoZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderTexNoZWriteAWrite{})};
m_texAdditiveZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveZWriteAWrite{})};
m_texAdditiveNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveNoZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveNoZWriteAWrite{})};
m_noTexZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderNoTexZWriteAWrite{})};
m_noTexNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexNoZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderNoTexNoZWriteAWrite{})};
m_noTexAdditiveZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveZWriteAWrite{})};
m_noTexAdditiveNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveNoZWrite{}),
hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveNoZWriteAWrite{})};
// m_texZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderTexZWriteAWrite{})};
// m_texNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexNoZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderTexNoZWriteAWrite{})};
// m_texAdditiveZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveZWriteAWrite{})};
// m_texAdditiveNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveNoZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderTexAdditiveNoZWriteAWrite{})};
// m_noTexZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderNoTexZWriteAWrite{})};
// m_noTexNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexNoZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderNoTexNoZWriteAWrite{})};
// m_noTexAdditiveZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveZWriteAWrite{})};
// m_noTexAdditiveNoZWrite = {hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveNoZWrite{}),
// hecl::conv->convert(Shader_CParticleSwooshShaderNoTexAdditiveNoZWriteAWrite{})};
}
void CParticleSwooshShaders::Shutdown() {
for (auto& s : m_texZWrite)
s.reset();
for (auto& s : m_texNoZWrite)
s.reset();
for (auto& s : m_texAdditiveZWrite)
s.reset();
for (auto& s : m_texAdditiveNoZWrite)
s.reset();
for (auto& s : m_noTexZWrite)
s.reset();
for (auto& s : m_noTexNoZWrite)
s.reset();
for (auto& s : m_noTexAdditiveZWrite)
s.reset();
for (auto& s : m_noTexAdditiveNoZWrite)
s.reset();
// for (auto& s : m_texZWrite)
// s.reset();
// for (auto& s : m_texNoZWrite)
// s.reset();
// for (auto& s : m_texAdditiveZWrite)
// s.reset();
// for (auto& s : m_texAdditiveNoZWrite)
// s.reset();
// for (auto& s : m_noTexZWrite)
// s.reset();
// for (auto& s : m_noTexNoZWrite)
// s.reset();
// for (auto& s : m_noTexAdditiveZWrite)
// s.reset();
// for (auto& s : m_noTexAdditiveNoZWrite)
// s.reset();
}
CParticleSwooshShaders::EShaderClass CParticleSwooshShaders::GetShaderClass(CParticleSwoosh& gen) {
@ -66,47 +66,47 @@ CParticleSwooshShaders::EShaderClass CParticleSwooshShaders::GetShaderClass(CPar
return EShaderClass::NoTex;
}
void CParticleSwooshShaders::BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CParticleSwoosh& gen) {
void CParticleSwooshShaders::BuildShaderDataBinding(CParticleSwoosh& gen) {
CSwooshDescription* desc = gen.GetDesc();
std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* pipeline = nullptr;
if (desc->x3c_TEXR) {
if (desc->x44_31_AALP) {
if (desc->x45_24_ZBUF)
pipeline = &m_texAdditiveZWrite;
else
pipeline = &m_texAdditiveNoZWrite;
} else {
if (desc->x45_24_ZBUF)
pipeline = &m_texZWrite;
else
pipeline = &m_texNoZWrite;
}
} else {
if (desc->x44_31_AALP) {
if (desc->x45_24_ZBUF)
pipeline = &m_noTexAdditiveZWrite;
else
pipeline = &m_noTexAdditiveNoZWrite;
} else {
if (desc->x45_24_ZBUF)
pipeline = &m_noTexZWrite;
else
pipeline = &m_noTexNoZWrite;
}
}
const CUVElement* const texr = desc->x3c_TEXR.get();
const std::array<boo::ObjToken<boo::ITexture>, 1> textures{
texr ? texr->GetValueTexture(0).GetObj()->GetBooTexture() : nullptr,
};
const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{gen.m_uniformBuf.get()};
for (size_t i = 0; i < gen.m_dataBind.size(); ++i) {
gen.m_dataBind[i] =
ctx.newShaderDataBinding((*pipeline)[i], gen.m_vertBuf.get(), nullptr, nullptr, uniforms.size(),
uniforms.data(), nullptr, texr ? 1 : 0, textures.data(), nullptr, nullptr);
}
// std::array<boo::ObjToken<boo::IShaderPipeline>, 2>* pipeline = nullptr;
//
// if (desc->x3c_TEXR) {
// if (desc->x44_31_AALP) {
// if (desc->x45_24_ZBUF)
// pipeline = &m_texAdditiveZWrite;
// else
// pipeline = &m_texAdditiveNoZWrite;
// } else {
// if (desc->x45_24_ZBUF)
// pipeline = &m_texZWrite;
// else
// pipeline = &m_texNoZWrite;
// }
// } else {
// if (desc->x44_31_AALP) {
// if (desc->x45_24_ZBUF)
// pipeline = &m_noTexAdditiveZWrite;
// else
// pipeline = &m_noTexAdditiveNoZWrite;
// } else {
// if (desc->x45_24_ZBUF)
// pipeline = &m_noTexZWrite;
// else
// pipeline = &m_noTexNoZWrite;
// }
// }
//
// const CUVElement* const texr = desc->x3c_TEXR.get();
// const std::array<boo::ObjToken<boo::ITexture>, 1> textures{
// texr ? texr->GetValueTexture(0).GetObj()->GetBooTexture() : nullptr,
// };
//
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> uniforms{gen.m_uniformBuf.get()};
// for (size_t i = 0; i < gen.m_dataBind.size(); ++i) {
// gen.m_dataBind[i] =
// ctx.newShaderDataBinding((*pipeline)[i], gen.m_vertBuf.get(), nullptr, nullptr, uniforms.size(),
// uniforms.data(), nullptr, texr ? 1 : 0, textures.data(), nullptr, nullptr);
// }
}
} // namespace metaforce

22
Runtime/Graphics/Shaders/CParticleSwooshShaders.hpp
View File

@ -2,7 +2,7 @@
#include <array>
#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
//#include <boo/graphicsdev/IGraphicsDataFactory.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CVector2f.hpp>
@ -22,21 +22,21 @@ public:
};
private:
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveNoZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexNoZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveZWrite;
static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveNoZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texNoZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_texAdditiveNoZWrite;
//
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexNoZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveZWrite;
// static std::array<boo::ObjToken<boo::IShaderPipeline>, 2> m_noTexAdditiveNoZWrite;
public:
static void Initialize();
static void Shutdown();
static EShaderClass GetShaderClass(CParticleSwoosh& gen);
static void BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CParticleSwoosh& gen);
static void BuildShaderDataBinding(CParticleSwoosh& gen);
};
} // namespace metaforce

196
Runtime/Graphics/Shaders/CPhazonSuitFilter.cpp
View File

@ -6,7 +6,7 @@
#include "Runtime/Graphics/CGraphics.hpp"
#include "Runtime/Graphics/CTexture.hpp"
#include <hecl/Pipeline.hpp>
//#include <hecl/Pipeline.hpp>
#include <zeus/CColor.hpp>
#include <zeus/CVector2f.hpp>
@ -15,103 +15,103 @@
namespace metaforce {
static boo::ObjToken<boo::IShaderPipeline> s_IndPipeline;
static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
static boo::ObjToken<boo::IShaderPipeline> s_BlurPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_IndPipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_Pipeline;
//static boo::ObjToken<boo::IShaderPipeline> s_BlurPipeline;
void CPhazonSuitFilter::Initialize() {
s_IndPipeline = hecl::conv->convert(Shader_CPhazonSuitFilterInd{});
s_Pipeline = hecl::conv->convert(Shader_CPhazonSuitFilterNoInd{});
s_BlurPipeline = hecl::conv->convert(Shader_CPhazonSuitFilterBlur{});
// s_IndPipeline = hecl::conv->convert(Shader_CPhazonSuitFilterInd{});
// s_Pipeline = hecl::conv->convert(Shader_CPhazonSuitFilterNoInd{});
// s_BlurPipeline = hecl::conv->convert(Shader_CPhazonSuitFilterBlur{});
}
void CPhazonSuitFilter::Shutdown() {
s_IndPipeline.reset();
s_Pipeline.reset();
s_BlurPipeline.reset();
// s_IndPipeline.reset();
// s_Pipeline.reset();
// s_BlurPipeline.reset();
}
void CPhazonSuitFilter::drawBlurPasses(float radius, const CTexture* indTex) {
SCOPED_GRAPHICS_DEBUG_GROUP("CPhazonSuitFilter::drawBlurPasses", zeus::skMagenta);
if (!m_dataBind || indTex != m_indTex) {
m_indTex = indTex;
CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
m_uniBufBlurX = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CVector4f), 1);
m_uniBufBlurY = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CVector4f), 1);
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CVector4f) * 2, 1);
struct BlurVert {
zeus::CVector3f pos;
zeus::CVector2f uv;
};
const std::array<BlurVert, 4> blurVerts{{
{{-1.f, 1.f, 0.f}, {0.f, 1.f}},
{{-1.f, -1.f, 0.f}, {0.f, 0.f}},
{{1.f, 1.f, 0.f}, {1.f, 1.f}},
{{1.f, -1.f, 0.f}, {1.f, 0.f}},
}};
m_blurVbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, blurVerts.data(), sizeof(BlurVert), blurVerts.size());
struct Vert {
zeus::CVector3f pos;
zeus::CVector2f screenUv;
zeus::CVector2f indUv;
zeus::CVector2f maskUv;
};
const std::array<Vert, 4> verts{{
{{-1.f, 1.f, 0.f}, {0.01f, 0.99f}, {0.f, 4.f}, {0.f, 1.f}},
{{-1.f, -1.f, 0.f}, {0.01f, 0.01f}, {0.f, 0.f}, {0.f, 0.f}},
{{1.f, 1.f, 0.f}, {0.99f, 0.99f}, {g_Viewport.aspect * 4.f, 4.f}, {1.f, 1.f}},
{{1.f, -1.f, 0.f}, {0.99f, 0.01f}, {g_Viewport.aspect * 4.f, 0.f}, {1.f, 0.f}},
}};
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(Vert), verts.size());
std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBufBlurX.get()};
constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
std::array<boo::ObjToken<boo::ITexture>, 4> texs;
std::array<int, 4> texBindIdxs;
texs[0] = CGraphics::g_SpareTexture.get();
texBindIdxs[0] = 1;
m_dataBindBlurX =
ctx.newShaderDataBinding(s_BlurPipeline, m_blurVbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
stages.data(), nullptr, nullptr, 1, texs.data(), texBindIdxs.data(), nullptr);
bufs[0] = m_uniBufBlurY.get();
texs[0] = CGraphics::g_SpareTexture.get();
texBindIdxs[0] = 2;
m_dataBindBlurY =
ctx.newShaderDataBinding(s_BlurPipeline, m_blurVbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
stages.data(), nullptr, nullptr, 1, texs.data(), texBindIdxs.data(), nullptr);
bufs[0] = m_uniBuf.get();
size_t texCount;
if (m_indTex) {
texs[0] = CGraphics::g_SpareTexture.get();
texBindIdxs[0] = 0;
texs[1] = m_indTex->GetBooTexture();
texBindIdxs[1] = 0;
texs[2] = CGraphics::g_SpareTexture.get();
texBindIdxs[2] = 1;
texs[3] = CGraphics::g_SpareTexture.get();
texBindIdxs[3] = 2;
texCount = 4;
} else {
texs[0] = CGraphics::g_SpareTexture.get();
texBindIdxs[0] = 0;
texs[1] = CGraphics::g_SpareTexture.get();
texBindIdxs[1] = 1;
texs[2] = CGraphics::g_SpareTexture.get();
texBindIdxs[2] = 2;
texCount = 3;
}
m_dataBind = ctx.newShaderDataBinding(m_indTex ? s_IndPipeline : s_Pipeline, m_vbo.get(), nullptr, nullptr,
bufs.size(), bufs.data(), stages.data(), nullptr, nullptr, texCount,
texs.data(), texBindIdxs.data(), nullptr);
return true;
} BooTrace);
}
// if (!m_dataBind || indTex != m_indTex) {
// m_indTex = indTex;
// CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
// m_uniBufBlurX = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CVector4f), 1);
// m_uniBufBlurY = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CVector4f), 1);
// m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CVector4f) * 2, 1);
//
// struct BlurVert {
// zeus::CVector3f pos;
// zeus::CVector2f uv;
// };
// const std::array<BlurVert, 4> blurVerts{{
// {{-1.f, 1.f, 0.f}, {0.f, 1.f}},
// {{-1.f, -1.f, 0.f}, {0.f, 0.f}},
// {{1.f, 1.f, 0.f}, {1.f, 1.f}},
// {{1.f, -1.f, 0.f}, {1.f, 0.f}},
// }};
// m_blurVbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, blurVerts.data(), sizeof(BlurVert), blurVerts.size());
//
// struct Vert {
// zeus::CVector3f pos;
// zeus::CVector2f screenUv;
// zeus::CVector2f indUv;
// zeus::CVector2f maskUv;
// };
// const std::array<Vert, 4> verts{{
// {{-1.f, 1.f, 0.f}, {0.01f, 0.99f}, {0.f, 4.f}, {0.f, 1.f}},
// {{-1.f, -1.f, 0.f}, {0.01f, 0.01f}, {0.f, 0.f}, {0.f, 0.f}},
// {{1.f, 1.f, 0.f}, {0.99f, 0.99f}, {g_Viewport.aspect * 4.f, 4.f}, {1.f, 1.f}},
// {{1.f, -1.f, 0.f}, {0.99f, 0.01f}, {g_Viewport.aspect * 4.f, 0.f}, {1.f, 0.f}},
// }};
// m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts.data(), sizeof(Vert), verts.size());
//
// std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBufBlurX.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// std::array<boo::ObjToken<boo::ITexture>, 4> texs;
// std::array<int, 4> texBindIdxs;
//
// texs[0] = CGraphics::g_SpareTexture.get();
// texBindIdxs[0] = 1;
// m_dataBindBlurX =
// ctx.newShaderDataBinding(s_BlurPipeline, m_blurVbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
// stages.data(), nullptr, nullptr, 1, texs.data(), texBindIdxs.data(), nullptr);
//
// bufs[0] = m_uniBufBlurY.get();
// texs[0] = CGraphics::g_SpareTexture.get();
// texBindIdxs[0] = 2;
// m_dataBindBlurY =
// ctx.newShaderDataBinding(s_BlurPipeline, m_blurVbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
// stages.data(), nullptr, nullptr, 1, texs.data(), texBindIdxs.data(), nullptr);
//
// bufs[0] = m_uniBuf.get();
// size_t texCount;
// if (m_indTex) {
// texs[0] = CGraphics::g_SpareTexture.get();
// texBindIdxs[0] = 0;
// texs[1] = m_indTex->GetBooTexture();
// texBindIdxs[1] = 0;
// texs[2] = CGraphics::g_SpareTexture.get();
// texBindIdxs[2] = 1;
// texs[3] = CGraphics::g_SpareTexture.get();
// texBindIdxs[3] = 2;
// texCount = 4;
// } else {
// texs[0] = CGraphics::g_SpareTexture.get();
// texBindIdxs[0] = 0;
// texs[1] = CGraphics::g_SpareTexture.get();
// texBindIdxs[1] = 1;
// texs[2] = CGraphics::g_SpareTexture.get();
// texBindIdxs[2] = 2;
// texCount = 3;
// }
//
// m_dataBind = ctx.newShaderDataBinding(m_indTex ? s_IndPipeline : s_Pipeline, m_vbo.get(), nullptr, nullptr,
// bufs.size(), bufs.data(), stages.data(), nullptr, nullptr, texCount,
// texs.data(), texBindIdxs.data(), nullptr);
// return true;
// } BooTrace);
// }
SClipScreenRect rect;
rect.x4_left = g_Viewport.x0_left;
@ -123,18 +123,18 @@ void CPhazonSuitFilter::drawBlurPasses(float radius, const CTexture* indTex) {
/* X Pass */
auto blurDir = zeus::CVector4f{g_Viewport.xc_height / float(g_Viewport.x8_width) * radius * blurScale, 0.f, 0.f, 0.f};
m_uniBufBlurX->load(&blurDir, sizeof(zeus::CVector4f));
// m_uniBufBlurX->load(&blurDir, sizeof(zeus::CVector4f));
CGraphics::SetShaderDataBinding(m_dataBindBlurX);
CGraphics::DrawArray(0, 4);
// CGraphics::SetShaderDataBinding(m_dataBindBlurX);
// CGraphics::DrawArray(0, 4);
CGraphics::ResolveSpareTexture(rect, 2);
/* Y Pass */
blurDir = zeus::CVector4f{0.f, radius * blurScale, 0.f, 0.f};
m_uniBufBlurY->load(&blurDir, sizeof(zeus::CVector4f));
// m_uniBufBlurY->load(&blurDir, sizeof(zeus::CVector4f));
CGraphics::SetShaderDataBinding(m_dataBindBlurY);
CGraphics::DrawArray(0, 4);
// CGraphics::SetShaderDataBinding(m_dataBindBlurY);
// CGraphics::DrawArray(0, 4);
CGraphics::ResolveSpareTexture(rect, 2);
}
@ -145,9 +145,9 @@ void CPhazonSuitFilter::draw(const zeus::CColor& color, float indScale, float in
zeus::CVector4f indScaleOff;
} uniform = {color, zeus::CVector4f(indScale, indScale, indOffX, indOffY)};
m_uniBuf->load(&uniform, sizeof(Uniform));
CGraphics::SetShaderDataBinding(m_dataBind);
CGraphics::DrawArray(0, 4);
// m_uniBuf->load(&uniform, sizeof(Uniform));
// CGraphics::SetShaderDataBinding(m_dataBind);
// CGraphics::DrawArray(0, 4);
}
} // namespace metaforce

Some files were not shown because too many files have changed in this diff Show More