rfmod/
geometry.rs

1/*
2* Rust-FMOD - Copyright (c) 2016 Gomez Guillaume.
3*
4* The Original software, FMOD library, is provided by FIRELIGHT TECHNOLOGIES.
5*
6* This software is provided 'as-is', without any express or implied warranty.
7* In no event will the authors be held liable for any damages arising from
8* the use of this software.
9*
10* Permission is granted to anyone to use this software for any purpose,
11* including commercial applications, and to alter it and redistribute it
12* freely, subject to the following restrictions:
13*
14* 1. The origin of this software must not be misrepresented; you must not claim
15*    that you wrote the original software. If you use this software in a product,
16*    an acknowledgment in the product documentation would be appreciated but is
17*    not required.
18*
19* 2. Altered source versions must be plainly marked as such, and must not be
20*    misrepresented as being the original software.
21*
22* 3. This notice may not be removed or altered from any source distribution.
23*/
24
25use ffi;
26use types::*;
27use vector;
28use libc::{c_int, c_void};
29use fmod_sys;
30use fmod_sys::MemoryUsageDetails;
31use std::mem::transmute;
32use std::default::Default;
33
34/// Geometry object
35pub struct Geometry {
36    geometry: *mut ffi::FMOD_GEOMETRY
37}
38
39impl ffi::FFI<ffi::FMOD_GEOMETRY> for Geometry {
40    fn wrap(g: *mut ffi::FMOD_GEOMETRY) -> Geometry {
41        Geometry {geometry: g}
42    }
43
44    fn unwrap(g: &Geometry) -> *mut ffi::FMOD_GEOMETRY {
45        g.geometry
46    }
47}
48
49impl Drop for Geometry {
50    fn drop(&mut self) {
51        self.release();
52    }
53}
54
55impl Geometry {
56    pub fn release(&mut self) -> ::Status {
57        if self.geometry !=::std::ptr::null_mut() {
58            match unsafe { ffi::FMOD_Geometry_Release(self.geometry) } {
59                ::Status::Ok => {
60                    self.geometry = ::std::ptr::null_mut();
61                   ::Status::Ok
62                }
63                e => e,
64            }
65        } else {
66            ::Status::Ok
67        }
68    }
69
70    pub fn add_polygon(&self, direct_occlusion: f32, reverb_occlusion: f32, double_sided: bool,
71                       vertices: Vec<vector::Vector>) -> Result<i32, ::Status> {
72        let t_double_sided = if double_sided == true {
73            1
74        } else {
75            0
76        };
77        let mut index = 0i32;
78        let t_vertices = Vec::with_capacity(vertices.len());
79
80        for tmp in vertices.iter() {
81            vector::get_ffi(tmp);
82        }
83
84        match unsafe { ffi::FMOD_Geometry_AddPolygon(self.geometry, direct_occlusion,
85                                                     reverb_occlusion, t_double_sided,
86                                                     vertices.len() as c_int, t_vertices.as_ptr(),
87                                                     &mut index) } {
88            ::Status::Ok => Ok(index),
89            e => Err(e),
90        }
91    }
92
93    pub fn get_num_polygons(&self) -> Result<i32, ::Status> {
94        let mut num = 0i32;
95
96        match unsafe { ffi::FMOD_Geometry_GetNumPolygons(self.geometry, &mut num) } {
97            ::Status::Ok => Ok(num),
98            e => Err(e)
99        }
100    }
101
102    pub fn get_max_polygons(&self) -> Result<(i32, i32), ::Status> {
103        let mut max_polygons = 0i32;
104        let mut max_vertices = 0i32;
105
106        match unsafe { ffi::FMOD_Geometry_GetMaxPolygons(self.geometry, &mut max_polygons,
107                                                         &mut max_vertices) } {
108            ::Status::Ok => Ok((max_polygons, max_vertices)),
109            e => Err(e),
110        }
111    }
112
113    pub fn get_polygon_num_vertices(&self, index: i32) -> Result<i32, ::Status> {
114        let mut num = 0i32;
115
116        match unsafe { ffi::FMOD_Geometry_GetPolygonNumVertices(self.geometry, index, &mut num) } {
117            ::Status::Ok => Ok(num),
118            e => Err(e),
119        }
120    }
121
122    pub fn set_polygon_vertex(&self, index: i32, vertex_index: i32,
123                              vertex: vector::Vector) -> ::Status {
124        let t_vertex = vector::get_ffi(&vertex);
125
126        unsafe { ffi::FMOD_Geometry_SetPolygonVertex(self.geometry, index, vertex_index,
127                                                     &t_vertex) }
128    }
129
130    pub fn get_polygon_vertex(&self, index: i32,
131                              vertex_index: i32) -> Result<vector::Vector, ::Status> {
132        let mut vertex = vector::get_ffi(&vector::Vector::new());
133
134        match unsafe { ffi::FMOD_Geometry_GetPolygonVertex(self.geometry, index, vertex_index,
135                                                           &mut vertex) } {
136            ::Status::Ok => Ok(vector::from_ptr(vertex)),
137            e => Err(e),
138        }
139    }
140
141    pub fn set_polygon_attributes(&self, index: i32, direct_occlusion: f32, reverb_occlusion: f32,
142                                  double_sided: bool) -> ::Status {
143        let t_double_sided = if double_sided == true {
144            1
145        } else {
146            0
147        };
148
149        unsafe { ffi::FMOD_Geometry_SetPolygonAttributes(self.geometry, index, direct_occlusion,
150                                                         reverb_occlusion, t_double_sided) }
151    }
152
153    /// Returns:
154    ///
155    /// Ok(direct_occlusion, reverb_occlusion, double_sided)
156    pub fn get_polygon_attributes(&self, index: i32) -> Result<(f32, f32, bool), ::Status> {
157        let mut direct_occlusion = 0f32;
158        let mut reverb_occlusion = 0f32;
159        let mut double_sided = 0;
160
161        match unsafe { ffi::FMOD_Geometry_GetPolygonAttributes(self.geometry, index,
162                                                               &mut direct_occlusion,
163                                                               &mut reverb_occlusion,
164                                                               &mut double_sided) } {
165            ::Status::Ok => Ok((direct_occlusion, reverb_occlusion, double_sided == 1)),
166            e => Err(e),
167        }
168    }
169
170    pub fn set_active(&self, active: bool) -> ::Status {
171        let t_active = if active == true {
172            1
173        } else {
174            0
175        };
176
177        unsafe { ffi::FMOD_Geometry_SetActive(self.geometry, t_active) }
178    }
179
180    pub fn get_active(&self) -> Result<bool, ::Status> {
181        let mut active = 0;
182
183        match unsafe { ffi::FMOD_Geometry_GetActive(self.geometry, &mut active) } {
184            ::Status::Ok => Ok(active == 1),
185            e => Err(e)
186        }
187    }
188
189    pub fn set_rotation(&self, forward: vector::Vector, up: vector::Vector) -> ::Status {
190        let t_forward = vector::get_ffi(&forward);
191        let t_up = vector::get_ffi(&up);
192
193        unsafe { ffi::FMOD_Geometry_SetRotation(self.geometry, &t_forward, &t_up) }
194    }
195
196    /// Returns:
197    ///
198    /// Ok(forward, up)
199    pub fn get_rotation(&self) -> Result<(vector::Vector, vector::Vector), ::Status> {
200        let mut forward = vector::get_ffi(&vector::Vector::new());
201        let mut up = vector::get_ffi(&vector::Vector::new());
202
203        match unsafe { ffi::FMOD_Geometry_GetRotation(self.geometry, &mut forward, &mut up) } {
204            ::Status::Ok => Ok((vector::from_ptr(forward), vector::from_ptr(up))),
205            e => Err(e)
206        }
207    }
208
209    pub fn set_position(&self, position: vector::Vector) -> ::Status {
210        let t_position = vector::get_ffi(&position);
211
212        unsafe { ffi::FMOD_Geometry_SetPosition(self.geometry, &t_position) }
213    }
214
215    pub fn get_position(&self) -> Result<vector::Vector, ::Status> {
216        let mut position = vector::get_ffi(&vector::Vector::new());
217
218        match unsafe { ffi::FMOD_Geometry_GetPosition(self.geometry, &mut position) } {
219            ::Status::Ok => Ok(vector::from_ptr(position)),
220            e => Err(e)
221        }
222    }
223
224    pub fn set_scale(&self, scale: vector::Vector) -> ::Status {
225        let t_scale = vector::get_ffi(&scale);
226
227        unsafe { ffi::FMOD_Geometry_SetScale(self.geometry, &t_scale) }
228    }
229
230    pub fn get_scale(&self) -> Result<vector::Vector, ::Status> {
231        let mut scale = vector::get_ffi(&vector::Vector::new());
232
233        match unsafe { ffi::FMOD_Geometry_GetScale(self.geometry, &mut scale) } {
234            ::Status::Ok => Ok(vector::from_ptr(scale)),
235            e => Err(e)
236        }
237    }
238
239    /// Returns:
240    ///
241    /// Ok(memory_used, details)
242    pub fn get_memory_info(&self, MemoryBits(memory_bits): MemoryBits,
243                           EventMemoryBits(event_memory_bits): EventMemoryBits)
244                           -> Result<(u32, MemoryUsageDetails), ::Status> {
245        let mut details = fmod_sys::get_memory_usage_details_ffi(Default::default());
246        let mut memory_used = 0u32;
247
248        match unsafe { ffi::FMOD_Geometry_GetMemoryInfo(self.geometry, memory_bits, event_memory_bits, &mut memory_used, &mut details) } {
249            ::Status::Ok => Ok((memory_used, fmod_sys::from_memory_usage_details_ptr(details))),
250            e => Err(e)
251        }
252    }
253
254    pub fn set_user_data<'r, T>(&'r self, user_data: &'r mut T) -> ::Status {
255        unsafe { ffi::FMOD_Geometry_SetUserData(self.geometry, transmute(user_data)) }
256    }
257
258    pub fn get_user_data<'r, T>(&'r self) -> Result<&'r mut T, ::Status> {
259        unsafe {
260            let mut user_data : *mut c_void = ::std::ptr::null_mut();
261
262            match ffi::FMOD_Geometry_GetUserData(self.geometry, &mut user_data) {
263                ::Status::Ok => {
264                    let tmp : &mut T = transmute::<*mut c_void, &mut T>(user_data);
265                    
266                    Ok(tmp)
267                },
268                e => Err(e)
269            }
270        }
271    }
272}
rfmod/geometry.rs

rfmod/
geometry.rs
