Merging Shrinkwrap Constraint!
[blender.git] / source / blender / blenkernel / BKE_shrinkwrap.h
1 /**
2  * BKE_shrinkwrap.h
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) Blender Foundation.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29 #ifndef BKE_SHRINKWRAP_H
30 #define BKE_SHRINKWRAP_H
31
32 /* mesh util */
33 //TODO: move this somewhere else
34 #include "BKE_customdata.h"
35 struct DerivedMesh;
36 struct Object;
37 struct DerivedMesh *object_get_derived_final(struct Object *ob, CustomDataMask dataMask);
38
39
40 /* SpaceTransform stuff */
41 /*
42  * TODO: move this somewhere else
43  *
44  * this structs encapsulates all needed data to convert between 2 coordinate spaces
45  * (where conversion can be represented by a matrix multiplication)
46  *
47  * This is used to reduce the number of arguments to pass to functions that need to perform
48  * this kind of operation and make it easier for the coder, as he/she doenst needs to recode
49  * the matrix calculation.
50  *
51  * A SpaceTransform is initialized using:
52  *   space_transform_setup( &data,  ob1, ob2 )
53  *
54  * After that the following calls can be used:
55  *   space_transform_apply (&data, co); //converts a coordinate in ob1 coords space to the corresponding ob2 coords
56  *   space_transform_invert(&data, co); //converts a coordinate in ob2 coords space to the corresponding ob1 coords
57  *
58  *      //Same Concept as space_transform_apply and space_transform_invert, but no is normalized after conversion
59  *   space_transform_apply_normal (&data, &no);
60  *   space_transform_invert_normal(&data, &no);
61  *
62  */
63 struct Object;
64
65 typedef struct SpaceTransform
66 {
67         float local2target[4][4];
68         float target2local[4][4];
69
70 } SpaceTransform;
71
72 void space_transform_from_matrixs(SpaceTransform *data, float local[][4], float target[][4]);
73 #define space_transform_setup(data, local, target) space_transform_from_matrixs(data, (local)->obmat, (target)->obmat)
74
75 void space_transform_apply (const SpaceTransform *data, float *co);
76 void space_transform_invert(const SpaceTransform *data, float *co);
77
78 void space_transform_apply_normal (const SpaceTransform *data, float *no);
79 void space_transform_invert_normal(const SpaceTransform *data, float *no);
80
81 /* Shrinkwrap stuff */
82 #include "BKE_bvhutils.h"
83
84 /*
85  * Shrinkwrap is composed by a set of functions and options that define the type of shrink.
86  *
87  * 3 modes are available:
88  *    - Nearest vertex
89  *        - Nearest surface
90  *    - Normal projection
91  *
92  * ShrinkwrapCalcData encapsulates all needed data for shrinkwrap functions.
93  * (So that you dont have to pass an enormous ammount of arguments to functions)
94  */
95
96 struct Object;
97 struct DerivedMesh;
98 struct MVert;
99 struct MDeformVert;
100 struct ShrinkwrapModifierData;
101 struct MDeformVert;
102 struct BVHTree;
103
104
105 typedef struct ShrinkwrapCalcData
106 {
107         ShrinkwrapModifierData *smd;    //shrinkwrap modifier data
108
109         struct Object *ob;                              //object we are applying shrinkwrap to
110
111         MVert *vert;                                    //Array of verts being projected (to fetch normals or other data)
112         float (*vertexCos)[3];                  //vertexs being shrinkwraped
113         int numVerts;
114
115         struct MDeformVert* dvert;                      //Pointer to mdeform array
116         int vgroup;                                             //Vertex group num
117
118         struct DerivedMesh *target;             //mesh we are shrinking to      
119         SpaceTransform local2target;    //transform to move bettwem local and target space
120
121         float keepDist;                                 //Distance to kept from target (units are in local space)
122
123 } ShrinkwrapCalcData;
124
125 void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *data);
126 void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *data);
127 void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *data);
128
129 void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Object *ob, struct DerivedMesh *dm, float (*vertexCos)[3], int numVerts);
130
131 /*
132  * This function casts a ray in the given BVHTree.. but it takes into consideration the space_transform, that is:
133  *
134  * if transf was configured with "space_transform_setup( &transf,  ob1, ob2 )"
135  * then the input (vert, dir, BVHTreeRayHit) must be defined in ob1 coordinates space
136  * and the BVHTree must be built in ob2 coordinate space.
137  *
138  * Thus it provides an easy way to cast the same ray across several trees (where each tree was built on its own coords space)
139  */
140 int normal_projection_project_vertex(char options, const float *vert, const float *dir, const SpaceTransform *transf, BVHTree *tree, BVHTreeRayHit *hit, BVHTree_RayCastCallback callback, void *userdata);
141
142 /*
143  * NULL initializers to local data
144  */
145 #define NULL_ShrinkwrapCalcData {NULL, }
146 #define NULL_BVHTreeFromMesh    {NULL, }
147 #define NULL_BVHTreeRayHit              {NULL, }
148 #define NULL_BVHTreeNearest             {0, }
149
150
151 #endif
152