Skip to content

Commit 1586c56

Browse files
RepiteoRepiteo
committed
Merge pull request #95626 from Chaosus/shader_fix_default_params
Fix shader uniforms has null as default value
2 parents 4f827e6 + 570e59d commit 1586c56

File tree

4 files changed

+298
-0
lines changed

4 files changed

+298
-0
lines changed

‎drivers/gles3/storage/material_storage.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -573,6 +573,9 @@ Variant ShaderData::get_default_parameter(const StringName &p_parameter) const {
573573
if (uniforms.has(p_parameter)) {
574574
ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
575575
Vector<ShaderLanguage::Scalar> default_value = uniform.default_value;
576+
if (default_value.is_empty()) {
577+
return ShaderLanguage::get_default_datatype_value(uniform.type, uniform.array_size, uniform.hint);
578+
}
576579
return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.array_size, uniform.hint);
577580
}
578581
return Variant();

‎servers/rendering/renderer_rd/storage_rd/material_storage.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -569,6 +569,9 @@ Variant MaterialStorage::ShaderData::get_default_parameter(const StringName &p_p
569569
if (uniforms.has(p_parameter)) {
570570
ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
571571
Vector<ShaderLanguage::Scalar> default_value = uniform.default_value;
572+
if (default_value.is_empty()) {
573+
return ShaderLanguage::get_default_datatype_value(uniform.type, uniform.array_size, uniform.hint);
574+
}
572575
return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.array_size, uniform.hint);
573576
}
574577
return Variant();

‎servers/rendering/shader_language.cpp‎

Lines changed: 291 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4513,6 +4513,297 @@ Variant ShaderLanguage::constant_value_to_variant(const Vector<Scalar> &p_value,
45134513
return Variant();
45144514
}
45154515

