1156 lines
40 KiB
C++
1156 lines
40 KiB
C++
/*************************************************************************/
|
|
/* material.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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 "material.h"
|
|
#include "scene/scene_string_names.h"
|
|
|
|
RID Material::get_rid() const {
|
|
|
|
return material;
|
|
}
|
|
|
|
Material::Material() {
|
|
|
|
material=VisualServer::get_singleton()->material_create();
|
|
}
|
|
|
|
Material::~Material() {
|
|
|
|
VisualServer::get_singleton()->free(material);
|
|
}
|
|
|
|
|
|
/////////////////////////////////
|
|
|
|
Mutex *FixedSpatialMaterial::material_mutex=NULL;
|
|
SelfList<FixedSpatialMaterial>::List FixedSpatialMaterial::dirty_materials;
|
|
Map<FixedSpatialMaterial::MaterialKey,FixedSpatialMaterial::ShaderData> FixedSpatialMaterial::shader_map;
|
|
FixedSpatialMaterial::ShaderNames* FixedSpatialMaterial::shader_names=NULL;
|
|
|
|
void FixedSpatialMaterial::init_shaders() {
|
|
|
|
#ifndef NO_THREADS
|
|
material_mutex = Mutex::create();
|
|
#endif
|
|
|
|
shader_names = memnew( ShaderNames );
|
|
|
|
shader_names->albedo="albedo";
|
|
shader_names->specular="specular";
|
|
shader_names->roughness="roughness";
|
|
shader_names->metalness="metalness";
|
|
shader_names->emission="emission";
|
|
shader_names->emission_energy="emission_energy";
|
|
shader_names->normal_scale="normal_scale";
|
|
shader_names->rim="rim";
|
|
shader_names->rim_tint="rim_tint";
|
|
shader_names->clearcoat="clearcoat";
|
|
shader_names->clearcoat_gloss="clearcoat_gloss";
|
|
shader_names->anisotropy="anisotropy_ratio";
|
|
shader_names->height_scale="height_scale";
|
|
shader_names->subsurface_scattering_strength="subsurface_scattering_strength";
|
|
shader_names->refraction="refraction";
|
|
shader_names->refraction_roughness="refraction_roughness";
|
|
shader_names->point_size="point_size";
|
|
shader_names->uv1_scale="uv1_scale";
|
|
shader_names->uv1_offset="uv1_offset";
|
|
shader_names->uv2_scale="uv2_scale";
|
|
shader_names->uv2_offset="uv2_offset";
|
|
|
|
shader_names->texture_names[TEXTURE_ALBEDO]="texture_albedo";
|
|
shader_names->texture_names[TEXTURE_SPECULAR]="texture_specular";
|
|
shader_names->texture_names[TEXTURE_EMISSION]="texture_emission";
|
|
shader_names->texture_names[TEXTURE_NORMAL]="texture_normal";
|
|
shader_names->texture_names[TEXTURE_RIM]="texture_rim";
|
|
shader_names->texture_names[TEXTURE_CLEARCOAT]="texture_clearcoat";
|
|
shader_names->texture_names[TEXTURE_FLOWMAP]="texture_flowmap";
|
|
shader_names->texture_names[TEXTURE_AMBIENT_OCCLUSION]="texture_ambient_occlusion";
|
|
shader_names->texture_names[TEXTURE_HEIGHT]="texture_height";
|
|
shader_names->texture_names[TEXTURE_SUBSURFACE_SCATTERING]="texture_subsurface_scattering";
|
|
shader_names->texture_names[TEXTURE_REFRACTION]="texture_refraction";
|
|
shader_names->texture_names[TEXTURE_REFRACTION_ROUGHNESS]="texture_refraction_roughness";
|
|
shader_names->texture_names[TEXTURE_DETAIL_MASK]="texture_detail_mask";
|
|
shader_names->texture_names[TEXTURE_DETAIL_ALBEDO]="texture_detail_albedo";
|
|
shader_names->texture_names[TEXTURE_DETAIL_NORMAL]="texture_detail_normal";
|
|
|
|
}
|
|
|
|
void FixedSpatialMaterial::finish_shaders(){
|
|
|
|
#ifndef NO_THREADS
|
|
memdelete( material_mutex );
|
|
#endif
|
|
|
|
memdelete( shader_names );
|
|
|
|
}
|
|
|
|
|
|
|
|
void FixedSpatialMaterial::_update_shader() {
|
|
|
|
dirty_materials.remove( &element );
|
|
|
|
MaterialKey mk = _compute_key();
|
|
if (mk.key==current_key.key)
|
|
return; //no update required in the end
|
|
|
|
if (shader_map.has(current_key)) {
|
|
shader_map[current_key].users--;
|
|
if (shader_map[current_key].users==0) {
|
|
//deallocate shader, as it's no longer in use
|
|
VS::get_singleton()->free(shader_map[current_key].shader);
|
|
shader_map.erase(current_key);
|
|
}
|
|
}
|
|
|
|
current_key=mk;
|
|
|
|
if (shader_map.has(mk)) {
|
|
|
|
VS::get_singleton()->material_set_shader(_get_material(),shader_map[mk].shader);
|
|
shader_map[mk].users++;
|
|
return;
|
|
}
|
|
|
|
//must create a shader!
|
|
|
|
String code="render_mode ";
|
|
switch(blend_mode) {
|
|
case BLEND_MODE_MIX: code+="blend_mix"; break;
|
|
case BLEND_MODE_ADD: code+="blend_add"; break;
|
|
case BLEND_MODE_SUB: code+="blend_sub"; break;
|
|
case BLEND_MODE_MUL: code+="blend_mul"; break;
|
|
}
|
|
|
|
switch(depth_draw_mode) {
|
|
case DEPTH_DRAW_OPAQUE_ONLY: code+=",depth_draw_opaque"; break;
|
|
case DEPTH_DRAW_ALWAYS: code+=",depth_draw_always"; break;
|
|
case DEPTH_DRAW_DISABLED: code+=",depth_draw_never"; break;
|
|
case DEPTH_DRAW_ALPHA_OPAQUE_PREPASS: code+=",depth_draw_alpha_prepass"; break;
|
|
}
|
|
|
|
switch(cull_mode) {
|
|
case CULL_BACK: code+=",cull_back"; break;
|
|
case CULL_FRONT: code+=",cull_front"; break;
|
|
case CULL_DISABLED: code+=",cull_disabled"; break;
|
|
|
|
}
|
|
|
|
if (flags[FLAG_UNSHADED]) {
|
|
code+=",unshaded";
|
|
}
|
|
if (flags[FLAG_ONTOP]) {
|
|
code+=",ontop";
|
|
}
|
|
|
|
code+=";\n";
|
|
|
|
|
|
code+="uniform vec4 albedo : hint_color;\n";
|
|
code+="uniform sampler2D texture_albedo : hint_albedo;\n";
|
|
if (specular_mode==SPECULAR_MODE_SPECULAR) {
|
|
code+="uniform vec4 specular : hint_color;\n";
|
|
} else {
|
|
code+="uniform float metalness;\n";
|
|
}
|
|
|
|
code+="uniform float roughness : hint_range(0,1);\n";
|
|
code+="uniform float point_size : hint_range(0,128);\n";
|
|
code+="uniform sampler2D texture_specular : hint_white;\n";
|
|
code+="uniform vec2 uv1_scale;\n";
|
|
code+="uniform vec2 uv1_offset;\n";
|
|
code+="uniform vec2 uv2_scale;\n";
|
|
code+="uniform vec2 uv2_offset;\n";
|
|
|
|
if (features[FEATURE_EMISSION]) {
|
|
|
|
code+="uniform sampler2D texture_emission : hint_black_albedo;\n";
|
|
code+="uniform vec4 emission : hint_color;\n";
|
|
code+="uniform float emission_energy;\n";
|
|
}
|
|
|
|
if (features[FEATURE_NORMAL_MAPPING]) {
|
|
code+="uniform sampler2D texture_normal : hint_normal;\n";
|
|
code+="uniform float normal_scale : hint_range(-16,16);\n";
|
|
}
|
|
if (features[FEATURE_RIM]) {
|
|
code+="uniform float rim : hint_range(0,1);\n";
|
|
code+="uniform float rim_tint : hint_range(0,1);\n";
|
|
code+="uniform sampler2D texture_rim : hint_white;\n";
|
|
}
|
|
if (features[FEATURE_CLEARCOAT]) {
|
|
code+="uniform float clearcoat : hint_range(0,1);\n";
|
|
code+="uniform float clearcoat_gloss : hint_range(0,1);\n";
|
|
code+="uniform sampler2D texture_clearcoat : hint_white;\n";
|
|
}
|
|
if (features[FEATURE_ANISOTROPY]) {
|
|
code+="uniform float anisotropy_ratio : hint_range(0,256);\n";
|
|
code+="uniform sampler2D texture_flowmap : hint_aniso;\n";
|
|
}
|
|
if (features[FEATURE_AMBIENT_OCCLUSION]) {
|
|
code+="uniform sampler2D texture_ambient_occlusion : hint_white;\n";
|
|
}
|
|
|
|
if (features[FEATURE_DETAIL]) {
|
|
code+="uniform sampler2D texture_detail_albedo : hint_albedo;\n";
|
|
code+="uniform sampler2D texture_detail_normal : hint_normal;\n";
|
|
code+="uniform sampler2D texture_detail_mask : hint_white;\n";
|
|
}
|
|
|
|
if (features[FEATURE_SUBSURACE_SCATTERING]) {
|
|
|
|
code+="uniform float subsurface_scattering_strength : hint_range(0,1);\n";
|
|
code+="uniform sampler2D texture_subsurface_scattering : hint_white;\n";
|
|
|
|
}
|
|
|
|
|
|
code+="\n\n";
|
|
|
|
code+="void vertex() {\n";
|
|
|
|
if (flags[FLAG_SRGB_VERTEX_COLOR]) {
|
|
|
|
code+="\tCOLOR.rgb = mix( pow((COLOR.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), COLOR.rgb* (1.0 / 12.92), lessThan(COLOR.rgb,vec3(0.04045)) );\n";
|
|
}
|
|
if (flags[FLAG_USE_POINT_SIZE]) {
|
|
|
|
code+="\tPOINT_SIZE=point_size;\n";
|
|
}
|
|
code+="\tUV=UV*uv1_scale+uv1_offset;\n";
|
|
if (detail_uv==DETAIL_UV_2) {
|
|
code+="\tUV2=UV2*uv2_scale+uv2_offset;\n";
|
|
}
|
|
|
|
code+="}\n";
|
|
code+="\n\n";
|
|
code+="void fragment() {\n";
|
|
|
|
if (flags[FLAG_USE_POINT_SIZE]) {
|
|
code+="\tvec4 albedo_tex = texture(texture_albedo,POINT_COORD);\n";
|
|
} else {
|
|
code+="\tvec4 albedo_tex = texture(texture_albedo,UV);\n";
|
|
}
|
|
|
|
if (flags[FLAG_ALBEDO_FROM_VERTEX_COLOR]) {
|
|
code+="\talbedo_tex *= COLOR;\n";
|
|
}
|
|
|
|
code+="\tALBEDO = albedo.rgb * albedo_tex.rgb;\n";
|
|
if (features[FEATURE_TRANSPARENT]) {
|
|
code+="\tALPHA = albedo.a * albedo_tex.a;\n";
|
|
}
|
|
|
|
if (features[FEATURE_EMISSION]) {
|
|
code+="\tEMISSION = (emission.rgb+texture(texture_emission,UV).rgb)*emission_energy;\n";
|
|
}
|
|
|
|
if (features[FEATURE_NORMAL_MAPPING]) {
|
|
code+="\tNORMALMAP = texture(texture_normal,UV).rgb;\n";
|
|
code+="\tNORMALMAP_DEPTH = normal_scale;\n";
|
|
}
|
|
|
|
if (features[FEATURE_RIM]) {
|
|
code+="\tvec2 rim_tex = texture(texture_rim,UV).xw;\n";
|
|
code+="\tRIM = rim*rim_tex.x;";
|
|
code+="\tRIM_TINT = rim_tint*rim_tex.y;\n";
|
|
}
|
|
|
|
if (features[FEATURE_CLEARCOAT]) {
|
|
code+="\tvec2 clearcoat_tex = texture(texture_clearcoat,UV).xw;\n";
|
|
code+="\tCLEARCOAT = clearcoat*clearcoat_tex.x;";
|
|
code+="\tCLEARCOAT_GLOSS = clearcoat_gloss*clearcoat_tex.y;\n";
|
|
}
|
|
|
|
if (features[FEATURE_ANISOTROPY]) {
|
|
code+="\tvec4 anisotropy_tex = texture(texture_flowmap,UV);\n";
|
|
code+="\tANISOTROPY = anisotropy_ratio*anisotropy_tex.a;\n";
|
|
code+="\tANISOTROPY_FLOW = anisotropy_tex.rg*2.0-1.0;\n";
|
|
}
|
|
|
|
if (features[FEATURE_AMBIENT_OCCLUSION]) {
|
|
code+="\tAO = texture(texture_ambient_occlusion,UV).r;\n";
|
|
}
|
|
|
|
if (features[FEATURE_SUBSURACE_SCATTERING]) {
|
|
|
|
code+="\tfloat sss_tex = texture(texture_subsurface_scattering,UV).r;\n";
|
|
code+="\tSSS_STRENGTH=subsurface_scattering_strength*sss_tex;\n";
|
|
}
|
|
|
|
if (features[FEATURE_DETAIL]) {
|
|
String det_uv=detail_uv==DETAIL_UV_1?"UV":"UV2";
|
|
code+="\tvec4 detail_tex = texture(texture_detail_albedo,"+det_uv+");\n";
|
|
code+="\tvec4 detail_norm_tex = texture(texture_detail_normal,"+det_uv+");\n";
|
|
code+="\tvec4 detail_mask_tex = texture(texture_detail_mask,UV);\n";
|
|
|
|
switch(detail_blend_mode) {
|
|
case BLEND_MODE_MIX: {
|
|
code+="\tvec3 detail = mix(ALBEDO.rgb,detail_tex.rgb,detail_tex.a);\n";
|
|
} break;
|
|
case BLEND_MODE_ADD: {
|
|
code+="\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb+detail_tex.rgb,detail_tex.a);\n";
|
|
} break;
|
|
case BLEND_MODE_SUB: {
|
|
code+="\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb-detail_tex.rgb,detail_tex.a);\n";
|
|
} break;
|
|
case BLEND_MODE_MUL: {
|
|
code+="\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb*detail_tex.rgb,detail_tex.a);\n";
|
|
} break;
|
|
|
|
}
|
|
|
|
code+="\tvec3 detail_norm = mix(NORMALMAP,detail_norm_tex.rgb,detail_tex.a);\n";
|
|
|
|
code+="\tNORMALMAP = mix(NORMALMAP,detail_norm,detail_mask_tex.r);\n";
|
|
code+="\tALBEDO.rgb = mix(ALBEDO.rgb,detail,detail_mask_tex.r);\n";
|
|
}
|
|
|
|
if (specular_mode==SPECULAR_MODE_SPECULAR) {
|
|
|
|
code+="\tvec4 specular_tex = texture(texture_specular,UV);\n";
|
|
code+="\tSPECULAR = specular.rgb * specular_tex.rgb;\n";
|
|
code+="\tROUGHNESS = specular_tex.a * roughness;\n";
|
|
} else {
|
|
code+="\tvec4 specular_tex = texture(texture_specular,UV);\n";
|
|
code+="\tSPECULAR = vec3(ALBEDO.rgb * metalness * specular_tex.r);\n";
|
|
code+="\tROUGHNESS = specular_tex.a * roughness;\n";
|
|
}
|
|
|
|
code+="}\n";
|
|
|
|
ShaderData shader_data;
|
|
shader_data.shader = VS::get_singleton()->shader_create(VS::SHADER_SPATIAL);
|
|
shader_data.users=1;
|
|
|
|
VS::get_singleton()->shader_set_code( shader_data.shader, code );
|
|
|
|
shader_map[mk]=shader_data;
|
|
|
|
VS::get_singleton()->material_set_shader(_get_material(),shader_data.shader);
|
|
|
|
}
|
|
|
|
void FixedSpatialMaterial::flush_changes() {
|
|
|
|
if (material_mutex)
|
|
material_mutex->lock();
|
|
|
|
while (dirty_materials.first()) {
|
|
|
|
dirty_materials.first()->self()->_update_shader();
|
|
}
|
|
|
|
if (material_mutex)
|
|
material_mutex->unlock();
|
|
}
|
|
|
|
void FixedSpatialMaterial::_queue_shader_change() {
|
|
|
|
if (material_mutex)
|
|
material_mutex->lock();
|
|
|
|
if (!element.in_list()) {
|
|
dirty_materials.add(&element);
|
|
}
|
|
|
|
if (material_mutex)
|
|
material_mutex->unlock();
|
|
|
|
|
|
}
|
|
|
|
bool FixedSpatialMaterial::_is_shader_dirty() const {
|
|
|
|
bool dirty=false;
|
|
|
|
if (material_mutex)
|
|
material_mutex->lock();
|
|
|
|
dirty=element.in_list();
|
|
|
|
if (material_mutex)
|
|
material_mutex->unlock();
|
|
|
|
return dirty;
|
|
}
|
|
void FixedSpatialMaterial::set_albedo(const Color& p_albedo) {
|
|
|
|
albedo=p_albedo;
|
|
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->albedo,p_albedo);
|
|
}
|
|
|
|
Color FixedSpatialMaterial::get_albedo() const{
|
|
|
|
return albedo;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_specular_mode(SpecularMode p_mode) {
|
|
specular_mode=p_mode;
|
|
_change_notify();
|
|
_queue_shader_change();
|
|
}
|
|
|
|
FixedSpatialMaterial::SpecularMode FixedSpatialMaterial::get_specular_mode() const {
|
|
|
|
return specular_mode;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_specular(const Color& p_specular){
|
|
|
|
specular=p_specular;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->specular,p_specular);
|
|
|
|
}
|
|
Color FixedSpatialMaterial::get_specular() const{
|
|
|
|
return specular;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_roughness(float p_roughness){
|
|
|
|
roughness=p_roughness;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->roughness,p_roughness);
|
|
|
|
}
|
|
|
|
|
|
float FixedSpatialMaterial::get_roughness() const{
|
|
|
|
return roughness;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_metalness(float p_metalness){
|
|
|
|
metalness=p_metalness;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->metalness,p_metalness);
|
|
}
|
|
|
|
|
|
float FixedSpatialMaterial::get_metalness() const{
|
|
|
|
return metalness;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_emission(const Color& p_emission){
|
|
|
|
emission=p_emission;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->emission,p_emission);
|
|
|
|
}
|
|
Color FixedSpatialMaterial::get_emission() const{
|
|
|
|
return emission;
|
|
}
|
|
|
|
|
|
void FixedSpatialMaterial::set_emission_energy(float p_emission_energy){
|
|
|
|
emission_energy=p_emission_energy;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->emission_energy,p_emission_energy);
|
|
|
|
}
|
|
float FixedSpatialMaterial::get_emission_energy() const{
|
|
|
|
return emission_energy;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_normal_scale(float p_normal_scale){
|
|
|
|
normal_scale=p_normal_scale;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->normal_scale,p_normal_scale);
|
|
|
|
}
|
|
float FixedSpatialMaterial::get_normal_scale() const{
|
|
|
|
return normal_scale;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_rim(float p_rim){
|
|
|
|
rim=p_rim;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->rim,p_rim);
|
|
|
|
|
|
}
|
|
float FixedSpatialMaterial::get_rim() const{
|
|
|
|
return rim;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_rim_tint(float p_rim_tint){
|
|
|
|
rim_tint=p_rim_tint;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->rim_tint,p_rim_tint);
|
|
|
|
}
|
|
float FixedSpatialMaterial::get_rim_tint() const{
|
|
|
|
return rim_tint;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_clearcoat(float p_clearcoat){
|
|
|
|
clearcoat=p_clearcoat;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->clearcoat,p_clearcoat);
|
|
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_clearcoat() const{
|
|
|
|
return clearcoat;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_clearcoat_gloss(float p_clearcoat_gloss){
|
|
|
|
clearcoat_gloss=p_clearcoat_gloss;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->clearcoat_gloss,p_clearcoat_gloss);
|
|
|
|
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_clearcoat_gloss() const{
|
|
|
|
return clearcoat_gloss;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_anisotropy(float p_anisotropy){
|
|
|
|
anisotropy=p_anisotropy;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->anisotropy,p_anisotropy);
|
|
|
|
}
|
|
float FixedSpatialMaterial::get_anisotropy() const{
|
|
|
|
return anisotropy;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_height_scale(float p_height_scale){
|
|
|
|
height_scale=p_height_scale;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->height_scale,p_height_scale);
|
|
|
|
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_height_scale() const{
|
|
|
|
return height_scale;
|
|
}
|
|
|
|
|
|
void FixedSpatialMaterial::set_subsurface_scattering_strength(float p_subsurface_scattering_strength){
|
|
|
|
subsurface_scattering_strength=p_subsurface_scattering_strength;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->subsurface_scattering_strength,subsurface_scattering_strength);
|
|
|
|
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_subsurface_scattering_strength() const{
|
|
|
|
return subsurface_scattering_strength;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_refraction(float p_refraction){
|
|
|
|
refraction=p_refraction;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->refraction,refraction);
|
|
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_refraction() const {
|
|
|
|
return refraction;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_refraction_roughness(float p_refraction_roughness) {
|
|
|
|
refraction_roughness=p_refraction_roughness;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->refraction_roughness,refraction_roughness);
|
|
|
|
|
|
}
|
|
float FixedSpatialMaterial::get_refraction_roughness() const {
|
|
|
|
return refraction_roughness;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_detail_uv(DetailUV p_detail_uv) {
|
|
|
|
if (detail_uv==p_detail_uv)
|
|
return;
|
|
|
|
detail_uv=p_detail_uv;
|
|
_queue_shader_change();
|
|
}
|
|
FixedSpatialMaterial::DetailUV FixedSpatialMaterial::get_detail_uv() const {
|
|
|
|
return detail_uv;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_blend_mode(BlendMode p_mode) {
|
|
|
|
if (blend_mode==p_mode)
|
|
return;
|
|
|
|
blend_mode=p_mode;
|
|
_queue_shader_change();
|
|
}
|
|
FixedSpatialMaterial::BlendMode FixedSpatialMaterial::get_blend_mode() const {
|
|
|
|
return blend_mode;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_detail_blend_mode(BlendMode p_mode) {
|
|
|
|
detail_blend_mode=p_mode;
|
|
_queue_shader_change();
|
|
}
|
|
FixedSpatialMaterial::BlendMode FixedSpatialMaterial::get_detail_blend_mode() const {
|
|
|
|
return detail_blend_mode;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_depth_draw_mode(DepthDrawMode p_mode) {
|
|
|
|
if (depth_draw_mode==p_mode)
|
|
return;
|
|
|
|
depth_draw_mode=p_mode;
|
|
_queue_shader_change();
|
|
}
|
|
FixedSpatialMaterial::DepthDrawMode FixedSpatialMaterial::get_depth_draw_mode() const {
|
|
|
|
return depth_draw_mode;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_cull_mode(CullMode p_mode) {
|
|
|
|
if (cull_mode==p_mode)
|
|
return;
|
|
|
|
cull_mode=p_mode;
|
|
_queue_shader_change();
|
|
}
|
|
FixedSpatialMaterial::CullMode FixedSpatialMaterial::get_cull_mode() const {
|
|
|
|
return cull_mode;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_diffuse_mode(DiffuseMode p_mode) {
|
|
|
|
if (diffuse_mode==p_mode)
|
|
return;
|
|
|
|
diffuse_mode=p_mode;
|
|
_queue_shader_change();
|
|
}
|
|
FixedSpatialMaterial::DiffuseMode FixedSpatialMaterial::get_diffuse_mode() const {
|
|
|
|
return diffuse_mode;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_flag(Flags p_flag,bool p_enabled) {
|
|
|
|
ERR_FAIL_INDEX(p_flag,FLAG_MAX);
|
|
|
|
if (flags[p_flag]==p_enabled)
|
|
return;
|
|
|
|
flags[p_flag]=p_enabled;
|
|
_queue_shader_change();
|
|
}
|
|
|
|
bool FixedSpatialMaterial::get_flag(Flags p_flag) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_flag,FLAG_MAX,false);
|
|
return flags[p_flag];
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_feature(Feature p_feature,bool p_enabled) {
|
|
|
|
ERR_FAIL_INDEX(p_feature,FEATURE_MAX);
|
|
if (features[p_feature]==p_enabled)
|
|
return;
|
|
|
|
features[p_feature]=p_enabled;
|
|
_change_notify();
|
|
_queue_shader_change();
|
|
|
|
|
|
}
|
|
|
|
bool FixedSpatialMaterial::get_feature(Feature p_feature) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_feature,FEATURE_MAX,false);
|
|
return features[p_feature];
|
|
}
|
|
|
|
|
|
|
|
void FixedSpatialMaterial::set_texture(TextureParam p_param, const Ref<Texture> &p_texture) {
|
|
|
|
ERR_FAIL_INDEX(p_param,TEXTURE_MAX);
|
|
textures[p_param]=p_texture;
|
|
RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->texture_names[p_param],rid);
|
|
}
|
|
|
|
Ref<Texture> FixedSpatialMaterial::get_texture(TextureParam p_param) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_param,TEXTURE_MAX,Ref<Texture>());
|
|
return textures[p_param];
|
|
}
|
|
|
|
|
|
void FixedSpatialMaterial::_validate_feature(const String& text, Feature feature,PropertyInfo& property) const {
|
|
if (property.name.begins_with(text) && property.name!=text+"_enabled" && !features[feature]) {
|
|
property.usage=0;
|
|
}
|
|
|
|
}
|
|
|
|
void FixedSpatialMaterial::_validate_property(PropertyInfo& property) const {
|
|
_validate_feature("normal",FEATURE_NORMAL_MAPPING,property);
|
|
_validate_feature("emission",FEATURE_EMISSION,property);
|
|
_validate_feature("rim",FEATURE_RIM,property);
|
|
_validate_feature("clearcoat",FEATURE_CLEARCOAT,property);
|
|
_validate_feature("anisotropy",FEATURE_ANISOTROPY,property);
|
|
_validate_feature("ao",FEATURE_AMBIENT_OCCLUSION,property);
|
|
_validate_feature("height",FEATURE_HEIGHT_MAPPING,property);
|
|
_validate_feature("subsurf_scatter",FEATURE_SUBSURACE_SCATTERING,property);
|
|
_validate_feature("refraction",FEATURE_REFRACTION,property);
|
|
_validate_feature("detail",FEATURE_DETAIL,property);
|
|
|
|
if (property.name=="specular/color" && specular_mode==SPECULAR_MODE_METALLIC) {
|
|
property.usage=0;
|
|
}
|
|
if (property.name=="specular/metalness" && specular_mode==SPECULAR_MODE_SPECULAR) {
|
|
property.usage=0;
|
|
}
|
|
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_line_width(float p_line_width) {
|
|
|
|
line_width=p_line_width;
|
|
VS::get_singleton()->material_set_line_width(_get_material(),line_width);
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_line_width() const {
|
|
|
|
return line_width;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_point_size(float p_point_size) {
|
|
|
|
point_size=p_point_size;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->point_size,p_point_size);
|
|
}
|
|
|
|
float FixedSpatialMaterial::get_point_size() const {
|
|
|
|
return point_size;
|
|
}
|
|
|
|
|
|
void FixedSpatialMaterial::set_uv1_scale(const Vector2& p_scale) {
|
|
|
|
uv1_scale=p_scale;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->uv1_scale,p_scale);
|
|
}
|
|
|
|
Vector2 FixedSpatialMaterial::get_uv1_scale() const{
|
|
|
|
return uv1_scale;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_uv1_offset(const Vector2& p_offset){
|
|
|
|
uv1_offset=p_offset;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->uv1_offset,p_offset);
|
|
|
|
}
|
|
Vector2 FixedSpatialMaterial::get_uv1_offset() const{
|
|
|
|
return uv1_offset;
|
|
}
|
|
|
|
|
|
void FixedSpatialMaterial::set_uv2_scale(const Vector2& p_scale) {
|
|
|
|
uv2_scale=p_scale;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->uv2_scale,p_scale);
|
|
}
|
|
|
|
Vector2 FixedSpatialMaterial::get_uv2_scale() const{
|
|
|
|
return uv2_scale;
|
|
}
|
|
|
|
void FixedSpatialMaterial::set_uv2_offset(const Vector2& p_offset){
|
|
|
|
uv2_offset=p_offset;
|
|
VS::get_singleton()->material_set_param(_get_material(),shader_names->uv2_offset,p_offset);
|
|
|
|
}
|
|
|
|
Vector2 FixedSpatialMaterial::get_uv2_offset() const{
|
|
|
|
return uv2_offset;
|
|
}
|
|
|
|
void FixedSpatialMaterial::_bind_methods() {
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_albedo","albedo"),&FixedSpatialMaterial::set_albedo);
|
|
ClassDB::bind_method(D_METHOD("get_albedo"),&FixedSpatialMaterial::get_albedo);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_specular_mode","specular_mode"),&FixedSpatialMaterial::set_specular_mode);
|
|
ClassDB::bind_method(D_METHOD("get_specular_mode"),&FixedSpatialMaterial::get_specular_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_specular","specular"),&FixedSpatialMaterial::set_specular);
|
|
ClassDB::bind_method(D_METHOD("get_specular"),&FixedSpatialMaterial::get_specular);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_metalness","metalness"),&FixedSpatialMaterial::set_metalness);
|
|
ClassDB::bind_method(D_METHOD("get_metalness"),&FixedSpatialMaterial::get_metalness);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_roughness","roughness"),&FixedSpatialMaterial::set_roughness);
|
|
ClassDB::bind_method(D_METHOD("get_roughness"),&FixedSpatialMaterial::get_roughness);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_emission","emission"),&FixedSpatialMaterial::set_emission);
|
|
ClassDB::bind_method(D_METHOD("get_emission"),&FixedSpatialMaterial::get_emission);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_emission_energy","emission_energy"),&FixedSpatialMaterial::set_emission_energy);
|
|
ClassDB::bind_method(D_METHOD("get_emission_energy"),&FixedSpatialMaterial::get_emission_energy);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_normal_scale","normal_scale"),&FixedSpatialMaterial::set_normal_scale);
|
|
ClassDB::bind_method(D_METHOD("get_normal_scale"),&FixedSpatialMaterial::get_normal_scale);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_rim","rim"),&FixedSpatialMaterial::set_rim);
|
|
ClassDB::bind_method(D_METHOD("get_rim"),&FixedSpatialMaterial::get_rim);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_rim_tint","rim_tint"),&FixedSpatialMaterial::set_rim_tint);
|
|
ClassDB::bind_method(D_METHOD("get_rim_tint"),&FixedSpatialMaterial::get_rim_tint);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_clearcoat","clearcoat"),&FixedSpatialMaterial::set_clearcoat);
|
|
ClassDB::bind_method(D_METHOD("get_clearcoat"),&FixedSpatialMaterial::get_clearcoat);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_clearcoat_gloss","clearcoat_gloss"),&FixedSpatialMaterial::set_clearcoat_gloss);
|
|
ClassDB::bind_method(D_METHOD("get_clearcoat_gloss"),&FixedSpatialMaterial::get_clearcoat_gloss);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_anisotropy","anisotropy"),&FixedSpatialMaterial::set_anisotropy);
|
|
ClassDB::bind_method(D_METHOD("get_anisotropy"),&FixedSpatialMaterial::get_anisotropy);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_height_scale","height_scale"),&FixedSpatialMaterial::set_height_scale);
|
|
ClassDB::bind_method(D_METHOD("get_height_scale"),&FixedSpatialMaterial::get_height_scale);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_subsurface_scattering_strength","strength"),&FixedSpatialMaterial::set_subsurface_scattering_strength);
|
|
ClassDB::bind_method(D_METHOD("get_subsurface_scattering_strength"),&FixedSpatialMaterial::get_subsurface_scattering_strength);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_refraction","refraction"),&FixedSpatialMaterial::set_refraction);
|
|
ClassDB::bind_method(D_METHOD("get_refraction"),&FixedSpatialMaterial::get_refraction);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_refraction_roughness","refraction_roughness"),&FixedSpatialMaterial::set_refraction_roughness);
|
|
ClassDB::bind_method(D_METHOD("get_refraction_roughness"),&FixedSpatialMaterial::get_refraction_roughness);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_line_width","line_width"),&FixedSpatialMaterial::set_line_width);
|
|
ClassDB::bind_method(D_METHOD("get_line_width"),&FixedSpatialMaterial::get_line_width);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_point_size","point_size"),&FixedSpatialMaterial::set_point_size);
|
|
ClassDB::bind_method(D_METHOD("get_point_size"),&FixedSpatialMaterial::get_point_size);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_detail_uv","detail_uv"),&FixedSpatialMaterial::set_detail_uv);
|
|
ClassDB::bind_method(D_METHOD("get_detail_uv"),&FixedSpatialMaterial::get_detail_uv);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_blend_mode","blend_mode"),&FixedSpatialMaterial::set_blend_mode);
|
|
ClassDB::bind_method(D_METHOD("get_blend_mode"),&FixedSpatialMaterial::get_blend_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_depth_draw_mode","depth_draw_mode"),&FixedSpatialMaterial::set_depth_draw_mode);
|
|
ClassDB::bind_method(D_METHOD("get_depth_draw_mode"),&FixedSpatialMaterial::get_depth_draw_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_cull_mode","cull_mode"),&FixedSpatialMaterial::set_cull_mode);
|
|
ClassDB::bind_method(D_METHOD("get_cull_mode"),&FixedSpatialMaterial::get_cull_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_diffuse_mode","diffuse_mode"),&FixedSpatialMaterial::set_diffuse_mode);
|
|
ClassDB::bind_method(D_METHOD("get_diffuse_mode"),&FixedSpatialMaterial::get_diffuse_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_flag","flag","enable"),&FixedSpatialMaterial::set_flag);
|
|
ClassDB::bind_method(D_METHOD("get_flag"),&FixedSpatialMaterial::get_flag);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_feature","feature","enable"),&FixedSpatialMaterial::set_feature);
|
|
ClassDB::bind_method(D_METHOD("get_feature","feature"),&FixedSpatialMaterial::get_feature);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_texture","param:Texture","texture"),&FixedSpatialMaterial::set_texture);
|
|
ClassDB::bind_method(D_METHOD("get_texture:Texture","param:Texture"),&FixedSpatialMaterial::get_texture);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_detail_blend_mode","detail_blend_mode"),&FixedSpatialMaterial::set_detail_blend_mode);
|
|
ClassDB::bind_method(D_METHOD("get_detail_blend_mode"),&FixedSpatialMaterial::get_detail_blend_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_uv1_scale","scale"),&FixedSpatialMaterial::set_uv1_scale);
|
|
ClassDB::bind_method(D_METHOD("get_uv1_scale"),&FixedSpatialMaterial::get_uv1_scale);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_uv1_offset","offset"),&FixedSpatialMaterial::set_uv1_offset);
|
|
ClassDB::bind_method(D_METHOD("get_uv1_offset"),&FixedSpatialMaterial::get_uv1_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_uv2_scale","scale"),&FixedSpatialMaterial::set_uv2_scale);
|
|
ClassDB::bind_method(D_METHOD("get_uv2_scale"),&FixedSpatialMaterial::get_uv2_scale);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_uv2_offset","offset"),&FixedSpatialMaterial::set_uv2_offset);
|
|
ClassDB::bind_method(D_METHOD("get_uv2_offset"),&FixedSpatialMaterial::get_uv2_offset);
|
|
|
|
ADD_GROUP("Flags","flags_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_transparent"),"set_feature","get_feature",FEATURE_TRANSPARENT);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_unshaded"),"set_flag","get_flag",FLAG_UNSHADED);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_on_top"),"set_flag","get_flag",FLAG_ONTOP);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_use_point_size"),"set_flag","get_flag",FLAG_USE_POINT_SIZE);
|
|
ADD_GROUP("Vertex Color","vertex_color");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"vertex_color_use_as_albedo"),"set_flag","get_flag",FLAG_ALBEDO_FROM_VERTEX_COLOR);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"vertex_color_is_srgb"),"set_flag","get_flag",FLAG_SRGB_VERTEX_COLOR);
|
|
|
|
ADD_GROUP("Parameters","params_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"params_diffuse_mode",PROPERTY_HINT_ENUM,"Labert,Lambert Wrap,Oren Nayar,Burley"),"set_diffuse_mode","get_diffuse_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"params_blend_mode",PROPERTY_HINT_ENUM,"Mix,Add,Sub,Mul"),"set_blend_mode","get_blend_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"params_cull_mode",PROPERTY_HINT_ENUM,"Back,Front,Disabled"),"set_cull_mode","get_cull_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"params_depth_draw_mode",PROPERTY_HINT_ENUM,"Opaque Only,Always,Never,Opaque Pre-Pass"),"set_depth_draw_mode","get_depth_draw_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"params_line_width",PROPERTY_HINT_RANGE,"0.1,128,0.1"),"set_line_width","get_line_width");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"params_point_size",PROPERTY_HINT_RANGE,"0.1,128,0.1"),"set_point_size","get_point_size");
|
|
|
|
ADD_GROUP("Albedo","albedo_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::COLOR,"albedo_color"),"set_albedo","get_albedo");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"albedo_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_ALBEDO);
|
|
|
|
ADD_GROUP("Specular","specular_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"specular_mode",PROPERTY_HINT_ENUM,"Metallic,Specular"),"set_specular_mode","get_specular_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::COLOR,"specular_color",PROPERTY_HINT_COLOR_NO_ALPHA),"set_specular","get_specular");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"specular_metalness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_metalness","get_metalness");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"specular_roughness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_roughness","get_roughness");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"specular_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_SPECULAR);
|
|
|
|
ADD_GROUP("Emission","emission_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"emission_enabled"),"set_feature","get_feature",FEATURE_EMISSION);
|
|
ADD_PROPERTY(PropertyInfo(Variant::COLOR,"emission_color",PROPERTY_HINT_COLOR_NO_ALPHA),"set_emission","get_emission");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"emission_energy",PROPERTY_HINT_RANGE,"0,16,0.01"),"set_emission_energy","get_emission_energy");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"emission_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_EMISSION);
|
|
|
|
ADD_GROUP("NormapMap","normal_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"normal_enabled"),"set_feature","get_feature",FEATURE_NORMAL_MAPPING);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"normal_scale",PROPERTY_HINT_RANGE,"-16,16,0.01"),"set_normal_scale","get_normal_scale");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"normal_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_NORMAL);
|
|
|
|
ADD_GROUP("Rim","rim_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"rim_enabled"),"set_feature","get_feature",FEATURE_RIM);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"rim_amount",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_rim","get_rim");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"rim_tint",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_rim_tint","get_rim_tint");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"rim_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_RIM);
|
|
|
|
ADD_GROUP("Clearcoat","clearcoat_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"clearcoat_enabled"),"set_feature","get_feature",FEATURE_CLEARCOAT);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"clearcoat_amount",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_clearcoat","get_clearcoat");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"clearcoat_gloss",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_clearcoat_gloss","get_clearcoat_gloss");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"clearcoat_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_CLEARCOAT);
|
|
|
|
ADD_GROUP("Anisotropy","anisotropy_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"anisotropy_enabled"),"set_feature","get_feature",FEATURE_ANISOTROPY);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"anisotropy_anisotropy",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_anisotropy","get_anisotropy");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"anisotropy_flowmap",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_FLOWMAP);
|
|
|
|
ADD_GROUP("Ambient Occlusion","ao_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"ao_enabled"),"set_feature","get_feature",FEATURE_AMBIENT_OCCLUSION);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"ao_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_AMBIENT_OCCLUSION);
|
|
|
|
ADD_GROUP("Height","height_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"height_enabled"),"set_feature","get_feature",FEATURE_HEIGHT_MAPPING);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"height_scale",PROPERTY_HINT_RANGE,"-16,16,0.01"),"set_height_scale","get_height_scale");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"height_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_HEIGHT);
|
|
|
|
ADD_GROUP("Subsurf Scatter","subsurf_scatter_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"subsurf_scatter_enabled"),"set_feature","get_feature",FEATURE_SUBSURACE_SCATTERING);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"subsurf_scatter_strength",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_subsurface_scattering_strength","get_subsurface_scattering_strength");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"subsurf_scatter_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_SUBSURFACE_SCATTERING);
|
|
|
|
ADD_GROUP("Refraction","refraction_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"refraction_enabled"),"set_feature","get_feature",FEATURE_REFRACTION);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"refraction_displacement",PROPERTY_HINT_RANGE,"-1,1,0.01"),"set_refraction","get_refraction");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL,"refraction_roughness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_refraction_roughness","get_refraction_roughness");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"refraction_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_REFRACTION);
|
|
|
|
ADD_GROUP("Detail","detail_");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"detail_enabled"),"set_feature","get_feature",FEATURE_DETAIL);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"detail_mask",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_DETAIL_MASK);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"detail_blend_mode",PROPERTY_HINT_ENUM,"Mix,Add,Sub,Mul"),"set_detail_blend_mode","get_detail_blend_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT,"detail_uv_layer",PROPERTY_HINT_ENUM,"UV1,UV2"),"set_detail_uv","get_detail_uv");
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"detail_albedo",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_DETAIL_ALBEDO);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"detail_normal",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_DETAIL_NORMAL);
|
|
|
|
ADD_GROUP("UV1","uv1_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv1_scale"),"set_uv1_scale","get_uv1_scale");
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv1_offset"),"set_uv1_offset","get_uv1_offset");
|
|
|
|
ADD_GROUP("UV2","uv2_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv2_scale"),"set_uv2_scale","get_uv2_scale");
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv2_offset"),"set_uv2_offset","get_uv2_offset");
|
|
|
|
|
|
BIND_CONSTANT( TEXTURE_ALBEDO );
|
|
BIND_CONSTANT( TEXTURE_SPECULAR );
|
|
BIND_CONSTANT( TEXTURE_EMISSION );
|
|
BIND_CONSTANT( TEXTURE_NORMAL );
|
|
BIND_CONSTANT( TEXTURE_RIM );
|
|
BIND_CONSTANT( TEXTURE_CLEARCOAT );
|
|
BIND_CONSTANT( TEXTURE_FLOWMAP );
|
|
BIND_CONSTANT( TEXTURE_AMBIENT_OCCLUSION );
|
|
BIND_CONSTANT( TEXTURE_HEIGHT );
|
|
BIND_CONSTANT( TEXTURE_SUBSURFACE_SCATTERING );
|
|
BIND_CONSTANT( TEXTURE_REFRACTION );
|
|
BIND_CONSTANT( TEXTURE_REFRACTION_ROUGHNESS );
|
|
BIND_CONSTANT( TEXTURE_DETAIL_MASK );
|
|
BIND_CONSTANT( TEXTURE_DETAIL_ALBEDO );
|
|
BIND_CONSTANT( TEXTURE_DETAIL_NORMAL );
|
|
BIND_CONSTANT( TEXTURE_MAX );
|
|
|
|
|
|
BIND_CONSTANT( DETAIL_UV_1 );
|
|
BIND_CONSTANT( DETAIL_UV_2 );
|
|
|
|
BIND_CONSTANT( FEATURE_TRANSPARENT );
|
|
BIND_CONSTANT( FEATURE_EMISSION );
|
|
BIND_CONSTANT( FEATURE_NORMAL_MAPPING );
|
|
BIND_CONSTANT( FEATURE_RIM );
|
|
BIND_CONSTANT( FEATURE_CLEARCOAT );
|
|
BIND_CONSTANT( FEATURE_ANISOTROPY );
|
|
BIND_CONSTANT( FEATURE_AMBIENT_OCCLUSION );
|
|
BIND_CONSTANT( FEATURE_HEIGHT_MAPPING );
|
|
BIND_CONSTANT( FEATURE_SUBSURACE_SCATTERING );
|
|
BIND_CONSTANT( FEATURE_REFRACTION );
|
|
BIND_CONSTANT( FEATURE_DETAIL );
|
|
BIND_CONSTANT( FEATURE_MAX );
|
|
|
|
BIND_CONSTANT( BLEND_MODE_MIX );
|
|
BIND_CONSTANT( BLEND_MODE_ADD );
|
|
BIND_CONSTANT( BLEND_MODE_SUB );
|
|
BIND_CONSTANT( BLEND_MODE_MUL );
|
|
|
|
BIND_CONSTANT( DEPTH_DRAW_OPAQUE_ONLY );
|
|
BIND_CONSTANT( DEPTH_DRAW_ALWAYS );
|
|
BIND_CONSTANT( DEPTH_DRAW_DISABLED );
|
|
BIND_CONSTANT( DEPTH_DRAW_ALPHA_OPAQUE_PREPASS );
|
|
|
|
|
|
BIND_CONSTANT( CULL_BACK );
|
|
BIND_CONSTANT( CULL_FRONT );
|
|
BIND_CONSTANT( CULL_DISABLED );
|
|
|
|
BIND_CONSTANT( FLAG_UNSHADED );
|
|
BIND_CONSTANT( FLAG_ONTOP );
|
|
BIND_CONSTANT( FLAG_ALBEDO_FROM_VERTEX_COLOR );
|
|
BIND_CONSTANT( FLAG_SRGB_VERTEX_COLOR )
|
|
BIND_CONSTANT( FLAG_USE_POINT_SIZE )
|
|
BIND_CONSTANT( FLAG_MAX );
|
|
|
|
BIND_CONSTANT( DIFFUSE_LAMBERT );
|
|
BIND_CONSTANT( DIFFUSE_LAMBERT_WRAP );
|
|
BIND_CONSTANT( DIFFUSE_OREN_NAYAR );
|
|
BIND_CONSTANT( DIFFUSE_BURLEY );
|
|
|
|
BIND_CONSTANT( SPECULAR_MODE_METALLIC );
|
|
BIND_CONSTANT( SPECULAR_MODE_SPECULAR );
|
|
|
|
}
|
|
|
|
|
|
FixedSpatialMaterial::FixedSpatialMaterial() : element(this) {
|
|
|
|
//initialize to right values
|
|
specular_mode=SPECULAR_MODE_METALLIC;
|
|
set_albedo(Color(0.7,0.7,0.7,1.0));
|
|
set_specular(Color(0.1,0.1,0.1));
|
|
set_roughness(0.0);
|
|
set_metalness(0.1);
|
|
set_emission(Color(0,0,0));
|
|
set_emission_energy(1.0);
|
|
set_normal_scale(1);
|
|
set_rim(1.0);
|
|
set_rim_tint(0.5);
|
|
set_clearcoat(1);
|
|
set_clearcoat_gloss(0.5);
|
|
set_anisotropy(0);
|
|
set_height_scale(1);
|
|
set_subsurface_scattering_strength(0);
|
|
set_refraction(0);
|
|
set_refraction_roughness(0);
|
|
set_line_width(1);
|
|
set_point_size(1);
|
|
set_uv1_offset(Vector2(0,0));
|
|
set_uv1_scale(Vector2(1,1));
|
|
set_uv2_offset(Vector2(0,0));
|
|
set_uv2_scale(Vector2(1,1));
|
|
|
|
detail_uv=DETAIL_UV_1;
|
|
blend_mode=BLEND_MODE_MIX;
|
|
detail_blend_mode=BLEND_MODE_MIX;
|
|
depth_draw_mode=DEPTH_DRAW_OPAQUE_ONLY;
|
|
cull_mode=CULL_BACK;
|
|
for(int i=0;i<FLAG_MAX;i++) {
|
|
flags[i]=0;
|
|
}
|
|
diffuse_mode=DIFFUSE_LAMBERT;
|
|
|
|
for(int i=0;i<FEATURE_MAX;i++) {
|
|
features[i]=false;
|
|
}
|
|
|
|
current_key.key=0;
|
|
current_key.invalid_key=1;
|
|
_queue_shader_change();
|
|
}
|
|
|
|
FixedSpatialMaterial::~FixedSpatialMaterial() {
|
|
|
|
if (material_mutex)
|
|
material_mutex->lock();
|
|
|
|
if (shader_map.has(current_key)) {
|
|
shader_map[current_key].users--;
|
|
if (shader_map[current_key].users==0) {
|
|
//deallocate shader, as it's no longer in use
|
|
VS::get_singleton()->free(shader_map[current_key].shader);
|
|
shader_map.erase(current_key);
|
|
}
|
|
|
|
VS::get_singleton()->material_set_shader(_get_material(),RID());
|
|
}
|
|
|
|
|
|
if (material_mutex)
|
|
material_mutex->unlock();
|
|
|
|
}
|