Relintai/voxelman
1
0
Fork 0
mirror of https://github.com/Relintai/voxelman.git synced 2024-11-14 10:17:20 +01:00
Code Issues Packages Projects Releases Wiki Activity
19a255c4dd
voxelman/world/voxel_chunk_prop_data.cpp

239 lines
8.7 KiB
C++
Raw Normal View History

Updated the license for 2020, and added it to the top of my cpp files.
2020-01-31 19:52:37 +01:00
/*
Copyright (c) 2019-2020 Péter Magyar
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.
*/
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
#include "voxel_chunk_prop_data.h"
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
#include "voxel_chunk.h"
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
int VoxelChunkPropData::get_x() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _x;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
void VoxelChunkPropData::set_x(const int value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_x = value;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
int VoxelChunkPropData::get_y() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _y;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
void VoxelChunkPropData::set_y(const int value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_y = value;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
int VoxelChunkPropData::get_z() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _z;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
void VoxelChunkPropData::set_z(const int value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_z = value;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
Vector3 VoxelChunkPropData::get_rotation() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _rotation;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
void VoxelChunkPropData::set_rotation(const Vector3 &value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_rotation = value;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
Vector3 VoxelChunkPropData::get_scale() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _scale;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
void VoxelChunkPropData::set_scale(const Vector3 &value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_scale = value;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
bool VoxelChunkPropData::get_snap_to_mesh() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _snap_to_mesh;
}
Fix typo.
2020-06-23 01:13:04 +02:00
void VoxelChunkPropData::set_snap_to_mesh(const bool value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_snap_to_mesh = value;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
Vector3 VoxelChunkPropData::get_snap_axis() const {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
return _snap_axis;
}
Added a few const qualifiers.
2020-06-23 01:05:41 +02:00
void VoxelChunkPropData::set_snap_axis(const Vector3 &value) {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_snap_axis = value;
}
Cleaned up the prop spawning api in chunk and world.
2020-04-15 13:06:45 +02:00
Ref<VoxelChunk> VoxelChunkPropData::get_owner() {
return _owner;
}
void VoxelChunkPropData::set_owner(const Ref<VoxelChunk> &chunk) {
_owner = chunk;
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
int VoxelChunkPropData::get_scene_id() const {
return _scene_id;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
void VoxelChunkPropData::set_scene_id(const int id) {
_scene_id = id;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
Transform VoxelChunkPropData::get_transform() const {
return _transform;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
void VoxelChunkPropData::set_transform(const Transform &value) {
_transform = value;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
Ref<PackedScene> VoxelChunkPropData::get_scene() {
return _scene;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
void VoxelChunkPropData::set_scene(const Ref<PackedScene> &value) {
_scene = value;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
Ref<MeshDataResource> VoxelChunkPropData::get_mesh() {
return _mesh;
}
void VoxelChunkPropData::set_mesh(const Ref<MeshDataResource> &value) {
_mesh = value;
}
Ref<Texture> VoxelChunkPropData::get_mesh_texture() {
return _texture;
}
void VoxelChunkPropData::set_mesh_texture(const Ref<Texture> &value) {
_texture = value;
}
Ref<PropDataLight> VoxelChunkPropData::get_light() {
return _light;
}
void VoxelChunkPropData::set_light(const Ref<PropDataLight> &value) {
_light = value;
}
Ref<PropData> VoxelChunkPropData::get_prop() {
return _prop;
}
void VoxelChunkPropData::set_prop(const Ref<PropData> &value) {
_prop = value;
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
Node *VoxelChunkPropData::get_spawned_prop() const {
return _spawned_prop;
Added a Texture property to VoxelChunkPropData aswell.
2019-11-05 21:27:31 +01:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
void VoxelChunkPropData::set_spawned_prop(Node *value) {
_spawned_prop = value;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
Node *VoxelChunkPropData::spawn_prop(Node *parent) {
return NULL;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
void VoxelChunkPropData::free_prop() {
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
void VoxelChunkPropData::set_translation_for_chunk(const Ref<VoxelChunk> &chunk, const int local_x, const int local_y, const int local_z) {
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
VoxelChunkPropData::VoxelChunkPropData() {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_x = 0;
_y = 0;
_z = 0;
_scale = Vector3(1, 1, 1);
_snap_to_mesh = false;
_snap_axis = Vector3(0, -1, 0);
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
_spawned_prop = NULL;
_scene_id = 0;
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
VoxelChunkPropData::~VoxelChunkPropData() {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_mesh.unref();
_texture.unref();
_light.unref();
_prop.unref();
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
_scene.unref();
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
_owner.unref();
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
void VoxelChunkPropData::_bind_methods() {
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
ClassDB::bind_method(D_METHOD("get_x"), &VoxelChunkPropData::get_x);
ClassDB::bind_method(D_METHOD("set_x", "value"), &VoxelChunkPropData::set_x);
ADD_PROPERTY(PropertyInfo(Variant::INT, "x"), "set_x", "get_x");
ClassDB::bind_method(D_METHOD("get_y"), &VoxelChunkPropData::get_y);
ClassDB::bind_method(D_METHOD("set_y", "value"), &VoxelChunkPropData::set_y);
ADD_PROPERTY(PropertyInfo(Variant::INT, "y"), "set_y", "get_y");
ClassDB::bind_method(D_METHOD("get_z"), &VoxelChunkPropData::get_z);
ClassDB::bind_method(D_METHOD("set_z", "value"), &VoxelChunkPropData::set_z);
ADD_PROPERTY(PropertyInfo(Variant::INT, "z"), "set_z", "get_z");
ClassDB::bind_method(D_METHOD("get_rotation"), &VoxelChunkPropData::get_rotation);
ClassDB::bind_method(D_METHOD("set_rotation", "value"), &VoxelChunkPropData::set_rotation);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "rotation"), "set_rotation", "get_rotation");
ClassDB::bind_method(D_METHOD("get_scale"), &VoxelChunkPropData::get_scale);
ClassDB::bind_method(D_METHOD("set_scale", "value"), &VoxelChunkPropData::set_scale);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "scale"), "set_scale", "get_scale");
ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &VoxelChunkPropData::get_snap_to_mesh);
ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &VoxelChunkPropData::set_snap_to_mesh);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh");
ClassDB::bind_method(D_METHOD("get_snap_axis"), &VoxelChunkPropData::get_snap_axis);
ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &VoxelChunkPropData::set_snap_axis);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis");
Cleaned up the prop spawning api in chunk and world.
2020-04-15 13:06:45 +02:00
ClassDB::bind_method(D_METHOD("get_owner"), &VoxelChunkPropData::get_owner);
ClassDB::bind_method(D_METHOD("set_owner", "value"), &VoxelChunkPropData::set_owner);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "owner", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk"), "set_owner", "get_owner");
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
ClassDB::bind_method(D_METHOD("get_scene_id"), &VoxelChunkPropData::get_scene_id);
ClassDB::bind_method(D_METHOD("set_scene_id", "value"), &VoxelChunkPropData::set_scene_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "scene_id"), "set_scene_id", "get_scene_id");
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
ClassDB::bind_method(D_METHOD("get_transform"), &VoxelChunkPropData::get_transform);
ClassDB::bind_method(D_METHOD("set_transform", "value"), &VoxelChunkPropData::set_transform);
ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "transform"), "set_transform", "get_transform");
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
Started reworking the way props are handled. Removed every old PropData related classes. Props are now just normal PackedScenes. Spawning conveniences/network synchronization will come later.
2020-04-04 17:22:07 +02:00
ClassDB::bind_method(D_METHOD("get_spawned_prop"), &VoxelChunkPropData::get_spawned_prop);
ClassDB::bind_method(D_METHOD("set_spawned_prop", "value"), &VoxelChunkPropData::set_spawned_prop);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "spawned_prop", PROPERTY_HINT_RESOURCE_TYPE, "Node"), "set_spawned_prop", "get_spawned_prop");
ClassDB::bind_method(D_METHOD("spawn_prop", "parent"), &VoxelChunkPropData::spawn_prop);
ClassDB::bind_method(D_METHOD("free_prop"), &VoxelChunkPropData::free_prop);
ClassDB::bind_method(D_METHOD("set_translation_for_chunk", "chunk", "local_x", "local_y", "local_z"), &VoxelChunkPropData::set_translation_for_chunk);
Brought back the old Prop implementation, and PropTool, because not only this implementation was already done, it will work better than spawning possibly thousands of nodes with the props module, but I also found a way to eventually make it more user friendly.
2020-06-22 21:49:58 +02:00
ClassDB::bind_method(D_METHOD("get_mesh"), &VoxelChunkPropData::get_mesh);
ClassDB::bind_method(D_METHOD("set_mesh", "value"), &VoxelChunkPropData::set_mesh);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "MeshDataResource"), "set_mesh", "get_mesh");
ClassDB::bind_method(D_METHOD("get_mesh_texture"), &VoxelChunkPropData::get_mesh_texture);
ClassDB::bind_method(D_METHOD("set_mesh_texture", "value"), &VoxelChunkPropData::set_mesh_texture);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_mesh_texture", "get_mesh_texture");
ClassDB::bind_method(D_METHOD("get_light"), &VoxelChunkPropData::get_light);
ClassDB::bind_method(D_METHOD("set_light", "value"), &VoxelChunkPropData::set_light);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "light", PROPERTY_HINT_RESOURCE_TYPE, "PropDataLight"), "set_light", "get_light");
ClassDB::bind_method(D_METHOD("get_prop"), &VoxelChunkPropData::get_prop);
ClassDB::bind_method(D_METHOD("set_prop", "value"), &VoxelChunkPropData::set_prop);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), "set_prop", "get_prop");
ClassDB::bind_method(D_METHOD("get_scene"), &VoxelChunkPropData::get_scene);
ClassDB::bind_method(D_METHOD("set_scene", "value"), &VoxelChunkPropData::set_scene);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "scene", PROPERTY_HINT_RESOURCE_TYPE, "PackedScene"), "set_scene", "get_scene");
Reworked the way chung handles props, and made chunk building fully scriptable.
2019-10-10 23:51:05 +02:00
}
Reference in New Issue Copy Permalink