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:
authorBrecht Van Lommel <brechtvanlommel@pandora.be>2009-09-29 23:12:12 +0400
committerBrecht Van Lommel <brechtvanlommel@pandora.be>2009-09-29 23:12:12 +0400
commit15d07720e515a2e9caada6ee9900c388c5e06490 (patch)
tree8154e70a86e3b9b0cf42a581db95f0a7d4029238 /source/blender/editors/render
parent7f5dc4644f72ffb56d23db79cc3208dbca2d5eab (diff)
Sorry, three commits in one, became difficult to untangle..
Editors Modules * render/ module added in editors, moved the preview render code there and also shading related operators. * physics/ module made more consistent with other modules. renaming files, making a single physics_ops.c for operators and keymaps. Also move all particle related operators here now. * space_buttons/ now should have only operators relevant to the buttons specificially. Updates & Notifiers * Material/Texture/World/Lamp can now be passed to DAG_id_flush_update, which will go back to a callback in editors. Eventually these should be in the depsgraph itself, but for now this gives a unified call for doing updates. * GLSL materials are now refreshed on changes. There's still various cases missing, * Preview icons now hook into this system, solving various update cases that were missed before. * Also fixes issue in my last commit, where some preview would not render, problem is avoided in the new system. Icon Rendering * On systems with support for non-power of two textures, an OpenGL texture is now used instead of glDrawPixels. This avoids problems with icons get clipped on region borders. On my Linux desktop, this gives an 1.1x speedup, and on my Mac laptop a 2.3x speedup overall in redrawing the full window, with the default setup. The glDrawPixels implementation on Mac seems to have a lot of overhread. * Preview icons are now drawn using proper premul alpha, and never faded so you can see them clearly. * Also tried to fix issue with texture node preview rendering, globals can't be used with threads reliably.
Diffstat (limited to 'source/blender/editors/render')
-rw-r--r--source/blender/editors/render/Makefile56
-rw-r--r--source/blender/editors/render/SConscript12
-rw-r--r--source/blender/editors/render/render_intern.h49
-rw-r--r--source/blender/editors/render/render_ops.c54
-rw-r--r--source/blender/editors/render/render_preview.c1146
-rw-r--r--source/blender/editors/render/render_shading.c645
6 files changed, 1962 insertions, 0 deletions
diff --git a/source/blender/editors/render/Makefile b/source/blender/editors/render/Makefile
new file mode 100644
index 00000000000..ed25f0be02a
--- /dev/null
+++ b/source/blender/editors/render/Makefile
@@ -0,0 +1,56 @@
+#
+# $Id$
+#
+# ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2007 Blender Foundation
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL LICENSE BLOCK *****
+#
+# Makes module object directory and bounces make to subdirectories.
+
+LIBNAME = ed_render
+DIR = $(OCGDIR)/blender/$(LIBNAME)
+
+include nan_compile.mk
+
+CFLAGS += $(LEVEL_1_C_WARNINGS)
+
+CPPFLAGS += -I$(NAN_GLEW)/include
+CPPFLAGS += -I$(OPENGL_HEADERS)
+
+CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
+CPPFLAGS += -I$(NAN_ELBEEM)/include
+
+CPPFLAGS += -I../../windowmanager
+CPPFLAGS += -I../../blenkernel
+CPPFLAGS += -I../../blenloader
+CPPFLAGS += -I../../blenlib
+CPPFLAGS += -I../../makesdna
+CPPFLAGS += -I../../makesrna
+CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../gpu
+CPPFLAGS += -I../../render/extern/include
+
+# own include
+
+CPPFLAGS += -I../include
diff --git a/source/blender/editors/render/SConscript b/source/blender/editors/render/SConscript
new file mode 100644
index 00000000000..cca2ab9b2ab
--- /dev/null
+++ b/source/blender/editors/render/SConscript
@@ -0,0 +1,12 @@
+#!/usr/bin/python
+Import ('env')
+
+sources = env.Glob('*.c')
+
+incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
+incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
+incs += ' #/intern/guardedalloc ../../gpu'
+incs += ' ../../makesrna ../../render/extern/include #/intern/elbeem/extern'
+incs += ' ../../blenloader'
+
+env.BlenderLib ( 'bf_editors_render', sources, Split(incs), [], libtype=['core'], priority=[45] )
diff --git a/source/blender/editors/render/render_intern.h b/source/blender/editors/render/render_intern.h
new file mode 100644
index 00000000000..dccc2d36002
--- /dev/null
+++ b/source/blender/editors/render/render_intern.h
@@ -0,0 +1,49 @@
+/**
+ * $Id:
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef RENDER_INTERN_H
+#define RENDER_INTERN_H
+
+struct wmOperatorType;
+
+/* render_shading.c */
+void OBJECT_OT_material_slot_add(struct wmOperatorType *ot);
+void OBJECT_OT_material_slot_remove(struct wmOperatorType *ot);
+void OBJECT_OT_material_slot_assign(struct wmOperatorType *ot);
+void OBJECT_OT_material_slot_select(struct wmOperatorType *ot);
+void OBJECT_OT_material_slot_deselect(struct wmOperatorType *ot);
+
+void MATERIAL_OT_new(struct wmOperatorType *ot);
+void TEXTURE_OT_new(struct wmOperatorType *ot);
+void WORLD_OT_new(struct wmOperatorType *ot);
+
+void SCENE_OT_render_layer_add(struct wmOperatorType *ot);
+void SCENE_OT_render_layer_remove(struct wmOperatorType *ot);
+
+#endif /* RENDER_INTERN_H */
+
diff --git a/source/blender/editors/render/render_ops.c b/source/blender/editors/render/render_ops.c
new file mode 100644
index 00000000000..8b60582d466
--- /dev/null
+++ b/source/blender/editors/render/render_ops.c
@@ -0,0 +1,54 @@
+/**
+ * $Id:
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+
+#include "DNA_windowmanager_types.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "render_intern.h" // own include
+
+/***************************** render ***********************************/
+
+void ED_operatortypes_render(void)
+{
+ WM_operatortype_append(OBJECT_OT_material_slot_add);
+ WM_operatortype_append(OBJECT_OT_material_slot_remove);
+ WM_operatortype_append(OBJECT_OT_material_slot_assign);
+ WM_operatortype_append(OBJECT_OT_material_slot_select);
+ WM_operatortype_append(OBJECT_OT_material_slot_deselect);
+
+ WM_operatortype_append(MATERIAL_OT_new);
+ WM_operatortype_append(TEXTURE_OT_new);
+ WM_operatortype_append(WORLD_OT_new);
+
+ WM_operatortype_append(SCENE_OT_render_layer_add);
+ WM_operatortype_append(SCENE_OT_render_layer_remove);
+}
+
diff --git a/source/blender/editors/render/render_preview.c b/source/blender/editors/render/render_preview.c
new file mode 100644
index 00000000000..81f6badc24b
--- /dev/null
+++ b/source/blender/editors/render/render_preview.c
@@ -0,0 +1,1146 @@
+/*
+ * $Id$
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/* global includes */
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#ifndef WIN32
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+#include "MEM_guardedalloc.h"
+
+#include "BLO_readfile.h"
+
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+#include "BLI_threads.h"
+
+#include "DNA_texture_types.h"
+#include "DNA_world_types.h"
+#include "DNA_camera_types.h"
+#include "DNA_image_types.h"
+#include "DNA_material_types.h"
+#include "DNA_node_types.h"
+#include "DNA_object_types.h"
+#include "DNA_lamp_types.h"
+#include "DNA_space_types.h"
+#include "DNA_view3d_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+
+#include "BKE_context.h"
+#include "BKE_depsgraph.h"
+#include "BKE_global.h"
+#include "BKE_image.h"
+#include "BKE_icons.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+#include "BKE_texture.h"
+#include "BKE_material.h"
+#include "BKE_node.h"
+#include "BKE_world.h"
+#include "BKE_texture.h"
+#include "BKE_utildefines.h"
+
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#include "PIL_time.h"
+
+#include "RE_pipeline.h"
+
+#include "GPU_material.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_render.h"
+#include "ED_view3d.h"
+
+#include "UI_interface.h"
+
+#include "render_intern.h"
+
+#define PR_XMIN 10
+#define PR_YMIN 5
+#define PR_XMAX 200
+#define PR_YMAX 195
+
+/* XXX */
+static int qtest() {return 0;}
+/* XXX */
+
+typedef struct ShaderPreview {
+ /* from wmJob */
+ void *owner;
+ short *stop, *do_update;
+
+ Scene *scene;
+ ID *id;
+ ID *parent;
+ MTex *slot;
+
+ int sizex, sizey;
+ unsigned int *pr_rect;
+ int pr_method;
+
+} ShaderPreview;
+
+
+
+/* unused now */
+void draw_tex_crop(Tex *tex)
+{
+ rcti rct;
+ int ret= 0;
+
+ if(tex==0) return;
+
+ if(tex->type==TEX_IMAGE) {
+ if(tex->cropxmin==0.0f) ret++;
+ if(tex->cropymin==0.0f) ret++;
+ if(tex->cropxmax==1.0f) ret++;
+ if(tex->cropymax==1.0f) ret++;
+ if(ret==4) return;
+
+ rct.xmin= PR_XMIN+2+tex->cropxmin*(PR_XMAX-PR_XMIN-4);
+ rct.xmax= PR_XMIN+2+tex->cropxmax*(PR_XMAX-PR_XMIN-4);
+ rct.ymin= PR_YMIN+2+tex->cropymin*(PR_YMAX-PR_YMIN-4);
+ rct.ymax= PR_YMIN+2+tex->cropymax*(PR_YMAX-PR_YMIN-4);
+
+ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+
+ glColor3ub(0, 0, 0);
+ glRecti(rct.xmin+1, rct.ymin-1, rct.xmax+1, rct.ymax-1);
+
+ glColor3ub(255, 255, 255);
+ glRecti(rct.xmin, rct.ymin, rct.xmax, rct.ymax);
+
+ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+ }
+
+}
+
+/* temporal abuse; if id_code is -1 it only does texture.... solve! */
+void BIF_preview_changed(short id_code)
+{
+#if 0
+ ScrArea *sa;
+
+ for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
+ if(sa->spacetype==SPACE_BUTS) {
+ SpaceButs *sbuts= sa->spacedata.first;
+ if(sbuts->mainb==CONTEXT_SHADING) {
+ int tab= sbuts->tab[CONTEXT_SHADING];
+ if(tab==TAB_SHADING_MAT && (id_code==ID_MA || id_code==ID_TE)) {
+ if (sbuts->ri) sbuts->ri->curtile= 0;
+ addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+ else if(tab==TAB_SHADING_TEX && (id_code==ID_TE || id_code==-1)) {
+ if (sbuts->ri) sbuts->ri->curtile= 0;
+ addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+ else if(tab==TAB_SHADING_LAMP && (id_code==ID_LA || id_code==ID_TE)) {
+ if (sbuts->ri) sbuts->ri->curtile= 0;
+ addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+ else if(tab==TAB_SHADING_WORLD && (id_code==ID_WO || id_code==ID_TE)) {
+ if (sbuts->ri) sbuts->ri->curtile= 0;
+ addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+ }
+ else if (sbuts->ri)
+ sbuts->ri->curtile= 0; /* ensure changes always result in re-render when context is restored */
+ }
+ else if(sa->spacetype==SPACE_NODE) {
+ SpaceNode *snode= sa->spacedata.first;
+ if(snode->treetype==NTREE_SHADER && (id_code==ID_MA || id_code==ID_TE)) {
+ snode_tag_dirty(snode);
+ }
+ }
+ else if(sa->spacetype==SPACE_VIEW3D) {
+ View3D *vd= sa->spacedata.first;
+ /* if is has a renderinfo, we consider that reason for signalling */
+ if (vd->ri) {
+ vd->ri->curtile= 0;
+ addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+ }
+ }
+
+ if(ELEM4(id_code, ID_MA, ID_TE, ID_LA, ID_WO)) {
+ Object *ob;
+ Material *ma;
+
+ if(id_code == ID_WO) {
+ for(ma=G.main->mat.first; ma; ma=ma->id.next) {
+ if(ma->gpumaterial.first) {
+ GPU_material_free(ma);
+ }
+ }
+ }
+ else if(id_code == ID_LA) {
+ for(ob=G.main->object.first; ob; ob=ob->id.next) {
+ if(ob->gpulamp.first) {
+ GPU_lamp_free(ob);
+ }
+ }
+
+ for(ma=G.main->mat.first; ma; ma=ma->id.next) {
+ if(ma->gpumaterial.first) {
+ GPU_material_free(ma);
+ }
+ }
+ } else if(OBACT) {
+ Object *ob = OBACT;
+
+ ma= give_current_material(ob, ob->actcol);
+ if(ma && ma->gpumaterial.first) {
+ GPU_material_free(ma);
+ }
+ }
+ }
+#endif
+}
+
+/* *************************** Preview for buttons *********************** */
+
+static Main *pr_main= NULL;
+
+void ED_preview_init_dbase(void)
+{
+ BlendFileData *bfd;
+ extern int datatoc_preview_blend_size;
+ extern char datatoc_preview_blend[];
+
+ G.fileflags |= G_FILE_NO_UI;
+ bfd= BLO_read_from_memory(datatoc_preview_blend, datatoc_preview_blend_size, NULL);
+ if (bfd) {
+ pr_main= bfd->main;
+
+ MEM_freeN(bfd);
+ }
+ G.fileflags &= ~G_FILE_NO_UI;
+}
+
+void ED_preview_free_dbase(void)
+{
+ if(pr_main)
+ free_main(pr_main);
+}
+
+static Object *find_object(ListBase *lb, const char *name)
+{
+ Object *ob;
+ for(ob= lb->first; ob; ob= ob->id.next)
+ if(strcmp(ob->id.name+2, name)==0)
+ break;
+ return ob;
+}
+
+/* call this with a pointer to initialize preview scene */
+/* call this with NULL to restore assigned ID pointers in preview scene */
+static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPreview *sp)
+{
+ Scene *sce;
+ Base *base;
+
+ if(pr_main==NULL) return NULL;
+
+ sce= pr_main->scene.first;
+ if(sce) {
+ /* this flag tells render to not execute depsgraph or ipos etc */
+ sce->r.scemode |= R_PREVIEWBUTS;
+ /* set world always back, is used now */
+ sce->world= pr_main->world.first;
+ /* now: exposure copy */
+ if(scene->world) {
+ sce->world->exp= scene->world->exp;
+ sce->world->range= scene->world->range;
+ }
+
+ sce->r.color_mgt_flag = scene->r.color_mgt_flag;
+ /* exception: don't color manage texture previews or icons */
+ if((sp && sp->pr_method==PR_ICON_RENDER) || id_type == ID_TE)
+ sce->r.color_mgt_flag &= ~R_COLOR_MANAGEMENT;
+ if((sp && sp->pr_method==PR_ICON_RENDER) && id_type != ID_WO)
+ sce->r.alphamode= R_ALPHAPREMUL;
+ else
+ sce->r.alphamode= R_ADDSKY;
+
+ sce->r.cfra= scene->r.cfra;
+
+ if(id_type==ID_MA) {
+ Material *mat= (Material *)id;
+
+ if(id) {
+ init_render_material(mat, 0, NULL); /* call that retrieves mode_l */
+ end_render_material(mat);
+
+ /* turn on raytracing if needed */
+ if(mat->mode_l & MA_RAYMIRROR)
+ sce->r.mode |= R_RAYTRACE;
+ if(mat->material_type == MA_TYPE_VOLUME)
+ sce->r.mode |= R_RAYTRACE;
+ if((mat->mode_l & MA_RAYTRANSP) && (mat->mode_l & MA_TRANSP))
+ sce->r.mode |= R_RAYTRACE;
+ if(mat->sss_flag & MA_DIFF_SSS)
+ sce->r.mode |= R_SSS;
+
+ /* turn off fake shadows if needed */
+ /* this only works in a specific case where the preview.blend contains
+ * an object starting with 'c' which has a material linked to it (not the obdata)
+ * and that material has a fake shadow texture in the active texture slot */
+ for(base= sce->base.first; base; base= base->next) {
+ if(base->object->id.name[2]=='c') {
+ Material *shadmat= give_current_material(base->object, base->object->actcol);
+ if(shadmat) {
+ if (mat->mode & MA_SHADBUF) shadmat->septex = 0;
+ else shadmat->septex |= 1;
+ }
+ }
+ }
+
+
+ if(sp->pr_method==PR_ICON_RENDER) {
+ if (mat->material_type == MA_TYPE_HALO) {
+ sce->lay= 1<<MA_FLAT;
+ }
+ else {
+ sce->lay= 1<<MA_SPHERE_A;
+ }
+ }
+ else {
+ sce->lay= 1<<mat->pr_type;
+ if(mat->nodetree)
+ ntreeInitPreview(mat->nodetree, sp->sizex, sp->sizey);
+ }
+ }
+ else {
+ sce->r.mode &= ~(R_OSA|R_RAYTRACE|R_SSS);
+ }
+
+ for(base= sce->base.first; base; base= base->next) {
+ if(base->object->id.name[2]=='p') {
+ if(ELEM4(base->object->type, OB_MESH, OB_CURVE, OB_SURF, OB_MBALL)) {
+ /* don't use assign_material, it changed mat->id.us, which shows in the UI */
+ Material ***matar= give_matarar(base->object);
+ int actcol= MAX2(base->object->actcol > 0, 1) - 1;
+
+ if(matar && actcol < base->object->totcol)
+ (*matar)[actcol]= mat;
+ }
+ }
+ }
+ }
+ else if(id_type==ID_TE) {
+ Tex *tex= (Tex *)id;
+
+ sce->lay= 1<<MA_TEXTURE;
+
+ for(base= sce->base.first; base; base= base->next) {
+ if(base->object->id.name[2]=='t') {
+ Material *mat= give_current_material(base->object, base->object->actcol);
+ if(mat && mat->mtex[0]) {
+ mat->mtex[0]->tex= tex;
+
+ if(sp && sp->slot)
+ mat->mtex[0]->which_output = sp->slot->which_output;
+
+ /* show alpha in this case */
+ if(tex==NULL || (tex->flag & TEX_PRV_ALPHA)) {
+ mat->mtex[0]->mapto |= MAP_ALPHA;
+ mat->alpha= 0.0f;
+ }
+ else {
+ mat->mtex[0]->mapto &= ~MAP_ALPHA;
+ mat->alpha= 1.0f;
+ }
+ }
+ }
+ }
+ }
+ else if(id_type==ID_LA) {
+ Lamp *la= (Lamp *)id;
+
+ if(la && la->type==LA_SUN && (la->sun_effect_type & LA_SUN_EFFECT_SKY)) {
+ sce->lay= 1<<MA_ATMOS;
+ sce->world= scene->world;
+ sce->camera= (Object *)find_object(&pr_main->object, "CameraAtmo");
+ }
+ else {
+ sce->lay= 1<<MA_LAMP;
+ sce->world= NULL;
+ sce->camera= (Object *)find_object(&pr_main->object, "Camera");
+ }
+ sce->r.mode &= ~R_SHADOW;
+
+ for(base= sce->base.first; base; base= base->next) {
+ if(base->object->id.name[2]=='p') {
+ if(base->object->type==OB_LAMP)
+ base->object->data= la;
+ }
+ }
+ }
+ else if(id_type==ID_WO) {
+ sce->lay= 1<<MA_SKY;
+ sce->world= (World *)id;
+ }
+
+ return sce;
+ }
+
+ return NULL;
+}
+
+/* new UI convention: draw is in pixel space already. */
+/* uses ROUNDBOX button in block to get the rect */
+static int ed_preview_draw_rect(ScrArea *sa, Scene *sce, ID *id, int split, int first, rcti *rect, rcti *newrect)
+{
+ RenderResult rres;
+ char name[32];
+ int gamma_correct=0;
+ int offx=0, newx= rect->xmax-rect->xmin, newy= rect->ymax-rect->ymin;
+
+ if (id && GS(id->name) != ID_TE) {
+ /* exception: don't color manage texture previews - show the raw values */
+ if (sce) gamma_correct = sce->r.color_mgt_flag & R_COLOR_MANAGEMENT;
+ }
+
+ if(!split || first) sprintf(name, "Preview %p", sa);
+ else sprintf(name, "SecondPreview %p", sa);
+
+ if(split) {
+ if(first) {
+ offx= 0;
+ newx= newx/2;
+ }
+ else {
+ offx= newx/2;
+ newx= newx - newx/2;
+ }
+ }
+
+ RE_GetResultImage(RE_GetRender(name), &rres);
+
+ if(rres.rectf) {
+
+ if(ABS(rres.rectx-newx)<2 && ABS(rres.recty-newy)<2) {
+ newrect->xmax= MAX2(newrect->xmax, rect->xmin + rres.rectx + offx);
+ newrect->ymax= MAX2(newrect->ymax, rect->ymin + rres.recty);
+
+ glPushMatrix();
+ glTranslatef(offx, 0, 0);
+ glaDrawPixelsSafe_to32(rect->xmin, rect->ymin, rres.rectx, rres.recty, rres.rectx, rres.rectf, gamma_correct);
+ glPopMatrix();
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+void ED_preview_draw(const bContext *C, void *idp, void *parentp, void *slotp, rcti *rect)
+{
+ if(idp) {
+ ScrArea *sa= CTX_wm_area(C);
+ Scene *sce = CTX_data_scene(C);
+ ID *id = (ID *)idp;
+ ID *parent= (ID *)parentp;
+ MTex *slot= (MTex *)slotp;
+ SpaceButs *sbuts= sa->spacedata.first;
+ rcti newrect;
+ int ok;
+ int newx= rect->xmax-rect->xmin, newy= rect->ymax-rect->ymin;
+
+ newrect.xmin= rect->xmin;
+ newrect.xmax= rect->xmin;
+ newrect.ymin= rect->ymin;
+ newrect.ymax= rect->ymin;
+
+ if(parent) {
+ ok = ed_preview_draw_rect(sa, sce, parent, 1, 1, rect, &newrect);
+ ok &= ed_preview_draw_rect(sa, sce, id, 1, 0, rect, &newrect);
+ }
+ else
+ ok = ed_preview_draw_rect(sa, sce, id, 0, 0, rect, &newrect);
+
+ if(ok)
+ *rect= newrect;
+
+ /* check for spacetype... */
+ if(sbuts->spacetype==SPACE_BUTS && sbuts->preview) {
+ sbuts->preview= 0;
+ ok= 0;
+ }
+
+ if(ok==0) {
+ ED_preview_shader_job(C, sa, id, parent, slot, newx, newy);
+ }
+ }
+}
+
+/* ******************************** Icon Preview **************************** */
+
+void ED_preview_icon_draw(const bContext *C, void *idp, void *arg1, void *arg2, rcti *rect)
+{
+}
+
+/* *************************** Preview for 3d window *********************** */
+
+void view3d_previewrender_progress(RenderResult *rr, volatile rcti *renrect)
+{
+// ScrArea *sa= NULL; // XXX
+// View3D *v3d= NULL; // XXX
+ RenderLayer *rl;
+ int ofsx=0, ofsy=0;
+
+ if(renrect) return;
+
+ rl= rr->layers.first;
+
+ /* this case is when we render envmaps... */
+// if(rr->rectx > v3d->ri->pr_rectx || rr->recty > v3d->ri->pr_recty)
+// return;
+
+// ofsx= v3d->ri->disprect.xmin + rr->tilerect.xmin;
+// ofsy= v3d->ri->disprect.ymin + rr->tilerect.ymin;
+
+ glDrawBuffer(GL_FRONT);
+// glaDefine2DArea(&sa->winrct);
+ glaDrawPixelsSafe_to32(ofsx, ofsy, rr->rectx, rr->recty, rr->rectx, rl->rectf, 0);
+ bglFlush();
+ glDrawBuffer(GL_BACK);
+
+}
+
+void BIF_view3d_previewrender_signal(ScrArea *sa, short signal)
+{
+#if 0
+ View3D *v3d= sa->spacedata.first;
+
+ /* this can be called from other window... solve! */
+ if(sa->spacetype!=SPACE_VIEW3D)
+ return; // XXX
+
+ if(v3d && v3d->ri) {
+ RenderInfo *ri= v3d->ri;
+ ri->status &= ~signal;
+ ri->curtile= 0;
+ //printf("preview signal %d\n", signal);
+ if(ri->re && (signal & PR_DBASE))
+ RE_Database_Free(ri->re);
+
+// addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+#endif
+}
+
+void BIF_view3d_previewrender_free(View3D *v3d)
+{
+#if 0
+ if(v3d->ri) {
+ RenderInfo *ri= v3d->ri;
+ if(ri->re) {
+// printf("free render\n");
+ RE_Database_Free(ri->re);
+ RE_FreeRender(ri->re);
+ ri->re= NULL;
+ }
+ if (v3d->ri->rect) MEM_freeN(v3d->ri->rect);
+ MEM_freeN(v3d->ri);
+ v3d->ri= NULL;
+ }
+#endif
+}
+
+/* returns 1 if OK, do not call while in panel space! */
+static int view3d_previewrender_get_rects(ScrArea *sa, rctf *viewplane, RenderInfo *ri, float *clipsta, float *clipend, int *ortho, float *pixsize)
+{
+ View3D *v3d= NULL; // XXX
+ RegionView3D *rv3d= NULL; // XXX
+ int rectx, recty;
+// uiBlock *block;
+
+// block= uiFindOpenPanelBlockName(&sa->uiblocks, "Preview");
+// if(block==NULL) return 0;
+
+ /* calculate preview rect size */
+// BLI_init_rctf(viewplane, 15.0f, (block->maxx - block->minx)-15.0f, 15.0f, (block->maxy - block->miny)-15.0f);
+// uiPanelPush(block);
+// ui_graphics_to_window_rct(sa->win, viewplane, &ri->disprect);
+// uiPanelPop(block);
+
+ /* correction for gla draw */
+// BLI_translate_rcti(&ri->disprect, -sa->winrct.xmin, -sa->winrct.ymin);
+
+ *ortho= get_view3d_viewplane(v3d, rv3d, sa->winx, sa->winy, viewplane, clipsta, clipend, pixsize);
+
+ rectx= ri->disprect.xmax - ri->disprect.xmin;
+ recty= ri->disprect.ymax - ri->disprect.ymin;
+
+ if(rectx<4 || recty<4) return 0;
+
+ if(ri->rect && (rectx!=ri->pr_rectx || recty!=ri->pr_recty)) {
+ MEM_freeN(ri->rect);
+ ri->rect= NULL;
+ ri->curtile= 0;
+ printf("changed size\n");
+ }
+ ri->pr_rectx= rectx;
+ ri->pr_recty= recty;
+
+ return 1;
+}
+
+/* called before a panel gets moved/scaled, makes sure we can see through */
+void BIF_view3d_previewrender_clear(ScrArea *sa)
+{
+#if 0
+ View3D *v3d= sa->spacedata.first;
+
+ if(v3d->ri) {
+ RenderInfo *ri= v3d->ri;
+ ri->curtile= 0;
+ if(ri->rect)
+ MEM_freeN(ri->rect);
+ ri->rect= NULL;
+ }
+#endif
+}
+
+/* afterqueue call */
+void BIF_view3d_previewrender(Scene *scene, ScrArea *sa)
+{
+ View3D *v3d= sa->spacedata.first;
+ RegionView3D *rv3d= NULL; // XXX
+ Render *re;
+ RenderInfo *ri=NULL; /* preview struct! */
+ RenderStats *rstats;
+ RenderData rdata;
+ rctf viewplane;
+ float clipsta, clipend, pixsize;
+ int orth;
+
+ /* first get the render info right */
+// if (!v3d->ri) {
+// ri= v3d->ri= MEM_callocN(sizeof(RenderInfo), "butsrenderinfo");
+// ri->tottile= 10000;
+// }
+// ri= v3d->ri;
+
+ if(0==view3d_previewrender_get_rects(sa, &viewplane, ri, &clipsta, &clipend, &orth, &pixsize))
+ return;
+
+ /* render is finished, so return */
+ if(ri->tottile && ri->curtile>=ri->tottile) return;
+
+ /* or return with a new event */
+ if(qtest()) {
+// addafterqueue(sa->win, RENDERPREVIEW, 1);
+ return;
+ }
+ //printf("Enter previewrender\n");
+ /* ok, are we rendering all over? */
+ if(ri->re==NULL) {
+ char name[32];
+
+ ri->status= 0;
+
+ sprintf(name, "View3dPreview %p", sa);
+ re= ri->re= RE_NewRender(name);
+ //RE_display_draw_cb(re, view3d_previewrender_progress);
+ //RE_stats_draw_cb(re, view3d_previewrender_stats);
+ //RE_test_break_cb(re, qtest);
+
+ /* no osa, blur, seq, layers, etc for preview render */
+ rdata= scene->r;
+ rdata.mode &= ~(R_OSA|R_MBLUR);
+ rdata.scemode &= ~(R_DOSEQ|R_DOCOMP|R_FREE_IMAGE);
+ rdata.layers.first= rdata.layers.last= NULL;
+ rdata.renderer= R_INTERN;
+
+ RE_InitState(re, NULL, &rdata, sa->winx, sa->winy, &ri->disprect);
+
+ if(orth)
+ RE_SetOrtho(re, &viewplane, clipsta, clipend);
+ else
+ RE_SetWindow(re, &viewplane, clipsta, clipend);
+ RE_SetPixelSize(re, pixsize);
+
+ /* until here are no escapes */
+ ri->status |= PR_DISPRECT;
+ ri->curtile= 0;
+ //printf("new render\n");
+ }
+
+ re= ri->re;
+
+ PIL_sleep_ms(100); /* wait 0.1 second if theres really no event... */
+ if(qtest()==0) {
+
+ /* check status */
+ if((ri->status & PR_DISPRECT)==0) {
+ RE_SetDispRect(ri->re, &ri->disprect);
+ if(orth)
+ RE_SetOrtho(ri->re, &viewplane, clipsta, clipend);
+ else
+ RE_SetWindow(ri->re, &viewplane, clipsta, clipend);
+ RE_SetPixelSize(re, pixsize);
+ ri->status |= PR_DISPRECT;
+ ri->curtile= 0;
+ //printf("disprect update\n");
+ }
+ if((ri->status & PR_DBASE)==0) {
+ unsigned int lay= scene->lay;
+
+ RE_SetView(re, rv3d->viewmat);
+
+ /* allow localview render for objects with lights in normal layers */
+ if(v3d->lay & 0xFF000000)
+ scene->lay |= v3d->lay;
+ else scene->lay= v3d->lay;
+
+ RE_Database_FromScene(re, scene, 0); // 0= dont use camera view
+ scene->lay= lay;
+
+ rstats= RE_GetStats(re);
+ if(rstats->convertdone)
+ ri->status |= PR_DBASE|PR_PROJECTED|PR_ROTATED;
+ ri->curtile= 0;
+
+ /* database can have created render-resol data... */
+ if(rstats->convertdone)
+ DAG_scene_flush_update(scene, scene->lay, 0);
+
+ //printf("dbase update\n");
+ }
+ if((ri->status & PR_PROJECTED)==0) {
+ if(ri->status & PR_DBASE) {
+ if(orth)
+ RE_SetOrtho(ri->re, &viewplane, clipsta, clipend);
+ else
+ RE_SetWindow(ri->re, &viewplane, clipsta, clipend);
+ RE_DataBase_ApplyWindow(re);
+ ri->status |= PR_PROJECTED;
+ }
+ ri->curtile= 0;
+ //printf("project update\n");
+ }
+
+ /* OK, can we enter render code? */
+ if(ri->status==(PR_DISPRECT|PR_DBASE|PR_PROJECTED|PR_ROTATED)) {
+ //printf("curtile %d tottile %d\n", ri->curtile, ri->tottile);
+ RE_TileProcessor(ri->re, ri->curtile, 0);
+
+ if(ri->rect==NULL)
+ ri->rect= MEM_mallocN(sizeof(int)*ri->pr_rectx*ri->pr_recty, "preview view3d rect");
+
+ RE_ResultGet32(ri->re, ri->rect);
+ }
+
+ rstats= RE_GetStats(ri->re);
+// if(rstats->totpart==rstats->partsdone && rstats->partsdone)
+// addqueue(sa->win, REDRAW, 1);
+// else
+// addafterqueue(sa->win, RENDERPREVIEW, 1);
+
+ ri->curtile= rstats->partsdone;
+ ri->tottile= rstats->totpart;
+ }
+ else {
+// addafterqueue(sa->win, RENDERPREVIEW, 1);
+ }
+
+ //printf("\n");
+}
+
+/* in panel space! */
+static void view3d_previewdraw_rect(ScrArea *sa, uiBlock *block, RenderInfo *ri)
+{
+// rctf dispf;
+
+ if(ri->rect==NULL)
+ return;
+
+// BLI_init_rctf(&dispf, 15.0f, (block->maxx - block->minx)-15.0f, 15.0f, (block->maxy - block->miny)-15.0f);
+// ui_graphics_to_window_rct(sa->win, &dispf, &ri->disprect);
+
+ /* correction for gla draw */
+// BLI_translate_rcti(&ri->disprect, -sa->winrct.xmin, -sa->winrct.ymin);
+
+ /* when panel scale changed, free rect */
+ if(ri->disprect.xmax-ri->disprect.xmin != ri->pr_rectx ||
+ ri->disprect.ymax-ri->disprect.ymin != ri->pr_recty) {
+ MEM_freeN(ri->rect);
+ ri->rect= NULL;
+ }
+ else {
+// glaDefine2DArea(&sa->winrct);
+ glaDrawPixelsSafe(ri->disprect.xmin, ri->disprect.ymin, ri->pr_rectx, ri->pr_recty, ri->pr_rectx, GL_RGBA, GL_UNSIGNED_BYTE, ri->rect);
+ }
+}
+
+/* is panel callback, supposed to be called with correct panel offset matrix */
+void BIF_view3d_previewdraw(struct ScrArea *sa, struct uiBlock *block)
+{
+ RegionView3D *rv3d= NULL;
+
+// if (v3d->ri==NULL || v3d->ri->rect==NULL)
+// addafterqueue(sa->win, RENDERPREVIEW, 1);
+// else {
+ view3d_previewdraw_rect(sa, block, rv3d->ri);
+// if(v3d->ri->curtile==0)
+// addafterqueue(sa->win, RENDERPREVIEW, 1);
+// }
+}
+
+
+/* **************************** new shader preview system ****************** */
+
+/* inside thread, called by renderer, sets job update value */
+static void shader_preview_draw(void *spv, RenderResult *rr, volatile struct rcti *rect)
+{
+ ShaderPreview *sp= spv;
+
+ *(sp->do_update)= 1;
+}
+
+/* called by renderer, checks job value */
+static int shader_preview_break(void *spv)
+{
+ ShaderPreview *sp= spv;
+
+ return *(sp->stop);
+}
+
+/* outside thread, called before redraw notifiers, it moves finished preview over */
+static void shader_preview_updatejob(void *spv)
+{
+// ShaderPreview *sp= spv;
+
+}
+
+static void shader_preview_render(ShaderPreview *sp, ID *id, int split, int first)
+{
+ Render *re;
+ Scene *sce;
+ float oldlens;
+ char name[32];
+ int sizex;
+
+ /* get the stuff from the builtin preview dbase */
+ sce= preview_prepare_scene(sp->scene, id, GS(id->name), sp); // XXX sizex
+ if(sce==NULL) return;
+
+ if(!split || first) sprintf(name, "Preview %p", sp->owner);
+ else sprintf(name, "SecondPreview %p", sp->owner);
+ re= RE_GetRender(name);
+
+ /* full refreshed render from first tile */
+ if(re==NULL)
+ re= RE_NewRender(name);
+
+ /* sce->r gets copied in RE_InitState! */
+ if(sp->pr_method==PR_DO_RENDER) {
+ sce->r.scemode |= R_NODE_PREVIEW;
+ sce->r.scemode &= ~R_NO_IMAGE_LOAD;
+ sce->r.mode |= R_OSA;
+ }
+ else { /* PR_ICON_RENDER */
+ sce->r.scemode &= ~R_NODE_PREVIEW;
+ sce->r.scemode |= R_NO_IMAGE_LOAD;
+ }
+
+ /* in case of split preview, use border render */
+ if(split) {
+ if(first) sizex= sp->sizex/2;
+ else sizex= sp->sizex - sp->sizex/2;
+ }
+ else sizex= sp->sizex;
+
+ /* allocates or re-uses render result */
+ RE_InitState(re, NULL, &sce->r, sizex, sp->sizey, NULL);
+
+ /* callbacs are cleared on GetRender() */
+ if(sp->pr_method==PR_DO_RENDER) {
+ RE_display_draw_cb(re, sp, shader_preview_draw);
+ RE_test_break_cb(re, sp, shader_preview_break);
+ }
+ /* lens adjust */
+ oldlens= ((Camera *)sce->camera->data)->lens;
+ if(sizex > sp->sizey)
+ ((Camera *)sce->camera->data)->lens *= (float)sp->sizey/(float)sizex;
+
+ /* entire cycle for render engine */
+ RE_SetCamera(re, sce->camera);
+ RE_Database_FromScene(re, sce, 1);
+ RE_TileProcessor(re, 0, 1); // actual render engine
+ RE_Database_Free(re);
+
+ ((Camera *)sce->camera->data)->lens= oldlens;
+
+ /* handle results */
+ if(sp->pr_method==PR_ICON_RENDER) {
+ if(sp->pr_rect)
+ RE_ResultGet32(re, sp->pr_rect);
+ }
+ else {
+ /* validate owner */
+ //if(ri->rect==NULL)
+ // ri->rect= MEM_mallocN(sizeof(int)*ri->pr_rectx*ri->pr_recty, "BIF_previewrender");
+ //RE_ResultGet32(re, ri->rect);
+ }
+
+ /* unassign the pointers, reset vars */
+ preview_prepare_scene(sp->scene, NULL, GS(id->name), NULL);
+}
+
+/* runs inside thread for material and icons */
+static void shader_preview_startjob(void *customdata, short *stop, short *do_update)
+{
+ ShaderPreview *sp= customdata;
+
+ sp->stop= stop;
+ sp->do_update= do_update;
+
+ if(sp->parent) {
+ shader_preview_render(sp, sp->parent, 1, 1);
+ shader_preview_render(sp, sp->id, 1, 0);
+ }
+ else
+ shader_preview_render(sp, sp->id, 0, 0);
+
+ *do_update= 1;
+}
+
+static void shader_preview_free(void *customdata)
+{
+ ShaderPreview *sp= customdata;
+
+ MEM_freeN(sp);
+}
+
+/* ************************* icon preview ********************** */
+
+static void icon_copy_rect(ImBuf *ibuf, unsigned int w, unsigned int h, unsigned int *rect)
+{
+ struct ImBuf *ima;
+ unsigned int *drect, *srect;
+ float scaledx, scaledy;
+ short ex, ey, dx, dy;
+
+ /* paranoia test */
+ if(ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL))
+ return;
+
+ /* waste of cpu cyles... but the imbuf API has no other way to scale fast (ton) */
+ ima = IMB_dupImBuf(ibuf);
+
+ if (!ima)
+ return;
+
+ if (ima->x > ima->y) {
+ scaledx = (float)w;
+ scaledy = ( (float)ima->y/(float)ima->x )*(float)w;
+ }
+ else {
+ scaledx = ( (float)ima->x/(float)ima->y )*(float)h;
+ scaledy = (float)h;
+ }
+
+ ex = (short)scaledx;
+ ey = (short)scaledy;
+
+ dx = (w - ex) / 2;
+ dy = (h - ey) / 2;
+
+ IMB_scalefastImBuf(ima, ex, ey);
+
+ /* if needed, convert to 32 bits */
+ if(ima->rect==NULL)
+ IMB_rect_from_float(ima);
+
+ srect = ima->rect;
+ drect = rect;
+
+ drect+= dy*w+dx;
+ for (;ey > 0; ey--){
+ memcpy(drect,srect, ex * sizeof(int));
+ drect += w;
+ srect += ima->x;
+ }
+
+ IMB_freeImBuf(ima);
+}
+
+static void set_alpha(char *cp, int sizex, int sizey, char alpha)
+{
+ int a, size= sizex*sizey;
+
+ for(a=0; a<size; a++, cp+=4)
+ cp[3]= alpha;
+}
+
+static void icon_preview_startjob(void *customdata, short *stop, short *do_update)
+{
+ ShaderPreview *sp= customdata;
+ ID *id= sp->id;
+ short idtype= GS(id->name);
+
+ if(idtype == ID_IM) {
+ Image *ima= (Image*)id;
+ ImBuf *ibuf= NULL;
+ ImageUser iuser;
+
+ /* ima->ok is zero when Image cannot load */
+ if(ima==NULL || ima->ok==0)
+ return;
+
+ /* setup dummy image user */
+ memset(&iuser, 0, sizeof(ImageUser));
+ iuser.ok= iuser.framenr= 1;
+ iuser.scene= sp->scene;
+
+ /* elubie: this needs to be changed: here image is always loaded if not
+ already there. Very expensive for large images. Need to find a way to
+ only get existing ibuf */
+ ibuf = BKE_image_get_ibuf(ima, &iuser);
+ if(ibuf==NULL || ibuf->rect==NULL)
+ return;
+
+ icon_copy_rect(ibuf, sp->sizex, sp->sizey, sp->pr_rect);
+
+ *do_update= 1;
+ }
+ else {
+ /* re-use shader job */
+ shader_preview_startjob(customdata, stop, do_update);
+
+ /* world is rendered with alpha=0, so it wasn't displayed
+ this could be render option for sky to, for later */
+ if(idtype == ID_WO) {
+ set_alpha((char*)sp->pr_rect, sp->sizex, sp->sizey, 255);
+ }
+ else if(idtype == ID_MA) {
+ Material* ma = (Material*)id;
+
+ if(ma->material_type == MA_TYPE_HALO)
+ set_alpha((char*)sp->pr_rect, sp->sizex, sp->sizey, 255);
+ }
+ }
+}
+
+/* use same function for icon & shader, so the job manager
+ does not run two of them at the same time. */
+
+static void common_preview_startjob(void *customdata, short *stop, short *do_update)
+{
+ ShaderPreview *sp= customdata;
+
+ if(sp->pr_method == PR_ICON_RENDER)
+ icon_preview_startjob(customdata, stop, do_update);
+ else
+ shader_preview_startjob(customdata, stop, do_update);
+}
+
+/* exported functions */
+
+void ED_preview_icon_job(const bContext *C, void *owner, ID *id, unsigned int *rect, int sizex, int sizey)
+{
+ wmJob *steve;
+ ShaderPreview *sp;
+
+ /* XXX ugly global still, but we can't do preview while rendering */
+ if(G.rendering) {
+ printf("abort icon because rendering\n");
+ return;
+ }
+
+ steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner);
+ sp= MEM_callocN(sizeof(ShaderPreview), "shader preview");
+
+ /* customdata for preview thread */
+ sp->scene= CTX_data_scene(C);
+ sp->owner= id;
+ sp->sizex= sizex;
+ sp->sizey= sizey;
+ sp->pr_method= PR_ICON_RENDER;
+ sp->pr_rect= rect;
+ sp->id = id;
+
+ /* setup job */
+ WM_jobs_customdata(steve, sp, shader_preview_free);
+ WM_jobs_timer(steve, 0.1, NC_MATERIAL, NC_MATERIAL);
+ WM_jobs_callbacks(steve, common_preview_startjob, NULL, NULL);
+
+ WM_jobs_start(CTX_wm_manager(C), steve);
+}
+
+void ED_preview_shader_job(const bContext *C, void *owner, ID *id, ID *parent, MTex *slot, int sizex, int sizey)
+{
+ wmJob *steve;
+ ShaderPreview *sp;
+
+ /* XXX ugly global still, but we can't do preview while rendering */
+ if(G.rendering) {
+ printf("abort shader because rendering\n");
+ return;
+ }
+
+ steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner);
+ sp= MEM_callocN(sizeof(ShaderPreview), "shader preview");
+
+ /* customdata for preview thread */
+ sp->scene= CTX_data_scene(C);
+ sp->owner= owner;
+ sp->sizex= sizex;
+ sp->sizey= sizey;
+ sp->pr_method= PR_DO_RENDER;
+ sp->id = id;
+ sp->parent= parent;
+ sp->slot= slot;
+
+ /* setup job */
+ WM_jobs_customdata(steve, sp, shader_preview_free);
+ WM_jobs_timer(steve, 0.1, NC_MATERIAL, NC_MATERIAL);
+ WM_jobs_callbacks(steve, common_preview_startjob, NULL, shader_preview_updatejob);
+
+ WM_jobs_start(CTX_wm_manager(C), steve);
+}
+
+
diff --git a/source/blender/editors/render/render_shading.c b/source/blender/editors/render/render_shading.c
new file mode 100644
index 00000000000..a31a60ecbd6
--- /dev/null
+++ b/source/blender/editors/render/render_shading.c
@@ -0,0 +1,645 @@
+/**
+ * $Id:
+ *
+ * ***** 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.
+ *
+ * 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) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_curve_types.h"
+#include "DNA_lamp_types.h"
+#include "DNA_material_types.h"
+#include "DNA_meshdata_types.h"
+#include "DNA_node_types.h"
+#include "DNA_object_types.h"
+#include "DNA_texture_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_world_types.h"
+
+#include "BKE_context.h"
+#include "BKE_depsgraph.h"
+#include "BKE_font.h"
+#include "BKE_icons.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+#include "BKE_material.h"
+#include "BKE_node.h"
+#include "BKE_scene.h"
+#include "BKE_texture.h"
+#include "BKE_utildefines.h"
+#include "BKE_world.h"
+
+#include "BLI_arithb.h"
+#include "BLI_editVert.h"
+#include "BLI_listbase.h"
+
+#include "GPU_material.h"
+
+#include "RNA_access.h"
+#include "RNA_enum_types.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_curve.h"
+#include "ED_mesh.h"
+#include "ED_render.h"
+
+#include "RNA_access.h"
+#include "RNA_define.h"
+
+#include "UI_interface.h"
+#include "UI_resources.h"
+
+#include "render_intern.h" // own include
+
+/***************************** Updates ***********************************
+ * ED_render_id_flush_update gets called from DAG_id_flush_update, to do *
+ * editor level updates when the ID changes. when these ID blocks are in *
+ * the dependency graph, we can get rid of the manual dependency checks */
+
+static int mtex_use_tex(MTex **mtex, int tot, Tex *tex)
+{
+ int a;
+
+ if(!mtex)
+ return 0;
+
+ for(a=0; a<tot; a++)
+ if(mtex[a] && mtex[a]->tex == tex)
+ return 1;
+
+ return 0;
+}
+
+static int nodes_use_tex(bNodeTree *ntree, Tex *tex)
+{
+ bNode *node;
+
+ for(node=ntree->nodes.first; node; node= node->next) {
+ if(node->id) {
+ if(node->id == (ID*)tex) {
+ return 1;
+ }
+ else if(node->type==NODE_GROUP) {
+ if(nodes_use_tex((bNodeTree *)node->id, tex))
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static void material_changed(Main *bmain, Material *ma)
+{
+ /* icons */
+ BKE_icon_changed(BKE_icon_getid(&ma->id));
+
+ /* glsl */
+ if(ma->gpumaterial.first)
+ GPU_material_free(ma);
+}
+
+static void texture_changed(Main *bmain, Tex *tex)
+{
+ Material *ma;
+ Lamp *la;
+ World *wo;
+
+ /* icons */
+ BKE_icon_changed(BKE_icon_getid(&tex->id));
+
+ /* find materials */
+ for(ma=bmain->mat.first; ma; ma=ma->id.next) {
+ if(mtex_use_tex(ma->mtex, MAX_MTEX, tex));
+ else if(ma->use_nodes && ma->nodetree && nodes_use_tex(ma->nodetree, tex));
+ else continue;
+
+ BKE_icon_changed(BKE_icon_getid(&ma->id));
+
+ if(ma->gpumaterial.first)
+ GPU_material_free(ma);
+ }
+
+ /* find lamps */
+ for(la=bmain->lamp.first; la; la=la->id.next) {
+ if(mtex_use_tex(la->mtex, MAX_MTEX, tex));
+ else continue;
+
+ BKE_icon_changed(BKE_icon_getid(&la->id));
+ }
+
+ /* find worlds */
+ for(wo=bmain->world.first; wo; wo=wo->id.next) {
+ if(mtex_use_tex(wo->mtex, MAX_MTEX, tex));
+ else continue;
+
+ BKE_icon_changed(BKE_icon_getid(&wo->id));
+ }
+}
+
+static void lamp_changed(Main *bmain, Lamp *la)
+{
+ Object *ob;
+ Material *ma;
+
+ /* icons */
+ BKE_icon_changed(BKE_icon_getid(&la->id));
+
+ /* glsl */
+ for(ob=bmain->object.first; ob; ob=ob->id.next)
+ if(ob->data == la && ob->gpulamp.first)
+ GPU_lamp_free(ob);
+
+ for(ma=bmain->mat.first; ma; ma=ma->id.next)
+ if(ma->gpumaterial.first)
+ GPU_material_free(ma);
+}
+
+static void world_changed(Main *bmain, World *wo)
+{
+ Material *ma;
+
+ /* icons */
+ BKE_icon_changed(BKE_icon_getid(&wo->id));
+
+ /* glsl */
+ for(ma=bmain->mat.first; ma; ma=ma->id.next)
+ if(ma->gpumaterial.first)
+ GPU_material_free(ma);
+}
+
+void ED_render_id_flush_update(Main *bmain, ID *id)
+{
+ switch(GS(id->name)) {
+ case ID_MA:
+ material_changed(bmain, (Material*)id);
+ break;
+ case ID_TE:
+ texture_changed(bmain, (Tex*)id);
+ break;
+ case ID_WO:
+ world_changed(bmain, (World*)id);
+ break;
+ case ID_LA:
+ lamp_changed(bmain, (Lamp*)id);
+ break;
+ default:
+ break;
+ }
+}
+
+/********************** material slot operators *********************/
+
+static int material_slot_add_exec(bContext *C, wmOperator *op)
+{
+ Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
+
+ if(!ob)
+ return OPERATOR_CANCELLED;
+
+ object_add_material_slot(ob);
+ WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
+
+ return OPERATOR_FINISHED;
+}
+
+void OBJECT_OT_material_slot_add(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Add Material Slot";
+ ot->idname= "OBJECT_OT_material_slot_add";
+ ot->description="Add a new material slot or duplicate the selected one.";
+
+ /* api callbacks */
+ ot->exec= material_slot_add_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+static int material_slot_remove_exec(bContext *C, wmOperator *op)
+{
+ Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
+
+ if(!ob)
+ return OPERATOR_CANCELLED;
+
+ object_remove_material_slot(ob);
+ WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
+
+ return OPERATOR_FINISHED;
+}
+
+void OBJECT_OT_material_slot_remove(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Remove Material Slot";
+ ot->idname= "OBJECT_OT_material_slot_remove";
+ ot->description="Remove the selected material slot.";
+
+ /* api callbacks */
+ ot->exec= material_slot_remove_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+static int material_slot_assign_exec(bContext *C, wmOperator *op)
+{
+ Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
+
+ if(!ob)
+ return OPERATOR_CANCELLED;
+
+ if(ob && ob->actcol>0) {
+ if(ob->type == OB_MESH) {
+ EditMesh *em= ((Mesh*)ob->data)->edit_mesh;
+ EditFace *efa;
+
+ if(em) {
+ for(efa= em->faces.first; efa; efa=efa->next)
+ if(efa->f & SELECT)
+ efa->mat_nr= ob->actcol-1;
+ }
+ }
+ else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
+ ListBase *editnurb= ((Curve*)ob->data)->editnurb;
+ Nurb *nu;
+
+ if(editnurb) {
+ for(nu= editnurb->first; nu; nu= nu->next)
+ if(isNurbsel(nu))
+ nu->mat_nr= nu->charidx= ob->actcol-1;
+ }
+ }
+ else if(ob->type == OB_FONT) {
+ EditFont *ef= ((Curve*)ob->data)->editfont;
+ int i, selstart, selend;
+
+ if(ef && BKE_font_getselection(ob, &selstart, &selend)) {
+ for(i=selstart; i<=selend; i++)
+ ef->textbufinfo[i].mat_nr = ob->actcol-1;
+ }
+ }
+ }
+
+ DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
+ WM_event_add_notifier(C, NC_GEOM|ND_DATA, ob->data);
+
+ return OPERATOR_FINISHED;
+}
+
+void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Assign Material Slot";
+ ot->idname= "OBJECT_OT_material_slot_assign";
+ ot->description="Assign the material in the selected material slot to the selected vertices.";
+
+ /* api callbacks */
+ ot->exec= material_slot_assign_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+static int material_slot_de_select(bContext *C, int select)
+{
+ Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
+
+ if(!ob)
+ return OPERATOR_CANCELLED;
+
+ if(ob->type == OB_MESH) {
+ EditMesh *em= ((Mesh*)ob->data)->edit_mesh;
+
+ if(em) {
+ if(select)
+ EM_select_by_material(em, ob->actcol-1);
+ else
+ EM_deselect_by_material(em, ob->actcol-1);
+ }
+ }
+ else if ELEM(ob->type, OB_CURVE, OB_SURF) {
+ ListBase *editnurb= ((Curve*)ob->data)->editnurb;
+ Nurb *nu;
+ BPoint *bp;
+ BezTriple *bezt;
+ int a;
+
+ for(nu= editnurb->first; nu; nu=nu->next) {
+ if(nu->mat_nr==ob->actcol-1) {
+ if(nu->bezt) {
+ a= nu->pntsu;
+ bezt= nu->bezt;
+ while(a--) {
+ if(bezt->hide==0) {
+ if(select) {
+ bezt->f1 |= SELECT;
+ bezt->f2 |= SELECT;
+ bezt->f3 |= SELECT;
+ }
+ else {
+ bezt->f1 &= ~SELECT;
+ bezt->f2 &= ~SELECT;
+ bezt->f3 &= ~SELECT;
+ }
+ }
+ bezt++;
+ }
+ }
+ else if(nu->bp) {
+ a= nu->pntsu*nu->pntsv;
+ bp= nu->bp;
+ while(a--) {
+ if(bp->hide==0) {
+ if(select) bp->f1 |= SELECT;
+ else bp->f1 &= ~SELECT;
+ }
+ bp++;
+ }
+ }
+ }
+ }
+ }
+
+ WM_event_add_notifier(C, NC_GEOM|ND_SELECT, ob->data);
+
+ return OPERATOR_FINISHED;
+}
+
+static int material_slot_select_exec(bContext *C, wmOperator *op)
+{
+ return material_slot_de_select(C, 1);
+}
+
+void OBJECT_OT_material_slot_select(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Select Material Slot";
+ ot->idname= "OBJECT_OT_material_slot_select";
+ ot->description="Select vertices assigned to the selected material slot.";
+
+ /* api callbacks */
+ ot->exec= material_slot_select_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+static int material_slot_deselect_exec(bContext *C, wmOperator *op)
+{
+ return material_slot_de_select(C, 0);
+}
+
+void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Deselect Material Slot";
+ ot->idname= "OBJECT_OT_material_slot_deselect";
+ ot->description="Deselect vertices assigned to the selected material slot.";
+
+ /* api callbacks */
+ ot->exec= material_slot_deselect_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+/********************** new material operator *********************/
+
+static int new_material_exec(bContext *C, wmOperator *op)
+{
+ Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
+ Object *ob;
+ PointerRNA ptr;
+ int index;
+
+ /* add or copy material */
+ if(ma)
+ ma= copy_material(ma);
+ else
+ ma= add_material("Material");
+
+ ma->id.us--; /* compensating for us++ in assign_material */
+
+ /* attempt to assign to material slot */
+ ptr= CTX_data_pointer_get_type(C, "material_slot", &RNA_MaterialSlot);
+
+ if(ptr.data) {
+ ob= ptr.id.data;
+ index= (Material**)ptr.data - ob->mat;
+
+ assign_material(ob, ma, index+1);
+
+ WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
+ }
+
+ WM_event_add_notifier(C, NC_MATERIAL|NA_ADDED, ma);
+
+ return OPERATOR_FINISHED;
+}
+
+void MATERIAL_OT_new(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "New Material";
+ ot->idname= "MATERIAL_OT_new";
+ ot->description="Add a new material.";
+
+ /* api callbacks */
+ ot->exec= new_material_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+/********************** new texture operator *********************/
+
+static int new_texture_exec(bContext *C, wmOperator *op)
+{
+ Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
+ ID *id;
+ MTex *mtex;
+ PointerRNA ptr;
+
+ /* add or copy texture */
+ if(tex)
+ tex= copy_texture(tex);
+ else
+ tex= add_texture("Texture");
+
+ id_us_min(&tex->id);
+
+ /* attempt to assign to texture slot */
+ ptr= CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot);
+
+ if(ptr.data) {
+ id= ptr.id.data;
+ mtex= ptr.data;
+
+ if(mtex) {
+ if(mtex->tex)
+ id_us_min(&mtex->tex->id);
+ mtex->tex= tex;
+ id_us_plus(&tex->id);
+ }
+
+ /* XXX nodes, notifier .. */
+ }
+
+ WM_event_add_notifier(C, NC_TEXTURE|NA_ADDED, tex);
+
+ return OPERATOR_FINISHED;
+}
+
+void TEXTURE_OT_new(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "New Texture";
+ ot->idname= "TEXTURE_OT_new";
+ ot->description="Add a new texture.";
+
+ /* api callbacks */
+ ot->exec= new_texture_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+/********************** new world operator *********************/
+
+static int new_world_exec(bContext *C, wmOperator *op)
+{
+ Scene *scene= CTX_data_scene(C);
+ World *wo= CTX_data_pointer_get_type(C, "world", &RNA_World).data;
+
+ /* add or copy world */
+ if(wo)
+ wo= copy_world(wo);
+ else
+ wo= add_world("World");
+
+ /* assign to scene */
+ if(scene->world)
+ id_us_min(&scene->world->id);
+ scene->world= wo;
+
+ WM_event_add_notifier(C, NC_WORLD|NA_ADDED, wo);
+
+ return OPERATOR_FINISHED;
+}
+
+void WORLD_OT_new(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "New World";
+ ot->idname= "WORLD_OT_new";
+ ot->description= "Add a new world.";
+
+ /* api callbacks */
+ ot->exec= new_world_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+/********************** render layer operators *********************/
+
+static int render_layer_add_exec(bContext *C, wmOperator *op)
+{
+ Scene *scene= CTX_data_scene(C);
+
+ scene_add_render_layer(scene);
+ scene->r.actlay= BLI_countlist(&scene->r.layers) - 1;
+
+ WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
+
+ return OPERATOR_FINISHED;
+}
+
+void SCENE_OT_render_layer_add(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Add Render Layer";
+ ot->idname= "SCENE_OT_render_layer_add";
+ ot->description="Add a render layer.";
+
+ /* api callbacks */
+ ot->exec= render_layer_add_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+static int render_layer_remove_exec(bContext *C, wmOperator *op)
+{
+ Scene *scene= CTX_data_scene(C);
+ SceneRenderLayer *rl;
+ int act= scene->r.actlay;
+
+ if(BLI_countlist(&scene->r.layers) <= 1)
+ return OPERATOR_CANCELLED;
+
+ rl= BLI_findlink(&scene->r.layers, scene->r.actlay);
+ BLI_remlink(&scene->r.layers, rl);
+ MEM_freeN(rl);
+
+ scene->r.actlay= 0;
+
+ if(scene->nodetree) {
+ bNode *node;
+ for(node= scene->nodetree->nodes.first; node; node= node->next) {
+ if(node->type==CMP_NODE_R_LAYERS && node->id==NULL) {
+ if(node->custom1==act)
+ node->custom1= 0;
+ else if(node->custom1>act)
+ node->custom1--;
+ }
+ }
+ }
+
+ WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
+
+ return OPERATOR_FINISHED;
+}
+
+void SCENE_OT_render_layer_remove(wmOperatorType *ot)
+{
+ /* identifiers */
+ ot->name= "Remove Render Layer";
+ ot->idname= "SCENE_OT_render_layer_remove";
+ ot->description="Remove the selected render layer.";
+
+ /* api callbacks */
+ ot->exec= render_layer_remove_exec;
+
+ /* flags */
+ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+