cosmol-viewer 0.1.1.dev1__tar.gz → 0.1.1.dev2__tar.gz

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/Cargo.lock

@@ -699,7 +699,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer"
-version = "0.1.1-nightly.1"
+version = "0.1.1-nightly.2"
 dependencies = [
  "bytemuck",
  "cosmol_viewer_core",
@@ -717,7 +717,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_core"
-version = "0.1.1-nightly.1"
+version = "0.1.1-nightly.2"
 dependencies = [
  "bytemuck",
  "eframe",
@@ -731,7 +731,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_gui"
-version = "0.1.1-nightly.1"
+version = "0.1.1-nightly.2"
 dependencies = [
  "bytemuck",
  "cosmol_viewer_core",
@@ -765,7 +765,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_wasm"
-version = "0.1.1-nightly.1"
+version = "0.1.1-nightly.2"
 dependencies = [
  "cosmol_viewer_core",
  "eframe",
@@ -3160,7 +3160,7 @@ dependencies = [
 
 [[package]]
 name = "test"
-version = "0.1.1-nightly.1"
+version = "0.1.1-nightly.2"
 dependencies = [
  "cosmol_viewer",
  "cosmol_viewer_core",

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/Cargo.toml

@@ -1,6 +1,6 @@
 [workspace.package]
 edition = "2024"
-version = "0.1.1-nightly.1"
+version = "0.1.1-nightly.2"
 authors = ["9028 wjt@cosmol.org"]
 repository = "https://github.com/COSMol-repl/COSMol-viewer"
 homepage = "https://github.com/COSMol-repl/COSMol-viewer"
@@ -19,3 +19,4 @@ glam = { version = "0.30.3" , features = ["serde"] }
 serde_json = "1.0.140"
 sha2 = "0.10.9"
 hex = "0.4.3"
+ipc-channel = "0.20.0"

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: cosmol-viewer
-Version: 0.1.1.dev1
+Version: 0.1.1.dev2
 Summary: Molecular visualization tools
 Author-email: 95028 <wjt@cosmol.org>

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/crates/core/src/lib.rs

@@ -1,20 +1,18 @@
 mod shader;
 use std::{
-    collections::HashMap,
     sync::{Arc, Mutex},
 };
 
 pub mod utils;
+pub mod parser;
 
 use eframe::egui::{self, Color32, Stroke};
 
-
-use serde::{Deserialize, Serialize};
 use shader::Canvas;
 
 pub use crate::utils::{Shape};
 pub mod shapes;
-use crate::{scene::Scene, shader::CameraState, utils::ToMesh};
+use crate::{scene::Scene};
 
 pub mod scene;
 

cosmol_viewer-0.1.1.dev2/crates/core/src/parser/mod.rs

@@ -0,0 +1,2 @@
+pub mod sdf;
+

cosmol_viewer-0.1.1.dev2/crates/core/src/parser/sdf.rs

@@ -0,0 +1,197 @@
+#[derive(Debug, Clone)]
+pub struct Atom {
+    pub atom: String,
+    pub elem: String,
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub serial: usize,
+    pub index: usize,
+    pub hetflag: bool,
+    pub bonds: Vec<usize>,
+    pub bond_order: Vec<f32>,
+    pub properties: std::collections::HashMap<String, String>,
+}
+
+pub type Molecule = Vec<Atom>;
+pub type MoleculeData  = Vec<Molecule>;
+
+#[derive(Default)]
+pub struct ParserOptions {
+    pub keep_h: bool,
+    pub multimodel: bool,
+    pub onemol: bool,
+}
+
+pub fn parse_sdf(sdf: &str, options: &ParserOptions) -> MoleculeData  {
+    let lines: Vec<&str> = sdf.lines().collect();
+    if lines.len() > 3 && lines[3].len() > 38 {
+        let version = lines[3][34..39].trim();
+        match version {
+            "V3000" => parse_v3000(lines, options),
+            _ => parse_v2000(lines, options),
+        }
+    } else {
+        vec![vec![]]
+    }
+}
+
+fn parse_v2000(mut lines: Vec<&str>, options: &ParserOptions) -> MoleculeData  {
+    let mut molecules = vec![vec![]];
+    let mut current = 0;
+
+    while lines.len() >= 4 {
+        let header = lines[3];
+        let atom_count = header[0..3].trim().parse::<usize>().unwrap_or(0);
+        let bond_count = header[3..6].trim().parse::<usize>().unwrap_or(0);
+
+        if atom_count == 0 || lines.len() < 4 + atom_count + bond_count {
+            break;
+        }
+
+        let mut serial_to_index = vec![None; atom_count];
+        let mut offset = 4;
+        let start = molecules[current].len();
+
+        for i in 0..atom_count {
+            let line = lines[offset + i];
+            let elem = line[31..34].trim();
+            let elem_cap = capitalize(elem);
+            if elem_cap != "H" || options.keep_h {
+                let atom = Atom {
+                    atom: elem_cap.clone(),
+                    elem: elem_cap,
+                    x: line[0..10].trim().parse().unwrap_or(0.0),
+                    y: line[10..20].trim().parse().unwrap_or(0.0),
+                    z: line[20..30].trim().parse().unwrap_or(0.0),
+                    serial: start + i,
+                    index: molecules[current].len(),
+                    hetflag: true,
+                    bonds: vec![],
+                    bond_order: vec![],
+                    properties: std::collections::HashMap::new(),
+                };
+                serial_to_index[i] = Some(molecules[current].len());
+                molecules[current].push(atom);
+            }
+        }
+
+        offset += atom_count;
+
+        for i in 0..bond_count {
+            let line = lines[offset + i];
+            let from = line[0..3].trim().parse::<usize>().unwrap_or(0).saturating_sub(1);
+            let to = line[3..6].trim().parse::<usize>().unwrap_or(0).saturating_sub(1);
+            let order = line[6..].trim().parse::<f32>().unwrap_or(1.0);
+            if let (Some(f), Some(t)) = (serial_to_index.get(from).and_then(|x| *x), serial_to_index.get(to).and_then(|x| *x)) {
+                molecules[current][f].bonds.push(t);
+                molecules[current][f].bond_order.push(order);
+                molecules[current][t].bonds.push(f);
+                molecules[current][t].bond_order.push(order);
+            }
+        }
+
+        let mut next_offset = offset + bond_count;
+        if options.multimodel {
+            if !options.onemol {
+                molecules.push(vec![]);
+                current += 1;
+            }
+            while next_offset < lines.len() && lines[next_offset] != "$$$$" {
+                next_offset += 1;
+            }
+            lines.drain(0..=next_offset);
+        } else {
+            break;
+        }
+    }
+
+    molecules
+}
+
+fn parse_v3000(mut lines: Vec<&str>, options: &ParserOptions) -> MoleculeData  {
+    let mut molecules = vec![vec![]];
+    let mut current = 0;
+
+    while lines.len() >= 8 {
+        if !lines[4].starts_with("M  V30 BEGIN CTAB") || !lines[5].starts_with("M  V30 COUNTS") {
+            break;
+        }
+
+        let counts: Vec<_> = lines[5][13..].split_whitespace().collect();
+        let atom_count = counts.get(0).and_then(|s| s.parse::<usize>().ok()).unwrap_or(0);
+        let bond_count = counts.get(1).and_then(|s| s.parse::<usize>().ok()).unwrap_or(0);
+        let mut offset = 7;
+
+        let mut serial_to_index = vec![None; atom_count];
+        let start = molecules[current].len();
+
+        for i in 0..atom_count {
+            let line = lines[offset + i];
+            let parts: Vec<_> = line[6..].split_whitespace().collect();
+            if parts.len() > 4 {
+                let elem_cap = capitalize(parts[1]);
+                if elem_cap != "H" || options.keep_h {
+                    let atom = Atom {
+                        atom: elem_cap.clone(),
+                        elem: elem_cap,
+                        x: parts[2].parse().unwrap_or(0.0),
+                        y: parts[3].parse().unwrap_or(0.0),
+                        z: parts[4].parse().unwrap_or(0.0),
+                        serial: start + i,
+                        index: molecules[current].len(),
+                        hetflag: true,
+                        bonds: vec![],
+                        bond_order: vec![],
+                        properties: std::collections::HashMap::new(),
+                    };
+                    serial_to_index[i] = Some(molecules[current].len());
+                    molecules[current].push(atom);
+                }
+            }
+        }
+
+        offset += atom_count + 1; // skip "END ATOM"
+        offset += 1; // BEGIN BOND
+
+        for i in 0..bond_count {
+            let line = lines[offset + i];
+            let parts: Vec<_> = line[6..].split_whitespace().collect();
+            if parts.len() > 3 {
+                let from = parts[2].parse::<usize>().unwrap_or(0).saturating_sub(1);
+                let to = parts[3].parse::<usize>().unwrap_or(0).saturating_sub(1);
+                let order = parts[1].parse::<f32>().unwrap_or(1.0);
+                if let (Some(f), Some(t)) = (serial_to_index.get(from).and_then(|x| *x), serial_to_index.get(to).and_then(|x| *x)) {
+                    molecules[current][f].bonds.push(t);
+                    molecules[current][f].bond_order.push(order);
+                    molecules[current][t].bonds.push(f);
+                    molecules[current][t].bond_order.push(order);
+                }
+            }
+        }
+
+        let mut next_offset = offset + bond_count;
+        if options.multimodel {
+            if !options.onemol {
+                molecules.push(vec![]);
+                current += 1;
+            }
+            while next_offset < lines.len() && lines[next_offset] != "$$$$" {
+                next_offset += 1;
+            }
+            lines.drain(0..=next_offset);
+        } else {
+            break;
+        }
+    }
+
+    molecules
+}
+
+fn capitalize(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        Some(first) => first.to_ascii_uppercase().to_string() + &chars.as_str().to_ascii_lowercase(),
+        None => String::new(),
+    }
+}

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/crates/core/src/scene.rs

@@ -11,6 +11,7 @@ pub struct Scene {
     pub camera_state: CameraState,
     pub named_shapes: HashMap<String, Shape>,
     pub unnamed_shapes: Vec<Shape>,
+    pub scale: f32,
 }
 
 impl Scene {
@@ -18,7 +19,7 @@ impl Scene {
         self.named_shapes
             .values()
             .chain(self.unnamed_shapes.iter())
-            .map(|s| s.to_mesh())
+            .map(|s| s.to_mesh(self.scale))
             .collect()
     }
 
@@ -28,9 +29,14 @@ impl Scene {
             camera_state: CameraState::new(1.0),
             named_shapes: HashMap::new(),
             unnamed_shapes: Vec::new(),
+            scale: 1.0,
         }
     }
 
+    pub fn scale(&mut self, scale: f32) {
+        self.scale = scale;
+    }
+
     pub fn add_shape<S: Into<Shape>>(&mut self, shape: S, id: Option<&str>) {
         let shape = shape.into();
         if let Some(id) = id {
@@ -46,7 +52,7 @@ impl Scene {
         }
     }
 
-    pub fn update_shape<S: Into<Shape>>(&mut self, shape: S, id: &str) {
+    pub fn update_shape<S: Into<Shape>>(&mut self, id: &str, shape: S) {
         let shape = shape.into();
         if let Some(existing_shape) = self.named_shapes.get_mut(id) {
             *existing_shape = shape;

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/crates/core/src/shader/canvas.rs

@@ -322,12 +322,6 @@ impl Shader {
     fn paint(&mut self, gl: &glow::Context, aspect_ratio: f32, camera_state: CameraState) {
         use glow::HasContext as _;
 
-        let proj = if aspect_ratio > 1.0 {
-            Mat4::from_scale([1.0 / aspect_ratio, 1.0, 1.0].into())
-        } else {
-            Mat4::from_scale([1.0, aspect_ratio, 1.0].into())
-        };
-
         let camera_position = -camera_state.direction * camera_state.distance;
         let camera_direction = camera_state.direction;
         let camera_up = camera_state.up;
@@ -346,19 +340,19 @@ impl Shader {
         };
 
         unsafe {
+            // 背面剔除 + 深度测试
             gl.enable(glow::CULL_FACE);
             gl.cull_face(glow::BACK);
-            gl.front_face(glow::CCW); // 如果你的三角形是逆时针定义的
+            gl.front_face(glow::CCW);
 
-            gl.enable(glow::DEPTH_TEST); // 开启深度测试
-            gl.depth_func(glow::LEQUAL); // 设置深度测试规则
+            gl.enable(glow::DEPTH_TEST);
+            gl.depth_func(glow::LEQUAL);
 
-            gl.clear(glow::COLOR_BUFFER_BIT | glow::DEPTH_BUFFER_BIT); // 清除颜色和深度
+            gl.clear(glow::COLOR_BUFFER_BIT | glow::DEPTH_BUFFER_BIT);
 
-            // 然后绘制背景（禁用深度），再绘制模型
-            gl.disable(glow::DEPTH_TEST);
+            // === 绘制背景 ===
+            gl.disable(glow::DEPTH_TEST); // ✅ 背景不需要深度
             gl.use_program(Some(self.program_bg));
-
             gl.uniform_3_f32_slice(
                 gl.get_uniform_location(self.program_bg, "background_color")
                     .as_ref(),
@@ -366,19 +360,29 @@ impl Shader {
             );
             gl.draw_arrays(glow::TRIANGLES, 0, 6);
 
-            // 再开启深度测试绘制场景
+            // === 绘制场景 ===
             gl.enable(glow::DEPTH_TEST);
+            // gl.depth_mask(false); // ✅ 关键：恢复写入深度缓冲区
+
+            // gl.enable(glow::BLEND);
+            // gl.blend_func_separate(
+            //     glow::ONE,
+            //     glow::ONE, // 颜色：累加所有透明颜色
+            //     glow::ZERO,
+            //     glow::ONE_MINUS_SRC_ALPHA, // alpha：按透明度混合
+            // );
+
             gl.use_program(Some(self.program));
 
             gl.uniform_matrix_4_f32_slice(
                 gl.get_uniform_location(self.program, "u_mvp").as_ref(),
                 false,
-                (proj * camera.view_proj()).as_ref(),
+                (camera.view_proj(aspect_ratio)).as_ref(),
             );
             gl.uniform_matrix_4_f32_slice(
                 gl.get_uniform_location(self.program, "u_model").as_ref(),
                 false,
-                (camera.u_model()).as_ref(),
+                (camera.view_matrix()).as_ref(),
             );
             gl.uniform_matrix_3_f32_slice(
                 gl.get_uniform_location(self.program, "u_normal_matrix")
@@ -396,7 +400,7 @@ impl Shader {
             );
 
             // 应用模型变换
-            let transformed_pos = camera.u_model() * light_pos_homogeneous;
+            let transformed_pos = camera.view_matrix() * light_pos_homogeneous;
 
             // 提取前三个分量 (xyz)
             let transformed_pos_xyz = [transformed_pos.x, transformed_pos.y, transformed_pos.z];
@@ -416,7 +420,7 @@ impl Shader {
             );
 
             // 应用模型变换
-            let transformed_camera_pos = camera.u_model() * camera_pos_homogeneous;
+            let transformed_camera_pos = camera.view_matrix() * camera_pos_homogeneous;
 
             // 提取前三个分量 (xyz)
             let transformed_camera_pos_xyz = [
@@ -446,7 +450,7 @@ impl Shader {
                 self.dirty = false;
             }
 
-            // 初始化时或每帧渲染前
+            // 绑定并上传缓冲
             gl.bind_vertex_array(Some(self.vertex_array));
             gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vbo));
             gl.buffer_data_u8_slice(
@@ -456,7 +460,6 @@ impl Shader {
             );
 
             gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.element_array_buffer));
-
             gl.buffer_data_u8_slice(
                 glow::ELEMENT_ARRAY_BUFFER,
                 bytemuck::cast_slice(&self.indices),
@@ -536,6 +539,7 @@ pub struct Camera {
 }
 
 impl Camera {
+    /// 假定模型空间 == 世界空间
     pub fn new(position: [f32; 3], forward: [f32; 3], up: [f32; 3], fov: f32, scale: f32) -> Self {
         let z = Vec3::from(forward).normalize();
         let up = Vec3::from(up);
@@ -548,45 +552,44 @@ impl Camera {
             x: x.into(),
             y: y.into(),
             fov,
-            scale: scale,
+            scale,
         }
     }
 
-    pub fn u_model(&self) -> Mat4 {
-        let (x, y, z, pos) = (self.x, self.y, self.z, self.position);
-
-        let shear = Mat4::from_cols_array_2d(&[
-            [x[0], x[1], x[2], 0.0],
-            [y[0], y[1], y[2], 0.0],
-            [z[0], z[1], z[2], 0.0],
-            [0.0, 0.0, 0.0, 1.0],
-        ])
-        .transpose();
-
-        let translate = Mat4::from_translation(-Vec3::from(pos));
+    /// 从世界空间变换到相机空间
+    pub fn view_matrix(&self) -> Mat4 {
+        let pos = Vec3::from(self.position);
+        let center = pos + Vec3::from(self.z);
+        let up = Vec3::from(self.y);
 
-        return shear * translate;
+        Mat4::look_at_rh(pos, center, up)
     }
 
-    pub fn view_proj(&self) -> Mat4 {
-        let proj = Mat4::from_cols_array_2d(&[
-            [1.0, 0.0, 0.0, 0.0],
-            [0.0, 1.0, 0.0, 0.0],
-            [0.0, 0.0, 1.0, 0.0],
-            [0.0, 0.0, self.scale, 1.0],
-        ])
-        .transpose();
+    /// 把 3D 场景投影成 2D 的视图
+    pub fn projection_matrix(&self, aspect: f32) -> Mat4 {
+        // 如果用 scale 控制的是放大倍率，可以解释为正交投影的比例因子
+        let s = self.scale;
+
+        // 你可以换成 perspective_rh(self.fov, aspect, near, far)
+        Mat4::orthographic_rh(
+            -s * aspect, s * aspect, // left, right
+            -s, s,                   // bottom, top
+            -1000.0, 1000.0          // near, far
+        )
+    }
 
-        return proj * self.u_model();
+    /// 相机变换矩阵 = 投影 × 视图变换
+    pub fn view_proj(&self, aspect: f32) -> Mat4 {
+        self.projection_matrix(aspect) * self.view_matrix()
     }
 
+    /// 法线矩阵：模型矩阵的 3x3 的逆转置
     pub fn normal_matrix(&self) -> Mat3 {
-        let model = self.u_model(); // Mat4
-        let mat3 = Mat3::from_mat4(model); // Extract the upper-left 3x3 matrix
-        mat3.inverse().transpose()
+        Mat3::from_mat4(self.view_matrix()).inverse().transpose()
     }
 }
 
+
 pub struct Light {
     pub position: [f32; 3],
     pub color: [f32; 3],

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/crates/core/src/shader/fragment.glsl

@@ -16,15 +16,13 @@ void main() {
     vec3 view_dir = normalize(u_view_pos - v_frag_pos);        // 计算从片元到相机的方向
     vec3 halfway_dir = normalize(light_dir + view_dir);        // halfway 向量用于 Blinn-Phong 高光
 
-    float diff = max(dot(normal, light_dir), 0.0);             // 漫反射项（Lambert）
+    float diff = max(dot(normal, light_dir), 0.0);              // 漫反射项（Lambert）
     float spec = pow(max(dot(normal, halfway_dir), 0.0), 32.0); // 高光项，32 是 shininess 参数
 
     vec3 ambient = 0.3 * u_light_color;                         // 环境光，固定系数0.2
     vec3 diffuse = diff * u_light_color;                        // 漫反射
-    // vec3 specular = spec * u_light_color;                       // 高光
 
-    vec3 light = (ambient + diffuse) * u_light_intensity; // 叠加光照并乘以强度
-    // vec3 light = (ambient + diffuse + specular) * u_light_intensity; // 叠加光照并乘以强度
+    vec3 light = (ambient + diffuse) * u_light_intensity;       // 叠加光照并乘以强度
 
     FragColor = vec4(v_color.rgb * light, v_color.a);
 }

{cosmol_viewer-0.1.1.dev1 → cosmol_viewer-0.1.1.dev2}/crates/core/src/shader/vertex.glsl

@@ -15,7 +15,7 @@ out vec4 v_color;
 void main() {
     vec4 world_pos = u_model * vec4(a_position, 1.0);
     v_frag_pos = world_pos.xyz;
-    v_normal = -normalize(u_normal_matrix * a_normal);
+    v_normal = normalize(u_normal_matrix * a_normal);
     v_color = a_color;
     gl_Position = u_mvp * vec4(a_position, 1.0);
 }

cosmol_viewer-0.1.1.dev2/crates/core/src/shapes/mod.rs

@@ -0,0 +1,3 @@
+pub mod sphere;
+pub mod stick;
+pub mod molecules;