kvark

Zed on Blade

See Zed editor: https://github.com/zed-industries/zed

• currently MacOS-only, using Metal directly for rendering in GPUI component See Blade engine: https://github.com/kvark/blade
• specifically the blade-graphics crate providing GPU abstraction

Motivation

I love Zed! It's lightning fast and has great UX. I want it to run as well on all major platforms. I'm currently using Linux most actively.

kvark

Art of Debugging

Obligatory disclaimer, this is all opinion and cannot possibly generalize to all problems, workflows, environments, etc. This is meant primarily as a launching point for an open-ended discussion on best practices in debugging code. This is a sketch of what may be a brief book that covers each point below with anecdotes, examples, and techniques.

Hypothesis 0

The ultimate goal of a debugging session is to rule out possibilities until only one remains. All applications of best practices, techniques, and tools should be pointed at this purpose (contextualize all points below against this statement). Debugging is first and foremost a critical thinking problem, and presence of mind is your most critical asset. Establish a mental model but do not be afraid to invalidate it as the investigation unfolds.

Hypothesis 1

kvark

What sort of graphics do you need?

• 2D only. All you need is...
  • Love: ggez
  • Not sure: piston
• 3D for sure. Do you like making your hands dirty?
  • Yes, give me some! What graphics APIs do you need supported?
    • GL only: glium, gl-rs
    • Vulkan only: vulkano, ash
    • Many/Other: gfx-rs
• Sometimes: amethyst

kvark

use cgmath::{Vector3};
use slog::{Logger};
use cobalt_rendering::{Target, Texture, TextureFormat};
use cobalt_rendering_world3d::{World, Model, Entity, Light, EntityId, LightId, Material};

use input::{InputState, FrameInput};
use player::{Player};

pub struct GameWorld {
    pub player: Player,

kvark

Achieving warp speed with Rust

Contents:

• Number one optimization tip: don't
• Never optimize blindly
• Don't bother optimizing one-time costs
• Improve your algorithms
• CPU architecture primer
• Keep as much as possible in cache
• Keep as much as possible in registers

kvark

kvark

Gfx and glium are Rust libraries that aim to provide a "rusty" abstraction over graphics programming APIs.
Both may look similar, and one of the questions that gets asked frequently on IRC is "what are the differences between gfx and glium?". Here is a comparison table:


                                     |          Gfx                                                                                                      |               Glium            
-------------------------------------|-------------------------------------------------------------------------------------------------------------------|--------------------------------
URL                                  | <https://github.com/gfx-rs/gfx-rs>                                                                                | <https://github.com/tomaka/glium>
History                              | Papers since Oct 2013. Really started in June 2014.                                                               | Private/confidential from Feb 201

kvark

Game Development:

• Design
  • The Cargo Cult of Game Mechanics
  • Howling Dog
• Procedural generation:
  • http://pcgbook.com/
• Physics:
  • Feynman Lectures

Graphics:

kvark

Clustered shading

http://www.cse.chalmers.se/~olaolss/get_file.php?filename=papers/clustered_shading_preprint.pdf

Why?

• Allows arbitrary complex material BRDFs
• Very friendly to MSAA and high resolutions
• Doesn't need the depth pre-pass
• Allows forward rendering of opaque and transparent objects in the same way
• Compatible with DX9/GL2 class hardware

kvark

Reasons why Rust can be faster than C++:

• aliasing information available to compiler (automatic __restrict)
• one less jump on virtual functions due to traits (Runtime polymorphism)
• undefined struct layout
• reference counting (Rc<T>) is lock-free because of being task-local
• allocator model: rust provides hints and could inline calls to jemalloc (issue, RFC)

It's worth noting that since Rust restricts pointers more than C does, the ordering restrictions on pointers could be relaxed. This hasn't been implemented in LLVM yet since most of the optimization work is based on leveraging the rules of C and C-family languages. Even if they did implement relaxations on the reordering rules, however, storing data in registers will still be easier to optimize.