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