summaryrefslogtreecommitdiff
path: root/servers
diff options
context:
space:
mode:
Diffstat (limited to 'servers')
-rw-r--r--servers/visual/rasterizer.cpp98
-rw-r--r--servers/visual/rasterizer.h75
-rw-r--r--servers/visual/shader_language.cpp354
-rw-r--r--servers/visual/shader_language.h21
-rw-r--r--servers/visual/shader_types.cpp23
-rw-r--r--servers/visual/shader_types.h3
-rw-r--r--servers/visual/visual_server_raster.cpp34
-rw-r--r--servers/visual/visual_server_raster.h19
-rw-r--r--servers/visual/visual_server_scene.cpp36
-rw-r--r--servers/visual_server.h31
10 files changed, 480 insertions, 214 deletions
diff --git a/servers/visual/rasterizer.cpp b/servers/visual/rasterizer.cpp
index 1be65be927..22bec0a31f 100644
--- a/servers/visual/rasterizer.cpp
+++ b/servers/visual/rasterizer.cpp
@@ -54,10 +54,10 @@ RID Rasterizer::create_default_material() {
/* Fixed MAterial SHADER API */
-RID Rasterizer::_create_shader(const FixedSpatialMaterialShaderKey& p_key) {
+RID Rasterizer::_create_shader(const SpatialMaterialShaderKey& p_key) {
ERR_FAIL_COND_V(!p_key.valid,RID());
- Map<FixedSpatialMaterialShaderKey,FixedSpatialMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
+ Map<SpatialMaterialShaderKey,SpatialMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
if (E) {
E->get().refcount++;
@@ -66,7 +66,7 @@ RID Rasterizer::_create_shader(const FixedSpatialMaterialShaderKey& p_key) {
uint64_t t = OS::get_singleton()->get_ticks_usec();
- FixedSpatialMaterialShader fms;
+ SpatialMaterialShader fms;
fms.refcount=1;
fms.shader=shader_create();
@@ -312,12 +312,12 @@ RID Rasterizer::_create_shader(const FixedSpatialMaterialShaderKey& p_key) {
return fms.shader;
}
-void Rasterizer::_free_shader(const FixedSpatialMaterialShaderKey& p_key) {
+void Rasterizer::_free_shader(const SpatialMaterialShaderKey& p_key) {
if (p_key.valid==0)
return; //not a valid key
- Map<FixedSpatialMaterialShaderKey,FixedSpatialMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
+ Map<SpatialMaterialShaderKey,SpatialMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
ERR_FAIL_COND(!E);
E->get().refcount--;
@@ -329,12 +329,12 @@ void Rasterizer::_free_shader(const FixedSpatialMaterialShaderKey& p_key) {
}
-void Rasterizer::fixed_material_set_flag(RID p_material, VS::FixedSpatialMaterialFlags p_flag, bool p_enabled) {
+void Rasterizer::fixed_material_set_flag(RID p_material, VS::SpatialMaterialFlags p_flag, bool p_enabled) {
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
switch(p_flag) {
@@ -350,11 +350,11 @@ void Rasterizer::fixed_material_set_flag(RID p_material, VS::FixedSpatialMateria
}
-bool Rasterizer::fixed_material_get_flag(RID p_material, VS::FixedSpatialMaterialFlags p_flag) const{
+bool Rasterizer::fixed_material_get_flag(RID p_material, VS::SpatialMaterialFlags p_flag) const{
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,false);
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
switch(p_flag) {
case VS::FIXED_MATERIAL_FLAG_USE_ALPHA: return fm.use_alpha;; break;
@@ -373,8 +373,8 @@ bool Rasterizer::fixed_material_get_flag(RID p_material, VS::FixedSpatialMateria
RID Rasterizer::fixed_material_create() {
RID mat = material_create();
- fixed_materials[mat]=memnew( FixedSpatialMaterial() );
- FixedSpatialMaterial &fm=*fixed_materials[mat];
+ fixed_materials[mat]=memnew( SpatialMaterial() );
+ SpatialMaterial &fm=*fixed_materials[mat];
fm.self=mat;
fm.get_key();
material_set_flag(mat,VS::MATERIAL_FLAG_COLOR_ARRAY_SRGB,true);
@@ -390,11 +390,11 @@ RID Rasterizer::fixed_material_create() {
-void Rasterizer::fixed_material_set_parameter(RID p_material, VS::FixedSpatialMaterialParam p_parameter, const Variant& p_value){
+void Rasterizer::fixed_material_set_parameter(RID p_material, VS::SpatialMaterialParam p_parameter, const Variant& p_value){
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
RID material=E->key();
ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
@@ -417,24 +417,24 @@ void Rasterizer::fixed_material_set_parameter(RID p_material, VS::FixedSpatialMa
}
-Variant Rasterizer::fixed_material_get_parameter(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const{
+Variant Rasterizer::fixed_material_get_parameter(RID p_material,VS::SpatialMaterialParam p_parameter) const{
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,Variant());
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
ERR_FAIL_INDEX_V(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX,Variant());
return fm.param[p_parameter];
}
-void Rasterizer::fixed_material_set_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter, RID p_texture){
+void Rasterizer::fixed_material_set_texture(RID p_material,VS::SpatialMaterialParam p_parameter, RID p_texture){
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
if (!E) {
print_line("Not found: "+itos(p_material.get_id()));
}
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
@@ -449,22 +449,22 @@ void Rasterizer::fixed_material_set_texture(RID p_material,VS::FixedSpatialMater
}
-RID Rasterizer::fixed_material_get_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const{
+RID Rasterizer::fixed_material_get_texture(RID p_material,VS::SpatialMaterialParam p_parameter) const{
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,RID());
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
ERR_FAIL_INDEX_V(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX,RID());
return fm.texture[p_parameter];
}
-void Rasterizer::fixed_material_set_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter, VS::FixedSpatialMaterialTexCoordMode p_mode) {
+void Rasterizer::fixed_material_set_texcoord_mode(RID p_material,VS::SpatialMaterialParam p_parameter, VS::SpatialMaterialTexCoordMode p_mode) {
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
fm.get_key();
@@ -476,11 +476,11 @@ void Rasterizer::fixed_material_set_texcoord_mode(RID p_material,VS::FixedSpatia
}
-VS::FixedSpatialMaterialTexCoordMode Rasterizer::fixed_material_get_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const {
+VS::SpatialMaterialTexCoordMode Rasterizer::fixed_material_get_texcoord_mode(RID p_material,VS::SpatialMaterialParam p_parameter) const {
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,VS::FIXED_MATERIAL_TEXCOORD_UV);
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
ERR_FAIL_INDEX_V(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX,VS::FIXED_MATERIAL_TEXCOORD_UV);
return fm.texture_tc[p_parameter];
@@ -488,9 +488,9 @@ VS::FixedSpatialMaterialTexCoordMode Rasterizer::fixed_material_get_texcoord_mod
void Rasterizer::fixed_material_set_uv_transform(RID p_material,const Transform& p_transform) {
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
RID material=E->key();
VS::get_singleton()->material_set_param(material,_fixed_material_uv_xform_name,p_transform);
@@ -503,18 +503,18 @@ void Rasterizer::fixed_material_set_uv_transform(RID p_material,const Transform&
Transform Rasterizer::fixed_material_get_uv_transform(RID p_material) const {
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,Transform());
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
return fm.uv_xform;
}
-void Rasterizer::fixed_material_set_light_shader(RID p_material,VS::FixedSpatialMaterialLightShader p_shader) {
+void Rasterizer::fixed_material_set_light_shader(RID p_material,VS::SpatialMaterialLightShader p_shader) {
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
fm.light_shader=p_shader;
@@ -523,20 +523,20 @@ void Rasterizer::fixed_material_set_light_shader(RID p_material,VS::FixedSpatial
}
-VS::FixedSpatialMaterialLightShader Rasterizer::fixed_material_get_light_shader(RID p_material) const {
+VS::SpatialMaterialLightShader Rasterizer::fixed_material_get_light_shader(RID p_material) const {
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,VS::FIXED_MATERIAL_LIGHT_SHADER_LAMBERT);
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
return fm.light_shader;
}
void Rasterizer::fixed_material_set_point_size(RID p_material,float p_size) {
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND(!E);
- FixedSpatialMaterial &fm=*E->get();
+ SpatialMaterial &fm=*E->get();
RID material=E->key();
VS::get_singleton()->material_set_param(material,_fixed_material_point_size_name,p_size);
@@ -548,9 +548,9 @@ void Rasterizer::fixed_material_set_point_size(RID p_material,float p_size) {
float Rasterizer::fixed_material_get_point_size(RID p_material) const{
- const Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ const Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
ERR_FAIL_COND_V(!E,1.0);
- const FixedSpatialMaterial &fm=*E->get();
+ const SpatialMaterial &fm=*E->get();
return fm.point_size;
@@ -561,9 +561,9 @@ void Rasterizer::_update_fixed_materials() {
while(fixed_material_dirty_list.first()) {
- FixedSpatialMaterial &fm=*fixed_material_dirty_list.first()->self();
+ SpatialMaterial &fm=*fixed_material_dirty_list.first()->self();
- FixedSpatialMaterialShaderKey new_key = fm.get_key();
+ SpatialMaterialShaderKey new_key = fm.get_key();
if (new_key.key!=fm.current_key.key) {
_free_shader(fm.current_key);
@@ -593,7 +593,7 @@ void Rasterizer::_update_fixed_materials() {
void Rasterizer::_free_fixed_material(const RID& p_material) {
- Map<RID,FixedSpatialMaterial*>::Element *E = fixed_materials.find(p_material);
+ Map<RID,SpatialMaterial*>::Element *E = fixed_materials.find(p_material);
if (E) {
@@ -636,7 +636,7 @@ Rasterizer::Rasterizer() {
draw_viewport_func=NULL;
- ERR_FAIL_COND( sizeof(FixedSpatialMaterialShaderKey)!=4);
+ ERR_FAIL_COND( sizeof(SpatialMaterialShaderKey)!=4);
}
diff --git a/servers/visual/rasterizer.h b/servers/visual/rasterizer.h
index 838ddead75..56c6dfe30a 100644
--- a/servers/visual/rasterizer.h
+++ b/servers/visual/rasterizer.h
@@ -98,9 +98,6 @@ public:
//int baked_lightmap_id;
bool mirror : 8;
- bool depth_scale : 8;
- bool billboard : 8;
- bool billboard_y : 8;
bool receive_shadows : 8;
bool visible : 8;
@@ -120,9 +117,6 @@ public:
base_type = VS::INSTANCE_NONE;
cast_shadows = VS::SHADOW_CASTING_SETTING_ON;
receive_shadows = true;
- depth_scale = false;
- billboard = false;
- billboard_y = false;
visible = true;
depth_layer = 0;
layer_mask = 1;
@@ -198,10 +192,7 @@ public:
/* SHADER API */
- virtual RID shader_create(VS::ShaderMode p_mode = VS::SHADER_SPATIAL) = 0;
-
- virtual void shader_set_mode(RID p_shader, VS::ShaderMode p_mode) = 0;
- virtual VS::ShaderMode shader_get_mode(RID p_shader) const = 0;
+ virtual RID shader_create() = 0;
virtual void shader_set_code(RID p_shader, const String &p_code) = 0;
virtual String shader_get_code(RID p_shader) const = 0;
@@ -452,19 +443,19 @@ public:
virtual void particles_set_gravity(RID p_particles, const Vector3 &p_gravity) = 0;
virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
virtual void particles_set_process_material(RID p_particles, RID p_material) = 0;
-
- virtual void particles_set_emission_shape(RID p_particles, VS::ParticlesEmissionShape p_shape) = 0;
- virtual void particles_set_emission_sphere_radius(RID p_particles, float p_radius) = 0;
- virtual void particles_set_emission_box_extents(RID p_particles, const Vector3 &p_extents) = 0;
- virtual void particles_set_emission_points(RID p_particles, const PoolVector<Vector3> &p_points) = 0;
+ virtual void particles_set_fixed_fps(RID p_particles, int p_fps) = 0;
+ virtual void particles_set_fractional_delta(RID p_particles, bool p_enable) = 0;
virtual void particles_set_draw_order(RID p_particles, VS::ParticlesDrawOrder p_order) = 0;
virtual void particles_set_draw_passes(RID p_particles, int p_count) = 0;
- virtual void particles_set_draw_pass_material(RID p_particles, int p_pass, RID p_material) = 0;
virtual void particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) = 0;
+ virtual void particles_request_process(RID p_particles) = 0;
virtual Rect3 particles_get_current_aabb(RID p_particles) = 0;
+ virtual Rect3 particles_get_aabb(RID p_particles) const = 0;
+
+ virtual void particles_set_emission_transform(RID p_particles, const Transform &p_transform) = 0;
/* RENDER TARGET */
@@ -971,7 +962,7 @@ protected:
/* Fixed Material Shader API */
- union FixedSpatialMaterialShaderKey {
+ union SpatialMaterialShaderKey {
struct {
uint16_t texcoord_mask;
@@ -987,21 +978,21 @@ protected:
uint32_t key;
- _FORCE_INLINE_ bool operator<(const FixedSpatialMaterialShaderKey& p_key) const { return key<p_key.key; }
+ _FORCE_INLINE_ bool operator<(const SpatialMaterialShaderKey& p_key) const { return key<p_key.key; }
};
- struct FixedSpatialMaterialShader {
+ struct SpatialMaterialShader {
int refcount;
RID shader;
};
- Map<FixedSpatialMaterialShaderKey,FixedSpatialMaterialShader> fixed_material_shaders;
+ Map<SpatialMaterialShaderKey,SpatialMaterialShader> fixed_material_shaders;
- RID _create_shader(const FixedSpatialMaterialShaderKey& p_key);
- void _free_shader(const FixedSpatialMaterialShaderKey& p_key);
+ RID _create_shader(const SpatialMaterialShaderKey& p_key);
+ void _free_shader(const SpatialMaterialShaderKey& p_key);
- struct FixedSpatialMaterial {
+ struct SpatialMaterial {
RID self;
@@ -1012,19 +1003,19 @@ protected:
bool use_xy_normalmap;
float point_size;
Transform uv_xform;
- VS::FixedSpatialMaterialLightShader light_shader;
+ VS::SpatialMaterialLightShader light_shader;
RID texture[VS::FIXED_MATERIAL_PARAM_MAX];
Variant param[VS::FIXED_MATERIAL_PARAM_MAX];
- VS::FixedSpatialMaterialTexCoordMode texture_tc[VS::FIXED_MATERIAL_PARAM_MAX];
+ VS::SpatialMaterialTexCoordMode texture_tc[VS::FIXED_MATERIAL_PARAM_MAX];
- SelfList<FixedSpatialMaterial> dirty_list;
+ SelfList<SpatialMaterial> dirty_list;
- FixedSpatialMaterialShaderKey current_key;
+ SpatialMaterialShaderKey current_key;
- _FORCE_INLINE_ FixedSpatialMaterialShaderKey get_key() const {
+ _FORCE_INLINE_ SpatialMaterialShaderKey get_key() const {
- FixedSpatialMaterialShaderKey k;
+ SpatialMaterialShaderKey k;
k.key=0;
k.use_alpha=use_alpha;
k.use_color_array=use_color_array;
@@ -1045,7 +1036,7 @@ protected:
}
- FixedSpatialMaterial() : dirty_list(this) {
+ SpatialMaterial() : dirty_list(this) {
use_alpha=false;
use_color_array=false;
@@ -1077,9 +1068,9 @@ protected:
StringName _fixed_material_uv_xform_name;
StringName _fixed_material_point_size_name;
- Map<RID,FixedSpatialMaterial*> fixed_materials;
+ Map<RID,SpatialMaterial*> fixed_materials;
- SelfList<FixedSpatialMaterial>::List fixed_material_dirty_list;
+ SelfList<SpatialMaterial>::List fixed_material_dirty_list;
protected:
void _update_fixed_materials();
@@ -1166,23 +1157,23 @@ public:
virtual RID fixed_material_create();
- virtual void fixed_material_set_flag(RID p_material, VS::FixedSpatialMaterialFlags p_flag, bool p_enabled);
- virtual bool fixed_material_get_flag(RID p_material, VS::FixedSpatialMaterialFlags p_flag) const;
+ virtual void fixed_material_set_flag(RID p_material, VS::SpatialMaterialFlags p_flag, bool p_enabled);
+ virtual bool fixed_material_get_flag(RID p_material, VS::SpatialMaterialFlags p_flag) const;
- virtual void fixed_material_set_parameter(RID p_material, VS::FixedSpatialMaterialParam p_parameter, const Variant& p_value);
- virtual Variant fixed_material_get_parameter(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const;
+ virtual void fixed_material_set_parameter(RID p_material, VS::SpatialMaterialParam p_parameter, const Variant& p_value);
+ virtual Variant fixed_material_get_parameter(RID p_material,VS::SpatialMaterialParam p_parameter) const;
- virtual void fixed_material_set_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter, RID p_texture);
- virtual RID fixed_material_get_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const;
+ virtual void fixed_material_set_texture(RID p_material,VS::SpatialMaterialParam p_parameter, RID p_texture);
+ virtual RID fixed_material_get_texture(RID p_material,VS::SpatialMaterialParam p_parameter) const;
- virtual void fixed_material_set_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter, VS::FixedSpatialMaterialTexCoordMode p_mode);
- virtual VS::FixedSpatialMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const;
+ virtual void fixed_material_set_texcoord_mode(RID p_material,VS::SpatialMaterialParam p_parameter, VS::SpatialMaterialTexCoordMode p_mode);
+ virtual VS::SpatialMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,VS::SpatialMaterialParam p_parameter) const;
virtual void fixed_material_set_uv_transform(RID p_material,const Transform& p_transform);
virtual Transform fixed_material_get_uv_transform(RID p_material) const;
- virtual void fixed_material_set_light_shader(RID p_material,VS::FixedSpatialMaterialLightShader p_shader);
- virtual VS::FixedSpatialMaterialLightShader fixed_material_get_light_shader(RID p_material) const;
+ virtual void fixed_material_set_light_shader(RID p_material,VS::SpatialMaterialLightShader p_shader);
+ virtual VS::SpatialMaterialLightShader fixed_material_get_light_shader(RID p_material) const;
virtual void fixed_material_set_point_size(RID p_material,float p_size);
virtual float fixed_material_get_point_size(RID p_material) const;
diff --git a/servers/visual/shader_language.cpp b/servers/visual/shader_language.cpp
index bc4452d5a8..ecb0bdef37 100644
--- a/servers/visual/shader_language.cpp
+++ b/servers/visual/shader_language.cpp
@@ -81,7 +81,8 @@ String ShaderLanguage::get_operator_text(Operator p_op) {
"++"
"--",
"()",
- "construct" };
+ "construct",
+ "index" };
return op_names[p_op];
}
@@ -176,6 +177,9 @@ const char *ShaderLanguage::token_names[TK_MAX] = {
"PERIOD",
"UNIFORM",
"VARYING",
+ "IN",
+ "OUT",
+ "INOUT",
"RENDER_MODE",
"HINT_WHITE_TEXTURE",
"HINT_BLACK_TEXTURE",
@@ -185,6 +189,7 @@ const char *ShaderLanguage::token_names[TK_MAX] = {
"HINT_BLACK_ALBEDO_TEXTURE",
"HINT_COLOR",
"HINT_RANGE",
+ "SHADER_TYPE",
"CURSOR",
"ERROR",
"EOF",
@@ -258,6 +263,9 @@ const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
{ TK_CF_RETURN, "return" },
{ TK_UNIFORM, "uniform" },
{ TK_VARYING, "varying" },
+ { TK_ARG_IN, "in" },
+ { TK_ARG_OUT, "out" },
+ { TK_ARG_INOUT, "inout" },
{ TK_RENDER_MODE, "render_mode" },
{ TK_HINT_WHITE_TEXTURE, "hint_white" },
{ TK_HINT_BLACK_TEXTURE, "hint_black" },
@@ -267,6 +275,7 @@ const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
{ TK_HINT_BLACK_ALBEDO_TEXTURE, "hint_black_albedo" },
{ TK_HINT_COLOR, "hint_color" },
{ TK_HINT_RANGE, "hint_range" },
+ { TK_SHADER_TYPE, "shader_type" },
{ TK_ERROR, NULL }
};
@@ -368,7 +377,7 @@ ShaderLanguage::Token ShaderLanguage::_get_token() {
if (GETCHAR(0) == '=') {
char_idx++;
return _make_token(TK_OP_GREATER_EQUAL);
- } else if (GETCHAR(0) == '<') {
+ } else if (GETCHAR(0) == '>') {
char_idx++;
if (GETCHAR(0) == '=') {
char_idx++;
@@ -871,7 +880,7 @@ bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type
}
if (na == nb) {
- valid = (na > TYPE_BOOL && na < TYPE_MAT2) || (p_op->op == OP_MUL && na >= TYPE_MAT2 && na <= TYPE_MAT4);
+ valid = (na > TYPE_BOOL && na <= TYPE_MAT4);
ret_type = na;
} else if (na == TYPE_INT && nb == TYPE_IVEC2) {
valid = true;
@@ -900,15 +909,24 @@ bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type
} else if (na == TYPE_FLOAT && nb == TYPE_VEC4) {
valid = true;
ret_type = TYPE_VEC4;
- } else if (p_op->op == OP_MUL && na == TYPE_VEC2 && nb == TYPE_MAT2) {
+ } else if (p_op->op == OP_MUL && na == TYPE_FLOAT && nb == TYPE_MAT2) {
valid = true;
ret_type = TYPE_MAT2;
- } else if (p_op->op == OP_MUL && na == TYPE_VEC3 && nb == TYPE_MAT3) {
+ } else if (p_op->op == OP_MUL && na == TYPE_FLOAT && nb == TYPE_MAT3) {
valid = true;
ret_type = TYPE_MAT3;
- } else if (p_op->op == OP_MUL && na == TYPE_VEC4 && nb == TYPE_MAT4) {
+ } else if (p_op->op == OP_MUL && na == TYPE_FLOAT && nb == TYPE_MAT4) {
valid = true;
ret_type = TYPE_MAT4;
+ } else if (p_op->op == OP_MUL && na == TYPE_VEC2 && nb == TYPE_MAT2) {
+ valid = true;
+ ret_type = TYPE_VEC2;
+ } else if (p_op->op == OP_MUL && na == TYPE_VEC3 && nb == TYPE_MAT3) {
+ valid = true;
+ ret_type = TYPE_VEC3;
+ } else if (p_op->op == OP_MUL && na == TYPE_VEC4 && nb == TYPE_MAT4) {
+ valid = true;
+ ret_type = TYPE_VEC4;
}
} break;
case OP_ASSIGN_MOD:
@@ -977,14 +995,6 @@ bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
- if (na >= TYPE_UINT && na <= TYPE_UVEC4) {
- na = DataType(na - 4);
- }
-
- if (nb >= TYPE_UINT && nb <= TYPE_UVEC4) {
- nb = DataType(nb - 4);
- }
-
if (na == TYPE_INT && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_INT;
@@ -1006,6 +1016,27 @@ bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type
} else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
valid = true;
ret_type = TYPE_IVEC4;
+ } else if (na == TYPE_UINT && nb == TYPE_UINT) {
+ valid = true;
+ ret_type = TYPE_UINT;
+ } else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
+ valid = true;
+ ret_type = TYPE_UVEC2;
+ } else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
+ valid = true;
+ ret_type = TYPE_UVEC3;
+ } else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
+ valid = true;
+ ret_type = TYPE_UVEC4;
+ } else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
+ valid = true;
+ ret_type = TYPE_UVEC2;
+ } else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
+ valid = true;
+ ret_type = TYPE_UVEC3;
+ } else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
+ valid = true;
+ ret_type = TYPE_UVEC4;
}
} break;
case OP_ASSIGN: {
@@ -1651,25 +1682,19 @@ const ShaderLanguage::BuiltinFuncDef ShaderLanguage::builtin_func_defs[] = {
{ "not", TYPE_BOOL, { TYPE_BVEC4, TYPE_VOID } },
//builtins - texture
- { "textureSize", TYPE_VEC2, { TYPE_SAMPLER2D, TYPE_INT, TYPE_VOID } },
- { "textureSize", TYPE_VEC2, { TYPE_ISAMPLER2D, TYPE_INT, TYPE_VOID } },
- { "textureSize", TYPE_VEC2, { TYPE_USAMPLER2D, TYPE_INT, TYPE_VOID } },
- { "textureSize", TYPE_VEC2, { TYPE_SAMPLERCUBE, TYPE_INT, TYPE_VOID } },
+ { "textureSize", TYPE_IVEC2, { TYPE_SAMPLER2D, TYPE_INT, TYPE_VOID } },
+ { "textureSize", TYPE_IVEC2, { TYPE_ISAMPLER2D, TYPE_INT, TYPE_VOID } },
+ { "textureSize", TYPE_IVEC2, { TYPE_USAMPLER2D, TYPE_INT, TYPE_VOID } },
+ { "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBE, TYPE_INT, TYPE_VOID } },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VOID } },
- { "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_VOID } },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
- { "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID } },
- { "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_VOID } },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
- { "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID } },
- { "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_VOID } },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
- { "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VOID } },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
@@ -1689,9 +1714,9 @@ const ShaderLanguage::BuiltinFuncDef ShaderLanguage::builtin_func_defs[] = {
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
- { "textureLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
- { "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
- { "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
+ { "textureLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
+ { "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
+ { "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID } },
@@ -2308,9 +2333,17 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
bool ok = _parse_function_arguments(p_block, p_builtin_types, func, &carg);
+ //test if function was parsed first
for (int i = 0; i < shader->functions.size(); i++) {
if (shader->functions[i].name == name) {
- shader->functions[i].uses_function.insert(name);
+ //add to current function as dependency
+ for (int j = 0; j < shader->functions.size(); j++) {
+ if (shader->functions[j].name == current_function) {
+ shader->functions[j].uses_function.insert(name);
+ break;
+ }
+ }
+ break;
}
}
@@ -2514,18 +2547,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
}
} break;
- case TYPE_MAT2:
- ok = (ident == "x" || ident == "y");
- member_type = TYPE_VEC2;
- break;
- case TYPE_MAT3:
- ok = (ident == "x" || ident == "y" || ident == "z");
- member_type = TYPE_VEC3;
- break;
- case TYPE_MAT4:
- ok = (ident == "x" || ident == "y" || ident == "z" || ident == "w");
- member_type = TYPE_VEC4;
- break;
+
default: {}
}
@@ -2552,6 +2574,116 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
//creates a subindexing expression in place
*/
+ } else if (tk.type == TK_BRACKET_OPEN) {
+
+ Node *index = _parse_and_reduce_expression(p_block, p_builtin_types);
+
+ if (index->get_datatype() != TYPE_INT && index->get_datatype() != TYPE_UINT) {
+ _set_error("Only integer datatypes are allowed for indexing");
+ return NULL;
+ }
+
+ bool index_valid = false;
+ DataType member_type;
+
+ switch (expr->get_datatype()) {
+ case TYPE_BVEC2:
+ case TYPE_VEC2:
+ case TYPE_IVEC2:
+ case TYPE_UVEC2:
+ case TYPE_MAT2:
+ if (index->type == Node::TYPE_CONSTANT) {
+ uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
+ if (index_constant >= 2) {
+ _set_error("Index out of range (0-1)");
+ return NULL;
+ }
+ } else {
+ _set_error("Only integer constants are allowed as index at the moment");
+ return NULL;
+ }
+ index_valid = true;
+ switch (expr->get_datatype()) {
+ case TYPE_BVEC2: member_type = TYPE_BOOL; break;
+ case TYPE_VEC2: member_type = TYPE_FLOAT; break;
+ case TYPE_IVEC2: member_type = TYPE_INT; break;
+ case TYPE_UVEC2: member_type = TYPE_UINT; break;
+ case TYPE_MAT2: member_type = TYPE_VEC2; break;
+ }
+
+ break;
+ case TYPE_BVEC3:
+ case TYPE_VEC3:
+ case TYPE_IVEC3:
+ case TYPE_UVEC3:
+ case TYPE_MAT3:
+ if (index->type == Node::TYPE_CONSTANT) {
+ uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
+ if (index_constant >= 3) {
+ _set_error("Index out of range (0-2)");
+ return NULL;
+ }
+ } else {
+ _set_error("Only integer constants are allowed as index at the moment");
+ return NULL;
+ }
+ index_valid = true;
+ switch (expr->get_datatype()) {
+ case TYPE_BVEC3: member_type = TYPE_BOOL; break;
+ case TYPE_VEC3: member_type = TYPE_FLOAT; break;
+ case TYPE_IVEC3: member_type = TYPE_INT; break;
+ case TYPE_UVEC3: member_type = TYPE_UINT; break;
+ case TYPE_MAT3: member_type = TYPE_VEC3; break;
+ }
+ break;
+ case TYPE_BVEC4:
+ case TYPE_VEC4:
+ case TYPE_IVEC4:
+ case TYPE_UVEC4:
+ case TYPE_MAT4:
+ if (index->type == Node::TYPE_CONSTANT) {
+ uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
+ if (index_constant >= 4) {
+ _set_error("Index out of range (0-3)");
+ return NULL;
+ }
+ } else {
+ _set_error("Only integer constants are allowed as index at the moment");
+ return NULL;
+ }
+ index_valid = true;
+ switch (expr->get_datatype()) {
+ case TYPE_BVEC4: member_type = TYPE_BOOL; break;
+ case TYPE_VEC4: member_type = TYPE_FLOAT; break;
+ case TYPE_IVEC4: member_type = TYPE_INT; break;
+ case TYPE_UVEC4: member_type = TYPE_UINT; break;
+ case TYPE_MAT4: member_type = TYPE_VEC4; break;
+ }
+ break;
+ default: {
+ _set_error("Object of type '" + get_datatype_name(expr->get_datatype()) + "' can't be indexed");
+ return NULL;
+ }
+ }
+
+ if (!index_valid) {
+ _set_error("Invalid index");
+ return NULL;
+ }
+
+ OperatorNode *op = alloc_node<OperatorNode>();
+ op->op = OP_INDEX;
+ op->return_cache = member_type;
+ op->arguments.push_back(expr);
+ op->arguments.push_back(index);
+ expr = op;
+
+ tk = _get_token();
+ if (tk.type != TK_BRACKET_CLOSE) {
+ _set_error("Expected ']' after indexing expression");
+ return NULL;
+ }
+
} else if (tk.type == TK_OP_INCREMENT || tk.type == TK_OP_DECREMENT) {
OperatorNode *op = alloc_node<OperatorNode>();
@@ -3077,6 +3209,52 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Dat
_set_tkpos(pos); //rollback
}
+ } else if (tk.type == TK_CF_RETURN) {
+
+ //check return type
+ BlockNode *b = p_block;
+ while (b && !b->parent_function) {
+ b = b->parent_block;
+ }
+
+ if (!b) {
+ _set_error("Bug");
+ return ERR_BUG;
+ }
+
+ ControlFlowNode *flow = alloc_node<ControlFlowNode>();
+ flow->flow_op = FLOW_OP_RETURN;
+
+ pos = _get_tkpos();
+ tk = _get_token();
+ if (tk.type == TK_SEMICOLON) {
+ //all is good
+ if (b->parent_function->return_type != TYPE_VOID) {
+ _set_error("Expected return with expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
+ return ERR_PARSE_ERROR;
+ }
+ } else {
+ _set_tkpos(pos); //rollback, wants expression
+ Node *expr = _parse_and_reduce_expression(p_block, p_builtin_types);
+ if (!expr)
+ return ERR_PARSE_ERROR;
+
+ if (b->parent_function->return_type != expr->get_datatype()) {
+ _set_error("Expected return expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
+ return ERR_PARSE_ERROR;
+ }
+
+ tk = _get_token();
+ if (tk.type != TK_SEMICOLON) {
+ _set_error("Expected ';' after return expression");
+ return ERR_PARSE_ERROR;
+ }
+
+ flow->expressions.push_back(expr);
+ }
+
+ p_block->statements.push_back(flow);
+
} else {
//nothng else, so expression
@@ -3100,10 +3278,47 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Dat
return OK;
}
-Error ShaderLanguage::_parse_shader(const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes) {
+Error ShaderLanguage::_parse_shader(const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types) {
Token tk = _get_token();
+ if (tk.type != TK_SHADER_TYPE) {
+ _set_error("Expected 'shader_type' at the begining of shader.");
+ return ERR_PARSE_ERROR;
+ }
+
+ tk = _get_token();
+
+ if (tk.type != TK_IDENTIFIER) {
+ _set_error("Expected identifier after 'shader_type', indicating type of shader.");
+ return ERR_PARSE_ERROR;
+ }
+
+ String shader_type_identifier;
+
+ shader_type_identifier = tk.text;
+
+ if (!p_shader_types.has(shader_type_identifier)) {
+
+ String valid;
+ for (Set<String>::Element *E = p_shader_types.front(); E; E = E->next()) {
+ if (valid != String()) {
+ valid += ", ";
+ }
+ valid += "'" + E->get() + "'";
+ }
+ _set_error("Invalid shader type, valid types are: " + valid);
+ return ERR_PARSE_ERROR;
+ }
+
+ tk = _get_token();
+
+ if (tk.type != TK_SEMICOLON) {
+ _set_error("Expected ';' after 'shader_type <type>'.");
+ }
+
+ tk = _get_token();
+
int texture_uniforms = 0;
int uniforms = 0;
@@ -3428,6 +3643,19 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, Map<StringName, DataTy
break;
}
+ ArgumentQualifier qualifier = ARGUMENT_QUALIFIER_IN;
+
+ if (tk.type == TK_ARG_IN) {
+ qualifier = ARGUMENT_QUALIFIER_IN;
+ tk = _get_token();
+ } else if (tk.type == TK_ARG_OUT) {
+ qualifier = ARGUMENT_QUALIFIER_OUT;
+ tk = _get_token();
+ } else if (tk.type == TK_ARG_INOUT) {
+ qualifier = ARGUMENT_QUALIFIER_INOUT;
+ tk = _get_token();
+ }
+
DataType ptype;
StringName pname;
DataPrecision pprecision = PRECISION_DEFAULT;
@@ -3466,6 +3694,7 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, Map<StringName, DataTy
arg.type = ptype;
arg.name = pname;
arg.precision = pprecision;
+ arg.qualifier = qualifier;
func_node->arguments.push_back(arg);
@@ -3515,7 +3744,42 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, Map<StringName, DataTy
return OK;
}
-Error ShaderLanguage::compile(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes) {
+String ShaderLanguage::get_shader_type(const String &p_code) {
+
+ bool reading_type = false;
+
+ String cur_identifier;
+
+ for (int i = 0; i < p_code.length() + 1; i++) {
+
+ if (p_code[i] == ';') {
+ break;
+
+ } else if (p_code[i] <= 32) {
+ if (cur_identifier != String()) {
+ if (!reading_type) {
+ if (cur_identifier != "shader_type") {
+ return String();
+ }
+
+ reading_type = true;
+ cur_identifier = String();
+ } else {
+ return cur_identifier;
+ }
+ }
+ } else {
+ cur_identifier += String::chr(p_code[i]);
+ }
+ }
+
+ if (reading_type)
+ return cur_identifier;
+
+ return String();
+}
+
+Error ShaderLanguage::compile(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types) {
clear();
@@ -3524,7 +3788,7 @@ Error ShaderLanguage::compile(const String &p_code, const Map<StringName, Map<St
nodes = NULL;
shader = alloc_node<ShaderNode>();
- Error err = _parse_shader(p_functions, p_render_modes);
+ Error err = _parse_shader(p_functions, p_render_modes, p_shader_types);
if (err != OK) {
return err;
@@ -3532,7 +3796,7 @@ Error ShaderLanguage::compile(const String &p_code, const Map<StringName, Map<St
return OK;
}
-Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, List<String> *r_options, String &r_call_hint) {
+Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types, List<String> *r_options, String &r_call_hint) {
clear();
@@ -3541,7 +3805,7 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Map<S
nodes = NULL;
shader = alloc_node<ShaderNode>();
- Error err = _parse_shader(p_functions, p_render_modes);
+ Error err = _parse_shader(p_functions, p_render_modes, p_shader_types);
switch (completion_type) {
diff --git a/servers/visual/shader_language.h b/servers/visual/shader_language.h
index a4757e3419..5e7ae3b70f 100644
--- a/servers/visual/shader_language.h
+++ b/servers/visual/shader_language.h
@@ -130,6 +130,9 @@ public:
TK_PERIOD,
TK_UNIFORM,
TK_VARYING,
+ TK_ARG_IN,
+ TK_ARG_OUT,
+ TK_ARG_INOUT,
TK_RENDER_MODE,
TK_HINT_WHITE_TEXTURE,
TK_HINT_BLACK_TEXTURE,
@@ -139,6 +142,7 @@ public:
TK_HINT_BLACK_ALBEDO_TEXTURE,
TK_HINT_COLOR,
TK_HINT_RANGE,
+ TK_SHADER_TYPE,
TK_CURSOR,
TK_ERROR,
TK_EOF,
@@ -227,6 +231,7 @@ public:
OP_POST_DECREMENT,
OP_CALL,
OP_CONSTRUCT,
+ OP_INDEX,
OP_MAX
};
@@ -242,6 +247,13 @@ public:
};
+ enum ArgumentQualifier {
+ ARGUMENT_QUALIFIER_IN,
+ ARGUMENT_QUALIFIER_OUT,
+ ARGUMENT_QUALIFIER_INOUT,
+
+ };
+
struct Node {
Node *next;
@@ -363,6 +375,7 @@ public:
struct Argument {
+ ArgumentQualifier qualifier;
StringName name;
DataType type;
DataPrecision precision;
@@ -577,14 +590,16 @@ private:
Error _parse_block(BlockNode *p_block, const Map<StringName, DataType> &p_builtin_types, bool p_just_one = false, bool p_can_break = false, bool p_can_continue = false);
- Error _parse_shader(const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes);
+ Error _parse_shader(const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types);
public:
//static void get_keyword_list(ShaderType p_type,List<String> *p_keywords);
void clear();
- Error compile(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes);
- Error complete(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, List<String> *r_options, String &r_call_hint);
+
+ static String get_shader_type(const String &p_code);
+ Error compile(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types);
+ Error complete(const String &p_code, const Map<StringName, Map<StringName, DataType> > &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types, List<String> *r_options, String &r_call_hint);
String get_error_text();
int get_error_line();
diff --git a/servers/visual/shader_types.cpp b/servers/visual/shader_types.cpp
index c5e31b235a..02e970c786 100644
--- a/servers/visual/shader_types.cpp
+++ b/servers/visual/shader_types.cpp
@@ -38,6 +38,10 @@ const Set<String> &ShaderTypes::get_modes(VS::ShaderMode p_mode) {
return shader_modes[p_mode].modes;
}
+const Set<String> &ShaderTypes::get_types() {
+ return shader_types;
+}
+
ShaderTypes *ShaderTypes::singleton = NULL;
ShaderTypes::ShaderTypes() {
@@ -61,11 +65,14 @@ ShaderTypes::ShaderTypes() {
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["COLOR"] = ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["POINT_SIZE"] = ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["INSTANCE_ID"] = ShaderLanguage::TYPE_INT;
+ shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["INSTANCE_CUSTOM"] = ShaderLanguage::TYPE_VEC4;
//builtins
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["WORLD_MATRIX"] = ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["INV_CAMERA_MATRIX"] = ShaderLanguage::TYPE_MAT4;
+ shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["CAMERA_MATRIX"] = ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["PROJECTION_MATRIX"] = ShaderLanguage::TYPE_MAT4;
+ shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["MODELVIEW_MATRIX"] = ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["TIME"] = ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["VIEWPORT_SIZE"] = ShaderLanguage::TYPE_VEC2;
@@ -122,7 +129,7 @@ ShaderTypes::ShaderTypes() {
shader_modes[VS::SHADER_SPATIAL].modes.insert("unshaded");
shader_modes[VS::SHADER_SPATIAL].modes.insert("ontop");
- shader_modes[VS::SHADER_SPATIAL].modes.insert("skip_transform");
+ shader_modes[VS::SHADER_SPATIAL].modes.insert("skip_default_transform");
/************ CANVAS ITEM **************************/
@@ -136,6 +143,7 @@ ShaderTypes::ShaderTypes() {
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["PROJECTION_MATRIX"] = ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["EXTRA_MATRIX"] = ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["TIME"] = ShaderLanguage::TYPE_FLOAT;
+ shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["PARTICLE_CUSTOM"] = ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["SRC_COLOR"] = ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["POSITION"] = ShaderLanguage::TYPE_VEC2;
@@ -189,14 +197,21 @@ ShaderTypes::ShaderTypes() {
shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["RESTART"] = ShaderLanguage::TYPE_BOOL;
shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["CUSTOM"] = ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["TRANSFORM"] = ShaderLanguage::TYPE_MAT4;
- shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["TIME"] = ShaderLanguage::TYPE_FLOAT;
+ shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["TIME"] = ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["LIFETIME"] = ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["DELTA"] = ShaderLanguage::TYPE_FLOAT;
- shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["SEED"] = ShaderLanguage::TYPE_BOOL;
- shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["ORIGIN"] = ShaderLanguage::TYPE_MAT4;
+ shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["NUMBER"] = ShaderLanguage::TYPE_UINT;
shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["INDEX"] = ShaderLanguage::TYPE_INT;
+ shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["SEED"] = ShaderLanguage::TYPE_UINT;
+ shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["GRAVITY"] = ShaderLanguage::TYPE_VEC3;
+ shader_modes[VS::SHADER_PARTICLES].functions["vertex"]["EMISSION_TRANSFORM"] = ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_PARTICLES].modes.insert("billboard");
shader_modes[VS::SHADER_PARTICLES].modes.insert("disable_force");
shader_modes[VS::SHADER_PARTICLES].modes.insert("disable_velocity");
+ shader_modes[VS::SHADER_PARTICLES].modes.insert("keep_data");
+
+ shader_types.insert("spatial");
+ shader_types.insert("canvas_item");
+ shader_types.insert("particles");
}
diff --git a/servers/visual/shader_types.h b/servers/visual/shader_types.h
index 1bddde8c82..1f5131e019 100644
--- a/servers/visual/shader_types.h
+++ b/servers/visual/shader_types.h
@@ -43,11 +43,14 @@ class ShaderTypes {
static ShaderTypes *singleton;
+ Set<String> shader_types;
+
public:
static ShaderTypes *get_singleton() { return singleton; }
const Map<StringName, Map<StringName, ShaderLanguage::DataType> > &get_functions(VS::ShaderMode p_mode);
const Set<String> &get_modes(VS::ShaderMode p_mode);
+ const Set<String> &get_types();
ShaderTypes();
};
diff --git a/servers/visual/visual_server_raster.cpp b/servers/visual/visual_server_raster.cpp
index 2666a95595..624dc6dfe0 100644
--- a/servers/visual/visual_server_raster.cpp
+++ b/servers/visual/visual_server_raster.cpp
@@ -38,6 +38,8 @@
// careful, these may run in different threads than the visual server
+int VisualServerRaster::changes = 0;
+
/* CURSOR */
void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor) {
}
@@ -391,33 +393,33 @@ RID VisualServerRaster::fixed_material_create() {
return rasterizer->fixed_material_create();
}
-void VisualServerRaster::fixed_material_set_flag(RID p_material, FixedSpatialMaterialFlags p_flag, bool p_enabled) {
+void VisualServerRaster::fixed_material_set_flag(RID p_material, SpatialMaterialFlags p_flag, bool p_enabled) {
rasterizer->fixed_material_set_flag(p_material,p_flag,p_enabled);
}
-bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedSpatialMaterialFlags p_flag) const {
+bool VisualServerRaster::fixed_material_get_flag(RID p_material, SpatialMaterialFlags p_flag) const {
return rasterizer->fixed_material_get_flag(p_material,p_flag);
}
-void VisualServerRaster::fixed_material_set_param(RID p_material, FixedSpatialMaterialParam p_parameter, const Variant& p_value) {
+void VisualServerRaster::fixed_material_set_param(RID p_material, SpatialMaterialParam p_parameter, const Variant& p_value) {
VS_CHANGED;
rasterizer->fixed_material_set_parameter(p_material,p_parameter,p_value);
}
-Variant VisualServerRaster::fixed_material_get_param(RID p_material,FixedSpatialMaterialParam p_parameter) const {
+Variant VisualServerRaster::fixed_material_get_param(RID p_material,SpatialMaterialParam p_parameter) const {
return rasterizer->fixed_material_get_parameter(p_material,p_parameter);
}
-void VisualServerRaster::fixed_material_set_texture(RID p_material,FixedSpatialMaterialParam p_parameter, RID p_texture) {
+void VisualServerRaster::fixed_material_set_texture(RID p_material,SpatialMaterialParam p_parameter, RID p_texture) {
VS_CHANGED;
rasterizer->fixed_material_set_texture(p_material,p_parameter,p_texture);
}
-RID VisualServerRaster::fixed_material_get_texture(RID p_material,FixedSpatialMaterialParam p_parameter) const {
+RID VisualServerRaster::fixed_material_get_texture(RID p_material,SpatialMaterialParam p_parameter) const {
return rasterizer->fixed_material_get_texture(p_material,p_parameter);
}
@@ -425,12 +427,12 @@ RID VisualServerRaster::fixed_material_get_texture(RID p_material,FixedSpatialMa
-void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material,FixedSpatialMaterialParam p_parameter, FixedSpatialMaterialTexCoordMode p_mode) {
+void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material,SpatialMaterialParam p_parameter, SpatialMaterialTexCoordMode p_mode) {
VS_CHANGED;
rasterizer->fixed_material_set_texcoord_mode(p_material,p_parameter,p_mode);
}
-VS::FixedSpatialMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material,FixedSpatialMaterialParam p_parameter) const {
+VS::SpatialMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material,SpatialMaterialParam p_parameter) const {
return rasterizer->fixed_material_get_texcoord_mode(p_material,p_parameter);
}
@@ -457,14 +459,14 @@ Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material) co
return rasterizer->fixed_material_get_uv_transform(p_material);
}
-void VisualServerRaster::fixed_material_set_light_shader(RID p_material,FixedSpatialMaterialLightShader p_shader) {
+void VisualServerRaster::fixed_material_set_light_shader(RID p_material,SpatialMaterialLightShader p_shader) {
VS_CHANGED;
rasterizer->fixed_material_set_light_shader(p_material,p_shader);
}
-VisualServerRaster::FixedSpatialMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material) const{
+VisualServerRaster::SpatialMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material) const{
return rasterizer->fixed_material_get_light_shader(p_material);
}
@@ -4521,7 +4523,7 @@ void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_po
RID VisualServerRaster::canvas_item_material_create() {
- Rasterizer::CanvasItemMaterial *material = memnew( Rasterizer::CanvasItemMaterial );
+ Rasterizer::ShaderMaterial *material = memnew( Rasterizer::ShaderMaterial );
return canvas_item_material_owner.make_rid(material);
}
@@ -4529,7 +4531,7 @@ RID VisualServerRaster::canvas_item_material_create() {
void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader){
VS_CHANGED;
- Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+ Rasterizer::ShaderMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND(!material);
material->shader=p_shader;
@@ -4537,7 +4539,7 @@ void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_s
void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value){
VS_CHANGED;
- Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+ Rasterizer::ShaderMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND(!material);
if (p_value.get_type()==Variant::NIL)
material->shader_param.erase(p_param);
@@ -4547,7 +4549,7 @@ void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, c
}
Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const{
- Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+ Rasterizer::ShaderMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND_V(!material,Variant());
if (!material->shader_param.has(p_param)) {
ERR_FAIL_COND_V(!material->shader.is_valid(),Variant());
@@ -4560,7 +4562,7 @@ Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material
void VisualServerRaster::canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode) {
VS_CHANGED;
- Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+ Rasterizer::ShaderMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND(!material);
material->shading_mode=p_mode;
@@ -4869,7 +4871,7 @@ void VisualServerRaster::free( RID p_rid ) {
} else if (canvas_item_material_owner.owns(p_rid)) {
- Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_rid);
+ Rasterizer::ShaderMaterial *material = canvas_item_material_owner.get(p_rid);
ERR_FAIL_COND(!material);
for(Set<Rasterizer::CanvasItem*>::Element *E=material->owners.front();E;E=E->next()) {
diff --git a/servers/visual/visual_server_raster.h b/servers/visual/visual_server_raster.h
index 58e07057f2..a0d567e872 100644
--- a/servers/visual/visual_server_raster.h
+++ b/servers/visual/visual_server_raster.h
@@ -56,7 +56,7 @@ class VisualServerRaster : public VisualServer {
};
- int changes;
+ static int changes;
bool draw_extra_frame;
RID test_cube;
@@ -376,7 +376,7 @@ class VisualServerRaster : public VisualServer {
- mutable RID_Owner<Rasterizer::CanvasItemMaterial> canvas_item_material_owner;
+ mutable RID_Owner<Rasterizer::ShaderMaterial> canvas_item_material_owner;
@@ -575,6 +575,8 @@ class VisualServerRaster : public VisualServer {
#endif
public:
+ _FORCE_INLINE_ static void redraw_request() { changes++; }
+
#define DISPLAY_CHANGED changes++;
#define BIND0R(m_r, m_name) \
@@ -647,10 +649,7 @@ public:
/* SHADER API */
- BIND1R(RID, shader_create, ShaderMode)
-
- BIND2(shader_set_mode, RID, ShaderMode)
- BIND1RC(ShaderMode, shader_get_mode, RID)
+ BIND0R(RID, shader_create)
BIND2(shader_set_code, RID, const String &)
BIND1RC(String, shader_get_code, RID)
@@ -855,16 +854,12 @@ public:
BIND2(particles_set_gravity, RID, const Vector3 &)
BIND2(particles_set_use_local_coordinates, RID, bool)
BIND2(particles_set_process_material, RID, RID)
-
- BIND2(particles_set_emission_shape, RID, VS::ParticlesEmissionShape)
- BIND2(particles_set_emission_sphere_radius, RID, float)
- BIND2(particles_set_emission_box_extents, RID, const Vector3 &)
- BIND2(particles_set_emission_points, RID, const PoolVector<Vector3> &)
+ BIND2(particles_set_fixed_fps, RID, int)
+ BIND2(particles_set_fractional_delta, RID, bool)
BIND2(particles_set_draw_order, RID, VS::ParticlesDrawOrder)
BIND2(particles_set_draw_passes, RID, int)
- BIND3(particles_set_draw_pass_material, RID, int, RID)
BIND3(particles_set_draw_pass_mesh, RID, int, RID)
BIND1R(Rect3, particles_get_current_aabb, RID);
diff --git a/servers/visual/visual_server_scene.cpp b/servers/visual/visual_server_scene.cpp
index 9b77ca9e1c..acaf5dc792 100644
--- a/servers/visual/visual_server_scene.cpp
+++ b/servers/visual/visual_server_scene.cpp
@@ -29,6 +29,7 @@
#include "visual_server_scene.h"
#include "os/os.h"
#include "visual_server_global.h"
+#include "visual_server_raster.h"
/* CAMERA API */
RID VisualServerScene::camera_create() {
@@ -609,7 +610,8 @@ void VisualServerScene::instance_set_base(RID p_instance, RID p_base) {
} break;
case VS::INSTANCE_MESH:
case VS::INSTANCE_MULTIMESH:
- case VS::INSTANCE_IMMEDIATE: {
+ case VS::INSTANCE_IMMEDIATE:
+ case VS::INSTANCE_PARTICLES: {
InstanceGeometryData *geom = memnew(InstanceGeometryData);
instance->base_data = geom;
@@ -975,16 +977,6 @@ void VisualServerScene::instance_geometry_set_flag(RID p_instance, VS::InstanceF
switch (p_flags) {
- case VS::INSTANCE_FLAG_BILLBOARD: {
-
- instance->billboard = p_enabled;
-
- } break;
- case VS::INSTANCE_FLAG_BILLBOARD_FIX_Y: {
-
- instance->billboard_y = p_enabled;
-
- } break;
case VS::INSTANCE_FLAG_CAST_SHADOW: {
if (p_enabled == true) {
instance->cast_shadows = VS::SHADOW_CASTING_SETTING_ON;
@@ -995,11 +987,6 @@ void VisualServerScene::instance_geometry_set_flag(RID p_instance, VS::InstanceF
instance->base_material_changed(); // to actually compute if shadows are visible or not
} break;
- case VS::INSTANCE_FLAG_DEPH_SCALE: {
-
- instance->depth_scale = p_enabled;
-
- } break;
case VS::INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
instance->visible_in_all_rooms = p_enabled;
@@ -1050,6 +1037,11 @@ void VisualServerScene::_update_instance(Instance *p_instance) {
reflection_probe->reflection_dirty = true;
}
+ if (p_instance->base_type == VS::INSTANCE_PARTICLES) {
+
+ VSG::storage->particles_set_emission_transform(p_instance->base, p_instance->transform);
+ }
+
if (p_instance->aabb.has_no_surface())
return;
@@ -1235,6 +1227,11 @@ void VisualServerScene::_update_instance_aabb(Instance *p_instance) {
new_aabb = VSG::storage->immediate_get_aabb(p_instance->base);
} break;
+ case VisualServer::INSTANCE_PARTICLES: {
+
+ new_aabb = VSG::storage->particles_get_aabb(p_instance->base);
+
+ } break;
#if 0
case VisualServer::INSTANCE_PARTICLES: {
@@ -1914,6 +1911,13 @@ void VisualServerScene::_render_scene(const Transform p_cam_transform, const Cam
InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(ins->base_data);
+ if (ins->base_type == VS::INSTANCE_PARTICLES) {
+ //particles visible? process them
+ VSG::storage->particles_request_process(ins->base);
+ //particles visible? request redraw
+ VisualServerRaster::redraw_request();
+ }
+
if (geom->lighting_dirty) {
int l = 0;
//only called when lights AABB enter/exit this geometry
diff --git a/servers/visual_server.h b/servers/visual_server.h
index dfa253ff25..d9a84697a4 100644
--- a/servers/visual_server.h
+++ b/servers/visual_server.h
@@ -153,10 +153,7 @@ public:
SHADER_MAX
};
- virtual RID shader_create(ShaderMode p_mode = SHADER_SPATIAL) = 0;
-
- virtual void shader_set_mode(RID p_shader, ShaderMode p_mode) = 0;
- virtual ShaderMode shader_get_mode(RID p_shader) const = 0;
+ virtual RID shader_create() = 0;
virtual void shader_set_code(RID p_shader, const String &p_code) = 0;
virtual String shader_get_code(RID p_shader) const = 0;
@@ -485,19 +482,8 @@ public:
virtual void particles_set_gravity(RID p_particles, const Vector3 &p_gravity) = 0;
virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
virtual void particles_set_process_material(RID p_particles, RID p_material) = 0;
-
- enum ParticlesEmissionShape {
- PARTICLES_EMSSION_POINT,
- PARTICLES_EMSSION_SPHERE,
- PARTICLES_EMSSION_BOX,
- PARTICLES_EMSSION_POINTS,
- PARTICLES_EMSSION_SEGMENTS,
- };
-
- virtual void particles_set_emission_shape(RID p_particles, ParticlesEmissionShape) = 0;
- virtual void particles_set_emission_sphere_radius(RID p_particles, float p_radius) = 0;
- virtual void particles_set_emission_box_extents(RID p_particles, const Vector3 &p_extents) = 0;
- virtual void particles_set_emission_points(RID p_particles, const PoolVector<Vector3> &p_points) = 0;
+ virtual void particles_set_fixed_fps(RID p_particles, int p_fps) = 0;
+ virtual void particles_set_fractional_delta(RID p_particles, bool p_enable) = 0;
enum ParticlesDrawOrder {
PARTICLES_DRAW_ORDER_INDEX,
@@ -507,13 +493,7 @@ public:
virtual void particles_set_draw_order(RID p_particles, ParticlesDrawOrder p_order) = 0;
- enum ParticlesDrawPassMode {
- PARTICLES_DRAW_PASS_MODE_QUAD,
- PARTICLES_DRAW_PASS_MODE_MESH
- };
-
virtual void particles_set_draw_passes(RID p_particles, int p_count) = 0;
- virtual void particles_set_draw_pass_material(RID p_particles, int p_pass, RID p_material) = 0;
virtual void particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) = 0;
virtual Rect3 particles_get_current_aabb(RID p_particles) = 0;
@@ -689,7 +669,7 @@ public:
INSTANCE_MAX,
/*INSTANCE_BAKED_LIGHT_SAMPLER,*/
- INSTANCE_GEOMETRY_MASK = (1 << INSTANCE_MESH) | (1 << INSTANCE_MULTIMESH) | (1 << INSTANCE_IMMEDIATE)
+ INSTANCE_GEOMETRY_MASK = (1 << INSTANCE_MESH) | (1 << INSTANCE_MULTIMESH) | (1 << INSTANCE_IMMEDIATE) | (1 << INSTANCE_PARTICLES)
};
virtual RID instance_create2(RID p_base, RID p_scenario);
@@ -718,10 +698,7 @@ public:
virtual Vector<ObjectID> instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario = RID()) const = 0;
enum InstanceFlags {
- INSTANCE_FLAG_BILLBOARD,
- INSTANCE_FLAG_BILLBOARD_FIX_Y,
INSTANCE_FLAG_CAST_SHADOW,
- INSTANCE_FLAG_DEPH_SCALE,
INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS,
INSTANCE_FLAG_USE_BAKED_LIGHT,
INSTANCE_FLAG_MAX
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-03 16:28:03 +0000