mirror of
https://github.com/korenkonder/ReDIVA.git
synced 2026-10-05 05:07:56 +03:00
617 lines
20 KiB
C++
617 lines
20 KiB
C++
/*
|
|
by korenkonder
|
|
GitHub/GitLab: korenkonder
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "../KKdLib/default.hpp"
|
|
#include "../KKdLib/time.hpp"
|
|
#include "../KKdLib/vec.hpp"
|
|
#include "GL/array_buffer.hpp"
|
|
#include "GL/shader_storage_buffer.hpp"
|
|
#include "GL/uniform_buffer.hpp"
|
|
#include "light_param/face.hpp"
|
|
#include "light_param/fog.hpp"
|
|
#include "light_param/light.hpp"
|
|
#include "light_param/wind.hpp"
|
|
#include "mdl/disp_manager.hpp"
|
|
#include "camera.hpp"
|
|
#include "render.hpp"
|
|
#include "render_manager.hpp"
|
|
#include "render_texture.hpp"
|
|
#include <unordered_map>
|
|
|
|
#define MATRIX_BUFFER_COUNT 320
|
|
|
|
enum render_data_flags {
|
|
RENDER_DATA_SHADER_UPDATE = 0x01,
|
|
RENDER_DATA_SCENE_UPDATE = 0x02,
|
|
RENDER_DATA_BATCH_UPDATE = 0x04,
|
|
};
|
|
|
|
struct draw_state_stats {
|
|
int32_t object_draw_count;
|
|
int32_t object_translucent_draw_count;
|
|
int32_t object_reflect_draw_count;
|
|
int32_t field_C;
|
|
int32_t field_10;
|
|
int32_t draw_count;
|
|
int32_t draw_triangle_count;
|
|
int32_t field_1C;
|
|
|
|
draw_state_stats();
|
|
|
|
void reset();
|
|
};
|
|
|
|
struct global_material_struct {
|
|
float_t bump_depth;
|
|
float_t intensity;
|
|
float_t reflectivity;
|
|
float_t reflect_uv_scale;
|
|
float_t refract_uv_scale;
|
|
|
|
global_material_struct();
|
|
};
|
|
|
|
struct draw_state {
|
|
struct render_data {
|
|
int32_t shader_index;
|
|
bool self_shadow;
|
|
bool shadow;
|
|
bool blend;
|
|
bool cull_front;
|
|
int32_t field_8;
|
|
draw_state_stats stats;
|
|
|
|
render_data();
|
|
};
|
|
|
|
draw_state_stats stats_prev;
|
|
bool wireframe;
|
|
bool wireframe_overlay;
|
|
bool shader_debug_flag;
|
|
bool use_global_material;
|
|
bool fog_height;
|
|
bool ex_data_mat;
|
|
bool shader;
|
|
int32_t shader_index;
|
|
int32_t show;
|
|
global_material_struct global_material;
|
|
int32_t field_68;
|
|
float_t fresnel;
|
|
render_data rend_data[GL_REND_STATE_COUNT];
|
|
|
|
draw_state();
|
|
|
|
bool get_use_global_material();
|
|
void stats_update();
|
|
void set_fog_height(bool value);
|
|
void set_use_global_material(bool value);
|
|
};
|
|
|
|
struct sss_data {
|
|
bool init_data;
|
|
bool enable;
|
|
bool npr_contour;
|
|
RenderTexture textures[4];
|
|
vec4 param;
|
|
|
|
sss_data();
|
|
~sss_data();
|
|
|
|
void free();
|
|
void init();
|
|
void set_texture(struct p_gl_rend_state& p_gl_rend_st, int32_t texture_index);
|
|
};
|
|
|
|
struct light_proj {
|
|
bool enable;
|
|
RenderTexture shadow_texture[2];
|
|
RenderTexture draw_texture;
|
|
uint32_t texture_id;
|
|
|
|
light_proj(int32_t width, int32_t height);
|
|
~light_proj();
|
|
|
|
void resize(int32_t width, int32_t height);
|
|
bool set(struct render_data_context& rend_data_ctx, cam_data& cam);
|
|
|
|
static bool set_mat(struct render_data_context& rend_data_ctx, cam_data& cam, bool set_mat);
|
|
};
|
|
|
|
struct camera_blur_shader_data {
|
|
vec4 g_transform[4];
|
|
};
|
|
|
|
struct contour_coef_shader_data {
|
|
vec4 g_contour;
|
|
vec4 g_near_far;
|
|
};
|
|
|
|
struct contour_params_shader_data {
|
|
vec4 g_near_far;
|
|
};
|
|
|
|
struct filter_scene_shader_data {
|
|
vec4 g_transform;
|
|
vec4 g_texcoord;
|
|
};
|
|
|
|
struct exposure_measure_shader_data {
|
|
vec4 g_spot_weight;
|
|
vec4 g_spot_coefficients[32];
|
|
};
|
|
|
|
struct gaussian_coef_shader_data {
|
|
vec4 g_coef[8];
|
|
};
|
|
|
|
struct esm_filter_batch_shader_data {
|
|
vec4 g_params;
|
|
vec4 g_gauss[2];
|
|
};
|
|
|
|
struct imgfilter_batch_shader_data {
|
|
vec4 g_texture_lod;
|
|
vec4 g_color_scale;
|
|
vec4 g_color_offset;
|
|
};
|
|
|
|
struct glass_eye_batch_shader_data {
|
|
vec4 g_ellipsoid_radius;
|
|
vec4 g_ellipsoid_scale;
|
|
vec4 g_tex_model_param;
|
|
vec4 g_tex_offset; //xy=tex_offset, zw=highlight_tex_offset
|
|
vec4 g_eb_radius;
|
|
vec4 g_eb_tex_model_param;
|
|
vec4 g_fresnel; //x=1-((n_1-n_2)/(n_2-n_1))^2, y=((n_1-n_2)/(n_2-n_1))^2, zw=unused
|
|
vec4 g_refract1; //x=(n_1/n_2)^2, y=1-(n_1/n_2)^2, z=n_1/n_2, w=unused
|
|
vec4 g_refract2; //x=(n_2/n_1)^2, y=1-(n_2/n_1)^2, z=n_2/n_1, w=unused
|
|
vec4 g_iris_radius;
|
|
vec4 g_cornea_radius;
|
|
vec4 g_pupil_radius;
|
|
vec4 g_tex_scale; //xy=tex_scale, z=trsmit_coef, w=lens_depth
|
|
};
|
|
|
|
struct glitter_batch_shader_data {
|
|
vec4 g_mvp[4];
|
|
vec4 g_glitter_blend_color;
|
|
vec4 g_state_material_diffuse;
|
|
vec4 g_state_material_emission;
|
|
};
|
|
|
|
struct quad_shader_data {
|
|
vec4 g_texcoord_modifier;
|
|
vec4 g_texel_size;
|
|
vec4 g_color;
|
|
vec4 g_texture_lod;
|
|
};
|
|
|
|
struct sprite_scene_shader_data {
|
|
mat4 g_transform;
|
|
vec4 g_framebuffer_size;
|
|
};
|
|
|
|
struct sss_filter_gaussian_coef_shader_data {
|
|
vec4 g_param;
|
|
vec4 g_coef[64];
|
|
};
|
|
|
|
struct sun_quad_shader_data {
|
|
vec4 g_transform[4];
|
|
vec4 g_emission;
|
|
};
|
|
|
|
struct tone_map_shader_data {
|
|
vec4 g_exposure;
|
|
vec4 g_flare_coef; //xy=flare_coef, z=light_proj
|
|
vec4 g_fade_color;
|
|
vec4 g_tone_scale; //xyz=tone_scale, w=fade_func
|
|
vec4 g_tone_offset; //xyz=tone_offset, w=inv_tone
|
|
vec4 g_texcoord_transforms[8];
|
|
};
|
|
|
|
struct transparency_batch_shader_data {
|
|
vec4 g_opacity;
|
|
};
|
|
|
|
struct render_data_context;
|
|
|
|
struct render_data {
|
|
struct obj_shader_data {
|
|
struct {
|
|
union {
|
|
struct {
|
|
uint32_t alpha_mask : 1; // bit 0
|
|
uint32_t alpha_test : 1; // bit 1
|
|
uint32_t aniso : 2; // bit 2:3
|
|
uint32_t aet_back : 1; // bit 4
|
|
uint32_t texture_blend : 3; // bit 5:7
|
|
uint32_t unk : 2; // bit 8:9
|
|
uint32_t chara_color : 1; // bit 10
|
|
uint32_t clip_plane : 1; // bit 11
|
|
uint32_t u08 : 1; // bit 12
|
|
uint32_t depth_peel : 1; // bit 13
|
|
uint32_t depth : 1; // bit 14
|
|
uint32_t u0b : 1; // bit 15
|
|
uint32_t alpha_blend : 3; // bit 16:18
|
|
uint32_t ripple_emit : 1; // bit 19
|
|
uint32_t esm_filter : 2; // bit 20:21
|
|
uint32_t exposure : 2; // bit 22:23
|
|
uint32_t scene_fade : 1; // bit 24
|
|
uint32_t fade : 3; // bit 25:27
|
|
uint32_t stage_ambient : 1; // bit 28
|
|
uint32_t flare : 2; // bit 29:30
|
|
} m;
|
|
uint32_t w;
|
|
} x;
|
|
union {
|
|
struct {
|
|
uint32_t fog_stage : 2; // bit 32+0:1
|
|
uint32_t fog_chara : 2; // bit 32+2:3
|
|
uint32_t u16 : 1; // bit 32+4
|
|
uint32_t gauss : 2; // bit 32+5:6
|
|
uint32_t eye_lens : 1; // bit 32+7
|
|
uint32_t image_filter : 3; // bit 32+8:10
|
|
uint32_t instance : 1; // bit 32+11
|
|
uint32_t tone_curve : 1; // bit 32+12
|
|
uint32_t light_proj : 1; // bit 32+13
|
|
uint32_t magnify : 4; // bit 32+14:17
|
|
uint32_t membrane : 2; // bit 32+18:19
|
|
uint32_t mlaa : 2; // bit 32+20:21
|
|
uint32_t mlaa_search : 2; // bit 32+22:23
|
|
uint32_t morph_color : 1; // bit 32+24
|
|
uint32_t morph : 1; // bit 32+25
|
|
uint32_t movie : 2; // bit 32+26:27
|
|
uint32_t u24 : 2; // bit 32+28:29
|
|
uint32_t u25 : 1; // bit 32+30
|
|
uint32_t npr_normal : 1; // bit 32+31
|
|
} m;
|
|
uint32_t w;
|
|
} y;
|
|
union {
|
|
struct {
|
|
uint32_t npr : 1; // bit 64+0
|
|
uint32_t stage_shadow2 : 2; // bit 64+1:2
|
|
uint32_t reflect : 2; // bit 64+3:4
|
|
uint32_t reduce : 4; // bit 64+5:8
|
|
uint32_t chara_shadow : 1; // bit 64+9
|
|
uint32_t chara_shadow2 : 2; // bit 64+10:11
|
|
uint32_t u2d : 3; // bit 64+12:14
|
|
uint32_t u2e : 2; // bit 64+15:16
|
|
uint32_t show_vector : 2; // bit 64+17:18
|
|
uint32_t skinning : 1; // bit 64+19
|
|
uint32_t snow_particle : 2; // bit 64+20:21
|
|
uint32_t specular_ibl : 2; // bit 64+22:23
|
|
uint32_t combiner : 1; // bit 64+24
|
|
uint32_t tex_0_type : 2; // bit 64+25:26
|
|
uint32_t tex_1_type : 2; // bit 64+27:28
|
|
uint32_t sss_filter : 2; // bit 64+29:30
|
|
} m;
|
|
uint32_t w;
|
|
} z;
|
|
union {
|
|
struct {
|
|
uint32_t sss_chara : 1; // bit 96+0
|
|
uint32_t star : 1; // bit 96+1
|
|
uint32_t texture_count : 2; // bit 96+2:3
|
|
uint32_t env_map : 1; // bit 96+4
|
|
uint32_t ripple : 2; // bit 96+5:6
|
|
uint32_t translucency : 1; // bit 96+7
|
|
uint32_t normal : 1; // bit 96+8
|
|
uint32_t transparency : 1; // bit 96+9
|
|
uint32_t water_reflect : 1; // bit 96+10
|
|
uint32_t u40 : 1; // bit 96+11
|
|
uint32_t u41 : 1; // bit 96+12
|
|
uint32_t stage_shadow : 1; // bit 96+13
|
|
uint32_t specular : 1; // bit 96+14
|
|
uint32_t tone_map : 2; // bit 96+15
|
|
uint32_t u45 : 1; // bit 96+16
|
|
} m;
|
|
uint32_t w;
|
|
} w;
|
|
} g_shader_flags;
|
|
|
|
void reset();
|
|
void set_shader_flags(const int32_t* shader_flags);
|
|
};
|
|
|
|
struct obj_scene_data {
|
|
vec4 g_irradiance_r_transforms[4];
|
|
vec4 g_irradiance_g_transforms[4];
|
|
vec4 g_irradiance_b_transforms[4];
|
|
vec4 g_light_env_stage_diffuse;
|
|
vec4 g_light_env_stage_specular;
|
|
vec4 g_light_env_chara_diffuse;
|
|
vec4 g_light_env_chara_ambient;
|
|
vec4 g_light_env_chara_specular;
|
|
vec4 g_light_env_reflect_diffuse;
|
|
vec4 g_light_env_reflect_ambient;
|
|
vec4 g_light_env_proj_diffuse;
|
|
vec4 g_light_env_proj_specular;
|
|
vec4 g_light_env_proj_position;
|
|
vec4 g_light_stage_dir;
|
|
vec4 g_light_stage_diff;
|
|
vec4 g_light_stage_spec;
|
|
vec4 g_light_chara_dir;
|
|
vec4 g_light_chara_spec;
|
|
vec4 g_light_chara_luce;
|
|
vec4 g_light_chara_back;
|
|
vec4 g_light_face_diff;
|
|
vec4 g_chara_color_rim;
|
|
vec4 g_chara_color0;
|
|
vec4 g_chara_color1;
|
|
vec4 g_chara_f_dir;
|
|
vec4 g_chara_f_ambient;
|
|
vec4 g_chara_f_diffuse;
|
|
vec4 g_chara_tc_param;
|
|
vec4 g_fog_depth_color;
|
|
vec4 g_fog_height_params; //x=density, y=start, z=end, w=1/(end-start)
|
|
vec4 g_fog_height_color;
|
|
vec4 g_fog_bump_params; //x=density, y=start, z=end, w=1/(end-start)
|
|
vec4 g_fog_state_params; //x=density, y=start, z=end, w=1/(end-start)
|
|
vec4 g_normal_tangent_transforms[3];
|
|
vec4 g_esm_param;
|
|
vec4 g_self_shadow_receivers[6];
|
|
vec4 g_shadow_ambient;
|
|
vec4 g_shadow_ambient1;
|
|
vec4 g_framebuffer_size;
|
|
vec4 g_light_reflect_dir;
|
|
vec4 g_clip_plane;
|
|
vec4 g_npr_cloth_spec_color;
|
|
vec4 g_view[3];
|
|
vec4 g_view_inverse[3];
|
|
vec4 g_projection_view[4];
|
|
vec4 g_view_position;
|
|
vec4 g_light_projection[4];
|
|
|
|
void reset();
|
|
};
|
|
|
|
struct obj_batch_data {
|
|
vec4 g_transforms[4];
|
|
vec4 g_worlds[3];
|
|
vec4 g_worlds_invtrans[3];
|
|
vec4 g_worldview[3];
|
|
vec4 g_worldview_inverse[3];
|
|
vec4 g_joint[3];
|
|
vec4 g_joint_inverse[3];
|
|
vec4 g_texcoord_transforms[4];
|
|
vec4 g_blend_color;
|
|
vec4 g_offset_color;
|
|
vec4 g_material_state_diffuse;
|
|
vec4 g_material_state_ambient;
|
|
vec4 g_material_state_emission;
|
|
vec4 g_material_state_shininess;
|
|
vec4 g_material_state_specular;
|
|
vec4 g_fresnel_coefficients;
|
|
vec4 g_texture_color_coefficients;
|
|
vec4 g_texture_color_offset;
|
|
vec4 g_texture_specular_coefficients;
|
|
vec4 g_texture_specular_offset;
|
|
vec4 g_shininess;
|
|
vec4 g_max_alpha;
|
|
vec4 g_morph_weight;
|
|
vec4 g_sss_param;
|
|
vec4 g_bump_depth;
|
|
vec4 g_intensity;
|
|
vec4 g_reflect_uv_scale;
|
|
|
|
void reset();
|
|
};
|
|
|
|
struct obj_skinning_data {
|
|
vec4 g_joint_transforms[768];
|
|
};
|
|
|
|
render_data_flags flags;
|
|
cam_data cam;
|
|
mat4 inv_view_mat;
|
|
int32_t shader_index;
|
|
uniform_value shader_flags;
|
|
obj_shader_data buffer_shader_data;
|
|
obj_scene_data buffer_scene_data;
|
|
obj_batch_data buffer_batch_data;
|
|
obj_skinning_data buffer_skinning_data;
|
|
GL::UniformBuffer buffer_shader;
|
|
GL::UniformBuffer buffer_scene;
|
|
GL::UniformBuffer buffer_batch;
|
|
GL::UniformBuffer buffer_skinning_ubo;
|
|
GL::ShaderStorageBuffer buffer_skinning;
|
|
|
|
void init();
|
|
void free();
|
|
void set_skinning_data(struct p_gl_rend_state& p_gl_rend_st, const mat4* mats, int32_t count);
|
|
void set_state(struct p_gl_rend_state& p_gl_rend_st);
|
|
void set_shader(uint32_t index);
|
|
};
|
|
|
|
struct render_data_context {
|
|
struct fog_params {
|
|
vec4 depth_color;
|
|
vec4 height_params;
|
|
vec4 height_color;
|
|
vec4 bump_params;
|
|
float_t density;
|
|
float_t start;
|
|
float_t end;
|
|
};
|
|
|
|
p_gl_rend_state state;
|
|
int32_t index;
|
|
render_data& data;
|
|
uniform_value& shader_flags;
|
|
|
|
render_data_context(int32_t index);
|
|
|
|
void get_scene_fog_params(render_data_context::fog_params& value);
|
|
void get_scene_light(vec4* light_env_stage_diffuse,
|
|
vec4* light_env_stage_specular, vec4* light_chara_dir, vec4* light_chara_luce,
|
|
vec4* light_env_chara_diffuse, vec4* light_env_chara_specular);
|
|
void reset_shader_flags();
|
|
void set_batch_alpha_threshold(const float_t value);
|
|
void set_batch_blend_color_offset_color(const vec4& blend_color, const vec4& offset_color);
|
|
void set_batch_material_color(const vec4& diffuse, const vec4& ambient,
|
|
const vec4& emission, const float_t material_shininess, const vec4& specular,
|
|
const vec4& fresnel_coefficients, const vec4& texture_color_coefficients,
|
|
const vec4& texture_color_offset, const vec4& texture_specular_coefficients,
|
|
const vec4& texture_specular_offset, const float_t shininess);
|
|
void set_batch_material_color_emission(const vec4& emission);
|
|
void set_batch_material_parameter(const vec4* specular, const vec4& bump_depth,
|
|
const vec4& intensity, const float_t reflect_uv_scale, const float_t refract_uv_scale);
|
|
void set_batch_min_alpha(const float_t value);
|
|
void set_batch_morph_weight(const float_t value);
|
|
void set_batch_scene_camera(const cam_data& cam);
|
|
void set_batch_sss_param(const vec4& sss_param);
|
|
void set_batch_texcoord_transforms(const mat4 mats[2]);
|
|
void set_batch_worlds(const mat4& mat);
|
|
void set_glitter_render_data_state();
|
|
void set_render_data_state();
|
|
void set_scene_fog_params(const render_data_context::fog_params& value);
|
|
void set_scene_framebuffer_size(const int32_t width, const int32_t height,
|
|
const int32_t render_width, const int32_t render_height);
|
|
void set_scene_light(const mat4& irradiance_r_transforms, const mat4& irradiance_g_transforms,
|
|
const mat4& irradiance_b_transforms, const vec4& light_env_stage_diffuse,
|
|
const vec4& light_env_stage_specular, const vec4& light_env_chara_diffuse,
|
|
const vec4& light_env_chara_ambient, const vec4& light_env_chara_specular,
|
|
const vec4& light_env_reflect_diffuse, const vec4& light_env_reflect_ambient,
|
|
const vec4& light_env_proj_diffuse, const vec4& light_env_proj_specular,
|
|
const vec4& light_env_proj_position, const vec4& light_stage_dir, const vec4& light_stage_diff,
|
|
const vec4& light_stage_spec, const vec4& light_chara_dir, const vec4& light_chara_spec,
|
|
const vec4& light_chara_luce, const vec4& light_chara_back, const vec4& light_face_diff,
|
|
const vec4& chara_color0, const vec4& chara_color1, const vec4& chara_f_dir, const vec4& chara_f_ambient,
|
|
const vec4& chara_f_diffuse, const vec4& chara_tc_param, const mat4& normal_tangent_transforms,
|
|
const vec4& light_reflect_dir, const vec4& clip_plane, const vec4& npr_cloth_spec_color);
|
|
void set_scene_light_projection(const mat4& light_projection);
|
|
void set_scene_shadow_params(const float_t esm_param,
|
|
const mat4 mats[2], const vec4& shadow_ambient, const vec4& shadow_ambient1);
|
|
void set_self_shadow(bool value);
|
|
void set_shader(uint32_t index);
|
|
void set_shadow(bool value);
|
|
void set_skinning_data(p_gl_rend_state& p_gl_rend_st, const mat4* mats, int32_t count);
|
|
};
|
|
|
|
struct render_context {
|
|
struct shared_storage_buffer {
|
|
void* data;
|
|
size_t offset;
|
|
size_t size;
|
|
GL::ShaderStorageBuffer buffer;
|
|
|
|
bool can_fill_data(size_t size);
|
|
void create(size_t size);
|
|
void destroy();
|
|
size_t fill_data(const void* data, size_t size);
|
|
};
|
|
|
|
struct shared_uniform_buffer {
|
|
void* data;
|
|
size_t offset;
|
|
size_t size;
|
|
GL::UniformBuffer buffer;
|
|
|
|
bool can_fill_data(size_t size);
|
|
void create(size_t size);
|
|
void destroy();
|
|
size_t fill_data(const void* data, size_t size);
|
|
};
|
|
|
|
struct shared_buffer_entry {
|
|
GLuint buffer;
|
|
size_t offset;
|
|
size_t size;
|
|
};
|
|
|
|
::camera* camera;
|
|
draw_state* draw_state;
|
|
mdl::DispManager* disp_manager;
|
|
rndr::RenderManager* render_manager;
|
|
sss_data* sss_data;
|
|
|
|
face face;
|
|
fog fog[FOG_MAX];
|
|
light_proj* litproj;
|
|
light_set light_set[LIGHT_SET_MAX];
|
|
|
|
rndr::Render render;
|
|
bool chara_reflect;
|
|
bool chara_refract;
|
|
|
|
mat4 matrix_buffer[MATRIX_BUFFER_COUNT];
|
|
|
|
GLuint box_vao;
|
|
GL::ArrayBuffer box_vbo;
|
|
|
|
GLuint lens_ghost_vao;
|
|
GL::ArrayBuffer lens_ghost_vbo;
|
|
|
|
GLuint common_vao;
|
|
|
|
RenderTexture reflect_buffer;
|
|
RenderTexture render_buffer;
|
|
RenderTexture screen_buffer;
|
|
RenderTexture screen_overlay_buffer;
|
|
RenderTexture shadow_buffer;
|
|
|
|
GL::UniformBuffer camera_blur_ubo;
|
|
GL::UniformBuffer contour_coef_ubo;
|
|
GL::UniformBuffer contour_params_ubo;
|
|
GL::UniformBuffer filter_scene_ubo;
|
|
GL::UniformBuffer esm_filter_batch_ubo;
|
|
GL::UniformBuffer imgfilter_batch_ubo;
|
|
GL::UniformBuffer exposure_measure_ubo;
|
|
GL::UniformBuffer gaussian_coef_ubo;
|
|
GL::UniformBuffer glass_eye_batch_ubo;
|
|
GL::UniformBuffer glitter_batch_ubo;
|
|
GL::UniformBuffer quad_ubo;
|
|
GL::UniformBuffer sprite_scene_ubo;
|
|
GL::UniformBuffer sss_filter_gaussian_coef_ubo;
|
|
GL::UniformBuffer sun_quad_ubo;
|
|
GL::UniformBuffer tone_map_ubo;
|
|
GL::UniformBuffer transparency_batch_ubo;
|
|
|
|
render_data data[GL_REND_STATE_COUNT];
|
|
|
|
texture* empty_texture_2d;
|
|
texture* empty_texture_cube_map;
|
|
|
|
GLuint samplers[18];
|
|
GLuint render_samplers[4];
|
|
GLuint sprite_samplers[3];
|
|
|
|
int32_t sprite_width;
|
|
int32_t sprite_height;
|
|
int32_t screen_x_offset;
|
|
int32_t screen_y_offset;
|
|
int32_t screen_width;
|
|
int32_t screen_height;
|
|
|
|
uint32_t max_uniform_block_size = 0;
|
|
uint32_t max_storage_block_size = 0;
|
|
|
|
std::vector<render_context::shared_storage_buffer> shared_storage_buffers;
|
|
std::unordered_map<size_t, shared_buffer_entry> shared_storage_buffer_entries;
|
|
std::vector<render_context::shared_uniform_buffer> shared_uniform_buffers;
|
|
std::unordered_map<size_t, shared_buffer_entry> shared_uniform_buffer_entries;
|
|
|
|
render_context();
|
|
~render_context();
|
|
|
|
void ctrl();
|
|
void disp();
|
|
void free();
|
|
void init();
|
|
void resize(int32_t render_width, int32_t render_height,
|
|
int32_t sprite_width, int32_t sprite_height,
|
|
int32_t screen_width, int32_t screen_height);
|
|
|
|
void add_shared_storage_uniform_buffer_data(size_t index,
|
|
const void* data, size_t size, size_t max_size, bool storage = false);
|
|
bool get_shared_storage_uniform_buffer_data(size_t index,
|
|
GLuint& buffer, size_t& offset, size_t& size, bool storage = false);
|
|
void post_proc();
|
|
void pre_proc();
|
|
};
|