Revert to master - those changes are globally valid, but remain incomplete,
[blender.git] / source / blender / blenkernel / intern / lamp.c
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) 2001-2002 by NaN Holding BV.
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 /** \file blender/blenkernel/intern/lamp.c
29  *  \ingroup bke
30  */
31
32 #include <stdlib.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_lamp_types.h"
38 #include "DNA_material_types.h"
39 #include "DNA_node_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_texture_types.h"
43
44 #include "BLI_math.h"
45 #include "BLI_utildefines.h"
46
47 #include "BKE_animsys.h"
48 #include "BKE_colortools.h"
49 #include "BKE_icons.h"
50 #include "BKE_global.h"
51 #include "BKE_lamp.h"
52 #include "BKE_library.h"
53 #include "BKE_main.h"
54 #include "BKE_node.h"
55
56 Lamp *BKE_lamp_add(Main *bmain, const char *name)
57 {
58         Lamp *la;
59         
60         la =  BKE_libblock_alloc(bmain, ID_LA, name);
61         
62         la->r = la->g = la->b = la->k = 1.0f;
63         la->haint = la->energy = 1.0f;
64         la->dist = 25.0f;
65         la->spotsize = DEG2RADF(45.0f);
66         la->spotblend = 0.15f;
67         la->att2 = 1.0f;
68         la->mode = LA_SHAD_BUF;
69         la->bufsize = 512;
70         la->clipsta = 0.5f;
71         la->clipend = 40.0f;
72         la->samp = 3;
73         la->bias = 1.0f;
74         la->soft = 3.0f;
75         la->compressthresh = 0.05f;
76         la->ray_samp = la->ray_sampy = la->ray_sampz = 1;
77         la->area_size = la->area_sizey = la->area_sizez = 0.1f;
78         la->buffers = 1;
79         la->buftype = LA_SHADBUF_HALFWAY;
80         la->ray_samp_method = LA_SAMP_HALTON;
81         la->adapt_thresh = 0.001f;
82         la->preview = NULL;
83         la->falloff_type = LA_FALLOFF_INVSQUARE;
84         la->curfalloff = curvemapping_add(1, 0.0f, 1.0f, 1.0f, 0.0f);
85         la->sun_effect_type = 0;
86         la->horizon_brightness = 1.0;
87         la->spread = 1.0;
88         la->sun_brightness = 1.0;
89         la->sun_size = 1.0;
90         la->backscattered_light = 1.0f;
91         la->atm_turbidity = 2.0f;
92         la->atm_inscattering_factor = 1.0f;
93         la->atm_extinction_factor = 1.0f;
94         la->atm_distance_factor = 1.0f;
95         la->sun_intensity = 1.0f;
96         la->skyblendtype = MA_RAMP_ADD;
97         la->skyblendfac = 1.0f;
98         la->sky_colorspace = BLI_XYZ_CIE;
99         la->sky_exposure = 1.0f;
100         la->shadow_frustum_size = 10.0f;
101         
102         curvemapping_initialize(la->curfalloff);
103         return la;
104 }
105
106 Lamp *BKE_lamp_copy(Lamp *la)
107 {
108         Lamp *lan;
109         int a;
110         
111         lan = BKE_libblock_copy(&la->id);
112
113         for (a = 0; a < MAX_MTEX; a++) {
114                 if (lan->mtex[a]) {
115                         lan->mtex[a] = MEM_mallocN(sizeof(MTex), "copylamptex");
116                         memcpy(lan->mtex[a], la->mtex[a], sizeof(MTex));
117                         id_us_plus((ID *)lan->mtex[a]->tex);
118                 }
119         }
120         
121         lan->curfalloff = curvemapping_copy(la->curfalloff);
122
123         if (la->nodetree)
124                 lan->nodetree = ntreeCopyTree(la->nodetree);
125         
126         if (la->preview)
127                 lan->preview = BKE_previewimg_copy(la->preview);
128         
129         if (la->id.lib) {
130                 BKE_id_lib_local_paths(G.main, la->id.lib, &lan->id);
131         }
132
133         return lan;
134 }
135
136 Lamp *localize_lamp(Lamp *la)
137 {
138         Lamp *lan;
139         int a;
140         
141         lan = BKE_libblock_copy_nolib(&la->id, false);
142
143         for (a = 0; a < MAX_MTEX; a++) {
144                 if (lan->mtex[a]) {
145                         lan->mtex[a] = MEM_mallocN(sizeof(MTex), "localize_lamp");
146                         memcpy(lan->mtex[a], la->mtex[a], sizeof(MTex));
147                         /* free lamp decrements */
148                         id_us_plus((ID *)lan->mtex[a]->tex);
149                 }
150         }
151         
152         lan->curfalloff = curvemapping_copy(la->curfalloff);
153
154         if (la->nodetree)
155                 lan->nodetree = ntreeLocalize(la->nodetree);
156         
157         lan->preview = NULL;
158         
159         return lan;
160 }
161
162 void BKE_lamp_make_local(Lamp *la)
163 {
164         Main *bmain = G.main;
165         Object *ob;
166         bool is_local = false, is_lib = false;
167
168         /* - only lib users: do nothing
169          * - only local users: set flag
170          * - mixed: make copy
171          */
172         
173         if (la->id.lib == NULL) return;
174         if (la->id.us == 1) {
175                 id_clear_lib_data(bmain, &la->id);
176                 return;
177         }
178         
179         ob = bmain->object.first;
180         while (ob) {
181                 if (ob->data == la) {
182                         if (ob->id.lib) is_lib = true;
183                         else is_local = true;
184                 }
185                 ob = ob->id.next;
186         }
187         
188         if (is_local && is_lib == false) {
189                 id_clear_lib_data(bmain, &la->id);
190         }
191         else if (is_local && is_lib) {
192                 Lamp *la_new = BKE_lamp_copy(la);
193                 la_new->id.us = 0;
194
195                 /* Remap paths of new ID using old library as base. */
196                 BKE_id_lib_local_paths(bmain, la->id.lib, &la_new->id);
197
198                 ob = bmain->object.first;
199                 while (ob) {
200                         if (ob->data == la) {
201                                 
202                                 if (ob->id.lib == NULL) {
203                                         ob->data = la_new;
204                                         la_new->id.us++;
205                                         la->id.us--;
206                                 }
207                         }
208                         ob = ob->id.next;
209                 }
210         }
211 }
212
213 void BKE_lamp_free(Lamp *la)
214 {
215         MTex *mtex;
216         int a;
217
218         for (a = 0; a < MAX_MTEX; a++) {
219                 mtex = la->mtex[a];
220                 if (mtex && mtex->tex) mtex->tex->id.us--;
221                 if (mtex) MEM_freeN(mtex);
222         }
223         
224         BKE_animdata_free((ID *)la);
225
226         curvemapping_free(la->curfalloff);
227
228         /* is no lib link block, but lamp extension */
229         if (la->nodetree) {
230                 ntreeFreeTree(la->nodetree);
231                 MEM_freeN(la->nodetree);
232         }
233         
234         BKE_previewimg_free(&la->preview);
235         BKE_icon_id_delete(&la->id);
236         la->id.icon_id = 0;
237 }
238
239 /* Calculate all drivers for lamps, see material_drivers_update for why this is a bad hack */
240
241 static void lamp_node_drivers_update(Scene *scene, bNodeTree *ntree, float ctime)
242 {
243         bNode *node;
244
245         /* nodetree itself */
246         if (ntree->adt && ntree->adt->drivers.first)
247                 BKE_animsys_evaluate_animdata(scene, &ntree->id, ntree->adt, ctime, ADT_RECALC_DRIVERS);
248         
249         /* nodes */
250         for (node = ntree->nodes.first; node; node = node->next)
251                 if (node->id && node->type == NODE_GROUP)
252                         lamp_node_drivers_update(scene, (bNodeTree *)node->id, ctime);
253 }
254
255 void lamp_drivers_update(Scene *scene, Lamp *la, float ctime)
256 {
257         /* Prevent infinite recursion by checking (and tagging the lamp) as having been visited already
258          * (see BKE_scene_update_tagged()). This assumes la->id.flag & LIB_DOIT isn't set by anything else
259          * in the meantime... [#32017] */
260         if (la->id.flag & LIB_DOIT)
261                 return;
262
263         la->id.flag |= LIB_DOIT;
264         
265         /* lamp itself */
266         if (la->adt && la->adt->drivers.first)
267                 BKE_animsys_evaluate_animdata(scene, &la->id, la->adt, ctime, ADT_RECALC_DRIVERS);
268         
269         /* nodes */
270         if (la->nodetree)
271                 lamp_node_drivers_update(scene, la->nodetree, ctime);
272
273         la->id.flag &= ~LIB_DOIT;
274 }
275