space-crush/space-crush-app/src/render/planets.rs

use std::mem::size_of;

use glc::{
    buffer::{Buffer, Usage},
    misc::{BindGuard, Bindable},
    shader::{Program, Type, Uniform},
    texture::Texture,
    vector::{Vector2f, Vector3f},
    vertex_array::{DataType, VertexArray},
};
use space_crush_common::{
    components::{Planet, Player, PlayerOwned, Position},
    misc::{ComponentEvent, LogResult, StorageHelper, StorageHelperMut},
};
use specs::{prelude::*, ReadStorage, System, World};

use crate::{
    constants::{
        PLANET_SIZE, PLAYER_COLOR_DEFAULT, UNIFORM_BUFFER_INDEX_CAMERA,
        UNIFORM_BUFFER_INDEX_UNIFORM,
    },
    misc::WorldHelper,
    Error,
};

pub struct Planets {
    program: Program,
    texture: Texture,
    vertex_array: VertexArray,
    reader_id: ReaderId<ComponentEvent<Planet>>,
    planet_count: usize,
}

#[repr(C, packed)]
struct VertexData {
    pos: Vector2f,
    size: gl::GLfloat,
    color: Vector3f,
}

impl Planets {
    pub fn new(world: &mut World) -> Result<Self, Error> {
        WriteStorage::<Planet>::setup(world);

        let program = world.load_program(vec![
            (Type::Vertex, "resources/shader/planet/vert.glsl"),
            (Type::Geometry, "resources/shader/planet/geom.glsl"),
            (Type::Fragment, "resources/shader/planet/frag.glsl"),
        ])?;

        program.uniform_block_binding("Camera", UNIFORM_BUFFER_INDEX_CAMERA)?;
        program.uniform_block_binding("Global", UNIFORM_BUFFER_INDEX_UNIFORM)?;

        program.bind();
        program.uniform("uTexture", Uniform::Texture(0))?;
        program.unbind();

        let texture = world.load_texture("resources/textures/planet01.png")?;

        const STRIDE: gl::GLsizei = size_of::<VertexData>() as gl::GLsizei;

        const OFFSET_POS: gl::GLsizei = 0;
        const OFFSET_SIZ: gl::GLsizei = OFFSET_POS + size_of::<Vector2f>() as gl::GLsizei;
        const OFFSET_CLR: gl::GLsizei = OFFSET_SIZ + size_of::<gl::GLfloat>() as gl::GLsizei;

        let vertex_array = VertexArray::builder()
            .bind_buffer(Buffer::new()?)
            .vertex_attrib_pointer(0, 2, DataType::Float, false, STRIDE, OFFSET_POS)?
            .vertex_attrib_pointer(1, 1, DataType::Float, false, STRIDE, OFFSET_SIZ)?
            .vertex_attrib_pointer(2, 3, DataType::Float, false, STRIDE, OFFSET_CLR)?
            .build()?;

        let reader_id = world
            .system_data::<WriteStorage<Planet>>()
            .register_event_reader();
        let planet_count = 0;

        Ok(Self {
            program,
            texture,
            vertex_array,
            reader_id,
            planet_count,
        })
    }
}

#[derive(SystemData)]
pub struct PlanetsData<'a> {
    positions: ReadStorage<'a, Position>,
    planets: ReadStorage<'a, Planet>,
    players: ReadStorage<'a, Player>,
    owned: ReadStorage<'a, PlayerOwned>,
}

impl<'a> System<'a> for Planets {
    type SystemData = PlanetsData<'a>;

    fn run(&mut self, data: Self::SystemData) {
        let PlanetsData {
            positions,
            planets,
            players,
            owned,
        } = data;

        /* handle events */
        let mut need_update = false;
        let events = planets.channel().read(&mut self.reader_id);
        for event in events {
            match event {
                ComponentEvent::Inserted(_, _) => {
                    need_update = true;

                    self.planet_count += 1;
                }
                ComponentEvent::Removed(_, _) => {
                    need_update = true;

                    self.planet_count -= 1;
                }
                ComponentEvent::Modified(_, _) => {
                    unreachable!("Updates of the planet component should not be tracked!")
                }
            }
        }

        /* update vertex array */
        let buffer = &mut self.vertex_array.buffers_mut()[0];
        if need_update {
            buffer
                .buffer_size(
                    Usage::StaticDraw,
                    self.planet_count * size_of::<VertexData>(),
                )
                .panic("Unable to change buffer size for planet data");

            let data = (&positions, &planets, owned.maybe());
            let mut buffer = buffer
                .map_mut::<VertexData>(true)
                .panic("Unable to map buffer for planet data");

            for (i, (position, _, owned)) in data.join().enumerate() {
                let mut d = &mut buffer[i];

                d.pos = *position.pos();
                d.size = position.shape().circle().unwrap_or(PLANET_SIZE);
                d.color = match owned.and_then(|owned| players.get(owned.owner())) {
                    Some(pv) => *pv.color(),
                    None => PLAYER_COLOR_DEFAULT,
                };
            }
        }

        /* render planets */
        let _guard = BindGuard::new(&self.program);
        let _guard = BindGuard::new(&self.vertex_array);
        let _guard = BindGuard::new(&self.texture);

        gl::enable(gl::BLEND);
        gl::blend_func(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
        gl::draw_arrays(gl::POINTS, 0, self.planet_count as _);
        gl::disable(gl::BLEND);
    }
}