lew/rust-rl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
rust-rl/src/main.rs

641 lines
25 KiB
Rust
Raw Blame History

use rust_rl::*;
use notan::prelude::*;
use notan::math::{ vec2, vec3, Mat4, Vec2 };
use notan::draw::create_textures_from_atlas;
use notan::draw::{ CreateFont, CreateDraw, DrawImages, Draw, DrawTextSection, DrawShapes };
use specs::prelude::*;
use specs::saveload::{ SimpleMarker, SimpleMarkerAllocator };
use bracket_lib::prelude::*;
use std::collections::HashMap;
use crate::consts::{ DISPLAYHEIGHT, DISPLAYWIDTH, TILESIZE, FONTSIZE };
use crate::states::state::Fonts;
const WORK_SIZE: Vec2 = vec2(
(DISPLAYWIDTH as f32) * TILESIZE.x,
(DISPLAYHEIGHT as f32) * TILESIZE.x
);
#[notan_main]
fn main() -> Result<(), String> {
let win_config = WindowConfig::new()
.set_size(DISPLAYWIDTH * (TILESIZE.x as u32), DISPLAYHEIGHT * (TILESIZE.x as u32))
.set_title("RUST-RL")
.set_resizable(true)
.set_fullscreen(true)
.set_taskbar_icon_data(Some(include_bytes!("../resources/icon.png")))
.set_vsync(true);
notan
::init_with(setup)
.add_config(win_config)
.add_config(notan::draw::DrawConfig)
.draw(draw)
.update(update)
.build()
}
fn setup(app: &mut App, gfx: &mut Graphics) -> State {
effects::sound::init_sounds(app);
let texture = gfx
.create_texture()
.from_image(include_bytes!("../resources/atlas.png"))
.build()
.unwrap();
let data = include_bytes!("../resources/atlas.json");
let atlas = create_textures_from_atlas(data, &texture).unwrap();
let texture = gfx
.create_texture()
.from_image(include_bytes!("../resources/td.png"))
.build()
.unwrap();
let data = include_bytes!("../resources/td.json");
let interface = create_textures_from_atlas(data, &texture).unwrap();
let font = Fonts::new(
gfx.create_font(include_bytes!("../resources/fonts/Greybeard-16px.ttf")).unwrap(),
Some(
gfx.create_font(include_bytes!("../resources/fonts/Greybeard-16px-Bold.ttf")).unwrap()
),
Some(
gfx.create_font(include_bytes!("../resources/fonts/Greybeard-16px-Italic.ttf")).unwrap()
)
);
let mut gs = State {
ecs: World::new(),
//audio: sounds,
atlas,
interface,
font,
mapgen_next_state: Some(RunState::MainMenu {
menu_selection: gui::MainMenuSelection::NewGame,
}),
mapgen_index: 0,
mapgen_history: Vec::new(),
mapgen_timer: 0.0,
};
gs.ecs.register::<Position>();
gs.ecs.register::<OtherLevelPosition>();
gs.ecs.register::<Renderable>();
gs.ecs.register::<Burden>();
gs.ecs.register::<Prop>();
gs.ecs.register::<Player>();
gs.ecs.register::<HasAncestry>();
gs.ecs.register::<HasClass>();
gs.ecs.register::<Chasing>();
gs.ecs.register::<Faction>();
gs.ecs.register::<Clock>();
gs.ecs.register::<Quips>();
gs.ecs.register::<Mind>();
gs.ecs.register::<Viewshed>();
gs.ecs.register::<Telepath>();
gs.ecs.register::<Name>();
gs.ecs.register::<ObfuscatedName>();
gs.ecs.register::<BlocksTile>();
gs.ecs.register::<BlocksVisibility>();
gs.ecs.register::<Door>();
gs.ecs.register::<Pools>();
gs.ecs.register::<Attributes>();
gs.ecs.register::<Skills>();
gs.ecs.register::<HungerClock>();
gs.ecs.register::<WantsToMelee>();
gs.ecs.register::<Item>();
gs.ecs.register::<Beatitude>();
gs.ecs.register::<IdentifiedItem>();
gs.ecs.register::<IdentifiedBeatitude>();
gs.ecs.register::<MagicItem>();
gs.ecs.register::<GrantsXP>();
gs.ecs.register::<LootTable>();
gs.ecs.register::<Energy>();
gs.ecs.register::<TakingTurn>();
gs.ecs.register::<Equippable>();
gs.ecs.register::<EquipmentChanged>();
gs.ecs.register::<Equipped>();
gs.ecs.register::<MeleeWeapon>();
gs.ecs.register::<NaturalAttacks>();
gs.ecs.register::<ArmourClassBonus>();
gs.ecs.register::<ToHitBonus>();
gs.ecs.register::<MoveMode>();
gs.ecs.register::<ProvidesHealing>();
gs.ecs.register::<InflictsDamage>();
gs.ecs.register::<Ranged>();
gs.ecs.register::<AOE>();
gs.ecs.register::<Digger>();
gs.ecs.register::<Confusion>();
gs.ecs.register::<Blind>();
gs.ecs.register::<MagicMapper>();
gs.ecs.register::<InBackpack>();
gs.ecs.register::<WantsToApproach>();
gs.ecs.register::<WantsToFlee>();
gs.ecs.register::<WantsToPickupItem>();
gs.ecs.register::<WantsToDropItem>();
gs.ecs.register::<WantsToRemoveItem>();
gs.ecs.register::<WantsToUseItem>();
gs.ecs.register::<Consumable>();
gs.ecs.register::<SingleActivation>();
gs.ecs.register::<Charges>();
gs.ecs.register::<ProvidesNutrition>();
gs.ecs.register::<Destructible>();
gs.ecs.register::<Hidden>();
gs.ecs.register::<EntryTrigger>();
gs.ecs.register::<EntityMoved>();
gs.ecs.register::<MultiAttack>();
gs.ecs.register::<ProvidesRemoveCurse>();
gs.ecs.register::<ProvidesIdentify>();
gs.ecs.register::<KnownSpells>();
gs.ecs.register::<GrantsSpell>();
gs.ecs.register::<Bleeds>();
gs.ecs.register::<ParticleLifetime>();
gs.ecs.register::<SpawnParticleSimple>();
gs.ecs.register::<SpawnParticleBurst>();
gs.ecs.register::<SpawnParticleLine>();
gs.ecs.register::<HasDamageModifiers>();
gs.ecs.register::<Intrinsics>();
gs.ecs.register::<Stackable>();
gs.ecs.register::<WantsToAssignKey>();
gs.ecs.register::<Key>();
gs.ecs.register::<WantsToRemoveKey>();
gs.ecs.register::<WantsToDelete>();
gs.ecs.register::<IntrinsicChanged>();
gs.ecs.register::<SimpleMarker<SerializeMe>>();
gs.ecs.register::<SerializationHelper>();
gs.ecs.register::<DMSerializationHelper>();
gs.ecs.insert(SimpleMarkerAllocator::<SerializeMe>::new());
raws::load_raws();
// Insert calls
gs.ecs.insert(RandomNumberGenerator::new());
gs.ecs.insert(map::MasterDungeonMap::new()); // Master map list
gs.ecs.insert(Map::new(true, 1, 64, 64, 0, "New Map", "N", 0)); // Map
gs.ecs.insert(Point::new(0, 0)); // Player pos
gs.ecs.insert(gui::Ancestry::Human); // ancestry
let player_entity = spawner::player(&mut gs.ecs, 0, 0);
gs.ecs.insert(player_entity); // Player entity
gs.ecs.insert(RunState::MapGeneration {}); // TODO: Set this back to RunState::MapGen
gs.ecs.insert(particle_system::ParticleBuilder::new());
gs.ecs.insert(rex_assets::RexAssets::new());
gamelog::setup_log();
gamelog::record_event(consts::events::EVENT::Level(1));
gs.generate_world_map(1, TileType::Floor);
gs
}
const ASCII_MODE: bool = false; // Change this to config setting
const SHOW_BOUNDARIES: bool = false; // Config setting
enum DrawType {
None,
Visible,
Telepathy,
}
#[derive(PartialEq, Eq, Hash)]
struct DrawKey {
x: i32,
y: i32,
render_order: i32,
}
struct DrawInfo {
e: Entity,
draw_type: DrawType,
}
fn draw_entities(
map: &Map,
ecs: &World,
draw: &mut Draw,
atlas: &HashMap<String, Texture>,
font: &Fonts
) {
{
let bounds = crate::camera::get_screen_bounds(ecs, false);
let bounds_to_px = bounds.to_px();
let offset_x = bounds_to_px.x_offset - bounds_to_px.min_x;
let offset_y = bounds_to_px.y_offset - bounds_to_px.min_y;
let positions = ecs.read_storage::<Position>();
let renderables = ecs.read_storage::<Renderable>();
let hidden = ecs.read_storage::<Hidden>();
let minds = ecs.read_storage::<Mind>();
let pools = ecs.read_storage::<Pools>();
let entities = ecs.entities();
let data = (&positions, &renderables, &entities, !&hidden).join().collect::<Vec<_>>();
let mut to_draw: HashMap<DrawKey, DrawInfo> = HashMap::new();
for (pos, render, e, _h) in data.iter() {
let idx = map.xy_idx(pos.x, pos.y);
if
crate::camera::in_bounds(
pos.x,
pos.y,
bounds.min_x,
bounds.min_y,
bounds.max_x,
bounds.max_y
)
{
let draw_type = if map.visible_tiles[idx] {
// If it's anything else, just draw it.
DrawType::Visible
} else if map.telepath_tiles[idx] {
let has_mind = minds.get(*e);
if has_mind.is_some() {
// Mobs we see through telepathy - generally we just
// draw these, but it uses a unique enum variant so
// it can be treated differently if needed in future.
DrawType::Telepathy
} else {
DrawType::None
}
} else {
// If we don't see it, and we don't sense it with
// telepathy, don't draw it at all.
DrawType::None
};
match draw_type {
DrawType::None => {}
_ => {
to_draw.insert(
DrawKey { x: pos.x, y: pos.y, render_order: render.render_order },
DrawInfo { e: *e, draw_type }
);
}
}
}
}
let mut entries: Vec<(&DrawKey, &DrawInfo)> = to_draw.iter().collect();
entries.sort_by_key(|&(k, _v)| std::cmp::Reverse(k.render_order));
for entry in entries.iter() {
// TODO: ABSTRACT THESE INTO FUNCTIONS ONCE FUNCTIONALITY IS SETTLED ON.
match entry.1.draw_type {
DrawType::Visible | DrawType::Telepathy => {
let renderable = renderables.get(entry.1.e).unwrap();
let id = if let Some(sprite) = atlas.get(&renderable.sprite) {
sprite
} else {
panic!("No entity sprite found for ID: {}", &renderable.sprite);
};
let x_pos = (entry.0.x as f32) * TILESIZE.sprite_x + offset_x;
let y_pos = (entry.0.y as f32) * TILESIZE.sprite_y + offset_y;
let mul = themes::darken_by_distance(
Point::new(entry.0.x, entry.0.y),
*ecs.fetch::<Point>()
);
let col = Color::from_rgb(
renderable.fg.r * mul,
renderable.fg.g * mul,
renderable.fg.b * mul
);
draw.image(id)
.position(
x_pos + renderable.offset.0 * TILESIZE.sprite_x,
y_pos + renderable.offset.1 * TILESIZE.sprite_y
)
.color(col)
.size(TILESIZE.sprite_x, TILESIZE.sprite_y);
if let Some(pool) = pools.get(entry.1.e) {
if pool.hit_points.current < pool.hit_points.max {
draw_entity_hp(x_pos, y_pos, pool, draw);
}
}
}
_ => {}
}
}
}
}
// Draws a HP bar LINE_WIDTH pixels thick centered above the entity.
fn draw_entity_hp(x: f32, y: f32, hp: &Pools, draw: &mut Draw) {
const LINE_WIDTH: f32 = 3.0;
let y = y + LINE_WIDTH + 1.0;
let x = x;
let fill_pct = (hp.hit_points.current as f32) / (hp.hit_points.max as f32);
draw.line((x + 1.0, y), (x + (TILESIZE.sprite_x - 1.0) * fill_pct, y))
.width(LINE_WIDTH)
.color(Color::GREEN);
}
fn render_map_in_view(
map: &Map,
ecs: &World,
draw: &mut Draw,
atlas: &HashMap<String, Texture>,
mapgen: bool
) {
let bounds = crate::camera::get_screen_bounds(ecs, mapgen);
let mut y = 0;
for tile_y in bounds.min_y..bounds.max_y {
let mut x = 0;
for tile_x in bounds.min_x..bounds.max_x {
if crate::camera::in_bounds(tile_x, tile_y, 0, 0, map.width, map.height) {
let idx = map.xy_idx(tile_x, tile_y);
if map.revealed_tiles[idx] || mapgen {
let draw_x =
(x as f32) * TILESIZE.sprite_x + (bounds.x_offset as f32) * TILESIZE.x;
let draw_y =
(y as f32) * TILESIZE.sprite_y + (bounds.y_offset as f32) * TILESIZE.x;
if ASCII_MODE {
let (glyph, fg, bg) = crate::map::themes::get_tile_renderables_for_id(
idx,
&*map,
Some(*ecs.fetch::<Point>()),
None
);
// TODO: Draw ASCII
} else {
let (id, tint) = crate::map::themes::get_sprite_for_id(
idx,
&*map,
Some(*ecs.fetch::<Point>())
);
let sprite = if let Some(sprite) = atlas.get(id) {
sprite
} else {
panic!("No sprite found for ID: {}", id);
};
draw.image(sprite)
.position(draw_x, draw_y)
.color(tint)
.size(TILESIZE.sprite_x, TILESIZE.sprite_y);
}
if !map.visible_tiles[idx] {
// Recall map memory. TODO: Improve this? Optimize? Do we need to remember more fields?
if let Some(memories) = map.memory.get(&idx) {
let mut sorted: Vec<_> = memories.iter().collect();
sorted.sort_by(|a, b| a.render_order.cmp(&b.render_order));
for memory in sorted.iter() {
let mult = consts::visuals::NON_VISIBLE_MULTIPLIER;
let col = Color::from_rgb(
memory.fg.r * mult,
memory.fg.g * mult,
memory.fg.b * mult
);
let sprite = if let Some(sprite) = atlas.get(&memory.sprite) {
sprite
} else {
panic!("No sprite found for ID: {}", memory.sprite);
};
draw.image(sprite)
.position(
draw_x + memory.offset.0 * TILESIZE.sprite_x,
draw_y + memory.offset.1 * TILESIZE.sprite_y
)
.color(col)
.size(TILESIZE.sprite_x, TILESIZE.sprite_y);
}
}
}
}
} else if SHOW_BOUNDARIES {
// TODO: Draw boundaries
}
x += 1;
}
y += 1;
}
}
struct BoxDraw {
frame: String,
fill: bool,
top_left: (i32, i32),
top_right: (i32, i32),
bottom_left: (i32, i32),
bottom_right: (i32, i32),
}
fn draw_spritebox(panel: BoxDraw, draw: &mut Draw, atlas: &HashMap<String, Texture>) {
draw.image(atlas.get(&format!("{}_1", panel.frame)).unwrap()).position(
(panel.top_left.0 as f32) * TILESIZE.x,
(panel.top_left.1 as f32) * TILESIZE.x
);
for i in panel.top_left.0 + 1..panel.top_right.0 {
draw.image(atlas.get(&format!("{}_2", panel.frame)).unwrap()).position(
(i as f32) * TILESIZE.x,
(panel.top_left.1 as f32) * TILESIZE.x
);
}
draw.image(atlas.get(&format!("{}_3", panel.frame)).unwrap()).position(
(panel.top_right.0 as f32) * TILESIZE.x,
(panel.top_right.1 as f32) * TILESIZE.x
);
for i in panel.top_left.1 + 1..panel.bottom_left.1 {
draw.image(atlas.get(&format!("{}_4", panel.frame)).unwrap()).position(
(panel.top_left.0 as f32) * TILESIZE.x,
(i as f32) * TILESIZE.x
);
}
if panel.fill {
for i in panel.top_left.0 + 1..panel.top_right.0 {
for j in panel.top_left.1 + 1..panel.bottom_left.1 {
draw.image(atlas.get(&format!("{}_5", panel.frame)).unwrap()).position(
(i as f32) * TILESIZE.x,
(j as f32) * TILESIZE.x
);
}
}
}
for i in panel.top_right.1 + 1..panel.bottom_right.1 {
draw.image(atlas.get(&format!("{}_6", panel.frame)).unwrap()).position(
(panel.top_right.0 as f32) * TILESIZE.x,
(i as f32) * TILESIZE.x
);
}
draw.image(atlas.get(&format!("{}_7", panel.frame)).unwrap()).position(
(panel.bottom_left.0 as f32) * TILESIZE.x,
(panel.bottom_left.1 as f32) * TILESIZE.x
);
for i in panel.bottom_left.0 + 1..panel.bottom_right.0 {
draw.image(atlas.get(&format!("{}_8", panel.frame)).unwrap()).position(
(i as f32) * TILESIZE.x,
(panel.bottom_left.1 as f32) * TILESIZE.x
);
}
draw.image(atlas.get(&format!("{}_9", panel.frame)).unwrap()).position(
(panel.bottom_right.0 as f32) * TILESIZE.x,
(panel.bottom_right.1 as f32) * TILESIZE.x
);
}
use crate::consts::visuals::{ VIEWPORT_H, VIEWPORT_W };
fn draw_bg(_ecs: &World, draw: &mut Draw, atlas: &HashMap<String, Texture>) {
let offset = crate::camera::get_offset();
let log = BoxDraw {
frame: "line".to_string(),
fill: false,
top_left: (0, 0),
top_right: (offset.x + VIEWPORT_W, 0),
bottom_left: (0, offset.y - 2),
bottom_right: (offset.x + VIEWPORT_W, offset.y - 2),
};
let game = BoxDraw {
frame: "line".to_string(),
fill: false,
top_left: (offset.x - 1, offset.y - 1),
top_right: (offset.x + VIEWPORT_W, offset.y - 1),
bottom_left: (offset.x - 1, offset.y + VIEWPORT_H),
bottom_right: (offset.x + VIEWPORT_W, offset.y + VIEWPORT_H),
};
let attr = BoxDraw {
frame: "line".to_string(),
fill: false,
top_left: (offset.x - 1, offset.y + VIEWPORT_H + 1),
top_right: (offset.x + VIEWPORT_W, offset.y + VIEWPORT_H + 1),
bottom_left: (offset.x - 1, (DISPLAYHEIGHT as i32) - 1),
bottom_right: (offset.x + VIEWPORT_W, (DISPLAYHEIGHT as i32) - 1),
};
let sidebox = BoxDraw {
frame: "line".to_string(),
fill: false,
top_left: (offset.x + VIEWPORT_W + 1, 0),
top_right: ((DISPLAYWIDTH as i32) - 1, 0),
bottom_left: (offset.x + VIEWPORT_W + 1, (DISPLAYHEIGHT as i32) - 1),
bottom_right: ((DISPLAYWIDTH as i32) - 1, (DISPLAYHEIGHT as i32) - 1),
};
draw_spritebox(log, draw, atlas);
draw_spritebox(game, draw, atlas);
draw_spritebox(attr, draw, atlas);
draw_spritebox(sidebox, draw, atlas);
}
fn draw(app: &mut App, gfx: &mut Graphics, gs: &mut State) {
let mut draw = gfx.create_draw();
draw.clear(Color::BLACK);
let mut log = false;
let runstate = *gs.ecs.fetch::<RunState>();
match runstate {
RunState::MainMenu { .. } => {
gui::draw_mainmenu(&gs.ecs, &mut draw, &gs.atlas, &gs.font);
}
RunState::CharacterCreation { .. } => {
gui::draw_charcreation(&gs.ecs, &mut draw, &gs.atlas, &gs.font);
}
RunState::PreRun { .. } => {}
RunState::MapGeneration => {
draw_bg(&gs.ecs, &mut draw, &gs.interface);
if config::CONFIG.logging.show_mapgen && gs.mapgen_history.len() > 0 {
render_map_in_view(
&gs.mapgen_history[gs.mapgen_index],
&gs.ecs,
&mut draw,
&gs.atlas,
true
);
}
gui::draw_ui2(&gs.ecs, &mut draw, &gs.atlas, &gs.font);
}
_ => {
let map = gs.ecs.fetch::<Map>();
draw_bg(&gs.ecs, &mut draw, &gs.interface);
render_map_in_view(&*map, &gs.ecs, &mut draw, &gs.atlas, false);
// Special case: targeting needs to be drawn *below* entities, but above tiles.
if let RunState::ShowTargeting { range, item: _, x, y, aoe } = runstate {
gui::draw_targeting(&gs.ecs, &mut draw, &gs.atlas, x, y, range, aoe);
}
draw_entities(&*map, &gs.ecs, &mut draw, &gs.atlas, &gs.font);
gui::draw_ui2(&gs.ecs, &mut draw, &gs.atlas, &gs.font);
log = true;
}
}
match runstate {
RunState::Farlook { x, y } => {
gui::draw_farlook(&gs.ecs, x, y, &mut draw, &gs.atlas);
//draw_tooltips(&gs.ecs, ctx, Some((x, y))); TODO: Put this in draw loop
}
RunState::ShowCheatMenu => {
gui::draw_cheat_menu(&mut draw, &gs.atlas, &gs.font);
}
RunState::ActionWithDirection { .. } => {
corner_text("In what direction? [0-9]/[YUHJKLBN]", &mut draw, &gs.font);
}
RunState::GameOver => {
corner_text("Create morgue file? [Y/N]", &mut draw, &gs.font);
}
RunState::ShowInventory => {
corner_text("Use what? [aA-zZ]/[Esc.]", &mut draw, &gs.font);
let offset = crate::camera::get_offset();
let (x, y) = (
((1 + offset.x) as f32) * TILESIZE.x,
((3 + offset.y) as f32) * TILESIZE.x,
);
gui::draw_backpack_items(&gs.ecs, &mut draw, &gs.font, x, y);
}
RunState::ShowDropItem => {
corner_text("Drop what? [aA-zZ]/[Esc.]", &mut draw, &gs.font);
let offset = crate::camera::get_offset();
let (x, y) = (
((1 + offset.x) as f32) * TILESIZE.x,
((3 + offset.y) as f32) * TILESIZE.x,
);
gui::draw_backpack_items(&gs.ecs, &mut draw, &gs.font, x, y);
}
RunState::ShowRemoveItem => {
corner_text("Unequip which item? [aA-zZ]/[Esc.]", &mut draw, &gs.font);
let offset = crate::camera::get_offset();
let (x, y) = (
((1 + offset.x) as f32) * TILESIZE.x,
((3 + offset.y) as f32) * TILESIZE.x,
);
gui::draw_items(&gs.ecs, &mut draw, &gs.font, x, y, gui::Location::Equipped, None);
}
RunState::ShowTargeting { .. } => {
corner_text("Targeting which tile? [0-9]/[YUHJKLBN]", &mut draw, &gs.font);
}
_ => {}
}
// TODO: Once the rest of drawing is finalised, this should be abstracted
// into some functions that make it easier to tell what is going on. But
// for the short-term:
// 1. notan::Text is required for rich text drawing, rather than just the
// basics that are accessible with notan::Draw's .text() method.
// 2. notan::Text cannot be projected, and rendering both Draw and Text
// requires two GPU calls instead of just one.
// 3. To fix this, our log is drawn to notan::Text, then rendered to a
// render texture, and applied as any other image to notan::Draw.
// 4. notan::Draw is projected, and then rendered, and everything works.
// Further stuff: Make the render texture only as large as is required,
// so text cannot escape the bounds of the logbox.
let (width, height) = gfx.size();
let win_size = vec2(width as f32, height as f32);
let (projection, _) = calc_projection(win_size, WORK_SIZE);
if log {
let buffer = gfx
.create_render_texture(width, height)
.build()
.expect("Failed to create render texture");
gamelog::render_log(
&buffer,
gfx,
&gs.font,
&(TILESIZE.x, TILESIZE.x * 6.0 + 4.0),
(VIEWPORT_W as f32) * TILESIZE.x,
5
);
draw.image(&buffer)
.position(0.0, 0.0)
.size(width as f32, height as f32);
}
draw.set_projection(Some(projection));
gfx.render(&draw);
}
fn update(ctx: &mut App, state: &mut State) {
state.update(ctx);
}
fn corner_text(text: &str, draw: &mut Draw, font: &Fonts) {
let offset = crate::camera::get_offset();
draw.text(&font.b(), &text)
.position(((offset.x + 1) as f32) * TILESIZE.x, ((offset.y + 1) as f32) * TILESIZE.x)
.size(FONTSIZE);
}
fn calc_projection(win_size: Vec2, work_size: Vec2) -> (Mat4, f32) {
let ratio = (win_size.x / work_size.x).min(win_size.y / work_size.y);
let proj = Mat4::orthographic_rh_gl(0.0, win_size.x, win_size.y, 0.0, -1.0, 1.0);
let scale = Mat4::from_scale(vec3(ratio, ratio, 1.0));
let position = vec3(
(win_size.x - work_size.x * ratio) * 0.5,
(win_size.y - work_size.y * ratio) * 0.5,
1.0
);
let trans = Mat4::from_translation(position);
(proj * trans * scale, ratio)
}
Reference in a new issue View git blame Copy permalink