RasterizerCanvasGLES3::~RasterizerCanvasGLES3() {

GLES3::MaterialStorage *material_storage = GLES3::MaterialStorage::get_singleton();

GLES3::MaterialStorage::get_singleton()->shaders.canvas_shader.version_free(state.canvas_shader_default_version);

material_storage->material_free(default_canvas_group_material);

material_storage->shader_free(default_canvas_group_shader);

#else

float_texture_supported = extensions.has("GL_ARB_texture_float") || extensions.has("GL_OES_texture_float");

etc2_supported = true;

s3tc_supported = extensions.has("GL_EXT_texture_compression_dxt1") || extensions.has("GL_EXT_texture_compression_s3tc") || extensions.has("WEBGL_compressed_texture_s3tc");

rgtc_supported = extensions.has("GL_EXT_texture_compression_rgtc") || extensions.has("GL_ARB_texture_compression_rgtc") || extensions.has("EXT_texture_compression_rgtc");

#endif

return shader->code;

}

GLES3::Shader *shader = shader_owner.get_or_null(p_shader);

ERR_FAIL_COND(!shader);

if (shader->data) {

}

}

return true; //by default everything casts shadows

}

GLES3::Material *material = material_owner.get_or_null(p_material);

ERR_FAIL_COND(!material);

if (material->shader && material->shader->data) {

material->shader->data->get_instance_param_list(r_parameters);

if (material->next_pass.is_valid()) {

}

}

}

}

}

HashMap<int, StringName> order;

for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {

}

}

RBMap<int, StringName> order;

for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {

}

}

RBMap<int, StringName> order;

for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {

struct ShaderData {

virtual void set_code(const String &p_Code) = 0;

virtual void set_default_texture_param(const StringName &p_name, RID p_texture, int p_index) = 0;

virtual void get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const = 0;

virtual bool is_param_texture(const StringName &p_param) const = 0;

virtual void set_code(const String &p_Code);

virtual void set_default_texture_param(const StringName &p_name, RID p_texture, int p_index);

virtual void get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const;

virtual bool is_param_texture(const StringName &p_param) const;

virtual void set_code(const String &p_Code);

virtual void set_default_texture_param(const StringName &p_name, RID p_texture, int p_index);

virtual void get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const;

virtual bool is_param_texture(const StringName &p_param) const;

virtual bool is_animated() const;

virtual void set_code(const String &p_Code);

virtual void set_default_texture_param(const StringName &p_name, RID p_texture, int p_index);

virtual void get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const;

virtual bool is_param_texture(const StringName &p_param) const;

virtual void shader_set_code(RID p_shader, const String &p_code) override;

virtual void shader_set_path_hint(RID p_shader, const String &p_path) override;

virtual String shader_get_code(RID p_shader) const override;

virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture, int p_index) override;

virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name, int p_index) const override;

virtual bool material_is_animated(RID p_material) override;

virtual bool material_casts_shadows(RID p_material) override;

virtual void material_update_dependency(RID p_material, DependencyTracker *p_instance) override;

int s = getaddrinfo(p_hostname.utf8().get_data(), nullptr, &hints, &result);

if (s != 0) {

return;

}

if (result == nullptr || result->ai_addr == nullptr) {

if (result) {

freeaddrinfo(result);

}

}

RID id = texture_owner.make_rid(texture);

if (p_data.size()) {

for (uint32_t i = 0; i < image_create_info.arrayLayers; i++) {

texture.owner = p_with_texture;

RID id = texture_owner.make_rid(texture);

_add_dependency(id, p_with_texture);

return id;

}

RID id = texture_owner.make_rid(texture);

return id;

}

texture.owner = p_with_texture;

RID id = texture_owner.make_rid(texture);

_add_dependency(id, p_with_texture);

return id;

passes.push_back(pass);

return framebuffer_format_create_multipass(p_format, passes, p_view_count);

}

_THREAD_SAFE_METHOD_

FramebufferFormatKey key;

framebuffer.size = p_size;

framebuffer.view_count = 1;

}

RID RenderingDeviceVulkan::framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check, uint32_t p_view_count) {

return framebuffer_create_multipass(p_texture_attachments, passes, p_format_check, p_view_count);

}

_THREAD_SAFE_METHOD_

Vector<AttachmentFormat> attachments;

framebuffer.view_count = p_view_count;

