-
Notifications
You must be signed in to change notification settings - Fork 2
/
object.hpp
169 lines (120 loc) · 4.26 KB
/
object.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#ifndef INCLUDED_HPP_OBJECT
#define INCLUDED_HPP_OBJECT
#include <vector>
#include "triangle.hpp"
#include <string>
#include <cl/cl.h>
#include <functional>
#include "obj_g_descriptor.hpp"
#include "object_context.hpp"
#include <vec/vec.hpp>
struct texture;
struct object_context_data;
template<typename T>
struct cache
{
T old = T();
T cur = T();
cl_event old_ev;
int init = 0;
};
struct texture_reference
{
int id;
};
struct object
{
std::string object_name;
cl_uint gpu_tri_start;
cl_uint gpu_tri_end;
cl_int feature_flag;
///put the current texture id in here, as well as
///the texture addressing information
///allow the tex_gpu structure to have a .write(gpu/cpu_texture, object)
///this would probably have to update the cpu side texture
///as well as the member in the cpu texture array
///?
///restrict this to same sized texture updates, or subupdates with offsets/size
cl_float4 pos;
cl_float4 rot;
quaternion rot_quat;
float dynamic_scale = 1.f;
cl_float4 centre; ///unused
bool isactive;
int tri_num;
int isloaded;
std::vector<triangle> tri_list;
std::function<int (object*, cl_float4)> obj_vis;
std::function<void (object*)> obj_load_func;
///remember to make this a generic vector of texture ids? Or can't due to opencl retardation?
cl_uint tid; ///texture id ///on load
cl_uint bid; ///bumpmap_id
cl_uint rid;
cl_uint ssid;
cl_int object_g_id; ///obj_g_descriptor id ///assigned
cl_uint has_bump; ///does this object have a bumpmap
//cl_uint last_gpu_position_id = -1;
///despite being named similarly, these two are very different
///specular = 1.f - rough, diffuse = kD
float specular;
float spec_mult;
float diffuse;
//cl_uint two_sided;
//cl_uint is_ss_reflective;
cache<float> scale_cache;
cache<cl_uint> tid_cache{UINT_MAX};
cache<cl_int> feature_flag_cache;
std::vector<cl_event> write_events;
cl_uint unique_id;
static cl_uint gid;
bool gpu_writable;
float position_quantise_grid_size = 1;
bool position_quantise = false;
object();
~object();
void set_screenspace_map_id(cl_uint id);
void set_active(bool param);
void set_pos(cl_float4);
void set_rot(cl_float4);
void set_rot_quat(quaternion);
void set_dynamic_scale(float _scale);
void set_ss_reflective(int is_reflective);
void set_two_sided(bool is_two_sided);
void set_outlined(bool is_outlined);
void set_is_static(bool is_static);
void set_does_not_receive_dynamic_shadows(bool does_not_receive);
void offset_pos(cl_float4);
void swap_90();
void swap_90_perp();
void stretch(int dim, float amount);
void scale(float);
void set_quantise_position(bool do_quantise, float grid_size = 1);
void destroy_textures(texture_context& tex_ctx);
void patch_non_square_texture_maps(texture_context& ctx);
void patch_non_2pow_texture_maps(texture_context& ctx);
void patch_stretch_texture_to_full(texture_context& ctx);
texture* get_texture();
///this is uncached for the moment
cl_float4 get_centre();
cl_float2 get_exact_height_bounds(); ///expensive!
float get_min_y();
void translate_centre(cl_float4);
void set_vis_func(std::function<int (object*, cl_float4)>);
int call_vis_func(object*, cl_float4);
void set_load_func(std::function<void (object*)>);
void call_load_func(object*);
void try_load(cl_float4); ///try and get the object, dependent on its visibility
///unused, probably removing visibility system due to complete infeasibility of automatic object loading based on anything useful
void g_flush(object_context& cpu_dat, bool force = false); ///flush position (currently just) etc to gpu memory
void set_buffer_offset(int offset);
int buffer_offset = 0;
///for writing to gpu, need the memory to stick around
private:
cl_float8 posrot;
cl_float4 last_pos;
cl_float4 last_rot;
cl_float4 last_rot_quat;
cl_float4 cl_rot_quat;
uint32_t last_object_context_data_id;
};
#endif