fixed spacing in the headers to get rid of some warnings and some other
[blender.git] / source / blender / render / intern / include / pixelblending.h
1 /*
2  *    pixelblending_ext.h
3  * external interface for pixelblending 
4  *
5  * $Id$
6  *
7  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version. The Blender
13  * Foundation also sells licenses for use in proprietary software under
14  * the Blender License.  See http://www.blender.org/BL/ for information
15  * about this.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software Foundation,
24  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
25  *
26  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
27  * All rights reserved.
28  *
29  * The Original Code is: all of this file.
30  *
31  * Contributor(s): none yet.
32  *
33  * ***** END GPL/BL DUAL LICENSE BLOCK *****
34  */
35
36 #ifndef PIXELBLENDING_EXT_H
37 #define PIXELBLENDING_EXT_H 
38
39 /* local includes */
40 #include "vanillaRenderPipe_types.h"
41
42 /* own include */
43 #include "pixelblending_types.h"
44
45 /**
46  * Samples pixel, depending on R.osa setting
47  */
48 int addtosampcol(unsigned short *sampcol, unsigned short *shortcol, int mask);
49
50 /**
51  * Samples pixel, bring your own R.osa setting
52  */
53 int addToSampCol(unsigned short *sampcol, unsigned short *shortcol, int mask, int osaNr);
54
55 /**
56  * Halo-add pixel, bring your own R.osa setting, and add factor
57  */
58 void addAddSampColF(float *s, float *d, int m, int osa, char add);
59
60 /**
61  * Alpha undersamples pixel, bring your own R.osa setting
62  */
63 int addUnderSampColF(float *sampcol, float *dest, int mask, int osaNr);
64
65 /**
66  * Alpha oversample pixel, bring your own R.osa setting
67  */
68 void addOverSampColF(float *sampcol, float *dest, int mask, int osaNr);
69
70 /**
71  * Convert a series of oversampled pixels into a single pixel. 
72  * (float vecs to float vec)
73  */
74 void sampleFloatColV2FloatColV(float *sample, float *dest, int osaNr);
75
76 /**
77  * Convert a series of oversampled pixels into a single pixel. Uses R.osa to
78  * count the length! (short vecs to short vec)
79  */
80 void sampleShortColV2ShortColV(unsigned short *sample, unsigned short *dest, int osaNr);
81
82 /**
83  * Take colour <bron>, and apply it to <doel> using the alpha value of
84  * <bron>. 
85  * @param doel
86  * @param bron
87  */
88 void addAlphaOverShort(unsigned short *doel, unsigned short *bron);   
89
90 /**
91  * Take colour <bron>, and apply it to <doel> using the alpha value of
92  * <doel>. 
93  * @param doel
94  * @param bron
95  */
96 void addAlphaUnderShort(unsigned short *doel, unsigned short *bron);  
97
98 /**
99  * Alpha-over blending for floats.
100  */
101 void addAlphaOverFloat(float *dest, float *source);  
102
103 /**
104  * Alpha-under blending for floats.
105  */
106 void addAlphaUnderFloat(float *dest, float *source);  
107
108 /**
109  * Write a 16-bit-colour colour vector to a 8-bit-colour colour vector. 
110  */
111 void cpShortColV2CharColV(unsigned short *source, char *dest);
112
113 /**
114  * Write a 8-bit-colour colour vector to a 16-bit-colour colour vector. 
115  */
116 void cpCharColV2ShortColV(char *source, unsigned short *dest);
117
118 /**
119  * Write a 32-bit-colour colour vector to a 8-bit-colour colour vector. 
120  */
121 void cpIntColV2CharColV(unsigned int *source, char *dest);
122
123 /**
124  * Write a floating-point-colour colour vector to a 8-bit-colour colour 
125  * vector. Clip colours to [0, 1].
126  */
127 void cpFloatColV2CharColV(float *source, char *dest);
128
129 /**
130  * Cpoy a 8-bit-colour vector to floating point colour vector.
131  */
132 void cpCharColV2FloatColV(char *source, float *dest);
133 /**
134  * Cpoy a 16-bit-colour vector to floating point colour vector.
135  */
136 void cpShortColV2FloatColV(unsigned short *source, float *dest);
137
138 /**
139  * Copy a float-colour colour vector.
140  */
141 void cpFloatColV(float *source, float *dest);
142
143 /**
144  * Copy a 16-bit-colour colour vector.
145  */
146 void cpShortColV(unsigned short *source, unsigned short *dest);
147
148 /**
149  * Copy an 8-bit-colour colour vector.
150  */
151 void cpCharColV(char *source, char *dest);
152
153 /**
154  * Add a fraction of <source> to <dest>. Result ends up in <dest>.
155  * The internal calculation is done with floats.
156  * 
157  * col(dest)   = (1 - alpha(source)*(1 - addfac)) * dest + source
158  * alpha(dest) = alpha(source) + alpha (dest)
159  */
160 void addalphaAddfacShort(unsigned short *dest, unsigned short *source, char addfac);
161
162 /**
163  * Same for floats
164  */
165 void addalphaAddfacFloat(float *dest, float *source, char addfac);
166
167 /**
168  * Add two halos. Result ends up in <dest>. This should be the 
169  * addition of two light sources. So far, I use normal alpha-under blending here.
170  * The internal calculation is done with floats. The add-factors have to be 
171  * compensated outside this routine.
172  * col(dest)   = s + (1 - alpha(s))d
173  * alpha(dest) = alpha(s) + (1 - alpha(s))alpha (d)
174  */
175 void addHaloToHaloShort(unsigned short *dest, unsigned short *source);
176
177 /**
178  * dest = dest + source
179  */
180 void addalphaAddFloat(float *dest, float *source);
181
182 /** ols functions: side effects?
183 void addalphaUnderFloat(char *doel, char *bron); think this already exists...
184 void addalphaUnderGammaFloat(char *doel, char *bron);
185 */
186 /**
187  * Blend bron under doel, while doing gamma correction
188  */
189 void addalphaUnderGammaFloat(float *doel, float *bron);
190
191 /**
192  * Transform an premul-alpha 32-bit colour into a key-alpha 32-bit colour.
193  */
194 void applyKeyAlphaCharCol(char* target);
195
196 /* Old blending functions */
197 void keyalpha(char *doel);   /* maakt premul 255 */
198 void addalphaUnder(char *doel, char *bron);
199 void addalphaUnderGamma(char *doel, char *bron);
200 void addalphaOver(char *doel, char *bron);
201 void addalphaAdd(char *doel, char *bron);
202 void addalphaAddshort(unsigned short *doel, unsigned short *bron);
203 /*  void addalphaAddfac(char *doel, char *bron, char addfac); to ext, temporarily */
204 void addalphaAddfacshort(unsigned short *doel,
205                                                  unsigned short *bron,
206                                                  short addfac);    
207
208 #endif /* PIXELBLENDING_EXT_H */
209