Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
bfa3e606
R
Rust
项目概览
int
/
Rust
11 个月 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
bfa3e606
编写于
2月 14, 2014
作者:
B
Ben Striegel
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Clean up the Perlin noise benchmark
上级
92c5738a
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
49 addition
and
65 deletion
+49
-65
src/test/bench/noise.rs
src/test/bench/noise.rs
+49
-65
未找到文件。
src/test/bench/noise.rs
浏览文件 @
bfa3e606
...
...
@@ -8,128 +8,112 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Perlin noise benchmark from https://gist.github.com/1170424
// Multi-language Perlin noise benchmark.
// See https://github.com/nsf/pnoise for timings and alternative implementations.
use
std
::
f64
;
use
std
::
rand
::
Rng
;
use
std
::
rand
;
use
std
::
f32
::
consts
::
PI
;
use
std
::
rand
::{
Rng
,
StdRng
};
struct
Vec2
{
x
:
f32
,
y
:
f32
,
}
#[inline(always)]
fn
lerp
(
a
:
f32
,
b
:
f32
,
v
:
f32
)
->
f32
{
a
*
(
1.0
-
v
)
+
b
*
v
}
#[inline(always)]
fn
smooth
(
v
:
f32
)
->
f32
{
v
*
v
*
(
3.0
-
2.0
*
v
)
}
fn
random_gradient
<
R
:
Rng
>
(
r
:
&
mut
R
)
->
Vec2
{
let
v
=
2.0
*
f64
::
consts
::
PI
*
r
.gen
();
Vec2
{
x
:
v
.cos
()
as
f32
,
y
:
v
.sin
()
as
f32
,
}
fn
random_gradient
<
R
:
Rng
>
(
r
:
&
mut
R
)
->
Vec2
{
let
v
=
PI
*
2.0
*
r
.gen
();
Vec2
{
x
:
v
.cos
(),
y
:
v
.sin
()
}
}
fn
gradient
(
orig
:
Vec2
,
grad
:
Vec2
,
p
:
Vec2
)
->
f32
{
let
sp
=
Vec2
{
x
:
p
.x
-
orig
.x
,
y
:
p
.y
-
orig
.y
};
grad
.x
*
sp
.x
+
grad
.y
*
sp
.y
(
p
.x
-
orig
.x
)
*
grad
.x
+
(
p
.y
-
orig
.y
)
*
grad
.y
}
struct
Noise2DContext
{
rgradients
:
[
Vec2
,
..
256
],
permutations
:
[
i
nt
,
..
256
],
permutations
:
[
i
32
,
..
256
],
}
impl
Noise2DContext
{
pub
fn
new
()
->
Noise2DContext
{
let
mut
r
=
rand
::
rng
();
let
mut
rgradients
=
[
Vec2
{
x
:
0.0
,
y
:
0.0
},
..
256
];
for
i
in
range
(
0
,
256
)
{
rgradients
[
i
]
=
random_gradient
(
&
mut
r
);
}
let
mut
permutations
=
[
0
,
..
256
];
for
i
in
range
(
0
,
256
)
{
permutations
[
i
]
=
i
;
fn
new
()
->
Noise2DContext
{
let
mut
rng
=
StdRng
::
new
();
let
mut
rgradients
=
[
Vec2
{
x
:
0.0
,
y
:
0.0
},
..
256
];
for
x
in
rgradients
.mut_iter
()
{
*
x
=
random_gradient
(
&
mut
rng
);
}
r
.shuffle_mut
(
permutations
);
Noise2DContext
{
rgradients
:
rgradients
,
permutations
:
permutations
,
let
mut
permutations
=
[
0i32
,
..
256
];
for
(
i
,
x
)
in
permutations
.mut_iter
()
.enumerate
()
{
*
x
=
i
as
i32
;
}
rng
.shuffle_mut
(
permutations
);
Noise2DContext
{
rgradients
:
rgradients
,
permutations
:
permutations
}
}
#[inline(always)]
pub
fn
get_gradient
(
&
self
,
x
:
int
,
y
:
int
)
->
Vec2
{
fn
get_gradient
(
&
self
,
x
:
i32
,
y
:
i32
)
->
Vec2
{
let
idx
=
self
.permutations
[
x
&
255
]
+
self
.permutations
[
y
&
255
];
self
.rgradients
[
idx
&
255
]
}
#[inline]
pub
fn
get_gradients
(
&
self
,
gradients
:
&
mut
[
Vec2
,
..
4
],
origins
:
&
mut
[
Vec2
,
..
4
],
x
:
f32
,
y
:
f32
)
{
fn
get_gradients
(
&
self
,
x
:
f32
,
y
:
f32
)
->
([
Vec2
,
..
4
],
[
Vec2
,
..
4
])
{
let
x0f
=
x
.floor
();
let
y0f
=
y
.floor
();
let
x0
=
x0f
as
int
;
let
y0
=
y0f
as
int
;
let
x1f
=
x0f
+
1.0
;
let
y1f
=
y0f
+
1.0
;
let
x0
=
x0f
as
i32
;
let
y0
=
y0f
as
i32
;
let
x1
=
x0
+
1
;
let
y1
=
y0
+
1
;
gradients
[
0
]
=
self
.get_gradient
(
x0
,
y0
);
gradients
[
1
]
=
self
.get_gradient
(
x1
,
y0
);
gradients
[
2
]
=
self
.get_gradient
(
x0
,
y1
);
gradients
[
3
]
=
self
.get_gradient
(
x1
,
y1
);
origins
[
0
]
=
Vec2
{
x
:
x0f
+
0.0
,
y
:
y0f
+
0.0
};
origins
[
1
]
=
Vec2
{
x
:
x0f
+
1.0
,
y
:
y0f
+
0.0
};
origins
[
2
]
=
Vec2
{
x
:
x0f
+
0.0
,
y
:
y0f
+
1.0
};
origins
[
3
]
=
Vec2
{
x
:
x0f
+
1.0
,
y
:
y0f
+
1.0
};
([
self
.get_gradient
(
x0
,
y0
),
self
.get_gradient
(
x1
,
y0
),
self
.get_gradient
(
x0
,
y1
),
self
.get_gradient
(
x1
,
y1
)],
[
Vec2
{
x
:
x0f
,
y
:
y0f
},
Vec2
{
x
:
x1f
,
y
:
y0f
},
Vec2
{
x
:
x0f
,
y
:
y1f
},
Vec2
{
x
:
x1f
,
y
:
y1f
}])
}
#[inline]
pub
fn
get
(
&
self
,
x
:
f32
,
y
:
f32
)
->
f32
{
fn
get
(
&
self
,
x
:
f32
,
y
:
f32
)
->
f32
{
let
p
=
Vec2
{
x
:
x
,
y
:
y
};
let
mut
gradients
=
[
Vec2
{
x
:
0.0
,
y
:
0.0
},
..
4
];
let
mut
origins
=
[
Vec2
{
x
:
0.0
,
y
:
0.0
},
..
4
];
self
.get_gradients
(
&
mut
gradients
,
&
mut
origins
,
x
,
y
);
let
(
gradients
,
origins
)
=
self
.get_gradients
(
x
,
y
);
let
v0
=
gradient
(
origins
[
0
],
gradients
[
0
],
p
);
let
v1
=
gradient
(
origins
[
1
],
gradients
[
1
],
p
);
let
v2
=
gradient
(
origins
[
2
],
gradients
[
2
],
p
);
let
v3
=
gradient
(
origins
[
3
],
gradients
[
3
],
p
);
let
fx
=
smooth
(
x
-
origins
[
0
]
.x
);
let
vx0
=
lerp
(
v0
,
v1
,
fx
);
let
vx1
=
lerp
(
v2
,
v3
,
fx
);
let
fy
=
smooth
(
y
-
origins
[
0
]
.y
);
lerp
(
vx0
,
vx1
,
fy
)
}
}
fn
main
()
{
let
symbols
=
[
" "
,
"░"
,
"▒"
,
"▓"
,
"█"
,
"█"
];
let
symbols
=
[
' '
,
'░'
,
'▒'
,
'▓'
,
'█'
,
'█'
];
let
mut
pixels
=
[
0f32
,
..
256
*
256
];
let
n2d
=
~
Noise2DContext
::
new
();
for
_
in
range
(
0
,
100u
)
{
let
n2d
=
Noise2DContext
::
new
();
for
_
in
range
(
0
,
100
)
{
for
y
in
range
(
0
,
256
)
{
for
x
in
range
(
0
,
256
)
{
let
v
=
n2d
.get
(
x
as
f32
*
0.1f32
,
y
as
f32
*
0.1f32
)
*
0.5f32
+
0.5f32
;
pixels
[
y
*
256
+
x
]
=
v
;
};
};
};
let
v
=
n2d
.get
(
x
as
f32
*
0.1
,
y
as
f32
*
0.1
);
pixels
[
y
*
256
+
x
]
=
v
*
0.5
+
0.5
;
}
}
}
for
y
in
range
(
0
,
256
)
{
for
x
in
range
(
0
,
256
)
{
print!
(
"{}"
,
symbols
[(
pixels
[
y
*
256
+
x
]
/
0.2f32
)
as
int
]);
let
idx
=
(
pixels
[
y
*
256
+
x
]
/
0.2
)
as
uint
;
print!
(
"{:c}"
,
symbols
[
idx
]);
}
print
ln!
(
"
"
);
print
!
(
"
\n
"
);
}
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录