summaryrefslogtreecommitdiff
path: root/scene/resources
diff options
context:
space:
mode:
Diffstat (limited to 'scene/resources')
-rw-r--r--scene/resources/animation.h2
-rw-r--r--scene/resources/audio_stream_sample.h2
-rw-r--r--scene/resources/environment.cpp58
-rw-r--r--scene/resources/environment.h16
-rw-r--r--scene/resources/font.h2
-rw-r--r--scene/resources/material.h2
-rw-r--r--scene/resources/mesh.cpp69
-rw-r--r--scene/resources/mesh.h19
-rw-r--r--scene/resources/mesh_library.h2
-rw-r--r--scene/resources/multimesh.h2
-rw-r--r--scene/resources/primitive_meshes.cpp1454
-rw-r--r--scene/resources/primitive_meshes.h312
-rw-r--r--scene/resources/shader_graph.h2
-rw-r--r--scene/resources/shape.h2
-rw-r--r--scene/resources/style_box.cpp23
-rw-r--r--scene/resources/style_box.h6
-rw-r--r--scene/resources/texture.cpp102
-rw-r--r--scene/resources/texture.h41
-rw-r--r--scene/resources/theme.h2
-rw-r--r--scene/resources/world.h2
-rw-r--r--scene/resources/world_2d.cpp7
-rw-r--r--scene/resources/world_2d.h4
22 files changed, 1927 insertions, 204 deletions
diff --git a/scene/resources/animation.h b/scene/resources/animation.h
index ef5befac65..b363f2b666 100644
--- a/scene/resources/animation.h
+++ b/scene/resources/animation.h
@@ -37,7 +37,7 @@
class Animation : public Resource {
GDCLASS(Animation, Resource);
- RES_BASE_EXTENSION("anm");
+ RES_BASE_EXTENSION("anim");
public:
enum TrackType {
diff --git a/scene/resources/audio_stream_sample.h b/scene/resources/audio_stream_sample.h
index 84d450e3f2..cd02df512f 100644
--- a/scene/resources/audio_stream_sample.h
+++ b/scene/resources/audio_stream_sample.h
@@ -84,7 +84,7 @@ public:
class AudioStreamSample : public AudioStream {
GDCLASS(AudioStreamSample, AudioStream)
- RES_BASE_EXTENSION("smp")
+ RES_BASE_EXTENSION("sample")
public:
enum Format {
diff --git a/scene/resources/environment.cpp b/scene/resources/environment.cpp
index e40fc0d4be..a435ba06cc 100644
--- a/scene/resources/environment.cpp
+++ b/scene/resources/environment.cpp
@@ -315,7 +315,7 @@ void Environment::_validate_property(PropertyInfo &property) const {
void Environment::set_ssr_enabled(bool p_enable) {
ssr_enabled = p_enable;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
+ VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance, ssr_roughness);
_change_notify();
}
@@ -327,57 +327,47 @@ bool Environment::is_ssr_enabled() const {
void Environment::set_ssr_max_steps(int p_steps) {
ssr_max_steps = p_steps;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
+ VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance, ssr_roughness);
}
int Environment::get_ssr_max_steps() const {
return ssr_max_steps;
}
-void Environment::set_ssr_accel(float p_accel) {
+void Environment::set_ssr_fade_in(float p_fade_in) {
- ssr_accel = p_accel;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
+ ssr_fade_in = p_fade_in;
+ VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance, ssr_roughness);
}
-float Environment::get_ssr_accel() const {
+float Environment::get_ssr_fade_in() const {
- return ssr_accel;
+ return ssr_fade_in;
}
-void Environment::set_ssr_fade(float p_fade) {
+void Environment::set_ssr_fade_out(float p_fade_out) {
- ssr_fade = p_fade;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
+ ssr_fade_out = p_fade_out;
+ VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance, ssr_roughness);
}
-float Environment::get_ssr_fade() const {
+float Environment::get_ssr_fade_out() const {
- return ssr_fade;
+ return ssr_fade_out;
}
void Environment::set_ssr_depth_tolerance(float p_depth_tolerance) {
ssr_depth_tolerance = p_depth_tolerance;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
+ VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance, ssr_roughness);
}
float Environment::get_ssr_depth_tolerance() const {
return ssr_depth_tolerance;
}
-void Environment::set_ssr_smooth(bool p_enable) {
-
- ssr_smooth = p_enable;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
-}
-bool Environment::is_ssr_smooth() const {
-
- return ssr_smooth;
-}
-
void Environment::set_ssr_rough(bool p_enable) {
ssr_roughness = p_enable;
- VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_accel, ssr_fade, ssr_depth_tolerance, ssr_smooth, ssr_roughness);
+ VS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance, ssr_roughness);
}
bool Environment::is_ssr_rough() const {
@@ -954,18 +944,15 @@ void Environment::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_ssr_max_steps", "max_steps"), &Environment::set_ssr_max_steps);
ClassDB::bind_method(D_METHOD("get_ssr_max_steps"), &Environment::get_ssr_max_steps);
- ClassDB::bind_method(D_METHOD("set_ssr_accel", "accel"), &Environment::set_ssr_accel);
- ClassDB::bind_method(D_METHOD("get_ssr_accel"), &Environment::get_ssr_accel);
+ ClassDB::bind_method(D_METHOD("set_ssr_fade_in", "fade_in"), &Environment::set_ssr_fade_in);
+ ClassDB::bind_method(D_METHOD("get_ssr_fade_in"), &Environment::get_ssr_fade_in);
- ClassDB::bind_method(D_METHOD("set_ssr_fade", "fade"), &Environment::set_ssr_fade);
- ClassDB::bind_method(D_METHOD("get_ssr_fade"), &Environment::get_ssr_fade);
+ ClassDB::bind_method(D_METHOD("set_ssr_fade_out", "fade_out"), &Environment::set_ssr_fade_out);
+ ClassDB::bind_method(D_METHOD("get_ssr_fade_out"), &Environment::get_ssr_fade_out);
ClassDB::bind_method(D_METHOD("set_ssr_depth_tolerance", "depth_tolerance"), &Environment::set_ssr_depth_tolerance);
ClassDB::bind_method(D_METHOD("get_ssr_depth_tolerance"), &Environment::get_ssr_depth_tolerance);
- ClassDB::bind_method(D_METHOD("set_ssr_smooth", "smooth"), &Environment::set_ssr_smooth);
- ClassDB::bind_method(D_METHOD("is_ssr_smooth"), &Environment::is_ssr_smooth);
-
ClassDB::bind_method(D_METHOD("set_ssr_rough", "rough"), &Environment::set_ssr_rough);
ClassDB::bind_method(D_METHOD("is_ssr_rough"), &Environment::is_ssr_rough);
@@ -973,9 +960,9 @@ void Environment::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "ss_reflections_enabled"), "set_ssr_enabled", "is_ssr_enabled");
ADD_PROPERTY(PropertyInfo(Variant::INT, "ss_reflections_max_steps", PROPERTY_HINT_RANGE, "1,512,1"), "set_ssr_max_steps", "get_ssr_max_steps");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "ss_reflections_accel", PROPERTY_HINT_RANGE, "0,4,0.01"), "set_ssr_accel", "get_ssr_accel");
- ADD_PROPERTY(PropertyInfo(Variant::REAL, "ss_reflections_fade", PROPERTY_HINT_EXP_EASING), "set_ssr_fade", "get_ssr_fade");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "ss_reflections_fade_in", PROPERTY_HINT_EXP_EASING), "set_ssr_fade_in", "get_ssr_fade_in");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "ss_reflections_fade_out", PROPERTY_HINT_EXP_EASING), "set_ssr_fade_out", "get_ssr_fade_out");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "ss_reflections_depth_tolerance", PROPERTY_HINT_RANGE, "0.1,128,0.1"), "set_ssr_depth_tolerance", "get_ssr_depth_tolerance");
- ADD_PROPERTY(PropertyInfo(Variant::BOOL, "ss_reflections_accel_smooth"), "set_ssr_smooth", "is_ssr_smooth");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "ss_reflections_roughness"), "set_ssr_rough", "is_ssr_rough");
ClassDB::bind_method(D_METHOD("set_ssao_enabled", "enabled"), &Environment::set_ssao_enabled);
@@ -1179,10 +1166,9 @@ Environment::Environment() {
ssr_enabled = false;
ssr_max_steps = 64;
- ssr_accel = 0.04;
- ssr_fade = 2.0;
+ ssr_fade_in = 0.15;
+ ssr_fade_out = 2.0;
ssr_depth_tolerance = 0.2;
- ssr_smooth = true;
ssr_roughness = true;
ssao_enabled = false;
diff --git a/scene/resources/environment.h b/scene/resources/environment.h
index 7df3458231..7eda8506b5 100644
--- a/scene/resources/environment.h
+++ b/scene/resources/environment.h
@@ -100,10 +100,9 @@ private:
bool ssr_enabled;
int ssr_max_steps;
- float ssr_accel;
- float ssr_fade;
+ float ssr_fade_in;
+ float ssr_fade_out;
float ssr_depth_tolerance;
- bool ssr_smooth;
bool ssr_roughness;
bool ssao_enabled;
@@ -225,18 +224,15 @@ public:
void set_ssr_max_steps(int p_steps);
int get_ssr_max_steps() const;
- void set_ssr_accel(float p_accel);
- float get_ssr_accel() const;
+ void set_ssr_fade_in(float p_transition);
+ float get_ssr_fade_in() const;
- void set_ssr_fade(float p_transition);
- float get_ssr_fade() const;
+ void set_ssr_fade_out(float p_transition);
+ float get_ssr_fade_out() const;
void set_ssr_depth_tolerance(float p_depth_tolerance);
float get_ssr_depth_tolerance() const;
- void set_ssr_smooth(bool p_enable);
- bool is_ssr_smooth() const;
-
void set_ssr_rough(bool p_enable);
bool is_ssr_rough() const;
diff --git a/scene/resources/font.h b/scene/resources/font.h
index 20978acccd..a04ffbdd4b 100644
--- a/scene/resources/font.h
+++ b/scene/resources/font.h
@@ -66,7 +66,7 @@ public:
class BitmapFont : public Font {
GDCLASS(BitmapFont, Font);
- RES_BASE_EXTENSION("fnt");
+ RES_BASE_EXTENSION("font");
Vector<Ref<Texture> > textures;
diff --git a/scene/resources/material.h b/scene/resources/material.h
index b6e85c8332..c043236489 100644
--- a/scene/resources/material.h
+++ b/scene/resources/material.h
@@ -43,7 +43,7 @@
class Material : public Resource {
GDCLASS(Material, Resource);
- RES_BASE_EXTENSION("mtl");
+ RES_BASE_EXTENSION("material");
OBJ_SAVE_TYPE(Material);
RID material;
diff --git a/scene/resources/mesh.cpp b/scene/resources/mesh.cpp
index 9f55f0c364..a3180ee1df 100644
--- a/scene/resources/mesh.cpp
+++ b/scene/resources/mesh.cpp
@@ -1047,72 +1047,3 @@ ArrayMesh::~ArrayMesh() {
VisualServer::get_singleton()->free(mesh);
}
-
-////////////////////////
-#if 0
-void QuadMesh::_bind_methods() {
-
- ClassDB::bind_method(D_METHOD("set_material", "material:Material"), &QuadMesh::set_material);
- ClassDB::bind_method(D_METHOD("get_material:Material"), &QuadMesh::get_material);
-
- ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material");
-}
-
-void QuadMesh::set_material(const Ref<Material> &p_material) {
-
- surface_set_material(0, p_material);
-}
-
-Ref<Material> QuadMesh::get_material() const {
-
- return surface_get_material(0);
-}
-
-QuadMesh::QuadMesh() {
-
- PoolVector<Vector3> faces;
- PoolVector<Vector3> normals;
- PoolVector<float> tangents;
- PoolVector<Vector2> uvs;
-
- faces.resize(4);
- normals.resize(4);
- tangents.resize(4 * 4);
- uvs.resize(4);
-
- for (int i = 0; i < 4; i++) {
-
- static const Vector3 quad_faces[4] = {
- Vector3(-1, -1, 0),
- Vector3(-1, 1, 0),
- Vector3(1, 1, 0),
- Vector3(1, -1, 0),
- };
-
- faces.set(i, quad_faces[i]);
- normals.set(i, Vector3(0, 0, 1));
- tangents.set(i * 4 + 0, 1.0);
- tangents.set(i * 4 + 1, 0.0);
- tangents.set(i * 4 + 2, 0.0);
- tangents.set(i * 4 + 3, 1.0);
-
- static const Vector2 quad_uv[4] = {
- Vector2(0, 1),
- Vector2(0, 0),
- Vector2(1, 0),
- Vector2(1, 1),
- };
-
- uvs.set(i, quad_uv[i]);
- }
-
- Array arr;
- arr.resize(ARRAY_MAX);
- arr[ARRAY_VERTEX] = faces;
- arr[ARRAY_NORMAL] = normals;
- arr[ARRAY_TANGENT] = tangents;
- arr[ARRAY_TEX_UV] = uvs;
-
- add_surface_from_arrays(PRIMITIVE_TRIANGLE_FAN, arr);
-}
-#endif
diff --git a/scene/resources/mesh.h b/scene/resources/mesh.h
index 7804a84f81..37fddf3aa6 100644
--- a/scene/resources/mesh.h
+++ b/scene/resources/mesh.h
@@ -140,7 +140,7 @@ public:
class ArrayMesh : public Mesh {
GDCLASS(ArrayMesh, Mesh);
- RES_BASE_EXTENSION("msh");
+ RES_BASE_EXTENSION("mesh");
private:
struct Surface {
@@ -214,23 +214,6 @@ public:
~ArrayMesh();
};
-#if 0
-class QuadMesh : public Mesh {
-
- GDCLASS(QuadMesh, Mesh)
-
-protected:
- virtual bool _is_generated() const { return true; }
- static void _bind_methods();
-
-public:
- void set_material(const Ref<Material> &p_material);
- Ref<Material> get_material() const;
- QuadMesh();
-};
-
-#endif
-
VARIANT_ENUM_CAST(Mesh::ArrayType);
VARIANT_ENUM_CAST(Mesh::PrimitiveType);
VARIANT_ENUM_CAST(Mesh::BlendShapeMode);
diff --git a/scene/resources/mesh_library.h b/scene/resources/mesh_library.h
index a381f54a19..cc39110a99 100644
--- a/scene/resources/mesh_library.h
+++ b/scene/resources/mesh_library.h
@@ -39,7 +39,7 @@
class MeshLibrary : public Resource {
GDCLASS(MeshLibrary, Resource);
- RES_BASE_EXTENSION("gt");
+ RES_BASE_EXTENSION("meshlib");
struct Item {
String name;
diff --git a/scene/resources/multimesh.h b/scene/resources/multimesh.h
index 4a00685b9f..7d6a0ce44f 100644
--- a/scene/resources/multimesh.h
+++ b/scene/resources/multimesh.h
@@ -36,7 +36,7 @@
class MultiMesh : public Resource {
GDCLASS(MultiMesh, Resource);
- RES_BASE_EXTENSION("mmsh");
+ RES_BASE_EXTENSION("multimesh");
public:
enum TransformFormat {
diff --git a/scene/resources/primitive_meshes.cpp b/scene/resources/primitive_meshes.cpp
new file mode 100644
index 0000000000..d4221dcb3f
--- /dev/null
+++ b/scene/resources/primitive_meshes.cpp
@@ -0,0 +1,1454 @@
+/*************************************************************************/
+/* primitive_meshes.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* http://www.godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
+/* */
+/* 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 "primitive_meshes.h"
+#include "servers/visual_server.h"
+
+/**
+ PrimitiveMesh
+*/
+void PrimitiveMesh::_update() {
+ if (!cache_is_dirty)
+ return;
+
+ Array arr;
+ arr.resize(VS::ARRAY_MAX);
+ _create_mesh_array(arr);
+
+ // in with the new
+ VisualServer::get_singleton()->mesh_clear(mesh);
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(mesh, (VisualServer::PrimitiveType)primitive_type, arr);
+ VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid());
+
+ cache_is_dirty = false;
+
+ _clear_triangle_mesh();
+ emit_changed();
+}
+
+void PrimitiveMesh::_queue_update() {
+ if (!cache_is_dirty) {
+ cache_is_dirty = true;
+ call_deferred("_update");
+ }
+}
+
+void PrimitiveMesh::set_aabb(Rect3 p_aabb) {
+ aabb = p_aabb;
+}
+
+int PrimitiveMesh::get_surface_count() const {
+ return 1;
+}
+
+int PrimitiveMesh::surface_get_array_len(int p_idx) const {
+ ERR_FAIL_INDEX_V(p_idx, 1, -1);
+ return VisualServer::get_singleton()->mesh_surface_get_array_len(mesh, 0);
+}
+
+int PrimitiveMesh::surface_get_array_index_len(int p_idx) const {
+ ERR_FAIL_INDEX_V(p_idx, 1, -1);
+ return VisualServer::get_singleton()->mesh_surface_get_array_index_len(mesh, 0);
+}
+
+Array PrimitiveMesh::surface_get_arrays(int p_surface) const {
+ ERR_FAIL_INDEX_V(p_surface, 1, Array());
+ return VisualServer::get_singleton()->mesh_surface_get_arrays(mesh, 0);
+}
+
+uint32_t PrimitiveMesh::surface_get_format(int p_idx) const {
+ ERR_FAIL_INDEX_V(p_idx, 1, 0);
+ return VisualServer::get_singleton()->mesh_surface_get_format(mesh, 0);
+}
+
+Mesh::PrimitiveType PrimitiveMesh::surface_get_primitive_type(int p_idx) const {
+ return primitive_type;
+}
+
+Ref<Material> PrimitiveMesh::surface_get_material(int p_idx) const {
+ return material;
+}
+
+int PrimitiveMesh::get_blend_shape_count() const {
+ return 0;
+}
+
+StringName PrimitiveMesh::get_blend_shape_name(int p_index) const {
+ return StringName();
+}
+
+Rect3 PrimitiveMesh::get_aabb() const {
+ return aabb;
+}
+
+RID PrimitiveMesh::get_rid() const {
+ return mesh;
+}
+
+void PrimitiveMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("_update"), &PrimitiveMesh::_update);
+
+ ClassDB::bind_method(D_METHOD("set_material", "material:Material"), &PrimitiveMesh::set_material);
+ ClassDB::bind_method(D_METHOD("get_material:Material"), &PrimitiveMesh::get_material);
+
+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material");
+}
+
+void PrimitiveMesh::set_material(const Ref<Material> &p_material) {
+ material = p_material;
+ if (!cache_is_dirty) {
+ // just apply it, else it'll happen when _update is called.
+ VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid());
+
+ _change_notify();
+ emit_changed();
+ };
+}
+
+Ref<Material> PrimitiveMesh::get_material() const {
+ return material;
+}
+
+PrimitiveMesh::PrimitiveMesh() {
+ // defaults
+ mesh = VisualServer::get_singleton()->mesh_create();
+
+ // assume primitive triangles as the type, correct for all but one and it will change this :)
+ primitive_type = Mesh::PRIMITIVE_TRIANGLES;
+
+ // make sure we do an update after we've finished constructing our object
+ cache_is_dirty = false;
+ _queue_update();
+}
+
+PrimitiveMesh::~PrimitiveMesh() {
+ VisualServer::get_singleton()->free(mesh);
+}
+
+/**
+ CapsuleMesh
+*/
+
+void CapsuleMesh::_create_mesh_array(Array &p_arr) {
+ int i, j, prevrow, thisrow, point;
+ float x, y, z, u, v, w;
+ float onethird = 1.0 / 3.0;
+ float twothirds = 2.0 / 3.0;
+
+ set_aabb(Rect3(Vector3(-radius, (mid_height * -0.5) - radius, -radius), Vector3(radius * 2.0, mid_height + (2.0 * radius), radius * 2.0)));
+
+ PoolVector<Vector3> points;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+ PoolVector<int> indices;
+ point = 0;
+
+#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
+ tangents.push_back(m_x); \
+ tangents.push_back(m_y); \
+ tangents.push_back(m_z); \
+ tangents.push_back(m_d);
+
+ /* top hemisphere */
+ thisrow = 0;
+ prevrow = 0;
+ for (j = 0; j <= (rings + 1); j++) {
+ v = j;
+ w;
+
+ v /= (rings + 1);
+ w = sin(0.5 * Math_PI * v);
+ y = radius * cos(0.5 * Math_PI * v);
+
+ for (i = 0; i <= radial_segments; i++) {
+ u = i;
+ u /= radial_segments;
+
+ x = sin(u * (Math_PI * 2.0));
+ z = cos(u * (Math_PI * 2.0));
+
+ Vector3 p = Vector3(x * radius * w, y, z * radius * w);
+ points.push_back(p + Vector3(0.0, 0.5 * mid_height, 0.0));
+ normals.push_back(p.normalized());
+ ADD_TANGENT(-z, 0.0, x, -1.0)
+ uvs.push_back(Vector2(u, v * onethird));
+ point++;
+
+ if (i > 0 && j > 0) {
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+ };
+
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ /* cylinder */
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (rings + 1); j++) {
+ v = j;
+ v /= (rings + 1);
+
+ y = mid_height * v;
+ y = (mid_height * 0.5) - y;
+
+ for (i = 0; i <= radial_segments; i++) {
+ u = i;
+ u /= radial_segments;
+
+ x = sin(u * (Math_PI * 2.0));
+ z = cos(u * (Math_PI * 2.0));
+
+ Vector3 p = Vector3(x * radius, y, z * radius);
+ points.push_back(p);
+ normals.push_back(Vector3(x, 0.0, z));
+ ADD_TANGENT(-z, 0.0, x, -1.0)
+ uvs.push_back(Vector2(u, onethird + (v * onethird)));
+ point++;
+
+ if (i > 0 && j > 0) {
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+ };
+
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ /* bottom hemisphere */
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (rings + 1); j++) {
+ v = j;
+ w;
+
+ v /= (rings + 1);
+ v += 1.0;
+ w = sin(0.5 * Math_PI * v);
+ y = radius * cos(0.5 * Math_PI * v);
+
+ for (i = 0; i <= radial_segments; i++) {
+ float u = i;
+ u /= radial_segments;
+
+ x = sin(u * (Math_PI * 2.0));
+ z = cos(u * (Math_PI * 2.0));
+
+ Vector3 p = Vector3(x * radius * w, y, z * radius * w);
+ points.push_back(p + Vector3(0.0, -0.5 * mid_height, 0.0));
+ normals.push_back(p.normalized());
+ ADD_TANGENT(-z, 0.0, x, -1.0)
+ uvs.push_back(Vector2(u, twothirds + ((v - 1.0) * onethird)));
+ point++;
+
+ if (i > 0 && j > 0) {
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+ };
+
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ p_arr[VS::ARRAY_VERTEX] = points;
+ p_arr[VS::ARRAY_NORMAL] = normals;
+ p_arr[VS::ARRAY_TANGENT] = tangents;
+ p_arr[VS::ARRAY_TEX_UV] = uvs;
+ p_arr[VS::ARRAY_INDEX] = indices;
+}
+
+void CapsuleMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_radius", "radius"), &CapsuleMesh::set_radius);
+ ClassDB::bind_method(D_METHOD("get_radius"), &CapsuleMesh::get_radius);
+ ClassDB::bind_method(D_METHOD("set_mid_height", "mid_height"), &CapsuleMesh::set_mid_height);
+ ClassDB::bind_method(D_METHOD("get_mid_height"), &CapsuleMesh::get_mid_height);
+
+ ClassDB::bind_method(D_METHOD("set_radial_segments", "segments"), &CapsuleMesh::set_radial_segments);
+ ClassDB::bind_method(D_METHOD("get_radial_segments"), &CapsuleMesh::get_radial_segments);
+ ClassDB::bind_method(D_METHOD("set_rings", "rings"), &CapsuleMesh::set_rings);
+ ClassDB::bind_method(D_METHOD("get_rings"), &CapsuleMesh::get_rings);
+
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_radius", "get_radius");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "mid_height", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_mid_height", "get_mid_height");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
+}
+
+void CapsuleMesh::set_radius(const float p_radius) {
+ radius = p_radius;
+ _queue_update();
+}
+
+float CapsuleMesh::get_radius() const {
+ return radius;
+}
+
+void CapsuleMesh::set_mid_height(const float p_mid_height) {
+ mid_height = p_mid_height;
+ _queue_update();
+}
+
+float CapsuleMesh::get_mid_height() const {
+ return mid_height;
+}
+
+void CapsuleMesh::set_radial_segments(const int p_segments) {
+ radial_segments = p_segments > 4 ? p_segments : 4;
+ _queue_update();
+}
+
+int CapsuleMesh::get_radial_segments() const {
+ return radial_segments;
+}
+
+void CapsuleMesh::set_rings(const int p_rings) {
+ rings = p_rings > 1 ? p_rings : 1;
+ _queue_update();
+}
+
+int CapsuleMesh::get_rings() const {
+ return rings;
+}
+
+CapsuleMesh::CapsuleMesh() {
+ // defaults
+ radius = 0.5;
+ mid_height = 0.5;
+ radial_segments = 64;
+ rings = 8;
+}
+
+/**
+ CubeMesh
+*/
+
+void CubeMesh::_create_mesh_array(Array &p_arr) {
+ int i, j, prevrow, thisrow, point;
+ float x, y, z;
+ float onethird = 1.0 / 3.0;
+ float twothirds = 2.0 / 3.0;
+
+ Vector3 start_pos = size * -0.5;
+
+ // set our bounding box
+ set_aabb(Rect3(start_pos, size));
+
+ PoolVector<Vector3> points;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+ PoolVector<int> indices;
+ point = 0;
+
+#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
+ tangents.push_back(m_x); \
+ tangents.push_back(m_y); \
+ tangents.push_back(m_z); \
+ tangents.push_back(m_d);
+
+ // front + back
+ y = start_pos.y;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= subdivide_h + 1; j++) {
+ x = start_pos.x;
+ for (i = 0; i <= subdivide_w + 1; i++) {
+ float u = i;
+ float v = j;
+ u /= (3.0 * (subdivide_w + 1.0));
+ v /= (2.0 * (subdivide_h + 1.0));
+
+ // front
+ points.push_back(Vector3(x, -y, -start_pos.z)); // double negative on the Z!
+ normals.push_back(Vector3(0.0, 0.0, 1.0));
+ ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(u, v));
+ point++;
+
+ // back
+ points.push_back(Vector3(-x, -y, start_pos.z));
+ normals.push_back(Vector3(0.0, 0.0, -1.0));
+ ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(twothirds + u, v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ int i2 = i * 2;
+
+ // front
+ indices.push_back(prevrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+
+ // back
+ indices.push_back(prevrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ };
+
+ x += size.x / (subdivide_w + 1.0);
+ };
+
+ y += size.y / (subdivide_h + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ // left + right
+ y = start_pos.y;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (subdivide_h + 1); j++) {
+ z = start_pos.z;
+ for (i = 0; i <= (subdivide_d + 1); i++) {
+ float u = i;
+ float v = j;
+ u /= (3.0 * (subdivide_d + 1.0));
+ v /= (2.0 * (subdivide_h + 1.0));
+
+ // right
+ points.push_back(Vector3(-start_pos.x, -y, -z));
+ normals.push_back(Vector3(1.0, 0.0, 0.0));
+ ADD_TANGENT(0.0, 0.0, 1.0, -1.0);
+ uvs.push_back(Vector2(onethird + u, v));
+ point++;
+
+ // left
+ points.push_back(Vector3(start_pos.x, -y, z));
+ normals.push_back(Vector3(-1.0, 0.0, 0.0));
+ ADD_TANGENT(0.0, 0.0, -1.0, -1.0);
+ uvs.push_back(Vector2(u, 0.5 + v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ int i2 = i * 2;
+
+ // right
+ indices.push_back(prevrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+
+ // left
+ indices.push_back(prevrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ };
+
+ z += size.z / (subdivide_d + 1.0);
+ };
+
+ y += size.y / (subdivide_h + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ // top + bottom
+ z = start_pos.z;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (subdivide_d + 1); j++) {
+ x = start_pos.x;
+ for (i = 0; i <= (subdivide_w + 1); i++) {
+ float u = i;
+ float v = j;
+ u /= (3.0 * (subdivide_w + 1.0));
+ v /= (2.0 * (subdivide_d + 1.0));
+
+ // top
+ points.push_back(Vector3(-x, -start_pos.y, -z));
+ normals.push_back(Vector3(0.0, 1.0, 0.0));
+ ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(onethird + u, 0.5 + v));
+ point++;
+
+ // bottom
+ points.push_back(Vector3(x, start_pos.y, -z));
+ normals.push_back(Vector3(0.0, -1.0, 0.0));
+ ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(twothirds + u, 0.5 + v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ int i2 = i * 2;
+
+ // top
+ indices.push_back(prevrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+
+ // bottom
+ indices.push_back(prevrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ };
+
+ x += size.x / (subdivide_w + 1.0);
+ };
+
+ z += size.z / (subdivide_d + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ p_arr[VS::ARRAY_VERTEX] = points;
+ p_arr[VS::ARRAY_NORMAL] = normals;
+ p_arr[VS::ARRAY_TANGENT] = tangents;
+ p_arr[VS::ARRAY_TEX_UV] = uvs;
+ p_arr[VS::ARRAY_INDEX] = indices;
+}
+
+void CubeMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_size", "size"), &CubeMesh::set_size);
+ ClassDB::bind_method(D_METHOD("get_size"), &CubeMesh::get_size);
+
+ ClassDB::bind_method(D_METHOD("set_subdivide_width", "subdivide"), &CubeMesh::set_subdivide_width);
+ ClassDB::bind_method(D_METHOD("get_subdivide_width"), &CubeMesh::get_subdivide_width);
+ ClassDB::bind_method(D_METHOD("set_subdivide_height", "divisions"), &CubeMesh::set_subdivide_height);
+ ClassDB::bind_method(D_METHOD("get_subdivide_height"), &CubeMesh::get_subdivide_height);
+ ClassDB::bind_method(D_METHOD("set_subdivide_depth", "divisions"), &CubeMesh::set_subdivide_depth);
+ ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &CubeMesh::get_subdivide_depth);
+
+ ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_height", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_height", "get_subdivide_height");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
+}
+
+void CubeMesh::set_size(const Vector3 &p_size) {
+ size = p_size;
+ _queue_update();
+}
+
+Vector3 CubeMesh::get_size() const {
+ return size;
+}
+
+void CubeMesh::set_subdivide_width(const int p_subdivide) {
+ subdivide_w = p_subdivide > 0 ? p_subdivide : 0;
+ _queue_update();
+}
+
+int CubeMesh::get_subdivide_width() const {
+ return subdivide_w;
+}
+
+void CubeMesh::set_subdivide_height(const int p_subdivide) {
+ subdivide_h = p_subdivide > 0 ? p_subdivide : 0;
+ _queue_update();
+}
+
+int CubeMesh::get_subdivide_height() const {
+ return subdivide_h;
+}
+
+void CubeMesh::set_subdivide_depth(const int p_subdivide) {
+ subdivide_d = p_subdivide > 0 ? p_subdivide : 0;
+ _queue_update();
+}
+
+int CubeMesh::get_subdivide_depth() const {
+ return subdivide_d;
+}
+
+CubeMesh::CubeMesh() {
+ // defaults
+ size = Vector3(1.0, 1.0, 1.0);
+ subdivide_w = 0;
+ subdivide_h = 0;
+ subdivide_d = 0;
+}
+
+/**
+ CylinderMesh
+*/
+
+void CylinderMesh::_create_mesh_array(Array &p_arr) {
+ int i, j, prevrow, thisrow, point;
+ float x, y, z, u, v, radius;
+
+ radius = bottom_radius > top_radius ? bottom_radius : top_radius;
+
+ set_aabb(Rect3(Vector3(-radius, height * -0.5, -radius), Vector3(radius * 2.0, height, radius * 2.0)));
+
+ PoolVector<Vector3> points;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+ PoolVector<int> indices;
+ point = 0;
+
+#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
+ tangents.push_back(m_x); \
+ tangents.push_back(m_y); \
+ tangents.push_back(m_z); \
+ tangents.push_back(m_d);
+
+ thisrow = 0;
+ prevrow = 0;
+ for (j = 0; j <= (rings + 1); j++) {
+ v = j;
+ v /= (rings + 1);
+
+ radius = top_radius + ((bottom_radius - top_radius) * v);
+
+ y = height * v;
+ y = (height * 0.5) - y;
+
+ for (i = 0; i <= radial_segments; i++) {
+ u = i;
+ u /= radial_segments;
+
+ x = sin(u * (Math_PI * 2.0));
+ z = cos(u * (Math_PI * 2.0));
+
+ Vector3 p = Vector3(x * radius, y, z * radius);
+ points.push_back(p);
+ normals.push_back(Vector3(x, 0.0, z));
+ ADD_TANGENT(-z, 0.0, x, -1.0)
+ uvs.push_back(Vector2(u, v * 0.5));
+ point++;
+
+ if (i > 0 && j > 0) {
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+ };
+
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ // add top
+ if (top_radius > 0.0) {
+ y = height * 0.5;
+
+ thisrow = point;
+ points.push_back(Vector3(0.0, y, 0.0));
+ normals.push_back(Vector3(0.0, 1.0, 0.0));
+ ADD_TANGENT(1.0, 0.0, 0.0, 1.0)
+ uvs.push_back(Vector2(0.25, 0.75));
+ point++;
+
+ for (i = 0; i <= radial_segments; i++) {
+ float r = i;
+ r /= radial_segments;
+
+ x = sin(r * (Math_PI * 2.0));
+ z = cos(r * (Math_PI * 2.0));
+
+ u = ((x + 1.0) * 0.25);
+ v = 0.5 + ((z + 1.0) * 0.25);
+
+ Vector3 p = Vector3(x * top_radius, y, z * top_radius);
+ points.push_back(p);
+ normals.push_back(Vector3(0.0, 1.0, 0.0));
+ ADD_TANGENT(1.0, 0.0, 0.0, 1.0)
+ uvs.push_back(Vector2(u, v));
+ point++;
+
+ if (i > 0) {
+ indices.push_back(thisrow);
+ indices.push_back(point - 1);
+ indices.push_back(point - 2);
+ };
+ };
+ };
+
+ // add bottom
+ if (bottom_radius > 0.0) {
+ y = height * -0.5;
+
+ thisrow = point;
+ points.push_back(Vector3(0.0, y, 0.0));
+ normals.push_back(Vector3(0.0, -1.0, 0.0));
+ ADD_TANGENT(-1.0, 0.0, 0.0, -1.0)
+ uvs.push_back(Vector2(0.75, 0.75));
+ point++;
+
+ for (i = 0; i <= radial_segments; i++) {
+ float r = i;
+ r /= radial_segments;
+
+ x = sin(r * (Math_PI * 2.0));
+ z = cos(r * (Math_PI * 2.0));
+
+ u = 0.5 + ((x + 1.0) * 0.25);
+ v = 1.0 - ((z + 1.0) * 0.25);
+
+ Vector3 p = Vector3(x * bottom_radius, y, z * bottom_radius);
+ points.push_back(p);
+ normals.push_back(Vector3(0.0, -1.0, 0.0));
+ ADD_TANGENT(-1.0, 0.0, 0.0, -1.0)
+ uvs.push_back(Vector2(u, v));
+ point++;
+
+ if (i > 0) {
+ indices.push_back(thisrow);
+ indices.push_back(point - 2);
+ indices.push_back(point - 1);
+ };
+ };
+ };
+
+ p_arr[VS::ARRAY_VERTEX] = points;
+ p_arr[VS::ARRAY_NORMAL] = normals;
+ p_arr[VS::ARRAY_TANGENT] = tangents;
+ p_arr[VS::ARRAY_TEX_UV] = uvs;
+ p_arr[VS::ARRAY_INDEX] = indices;
+}
+
+void CylinderMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_top_radius", "radius"), &CylinderMesh::set_top_radius);
+ ClassDB::bind_method(D_METHOD("get_top_radius"), &CylinderMesh::get_top_radius);
+ ClassDB::bind_method(D_METHOD("set_bottom_radius", "radius"), &CylinderMesh::set_bottom_radius);
+ ClassDB::bind_method(D_METHOD("get_bottom_radius"), &CylinderMesh::get_bottom_radius);
+ ClassDB::bind_method(D_METHOD("set_height", "height"), &CylinderMesh::set_height);
+ ClassDB::bind_method(D_METHOD("get_height"), &CylinderMesh::get_height);
+
+ ClassDB::bind_method(D_METHOD("set_radial_segments", "segments"), &CylinderMesh::set_radial_segments);
+ ClassDB::bind_method(D_METHOD("get_radial_segments"), &CylinderMesh::get_radial_segments);
+ ClassDB::bind_method(D_METHOD("set_rings", "rings"), &CylinderMesh::set_rings);
+ ClassDB::bind_method(D_METHOD("get_rings"), &CylinderMesh::get_rings);
+
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "top_radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_top_radius", "get_top_radius");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "bottom_radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_bottom_radius", "get_bottom_radius");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_height", "get_height");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
+}
+
+void CylinderMesh::set_top_radius(const float p_radius) {
+ top_radius = p_radius;
+ _queue_update();
+}
+
+float CylinderMesh::get_top_radius() const {
+ return top_radius;
+}
+
+void CylinderMesh::set_bottom_radius(const float p_radius) {
+ bottom_radius = p_radius;
+ _queue_update();
+}
+
+float CylinderMesh::get_bottom_radius() const {
+ return bottom_radius;
+}
+
+void CylinderMesh::set_height(const float p_height) {
+ height = p_height;
+ _queue_update();
+}
+
+float CylinderMesh::get_height() const {
+ return height;
+}
+
+void CylinderMesh::set_radial_segments(const int p_segments) {
+ radial_segments = p_segments > 4 ? p_segments : 4;
+ _queue_update();
+}
+
+int CylinderMesh::get_radial_segments() const {
+ return radial_segments;
+}
+
+void CylinderMesh::set_rings(const int p_rings) {
+ rings = p_rings > 0 ? p_rings : 0;
+ _queue_update();
+}
+
+int CylinderMesh::get_rings() const {
+ return rings;
+}
+
+CylinderMesh::CylinderMesh() {
+ // defaults
+ top_radius = 0.5;
+ bottom_radius = 0.5;
+ height = 1.0;
+ radial_segments = 64;
+ rings = 4;
+}
+
+/**
+ PlaneMesh
+*/
+
+void PlaneMesh::_create_mesh_array(Array &p_arr) {
+ int i, j, prevrow, thisrow, point;
+ float x, z;
+
+ Size2 start_pos = size * -0.5;
+
+ set_aabb(Rect3(Vector3(start_pos.x, 0.0, start_pos.y), Vector3(size.x, 0.0, size.y)));
+
+ PoolVector<Vector3> points;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+ PoolVector<int> indices;
+ point = 0;
+
+#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
+ tangents.push_back(m_x); \
+ tangents.push_back(m_y); \
+ tangents.push_back(m_z); \
+ tangents.push_back(m_d);
+
+ /* top + bottom */
+ z = start_pos.y;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (subdivide_d + 1); j++) {
+ x = start_pos.x;
+ for (i = 0; i <= (subdivide_w + 1); i++) {
+ float u = i;
+ float v = j;
+ u /= (subdivide_w + 1.0);
+ v /= (subdivide_d + 1.0);
+
+ points.push_back(Vector3(-x, 0.0, -z));
+ normals.push_back(Vector3(0.0, 1.0, 0.0));
+ ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(u, v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+
+ x += size.x / (subdivide_w + 1.0);
+ };
+
+ z += size.y / (subdivide_d + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ p_arr[VS::ARRAY_VERTEX] = points;
+ p_arr[VS::ARRAY_NORMAL] = normals;
+ p_arr[VS::ARRAY_TANGENT] = tangents;
+ p_arr[VS::ARRAY_TEX_UV] = uvs;
+ p_arr[VS::ARRAY_INDEX] = indices;
+}
+
+void PlaneMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_size", "size"), &PlaneMesh::set_size);
+ ClassDB::bind_method(D_METHOD("get_size"), &PlaneMesh::get_size);
+
+ ClassDB::bind_method(D_METHOD("set_subdivide_width", "subdivide"), &PlaneMesh::set_subdivide_width);
+ ClassDB::bind_method(D_METHOD("get_subdivide_width"), &PlaneMesh::get_subdivide_width);
+ ClassDB::bind_method(D_METHOD("set_subdivide_depth", "subdivide"), &PlaneMesh::set_subdivide_depth);
+ ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &PlaneMesh::get_subdivide_depth);
+
+ ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
+}
+
+void PlaneMesh::set_size(const Size2 &p_size) {
+ size = p_size;
+ _queue_update();
+}
+
+Size2 PlaneMesh::get_size() const {
+ return size;
+}
+
+void PlaneMesh::set_subdivide_width(const int p_subdivide) {
+ subdivide_w = p_subdivide > 0 ? p_subdivide : 0;
+ _queue_update();
+}
+
+int PlaneMesh::get_subdivide_width() const {
+ return subdivide_w;
+}
+
+void PlaneMesh::set_subdivide_depth(const int p_subdivide) {
+ subdivide_d = p_subdivide > 0 ? p_subdivide : 0;
+ _queue_update();
+}
+
+int PlaneMesh::get_subdivide_depth() const {
+ return subdivide_d;
+}
+
+PlaneMesh::PlaneMesh() {
+ // defaults
+ size = Size2(1.0, 1.0);
+ subdivide_w = 0;
+ subdivide_d = 0;
+}
+
+/**
+ PrismMesh
+*/
+
+void PrismMesh::_create_mesh_array(Array &p_arr) {
+ int i, j, prevrow, thisrow, point;
+ float x, y, z;
+ float onethird = 1.0 / 3.0;
+ float twothirds = 2.0 / 3.0;
+
+ Vector3 start_pos = size * -0.5;
+
+ // set our bounding box
+ set_aabb(Rect3(start_pos, size));
+
+ PoolVector<Vector3> points;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+ PoolVector<int> indices;
+ point = 0;
+
+#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
+ tangents.push_back(m_x); \
+ tangents.push_back(m_y); \
+ tangents.push_back(m_z); \
+ tangents.push_back(m_d);
+
+ /* front + back */
+ y = start_pos.y;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (subdivide_h + 1); j++) {
+ float scale = (y - start_pos.y) / size.y;
+ float scaled_size_x = size.x * scale;
+ float start_x = start_pos.x;
+ float offset_front = 0.0;
+ float offset_back = 0.0;
+
+ start_x += (1.0 - scale) * size.x * left_to_right;
+ offset_front += (1.0 - scale) * onethird * left_to_right;
+ offset_back = (1.0 - scale) * onethird * (1.0 - left_to_right);
+
+ x = 0.0;
+ for (i = 0; i <= (subdivide_w + 1); i++) {
+ float u = i;
+ float v = j;
+ u /= (3.0 * (subdivide_w + 1.0));
+ v /= (2.0 * (subdivide_h + 1.0));
+
+ u *= scale;
+
+ /* front */
+ points.push_back(Vector3(start_x + x, -y, -start_pos.z)); // double negative on the Z!
+ normals.push_back(Vector3(0.0, 0.0, 1.0));
+ ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(offset_front + u, v));
+ point++;
+
+ /* back */
+ points.push_back(Vector3(start_x + scaled_size_x - x, -y, start_pos.z));
+ normals.push_back(Vector3(0.0, 0.0, -1.0));
+ ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(twothirds + offset_back + u, v));
+ point++;
+
+ if (i > 0 && j == 1) {
+ int i2 = i * 2;
+
+ /* front */
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+
+ /* back */
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ } else if (i > 0 && j > 0) {
+ int i2 = i * 2;
+
+ /* front */
+ indices.push_back(prevrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+
+ /* back */
+ indices.push_back(prevrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ };
+
+ x += scale * size.x / (subdivide_w + 1.0);
+ };
+
+ y += size.y / (subdivide_h + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ /* left + right */
+ Vector3 normal_left, normal_right;
+
+ normal_left = Vector3(-size.y, size.x * left_to_right, 0.0);
+ normal_right = Vector3(size.y, size.x * left_to_right, 0.0);
+ normal_left.normalize();
+ normal_right.normalize();
+
+ y = start_pos.y;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (subdivide_h + 1); j++) {
+ float left, right;
+ float scale = (y - start_pos.y) / size.y;
+
+ left = start_pos.x + (size.x * (1.0 - scale) * left_to_right);
+ right = left + (size.x * scale);
+
+ z = start_pos.z;
+ for (i = 0; i <= (subdivide_d + 1); i++) {
+ float u = i;
+ float v = j;
+ u /= (3.0 * (subdivide_d + 1.0));
+ v /= (2.0 * (subdivide_h + 1.0));
+
+ /* right */
+ points.push_back(Vector3(right, -y, -z));
+ normals.push_back(normal_right);
+ ADD_TANGENT(0.0, 0.0, 1.0, -1.0);
+ uvs.push_back(Vector2(onethird + u, v));
+ point++;
+
+ /* left */
+ points.push_back(Vector3(left, -y, z));
+ normals.push_back(normal_left);
+ ADD_TANGENT(0.0, 0.0, -1.0, -1.0);
+ uvs.push_back(Vector2(u, 0.5 + v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ int i2 = i * 2;
+
+ /* right */
+ indices.push_back(prevrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+ indices.push_back(prevrow + i2);
+ indices.push_back(thisrow + i2);
+ indices.push_back(thisrow + i2 - 2);
+
+ /* left */
+ indices.push_back(prevrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ indices.push_back(prevrow + i2 + 1);
+ indices.push_back(thisrow + i2 + 1);
+ indices.push_back(thisrow + i2 - 1);
+ };
+
+ z += size.z / (subdivide_d + 1.0);
+ };
+
+ y += size.y / (subdivide_h + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ /* bottom */
+ z = start_pos.z;
+ thisrow = point;
+ prevrow = 0;
+ for (j = 0; j <= (subdivide_d + 1); j++) {
+ x = start_pos.x;
+ for (i = 0; i <= (subdivide_w + 1); i++) {
+ float u = i;
+ float v = j;
+ u /= (3.0 * (subdivide_w + 1.0));
+ v /= (2.0 * (subdivide_d + 1.0));
+
+ /* bottom */
+ points.push_back(Vector3(x, start_pos.y, -z));
+ normals.push_back(Vector3(0.0, -1.0, 0.0));
+ ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
+ uvs.push_back(Vector2(twothirds + u, 0.5 + v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ /* bottom */
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+
+ x += size.x / (subdivide_w + 1.0);
+ };
+
+ z += size.z / (subdivide_d + 1.0);
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ p_arr[VS::ARRAY_VERTEX] = points;
+ p_arr[VS::ARRAY_NORMAL] = normals;
+ p_arr[VS::ARRAY_TANGENT] = tangents;
+ p_arr[VS::ARRAY_TEX_UV] = uvs;
+ p_arr[VS::ARRAY_INDEX] = indices;
+}
+
+void PrismMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_left_to_right", "left_to_right"), &PrismMesh::set_left_to_right);
+ ClassDB::bind_method(D_METHOD("get_left_to_right"), &PrismMesh::get_left_to_right);
+
+ ClassDB::bind_method(D_METHOD("set_size", "size"), &PrismMesh::set_size);
+ ClassDB::bind_method(D_METHOD("get_size"), &PrismMesh::get_size);
+
+ ClassDB::bind_method(D_METHOD("set_subdivide_width", "segments"), &PrismMesh::set_subdivide_width);
+ ClassDB::bind_method(D_METHOD("get_subdivide_width"), &PrismMesh::get_subdivide_width);
+ ClassDB::bind_method(D_METHOD("set_subdivide_height", "segments"), &PrismMesh::set_subdivide_height);
+ ClassDB::bind_method(D_METHOD("get_subdivide_height"), &PrismMesh::get_subdivide_height);
+ ClassDB::bind_method(D_METHOD("set_subdivide_depth", "segments"), &PrismMesh::set_subdivide_depth);
+ ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &PrismMesh::get_subdivide_depth);
+
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "left_to_right", PROPERTY_HINT_RANGE, "-2.0,2.0,0.1"), "set_left_to_right", "get_left_to_right");
+ ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_size", "get_size");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_height", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_height", "get_subdivide_height");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
+}
+
+void PrismMesh::set_left_to_right(const float p_left_to_right) {
+ left_to_right = p_left_to_right;
+ _queue_update();
+}
+
+float PrismMesh::get_left_to_right() const {
+ return left_to_right;
+}
+
+void PrismMesh::set_size(const Vector3 &p_size) {
+ size = p_size;
+ _queue_update();
+}
+
+Vector3 PrismMesh::get_size() const {
+ return size;
+}
+
+void PrismMesh::set_subdivide_width(const int p_divisions) {
+ subdivide_w = p_divisions > 0 ? p_divisions : 0;
+ _queue_update();
+}
+
+int PrismMesh::get_subdivide_width() const {
+ return subdivide_w;
+}
+
+void PrismMesh::set_subdivide_height(const int p_divisions) {
+ subdivide_h = p_divisions > 0 ? p_divisions : 0;
+ _queue_update();
+}
+
+int PrismMesh::get_subdivide_height() const {
+ return subdivide_h;
+}
+
+void PrismMesh::set_subdivide_depth(const int p_divisions) {
+ subdivide_d = p_divisions > 0 ? p_divisions : 0;
+ _queue_update();
+}
+
+int PrismMesh::get_subdivide_depth() const {
+ return subdivide_d;
+}
+
+PrismMesh::PrismMesh() {
+ // defaults
+ left_to_right = 0.5;
+ size = Vector3(1.0, 1.0, 1.0);
+ subdivide_w = 0;
+ subdivide_h = 0;
+ subdivide_d = 0;
+}
+
+/**
+ QuadMesh
+*/
+
+void QuadMesh::_create_mesh_array(Array &p_arr) {
+ PoolVector<Vector3> faces;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+
+ faces.resize(4);
+ normals.resize(4);
+ tangents.resize(4 * 4);
+ uvs.resize(4);
+
+ for (int i = 0; i < 4; i++) {
+
+ static const Vector3 quad_faces[4] = {
+ Vector3(-1, -1, 0),
+ Vector3(-1, 1, 0),
+ Vector3(1, 1, 0),
+ Vector3(1, -1, 0),
+ };
+
+ faces.set(i, quad_faces[i]);
+ normals.set(i, Vector3(0, 0, 1));
+ tangents.set(i * 4 + 0, 1.0);
+ tangents.set(i * 4 + 1, 0.0);
+ tangents.set(i * 4 + 2, 0.0);
+ tangents.set(i * 4 + 3, 1.0);
+
+ static const Vector2 quad_uv[4] = {
+ Vector2(0, 1),
+ Vector2(0, 0),
+ Vector2(1, 0),
+ Vector2(1, 1),
+ };
+
+ uvs.set(i, quad_uv[i]);
+ }
+
+ p_arr[ARRAY_VERTEX] = faces;
+ p_arr[ARRAY_NORMAL] = normals;
+ p_arr[ARRAY_TANGENT] = tangents;
+ p_arr[ARRAY_TEX_UV] = uvs;
+};
+
+void QuadMesh::_bind_methods() {
+ // nothing here yet...
+}
+
+QuadMesh::QuadMesh() {
+ primitive_type = PRIMITIVE_TRIANGLE_FAN;
+}
+
+/**
+ SphereMesh
+*/
+
+void SphereMesh::_create_mesh_array(Array &p_arr) {
+ int i, j, prevrow, thisrow, point;
+ float x, y, z;
+
+ // set our bounding box
+ set_aabb(Rect3(Vector3(-radius, height * -0.5, -radius), Vector3(radius * 2.0, height, radius * 2.0)));
+
+ PoolVector<Vector3> points;
+ PoolVector<Vector3> normals;
+ PoolVector<float> tangents;
+ PoolVector<Vector2> uvs;
+ PoolVector<int> indices;
+ point = 0;
+
+#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
+ tangents.push_back(m_x); \
+ tangents.push_back(m_y); \
+ tangents.push_back(m_z); \
+ tangents.push_back(m_d);
+
+ thisrow = 0;
+ prevrow = 0;
+ for (j = 0; j <= (rings + 1); j++) {
+ float v = j;
+ float w;
+
+ v /= (rings + 1);
+ w = sin(Math_PI * v);
+ y = height * (is_hemisphere ? 1.0 : 0.5) * cos(Math_PI * v);
+
+ for (i = 0; i <= radial_segments; i++) {
+ float u = i;
+ u /= radial_segments;
+
+ x = sin(u * (Math_PI * 2.0));
+ z = cos(u * (Math_PI * 2.0));
+
+ if (is_hemisphere && y < 0.0) {
+ points.push_back(Vector3(x * radius * w, 0.0, z * radius * w));
+ normals.push_back(Vector3(0.0, -1.0, 0.0));
+ } else {
+ Vector3 p = Vector3(x * radius * w, y, z * radius * w);
+ points.push_back(p);
+ normals.push_back(p.normalized());
+ };
+ ADD_TANGENT(-z, 0.0, x, -1.0)
+ uvs.push_back(Vector2(u, v));
+ point++;
+
+ if (i > 0 && j > 0) {
+ indices.push_back(prevrow + i - 1);
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i - 1);
+
+ indices.push_back(prevrow + i);
+ indices.push_back(thisrow + i);
+ indices.push_back(thisrow + i - 1);
+ };
+ };
+
+ prevrow = thisrow;
+ thisrow = point;
+ };
+
+ p_arr[VS::ARRAY_VERTEX] = points;
+ p_arr[VS::ARRAY_NORMAL] = normals;
+ p_arr[VS::ARRAY_TANGENT] = tangents;
+ p_arr[VS::ARRAY_TEX_UV] = uvs;
+ p_arr[VS::ARRAY_INDEX] = indices;
+}
+
+void SphereMesh::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_radius", "radius"), &SphereMesh::set_radius);
+ ClassDB::bind_method(D_METHOD("get_radius"), &SphereMesh::get_radius);
+ ClassDB::bind_method(D_METHOD("set_height", "height"), &SphereMesh::set_height);
+ ClassDB::bind_method(D_METHOD("get_height"), &SphereMesh::get_height);
+
+ ClassDB::bind_method(D_METHOD("set_radial_segments", "radial_segments"), &SphereMesh::set_radial_segments);
+ ClassDB::bind_method(D_METHOD("get_radial_segments"), &SphereMesh::get_radial_segments);
+ ClassDB::bind_method(D_METHOD("set_rings", "rings"), &SphereMesh::set_rings);
+ ClassDB::bind_method(D_METHOD("get_rings"), &SphereMesh::get_rings);
+
+ ClassDB::bind_method(D_METHOD("set_is_hemisphere", "is_hemisphere"), &SphereMesh::set_is_hemisphere);
+ ClassDB::bind_method(D_METHOD("get_is_hemisphere"), &SphereMesh::get_is_hemisphere);
+
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_radius", "get_radius");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_height", "get_height");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_hemisphere"), "set_is_hemisphere", "get_is_hemisphere");
+}
+
+void SphereMesh::set_radius(const float p_radius) {
+ radius = p_radius;
+ _queue_update();
+}
+
+float SphereMesh::get_radius() const {
+ return radius;
+}
+
+void SphereMesh::set_height(const float p_height) {
+ height = p_height;
+ _queue_update();
+}
+
+float SphereMesh::get_height() const {
+ return height;
+}
+
+void SphereMesh::set_radial_segments(const int p_radial_segments) {
+ radial_segments = p_radial_segments > 4 ? p_radial_segments : 4;
+ _queue_update();
+}
+
+int SphereMesh::get_radial_segments() const {
+ return radial_segments;
+}
+
+void SphereMesh::set_rings(const int p_rings) {
+ rings = p_rings > 1 ? p_rings : 1;
+ _queue_update();
+}
+
+int SphereMesh::get_rings() const {
+ return rings;
+}
+
+void SphereMesh::set_is_hemisphere(const bool p_is_hemisphere) {
+ is_hemisphere = p_is_hemisphere;
+ _queue_update();
+}
+
+bool SphereMesh::get_is_hemisphere() const {
+ return is_hemisphere;
+}
+
+SphereMesh::SphereMesh() {
+ // defaults
+ radius = 0.5;
+ height = 1.0;
+ radial_segments = 64;
+ rings = 32;
+ is_hemisphere = false;
+}
diff --git a/scene/resources/primitive_meshes.h b/scene/resources/primitive_meshes.h
new file mode 100644
index 0000000000..91d1af2ee1
--- /dev/null
+++ b/scene/resources/primitive_meshes.h
@@ -0,0 +1,312 @@
+/*************************************************************************/
+/* primitive_meshes.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* http://www.godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
+/* */
+/* 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. */
+/*************************************************************************/
+
+#ifndef PRIMITIVE_MESHES_H
+#define PRIMITIVE_MESHES_H
+
+#include "scene/resources/mesh.h"
+
+///@TODO probably should change a few integers to unsigned integers...
+
+/**
+ @author Bastiaan Olij <mux213@gmail.com>
+
+ Base class for all the classes in this file, handles a number of code functions that are shared among all meshes.
+ This class is set appart that it assumes a single surface is always generated for our mesh.
+*/
+class PrimitiveMesh : public Mesh {
+
+ GDCLASS(PrimitiveMesh, Mesh);
+
+private:
+ RID mesh;
+ Rect3 aabb;
+
+ Ref<Material> material;
+
+ bool cache_is_dirty;
+ void _update();
+
+protected:
+ Mesh::PrimitiveType primitive_type;
+
+ static void _bind_methods();
+
+ virtual void _create_mesh_array(Array &p_arr) = 0;
+ void _queue_update();
+
+ void set_aabb(Rect3 p_aabb);
+
+public:
+ virtual int get_surface_count() const;
+ virtual int surface_get_array_len(int p_idx) const;
+ virtual int surface_get_array_index_len(int p_idx) const;
+ virtual Array surface_get_arrays(int p_surface) const;
+ virtual uint32_t surface_get_format(int p_idx) const;
+ virtual Mesh::PrimitiveType surface_get_primitive_type(int p_idx) const;
+ virtual Ref<Material> surface_get_material(int p_idx) const;
+ virtual int get_blend_shape_count() const;
+ virtual StringName get_blend_shape_name(int p_index) const;
+ virtual Rect3 get_aabb() const;
+ virtual RID get_rid() const;
+
+ void set_material(const Ref<Material> &p_material);
+ Ref<Material> get_material() const;
+
+ PrimitiveMesh();
+ ~PrimitiveMesh();
+};
+
+/**
+ Mesh for a simple capsule
+*/
+class CapsuleMesh : public PrimitiveMesh {
+ GDCLASS(CapsuleMesh, PrimitiveMesh);
+
+private:
+ float radius;
+ float mid_height;
+ int radial_segments;
+ int rings;
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ void set_radius(const float p_radius);
+ float get_radius() const;
+
+ void set_mid_height(const float p_mid_height);
+ float get_mid_height() const;
+
+ void set_radial_segments(const int p_segments);
+ int get_radial_segments() const;
+
+ void set_rings(const int p_rings);
+ int get_rings() const;
+
+ CapsuleMesh();
+};
+
+/**
+ Similar to test cube but with subdivision support and different texture coordinates
+*/
+class CubeMesh : public PrimitiveMesh {
+
+ GDCLASS(CubeMesh, PrimitiveMesh);
+
+private:
+ Vector3 size;
+ int subdivide_w;
+ int subdivide_h;
+ int subdivide_d;
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ void set_size(const Vector3 &p_size);
+ Vector3 get_size() const;
+
+ void set_subdivide_width(const int p_divisions);
+ int get_subdivide_width() const;
+
+ void set_subdivide_height(const int p_divisions);
+ int get_subdivide_height() const;
+
+ void set_subdivide_depth(const int p_divisions);
+ int get_subdivide_depth() const;
+
+ CubeMesh();
+};
+
+/**
+ A cylinder
+*/
+
+class CylinderMesh : public PrimitiveMesh {
+
+ GDCLASS(CylinderMesh, PrimitiveMesh);
+
+private:
+ float top_radius;
+ float bottom_radius;
+ float height;
+ int radial_segments;
+ int rings;
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ void set_top_radius(const float p_radius);
+ float get_top_radius() const;
+
+ void set_bottom_radius(const float p_radius);
+ float get_bottom_radius() const;
+
+ void set_height(const float p_height);
+ float get_height() const;
+
+ void set_radial_segments(const int p_segments);
+ int get_radial_segments() const;
+
+ void set_rings(const int p_rings);
+ int get_rings() const;
+
+ CylinderMesh();
+};
+
+/**
+ Similar to quadmesh but with tesselation support
+*/
+class PlaneMesh : public PrimitiveMesh {
+
+ GDCLASS(PlaneMesh, PrimitiveMesh);
+
+private:
+ Size2 size;
+ int subdivide_w;
+ int subdivide_d;
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ void set_size(const Size2 &p_size);
+ Size2 get_size() const;
+
+ void set_subdivide_width(const int p_divisions);
+ int get_subdivide_width() const;
+
+ void set_subdivide_depth(const int p_divisions);
+ int get_subdivide_depth() const;
+
+ PlaneMesh();
+};
+
+/**
+ A prism shapen, handy for ramps, triangles, etc.
+*/
+class PrismMesh : public PrimitiveMesh {
+
+ GDCLASS(PrismMesh, PrimitiveMesh);
+
+private:
+ float left_to_right;
+ Vector3 size;
+ int subdivide_w;
+ int subdivide_h;
+ int subdivide_d;
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ void set_left_to_right(const float p_left_to_right);
+ float get_left_to_right() const;
+
+ void set_size(const Vector3 &p_size);
+ Vector3 get_size() const;
+
+ void set_subdivide_width(const int p_divisions);
+ int get_subdivide_width() const;
+
+ void set_subdivide_height(const int p_divisions);
+ int get_subdivide_height() const;
+
+ void set_subdivide_depth(const int p_divisions);
+ int get_subdivide_depth() const;
+
+ PrismMesh();
+};
+
+/**
+ Our original quadmesh...
+*/
+
+class QuadMesh : public PrimitiveMesh {
+
+ GDCLASS(QuadMesh, PrimitiveMesh)
+
+private:
+ // nothing? really? Maybe add size some day atleast... :)
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ QuadMesh();
+};
+
+/**
+ A sphere..
+*/
+class SphereMesh : public PrimitiveMesh {
+
+ GDCLASS(SphereMesh, PrimitiveMesh);
+
+private:
+ float radius;
+ float height;
+ int radial_segments;
+ int rings;
+ bool is_hemisphere;
+
+protected:
+ static void _bind_methods();
+ virtual void _create_mesh_array(Array &p_arr);
+
+public:
+ void set_radius(const float p_radius);
+ float get_radius() const;
+
+ void set_height(const float p_height);
+ float get_height() const;
+
+ void set_radial_segments(const int p_radial_segments);
+ int get_radial_segments() const;
+
+ void set_rings(const int p_rings);
+ int get_rings() const;
+
+ void set_is_hemisphere(const bool p_is_hemisphere);
+ bool get_is_hemisphere() const;
+
+ SphereMesh();
+};
+
+#endif
diff --git a/scene/resources/shader_graph.h b/scene/resources/shader_graph.h
index b9ec294eb8..36578ce1f7 100644
--- a/scene/resources/shader_graph.h
+++ b/scene/resources/shader_graph.h
@@ -37,7 +37,7 @@
class ShaderGraph : public Shader {
GDCLASS( ShaderGraph, Shader );
- RES_BASE_EXTENSION("sgp");
+ RES_BASE_EXTENSION("vshader");
public:
diff --git a/scene/resources/shape.h b/scene/resources/shape.h
index ea3ba9ab0a..c15638aeed 100644
--- a/scene/resources/shape.h
+++ b/scene/resources/shape.h
@@ -37,7 +37,7 @@ class Shape : public Resource {
GDCLASS(Shape, Resource);
OBJ_SAVE_TYPE(Shape);
- RES_BASE_EXTENSION("shp");
+ RES_BASE_EXTENSION("shape");
RID shape;
Ref<ArrayMesh> debug_mesh_cache;
diff --git a/scene/resources/style_box.cpp b/scene/resources/style_box.cpp
index 8874cbc102..2714ffec10 100644
--- a/scene/resources/style_box.cpp
+++ b/scene/resources/style_box.cpp
@@ -114,6 +114,19 @@ RES StyleBoxTexture::get_texture() const {
return texture;
}
+void StyleBoxTexture::set_normal_map(RES p_normal_map) {
+
+ if (normal_map == p_normal_map)
+ return;
+ normal_map = p_normal_map;
+ emit_changed();
+}
+
+RES StyleBoxTexture::get_normal_map() const {
+
+ return normal_map;
+}
+
void StyleBoxTexture::set_margin_size(Margin p_margin, float p_size) {
margin[p_margin] = p_size;
@@ -143,7 +156,11 @@ void StyleBoxTexture::draw(RID p_canvas_item, const Rect2 &p_rect) const {
rect.size.x += expand_margin[MARGIN_LEFT] + expand_margin[MARGIN_RIGHT];
rect.size.y += expand_margin[MARGIN_TOP] + expand_margin[MARGIN_BOTTOM];
- VisualServer::get_singleton()->canvas_item_add_nine_patch(p_canvas_item, rect, src_rect, texture->get_rid(), Vector2(margin[MARGIN_LEFT], margin[MARGIN_TOP]), Vector2(margin[MARGIN_RIGHT], margin[MARGIN_BOTTOM]), VS::NINE_PATCH_STRETCH, VS::NINE_PATCH_STRETCH, draw_center, modulate);
+ RID normal_rid;
+ if (normal_map.is_valid())
+ normal_rid = normal_map->get_rid();
+
+ VisualServer::get_singleton()->canvas_item_add_nine_patch(p_canvas_item, rect, src_rect, texture->get_rid(), Vector2(margin[MARGIN_LEFT], margin[MARGIN_TOP]), Vector2(margin[MARGIN_RIGHT], margin[MARGIN_BOTTOM]), VS::NINE_PATCH_STRETCH, VS::NINE_PATCH_STRETCH, draw_center, modulate, normal_rid);
}
void StyleBoxTexture::set_draw_center(bool p_draw) {
@@ -209,6 +226,9 @@ void StyleBoxTexture::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_texture", "texture:Texture"), &StyleBoxTexture::set_texture);
ClassDB::bind_method(D_METHOD("get_texture:Texture"), &StyleBoxTexture::get_texture);
+ ClassDB::bind_method(D_METHOD("set_normal_map", "normal_map:Texture"), &StyleBoxTexture::set_normal_map);
+ ClassDB::bind_method(D_METHOD("get_normal_map:Texture"), &StyleBoxTexture::get_normal_map);
+
ClassDB::bind_method(D_METHOD("set_margin_size", "margin", "size"), &StyleBoxTexture::set_margin_size);
ClassDB::bind_method(D_METHOD("get_margin_size", "margin"), &StyleBoxTexture::get_margin_size);
@@ -227,6 +247,7 @@ void StyleBoxTexture::_bind_methods() {
ADD_SIGNAL(MethodInfo("texture_changed"));
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture");
+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "normal_map", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_normal_map", "get_normal_map");
ADD_PROPERTYNZ(PropertyInfo(Variant::RECT2, "region_rect"), "set_region_rect", "get_region_rect");
ADD_GROUP("Margin", "margin_");
ADD_PROPERTYI(PropertyInfo(Variant::REAL, "margin_left", PROPERTY_HINT_RANGE, "0,2048,1"), "set_margin_size", "get_margin_size", MARGIN_LEFT);
diff --git a/scene/resources/style_box.h b/scene/resources/style_box.h
index bbb2444bd7..7547c2ea81 100644
--- a/scene/resources/style_box.h
+++ b/scene/resources/style_box.h
@@ -39,7 +39,7 @@
class StyleBox : public Resource {
GDCLASS(StyleBox, Resource);
- RES_BASE_EXTENSION("sbx");
+ RES_BASE_EXTENSION("stylebox");
OBJ_SAVE_TYPE(StyleBox);
float margin[4];
@@ -81,6 +81,7 @@ class StyleBoxTexture : public StyleBox {
float margin[4];
Rect2 region_rect;
Ref<Texture> texture;
+ Ref<Texture> normal_map;
bool draw_center;
Color modulate;
@@ -101,6 +102,9 @@ public:
void set_texture(RES p_texture);
RES get_texture() const;
+ void set_normal_map(RES p_normal_map);
+ RES get_normal_map() const;
+
void set_draw_center(bool p_draw);
bool get_draw_center() const;
virtual Size2 get_center_size() const;
diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index 0b8ad5536c..2120b37497 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -28,25 +28,28 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "texture.h"
+#include "core/method_bind_ext.inc"
#include "core/os/os.h"
#include "io/image_loader.h"
-
Size2 Texture::get_size() const {
return Size2(get_width(), get_height());
}
-void Texture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
+void Texture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
- VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, get_size()), get_rid(), false, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, get_size()), get_rid(), false, p_modulate, p_transpose, normal_rid);
}
-void Texture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
+void Texture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
- VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, get_rid(), p_tile, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, get_rid(), p_tile, p_modulate, p_transpose, normal_rid);
}
-void Texture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
+void Texture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map, bool p_clip_uv) const {
- VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, get_rid(), p_src_rect, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, get_rid(), p_src_rect, p_modulate, p_transpose, normal_rid, p_clip_uv);
}
bool Texture::get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect, Rect2 &r_rect, Rect2 &r_src_rect) const {
@@ -65,9 +68,9 @@ void Texture::_bind_methods() {
ClassDB::bind_method(D_METHOD("has_alpha"), &Texture::has_alpha);
ClassDB::bind_method(D_METHOD("set_flags", "flags"), &Texture::set_flags);
ClassDB::bind_method(D_METHOD("get_flags"), &Texture::get_flags);
- ClassDB::bind_method(D_METHOD("draw", "canvas_item", "pos", "modulate", "transpose"), &Texture::draw, DEFVAL(Color(1, 1, 1)), DEFVAL(false));
- ClassDB::bind_method(D_METHOD("draw_rect", "canvas_item", "rect", "tile", "modulate", "transpose"), &Texture::draw_rect, DEFVAL(Color(1, 1, 1)), DEFVAL(false));
- ClassDB::bind_method(D_METHOD("draw_rect_region", "canvas_item", "rect", "src_rect", "modulate", "transpose"), &Texture::draw_rect_region, DEFVAL(Color(1, 1, 1)), DEFVAL(false));
+ ClassDB::bind_method(D_METHOD("draw", "canvas_item", "pos", "modulate", "transpose", "normal_map:Texture"), &Texture::draw, DEFVAL(Color(1, 1, 1)), DEFVAL(false), DEFVAL(Variant()));
+ ClassDB::bind_method(D_METHOD("draw_rect", "canvas_item", "rect", "tile", "modulate", "transpose", "normal_map:Texture"), &Texture::draw_rect, DEFVAL(Color(1, 1, 1)), DEFVAL(false), DEFVAL(Variant()));
+ ClassDB::bind_method(D_METHOD("draw_rect_region", "canvas_item", "rect", "src_rect", "modulate", "transpose", "normal_map:Texture", "clip_uv"), &Texture::draw_rect_region, DEFVAL(Color(1, 1, 1)), DEFVAL(false), DEFVAL(Variant()), DEFVAL(true));
BIND_CONSTANT(FLAG_MIPMAPS);
BIND_CONSTANT(FLAG_REPEAT);
@@ -265,23 +268,26 @@ bool ImageTexture::has_alpha() const {
return (format == Image::FORMAT_LA8 || format == Image::FORMAT_RGBA8);
}
-void ImageTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
+void ImageTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
if ((w | h) == 0)
return;
- VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, Size2(w, h)), texture, false, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, Size2(w, h)), texture, false, p_modulate, p_transpose, normal_rid);
}
-void ImageTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
+void ImageTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
if ((w | h) == 0)
return;
- VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, texture, p_tile, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, texture, p_tile, p_modulate, p_transpose, normal_rid);
}
-void ImageTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
+void ImageTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map, bool p_clip_uv) const {
if ((w | h) == 0)
return;
- VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, texture, p_src_rect, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, texture, p_src_rect, p_modulate, p_transpose, normal_rid, p_clip_uv);
}
void ImageTexture::set_size_override(const Size2 &p_size) {
@@ -390,8 +396,17 @@ void StreamTexture::_requested_srgb(void *p_ud) {
request_srgb_callback(stex);
}
+void StreamTexture::_requested_normal(void *p_ud) {
+
+ StreamTexture *st = (StreamTexture *)p_ud;
+ Ref<StreamTexture> stex(st);
+ ERR_FAIL_COND(!request_normal_callback);
+ request_normal_callback(stex);
+}
+
StreamTexture::TextureFormatRequestCallback StreamTexture::request_3d_callback = NULL;
StreamTexture::TextureFormatRequestCallback StreamTexture::request_srgb_callback = NULL;
+StreamTexture::TextureFormatRequestCallback StreamTexture::request_normal_callback = NULL;
uint32_t StreamTexture::get_flags() const {
@@ -421,12 +436,13 @@ Error StreamTexture::_load_data(const String &p_path, int &tw, int &th, int &fla
flags = f->get_32(); //texture flags!
uint32_t df = f->get_32(); //data format
- /*
+/*
print_line("width: " + itos(tw));
print_line("height: " + itos(th));
print_line("flags: " + itos(flags));
print_line("df: " + itos(df));
*/
+#ifdef TOOLS_ENABLED
if (request_3d_callback && df & FORMAT_BIT_DETECT_3D) {
//print_line("request detect 3D at " + p_path);
@@ -444,6 +460,14 @@ Error StreamTexture::_load_data(const String &p_path, int &tw, int &th, int &fla
VS::get_singleton()->texture_set_detect_srgb_callback(texture, NULL, NULL);
}
+ if (request_srgb_callback && df & FORMAT_BIT_DETECT_NORMAL) {
+ //print_line("request detect srgb at " + p_path);
+ VS::get_singleton()->texture_set_detect_normal_callback(texture, _requested_normal, this);
+ } else {
+ //print_line("not requesting detect normal at " + p_path);
+ VS::get_singleton()->texture_set_detect_normal_callback(texture, NULL, NULL);
+ }
+#endif
if (!(df & FORMAT_BIT_STREAM)) {
p_size_limit = 0;
}
@@ -647,23 +671,26 @@ RID StreamTexture::get_rid() const {
return texture;
}
-void StreamTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
+void StreamTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
if ((w | h) == 0)
return;
- VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, Size2(w, h)), texture, false, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, Size2(w, h)), texture, false, p_modulate, p_transpose, normal_rid);
}
-void StreamTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
+void StreamTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
if ((w | h) == 0)
return;
- VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, texture, p_tile, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, texture, p_tile, p_modulate, p_transpose, normal_rid);
}
-void StreamTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
+void StreamTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map, bool p_clip_uv) const {
if ((w | h) == 0)
return;
- VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, texture, p_src_rect, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, texture, p_src_rect, p_modulate, p_transpose, normal_rid, p_clip_uv);
}
bool StreamTexture::has_alpha() const {
@@ -845,7 +872,7 @@ void AtlasTexture::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::RECT2, "margin"), "set_margin", "get_margin");
}
-void AtlasTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
+void AtlasTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
Rect2 rc = region;
@@ -860,10 +887,11 @@ void AtlasTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_m
rc.size.height = atlas->get_height();
}
- VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, Rect2(p_pos + margin.position, rc.size), atlas->get_rid(), rc, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, Rect2(p_pos + margin.position, rc.size), atlas->get_rid(), rc, p_modulate, p_transpose, normal_rid);
}
-void AtlasTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
+void AtlasTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
Rect2 rc = region;
@@ -881,9 +909,10 @@ void AtlasTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile
Vector2 scale = p_rect.size / (region.size + margin.size);
Rect2 dr(p_rect.position + margin.position * scale, rc.size * scale);
- VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), rc, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), rc, p_modulate, p_transpose, normal_rid);
}
-void AtlasTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
+void AtlasTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map, bool p_clip_uv) const {
//this might not necessarily work well if using a rect, needs to be fixed properly
Rect2 rc = region;
@@ -911,7 +940,8 @@ void AtlasTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, cons
}
Rect2 dr(p_rect.position + ofs * scale, src_c.size * scale);
- VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), src_c, p_modulate, p_transpose);
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
+ VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), src_c, p_modulate, p_transpose, normal_rid, p_clip_uv);
}
bool AtlasTexture::get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect, Rect2 &r_rect, Rect2 &r_src_rect) const {
@@ -1076,16 +1106,16 @@ void LargeTexture::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_data", "_get_data");
}
-void LargeTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
+void LargeTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
for (int i = 0; i < pieces.size(); i++) {
// TODO
- pieces[i].texture->draw(p_canvas_item, pieces[i].offset + p_pos, p_modulate, p_transpose);
+ pieces[i].texture->draw(p_canvas_item, pieces[i].offset + p_pos, p_modulate, p_transpose, p_normal_map);
}
}
-void LargeTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
+void LargeTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map) const {
//tiling not supported for this
if (size.x == 0 || size.y == 0)
@@ -1093,13 +1123,14 @@ void LargeTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile
Size2 scale = p_rect.size / size;
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
for (int i = 0; i < pieces.size(); i++) {
// TODO
- pieces[i].texture->draw_rect(p_canvas_item, Rect2(pieces[i].offset * scale + p_rect.position, pieces[i].texture->get_size() * scale), false, p_modulate, p_transpose);
+ pieces[i].texture->draw_rect(p_canvas_item, Rect2(pieces[i].offset * scale + p_rect.position, pieces[i].texture->get_size() * scale), false, p_modulate, p_transpose, p_normal_map);
}
}
-void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
+void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, const Ref<Texture> &p_normal_map, bool p_clip_uv) const {
//tiling not supported for this
if (p_src_rect.size.x == 0 || p_src_rect.size.y == 0)
@@ -1107,6 +1138,7 @@ void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, cons
Size2 scale = p_rect.size / p_src_rect.size;
+ RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
for (int i = 0; i < pieces.size(); i++) {
// TODO
@@ -1118,7 +1150,7 @@ void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, cons
target.size *= scale;
target.position = p_rect.position + (p_src_rect.position + rect.position) * scale;
local.position -= rect.position;
- pieces[i].texture->draw_rect_region(p_canvas_item, target, local, p_modulate, p_transpose);
+ pieces[i].texture->draw_rect_region(p_canvas_item, target, local, p_modulate, p_transpose, p_normal_map, false);
}
}
diff --git a/scene/resources/texture.h b/scene/resources/texture.h
index 9ee9588d2b..2b82dbd21f 100644
--- a/scene/resources/texture.h
+++ b/scene/resources/texture.h
@@ -68,9 +68,9 @@ public:
virtual void set_flags(uint32_t p_flags) = 0;
virtual uint32_t get_flags() const = 0;
- virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
+ virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>(), bool p_clip_uv = true) const;
virtual bool get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect, Rect2 &r_rect, Rect2 &r_src_rect) const;
virtual Ref<Image> get_data() const { return Ref<Image>(); }
@@ -131,9 +131,9 @@ public:
virtual RID get_rid() const;
bool has_alpha() const;
- virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
+ virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>(), bool p_clip_uv = true) const;
void set_storage(Storage p_storage);
Storage get_storage() const;
@@ -167,6 +167,7 @@ public:
FORMAT_BIT_HAS_MIPMAPS = 1 << 23,
FORMAT_BIT_DETECT_3D = 1 << 24,
FORMAT_BIT_DETECT_SRGB = 1 << 25,
+ FORMAT_BIT_DETECT_NORMAL = 1 << 26,
};
private:
@@ -181,6 +182,7 @@ private:
static void _requested_3d(void *p_ud);
static void _requested_srgb(void *p_ud);
+ static void _requested_normal(void *p_ud);
protected:
static void _bind_methods();
@@ -190,6 +192,7 @@ public:
static TextureFormatRequestCallback request_3d_callback;
static TextureFormatRequestCallback request_srgb_callback;
+ static TextureFormatRequestCallback request_normal_callback;
uint32_t get_flags() const;
Image::Format get_format() const;
@@ -200,9 +203,9 @@ public:
int get_height() const;
virtual RID get_rid() const;
- virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
+ virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>(), bool p_clip_uv = true) const;
virtual bool has_alpha() const;
virtual void set_flags(uint32_t p_flags);
@@ -226,7 +229,7 @@ VARIANT_ENUM_CAST(ImageTexture::Storage);
class AtlasTexture : public Texture {
GDCLASS(AtlasTexture, Texture);
- RES_BASE_EXTENSION("atex");
+ RES_BASE_EXTENSION("atlastex");
protected:
Ref<Texture> atlas;
@@ -254,9 +257,9 @@ public:
void set_margin(const Rect2 &p_margin);
Rect2 get_margin() const;
- virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
+ virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>(), bool p_clip_uv = true) const;
virtual bool get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect, Rect2 &r_rect, Rect2 &r_src_rect) const;
AtlasTexture();
@@ -265,7 +268,7 @@ public:
class LargeTexture : public Texture {
GDCLASS(LargeTexture, Texture);
- RES_BASE_EXTENSION("ltex");
+ RES_BASE_EXTENSION("largetex");
protected:
struct Piece {
@@ -302,9 +305,9 @@ public:
Vector2 get_piece_offset(int p_idx) const;
Ref<Texture> get_piece_texture(int p_idx) const;
- virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
- virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
+ virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>()) const;
+ virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, const Ref<Texture> &p_normal_map = Ref<Texture>(), bool p_clip_uv = true) const;
LargeTexture();
};
@@ -312,7 +315,7 @@ public:
class CubeMap : public Resource {
GDCLASS(CubeMap, Resource);
- RES_BASE_EXTENSION("cbm");
+ RES_BASE_EXTENSION("cubemap");
public:
enum Storage {
@@ -393,7 +396,7 @@ VARIANT_ENUM_CAST(CubeMap::Storage);
class CurveTexture : public Texture {
GDCLASS(CurveTexture, Texture);
- RES_BASE_EXTENSION("cvtex");
+ RES_BASE_EXTENSION("curvetex");
private:
RID texture;
diff --git a/scene/resources/theme.h b/scene/resources/theme.h
index 1a5cfcf4b2..1dfea7f421 100644
--- a/scene/resources/theme.h
+++ b/scene/resources/theme.h
@@ -43,7 +43,7 @@
class Theme : public Resource {
GDCLASS(Theme, Resource);
- RES_BASE_EXTENSION("thm");
+ RES_BASE_EXTENSION("theme");
static Ref<Theme> default_theme;
diff --git a/scene/resources/world.h b/scene/resources/world.h
index 96857a577a..5291b3974b 100644
--- a/scene/resources/world.h
+++ b/scene/resources/world.h
@@ -41,7 +41,7 @@ class VisibilityNotifier;
class World : public Resource {
GDCLASS(World, Resource);
- RES_BASE_EXTENSION("wrd");
+ RES_BASE_EXTENSION("world");
private:
RID space;
diff --git a/scene/resources/world_2d.cpp b/scene/resources/world_2d.cpp
index ec9ec96e50..36d2a38b3d 100644
--- a/scene/resources/world_2d.cpp
+++ b/scene/resources/world_2d.cpp
@@ -360,16 +360,17 @@ RID World2D::get_space() {
return space;
}
-RID World2D::get_sound_space() {
+void World2D::get_viewport_list(List<Viewport *> *r_viewports) {
- return sound_space;
+ for (Map<Viewport *, SpatialIndexer2D::ViewportData>::Element *E = indexer->viewports.front(); E; E = E->next()) {
+ r_viewports->push_back(E->key());
+ }
}
void World2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_canvas"), &World2D::get_canvas);
ClassDB::bind_method(D_METHOD("get_space"), &World2D::get_space);
- ClassDB::bind_method(D_METHOD("get_sound_space"), &World2D::get_sound_space);
ClassDB::bind_method(D_METHOD("get_direct_space_state:Physics2DDirectSpaceState"), &World2D::get_direct_space_state);
}
diff --git a/scene/resources/world_2d.h b/scene/resources/world_2d.h
index 2b6e7e7383..35c8ce390f 100644
--- a/scene/resources/world_2d.h
+++ b/scene/resources/world_2d.h
@@ -44,7 +44,6 @@ class World2D : public Resource {
RID canvas;
RID space;
- RID sound_space;
SpatialIndexer2D *indexer;
@@ -66,10 +65,11 @@ protected:
public:
RID get_canvas();
RID get_space();
- RID get_sound_space();
Physics2DDirectSpaceState *get_direct_space_state();
+ void get_viewport_list(List<Viewport *> *r_viewports);
+
World2D();
~World2D();
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-13 09:27:12 +0000