Made TerramanLibraryMergerPCM inherit from TerramanLibrary instead of TerramanLibraryMerger. Added the code from TerramanLibraryMerger as a base for it.

This commit is contained in:
Relintai 2021-08-02 19:10:52 +02:00
parent 460f38090b
commit 74ab6b315e
2 changed files with 510 additions and 5 deletions

View File

@ -22,15 +22,456 @@ SOFTWARE.
#include "terraman_library_merger_pcm.h" #include "terraman_library_merger_pcm.h"
#include "scene/resources/packed_scene.h"
#include "scene/resources/texture.h"
#ifdef PROPS_PRESENT
#include "../../props/props/prop_data.h"
#include "../../props/props/prop_data_prop.h"
#endif
#if MESH_DATA_RESOURCE_PRESENT
#include "../../mesh_data_resource/props/prop_data_mesh_data.h"
#endif
#include "../defines.h"
bool TerramanLibraryMergerPCM::_supports_caching() { bool TerramanLibraryMergerPCM::_supports_caching() {
return true; return true;
} }
int TerramanLibraryMergerPCM::get_texture_flags() const {
return _packer->get_texture_flags();
}
void TerramanLibraryMergerPCM::set_texture_flags(const int flags) {
_packer->set_texture_flags(flags);
_prop_packer->set_texture_flags(flags);
}
int TerramanLibraryMergerPCM::get_max_atlas_size() const {
return _packer->get_max_atlas_size();
}
void TerramanLibraryMergerPCM::set_max_atlas_size(const int size) {
_packer->set_max_atlas_size(size);
_prop_packer->set_max_atlas_size(size);
}
bool TerramanLibraryMergerPCM::get_keep_original_atlases() const {
return _packer->get_keep_original_atlases();
}
void TerramanLibraryMergerPCM::set_keep_original_atlases(const bool value) {
_packer->set_keep_original_atlases(value);
_prop_packer->set_keep_original_atlases(value);
}
Color TerramanLibraryMergerPCM::get_background_color() const {
return _packer->get_background_color();
}
void TerramanLibraryMergerPCM::set_background_color(const Color &color) {
_packer->set_background_color(color);
_prop_packer->set_background_color(color);
}
int TerramanLibraryMergerPCM::get_margin() const {
return _packer->get_margin();
}
void TerramanLibraryMergerPCM::set_margin(const int margin) {
_packer->set_margin(margin);
_prop_packer->set_margin(margin);
}
//Surfaces
Ref<TerraSurface> TerramanLibraryMergerPCM::voxel_surface_get(const int index) {
ERR_FAIL_INDEX_V(index, _voxel_surfaces.size(), Ref<TerraSurface>(NULL));
return _voxel_surfaces[index];
}
void TerramanLibraryMergerPCM::voxel_surface_add(Ref<TerraSurface> value) {
ERR_FAIL_COND(!value.is_valid());
value->set_library(Ref<TerramanLibraryMergerPCM>(this));
value->set_id(_voxel_surfaces.size());
_voxel_surfaces.push_back(value);
}
void TerramanLibraryMergerPCM::voxel_surface_set(const int index, Ref<TerraSurface> value) {
ERR_FAIL_COND(index < 0);
if (_voxel_surfaces.size() < index) {
_voxel_surfaces.resize(index + 1);
}
if (_voxel_surfaces[index].is_valid()) {
_voxel_surfaces.get(index)->set_library(Ref<TerramanLibraryMergerPCM>(NULL));
}
if (value.is_valid()) {
value->set_library(Ref<TerramanLibraryMergerPCM>(this));
_voxel_surfaces.set(index, value);
}
}
void TerramanLibraryMergerPCM::voxel_surface_remove(const int index) {
_voxel_surfaces.remove(index);
}
int TerramanLibraryMergerPCM::voxel_surface_get_num() const {
return _voxel_surfaces.size();
}
void TerramanLibraryMergerPCM::voxel_surfaces_clear() {
_packer->clear();
for (int i = 0; i < _voxel_surfaces.size(); i++) {
Ref<TerraSurfaceMerger> surface = _voxel_surfaces[i];
if (surface.is_valid()) {
surface->set_library(NULL);
}
}
_voxel_surfaces.clear();
}
Vector<Variant> TerramanLibraryMergerPCM::get_voxel_surfaces() {
VARIANT_ARRAY_GET(_voxel_surfaces);
}
void TerramanLibraryMergerPCM::set_voxel_surfaces(const Vector<Variant> &surfaces) {
_voxel_surfaces.clear();
for (int i = 0; i < surfaces.size(); i++) {
Ref<TerraSurfaceMerger> surface = Ref<TerraSurfaceMerger>(surfaces[i]);
if (surface.is_valid()) {
surface->set_library(this);
}
_voxel_surfaces.push_back(surface);
}
}
#ifdef PROPS_PRESENT
Ref<PropData> TerramanLibraryMergerPCM::get_prop(const int index) {
ERR_FAIL_INDEX_V(index, _props.size(), Ref<PropData>());
return _props[index];
}
void TerramanLibraryMergerPCM::add_prop(Ref<PropData> value) {
_props.push_back(value);
}
bool TerramanLibraryMergerPCM::has_prop(const Ref<PropData> &value) const {
return _props.find(value) != -1;
}
void TerramanLibraryMergerPCM::set_prop(const int index, const Ref<PropData> &value) {
ERR_FAIL_INDEX(index, _props.size());
_props.write[index] = value;
}
void TerramanLibraryMergerPCM::remove_prop(const int index) {
ERR_FAIL_INDEX(index, _props.size());
_props.remove(index);
}
int TerramanLibraryMergerPCM::get_num_props() const {
return _props.size();
}
void TerramanLibraryMergerPCM::clear_props() {
_props.clear();
}
Vector<Variant> TerramanLibraryMergerPCM::get_props() {
VARIANT_ARRAY_GET(_props);
}
void TerramanLibraryMergerPCM::set_props(const Vector<Variant> &props) {
VARIANT_ARRAY_SET(props, _props, PropData);
}
Rect2 TerramanLibraryMergerPCM::get_prop_uv_rect(const Ref<Texture> &texture) {
if (!texture.is_valid()) {
return Rect2(0, 0, 1, 1);
}
Ref<AtlasTexture> at = _prop_packer->get_texture(texture);
if (!at.is_valid()) {
return Rect2(0, 0, 1, 1);
}
Rect2 region = at->get_region();
Ref<Texture> tex = at->get_atlas();
if (!tex.is_valid()) {
return Rect2(0, 0, 1, 1);
}
Ref<Image> image = tex->get_data();
if (!image.is_valid()) {
return Rect2(0, 0, 1, 1);
}
float w = image->get_width();
float h = image->get_height();
region.position = Size2(region.position.x / w, region.position.y / h);
region.size = Size2(region.size.x / w, region.size.y / h);
return region;
}
Ref<TexturePacker> TerramanLibraryMergerPCM::get_prop_packer() {
return _prop_packer;
}
#endif
void TerramanLibraryMergerPCM::refresh_rects() {
bool texture_added = false;
for (int i = 0; i < _voxel_surfaces.size(); i++) {
Ref<TerraSurfaceMerger> surface = Ref<TerraSurfaceMerger>(_voxel_surfaces[i]);
if (surface.is_valid()) {
for (int j = 0; j < TerraSurface::TERRA_SIDES_COUNT; ++j) {
Ref<Texture> tex = surface->get_texture(static_cast<TerraSurface::TerraSurfaceSides>(j));
if (!tex.is_valid())
continue;
if (!_packer->contains_texture(tex)) {
texture_added = true;
surface->set_region(static_cast<TerraSurface::TerraSurfaceSides>(j), _packer->add_texture(tex));
} else {
surface->set_region(static_cast<TerraSurface::TerraSurfaceSides>(j), _packer->get_texture(tex));
}
}
}
}
if (texture_added) {
_packer->merge();
ERR_FAIL_COND(_packer->get_texture_count() == 0);
Ref<Texture> tex = _packer->get_generated_texture(0);
setup_material_albedo(MATERIAL_INDEX_TERRAS, tex);
setup_material_albedo(MATERIAL_INDEX_LIQUID, tex);
}
#ifdef PROPS_PRESENT
//todo add this back
//texture_added = false;
for (int i = 0; i < _props.size(); i++) {
Ref<PropData> prop = _props.get(i);
if (prop.is_valid()) {
if (process_prop_textures(prop))
texture_added = true;
}
}
//if (texture_added) {
if (_prop_packer->get_texture_count() > 0) {
_prop_packer->merge();
//ERR_FAIL_COND(_prop_packer->get_texture_count() == 0);
Ref<Texture> tex = _prop_packer->get_generated_texture(0);
setup_material_albedo(MATERIAL_INDEX_PROP, tex);
}
#endif
for (int i = 0; i < _voxel_surfaces.size(); i++) {
Ref<TerraSurfaceMerger> surface = _voxel_surfaces[i];
if (surface.is_valid()) {
surface->refresh_rects();
}
}
set_initialized(true);
}
void TerramanLibraryMergerPCM::_setup_material_albedo(const int material_index, const Ref<Texture> &texture) {
Ref<SpatialMaterial> mat;
int count = 0;
switch (material_index) {
case MATERIAL_INDEX_TERRAS:
count = material_get_num();
break;
case MATERIAL_INDEX_LIQUID:
count = liquid_material_get_num();
break;
case MATERIAL_INDEX_PROP:
count = prop_material_get_num();
break;
}
for (int i = 0; i < count; ++i) {
switch (material_index) {
case MATERIAL_INDEX_TERRAS:
mat = material_get(i);
break;
case MATERIAL_INDEX_LIQUID:
mat = liquid_material_get(i);
break;
case MATERIAL_INDEX_PROP:
mat = prop_material_get(i);
break;
}
Ref<SpatialMaterial> spmat;
if (spmat.is_valid()) {
spmat->set_texture(SpatialMaterial::TEXTURE_ALBEDO, texture);
return;
}
Ref<ShaderMaterial> shmat;
switch (material_index) {
case MATERIAL_INDEX_TERRAS:
shmat = material_get(i);
break;
case MATERIAL_INDEX_LIQUID:
shmat = liquid_material_get(i);
break;
case MATERIAL_INDEX_PROP:
shmat = prop_material_get(i);
break;
}
if (shmat.is_valid()) {
shmat->set_shader_param("texture_albedo", texture);
}
}
}
TerramanLibraryMergerPCM::TerramanLibraryMergerPCM() { TerramanLibraryMergerPCM::TerramanLibraryMergerPCM() {
_packer.instance();
#if GODOT4
#warning implement
#else
_packer->set_texture_flags(Texture::FLAG_MIPMAPS | Texture::FLAG_FILTER);
#endif
_packer->set_max_atlas_size(1024);
_packer->set_keep_original_atlases(false);
_packer->set_margin(0);
_prop_packer.instance();
#if GODOT4
#warning implement
#else
_prop_packer->set_texture_flags(Texture::FLAG_MIPMAPS | Texture::FLAG_FILTER);
#endif
_prop_packer->set_max_atlas_size(1024);
_prop_packer->set_keep_original_atlases(false);
_prop_packer->set_margin(0);
} }
TerramanLibraryMergerPCM::~TerramanLibraryMergerPCM() { TerramanLibraryMergerPCM::~TerramanLibraryMergerPCM() {
for (int i = 0; i < _voxel_surfaces.size(); ++i) {
Ref<TerraSurface> surface = _voxel_surfaces[i];
if (surface.is_valid()) {
surface->set_library(Ref<TerramanLibraryMergerPCM>());
}
} }
void TerramanLibraryMergerPCM::_bind_methods() { _voxel_surfaces.clear();
_packer->clear();
_packer.unref();
_prop_packer->clear();
_prop_packer.unref();
}
#ifdef PROPS_PRESENT
bool TerramanLibraryMergerPCM::process_prop_textures(Ref<PropData> prop) {
if (!prop.is_valid()) {
return false;
}
bool texture_added = false;
for (int i = 0; i < prop->get_prop_count(); ++i) {
Ref<PropDataMeshData> pdm = prop->get_prop(i);
if (pdm.is_valid()) {
Ref<Texture> tex = pdm->get_texture();
if (!tex.is_valid())
continue;
if (!_prop_packer->contains_texture(tex)) {
_prop_packer->add_texture(tex);
texture_added = true;
}
}
Ref<PropDataProp> pdp = prop->get_prop(i);
if (pdp.is_valid()) {
if (process_prop_textures(pdp))
texture_added = true;
}
}
return texture_added;
}
#endif
void TerramanLibraryMergerPCM::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_texture_flags"), &TerramanLibraryMergerPCM::get_texture_flags);
ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &TerramanLibraryMergerPCM::set_texture_flags);
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic Linear,Convert to Linear,Mirrored Repeat,Video Surface"), "set_texture_flags", "get_texture_flags");
ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &TerramanLibraryMergerPCM::get_max_atlas_size);
ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &TerramanLibraryMergerPCM::set_max_atlas_size);
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_atlas_size"), "set_max_atlas_size", "get_max_atlas_size");
ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &TerramanLibraryMergerPCM::get_keep_original_atlases);
ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &TerramanLibraryMergerPCM::set_keep_original_atlases);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_original_atlases"), "set_keep_original_atlases", "get_keep_original_atlases");
ClassDB::bind_method(D_METHOD("get_background_color"), &TerramanLibraryMergerPCM::get_background_color);
ClassDB::bind_method(D_METHOD("set_background_color", "color"), &TerramanLibraryMergerPCM::set_background_color);
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_background_color", "get_background_color");
ClassDB::bind_method(D_METHOD("get_margin"), &TerramanLibraryMergerPCM::get_margin);
ClassDB::bind_method(D_METHOD("set_margin", "size"), &TerramanLibraryMergerPCM::set_margin);
ADD_PROPERTY(PropertyInfo(Variant::INT, "margin"), "set_margin", "get_margin");
ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &TerramanLibraryMergerPCM::get_voxel_surfaces);
ClassDB::bind_method(D_METHOD("set_voxel_surfaces"), &TerramanLibraryMergerPCM::set_voxel_surfaces);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "voxel_surfaces", PROPERTY_HINT_NONE, "17/17:TerraSurfaceMerger", PROPERTY_USAGE_DEFAULT, "TerraSurfaceMerger"), "set_voxel_surfaces", "get_voxel_surfaces");
#ifdef PROPS_PRESENT
ClassDB::bind_method(D_METHOD("get_props"), &TerramanLibraryMergerPCM::get_props);
ClassDB::bind_method(D_METHOD("set_props"), &TerramanLibraryMergerPCM::set_props);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "props", PROPERTY_HINT_NONE, "17/17:PropData", PROPERTY_USAGE_DEFAULT, "PropData"), "set_props", "get_props");
ClassDB::bind_method(D_METHOD("get_prop_uv_rect", "texture"), &TerramanLibraryMergerPCM::get_prop_uv_rect);
ClassDB::bind_method(D_METHOD("get_prop_packer"), &TerramanLibraryMergerPCM::get_prop_packer);
#endif
ClassDB::bind_method(D_METHOD("_setup_material_albedo", "material_index", "texture"), &TerramanLibraryMergerPCM::_setup_material_albedo);
} }

