Moved `render` into `crates`

master
Mark 2023-12-31 18:39:37 -08:00
parent fa8a0f5761
commit fc728eaf0e
Signed by: Mark
GPG Key ID: C6D63995FE72FD80
26 changed files with 192 additions and 101 deletions

15
Cargo.lock generated
View File

@ -578,10 +578,10 @@ name = "galactica"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"bytemuck",
"cgmath", "cgmath",
"crossbeam", "crossbeam",
"galactica-content", "galactica-content",
"galactica-render",
"image", "image",
"nalgebra", "nalgebra",
"pollster", "pollster",
@ -605,6 +605,19 @@ dependencies = [
"walkdir", "walkdir",
] ]
[[package]]
name = "galactica-render"
version = "0.0.0"
dependencies = [
"anyhow",
"bytemuck",
"cgmath",
"galactica-content",
"image",
"wgpu",
"winit",
]
[[package]] [[package]]
name = "getrandom" name = "getrandom"
version = "0.2.11" version = "0.2.11"

View File

@ -28,26 +28,27 @@ rpath = false
[workspace] [workspace]
members = ["crates/content"] members = ["crates/content", "crates/render"]
[dependencies] [dependencies]
# Internal crates # Internal crates
galactica-content = { path = "crates/content" } galactica-content = { path = "crates/content" }
galactica-render = { path = "crates/render" }
# Files # Files
image = { version = "0.24", features = ["png"] } image = { version = "0.24", features = ["png"] }
# Graphics # Graphics
winit = "0.28" winit = "0.28"
wgpu = "0.18" wgpu = "0.18"
bytemuck = { version = "1.12", features = ["derive"] }
# Physics # Physics
rapier2d = { version = "0.17.2" } #, features = ["parallel"] } rapier2d = { version = "0.17.2" }
nalgebra = "0.32.3" nalgebra = "0.32.3"
crossbeam = "0.8.3" crossbeam = "0.8.3"
# Misc helpers # Misc helpers
pollster = "0.3" pollster = "0.3"
anyhow = "1.0" anyhow = "1.0"
# TODO: migrate to nalgebra
cgmath = "0.18.0" cgmath = "0.18.0"
rand = "0.8.5" rand = "0.8.5"
walkdir = "2.4.0" walkdir = "2.4.0"

17
crates/render/Cargo.toml Normal file
View File

@ -0,0 +1,17 @@
[package]
name = "galactica-render"
version = "0.0.0"
edition = "2021"
[dependencies]
galactica-content = { path = "../content" }
# Misc helpers
anyhow = "1.0"
cgmath = "0.18.0"
# Files
image = { version = "0.24", features = ["png"] }
# Graphics
winit = "0.28"
wgpu = "0.18"
bytemuck = { version = "1.12", features = ["derive"] }

View File

@ -1,4 +1,4 @@
use crate::consts; use crate::consts_main;
use cgmath::Matrix4; use cgmath::Matrix4;
// We can draw at most this many sprites on the screen. // We can draw at most this many sprites on the screen.
@ -6,7 +6,7 @@ use cgmath::Matrix4;
pub const SPRITE_INSTANCE_LIMIT: u64 = 500; pub const SPRITE_INSTANCE_LIMIT: u64 = 500;
// Must be small enough to fit in an i32 // Must be small enough to fit in an i32
pub const STARFIELD_INSTANCE_LIMIT: u64 = consts::STARFIELD_COUNT * 24; pub const STARFIELD_INSTANCE_LIMIT: u64 = consts_main::STARFIELD_COUNT * 24;
/// Shader entry points /// Shader entry points
pub const SHADER_MAIN_VERTEX: &'static str = "vertex_main"; pub const SHADER_MAIN_VERTEX: &'static str = "vertex_main";

View File

