Cycles microdisplacement: Support for Catmull-Clark subdivision via OpenSubdiv
[blender.git] / intern / cycles / render / attribute.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __ATTRIBUTE_H__
18 #define __ATTRIBUTE_H__
19
20 #include "kernel_types.h"
21
22 #include "util_list.h"
23 #include "util_param.h"
24 #include "util_types.h"
25 #include "util_vector.h"
26
27 CCL_NAMESPACE_BEGIN
28
29 class Attribute;
30 class AttributeRequest;
31 class AttributeRequestSet;
32 class AttributeSet;
33 class ImageManager;
34 class Mesh;
35 struct Transform;
36
37 /* Attributes for voxels are images */
38
39 struct VoxelAttribute {
40         ImageManager *manager;
41         int slot;
42 };
43
44 /* Attribute
45  *
46  * Arbitrary data layers on meshes.
47  * Supported types: Float, Color, Vector, Normal, Point */
48
49 class Attribute {
50 public:
51         ustring name;
52         AttributeStandard std;
53
54         TypeDesc type;
55         vector<char> buffer;
56         AttributeElement element;
57         uint flags; /* enum AttributeFlag */
58
59         Attribute() {}
60         ~Attribute();
61         void set(ustring name, TypeDesc type, AttributeElement element);
62         void resize(Mesh *mesh, AttributePrimitive prim, bool reserve_only);
63         void resize(size_t num_elements);
64
65         size_t data_sizeof() const;
66         size_t element_size(Mesh *mesh, AttributePrimitive prim) const;
67         size_t buffer_size(Mesh *mesh, AttributePrimitive prim) const;
68
69         char *data() { return (buffer.size())? &buffer[0]: NULL; };
70         float3 *data_float3() { return (float3*)data(); }
71         float4 *data_float4() { return (float4*)data(); }
72         float *data_float() { return (float*)data(); }
73         uchar4 *data_uchar4() { return (uchar4*)data(); }
74         Transform *data_transform() { return (Transform*)data(); }
75         VoxelAttribute *data_voxel()  { return ( VoxelAttribute*)data(); }
76
77         const char *data() const { return (buffer.size())? &buffer[0]: NULL; }
78         const float3 *data_float3() const { return (const float3*)data(); }
79         const float4 *data_float4() const { return (const float4*)data(); }
80         const float *data_float() const { return (const float*)data(); }
81         const Transform *data_transform() const { return (const Transform*)data(); }
82         const VoxelAttribute *data_voxel() const { return (const VoxelAttribute*)data(); }
83
84         void zero_data(void* dst);
85         void add_with_weight(void* dst, void* src, float weight);
86
87         void add(const float& f);
88         void add(const float3& f);
89         void add(const uchar4& f);
90         void add(const Transform& f);
91         void add(const VoxelAttribute& f);
92         void add(const char *data);
93
94         static bool same_storage(TypeDesc a, TypeDesc b);
95         static const char *standard_name(AttributeStandard std);
96         static AttributeStandard name_standard(const char *name);
97 };
98
99 /* Attribute Set
100  *
101  * Set of attributes on a mesh. */
102
103 class AttributeSet {
104 public:
105         Mesh *triangle_mesh;
106         Mesh *curve_mesh;
107         Mesh *subd_mesh;
108         list<Attribute> attributes;
109
110         AttributeSet();
111         ~AttributeSet();
112
113         Attribute *add(ustring name, TypeDesc type, AttributeElement element);
114         Attribute *find(ustring name) const;
115         void remove(ustring name);
116
117         Attribute *add(AttributeStandard std, ustring name = ustring());
118         Attribute *find(AttributeStandard std) const;
119         void remove(AttributeStandard std);
120
121         Attribute *find(AttributeRequest& req);
122
123         void resize(bool reserve_only = false);
124         void clear();
125 };
126
127 /* AttributeRequest
128  *
129  * Request from a shader to use a certain attribute, so we can figure out
130  * which ones we need to export from the host app end store for the kernel.
131  * The attribute is found either by name or by standard attribute type. */
132
133 class AttributeRequest {
134 public:
135         ustring name;
136         AttributeStandard std;
137
138         /* temporary variables used by MeshManager */
139         TypeDesc triangle_type, curve_type, subd_type;
140         AttributeDescriptor triangle_desc, curve_desc, subd_desc;
141
142         explicit AttributeRequest(ustring name_);
143         explicit AttributeRequest(AttributeStandard std);
144 };
145
146 /* AttributeRequestSet
147  *
148  * Set of attributes requested by a shader. */
149
150 class AttributeRequestSet {
151 public:
152         vector<AttributeRequest> requests;
153
154         AttributeRequestSet();
155         ~AttributeRequestSet();
156
157         void add(ustring name);
158         void add(AttributeStandard std);
159         void add(AttributeRequestSet& reqs);
160
161         bool find(ustring name);
162         bool find(AttributeStandard std);
163
164         size_t size();
165         void clear();
166
167         bool modified(const AttributeRequestSet& other);
168 };
169
170 CCL_NAMESPACE_END
171
172 #endif /* __ATTRIBUTE_H__ */
173