Initial revision
[blender.git] / source / blender / render / intern / include / vanillaRenderPipe_int.h
1 /*
2  * vanillaRenderPipe_int.h
3  *
4  * $Id$
5  *
6  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL/BL DUAL LICENSE BLOCK *****
33  */
34
35 #ifndef VANILLARENDERPIPE_INT_H
36 #define VANILLARENDERPIPE_INT_H
37
38 #include "vanillaRenderPipe_types.h"
39 #include "zbufferdatastruct_types.h"
40
41 /**
42  * Z buffer initializer, for new pipeline.
43  * <LI>
44  * <IT> AColourBuffer : colour buffer for one line
45  * <IT> APixbufExt    : pixel data buffer for one line, depth RE_ZBUFLEN 
46  * </LI>
47  */
48 void initRenderBuffers(int width);
49 /*  void initRenderBuffers(void); */
50
51 /**
52  * Z buffer destructor, frees stuff from initZBuffers().
53  */
54 void freeRenderBuffers(void);
55
56 /** 
57  * Fill the accumulation buffer APixbufExt with face and halo indices. 
58  * Note: Uses globals.
59  * @param y the line number to set
60  */
61 void calcZBufLine(int y);
62
63 /** 
64  * Shade and render the pixels in this line, into AColourBuffer
65  * Note: Uses globals.
66  * @param y the line number to set
67  */
68 void renderZBufLine(int y);
69
70 /**
71  * Count and sort the list behind ap into buf. Sorts on min. distance.
72  * Low index <=> high z
73  */
74 int countAndSortPixelFaces(int buf[RE_MAX_FACES_PER_PIXEL][5], 
75                            RE_APixstrExt *ap);
76
77 /** 
78  * Compose the conflict and colour stacks 
79  * Note: Uses globals.
80  */
81 int composeStack(int zrow[RE_MAX_FACES_PER_PIXEL][RE_PIXELFIELDSIZE],
82                                  struct RE_faceField* stack, int ptr,
83                                  int totvlak, float x, float y, int osaNr);
84 /**
85  * Integrate conflicting layers.
86  * Note: Uses globals.
87  */
88 int resolveConflict(struct RE_faceField* stack, int ptr, float x, float y);
89
90 /**
91  * Integrate the colour stack, defer conflicts.
92  * Note: Uses globals.
93  */
94 void integrateStack(struct RE_faceField* stack, int ptr,
95                                         float x, float y, int osaNr);
96                                         
97 /**
98  * Calculate the view depth to this object on this location, with 
99  * the current view parameters in R.
100  */
101 int calcDepth(float x, float y, void *data, int type);
102
103
104
105 /**
106  * Fills in distances of all faces in a z buffer, for given jitter settings.
107  */
108 int fillZBufDistances(void);
109
110 /**
111  * Fills in distances of faces in the z buffer.
112  *
113  * Halo z buffering ---------------------------------------------- 
114  *
115  * A halo is treated here as a billboard: no z-extension, always   
116  * oriented perpendicular to the viewer. The rest of the z-buffer  
117  * stores face-numbers first, then calculates colours as the       
118  * final image is rendered. We'll use the same approach here,      
119  * which differs from the original method (which was add halos per 
120  * scan line). This means that the z-buffer now also needs to      
121  * store info about what sort of 'thing' the index refers to.      
122  *                                                                 
123  * Halo extension:                                                 
124  * h.maxy  ---------                                               
125  *         |          h.xs + h.rad                                 
126  *             |      h.xs                                         
127  *                 |  h.xs - h.rad                                 
128  * h.miny  ---------                                               
129  *                                                                 
130  * These coordinates must be clipped to picture size.              
131  * I'm not quite certain about halo numbering.                     
132  *                                                                 
133  * Halos and jittering -------------------------------------------  
134  *                                                                 
135  * Halos were not jittered previously. Now they are. I wonder      
136  * whether this may have some adverse effects here.                
137  
138  * @return 1 for succes, 0 if the operation was interrupted.
139  */
140 int zBufferAllFaces(void);
141
142 /**
143  * Fills in distances of halos in the z buffer.
144  * @return 1 for succes, 0 if the operation was interrupted.
145  */
146 int zBufferAllHalos(void);
147
148 /**
149  * New fill function for z buffer, for edge-only rendering.
150  */
151 void zBufferFillEdge(float *vec1, float *vec2);
152
153 /**
154  * New fill function for z buffer.
155  */
156 void zBufferFillFace(float *v1, float *v2, float *v3);
157
158 /**
159  * One more filler: fill in halo data in z buffer.
160  * Empty so far, but may receive content of halo loop.
161  */
162 void zBufferFillHalo(void);
163
164 /**
165  * Copy the colour buffer output to R.rectot, to line y.
166  */
167 void transferColourBufferToOutput(int y);
168
169 /**
170  * Set the colour buffer fields to zero.
171  */
172 void eraseColBuf(RE_COLBUFTYPE *buf);
173
174 /**
175  * Blend source over dest, and leave result in dest. 1 pixel.
176  */
177 void blendOverFloat(int type, float* dest, float* source, void* data);
178
179 /**
180  * Blend source over dest, and leave result in dest. 1 pixel into 
181  * multiple bins.
182  */
183 void blendOverFloatRow(int type, float* dest, float* source, 
184                        void* data, int mask, int osaNr) ;
185
186 /**
187  * Do a post-process step on a finalized render image.
188  */
189 void std_transFloatColV2CharColV( RE_COLBUFTYPE *buf, char *target);
190
191 #endif /* VANILLARENDERPIPE_INT_H */