cosmol-viewer 0.1.1.dev3__tar.gz → 0.1.1.dev5__tar.gz

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/Cargo.lock

@@ -699,7 +699,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer"
-version = "0.1.1-nightly.3"
+version = "0.1.1-nightly.5"
 dependencies = [
  "bytemuck",
  "cosmol_viewer_core",
@@ -717,21 +717,23 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_core"
-version = "0.1.1-nightly.3"
+version = "0.1.1-nightly.5"
 dependencies = [
  "bytemuck",
  "eframe",
  "egui_extras",
  "glam",
+ "once_cell",
  "serde",
  "serde_json",
+ "serde_repr",
  "wasm-bindgen-futures",
  "web-sys",
 ]
 
 [[package]]
 name = "cosmol_viewer_gui"
-version = "0.1.1-nightly.3"
+version = "0.1.1-nightly.5"
 dependencies = [
  "bytemuck",
  "cosmol_viewer_core",
@@ -765,7 +767,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_wasm"
-version = "0.1.1-nightly.3"
+version = "0.1.1-nightly.5"
 dependencies = [
  "cosmol_viewer_core",
  "eframe",
@@ -3160,7 +3162,7 @@ dependencies = [
 
 [[package]]
 name = "test"
-version = "0.1.1-nightly.3"
+version = "0.1.1-nightly.5"
 dependencies = [
  "cosmol_viewer",
  "cosmol_viewer_core",

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/Cargo.toml

@@ -1,6 +1,6 @@
 [workspace.package]
 edition = "2024"
-version = "0.1.1-nightly.3"
+version = "0.1.1-nightly.5"
 authors = ["9028 wjt@cosmol.org"]
 repository = "https://github.com/COSMol-repl/COSMol-viewer"
 homepage = "https://github.com/COSMol-repl/COSMol-viewer"

cosmol_viewer-0.1.1.dev5/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: cosmol-viewer
+Version: 0.1.1.dev5
+Summary: Molecular visualization tools
+Author-email: 95028 <wjt@cosmol.org>
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/COSMol-repl/COSMol-viewer
+
+# COSMol-viewer
+
+A high-performance molecular visualization library built with Rust and WebGPU, designed for seamless integration into Python workflows.
+
+- ⚡ Fast: Native-speed rendering powered by Rust and GPU acceleration
+
+- 🧬 Flexible: Load molecules from .sdf, .pdb, and dynamically update 3D structures
+
+- 📓 Notebook-friendly: Fully supports Jupyter and Google Colab — ideal for education, research, and live demos
+
+- 🔁 Real-time updates: Update molecular coordinates on-the-fly for simulations or animations
+
+- 🎨 Customizable: Control styles, camera, and rendering settings programmatically
+
+# Installation
+
+```sh
+pip install cosmol-viewer==0.1.1.dev5
+```
+
+# Usage
+
+```python
+from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
+
+# === Step 1: Load and render a molecule ===
+with open("molecule.sdf", "r") as f:
+    sdf = f.read()
+    mol = Molecules(parse_sdf(sdf)).centered()
+
+scene = Scene()
+scene.scale(0.1)
+scene.add_shape(mol, "mol")
+
+viewer = Viewer.render(scene)  # Launch the viewer
+
+# === Step 2: Update the same molecule dynamically ===
+import time
+
+for i in range(1, 10):  # Simulate multiple frames
+    with open(f"frames/frame_{i}.sdf", "r") as f:
+        sdf = f.read()
+        updated_mol = Molecules(parse_sdf(sdf)).centered()
+
+    scene.update_shape("mol", updated_mol)
+    viewer.update(scene)
+
+    time.sleep(0.033)  # ~30 FPS
+```

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/core/Cargo.toml

@@ -12,4 +12,6 @@ egui_extras.workspace = true
 serde = { version = "1.0.219" , features = ["derive"] }
 bytemuck = "1.23.1"
 web-sys = "0.3.77"
+serde_repr = "0.1"
 wasm-bindgen-futures = "0.4.50"
+once_cell = "1.21.3"

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/core/src/shader/canvas.rs

@@ -39,7 +39,6 @@ impl Canvas {
         // 正值表示向上滚动，通常是“缩小”，负值是放大
         if scroll_delta != 0.0 {
             self.camera_state.scale *= (1.0 + scroll_delta * 0.001).clamp(0.1, 10.0);
-            println!("scale {:?}", self.camera_state.scale);
         }
 
         self.camera_state = rotate_camera(self.camera_state, response.drag_motion());
@@ -289,15 +288,13 @@ impl Shader {
         for mesh in scene_data._get_meshes() {
             self.vertex3d
                 .extend(mesh.vertices.iter().enumerate().map(|(i, pos)| {
-                    let mut j = i;
-                    j = i % 50;
                     Vertex3d {
                         position: *pos,
                         normal: mesh.normals[i],
                         color: mesh
                             .colors
                             .as_ref()
-                            .and_then(|colors| colors.get(j))
+                            .and_then(|colors| colors.get(i))
                             .unwrap_or(&[1.0, 1.0, 1.0, 1.0])
                             .clone(),
                     }
@@ -311,14 +308,6 @@ impl Shader {
         self.dirty = true;
     }
 
-    fn destroy(&self, gl: &glow::Context) {
-        // use glow::HasContext as _;
-        // unsafe {
-        //     gl.delete_program(self.program);
-        //     gl.delete_vertex_array(self.vertex_array);
-        // }
-    }
-
     fn paint(&mut self, gl: &glow::Context, aspect_ratio: f32, camera_state: CameraState) {
         use glow::HasContext as _;
 
@@ -336,7 +325,7 @@ impl Shader {
         let light = Light {
             position: [2.0, -3.0, 2.0],
             color: [1.0, 0.9, 0.9],
-            intensity: 0.7,
+            intensity: 1.0,
         };
 
         unsafe {
@@ -362,7 +351,7 @@ impl Shader {
 
             // === 绘制场景 ===
             gl.enable(glow::DEPTH_TEST);
-            // gl.depth_mask(false); // ✅ 关键：恢复写入深度缓冲区
+            gl.depth_mask(true); // ✅ 关键：恢复写入深度缓冲区
 
             // gl.enable(glow::BLEND);
             // gl.blend_func_separate(
@@ -437,7 +426,7 @@ impl Shader {
             gl.uniform_3_f32_slice(
                 gl.get_uniform_location(self.program, "u_light_color")
                     .as_ref(),
-                (light.color).as_ref(),
+                (light.color.map(|x| x * light.intensity)).as_ref(),
             );
 
             gl.uniform_1_f32(
@@ -497,34 +486,37 @@ impl CameraState {
 
 pub fn rotate_camera(mut camera_state: CameraState, drag_motion: Vec2) -> CameraState {
     let sensitivity = 0.005;
-    let yaw = drag_motion.x * sensitivity;
-    let pitch = drag_motion.y * sensitivity;
+    let yaw = -drag_motion.x * sensitivity;    // 水平拖动 → 绕 up 旋转
+    let pitch = -drag_motion.y * sensitivity;  // 垂直拖动 → 绕 right 旋转
 
-    // 计算右向量
-    let right = camera_state.direction.cross(camera_state.up).normalize();
+    // 当前方向
+    let dir = camera_state.direction;
 
-    // 计算绕 Y 的旋转（水平拖动）
-    let yaw_quat = Quat::from_axis_angle(Vec3::Y, yaw);
+    // right = 当前方向 × 当前 up
+    let right = dir.cross(camera_state.up).normalize();
 
-    // 计算绕右轴的旋转（垂直拖动）
-    let pitch_quat = Quat::from_axis_angle(right, -pitch);
+    // 1. pitch：绕当前 right 轴旋转（垂直）
+    let pitch_quat = Quat::from_axis_angle(right, pitch);
+    let rotated_dir = pitch_quat * dir;
+    let rotated_up = pitch_quat * camera_state.up;
 
-    // 最终方向 = 原方向应用 pitch，然后再应用 yaw
-    let new_direction = yaw_quat * pitch_quat * camera_state.direction;
-    camera_state.direction = new_direction.normalize();
+    // 2. yaw：绕当前“视角 up”旋转（水平）
+    let yaw_quat = Quat::from_axis_angle(rotated_up, yaw);
+    let final_dir = yaw_quat * rotated_dir;
 
-    // 更新 up 向量（可选，视需求而定）
-    camera_state.up = yaw_quat * pitch_quat * camera_state.up;
+    camera_state.direction = final_dir.normalize();
+    camera_state.up = (yaw_quat * rotated_up).normalize();
 
-    return camera_state;
+    camera_state
 }
 
+
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable, Debug, Serialize, Deserialize)]
 pub struct Vertex3d {
     pub position: [f32; 3],
     pub normal: [f32; 3],
-    pub color: [f32; 4], // 可选颜色属性
+    pub color: [f32; 4],
 }
 
 #[repr(C)]

cosmol_viewer-0.1.1.dev5/crates/core/src/shader/fragment.glsl

@@ -0,0 +1,34 @@
+precision mediump float;
+
+uniform vec3 u_light_pos;
+uniform vec3 u_light_color;
+uniform vec3 u_view_pos;
+uniform float u_light_intensity;
+
+in vec3 v_normal;
+in vec4 v_color;
+in vec3 v_frag_pos;
+
+out vec4 FragColor;
+
+void main() {
+    vec3 normal = normalize(v_normal);
+    vec3 light_dir = normalize(u_light_pos - v_frag_pos);
+    vec3 view_dir = normalize(u_view_pos - v_frag_pos);
+
+    // === 环境光 ===
+    vec3 ambient = 0.7 * u_light_color;
+
+    // === 漫反射 ===
+    float diff = max(dot(normal, light_dir), 0.0);
+    vec3 diffuse = 0.5 * diff * u_light_color;
+
+    // === 高光 ===
+    vec3 halfway_dir = normalize(light_dir + view_dir); // Blinn 模型
+    float spec = pow(max(dot(normal, halfway_dir), 0.0), 64.0); // shininess 可调
+    vec3 specular = 0.3 * spec * u_light_color; // 强度可调
+
+    // === 最终颜色 ===
+    vec3 lighting = (ambient + diffuse) * v_color.rgb + specular;
+    FragColor = vec4(lighting * u_light_intensity, v_color.a);
+}

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/core/src/shapes/molecules.rs

@@ -1,10 +1,9 @@
-use glam::Mat3;
 use serde::{Deserialize, Serialize};
+use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::{
     Shape,
     parser::sdf::MoleculeData,
-    scene::Scene,
     shapes::{sphere::Sphere, stick::Stick},
     utils::{Interaction, MeshData, VisualShape, VisualStyle},
 };
@@ -50,7 +49,7 @@ impl AtomType {
     pub fn color(&self) -> [f32; 3] {
         match self {
             AtomType::H => [1.0, 1.0, 1.0],       // 白色
-            AtomType::C => [0.2, 0.2, 0.2],       // 深灰
+            AtomType::C => [0.3, 0.3, 0.3],       // 深灰
             AtomType::N => [0.0, 0.0, 1.0],       // 蓝色
             AtomType::O => [1.0, 0.0, 0.0],       // 红色
             AtomType::F => [0.0, 0.8, 0.0],       // 绿
@@ -80,12 +79,13 @@ impl AtomType {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize_repr, Deserialize_repr)]
+#[repr(u8)]
 pub enum BondType {
-    SINGLE,
-    DOUBLE,
-    TRIPLE,
-    AROMATIC,
+    SINGLE = 1,
+    DOUBLE = 2,
+    TRIPLE = 3,
+    AROMATIC = 0,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -210,10 +210,7 @@ impl Molecules {
             let radius = self.atom_types.get(i).unwrap_or(&AtomType::Unknown).radius() * 0.2;
             let color = self.atom_types.get(i).unwrap_or(&AtomType::Unknown).color();
 
-            println!("atom: {}, color: {:?}, radius: {}", i, color, radius);
-
             let mut sphere = Sphere::new(*pos, radius);
-            sphere.style = self.style; // 继承样式
             sphere.interaction = self.interaction;
             sphere = sphere.color(color);
 
@@ -226,7 +223,7 @@ impl Molecules {
             for n in mesh.normals {
                 normals.push(n.map(|x| x * scale));
             }
-            for c in mesh.colors.unwrap_or_default() {
+            for c in mesh.colors.unwrap() {
                 colors.push(c);
             }
             for idx in mesh.indices {
@@ -243,8 +240,8 @@ impl Molecules {
             let pos_b = self.atoms[b as usize];
 
             let mut stick = Stick::new(pos_a, pos_b, 0.1); // or radius by bond type
-            stick.style = self.style;
             stick.interaction = self.interaction;
+            stick = stick.color([0.7, 0.7, 0.7]);
 
             let mesh = stick.to_mesh(1.0);
 
@@ -254,7 +251,7 @@ impl Molecules {
             for n in mesh.normals {
                 normals.push(n.map(|x| x * scale));
             }
-            for c in mesh.colors.unwrap_or_default() {
+            for c in mesh.colors.unwrap() {
                 colors.push(c);
             }
             for idx in mesh.indices {

cosmol_viewer-0.1.1.dev5/crates/core/src/shapes/sphere.rs

@@ -0,0 +1,246 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{scene::Scene, utils::{Interaction, MeshData, VisualShape, VisualStyle}, Shape};
+
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+#[derive(Clone)]
+struct SphereTemplate {
+    vertices: Vec<[f32; 3]>,
+    normals: Vec<[f32; 3]>,
+    indices: Vec<u32>,
+}
+
+static SPHERE_TEMPLATE_CACHE: Lazy<Mutex<HashMap<u32, SphereTemplate>>> = Lazy::new(|| {
+    Mutex::new(HashMap::new())
+});
+
+fn get_or_generate_template(quality: u32) -> SphereTemplate {
+    let mut cache = SPHERE_TEMPLATE_CACHE.lock().unwrap();
+
+    if let Some(template) = cache.get(&quality) {
+        return template.clone(); // 直接返回已有的
+    }
+
+    let lat_segments = 10 * quality;
+    let lon_segments = 20 * quality;
+
+    let mut vertices = Vec::new();
+    let mut normals = Vec::new();
+    let mut indices = Vec::new();
+
+    for i in 0..=lat_segments {
+        let theta = std::f32::consts::PI * (i as f32) / (lat_segments as f32);
+        let sin_theta = theta.sin();
+        let cos_theta = theta.cos();
+
+        for j in 0..=lon_segments {
+            let phi = 2.0 * std::f32::consts::PI * (j as f32) / (lon_segments as f32);
+            let sin_phi = phi.sin();
+            let cos_phi = phi.cos();
+
+            let nx = sin_theta * cos_phi;
+            let ny = cos_theta;
+            let nz = sin_theta * sin_phi;
+
+            vertices.push([nx, ny, nz]); // 单位球
+            normals.push([nx, ny, nz]);
+        }
+    }
+
+    for i in 0..lat_segments {
+        for j in 0..lon_segments {
+            let first = i * (lon_segments + 1) + j;
+            let second = first + lon_segments + 1;
+
+            indices.push(first);
+            indices.push(first + 1);
+            indices.push(second);
+
+            indices.push(second);
+            indices.push(first + 1);
+            indices.push(second + 1);
+        }
+    }
+
+    let template = SphereTemplate {
+        vertices,
+        normals,
+        indices,
+    };
+
+    cache.insert(quality, template.clone());
+
+    template
+}
+
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
+pub struct Sphere {
+    pub center: [f32; 3],
+    pub radius: f32,
+    pub quality: u32,
+
+    pub style: VisualStyle,
+    pub interaction: Interaction,
+}
+
+impl Into<Shape> for Sphere {
+    fn into(self) -> Shape {
+        Shape::Sphere(self)
+    }
+}
+
+impl Sphere {
+    pub fn new(center: [f32; 3], radius: f32) -> Self {
+        Self {
+            center,
+            radius,
+            quality: 2,
+            style: VisualStyle {
+                opacity: 1.0,
+                visible: true,
+                ..Default::default()
+            },
+            interaction: Default::default(),
+        }
+    }
+
+    pub fn center(mut self, center: [f32; 3])-> Self {
+        self.center = center;
+        self
+    }
+
+    pub fn set_radius(mut self, radius: f32)-> Self {
+        self.radius = radius;
+        self
+    }
+
+    pub fn clickable(mut self, val: bool) -> Self {
+        self.interaction.clickable = val;
+        self
+    }
+
+    // pub fn to_mesh(&self, scale: f32) -> MeshData {
+    //     let mut vertices = Vec::new();
+    //     let mut normals = Vec::new();
+    //     let mut indices = Vec::new();
+    //     let mut colors = Vec::new();
+
+    //     let lat_segments = 10 * self.quality;
+    //     let lon_segments = 20 * self.quality;
+
+    //     let r = self.radius;
+    //     let [cx, cy, cz] = self.center;
+
+    //     // 基础颜色（带透明度）
+    //     let base_color = self.style.color.unwrap_or([1.0, 1.0, 1.0]);
+    //     let alpha = self.style.opacity.clamp(0.0, 1.0);
+    //     let color_rgba = [base_color[0], base_color[1], base_color[2], alpha];
+
+    //     for i in 0..=lat_segments {
+    //         let theta = std::f32::consts::PI * (i as f32) / (lat_segments as f32);
+    //         let sin_theta = theta.sin();
+    //         let cos_theta = theta.cos();
+
+    //         for j in 0..=lon_segments {
+    //             let phi = 2.0 * std::f32::consts::PI * (j as f32) / (lon_segments as f32);
+    //             let sin_phi = phi.sin();
+    //             let cos_phi = phi.cos();
+
+    //             let nx = sin_theta * cos_phi;
+    //             let ny = cos_theta;
+    //             let nz = sin_theta * sin_phi;
+
+    //             let x = cx + r * nx;
+    //             let y = cy + r * ny;
+    //             let z = cz + r * nz;
+
+    //             vertices.push([x, y, z].map(|x| x * scale));
+    //             normals.push([nx, ny, nz].map(|x| x * scale));
+    //             colors.push(color_rgba); // 每个顶点同样颜色
+    //         }
+    //     }
+
+    //     for i in 0..lat_segments {
+    //         for j in 0..lon_segments {
+    //             let first = i * (lon_segments + 1) + j;
+    //             let second = first + lon_segments + 1;
+
+    //             indices.push(first);
+    //             indices.push(first + 1);
+    //             indices.push(second);
+
+    //             indices.push(second);
+    //             indices.push(first + 1);
+    //             indices.push(second + 1);
+    //         }
+    //     }
+
+    //     MeshData {
+    //         vertices,
+    //         normals,
+    //         indices,
+    //         colors: Some(colors),
+    //         transform: None,
+    //         is_wireframe: self.style.wireframe,
+    //     }
+    // }
+        pub fn to_mesh(&self, scale: f32) -> MeshData {
+        let template = get_or_generate_template(self.quality);
+
+        let [cx, cy, cz] = self.center;
+        let r = self.radius;
+
+        let transformed_vertices: Vec<[f32; 3]> = template.vertices.iter()
+            .map(|v| [
+                (v[0] * r + cx) * scale,
+                (v[1] * r + cy) * scale,
+                (v[2] * r + cz) * scale,
+            ])
+            .collect();
+
+        let transformed_normals: Vec<[f32; 3]> = template.normals
+            .iter()
+            .map(|n| n.map(|x| x * scale)) // 你可以不乘 scale，如果只用于方向
+            .collect();
+
+        let base_color = self.style.color.unwrap_or([1.0, 1.0, 1.0]);
+        let alpha = self.style.opacity.clamp(0.0, 1.0);
+        let color = [base_color[0], base_color[1], base_color[2], alpha];
+
+        let colors = vec![color; transformed_vertices.len()];
+
+        MeshData {
+            vertices: transformed_vertices,
+            normals: transformed_normals,
+            indices: template.indices.clone(),
+            colors: Some(colors),
+            transform: None,
+            is_wireframe: self.style.wireframe,
+        }
+
+    }
+}
+
+impl VisualShape for Sphere {
+    fn style_mut(&mut self) -> &mut VisualStyle {
+        &mut self.style
+    }
+}
+
+pub trait UpdateSphere {
+    fn update_sphere(&mut self, id: &str, f: impl FnOnce(&mut Sphere));
+}
+
+impl UpdateSphere for Scene {
+    fn update_sphere(&mut self, id: &str, f: impl FnOnce(&mut Sphere)) {
+        if let Some(Shape::Sphere(sphere)) = self.named_shapes.get_mut(id) {
+            f(sphere);
+        } else {
+            panic!("Sphere with ID '{}' not found or is not a Sphere", id);
+        }
+    }
+}

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/core/src/shapes/stick.rs

@@ -1,4 +1,3 @@
-use glam::Mat3;
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -40,17 +39,17 @@ impl Stick {
         }
     }
 
-    pub fn radius(mut self, radius: f32) -> Self{
+    pub fn radius(mut self, radius: f32) -> Self {
         self.radius = radius;
         self
     }
 
-    pub fn start(mut self, start: [f32; 3]) -> Self{
+    pub fn start(mut self, start: [f32; 3]) -> Self {
         self.start = start;
         self
     }
 
-    pub fn end(mut self, end: [f32; 3]) -> Self{
+    pub fn end(mut self, end: [f32; 3]) -> Self {
         self.end = end;
         self
     }
@@ -96,13 +95,13 @@ impl Stick {
 
         for i in 0..segments {
             let idx = i * 2;
-            indices.push(idx);
-            indices.push(idx + 1);
             indices.push(idx + 2);
-
             indices.push(idx + 1);
-            indices.push(idx + 3);
+            indices.push(idx);
+
             indices.push(idx + 2);
+            indices.push(idx + 3);
+            indices.push(idx + 1);
         }
 
         // 对齐旋转：Z -> axis

cosmol_viewer-0.1.1.dev5/crates/python/README.md

@@ -0,0 +1,49 @@
+# COSMol-viewer
+
+A high-performance molecular visualization library built with Rust and WebGPU, designed for seamless integration into Python workflows.
+
+- ⚡ Fast: Native-speed rendering powered by Rust and GPU acceleration
+
+- 🧬 Flexible: Load molecules from .sdf, .pdb, and dynamically update 3D structures
+
+- 📓 Notebook-friendly: Fully supports Jupyter and Google Colab — ideal for education, research, and live demos
+
+- 🔁 Real-time updates: Update molecular coordinates on-the-fly for simulations or animations
+
+- 🎨 Customizable: Control styles, camera, and rendering settings programmatically
+
+# Installation
+
+```sh
+pip install cosmol-viewer==0.1.1.dev5
+```
+
+# Usage
+
+```python
+from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
+
+# === Step 1: Load and render a molecule ===
+with open("molecule.sdf", "r") as f:
+    sdf = f.read()
+    mol = Molecules(parse_sdf(sdf)).centered()
+
+scene = Scene()
+scene.scale(0.1)
+scene.add_shape(mol, "mol")
+
+viewer = Viewer.render(scene)  # Launch the viewer
+
+# === Step 2: Update the same molecule dynamically ===
+import time
+
+for i in range(1, 10):  # Simulate multiple frames
+    with open(f"frames/frame_{i}.sdf", "r") as f:
+        sdf = f.read()
+        updated_mol = Molecules(parse_sdf(sdf)).centered()
+
+    scene.update_shape("mol", updated_mol)
+    viewer.update(scene)
+
+    time.sleep(0.033)  # ~30 FPS
+```

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/python/build.rs

@@ -1,4 +1,4 @@
-use std::{env, process::Command};
+// use std::{env, process::Command};
 
 fn main() {
     // let is_ci = env::var("GITHUB_ACTIONS").is_ok();

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/python/src/lib.rs

@@ -18,8 +18,8 @@ pub struct Scene {
 
 #[pymethods]
 impl Scene {
-    #[staticmethod]
-    pub fn create_viewer() -> Self {
+    #[new]
+    pub fn new() -> Self {
         Self {
             inner: _Scene::new(),
         }
@@ -138,8 +138,6 @@ impl Viewer {
 
     #[staticmethod]
     pub fn render(scene: &Scene, py: Python) -> Self {
-        println!("scene {}", serde_json::to_string(&scene.inner).unwrap());
-
         let env_type = detect_runtime_env(py).unwrap();
         match env_type {
             RuntimeEnv::Colab | RuntimeEnv::Jupyter => {

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/crates/python/src/shapes.rs

@@ -1,6 +1,6 @@
 use cosmol_viewer_core::{
     shapes::{molecules::Molecules, sphere::Sphere, stick::Stick},
-    utils::{VisualShape, VisualStyle},
+    utils::VisualShape,
 };
 use pyo3::{PyRefMut, pyclass, pymethods};
 

{cosmol_viewer-0.1.1.dev3 → cosmol_viewer-0.1.1.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cosmol-viewer"
-version = "0.1.1.dev3"
+version = "0.1.1.dev5"
 description = "Molecular visualization tools"
 authors = [{name = "95028", email = "wjt@cosmol.org"}]
 
@@ -11,3 +11,6 @@ build-backend = "maturin"
 [tool.maturin]
 name = "cosmol_viewer"
 manifest-path = "crates/python/Cargo.toml"
+
+[project.urls]
+Repository = "https://github.com/COSMol-repl/COSMol-viewer"

cosmol_viewer-0.1.1.dev3/PKG-INFO

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

cosmol_viewer-0.1.1.dev3/crates/core/src/shader/fragment.glsl

@@ -1,28 +0,0 @@
-precision mediump float;
-
-uniform vec3 u_light_pos;
-uniform vec3 u_light_color;
-uniform vec3 u_view_pos;
-uniform float u_light_intensity;
-
-in vec3 v_normal;
-in vec4 v_color;
-in vec3 v_frag_pos;
-
-out vec4 FragColor;
-void main() {
-    vec3 normal = normalize(v_normal);                         // 归一化法线
-    vec3 light_dir = normalize(u_light_pos - v_frag_pos);      // 计算从片元到光源的方向
-    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 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 light = (ambient + diffuse) * u_light_intensity;       // 叠加光照并乘以强度
-
-    FragColor = vec4(v_color.rgb * light, v_color.a);
-}

cosmol_viewer-0.1.1.dev3/crates/core/src/shapes/sphere.rs

@@ -1,136 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{scene::Scene, utils::{Interaction, MeshData, VisualShape, VisualStyle}, Shape};
-
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub struct Sphere {
-    pub center: [f32; 3],
-    pub radius: f32,
-    pub quality: u32,
-
-    pub style: VisualStyle,
-    pub interaction: Interaction,
-}
-
-impl Into<Shape> for Sphere {
-    fn into(self) -> Shape {
-        Shape::Sphere(self)
-    }
-}
-
-impl Sphere {
-    pub fn new(center: [f32; 3], radius: f32) -> Self {
-        Self {
-            center,
-            radius,
-            quality: 2,
-            style: VisualStyle {
-                opacity: 1.0,
-                visible: true,
-                ..Default::default()
-            },
-            interaction: Default::default(),
-        }
-    }
-
-    pub fn center(mut self, center: [f32; 3])-> Self {
-        self.center = center;
-        self
-    }
-
-    pub fn set_radius(mut self, radius: f32)-> Self {
-        self.radius = radius;
-        self
-    }
-
-    pub fn clickable(mut self, val: bool) -> Self {
-        self.interaction.clickable = val;
-        self
-    }
-
-    pub fn to_mesh(&self, scale: f32) -> MeshData {
-        let mut vertices = Vec::new();
-        let mut normals = Vec::new();
-        let mut indices = Vec::new();
-        let mut colors = Vec::new();
-
-        let lat_segments = 10 * self.quality;
-        let lon_segments = 20 * self.quality;
-
-        let r = self.radius;
-        let [cx, cy, cz] = self.center;
-
-        // 基础颜色（带透明度）
-        let base_color = self.style.color.unwrap_or([1.0, 1.0, 1.0]);
-        let alpha = self.style.opacity.clamp(0.0, 1.0);
-        let color_rgba = [base_color[0], base_color[1], base_color[2], alpha];
-
-        for i in 0..=lat_segments {
-            let theta = std::f32::consts::PI * (i as f32) / (lat_segments as f32);
-            let sin_theta = theta.sin();
-            let cos_theta = theta.cos();
-
-            for j in 0..=lon_segments {
-                let phi = 2.0 * std::f32::consts::PI * (j as f32) / (lon_segments as f32);
-                let sin_phi = phi.sin();
-                let cos_phi = phi.cos();
-
-                let nx = sin_theta * cos_phi;
-                let ny = cos_theta;
-                let nz = sin_theta * sin_phi;
-
-                let x = cx + r * nx;
-                let y = cy + r * ny;
-                let z = cz + r * nz;
-
-                vertices.push([x, y, z].map(|x| x * scale));
-                normals.push([nx, ny, nz].map(|x| x * scale));
-                colors.push(color_rgba); // 每个顶点同样颜色
-            }
-        }
-
-        for i in 0..lat_segments {
-            for j in 0..lon_segments {
-                let first = i * (lon_segments + 1) + j;
-                let second = first + lon_segments + 1;
-
-                indices.push(first);
-                indices.push(second);
-                indices.push(first + 1);
-
-                indices.push(second);
-                indices.push(second + 1);
-                indices.push(first + 1);
-            }
-        }
-
-        MeshData {
-            vertices,
-            normals,
-            indices,
-            colors: Some(colors),
-            transform: None,
-            is_wireframe: self.style.wireframe,
-        }
-    }
-}
-
-impl VisualShape for Sphere {
-    fn style_mut(&mut self) -> &mut VisualStyle {
-        &mut self.style
-    }
-}
-
-pub trait UpdateSphere {
-    fn update_sphere(&mut self, id: &str, f: impl FnOnce(&mut Sphere));
-}
-
-impl UpdateSphere for Scene {
-    fn update_sphere(&mut self, id: &str, f: impl FnOnce(&mut Sphere)) {
-        if let Some(Shape::Sphere(sphere)) = self.named_shapes.get_mut(id) {
-            f(sphere);
-        } else {
-            panic!("Sphere with ID '{}' not found or is not a Sphere", id);
-        }
-    }
-}