1#![allow(non_upper_case_globals)]
2
3extern crate fastnoise_simd_bindings;
4
5pub mod enums;
6pub mod vector_set;
7pub mod noise_set;
8pub mod properties;
9
10pub use enums::{
11 NoiseType,
12 FractalType,
13 PerturbType,
14 CellularDistanceFn,
15 CellularReturnType,
16 SIMDType,
17};
18pub use properties::{
19 GeneralProperties,
20 FractalProperties,
21 CellularProperties,
22 PerturbProperties,
23};
24pub use vector_set::VectorSet;
25pub use noise_set::NoiseSet;
26use fastnoise_simd_bindings as binds;
27
28pub struct FastNoiseSIMD {
29 inner: *mut binds::FastNoiseSIMD,
30}
31
32impl FastNoiseSIMD {
33 pub fn new(seed: i32) -> Self {
34 unsafe {
35 FastNoiseSIMD {
36 inner: binds::FastNoiseSIMD::NewFastNoiseSIMD(seed),
37 }
38 }
39 }
40
41 pub fn get_simd_type() -> SIMDType {
42 unsafe {
43 SIMDType::from_c(binds::FastNoiseSIMD::GetSIMDLevel() as u32)
44 }
45 }
46
47 pub fn set_general_properties(
48 &mut self,
49 properties: GeneralProperties
50 ) {
51 let inner = unsafe { &mut *self.inner };
52 inner.m_noiseType = properties.noise_type.into_c();
53 inner.m_seed = properties.seed;
54 inner.m_frequency = properties.frequency;
55 inner.m_xScale = properties.x_scale;
56 inner.m_yScale = properties.y_scale;
57 inner.m_zScale = properties.z_scale;
58 }
59
60 pub fn get_general_properties(&self) -> GeneralProperties {
61 let inner = unsafe { &*self.inner };
62
63 GeneralProperties {
64 noise_type: NoiseType::from_c(inner.m_noiseType),
65 seed: inner.m_seed,
66 frequency: inner.m_frequency,
67 x_scale: inner.m_xScale,
68 y_scale: inner.m_yScale,
69 z_scale: inner.m_zScale,
70 }
71 }
72
73 pub fn set_fractal_properties(
74 &mut self,
75 properties: FractalProperties
76 ) {
77 let inner = unsafe { &mut *self.inner };
78 inner.m_fractalType = properties.fractal_type.into_c();
79 inner.m_octaves = properties.octaves;
80 inner.m_lacunarity = properties.lacunarity;
81 inner.m_gain = properties.gain;
82 inner.m_fractalBounding = unsafe {
83 binds::FastNoiseSIMD::CalculateFractalBounding(
84 inner.m_octaves, inner.m_gain) };
85 }
86
87 pub fn get_fractal_properties(&self) -> FractalProperties {
88 let inner = unsafe { &*self.inner };
89
90 FractalProperties {
91 fractal_type: FractalType::from_c(inner.m_fractalType),
92 octaves: inner.m_octaves,
93 lacunarity: inner.m_lacunarity,
94 gain: inner.m_gain
95 }
96 }
97
98 pub fn set_cellular_properties(
99 &mut self,
100 properties: CellularProperties
101 ) {
102 let inner = unsafe { &mut *self.inner };
103 inner.m_cellularReturnType = properties.return_type.into_c();
104 inner.m_cellularDistanceFunction = properties.return_func.into_c();
105 inner.m_cellularDistanceIndex0 = properties.distance2_index0;
106 inner.m_cellularDistanceIndex1 = properties.distance2_index1;
107 inner.m_cellularJitter = properties.jitter;
108 inner.m_cellularNoiseLookupType = properties.noise_lookup_type.into_c();
109 inner.m_cellularNoiseLookupFrequency = properties.noise_lookup_freq;
110 }
111
112 pub fn get_cellular_properties(&self) -> CellularProperties {
113 let inner = unsafe { &*self.inner };
114
115 CellularProperties {
116 return_type: CellularReturnType::from_c(inner.m_cellularReturnType),
117 return_func: CellularDistanceFn::from_c(inner.m_cellularDistanceFunction),
118 distance2_index0: inner.m_cellularDistanceIndex0,
119 distance2_index1: inner.m_cellularDistanceIndex1,
120 jitter: inner.m_cellularJitter,
121 noise_lookup_type: NoiseType::from_c(inner.m_cellularNoiseLookupType),
122 noise_lookup_freq: inner.m_cellularNoiseLookupFrequency
123 }
124 }
125
126 pub fn set_perturb_properties(
127 &mut self,
128 properties: PerturbProperties,
129 ) {
130 let inner = unsafe { &mut *self.inner };
131 inner.m_perturbType = properties.perturb_type.into_c();
132 inner.m_perturbAmp = properties.amp / 511.5;
133 inner.m_perturbFrequency = properties.frequency;
134 inner.m_perturbOctaves = properties.fractal_octaves;
135 inner.m_perturbLacunarity = properties.fractal_lacunarity;
136 inner.m_perturbGain = properties.fractal_gain;
137 inner.m_perturbNormaliseLength = properties.normalise_length;
138 inner.m_perturbFractalBounding = unsafe {
139 binds::FastNoiseSIMD::CalculateFractalBounding(
140 inner.m_perturbOctaves, inner.m_perturbGain) };
141 }
142
143 pub fn get_perturb_properties(&self) -> PerturbProperties {
144 let inner = unsafe { &*self.inner };
145
146 PerturbProperties {
147 perturb_type: PerturbType::from_c(inner.m_perturbType),
148 amp: inner.m_perturbAmp * 511.5,
149 frequency: inner.m_perturbFrequency,
150 fractal_octaves: inner.m_perturbOctaves,
151 fractal_lacunarity: inner.m_perturbLacunarity,
152 fractal_gain: inner.m_perturbGain,
153 normalise_length: inner.m_perturbNormaliseLength
154 }
155 }
156
157 pub fn get_vector_set(
159 _x_size: i32,
160 _y_size: i32,
161 _z_size: i32
162 ) -> VectorSet {
163 unimplemented!()
170 }
171
172 pub fn get_sampling_vector_set(
174 _sample_scale: i32,
175 _x_size: i32,
176 _y_size: i32,
177 _z_size: i32
178 ) -> VectorSet {
179 unimplemented!()
187 }
188
189 pub fn fill_vector_set(
191 _vector_set: &mut VectorSet,
192 _x_size: i32,
193 _y_size: i32,
194 _z_size: i32
195 ) {
196 unimplemented!()
204 }
205
206 pub fn fill_sampling_vector_set(
208 _vector_set: &mut VectorSet,
209 _sample_scale: i32,
210 _x_size: i32,
211 _y_size: i32,
212 _z_size: i32
213 ) {
214 unimplemented!()
223 }
224
225 pub fn fill_noise_set1(
227 &mut self,
228 _noise_set: &mut NoiseSet,
229 _vector_set: &mut VectorSet,
230 _x_offset: f32,
231 _y_offset: f32,
232 _z_offset: f32
233 ) {
234 unimplemented!()
244 }
245
246 pub fn get_noise_set(
247 &mut self,
248 x_start: i32,
249 y_start: i32,
250 z_start: i32,
251 x_size: i32,
252 y_size: i32,
253 z_size: i32,
254 scale_modifier: f32
255 ) -> NoiseSet {
256 let inner = unsafe {
257 (*self.inner).GetNoiseSet(
258 x_start,
259 y_start,
260 z_start,
261 x_size,
262 y_size,
263 z_size,
264 scale_modifier
265 )
266 };
267
268 NoiseSet {
269 inner,
270 x_start,
271 y_start,
272 z_start,
273 x_size,
274 y_size,
275 z_size,
276 }
277 }
278
279 pub fn fill_noise_set(
280 &mut self,
281 noise_set: &mut NoiseSet,
282 x_start: i32,
283 y_start: i32,
284 z_start: i32,
285 x_size: i32,
286 y_size: i32,
287 z_size: i32,
288 scale_modifier: f32
289 ) {
290 unsafe {
291 (*self.inner).FillNoiseSet(
292 noise_set.inner,
293 x_start,
294 y_start,
295 z_start,
296 x_size,
297 y_size,
298 z_size,
299 scale_modifier
300 )
301 }
302
303 noise_set.x_start = x_start;
304 noise_set.y_start = y_start;
305 noise_set.z_start = z_start;
306 noise_set.x_size = x_size;
307 noise_set.y_size = y_size;
308 noise_set.z_size = z_size;
309 }
310
311 pub fn get_sampled_noise_set(
312 &mut self,
313 x_start: i32,
314 y_start: i32,
315 z_start: i32,
316 x_size: i32,
317 y_size: i32,
318 z_size: i32,
319 sample_scale: i32,
320 ) -> NoiseSet {
321 let inner = unsafe {
322 (*self.inner).GetSampledNoiseSet(
323 x_start,
324 y_start,
325 z_start,
326 x_size,
327 y_size,
328 z_size,
329 sample_scale
330 )
331 };
332
333 NoiseSet {
334 inner,
335 x_start,
336 y_start,
337 z_start,
338 x_size,
339 y_size,
340 z_size,
341 }
342 }
343
344 pub fn get_white_noise_set(
345 &mut self,
346 x_start: i32,
347 y_start: i32,
348 z_start: i32,
349 x_size: i32,
350 y_size: i32,
351 z_size: i32,
352 scale_modifier: f32
353 ) -> NoiseSet {
354 let inner = unsafe {
355 (*self.inner).GetWhiteNoiseSet(
356 x_start,
357 y_start,
358 z_start,
359 x_size,
360 y_size,
361 z_size,
362 scale_modifier
363 )
364 };
365
366 NoiseSet {
367 inner,
368 x_start,
369 y_start,
370 z_start,
371 x_size,
372 y_size,
373 z_size,
374 }
375 }
376
377 pub fn get_value_set(
378 &mut self,
379 x_start: i32,
380 y_start: i32,
381 z_start: i32,
382 x_size: i32,
383 y_size: i32,
384 z_size: i32,
385 scale_modifier: f32
386 ) -> NoiseSet {
387 let inner = unsafe {
388 (*self.inner).GetValueSet(
389 x_start,
390 y_start,
391 z_start,
392 x_size,
393 y_size,
394 z_size,
395 scale_modifier
396 )
397 };
398
399 NoiseSet {
400 inner,
401 x_start,
402 y_start,
403 z_start,
404 x_size,
405 y_size,
406 z_size,
407 }
408 }
409
410 pub fn get_value_fractal_set(
411 &mut self,
412 x_start: i32,
413 y_start: i32,
414 z_start: i32,
415 x_size: i32,
416 y_size: i32,
417 z_size: i32,
418 scale_modifier: f32
419 ) -> NoiseSet {
420 let inner = unsafe {
421 (*self.inner).GetValueFractalSet(
422 x_start,
423 y_start,
424 z_start,
425 x_size,
426 y_size,
427 z_size,
428 scale_modifier
429 )
430 };
431
432 NoiseSet {
433 inner,
434 x_start,
435 y_start,
436 z_start,
437 x_size,
438 y_size,
439 z_size,
440 }
441 }
442
443 pub fn get_perlin_set(
444 &mut self,
445 x_start: i32,
446 y_start: i32,
447 z_start: i32,
448 x_size: i32,
449 y_size: i32,
450 z_size: i32,
451 scale_modifier: f32
452 ) -> NoiseSet {
453 let inner = unsafe {
454 (*self.inner).GetPerlinSet(
455 x_start,
456 y_start,
457 z_start,
458 x_size,
459 y_size,
460 z_size,
461 scale_modifier
462 )
463 };
464
465 NoiseSet {
466 inner,
467 x_start,
468 y_start,
469 z_start,
470 x_size,
471 y_size,
472 z_size,
473 }
474 }
475
476 pub fn get_perlin_fractal_set(
477 &mut self,
478 x_start: i32,
479 y_start: i32,
480 z_start: i32,
481 x_size: i32,
482 y_size: i32,
483 z_size: i32,
484 scale_modifier: f32
485 ) -> NoiseSet {
486 let inner = unsafe {
487 (*self.inner).GetPerlinFractalSet(
488 x_start,
489 y_start,
490 z_start,
491 x_size,
492 y_size,
493 z_size,
494 scale_modifier
495 )
496 };
497
498 NoiseSet {
499 inner,
500 x_start,
501 y_start,
502 z_start,
503 x_size,
504 y_size,
505 z_size,
506 }
507 }
508
509 pub fn get_simplex_set(
510 &mut self,
511 x_start: i32,
512 y_start: i32,
513 z_start: i32,
514 x_size: i32,
515 y_size: i32,
516 z_size: i32,
517 scale_modifier: f32
518 ) -> NoiseSet {
519 let inner = unsafe {
520 (*self.inner).GetSimplexSet(
521 x_start,
522 y_start,
523 z_start,
524 x_size,
525 y_size,
526 z_size,
527 scale_modifier
528 )
529 };
530
531 NoiseSet {
532 inner,
533 x_start,
534 y_start,
535 z_start,
536 x_size,
537 y_size,
538 z_size,
539 }
540 }
541
542 pub fn get_simplex_fractal_set(
543 &mut self,
544 x_start: i32,
545 y_start: i32,
546 z_start: i32,
547 x_size: i32,
548 y_size: i32,
549 z_size: i32,
550 scale_modifier: f32
551 ) -> NoiseSet {
552 let inner = unsafe {
553 (*self.inner).GetSimplexFractalSet(
554 x_start,
555 y_start,
556 z_start,
557 x_size,
558 y_size,
559 z_size,
560 scale_modifier
561 )
562 };
563
564 NoiseSet {
565 inner,
566 x_start,
567 y_start,
568 z_start,
569 x_size,
570 y_size,
571 z_size,
572 }
573 }
574
575 pub fn get_cellular_set(
576 &mut self,
577 x_start: i32,
578 y_start: i32,
579 z_start: i32,
580 x_size: i32,
581 y_size: i32,
582 z_size: i32,
583 scale_modifier: f32
584 ) -> NoiseSet {
585 let inner = unsafe {
586 (*self.inner).GetCellularSet(
587 x_start,
588 y_start,
589 z_start,
590 x_size,
591 y_size,
592 z_size,
593 scale_modifier
594 )
595 };
596
597 NoiseSet {
598 inner,
599 x_start,
600 y_start,
601 z_start,
602 x_size,
603 y_size,
604 z_size,
605 }
606 }
607
608 pub fn get_cubic_set(
609 &mut self,
610 x_start: i32,
611 y_start: i32,
612 z_start: i32,
613 x_size: i32,
614 y_size: i32,
615 z_size: i32,
616 scale_modifier: f32
617 ) -> NoiseSet {
618 let inner = unsafe {
619 (*self.inner).GetCubicSet(
620 x_start,
621 y_start,
622 z_start,
623 x_size,
624 y_size,
625 z_size,
626 scale_modifier
627 )
628 };
629
630 NoiseSet {
631 inner,
632 x_start,
633 y_start,
634 z_start,
635 x_size,
636 y_size,
637 z_size,
638 }
639 }
640
641 pub fn get_cubic_fractal_set(
642 &mut self,
643 x_start: i32,
644 y_start: i32,
645 z_start: i32,
646 x_size: i32,
647 y_size: i32,
648 z_size: i32,
649 scale_modifier: f32
650 ) -> NoiseSet {
651 let inner = unsafe {
652 (*self.inner).GetCubicFractalSet(
653 x_start,
654 y_start,
655 z_start,
656 x_size,
657 y_size,
658 z_size,
659 scale_modifier
660 )
661 };
662
663 NoiseSet {
664 inner,
665 x_start,
666 y_start,
667 z_start,
668 x_size,
669 y_size,
670 z_size,
671 }
672 }
673}