Survivalcraft API 1.8.2.3 v1.8.2.3
Survivalcraft 2.4
载入中...
搜索中...
未找到
SimplexNoise.cs
浏览该文件的文档.
1namespace Game {
2 public static class SimplexNoise {
3 public static int[][] m_grad3 = [
4 [1, 1, 0],
5 [-1, 1, 0],
6 [1, -1, 0],
7 [-1, -1, 0],
8 [1, 0, 1],
9 [-1, 0, 1],
10 [1, 0, -1],
11 [-1, 0, -1],
12 [0, 1, 1],
13 [0, -1, 1],
14 [0, 1, -1],
15 [0, -1, -1]
16 ];
17
18 public static int[] m_permutations = [
19 151,
20 160,
21 137,
22 91,
23 90,
24 15,
25 131,
26 13,
27 201,
28 95,
29 96,
30 53,
31 194,
32 233,
33 7,
34 225,
35 140,
36 36,
37 103,
38 30,
39 69,
40 142,
41 8,
42 99,
43 37,
44 240,
45 21,
46 10,
47 23,
48 190,
49 6,
50 148,
51 247,
52 120,
53 234,
54 75,
55 0,
56 26,
57 197,
58 62,
59 94,
60 252,
61 219,
62 203,
63 117,
64 35,
65 11,
66 32,
67 57,
68 177,
69 33,
70 88,
71 237,
72 149,
73 56,
74 87,
75 174,
76 20,
77 125,
78 136,
79 171,
80 168,
81 68,
82 175,
83 74,
84 165,
85 71,
86 134,
87 139,
88 48,
89 27,
90 166,
91 77,
92 146,
93 158,
94 231,
95 83,
96 111,
97 229,
98 122,
99 60,
100 211,
101 133,
102 230,
103 220,
104 105,
105 92,
106 41,
107 55,
108 46,
109 245,
110 40,
111 244,
112 102,
113 143,
114 54,
115 65,
116 25,
117 63,
118 161,
119 1,
120 216,
121 80,
122 73,
123 209,
124 76,
125 132,
126 187,
127 208,
128 89,
129 18,
130 169,
131 200,
132 196,
133 135,
134 130,
135 116,
136 188,
137 159,
138 86,
139 164,
140 100,
141 109,
142 198,
143 173,
144 186,
145 3,
146 64,
147 52,
148 217,
149 226,
150 250,
151 124,
152 123,
153 5,
154 202,
155 38,
156 147,
157 118,
158 126,
159 255,
160 82,
161 85,
162 212,
163 207,
164 206,
165 59,
166 227,
167 47,
168 16,
169 58,
170 17,
171 182,
172 189,
173 28,
174 42,
175 223,
176 183,
177 170,
178 213,
179 119,
180 248,
181 152,
182 2,
183 44,
184 154,
185 163,
186 70,
187 221,
188 153,
189 101,
190 155,
191 167,
192 43,
193 172,
194 9,
195 129,
196 22,
197 39,
198 253,
199 19,
200 98,
201 108,
202 110,
203 79,
204 113,
205 224,
206 232,
207 178,
208 185,
209 112,
210 104,
211 218,
212 246,
213 97,
214 228,
215 251,
216 34,
217 242,
218 193,
219 238,
220 210,
221 144,
222 12,
223 191,
224 179,
225 162,
226 241,
227 81,
228 51,
229 145,
230 235,
231 249,
232 14,
233 239,
234 107,
235 49,
236 192,
237 214,
238 31,
239 181,
240 199,
241 106,
242 157,
243 184,
244 84,
245 204,
246 176,
247 115,
248 121,
249 50,
250 45,
251 127,
252 4,
253 150,
254 254,
255 138,
256 236,
257 205,
258 93,
259 222,
260 114,
261 67,
262 29,
263 24,
264 72,
265 243,
266 141,
267 128,
268 195,
269 78,
270 66,
271 215,
272 61,
273 156,
274 180,
275 151,
276 160,
277 137,
278 91,
279 90,
280 15,
281 131,
282 13,
283 201,
284 95,
285 96,
286 53,
287 194,
288 233,
289 7,
290 225,
291 140,
292 36,
293 103,
294 30,
295 69,
296 142,
297 8,
298 99,
299 37,
300 240,
301 21,
302 10,
303 23,
304 190,
305 6,
306 148,
307 247,
308 120,
309 234,
310 75,
311 0,
312 26,
313 197,
314 62,
315 94,
316 252,
317 219,
318 203,
319 117,
320 35,
321 11,
322 32,
323 57,
324 177,
325 33,
326 88,
327 237,
328 149,
329 56,
330 87,
331 174,
332 20,
333 125,
334 136,
335 171,
336 168,
337 68,
338 175,
339 74,
340 165,
341 71,
342 134,
343 139,
344 48,
345 27,
346 166,
347 77,
348 146,
349 158,
350 231,
351 83,
352 111,
353 229,
354 122,
355 60,
356 211,
357 133,
358 230,
359 220,
360 105,
361 92,
362 41,
363 55,
364 46,
365 245,
366 40,
367 244,
368 102,
369 143,
370 54,
371 65,
372 25,
373 63,
374 161,
375 1,
376 216,
377 80,
378 73,
379 209,
380 76,
381 132,
382 187,
383 208,
384 89,
385 18,
386 169,
387 200,
388 196,
389 135,
390 130,
391 116,
392 188,
393 159,
394 86,
395 164,
396 100,
397 109,
398 198,
399 173,
400 186,
401 3,
402 64,
403 52,
404 217,
405 226,
406 250,
407 124,
408 123,
409 5,
410 202,
411 38,
412 147,
413 118,
414 126,
415 255,
416 82,
417 85,
418 212,
419 207,
420 206,
421 59,
422 227,
423 47,
424 16,
425 58,
426 17,
427 182,
428 189,
429 28,
430 42,
431 223,
432 183,
433 170,
434 213,
435 119,
436 248,
437 152,
438 2,
439 44,
440 154,
441 163,
442 70,
443 221,
444 153,
445 101,
446 155,
447 167,
448 43,
449 172,
450 9,
451 129,
452 22,
453 39,
454 253,
455 19,
456 98,
457 108,
458 110,
459 79,
460 113,
461 224,
462 232,
463 178,
464 185,
465 112,
466 104,
467 218,
468 246,
469 97,
470 228,
471 251,
472 34,
473 242,
474 193,
475 238,
476 210,
477 144,
478 12,
479 191,
480 179,
481 162,
482 241,
483 81,
484 51,
485 145,
486 235,
487 249,
488 14,
489 239,
490 107,
491 49,
492 192,
493 214,
494 31,
495 181,
496 199,
497 106,
498 157,
499 184,
500 84,
501 204,
502 176,
503 115,
504 121,
505 50,
506 45,
507 127,
508 4,
509 150,
510 254,
511 138,
512 236,
513 205,
514 93,
515 222,
516 114,
517 67,
518 29,
519 24,
520 72,
521 243,
522 141,
523 128,
524 195,
525 78,
526 66,
527 215,
528 61,
529 156,
530 180
531 ];
532
533 public static float Dot(int[] g, float x, float y) => g[0] * x + g[1] * y;
534
535 public static float Dot(int[] g, float x, float y, float z) => g[0] * x + g[1] * y + g[2] * z;
536
537 public static float Hash(int x) {
538 x = (x << 13) ^ x;
539 return ((x * (x * x * 15731 + 789221) + 1376312589) & 0x7FFFFFFF) / 2.14748365E+09f;
540 }
541
542 public static float Noise(float x) {
543 int num = (int)MathF.Floor(x);
544 int x2 = (int)MathF.Ceiling(x);
545 float num2 = x - num;
546 float num3 = Hash(num);
547 float num4 = Hash(x2);
548 return num3 + num2 * num2 * (3f - 2f * num2) * (num4 - num3);
549 }
550
551 public static float Noise(float x, float y) {
552 float num = (x + y) * 0.366025418f;
553 int num2 = (int)MathF.Floor(x + num);
554 int num3 = (int)MathF.Floor(y + num);
555 float num4 = (num2 + num3) * 0.211324871f;
556 float num5 = num2 - num4;
557 float num6 = num3 - num4;
558 float num7 = x - num5;
559 float num8 = y - num6;
560 int num9;
561 int num10;
562 if (num7 > num8) {
563 num9 = 1;
564 num10 = 0;
565 }
566 else {
567 num9 = 0;
568 num10 = 1;
569 }
570 float num11 = num7 - num9 + 0.211324871f;
571 float num12 = num8 - num10 + 0.211324871f;
572 float num13 = num7 - 1f + 0.422649741f;
573 float num14 = num8 - 1f + 0.422649741f;
574 int num15 = num2 & 0xFF;
575 int num16 = num3 & 0xFF;
576 int num17 = m_permutations[num15 + m_permutations[num16]] % 12;
577 int num18 = m_permutations[num15 + num9 + m_permutations[num16 + num10]] % 12;
578 int num19 = m_permutations[num15 + 1 + m_permutations[num16 + 1]] % 12;
579 float num20 = 0.5f - num7 * num7 - num8 * num8;
580 float num21;
581 if (num20 < 0f) {
582 num21 = 0f;
583 }
584 else {
585 num20 *= num20;
586 num21 = num20 * num20 * Dot(m_grad3[num17], num7, num8);
587 }
588 float num22 = 0.5f - num11 * num11 - num12 * num12;
589 float num23;
590 if (num22 < 0f) {
591 num23 = 0f;
592 }
593 else {
594 num22 *= num22;
595 num23 = num22 * num22 * Dot(m_grad3[num18], num11, num12);
596 }
597 float num24 = 0.5f - num13 * num13 - num14 * num14;
598 float num25;
599 if (num24 < 0f) {
600 num25 = 0f;
601 }
602 else {
603 num24 *= num24;
604 num25 = num24 * num24 * Dot(m_grad3[num19], num13, num14);
605 }
606 return 35f * (num21 + num23 + num25) + 0.5f;
607 }
608
609 public static float Noise(float x, float y, float z) {
610 float num = (x + y + z) * 0.333333343f;
611 int num2 = (int)MathF.Floor(x + num);
612 int num3 = (int)MathF.Floor(y + num);
613 int num4 = (int)MathF.Floor(z + num);
614 float num5 = (num2 + num3 + num4) * (355f / (678f * (float)Math.PI));
615 float num6 = num2 - num5;
616 float num7 = num3 - num5;
617 float num8 = num4 - num5;
618 float num9 = x - num6;
619 float num10 = y - num7;
620 float num11 = z - num8;
621 int num12;
622 int num13;
623 int num14;
624 int num15;
625 int num16;
626 int num17;
627 if (num9 >= num10) {
628 if (num10 >= num11) {
629 num12 = 1;
630 num13 = 0;
631 num14 = 0;
632 num15 = 1;
633 num16 = 1;
634 num17 = 0;
635 }
636 else if (num9 >= num11) {
637 num12 = 1;
638 num13 = 0;
639 num14 = 0;
640 num15 = 1;
641 num16 = 0;
642 num17 = 1;
643 }
644 else {
645 num12 = 0;
646 num13 = 0;
647 num14 = 1;
648 num15 = 1;
649 num16 = 0;
650 num17 = 1;
651 }
652 }
653 else if (num10 < num11) {
654 num12 = 0;
655 num13 = 0;
656 num14 = 1;
657 num15 = 0;
658 num16 = 1;
659 num17 = 1;
660 }
661 else if (num9 < num11) {
662 num12 = 0;
663 num13 = 1;
664 num14 = 0;
665 num15 = 0;
666 num16 = 1;
667 num17 = 1;
668 }
669 else {
670 num12 = 0;
671 num13 = 1;
672 num14 = 0;
673 num15 = 1;
674 num16 = 1;
675 num17 = 0;
676 }
677 float num18 = num9 - num12 + 355f / (678f * (float)Math.PI);
678 float num19 = num10 - num13 + 355f / (678f * (float)Math.PI);
679 float num20 = num11 - num14 + 355f / (678f * (float)Math.PI);
680 float num21 = num9 - num15 + 0.333333343f;
681 float num22 = num10 - num16 + 0.333333343f;
682 float num23 = num11 - num17 + 0.333333343f;
683 float num24 = num9 - 1f + 0.5f;
684 float num25 = num10 - 1f + 0.5f;
685 float num26 = num11 - 1f + 0.5f;
686 int num27 = num2 & 0xFF;
687 int num28 = num3 & 0xFF;
688 int num29 = num4 & 0xFF;
689 int num30 = m_permutations[num27 + m_permutations[num28 + m_permutations[num29]]] % 12;
690 int num31 = m_permutations[num27 + num12 + m_permutations[num28 + num13 + m_permutations[num29 + num14]]] % 12;
691 int num32 = m_permutations[num27 + num15 + m_permutations[num28 + num16 + m_permutations[num29 + num17]]] % 12;
692 int num33 = m_permutations[num27 + 1 + m_permutations[num28 + 1 + m_permutations[num29 + 1]]] % 12;
693 float num34 = 0.6f - num9 * num9 - num10 * num10 - num11 * num11;
694 float num35;
695 if (num34 < 0f) {
696 num35 = 0f;
697 }
698 else {
699 num34 *= num34;
700 num35 = num34 * num34 * Dot(m_grad3[num30], num9, num10, num11);
701 }
702 float num36 = 0.6f - num18 * num18 - num19 * num19 - num20 * num20;
703 float num37;
704 if (num36 < 0f) {
705 num37 = 0f;
706 }
707 else {
708 num36 *= num36;
709 num37 = num36 * num36 * Dot(m_grad3[num31], num18, num19, num20);
710 }
711 float num38 = 0.6f - num21 * num21 - num22 * num22 - num23 * num23;
712 float num39;
713 if (num38 < 0f) {
714 num39 = 0f;
715 }
716 else {
717 num38 *= num38;
718 num39 = num38 * num38 * Dot(m_grad3[num32], num21, num22, num23);
719 }
720 float num40 = 0.6f - num24 * num24 - num25 * num25 - num26 * num26;
721 float num41;
722 if (num40 < 0f) {
723 num41 = 0f;
724 }
725 else {
726 num40 *= num40;
727 num41 = num40 * num40 * Dot(m_grad3[num33], num24, num25, num26);
728 }
729 return 16f * (num35 + num37 + num39 + num41) + 0.5f;
730 }
731
732 public static float OctavedNoise(float x, float frequency, int octaves, float frequencyStep, float amplitudeStep, bool ridged = false) {
733 float num = 0f;
734 float num2 = 0f;
735 float num3 = 1f;
736 for (int i = 0; i < octaves; i++) {
737 num += num3 * Noise(x * frequency);
738 num2 += num3;
739 frequency *= frequencyStep;
740 num3 *= amplitudeStep;
741 }
742 return !ridged ? num / num2 : 1f - MathF.Abs(2f * num / num2 - 1f);
743 }
744
745 public static float OctavedNoise(float x,
746 float y,
747 float frequency,
748 int octaves,
749 float frequencyStep,
750 float amplitudeStep,
751 bool ridged = false) {
752 float num = 0f;
753 float num2 = 0f;
754 float num3 = 1f;
755 for (int i = 0; i < octaves; i++) {
756 num += num3 * Noise(x * frequency, y * frequency);
757 num2 += num3;
758 frequency *= frequencyStep;
759 num3 *= amplitudeStep;
760 }
761 return !ridged ? num / num2 : 1f - MathF.Abs(2f * num / num2 - 1f);
762 }
763
764 public static float OctavedNoise(float x,
765 float y,
766 float z,
767 float frequency,
768 int octaves,
769 float frequencyStep,
770 float amplitudeStep,
771 bool ridged = false) {
772 float num = 0f;
773 float num2 = 0f;
774 float num3 = 1f;
775 for (int i = 0; i < octaves; i++) {
776 num += num3 * Noise(x * frequency, y * frequency, z * frequency);
777 num2 += num3;
778 frequency *= frequencyStep;
779 num3 *= amplitudeStep;
780 }
781 return !ridged ? num / num2 : 1f - MathF.Abs(2f * num / num2 - 1f);
782 }
783 }
784}
Game.SimplexNoise.m_grad3
static int[][] m_grad3
定义 SimplexNoise.cs:3
Game.SimplexNoise.Noise
static float Noise(float x, float y)
定义 SimplexNoise.cs:551
Game.SimplexNoise.Hash
static float Hash(int x)
定义 SimplexNoise.cs:537
Game.SimplexNoise.Dot
static float Dot(int[] g, float x, float y)
定义 SimplexNoise.cs:533
Game.SimplexNoise.Dot
static float Dot(int[] g, float x, float y, float z)
定义 SimplexNoise.cs:535
Game.SimplexNoise.OctavedNoise
static float OctavedNoise(float x, float y, float frequency, int octaves, float frequencyStep, float amplitudeStep, bool ridged=false)
定义 SimplexNoise.cs:745
Game.SimplexNoise.Noise
static float Noise(float x)
定义 SimplexNoise.cs:542
Game.SimplexNoise.OctavedNoise
static float OctavedNoise(float x, float frequency, int octaves, float frequencyStep, float amplitudeStep, bool ridged=false)
定义 SimplexNoise.cs:732
Game.SimplexNoise.Noise
static float Noise(float x, float y, float z)
定义 SimplexNoise.cs:609
Game.SimplexNoise.m_permutations
static int[] m_permutations
定义 SimplexNoise.cs:18
Game.SimplexNoise.OctavedNoise
static float OctavedNoise(float x, float y, float z, float frequency, int octaves, float frequencyStep, float amplitudeStep, bool ridged=false)
定义 SimplexNoise.cs:764