tsuki/radar-gi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sync

Browse Source
This commit is contained in:
tsuki 2024-07-10 23:48:28 +08:00
parent 8721daed30
commit 2fcff3c6d9
7 changed files with 193 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/components/program.rs
View File

@ -53,34 +53,39 @@ impl Program {
self.set_hook("viewport", viewport.snippet());
}
pub fn compile(&mut self, gl: &glow::Context) {
pub fn compile(&mut self, gl: &glow::Context) -> crate::errors::Result<()> {
use crate::errors::Error;
unsafe {
let vertex_array = gl
.create_vertex_array()
.expect("Cannot create vertex array");
// let vertex_array = gl
// .create_vertex_array()
// .expect("Cannot create vertex array");
let program = gl.create_program().expect("Cannot create program");
let program = gl.create_program().map_err(|e| Error::InvalidProgram(e))?;
let vertex_shader =
self.create_shader(gl, &self.vertex.to_string(), glow::VERTEX_SHADER);
self.create_shader(gl, &self.vertex.to_string(),self.version, glow::VERTEX_SHADER);
let fragment_shader =
self.create_shader(gl, &self.fragment.to_string(), glow::FRAGMENT_SHADER);
self.create_shader(gl, &self.fragment.to_string(),self.version, glow::FRAGMENT_SHADER);
gl.link_program(program);
if !gl.get_program_link_status(program) {
panic!("{}", gl.get_program_info_log(program));
return Err(Error::InvalidProgram(gl.get_program_info_log(program)));
}
gl.detach_shader(program, vertex_shader);
gl.detach_shader(program, fragment_shader);
self.native_program = Some(program);
}
Ok(())
}
fn create_shader(
&self,
gl: &glow::Context,
code: &str,
version: &'static str,
shader_type: u32,
) -> <glow::Context as HasContext>::Shader {
let shader = unsafe {

17
src/components/shader.rs
View File

@ -27,7 +27,7 @@ impl std::fmt::Display for Shader {
impl Shader {
pub fn new<S: Borrow<str>>(target: ShaderType, code: CodeType<S>) -> Result<Self> {
let code = match code {
let mut code = match code {
CodeType::Code(code) => code.borrow().to_string(),
CodeType::Path(path) => {
let code = find_file(path).expect("Failed to find file");
@ -35,6 +35,21 @@ impl Shader {
}
};
match target {
glow::VERTEX_SHADER => {
code.insert_str(0, "#define _GLUMPY__VERTEX_SHADER__\n");
}
glow::FRAGMENT_SHADER => {
code.insert_str(0, "#define _GLUMPY__FRAGMENT_SHADER__\n");
}
_ => {
warn!("Unknown shader type: {}", target);
}
}
let code = merge_includes(code).map_err(|e| Error::InvalidSnippet(e.to_string()))?;
let parsed = CodeBlock::new(&code)?;

6
src/errors.rs
View File

@ -6,4 +6,10 @@ pub type Result<T> = std::result::Result<T, Error>;
pub enum Error {
#[error("Invalid Snippet {0}")]
InvalidSnippet(String),
#[error("Invalid Shader {0}")]
InvalidShader(String),
#[error("Invalid Program {0}")]
InvalidProgram(String),
}

22
src/graphics/collections/agg_fast_path.rs
View File

@ -11,7 +11,7 @@ use crate::graphics::Graphics;
use super::Colletion;
struct AggFastPath {
pub struct AggFastPath {
program: Program,
buffer: Vec<Point>,
}
@ -35,21 +35,23 @@ impl AggFastPath {
uniform float linewidth;
unifrom float antialias;
uniform float antialias;
uniform vec4 color;
") ,false, None)?;
print!("{}", input_snippet);
let vertex = vertex.add_snippet_before(input_snippet);
let vertex = vertex.add_snippet_before(input_snippet + fetchcode([], "agg_fast"));
let mut program = Program::new(vertex, fragment, None, "");
let mut program = Program::new(vertex, fragment, None, "330 core");
program.set_transform(transform);
program.set_viewport(viewport);
println!("{}", program.vertex());
println!("{}", program.fragment());
Ok(Self {
program,
buffer: Vec::with_capacity(128),
@ -66,6 +68,12 @@ impl Colletion for AggFastPath {
}
impl Graphics for AggFastPath {
fn compile(&mut self, gl: &glow::Context) -> Result<()> {
self.program.compile(gl)
}
fn draw(&self) -> Result<()> {
use bytemuck::cast_slice;
@ -251,7 +259,5 @@ mod test {
let agg_path = AggFastPath::new(&transform, &viewport).unwrap();
}
}

2
src/graphics/mod.rs
View File

@ -9,4 +9,6 @@ pub use colormesh::ColorMesh;
pub trait Graphics {
fn draw(&self) -> Result<()>;
fn compile(&mut self, gl: &glow::Context) -> Result<()>;
}

70
src/support/supporter.rs
View File

@ -1,5 +1,16 @@
use crate::utils::Triangler;
use nalgebra_glm::perspective;
use crate::camera::Camera;
use crate::graphics::Graphics;
use crate::{
graphics::{
collections::agg_fast_path::AggFastPath,
transforms::{
polar::Polar, position::Position, trackball::Trackball, viewport::Viewport, Transform,
},
},
utils::Triangler,
};
use cgmath::InnerSpace;
use glow::HasContext;
use glutin::{
config::ConfigTemplateBuilder,
context::{ContextAttributesBuilder, NotCurrentGlContext, PossiblyCurrentContext},
@ -7,18 +18,19 @@ use glutin::{
surface::{GlSurface, Surface, SurfaceAttributesBuilder, WindowSurface},
};
use imgui::Ui;
use imgui_winit_support::{HiDpiMode, winit::{
use imgui_winit_support::{
winit::{
dpi::{LogicalSize, PhysicalPosition},
event_loop::EventLoop,
window::{Window, WindowBuilder},
}, WinitPlatform};
},
HiDpiMode, WinitPlatform,
};
use nalgebra_glm::perspective;
use nalgebra_glm::Vec3;
use raw_window_handle::HasRawWindowHandle;
use std::num::NonZeroU32;
use std::time::Instant;
use cgmath::InnerSpace;
use glow::HasContext;
use nalgebra_glm::Vec3;
use crate::camera::Camera;
pub fn init<FUi>(mut run_ui: FUi)
where
@ -28,7 +40,6 @@ where
let (mut winit_platform, mut imgui_context) = imgui_init(&window);
{
let dpi_mode = if let Ok(factor) = std::env::var("IMGUI_EXAMPLE_FORCE_DPI_FACTOR") {
// Allow forcing of HiDPI factor for debugging purposes
match factor.parse::<f64>() {
@ -55,6 +66,18 @@ where
let mut last_frame = Instant::now();
let tri_renderer = Triangler::new(ig_renderer.gl_context(), "#version 330");
let viewport = Trackball::new().unwrap();
let trans = Polar::new().unwrap();
let position = Position::new().unwrap();
let transform = viewport.chain(trans.chain(position));
let viewport = Viewport::new().unwrap();
let mut agg_path = AggFastPath::new(&transform, &viewport).unwrap();
agg_path.compile(ig_renderer.gl_context()).unwrap();
let program = tri_renderer.program();
let mut camera = Camera::new(
Vec3::new(0.5, 0.5, 1.0), // Camera position (world location
@ -97,7 +120,8 @@ where
let loc = gl.get_uniform_location(program, "projection");
let size = window.inner_size();
let projection = perspective(size.width as f32 / size.height as f32, 45.0, 0.1, 100.0);
let projection =
perspective(size.width as f32 / size.height as f32, 45.0, 0.1, 100.0);
gl.uniform_matrix_4_f32_slice(loc.as_ref(), false, projection.as_slice());
let loc = gl.get_uniform_location(program, "view");
@ -112,7 +136,14 @@ where
if ui.is_mouse_pos_valid(ui.io().mouse_pos) {
let mouse_pos = ui.io().mouse_pos;
if ui.is_mouse_dragging(imgui::MouseButton::Right) {
mouse_callback(&mut last_position, PhysicalPosition::new(mouse_pos[0] as f64, mouse_pos[1] as f64), 0.05, &mut pitch, &mut yaw, &mut camera);
mouse_callback(
&mut last_position,
PhysicalPosition::new(mouse_pos[0] as f64, mouse_pos[1] as f64),
0.05,
&mut pitch,
&mut yaw,
&mut camera,
);
}
}
@ -166,8 +197,15 @@ where
.unwrap()
}
fn mouse_callback(last_position: &mut Option<PhysicalPosition<f64>>, current_position:PhysicalPosition<f64>, sensitivity: f64, pitch: &mut f64, yaw: &mut f64, camera: &mut Camera) {
use cgmath::{Euler, Deg, Quaternion};
fn mouse_callback(
last_position: &mut Option<PhysicalPosition<f64>>,
current_position: PhysicalPosition<f64>,
sensitivity: f64,
pitch: &mut f64,
yaw: &mut f64,
camera: &mut Camera,
) {
use cgmath::{Deg, Euler, Quaternion};
let xpos = current_position.x;
let ypos = current_position.y;
@ -197,11 +235,7 @@ fn mouse_callback(last_position: &mut Option<PhysicalPosition<f64>>, current_pos
*pitch = -89.0;
}
let euler_deg = Euler::new(
Deg(*pitch),
Deg(*yaw),
Deg(0.0),
);
let euler_deg = Euler::new(Deg(*pitch), Deg(*yaw), Deg(0.0));
let c = Quaternion::from(euler_deg).normalize();

85
src/utils/parser.rs
View File

@ -137,7 +137,7 @@ fn include(input: &str) -> IResult<&str, Include> {
))
}
#[derive(Debug, Clone)]
#[derive(Debug, Clone, PartialEq)]
pub enum Modifier {
Const,
Static,
@ -1282,6 +1282,83 @@ impl CodeBlock {
pub fn mangling<S: AsRef<str>>(&mut self, suffix: S) -> HashMap<String, String> {
let mut map = HashMap::new();
fn _expression_mangling(exp: &mut Expression, map: &HashMap<String, String>) {
match exp {
Expression::Variable(v) => {
if let Some(new) = map.get(v) {
*v = new.clone();
}
}
Expression::FunctionCall { parameters, .. } => {
for para in parameters.iter_mut() {
_expression_mangling(para, map);
}
}
Expression::Assignment { left, right } => {
_expression_mangling(left, map);
_expression_mangling(right, map);
}
Expression::StructMemberAccess { base, .. } => {
_expression_mangling(base, map);
}
Expression::StructPointerAccess { base, .. } => {
_expression_mangling(base, map);
}
_ => {}
}
}
fn _mangling_block(block: &mut Statement, map: &HashMap<String, String>) {
if let Statement::Block(b) = block {
for statement in b.iter_mut() {
match statement.as_mut() {
Statement::DoWhile { condition, .. } => {
_expression_mangling(condition, map);
}
Statement::Expression(e) => {
_expression_mangling(e, map);
}
Statement::If { condition, block } => {
_expression_mangling(condition, map);
_mangling_block(block, map);
}
Statement::While { condition, block } => {
_expression_mangling(condition, map);
_mangling_block(block, map);
}
Statement::For { condition, block } => {
_expression_mangling(condition, map);
_mangling_block(block, map);
}
Statement::Declaration { value, .. } => {
if let Some(v) = value {
_expression_mangling(v, map);
}
}
Statement::Return(v) => {
if let Some(v) = v {
_expression_mangling(v, map);
}
}
_ => {}
}
}
}
}
fn _mangling(codes: &mut Vec<Code>, suffix: &str, map: &mut HashMap<String, String>) {
for code in codes.iter_mut() {
match code {
@ -1291,8 +1368,14 @@ impl CodeBlock {
v.borrow_mut().name = new_name.clone();
map.insert(raw_name, new_name);
_mangling_block(&mut v.borrow_mut().body, map);
}
Code::ShareVariable(v) => {
if v.borrow().modif.contains(&Modifier::Const) {
return;
}
let raw_name = v.borrow().name.clone();
let new_name = format!("{}_{}", raw_name, suffix);