RID id = framebuffer_owner.make_rid(framebuffer);

for (int i = 0; i < p_texture_attachments.size(); i++) {

if (p_texture_attachments[i].is_valid()) {

return framebuffer->format_id;

}

/*****************/

/**** SAMPLER ****/

/*****************/

VkResult res = vkCreateSampler(device, &sampler_create_info, nullptr, &sampler);

ERR_FAIL_COND_V_MSG(res, RID(), "vkCreateSampler failed with error " + itos(res) + ".");

}

/**********************/

_buffer_memory_barrier(buffer.buffer, 0, data_size, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, false);

}

}

// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated

_buffer_update(&index_buffer, 0, r, data_size);

_buffer_memory_barrier(index_buffer.buffer, 0, data_size, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_INDEX_READ_BIT, false);

}

}

RID RenderingDeviceVulkan::index_array_create(RID p_index_buffer, uint32_t p_index_offset, uint32_t p_index_count) {

ERR_FAIL_V_MSG(RID(), error_text);

}

}

uint32_t RenderingDeviceVulkan::shader_get_vertex_input_attribute_mask(RID p_shader) {

_buffer_update(&buffer, 0, r, data_size);

_buffer_memory_barrier(buffer.buffer, 0, data_size, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_UNIFORM_READ_BIT, false);

}

}

RID RenderingDeviceVulkan::storage_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data, uint32_t p_usage) {

}

//allocate the view

}

RenderingDeviceVulkan::DescriptorPool *RenderingDeviceVulkan::_descriptor_pool_allocate(const DescriptorPoolKey &p_key) {

uniform_set.shader_id = p_shader;

RID id = uniform_set_owner.make_rid(uniform_set);

//add dependencies

_add_dependency(id, p_shader);

for (uint32_t i = 0; i < uniform_count; i++) {

return uniform_set_owner.owns(p_uniform_set);

}

UniformSet *us = uniform_set_owner.get_or_null(p_uniform_set);

ERR_FAIL_COND(!us);

us->invalidated_callback = p_callback;

#endif

//create ID to associate with this pipeline

RID id = render_pipeline_owner.make_rid(pipeline);

//now add all the dependencies

_add_dependency(id, p_shader);

return id;

//create ID to associate with this pipeline

RID id = compute_pipeline_owner.make_rid(pipeline);

//now add all the dependencies

_add_dependency(id, p_shader);

return id;

} else if (framebuffer_owner.owns(p_id)) {

Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_id);

frames[frame].framebuffers_to_dispose_of.push_back(*framebuffer);

framebuffer_owner.free(p_id);

} else if (sampler_owner.owns(p_id)) {

VkSampler *sampler = sampler_owner.get_or_null(p_id);

uint32_t storage_mask = 0;

Vector<RID> texture_ids;

struct Version {

VkFramebuffer framebuffer = VK_NULL_HANDLE;

LocalVector<AttachableTexture> attachable_textures; //used for validation

Vector<Texture *> mutable_sampled_textures; //used for layout change

Vector<Texture *> mutable_storage_textures; //used for layout change

void *invalidated_callback_userdata = nullptr;

};

/*********************/

virtual FramebufferFormatID framebuffer_format_create(const Vector<AttachmentFormat> &p_format, uint32_t p_view_count = 1);

virtual FramebufferFormatID framebuffer_format_create_empty(TextureSamples p_samples = TEXTURE_SAMPLES_1);

virtual TextureSamples framebuffer_format_get_texture_samples(FramebufferFormatID p_format, uint32_t p_pass = 0);

virtual RID framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check = INVALID_ID, uint32_t p_view_count = 1);

virtual RID framebuffer_create_empty(const Size2i &p_size, TextureSamples p_samples = TEXTURE_SAMPLES_1, FramebufferFormatID p_format_check = INVALID_ID);

virtual FramebufferFormatID framebuffer_get_format(RID p_framebuffer);

virtual RID uniform_set_create(const Vector<Uniform> &p_uniforms, RID p_shader, uint32_t p_shader_set);

virtual bool uniform_set_is_valid(RID p_uniform_set);

virtual Error buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data, uint32_t p_post_barrier = BARRIER_MASK_ALL); //works for any buffer

virtual Error buffer_clear(RID p_buffer, uint32_t p_offset, uint32_t p_size, uint32_t p_post_barrier = BARRIER_MASK_ALL);