summaryrefslogtreecommitdiff
path: root/engine/src/renderer
diff options
context:
space:
mode:
Diffstat (limited to 'engine/src/renderer')
-rw-r--r--engine/src/renderer/opengl.rs1420
-rw-r--r--engine/src/renderer/opengl/glutin_compat.rs268
-rw-r--r--engine/src/renderer/opengl/graphics_mesh.rs120
-rw-r--r--engine/src/renderer/opengl/vertex.rs9
4 files changed, 1473 insertions, 344 deletions
diff --git a/engine/src/renderer/opengl.rs b/engine/src/renderer/opengl.rs
index b48bac5..fb7dfbe 100644
--- a/engine/src/renderer/opengl.rs
+++ b/engine/src/renderer/opengl.rs
@@ -1,84 +1,101 @@
//! OpenGL renderer.
+use std::any::type_name;
use std::collections::HashMap;
-use std::ffi::{c_void, CString};
+use std::ffi::CString;
use std::io::{Error as IoError, ErrorKind as IoErrorKind};
use std::path::Path;
-use std::process::abort;
use ecs::actions::Actions;
-use ecs::component::local::Local;
use ecs::component::Handle as ComponentHandle;
-use ecs::phase::START as START_PHASE;
+use ecs::entity::obtainer::Obtainer as EntityObtainer;
+use ecs::event::component::{Changed, Removed};
+use ecs::pair::{ChildOf, Pair, Wildcard};
+use ecs::phase::Phase;
use ecs::query::term::Without;
use ecs::sole::Single;
-use ecs::system::initializable::Initializable;
-use ecs::system::Into as _;
-use ecs::{Component, Query};
-
-use crate::asset::{Assets, Id as AssetId};
-use crate::camera::{Active as ActiveCamera, Camera};
-use crate::color::Color;
-use crate::data_types::dimens::Dimens;
-use crate::draw_flags::{DrawFlags, NoDraw, PolygonModeConfig};
-use crate::image::{ColorType as ImageColorType, Image};
-use crate::lighting::{DirectionalLight, GlobalLight, PointLight};
-use crate::material::{Flags as MaterialFlags, Material};
-use crate::matrix::Matrix;
-use crate::mesh::Mesh;
-use crate::model::Model;
-use crate::opengl::buffer::{Buffer, Usage as BufferUsage};
-use crate::opengl::debug::{
- enable_debug_output,
+use ecs::system::observer::Observe;
+use ecs::{declare_entity, Component, Query};
+use glutin::display::GetGlDisplay;
+use glutin::prelude::GlDisplay;
+use glutin::surface::GlSurface;
+use opengl_bindings::debug::{
set_debug_message_callback,
set_debug_message_control,
MessageIdsAction,
MessageSeverity,
MessageSource,
MessageType,
+ SetDebugMessageControlError as GlSetDebugMessageControlError,
};
-use crate::opengl::glsl::{
- preprocess as glsl_preprocess,
- PreprocessingError as GlslPreprocessingError,
+use opengl_bindings::misc::{
+ clear_buffers,
+ enable,
+ set_enabled,
+ BufferClearMask,
+ Capability,
+ SetViewportError as GlSetViewportError,
};
-use crate::opengl::shader::{
+use opengl_bindings::shader::{
Error as GlShaderError,
Kind as ShaderKind,
Program as GlShaderProgram,
Shader as GlShader,
};
-use crate::opengl::texture::{
+use opengl_bindings::texture::{
Filtering as GlTextureFiltering,
+ GenerateError as GlTextureGenerateError,
PixelDataFormat as GlTexturePixelDataFormat,
Texture as GlTexture,
Wrapping as GlTextureWrapping,
};
-use crate::opengl::vertex_array::{
- DataType as VertexArrayDataType,
+use opengl_bindings::vertex_array::{
+ DrawError as GlDrawError,
PrimitiveKind,
VertexArray,
};
-use crate::opengl::{
- clear_buffers,
- enable,
- get_context_flags as get_opengl_context_flags,
- BufferClearMask,
- Capability,
- ContextFlags,
+use opengl_bindings::{ContextWithFns, CurrentContextWithFns};
+use safer_ffi::layout::ReprC;
+
+use crate::asset::{Assets, Id as AssetId};
+use crate::camera::{Active as ActiveCamera, Camera};
+use crate::color::Color;
+use crate::data_types::dimens::Dimens;
+use crate::draw_flags::{DrawFlags, NoDraw, PolygonModeConfig};
+use crate::image::{ColorType as ImageColorType, Image};
+use crate::lighting::{DirectionalLight, GlobalLight, PointLight};
+use crate::material::{Flags as MaterialFlags, Material};
+use crate::matrix::Matrix;
+use crate::model::Model;
+use crate::opengl::glsl::{
+ preprocess as glsl_preprocess,
+ PreprocessingError as GlslPreprocessingError,
};
use crate::projection::{ClipVolume, Projection};
-use crate::renderer::opengl::vertex::{AttributeComponentType, Vertex};
-use crate::renderer::RENDER_PHASE;
+use crate::renderer::opengl::glutin_compat::{
+ DisplayBuilder,
+ Error as GlutinCompatError,
+};
+use crate::renderer::opengl::graphics_mesh::GraphicsMesh;
+use crate::renderer::{GraphicsProperties, RENDER_PHASE};
use crate::texture::{
Filtering as TextureFiltering,
Properties as TextureProperties,
Wrapping as TextureWrapping,
};
use crate::transform::{Scale, WorldPosition};
-use crate::util::{defer, Defer, RefOrValue};
+use crate::util::MapVec;
use crate::vector::{Vec2, Vec3};
-use crate::window::Window;
+use crate::windowing::window::{
+ Closed as WindowClosed,
+ CreationAttributes as WindowCreationAttributes,
+ CreationReady,
+ Window,
+};
+use crate::windowing::Context as WindowingContext;
+mod glutin_compat;
+mod graphics_mesh;
mod vertex;
const AMBIENT_MAP_TEXTURE_UNIT: u32 = 0;
@@ -91,9 +108,66 @@ type RenderableEntity<'a> = (
Option<&'a WorldPosition>,
Option<&'a Scale>,
Option<&'a DrawFlags>,
- Option<&'a GlObjects>,
+ &'a [Pair<DataInGraphicsContext, Wildcard>],
+);
+
+declare_entity!(
+ pub POST_RENDER_PHASE,
+ (Phase, Pair::builder().relation::<ChildOf>().target_id(*RENDER_PHASE).build())
);
+#[derive(Debug, Component)]
+struct WithGraphicsContext;
+
+#[derive(Debug, Component)]
+struct WindowGlConfig
+{
+ gl_config: glutin::config::Config,
+}
+
+#[derive(Debug, Component)]
+struct WindowGraphicsSurface
+{
+ surface: glutin::surface::Surface<glutin::surface::WindowSurface>,
+}
+
+#[derive(Component)]
+struct GraphicsContext
+{
+ context: ContextWithFns,
+ shader_program: Option<GlShaderProgram>,
+ textures_objs: HashMap<AssetId, GlTexture>,
+ default_1x1_texture_obj: Option<GlTexture>,
+ graphics_mesh_store: GraphicsMeshStore,
+}
+
+#[derive(Debug, Default)]
+struct GraphicsMeshStore
+{
+ graphics_meshes: MapVec<GraphicsMeshId, GraphicsMesh>,
+ next_id: GraphicsMeshId,
+}
+
+impl GraphicsMeshStore
+{
+ fn insert(&mut self, graphics_mesh: GraphicsMesh) -> GraphicsMeshId
+ {
+ let id = self.next_id;
+
+ self.graphics_meshes.insert(id, graphics_mesh);
+
+ self.next_id.inner += 1;
+
+ id
+ }
+}
+
+#[derive(Debug, Component)]
+struct DataInGraphicsContext
+{
+ graphics_mesh_id: GraphicsMeshId,
+}
+
#[derive(Debug, Default)]
#[non_exhaustive]
pub struct Extension {}
@@ -103,253 +177,877 @@ impl ecs::extension::Extension for Extension
fn collect(self, mut collector: ecs::extension::Collector<'_>)
{
collector.add_declared_entity(&RENDER_PHASE);
+ collector.add_declared_entity(&POST_RENDER_PHASE);
- collector.add_system(*START_PHASE, initialize);
+ collector.add_system(*RENDER_PHASE, render);
- collector.add_system(
- *RENDER_PHASE,
- render
- .into_system()
- .initialize((GlobalGlObjects::default(),)),
- );
+ collector.add_system(*POST_RENDER_PHASE, prepare_windows);
+ collector.add_system(*POST_RENDER_PHASE, init_window_graphics);
+
+ collector.add_observer(handle_model_removed);
+
+ collector.add_observer(handle_window_changed);
+ collector.add_observer(handle_window_removed);
}
}
-fn initialize(window: Single<Window>)
+#[tracing::instrument(skip_all)]
+fn handle_model_removed(observe: Observe<Pair<Removed, Model>>, mut actions: Actions)
{
- window
- .make_context_current()
- .expect("Failed to make window context current");
+ for evt_match in &observe {
+ let ent_id = evt_match.id();
- gl::load_with(|symbol| match window.get_proc_address(symbol) {
- Ok(addr) => addr as *const c_void,
- Err(err) => {
- println!(
- "FATAL ERROR: Failed to get adress of OpenGL function {symbol}: {err}",
- );
+ tracing::debug!(entity_id=%ent_id, "Cleaning up after model");
- abort();
- }
- });
+ let ent = evt_match.get_ent_infallible();
- if get_opengl_context_flags().contains(ContextFlags::DEBUG) {
- initialize_debug();
+ for data_in_graphics_ctx_pair in
+ ent.get_wildcard_pair_matches::<DataInGraphicsContext, Wildcard>()
+ {
+ actions.remove_components(ent_id, [data_in_graphics_ctx_pair.id()]);
+
+ let Some(graphics_context_ent) = data_in_graphics_ctx_pair.get_target_ent()
+ else {
+ tracing::trace!(
+ concat!(
+ "Graphics context referenced by pair ({}, {}) does not exist. ",
+ "Skipping cleanup of this model"
+ ),
+ type_name::<DataInGraphicsContext>(),
+ data_in_graphics_ctx_pair.id().target_entity()
+ );
+
+ continue;
+ };
+
+ let Some(data_in_graphics_ctx) =
+ data_in_graphics_ctx_pair.get_data_as_relation()
+ else {
+ unreachable!();
+ };
+
+ let Some(mut graphics_context) =
+ graphics_context_ent.get_mut::<GraphicsContext>()
+ else {
+ tracing::trace!(
+ "Graphics context entity {} does not have a {} component",
+ graphics_context_ent.uid(),
+ type_name::<GraphicsContext>()
+ );
+ continue;
+ };
+
+ graphics_context
+ .graphics_mesh_store
+ .graphics_meshes
+ .remove(data_in_graphics_ctx.graphics_mesh_id);
+ }
}
+}
+
+#[tracing::instrument(skip_all)]
+fn handle_window_changed(
+ observe: Observe<Pair<Changed, Window>>,
+ entity_obtainer: EntityObtainer,
+)
+{
+ for evt_match in &observe {
+ let window_ent = evt_match.get_ent_infallible();
+
+ tracing::trace!(
+ new_state = ?evt_match.get_changed_comp(),
+ "Handling window change"
+ );
+
+ let Some(window_graphics_surface) = window_ent.get::<WindowGraphicsSurface>()
+ else {
+ continue;
+ };
+
+ let Some(graphics_context_ent_id) = window_ent
+ .get_matching_components(
+ Pair::builder()
+ .relation::<WithGraphicsContext>()
+ .target_id(Wildcard::uid())
+ .build()
+ .id(),
+ )
+ .next()
+ .map(|comp_ref| comp_ref.id().target_entity())
+ else {
+ continue;
+ };
- let window_size = window.size().expect("Failed to get window size");
+ let Some(graphics_context_ent) =
+ entity_obtainer.get_entity(graphics_context_ent_id)
+ else {
+ tracing::error!("Graphics context entity does not exist");
+ continue;
+ };
- set_viewport(Vec2 { x: 0, y: 0 }, window_size);
+ let Some(graphics_context) = graphics_context_ent.get::<GraphicsContext>() else {
+ tracing::error!(
+ "Graphics context entity does not have a GraphicsContext component"
+ );
+ continue;
+ };
- window.set_framebuffer_size_callback(|new_window_size| {
- set_viewport(Vec2::ZERO, new_window_size);
- });
+ let Ok(current_graphics_context) = graphics_context
+ .context
+ .make_current(&window_graphics_surface.surface)
+ else {
+ tracing::error!("Failed to make graphics context current");
+ continue;
+ };
- enable(Capability::DepthTest);
- enable(Capability::MultiSample);
+ if let Err(err) = set_viewport(
+ &current_graphics_context,
+ Vec2::default(),
+ evt_match.get_changed_comp().inner_size(),
+ ) {
+ tracing::error!("Failed to set viewport: {err}");
+ }
+ }
}
#[tracing::instrument(skip_all)]
-#[allow(clippy::too_many_arguments)]
-fn render(
- query: Query<RenderableEntity<'_>, (Without<NoDraw>,)>,
- point_light_query: Query<(&PointLight, &WorldPosition)>,
- directional_lights: Query<(&DirectionalLight,)>,
- camera_query: Query<(&Camera, &WorldPosition, &ActiveCamera)>,
- window: Single<Window>,
- global_light: Single<GlobalLight>,
- assets: Single<Assets>,
- mut gl_objects: Local<GlobalGlObjects>,
+fn handle_window_removed(observe: Observe<Pair<Removed, Window>>, mut actions: Actions)
+{
+ for evt_match in &observe {
+ let window_ent_id = evt_match.id();
+
+ let window_ent = evt_match.get_ent_infallible();
+
+ tracing::debug!(
+ entity_id = %window_ent_id,
+ title = %evt_match.get_removed_comp().title,
+ "Handling removal of window"
+ );
+
+ actions.remove_comps::<(WindowGraphicsSurface, WindowGlConfig)>(window_ent_id);
+
+ let Some(with_graphics_ctx_pair_handle) =
+ window_ent.get_first_wildcard_pair_match::<WithGraphicsContext, Wildcard>()
+ else {
+ tracing::warn!("Window entity is missing a (WithGraphicsContext, *) pair");
+ continue;
+ };
+
+ let graphics_context_ent_id = with_graphics_ctx_pair_handle.id().target_entity();
+
+ actions.remove_comps::<(GraphicsContext,)>(graphics_context_ent_id);
+
+ actions.remove_components(window_ent_id, [with_graphics_ctx_pair_handle.id()]);
+ }
+}
+
+#[derive(Debug, Component)]
+struct SetupFailed;
+
+// fn on_window_creation_attrs_added(
+// observe: Observe<Pair<Added, WindowCreationAttributes>>,
+// windowing: Single<Windowing>,
+// window_store: Single<WindowStore>,
+// mut actions: Actions,
+// )
+// {
+// for evt_match in &observe {
+// let Some(ent) = evt_match.get_entity() else {
+// unreachable!();
+// };
+//
+// if ent.has_component(WindowGlConfig::id()) ||
+// ent.has_component(WindowClosed::id()) || ent.has_component() {} }
+// }
+
+fn prepare_windows(
+ window_query: Query<
+ (
+ Option<&Window>,
+ &mut WindowCreationAttributes,
+ Option<&GraphicsProperties>,
+ ),
+ (
+ Without<CreationReady>,
+ Without<WindowGlConfig>,
+ Without<WindowClosed>,
+ Without<SetupFailed>,
+ ),
+ >,
+ windowing_context: Single<WindowingContext>,
mut actions: Actions,
)
{
- let Some((camera, camera_world_pos, _)) = camera_query.iter().next() else {
- tracing::warn!("No current camera. Nothing will be rendered");
+ let Some(display_handle) = windowing_context.display_handle() else {
return;
};
- let directional_lights = directional_lights.iter().collect::<Vec<_>>();
+ for (window_ent_id, (window, mut window_creation_attrs, graphics_props)) in
+ window_query.iter_with_euids()
+ {
+ tracing::debug!("Preparing window entity {window_ent_id} for use in rendering");
- let GlobalGlObjects {
- shader_program,
- textures: gl_textures,
- default_1x1_texture: default_1x1_gl_texture,
- } = &mut *gl_objects;
+ let mut glutin_config_template_builder =
+ glutin::config::ConfigTemplateBuilder::new();
- let shader_program =
- shader_program.get_or_insert_with(|| create_default_shader_program().unwrap());
+ let graphics_props = match graphics_props.as_ref() {
+ Some(graphics_props) => &*graphics_props,
+ None => {
+ actions.add_components(window_ent_id, (GraphicsProperties::default(),));
- clear_buffers(BufferClearMask::COLOR | BufferClearMask::DEPTH);
+ &GraphicsProperties::default()
+ }
+ };
- 'subject_loop: for (
- euid,
- (model, material_flags, position, scale, draw_flags, gl_objects),
- ) in query.iter_with_euids()
+ if let Some(multisampling_sample_cnt) = graphics_props.multisampling_sample_cnt {
+ glutin_config_template_builder = glutin_config_template_builder
+ .with_multisampling(multisampling_sample_cnt);
+ }
+
+ let window_handle = match window
+ .as_ref()
+ .map(|window| unsafe {
+ windowing_context.get_window_as_handle(&window.wid())
+ })
+ .flatten()
+ .transpose()
+ {
+ Ok(window_handle) => window_handle,
+ Err(err) => {
+ tracing::error!("Failed to get window handle: {err}");
+ actions.add_components(window_ent_id, (SetupFailed,));
+ continue;
+ }
+ };
+
+ let (new_window_creation_attrs, gl_config) = match DisplayBuilder::new()
+ .with_window_attributes(window_creation_attrs.clone())
+ .build(
+ window_handle,
+ &display_handle,
+ glutin_config_template_builder,
+ |mut cfgs| cfgs.next(),
+ ) {
+ Ok((new_window_creation_attrs, gl_config)) => {
+ (new_window_creation_attrs, gl_config)
+ }
+ Err(GlutinCompatError::WindowRequired) => {
+ actions.add_components(window_ent_id, (CreationReady,));
+ continue;
+ }
+ Err(err) => {
+ tracing::error!("Failed to create platform graphics display: {err}");
+ actions.add_components(window_ent_id, (SetupFailed,));
+ continue;
+ }
+ };
+
+ *window_creation_attrs = new_window_creation_attrs;
+
+ // let gl_config_template = glutin_config_template_builder.build();
+ //
+ // let display = match glutin_winit_compat::create_display(
+ // unsafe { engine_display.as_display_handle() },
+ // glutin_winit_compat::ApiPreference::default(),
+ // None,
+ // ) {
+ // Ok(gl_display) => gl_display,
+ // Err(err) => {
+ // tracing::error!("Failed to create graphics platform display: {err}");
+ // continue;
+ // }
+ // };
+ //
+ // let mut gl_configs = match unsafe { display.find_configs(gl_config_template) }
+ // { Ok(gl_configs) => gl_configs,
+ // Err(err) => {
+ // tracing::error!("Failed to find GL configs: {err:?}");
+ // continue;
+ // }
+ // };
+ //
+ // let Some(first_gl_config) = gl_configs.next() else {
+ // tracing::error!("No matching GL configuration exists");
+ // continue;
+ // };
+ //
+ // *window_creation_attrs = finalize_window_creation_attrs(
+ // window_creation_attrs.clone(),
+ // &first_gl_config,
+ // );
+
+ actions.add_components(window_ent_id, (WindowGlConfig { gl_config },));
+
+ if window.is_none() {
+ actions.add_components(window_ent_id, (CreationReady,));
+ }
+ }
+}
+
+#[tracing::instrument(skip_all)]
+fn init_window_graphics(
+ window_query: Query<
+ (&Window, &WindowGlConfig, &GraphicsProperties),
+ (Without<WindowGraphicsSurface>, Without<SetupFailed>),
+ >,
+ mut actions: Actions,
+ windowing_context: Single<WindowingContext>,
+)
+{
+ for (window_ent_id, (window, window_gl_config, graphics_props)) in
+ window_query.iter_with_euids()
{
- let Some(model_data) = assets.get(&model.asset_handle) else {
- tracing::trace!("Missing model asset");
+ tracing::info!("Initializing graphics for window {window_ent_id}");
+
+ let display = window_gl_config.gl_config.display();
+
+ let window_handle =
+ match unsafe { windowing_context.get_window_as_handle(&window.wid()) }
+ .transpose()
+ {
+ Ok(Some(window_handle)) => window_handle,
+ Ok(None) => {
+ tracing::error!(
+ wid = ?window.wid(),
+ entity_id = %window_ent_id,
+ "Windowing context does not contain window"
+ );
+ actions.add_components(window_ent_id, (SetupFailed,));
+ continue;
+ }
+ Err(err) => {
+ tracing::error!("Failed to get window handle: {err}");
+ actions.add_components(window_ent_id, (SetupFailed,));
+ continue;
+ }
+ };
+
+ let Some(window_inner_size) = window.inner_size().try_into_nonzero() else {
+ tracing::error!(
+ "Cannot create a surface for a window with a width/height of 0",
+ );
continue;
};
- let material_flags = material_flags
- .map(|material_flags| material_flags.clone())
- .unwrap_or_default();
+ let surface = match unsafe {
+ display.create_window_surface(
+ &window_gl_config.gl_config,
+ &glutin::surface::SurfaceAttributesBuilder::<
+ glutin::surface::WindowSurface,
+ >::new()
+ .build(
+ window_handle.as_raw(),
+ window_inner_size.width,
+ window_inner_size.height,
+ ),
+ )
+ } {
+ Ok(surface) => surface,
+ Err(err) => {
+ tracing::error!("Failed to create window surface: {err}");
+ continue;
+ }
+ };
- let gl_objs = match gl_objects.as_deref() {
- Some(gl_objs) => RefOrValue::Ref(gl_objs),
- None => RefOrValue::Value(Some(GlObjects::new(&model_data.mesh))),
+ let context = match unsafe {
+ display.create_context(
+ &window_gl_config.gl_config,
+ &glutin::context::ContextAttributesBuilder::new()
+ .with_debug(graphics_props.debug)
+ .build(Some(window_handle.as_raw())),
+ )
+ } {
+ Ok(context) => context,
+ Err(err) => {
+ tracing::error!("Failed to create graphics context: {err}");
+ continue;
+ }
};
- defer!(|gl_objs| {
- if let RefOrValue::Value(opt_gl_objs) = gl_objs {
- actions.add_components(euid, (opt_gl_objs.take().unwrap(),));
- };
- });
+ let context = match ContextWithFns::new(context, &surface) {
+ Ok(context) => context,
+ Err(err) => {
+ tracing::error!("Failed to create graphics context: {err}");
+ continue;
+ }
+ };
- apply_transformation_matrices(
- Transformation {
- position: position.map(|pos| *pos).unwrap_or_default().position,
- scale: scale.map(|scale| *scale).unwrap_or_default().scale,
- },
- shader_program,
- &camera,
- &camera_world_pos,
- window.size().expect("Failed to get window size"),
- );
+ let Ok(current_graphics_context) = context.make_current(&surface) else {
+ tracing::error!("Failed to make graphics context current");
+ continue;
+ };
- if model_data.materials.len() > 1 {
- tracing::warn!(concat!(
- "Multiple model materials are not supported ",
- "so only the first material will be used"
- ));
+ if let Err(err) = set_viewport(
+ &current_graphics_context,
+ Vec2 { x: 0, y: 0 },
+ window.inner_size(),
+ ) {
+ tracing::error!("Failed to set viewport: {err}");
}
- let material = match model_data.materials.values().next() {
- Some(material) => material,
- None => {
- tracing::warn!("Model has no materials. Using default material");
+ set_enabled(
+ &current_graphics_context,
+ Capability::DepthTest,
+ graphics_props.depth_test,
+ );
- &Material::default()
+ set_enabled(
+ &current_graphics_context,
+ Capability::MultiSample,
+ graphics_props.multisampling_sample_cnt.is_some(),
+ );
+
+ if graphics_props.debug {
+ enable(&current_graphics_context, Capability::DebugOutput);
+ enable(
+ &current_graphics_context,
+ Capability::DebugOutputSynchronous,
+ );
+
+ set_debug_message_callback(
+ &current_graphics_context,
+ opengl_debug_message_cb,
+ );
+
+ match set_debug_message_control(
+ &current_graphics_context,
+ None,
+ None,
+ None,
+ &[],
+ MessageIdsAction::Disable,
+ ) {
+ Ok(()) => {}
+ Err(GlSetDebugMessageControlError::TooManyIds {
+ id_cnt: _,
+ max_id_cnt: _,
+ }) => {
+ unreachable!() // No ids are given
+ }
}
- };
+ }
- apply_light(
- &material,
- &material_flags,
- &global_light,
- shader_program,
- (point_light_query.iter(), point_light_query.iter().count()),
- directional_lights
- .iter()
- .map(|(dir_light,)| &**dir_light)
- .collect::<Vec<_>>()
- .as_slice(),
- &camera_world_pos,
+ let graphics_context_ent_id = actions.spawn((GraphicsContext {
+ context,
+ shader_program: None,
+ textures_objs: HashMap::new(),
+ default_1x1_texture_obj: None,
+ graphics_mesh_store: GraphicsMeshStore::default(),
+ },));
+
+ actions.add_components(
+ window_ent_id,
+ (
+ WindowGraphicsSurface { surface },
+ Pair::builder()
+ .relation::<WithGraphicsContext>()
+ .target_id(graphics_context_ent_id)
+ .build(),
+ ),
);
+ }
+}
- let material_texture_maps = [
- (&material.ambient_map, AMBIENT_MAP_TEXTURE_UNIT),
- (&material.diffuse_map, DIFFUSE_MAP_TEXTURE_UNIT),
- (&material.specular_map, SPECULAR_MAP_TEXTURE_UNIT),
- ];
+#[tracing::instrument(skip_all)]
+#[allow(clippy::too_many_arguments)]
+fn render(
+ query: Query<RenderableEntity<'_>, (Without<NoDraw>,)>,
+ point_light_query: Query<(&PointLight, &WorldPosition)>,
+ directional_lights: Query<(&DirectionalLight,)>,
+ camera_query: Query<(&Camera, &WorldPosition, &ActiveCamera)>,
+ window_query: Query<(
+ &Window,
+ &WindowGraphicsSurface,
+ &GraphicsProperties,
+ Pair<WithGraphicsContext, Wildcard>,
+ )>,
+ global_light: Single<GlobalLight>,
+ assets: Single<Assets>,
+ mut actions: Actions,
+)
+{
+ for (
+ window_ent_id,
+ (window, window_graphics_surface, window_graphics_props, graphics_context_pair),
+ ) in window_query.iter_with_euids()
+ {
+ let Some(graphics_context_ent) = graphics_context_pair.get_target_ent() else {
+ tracing::error!("Window's associated graphics context entity does not exist");
+ actions.remove_components(window_ent_id, [graphics_context_pair.id()]);
+ continue;
+ };
- for (texture, texture_unit) in material_texture_maps {
- let Some(texture) = texture else {
- let gl_texture = default_1x1_gl_texture.get_or_insert_with(|| {
- create_gl_texture(
- &Image::from_color(1, Color::WHITE_U8),
- &TextureProperties::default(),
- )
- });
+ let Some(mut graphics_context) =
+ graphics_context_ent.get_mut::<GraphicsContext>()
+ else {
+ tracing::error!(
+ "Graphics context entity does not have a GraphicsContext component"
+ );
+ return;
+ };
- gl_texture.bind_to_texture_unit(texture_unit);
+ let GraphicsContext {
+ ref context,
+ ref mut shader_program,
+ ref mut textures_objs,
+ ref mut default_1x1_texture_obj,
+ ref mut graphics_mesh_store,
+ } = *graphics_context;
+
+ let Some((camera, camera_world_pos, _)) = camera_query.iter().next() else {
+ tracing::warn!("No current camera. Nothing will be rendered");
+ return;
+ };
+
+ let Ok(current_graphics_context) =
+ context.make_current(&window_graphics_surface.surface)
+ else {
+ tracing::error!("Failed to make graphics context current");
+ continue;
+ };
+
+ let directional_lights = directional_lights.iter().collect::<Vec<_>>();
+
+ let shader_program = shader_program.get_or_insert_with(|| {
+ create_default_shader_program(&current_graphics_context).unwrap()
+ });
+
+ let mut clear_mask = BufferClearMask::COLOR;
+
+ clear_mask.set(BufferClearMask::DEPTH, window_graphics_props.depth_test);
+ clear_buffers(&current_graphics_context, clear_mask);
+
+ for (
+ euid,
+ (
+ model,
+ material_flags,
+ position,
+ scale,
+ draw_flags,
+ data_in_graphics_ctx_pairs,
+ ),
+ ) in query.iter_with_euids()
+ {
+ let Some(model_data) = assets.get(&model.asset_handle) else {
+ tracing::trace!("Missing model asset");
continue;
};
- let texture_image_asset_id = texture.asset_handle.id();
+ let material_flags = material_flags
+ .map(|material_flags| material_flags.clone())
+ .unwrap_or_default();
+
+ let graphics_mesh_id = match data_in_graphics_ctx_pairs
+ .get_with_target_id(graphics_context_ent.uid())
+ {
+ Some(data_in_graphics_ctx_pair) => {
+ let Some(data_in_graphics_ctx) =
+ data_in_graphics_ctx_pair.get_data::<DataInGraphicsContext>()
+ else {
+ tracing::warn!(
+ concat!(
+ "Pair with relation {} ({}) has no data or data with a ",
+ "wrong type. This pair will be removed"
+ ),
+ type_name::<DataInGraphicsContext>(),
+ data_in_graphics_ctx_pair.id()
+ );
+
+ actions.remove_components(euid, [data_in_graphics_ctx_pair.id()]);
+ continue;
+ };
- let gl_texture = match gl_textures.get(&texture_image_asset_id) {
- Some(gl_texture) => gl_texture,
+ data_in_graphics_ctx.graphics_mesh_id
+ }
None => {
- let Some(image) = assets.get::<Image>(&texture.asset_handle) else {
- tracing::trace!("Missing texture asset");
- continue 'subject_loop;
+ let graphics_mesh = match GraphicsMesh::new(
+ &current_graphics_context,
+ &model_data.mesh,
+ ) {
+ Ok(graphics_mesh) => graphics_mesh,
+ Err(err) => {
+ tracing::error!(
+ "Failed to create {}: {err}",
+ type_name::<GraphicsMesh>()
+ );
+
+ // This system should not try again
+ actions.add_components(euid, (NoDraw,));
+
+ continue;
+ }
};
- gl_textures.insert(
- texture_image_asset_id,
- create_gl_texture(image, &texture.properties),
+ let graphics_mesh_id = graphics_mesh_store.insert(graphics_mesh);
+
+ actions.add_components(
+ euid,
+ (Pair::builder()
+ .relation_as_data(DataInGraphicsContext { graphics_mesh_id })
+ .target_id(graphics_context_ent.uid())
+ .build(),),
);
- gl_textures
- .get(&texture.asset_handle.id())
- .expect("Not possible")
+ graphics_mesh_id
}
};
- gl_texture.bind_to_texture_unit(texture_unit);
- }
-
- shader_program.activate();
+ let Some(graphics_mesh) =
+ graphics_mesh_store.graphics_meshes.get(&graphics_mesh_id)
+ else {
+ tracing::error!("Graphics mesh with ID: {graphics_mesh_id:?} not found");
+ continue;
+ };
- if let Some(draw_flags) = &draw_flags {
- crate::opengl::set_polygon_mode(
- draw_flags.polygon_mode_config.face,
- draw_flags.polygon_mode_config.mode,
+ apply_transformation_matrices(
+ &current_graphics_context,
+ Transformation {
+ position: position.map(|pos| *pos).unwrap_or_default().position,
+ scale: scale.map(|scale| *scale).unwrap_or_default().scale,
+ },
+ shader_program,
+ &camera,
+ &camera_world_pos,
+ window.inner_size(),
);
- }
- draw_mesh(gl_objs.get().unwrap());
+ if model_data.materials.len() > 1 {
+ tracing::warn!(concat!(
+ "Multiple model materials are not supported ",
+ "so only the first material will be used"
+ ));
+ }
- if draw_flags.is_some() {
- let default_polygon_mode_config = PolygonModeConfig::default();
+ let material = match model_data.materials.values().next() {
+ Some(material) => material,
+ None => {
+ tracing::warn!("Model has no materials. Using default material");
- crate::opengl::set_polygon_mode(
- default_polygon_mode_config.face,
- default_polygon_mode_config.mode,
+ &Material::default()
+ }
+ };
+
+ apply_light(
+ &current_graphics_context,
+ &material,
+ &material_flags,
+ &global_light,
+ shader_program,
+ (point_light_query.iter(), point_light_query.iter().count()),
+ directional_lights
+ .iter()
+ .map(|(dir_light,)| &**dir_light)
+ .collect::<Vec<_>>()
+ .as_slice(),
+ &camera_world_pos,
);
+
+ match create_bind_material_textures(
+ &current_graphics_context,
+ &material,
+ &assets,
+ textures_objs,
+ default_1x1_texture_obj,
+ ) {
+ Ok(()) => {}
+ Err(CreateBindMaterialTexturesError::MissingTextureAsset) => {
+ continue;
+ }
+ Err(
+ err @ CreateBindMaterialTexturesError::CreateTextureFailed { .. },
+ ) => {
+ tracing::error!(
+ "Creating &/ binding material textures failed: {err}"
+ );
+
+ // This system should not try again
+ actions.add_components(euid, (NoDraw,));
+
+ continue;
+ }
+ }
+
+ shader_program.activate(&current_graphics_context);
+
+ if let Some(draw_flags) = &draw_flags {
+ opengl_bindings::misc::set_polygon_mode(
+ &current_graphics_context,
+ draw_flags.polygon_mode_config.face,
+ draw_flags.polygon_mode_config.mode,
+ );
+ }
+
+ if let Err(err) = draw_mesh(&current_graphics_context, &graphics_mesh) {
+ tracing::error!(
+ entity_id = %euid,
+ graphics_context_entity_id = %graphics_context_ent.uid(),
+ "Failed to draw mesh: {err}",
+ );
+
+ // This system should not try again
+ actions.add_components(euid, (NoDraw,));
+
+ continue;
+ };
+
+ if draw_flags.is_some() {
+ let default_polygon_mode_config = PolygonModeConfig::default();
+
+ opengl_bindings::misc::set_polygon_mode(
+ &current_graphics_context,
+ default_polygon_mode_config.face,
+ default_polygon_mode_config.mode,
+ );
+ }
+ }
+
+ if let Err(err) = window_graphics_surface
+ .surface
+ .swap_buffers(context.context())
+ {
+ tracing::error!("Failed to swap buffers: {err}");
}
}
}
-#[derive(Debug, Default, Component)]
-struct GlobalGlObjects
+fn create_default_texture(current_context: &CurrentContextWithFns<'_>) -> GlTexture
{
- shader_program: Option<GlShaderProgram>,
- textures: HashMap<AssetId, GlTexture>,
- default_1x1_texture: Option<GlTexture>,
+ match create_gl_texture(
+ current_context,
+ &Image::from_color(Dimens { width: 1, height: 1 }, Color::WHITE_U8),
+ &TextureProperties::default(),
+ ) {
+ Ok(gl_texture) => gl_texture,
+ Err(
+ GlTextureGenerateError::SizeWidthValueTooLarge { value: _, max_value: _ }
+ | GlTextureGenerateError::SizeHeightValueTooLarge { value: _, max_value: _ },
+ ) => unreachable!(),
+ }
}
-fn set_viewport(position: Vec2<u32>, size: Dimens<u32>)
+fn create_bind_material_textures(
+ current_context: &CurrentContextWithFns<'_>,
+ material: &Material,
+ assets: &Assets,
+ texture_objs: &mut HashMap<AssetId, GlTexture>,
+ default_1x1_texture_obj: &mut Option<GlTexture>,
+) -> Result<(), CreateBindMaterialTexturesError>
{
- crate::opengl::set_viewport(position, size);
+ let material_texture_maps = [
+ (&material.ambient_map, AMBIENT_MAP_TEXTURE_UNIT),
+ (&material.diffuse_map, DIFFUSE_MAP_TEXTURE_UNIT),
+ (&material.specular_map, SPECULAR_MAP_TEXTURE_UNIT),
+ ];
+
+ for (texture, texture_unit) in material_texture_maps {
+ let Some(texture) = texture else {
+ let gl_texture = default_1x1_texture_obj
+ .get_or_insert_with(|| create_default_texture(current_context));
+
+ gl_texture.bind_to_texture_unit(current_context, texture_unit);
+
+ continue;
+ };
+
+ let texture_image_asset_id = texture.asset_handle.id();
+
+ let gl_texture = match texture_objs.get(&texture_image_asset_id) {
+ Some(gl_texture) => gl_texture,
+ None => {
+ let Some(image) = assets.get::<Image>(&texture.asset_handle) else {
+ tracing::trace!(handle=?texture.asset_handle, "Missing texture asset");
+ return Err(CreateBindMaterialTexturesError::MissingTextureAsset);
+ };
+
+ texture_objs.entry(texture_image_asset_id).or_insert(
+ create_gl_texture(current_context, image, &texture.properties)
+ .map_err(|err| {
+ CreateBindMaterialTexturesError::CreateTextureFailed {
+ err,
+ image_asset_id: texture_image_asset_id,
+ }
+ })?,
+ )
+ }
+ };
+
+ gl_texture.bind_to_texture_unit(current_context, texture_unit);
+ }
+
+ Ok(())
}
-fn initialize_debug()
+#[derive(Debug, thiserror::Error)]
+enum CreateBindMaterialTexturesError
{
- enable_debug_output();
+ #[error("Missing texture asset")]
+ MissingTextureAsset,
- set_debug_message_callback(opengl_debug_message_cb);
- set_debug_message_control(None, None, None, &[], MessageIdsAction::Disable);
+ #[error("Failed to create texture from image asset with ID {image_asset_id:?}")]
+ CreateTextureFailed
+ {
+ #[source]
+ err: GlTextureGenerateError,
+ image_asset_id: AssetId,
+ },
}
-fn draw_mesh(gl_objects: &GlObjects)
+fn set_viewport(
+ current_context: &CurrentContextWithFns<'_>,
+ position: Vec2<u32>,
+ size: &Dimens<u32>,
+) -> Result<(), GlSetViewportError>
{
- gl_objects.vertex_arr.bind();
+ let position =
+ opengl_bindings::data_types::Vec2::<u32> { x: position.x, y: position.y };
- if gl_objects.index_buffer.is_some() {
- VertexArray::draw_elements(PrimitiveKind::Triangles, 0, gl_objects.element_cnt);
+ let size = opengl_bindings::data_types::Dimens::<u32> {
+ width: size.width,
+ height: size.height,
+ };
+
+ opengl_bindings::misc::set_viewport(current_context, &position, &size)
+}
+
+fn draw_mesh(
+ current_context: &CurrentContextWithFns<'_>,
+ graphics_mesh: &GraphicsMesh,
+) -> Result<(), GlDrawError>
+{
+ graphics_mesh.vertex_arr.bind(current_context);
+
+ if graphics_mesh.index_buffer.is_some() {
+ VertexArray::draw_elements(
+ current_context,
+ PrimitiveKind::Triangles,
+ 0,
+ graphics_mesh.element_cnt,
+ )?;
} else {
- VertexArray::draw_arrays(PrimitiveKind::Triangles, 0, gl_objects.element_cnt);
+ VertexArray::draw_arrays(
+ current_context,
+ PrimitiveKind::Triangles,
+ 0,
+ graphics_mesh.element_cnt,
+ )?;
}
+
+ Ok(())
}
-fn create_gl_texture(image: &Image, texture_properties: &TextureProperties) -> GlTexture
+fn create_gl_texture(
+ current_context: &CurrentContextWithFns<'_>,
+ image: &Image,
+ texture_properties: &TextureProperties,
+) -> Result<GlTexture, GlTextureGenerateError>
{
- let mut gl_texture = GlTexture::new();
+ let gl_texture = GlTexture::new(current_context);
gl_texture.generate(
- image.dimensions(),
+ current_context,
+ &image.dimensions().into(),
image.as_bytes(),
match image.color_type() {
ImageColorType::Rgb8 => GlTexturePixelDataFormat::Rgb8,
@@ -358,19 +1056,24 @@ fn create_gl_texture(image: &Image, texture_properties: &TextureProperties) -> G
unimplemented!();
}
},
- );
+ )?;
- gl_texture.set_wrap(texture_wrapping_to_gl(texture_properties.wrap));
+ gl_texture.set_wrap(
+ current_context,
+ texture_wrapping_to_gl(texture_properties.wrap),
+ );
- gl_texture.set_magnifying_filter(texture_filtering_to_gl(
- texture_properties.magnifying_filter,
- ));
+ gl_texture.set_magnifying_filter(
+ current_context,
+ texture_filtering_to_gl(texture_properties.magnifying_filter),
+ );
- gl_texture.set_minifying_filter(texture_filtering_to_gl(
- texture_properties.minifying_filter,
- ));
+ gl_texture.set_minifying_filter(
+ current_context,
+ texture_filtering_to_gl(texture_properties.minifying_filter),
+ );
- gl_texture
+ Ok(gl_texture)
}
const VERTEX_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/vertex.glsl");
@@ -379,32 +1082,34 @@ const FRAGMENT_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/fragment.glsl")
const VERTEX_DATA_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/vertex_data.glsl");
const LIGHT_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/light.glsl");
-fn create_default_shader_program() -> Result<GlShaderProgram, CreateShaderError>
+fn create_default_shader_program(
+ current_context: &CurrentContextWithFns<'_>,
+) -> Result<GlShaderProgram, CreateShaderError>
{
- let mut vertex_shader = GlShader::new(ShaderKind::Vertex);
+ let vertex_shader = GlShader::new(current_context, ShaderKind::Vertex);
- vertex_shader.set_source(&*glsl_preprocess(
- VERTEX_GLSL_SHADER_SRC,
- &get_glsl_shader_content,
- )?)?;
+ vertex_shader.set_source(
+ current_context,
+ &*glsl_preprocess(VERTEX_GLSL_SHADER_SRC, &get_glsl_shader_content)?,
+ )?;
- vertex_shader.compile()?;
+ vertex_shader.compile(current_context)?;
- let mut fragment_shader = GlShader::new(ShaderKind::Fragment);
+ let fragment_shader = GlShader::new(current_context, ShaderKind::Fragment);
- fragment_shader.set_source(&*glsl_preprocess(
- FRAGMENT_GLSL_SHADER_SRC,
- &get_glsl_shader_content,
- )?)?;
+ fragment_shader.set_source(
+ current_context,
+ &*glsl_preprocess(FRAGMENT_GLSL_SHADER_SRC, &get_glsl_shader_content)?,
+ )?;
- fragment_shader.compile()?;
+ fragment_shader.compile(current_context)?;
- let mut gl_shader_program = GlShaderProgram::new();
+ let gl_shader_program = GlShaderProgram::new(current_context);
- gl_shader_program.attach(&vertex_shader);
- gl_shader_program.attach(&fragment_shader);
+ gl_shader_program.attach(current_context, &vertex_shader);
+ gl_shader_program.attach(current_context, &fragment_shader);
- gl_shader_program.link()?;
+ gl_shader_program.link(current_context)?;
Ok(gl_shader_program)
}
@@ -435,108 +1140,36 @@ fn get_glsl_shader_content(path: &Path) -> Result<Vec<u8>, std::io::Error>
))
}
-#[derive(Debug, Component)]
-struct GlObjects
-{
- /// Vertex and index buffer has to live as long as the vertex array
- _vertex_buffer: Buffer<Vertex>,
- index_buffer: Option<Buffer<u32>>,
- element_cnt: u32,
-
- vertex_arr: VertexArray,
-}
-
-impl GlObjects
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct GraphicsMeshId
{
- #[tracing::instrument(skip_all)]
- fn new(mesh: &Mesh) -> Self
- {
- tracing::trace!(
- "Creating vertex array, vertex buffer{}",
- if mesh.indices().is_some() {
- " and index buffer"
- } else {
- ""
- }
- );
-
- let mut vertex_arr = VertexArray::new();
- let mut vertex_buffer = Buffer::new();
-
- vertex_buffer.store_mapped(mesh.vertices(), BufferUsage::Static, |vertex| {
- Vertex {
- pos: vertex.pos,
- texture_coords: vertex.texture_coords,
- normal: vertex.normal,
- }
- });
-
- vertex_arr.bind_vertex_buffer(0, &vertex_buffer, 0);
-
- let mut offset = 0u32;
-
- for attrib in Vertex::attrs() {
- vertex_arr.enable_attrib(attrib.index);
-
- vertex_arr.set_attrib_format(
- attrib.index,
- match attrib.component_type {
- AttributeComponentType::Float => VertexArrayDataType::Float,
- },
- false,
- offset,
- );
-
- vertex_arr.set_attrib_vertex_buf_binding(attrib.index, 0);
-
- offset += attrib.component_size * attrib.component_cnt as u32;
- }
-
- if let Some(indices) = mesh.indices() {
- let mut index_buffer = Buffer::new();
-
- index_buffer.store(indices, BufferUsage::Static);
-
- vertex_arr.bind_element_buffer(&index_buffer);
-
- return Self {
- _vertex_buffer: vertex_buffer,
- index_buffer: Some(index_buffer),
- element_cnt: indices
- .len()
- .try_into()
- .expect("Mesh index count does not fit into a 32-bit unsigned int"),
- vertex_arr,
- };
- }
-
- Self {
- _vertex_buffer: vertex_buffer,
- index_buffer: None,
- element_cnt: mesh
- .vertices()
- .len()
- .try_into()
- .expect("Mesh vertex count does not fit into a 32-bit unsigned int"),
- vertex_arr,
- }
- }
+ inner: usize,
}
fn apply_transformation_matrices(
+ current_context: &CurrentContextWithFns<'_>,
transformation: Transformation,
gl_shader_program: &mut GlShaderProgram,
camera: &Camera,
camera_world_pos: &WorldPosition,
- window_size: Dimens<u32>,
+ window_size: &Dimens<u32>,
)
{
- gl_shader_program
- .set_uniform(c"model", &create_transformation_matrix(transformation));
+ gl_shader_program.set_uniform(
+ current_context,
+ c"model",
+ &opengl_bindings::data_types::Matrix {
+ items: create_transformation_matrix(transformation).items,
+ },
+ );
let view_matrix = create_view_matrix(camera, &camera_world_pos.position);
- gl_shader_program.set_uniform(c"view", &view_matrix);
+ gl_shader_program.set_uniform(
+ current_context,
+ c"view",
+ &opengl_bindings::data_types::Matrix { items: view_matrix.items },
+ );
#[allow(clippy::cast_precision_loss)]
let proj_matrix = match &camera.projection {
@@ -548,10 +1181,15 @@ fn apply_transformation_matrices(
.to_matrix_rh(&camera_world_pos.position, ClipVolume::NegOneToOne),
};
- gl_shader_program.set_uniform(c"projection", &proj_matrix);
+ gl_shader_program.set_uniform(
+ current_context,
+ c"projection",
+ &opengl_bindings::data_types::Matrix { items: proj_matrix.items },
+ );
}
fn apply_light<'point_light>(
+ current_context: &CurrentContextWithFns<'_>,
material: &Material,
material_flags: &MaterialFlags,
global_light: &GlobalLight,
@@ -580,16 +1218,20 @@ fn apply_light<'point_light>(
);
for (dir_light_index, dir_light) in directional_lights.iter().enumerate() {
+ let direction: opengl_bindings::data_types::Vec3<_> = dir_light.direction.into();
+
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name(
"directional_lights",
dir_light_index,
"direction",
),
- &dir_light.direction,
+ &direction,
);
set_light_phong_uniforms(
+ current_context,
gl_shader_program,
"directional_lights",
dir_light_index,
@@ -599,18 +1241,26 @@ fn apply_light<'point_light>(
// There probably won't be more than 2147483648 directional lights
#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
- gl_shader_program
- .set_uniform(c"directional_light_cnt", &(directional_lights.len() as i32));
+ gl_shader_program.set_uniform(
+ current_context,
+ c"directional_light_cnt",
+ &(directional_lights.len() as i32),
+ );
for (point_light_index, (point_light, point_light_world_pos)) in
point_light_iter.enumerate()
{
+ let pos: opengl_bindings::data_types::Vec3<_> =
+ (point_light_world_pos.position + point_light.local_position).into();
+
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name("point_lights", point_light_index, "position"),
- &(point_light_world_pos.position + point_light.local_position),
+ &pos,
);
set_light_phong_uniforms(
+ current_context,
gl_shader_program,
"point_lights",
point_light_index,
@@ -618,6 +1268,7 @@ fn apply_light<'point_light>(
);
set_light_attenuation_uniforms(
+ current_context,
gl_shader_program,
"point_lights",
point_light_index,
@@ -627,44 +1278,67 @@ fn apply_light<'point_light>(
// There probably won't be more than 2147483648 point lights
#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
- gl_shader_program.set_uniform(c"point_light_cnt", &(point_light_cnt as i32));
-
gl_shader_program.set_uniform(
- c"material.ambient",
- &Vec3::from(if material_flags.use_ambient_color {
+ current_context,
+ c"point_light_cnt",
+ &(point_light_cnt as i32),
+ );
+
+ let ambient: opengl_bindings::data_types::Vec3<_> =
+ Vec3::from(if material_flags.use_ambient_color {
material.ambient.clone()
} else {
global_light.ambient.clone()
- }),
- );
+ })
+ .into();
+
+ gl_shader_program.set_uniform(current_context, c"material.ambient", &ambient);
- gl_shader_program
- .set_uniform(c"material.diffuse", &Vec3::from(material.diffuse.clone()));
+ let diffuse: opengl_bindings::data_types::Vec3<_> =
+ Vec3::from(material.diffuse.clone()).into();
+
+ gl_shader_program.set_uniform(current_context, c"material.diffuse", &diffuse);
+
+ let specular: opengl_bindings::data_types::Vec3<_> =
+ Vec3::from(material.specular.clone()).into();
#[allow(clippy::cast_possible_wrap)]
- gl_shader_program
- .set_uniform(c"material.specular", &Vec3::from(material.specular.clone()));
+ gl_shader_program.set_uniform(current_context, c"material.specular", &specular);
#[allow(clippy::cast_possible_wrap)]
- gl_shader_program
- .set_uniform(c"material.ambient_map", &(AMBIENT_MAP_TEXTURE_UNIT as i32));
+ gl_shader_program.set_uniform(
+ current_context,
+ c"material.ambient_map",
+ &(AMBIENT_MAP_TEXTURE_UNIT as i32),
+ );
#[allow(clippy::cast_possible_wrap)]
- gl_shader_program
- .set_uniform(c"material.diffuse_map", &(DIFFUSE_MAP_TEXTURE_UNIT as i32));
+ gl_shader_program.set_uniform(
+ current_context,
+ c"material.diffuse_map",
+ &(DIFFUSE_MAP_TEXTURE_UNIT as i32),
+ );
#[allow(clippy::cast_possible_wrap)]
gl_shader_program.set_uniform(
+ current_context,
c"material.specular_map",
&(SPECULAR_MAP_TEXTURE_UNIT as i32),
);
- gl_shader_program.set_uniform(c"material.shininess", &material.shininess);
+ gl_shader_program.set_uniform(
+ current_context,
+ c"material.shininess",
+ &material.shininess,
+ );
+
+ let view_pos: opengl_bindings::data_types::Vec3<_> = camera_world_pos.position.into();
- gl_shader_program.set_uniform(c"view_pos", &camera_world_pos.position);
+ gl_shader_program.set_uniform(current_context, c"view_pos", &view_pos);
}
fn set_light_attenuation_uniforms(
+ current_context: &CurrentContextWithFns<'_>,
gl_shader_program: &mut GlShaderProgram,
light_array: &str,
light_index: usize,
@@ -672,6 +1346,7 @@ fn set_light_attenuation_uniforms(
)
{
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name(
light_array,
light_index,
@@ -681,11 +1356,13 @@ fn set_light_attenuation_uniforms(
);
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name(light_array, light_index, "attenuation_props.linear"),
&light.attenuation_params.linear,
);
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name(
light_array,
light_index,
@@ -696,6 +1373,7 @@ fn set_light_attenuation_uniforms(
}
fn set_light_phong_uniforms(
+ current_context: &CurrentContextWithFns<'_>,
gl_shader_program: &mut GlShaderProgram,
light_array: &str,
light_index: usize,
@@ -703,13 +1381,23 @@ fn set_light_phong_uniforms(
)
{
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name(light_array, light_index, "phong.diffuse"),
- &Vec3::from(light.diffuse().clone()),
+ &opengl_bindings::data_types::Vec3 {
+ x: light.diffuse().red,
+ y: light.diffuse().green,
+ z: light.diffuse().blue,
+ },
);
gl_shader_program.set_uniform(
+ current_context,
&create_light_uniform_name(light_array, light_index, "phong.specular"),
- &Vec3::from(light.specular().clone()),
+ &opengl_bindings::data_types::Vec3 {
+ x: light.specular().red,
+ y: light.specular().green,
+ z: light.specular().blue,
+ },
);
}
@@ -797,7 +1485,8 @@ fn opengl_debug_message_cb(
let backtrace = Backtrace::capture();
if matches!(backtrace.status(), BacktraceStatus::Captured) {
- event!(Level::TRACE, "{backtrace}");
+ tracing::error!("{backtrace}");
+ // event!(Level::TRACE, "{backtrace}");
}
}
MessageType::Other => {
@@ -845,3 +1534,54 @@ fn texture_filtering_to_gl(texture_filtering: TextureFiltering) -> GlTextureFilt
TextureFiltering::Nearest => GlTextureFiltering::Nearest,
}
}
+
+impl<Value: ReprC + Copy> From<Vec2<Value>> for opengl_bindings::data_types::Vec2<Value>
+{
+ fn from(vec2: Vec2<Value>) -> Self
+ {
+ Self { x: vec2.x, y: vec2.y }
+ }
+}
+
+impl<Value: ReprC + Copy> From<Vec3<Value>> for opengl_bindings::data_types::Vec3<Value>
+{
+ fn from(vec3: Vec3<Value>) -> Self
+ {
+ Self { x: vec3.x, y: vec3.y, z: vec3.z }
+ }
+}
+
+impl<Value: Copy> From<Dimens<Value>> for opengl_bindings::data_types::Dimens<Value>
+{
+ fn from(dimens: Dimens<Value>) -> Self
+ {
+ Self {
+ width: dimens.width,
+ height: dimens.height,
+ }
+ }
+}
+
+impl From<crate::draw_flags::PolygonMode> for opengl_bindings::misc::PolygonMode
+{
+ fn from(mode: crate::draw_flags::PolygonMode) -> Self
+ {
+ match mode {
+ crate::draw_flags::PolygonMode::Point => Self::Point,
+ crate::draw_flags::PolygonMode::Fill => Self::Fill,
+ crate::draw_flags::PolygonMode::Line => Self::Line,
+ }
+ }
+}
+
+impl From<crate::draw_flags::PolygonModeFace> for opengl_bindings::misc::PolygonModeFace
+{
+ fn from(face: crate::draw_flags::PolygonModeFace) -> Self
+ {
+ match face {
+ crate::draw_flags::PolygonModeFace::Front => Self::Front,
+ crate::draw_flags::PolygonModeFace::Back => Self::Back,
+ crate::draw_flags::PolygonModeFace::FrontAndBack => Self::FrontAndBack,
+ }
+ }
+}
diff --git a/engine/src/renderer/opengl/glutin_compat.rs b/engine/src/renderer/opengl/glutin_compat.rs
new file mode 100644
index 0000000..cfd6ea7
--- /dev/null
+++ b/engine/src/renderer/opengl/glutin_compat.rs
@@ -0,0 +1,268 @@
+// Original file:
+// https://github.com/rust-windowing/glutin/blob/
+// 0433af9018febe0696c485ed9d66c40dad41f2d4/glutin-winit/src/lib.rs
+//
+// Copyright © 2022 Kirill Chibisov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the “Software”), to deal
+// in the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+//! This library provides helpers for cross-platform [`glutin`] bootstrapping
+//! with [`winit`].
+
+#![deny(rust_2018_idioms)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(clippy::all)]
+#![deny(missing_debug_implementations)]
+#![deny(missing_docs)]
+#![cfg_attr(clippy, deny(warnings))]
+
+use glutin::config::{Config, ConfigTemplateBuilder};
+use glutin::display::{Display, DisplayApiPreference};
+use glutin::error::Error as GlutinError;
+#[cfg(x11_platform)]
+use glutin::platform::x11::X11GlConfigExt;
+use glutin::prelude::*;
+use raw_window_handle::{DisplayHandle, RawWindowHandle, WindowHandle};
+
+use crate::windowing::window::CreationAttributes as WindowCreationAttributes;
+
+#[cfg(all(not(egl_backend), not(glx_backend), not(wgl_backend), not(cgl_backend)))]
+compile_error!("Please select at least one api backend");
+
+/// The helper to perform [`Display`] creation and OpenGL platform
+/// bootstrapping with the help of [`winit`] with little to no platform specific
+/// code.
+///
+/// This is only required for the initial setup. If you want to create
+/// additional windows just use the [`finalize_window`] function and the
+/// configuration you've used either for the original window or picked with the
+/// existing [`Display`].
+///
+/// [`winit`]: winit
+/// [`Display`]: glutin::display::Display
+#[derive(Default, Debug, Clone)]
+pub struct DisplayBuilder
+{
+ preference: ApiPreference,
+ window_attributes: WindowCreationAttributes,
+}
+
+impl DisplayBuilder
+{
+ /// Create new display builder.
+ pub fn new() -> Self
+ {
+ Default::default()
+ }
+
+ /// The preference in picking the configuration.
+ #[allow(dead_code)]
+ pub fn with_preference(mut self, preference: ApiPreference) -> Self
+ {
+ self.preference = preference;
+ self
+ }
+
+ /// The window attributes to use when building a window.
+ ///
+ /// By default no window is created.
+ pub fn with_window_attributes(
+ mut self,
+ window_creation_attrs: WindowCreationAttributes,
+ ) -> Self
+ {
+ self.window_attributes = window_creation_attrs;
+ self
+ }
+
+ /// Initialize the OpenGL platform and create a compatible window to use
+ /// with it when the [`WindowAttributes`] was passed with
+ /// [`Self::with_window_attributes()`]. It's optional, since on some
+ /// platforms like `Android` it is not available early on, so you want to
+ /// find configuration and later use it with the [`finalize_window`].
+ /// But if you don't care about such platform you can always pass
+ /// [`WindowAttributes`].
+ ///
+ /// # Api-specific
+ ///
+ /// **WGL:** - [`WindowAttributes`] **must** be passed in
+ /// [`Self::with_window_attributes()`] if modern OpenGL(ES) is desired,
+ /// otherwise only builtin functions like `glClear` will be available.
+ pub fn build<ConfigPickerFn>(
+ self,
+ window_handle: Option<WindowHandle<'_>>,
+ display_handle: &DisplayHandle<'_>,
+ template_builder: ConfigTemplateBuilder,
+ config_picker_fn: ConfigPickerFn,
+ ) -> Result<(WindowCreationAttributes, Config), Error>
+ where
+ ConfigPickerFn: FnOnce(Box<dyn Iterator<Item = Config> + '_>) -> Option<Config>,
+ {
+ // XXX with WGL backend window should be created first.
+ let raw_window_handle = if cfg!(wgl_backend) {
+ let Some(window_handle) = window_handle else {
+ return Err(Error::WindowRequired);
+ };
+
+ Some(window_handle.as_raw())
+ } else {
+ None
+ };
+
+ let gl_display =
+ create_display(display_handle, self.preference, raw_window_handle)
+ .map_err(Error::CreateDisplayFailed)?;
+
+ // XXX the native window must be passed to config picker when WGL is used
+ // otherwise very limited OpenGL features will be supported.
+ #[cfg(wgl_backend)]
+ let template_builder = if let Some(raw_window_handle) = raw_window_handle {
+ template_builder.compatible_with_native_window(raw_window_handle)
+ } else {
+ template_builder
+ };
+
+ let template = template_builder.build();
+
+ // SAFETY: The RawWindowHandle passed on the config template
+ // (when cfg(wgl_backend)) will always point to a valid object since it is
+ // derived from the window_handle argument which when Some is a WindowHandle and
+ // WindowHandles always point to a valid object
+ let gl_configs = unsafe { gl_display.find_configs(template) }
+ .map_err(Error::FindConfigsFailed)?;
+
+ let picked_gl_config =
+ config_picker_fn(gl_configs).ok_or(Error::NoConfigPicked)?;
+
+ #[cfg(not(wgl_backend))]
+ let window_attrs =
+ { finalize_window_creation_attrs(self.window_attributes, &picked_gl_config) };
+
+ #[cfg(wgl_backend)]
+ let window_attrs = self.window_attributes;
+
+ Ok((window_attrs, picked_gl_config))
+ }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error
+{
+ #[error("Failed to create display")]
+ CreateDisplayFailed(#[source] GlutinError),
+
+ #[error("Failed to find configs")]
+ FindConfigsFailed(#[source] GlutinError),
+
+ #[error("No config was picked by config picker function")]
+ NoConfigPicked,
+
+ #[error("Window required for building display on current platform")]
+ WindowRequired,
+}
+
+fn create_display(
+ display_handle: &DisplayHandle<'_>,
+ _api_preference: ApiPreference,
+ _raw_window_handle: Option<RawWindowHandle>,
+) -> Result<Display, GlutinError>
+{
+ #[cfg(egl_backend)]
+ let _preference = DisplayApiPreference::Egl;
+
+ #[cfg(glx_backend)]
+ let _preference = DisplayApiPreference::Glx(Box::new(
+ crate::windowing::window::platform::x11::register_xlib_error_hook,
+ ));
+
+ #[cfg(cgl_backend)]
+ let _preference = DisplayApiPreference::Cgl;
+
+ #[cfg(wgl_backend)]
+ let _preference = DisplayApiPreference::Wgl(_raw_window_handle);
+
+ #[cfg(all(egl_backend, glx_backend))]
+ let _preference = match _api_preference {
+ ApiPreference::PreferEgl => DisplayApiPreference::EglThenGlx(Box::new(
+ crate::windowing::window::platform::x11::register_xlib_error_hook,
+ )),
+ ApiPreference::FallbackEgl => DisplayApiPreference::GlxThenEgl(Box::new(
+ crate::windowing::window::platform::x11::register_xlib_error_hook,
+ )),
+ };
+
+ #[cfg(all(wgl_backend, egl_backend))]
+ let _preference = match _api_preference {
+ ApiPreference::PreferEgl => DisplayApiPreference::EglThenWgl(_raw_window_handle),
+ ApiPreference::FallbackEgl => {
+ DisplayApiPreference::WglThenEgl(_raw_window_handle)
+ }
+ };
+
+ let handle = display_handle.as_raw();
+ unsafe { Ok(Display::new(handle, _preference)?) }
+}
+
+/// Finalize [`Window`] creation by applying the options from the [`Config`], be
+/// aware that it could remove incompatible options from the window builder like
+/// `transparency`, when the provided config doesn't support it.
+///
+/// [`Window`]: winit::window::Window
+/// [`Config`]: glutin::config::Config
+#[cfg(not(wgl_backend))]
+fn finalize_window_creation_attrs(
+ mut attributes: WindowCreationAttributes,
+ gl_config: &Config,
+) -> WindowCreationAttributes
+{
+ // Disable transparency if the end config doesn't support it.
+ if gl_config.supports_transparency() == Some(false) {
+ attributes = attributes.with_transparent(false);
+ }
+
+ #[cfg(x11_platform)]
+ let attributes = if let Some(x11_visual) = gl_config.x11_visual() {
+ attributes.with_x11_visual(x11_visual.visual_id() as _)
+ } else {
+ attributes
+ };
+
+ attributes
+}
+
+/// Simplified version of the [`DisplayApiPreference`] which is used to simplify
+/// cross platform window creation.
+///
+/// To learn about platform differences the [`DisplayApiPreference`] variants.
+///
+/// [`DisplayApiPreference`]: glutin::display::DisplayApiPreference
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum ApiPreference
+{
+ /// Prefer `EGL` over system provider like `GLX` and `WGL`.
+ PreferEgl,
+
+ /// Fallback to `EGL` when failed to create the system profile.
+ ///
+ /// This behavior is used by default. However consider using
+ /// [`Self::PreferEgl`] if you don't care about missing EGL features.
+ #[default]
+ FallbackEgl,
+}
diff --git a/engine/src/renderer/opengl/graphics_mesh.rs b/engine/src/renderer/opengl/graphics_mesh.rs
new file mode 100644
index 0000000..9b929c0
--- /dev/null
+++ b/engine/src/renderer/opengl/graphics_mesh.rs
@@ -0,0 +1,120 @@
+use opengl_bindings::buffer::{Buffer as GlBuffer, Usage as GlBufferUsage};
+use opengl_bindings::vertex_array::{
+ DataType as GlVertexArrayDataType,
+ VertexArray as GlVertexArray,
+};
+use opengl_bindings::CurrentContextWithFns as GlCurrentContextWithFns;
+
+use crate::mesh::Mesh;
+use crate::renderer::opengl::vertex::{
+ AttributeComponentType as VertexAttributeComponentType,
+ Vertex as RendererVertex,
+};
+
+#[derive(Debug)]
+pub struct GraphicsMesh
+{
+ /// Vertex and index buffer has to live as long as the vertex array
+ _vertex_buffer: GlBuffer<RendererVertex>,
+ pub index_buffer: Option<GlBuffer<u32>>,
+ pub element_cnt: u32,
+ pub vertex_arr: GlVertexArray,
+}
+
+impl GraphicsMesh
+{
+ #[tracing::instrument(skip_all)]
+ pub fn new(
+ current_context: &GlCurrentContextWithFns<'_>,
+ mesh: &Mesh,
+ ) -> Result<Self, Error>
+ {
+ tracing::trace!(
+ "Creating vertex array, vertex buffer{}",
+ if mesh.indices().is_some() {
+ " and index buffer"
+ } else {
+ ""
+ }
+ );
+
+ let vertex_arr = GlVertexArray::new(current_context);
+ let vertex_buffer = GlBuffer::new(current_context);
+
+ vertex_buffer
+ .store_mapped(
+ current_context,
+ mesh.vertices(),
+ GlBufferUsage::Static,
+ |vertex| RendererVertex {
+ pos: vertex.pos.into(),
+ texture_coords: vertex.texture_coords.into(),
+ normal: vertex.normal.into(),
+ },
+ )
+ .map_err(Error::StoreVerticesFailed)?;
+
+ vertex_arr.bind_vertex_buffer(current_context, 0, &vertex_buffer, 0);
+
+ let mut offset = 0u32;
+
+ for attrib in RendererVertex::attrs() {
+ vertex_arr.enable_attrib(current_context, attrib.index);
+
+ vertex_arr.set_attrib_format(
+ current_context,
+ attrib.index,
+ match attrib.component_type {
+ VertexAttributeComponentType::Float => GlVertexArrayDataType::Float,
+ },
+ false,
+ offset,
+ );
+
+ vertex_arr.set_attrib_vertex_buf_binding(current_context, attrib.index, 0);
+
+ offset += attrib.component_size * attrib.component_cnt as u32;
+ }
+
+ if let Some(indices) = mesh.indices() {
+ let index_buffer = GlBuffer::new(current_context);
+
+ index_buffer
+ .store(current_context, indices, GlBufferUsage::Static)
+ .map_err(Error::StoreIndicesFailed)?;
+
+ vertex_arr.bind_element_buffer(current_context, &index_buffer);
+
+ return Ok(Self {
+ _vertex_buffer: vertex_buffer,
+ index_buffer: Some(index_buffer),
+ element_cnt: indices
+ .len()
+ .try_into()
+ .expect("Mesh index count does not fit into a 32-bit unsigned int"),
+ vertex_arr,
+ });
+ }
+
+ Ok(Self {
+ _vertex_buffer: vertex_buffer,
+ index_buffer: None,
+ element_cnt: mesh
+ .vertices()
+ .len()
+ .try_into()
+ .expect("Mesh vertex count does not fit into a 32-bit unsigned int"),
+ vertex_arr,
+ })
+ }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error
+{
+ #[error("Failed to store vertices in vertex buffer")]
+ StoreVerticesFailed(#[source] opengl_bindings::buffer::Error),
+
+ #[error("Failed to store indices in index buffer")]
+ StoreIndicesFailed(#[source] opengl_bindings::buffer::Error),
+}
diff --git a/engine/src/renderer/opengl/vertex.rs b/engine/src/renderer/opengl/vertex.rs
index 499b94b..5a1593e 100644
--- a/engine/src/renderer/opengl/vertex.rs
+++ b/engine/src/renderer/opengl/vertex.rs
@@ -1,12 +1,13 @@
-use crate::vector::{Vec2, Vec3};
+use safer_ffi::derive_ReprC;
#[derive(Debug, Clone)]
+#[derive_ReprC]
#[repr(C)]
pub struct Vertex
{
- pub pos: Vec3<f32>,
- pub texture_coords: Vec2<f32>,
- pub normal: Vec3<f32>,
+ pub pos: opengl_bindings::data_types::Vec3<f32>,
+ pub texture_coords: opengl_bindings::data_types::Vec2<f32>,
+ pub normal: opengl_bindings::data_types::Vec3<f32>,
}
impl Vertex
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-10-19 13:21:07 +0000