mirror of
https://gitlab.com/veloren/veloren.git
synced 2024-08-30 18:12:32 +00:00
1796c09ca1
See the doc comments in `common/src/vol.rs` for more information on
the API itself.
The changes include:
* Consistent `Err`/`Error` naming.
* Types are named `...Error`.
* `enum` variants are named `...Err`.
* Rename `VolMap{2d, 3d}` -> `VolGrid{2d, 3d}`. This is in preparation
to an upcoming change where a “map” in the game related sense will
be added.
* Add volume iterators. There are two types of them:
* _Position_ iterators obtained from the trait `IntoPosIterator`
using the method
`fn pos_iter(self, lower_bound: Vec3<i32>, upper_bound: Vec3<i32>) -> ...`
which returns an iterator over `Vec3<i32>`.
* _Volume_ iterators obtained from the trait `IntoVolIterator`
using the method
`fn vol_iter(self, lower_bound: Vec3<i32>, upper_bound: Vec3<i32>) -> ...`
which returns an iterator over `(Vec3<i32>, &Self::Vox)`.
Those traits will usually be implemented by references to volume
types (i.e. `impl IntoVolIterator<'a> for &'a T` where `T` is some
type which usually implements several volume traits, such as `Chunk`).
* _Position_ iterators iterate over the positions valid for that
volume.
* _Volume_ iterators do the same but return not only the position
but also the voxel at that position, in each iteration.
* Introduce trait `RectSizedVol` for the use case which we have with
`Chonk`: A `Chonk` is sized only in x and y direction.
* Introduce traits `RasterableVol`, `RectRasterableVol`
* `RasterableVol` represents a volume that is compile-time sized and has
its lower bound at `(0, 0, 0)`. The name `RasterableVol` was chosen
because such a volume can be used with `VolGrid3d`.
* `RectRasterableVol` represents a volume that is compile-time sized at
least in x and y direction and has its lower bound at `(0, 0, z)`.
There's no requirement on he lower bound or size in z direction.
The name `RectRasterableVol` was chosen because such a volume can be
used with `VolGrid2d`.
95 lines
2.8 KiB
Rust
95 lines
2.8 KiB
Rust
use crate::{
|
|
mesh::{vol, Meshable},
|
|
render::{self, FigurePipeline, Mesh, SpritePipeline},
|
|
};
|
|
use common::{
|
|
figure::Segment,
|
|
util::{linear_to_srgb, srgb_to_linear},
|
|
vol::{IntoFullVolIterator, Vox},
|
|
};
|
|
use vek::*;
|
|
|
|
type FigureVertex = <FigurePipeline as render::Pipeline>::Vertex;
|
|
type SpriteVertex = <SpritePipeline as render::Pipeline>::Vertex;
|
|
|
|
impl Meshable<FigurePipeline, FigurePipeline> for Segment {
|
|
type Pipeline = FigurePipeline;
|
|
type TranslucentPipeline = FigurePipeline;
|
|
type Supplement = Vec3<f32>;
|
|
|
|
fn generate_mesh(
|
|
&self,
|
|
offs: Self::Supplement,
|
|
) -> (Mesh<Self::Pipeline>, Mesh<Self::TranslucentPipeline>) {
|
|
let mut mesh = Mesh::new();
|
|
|
|
for (pos, vox) in self.full_vol_iter() {
|
|
if let Some(col) = vox.get_color() {
|
|
let col = col.map(|e| e as f32 / 255.0);
|
|
|
|
vol::push_vox_verts(
|
|
&mut mesh,
|
|
self,
|
|
pos,
|
|
offs + pos.map(|e| e as f32),
|
|
col,
|
|
|origin, norm, col, ao, light| {
|
|
FigureVertex::new(
|
|
origin,
|
|
norm,
|
|
linear_to_srgb(srgb_to_linear(col) * ao * light),
|
|
0,
|
|
)
|
|
},
|
|
true,
|
|
&[[[1.0; 3]; 3]; 3],
|
|
|vox| vox.is_empty(),
|
|
|vox| !vox.is_empty(),
|
|
);
|
|
}
|
|
}
|
|
|
|
(mesh, Mesh::new())
|
|
}
|
|
}
|
|
|
|
impl Meshable<SpritePipeline, SpritePipeline> for Segment {
|
|
type Pipeline = SpritePipeline;
|
|
type TranslucentPipeline = SpritePipeline;
|
|
type Supplement = Vec3<f32>;
|
|
|
|
fn generate_mesh(
|
|
&self,
|
|
offs: Self::Supplement,
|
|
) -> (Mesh<Self::Pipeline>, Mesh<Self::TranslucentPipeline>) {
|
|
let mut mesh = Mesh::new();
|
|
|
|
for (pos, vox) in self.full_vol_iter() {
|
|
if let Some(col) = vox.get_color() {
|
|
let col = col.map(|e| e as f32 / 255.0);
|
|
|
|
vol::push_vox_verts(
|
|
&mut mesh,
|
|
self,
|
|
pos,
|
|
offs + pos.map(|e| e as f32),
|
|
col,
|
|
|origin, norm, col, ao, light| {
|
|
SpriteVertex::new(
|
|
origin,
|
|
norm,
|
|
linear_to_srgb(srgb_to_linear(col) * ao * light),
|
|
)
|
|
},
|
|
true,
|
|
&[[[1.0; 3]; 3]; 3],
|
|
|vox| vox.is_empty(),
|
|
|vox| !vox.is_empty(),
|
|
);
|
|
}
|
|
}
|
|
|
|
(mesh, Mesh::new())
|
|
}
|
|
}
|