4516+
Variant ShaderLanguage::get_default_datatype_value(DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint) {
4517+
int array_size = p_array_size;
4518+
4519+
Variant value;
4520+
switch (p_type) {
4521+
case ShaderLanguage::TYPE_BOOL:
4522+
if (array_size > 0) {
4523+
PackedInt32Array array;
4524+
for (int i = 0; i < array_size; i++) {
4525+
array.push_back(false);
4526+
}
4527+
value = Variant(array);
4528+
} else {
4529+
VariantInitializer<bool>::init(&value);
4530+
VariantDefaultInitializer<bool>::init(&value);
4531+
}
4532+
break;
4533+
case ShaderLanguage::TYPE_BVEC2:
4534+
array_size *= 2;
4535+
4536+
if (array_size > 0) {
4537+
PackedInt32Array array;
4538+
for (int i = 0; i < array_size; i++) {
4539+
array.push_back(false);
4540+
}
4541+
value = Variant(array);
4542+
} else {
4543+
VariantInitializer<int64_t>::init(&value);
4544+
VariantDefaultInitializer<int64_t>::init(&value);
4545+
}
4546+
break;
4547+
case ShaderLanguage::TYPE_BVEC3:
4548+
array_size *= 3;
4549+
4550+
if (array_size > 0) {
4551+
PackedInt32Array array;
4552+
for (int i = 0; i < array_size; i++) {
4553+
array.push_back(false);
4554+
}
4555+
value = Variant(array);
4556+
} else {
4557+
VariantInitializer<int64_t>::init(&value);
4558+
VariantDefaultInitializer<int64_t>::init(&value);
4559+
}
4560+
break;
4561+
case ShaderLanguage::TYPE_BVEC4:
4562+
array_size *= 4;
4563+
4564+
if (array_size > 0) {
4565+
PackedInt32Array array;
4566+
for (int i = 0; i < array_size; i++) {
4567+
array.push_back(false);
4568+
}
4569+
value = Variant(array);
4570+
} else {
4571+
VariantInitializer<int64_t>::init(&value);
4572+
VariantDefaultInitializer<int64_t>::init(&value);
4573+
}
4574+
break;
4575+
case ShaderLanguage::TYPE_INT:
4576+
if (array_size > 0) {
4577+
PackedInt32Array array;
4578+
for (int i = 0; i < array_size; i++) {
4579+
array.push_back(0);
4580+
}
4581+
value = Variant(array);
4582+
} else {
4583+
VariantInitializer<int64_t>::init(&value);
4584+
VariantDefaultInitializer<int64_t>::init(&value);
4585+
}
4586+
break;
4587+
case ShaderLanguage::TYPE_IVEC2:
4588+
if (array_size > 0) {
4589+
array_size *= 2;
4590+
4591+
PackedInt32Array array;
4592+
for (int i = 0; i < array_size; i++) {
4593+
array.push_back(0);
4594+
}
4595+
value = Variant(array);
4596+
} else {
4597+
VariantInitializer<Vector2i>::init(&value);
4598+
VariantDefaultInitializer<Vector2i>::init(&value);
4599+
}
4600+
break;
4601+
case ShaderLanguage::TYPE_IVEC3:
4602+
if (array_size > 0) {
4603+
array_size *= 3;
4604+
4605+
PackedInt32Array array;
4606+
for (int i = 0; i < array_size; i++) {
4607+
array.push_back(0);
4608+
}
4609+
value = Variant(array);
4610+
} else {
4611+
VariantInitializer<Vector3i>::init(&value);
4612+
VariantDefaultInitializer<Vector3i>::init(&value);
4613+
}
4614+
break;
4615+
case ShaderLanguage::TYPE_IVEC4:
4616+
if (array_size > 0) {
4617+
array_size *= 4;
4618+
4619+
PackedInt32Array array;
4620+
for (int i = 0; i < array_size; i++) {
4621+
array.push_back(0);
4622+
}
4623+
value = Variant(array);
4624+
} else {
4625+
VariantInitializer<Vector4i>::init(&value);
4626+
VariantDefaultInitializer<Vector4i>::init(&value);
4627+
}
4628+
break;
4629+
case ShaderLanguage::TYPE_UINT:
4630+
if (array_size > 0) {
4631+
PackedInt32Array array;
4632+
for (int i = 0; i < array_size; i++) {
4633+
array.push_back(0U);
4634+
}
4635+
value = Variant(array);
4636+
} else {
4637+
VariantInitializer<int64_t>::init(&value);
4638+
VariantDefaultInitializer<int64_t>::init(&value);
4639+
}
4640+
break;
4641+
case ShaderLanguage::TYPE_UVEC2:
4642+
if (array_size > 0) {
4643+
array_size *= 2;
4644+
4645+
PackedInt32Array array;
4646+
for (int i = 0; i < array_size; i++) {
4647+
array.push_back(0U);
4648+
}
4649+
value = Variant(array);
4650+
} else {
4651+
VariantInitializer<Vector2i>::init(&value);
4652+
VariantDefaultInitializer<Vector2i>::init(&value);
4653+
}
4654+
break;
4655+
case ShaderLanguage::TYPE_UVEC3:
4656+
if (array_size > 0) {
4657+
array_size *= 3;
4658+
4659+
PackedInt32Array array;
4660+
for (int i = 0; i < array_size; i++) {
4661+
array.push_back(0U);
4662+
}
4663+
value = Variant(array);
4664+
} else {
4665+
VariantInitializer<Vector3i>::init(&value);
4666+
VariantDefaultInitializer<Vector3i>::init(&value);
4667+
}
4668+
break;
4669+
case ShaderLanguage::TYPE_UVEC4:
4670+
if (array_size > 0) {
4671+
array_size *= 4;
4672+
4673+
PackedInt32Array array;
4674+
for (int i = 0; i < array_size; i++) {
4675+
array.push_back(0U);
4676+
}
4677+
value = Variant(array);
4678+
} else {
4679+
VariantInitializer<Vector4i>::init(&value);
4680+
VariantDefaultInitializer<Vector4i>::init(&value);
4681+
}
4682+
break;
4683+
case ShaderLanguage::TYPE_FLOAT:
4684+
if (array_size > 0) {
4685+
PackedFloat32Array array;
4686+
for (int i = 0; i < array_size; i++) {
4687+
array.push_back(0.0f);
4688+
}
4689+
value = Variant(array);
4690+
} else {
4691+
VariantInitializer<float>::init(&value);
4692+
VariantDefaultInitializer<float>::init(&value);
4693+
}
4694+
break;
4695+
case ShaderLanguage::TYPE_VEC2:
4696+
if (array_size > 0) {
4697+
PackedVector2Array array;
4698+
for (int i = 0; i < array_size; i++) {
4699+
array.push_back(Vector2(0.0f, 0.0f));
4700+
}
4701+
value = Variant(array);
4702+
} else {
4703+
VariantInitializer<Vector2>::init(&value);
4704+
VariantDefaultInitializer<Vector2>::init(&value);
4705+
}
4706+
break;
4707+
case ShaderLanguage::TYPE_VEC3:
4708+
if (array_size > 0) {
4709+
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
4710+
PackedColorArray array;
4711+
for (int i = 0; i < array_size; i++) {
4712+
array.push_back(Color(0.0f, 0.0f, 0.0f));
4713+
}
4714+
value = Variant(array);
4715+
} else {
4716+
PackedVector3Array array;
4717+
for (int i = 0; i < array_size; i++) {
4718+
array.push_back(Vector3(0.0f, 0.0f, 0.0f));
4719+
}
4720+
value = Variant(array);
4721+
}
4722+
} else {
4723+
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
4724+
VariantInitializer<Color>::init(&value);
4725+
VariantDefaultInitializer<Color>::init(&value);
4726+
} else {
4727+
VariantInitializer<Vector3>::init(&value);
4728+
VariantDefaultInitializer<Vector3>::init(&value);
4729+
}
4730+
}
4731+
break;
4732+
case ShaderLanguage::TYPE_VEC4:
4733+
if (array_size > 0) {
4734+
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
4735+
PackedColorArray array;
4736+
for (int i = 0; i < array_size; i++) {
4737+
array.push_back(Color(0.0f, 0.0f, 0.0f, 0.0f));
4738+
}
4739+
value = Variant(array);
4740+
} else {
4741+
PackedVector4Array array;
4742+
for (int i = 0; i < array_size; i++) {
4743+
array.push_back(Vector4(0.0f, 0.0f, 0.0f, 0.0f));
4744+
}
4745+
value = Variant(array);
4746+
}
4747+
} else {
4748+
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
4749+
VariantInitializer<Color>::init(&value);
4750+
VariantDefaultInitializer<Color>::init(&value);
4751+
} else {
4752+
VariantInitializer<Vector4>::init(&value);
4753+
VariantDefaultInitializer<Vector4>::init(&value);
4754+
}
4755+
}
4756+
break;
4757+
case ShaderLanguage::TYPE_MAT2:
4758+
if (array_size > 0) {
4759+
PackedFloat32Array array;
4760+
for (int i = 0; i < array_size; i++) {
4761+
for (int j = 0; j < 4; j++) {
4762+
array.push_back(0.0f);
4763+
}
4764+
}
4765+
value = Variant(array);
4766+
} else {
4767+
VariantInitializer<Transform2D>::init(&value);
4768+
VariantDefaultInitializer<Transform2D>::init(&value);
4769+
}
4770+
break;
4771+
case ShaderLanguage::TYPE_MAT3: {
4772+
if (array_size > 0) {
4773+
PackedFloat32Array array;
4774+
for (int i = 0; i < array_size; i++) {
4775+
for (int j = 0; j < 9; j++) {
4776+
array.push_back(0.0f);
4777+
}
4778+
}
4779+
value = Variant(array);
4780+
} else {
4781+
VariantInitializer<Basis>::init(&value);
4782+
VariantDefaultInitializer<Basis>::init(&value);
4783+
}
4784+
break;
4785+
}
4786+
case ShaderLanguage::TYPE_MAT4: {
4787+
if (array_size > 0) {
4788+
PackedFloat32Array array;
4789+
for (int i = 0; i < array_size; i++) {
4790+
for (int j = 0; j < 16; j++) {
4791+
array.push_back(0.0f);
4792+
}
4793+
}
4794+
value = Variant(array);
4795+
} else {
4796+
VariantInitializer<Projection>::init(&value);
4797+
VariantDefaultInitializer<Projection>::init(&value);
4798+
}
4799+
break;
4800+
}
4801+
default: {
4802+
} break;
4803+
}
4804+
return value;
4805+
}
4806+
45164807
PropertyInfo ShaderLanguage::uniform_to_property_info(const ShaderNode::Uniform &p_uniform) {
45174808
PropertyInfo pi;
45184809
switch (p_uniform.type) {

‎servers/rendering/shader_language.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -824,6 +824,7 @@ class ShaderLanguage {
824824
static bool is_float_type(DataType p_type);
825825
static bool is_sampler_type(DataType p_type);
826826
static Variant constant_value_to_variant(const Vector<Scalar> &p_value, DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint = ShaderLanguage::ShaderNode::Uniform::HINT_NONE);
827+
static Variant get_default_datatype_value(DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint);
827828
static PropertyInfo uniform_to_property_info(const ShaderNode::Uniform &p_uniform);
828829
static uint32_t get_datatype_size(DataType p_type);
829830
static uint32_t get_datatype_component_count(DataType p_type);

0 commit comments

Comments
 (0)