mirror of
https://github.com/Relintai/pandemonium_engine.git
synced 2024-12-22 11:56:49 +01:00
520 lines
18 KiB
C++
520 lines
18 KiB
C++
/*************************************************************************/
|
|
/* voxel_mesher_blocky.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* PANDEMONIUM ENGINE */
|
|
/* https://github.com/Relintai/pandemonium_engine */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2022-present Péter Magyar. */
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
#include "voxel_mesher_blocky.h"
|
|
|
|
#include "../../world/default/voxel_chunk_default.h"
|
|
|
|
bool VoxelMesherBlocky::get_always_add_colors() const {
|
|
return _always_add_colors;
|
|
}
|
|
void VoxelMesherBlocky::set_always_add_colors(const bool value) {
|
|
_always_add_colors = value;
|
|
}
|
|
|
|
void VoxelMesherBlocky::_add_chunk(Ref<VoxelChunk> p_chunk) {
|
|
Ref<VoxelChunkDefault> chunk = p_chunk;
|
|
|
|
ERR_FAIL_COND(!chunk.is_valid());
|
|
|
|
//if ((get_build_flags() & VoxelChunkDefault::BUILD_FLAG_GENERATE_AO) != 0)
|
|
// if (!chunk->get_channel(VoxelChunkDefault::DEFAULT_CHANNEL_AO))
|
|
// chunk->generate_ao();
|
|
|
|
int x_size = chunk->get_size_x();
|
|
int y_size = chunk->get_size_y();
|
|
int z_size = chunk->get_size_z();
|
|
|
|
float voxel_scale = get_voxel_scale();
|
|
|
|
uint8_t *channel_type = chunk->channel_get(_channel_index_type);
|
|
|
|
if (!channel_type)
|
|
return;
|
|
|
|
uint8_t *channel_color_r = NULL;
|
|
uint8_t *channel_color_g = NULL;
|
|
uint8_t *channel_color_b = NULL;
|
|
uint8_t *channel_ao = NULL;
|
|
uint8_t *channel_rao = NULL;
|
|
|
|
Color base_light(_base_light_value, _base_light_value, _base_light_value);
|
|
Color light(1, 1, 1);
|
|
bool use_lighting = (get_build_flags() & VoxelChunkDefault::BUILD_FLAG_USE_LIGHTING) != 0;
|
|
bool use_ao = (get_build_flags() & VoxelChunkDefault::BUILD_FLAG_USE_AO) != 0;
|
|
bool use_rao = (get_build_flags() & VoxelChunkDefault::BUILD_FLAG_USE_RAO) != 0;
|
|
|
|
if (use_lighting) {
|
|
channel_color_r = chunk->channel_get(VoxelChunkDefault::DEFAULT_CHANNEL_LIGHT_COLOR_R);
|
|
channel_color_g = chunk->channel_get(VoxelChunkDefault::DEFAULT_CHANNEL_LIGHT_COLOR_G);
|
|
channel_color_b = chunk->channel_get(VoxelChunkDefault::DEFAULT_CHANNEL_LIGHT_COLOR_B);
|
|
|
|
if (use_ao)
|
|
channel_ao = chunk->channel_get(VoxelChunkDefault::DEFAULT_CHANNEL_AO);
|
|
|
|
if (use_rao)
|
|
channel_rao = chunk->channel_get(VoxelChunkDefault::DEFAULT_CHANNEL_RANDOM_AO);
|
|
}
|
|
|
|
Vector<uint8_t> liquids;
|
|
for (int i = 0; i < _library->voxel_surface_get_num(); ++i) {
|
|
Ref<VoxelSurface> surface = _library->voxel_surface_get(i);
|
|
|
|
if (!surface.is_valid())
|
|
continue;
|
|
|
|
if (surface->get_liquid())
|
|
liquids.push_back(static_cast<uint8_t>(i + 1));
|
|
}
|
|
|
|
for (int y = chunk->get_margin_start(); y < y_size + chunk->get_margin_start(); ++y) {
|
|
for (int z = chunk->get_margin_start(); z < z_size + chunk->get_margin_start(); ++z) {
|
|
for (int x = chunk->get_margin_start(); x < x_size + chunk->get_margin_start(); ++x) {
|
|
int index = chunk->get_data_index(x, y, z);
|
|
int indexxp = chunk->get_data_index(x + 1, y, z);
|
|
int indexxn = chunk->get_data_index(x - 1, y, z);
|
|
int indexyp = chunk->get_data_index(x, y + 1, z);
|
|
int indexyn = chunk->get_data_index(x, y - 1, z);
|
|
int indexzp = chunk->get_data_index(x, y, z + 1);
|
|
int indexzn = chunk->get_data_index(x, y, z - 1);
|
|
|
|
uint8_t type = channel_type[index];
|
|
|
|
if (type == 0)
|
|
continue;
|
|
|
|
if (liquids.find(type) != -1)
|
|
continue;
|
|
|
|
Ref<VoxelSurface> surface = _library->voxel_surface_get(type - 1);
|
|
|
|
if (!surface.is_valid())
|
|
continue;
|
|
|
|
uint8_t neighbours[] = {
|
|
channel_type[indexxp],
|
|
channel_type[indexxn],
|
|
channel_type[indexyp],
|
|
channel_type[indexyn],
|
|
channel_type[indexzp],
|
|
channel_type[indexzn],
|
|
};
|
|
|
|
for (int i = 0; i < 6; ++i) {
|
|
if (liquids.find(neighbours[i]) != -1) {
|
|
neighbours[i] = 0;
|
|
}
|
|
}
|
|
|
|
//x + 1
|
|
if (neighbours[0] == 0) {
|
|
if (use_lighting) {
|
|
light = Color(channel_color_r[indexxp] / 255.0,
|
|
channel_color_g[indexxp] / 255.0,
|
|
channel_color_b[indexxp] / 255.0);
|
|
|
|
float ao = 0;
|
|
|
|
if (use_ao)
|
|
ao = channel_ao[indexxp] / 255.0;
|
|
|
|
if (use_rao) {
|
|
float rao = channel_rao[indexxp] / 255.0;
|
|
ao += rao;
|
|
}
|
|
|
|
light += base_light;
|
|
|
|
if (ao > 0)
|
|
light -= Color(ao, ao, ao) * _ao_strength;
|
|
|
|
light.r = CLAMP(light.r, 0, 1.0);
|
|
light.g = CLAMP(light.g, 0, 1.0);
|
|
light.b = CLAMP(light.b, 0, 1.0);
|
|
}
|
|
|
|
int vc = get_vertex_count();
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 1);
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 3);
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 0);
|
|
|
|
Vector2 uvs[] = {
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale())
|
|
};
|
|
|
|
Vector3 verts[] = {
|
|
Vector3(1, 0, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 1, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 1, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 0, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale
|
|
};
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
add_normal(Vector3(1, 0, 0));
|
|
|
|
if (use_lighting || _always_add_colors)
|
|
add_color(light);
|
|
|
|
add_uv(uvs[i]);
|
|
add_vertex(verts[i]);
|
|
}
|
|
}
|
|
|
|
//x - 1
|
|
if (neighbours[1] == 0) {
|
|
if (use_lighting) {
|
|
light = Color(channel_color_r[indexxn] / 255.0,
|
|
channel_color_g[indexxn] / 255.0,
|
|
channel_color_b[indexxn] / 255.0);
|
|
|
|
float ao = 0;
|
|
|
|
if (use_ao)
|
|
ao = channel_ao[indexxn] / 255.0;
|
|
|
|
if (use_rao) {
|
|
float rao = channel_rao[indexxn] / 255.0;
|
|
ao += rao;
|
|
}
|
|
|
|
light += base_light;
|
|
|
|
if (ao > 0)
|
|
light -= Color(ao, ao, ao) * _ao_strength;
|
|
|
|
light.r = CLAMP(light.r, 0, 1.0);
|
|
light.g = CLAMP(light.g, 0, 1.0);
|
|
light.b = CLAMP(light.b, 0, 1.0);
|
|
}
|
|
|
|
int vc = get_vertex_count();
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 1);
|
|
add_indices(vc + 2);
|
|
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 3);
|
|
|
|
Vector2 uvs[] = {
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale())
|
|
};
|
|
|
|
Vector3 verts[] = {
|
|
Vector3(0, 0, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 1, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 1, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 0, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale
|
|
};
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
add_normal(Vector3(-1, 0, 0));
|
|
|
|
if (use_lighting || _always_add_colors)
|
|
add_color(light);
|
|
|
|
add_uv(uvs[i]);
|
|
add_vertex(verts[i]);
|
|
}
|
|
}
|
|
|
|
//y + 1
|
|
if (neighbours[2] == 0) {
|
|
if (use_lighting) {
|
|
light = Color(channel_color_r[indexyp] / 255.0,
|
|
channel_color_g[indexyp] / 255.0,
|
|
channel_color_b[indexyp] / 255.0);
|
|
|
|
float ao = 0;
|
|
|
|
if (use_ao)
|
|
ao = channel_ao[indexyp] / 255.0;
|
|
|
|
if (use_rao) {
|
|
float rao = channel_rao[indexyp] / 255.0;
|
|
ao += rao;
|
|
}
|
|
|
|
light += base_light;
|
|
|
|
if (ao > 0)
|
|
light -= Color(ao, ao, ao) * _ao_strength;
|
|
}
|
|
|
|
light.r = CLAMP(light.r, 0, 1.0);
|
|
light.g = CLAMP(light.g, 0, 1.0);
|
|
light.b = CLAMP(light.b, 0, 1.0);
|
|
|
|
int vc = get_vertex_count();
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 1);
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 3);
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 0);
|
|
|
|
Vector2 uvs[] = {
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale())
|
|
};
|
|
|
|
Vector3 verts[] = {
|
|
Vector3(1, 1, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 1, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 1, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 1, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale
|
|
};
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
add_normal(Vector3(0, 1, 0));
|
|
|
|
if (use_lighting || _always_add_colors)
|
|
add_color(light);
|
|
|
|
add_uv(uvs[i]);
|
|
add_vertex(verts[i]);
|
|
}
|
|
}
|
|
|
|
//y - 1
|
|
if (neighbours[3] == 0) {
|
|
if (use_lighting) {
|
|
light = Color(channel_color_r[indexyn] / 255.0,
|
|
channel_color_g[indexyn] / 255.0,
|
|
channel_color_b[indexyn] / 255.0);
|
|
|
|
float ao = 0;
|
|
|
|
if (use_ao)
|
|
ao = channel_ao[indexyn] / 255.0;
|
|
|
|
if (use_rao) {
|
|
float rao = channel_rao[indexyn] / 255.0;
|
|
ao += rao;
|
|
}
|
|
|
|
light += base_light;
|
|
|
|
if (ao > 0)
|
|
light -= Color(ao, ao, ao) * _ao_strength;
|
|
}
|
|
|
|
light.r = CLAMP(light.r, 0, 1.0);
|
|
light.g = CLAMP(light.g, 0, 1.0);
|
|
light.b = CLAMP(light.b, 0, 1.0);
|
|
|
|
int vc = get_vertex_count();
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 1);
|
|
add_indices(vc + 2);
|
|
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 3);
|
|
|
|
Vector2 uvs[] = {
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale())
|
|
};
|
|
|
|
Vector3 verts[] = {
|
|
Vector3(1, 0, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 0, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 0, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 0, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale
|
|
};
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
add_normal(Vector3(0, -1, 0));
|
|
|
|
if (use_lighting || _always_add_colors)
|
|
add_color(light);
|
|
|
|
add_uv(uvs[i]);
|
|
add_vertex(verts[i]);
|
|
}
|
|
}
|
|
|
|
//z + 1
|
|
if (neighbours[4] == 0) {
|
|
if (use_lighting) {
|
|
light = Color(channel_color_r[indexzp] / 255.0,
|
|
channel_color_g[indexzp] / 255.0,
|
|
channel_color_b[indexzp] / 255.0);
|
|
|
|
float ao = 0;
|
|
|
|
if (use_ao)
|
|
ao = channel_ao[indexzp] / 255.0;
|
|
|
|
if (use_rao) {
|
|
float rao = channel_rao[indexzp] / 255.0;
|
|
ao += rao;
|
|
}
|
|
|
|
light += base_light;
|
|
|
|
if (ao > 0)
|
|
light -= Color(ao, ao, ao) * _ao_strength;
|
|
|
|
light.r = CLAMP(light.r, 0, 1.0);
|
|
light.g = CLAMP(light.g, 0, 1.0);
|
|
light.b = CLAMP(light.b, 0, 1.0);
|
|
}
|
|
|
|
int vc = get_vertex_count();
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 1);
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 3);
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 0);
|
|
|
|
Vector2 uvs[] = {
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale())
|
|
};
|
|
|
|
Vector3 verts[] = {
|
|
Vector3(1, 0, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 1, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 1, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 0, 1) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale
|
|
};
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
add_normal(Vector3(0, 0, 1));
|
|
|
|
if (use_lighting || _always_add_colors)
|
|
add_color(light);
|
|
|
|
add_uv(uvs[i]);
|
|
add_vertex(verts[i]);
|
|
}
|
|
}
|
|
|
|
//z - 1
|
|
if (neighbours[5] == 0) {
|
|
if (use_lighting) {
|
|
light = Color(channel_color_r[indexzn] / 255.0,
|
|
channel_color_g[indexzn] / 255.0,
|
|
channel_color_b[indexzn] / 255.0);
|
|
|
|
float ao = 0;
|
|
|
|
if (use_ao)
|
|
ao = channel_ao[indexzn] / 255.0;
|
|
|
|
if (use_rao) {
|
|
float rao = channel_rao[indexzn] / 255.0;
|
|
ao += rao;
|
|
}
|
|
|
|
light += base_light;
|
|
|
|
if (ao > 0)
|
|
light -= Color(ao, ao, ao) * _ao_strength;
|
|
|
|
light.r = CLAMP(light.r, 0, 1.0);
|
|
light.g = CLAMP(light.g, 0, 1.0);
|
|
light.b = CLAMP(light.b, 0, 1.0);
|
|
}
|
|
|
|
int vc = get_vertex_count();
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 1);
|
|
add_indices(vc + 2);
|
|
|
|
add_indices(vc + 0);
|
|
add_indices(vc + 2);
|
|
add_indices(vc + 3);
|
|
|
|
Vector2 uvs[] = {
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(0, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 0), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale()),
|
|
surface->transform_uv_scaled(VoxelSurface::VOXEL_SIDE_SIDE, Vector2(1, 1), x % get_texture_scale(), z % get_texture_scale(), get_texture_scale())
|
|
};
|
|
|
|
Vector3 verts[] = {
|
|
Vector3(1, 0, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(1, 1, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 1, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale,
|
|
Vector3(0, 0, 0) * voxel_scale + Vector3(x - 1, y - 1, z - 1) * voxel_scale
|
|
};
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
add_normal(Vector3(0, 0, -1));
|
|
|
|
if (use_lighting || _always_add_colors)
|
|
add_color(light);
|
|
|
|
add_uv(uvs[i]);
|
|
add_vertex(verts[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VoxelMesherBlocky::VoxelMesherBlocky() {
|
|
_always_add_colors = false;
|
|
}
|
|
|
|
VoxelMesherBlocky::~VoxelMesherBlocky() {
|
|
}
|
|
|
|
void VoxelMesherBlocky::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("_add_chunk", "buffer"), &VoxelMesherBlocky::_add_chunk);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_always_add_colors"), &VoxelMesherBlocky::get_always_add_colors);
|
|
ClassDB::bind_method(D_METHOD("set_always_add_colors", "value"), &VoxelMesherBlocky::set_always_add_colors);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "always_add_colors"), "set_always_add_colors", "get_always_add_colors");
|
|
}
|