mirror of
https://github.com/Relintai/pandemonium_engine_minimal.git
synced 2024-11-17 22:17:19 +01:00
Removed the sky api.
This commit is contained in:
parent
2703102a81
commit
f166dec796
@ -239,11 +239,6 @@ public:
|
||||
virtual Size2 texture_size_with_proxy(RID p_texture) const { return Size2(); }
|
||||
void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) {}
|
||||
|
||||
/* SKY API */
|
||||
|
||||
RID sky_create() { return RID(); }
|
||||
void sky_set_texture(RID p_sky, RID p_cube_map, int p_radiance_size) {}
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
RID shader_create() { return RID(); }
|
||||
|
@ -2612,115 +2612,6 @@ void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements,
|
||||
state.scene_shader.set_conditional(SceneShaderGLES2::USE_DEPTH_PREPASS, false);
|
||||
}
|
||||
|
||||
void RasterizerSceneGLES2::_draw_sky(RasterizerStorageGLES2::Sky *p_sky, const Projection &p_projection, const Transform &p_transform, bool p_vflip, float p_custom_fov, float p_energy, const Basis &p_sky_orientation) {
|
||||
ERR_FAIL_COND(!p_sky);
|
||||
|
||||
RasterizerStorageGLES2::Texture *tex = storage->texture_owner.getornull(p_sky->panorama);
|
||||
ERR_FAIL_COND(!tex);
|
||||
|
||||
tex = tex->get_ptr(); //resolve for proxies
|
||||
|
||||
WRAPPED_GL_ACTIVE_TEXTURE(GL_TEXTURE0);
|
||||
glBindTexture(tex->target, tex->tex_id);
|
||||
|
||||
glDepthMask(GL_TRUE);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDisable(GL_CULL_FACE);
|
||||
glDisable(GL_BLEND);
|
||||
glDepthFunc(GL_LEQUAL);
|
||||
|
||||
// Camera
|
||||
Projection camera;
|
||||
|
||||
if (p_custom_fov) {
|
||||
float near_plane = p_projection.get_z_near();
|
||||
float far_plane = p_projection.get_z_far();
|
||||
float aspect = p_projection.get_aspect();
|
||||
|
||||
camera.set_perspective(p_custom_fov, aspect, near_plane, far_plane);
|
||||
} else {
|
||||
camera = p_projection;
|
||||
}
|
||||
|
||||
float flip_sign = p_vflip ? -1 : 1;
|
||||
|
||||
// If matrix[2][0] or matrix[2][1] we're dealing with an asymmetrical projection matrix. This is the case for stereoscopic rendering (i.e. VR).
|
||||
// To ensure the image rendered is perspective correct we need to move some logic into the shader. For this the USE_ASYM_PANO option is introduced.
|
||||
// It also means the uv coordinates are ignored in this mode and we don't need our loop.
|
||||
bool asymmetrical = ((camera.matrix[2][0] != 0.0) || (camera.matrix[2][1] != 0.0));
|
||||
|
||||
Vector3 vertices[8] = {
|
||||
Vector3(-1, -1 * flip_sign, 1),
|
||||
Vector3(0, 1, 0),
|
||||
Vector3(1, -1 * flip_sign, 1),
|
||||
Vector3(1, 1, 0),
|
||||
Vector3(1, 1 * flip_sign, 1),
|
||||
Vector3(1, 0, 0),
|
||||
Vector3(-1, 1 * flip_sign, 1),
|
||||
Vector3(0, 0, 0),
|
||||
};
|
||||
|
||||
if (!asymmetrical) {
|
||||
Vector2 vp_he = camera.get_viewport_half_extents();
|
||||
float zn;
|
||||
zn = p_projection.get_z_near();
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
Vector3 uv = vertices[i * 2 + 1];
|
||||
uv.x = (uv.x * 2.0 - 1.0) * vp_he.x;
|
||||
uv.y = -(uv.y * 2.0 - 1.0) * vp_he.y;
|
||||
uv.z = -zn;
|
||||
vertices[i * 2 + 1] = p_transform.basis.xform(uv).normalized();
|
||||
vertices[i * 2 + 1].z = -vertices[i * 2 + 1].z;
|
||||
}
|
||||
}
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, state.sky_verts);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3) * 8, vertices, GL_DYNAMIC_DRAW);
|
||||
|
||||
// bind sky vertex array....
|
||||
glVertexAttribPointer(RS::ARRAY_VERTEX, 3, GL_FLOAT, GL_FALSE, sizeof(Vector3) * 2, nullptr);
|
||||
glVertexAttribPointer(RS::ARRAY_TEX_UV, 3, GL_FLOAT, GL_FALSE, sizeof(Vector3) * 2, CAST_INT_TO_UCHAR_PTR(sizeof(Vector3)));
|
||||
glEnableVertexAttribArray(RS::ARRAY_VERTEX);
|
||||
glEnableVertexAttribArray(RS::ARRAY_TEX_UV);
|
||||
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_ASYM_PANO, asymmetrical);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_PANORAMA, !asymmetrical);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_MULTIPLIER, true);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_CUBEMAP, false);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_COPY_SECTION, false);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_CUSTOM_ALPHA, false);
|
||||
if (storage->frame.current_rt) {
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::OUTPUT_LINEAR, storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_KEEP_3D_LINEAR]);
|
||||
} else {
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::OUTPUT_LINEAR, false);
|
||||
}
|
||||
storage->shaders.copy.bind();
|
||||
storage->shaders.copy.set_uniform(CopyShaderGLES2::MULTIPLIER, p_energy);
|
||||
|
||||
// don't know why but I always have problems setting a uniform mat3, so we're using a transform
|
||||
storage->shaders.copy.set_uniform(CopyShaderGLES2::SKY_TRANSFORM, Transform(p_sky_orientation, Vector3(0.0, 0.0, 0.0)).affine_inverse());
|
||||
|
||||
if (asymmetrical) {
|
||||
// pack the bits we need from our projection matrix
|
||||
storage->shaders.copy.set_uniform(CopyShaderGLES2::ASYM_PROJ, camera.matrix[2][0], camera.matrix[0][0], camera.matrix[2][1], camera.matrix[1][1]);
|
||||
///@TODO I couldn't get mat3 + p_transform.basis to work, that would be better here.
|
||||
storage->shaders.copy.set_uniform(CopyShaderGLES2::PANO_TRANSFORM, p_transform);
|
||||
}
|
||||
|
||||
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
||||
|
||||
glDisableVertexAttribArray(RS::ARRAY_VERTEX);
|
||||
glDisableVertexAttribArray(RS::ARRAY_TEX_UV);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_ASYM_PANO, false);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_PANORAMA, false);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_MULTIPLIER, false);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_CUBEMAP, false);
|
||||
storage->shaders.copy.set_conditional(CopyShaderGLES2::OUTPUT_LINEAR, false);
|
||||
}
|
||||
|
||||
void RasterizerSceneGLES2::_post_process(Environment3D *env, const Projection &p_cam_projection) {
|
||||
//copy to front buffer
|
||||
|
||||
@ -3338,7 +3229,7 @@ void RasterizerSceneGLES2::render_scene(const Transform &p_cam_transform, const
|
||||
if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
|
||||
clear_color = Color(0, 0, 0, 0);
|
||||
storage->frame.clear_request = false;
|
||||
} else if (!env || env->bg_mode == RS::ENV_BG_CLEAR_COLOR || env->bg_mode == RS::ENV_BG_SKY) {
|
||||
} else if (!env || env->bg_mode == RS::ENV_BG_CLEAR_COLOR) {
|
||||
if (storage->frame.clear_request) {
|
||||
clear_color = storage->frame.clear_request_color;
|
||||
storage->frame.clear_request = false;
|
||||
@ -3378,17 +3269,10 @@ void RasterizerSceneGLES2::render_scene(const Transform &p_cam_transform, const
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
|
||||
// render sky
|
||||
RasterizerStorageGLES2::Sky *sky = nullptr;
|
||||
GLuint env_radiance_tex = 0;
|
||||
if (env) {
|
||||
switch (env->bg_mode) {
|
||||
case RS::ENV_BG_COLOR_SKY:
|
||||
case RS::ENV_BG_SKY: {
|
||||
sky = storage->sky_owner.getornull(env->sky);
|
||||
|
||||
if (sky) {
|
||||
env_radiance_tex = sky->radiance;
|
||||
}
|
||||
case RS::ENV_BG_COLOR_SKY: {
|
||||
} break;
|
||||
case RS::ENV_BG_CANVAS: {
|
||||
// use screen copy as background
|
||||
@ -3416,13 +3300,6 @@ void RasterizerSceneGLES2::render_scene(const Transform &p_cam_transform, const
|
||||
render_list.sort_by_key(false);
|
||||
_render_render_list(render_list.elements, render_list.element_count, cam_transform, p_cam_projection, p_eye, p_shadow_atlas, env, env_radiance_tex, 0.0, 0.0, reverse_cull, false, false);
|
||||
|
||||
// then draw the sky after
|
||||
if (env && env->bg_mode == RS::ENV_BG_SKY && (!storage->frame.current_rt || !storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT])) {
|
||||
if (sky && sky->panorama.is_valid()) {
|
||||
_draw_sky(sky, p_cam_projection, cam_transform, false, env->sky_custom_fov, env->bg_energy, env->sky_orientation);
|
||||
}
|
||||
}
|
||||
|
||||
if (storage->frame.current_rt && state.used_screen_texture) {
|
||||
//copy screen texture
|
||||
|
||||
|
@ -742,8 +742,6 @@ public:
|
||||
bool p_alpha_pass,
|
||||
bool p_shadow);
|
||||
|
||||
void _draw_sky(RasterizerStorageGLES2::Sky *p_sky, const Projection &p_projection, const Transform &p_transform, bool p_vflip, float p_custom_fov, float p_energy, const Basis &p_sky_orientation);
|
||||
|
||||
_FORCE_INLINE_ void _set_cull(bool p_front, bool p_disabled, bool p_reverse_cull);
|
||||
_FORCE_INLINE_ bool _setup_material(RasterizerStorageGLES2::Material *p_material, bool p_alpha_pass, Size2i p_skeleton_tex_size = Size2i(0, 0));
|
||||
_FORCE_INLINE_ void _setup_geometry(RenderList::Element *p_element, RasterizerStorageGLES2::Skeleton *p_skeleton);
|
||||
|
@ -1151,169 +1151,6 @@ RID RasterizerStorageGLES2::texture_create_radiance_cubemap(RID p_source, int p_
|
||||
return RID();
|
||||
}
|
||||
|
||||
RID RasterizerStorageGLES2::sky_create() {
|
||||
Sky *sky = memnew(Sky);
|
||||
sky->radiance = 0;
|
||||
return sky_owner.make_rid(sky);
|
||||
}
|
||||
|
||||
void RasterizerStorageGLES2::sky_set_texture(RID p_sky, RID p_panorama, int p_radiance_size) {
|
||||
Sky *sky = sky_owner.getornull(p_sky);
|
||||
ERR_FAIL_COND(!sky);
|
||||
|
||||
if (sky->panorama.is_valid()) {
|
||||
sky->panorama = RID();
|
||||
glDeleteTextures(1, &sky->radiance);
|
||||
sky->radiance = 0;
|
||||
}
|
||||
|
||||
sky->panorama = p_panorama;
|
||||
if (!sky->panorama.is_valid()) {
|
||||
return; // the panorama was cleared
|
||||
}
|
||||
|
||||
Texture *texture = texture_owner.getornull(sky->panorama);
|
||||
if (!texture) {
|
||||
sky->panorama = RID();
|
||||
ERR_FAIL_COND(!texture);
|
||||
}
|
||||
|
||||
texture = texture->get_ptr(); //resolve for proxies
|
||||
|
||||
// glBindVertexArray(0) and more
|
||||
{
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
||||
glDisable(GL_CULL_FACE);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
glDisable(GL_BLEND);
|
||||
|
||||
for (int i = 0; i < RS::ARRAY_MAX - 1; i++) {
|
||||
glDisableVertexAttribArray(i);
|
||||
}
|
||||
}
|
||||
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE0);
|
||||
glBindTexture(texture->target, texture->tex_id);
|
||||
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //need this for proper sampling
|
||||
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE1);
|
||||
glBindTexture(GL_TEXTURE_2D, resources.radical_inverse_vdc_cache_tex);
|
||||
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
|
||||
// New cubemap that will hold the mipmaps with different roughness values
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE2);
|
||||
glGenTextures(1, &sky->radiance);
|
||||
glBindTexture(GL_TEXTURE_CUBE_MAP, sky->radiance);
|
||||
|
||||
int size = p_radiance_size / 2; //divide by two because its a cubemap (this is an approximation because GLES3 uses a dual paraboloid)
|
||||
|
||||
GLenum internal_format = GL_RGB;
|
||||
GLenum format = GL_RGB;
|
||||
GLenum type = GL_UNSIGNED_BYTE;
|
||||
|
||||
// Set the initial (empty) mipmaps
|
||||
// Mobile hardware (PowerVR specially) prefers this approach,
|
||||
// the previous approach with manual lod levels kills the game.
|
||||
for (int i = 0; i < 6; i++) {
|
||||
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internal_format, size, size, 0, format, type, nullptr);
|
||||
}
|
||||
|
||||
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
|
||||
|
||||
// No filters for now
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
|
||||
// Framebuffer
|
||||
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, resources.mipmap_blur_fbo);
|
||||
|
||||
int mipmaps = 6;
|
||||
int lod = 0;
|
||||
int mm_level = mipmaps;
|
||||
size = p_radiance_size / 2;
|
||||
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES2::USE_SOURCE_PANORAMA, true);
|
||||
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES2::USE_DIRECT_WRITE, true);
|
||||
shaders.cubemap_filter.bind();
|
||||
|
||||
// third, render to the framebuffer using separate textures, then copy to mipmaps
|
||||
while (size >= 1) {
|
||||
//make framebuffer size the texture size, need to use a separate texture for compatibility
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE3);
|
||||
glBindTexture(GL_TEXTURE_2D, resources.mipmap_blur_color);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size, size, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, resources.mipmap_blur_color, 0);
|
||||
|
||||
if (lod == 1) {
|
||||
// We set USE_DIRECT_WRITE to false for LOD levels 1 and up, so the shader will properly
|
||||
// filter the roughness instead of just copying 1:1 from the source panorama.
|
||||
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES2::USE_DIRECT_WRITE, false);
|
||||
shaders.cubemap_filter.bind();
|
||||
}
|
||||
glViewport(0, 0, size, size);
|
||||
bind_quad_array();
|
||||
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE2); //back to panorama
|
||||
|
||||
for (int i = 0; i < 6; i++) {
|
||||
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES2::FACE_ID, i);
|
||||
|
||||
float roughness = mm_level >= 0 ? lod / (float)(mipmaps - 1) : 1;
|
||||
roughness = MIN(1.0, roughness); //keep max at 1
|
||||
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES2::ROUGHNESS, roughness);
|
||||
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES2::Z_FLIP, false);
|
||||
|
||||
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
||||
|
||||
glCopyTexSubImage2D(_cube_side_enum[i], lod, 0, 0, 0, 0, size, size);
|
||||
}
|
||||
|
||||
size >>= 1;
|
||||
|
||||
mm_level--;
|
||||
|
||||
lod++;
|
||||
}
|
||||
|
||||
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES2::USE_SOURCE_PANORAMA, false);
|
||||
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES2::USE_DIRECT_WRITE, false);
|
||||
|
||||
// restore ranges
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE2); //back to panorama
|
||||
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE3); //back to panorama
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE1);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE0);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
|
||||
//reset flags on Sky Texture that may have changed
|
||||
texture_set_flags(sky->panorama, texture->flags);
|
||||
|
||||
// Framebuffer did its job. thank mr framebuffer
|
||||
gl_wrapper.gl_active_texture(GL_TEXTURE0); //back to panorama
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES2::system_fbo);
|
||||
}
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
RID RasterizerStorageGLES2::shader_create() {
|
||||
@ -5634,13 +5471,6 @@ bool RasterizerStorageGLES2::free(RID p_rid) {
|
||||
texture_owner.free(p_rid);
|
||||
memdelete(t);
|
||||
|
||||
return true;
|
||||
} else if (sky_owner.owns(p_rid)) {
|
||||
Sky *sky = sky_owner.get(p_rid);
|
||||
sky_set_texture(p_rid, RID(), 256);
|
||||
sky_owner.free(p_rid);
|
||||
memdelete(sky);
|
||||
|
||||
return true;
|
||||
} else if (shader_owner.owns(p_rid)) {
|
||||
Shader *shader = shader_owner.get(p_rid);
|
||||
|
@ -381,19 +381,6 @@ public:
|
||||
|
||||
virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable);
|
||||
|
||||
/* SKY API */
|
||||
|
||||
struct Sky : public RID_Data {
|
||||
RID panorama;
|
||||
GLuint radiance;
|
||||
int radiance_size;
|
||||
};
|
||||
|
||||
mutable RID_Owner<Sky> sky_owner;
|
||||
|
||||
virtual RID sky_create();
|
||||
virtual void sky_set_texture(RID p_sky, RID p_panorama, int p_radiance_size);
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
struct Material;
|
||||
|
@ -235,11 +235,6 @@ public:
|
||||
virtual Size2 texture_size_with_proxy(RID p_texture) const = 0;
|
||||
virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) = 0;
|
||||
|
||||
/* SKY API */
|
||||
|
||||
virtual RID sky_create() = 0;
|
||||
virtual void sky_set_texture(RID p_sky, RID p_cube_map, int p_radiance_size) = 0;
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
virtual RID shader_create() = 0;
|
||||
|
@ -182,11 +182,6 @@ public:
|
||||
|
||||
BIND2(texture_set_force_redraw_if_visible, RID, bool)
|
||||
|
||||
/* SKY API */
|
||||
|
||||
BIND0R(RID, sky_create)
|
||||
BIND3(sky_set_texture, RID, RID, int)
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
BIND0R(RID, shader_create)
|
||||
|
@ -141,7 +141,6 @@ void RenderingServerWrapMT::finish() {
|
||||
}
|
||||
|
||||
texture_free_cached_ids();
|
||||
sky_free_cached_ids();
|
||||
shader_free_cached_ids();
|
||||
material_free_cached_ids();
|
||||
mesh_free_cached_ids();
|
||||
|
@ -108,11 +108,6 @@ public:
|
||||
|
||||
FUNC2(texture_set_force_redraw_if_visible, RID, bool)
|
||||
|
||||
/* SKY API */
|
||||
|
||||
FUNCRID(sky)
|
||||
FUNC3(sky_set_texture, RID, RID, int)
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
FUNCRID(shader)
|
||||
|
@ -1862,10 +1862,7 @@ void RenderingServer::_bind_methods() {
|
||||
|
||||
ClassDB::bind_method(D_METHOD("texture_debug_usage"), &RenderingServer::_texture_debug_usage_bind);
|
||||
ClassDB::bind_method(D_METHOD("textures_keep_original", "enable"), &RenderingServer::textures_keep_original);
|
||||
#ifndef _3D_DISABLED
|
||||
ClassDB::bind_method(D_METHOD("sky_create"), &RenderingServer::sky_create);
|
||||
ClassDB::bind_method(D_METHOD("sky_set_texture", "sky", "cube_map", "radiance_size"), &RenderingServer::sky_set_texture);
|
||||
#endif
|
||||
|
||||
ClassDB::bind_method(D_METHOD("shader_create"), &RenderingServer::shader_create);
|
||||
ClassDB::bind_method(D_METHOD("shader_set_code", "shader", "code"), &RenderingServer::shader_set_code);
|
||||
ClassDB::bind_method(D_METHOD("shader_get_code", "shader"), &RenderingServer::shader_get_code);
|
||||
@ -2437,7 +2434,6 @@ void RenderingServer::_bind_methods() {
|
||||
|
||||
BIND_ENUM_CONSTANT(ENV_BG_CLEAR_COLOR);
|
||||
BIND_ENUM_CONSTANT(ENV_BG_COLOR);
|
||||
BIND_ENUM_CONSTANT(ENV_BG_SKY);
|
||||
BIND_ENUM_CONSTANT(ENV_BG_COLOR_SKY);
|
||||
BIND_ENUM_CONSTANT(ENV_BG_CANVAS);
|
||||
BIND_ENUM_CONSTANT(ENV_BG_KEEP);
|
||||
|
@ -177,11 +177,6 @@ public:
|
||||
virtual void texture_set_proxy(RID p_proxy, RID p_base) = 0;
|
||||
virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) = 0;
|
||||
|
||||
/* SKY API */
|
||||
|
||||
virtual RID sky_create() = 0;
|
||||
virtual void sky_set_texture(RID p_sky, RID p_cube_map, int p_radiance_size) = 0;
|
||||
|
||||
/* SHADER API */
|
||||
|
||||
enum ShaderMode {
|
||||
@ -653,7 +648,6 @@ public:
|
||||
|
||||
ENV_BG_CLEAR_COLOR,
|
||||
ENV_BG_COLOR,
|
||||
ENV_BG_SKY,
|
||||
ENV_BG_COLOR_SKY,
|
||||
ENV_BG_CANVAS,
|
||||
ENV_BG_KEEP,
|
||||
|
Loading…
Reference in New Issue
Block a user