@ -0,0 +1,26 @@
pub const ZOOM_MIN: f32 = 200.0;
pub const ZOOM_MAX: f32 = 2000.0;
/// Z-axis range for starfield stars
/// This does not affect scale.
pub const STARFIELD_Z_MIN: f32 = 100.0;
pub const STARFIELD_Z_MAX: f32 = 200.0;
/// Size range for starfield stars, in game units.
/// This is scaled for zoom, but NOT for distance.
pub const STARFIELD_SIZE_MIN: f32 = 0.2;
pub const STARFIELD_SIZE_MAX: f32 = 1.8;
/// Size of a square starfield tile, in game units.
/// A tile of size STARFIELD_Z_MAX * screen-size-in-game-units
/// will completely cover a (square) screen. This depends on zoom!
///
/// Use a value smaller than zoom_max for debug.
pub const STARFIELD_SIZE: u64 = STARFIELD_Z_MAX as u64 * ZOOM_MAX as u64;
/// Average number of stars per game unit
pub const STARFIELD_DENSITY: f64 = 0.01;
/// Number of stars in one starfield tile
/// Must fit inside an i32
pub const STARFIELD_COUNT: u64 = (STARFIELD_SIZE as f64 * STARFIELD_DENSITY) as u64;

View File

@ -12,6 +12,7 @@ use winit::{
use super::{ use super::{
consts::{OPENGL_TO_WGPU_MATRIX, SPRITE_INSTANCE_LIMIT, STARFIELD_INSTANCE_LIMIT}, consts::{OPENGL_TO_WGPU_MATRIX, SPRITE_INSTANCE_LIMIT, STARFIELD_INSTANCE_LIMIT},
consts_main,
globaldata::{GlobalData, GlobalDataContent}, globaldata::{GlobalData, GlobalDataContent},
pipeline::PipelineBuilder, pipeline::PipelineBuilder,
sprite::ObjectSubSprite, sprite::ObjectSubSprite,
@ -21,9 +22,8 @@ use super::{
types::{SpriteInstance, StarfieldInstance, TexturedVertex}, types::{SpriteInstance, StarfieldInstance, TexturedVertex},
VertexBuffer, VertexBuffer,
}, },
ObjectSprite, UiSprite, ObjectSprite, StarfieldStar, UiSprite,
}; };
use crate::{consts, game::Game};
pub struct GPUState { pub struct GPUState {
device: wgpu::Device, device: wgpu::Device,
@ -145,7 +145,7 @@ impl GPUState {
let sprite_pipeline = PipelineBuilder::new("sprite", &device) let sprite_pipeline = PipelineBuilder::new("sprite", &device)
.set_shader(include_str!(concat!( .set_shader(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"), env!("CARGO_MANIFEST_DIR"),
"/src/render/shaders/", "/shaders/",
"sprite.wgsl" "sprite.wgsl"
))) )))
.set_format(config.format) .set_format(config.format)
@ -157,7 +157,7 @@ impl GPUState {
let starfield_pipeline = PipelineBuilder::new("starfield", &device) let starfield_pipeline = PipelineBuilder::new("starfield", &device)
.set_shader(include_str!(concat!( .set_shader(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"), env!("CARGO_MANIFEST_DIR"),
"/src/render/shaders/", "/shaders/",
"starfield.wgsl" "starfield.wgsl"
))) )))
.set_format(config.format) .set_format(config.format)
@ -190,7 +190,7 @@ impl GPUState {
&self.window &self.window
} }
pub fn resize(&mut self, game: &Game, new_size: PhysicalSize<u32>) { pub fn resize(&mut self, starfield: &Vec<StarfieldStar>, new_size: PhysicalSize<u32>) {
if new_size.width > 0 && new_size.height > 0 { if new_size.width > 0 && new_size.height > 0 {
self.window_size = new_size; self.window_size = new_size;
self.window_aspect = new_size.width as f32 / new_size.height as f32; self.window_aspect = new_size.width as f32 / new_size.height as f32;
@ -198,18 +198,19 @@ impl GPUState {
self.config.height = new_size.height; self.config.height = new_size.height;
self.surface.configure(&self.device, &self.config); self.surface.configure(&self.device, &self.config);
} }
self.update_starfield_buffer(game) self.update_starfield_buffer(starfield)
} }
/// Create a SpriteInstance for an object and add it to `instances`. /// Create a SpriteInstance for an object and add it to `instances`.
/// Also handles child sprites. /// Also handles child sprites.
fn push_object_sprite( fn push_object_sprite(
&self, &self,
game: &Game, camera_zoom: f32,
camera_pos: Point2<f32>,
instances: &mut Vec<SpriteInstance>, instances: &mut Vec<SpriteInstance>,
clip_ne: Point2<f32>, clip_ne: Point2<f32>,
clip_sw: Point2<f32>, clip_sw: Point2<f32>,
s: ObjectSprite, s: &ObjectSprite,
) { ) {
// Position adjusted for parallax // Position adjusted for parallax
// TODO: adjust parallax for zoom? // TODO: adjust parallax for zoom?
@ -217,7 +218,7 @@ impl GPUState {
(Point2 { (Point2 {
x: s.pos.x, x: s.pos.x,
y: s.pos.y, y: s.pos.y,
} - game.camera.pos.to_vec()) } - camera_pos.to_vec())
/ s.pos.z / s.pos.z
}; };
let texture = self.texture_array.get_texture(s.texture); let texture = self.texture_array.get_texture(s.texture);
@ -241,7 +242,7 @@ impl GPUState {
} }
// TODO: clean up // TODO: clean up
let scale = height / game.camera.zoom; let scale = height / camera_zoom;
// Note that our mesh starts centered at (0, 0). // Note that our mesh starts centered at (0, 0).
// This is essential---we do not want scale and rotation // This is essential---we do not want scale and rotation
@ -270,8 +271,8 @@ impl GPUState {
// The height of the viewport is `zoom` in game units, // The height of the viewport is `zoom` in game units,
// but it's 2 in screen units! (since coordinates range from -1 to 1) // but it's 2 in screen units! (since coordinates range from -1 to 1)
let translate = Matrix4::from_translation(Vector3 { let translate = Matrix4::from_translation(Vector3 {
x: pos.x / (game.camera.zoom / 2.0) / self.window_aspect, x: pos.x / (camera_zoom / 2.0) / self.window_aspect,
y: pos.y / (game.camera.zoom / 2.0), y: pos.y / (camera_zoom / 2.0),
z: 0.0, z: 0.0,
}); });
@ -286,9 +287,9 @@ impl GPUState {
}); });
// Add children // Add children
if let Some(children) = s.children { if let Some(children) = &s.children {
for c in children { for c in children {
self.push_object_subsprite(game, instances, c, pos, s.angle); self.push_object_subsprite(camera_zoom, instances, c, pos, s.angle);
} }
} }
} }
@ -297,29 +298,29 @@ impl GPUState {
/// Only called by `self.push_object_sprite`. /// Only called by `self.push_object_sprite`.
fn push_object_subsprite( fn push_object_subsprite(
&self, &self,
game: &Game, camera_zoom: f32,
instances: &mut Vec<SpriteInstance>, instances: &mut Vec<SpriteInstance>,
s: ObjectSubSprite, s: &ObjectSubSprite,
parent_pos: Point2<f32>, parent_pos: Point2<f32>,
parent_angle: Deg<f32>, parent_angle: Deg<f32>,
) { ) {
let texture = self.texture_array.get_texture(s.texture); let texture = self.texture_array.get_texture(s.texture);
let scale = s.size / (s.pos.z * game.camera.zoom); let scale = s.size / (s.pos.z * camera_zoom);
let sprite_aspect_and_scale = let sprite_aspect_and_scale =
Matrix4::from_nonuniform_scale(texture.aspect * scale, scale, 1.0); Matrix4::from_nonuniform_scale(texture.aspect * scale, scale, 1.0);
let rotate = Matrix4::from_angle_z(s.angle); let rotate = Matrix4::from_angle_z(s.angle);
let screen_aspect = Matrix4::from_nonuniform_scale(1.0 / self.window_aspect, 1.0, 1.0); let screen_aspect = Matrix4::from_nonuniform_scale(1.0 / self.window_aspect, 1.0, 1.0);
let ptranslate = Matrix4::from_translation(Vector3 { let ptranslate = Matrix4::from_translation(Vector3 {
x: parent_pos.x / (game.camera.zoom / 2.0) / self.window_aspect, x: parent_pos.x / (camera_zoom / 2.0) / self.window_aspect,
y: parent_pos.y / (game.camera.zoom / 2.0), y: parent_pos.y / (camera_zoom / 2.0),
z: 0.0, z: 0.0,
}); });
let protate = Matrix4::from_angle_z(parent_angle); let protate = Matrix4::from_angle_z(parent_angle);
let translate = Matrix4::from_translation(Vector3 { let translate = Matrix4::from_translation(Vector3 {
x: s.pos.x / (game.camera.zoom / 2.0) / self.window_aspect, x: s.pos.x / (camera_zoom / 2.0) / self.window_aspect,
y: s.pos.y / (game.camera.zoom / 2.0), y: s.pos.y / (camera_zoom / 2.0),
z: 0.0, z: 0.0,
}); });
@ -337,7 +338,7 @@ impl GPUState {
} }
/// Create a SpriteInstance for a ui sprite and add it to `instances` /// Create a SpriteInstance for a ui sprite and add it to `instances`
fn push_ui_sprite(&self, instances: &mut Vec<SpriteInstance>, s: UiSprite) { fn push_ui_sprite(&self, instances: &mut Vec<SpriteInstance>, s: &UiSprite) {
let logical_size: LogicalSize<f32> = let logical_size: LogicalSize<f32> =
self.window_size.to_logical(self.window.scale_factor()); self.window_size.to_logical(self.window.scale_factor());
@ -375,19 +376,25 @@ impl GPUState {
/// Will panic if SPRITE_INSTANCE_LIMIT is exceeded. /// Will panic if SPRITE_INSTANCE_LIMIT is exceeded.
/// ///
/// This is only called inside self.render() /// This is only called inside self.render()
fn make_sprite_instances(&self, game: &Game) -> Vec<SpriteInstance> { fn make_sprite_instances(
&self,
camera_zoom: f32,
camera_pos: Point2<f32>,
objects: &Vec<ObjectSprite>,
ui: &Vec<UiSprite>,
) -> Vec<SpriteInstance> {
let mut instances: Vec<SpriteInstance> = Vec::new(); let mut instances: Vec<SpriteInstance> = Vec::new();
// Game coordinates (relative to camera) of ne and sw corners of screen. // Game coordinates (relative to camera) of ne and sw corners of screen.
// Used to skip off-screen sprites. // Used to skip off-screen sprites.
let clip_ne = Point2::from((-self.window_aspect, 1.0)) * game.camera.zoom; let clip_ne = Point2::from((-self.window_aspect, 1.0)) * camera_zoom;
let clip_sw = Point2::from((self.window_aspect, -1.0)) * game.camera.zoom; let clip_sw = Point2::from((self.window_aspect, -1.0)) * camera_zoom;
for s in game.get_object_sprites() { for s in objects {
self.push_object_sprite(game, &mut instances, clip_ne, clip_sw, s); self.push_object_sprite(camera_zoom, camera_pos, &mut instances, clip_ne, clip_sw, s);
} }
for s in game.get_ui_sprites() { for s in ui {
self.push_ui_sprite(&mut instances, s); self.push_ui_sprite(&mut instances, s);
} }
@ -404,18 +411,19 @@ impl GPUState {
/// Will panic if STARFIELD_INSTANCE_LIMIT is exceeded. /// Will panic if STARFIELD_INSTANCE_LIMIT is exceeded.
/// ///
/// Starfield data rarely changes, so this is called only when it's needed. /// Starfield data rarely changes, so this is called only when it's needed.
pub fn update_starfield_buffer(&mut self, game: &Game) { pub fn update_starfield_buffer(&mut self, starfield: &Vec<StarfieldStar>) {
let sz = consts::STARFIELD_SIZE as f32; let sz = consts_main::STARFIELD_SIZE as f32;
// Compute window size in starfield tiles // Compute window size in starfield tiles
let mut nw_tile: Point2<i32> = { let mut nw_tile: Point2<i32> = {
// Game coordinates (relative to camera) of nw corner of screen. // Game coordinates (relative to camera) of nw corner of screen.
let clip_nw = Point2::from((self.window_aspect, 1.0)) * consts::ZOOM_MAX; // TODO: we probably don't need to re-compute this on resize
let clip_nw = Point2::from((self.window_aspect, 1.0)) * consts_main::ZOOM_MAX;
// Parallax correction. // Parallax correction.
// Also, adjust v for mod to work properly // Also, adjust v for mod to work properly
// (v is centered at 0) // (v is centered at 0)
let v: Point2<f32> = clip_nw * consts::STARFIELD_Z_MIN; let v: Point2<f32> = clip_nw * consts_main::STARFIELD_Z_MIN;
let v_adj: Point2<f32> = (v.x + (sz / 2.0), v.y + (sz / 2.0)).into(); let v_adj: Point2<f32> = (v.x + (sz / 2.0), v.y + (sz / 2.0)).into();
#[rustfmt::skip] #[rustfmt::skip]
@ -439,7 +447,7 @@ impl GPUState {
// Truncate tile grid to buffer size // Truncate tile grid to buffer size
// (The window won't be full of stars if our instance limit is too small) // (The window won't be full of stars if our instance limit is too small)
while ((nw_tile.x * 2 + 1) * (nw_tile.y * 2 + 1) * consts::STARFIELD_COUNT as i32) while ((nw_tile.x * 2 + 1) * (nw_tile.y * 2 + 1) * consts_main::STARFIELD_COUNT as i32)
> STARFIELD_INSTANCE_LIMIT as i32 > STARFIELD_INSTANCE_LIMIT as i32
{ {
nw_tile -= Vector2::from((1, 1)); nw_tile -= Vector2::from((1, 1));
@ -454,7 +462,7 @@ impl GPUState {
y: sz * y as f32, y: sz * y as f32,
z: 0.0, z: 0.0,
}; };
for s in &game.system.starfield { for s in starfield {
instances.push(StarfieldInstance { instances.push(StarfieldInstance {
position: (s.pos + offset).into(), position: (s.pos + offset).into(),
size: s.size, size: s.size,
@ -477,7 +485,13 @@ impl GPUState {
); );
} }
pub fn render(&mut self, game: &Game) -> Result<(), wgpu::SurfaceError> { pub fn render(
&mut self,
camera_pos: Point2<f32>,
camera_zoom: f32,
object_sprites: &Vec<ObjectSprite>,
ui_sprites: &Vec<UiSprite>,
) -> Result<(), wgpu::SurfaceError> {
let output = self.surface.get_current_texture()?; let output = self.surface.get_current_texture()?;
let view = output let view = output
.texture .texture
@ -515,22 +529,26 @@ impl GPUState {
&self.global_data.buffer, &self.global_data.buffer,
0, 0,
bytemuck::cast_slice(&[GlobalDataContent { bytemuck::cast_slice(&[GlobalDataContent {
camera_position: game.camera.pos.into(), camera_position: camera_pos.into(),
camera_zoom: [game.camera.zoom, 0.0], camera_zoom: [camera_zoom, 0.0],
camera_zoom_limits: [consts::ZOOM_MIN, consts::ZOOM_MAX], camera_zoom_limits: [consts_main::ZOOM_MIN, consts_main::ZOOM_MAX],
window_size: [ window_size: [
self.window_size.width as f32, self.window_size.width as f32,
self.window_size.height as f32, self.window_size.height as f32,
], ],
window_aspect: [self.window_aspect, 0.0], window_aspect: [self.window_aspect, 0.0],
starfield_texture: [self.texture_array.get_starfield_texture().index, 0], starfield_texture: [self.texture_array.get_starfield_texture().index, 0],
starfield_tile_size: [consts::STARFIELD_SIZE as f32, 0.0], starfield_tile_size: [consts_main::STARFIELD_SIZE as f32, 0.0],
starfield_size_limits: [consts::STARFIELD_SIZE_MIN, consts::STARFIELD_SIZE_MAX], starfield_size_limits: [
consts_main::STARFIELD_SIZE_MIN,
consts_main::STARFIELD_SIZE_MAX,
],
}]), }]),
); );
// Create sprite instances // Create sprite instances
let sprite_instances = self.make_sprite_instances(game); let sprite_instances =
self.make_sprite_instances(camera_zoom, camera_pos, object_sprites, ui_sprites);
self.queue.write_buffer( self.queue.write_buffer(
&self.vertex_buffers.sprite.instances, &self.vertex_buffers.sprite.instances,
0, 0,

28
crates/render/src/lib.rs Normal file
View File

@ -0,0 +1,28 @@
mod consts;
mod globaldata;
mod gpustate;
mod pipeline;
mod sprite;
mod texturearray;
mod vertexbuffer;
// TODO: remove
mod consts_main;
use cgmath::{Point3, Vector2};
pub use gpustate::GPUState;
pub use sprite::{AnchoredUiPosition, ObjectSprite, ObjectSubSprite, UiSprite};
pub struct StarfieldStar {
/// Star coordinates, in world space.
/// These are relative to the center of a starfield tile.
pub pos: Point3<f32>,
/// Height in game units.
/// Will be scaled for zoom, but not for distance.
pub size: f32,
/// Color/brightness variation. Random between 0 and 1.
/// Used in starfield shader.
pub tint: Vector2<f32>,
}

View File

@ -1,15 +1,15 @@
use cgmath::{Deg, InnerSpace, Point2}; use cgmath::{Deg, InnerSpace, Point2};
use galactica_content as content;
use galactica_content::FactionHandle; use galactica_content::FactionHandle;
use galactica_render::{AnchoredUiPosition, ObjectSprite, UiSprite};
use std::time::Instant; use std::time::Instant;
use winit::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, VirtualKeyCode}; use winit::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, VirtualKeyCode};
use super::{camera::Camera, outfits, system::System}; use super::{camera::Camera, outfits, system::System};
use crate::{ use crate::{
consts, consts,
content::Content,
inputstatus::InputStatus, inputstatus::InputStatus,
physics::{util, Physics, ShipHandle}, physics::{util, Physics, ShipHandle},
render::{AnchoredUiPosition, ObjectSprite, UiSprite},
shipbehavior::{self, ShipBehavior}, shipbehavior::{self, ShipBehavior},
}; };
@ -20,7 +20,12 @@ impl Ui {
Self {} Self {}
} }
fn build_radar(&self, player: &ShipHandle, physics: &Physics, ct: &Content) -> Vec<UiSprite> { fn build_radar(
&self,
player: &ShipHandle,
physics: &Physics,
ct: &content::Content,
) -> Vec<UiSprite> {
let mut out = Vec::new(); let mut out = Vec::new();
let radar_range = 2000.0; let radar_range = 2000.0;
@ -76,11 +81,11 @@ pub struct Game {
ui: Ui, ui: Ui,
physics: Physics, physics: Physics,
shipbehaviors: Vec<Box<dyn ShipBehavior>>, shipbehaviors: Vec<Box<dyn ShipBehavior>>,
content: Content, content: content::Content,
} }
impl Game { impl Game {
pub fn new(ct: Content) -> Self { pub fn new(ct: content::Content) -> Self {
let mut physics = Physics::new(); let mut physics = Physics::new();
let mut o1 = outfits::ShipOutfits::new(&ct.ships[0]); let mut o1 = outfits::ShipOutfits::new(&ct.ships[0]);

View File

@ -1,7 +1,6 @@
use cgmath::{Deg, Point3}; use cgmath::{Deg, Point3};
use content::{OutfitSpace, TextureHandle}; use galactica_content as content;
use galactica_render::ObjectSubSprite;
use crate::{content, render::ObjectSubSprite};
/// Represents a gun attached to a specific ship at a certain gunpoint. /// Represents a gun attached to a specific ship at a certain gunpoint.
#[derive(Debug)] #[derive(Debug)]
@ -28,7 +27,7 @@ impl ShipGun {
pub struct OutfitStatSum { pub struct OutfitStatSum {
pub engine_thrust: f32, pub engine_thrust: f32,
pub steer_power: f32, pub steer_power: f32,
pub engine_flare_textures: Vec<TextureHandle>, pub engine_flare_textures: Vec<content::TextureHandle>,
} }
impl OutfitStatSum { impl OutfitStatSum {
@ -67,9 +66,9 @@ impl OutfitStatSum {
#[derive(Debug)] #[derive(Debug)]
pub struct ShipOutfits { pub struct ShipOutfits {
pub stats: OutfitStatSum, pub stats: OutfitStatSum,
pub total_space: OutfitSpace, pub total_space: content::OutfitSpace,
available_space: OutfitSpace, available_space: content::OutfitSpace,
outfits: Vec<content::Outfit>, outfits: Vec<content::Outfit>,
guns: Vec<ShipGun>, guns: Vec<ShipGun>,
enginepoints: Vec<content::EnginePoint>, enginepoints: Vec<content::EnginePoint>,

View File

@ -1,22 +1,10 @@
use cgmath::{Point3, Vector2}; use cgmath::{Point3, Vector2};
use galactica_content as content;
use galactica_render::{ObjectSprite, StarfieldStar};
use rand::{self, Rng}; use rand::{self, Rng};
use super::SystemObject; use super::SystemObject;
use crate::{consts, content, render::ObjectSprite}; use crate::consts;
pub struct StarfieldStar {
/// Star coordinates, in world space.
/// These are relative to the center of a starfield tile.
pub pos: Point3<f32>,
/// Height in game units.
/// Will be scaled for zoom, but not for distance.
pub size: f32,
/// Color/brightness variation. Random between 0 and 1.
/// Used in starfield shader.
pub tint: Vector2<f32>,
}
pub struct System { pub struct System {
pub name: String, pub name: String,

View File

@ -1,7 +1,6 @@
use cgmath::{Deg, Point3}; use cgmath::{Deg, Point3};
use galactica_content::TextureHandle; use galactica_content::TextureHandle;
use galactica_render::ObjectSprite;
use crate::render::ObjectSprite;
pub struct SystemObject { pub struct SystemObject {
pub sprite_texture: TextureHandle, pub sprite_texture: TextureHandle,

View File

@ -3,13 +3,11 @@ mod game;
mod inputstatus; mod inputstatus;
mod objects; mod objects;
mod physics; mod physics;
mod render;
mod shipbehavior; mod shipbehavior;
use std::path::PathBuf; use std::path::PathBuf;
use anyhow::Result; use anyhow::Result;
use galactica_content as content;
use winit::{ use winit::{
event::{Event, KeyboardInput, WindowEvent}, event::{Event, KeyboardInput, WindowEvent},
event_loop::{ControlFlow, EventLoop}, event_loop::{ControlFlow, EventLoop},
@ -18,7 +16,7 @@ use winit::{
fn main() -> Result<()> { fn main() -> Result<()> {
// TODO: error if missing // TODO: error if missing
let content = content::Content::load_dir( let content = galactica_content::Content::load_dir(
PathBuf::from(consts::CONTENT_ROOT), PathBuf::from(consts::CONTENT_ROOT),
PathBuf::from(consts::TEXTURE_ROOT), PathBuf::from(consts::TEXTURE_ROOT),
consts::STARFIELD_TEXTURE_NAME.to_owned(), consts::STARFIELD_TEXTURE_NAME.to_owned(),
@ -26,17 +24,24 @@ fn main() -> Result<()> {
let event_loop = EventLoop::new(); let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&event_loop).unwrap(); let window = WindowBuilder::new().build(&event_loop).unwrap();
let mut gpu = pollster::block_on(render::GPUState::new(window, &content))?; let mut gpu = pollster::block_on(galactica_render::GPUState::new(window, &content))?;
let mut game = game::Game::new(content); let mut game = game::Game::new(content);
gpu.update_starfield_buffer(&game); gpu.update_starfield_buffer(&game.system.starfield);
event_loop.run(move |event, _, control_flow| { event_loop.run(move |event, _, control_flow| {
match event { match event {
Event::RedrawRequested(window_id) if window_id == gpu.window().id() => { Event::RedrawRequested(window_id) if window_id == gpu.window().id() => {
match gpu.render(&game) { match gpu.render(
game.camera.pos,
game.camera.zoom,
&game.get_object_sprites(),
&game.get_ui_sprites(),
) {
Ok(_) => {} Ok(_) => {}
Err(wgpu::SurfaceError::Lost) => gpu.resize(&game, gpu.window_size), Err(wgpu::SurfaceError::Lost) => {
gpu.resize(&game.system.starfield, gpu.window_size)
}
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit, Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
// All other errors (Outdated, Timeout) should be resolved by the next frame // All other errors (Outdated, Timeout) should be resolved by the next frame
Err(e) => eprintln!("{:?}", e), Err(e) => eprintln!("{:?}", e),
@ -72,10 +77,10 @@ fn main() -> Result<()> {
game.process_scroll(delta, phase); game.process_scroll(delta, phase);
} }
WindowEvent::Resized(physical_size) => { WindowEvent::Resized(physical_size) => {
gpu.resize(&game, *physical_size); gpu.resize(&game.system.starfield, *physical_size);
} }
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => { WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
gpu.resize(&game, **new_inner_size); gpu.resize(&game.system.starfield, **new_inner_size);
} }
_ => {} _ => {}
}, },

View File

@ -1,11 +1,12 @@
use cgmath::{Deg, InnerSpace, Point3, Vector2}; use cgmath::{Deg, InnerSpace, Point3, Vector2};
use galactica_content::{FactionHandle, TextureHandle}; use galactica_content::{FactionHandle, TextureHandle};
use galactica_render::ObjectSprite;
use rapier2d::{ use rapier2d::{
dynamics::{RigidBody, RigidBodyBuilder, RigidBodyHandle}, dynamics::{RigidBody, RigidBodyBuilder, RigidBodyHandle},
geometry::{ColliderBuilder, ColliderHandle}, geometry::{ColliderBuilder, ColliderHandle},
}; };
use crate::{physics::util, render::ObjectSprite}; use crate::physics::util;
pub struct ProjectileBuilder { pub struct ProjectileBuilder {
pub rigid_body: RigidBodyBuilder, pub rigid_body: RigidBodyBuilder,

View File

@ -1,5 +1,7 @@
use cgmath::{Deg, EuclideanSpace, InnerSpace, Matrix2, Rad, Vector2}; use cgmath::{Deg, EuclideanSpace, InnerSpace, Matrix2, Rad, Vector2};
use content::{FactionHandle, TextureHandle}; use content::{FactionHandle, TextureHandle};
use galactica_content as content;
use galactica_render::ObjectSprite;
use nalgebra::vector; use nalgebra::vector;
use rand::Rng; use rand::Rng;
use rapier2d::{ use rapier2d::{
@ -10,10 +12,8 @@ use rapier2d::{
use super::ProjectileBuilder; use super::ProjectileBuilder;
use crate::{ use crate::{
content,
game::outfits, game::outfits,
physics::{util, ShipHandle}, physics::{util, ShipHandle},
render::ObjectSprite,
}; };
pub struct ShipTickResult { pub struct ShipTickResult {

View File

@ -1,6 +1,7 @@
use cgmath::Point2; use cgmath::Point2;
use content::{Content, FactionHandle};
use crossbeam::channel::Receiver; use crossbeam::channel::Receiver;
use galactica_content as content;
use galactica_render::ObjectSprite;
use nalgebra::vector; use nalgebra::vector;
use rapier2d::{ use rapier2d::{
dynamics::{RigidBody, RigidBodyBuilder, RigidBodyHandle}, dynamics::{RigidBody, RigidBodyBuilder, RigidBodyHandle},
@ -10,7 +11,7 @@ use rapier2d::{
use std::{collections::HashMap, f32::consts::PI}; use std::{collections::HashMap, f32::consts::PI};
use super::{wrapper::Wrapper, ShipHandle}; use super::{wrapper::Wrapper, ShipHandle};
use crate::{content, game::outfits, objects, render::ObjectSprite}; use crate::{game::outfits, objects};
/// Keeps track of all objects in the world that we can interact with. /// Keeps track of all objects in the world that we can interact with.
/// Also wraps our physics engine /// Also wraps our physics engine
@ -84,7 +85,7 @@ impl Physics {
ct: &content::Ship, ct: &content::Ship,
outfits: outfits::ShipOutfits, outfits: outfits::ShipOutfits,
position: Point2<f32>, position: Point2<f32>,
faction: FactionHandle, faction: content::FactionHandle,
) -> ShipHandle { ) -> ShipHandle {
let cl = ColliderBuilder::convex_decomposition( let cl = ColliderBuilder::convex_decomposition(
&ct.collision.points[..], &ct.collision.points[..],
@ -114,7 +115,7 @@ impl Physics {
return h; return h;
} }
pub fn step(&mut self, t: f32, ct: &Content) { pub fn step(&mut self, t: f32, ct: &content::Content) {
// Run ship updates // Run ship updates
let mut res = Vec::new(); let mut res = Vec::new();
let mut to_remove = Vec::new(); let mut to_remove = Vec::new();

View File

@ -1,10 +0,0 @@
mod consts;
mod globaldata;
mod gpustate;
mod pipeline;
mod sprite;
mod texturearray;
mod vertexbuffer;
pub use gpustate::GPUState;
pub use sprite::{AnchoredUiPosition, ObjectSprite, ObjectSubSprite, UiSprite};