Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--source/Makefile2
-rw-r--r--source/blender/blenkernel/intern/material.c4
-rw-r--r--source/blender/makesdna/DNA_material_types.h1
-rw-r--r--source/blender/makesdna/DNA_scene_types.h4
-rw-r--r--source/blender/radiosity/extern/include/radio.h5
-rw-r--r--source/blender/radiosity/intern/source/radfactors.c2
-rw-r--r--source/blender/radiosity/intern/source/radrender.c541
-rw-r--r--source/blender/render/extern/include/render_types.h11
-rw-r--r--source/blender/render/intern/source/initrender.c17
-rw-r--r--source/blender/render/intern/source/renderPreAndPost.c4
-rw-r--r--source/blender/render/intern/source/rendercore.c27
-rw-r--r--source/blender/render/intern/source/zbuf.c81
-rw-r--r--source/blender/renderconverter/intern/convertBlenderScene.c13
-rw-r--r--source/blender/src/buttons.c199
14 files changed, 772 insertions, 139 deletions
diff --git a/source/Makefile b/source/Makefile
index c256a0291ce..7b84cac1a49 100644
--- a/source/Makefile
+++ b/source/Makefile
@@ -74,7 +74,6 @@ PYPLAYERLIB ?= $(PYLIB)
GRPLIB = $(OCGDIR)/creator/$(DEBUG_DIR)libcreator.a
GRPLIB += $(OCGDIR)/blender/src/$(DEBUG_DIR)libsrcpublisher.a
- GRPLIB += $(OCGDIR)/blender/radiosity/$(DEBUG_DIR)libradiosity.a
GRPLIB += $(NAN_DECIMATION)/lib/libdecimation.a
GRPLIB += $(NAN_BSP)/lib/$(DEBUG_DIR)libbsp.a
GRPLIB += $(NAN_SOUNDSYSTEM)/lib/$(DEBUG_DIR)libSoundSystem.a
@@ -83,6 +82,7 @@ PYPLAYERLIB ?= $(PYLIB)
GRPLIB += $(OCGDIR)/blender/img/$(DEBUG_DIR)libimg.a
GRPLIB += $(OCGDIR)/blender/renderconverter/$(DEBUG_DIR)librenderconverter.a
GRPLIB += $(OCGDIR)/blender/render/$(DEBUG_DIR)librender.a
+ GRPLIB += $(OCGDIR)/blender/radiosity/$(DEBUG_DIR)libradiosity.a
GRPLIB += $(OCGDIR)/blender/python/$(DEBUG_DIR)libpython.a
diff --git a/source/blender/blenkernel/intern/material.c b/source/blender/blenkernel/intern/material.c
index a74670dbde9..5d0c1fcc739 100644
--- a/source/blender/blenkernel/intern/material.c
+++ b/source/blender/blenkernel/intern/material.c
@@ -102,7 +102,7 @@ void init_material(Material *ma)
ma->param[3]= 0.1;
- ma->mode= MA_TRACEBLE+MA_SHADOW;
+ ma->mode= MA_TRACEBLE+MA_SHADOW+MA_RADIO;
}
Material *add_material(char *name)
@@ -566,6 +566,8 @@ void init_render_material(Material *ma)
}
if(ma->mode & MA_VERTEXCOLP) ma->mode |= MA_VERTEXCOL;
+ if(ma->mode & MA_RADIO) needuv= 1;
+
if(ma->mode & (MA_VERTEXCOL|MA_FACETEXTURE)) {
needuv= 1;
if(R.osa) ma->texco |= TEXCO_OSA; /* for texfaces */
diff --git a/source/blender/makesdna/DNA_material_types.h b/source/blender/makesdna/DNA_material_types.h
index 36b3e811953..e7639d97d5a 100644
--- a/source/blender/makesdna/DNA_material_types.h
+++ b/source/blender/makesdna/DNA_material_types.h
@@ -122,6 +122,7 @@ typedef struct Material {
#define MA_NOMIST 0x4000
#define MA_HALO_SHADE 0x4000
#define MA_HALO_FLARE 0x8000
+#define MA_RADIO 0x10000
/* diff_shader */
#define MA_DIFF_LAMBERT 0
diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h
index 7ce8447da6a..a6241f8d607 100644
--- a/source/blender/makesdna/DNA_scene_types.h
+++ b/source/blender/makesdna/DNA_scene_types.h
@@ -170,7 +170,7 @@ typedef struct RenderData {
* 5: edge shading
* 6: field rendering
* 7: Disables time difference in field calculations
- * 8: Gauss ? is this for sampling?
+ * 8: radio rendering
* 9: borders
* 10: panorama
* 11: crop
@@ -272,7 +272,7 @@ typedef struct Scene {
#define R_EDGE 0x0020
#define R_FIELDS 0x0040
#define R_FIELDSTILL 0x0080
-#define R_GAUSS 0x0100
+#define R_RADIO 0x0100
#define R_BORDER 0x0200
#define R_PANORAMA 0x0400
#define R_MOVIECROP 0x0800
diff --git a/source/blender/radiosity/extern/include/radio.h b/source/blender/radiosity/extern/include/radio.h
index 23190a02ec2..2f4e1ff5408 100644
--- a/source/blender/radiosity/extern/include/radio.h
+++ b/source/blender/radiosity/extern/include/radio.h
@@ -164,8 +164,11 @@ extern void setcolNode(RNode *rn, unsigned int *col);
extern void pseudoAmb(void);
extern void rad_forcedraw(void);
extern void drawpatch_ext(RPatch *patch, unsigned int col);
-
extern void RAD_drawall(int depth_is_on);
+/* radrender.c */
+extern void do_radio_render(void);
+void end_radio_render(void);
+
#endif /* RADIO_H */
diff --git a/source/blender/radiosity/intern/source/radfactors.c b/source/blender/radiosity/intern/source/radfactors.c
index d0b6a7752a9..5e2812138e2 100644
--- a/source/blender/radiosity/intern/source/radfactors.c
+++ b/source/blender/radiosity/intern/source/radfactors.c
@@ -479,7 +479,7 @@ void backface_test(RPatch *shoot)
if(rp!=shoot) {
VecSubf(tvec, shoot->cent, rp->cent);
- if( tvec[0]*shoot->norm[0]+ tvec[1]*shoot->norm[1]+ tvec[2]*shoot->norm[2]>0.0) {
+ if( tvec[0]*rp->norm[0]+ tvec[1]*rp->norm[1]+ tvec[2]*rp->norm[2]<0.0) {
setnodeflags(rp->first, RAD_BACKFACE, 1);
}
}
diff --git a/source/blender/radiosity/intern/source/radrender.c b/source/blender/radiosity/intern/source/radrender.c
new file mode 100644
index 00000000000..151b5cd40ff
--- /dev/null
+++ b/source/blender/radiosity/intern/source/radrender.c
@@ -0,0 +1,541 @@
+/* ***************************************
+ *
+ * ***** BEGIN GPL/BL DUAL 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License. See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+/* radrender.c, aug 2003
+ *
+ * Most of the code here is copied from radiosity code, to optimize for renderfaces.
+ * Shared function calls mostly reside in radfactors.c
+ * No adaptive subdivision takes place
+ *
+ * - do_radio_render(); main call, extern
+ * - initradfaces(); add radface structs in render faces, init radio globals
+ * -
+ * - initradiosity(); LUTs
+ * - inithemiwindows();
+ * - progressiverad(); main itteration loop
+ * - hemi zbuffers
+ * - calc rad factors
+ *
+ * - closehemiwindows();
+ * - freeAllRad();
+ * - make vertex colors
+ *
+ * - during render, materials use totrad as ambient replacement
+ * - free radfaces
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_rand.h"
+
+#include "BKE_utildefines.h"
+#include "BKE_global.h"
+#include "BKE_main.h"
+
+#include "BIF_screen.h"
+
+#include "radio.h"
+#include "render.h"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* only needed now for a print, if its useful move to RG */
+static float maxenergy;
+
+/* find the face with maximum energy to become shooter */
+/* nb: _rr means rad-render version of existing radio call */
+VlakRen *findshoot_rr()
+{
+ RadFace *rf;
+ VlakRen *vlr=NULL, *shoot;
+ float energy;
+ int a;
+
+ shoot= NULL;
+ maxenergy= 0.0;
+
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+ if(vlr->radface) {
+ rf= vlr->radface;
+ rf->flag &= ~RAD_SHOOT;
+
+ energy= rf->unshot[0]*rf->area;
+ energy+= rf->unshot[1]*rf->area;
+ energy+= rf->unshot[2]*rf->area;
+
+ if(energy>maxenergy) {
+ shoot= vlr;
+ maxenergy= energy;
+ }
+ }
+ }
+
+ if(shoot) {
+ maxenergy/= RG.totenergy;
+ if(maxenergy<RG.convergence) return NULL;
+ shoot->radface->flag |= RAD_SHOOT;
+ }
+
+ return shoot;
+}
+
+void backface_test_rr(VlakRen *shoot)
+{
+ VlakRen *vlr=NULL;
+ RadFace *rf;
+ float tvec[3];
+ int a;
+
+ /* backface testing */
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+ if(vlr->radface) {
+ rf= vlr->radface;
+ if(vlr!=shoot) {
+
+ VecSubf(tvec, shoot->radface->cent, rf->cent);
+
+ if( tvec[0]*rf->norm[0]+ tvec[1]*rf->norm[1]+ tvec[2]*rf->norm[2] < 0.0) {
+ rf->flag |= RAD_BACKFACE;
+ }
+ }
+ }
+ }
+}
+
+void clear_backface_test_rr()
+{
+ VlakRen *vlr=NULL;
+ RadFace *rf;
+ int a;
+
+ /* backface flag clear */
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+ rf->flag &= ~RAD_BACKFACE;
+ }
+ }
+}
+
+extern RadView hemitop, hemiside; // radfactors.c
+
+/* hemi-zbuffering, delivers formfactors array */
+void makeformfactors_rr(VlakRen *shoot)
+{
+ VlakRen *vlr=NULL;
+ RadFace *rf;
+ float len, vec[3], up[3], side[3], tar[5][3], *fp;
+ int a;
+
+ memset(RG.formfactors, 0, sizeof(float)*RG.totelem);
+
+ /* set up hemiview */
+ /* first: upvector for hemitop, we use diagonal hemicubes to prevent aliasing */
+
+ VecSubf(vec, shoot->v1->co, shoot->radface->cent);
+ Crossf(up, shoot->radface->norm, vec);
+ len= Normalise(up);
+
+ VECCOPY(hemitop.up, up);
+ VECCOPY(hemiside.up, shoot->radface->norm);
+
+ Crossf(side, shoot->radface->norm, up);
+
+ /* five targets */
+ VecAddf(tar[0], shoot->radface->cent, shoot->radface->norm);
+ VecAddf(tar[1], shoot->radface->cent, up);
+ VecSubf(tar[2], shoot->radface->cent, up);
+ VecAddf(tar[3], shoot->radface->cent, side);
+ VecSubf(tar[4], shoot->radface->cent, side);
+
+ /* camera */
+ VECCOPY(hemiside.cam, shoot->radface->cent);
+ VECCOPY(hemitop.cam, shoot->radface->cent);
+
+ /* do it! */
+ VECCOPY(hemitop.tar, tar[0]);
+ hemizbuf(&hemitop);
+
+ for(a=1; a<5; a++) {
+ VECCOPY(hemiside.tar, tar[a]);
+ hemizbuf(&hemiside);
+ }
+
+ /* convert factors to real radiosity */
+ fp= RG.formfactors;
+
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+ if(*fp!=0.0 && rf->area!=0.0) {
+ *fp *= shoot->radface->area/rf->area;
+ if(*fp>1.0) *fp= 1.0001;
+ }
+ fp++;
+ }
+ }
+}
+
+/* based at RG.formfactors array, distribute shoot energy over other faces */
+void applyformfactors_rr(VlakRen *shoot)
+{
+ VlakRen *vlr=NULL;
+ RadFace *rf;
+ float *fp, *ref, unr, ung, unb, r, g, b;
+ int a;
+
+ unr= shoot->radface->unshot[0];
+ ung= shoot->radface->unshot[1];
+ unb= shoot->radface->unshot[2];
+
+ fp= RG.formfactors;
+
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+ if(*fp!= 0.0) {
+
+ ref= &(vlr->mat->r);
+
+ r= (*fp)*unr*ref[0];
+ g= (*fp)*ung*ref[1];
+ b= (*fp)*unb*ref[2];
+
+
+ rf->totrad[0]+= r;
+ rf->totrad[1]+= g;
+ rf->totrad[2]+= b;
+
+ rf->unshot[0]+= r;
+ rf->unshot[1]+= g;
+ rf->unshot[2]+= b;
+ }
+ fp++;
+ }
+ }
+ /* shoot energy has been shot */
+ shoot->radface->unshot[0]= shoot->radface->unshot[1]= shoot->radface->unshot[2]= 0.0;
+}
+
+
+/* main loop for itterations */
+void progressiverad_rr()
+{
+ VlakRen *shoot;
+ int it= 0;
+
+ shoot= findshoot_rr();
+ while( shoot ) {
+
+ /* backfaces receive no energy, but are zbuffered */
+ backface_test_rr(shoot);
+ /* hemi-zbuffers */
+ makeformfactors_rr(shoot);
+ /* based at RG.formfactors array, distribute shoot energy over other faces */
+ applyformfactors_rr(shoot);
+
+ it++;
+ printf("\r Radiostity step %d", it); fflush(stdout);
+
+ clear_backface_test_rr();
+
+ if(blender_test_break()) break;
+ if(RG.maxiter && RG.maxiter<=it) break;
+
+ shoot= findshoot_rr();
+ }
+ printf("\n Unshot energy:%f\n", 1000.0*maxenergy);
+}
+
+static RadFace *radfaces=NULL;
+
+void initradfaces()
+{
+ VlakRen *vlr= NULL;
+ RadFace *rf;
+ int a, b;
+
+ /* globals */
+ RG.totenergy= 0.0;
+ RG.totpatch= 0; // we count initial emittors here
+ RG.totelem= 0; // total # faces are put here (so we can use radfactors.c calls)
+ /* size is needed for hemicube clipping */
+ RG.min[0]= RG.min[1]= RG.min[2]= 1.0e20;
+ RG.max[0]= RG.max[1]= RG.max[2]= -1.0e20;
+
+ /* count first for fast malloc */
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->mat->mode & MA_RADIO) {
+ if(vlr->mat->emit > 0.0) {
+ RG.totpatch++;
+ }
+ RG.totelem++;
+ }
+ }
+
+printf(" Rad elems: %d emittors %d\n", RG.totelem, RG.totpatch);
+ if(RG.totelem==0 || RG.totpatch==0) return;
+
+ /* make/init radfaces */
+ rf=radfaces= MEM_callocN(RG.totelem*sizeof(RadFace), "radfaces");
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->mat->mode & MA_RADIO) {
+
+ /* during render, vlr->n gets flipped/corrected, we cannot have that */
+ if(vlr->v4) CalcNormFloat4(vlr->v1->co, vlr->v2->co, vlr->v3->co, vlr->v4->co, rf->norm);
+ else CalcNormFloat(vlr->v1->co, vlr->v2->co, vlr->v3->co, rf->norm);
+
+ rf->totrad[0]= vlr->mat->emit*vlr->mat->r;
+ rf->totrad[1]= vlr->mat->emit*vlr->mat->g;
+ rf->totrad[2]= vlr->mat->emit*vlr->mat->b;
+ VECCOPY(rf->unshot, rf->totrad);
+
+ if(vlr->v4) {
+ rf->area= AreaQ3Dfl(vlr->v1->co, vlr->v2->co, vlr->v3->co, vlr->v4->co);
+ CalcCent4f(rf->cent, vlr->v1->co, vlr->v2->co, vlr->v3->co, vlr->v4->co);
+ }
+ else {
+ rf->area= AreaT3Dfl(vlr->v1->co, vlr->v2->co, vlr->v3->co);
+ CalcCent3f(rf->cent, vlr->v1->co, vlr->v2->co, vlr->v3->co);
+ }
+
+ RG.totenergy+= rf->unshot[0]*rf->area;
+ RG.totenergy+= rf->unshot[1]*rf->area;
+ RG.totenergy+= rf->unshot[2]*rf->area;
+
+ for(b=0; b<3; b++) {
+ RG.min[b]= MIN2(RG.min[b], rf->cent[b]);
+ RG.max[b]= MAX2(RG.max[b], rf->cent[b]);
+ }
+
+
+ vlr->radface= rf++;
+ }
+ }
+ RG.size[0]= (RG.max[0]- RG.min[0]);
+ RG.size[1]= (RG.max[1]- RG.min[1]);
+ RG.size[2]= (RG.max[2]- RG.min[2]);
+ RG.maxsize= MAX3(RG.size[0],RG.size[1],RG.size[2]);
+
+ /* formfactor array */
+ if(RG.formfactors) MEM_freeN(RG.formfactors);
+ if(RG.totelem)
+ RG.formfactors= MEM_mallocN(sizeof(float)*RG.totelem, "formfactors");
+ else
+ RG.formfactors= NULL;
+
+}
+
+static void vecaddfac(float *vec, float *v1, float *v2, float fac)
+{
+ vec[0]= v1[0] + fac*v2[0];
+ vec[1]= v1[1] + fac*v2[1];
+ vec[2]= v1[2] + fac*v2[2];
+
+}
+
+/* unused now, doesnt work... */
+void filter_rad_values()
+{
+ VlakRen *vlr=NULL;
+ VertRen *v1=NULL;
+ RadFace *rf;
+ float n1[3], n2[3], n3[4], n4[3], co[4];
+ int a;
+
+ /* one filter pass */
+ for(a=0; a<R.totvert; a++) {
+ if((a & 255)==0) v1= R.blove[a>>8]; else v1++;
+ if(v1->accum>0.0) {
+ v1->rad[0]= v1->rad[0]/v1->accum;
+ v1->rad[1]= v1->rad[1]/v1->accum;
+ v1->rad[2]= v1->rad[2]/v1->accum;
+ v1->accum= 0.0;
+ }
+ }
+ /* cosines in verts accumulate in faces */
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+
+ /* calculate cosines of angles, for weighted add (irregular faces) */
+ VecSubf(n1, vlr->v2->co, vlr->v1->co);
+ VecSubf(n2, vlr->v3->co, vlr->v2->co);
+ Normalise(n1);
+ Normalise(n2);
+
+ if(vlr->v4==NULL) {
+ VecSubf(n3, vlr->v1->co, vlr->v3->co);
+ Normalise(n3);
+
+ co[0]= saacos(-n3[0]*n1[0]-n3[1]*n1[1]-n3[2]*n1[2])/M_PI;
+ co[1]= saacos(-n1[0]*n2[0]-n1[1]*n2[1]-n1[2]*n2[2])/M_PI;
+ co[2]= saacos(-n2[0]*n3[0]-n2[1]*n3[1]-n2[2]*n3[2])/M_PI;
+ co[0]= co[1]= co[2]= 1.0/3.0;
+ }
+ else {
+ VecSubf(n3, vlr->v4->co, vlr->v3->co);
+ VecSubf(n4, vlr->v1->co, vlr->v4->co);
+ Normalise(n3);
+ Normalise(n4);
+
+ co[0]= saacos(-n4[0]*n1[0]-n4[1]*n1[1]-n4[2]*n1[2])/M_PI;
+ co[1]= saacos(-n1[0]*n2[0]-n1[1]*n2[1]-n1[2]*n2[2])/M_PI;
+ co[2]= saacos(-n2[0]*n3[0]-n2[1]*n3[1]-n2[2]*n3[2])/M_PI;
+ co[3]= saacos(-n3[0]*n4[0]-n3[1]*n4[1]-n3[2]*n4[2])/M_PI;
+ co[0]= co[1]= co[2]= co[3]= 1.0/4.0;
+ }
+
+ rf->totrad[0]= rf->totrad[1]= rf->totrad[2]= 0.0;
+
+ vecaddfac(rf->totrad, rf->totrad, vlr->v1->rad, co[0]);
+ vecaddfac(rf->totrad, rf->totrad, vlr->v2->rad, co[1]);
+ vecaddfac(rf->totrad, rf->totrad, vlr->v3->rad, co[2]);
+ if(vlr->v4) {
+ vecaddfac(rf->totrad, rf->totrad, vlr->v4->rad, co[3]);
+ }
+ }
+ }
+
+ /* accumulate vertexcolors again */
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+
+ vecaddfac(vlr->v1->rad, vlr->v1->rad, rf->totrad, rf->area);
+ vlr->v1->accum+= rf->area;
+ vecaddfac(vlr->v2->rad, vlr->v2->rad, rf->totrad, rf->area);
+ vlr->v2->accum+= rf->area;
+ vecaddfac(vlr->v3->rad, vlr->v3->rad, rf->totrad, rf->area);
+ vlr->v3->accum+= rf->area;
+ if(vlr->v4) {
+ vecaddfac(vlr->v4->rad, vlr->v4->rad, rf->totrad, rf->area);
+ vlr->v4->accum+= rf->area;
+ }
+ }
+ }
+
+}
+
+void make_vertex_rad_values()
+{
+ VertRen *v1=NULL;
+ VlakRen *vlr=NULL;
+ RadFace *rf;
+ int a;
+
+ /* accumulate vertexcolors */
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+
+ vecaddfac(vlr->v1->rad, vlr->v1->rad, rf->totrad, rf->area);
+ vlr->v1->accum+= rf->area;
+ vecaddfac(vlr->v2->rad, vlr->v2->rad, rf->totrad, rf->area);
+ vlr->v2->accum+= rf->area;
+ vecaddfac(vlr->v3->rad, vlr->v3->rad, rf->totrad, rf->area);
+ vlr->v3->accum+= rf->area;
+ if(vlr->v4) {
+ vecaddfac(vlr->v4->rad, vlr->v4->rad, rf->totrad, rf->area);
+ vlr->v4->accum+= rf->area;
+ }
+ }
+ }
+
+ /* make vertex colors */
+ RG.igamma= 1.0/RG.gamma;
+ RG.radfactor= RG.radfac*pow(64*64, RG.igamma)/256.0; /* compatible with radio-tool */
+
+ for(a=0; a<R.totvert; a++) {
+ if((a & 255)==0) v1= R.blove[a>>8]; else v1++;
+ if(v1->accum>0.0) {
+ v1->rad[0]= RG.radfactor*pow( v1->rad[0]/v1->accum, RG.igamma);
+ v1->rad[1]= RG.radfactor*pow( v1->rad[1]/v1->accum, RG.igamma);
+ v1->rad[2]= RG.radfactor*pow( v1->rad[2]/v1->accum, RG.igamma);
+ }
+ }
+
+}
+
+/* main call, extern */
+void do_radio_render(void)
+{
+ if(G.scene->radio==NULL) add_radio();
+ freeAllRad(); /* just in case radio-tool is still used */
+
+ set_radglobal(); /* init the RG struct */
+
+ initradfaces(); /* add radface structs to render faces */
+ if(RG.totenergy==0.0) return;
+
+ initradiosity(); /* LUT's */
+ inithemiwindows(); /* views, need RG.maxsize for clipping */
+
+ progressiverad_rr(); /* main radio loop */
+
+ freeAllRad(); /* luts, hemis, sets vars at zero */
+
+ make_vertex_rad_values(); /* convert face energy to vertex ones */
+}
+
+/* free call, after rendering, extern */
+void end_radio_render(void)
+{
+ if(radfaces) MEM_freeN(radfaces);
+ radfaces= NULL;
+}
+
diff --git a/source/blender/render/extern/include/render_types.h b/source/blender/render/extern/include/render_types.h
index 2f33ae686a5..6b790c66936 100644
--- a/source/blender/render/extern/include/render_types.h
+++ b/source/blender/render/extern/include/render_types.h
@@ -54,7 +54,7 @@
typedef struct RE_Render
{
float co[3];
- float lo[3], gl[3], uv[3], ref[3], orn[3], winco[3], sticky[3], vcol[3];
+ float lo[3], gl[3], uv[3], ref[3], orn[3], winco[3], sticky[3], vcol[3], rad[3];
float itot, i, ic, rgb, norm;
float vn[3], view[3], *vno, refcol[4];
@@ -152,10 +152,12 @@ typedef struct VertRen
float co[3];
float n[3];
float ho[4];
+ float rad[3]; /* result radio rendering */
float *orco;
float *sticky;
void *svert; /* smooth vert, only used during initrender */
short clip, texofs; /* texofs= flag */
+ float accum; /* accum for radio weighting */
} VertRen;
/* ------------------------------------------------------------------------- */
@@ -170,6 +172,12 @@ struct Material;
struct MFace;
struct TFace;
+typedef struct RadFace {
+ float unshot[3], totrad[3];
+ float norm[3], cent[3], area;
+ int flag;
+} RadFace;
+
typedef struct VlakRen
{
struct VertRen *v1, *v2, *v3, *v4;
@@ -181,6 +189,7 @@ typedef struct VlakRen
char snproj, puno;
char flag, ec;
unsigned int lay;
+ RadFace *radface;
} VlakRen;
diff --git a/source/blender/render/intern/source/initrender.c b/source/blender/render/intern/source/initrender.c
index bd331aa44d8..37e6f4deb56 100644
--- a/source/blender/render/intern/source/initrender.c
+++ b/source/blender/render/intern/source/initrender.c
@@ -178,15 +178,16 @@ float calc_weight(float *weight, int i, int j)
weight[a]= 0.0;
- if(R.r.mode & R_GAUSS) {
- if(dist<1.5) {
- x = dist*1.5;
- weight[a]= (1.0/exp(x*x) - 1.0/exp(1.5*1.5*1.5*1.5));
- }
- }
- else {
+ /* gaussian weighting has been cancelled */
+ //if(R.r.mode & R_GAUSS) {
+ // if(dist<1.5) {
+ // x = dist*1.5;
+ // weight[a]= (1.0/exp(x*x) - 1.0/exp(1.5*1.5*1.5*1.5));
+ // }
+ //}
+ //else {
if(i==0 && j==0) weight[a]= 1.0;
- }
+ //}
totw+= weight[a];
diff --git a/source/blender/render/intern/source/renderPreAndPost.c b/source/blender/render/intern/source/renderPreAndPost.c
index 678f241a1e2..63a59bc659b 100644
--- a/source/blender/render/intern/source/renderPreAndPost.c
+++ b/source/blender/render/intern/source/renderPreAndPost.c
@@ -43,6 +43,7 @@
#include "envmap.h"
#include "renderHelp.h"
#include "shadowBuffer.h"
+#include "radio.h"
#ifdef HAVE_CONFIG_H
#include <config.h>
@@ -79,6 +80,9 @@ void prepareScene()
}
}
+ /* RADIO */
+ if(R.r.mode & R_RADIO) do_radio_render();
+
/* ENVIRONMENT MAPS */
make_envmaps();
}
diff --git a/source/blender/render/intern/source/rendercore.c b/source/blender/render/intern/source/rendercore.c
index d9066494284..0153974c370 100644
--- a/source/blender/render/intern/source/rendercore.c
+++ b/source/blender/render/intern/source/rendercore.c
@@ -1896,26 +1896,33 @@ void shade_lamp_loop()
else ma->alpha= (1.0-t)*R.mat->alpha+t;
}
}
+
+ if( ma->mode & MA_RADIO) {
+ ir+= ma->amb*R.rad[0];
+ ig+= ma->amb*R.rad[1];
+ ib+= ma->amb*R.rad[2];
+ }
+
if(R.refcol[0]==0.0) {
- a= 65535.0*( ma->r*ir +ma->ambr +isr);
+ a= 65535.0*( ma->r*ir +ma->ambr +isr +ma->amb*R.rad[0]);
if(a>65535) a=65535; else if(a<0) a= 0;
shortcol[0]= a;
- a= 65535.0*(ma->g*ig +ma->ambg +isg);
+ a= 65535.0*(ma->g*ig +ma->ambg +isg +ma->amb*R.rad[1]);
if(a>65535) a=65535; else if(a<0) a= 0;
shortcol[1]= a;
- a= 65535*(ma->b*ib +ma->ambb +isb);
+ a= 65535*(ma->b*ib +ma->ambb +isb + ma->amb*R.rad[2]);
if(a>65535) a=65535; else if(a<0) a= 0;
shortcol[2]= a;
}
else {
- a= 65535.0*( ma->mirr*R.refcol[1] + (1.0 - ma->mirr*R.refcol[0])*(ma->r*ir +ma->ambr) +isr);
+ a= 65535.0*( ma->mirr*R.refcol[1] + (1.0 - ma->mirr*R.refcol[0])*(ma->r*ir +ma->ambr +ma->amb*R.rad[0]) +isr);
if(a>65535) a=65535; else if(a<0) a= 0;
shortcol[0]= a;
- a= 65535.0*( ma->mirg*R.refcol[2] + (1.0 - ma->mirg*R.refcol[0])*(ma->g*ig +ma->ambg) +isg);
+ a= 65535.0*( ma->mirg*R.refcol[2] + (1.0 - ma->mirg*R.refcol[0])*(ma->g*ig +ma->ambg +ma->amb*R.rad[1]) +isg);
if(a>65535) a=65535; else if(a<0) a= 0;
shortcol[1]= a;
- a= 65535.0*( ma->mirb*R.refcol[3] + (1.0 - ma->mirb*R.refcol[0])*(ma->b*ib +ma->ambb) +isb);
+ a= 65535.0*( ma->mirb*R.refcol[3] + (1.0 - ma->mirb*R.refcol[0])*(ma->b*ib +ma->ambb +ma->amb*R.rad[2]) +isb);
if(a>65535) a=65535; else if(a<0) a= 0;
shortcol[2]= a;
}
@@ -2266,6 +2273,14 @@ void shadepixel(float x, float y, int vlaknr)
R.vcol[2]= 0.0;
}
}
+ if(R.matren->mode & MA_RADIO) {
+ R.rad[0]= (l*v3->rad[0] - u*v1->rad[0] - v*v2->rad[0]);
+ R.rad[1]= (l*v3->rad[1] - u*v1->rad[1] - v*v2->rad[1]);
+ R.rad[2]= (l*v3->rad[2] - u*v1->rad[2] - v*v2->rad[2]);
+ }
+ else {
+ R.rad[0]= R.rad[1]= R.rad[2]= 0.0;
+ }
if(R.matren->mode & MA_FACETEXTURE) {
if((R.matren->mode & MA_VERTEXCOL)==0) {
R.vcol[0]= 1.0;
diff --git a/source/blender/render/intern/source/zbuf.c b/source/blender/render/intern/source/zbuf.c
index 4b0a8652a68..1cbe015731a 100644
--- a/source/blender/render/intern/source/zbuf.c
+++ b/source/blender/render/intern/source/zbuf.c
@@ -1876,10 +1876,9 @@ static int hashlist_projectvert(float *v1, float *hoco)
return buck->clip;
}
-
+/* used for booth radio 'tool' as during render */
void RE_zbufferall_radio(struct RadView *vw, RNode **rg_elem, int rg_totelem)
{
- RNode **re, *rn;
float hoco[4][4];
int a;
int c1, c2, c3, c4= 0;
@@ -1910,31 +1909,67 @@ void RE_zbufferall_radio(struct RadView *vw, RNode **rg_elem, int rg_totelem)
fillrect(R.rectot, R.rectx, R.recty, 0xFFFFFF);
zbuffunc= zbufinvulGL;
-
- re= rg_elem;
- re+= (rg_totelem-1);
- for(a= rg_totelem-1; a>=0; a--, re--) {
- rn= *re;
- if( (rn->f & RAD_SHOOT)==0 ) { /* no shootelement */
-
- if( rn->f & RAD_BACKFACE) Zvlnr= 0xFFFFFF;
- else Zvlnr= a;
-
- c1= hashlist_projectvert(rn->v1, hoco[0]);
- c2= hashlist_projectvert(rn->v2, hoco[1]);
- c3= hashlist_projectvert(rn->v3, hoco[2]);
-
- if(rn->v4) {
- c4= hashlist_projectvert(rn->v4, hoco[3]);
+
+ if(rg_elem) { /* radio tool */
+ RNode **re, *rn;
+
+ re= rg_elem;
+ re+= (rg_totelem-1);
+ for(a= rg_totelem-1; a>=0; a--, re--) {
+ rn= *re;
+ if( (rn->f & RAD_SHOOT)==0 ) { /* no shootelement */
+
+ if( rn->f & RAD_BACKFACE) Zvlnr= 0xFFFFFF;
+ else Zvlnr= a;
+
+ c1= hashlist_projectvert(rn->v1, hoco[0]);
+ c2= hashlist_projectvert(rn->v2, hoco[1]);
+ c3= hashlist_projectvert(rn->v3, hoco[2]);
+
+ if(rn->v4) {
+ c4= hashlist_projectvert(rn->v4, hoco[3]);
+ }
+
+ zbufclip(hoco[0], hoco[1], hoco[2], c1, c2, c3);
+ if(rn->v4) {
+ zbufclip(hoco[0], hoco[2], hoco[3], c1, c3, c4);
+ }
}
-
- zbufclip(hoco[0], hoco[1], hoco[2], c1, c2, c3);
- if(rn->v4) {
- zbufclip(hoco[0], hoco[2], hoco[3], c1, c3, c4);
+ }
+ }
+ else { /* radio render */
+ VlakRen *vlr=NULL;
+ RadFace *rf;
+ int totface=0;
+
+ for(a=0; a<R.totvlak; a++) {
+ if((a & 255)==0) vlr= R.blovl[a>>8]; else vlr++;
+
+ if(vlr->radface) {
+ rf= vlr->radface;
+ if( (rf->flag & RAD_SHOOT)==0 ) { /* no shootelement */
+
+ if( rf->flag & RAD_BACKFACE) Zvlnr= 0xFFFFFF; /* receives no energy, but is zbuffered */
+ else Zvlnr= totface;
+
+ c1= hashlist_projectvert(vlr->v1->co, hoco[0]);
+ c2= hashlist_projectvert(vlr->v2->co, hoco[1]);
+ c3= hashlist_projectvert(vlr->v3->co, hoco[2]);
+
+ if(vlr->v4) {
+ c4= hashlist_projectvert(vlr->v4->co, hoco[3]);
+ }
+
+ zbufclip(hoco[0], hoco[1], hoco[2], c1, c2, c3);
+ if(vlr->v4) {
+ zbufclip(hoco[0], hoco[2], hoco[3], c1, c3, c4);
+ }
+ }
+ totface++;
}
}
}
-
+
/* restore */
R.rectx= rectxo;
R.recty= rectyo;
diff --git a/source/blender/renderconverter/intern/convertBlenderScene.c b/source/blender/renderconverter/intern/convertBlenderScene.c
index 2008236b0ec..b86ed966d5b 100644
--- a/source/blender/renderconverter/intern/convertBlenderScene.c
+++ b/source/blender/renderconverter/intern/convertBlenderScene.c
@@ -1499,7 +1499,7 @@ static void init_render_mesh(Object *ob)
float xn, yn, zn, nor[3], imat[3][3], mat[4][4];
float *extverts=0, *orco;
int a, a1, ok, do_puno, need_orco=0, totvlako, totverto, vertofs;
- int start, end, flipnorm;
+ int start, end, flipnorm, do_autosmooth=0;
me= ob->data;
if (rendermesh_uses_displist(me) && me->subdivr>0) {
@@ -1613,7 +1613,7 @@ static void init_render_mesh(Object *ob)
ma= give_render_material(ob, a1+1);
if(ma==0) ma= &defmaterial;
-
+
/* test for 100% transparant */
ok= 1;
if(ma->alpha==0.0 && ma->spectra==0.0) {
@@ -1627,7 +1627,9 @@ static void init_render_mesh(Object *ob)
}
if(ok) {
-
+ /* radio faces need autosmooth, to separate shared vertices in corners */
+ if(ma->mode & MA_RADIO) do_autosmooth= 1;
+
start= 0;
end= me->totface;
set_buildvars(ob, &start, &end);
@@ -1747,7 +1749,7 @@ static void init_render_mesh(Object *ob)
}
}
- if(me->flag & ME_AUTOSMOOTH) {
+ if(do_autosmooth || (me->flag & ME_AUTOSMOOTH)) {
autosmooth(totverto, totvlako, me->smoothresh);
do_puno= 1;
}
@@ -2766,7 +2768,8 @@ void RE_freeRotateBlenderScene(void)
end_render_textures();
end_render_materials();
-
+ end_radio_render();
+
R.totvlak=R.totvert=R.totlamp=R.tothalo= 0;
}
diff --git a/source/blender/src/buttons.c b/source/blender/src/buttons.c
index 3a975a4de34..845eff9df26 100644
--- a/source/blender/src/buttons.c
+++ b/source/blender/src/buttons.c
@@ -2553,102 +2553,119 @@ void radiobuts(void)
rad= G.scene->radio;
}
- flag= rad_phase();
-
sprintf(str, "buttonswin %d", curarea->win);
block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
- uiAutoBlock(block, 10, 30, 190, 100, UI_BLOCK_ROWS);
- if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_INIT, "Limit Subdivide", 0, 0, 10, 10, NULL, 0, 0, 0, 0, "Subdivide patches");
+ flag= rad_phase();
+
+ if(flag & RAD_PHASE_PATCHES) {
+ uiBlockSetCol(block, BUTSALMON);
+ uiDefBut(block, BUT, B_RAD_INIT, "Limit Subdivide", 10, 70, 190, 40, NULL, 0, 0, 0, 0, "Subdivide patches");
+ }
if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTPURPLE);
else uiBlockSetCol(block, BUTSALMON);
- uiDefBut(block, BUT, B_RAD_COLLECT, "Collect Meshes", 1, 0, 10, 10, NULL, 0, 0, 0, 0, "Convert selected and visible meshes to patches");
+ uiDefBut(block, BUT, B_RAD_COLLECT, "Collect Meshes", 10, 30, 190, 40, NULL, 0, 0, 0, 0, "Convert selected and visible meshes to patches");
uiDrawBlock(block);
- sprintf(str, "buttonswin1 %d", curarea->win);
- block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
- uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
-
- uiBlockSetCol(block, BUTGREEN);
- uiDefButS(block, ROW, B_RAD_DRAW, "Wire", 0, 0, 10, 10, &rad->drawtype, 0.0, 0.0, 0, 0, "Enable wireframe drawmode");
- uiDefButS(block, ROW, B_RAD_DRAW, "Solid", 0, 0, 10, 10, &rad->drawtype, 0.0, 1.0, 0, 0, "Enable solid drawmode");
- uiDefButS(block, ROW, B_RAD_DRAW, "Gour", 0, 0, 10, 10, &rad->drawtype, 0.0, 2.0, 0, 0, "Enable Gourad drawmode");
- uiBlockSetCol(block, BUTGREY);
- uiDefButS(block, TOG|BIT|0, B_RAD_DRAW, "ShowLim", 1, 0, 10, 10, &rad->flag, 0, 0, 0, 0, "Visualize patch and element limits");
- uiDefButS(block, TOG|BIT|1, B_RAD_DRAW, "Z", 1, 0, 3, 10, &rad->flag, 0, 0, 0, 0, "Draw limits different");
- uiBlockSetCol(block, BUTGREY);
- uiDefButS(block, NUM, B_RAD_LIMITS, "ElMax:", 2, 0, 10, 10, &rad->elma, 1.0, 500.0, 0, 0, "Set maximum size of an element");
- uiDefButS(block, NUM, B_RAD_LIMITS, "ElMin:", 2, 0, 10, 10, &rad->elmi, 1.0, 100.0, 0, 0, "Set minimum size of an element");
- uiDefButS(block, NUM, B_RAD_LIMITS, "PaMax:", 3, 0, 10, 10, &rad->pama, 10.0, 1000.0, 0, 0, "Set maximum size of a patch");
- uiDefButS(block, NUM, B_RAD_LIMITS, "PaMin:", 3, 0, 10, 10, &rad->pami, 10.0, 1000.0, 0, 0, "Set minimum size of a patch");
- uiDrawBlock(block);
-
- sprintf(str, "buttonswin2 %d", curarea->win);
- block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
- uiAutoBlock(block, 450, 30, 180, 150, UI_BLOCK_ROWS);
+ if(flag==0) {
- if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_SHOOTE, "Subdiv Shoot Element", 0, 0, 12, 10, NULL, 0, 0, 0, 0, "");
- uiDefBut(block, BUT, B_RAD_SHOOTP, "Subdiv Shoot Patch", 1, 0, 12, 10, NULL, 0, 0, 0, 0, "Detect high energy changes");
- uiBlockSetCol(block, BUTGREY);
- uiDefButS(block, NUM, 0, "Max Subdiv Shoot:", 2, 0, 10, 10, &rad->maxsublamp, 1.0, 250.0, 0, 0, "Set the maximum number of shoot patches that are evaluated");
- uiDefButI(block, NUM, 0, "MaxEl:", 3, 0, 10, 10, &rad->maxnode, 1.0, 250000.0, 0, 0, "Set the maximum allowed number of elements");
- uiDefButS(block, NUM, B_RAD_LIMITS, "Hemires:", 4, 0, 10, 10, &rad->hemires, 100.0, 1000.0, 100, 0, "Set the size of a hemicube");
- uiDrawBlock(block);
+ sprintf(str, "buttonswin1 %d", curarea->win);
+ block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
+ uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButS(block, NUM, B_RAD_LIMITS, "Hemires:", 0, 0, 10, 10, &rad->hemires, 100.0, 1000.0, 100, 0, "Set the size of a hemicube");
+ uiDefButS(block, NUM, 0, "Max Iterations:", 1, 0, 10, 10, &rad->maxiter, 0.0, 10000.0, 0, 0, "Maximum number of radiosity rounds");
+ uiDefButF(block, NUM, B_RAD_FAC, "Mult:", 2, 0, 50, 10, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitply the energy values");
+ uiDefButF(block, NUM, B_RAD_FAC, "Gamma:", 2, 0, 50, 10, &rad->gamma, 0.2, 10.0, 10, 0, "Change the contrast of the energy values");
+ uiDefButF(block, NUM, 0, "Convergence:", 3, 0, 10, 10, &rad->convergence, 0.0, 1.0, 10, 0, "Set the lower threshold of unshot energy");
+ uiDrawBlock(block);
+ }
+ else {
- sprintf(str, "buttonswin3 %d", curarea->win);
- block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
- uiAutoBlock(block, 640, 30, 200, 150, UI_BLOCK_ROWS);
- uiBlockSetCol(block, BUTGREY);
- uiDefButS(block, NUM, 0, "Max Iterations:", 0, 0, 10, 10, &rad->maxiter, 0.0, 10000.0, 0, 0, "Maximum number of radiosity rounds");
- uiDefButF(block, NUM, 0, "Convergence:", 1, 0, 10, 10, &rad->convergence, 0.0, 1.0, 10, 0, "Set the lower threshold of unshot energy");
- uiDefButS(block, NUM, 0, "SubSh P:", 2, 0, 10, 10, &rad->subshootp, 0.0, 10.0, 0, 0, "Set the number of times the environment is tested to detect pathes");
- uiDefButS(block, NUM, 0, "SubSh E:", 2, 0, 10, 10, &rad->subshoote, 0.0, 10.0, 0, 0, "Set the number of times the environment is tested to detect elements");
- if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
- uiDefBut(block, BUT, B_RAD_GO, "GO", 3, 0, 10, 15, NULL, 0, 0, 0, 0, "Start the radiosity simulation");
- uiDrawBlock(block);
+ sprintf(str, "buttonswin1 %d", curarea->win);
+ block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
+ uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
+
+ uiBlockSetCol(block, BUTGREEN);
+ uiDefButS(block, ROW, B_RAD_DRAW, "Wire", 0, 0, 10, 10, &rad->drawtype, 0.0, 0.0, 0, 0, "Enable wireframe drawmode");
+ uiDefButS(block, ROW, B_RAD_DRAW, "Solid", 0, 0, 10, 10, &rad->drawtype, 0.0, 1.0, 0, 0, "Enable solid drawmode");
+ uiDefButS(block, ROW, B_RAD_DRAW, "Gour", 0, 0, 10, 10, &rad->drawtype, 0.0, 2.0, 0, 0, "Enable Gourad drawmode");
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButS(block, TOG|BIT|0, B_RAD_DRAW, "ShowLim", 1, 0, 10, 10, &rad->flag, 0, 0, 0, 0, "Visualize patch and element limits");
+ uiDefButS(block, TOG|BIT|1, B_RAD_DRAW, "Z", 1, 0, 3, 10, &rad->flag, 0, 0, 0, 0, "Draw limits different");
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButS(block, NUM, B_RAD_LIMITS, "ElMax:", 2, 0, 10, 10, &rad->elma, 1.0, 500.0, 0, 0, "Set maximum size of an element");
+ uiDefButS(block, NUM, B_RAD_LIMITS, "ElMin:", 2, 0, 10, 10, &rad->elmi, 1.0, 100.0, 0, 0, "Set minimum size of an element");
+ uiDefButS(block, NUM, B_RAD_LIMITS, "PaMax:", 3, 0, 10, 10, &rad->pama, 10.0, 1000.0, 0, 0, "Set maximum size of a patch");
+ uiDefButS(block, NUM, B_RAD_LIMITS, "PaMin:", 3, 0, 10, 10, &rad->pami, 10.0, 1000.0, 0, 0, "Set minimum size of a patch");
+ uiDrawBlock(block);
+
+ sprintf(str, "buttonswin2 %d", curarea->win);
+ block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
+ uiAutoBlock(block, 450, 30, 180, 150, UI_BLOCK_ROWS);
+
+ if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
+ else uiBlockSetCol(block, BUTGREY);
+ uiDefBut(block, BUT, B_RAD_SHOOTE, "Subdiv Shoot Element", 0, 0, 12, 10, NULL, 0, 0, 0, 0, "");
+ uiDefBut(block, BUT, B_RAD_SHOOTP, "Subdiv Shoot Patch", 1, 0, 12, 10, NULL, 0, 0, 0, 0, "Detect high energy changes");
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButS(block, NUM, 0, "Max Subdiv Shoot:", 2, 0, 10, 10, &rad->maxsublamp, 1.0, 250.0, 0, 0, "Set the maximum number of shoot patches that are evaluated");
+ uiDefButI(block, NUM, 0, "MaxEl:", 3, 0, 10, 10, &rad->maxnode, 1.0, 250000.0, 0, 0, "Set the maximum allowed number of elements");
+ uiDefButS(block, NUM, B_RAD_LIMITS, "Hemires:", 4, 0, 10, 10, &rad->hemires, 100.0, 1000.0, 100, 0, "Set the size of a hemicube");
+ uiDrawBlock(block);
+
+ sprintf(str, "buttonswin3 %d", curarea->win);
+ block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
+ uiAutoBlock(block, 640, 30, 200, 150, UI_BLOCK_ROWS);
+
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButS(block, NUM, 0, "Max Iterations:", 0, 0, 10, 10, &rad->maxiter, 0.0, 10000.0, 0, 0, "Maximum number of radiosity rounds");
+ uiDefButF(block, NUM, 0, "Convergence:", 1, 0, 10, 10, &rad->convergence, 0.0, 1.0, 10, 0, "Set the lower threshold of unshot energy");
+ uiDefButS(block, NUM, 0, "SubSh P:", 2, 0, 10, 10, &rad->subshootp, 0.0, 10.0, 0, 0, "Set the number of times the environment is tested to detect pathes");
+ uiDefButS(block, NUM, 0, "SubSh E:", 2, 0, 10, 10, &rad->subshoote, 0.0, 10.0, 0, 0, "Set the number of times the environment is tested to detect elements");
+ if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
+ uiDefBut(block, BUT, B_RAD_GO, "GO", 3, 0, 10, 15, NULL, 0, 0, 0, 0, "Start the radiosity simulation");
+ uiDrawBlock(block);
+
+ sprintf(str, "buttonswin4 %d", curarea->win);
+ block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
+ uiAutoBlock(block, 850, 30, 200, 150, UI_BLOCK_ROWS);
- sprintf(str, "buttonswin4 %d", curarea->win);
- block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
- uiAutoBlock(block, 850, 30, 200, 150, UI_BLOCK_ROWS);
-
- uiBlockSetCol(block, BUTGREY);
- uiDefButF(block, NUM, B_RAD_FAC, "Mult:", 0, 0, 50, 17, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitply the energy values");
- uiDefButF(block, NUM, B_RAD_FAC, "Gamma:", 0, 0, 50, 17, &rad->gamma, 0.2, 10.0, 10, 0, "Change the contrast of the energy values");
- if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_FACEFILT, "FaceFilter", 1, 0, 10, 10, NULL, 0, 0, 0, 0, "Force an extra smoothing");
- if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_NODELIM, "RemoveDoubles", 2, 0, 30, 10, NULL, 0.0, 50.0, 0, 0, "Join elements which differ less than 'Lim'");
- uiBlockSetCol(block, BUTGREY);
- uiDefButS(block, NUM, 0, "Lim:", 2, 0, 10, 10, &rad->nodelim, 0.0, 50.0, 0, 0, "Set the range for removing doubles");
- if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_NODEFILT, "Element Filter", 3, 0, 10, 10, NULL, 0, 0, 0, 0, "Filter elements to remove aliasing artefacts");
- uiDrawBlock(block);
-
- sprintf(str, "buttonswin5 %d", curarea->win);
- block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
- uiAutoBlock(block, 1060, 30, 190, 150, UI_BLOCK_ROWS);
-
- if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_FREE, "Free Radio Data", 0, 0, 10, 10, NULL, 0, 0, 0, 0, "Release all memory used by Radiosity");
- if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
- else uiBlockSetCol(block, BUTGREY);
- uiDefBut(block, BUT, B_RAD_REPLACE, "Replace Meshes", 1, 0, 10, 10, NULL, 0, 0, 0, 0, "Convert meshes to Mesh objects with vertex colours, changing input-meshes");
- uiDefBut(block, BUT, B_RAD_ADDMESH, "Add new Meshes", 2, 0, 10, 10, NULL, 0, 0, 0, 0, "Convert meshes to Mesh objects with vertex colours, unchanging input-meshes");
- uiDrawBlock(block);
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButF(block, NUM, B_RAD_FAC, "Mult:", 0, 0, 50, 17, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitply the energy values");
+ uiDefButF(block, NUM, B_RAD_FAC, "Gamma:", 0, 0, 50, 17, &rad->gamma, 0.2, 10.0, 10, 0, "Change the contrast of the energy values");
+ if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
+ else uiBlockSetCol(block, BUTGREY);
+ uiDefBut(block, BUT, B_RAD_FACEFILT, "FaceFilter", 1, 0, 10, 10, NULL, 0, 0, 0, 0, "Force an extra smoothing");
+ if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
+ else uiBlockSetCol(block, BUTGREY);
+ uiDefBut(block, BUT, B_RAD_NODELIM, "RemoveDoubles", 2, 0, 30, 10, NULL, 0.0, 50.0, 0, 0, "Join elements which differ less than 'Lim'");
+ uiBlockSetCol(block, BUTGREY);
+ uiDefButS(block, NUM, 0, "Lim:", 2, 0, 10, 10, &rad->nodelim, 0.0, 50.0, 0, 0, "Set the range for removing doubles");
+ if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
+ else uiBlockSetCol(block, BUTGREY);
+ uiDefBut(block, BUT, B_RAD_NODEFILT, "Element Filter", 3, 0, 10, 10, NULL, 0, 0, 0, 0, "Filter elements to remove aliasing artefacts");
+ uiDrawBlock(block);
- rad_status_str(str);
- cpack(0);
- glRasterPos2i(210, 189);
- BMF_DrawString(uiBlockGetCurFont(block), str);
+ sprintf(str, "buttonswin5 %d", curarea->win);
+ block= uiNewBlock(&curarea->uiblocks, str, UI_EMBOSSX, UI_HELV, curarea->win);
+ uiAutoBlock(block, 1060, 30, 190, 150, UI_BLOCK_ROWS);
+
+ if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
+ else uiBlockSetCol(block, BUTGREY);
+ uiDefBut(block, BUT, B_RAD_FREE, "Free Radio Data", 0, 0, 10, 10, NULL, 0, 0, 0, 0, "Release all memory used by Radiosity");
+ if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
+ else uiBlockSetCol(block, BUTGREY);
+ uiDefBut(block, BUT, B_RAD_REPLACE, "Replace Meshes", 1, 0, 10, 10, NULL, 0, 0, 0, 0, "Convert meshes to Mesh objects with vertex colours, changing input-meshes");
+ uiDefBut(block, BUT, B_RAD_ADDMESH, "Add new Meshes", 2, 0, 10, 10, NULL, 0, 0, 0, 0, "Convert meshes to Mesh objects with vertex colours, unchanging input-meshes");
+ uiDrawBlock(block);
+
+ rad_status_str(str);
+ cpack(0);
+ glRasterPos2i(210, 189);
+ BMF_DrawString(uiBlockGetCurFont(block), str);
+ }
}
@@ -4272,16 +4289,17 @@ void matbuts(void)
uiDefButI(block, TOG|BIT|0, 0, "Traceable", 576,200,77,18, &(ma->mode), 0, 0, 0, 0, "Make material visible for shadow lamps");
uiDefButI(block, TOG|BIT|1, 0, "Shadow", 576,181,77,18, &(ma->mode), 0, 0, 0, 0, "Enable material for shadows");
- uiDefButI(block, TOG|BIT|2, B_MATPRV, "Shadeless", 576, 162, 77, 18, &(ma->mode), 0, 0, 0, 0, "Make material insensitive to light or shadow");
- uiDefButI(block, TOG|BIT|3, 0, "Wire", 576, 143, 77, 18, &(ma->mode), 0, 0, 0, 0, "Render only the edges of faces");
- uiDefButI(block, TOG|BIT|6, 0, "ZTransp", 576, 124, 77, 18, &(ma->mode), 0, 0, 0, 0, "Z-Buffer transparent faces");
- uiDefButI(block, TOG|BIT|8, 0, "ZInvert", 576, 105, 77, 18, &(ma->mode), 0, 0, 0, 0, "Render with inverted Z Buffer");
+ uiDefButI(block, TOG|BIT|16, 0, "Radio", 576, 162, 77,18, &(ma->mode), 0, 0, 0, 0, "Set the material insensitive to mist");
+ uiDefButI(block, TOG|BIT|2, B_MATPRV, "Shadeless", 576, 143, 77, 18, &(ma->mode), 0, 0, 0, 0, "Make material insensitive to light or shadow");
+ uiDefButI(block, TOG|BIT|3, 0, "Wire", 576, 124, 77, 18, &(ma->mode), 0, 0, 0, 0, "Render only the edges of faces");
+ uiDefButI(block, TOG|BIT|6, 0, "ZTransp", 576, 105, 77, 18, &(ma->mode), 0, 0, 0, 0, "Z-Buffer transparent faces");
uiDefButI(block, TOG|BIT|5, B_MATPRV_DRAW, "Halo", 576, 86, 77, 18, &(ma->mode), 0, 0, 0, 0, "Render as a halo");
uiDefButI(block, TOG|BIT|9, 0, "Env", 576, 67, 77, 18, &(ma->mode), 0, 0, 0, 0, "Do not render material");
uiDefButI(block, TOG|BIT|10, 0, "OnlyShadow", 576, 48, 77, 18, &(ma->mode), 0, 0, 0, 0, "Let alpha be determined on the degree of shadow");
uiDefButI(block, TOG|BIT|14, 0, "No Mist", 576, 29, 77,18, &(ma->mode), 0, 0, 0, 0, "Set the material insensitive to mist");
+ uiDefButI(block, TOG|BIT|8, 0, "ZInvert", 576, 10, 77, 18, &(ma->mode), 0, 0, 0, 0, "Render with inverted Z Buffer");
uiBlockSetCol(block, BUTGREY);
- uiDefButF(block, NUM, 0, "Zoffs:", 576, 10, 77,18, &(ma->zoffs), 0.0, 10.0, 0, 0, "Give face an artificial offset");
+ uiDefButF(block, NUM, 0, "Zoffs:", 576, -9, 77,18, &(ma->zoffs), 0.0, 10.0, 0, 0, "Give face an artificial offset");
}
/* PREVIEW RENDER */
@@ -6605,7 +6623,8 @@ void renderbuts(void)
uiBlockSetCol(block, BUTGREY);
uiDefButS(block, TOG|BIT|1,0,"Shadows", 565,167,122,22, &G.scene->r.mode, 0, 0, 0, 0, "Enable shadow calculation");
- uiDefButS(block, TOG|BIT|10,0,"Panorama",565,142,122,22, &G.scene->r.mode, 0, 0, 0, 0, "Enable panorama rendering (output width is multiplied by Xparts)");
+ uiDefButS(block, TOG|BIT|10,0,"Pano",565,142,61,22, &G.scene->r.mode, 0, 0, 0, 0, "Enable panorama rendering (output width is multiplied by Xparts)");
+ uiDefButS(block, TOG|BIT|8,0,"Radio",626,142,61,22, &G.scene->r.mode, 0, 0, 0, 0, "Enable radiosity rendering");
uiDefButS(block, ROW,B_DIFF,"100%", 565,114,121,20,&G.scene->r.size,1.0,100.0, 0, 0, "Set render size to defined size");
uiDefButS(block, ROW,B_DIFF,"75%", 565,90,36,20,&G.scene->r.size,1.0,75.0, 0, 0, "Set render size to 3/4 of defined size");
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-01 06:40:38 +0300