View File

@ -33,23 +33,87 @@ SOFTWARE.
#include "core/map.h" #include "core/map.h"
#endif #endif
#include "terraman_library_merger.h" #include "terraman_library.h"
#include "scene/resources/material.h"
#include "../data/terra_light.h"
#include "terra_surface_merger.h"
class TerraSurfaceSimple;
class TerraMesher;
class PackedScene;
//pcm = per chunk material //pcm = per chunk material
class TerramanLibraryMergerPCM : public TerramanLibraryMerger { //inherit it from the normal library? class TerramanLibraryMergerPCM : public TerramanLibrary {
GDCLASS(TerramanLibraryMergerPCM, TerramanLibraryMerger); GDCLASS(TerramanLibraryMergerPCM, TerramanLibrary);
public: public:
bool _supports_caching(); bool _supports_caching();
//Ref<MaterialEntry> get_mat_entry_for_key(key) int get_texture_flags() const;
void set_texture_flags(const int flags);
int get_max_atlas_size() const;
void set_max_atlas_size(const int size);
bool get_keep_original_atlases() const;
void set_keep_original_atlases(const bool value);
Color get_background_color() const;
void set_background_color(const Color &color);
int get_margin() const;
void set_margin(const int margin);
Ref<TerraSurface> voxel_surface_get(const int index);
void voxel_surface_add(Ref<TerraSurface> value);
void voxel_surface_set(const int index, Ref<TerraSurface> value);
void voxel_surface_remove(const int index);
int voxel_surface_get_num() const;
void voxel_surfaces_clear();
Vector<Variant> get_voxel_surfaces();
void set_voxel_surfaces(const Vector<Variant> &surfaces);
#ifdef PROPS_PRESENT
Ref<PropData> get_prop(const int index);
void add_prop(Ref<PropData> value);
bool has_prop(const Ref<PropData> &value) const;
void set_prop(const int index, const Ref<PropData> &value);
void remove_prop(const int index);
int get_num_props() const;
void clear_props();
Vector<Variant> get_props();
void set_props(const Vector<Variant> &props);
Rect2 get_prop_uv_rect(const Ref<Texture> &texture);
Ref<TexturePacker> get_prop_packer();
#endif
void refresh_rects();
void _setup_material_albedo(const int material_index, const Ref<Texture> &texture);
TerramanLibraryMergerPCM(); TerramanLibraryMergerPCM();
~TerramanLibraryMergerPCM(); ~TerramanLibraryMergerPCM();
protected: protected:
#ifdef PROPS_PRESENT
bool process_prop_textures(Ref<PropData> prop);
#endif
static void _bind_methods(); static void _bind_methods();
Vector<Ref<TerraSurfaceMerger> > _voxel_surfaces;
#ifdef PROPS_PRESENT
Vector<Ref<PropData> > _props;
#endif
Ref<TexturePacker> _packer;
Ref<TexturePacker> _prop_packer;
}; };
#endif #endif