miserable failure to get text rendering to work using these 'easy text rendering' tricks. Will be bringing in a third party library which I have to write the damn backend implementation for
parent
77b781df1a
commit
db8cbdc77e
@ -0,0 +1,449 @@
|
||||
Content-Type: text/x-zim-wiki
|
||||
Wiki-Format: zim 0.4
|
||||
Creation-Date: 2020-02-28T22:36:46-08:00
|
||||
|
||||
====== PossiblePathfinderPort ======
|
||||
Created Friday 28 February 2020
|
||||
|
||||
|
||||
|
||||
|
||||
pub struct RenderState<'a, D> where D: Device
|
||||
pub target: &'a RenderTarget<'a, D>,
|
||||
pub program: &'a D::Program,
|
||||
pub vertex_array: &'a D::VertexArray,
|
||||
pub primitive: Primitive,
|
||||
pub uniforms: &'a [(&'a D::Uniform, UniformData)],
|
||||
pub textures: &'a [&'a D::Texture],
|
||||
pub viewport: RectI,
|
||||
pub options: RenderOptions,
|
||||
|
||||
|
||||
**So I need to define the following types in Vulkan syntax**
|
||||
|
||||
**The other port uses container classes for these **
|
||||
|
||||
|
||||
type Buffer;
|
||||
type Framebuffer;
|
||||
type Program;
|
||||
**VulkanProgram**
|
||||
type Shader;
|
||||
type Texture;
|
||||
type TextureDataReceiver;
|
||||
type TimerQuery;
|
||||
type Uniform;
|
||||
type VertexArray;
|
||||
type VertexAttr;
|
||||
|
||||
|
||||
|
||||
[ ] fn create_texture(&self, format: TextureFormat, size: Vector2I) -> Self::Texture;
|
||||
|
||||
So for this function I'm going to need to convert Texture
|
||||
|
||||
fn create_texture_from_data(&self, format: TextureFormat, size: Vector2I, data: TextureDataRef)
|
||||
-> Self::Texture;
|
||||
fn create_shader(&self, resources: &dyn ResourceLoader, name: &str, kind: ShaderKind)
|
||||
-> Self::Shader;
|
||||
fn create_shader_from_source(&self, name: &str, source: &[u8], kind: ShaderKind)
|
||||
-> Self::Shader;
|
||||
fn create_vertex_array(&self) -> Self::VertexArray;
|
||||
fn create_program_from_shaders(
|
||||
&self,
|
||||
resources: &dyn ResourceLoader,
|
||||
name: &str,
|
||||
vertex_shader: Self::Shader,
|
||||
fragment_shader: Self::Shader,
|
||||
) -> Self::Program;
|
||||
fn get_vertex_attr(&self, program: &Self::Program, name: &str) -> Option<Self::VertexAttr>;
|
||||
fn get_uniform(&self, program: &Self::Program, name: &str) -> Self::Uniform;
|
||||
fn bind_buffer(&self,
|
||||
vertex_array: &Self::VertexArray,
|
||||
buffer: &Self::Buffer,
|
||||
target: BufferTarget);
|
||||
fn configure_vertex_attr(&self,
|
||||
vertex_array: &Self::VertexArray,
|
||||
attr: &Self::VertexAttr,
|
||||
descriptor: &VertexAttrDescriptor);
|
||||
fn create_framebuffer(&self, texture: Self::Texture) -> Self::Framebuffer;
|
||||
fn create_buffer(&self) -> Self::Buffer;
|
||||
fn allocate_buffer<T>(
|
||||
&self,
|
||||
buffer: &Self::Buffer,
|
||||
data: BufferData<T>,
|
||||
target: BufferTarget,
|
||||
mode: BufferUploadMode,
|
||||
);
|
||||
fn framebuffer_texture<'f>(&self, framebuffer: &'f Self::Framebuffer) -> &'f Self::Texture;
|
||||
fn destroy_framebuffer(&self, framebuffer: Self::Framebuffer) -> Self::Texture;
|
||||
fn texture_format(&self, texture: &Self::Texture) -> TextureFormat;
|
||||
fn texture_size(&self, texture: &Self::Texture) -> Vector2I;
|
||||
fn set_texture_sampling_mode(&self, texture: &Self::Texture, flags: TextureSamplingFlags);
|
||||
fn upload_to_texture(&self, texture: &Self::Texture, rect: RectI, data: TextureDataRef);
|
||||
|
||||
**Command buffer stuff**
|
||||
fn begin_commands(&self);
|
||||
fn end_commands(&self);
|
||||
|
||||
|
||||
fn draw_arrays(&self, index_count: u32, render_state: &RenderState<Self>);
|
||||
fn draw_elements(&self, index_count: u32, render_state: &RenderState<Self>);
|
||||
fn draw_elements_instanced(&self,
|
||||
index_count: u32,
|
||||
instance_count: u32,
|
||||
render_state: &RenderState<Self>);
|
||||
|
||||
**This is the weird timing stuff**
|
||||
fn create_timer_query(&self) -> Self::TimerQuery;
|
||||
fn begin_timer_query(&self, query: &Self::TimerQuery);
|
||||
fn end_timer_query(&self, query: &Self::TimerQuery);
|
||||
fn try_recv_timer_query(&self, query: &Self::TimerQuery) -> Option<Duration>;
|
||||
fn recv_timer_query(&self, query: &Self::TimerQuery) -> Duration;
|
||||
|
||||
**And then the GPU reads**
|
||||
fn try_recv_texture_data(&self, receiver: &Self::TextureDataReceiver) -> Option<TextureData>;
|
||||
fn recv_texture_data(&self, receiver: &Self::TextureDataReceiver) -> TextureData;
|
||||
|
||||
**This maybe reads?**
|
||||
fn read_pixels(&self, target: &RenderTarget<Self>, viewport: RectI)
|
||||
-> Self::TextureDataReceiver;
|
||||
|
||||
**This just creates a texture like I do**
|
||||
fn create_texture_from_png(&self, resources: &dyn ResourceLoader, name: &str) -> Self::Texture;
|
||||
|
||||
**This one just **
|
||||
fn create_program_from_shader_names(
|
||||
&self,
|
||||
resources: &dyn ResourceLoader,
|
||||
program_name: &str,
|
||||
vertex_shader_name: &str,
|
||||
fragment_shader_name: &str,
|
||||
) -> Self::Program {
|
||||
let vertex_shader = self.create_shader(resources, vertex_shader_name, ShaderKind::Vertex);
|
||||
let fragment_shader =
|
||||
self.create_shader(resources, fragment_shader_name, ShaderKind::Fragment);
|
||||
self.create_program_from_shaders(resources, program_name, vertex_shader, fragment_shader)
|
||||
}
|
||||
|
||||
fn create_program(&self, resources: &dyn ResourceLoader, name: &str) -> Self::Program {
|
||||
self.create_program_from_shader_names(resources, name, name, name)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TextureFormat {
|
||||
R8,
|
||||
R16F,
|
||||
RGBA8,
|
||||
RGBA16F,
|
||||
RGBA32F,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum VertexAttrType {
|
||||
F32,
|
||||
I16,
|
||||
I8,
|
||||
U16,
|
||||
U8,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum BufferData<'a, T> {
|
||||
Uninitialized(usize),
|
||||
Memory(&'a [T]),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum BufferTarget {
|
||||
Vertex,
|
||||
Index,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum BufferUploadMode {
|
||||
Static,
|
||||
Dynamic,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum ShaderKind {
|
||||
Vertex,
|
||||
Fragment,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum UniformData {
|
||||
Float(f32),
|
||||
IVec3([i32; 3]),
|
||||
Int(i32),
|
||||
Mat2(F32x4),
|
||||
Mat4([F32x4; 4]),
|
||||
Vec2(F32x2),
|
||||
Vec3([f32; 3]),
|
||||
Vec4(F32x4),
|
||||
TextureUnit(u32),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum Primitive {
|
||||
Triangles,
|
||||
Lines,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct RenderState<'a, D> where D: Device {
|
||||
pub target: &'a RenderTarget<'a, D>,
|
||||
pub program: &'a D::Program,
|
||||
pub vertex_array: &'a D::VertexArray,
|
||||
pub primitive: Primitive,
|
||||
pub uniforms: &'a [(&'a D::Uniform, UniformData)],
|
||||
pub textures: &'a [&'a D::Texture],
|
||||
pub viewport: RectI,
|
||||
pub options: RenderOptions,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RenderOptions {
|
||||
pub blend: Option<BlendState>,
|
||||
pub depth: Option<DepthState>,
|
||||
pub stencil: Option<StencilState>,
|
||||
pub clear_ops: ClearOps,
|
||||
pub color_mask: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default)]
|
||||
pub struct ClearOps {
|
||||
pub color: Option<ColorF>,
|
||||
pub depth: Option<f32>,
|
||||
pub stencil: Option<u8>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum RenderTarget<'a, D> where D: Device {
|
||||
Default,
|
||||
Framebuffer(&'a D::Framebuffer),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct BlendState {
|
||||
pub dest_rgb_factor: BlendFactor,
|
||||
pub dest_alpha_factor: BlendFactor,
|
||||
pub src_rgb_factor: BlendFactor,
|
||||
pub src_alpha_factor: BlendFactor,
|
||||
pub op: BlendOp,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum BlendFactor {
|
||||
Zero,
|
||||
One,
|
||||
SrcAlpha,
|
||||
OneMinusSrcAlpha,
|
||||
DestAlpha,
|
||||
OneMinusDestAlpha,
|
||||
DestColor,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum BlendOp {
|
||||
Add,
|
||||
Subtract,
|
||||
ReverseSubtract,
|
||||
Min,
|
||||
Max,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Default, Debug)]
|
||||
pub struct DepthState {
|
||||
pub func: DepthFunc,
|
||||
pub write: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum DepthFunc {
|
||||
Less,
|
||||
Always,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct StencilState {
|
||||
pub func: StencilFunc,
|
||||
pub reference: u32,
|
||||
pub mask: u32,
|
||||
pub write: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum StencilFunc {
|
||||
Always,
|
||||
Equal,
|
||||
}
|
||||
|
||||
impl Default for RenderOptions {
|
||||
#[inline]
|
||||
fn default() -> RenderOptions {
|
||||
RenderOptions {
|
||||
blend: None,
|
||||
depth: None,
|
||||
stencil: None,
|
||||
clear_ops: ClearOps::default(),
|
||||
color_mask: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for BlendOp {
|
||||
#[inline]
|
||||
fn default() -> BlendOp {
|
||||
BlendOp::Add
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for StencilState {
|
||||
#[inline]
|
||||
fn default() -> StencilState {
|
||||
StencilState {
|
||||
func: StencilFunc::default(),
|
||||
reference: 0,
|
||||
mask: !0,
|
||||
write: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for DepthFunc {
|
||||
#[inline]
|
||||
fn default() -> DepthFunc {
|
||||
DepthFunc::Less
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for StencilFunc {
|
||||
#[inline]
|
||||
fn default() -> StencilFunc {
|
||||
StencilFunc::Always
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum TextureData {
|
||||
U8(Vec<u8>),
|
||||
U16(Vec<u16>),
|
||||
F16(Vec<f16>),
|
||||
F32(Vec<f32>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum TextureDataRef<'a> {
|
||||
U8(&'a [u8]),
|
||||
F16(&'a [f16]),
|
||||
F32(&'a [f32]),
|
||||
}
|
||||
|
||||
impl UniformData {
|
||||
#[inline]
|
||||
pub fn from_transform_3d(transform: &Transform4F) -> UniformData {
|
||||
UniformData::Mat4([transform.c0, transform.c1, transform.c2, transform.c3])
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct VertexAttrDescriptor {
|
||||
pub size: usize,
|
||||
pub class: VertexAttrClass,
|
||||
pub attr_type: VertexAttrType,
|
||||
pub stride: usize,
|
||||
pub offset: usize,
|
||||
pub divisor: u32,
|
||||
pub buffer_index: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum VertexAttrClass {
|
||||
Float,
|
||||
FloatNorm,
|
||||
Int,
|
||||
}
|
||||
|
||||
impl TextureFormat {
|
||||
#[inline]
|
||||
pub fn channels(self) -> usize {
|
||||
match self {
|
||||
TextureFormat::R8 | TextureFormat::R16F => 1,
|
||||
TextureFormat::RGBA8 | TextureFormat::RGBA16F | TextureFormat::RGBA32F => 4,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn bytes_per_pixel(self) -> usize {
|
||||
match self {
|
||||
TextureFormat::R8 => 1,
|
||||
TextureFormat::R16F => 2,
|
||||
TextureFormat::RGBA8 => 4,
|
||||
TextureFormat::RGBA16F => 8,
|
||||
TextureFormat::RGBA32F => 16,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ClearOps {
|
||||
#[inline]
|
||||
pub fn has_ops(&self) -> bool {
|
||||
self.color.is_some() || self.depth.is_some() || self.stencil.is_some()
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for BlendState {
|
||||
#[inline]
|
||||
fn default() -> BlendState {
|
||||
BlendState {
|
||||
src_rgb_factor: BlendFactor::One,
|
||||
dest_rgb_factor: BlendFactor::OneMinusSrcAlpha,
|
||||
src_alpha_factor: BlendFactor::One,
|
||||
dest_alpha_factor: BlendFactor::One,
|
||||
op: BlendOp::Add,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
pub struct TextureSamplingFlags: u8 {
|
||||
const REPEAT_U = 0x01;
|
||||
const REPEAT_V = 0x02;
|
||||
const NEAREST_MIN = 0x04;
|
||||
const NEAREST_MAG = 0x08;
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TextureDataRef<'a> {
|
||||
#[doc(hidden)]
|
||||
pub fn check_and_extract_data_ptr(self, minimum_size: Vector2I, format: TextureFormat)
|
||||
-> *const c_void {
|
||||
let channels = match (format, self) {
|
||||
(TextureFormat::R8, TextureDataRef::U8(_)) => 1,
|
||||
(TextureFormat::RGBA8, TextureDataRef::U8(_)) => 4,
|
||||
(TextureFormat::RGBA16F, TextureDataRef::F16(_)) => 4,
|
||||
(TextureFormat::RGBA32F, TextureDataRef::F32(_)) => 4,
|
||||
_ => panic!("Unimplemented texture format!"),
|
||||
};
|
||||
|
||||
let area = minimum_size.x() as usize * minimum_size.y() as usize;
|
||||
|
||||
match self {
|
||||
TextureDataRef::U8(data) => {
|
||||
assert!(data.len() >= area * channels);
|
||||
data.as_ptr() as *const c_void
|
||||
}
|
||||
TextureDataRef::F16(data) => {
|
||||
assert!(data.len() >= area * channels);
|
||||
data.as_ptr() as *const c_void
|
||||
}
|
||||
TextureDataRef::F32(data) => {
|
||||
assert!(data.len() >= area * channels);
|
||||
data.as_ptr() as *const c_void
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue