Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / BKE_ccg.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2012 by Nicholas Bishop.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef __BKE_CCG_H__
29 #define __BKE_CCG_H__
30
31 /** \file BKE_ccg.h
32  *  \ingroup bke
33  */
34
35 /* defines BLI_INLINE */
36 #include "BLI_utildefines.h"
37
38 /* declares fprintf() and abort(), needed for BLI_assert */
39 #include <stdio.h>
40 #include <stdlib.h>
41
42 struct CCGSubSurf;
43
44 /* Each CCGElem is CCGSubSurf's representation of a subdivided
45  * vertex. All CCGElems in a particular CCGSubSurf have the same
46  * layout, but the layout can vary from one CCGSubSurf to another. For
47  * this reason, CCGElem is presented as an opaque pointer, and
48  * elements should always be accompanied by a CCGKey, which provides
49  * the necessary offsets to access components of a CCGElem.
50  */
51 typedef struct CCGElem CCGElem;
52
53 typedef struct CCGKey {
54         int level;
55
56         /* number of bytes in each element (one float per layer, plus
57          * three floats for normals if enabled) */
58         int elem_size;
59
60         /* number of elements along each side of grid */
61         int grid_size;
62         /* number of elements in the grid (grid size squared) */
63         int grid_area;
64         /* number of bytes in each grid (grid_area * elem_size) */
65         int grid_bytes;
66
67         /* currently always the last three floats, unless normals are
68          * disabled */
69         int normal_offset;
70
71         /* offset in bytes of mask value; only valid if 'has_mask' is
72          * true */
73         int mask_offset;
74
75         int num_layers;
76         int has_normals;
77         int has_mask;
78 } CCGKey;
79
80 /* initialize 'key' at the specified level */
81 void CCG_key(CCGKey *key, const struct CCGSubSurf *ss, int level);
82 void CCG_key_top_level(CCGKey *key, const struct CCGSubSurf *ss);
83
84 /* get a pointer to the coordinate, normal, or mask components */
85 BLI_INLINE float *CCG_elem_co(const CCGKey *key, CCGElem *elem);
86 BLI_INLINE float *CCG_elem_no(const CCGKey *key, CCGElem *elem);
87 BLI_INLINE float *CCG_elem_mask(const CCGKey *key, CCGElem *elem);
88
89 /* get the element at 'offset' in an array */
90 BLI_INLINE CCGElem *CCG_elem_offset(const CCGKey *key, CCGElem *elem, int offset);
91
92 /* get the element at coordinate (x,y) in a face-grid array */
93 BLI_INLINE CCGElem *CCG_grid_elem(const CCGKey *key, CCGElem *elem, int x, int y);
94
95 /* combinations of above functions */
96 BLI_INLINE float *CCG_grid_elem_co(const CCGKey *key, CCGElem *elem, int x, int y);
97 BLI_INLINE float *CCG_grid_elem_no(const CCGKey *key, CCGElem *elem, int x, int y);
98 BLI_INLINE float *CCG_grid_elem_mask(const CCGKey *key, CCGElem *elem, int x, int y);
99 BLI_INLINE float *CCG_elem_offset_co(const CCGKey *key, CCGElem *elem, int offset);
100 BLI_INLINE float *CCG_elem_offset_no(const CCGKey *key, CCGElem *elem, int offset);
101 BLI_INLINE float *CCG_elem_offset_mask(const CCGKey *key, CCGElem *elem, int offset);
102
103 /* for iteration, get a pointer to the next element in an array */
104 BLI_INLINE CCGElem *CCG_elem_next(const CCGKey *key, CCGElem *elem);
105
106
107 /* inline definitions follow */
108
109 BLI_INLINE float *CCG_elem_co(const CCGKey *UNUSED(key), CCGElem *elem)
110 {
111         return (float *)elem;
112 }
113
114 BLI_INLINE float *CCG_elem_no(const CCGKey *key, CCGElem *elem)
115 {
116         BLI_assert(key->has_normals);
117         return (float *)((char *)elem + key->normal_offset);
118 }
119
120 BLI_INLINE float *CCG_elem_mask(const CCGKey *key, CCGElem *elem)
121 {
122         BLI_assert(key->has_mask);
123         return (float *)((char *)elem + (key->mask_offset));
124 }
125
126 BLI_INLINE CCGElem *CCG_elem_offset(const CCGKey *key, CCGElem *elem, int offset)
127 {
128         return (CCGElem *)(((char *)elem) + key->elem_size * offset);
129 }
130
131 BLI_INLINE CCGElem *CCG_grid_elem(const CCGKey *key, CCGElem *elem, int x, int y)
132 {
133 //      BLI_assert(x < key->grid_size && y < key->grid_size);
134         return CCG_elem_offset(key, elem, (y * key->grid_size + x));
135 }
136
137 BLI_INLINE float *CCG_grid_elem_co(const CCGKey *key, CCGElem *elem, int x, int y)
138 {
139         return CCG_elem_co(key, CCG_grid_elem(key, elem, x, y));
140 }
141
142 BLI_INLINE float *CCG_grid_elem_no(const CCGKey *key, CCGElem *elem, int x, int y)
143 {
144         return CCG_elem_no(key, CCG_grid_elem(key, elem, x, y));
145 }
146
147 BLI_INLINE float *CCG_grid_elem_mask(const CCGKey *key, CCGElem *elem, int x, int y)
148 {
149         return CCG_elem_mask(key, CCG_grid_elem(key, elem, x, y));
150 }
151
152 BLI_INLINE float *CCG_elem_offset_co(const CCGKey *key, CCGElem *elem, int offset)
153 {
154         return CCG_elem_co(key, CCG_elem_offset(key, elem, offset));
155 }
156
157 BLI_INLINE float *CCG_elem_offset_no(const CCGKey *key, CCGElem *elem, int offset)
158 {
159         return CCG_elem_no(key, CCG_elem_offset(key, elem, offset));
160 }
161
162 BLI_INLINE float *CCG_elem_offset_mask(const CCGKey *key, CCGElem *elem, int offset)
163 {
164         return CCG_elem_mask(key, CCG_elem_offset(key, elem, offset));
165 }
166
167 BLI_INLINE CCGElem *CCG_elem_next(const CCGKey *key, CCGElem *elem)
168 {
169         return CCG_elem_offset(key, elem, 1);
170 }
171
172 #endif