258 lines
8.3 KiB
C++
258 lines
8.3 KiB
C++
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2006 by Blender Foundation
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
|
*/
|
|
/** \file RE_shader_ext.h
|
|
* \ingroup render
|
|
*/
|
|
|
|
|
|
#ifndef __RE_SHADER_EXT_H__
|
|
#define __RE_SHADER_EXT_H__
|
|
|
|
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
|
|
/* this include is for shading and texture exports */
|
|
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
|
|
|
|
/* localized texture result data */
|
|
/* note; tr tg tb ta has to remain in this order */
|
|
typedef struct TexResult {
|
|
float tin, tr, tg, tb, ta;
|
|
int talpha;
|
|
float *nor;
|
|
} TexResult;
|
|
|
|
/* localized shade result data */
|
|
typedef struct ShadeResult {
|
|
float combined[4];
|
|
float col[4];
|
|
float alpha, mist, z;
|
|
float emit[3];
|
|
float diff[3]; /* diffuse with no ramps, shadow, etc */
|
|
float diffshad[3]; /* diffuse with shadow */
|
|
float spec[3]; /* specular with shadow */
|
|
float shad[4]; /* shad[3] is shadow intensity */
|
|
float ao[3];
|
|
float env[3];
|
|
float indirect[3];
|
|
float refl[3];
|
|
float refr[3];
|
|
float nor[3];
|
|
float winspeed[4];
|
|
float rayhits[4];
|
|
} ShadeResult;
|
|
|
|
/* only here for quick copy */
|
|
struct ShadeInputCopy {
|
|
|
|
struct Material *mat;
|
|
struct VlakRen *vlr;
|
|
struct StrandRen *strand;
|
|
struct ObjectInstanceRen *obi;
|
|
struct ObjectRen *obr;
|
|
int facenr;
|
|
float facenor[3]; /* copy from face */
|
|
short flippednor; /* is facenor flipped? */
|
|
struct VertRen *v1, *v2, *v3; /* vertices can be in any order for quads... */
|
|
short i1, i2, i3; /* original vertex indices */
|
|
short puno;
|
|
short osatex;
|
|
float vn[3], vno[3]; /* actual render normal, and a copy to restore it */
|
|
float n1[3], n2[3], n3[3]; /* vertex normals, corrected */
|
|
int mode, mode2; /* base material mode (OR-ed result of entire node tree) */
|
|
};
|
|
|
|
typedef struct ShadeInputUV {
|
|
float dxuv[3], dyuv[3], uv[3];
|
|
const char *name;
|
|
} ShadeInputUV;
|
|
|
|
typedef struct ShadeInputCol {
|
|
float col[4];
|
|
const char *name;
|
|
} ShadeInputCol;
|
|
|
|
/* localized renderloop data */
|
|
typedef struct ShadeInput {
|
|
/* copy from face, also to extract tria from quad */
|
|
/* note it mirrors a struct above for quick copy */
|
|
|
|
struct Material *mat;
|
|
struct VlakRen *vlr;
|
|
struct StrandRen *strand;
|
|
struct ObjectInstanceRen *obi;
|
|
struct ObjectRen *obr;
|
|
int facenr;
|
|
float facenor[3]; /* copy from face */
|
|
short flippednor; /* is facenor flipped? */
|
|
struct VertRen *v1, *v2, *v3; /* vertices can be in any order for quads... */
|
|
short i1, i2, i3; /* original vertex indices */
|
|
short puno;
|
|
short osatex;
|
|
float vn[3], vno[3]; /* actual render normal, and a copy to restore it */
|
|
float n1[3], n2[3], n3[3]; /* vertex normals, corrected */
|
|
int mode, mode2; /* base material mode (OR-ed result of entire node tree) */
|
|
|
|
/* internal face coordinates */
|
|
float u, v, dx_u, dx_v, dy_u, dy_v;
|
|
float co[3], view[3], camera_co[3];
|
|
|
|
/* copy from material, keep synced so we can do memcopy */
|
|
/* current size: 23*4 */
|
|
float r, g, b;
|
|
float specr, specg, specb;
|
|
float mirr, mirg, mirb;
|
|
float ambr, ambb, ambg;
|
|
|
|
float amb, emit, ang, spectra, ray_mirror;
|
|
float alpha, refl, spec, zoffs, add;
|
|
float translucency;
|
|
/* end direct copy from material */
|
|
|
|
/* individual copies: */
|
|
int har; /* hardness */
|
|
|
|
/* texture coordinates */
|
|
float lo[3], gl[3], ref[3], orn[3], winco[3], vcol[4];
|
|
float refcol[4], displace[3];
|
|
float strandco, tang[3], nmapnorm[3], nmaptang[4], stress, winspeed[4];
|
|
float duplilo[3], dupliuv[3];
|
|
float tangents[8][4]; /* 8 = MAX_MTFACE */
|
|
|
|
ShadeInputUV uv[8]; /* 8 = MAX_MTFACE */
|
|
ShadeInputCol col[8]; /* 8 = MAX_MCOL */
|
|
int totuv, totcol, actuv, actcol;
|
|
|
|
/* dx/dy OSA coordinates */
|
|
float dxco[3], dyco[3];
|
|
float dxlo[3], dylo[3], dxgl[3], dygl[3];
|
|
float dxref[3], dyref[3], dxorn[3], dyorn[3];
|
|
float dxno[3], dyno[3], dxview, dyview;
|
|
float dxlv[3], dylv[3];
|
|
float dxwin[3], dywin[3];
|
|
float dxrefract[3], dyrefract[3];
|
|
float dxstrand, dystrand;
|
|
|
|
/* AO is a pre-process now */
|
|
float ao[3], indirect[3], env[3];
|
|
|
|
int xs, ys; /* pixel to be rendered */
|
|
int mask; /* subsample mask */
|
|
float scanco[3]; /* original scanline coordinate without jitter */
|
|
|
|
int samplenr; /* sample counter, to detect if we should do shadow again */
|
|
int depth; /* 1 or larger on raytrace shading */
|
|
int volume_depth; /* number of intersections through volumes */
|
|
|
|
/* for strand shading, normal at the surface */
|
|
float surfnor[3], surfdist;
|
|
|
|
/* from initialize, part or renderlayer */
|
|
bool do_preview; /* for nodes, in previewrender */
|
|
bool do_manage; /* color management flag */
|
|
bool use_world_space_shading;
|
|
short thread, sample; /* sample: ShadeSample array index */
|
|
short nodes; /* indicate node shading, temp hack to prevent recursion */
|
|
|
|
unsigned int lay;
|
|
int layflag, passflag, combinedflag;
|
|
short object_pass_index;
|
|
|
|
#ifdef RE_RAYCOUNTER
|
|
RayCounter raycounter;
|
|
#endif
|
|
|
|
} ShadeInput;
|
|
|
|
typedef struct BakeImBufuserData {
|
|
float *displacement_buffer;
|
|
char *mask_buffer;
|
|
} BakeImBufuserData;
|
|
|
|
/* node shaders... */
|
|
struct Tex;
|
|
struct MTex;
|
|
struct ImBuf;
|
|
struct ImagePool;
|
|
struct Object;
|
|
|
|
/* this one uses nodes */
|
|
int multitex_ext(struct Tex *tex,
|
|
float texvec[3],
|
|
float dxt[3], float dyt[3],
|
|
int osatex,
|
|
struct TexResult *texres,
|
|
const short thread,
|
|
struct ImagePool *pool,
|
|
bool scene_color_manage,
|
|
const bool skip_load_image);
|
|
/* nodes disabled */
|
|
int multitex_ext_safe(struct Tex *tex, float texvec[3], struct TexResult *texres, struct ImagePool *pool, bool scene_color_manage, const bool skip_load_image);
|
|
/* only for internal node usage */
|
|
int multitex_nodes(struct Tex *tex, float texvec[3], float dxt[3], float dyt[3], int osatex, struct TexResult *texres,
|
|
const short thread, short which_output, struct ShadeInput *shi, struct MTex *mtex,
|
|
struct ImagePool *pool);
|
|
float RE_lamp_get_data(struct ShadeInput *shi, struct Object *lamp_obj, float col[4], float lv[3], float *dist, float shadow[4]);
|
|
void RE_instance_get_particle_info(struct ObjectInstanceRen *obi, float *index, float *random, float *age, float *lifetime, float co[3], float *size, float vel[3], float angvel[3]);
|
|
|
|
float RE_fresnel_dielectric(float incoming[3], float normal[3], float eta);
|
|
|
|
/* shaded view and bake */
|
|
struct Render;
|
|
struct Image;
|
|
|
|
int RE_bake_shade_all_selected(struct Render *re, int type, struct Object *actob, short *do_update, float *progress);
|
|
struct Image *RE_bake_shade_get_image(void);
|
|
void RE_bake_ibuf_filter(struct ImBuf *ibuf, char *mask, const int filter);
|
|
void RE_bake_ibuf_normalize_displacement(struct ImBuf *ibuf, float *displacement, char *mask, float displacement_min, float displacement_max);
|
|
float RE_bake_make_derivative(struct ImBuf *ibuf, float *heights_buffer, const char *mask,
|
|
const float height_min, const float height_max,
|
|
const float fmult);
|
|
|
|
enum {
|
|
RE_OBJECT_INSTANCE_MATRIX_OB,
|
|
RE_OBJECT_INSTANCE_MATRIX_OBINV,
|
|
RE_OBJECT_INSTANCE_MATRIX_LOCALTOVIEW,
|
|
RE_OBJECT_INSTANCE_MATRIX_LOCALTOVIEWINV,
|
|
};
|
|
|
|
const float (*RE_object_instance_get_matrix(struct ObjectInstanceRen *obi, int matrix_id))[4];
|
|
|
|
float RE_object_instance_get_object_pass_index(struct ObjectInstanceRen *obi);
|
|
float RE_object_instance_get_random_id(struct ObjectInstanceRen *obi);
|
|
|
|
enum {
|
|
RE_VIEW_MATRIX,
|
|
RE_VIEWINV_MATRIX,
|
|
};
|
|
|
|
const float (*RE_render_current_get_matrix(int matrix_id))[4];
|
|
|
|
#define BAKE_RESULT_OK 0
|
|
#define BAKE_RESULT_NO_OBJECTS 1
|
|
#define BAKE_RESULT_FEEDBACK_LOOP 2
|
|
|
|
#endif /* __RE_SHADER_EXT_H__ */
|