mirror of
https://github.com/griffi-gh/kubi.git
synced 2024-12-25 05:08:21 -06:00
add trans rendering and crosshair
This commit is contained in:
parent
b95be7fb2a
commit
d57787059a
BIN
assets/blocks/water.png
Normal file
BIN
assets/blocks/water.png
Normal file
Binary file not shown.
After Width: | Height: | Size: 341 B |
|
@ -22,6 +22,7 @@ pub enum BlockTexture {
|
|||
Cobblestone,
|
||||
Planks,
|
||||
WaterSolid,
|
||||
Water,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, EnumIter, TryFromPrimitive)]
|
||||
|
@ -136,7 +137,7 @@ impl Block {
|
|||
},
|
||||
Self::Water => BlockDescriptor {
|
||||
name: "water",
|
||||
render: RenderType::BinaryTransparency(CubeTexture::all(BlockTexture::WaterSolid)),
|
||||
render: RenderType::TransBlock(CubeTexture::all(BlockTexture::Water)),
|
||||
collision: CollisionType::None,
|
||||
raycast_collision: true,
|
||||
drops: None,
|
||||
|
@ -217,6 +218,7 @@ pub enum CollisionType {
|
|||
pub enum RenderType {
|
||||
None,
|
||||
SolidBlock(CubeTexture),
|
||||
TransBlock(CubeTexture),
|
||||
BinaryTransparency(CubeTexture),
|
||||
CrossShape(CrossTexture),
|
||||
}
|
||||
|
|
|
@ -8,6 +8,7 @@ in vec2 v_uv;
|
|||
flat in uint v_tex_index;
|
||||
out vec4 color;
|
||||
uniform sampler2DArray tex;
|
||||
uniform bool discard_alpha;
|
||||
|
||||
// vec4 alpha_drop(vec4 b, vec4 a) {
|
||||
// if ((a.w < 1.) || (b.w < 1.)) {
|
||||
|
@ -20,10 +21,10 @@ void main() {
|
|||
// base color from texture
|
||||
color = texture(tex, vec3(v_uv, v_tex_index));
|
||||
// discard transparent pixels
|
||||
if (color.w < 0.5) discard;
|
||||
if (color.w < (discard_alpha ? 0.01 : 0.5)) discard;
|
||||
//basic "lighting"
|
||||
float light = abs(v_normal.x) + .8 * abs(v_normal.y) + .6 * abs(v_normal.z);
|
||||
color *= vec4(vec3(light), 1.);
|
||||
//discard alpha
|
||||
color.w = 1.;
|
||||
if (discard_alpha) color.w = 1.;
|
||||
}
|
||||
|
|
|
@ -15,12 +15,13 @@ use std::time::Instant;
|
|||
|
||||
pub(crate) use kubi_shared::transform;
|
||||
|
||||
mod ui {
|
||||
pub(crate) mod loading_screen;
|
||||
pub(crate) mod connecting_screen;
|
||||
pub(crate) mod chat_ui;
|
||||
}
|
||||
pub(crate) use ui::{loading_screen, connecting_screen, chat_ui};
|
||||
mod ui;
|
||||
pub(crate) use ui::{
|
||||
loading_screen,
|
||||
connecting_screen,
|
||||
chat_ui,
|
||||
crosshair_ui,
|
||||
};
|
||||
|
||||
pub(crate) mod rendering;
|
||||
pub(crate) mod world;
|
||||
|
@ -91,6 +92,7 @@ use filesystem::AssetManager;
|
|||
use client_physics::{init_client_physics, update_client_physics_late};
|
||||
use chat_ui::render_chat;
|
||||
use chat::init_chat_manager;
|
||||
use crosshair_ui::{init_crosshair_image, draw_crosshair};
|
||||
|
||||
/// stuff required to init the renderer and other basic systems
|
||||
fn pre_startup() -> Workload {
|
||||
|
@ -116,6 +118,7 @@ fn startup() -> Workload {
|
|||
init_delta_time,
|
||||
init_client_physics,
|
||||
init_chat_manager,
|
||||
init_crosshair_image,
|
||||
).into_sequential_workload()
|
||||
}
|
||||
|
||||
|
@ -151,6 +154,7 @@ fn update() -> Workload {
|
|||
update_block_placement,
|
||||
apply_queued_blocks,
|
||||
render_chat,
|
||||
draw_crosshair,
|
||||
).into_sequential_workload().run_if(is_ingame),
|
||||
update_networking_late.run_if(is_multiplayer),
|
||||
compute_cameras,
|
||||
|
|
|
@ -34,6 +34,7 @@ impl AssetPaths for BlockTexture {
|
|||
Self::Cobblestone => "cobblestone.png",
|
||||
Self::Planks => "planks.png",
|
||||
Self::WaterSolid => "solid_water.png",
|
||||
Self::Water => "water.png",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -54,7 +54,7 @@ pub fn draw_world(
|
|||
settings: UniqueView<GameSettings>
|
||||
) {
|
||||
let camera = camera.iter().next().expect("No cameras in the scene");
|
||||
let draw_parameters = DrawParameters {
|
||||
let mut draw_parameters = DrawParameters {
|
||||
depth: Depth {
|
||||
test: DepthTest::IfLess,
|
||||
write: true,
|
||||
|
@ -75,6 +75,8 @@ pub fn draw_world(
|
|||
let view = camera.view_matrix.to_cols_array_2d();
|
||||
let perspective = camera.perspective_matrix.to_cols_array_2d();
|
||||
|
||||
let mut enqueue_trans = Vec::new();
|
||||
|
||||
for (&position, chunk) in &chunks.chunks {
|
||||
if let Some(key) = chunk.mesh_index {
|
||||
let mesh = meshes.get(key).expect("Mesh index pointing to nothing");
|
||||
|
@ -107,10 +109,33 @@ pub fn draw_world(
|
|||
},
|
||||
&draw_parameters
|
||||
).unwrap();
|
||||
|
||||
if mesh.trans_index_buffer.len() > 0 {
|
||||
enqueue_trans.push((chunk, mesh));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
draw_parameters.blend = Blend::alpha_blending();
|
||||
draw_parameters.backface_culling = BackfaceCullingMode::CullingDisabled;
|
||||
|
||||
for (chunk, mesh) in enqueue_trans {
|
||||
let world_position = chunk.position.as_vec3() * CHUNK_SIZE as f32;
|
||||
target.0.draw(
|
||||
&mesh.trans_vertex_buffer,
|
||||
&mesh.trans_index_buffer,
|
||||
&program.0,
|
||||
&uniform! {
|
||||
position_offset: world_position.to_array(),
|
||||
view: view,
|
||||
perspective: perspective,
|
||||
tex: texture_sampler,
|
||||
},
|
||||
&draw_parameters
|
||||
).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn draw_current_chunk_border(
|
||||
mut target: NonSendSync<UniqueViewMut<RenderTarget>>,
|
||||
player: View<MainPlayer>,
|
||||
|
|
4
kubi/src/ui.rs
Normal file
4
kubi/src/ui.rs
Normal file
|
@ -0,0 +1,4 @@
|
|||
pub(crate) mod loading_screen;
|
||||
pub(crate) mod connecting_screen;
|
||||
pub(crate) mod chat_ui;
|
||||
pub(crate) mod crosshair_ui;
|
60
kubi/src/ui/crosshair_ui.rs
Normal file
60
kubi/src/ui/crosshair_ui.rs
Normal file
|
@ -0,0 +1,60 @@
|
|||
use std::f32::consts::PI;
|
||||
|
||||
use glam::uvec2;
|
||||
use hui::{
|
||||
draw::{ImageHandle, TextureFormat},
|
||||
element::{container::Container, image::Image, transformer::ElementTransformExt, UiElementExt},
|
||||
layout::Alignment,
|
||||
size
|
||||
};
|
||||
use shipyard::{AllStoragesViewMut, IntoIter, NonSendSync, Unique, UniqueView, UniqueViewMut, View};
|
||||
use crate::{hui_integration::UiState, player::MainPlayer, rendering::WindowSize, world::raycast::LookingAtBlock};
|
||||
|
||||
const CROSSHAIR_SIZE: usize = 9;
|
||||
const CROSSHAIR: &[u8] = &[
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
|
||||
];
|
||||
|
||||
#[derive(Unique)]
|
||||
pub struct CrosshairImage(ImageHandle);
|
||||
|
||||
pub fn init_crosshair_image(storages: AllStoragesViewMut) {
|
||||
let mut ui = storages.borrow::<NonSendSync<UniqueViewMut<UiState>>>().unwrap();
|
||||
let image = ui.hui.add_image(TextureFormat::Grayscale, CROSSHAIR, CROSSHAIR_SIZE);
|
||||
storages.add_unique(CrosshairImage(image));
|
||||
}
|
||||
|
||||
pub fn draw_crosshair(
|
||||
mut ui: NonSendSync<UniqueViewMut<UiState>>,
|
||||
crosshair: UniqueView<CrosshairImage>,
|
||||
size: UniqueView<WindowSize>,
|
||||
player: View<MainPlayer>,
|
||||
raycast: View<LookingAtBlock>,
|
||||
) {
|
||||
let mut cursor_active = false;
|
||||
if let Some((_, raycast)) = (&player, &raycast).iter().next() {
|
||||
cursor_active = raycast.0.is_some();
|
||||
}
|
||||
|
||||
Container::default()
|
||||
.with_size(size!(100%))
|
||||
.with_align(Alignment::Center)
|
||||
.with_children(|ui| {
|
||||
Image::new(crosshair.0)
|
||||
.with_color((1., 1., 1., 0.5))
|
||||
.with_size(size!(18, 18))
|
||||
.transform()
|
||||
.scale(glam::Vec2::splat(if cursor_active { 1. } else { 0.66 }))
|
||||
.rotate(if cursor_active { 0. } else { PI / 4. })
|
||||
.add_child(ui);
|
||||
})
|
||||
.add_root(&mut ui.hui, uvec2(size.0.x & !1, size.0.y & !1).as_vec2());
|
||||
}
|
|
@ -17,6 +17,8 @@ impl ChunkData {
|
|||
pub struct ChunkMesh {
|
||||
pub vertex_buffer: VertexBuffer<ChunkVertex>,
|
||||
pub index_buffer: IndexBuffer<u32>,
|
||||
pub trans_vertex_buffer: VertexBuffer<ChunkVertex>,
|
||||
pub trans_index_buffer: IndexBuffer<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
|
||||
|
|
|
@ -220,7 +220,11 @@ fn process_completed_tasks(
|
|||
//increase ops counter
|
||||
ops += 1;
|
||||
},
|
||||
ChunkTaskResponse::GeneratedMesh { position, vertices, indexes } => {
|
||||
ChunkTaskResponse::GeneratedMesh {
|
||||
position,
|
||||
vertices, indices,
|
||||
trans_vertices, trans_indices,
|
||||
} => {
|
||||
//check if chunk exists
|
||||
let Some(chunk) = world.chunks.get_mut(&position) else {
|
||||
log::warn!("mesh discarded: chunk doesn't exist");
|
||||
|
@ -234,11 +238,12 @@ fn process_completed_tasks(
|
|||
}
|
||||
|
||||
//apply the mesh
|
||||
let vertex_buffer = VertexBuffer::immutable(&renderer.display, &vertices).unwrap();
|
||||
let index_buffer = IndexBuffer::immutable(&renderer.display, PrimitiveType::TrianglesList, &indexes).unwrap();
|
||||
//TODO: Skip if mesh is empty? (i.e. set to None)
|
||||
let mesh = ChunkMesh {
|
||||
vertex_buffer,
|
||||
index_buffer,
|
||||
vertex_buffer: VertexBuffer::immutable(&renderer.display, &vertices).unwrap(),
|
||||
index_buffer: IndexBuffer::immutable(&renderer.display, PrimitiveType::TrianglesList, &indices).unwrap(),
|
||||
trans_vertex_buffer: VertexBuffer::immutable(&renderer.display, &trans_vertices).unwrap(),
|
||||
trans_index_buffer: IndexBuffer::immutable(&renderer.display, PrimitiveType::TrianglesList, &trans_indices).unwrap(),
|
||||
};
|
||||
if let Some(index) = chunk.mesh_index {
|
||||
meshes.update(index, mesh).expect("Mesh update failed");
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
use glam::{IVec3, ivec3};
|
||||
use strum::IntoEnumIterator;
|
||||
use kubi_shared::block::{Block, RenderType};
|
||||
use kubi_shared::block::{Block, BlockTexture, RenderType};
|
||||
use crate::world::chunk::CHUNK_SIZE;
|
||||
use crate::rendering::world::ChunkVertex;
|
||||
|
||||
|
@ -10,7 +10,10 @@ mod builder;
|
|||
use data::MeshGenData;
|
||||
use builder::{MeshBuilder, CubeFace, DiagonalFace};
|
||||
|
||||
pub fn generate_mesh(data: MeshGenData) -> (Vec<ChunkVertex>, Vec<u32>) {
|
||||
pub fn generate_mesh(data: MeshGenData) -> (
|
||||
(Vec<ChunkVertex>, Vec<u32>),
|
||||
(Vec<ChunkVertex>, Vec<u32>),
|
||||
) {
|
||||
let get_block = |pos: IVec3| -> Block {
|
||||
if pos.x < 0 {
|
||||
data.block_data_neg_x[(CHUNK_SIZE as i32 + pos.x) as usize][pos.y as usize][pos.z as usize]
|
||||
|
@ -30,6 +33,7 @@ pub fn generate_mesh(data: MeshGenData) -> (Vec<ChunkVertex>, Vec<u32>) {
|
|||
};
|
||||
|
||||
let mut builder = MeshBuilder::new();
|
||||
let mut trans_builder = MeshBuilder::new();
|
||||
|
||||
for x in 0..CHUNK_SIZE as i32 {
|
||||
for y in 0..CHUNK_SIZE as i32 {
|
||||
|
@ -39,7 +43,9 @@ pub fn generate_mesh(data: MeshGenData) -> (Vec<ChunkVertex>, Vec<u32>) {
|
|||
let descriptor = block.descriptor();
|
||||
match descriptor.render {
|
||||
RenderType::None => continue,
|
||||
RenderType::SolidBlock(textures) | RenderType::BinaryTransparency(textures) => {
|
||||
RenderType::SolidBlock(textures) |
|
||||
RenderType::BinaryTransparency(textures) |
|
||||
RenderType::TransBlock(textures) => {
|
||||
for face in CubeFace::iter() {
|
||||
let facing_direction = face.normal();
|
||||
let facing_coord = coord + facing_direction;
|
||||
|
@ -47,10 +53,12 @@ pub fn generate_mesh(data: MeshGenData) -> (Vec<ChunkVertex>, Vec<u32>) {
|
|||
let facing_descriptor = facing_block.descriptor();
|
||||
let face_obstructed = match descriptor.render {
|
||||
RenderType::SolidBlock(_) => matches!(facing_descriptor.render, RenderType::SolidBlock(_)),
|
||||
RenderType::BinaryTransparency(_) => {
|
||||
RenderType::BinaryTransparency(_) |
|
||||
RenderType::TransBlock(_) => {
|
||||
match facing_descriptor.render {
|
||||
RenderType::SolidBlock(_) => true,
|
||||
RenderType::BinaryTransparency(_) => block == facing_block,
|
||||
RenderType::BinaryTransparency(_) |
|
||||
RenderType::TransBlock(_) => block == facing_block,
|
||||
_ => false,
|
||||
}
|
||||
},
|
||||
|
@ -65,7 +73,11 @@ pub fn generate_mesh(data: MeshGenData) -> (Vec<ChunkVertex>, Vec<u32>) {
|
|||
CubeFace::Back => textures.back,
|
||||
CubeFace::Bottom => textures.bottom,
|
||||
};
|
||||
builder.add_face(face, coord, face_texture as u8);
|
||||
let cur_builder = match descriptor.render {
|
||||
RenderType::TransBlock(_) => &mut trans_builder,
|
||||
_ => &mut builder,
|
||||
};
|
||||
cur_builder.add_face(face, coord, face_texture as u8);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
@ -88,5 +100,5 @@ pub fn generate_mesh(data: MeshGenData) -> (Vec<ChunkVertex>, Vec<u32>) {
|
|||
}
|
||||
}
|
||||
|
||||
builder.finish()
|
||||
(builder.finish(), trans_builder.finish())
|
||||
}
|
||||
|
|
|
@ -29,7 +29,9 @@ pub enum ChunkTaskResponse {
|
|||
GeneratedMesh {
|
||||
position: IVec3,
|
||||
vertices: Vec<ChunkVertex>,
|
||||
indexes: Vec<u32>
|
||||
indices: Vec<u32>,
|
||||
trans_vertices: Vec<ChunkVertex>,
|
||||
trans_indices: Vec<u32>,
|
||||
},
|
||||
}
|
||||
|
||||
|
@ -55,8 +57,15 @@ impl ChunkTaskManager {
|
|||
self.pool.spawn(move || {
|
||||
let _ = sender.send(match task {
|
||||
ChunkTask::GenerateMesh { position, data } => {
|
||||
let (vertices, indexes) = generate_mesh(data);
|
||||
ChunkTaskResponse::GeneratedMesh { position, vertices, indexes }
|
||||
let (
|
||||
(vertices, indices),
|
||||
(trans_vertices, trans_indices),
|
||||
) = generate_mesh(data);
|
||||
ChunkTaskResponse::GeneratedMesh {
|
||||
position,
|
||||
vertices, indices,
|
||||
trans_vertices, trans_indices,
|
||||
}
|
||||
},
|
||||
ChunkTask::LoadChunk { position, seed } => {
|
||||
let (chunk_data, queued) = generate_world(position, seed);
|
||||
|
|
Loading…
Reference in a new issue