diff options
author | Ton Roosendaal <ton@blender.org> | 2008-12-19 15:14:58 +0300 |
---|---|---|
committer | Ton Roosendaal <ton@blender.org> | 2008-12-19 15:14:58 +0300 |
commit | d92b45d558b861ef3c314f1d9c926113aa36326c (patch) | |
tree | d057b1bf627026fc1bbecec74e4625ed737d5229 /source | |
parent | c752ec9fc458f6fd1fc0ae7a156d33bf86e73eff (diff) |
2.5
Drawing code for space_view3d module.
It's still not cleaned, have to check on context usage still.
Also missing is editmodes, armatures, and probably more.
Known issue: splitting to 2nd window gives bad opengl lighting.
Picture for fun:
http://www.blender.org/bf/rt2.jpg
Current stat: brought back almost 10k lines! :)
Diffstat (limited to 'source')
-rw-r--r-- | source/blender/editors/include/BIF_retopo.h | 110 | ||||
-rw-r--r-- | source/blender/editors/include/ED_types.h | 5 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/Makefile | 1 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/SConscript | 1 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/drawmesh.c | 579 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/drawobject.c | 5475 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/view3d_draw.c | 385 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/view3d_edit.c | 1086 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/view3d_header.c | 1 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/view3d_intern.h | 48 | ||||
-rw-r--r-- | source/blender/editors/space_view3d/view3d_view.c | 941 | ||||
-rw-r--r-- | source/blender/windowmanager/SConscript | 2 | ||||
-rw-r--r-- | source/blender/windowmanager/WM_api.h | 2 | ||||
-rw-r--r-- | source/blender/windowmanager/intern/Makefile | 1 | ||||
-rw-r--r-- | source/blender/windowmanager/intern/wm_init_exit.c | 12 | ||||
-rw-r--r-- | source/blender/windowmanager/intern/wm_subwindow.c | 2 |
16 files changed, 8510 insertions, 141 deletions
diff --git a/source/blender/editors/include/BIF_retopo.h b/source/blender/editors/include/BIF_retopo.h new file mode 100644 index 00000000000..cc2fda56b07 --- /dev/null +++ b/source/blender/editors/include/BIF_retopo.h @@ -0,0 +1,110 @@ +/* + * $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) 2006 by Nicholas Bishop + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef BIF_RETOPO_H +#define BIF_RETOPO_H + +#include "DNA_vec_types.h" + +/* For bglMats */ +#include "BIF_glutil.h" + +struct EditVert; +struct Mesh; +struct View3D; + +typedef struct RetopoViewData { + bglMats mats; + + char queue_matrix_update; +} RetopoViewData; + +typedef struct RetopoPaintPoint { + struct RetopoPaintPoint *next, *prev; + vec2s loc; + short index; + float co[3]; + struct EditVert *eve; +} RetopoPaintPoint; + +typedef struct RetopoPaintLine { + struct RetopoPaintLine *next, *prev; + ListBase points; + ListBase hitlist; /* RetopoPaintHit */ + RetopoPaintPoint *cyclic; +} RetopoPaintLine; + +typedef struct RetopoPaintSel { + struct RetopoPaintSel *next, *prev; + RetopoPaintLine *line; + char first; +} RetopoPaintSel; + +typedef struct RetopoPaintData { + char in_drag; + short sloc[2]; + + ListBase lines; + ListBase intersections; /* RetopoPaintPoint */ + + short seldist; + RetopoPaintSel nearest; + + struct View3D *paint_v3d; +} RetopoPaintData; + +RetopoPaintData *get_retopo_paint_data(void); + +char retopo_mesh_check(void); +char retopo_curve_check(void); + +void retopo_end_okee(void); + +void retopo_free_paint_data(RetopoPaintData *rpd); +void retopo_free_paint(void); + +char retopo_mesh_paint_check(void); +void retopo_paint_view_update(struct View3D *v3d); +void retopo_force_update(void); +void retopo_paint_toggle(void*,void*); +char retopo_paint(const unsigned short event); +void retopo_draw_paint_lines(void); +RetopoPaintData *retopo_paint_data_copy(RetopoPaintData *rpd); + +void retopo_toggle(void*,void*); +void retopo_do_vert(struct View3D *v3d, float *v); +void retopo_do_all(void); +void retopo_do_all_cb(void *, void *); +void retopo_queue_updates(struct View3D *v3d); + +void retopo_matrix_update(struct View3D *v3d); + +void retopo_free_view_data(struct View3D *v3d); + +#endif diff --git a/source/blender/editors/include/ED_types.h b/source/blender/editors/include/ED_types.h index 7b19341fb9e..ec5dce0c70d 100644 --- a/source/blender/editors/include/ED_types.h +++ b/source/blender/editors/include/ED_types.h @@ -31,8 +31,9 @@ /* **************** GENERAL EDITOR-WIDE TYPES AND DEFINES ************************** */ /* old blender defines... should be depricated? */ -#define SELECT 1 -#define ACTIVE 2 +#define DESELECT 0 +#define SELECT 1 +#define ACTIVE 2 #endif /* ED_TYPES_H */ diff --git a/source/blender/editors/space_view3d/Makefile b/source/blender/editors/space_view3d/Makefile index e097d041a37..7a5f609a187 100644 --- a/source/blender/editors/space_view3d/Makefile +++ b/source/blender/editors/space_view3d/Makefile @@ -48,6 +48,7 @@ CPPFLAGS += -I../../blenlib CPPFLAGS += -I../../makesdna CPPFLAGS += -I../../imbuf CPPFLAGS += -I../../python +CPPFLAGS += -I../../gpu CPPFLAGS += -I../../render/extern/include CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include diff --git a/source/blender/editors/space_view3d/SConscript b/source/blender/editors/space_view3d/SConscript index 5d30ae91deb..77cf03820ed 100644 --- a/source/blender/editors/space_view3d/SConscript +++ b/source/blender/editors/space_view3d/SConscript @@ -6,5 +6,6 @@ sources = env.Glob('*.c') incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include' incs += ' ../../render/extern/include #/intern/guardedalloc #intern/bmfont' +incs += ' ../../gpu' env.BlenderLib ( 'bf_editors_space_view3d', sources, Split(incs), [], libtype=['core','intern'], priority=[35, 40] ) diff --git a/source/blender/editors/space_view3d/drawmesh.c b/source/blender/editors/space_view3d/drawmesh.c new file mode 100644 index 00000000000..01740d2b3b4 --- /dev/null +++ b/source/blender/editors/space_view3d/drawmesh.c @@ -0,0 +1,579 @@ +/** + * $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) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Blender Foundation, full update, glsl support + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <string.h> +#include <math.h> + +#include "MEM_guardedalloc.h" + +#include "BLI_blenlib.h" +#include "BLI_arithb.h" +#include "BLI_edgehash.h" +#include "BLI_editVert.h" + +#include "IMB_imbuf.h" +#include "IMB_imbuf_types.h" + +#include "DNA_image_types.h" +#include "DNA_lamp_types.h" +#include "DNA_material_types.h" +#include "DNA_mesh_types.h" +#include "DNA_meshdata_types.h" +#include "DNA_object_types.h" +#include "DNA_property_types.h" +#include "DNA_scene_types.h" +#include "DNA_screen_types.h" +#include "DNA_view3d_types.h" +#include "DNA_userdef_types.h" + +#include "BKE_bmfont.h" +#include "BKE_context.h" +#include "BKE_displist.h" +#include "BKE_DerivedMesh.h" +#include "BKE_effect.h" +#include "BKE_global.h" +#include "BKE_image.h" +#include "BKE_main.h" +#include "BKE_material.h" +#include "BKE_mesh.h" +#include "BKE_object.h" +#include "BKE_property.h" +#include "BKE_utildefines.h" + +#include "BIF_gl.h" +#include "BIF_glutil.h" + +#include "UI_resources.h" +#include "UI_interface_icons.h" + +#include "GPU_extensions.h" +#include "GPU_draw.h" + +#include "view3d_intern.h" // own include + +/***/ + + /* Flags for marked edges */ +enum { + eEdge_Visible = (1<<0), + eEdge_Select = (1<<1), +}; + + /* Creates a hash of edges to flags indicating + * adjacent tface select/active/etc flags. + */ +static void get_marked_edge_info__orFlags(EdgeHash *eh, int v0, int v1, int flags) +{ + int *flags_p; + + if (!BLI_edgehash_haskey(eh, v0, v1)) { + BLI_edgehash_insert(eh, v0, v1, 0); + } + + flags_p = (int*) BLI_edgehash_lookup_p(eh, v0, v1); + *flags_p |= flags; +} + +static EdgeHash *get_tface_mesh_marked_edge_info(Mesh *me) +{ + EdgeHash *eh = BLI_edgehash_new(); + int i; + MFace *mf; + MTFace *tf = NULL; + + for (i=0; i<me->totface; i++) { + mf = &me->mface[i]; + if (me->mtface) + tf = &me->mtface[i]; + + if (mf->v3) { + if (!(mf->flag&ME_HIDE)) { + unsigned int flags = eEdge_Visible; + if (mf->flag&ME_FACE_SEL) flags |= eEdge_Select; + + get_marked_edge_info__orFlags(eh, mf->v1, mf->v2, flags); + get_marked_edge_info__orFlags(eh, mf->v2, mf->v3, flags); + if (mf->v4) { + get_marked_edge_info__orFlags(eh, mf->v3, mf->v4, flags); + get_marked_edge_info__orFlags(eh, mf->v4, mf->v1, flags); + } else { + get_marked_edge_info__orFlags(eh, mf->v3, mf->v1, flags); + } + } + } + } + + return eh; +} + + +static int draw_tfaces3D__setHiddenOpts(void *userData, int index) +{ + struct { Mesh *me; EdgeHash *eh; } *data = userData; + MEdge *med = &data->me->medge[index]; + uintptr_t flags = (intptr_t) BLI_edgehash_lookup(data->eh, med->v1, med->v2); + + if((G.f & G_DRAWSEAMS) && (med->flag&ME_SEAM)) { + return 0; + } else if(G.f & G_DRAWEDGES){ + if (G.f&G_HIDDENEDGES) { + return 1; + } else { + return (flags & eEdge_Visible); + } + } else { + return (flags & eEdge_Select); + } +} +static int draw_tfaces3D__setSeamOpts(void *userData, int index) +{ + struct { Mesh *me; EdgeHash *eh; } *data = userData; + MEdge *med = &data->me->medge[index]; + uintptr_t flags = (intptr_t) BLI_edgehash_lookup(data->eh, med->v1, med->v2); + + if (med->flag&ME_SEAM) { + if (G.f&G_HIDDENEDGES) { + return 1; + } else { + return (flags & eEdge_Visible); + } + } else { + return 0; + } +} +static int draw_tfaces3D__setSelectOpts(void *userData, int index) +{ + struct { Mesh *me; EdgeHash *eh; } *data = userData; + MEdge *med = &data->me->medge[index]; + uintptr_t flags = (intptr_t) BLI_edgehash_lookup(data->eh, med->v1, med->v2); + + return flags & eEdge_Select; +} +static int draw_tfaces3D__setActiveOpts(void *userData, int index) +{ + struct { Mesh *me; EdgeHash *eh; } *data = userData; + MEdge *med = &data->me->medge[index]; + uintptr_t flags = (intptr_t) BLI_edgehash_lookup(data->eh, med->v1, med->v2); + + if (flags & eEdge_Select) { + return 1; + } else { + return 0; + } +} +static int draw_tfaces3D__drawFaceOpts(void *userData, int index) +{ + Mesh *me = (Mesh*)userData; + + MFace *mface = &me->mface[index]; + if (!(mface->flag&ME_HIDE) && (mface->flag&ME_FACE_SEL)) + return 2; /* Don't set color */ + else + return 0; +} +static void draw_tfaces3D(Object *ob, Mesh *me, DerivedMesh *dm) +{ + struct { Mesh *me; EdgeHash *eh; } data; + + data.me = me; + data.eh = get_tface_mesh_marked_edge_info(me); + + glEnable(GL_DEPTH_TEST); + glDisable(GL_LIGHTING); + bglPolygonOffset(1.0); + + /* Draw (Hidden) Edges */ + UI_ThemeColor(TH_EDGE_FACESEL); + dm->drawMappedEdges(dm, draw_tfaces3D__setHiddenOpts, &data); + + /* Draw Seams */ + if(G.f & G_DRAWSEAMS) { + UI_ThemeColor(TH_EDGE_SEAM); + glLineWidth(2); + + dm->drawMappedEdges(dm, draw_tfaces3D__setSeamOpts, &data); + + glLineWidth(1); + } + + /* Draw Selected Faces */ + if(G.f & G_DRAWFACES) { + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + UI_ThemeColor4(TH_FACE_SELECT); + + dm->drawMappedFacesTex(dm, draw_tfaces3D__drawFaceOpts, (void*)me); + + glDisable(GL_BLEND); + } + + bglPolygonOffset(1.0); + + /* Draw Stippled Outline for selected faces */ + glColor3ub(255, 255, 255); + setlinestyle(1); + dm->drawMappedEdges(dm, draw_tfaces3D__setSelectOpts, &data); + setlinestyle(0); + + dm->drawMappedEdges(dm, draw_tfaces3D__setActiveOpts, &data); + + bglPolygonOffset(0.0); // resets correctly now, even after calling accumulated offsets + + BLI_edgehash_free(data.eh, NULL); +} + +static Material *give_current_material_or_def(Object *ob, int matnr) +{ + extern Material defmaterial; // render module abuse... + Material *ma= give_current_material(ob, matnr); + + return ma?ma:&defmaterial; +} + +static int set_draw_settings_cached(int clearcache, int textured, MTFace *texface, int lit, Object *litob, int litmatnr, int doublesided) +{ + static int c_textured; + static int c_lit; + static int c_doublesided; + static MTFace *c_texface; + static Object *c_litob; + static int c_litmatnr; + static int c_badtex; + + if (clearcache) { + c_textured= c_lit= c_doublesided= -1; + c_texface= (MTFace*) -1; + c_litob= (Object*) -1; + c_litmatnr= -1; + c_badtex= 0; + } + + if (texface) { + lit = lit && (lit==-1 || texface->mode&TF_LIGHT); + textured = textured && (texface->mode&TF_TEX); + doublesided = texface->mode&TF_TWOSIDE; + } else { + textured = 0; + } + + if (doublesided!=c_doublesided) { + if (doublesided) glDisable(GL_CULL_FACE); + else glEnable(GL_CULL_FACE); + + c_doublesided= doublesided; + } + + if (textured!=c_textured || texface!=c_texface) { + if (textured ) { + c_badtex= !GPU_set_tpage(texface); + } else { + GPU_set_tpage(0); + c_badtex= 0; + } + c_textured= textured; + c_texface= texface; + } + + if (c_badtex) lit= 0; + if (lit!=c_lit || litob!=c_litob || litmatnr!=c_litmatnr) { + if (lit) { + Material *ma= give_current_material_or_def(litob, litmatnr+1); + float spec[4]; + + spec[0]= ma->spec*ma->specr; + spec[1]= ma->spec*ma->specg; + spec[2]= ma->spec*ma->specb; + spec[3]= 1.0; + + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spec); + glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); + glEnable(GL_LIGHTING); + glEnable(GL_COLOR_MATERIAL); + } + else { + glDisable(GL_LIGHTING); + glDisable(GL_COLOR_MATERIAL); + } + c_lit= lit; + c_litob= litob; + c_litmatnr= litmatnr; + } + + return c_badtex; +} + +/* Icky globals, fix with userdata parameter */ + +struct TextureDrawState { + Object *ob; + int islit, istex; + unsigned char obcol[4]; +} Gtexdraw = {NULL, 0, 0, {0, 0, 0, 0}}; + +static void draw_textured_begin(Scene *scene, View3D *v3d, Object *ob) +{ + unsigned char obcol[4]; + int istex, solidtex= 0; + + if(v3d->drawtype==OB_SOLID || (ob==G.obedit && v3d->drawtype!=OB_TEXTURE)) { + /* draw with default lights in solid draw mode and edit mode */ + solidtex= 1; + Gtexdraw.islit= -1; + } + else + /* draw with lights in the scene otherwise */ + Gtexdraw.islit= GPU_scene_object_lights(scene, ob, v3d->lay, v3d->viewmat); + + obcol[0]= CLAMPIS(ob->col[0]*255, 0, 255); + obcol[1]= CLAMPIS(ob->col[1]*255, 0, 255); + obcol[2]= CLAMPIS(ob->col[2]*255, 0, 255); + obcol[3]= CLAMPIS(ob->col[3]*255, 0, 255); + + glCullFace(GL_BACK); glEnable(GL_CULL_FACE); + if(solidtex || v3d->drawtype==OB_TEXTURE) istex= 1; + else istex= 0; + + Gtexdraw.ob = ob; + Gtexdraw.istex = istex; + memcpy(Gtexdraw.obcol, obcol, sizeof(obcol)); + set_draw_settings_cached(1, 0, 0, Gtexdraw.islit, 0, 0, 0); + glShadeModel(GL_SMOOTH); +} + +static void draw_textured_end() +{ + /* switch off textures */ + GPU_set_tpage(0); + + glShadeModel(GL_FLAT); + glDisable(GL_CULL_FACE); + + /* XXX, bad patch - GPU_default_lights() calls + * glLightfv(GL_LIGHT_POSITION, ...) which + * is transformed by the current matrix... we + * need to make sure that matrix is identity. + * + * It would be better if drawmesh.c kept track + * of and restored the light settings it changed. + * - zr + */ + glPushMatrix(); + glLoadIdentity(); + GPU_default_lights(); + glPopMatrix(); +} + + +static int draw_tface__set_draw(MTFace *tface, MCol *mcol, int matnr) +{ + if (tface && (tface->mode&TF_INVISIBLE)) return 0; + + if (tface && set_draw_settings_cached(0, Gtexdraw.istex, tface, Gtexdraw.islit, Gtexdraw.ob, matnr, TF_TWOSIDE)) { + glColor3ub(0xFF, 0x00, 0xFF); + return 2; /* Don't set color */ + } else if (tface && tface->mode&TF_OBCOL) { + glColor3ubv(Gtexdraw.obcol); + return 2; /* Don't set color */ + } else if (!mcol) { + if (tface) glColor3f(1.0, 1.0, 1.0); + else { + Material *ma= give_current_material(Gtexdraw.ob, matnr+1); + if(ma) glColor3f(ma->r, ma->g, ma->b); + else glColor3f(1.0, 1.0, 1.0); + } + return 2; /* Don't set color */ + } else { + return 1; /* Set color from mcol */ + } +} + +static int draw_tface_mapped__set_draw(void *userData, int index) +{ + Mesh *me = (Mesh*)userData; + MTFace *tface = (me->mtface)? &me->mtface[index]: NULL; + MFace *mface = (me->mface)? &me->mface[index]: NULL; + MCol *mcol = (me->mcol)? &me->mcol[index]: NULL; + int matnr = me->mface[index].mat_nr; + if (mface && mface->flag&ME_HIDE) return 0; + return draw_tface__set_draw(tface, mcol, matnr); +} + +static int draw_em_tf_mapped__set_draw(void *userData, int index) +{ + EditMesh *em = userData; + EditFace *efa= NULL; // XXX = EM_get_face_for_index(index); + MTFace *tface; + MCol *mcol; + int matnr; + + if (efa==NULL || efa->h) + return 0; + + tface = CustomData_em_get(&em->fdata, efa->data, CD_MTFACE); + mcol = CustomData_em_get(&em->fdata, efa->data, CD_MCOL); + matnr = efa->mat_nr; + + return draw_tface__set_draw(tface, mcol, matnr); +} + +static int wpaint__setSolidDrawOptions(void *userData, int index, int *drawSmooth_r) +{ + Mesh *me = (Mesh*)userData; + MTFace *tface = (me->mtface)? &me->mtface[index]: NULL; + MFace *mface = (me->mface)? &me->mface[index]: NULL; + + if ((mface->flag&ME_HIDE) || (tface && (tface->mode&TF_INVISIBLE))) + return 0; + + *drawSmooth_r = 1; + return 1; +} + +void draw_mesh_text(Object *ob, int glsl) +{ + Mesh *me = ob->data; + DerivedMesh *ddm; + MFace *mf, *mface= me->mface; + MTFace *tface= me->mtface; + MCol *mcol= me->mcol; /* why does mcol exist? */ + bProperty *prop = get_ob_property(ob, "Text"); + GPUVertexAttribs gattribs; + int a, totface= me->totface; + + /* don't draw without tfaces */ + if(!tface) + return; + + /* don't draw when editing */ + if(ob==G.obedit) + return; + else if(ob==OBACT) + if(FACESEL_PAINT_TEST) + return; + + ddm = mesh_get_derived_deform(ob, CD_MASK_BAREMESH); + + for(a=0, mf=mface; a<totface; a++, tface++, mf++) { + int mode= tface->mode; + int matnr= mf->mat_nr; + int mf_smooth= mf->flag & ME_SMOOTH; + + if (!(mf->flag&ME_HIDE) && !(mode&TF_INVISIBLE) && (mode&TF_BMFONT)) { + float v1[3], v2[3], v3[3], v4[3]; + char string[MAX_PROPSTRING]; + int characters, i, glattrib= -1, badtex= 0; + + if(glsl) { + GPU_enable_material(matnr+1, &gattribs); + + for(i=0; i<gattribs.totlayer; i++) { + if(gattribs.layer[i].type == CD_MTFACE) { + glattrib = gattribs.layer[i].glindex; + break; + } + } + } + else { + badtex = set_draw_settings_cached(0, Gtexdraw.istex, tface, Gtexdraw.islit, Gtexdraw.ob, matnr, TF_TWOSIDE); + if (badtex) { + if (mcol) mcol+=4; + continue; + } + } + + ddm->getVertCo(ddm, mf->v1, v1); + ddm->getVertCo(ddm, mf->v2, v2); + ddm->getVertCo(ddm, mf->v3, v3); + if (mf->v4) ddm->getVertCo(ddm, mf->v4, v4); + + // The BM_FONT handling is in the gpu module, shared with the + // game engine, was duplicated previously + + set_property_valstr(prop, string); + characters = strlen(string); + + if(!BKE_image_get_ibuf(tface->tpage, NULL)) + characters = 0; + + if (!mf_smooth) { + float nor[3]; + + CalcNormFloat(v1, v2, v3, nor); + + glNormal3fv(nor); + } + + GPU_render_text(tface, tface->mode, string, characters, + (unsigned int*)mcol, v1, v2, v3, (mf->v4? v4: NULL), glattrib); + } + if (mcol) { + mcol+=4; + } + } + + ddm->release(ddm); +} + +void draw_mesh_textured(Scene *scene, View3D *v3d, Object *ob, DerivedMesh *dm, int faceselect) +{ + Mesh *me= ob->data; + + /* correct for negative scale */ + if(ob->transflag & OB_NEG_SCALE) glFrontFace(GL_CW); + else glFrontFace(GL_CCW); + + /* draw the textured mesh */ + draw_textured_begin(scene, v3d, ob); + + if(ob==G.obedit) { + dm->drawMappedFacesTex(dm, draw_em_tf_mapped__set_draw, G.editMesh); + } else if(faceselect) { + if(G.f & G_WEIGHTPAINT) + dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, me, 1); + else + dm->drawMappedFacesTex(dm, draw_tface_mapped__set_draw, me); + } + else + dm->drawFacesTex(dm, draw_tface__set_draw); + + /* draw game engine text hack */ + if(get_ob_property(ob, "Text")) + draw_mesh_text(ob, 0); + + draw_textured_end(); + + /* draw edges and selected faces over textured mesh */ + if(!G.obedit && faceselect) + draw_tfaces3D(ob, me, dm); + + /* reset from negative scale correction */ + glFrontFace(GL_CCW); + + /* in editmode, the blend mode needs to be set incase it was ADD */ + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +} + diff --git a/source/blender/editors/space_view3d/drawobject.c b/source/blender/editors/space_view3d/drawobject.c new file mode 100644 index 00000000000..f5a2cd9df00 --- /dev/null +++ b/source/blender/editors/space_view3d/drawobject.c @@ -0,0 +1,5475 @@ +/** + * $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) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Blender Foundation, full recode and added functions + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <string.h> +#include <math.h> + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include "MEM_guardedalloc.h" + +#include "BMF_Api.h" + +#include "IMB_imbuf.h" + + +#include "MTC_matrixops.h" + +#include "DNA_armature_types.h" +#include "DNA_camera_types.h" +#include "DNA_curve_types.h" +#include "DNA_constraint_types.h" // for drawing constraint +#include "DNA_effect_types.h" +#include "DNA_ipo_types.h" +#include "DNA_lamp_types.h" +#include "DNA_lattice_types.h" +#include "DNA_material_types.h" +#include "DNA_mesh_types.h" +#include "DNA_meshdata_types.h" +#include "DNA_meta_types.h" +#include "DNA_modifier_types.h" +#include "DNA_object_types.h" +#include "DNA_object_force.h" +#include "DNA_particle_types.h" +#include "DNA_space_types.h" +#include "DNA_scene_types.h" +#include "DNA_screen_types.h" +#include "DNA_userdef_types.h" +#include "DNA_view3d_types.h" +#include "DNA_world_types.h" +// FSPARTICLE +#include "DNA_object_fluidsim.h" + +#include "BLI_blenlib.h" +#include "BLI_arithb.h" +#include "BLI_editVert.h" +#include "BLI_edgehash.h" +#include "BLI_rand.h" + +#include "BKE_anim.h" //for the where_on_path function +#include "BKE_context.h" +#include "BKE_curve.h" +#include "BKE_constraint.h" // for the get_constraint_target function +#include "BKE_DerivedMesh.h" +#include "BKE_deform.h" +#include "BKE_displist.h" +#include "BKE_effect.h" +#include "BKE_font.h" +#include "BKE_global.h" +#include "BKE_image.h" +#include "BKE_ipo.h" +#include "BKE_key.h" +#include "BKE_lattice.h" +#include "BKE_mesh.h" +#include "BKE_material.h" +#include "BKE_mball.h" +#include "BKE_modifier.h" +#include "BKE_object.h" +#include "BKE_particle.h" +#include "BKE_property.h" +#include "BKE_utildefines.h" + +#include "BIF_gl.h" +#include "BIF_glutil.h" + +#include "GPU_draw.h" +#include "GPU_material.h" +#include "GPU_extensions.h" + +#include "ED_types.h" +#include "ED_util.h" + +#include "UI_resources.h" +#include "UI_interface_icons.h" + +#include "WM_api.h" + +#include "view3d_intern.h" // own include + + +/* pretty stupid */ +/* extern Lattice *editLatt; already in BKE_lattice.h */ +/* editcurve.c */ +extern ListBase editNurb; +/* editmball.c */ +extern ListBase editelems; + +static void draw_bounding_volume(Object *ob); + +static void drawcube_size(float size); +static void drawcircle_size(float size); +static void draw_empty_sphere(float size); +static void draw_empty_cone(float size); + +EditVert *EM_get_vert_for_index(int x) {return 0;} // XXX +EditEdge *EM_get_edge_for_index(int x) {return 0;} // XXX +EditFace *EM_get_face_for_index(int x) {return 0;} // XXX +void EM_init_index_arrays(int x, int y, int z) {} // XXX +void EM_free_index_arrays(void) {} // XXX +#define EM_FGON 0 +EditFace *EM_get_actFace(int x) {return NULL;} // XXX +int draw_armature(Base *base, int x, int y) {return 0;} // XXX +int em_solidoffs; // XXX +int em_wireoffs; +int em_vertoffs; + +/* check for glsl drawing */ + +int draw_glsl_material(Scene *scene, Object *ob, View3D *v3d, int dt) +{ + if(!GPU_extensions_minimum_support()) + return 0; + if(G.f & G_PICKSEL) + return 0; + if(!CHECK_OB_DRAWTEXTURE(v3d, dt)) + return 0; + if(ob==OBACT && (G.f & G_WEIGHTPAINT)) + return 0; + + return ((G.fileflags & G_FILE_GAME_MAT) && + (G.fileflags & G_FILE_GAME_MAT_GLSL) && (dt >= OB_SHADED)); +} + +static int check_material_alpha(Base *base, Object *ob, int glsl) +{ + if(base->flag & OB_FROMDUPLI) + return 0; + + if(G.f & G_PICKSEL) + return 0; + + if(G.obedit && G.obedit->data==ob->data) + return 0; + + return (glsl || (ob->dtx & OB_DRAWTRANSP)); +} + + /***/ +static unsigned int colortab[24]= + {0x0, 0xFF88FF, 0xFFBBFF, + 0x403000, 0xFFFF88, 0xFFFFBB, + 0x104040, 0x66CCCC, 0x77CCCC, + 0x104010, 0x55BB55, 0x66FF66, + 0xFFFFFF +}; + + +static float cube[8][3] = { + {-1.0, -1.0, -1.0}, + {-1.0, -1.0, 1.0}, + {-1.0, 1.0, 1.0}, + {-1.0, 1.0, -1.0}, + { 1.0, -1.0, -1.0}, + { 1.0, -1.0, 1.0}, + { 1.0, 1.0, 1.0}, + { 1.0, 1.0, -1.0}, +}; + +/* ----------------- OpenGL Circle Drawing - Tables for Optimised Drawing Speed ------------------ */ +/* 32 values of sin function (still same result!) */ +static float sinval[32] = { + 0.00000000, + 0.20129852, + 0.39435585, + 0.57126821, + 0.72479278, + 0.84864425, + 0.93775213, + 0.98846832, + 0.99871650, + 0.96807711, + 0.89780453, + 0.79077573, + 0.65137248, + 0.48530196, + 0.29936312, + 0.10116832, + -0.10116832, + -0.29936312, + -0.48530196, + -0.65137248, + -0.79077573, + -0.89780453, + -0.96807711, + -0.99871650, + -0.98846832, + -0.93775213, + -0.84864425, + -0.72479278, + -0.57126821, + -0.39435585, + -0.20129852, + 0.00000000 +}; + +/* 32 values of cos function (still same result!) */ +static float cosval[32] ={ + 1.00000000, + 0.97952994, + 0.91895781, + 0.82076344, + 0.68896691, + 0.52896401, + 0.34730525, + 0.15142777, + -0.05064916, + -0.25065253, + -0.44039415, + -0.61210598, + -0.75875812, + -0.87434661, + -0.95413925, + -0.99486932, + -0.99486932, + -0.95413925, + -0.87434661, + -0.75875812, + -0.61210598, + -0.44039415, + -0.25065253, + -0.05064916, + 0.15142777, + 0.34730525, + 0.52896401, + 0.68896691, + 0.82076344, + 0.91895781, + 0.97952994, + 1.00000000 +}; + +/* flag is same as for draw_object */ +void drawaxes(float size, int flag, char drawtype) +{ + int axis; + float v1[3]= {0.0, 0.0, 0.0}; + float v2[3]= {0.0, 0.0, 0.0}; + float v3[3]= {0.0, 0.0, 0.0}; + + if(G.f & G_RENDER_SHADOW) + return; + + switch(drawtype) { + + case OB_PLAINAXES: + for (axis=0; axis<3; axis++) { + float v1[3]= {0.0, 0.0, 0.0}; + float v2[3]= {0.0, 0.0, 0.0}; + + glBegin(GL_LINES); + + v1[axis]= size; + v2[axis]= -size; + glVertex3fv(v1); + glVertex3fv(v2); + + glEnd(); + } + break; + case OB_SINGLE_ARROW: + + glBegin(GL_LINES); + /* in positive z direction only */ + v1[2]= size; + glVertex3fv(v1); + glVertex3fv(v2); + glEnd(); + + /* square pyramid */ + glBegin(GL_TRIANGLES); + + v2[0]= size*0.035; v2[1] = size*0.035; + v3[0]= size*-0.035; v3[1] = size*0.035; + v2[2]= v3[2]= size*0.75; + + for (axis=0; axis<4; axis++) { + if (axis % 2 == 1) { + v2[0] *= -1; + v3[1] *= -1; + } else { + v2[1] *= -1; + v3[0] *= -1; + } + + glVertex3fv(v1); + glVertex3fv(v2); + glVertex3fv(v3); + + } + glEnd(); + + break; + case OB_CUBE: + drawcube_size(size); + break; + + case OB_CIRCLE: + drawcircle_size(size); + break; + + case OB_EMPTY_SPHERE: + draw_empty_sphere(size); + break; + + case OB_EMPTY_CONE: + draw_empty_cone(size); + break; + + case OB_ARROWS: + default: + for (axis=0; axis<3; axis++) { + float v1[3]= {0.0, 0.0, 0.0}; + float v2[3]= {0.0, 0.0, 0.0}; + int arrow_axis= (axis==0)?1:0; + + glBegin(GL_LINES); + + v2[axis]= size; + glVertex3fv(v1); + glVertex3fv(v2); + + v1[axis]= size*0.8; + v1[arrow_axis]= -size*0.125; + glVertex3fv(v1); + glVertex3fv(v2); + + v1[arrow_axis]= size*0.125; + glVertex3fv(v1); + glVertex3fv(v2); + + glEnd(); + + v2[axis]+= size*0.125; + glRasterPos3fv(v2); + + // patch for 3d cards crashing on glSelect for text drawing (IBM) + if((flag & DRAW_PICKING) == 0) { + if (axis==0) + BMF_DrawString(G.font, "x"); + else if (axis==1) + BMF_DrawString(G.font, "y"); + else + BMF_DrawString(G.font, "z"); + } + } + break; + } +} + +void drawcircball(int mode, float *cent, float rad, float tmat[][4]) +{ + float vec[3], vx[3], vy[3]; + int a, tot=32; + + VECCOPY(vx, tmat[0]); + VECCOPY(vy, tmat[1]); + VecMulf(vx, rad); + VecMulf(vy, rad); + + glBegin(mode); + for(a=0; a<tot; a++) { + vec[0]= cent[0] + *(sinval+a) * vx[0] + *(cosval+a) * vy[0]; + vec[1]= cent[1] + *(sinval+a) * vx[1] + *(cosval+a) * vy[1]; + vec[2]= cent[2] + *(sinval+a) * vx[2] + *(cosval+a) * vy[2]; + glVertex3fv(vec); + } + glEnd(); +} + +/* circle for object centers, special_color is for library or ob users */ +static void drawcentercircle(View3D *v3d, float *vec, int selstate, int special_color) +{ + float size; + + size= v3d->persmat[0][3]*vec[0]+ v3d->persmat[1][3]*vec[1]+ v3d->persmat[2][3]*vec[2]+ v3d->persmat[3][3]; + size*= v3d->pixsize*((float)U.obcenter_dia*0.5f); + + /* using gldepthfunc guarantees that it does write z values, but not checks for it, so centers remain visible independt order of drawing */ + if(v3d->zbuf) glDepthFunc(GL_ALWAYS); + glEnable(GL_BLEND); + + if(special_color) { + if (selstate==ACTIVE || selstate==SELECT) glColor4ub(0x88, 0xFF, 0xFF, 155); + + else glColor4ub(0x55, 0xCC, 0xCC, 155); + } + else { + if (selstate == ACTIVE) UI_ThemeColorShadeAlpha(TH_ACTIVE, 0, -80); + else if (selstate == SELECT) UI_ThemeColorShadeAlpha(TH_SELECT, 0, -80); + else if (selstate == DESELECT) UI_ThemeColorShadeAlpha(TH_TRANSFORM, 0, -80); + } + drawcircball(GL_POLYGON, vec, size, v3d->viewinv); + + UI_ThemeColorShadeAlpha(TH_WIRE, 0, -30); + drawcircball(GL_LINE_LOOP, vec, size, v3d->viewinv); + + glDisable(GL_BLEND); + if(v3d->zbuf) glDepthFunc(GL_LEQUAL); +} + + +void drawsolidcube(float size) +{ + float n[3]; + + glPushMatrix(); + glScalef(size, size, size); + + n[0]=0; n[1]=0; n[2]=0; + glBegin(GL_QUADS); + n[0]= -1.0; + glNormal3fv(n); + glVertex3fv(cube[0]); glVertex3fv(cube[1]); glVertex3fv(cube[2]); glVertex3fv(cube[3]); + n[0]=0; + glEnd(); + + glBegin(GL_QUADS); + n[1]= -1.0; + glNormal3fv(n); + glVertex3fv(cube[0]); glVertex3fv(cube[4]); glVertex3fv(cube[5]); glVertex3fv(cube[1]); + n[1]=0; + glEnd(); + + glBegin(GL_QUADS); + n[0]= 1.0; + glNormal3fv(n); + glVertex3fv(cube[4]); glVertex3fv(cube[7]); glVertex3fv(cube[6]); glVertex3fv(cube[5]); + n[0]=0; + glEnd(); + + glBegin(GL_QUADS); + n[1]= 1.0; + glNormal3fv(n); + glVertex3fv(cube[7]); glVertex3fv(cube[3]); glVertex3fv(cube[2]); glVertex3fv(cube[6]); + n[1]=0; + glEnd(); + + glBegin(GL_QUADS); + n[2]= 1.0; + glNormal3fv(n); + glVertex3fv(cube[1]); glVertex3fv(cube[5]); glVertex3fv(cube[6]); glVertex3fv(cube[2]); + n[2]=0; + glEnd(); + + glBegin(GL_QUADS); + n[2]= -1.0; + glNormal3fv(n); + glVertex3fv(cube[7]); glVertex3fv(cube[4]); glVertex3fv(cube[0]); glVertex3fv(cube[3]); + glEnd(); + + glPopMatrix(); +} + +static void drawcube(void) +{ + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[0]); glVertex3fv(cube[1]);glVertex3fv(cube[2]); glVertex3fv(cube[3]); + glVertex3fv(cube[0]); glVertex3fv(cube[4]);glVertex3fv(cube[5]); glVertex3fv(cube[6]); + glVertex3fv(cube[7]); glVertex3fv(cube[4]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[1]); glVertex3fv(cube[5]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[2]); glVertex3fv(cube[6]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[3]); glVertex3fv(cube[7]); + glEnd(); +} + +/* draws a cube on given the scaling of the cube, assuming that + * all required matrices have been set (used for drawing empties) + */ +static void drawcube_size(float size) +{ + glBegin(GL_LINE_STRIP); + glVertex3f(-size,-size,-size); glVertex3f(-size,-size,size);glVertex3f(-size,size,size); glVertex3f(-size,size,-size); + glVertex3f(-size,-size,-size); glVertex3f(size,-size,-size);glVertex3f(size,-size,size); glVertex3f(size,size,size); + glVertex3f(size,size,-size); glVertex3f(size,-size,-size); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3f(-size,-size,size); glVertex3f(size,-size,size); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3f(-size,size,size); glVertex3f(size,size,size); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3f(-size,size,-size); glVertex3f(size,size,-size); + glEnd(); +} + +/* this is an unused (old) cube-drawing function based on a given size */ +#if 0 +static void drawcube_size(float *size) +{ + + glPushMatrix(); + glScalef(size[0], size[1], size[2]); + + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[0]); glVertex3fv(cube[1]);glVertex3fv(cube[2]); glVertex3fv(cube[3]); + glVertex3fv(cube[0]); glVertex3fv(cube[4]);glVertex3fv(cube[5]); glVertex3fv(cube[6]); + glVertex3fv(cube[7]); glVertex3fv(cube[4]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[1]); glVertex3fv(cube[5]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[2]); glVertex3fv(cube[6]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glVertex3fv(cube[3]); glVertex3fv(cube[7]); + glEnd(); + + glPopMatrix(); +} +#endif + +static void drawshadbuflimits(Lamp *la, float mat[][4]) +{ + float sta[3], end[3], lavec[3]; + + lavec[0]= -mat[2][0]; + lavec[1]= -mat[2][1]; + lavec[2]= -mat[2][2]; + Normalize(lavec); + + sta[0]= mat[3][0]+ la->clipsta*lavec[0]; + sta[1]= mat[3][1]+ la->clipsta*lavec[1]; + sta[2]= mat[3][2]+ la->clipsta*lavec[2]; + + end[0]= mat[3][0]+ la->clipend*lavec[0]; + end[1]= mat[3][1]+ la->clipend*lavec[1]; + end[2]= mat[3][2]+ la->clipend*lavec[2]; + + + glBegin(GL_LINE_STRIP); + glVertex3fv(sta); + glVertex3fv(end); + glEnd(); + + glPointSize(3.0); + bglBegin(GL_POINTS); + bglVertex3fv(sta); + bglVertex3fv(end); + bglEnd(); + glPointSize(1.0); +} + + + +static void spotvolume(float *lvec, float *vvec, float inp) +{ + /* camera is at 0,0,0 */ + float temp[3],plane[3],mat1[3][3],mat2[3][3],mat3[3][3],mat4[3][3],q[4],co,si,angle; + + Normalize(lvec); + Normalize(vvec); /* is this the correct vector ? */ + + Crossf(temp,vvec,lvec); /* equation for a plane through vvec en lvec */ + Crossf(plane,lvec,temp); /* a plane perpendicular to this, parrallel with lvec */ + + Normalize(plane); + + /* now we've got two equations: one of a cone and one of a plane, but we have + three unknowns. We remove one unkown by rotating the plane to z=0 (the plane normal) */ + + /* rotate around cross product vector of (0,0,1) and plane normal, dot product degrees */ + /* according definition, we derive cross product is (plane[1],-plane[0],0), en cos = plane[2]);*/ + + /* translating this comment to english didnt really help me understanding the math! :-) (ton) */ + + q[1] = plane[1] ; + q[2] = -plane[0] ; + q[3] = 0 ; + Normalize(&q[1]); + + angle = saacos(plane[2])/2.0; + co = cos(angle); + si = sqrt(1-co*co); + + q[0] = co; + q[1] *= si; + q[2] *= si; + q[3] = 0; + + QuatToMat3(q,mat1); + + /* rotate lamp vector now over acos(inp) degrees */ + + vvec[0] = lvec[0] ; + vvec[1] = lvec[1] ; + vvec[2] = lvec[2] ; + + Mat3One(mat2); + co = inp; + si = sqrt(1-inp*inp); + + mat2[0][0] = co; + mat2[1][0] = -si; + mat2[0][1] = si; + mat2[1][1] = co; + Mat3MulMat3(mat3,mat2,mat1); + + mat2[1][0] = si; + mat2[0][1] = -si; + Mat3MulMat3(mat4,mat2,mat1); + Mat3Transp(mat1); + + Mat3MulMat3(mat2,mat1,mat3); + Mat3MulVecfl(mat2,lvec); + Mat3MulMat3(mat2,mat1,mat4); + Mat3MulVecfl(mat2,vvec); + + return; +} + +static void drawlamp(const bContext *C, Scene *scene, View3D *v3d, Object *ob) +{ + Lamp *la; + float vec[3], lvec[3], vvec[3], circrad, x,y,z; + float pixsize, lampsize; + float imat[4][4], curcol[4]; + char col[4]; + + if(G.f & G_RENDER_SHADOW) + return; + + la= ob->data; + + /* we first draw only the screen aligned & fixed scale stuff */ + glPushMatrix(); + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + + /* lets calculate the scale: */ + pixsize= v3d->persmat[0][3]*ob->obmat[3][0]+ v3d->persmat[1][3]*ob->obmat[3][1]+ v3d->persmat[2][3]*ob->obmat[3][2]+ v3d->persmat[3][3]; + pixsize*= v3d->pixsize; + lampsize= pixsize*((float)U.obcenter_dia*0.5f); + + /* and view aligned matrix: */ + Mat4CpyMat4(imat, v3d->viewinv); + Normalize(imat[0]); + Normalize(imat[1]); + + /* for AA effects */ + glGetFloatv(GL_CURRENT_COLOR, curcol); + curcol[3]= 0.6; + glColor4fv(curcol); + + if(ob->id.us>1) { + if (ob==OBACT || (ob->flag & SELECT)) glColor4ub(0x88, 0xFF, 0xFF, 155); + else glColor4ub(0x77, 0xCC, 0xCC, 155); + } + + /* Inner Circle */ + VECCOPY(vec, ob->obmat[3]); + glEnable(GL_BLEND); + drawcircball(GL_LINE_LOOP, vec, lampsize, imat); + glDisable(GL_BLEND); + drawcircball(GL_POLYGON, vec, lampsize, imat); + + /* restore */ + if(ob->id.us>1) + glColor4fv(curcol); + + /* Outer circle */ + circrad = 3.0f*lampsize; + drawcircball(GL_LINE_LOOP, vec, circrad, imat); + + setlinestyle(3); + + /* draw dashed outer circle if shadow is on. remember some lamps can't have certain shadows! */ + if (la->type!=LA_HEMI) { + if ((la->mode & LA_SHAD_RAY) || + ((la->mode & LA_SHAD_BUF) && (la->type==LA_SPOT)) ) + { + drawcircball(GL_LINE_LOOP, vec, circrad + 3.0f*pixsize, imat); + } + } + + /* draw the pretty sun rays */ + if(la->type==LA_SUN) { + float v1[3], v2[3], mat[3][3]; + short axis; + + /* setup a 45 degree rotation matrix */ + VecRotToMat3(imat[2], M_PI/4.0f, mat); + + /* vectors */ + VECCOPY(v1, imat[0]); + VecMulf(v1, circrad*1.2f); + VECCOPY(v2, imat[0]); + VecMulf(v2, circrad*2.5f); + + /* center */ + glTranslatef(vec[0], vec[1], vec[2]); + + setlinestyle(3); + + glBegin(GL_LINES); + for (axis=0; axis<8; axis++) { + glVertex3fv(v1); + glVertex3fv(v2); + Mat3MulVecfl(mat, v1); + Mat3MulVecfl(mat, v2); + } + glEnd(); + + glTranslatef(-vec[0], -vec[1], -vec[2]); + + } + + if (la->type==LA_LOCAL) { + if(la->mode & LA_SPHERE) { + drawcircball(GL_LINE_LOOP, vec, la->dist, imat); + } + /* yafray: for photonlight also draw lightcone as for spot */ + } + + glPopMatrix(); /* back in object space */ + vec[0]= vec[1]= vec[2]= 0.0f; + + if ((la->type==LA_SPOT) || (la->type==LA_YF_PHOTON)) { + lvec[0]=lvec[1]= 0.0; + lvec[2] = 1.0; + x = v3d->persmat[0][2]; + y = v3d->persmat[1][2]; + z = v3d->persmat[2][2]; + vvec[0]= x*ob->obmat[0][0] + y*ob->obmat[0][1] + z*ob->obmat[0][2]; + vvec[1]= x*ob->obmat[1][0] + y*ob->obmat[1][1] + z*ob->obmat[1][2]; + vvec[2]= x*ob->obmat[2][0] + y*ob->obmat[2][1] + z*ob->obmat[2][2]; + + y = cos( M_PI*la->spotsize/360.0 ); + spotvolume(lvec, vvec, y); + x = -la->dist; + lvec[0] *= x ; + lvec[1] *= x ; + lvec[2] *= x; + vvec[0] *= x ; + vvec[1] *= x ; + vvec[2] *= x; + + /* draw the angled sides of the cone */ + glBegin(GL_LINE_STRIP); + glVertex3fv(vvec); + glVertex3fv(vec); + glVertex3fv(lvec); + glEnd(); + + z = x*sqrt(1.0 - y*y); + x *= y; + + /* draw the circle/square at the end of the cone */ + glTranslatef(0.0, 0.0 , x); + if(la->mode & LA_SQUARE) { + vvec[0]= fabs(z); + vvec[1]= fabs(z); + vvec[2]= 0.0; + glBegin(GL_LINE_LOOP); + glVertex3fv(vvec); + vvec[1]= -fabs(z); + glVertex3fv(vvec); + vvec[0]= -fabs(z); + glVertex3fv(vvec); + vvec[1]= fabs(z); + glVertex3fv(vvec); + glEnd(); + } + else circ(0.0, 0.0, fabs(z)); + + /* draw the circle/square representing spotbl */ + if(la->type==LA_SPOT) { + float spotblcirc = fabs(z)*(1 - pow(la->spotblend, 2)); + /* make sure the line is always visible - prevent it from reaching the outer border (or 0) + * values are kinda arbitrary - just what seemed to work well */ + if (spotblcirc == 0) spotblcirc = 0.15; + else if (spotblcirc == fabs(z)) spotblcirc = fabs(z) - 0.07; + circ(0.0, 0.0, spotblcirc); + } + + } + else if ELEM(la->type, LA_HEMI, LA_SUN) { + + /* draw the line from the circle along the dist */ + glBegin(GL_LINE_STRIP); + vec[2] = -circrad; + glVertex3fv(vec); + vec[2]= -la->dist; + glVertex3fv(vec); + glEnd(); + + if(la->type==LA_HEMI) { + /* draw the hemisphere curves */ + short axis, steps, dir; + float outdist, zdist, mul; + vec[0]=vec[1]=vec[2]= 0.0; + outdist = 0.14; mul = 1.4; dir = 1; + + setlinestyle(4); + /* loop over the 4 compass points, and draw each arc as a LINE_STRIP */ + for (axis=0; axis<4; axis++) { + float v[3]= {0.0, 0.0, 0.0}; + zdist = 0.02; + + glBegin(GL_LINE_STRIP); + + for (steps=0; steps<6; steps++) { + if (axis == 0 || axis == 1) { /* x axis up, x axis down */ + /* make the arcs start at the edge of the energy circle */ + if (steps == 0) v[0] = dir*circrad; + else v[0] = v[0] + dir*(steps*outdist); + } else if (axis == 2 || axis == 3) { /* y axis up, y axis down */ + /* make the arcs start at the edge of the energy circle */ + if (steps == 0) v[1] = dir*circrad; + else v[1] = v[1] + dir*(steps*outdist); + } + + v[2] = v[2] - steps*zdist; + + glVertex3fv(v); + + zdist = zdist * mul; + } + + glEnd(); + /* flip the direction */ + dir = -dir; + } + } + } else if(la->type==LA_AREA) { + setlinestyle(3); + if(la->area_shape==LA_AREA_SQUARE) + fdrawbox(-la->area_size*0.5, -la->area_size*0.5, la->area_size*0.5, la->area_size*0.5); + else if(la->area_shape==LA_AREA_RECT) + fdrawbox(-la->area_size*0.5, -la->area_sizey*0.5, la->area_size*0.5, la->area_sizey*0.5); + + glBegin(GL_LINE_STRIP); + glVertex3f(0.0,0.0,-circrad); + glVertex3f(0.0,0.0,-la->dist); + glEnd(); + } + + /* and back to viewspace */ + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + VECCOPY(vec, ob->obmat[3]); + + setlinestyle(0); + + if(la->type==LA_SPOT && (la->mode & LA_SHAD_BUF) ) { + drawshadbuflimits(la, ob->obmat); + } + + UI_GetThemeColor4ubv(TH_LAMP, col); + glColor4ub(col[0], col[1], col[2], col[3]); + + glEnable(GL_BLEND); + + if (vec[2]>0) vec[2] -= circrad; + else vec[2] += circrad; + + glBegin(GL_LINE_STRIP); + glVertex3fv(vec); + vec[2]= 0; + glVertex3fv(vec); + glEnd(); + + glPointSize(2.0); + glBegin(GL_POINTS); + glVertex3fv(vec); + glEnd(); + glPointSize(1.0); + + glDisable(GL_BLEND); + + /* restore for drawing extra stuff */ + glColor3fv(curcol); + +} + +static void draw_limit_line(float sta, float end, unsigned int col) +{ + glBegin(GL_LINES); + glVertex3f(0.0, 0.0, -sta); + glVertex3f(0.0, 0.0, -end); + glEnd(); + + glPointSize(3.0); + glBegin(GL_POINTS); + cpack(col); + glVertex3f(0.0, 0.0, -sta); + glVertex3f(0.0, 0.0, -end); + glEnd(); + glPointSize(1.0); +} + + +/* yafray: draw camera focus point (cross, similar to aqsis code in tuhopuu) */ +/* qdn: now also enabled for Blender to set focus point for defocus composit node */ +static void draw_focus_cross(float dist, float size) +{ + glBegin(GL_LINES); + glVertex3f(-size, 0.f, -dist); + glVertex3f(size, 0.f, -dist); + glVertex3f(0.f, -size, -dist); + glVertex3f(0.f, size, -dist); + glEnd(); +} + +/* flag similar to draw_object() */ +static void drawcamera(const bContext *C, Scene *scene, View3D *v3d, Object *ob, int flag) +{ + /* a standing up pyramid with (0,0,0) as top */ + Camera *cam; + World *wrld; + float vec[8][4], tmat[4][4], fac, facx, facy, depth; + int i; + + if(G.f & G_RENDER_SHADOW) + return; + + cam= ob->data; + + glDisable(GL_LIGHTING); + glDisable(GL_CULL_FACE); + + if(v3d->persp>=2 && cam->type==CAM_ORTHO && ob==v3d->camera) { + facx= 0.5*cam->ortho_scale*1.28; + facy= 0.5*cam->ortho_scale*1.024; + depth= -cam->clipsta-0.1; + } + else { + fac= cam->drawsize; + if(v3d->persp>=2 && ob==v3d->camera) fac= cam->clipsta+0.1; /* that way it's always visible */ + + depth= - fac*cam->lens/16.0; + facx= fac*1.28; + facy= fac*1.024; + } + + vec[0][0]= 0.0; vec[0][1]= 0.0; vec[0][2]= 0.001; /* GLBUG: for picking at iris Entry (well thats old!) */ + vec[1][0]= facx; vec[1][1]= facy; vec[1][2]= depth; + vec[2][0]= facx; vec[2][1]= -facy; vec[2][2]= depth; + vec[3][0]= -facx; vec[3][1]= -facy; vec[3][2]= depth; + vec[4][0]= -facx; vec[4][1]= facy; vec[4][2]= depth; + + glBegin(GL_LINE_LOOP); + glVertex3fv(vec[1]); + glVertex3fv(vec[2]); + glVertex3fv(vec[3]); + glVertex3fv(vec[4]); + glEnd(); + + + if(v3d->persp>=2 && ob==v3d->camera) return; + + glBegin(GL_LINE_STRIP); + glVertex3fv(vec[2]); + glVertex3fv(vec[0]); + glVertex3fv(vec[1]); + glVertex3fv(vec[4]); + glVertex3fv(vec[0]); + glVertex3fv(vec[3]); + glEnd(); + + + /* arrow on top */ + vec[0][2]= depth; + + + /* draw an outline arrow for inactive cameras and filled + * for active cameras. We actually draw both outline+filled + * for active cameras so the wire can be seen side-on */ + for (i=0;i<2;i++) { + if (i==0) glBegin(GL_LINE_LOOP); + else if (i==1 && (ob == v3d->camera)) glBegin(GL_TRIANGLES); + else break; + + vec[0][0]= -0.7*cam->drawsize; + vec[0][1]= 1.1*cam->drawsize; + glVertex3fv(vec[0]); + + vec[0][0]= 0.0; + vec[0][1]= 1.8*cam->drawsize; + glVertex3fv(vec[0]); + + vec[0][0]= 0.7*cam->drawsize; + vec[0][1]= 1.1*cam->drawsize; + glVertex3fv(vec[0]); + + glEnd(); + } + + if(flag==0) { + if(cam->flag & (CAM_SHOWLIMITS+CAM_SHOWMIST)) { + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + Mat4CpyMat4(vec, ob->obmat); + Mat4Ortho(vec); + wmMultMatrix(CTX_wm_window(C), vec); + + MTC_Mat4SwapMat4(v3d->persmat, tmat); + wmGetSingleMatrix(CTX_wm_window(C), v3d->persmat); + + if(cam->flag & CAM_SHOWLIMITS) { + draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF); + /* qdn: was yafray only, now also enabled for Blender to be used with defocus composit node */ + draw_focus_cross(dof_camera(ob), cam->drawsize); + } + + wrld= scene->world; + if(cam->flag & CAM_SHOWMIST) + if(wrld) draw_limit_line(wrld->miststa, wrld->miststa+wrld->mistdist, 0xFFFFFF); + + MTC_Mat4SwapMat4(v3d->persmat, tmat); + } + } +} + +static void lattice_draw_verts(Lattice *lt, DispList *dl, short sel) +{ + BPoint *bp = lt->def; + float *co = dl?dl->verts:NULL; + int u, v, w; + + UI_ThemeColor(sel?TH_VERTEX_SELECT:TH_VERTEX); + glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE)); + bglBegin(GL_POINTS); + + for(w=0; w<lt->pntsw; w++) { + int wxt = (w==0 || w==lt->pntsw-1); + for(v=0; v<lt->pntsv; v++) { + int vxt = (v==0 || v==lt->pntsv-1); + for(u=0; u<lt->pntsu; u++, bp++, co+=3) { + int uxt = (u==0 || u==lt->pntsu-1); + if(!(lt->flag & LT_OUTSIDE) || uxt || vxt || wxt) { + if(bp->hide==0) { + if((bp->f1 & SELECT)==sel) { + bglVertex3fv(dl?co:bp->vec); + } + } + } + } + } + } + + glPointSize(1.0); + bglEnd(); +} + +void lattice_foreachScreenVert(void (*func)(void *userData, BPoint *bp, int x, int y), void *userData) +{ + ARegion *ar= NULL; // XXX + View3D *v3d= NULL; // XXX + BPoint *bp = editLatt->def; + DispList *dl = find_displist(&G.obedit->disp, DL_VERTS); + float *co = dl?dl->verts:NULL; + float pmat[4][4], vmat[4][4]; + int i, N = editLatt->pntsu*editLatt->pntsv*editLatt->pntsw; + short s[2]; + + view3d_get_object_project_mat(v3d, G.obedit, pmat, vmat); + + for (i=0; i<N; i++, bp++, co+=3) { + if (bp->hide==0) { + view3d_project_short_clip(ar, v3d, dl?co:bp->vec, s, pmat, vmat); + func(userData, bp, s[0], s[1]); + } + } +} + +static void drawlattice__point(Lattice *lt, DispList *dl, int u, int v, int w, int use_wcol) +{ + int index = ((w*lt->pntsv + v)*lt->pntsu) + u; + + if(use_wcol) { +#if 0 + XXX + float col[3]; + MDeformWeight *mdw= get_defweight (lt->dvert+index, use_wcol-1); + + weight_to_rgb(mdw?mdw->weight:0.0f, col, col+1, col+2); + glColor3fv(col); +#endif + } + + if (dl) { + glVertex3fv(&dl->verts[index*3]); + } else { + glVertex3fv(lt->def[index].vec); + } +} + +/* lattice color is hardcoded, now also shows weightgroup values in edit mode */ +static void drawlattice(View3D *v3d, Object *ob) +{ + Lattice *lt; + DispList *dl; + int u, v, w; + int use_wcol= 0; + + lt= (ob==G.obedit)?editLatt:ob->data; + + /* now we default make displist, this will modifiers work for non animated case */ + if(ob->disp.first==NULL) + lattice_calc_modifiers(ob); + dl= find_displist(&ob->disp, DL_VERTS); + + if(ob==G.obedit) { + cpack(0x004000); + + if(ob->defbase.first && lt->dvert) { + use_wcol= ob->actdef; + glShadeModel(GL_SMOOTH); + } + } + + glBegin(GL_LINES); + for(w=0; w<lt->pntsw; w++) { + int wxt = (w==0 || w==lt->pntsw-1); + for(v=0; v<lt->pntsv; v++) { + int vxt = (v==0 || v==lt->pntsv-1); + for(u=0; u<lt->pntsu; u++) { + int uxt = (u==0 || u==lt->pntsu-1); + + if(w && ((uxt || vxt) || !(lt->flag & LT_OUTSIDE))) { + drawlattice__point(lt, dl, u, v, w-1, use_wcol); + drawlattice__point(lt, dl, u, v, w, use_wcol); + } + if(v && ((uxt || wxt) || !(lt->flag & LT_OUTSIDE))) { + drawlattice__point(lt, dl, u, v-1, w, use_wcol); + drawlattice__point(lt, dl, u, v, w, use_wcol); + } + if(u && ((vxt || wxt) || !(lt->flag & LT_OUTSIDE))) { + drawlattice__point(lt, dl, u-1, v, w, use_wcol); + drawlattice__point(lt, dl, u, v, w, use_wcol); + } + } + } + } + glEnd(); + + /* restoration for weight colors */ + if(use_wcol) + glShadeModel(GL_FLAT); + + if(ob==G.obedit) { + if(v3d->zbuf) glDisable(GL_DEPTH_TEST); + + lattice_draw_verts(lt, dl, 0); + lattice_draw_verts(lt, dl, 1); + + if(v3d->zbuf) glEnable(GL_DEPTH_TEST); + } +} + +/* ***************** ******************** */ + +static void mesh_foreachScreenVert__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s) +{ + struct { void (*func)(void *userData, EditVert *eve, int x, int y, int index); void *userData; int clipVerts; float pmat[4][4], vmat[4][4]; } *data = userData; + ARegion *ar= NULL; // XXX + View3D *v3d= NULL; // XXX + EditVert *eve = EM_get_vert_for_index(index); + short s[2]; + + if (eve->h==0) { + if (data->clipVerts) { + view3d_project_short_clip(ar, v3d, co, s, data->pmat, data->vmat); + } else { + view3d_project_short_noclip(ar, co, s, data->pmat); + } + + data->func(data->userData, eve, s[0], s[1], index); + } +} +void mesh_foreachScreenVert(void (*func)(void *userData, EditVert *eve, int x, int y, int index), void *userData, int clipVerts) +{ + struct { void (*func)(void *userData, EditVert *eve, int x, int y, int index); void *userData; int clipVerts; float pmat[4][4], vmat[4][4]; } data; + View3D *v3d= NULL; // XXX + DerivedMesh *dm = editmesh_get_derived_cage(CD_MASK_BAREMESH); + + data.func = func; + data.userData = userData; + data.clipVerts = clipVerts; + + view3d_get_object_project_mat(v3d, G.obedit, data.pmat, data.vmat); + + EM_init_index_arrays(1, 0, 0); + dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data); + EM_free_index_arrays(); + + dm->release(dm); +} + +static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, float *v0co, float *v1co) +{ + struct { void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index); void *userData; int clipVerts; float pmat[4][4], vmat[4][4]; } *data = userData; + ARegion *ar= NULL; // XXX + View3D *v3d= NULL; // XXX + EditEdge *eed = EM_get_edge_for_index(index); + short s[2][2]; + + if (eed->h==0) { + if (data->clipVerts==1) { + view3d_project_short_clip(ar, v3d, v0co, s[0], data->pmat, data->vmat); + view3d_project_short_clip(ar, v3d, v1co, s[1], data->pmat, data->vmat); + } else { + view3d_project_short_noclip(ar, v0co, s[0], data->pmat); + view3d_project_short_noclip(ar, v1co, s[1], data->pmat); + + if (data->clipVerts==2) { + if (!(s[0][0]>=0 && s[0][1]>= 0 && s[0][0]<ar->winx && s[0][1]<ar->winy)) + if (!(s[1][0]>=0 && s[1][1]>= 0 && s[1][0]<ar->winx && s[1][1]<ar->winy)) + return; + } + } + + data->func(data->userData, eed, s[0][0], s[0][1], s[1][0], s[1][1], index); + } +} +void mesh_foreachScreenEdge(void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index), void *userData, int clipVerts) +{ + struct { void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index); void *userData; int clipVerts; float pmat[4][4], vmat[4][4]; } data; + View3D *v3d= NULL; // XXX + DerivedMesh *dm = editmesh_get_derived_cage(CD_MASK_BAREMESH); + + data.func = func; + data.userData = userData; + data.clipVerts = clipVerts; + + view3d_get_object_project_mat(v3d, G.obedit, data.pmat, data.vmat); + + EM_init_index_arrays(0, 1, 0); + dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data); + EM_free_index_arrays(); + + dm->release(dm); +} + +static void mesh_foreachScreenFace__mapFunc(void *userData, int index, float *cent, float *no) +{ + struct { void (*func)(void *userData, EditFace *efa, int x, int y, int index); void *userData; float pmat[4][4], vmat[4][4]; } *data = userData; + ARegion *ar= NULL; // XXX + View3D *v3d= NULL; // XXX + EditFace *efa = EM_get_face_for_index(index); + short s[2]; + + if (efa && efa->h==0 && efa->fgonf!=EM_FGON) { + view3d_project_short_clip(ar, v3d, cent, s, data->pmat, data->vmat); + + data->func(data->userData, efa, s[0], s[1], index); + } +} +void mesh_foreachScreenFace(void (*func)(void *userData, EditFace *efa, int x, int y, int index), void *userData) +{ + struct { void (*func)(void *userData, EditFace *efa, int x, int y, int index); void *userData; float pmat[4][4], vmat[4][4]; } data; + DerivedMesh *dm = editmesh_get_derived_cage(CD_MASK_BAREMESH); + View3D *v3d= NULL; // XXX + + data.func = func; + data.userData = userData; + + view3d_get_object_project_mat(v3d, G.obedit, data.pmat, data.vmat); + + EM_init_index_arrays(0, 0, 1); + dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data); + EM_free_index_arrays(); + + dm->release(dm); +} + +void nurbs_foreachScreenVert(void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y), void *userData) +{ + ARegion *ar= NULL; // XXX + View3D *v3d= NULL; // XXX + float pmat[4][4], vmat[4][4]; + short s[2]; + Nurb *nu; + int i; + + view3d_get_object_project_mat(v3d, G.obedit, pmat, vmat); + + for (nu= editNurb.first; nu; nu=nu->next) { + if((nu->type & 7)==CU_BEZIER) { + for (i=0; i<nu->pntsu; i++) { + BezTriple *bezt = &nu->bezt[i]; + + if(bezt->hide==0) { + if (G.f & G_HIDDENHANDLES) { + view3d_project_short_clip(ar, v3d, bezt->vec[1], s, pmat, vmat); + if (s[0] != IS_CLIPPED) + func(userData, nu, NULL, bezt, 1, s[0], s[1]); + } else { + view3d_project_short_clip(ar, v3d, bezt->vec[0], s, pmat, vmat); + if (s[0] != IS_CLIPPED) + func(userData, nu, NULL, bezt, 0, s[0], s[1]); + view3d_project_short_clip(ar, v3d, bezt->vec[1], s, pmat, vmat); + if (s[0] != IS_CLIPPED) + func(userData, nu, NULL, bezt, 1, s[0], s[1]); + view3d_project_short_clip(ar, v3d, bezt->vec[2], s, pmat, vmat); + if (s[0] != IS_CLIPPED) + func(userData, nu, NULL, bezt, 2, s[0], s[1]); + } + } + } + } + else { + for (i=0; i<nu->pntsu*nu->pntsv; i++) { + BPoint *bp = &nu->bp[i]; + + if(bp->hide==0) { + view3d_project_short_clip(ar, v3d, bp->vec, s, pmat, vmat); + func(userData, nu, bp, NULL, -1, s[0], s[1]); + } + } + } + } +} + +/* ************** DRAW MESH ****************** */ + +/* First section is all the "simple" draw routines, + * ones that just pass some sort of primitive to GL, + * with perhaps various options to control lighting, + * color, etc. + * + * These routines should not have user interface related + * logic!!! + */ + +static void draw_dm_face_normals__mapFunc(void *userData, int index, float *cent, float *no) +{ + Scene *scene= NULL; // XXX + EditFace *efa = EM_get_face_for_index(index); + + if (efa->h==0 && efa->fgonf!=EM_FGON) { + glVertex3fv(cent); + glVertex3f( cent[0] + no[0]*scene->editbutsize, + cent[1] + no[1]*scene->editbutsize, + cent[2] + no[2]*scene->editbutsize); + } +} +static void draw_dm_face_normals(DerivedMesh *dm) { + glBegin(GL_LINES); + dm->foreachMappedFaceCenter(dm, draw_dm_face_normals__mapFunc, 0); + glEnd(); +} + +static void draw_dm_face_centers__mapFunc(void *userData, int index, float *cent, float *no) +{ + EditFace *efa = EM_get_face_for_index(index); + int sel = *((int*) userData); + + if (efa->h==0 && efa->fgonf!=EM_FGON && (efa->f&SELECT)==sel) { + bglVertex3fv(cent); + } +} +static void draw_dm_face_centers(DerivedMesh *dm, int sel) +{ + bglBegin(GL_POINTS); + dm->foreachMappedFaceCenter(dm, draw_dm_face_centers__mapFunc, &sel); + bglEnd(); +} + +static void draw_dm_vert_normals__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s) +{ + Scene *scene= NULL; // XXX + EditVert *eve = EM_get_vert_for_index(index); + + if (eve->h==0) { + glVertex3fv(co); + + if (no_f) { + glVertex3f( co[0] + no_f[0]*scene->editbutsize, + co[1] + no_f[1]*scene->editbutsize, + co[2] + no_f[2]*scene->editbutsize); + } else { + glVertex3f( co[0] + no_s[0]*scene->editbutsize/32767.0f, + co[1] + no_s[1]*scene->editbutsize/32767.0f, + co[2] + no_s[2]*scene->editbutsize/32767.0f); + } + } +} +static void draw_dm_vert_normals(DerivedMesh *dm) { + glBegin(GL_LINES); + dm->foreachMappedVert(dm, draw_dm_vert_normals__mapFunc, NULL); + glEnd(); +} + + /* Draw verts with color set based on selection */ +static void draw_dm_verts__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s) +{ + struct { int sel; EditVert *eve_act; } * data = userData; + EditVert *eve = EM_get_vert_for_index(index); + + if (eve->h==0 && (eve->f&SELECT)==data->sel) { + /* draw active larger - need to stop/start point drawing for this :/ */ + if (eve==data->eve_act) { + float size = UI_GetThemeValuef(TH_VERTEX_SIZE); + UI_ThemeColor4(TH_EDITMESH_ACTIVE); + + bglEnd(); + + glPointSize(size); + bglBegin(GL_POINTS); + bglVertex3fv(co); + bglEnd(); + + UI_ThemeColor4(data->sel?TH_VERTEX_SELECT:TH_VERTEX); + glPointSize(size); + bglBegin(GL_POINTS); + } else { + bglVertex3fv(co); + } + } +} +static void draw_dm_verts(DerivedMesh *dm, int sel, EditVert *eve_act) +{ + struct { int sel; EditVert *eve_act; } data; + data.sel = sel; + data.eve_act = eve_act; + + bglBegin(GL_POINTS); + dm->foreachMappedVert(dm, draw_dm_verts__mapFunc, &data); + bglEnd(); +} + + /* Draw edges with color set based on selection */ +static int draw_dm_edges_sel__setDrawOptions(void *userData, int index) +{ + EditEdge *eed = EM_get_edge_for_index(index); + //unsigned char **cols = userData, *col; + struct { unsigned char *baseCol, *selCol, *actCol; EditEdge *eed_act; } * data = userData; + unsigned char *col; + + if (eed->h==0) { + if (eed==data->eed_act) { + glColor4ubv(data->actCol); + } else { + if (eed->f&SELECT) { + col = data->selCol; + } else { + col = data->baseCol; + } + /* no alpha, this is used so a transparent color can disable drawing unselected edges in editmode */ + if (col[3]==0) return 0; + + glColor4ubv(col); + } + return 1; + } else { + return 0; + } +} +static void draw_dm_edges_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditEdge *eed_act) +{ + struct { unsigned char *baseCol, *selCol, *actCol; EditEdge *eed_act; } data; + + data.baseCol = baseCol; + data.selCol = selCol; + data.actCol = actCol; + data.eed_act = eed_act; + dm->drawMappedEdges(dm, draw_dm_edges_sel__setDrawOptions, &data); +} + + /* Draw edges */ +static int draw_dm_edges__setDrawOptions(void *userData, int index) +{ + return EM_get_edge_for_index(index)->h==0; +} +static void draw_dm_edges(DerivedMesh *dm) +{ + dm->drawMappedEdges(dm, draw_dm_edges__setDrawOptions, NULL); +} + + /* Draw edges with color interpolated based on selection */ +static int draw_dm_edges_sel_interp__setDrawOptions(void *userData, int index) +{ + return EM_get_edge_for_index(index)->h==0; +} +static void draw_dm_edges_sel_interp__setDrawInterpOptions(void *userData, int index, float t) +{ + EditEdge *eed = EM_get_edge_for_index(index); + unsigned char **cols = userData; + unsigned char *col0 = cols[(eed->v1->f&SELECT)?1:0]; + unsigned char *col1 = cols[(eed->v2->f&SELECT)?1:0]; + + glColor4ub( col0[0] + (col1[0]-col0[0])*t, + col0[1] + (col1[1]-col0[1])*t, + col0[2] + (col1[2]-col0[2])*t, + col0[3] + (col1[3]-col0[3])*t); +} +static void draw_dm_edges_sel_interp(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol) +{ + unsigned char *cols[2]; + cols[0] = baseCol; + cols[1] = selCol; + dm->drawMappedEdgesInterp(dm, draw_dm_edges_sel_interp__setDrawOptions, draw_dm_edges_sel_interp__setDrawInterpOptions, cols); +} + + /* Draw only seam edges */ +static int draw_dm_edges_seams__setDrawOptions(void *userData, int index) +{ + EditEdge *eed = EM_get_edge_for_index(index); + + return (eed->h==0 && eed->seam); +} +static void draw_dm_edges_seams(DerivedMesh *dm) +{ + dm->drawMappedEdges(dm, draw_dm_edges_seams__setDrawOptions, NULL); +} + + /* Draw only sharp edges */ +static int draw_dm_edges_sharp__setDrawOptions(void *userData, int index) +{ + EditEdge *eed = EM_get_edge_for_index(index); + + return (eed->h==0 && eed->sharp); +} +static void draw_dm_edges_sharp(DerivedMesh *dm) +{ + dm->drawMappedEdges(dm, draw_dm_edges_sharp__setDrawOptions, NULL); +} + + + /* Draw faces with color set based on selection + * return 2 for the active face so it renders with stipple enabled */ +static int draw_dm_faces_sel__setDrawOptions(void *userData, int index, int *drawSmooth_r) +{ + struct { unsigned char *cols[3]; EditFace *efa_act; } * data = userData; + EditFace *efa = EM_get_face_for_index(index); + unsigned char *col; + + if (efa->h==0) { + if (efa == data->efa_act) { + glColor4ubv(data->cols[2]); + return 2; /* stipple */ + } else { + col = data->cols[(efa->f&SELECT)?1:0]; + if (col[3]==0) return 0; + glColor4ubv(col); + return 1; + } + } + return 0; +} + +/* also draws the active face */ +static void draw_dm_faces_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditFace *efa_act) +{ + struct { unsigned char *cols[3]; EditFace *efa_act; } data; + data.cols[0] = baseCol; + data.cols[1] = selCol; + data.cols[2] = actCol; + data.efa_act = efa_act; + + dm->drawMappedFaces(dm, draw_dm_faces_sel__setDrawOptions, &data, 0); +} + +static int draw_dm_creases__setDrawOptions(void *userData, int index) +{ + EditEdge *eed = EM_get_edge_for_index(index); + + if (eed->h==0 && eed->crease!=0.0) { + UI_ThemeColorBlend(TH_WIRE, TH_EDGE_SELECT, eed->crease); + return 1; + } else { + return 0; + } +} +static void draw_dm_creases(DerivedMesh *dm) +{ + glLineWidth(3.0); + dm->drawMappedEdges(dm, draw_dm_creases__setDrawOptions, NULL); + glLineWidth(1.0); +} + +static int draw_dm_bweights__setDrawOptions(void *userData, int index) +{ + EditEdge *eed = EM_get_edge_for_index(index); + + if (eed->h==0 && eed->bweight!=0.0) { + UI_ThemeColorBlend(TH_WIRE, TH_EDGE_SELECT, eed->bweight); + return 1; + } else { + return 0; + } +} +static void draw_dm_bweights__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s) +{ + EditVert *eve = EM_get_vert_for_index(index); + + if (eve->h==0 && eve->bweight!=0.0) { + UI_ThemeColorBlend(TH_VERTEX, TH_VERTEX_SELECT, eve->bweight); + bglVertex3fv(co); + } +} +static void draw_dm_bweights(Scene *scene, DerivedMesh *dm) +{ + if (scene->selectmode & SCE_SELECT_VERTEX) { + glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE) + 2); + bglBegin(GL_POINTS); + dm->foreachMappedVert(dm, draw_dm_bweights__mapFunc, NULL); + bglEnd(); + } + else { + glLineWidth(3.0); + dm->drawMappedEdges(dm, draw_dm_bweights__setDrawOptions, NULL); + glLineWidth(1.0); + } +} + +/* Second section of routines: Combine first sets to form fancy + * drawing routines (for example rendering twice to get overlays). + * + * Also includes routines that are basic drawing but are too + * specialized to be split out (like drawing creases or measurements). + */ + +/* EditMesh drawing routines*/ + +static void draw_em_fancy_verts(Scene *scene, View3D *v3d, EditMesh *em, DerivedMesh *cageDM, EditVert *eve_act) +{ + int sel; + + if(v3d->zbuf) glDepthMask(0); // disable write in zbuffer, zbuf select + + for (sel=0; sel<2; sel++) { + char col[4], fcol[4]; + int pass; + + UI_GetThemeColor3ubv(sel?TH_VERTEX_SELECT:TH_VERTEX, col); + UI_GetThemeColor3ubv(sel?TH_FACE_DOT:TH_WIRE, fcol); + + for (pass=0; pass<2; pass++) { + float size = UI_GetThemeValuef(TH_VERTEX_SIZE); + float fsize = UI_GetThemeValuef(TH_FACEDOT_SIZE); + + if (pass==0) { + if(v3d->zbuf && !(v3d->flag&V3D_ZBUF_SELECT)) { + glDisable(GL_DEPTH_TEST); + + glEnable(GL_BLEND); + } else { + continue; + } + + size = (size>2.1?size/2.0:size); + fsize = (fsize>2.1?fsize/2.0:fsize); + col[3] = fcol[3] = 100; + } else { + col[3] = fcol[3] = 255; + } + + if(scene->selectmode & SCE_SELECT_VERTEX) { + glPointSize(size); + glColor4ubv((GLubyte *)col); + draw_dm_verts(cageDM, sel, eve_act); + } + + if( CHECK_OB_DRAWFACEDOT(scene, v3d, G.obedit->dt) ) { + glPointSize(fsize); + glColor4ubv((GLubyte *)fcol); + draw_dm_face_centers(cageDM, sel); + } + + if (pass==0) { + glDisable(GL_BLEND); + glEnable(GL_DEPTH_TEST); + } + } + } + + if(v3d->zbuf) glDepthMask(1); + glPointSize(1.0); +} + +static void draw_em_fancy_edges(Scene *scene, View3D *v3d, DerivedMesh *cageDM, short sel_only, EditEdge *eed_act) +{ + int pass; + unsigned char wireCol[4], selCol[4], actCol[4]; + + /* since this function does transparant... */ + UI_GetThemeColor4ubv(TH_EDGE_SELECT, (char *)selCol); + UI_GetThemeColor4ubv(TH_WIRE, (char *)wireCol); + UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, (char *)actCol); + + /* when sel only is used, dont render wire, only selected, this is used for + * textured draw mode when the 'edges' option is disabled */ + if (sel_only) + wireCol[3] = 0; + + for (pass=0; pass<2; pass++) { + /* show wires in transparant when no zbuf clipping for select */ + if (pass==0) { + if (v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT)==0) { + glEnable(GL_BLEND); + glDisable(GL_DEPTH_TEST); + selCol[3] = 85; + if (!sel_only) wireCol[3] = 85; + } else { + continue; + } + } else { + selCol[3] = 255; + if (!sel_only) wireCol[3] = 255; + } + + if(scene->selectmode == SCE_SELECT_FACE) { + draw_dm_edges_sel(cageDM, wireCol, selCol, actCol, eed_act); + } + else if( (G.f & G_DRAWEDGES) || (scene->selectmode & SCE_SELECT_EDGE) ) { + if(cageDM->drawMappedEdgesInterp && (scene->selectmode & SCE_SELECT_VERTEX)) { + glShadeModel(GL_SMOOTH); + draw_dm_edges_sel_interp(cageDM, wireCol, selCol); + glShadeModel(GL_FLAT); + } else { + draw_dm_edges_sel(cageDM, wireCol, selCol, actCol, eed_act); + } + } + else { + if (!sel_only) { + glColor4ubv(wireCol); + draw_dm_edges(cageDM); + } + } + + if (pass==0) { + glDisable(GL_BLEND); + glEnable(GL_DEPTH_TEST); + } + } +} + +static void draw_em_measure_stats(View3D *v3d, Object *ob, EditMesh *em) +{ + EditEdge *eed; + EditFace *efa; + float v1[3], v2[3], v3[3], v4[3]; + float fvec[3]; + char val[32]; /* Stores the measurement display text here */ + char conv_float[5]; /* Use a float conversion matching the grid size */ + float area, col[3]; /* area of the face, color of the text to draw */ + + if(G.f & (G_RENDER_OGL|G_RENDER_SHADOW)) + return; + + /* make the precission of the pronted value proportionate to the gridsize */ + if ((v3d->grid) < 0.01) + strcpy(conv_float, "%.6f"); + else if ((v3d->grid) < 0.1) + strcpy(conv_float, "%.5f"); + else if ((v3d->grid) < 1.0) + strcpy(conv_float, "%.4f"); + else if ((v3d->grid) < 10.0) + strcpy(conv_float, "%.3f"); + else + strcpy(conv_float, "%.2f"); + + + if(v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT)==0) + glDisable(GL_DEPTH_TEST); + + if(v3d->zbuf) bglPolygonOffset(5.0); + + if(G.f & G_DRAW_EDGELEN) { + UI_GetThemeColor3fv(TH_TEXT, col); + /* make color a bit more red */ + if(col[0]> 0.5) {col[1]*=0.7; col[2]*= 0.7;} + else col[0]= col[0]*0.7 + 0.3; + glColor3fv(col); + + for(eed= em->edges.first; eed; eed= eed->next) { + /* draw non fgon edges, or selected edges, or edges next to selected verts while draging */ + if((eed->h != EM_FGON) && ((eed->f & SELECT) || (G.moving && ((eed->v1->f & SELECT) || (eed->v2->f & SELECT)) ))) { + VECCOPY(v1, eed->v1->co); + VECCOPY(v2, eed->v2->co); + + glRasterPos3f( 0.5*(v1[0]+v2[0]), 0.5*(v1[1]+v2[1]), 0.5*(v1[2]+v2[2])); + + if(v3d->flag & V3D_GLOBAL_STATS) { + Mat4MulVecfl(ob->obmat, v1); + Mat4MulVecfl(ob->obmat, v2); + } + + sprintf(val, conv_float, VecLenf(v1, v2)); + BMF_DrawString( G.fonts, val); + } + } + } + + if(G.f & G_DRAW_FACEAREA) { +// XXX extern int faceselectedOR(EditFace *efa, int flag); // editmesh.h shouldn't be in this file... ok for now? + + UI_GetThemeColor3fv(TH_TEXT, col); + /* make color a bit more green */ + if(col[1]> 0.5) {col[0]*=0.7; col[2]*= 0.7;} + else col[1]= col[1]*0.7 + 0.3; + glColor3fv(col); + + for(efa= em->faces.first; efa; efa= efa->next) { + if((efa->f & SELECT)) { // XXX || (G.moving && faceselectedOR(efa, SELECT)) ) { + VECCOPY(v1, efa->v1->co); + VECCOPY(v2, efa->v2->co); + VECCOPY(v3, efa->v3->co); + if (efa->v4) { + VECCOPY(v4, efa->v4->co); + } + if(v3d->flag & V3D_GLOBAL_STATS) { + Mat4MulVecfl(ob->obmat, v1); + Mat4MulVecfl(ob->obmat, v2); + Mat4MulVecfl(ob->obmat, v3); + if (efa->v4) Mat4MulVecfl(ob->obmat, v4); + } + + if (efa->v4) + area= AreaQ3Dfl(v1, v2, v3, v4); + else + area = AreaT3Dfl(v1, v2, v3); + + sprintf(val, conv_float, area); + glRasterPos3fv(efa->cent); + BMF_DrawString( G.fonts, val); + } + } + } + + if(G.f & G_DRAW_EDGEANG) { + EditEdge *e1, *e2, *e3, *e4; + + UI_GetThemeColor3fv(TH_TEXT, col); + /* make color a bit more blue */ + if(col[2]> 0.5) {col[0]*=0.7; col[1]*= 0.7;} + else col[2]= col[2]*0.7 + 0.3; + glColor3fv(col); + + for(efa= em->faces.first; efa; efa= efa->next) { + VECCOPY(v1, efa->v1->co); + VECCOPY(v2, efa->v2->co); + VECCOPY(v3, efa->v3->co); + if(efa->v4) { + VECCOPY(v4, efa->v4->co); + } + else { + VECCOPY(v4, v3); + } + if(v3d->flag & V3D_GLOBAL_STATS) { + Mat4MulVecfl(ob->obmat, v1); + Mat4MulVecfl(ob->obmat, v2); + Mat4MulVecfl(ob->obmat, v3); + Mat4MulVecfl(ob->obmat, v4); + } + + e1= efa->e1; + e2= efa->e2; + e3= efa->e3; + if(efa->e4) e4= efa->e4; else e4= e3; + + /* Calculate the angles */ + + if( (e4->f & e1->f & SELECT) || (G.moving && (efa->v1->f & SELECT)) ) { + /* Vec 1 */ + sprintf(val,"%.3f", VecAngle3(v4, v1, v2)); + VecLerpf(fvec, efa->cent, efa->v1->co, 0.8); + glRasterPos3fv(fvec); + BMF_DrawString( G.fonts, val); + } + if( (e1->f & e2->f & SELECT) || (G.moving && (efa->v2->f & SELECT)) ) { + /* Vec 2 */ + sprintf(val,"%.3f", VecAngle3(v1, v2, v3)); + VecLerpf(fvec, efa->cent, efa->v2->co, 0.8); + glRasterPos3fv(fvec); + BMF_DrawString( G.fonts, val); + } + if( (e2->f & e3->f & SELECT) || (G.moving && (efa->v3->f & SELECT)) ) { + /* Vec 3 */ + if(efa->v4) + sprintf(val,"%.3f", VecAngle3(v2, v3, v4)); + else + sprintf(val,"%.3f", VecAngle3(v2, v3, v1)); + VecLerpf(fvec, efa->cent, efa->v3->co, 0.8); + glRasterPos3fv(fvec); + BMF_DrawString( G.fonts, val); + } + /* Vec 4 */ + if(efa->v4) { + if( (e3->f & e4->f & SELECT) || (G.moving && (efa->v4->f & SELECT)) ) { + sprintf(val,"%.3f", VecAngle3(v3, v4, v1)); + VecLerpf(fvec, efa->cent, efa->v4->co, 0.8); + glRasterPos3fv(fvec); + BMF_DrawString( G.fonts, val); + } + } + } + } + + if(v3d->zbuf) { + glEnable(GL_DEPTH_TEST); + bglPolygonOffset(0.0); + } +} + +static int draw_em_fancy__setFaceOpts(void *userData, int index, int *drawSmooth_r) +{ + EditFace *efa = EM_get_face_for_index(index); + + if (efa->h==0) { + GPU_enable_material(efa->mat_nr+1, NULL); + return 1; + } + else + return 0; +} + +static int draw_em_fancy__setGLSLFaceOpts(void *userData, int index) +{ + EditFace *efa = EM_get_face_for_index(index); + + return (efa->h==0); +} + +static void draw_em_fancy(Scene *scene, View3D *v3d, Object *ob, EditMesh *em, DerivedMesh *cageDM, DerivedMesh *finalDM, int dt) +{ + Mesh *me = ob->data; + EditFace *efa_act = EM_get_actFace(0); /* annoying but active faces is stored differently */ + EditEdge *eed_act = NULL; + EditVert *eve_act = NULL; + + if (G.editMesh->selected.last) { + EditSelection *ese = G.editMesh->selected.last; + /* face is handeled above */ + /*if (ese->type == EDITFACE ) { + efa_act = (EditFace *)ese->data; + } else */ if ( ese->type == EDITEDGE ) { + eed_act = (EditEdge *)ese->data; + } else if ( ese->type == EDITVERT ) { + eve_act = (EditVert *)ese->data; + } + } + + EM_init_index_arrays(1, 1, 1); + + if(dt>OB_WIRE) { + if(CHECK_OB_DRAWTEXTURE(v3d, dt)) { + if(draw_glsl_material(scene, ob, v3d, dt)) { + glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); + + finalDM->drawMappedFacesGLSL(finalDM, GPU_enable_material, + draw_em_fancy__setGLSLFaceOpts, NULL); + GPU_disable_material(); + + glFrontFace(GL_CCW); + } + else { + draw_mesh_textured(scene, v3d, ob, finalDM, 0); + } + } + else { + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, me->flag & ME_TWOSIDED); + + glEnable(GL_LIGHTING); + glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); + + finalDM->drawMappedFaces(finalDM, draw_em_fancy__setFaceOpts, 0, 0); + + glFrontFace(GL_CCW); + glDisable(GL_LIGHTING); + } + + // Setup for drawing wire over, disable zbuffer + // write to show selected edge wires better + UI_ThemeColor(TH_WIRE); + + bglPolygonOffset(1.0); + glDepthMask(0); + } + else { + if (cageDM!=finalDM) { + UI_ThemeColorBlend(TH_WIRE, TH_BACK, 0.7); + finalDM->drawEdges(finalDM, 1); + } + } + + if((G.f & (G_DRAWFACES)) || FACESEL_PAINT_TEST) { /* transp faces */ + unsigned char col1[4], col2[4], col3[4]; + + UI_GetThemeColor4ubv(TH_FACE, (char *)col1); + UI_GetThemeColor4ubv(TH_FACE_SELECT, (char *)col2); + UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, (char *)col3); + + glEnable(GL_BLEND); + glDepthMask(0); // disable write in zbuffer, needed for nice transp + + /* dont draw unselected faces, only selected, this is MUCH nicer when texturing */ + if CHECK_OB_DRAWTEXTURE(v3d, dt) + col1[3] = 0; + + draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act); + + glDisable(GL_BLEND); + glDepthMask(1); // restore write in zbuffer + } else if (efa_act) { + /* even if draw faces is off it would be nice to draw the stipple face + * Make all other faces zero alpha except for the active + * */ + unsigned char col1[4], col2[4], col3[4]; + col1[3] = col2[3] = 0; /* dont draw */ + UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, (char *)col3); + + glEnable(GL_BLEND); + glDepthMask(0); // disable write in zbuffer, needed for nice transp + + draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act); + + glDisable(GL_BLEND); + glDepthMask(1); // restore write in zbuffer + + } + + /* here starts all fancy draw-extra over */ + if((G.f & G_DRAWEDGES)==0 && CHECK_OB_DRAWTEXTURE(v3d, dt)) { + /* we are drawing textures and 'G_DRAWEDGES' is disabled, dont draw any edges */ + + /* only draw selected edges otherwise there is no way of telling if a face is selected */ + draw_em_fancy_edges(scene, v3d, cageDM, 1, eed_act); + + } else { + if(G.f & G_DRAWSEAMS) { + UI_ThemeColor(TH_EDGE_SEAM); + glLineWidth(2); + + draw_dm_edges_seams(cageDM); + + glColor3ub(0,0,0); + glLineWidth(1); + } + + if(G.f & G_DRAWSHARP) { + UI_ThemeColor(TH_EDGE_SHARP); + glLineWidth(2); + + draw_dm_edges_sharp(cageDM); + + glColor3ub(0,0,0); + glLineWidth(1); + } + + if(G.f & G_DRAWCREASES) { + draw_dm_creases(cageDM); + } + if(G.f & G_DRAWBWEIGHTS) { + draw_dm_bweights(scene, cageDM); + } + + draw_em_fancy_edges(scene, v3d, cageDM, 0, eed_act); + } + if(ob==G.obedit) { +// XXX retopo_matrix_update(v3d); + + draw_em_fancy_verts(scene, v3d, em, cageDM, eve_act); + + if(G.f & G_DRAWNORMALS) { + UI_ThemeColor(TH_NORMAL); + draw_dm_face_normals(cageDM); + } + if(G.f & G_DRAW_VNORMALS) { + UI_ThemeColor(TH_NORMAL); + draw_dm_vert_normals(cageDM); + } + + if(G.f & (G_DRAW_EDGELEN|G_DRAW_FACEAREA|G_DRAW_EDGEANG)) + draw_em_measure_stats(v3d, ob, em); + } + + if(dt>OB_WIRE) { + glDepthMask(1); + bglPolygonOffset(0.0); + GPU_disable_material(); + } + + EM_free_index_arrays(); +} + +/* Mesh drawing routines */ + +static void draw_mesh_object_outline(View3D *v3d, Object *ob, DerivedMesh *dm) +{ + + if(v3d->transp==0) { // not when we draw the transparent pass + glLineWidth(2.0); + glDepthMask(0); + + /* if transparent, we cannot draw the edges for solid select... edges have no material info. + drawFacesSolid() doesn't draw the transparent faces */ + if(ob->dtx & OB_DRAWTRANSP) { + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + dm->drawFacesSolid(dm, GPU_enable_material); + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + GPU_disable_material(); + } + else { + dm->drawEdges(dm, 0); + } + + glLineWidth(1.0); + glDepthMask(1); + } +} + +static int wpaint__setSolidDrawOptions(void *userData, int index, int *drawSmooth_r) +{ + *drawSmooth_r = 1; + return 1; +} + +static void draw_mesh_fancy(Scene *scene, View3D *v3d, Base *base, int dt, int flag) +{ + Object *ob= base->object; + Mesh *me = ob->data; + Material *ma= give_current_material(ob, 1); + int hasHaloMat = (ma && (ma->mode&MA_HALO)); + int draw_wire = 0; + int totvert, totedge, totface; + DispList *dl; + DerivedMesh *dm= mesh_get_derived_final(ob, get_viewedit_datamask()); + + if(!dm) + return; + + if (ob->dtx&OB_DRAWWIRE) { + draw_wire = 2; /* draw wire after solid using zoffset and depth buffer adjusment */ + } + + totvert = dm->getNumVerts(dm); + totedge = dm->getNumEdges(dm); + totface = dm->getNumFaces(dm); + + /* vertexpaint, faceselect wants this, but it doesnt work for shaded? */ + if(dt!=OB_SHADED) + glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); + + // Unwanted combination. + if (ob==OBACT && FACESEL_PAINT_TEST) draw_wire = 0; + + if(dt==OB_BOUNDBOX) { + draw_bounding_volume(ob); + } + else if(hasHaloMat || (totface==0 && totedge==0)) { + glPointSize(1.5); + dm->drawVerts(dm); + glPointSize(1.0); + } + else if(dt==OB_WIRE || totface==0) { + draw_wire = 1; /* draw wire only, no depth buffer stuff */ + } + else if( (ob==OBACT && (G.f & G_TEXTUREPAINT || FACESEL_PAINT_TEST)) || + CHECK_OB_DRAWTEXTURE(v3d, dt)) + { + int faceselect= (ob==OBACT && FACESEL_PAINT_TEST); + + if ((v3d->flag&V3D_SELECT_OUTLINE) && (base->flag&SELECT) && !(G.f&G_PICKSEL || FACESEL_PAINT_TEST) && !draw_wire) { + draw_mesh_object_outline(v3d, ob, dm); + } + + if(draw_glsl_material(scene, ob, v3d, dt)) { + glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); + + dm->drawFacesGLSL(dm, GPU_enable_material); +// if(get_ob_property(ob, "Text")) +// XXX draw_mesh_text(ob, 1); + GPU_disable_material(); + + glFrontFace(GL_CCW); + } + else { + draw_mesh_textured(scene, v3d, ob, dm, faceselect); + } + + if(!faceselect) { + if(base->flag & SELECT) + UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT); + else + UI_ThemeColor(TH_WIRE); + + dm->drawLooseEdges(dm); + } + } + else if(dt==OB_SOLID) { + if((v3d->flag&V3D_SELECT_OUTLINE) && (base->flag&SELECT) && !draw_wire) + draw_mesh_object_outline(v3d, ob, dm); + + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, me->flag & ME_TWOSIDED ); + + glEnable(GL_LIGHTING); + glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); + + dm->drawFacesSolid(dm, GPU_enable_material); + GPU_disable_material(); + + glFrontFace(GL_CCW); + glDisable(GL_LIGHTING); + + if(base->flag & SELECT) { + UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT); + } else { + UI_ThemeColor(TH_WIRE); + } + dm->drawLooseEdges(dm); + } + else if(dt==OB_SHADED) { + int do_draw= 1; /* to resolve all G.f settings below... */ + + if(ob==OBACT) { + do_draw= 0; + if( (G.f & G_WEIGHTPAINT)) { + /* enforce default material settings */ + GPU_enable_material(0, NULL); + + /* but set default spec */ + glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR); + glEnable(GL_COLOR_MATERIAL); /* according manpages needed */ + glColor3ub(120, 120, 120); + glDisable(GL_COLOR_MATERIAL); + /* diffuse */ + glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); + glEnable(GL_LIGHTING); + glEnable(GL_COLOR_MATERIAL); + + dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, me->mface, 1); + glDisable(GL_COLOR_MATERIAL); + glDisable(GL_LIGHTING); + + GPU_disable_material(); + } + else if((G.f & (G_VERTEXPAINT+G_TEXTUREPAINT)) && me->mcol) { + dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, NULL, 1); + } + else if(G.f & (G_VERTEXPAINT+G_TEXTUREPAINT)) { + glColor3f(1.0f, 1.0f, 1.0f); + dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, NULL, 0); + } + else do_draw= 1; + } + if(do_draw) { + dl = ob->disp.first; + if (!dl || !dl->col1) { + /* release and reload derivedmesh because it might be freed in + shadeDispList due to a different datamask */ + dm->release(dm); + shadeDispList(base); + dl = find_displist(&ob->disp, DL_VERTCOL); + dm= mesh_get_derived_final(ob, get_viewedit_datamask()); + } + + if ((v3d->flag&V3D_SELECT_OUTLINE) && (base->flag&SELECT) && !draw_wire) { + draw_mesh_object_outline(v3d, ob, dm); + } + + /* False for dupliframe objects */ + if (dl) { + unsigned int *obCol1 = dl->col1; + unsigned int *obCol2 = dl->col2; + + dm->drawFacesColored(dm, me->flag&ME_TWOSIDED, (unsigned char*) obCol1, (unsigned char*) obCol2); + } + + if(base->flag & SELECT) { + UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT); + } else { + UI_ThemeColor(TH_WIRE); + } + dm->drawLooseEdges(dm); + } + } + + /* set default draw color back for wire or for draw-extra later on */ + if (dt!=OB_WIRE) { + if(base->flag & SELECT) { + if(ob==OBACT && ob->flag & OB_FROMGROUP) + UI_ThemeColor(TH_GROUP_ACTIVE); + else if(ob->flag & OB_FROMGROUP) + UI_ThemeColorShade(TH_GROUP_ACTIVE, -16); + else if(flag!=DRAW_CONSTCOLOR) + UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT); + else + glColor3ub(80,80,80); + } else { + if (ob->flag & OB_FROMGROUP) + UI_ThemeColor(TH_GROUP); + else { + if(ob->dtx & OB_DRAWWIRE && flag==DRAW_CONSTCOLOR) + glColor3ub(80,80,80); + else + UI_ThemeColor(TH_WIRE); + } + } + } + if (draw_wire) { + /* If drawing wire and drawtype is not OB_WIRE then we are + * overlaying the wires. + * + * UPDATE bug #10290 - With this wire-only objects can draw + * behind other objects depending on their order in the scene. 2x if 0's below. undo'ing zr's commit: r4059 + * + * if draw wire is 1 then just drawing wire, no need for depth buffer stuff, + * otherwise this wire is to overlay solid mode faces so do some depth buffer tricks. + */ + if (dt!=OB_WIRE && draw_wire==2) { + bglPolygonOffset(1.0); + glDepthMask(0); // disable write in zbuffer, selected edge wires show better + } + + dm->drawEdges(dm, (dt==OB_WIRE || totface==0)); + + if (dt!=OB_WIRE && draw_wire==2) { + glDepthMask(1); + bglPolygonOffset(0.0); + } + } + + dm->release(dm); +} + +/* returns 1 if nothing was drawn, for detecting to draw an object center */ +static int draw_mesh_object(Scene *scene, View3D *v3d, Base *base, int dt, int flag) +{ + Object *ob= base->object; + Mesh *me= ob->data; + int do_alpha_pass= 0, drawlinked= 0, retval= 0, glsl, check_alpha; + + if(G.obedit && ob!=G.obedit && ob->data==G.obedit->data) { + if(ob_get_key(ob)); + else drawlinked= 1; + } + + if(ob==G.obedit || drawlinked) { + DerivedMesh *finalDM, *cageDM; + + if (G.obedit!=ob) + finalDM = cageDM = editmesh_get_derived_base(); + else + cageDM = editmesh_get_derived_cage_and_final(&finalDM, + get_viewedit_datamask()); + + if(dt>OB_WIRE) { + // no transp in editmode, the fancy draw over goes bad then + glsl = draw_glsl_material(scene, ob, v3d, dt); + GPU_set_object_materials(scene, ob, glsl, NULL); + } + + draw_em_fancy(scene, v3d, ob, G.editMesh, cageDM, finalDM, dt); + + if (G.obedit!=ob && finalDM) + finalDM->release(finalDM); + } +// else if(!G.obedit && (G.f & G_SCULPTMODE) &&(scene->sculptdata.flags & SCULPT_DRAW_FAST) && +// OBACT==ob && !sculpt_modifiers_active(ob)) { +// XXX sculptmode_draw_mesh(0); +// } + else { + /* don't create boundbox here with mesh_get_bb(), the derived system will make it, puts deformed bb's OK */ + if(me->totface<=4 || boundbox_clip(v3d, ob->obmat, (ob->bb)? ob->bb: me->bb)) { + glsl = draw_glsl_material(scene, ob, v3d, dt); + check_alpha = check_material_alpha(base, ob, glsl); + + if(dt==OB_SOLID || glsl) { + GPU_set_object_materials(scene, ob, glsl, + (check_alpha)? &do_alpha_pass: NULL); + } + + draw_mesh_fancy(scene, v3d, base, dt, flag); + + if(me->totvert==0) retval= 1; + } + } + + /* GPU_set_object_materials checked if this is needed */ + if(do_alpha_pass) add_view3d_after(v3d, base, V3D_TRANSP, flag); + + return retval; +} + +/* ************** DRAW DISPLIST ****************** */ + +static int draw_index_wire= 1; +static int index3_nors_incr= 1; + +/* returns 1 when nothing was drawn */ +static int drawDispListwire(ListBase *dlbase) +{ + DispList *dl; + int parts, nr; + float *data; + + if(dlbase==NULL) return 1; + + glDisableClientState(GL_NORMAL_ARRAY); + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + + for(dl= dlbase->first; dl; dl= dl->next) { + if(dl->parts==0 || dl->nr==0) + continue; + + data= dl->verts; + + switch(dl->type) { + case DL_SEGM: + + glVertexPointer(3, GL_FLOAT, 0, data); + + for(parts=0; parts<dl->parts; parts++) + glDrawArrays(GL_LINE_STRIP, parts*dl->nr, dl->nr); + + break; + case DL_POLY: + + glVertexPointer(3, GL_FLOAT, 0, data); + + for(parts=0; parts<dl->parts; parts++) + glDrawArrays(GL_LINE_LOOP, parts*dl->nr, dl->nr); + + break; + case DL_SURF: + + glVertexPointer(3, GL_FLOAT, 0, data); + + for(parts=0; parts<dl->parts; parts++) { + if(dl->flag & DL_CYCL_U) + glDrawArrays(GL_LINE_LOOP, parts*dl->nr, dl->nr); + else + glDrawArrays(GL_LINE_STRIP, parts*dl->nr, dl->nr); + } + + for(nr=0; nr<dl->nr; nr++) { + int ofs= 3*dl->nr; + + data= ( dl->verts )+3*nr; + parts= dl->parts; + + if(dl->flag & DL_CYCL_V) glBegin(GL_LINE_LOOP); + else glBegin(GL_LINE_STRIP); + + while(parts--) { + glVertex3fv(data); + data+=ofs; + } + glEnd(); + + /* (ton) this code crashes for me when resolv is 86 or higher... no clue */ +// glVertexPointer(3, GL_FLOAT, sizeof(float)*3*dl->nr, data + 3*nr); +// if(dl->flag & DL_CYCL_V) +// glDrawArrays(GL_LINE_LOOP, 0, dl->parts); +// else +// glDrawArrays(GL_LINE_STRIP, 0, dl->parts); + } + break; + + case DL_INDEX3: + if(draw_index_wire) { + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glDrawElements(GL_TRIANGLES, 3*dl->parts, GL_UNSIGNED_INT, dl->index); + } + break; + + case DL_INDEX4: + if(draw_index_wire) { + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glDrawElements(GL_QUADS, 4*dl->parts, GL_UNSIGNED_INT, dl->index); + } + break; + } + } + + glEnableClientState(GL_NORMAL_ARRAY); + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + + return 0; +} + +static void drawDispListsolid(ListBase *lb, Object *ob, int glsl) +{ + DispList *dl; + GPUVertexAttribs gattribs; + float *data, curcol[4]; + float *ndata; + + if(lb==NULL) return; + + /* for drawing wire */ + glGetFloatv(GL_CURRENT_COLOR, curcol); + + glEnable(GL_LIGHTING); + + if(ob->transflag & OB_NEG_SCALE) glFrontFace(GL_CW); + else glFrontFace(GL_CCW); + + if(ob->type==OB_MBALL) { // mball always smooth shaded + glShadeModel(GL_SMOOTH); + } + + dl= lb->first; + while(dl) { + data= dl->verts; + ndata= dl->nors; + + switch(dl->type) { + case DL_SEGM: + if(ob->type==OB_SURF) { + int nr; + + glDisable(GL_LIGHTING); + glColor3fv(curcol); + + // glVertexPointer(3, GL_FLOAT, 0, dl->verts); + // glDrawArrays(GL_LINE_STRIP, 0, dl->nr); + + glBegin(GL_LINE_STRIP); + for(nr= dl->nr; nr; nr--, data+=3) + glVertex3fv(data); + glEnd(); + + glEnable(GL_LIGHTING); + } + break; + case DL_POLY: + if(ob->type==OB_SURF) { + int nr; + + UI_ThemeColor(TH_WIRE); + glDisable(GL_LIGHTING); + + /* for some reason glDrawArrays crashes here in half of the platforms (not osx) */ + //glVertexPointer(3, GL_FLOAT, 0, dl->verts); + //glDrawArrays(GL_LINE_LOOP, 0, dl->nr); + + glBegin(GL_LINE_LOOP); + for(nr= dl->nr; nr; nr--, data+=3) + glVertex3fv(data); + glEnd(); + + glEnable(GL_LIGHTING); + break; + } + case DL_SURF: + + if(dl->index) { + GPU_enable_material(dl->col+1, (glsl)? &gattribs: NULL); + + if(dl->rt & CU_SMOOTH) glShadeModel(GL_SMOOTH); + else glShadeModel(GL_FLAT); + + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glNormalPointer(GL_FLOAT, 0, dl->nors); + glDrawElements(GL_QUADS, 4*dl->totindex, GL_UNSIGNED_INT, dl->index); + GPU_disable_material(); + } + break; + + case DL_INDEX3: + GPU_enable_material(dl->col+1, (glsl)? &gattribs: NULL); + + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + + /* voor polys only one normal needed */ + if(index3_nors_incr==0) { + glDisableClientState(GL_NORMAL_ARRAY); + glNormal3fv(ndata); + } + else + glNormalPointer(GL_FLOAT, 0, dl->nors); + + glDrawElements(GL_TRIANGLES, 3*dl->parts, GL_UNSIGNED_INT, dl->index); + GPU_disable_material(); + + if(index3_nors_incr==0) + glEnableClientState(GL_NORMAL_ARRAY); + + break; + + case DL_INDEX4: + GPU_enable_material(dl->col+1, (glsl)? &gattribs: NULL); + + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glNormalPointer(GL_FLOAT, 0, dl->nors); + glDrawElements(GL_QUADS, 4*dl->parts, GL_UNSIGNED_INT, dl->index); + + GPU_disable_material(); + + break; + } + dl= dl->next; + } + + glShadeModel(GL_FLAT); + glDisable(GL_LIGHTING); + glFrontFace(GL_CCW); +} + +static void drawDispListshaded(ListBase *lb, Object *ob) +{ + DispList *dl, *dlob; + unsigned int *cdata; + + if(lb==NULL) return; + + glShadeModel(GL_SMOOTH); + glDisableClientState(GL_NORMAL_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + dl= lb->first; + dlob= ob->disp.first; + while(dl && dlob) { + + cdata= dlob->col1; + if(cdata==NULL) break; + + switch(dl->type) { + case DL_SURF: + if(dl->index) { + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, cdata); + glDrawElements(GL_QUADS, 4*dl->totindex, GL_UNSIGNED_INT, dl->index); + } + break; + + case DL_INDEX3: + + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, cdata); + glDrawElements(GL_TRIANGLES, 3*dl->parts, GL_UNSIGNED_INT, dl->index); + break; + + case DL_INDEX4: + + glVertexPointer(3, GL_FLOAT, 0, dl->verts); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, cdata); + glDrawElements(GL_QUADS, 4*dl->parts, GL_UNSIGNED_INT, dl->index); + break; + } + + dl= dl->next; + dlob= dlob->next; + } + + glShadeModel(GL_FLAT); + glEnableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_COLOR_ARRAY); +} + +/* returns 1 when nothing was drawn */ +static int drawDispList(Scene *scene, View3D *v3d, Base *base, int dt) +{ + Object *ob= base->object; + ListBase *lb=0; + DispList *dl; + Curve *cu; + int solid, retval= 0; + + solid= (dt > OB_WIRE); + + switch(ob->type) { + case OB_FONT: + case OB_CURVE: + cu= ob->data; + + lb= &cu->disp; + + if(solid) { + dl= lb->first; + if(dl==NULL) return 1; + + if(dl->nors==0) addnormalsDispList(ob, lb); + index3_nors_incr= 0; + + if( displist_has_faces(lb)==0) { + draw_index_wire= 0; + drawDispListwire(lb); + draw_index_wire= 1; + } + else { + if(draw_glsl_material(scene, ob, v3d, dt)) { + GPU_set_object_materials(scene, ob, 1, NULL); + drawDispListsolid(lb, ob, 1); + } + else if(dt == OB_SHADED) { + if(ob->disp.first==0) shadeDispList(base); + drawDispListshaded(lb, ob); + } + else { + GPU_set_object_materials(scene, ob, 0, NULL); + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0); + drawDispListsolid(lb, ob, 0); + } + if(ob==G.obedit && cu->bevobj==NULL && cu->taperobj==NULL && cu->ext1 == 0.0 && cu->ext2 == 0.0) { + cpack(0); + draw_index_wire= 0; + drawDispListwire(lb); + draw_index_wire= 1; + } + } + index3_nors_incr= 1; + } + else { + draw_index_wire= 0; + retval= drawDispListwire(lb); + draw_index_wire= 1; + } + break; + case OB_SURF: + + lb= &((Curve *)ob->data)->disp; + + if(solid) { + dl= lb->first; + if(dl==NULL) return 1; + + if(dl->nors==NULL) addnormalsDispList(ob, lb); + + if(draw_glsl_material(scene, ob, v3d, dt)) { + GPU_set_object_materials(scene, ob, 1, NULL); + drawDispListsolid(lb, ob, 1); + } + else if(dt==OB_SHADED) { + if(ob->disp.first==NULL) shadeDispList(base); + drawDispListshaded(lb, ob); + } + else { + GPU_set_object_materials(scene, ob, 0, NULL); + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0); + + drawDispListsolid(lb, ob, 0); + } + } + else { + retval= drawDispListwire(lb); + } + break; + case OB_MBALL: + + if( is_basis_mball(ob)) { + lb= &ob->disp; + if(lb->first==NULL) makeDispListMBall(ob); + if(lb->first==NULL) return 1; + + if(solid) { + + if(draw_glsl_material(scene, ob, v3d, dt)) { + GPU_set_object_materials(scene, ob, 1, NULL); + drawDispListsolid(lb, ob, 1); + } + else if(dt == OB_SHADED) { + dl= lb->first; + if(dl && dl->col1==0) shadeDispList(base); + drawDispListshaded(lb, ob); + } + else { + GPU_set_object_materials(scene, ob, 0, NULL); + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0); + + drawDispListsolid(lb, ob, 0); + } + } + else{ + /* MetaBalls use DL_INDEX4 type of DispList */ + retval= drawDispListwire(lb); + } + } + break; + } + + return retval; +} + +/* unified drawing of all new particle systems draw types except dupli ob & group */ +/* mostly tries to use vertex arrays for speed */ + +/* 1. check that everything is ok & updated */ +/* 2. start initialising things */ +/* 3. initialize according to draw type */ +/* 4. allocate drawing data arrays */ +/* 5. start filling the arrays */ +/* 6. draw the arrays */ +/* 7. clean up */ +static void draw_new_particle_system(const bContext *C, View3D *v3d, Base *base, ParticleSystem *psys, int dt) +{ + Object *ob=base->object; + ParticleSystemModifierData *psmd; + ParticleSettings *part; + ParticleData *pars, *pa; + ParticleKey state, *states=0; + ParticleCacheKey *cache=0; + Material *ma; + Object *bb_ob=0; + float vel[3], vec[3], vec2[3], imat[4][4], onevec[3]={0.0f,0.0f,0.0f}, bb_center[3]; + float timestep, pixsize=1.0, pa_size, pa_time, r_tilt; + float cfra=bsystem_time(ob,(float)CFRA,0.0); + float *vdata=0, *vedata=0, *cdata=0, *ndata=0, *vd=0, *ved=0, *cd=0, *nd=0, xvec[3], yvec[3], zvec[3]; + float ma_r=0.0f, ma_g=0.0f, ma_b=0.0f; + int a, k, k_max=0, totpart, totpoint=0, draw_as, path_nbr=0; + int path_possible=0, keys_possible=0, draw_keys=0, totchild=0; + int select=ob->flag&SELECT, create_cdata=0; + GLint polygonmode[2]; + char val[32]; + +/* 1. */ + if(psys==0) + return; + + part=psys->part; + pars=psys->particles; + + if(part==0 || !psys_check_enabled(ob, psys)) + return; + + if(pars==0) return; + + if(!G.obedit && psys_in_edit_mode(psys) + && psys->flag & PSYS_HAIR_DONE && part->draw_as==PART_DRAW_PATH) + return; + + if(part->draw_as==PART_DRAW_NOT) return; + +/* 2. */ + if(part->phystype==PART_PHYS_KEYED){ + if(psys->flag & PSYS_FIRST_KEYED){ + if(psys->flag&PSYS_KEYED){ + select=psys_count_keyed_targets(ob,psys); + if(psys->totkeyed==0) + return; + } + } + else + return; + } + + if(select){ + select=0; + if(psys_get_current(ob)==psys) + select=1; + } + + psys->flag|=PSYS_DRAWING; + + if(part->type==PART_HAIR && !psys->childcache) + totchild=0; + else + totchild=psys->totchild*part->disp/100; + + ma= give_current_material(ob,part->omat); + + if(ma) { + ma_r = ma->r; + ma_g = ma->g; + ma_b = ma->b; + } + + if(v3d->zbuf) glDepthMask(1); + + if(select) + cpack(0xFFFFFF); + else if((ma) && (part->draw&PART_DRAW_MAT_COL)) { + glColor3f(ma->r,ma->g,ma->b); + create_cdata = 1; + } + else + cpack(0); + + psmd= psys_get_modifier(ob,psys); + + timestep= psys_get_timestep(part); + + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + + if( (base->flag & OB_FROMDUPLI) && (ob->flag & OB_FROMGROUP) ) { + float mat[4][4]; + Mat4MulMat4(mat, psys->imat, ob->obmat); + wmMultMatrix(CTX_wm_window(C), mat); + } + + totpart=psys->totpart; + draw_as=part->draw_as; + + if(part->flag&PART_GLOB_TIME) + cfra=bsystem_time(0,(float)CFRA,0.0); + + if(psys->pathcache){ + path_possible=1; + keys_possible=1; + } + if(draw_as==PART_DRAW_PATH && path_possible==0) + draw_as=PART_DRAW_DOT; + + if(draw_as!=PART_DRAW_PATH && keys_possible && part->draw&PART_DRAW_KEYS){ + path_nbr=part->keys_step; + draw_keys=1; + } + +/* 3. */ + switch(draw_as){ + case PART_DRAW_DOT: + if(part->draw_size) + glPointSize(part->draw_size); + else + glPointSize(2.0); /* default dot size */ + break; + case PART_DRAW_CIRC: + /* calculate view aligned matrix: */ + Mat4CpyMat4(imat, v3d->viewinv); + Normalize(imat[0]); + Normalize(imat[1]); + /* no break! */ + case PART_DRAW_CROSS: + case PART_DRAW_AXIS: + /* lets calculate the scale: */ + pixsize= v3d->persmat[0][3]*ob->obmat[3][0]+ v3d->persmat[1][3]*ob->obmat[3][1]+ v3d->persmat[2][3]*ob->obmat[3][2]+ v3d->persmat[3][3]; + pixsize*= v3d->pixsize; + if(part->draw_size==0.0) + pixsize*=2.0; + else + pixsize*=part->draw_size; + break; + case PART_DRAW_OB: + if(part->dup_ob==0) + draw_as=PART_DRAW_DOT; + else + draw_as=0; + break; + case PART_DRAW_GR: + if(part->dup_group==0) + draw_as=PART_DRAW_DOT; + else + draw_as=0; + break; + case PART_DRAW_BB: + if(v3d->camera==0 && part->bb_ob==0){ +// XXX error("Billboards need an active camera or a target object!"); + + draw_as=part->draw_as=PART_DRAW_DOT; + + if(part->draw_size) + glPointSize(part->draw_size); + else + glPointSize(2.0); /* default dot size */ + } + else if(part->bb_ob) + bb_ob=part->bb_ob; + else + bb_ob=v3d->camera; + + if(part->bb_align<PART_BB_VIEW) + onevec[part->bb_align]=1.0f; + break; + case PART_DRAW_PATH: + break; + } + if(part->draw & PART_DRAW_SIZE && part->draw_as!=PART_DRAW_CIRC){ + Mat4CpyMat4(imat, v3d->viewinv); + Normalize(imat[0]); + Normalize(imat[1]); + } + +/* 4. */ + if(draw_as && draw_as!=PART_DRAW_PATH){ + if(draw_as!=PART_DRAW_CIRC){ + switch(draw_as){ + case PART_DRAW_AXIS: + case PART_DRAW_CROSS: + if(draw_as!=PART_DRAW_CROSS || create_cdata) + cdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*6*3*sizeof(float), "particle_cdata"); + vdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*6*3*sizeof(float), "particle_vdata"); + break; + case PART_DRAW_LINE: + if(create_cdata) + cdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*2*3*sizeof(float), "particle_cdata"); + vdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*2*3*sizeof(float), "particle_vdata"); + break; + case PART_DRAW_BB: + if(create_cdata) + cdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*4*3*sizeof(float), "particle_cdata"); + vdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*4*3*sizeof(float), "particle_vdata"); + ndata=MEM_callocN((totpart+totchild)*(path_nbr+1)*4*3*sizeof(float), "particle_vdata"); + break; + default: + if(create_cdata) + cdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*3*sizeof(float), "particle_cdata"); + vdata=MEM_callocN((totpart+totchild)*(path_nbr+1)*3*sizeof(float), "particle_vdata"); + } + } + + if(part->draw&PART_DRAW_VEL && draw_as!=PART_DRAW_LINE) + vedata=MEM_callocN((totpart+totchild)*2*3*(path_nbr+1)*sizeof(float), "particle_vedata"); + + vd=vdata; + ved=vedata; + cd=cdata; + nd=ndata; + + psys->lattice=psys_get_lattice(ob,psys); + } + + if(draw_as){ +/* 5. */ + for(a=0,pa=pars; a<totpart+totchild; a++, pa++){ + if(a<totpart){ + if(totchild && (part->draw&PART_DRAW_PARENT)==0) continue; + if(pa->flag & PARS_NO_DISP || pa->flag & PARS_UNEXIST) continue; + + pa_time=(cfra-pa->time)/pa->lifetime; + pa_size=pa->size; + + if((part->flag&PART_ABS_TIME)==0){ + if(ma && ma->ipo){ + IpoCurve *icu; + + /* correction for lifetime */ + calc_ipo(ma->ipo, 100.0f*pa_time); + + for(icu = ma->ipo->curve.first; icu; icu=icu->next) { + if(icu->adrcode == MA_COL_R) + ma_r = icu->curval; + else if(icu->adrcode == MA_COL_G) + ma_g = icu->curval; + else if(icu->adrcode == MA_COL_B) + ma_b = icu->curval; + } + } + if(part->ipo) { + IpoCurve *icu; + + /* correction for lifetime */ + calc_ipo(part->ipo, 100*pa_time); + + for(icu = part->ipo->curve.first; icu; icu=icu->next) { + if(icu->adrcode == PART_SIZE) + pa_size = icu->curval; + } + } + } + + r_tilt=1.0f+pa->r_ave[0]; + + if(path_nbr){ + cache=psys->pathcache[a]; + k_max=(int)(cache->steps); + } + } + else{ + ChildParticle *cpa= &psys->child[a-totpart]; + + pa_time=psys_get_child_time(psys,cpa,cfra); + + if((part->flag&PART_ABS_TIME)==0) { + if(ma && ma->ipo){ + IpoCurve *icu; + + /* correction for lifetime */ + calc_ipo(ma->ipo, 100.0f*pa_time); + + for(icu = ma->ipo->curve.first; icu; icu=icu->next) { + if(icu->adrcode == MA_COL_R) + ma_r = icu->curval; + else if(icu->adrcode == MA_COL_G) + ma_g = icu->curval; + else if(icu->adrcode == MA_COL_B) + ma_b = icu->curval; + } + } + } + + pa_size=psys_get_child_size(psys,cpa,cfra,0); + + r_tilt=2.0f*cpa->rand[2]; + if(path_nbr){ + cache=psys->childcache[a-totpart]; + k_max=(int)(cache->steps); + } + } + + if(draw_as!=PART_DRAW_PATH){ + int next_pa=0; + for(k=0; k<=path_nbr; k++){ + if(draw_keys){ + state.time=(float)k/(float)path_nbr; + psys_get_particle_on_path(ob,psys,a,&state,1); + } + else if(path_nbr){ + if(k<=k_max){ + VECCOPY(state.co,(cache+k)->co); + VECCOPY(state.vel,(cache+k)->vel); + QUATCOPY(state.rot,(cache+k)->rot); + } + else + continue; + } + else{ + state.time=cfra; + if(psys_get_particle_state(ob,psys,a,&state,0)==0){ + next_pa=1; + break; + } + } + + switch(draw_as){ + case PART_DRAW_DOT: + if(cd) { + cd[0]=ma_r; + cd[1]=ma_g; + cd[2]=ma_b; + cd+=3; + } + if(vd){ + VECCOPY(vd,state.co) vd+=3; + } + break; + case PART_DRAW_CROSS: + case PART_DRAW_AXIS: + vec[0]=2.0f*pixsize; + vec[1]=vec[2]=0.0; + QuatMulVecf(state.rot,vec); + if(draw_as==PART_DRAW_AXIS){ + cd[1]=cd[2]=cd[4]=cd[5]=0.0; + cd[0]=cd[3]=1.0; + cd[6]=cd[8]=cd[9]=cd[11]=0.0; + cd[7]=cd[10]=1.0; + cd[13]=cd[12]=cd[15]=cd[16]=0.0; + cd[14]=cd[17]=1.0; + cd+=18; + + VECCOPY(vec2,state.co); + } + else { + if(cd) { + cd[0]=cd[3]=cd[6]=cd[9]=cd[12]=cd[15]=ma_r; + cd[1]=cd[4]=cd[7]=cd[10]=cd[13]=cd[16]=ma_g; + cd[2]=cd[5]=cd[8]=cd[11]=cd[14]=cd[17]=ma_b; + cd+=18; + } + VECSUB(vec2,state.co,vec); + } + + VECADD(vec,state.co,vec); + VECCOPY(vd,vec); vd+=3; + VECCOPY(vd,vec2); vd+=3; + + vec[1]=2.0f*pixsize; + vec[0]=vec[2]=0.0; + QuatMulVecf(state.rot,vec); + if(draw_as==PART_DRAW_AXIS){ + VECCOPY(vec2,state.co); + } + else VECSUB(vec2,state.co,vec); + + VECADD(vec,state.co,vec); + VECCOPY(vd,vec); vd+=3; + VECCOPY(vd,vec2); vd+=3; + + vec[2]=2.0f*pixsize; + vec[0]=vec[1]=0.0; + QuatMulVecf(state.rot,vec); + if(draw_as==PART_DRAW_AXIS){ + VECCOPY(vec2,state.co); + } + else VECSUB(vec2,state.co,vec); + + VECADD(vec,state.co,vec); + + VECCOPY(vd,vec); vd+=3; + VECCOPY(vd,vec2); vd+=3; + break; + case PART_DRAW_LINE: + VECCOPY(vec,state.vel); + Normalize(vec); + if(part->draw & PART_DRAW_VEL_LENGTH) + VecMulf(vec,VecLength(state.vel)); + VECADDFAC(vd,state.co,vec,-part->draw_line[0]); vd+=3; + VECADDFAC(vd,state.co,vec,part->draw_line[1]); vd+=3; + if(cd) { + cd[0]=cd[3]=ma_r; + cd[1]=cd[4]=ma_g; + cd[2]=cd[5]=ma_b; + cd+=3; + } + break; + case PART_DRAW_CIRC: + if(create_cdata) + glColor3f(ma_r,ma_g,ma_b); + drawcircball(GL_LINE_LOOP, state.co, pixsize, imat); + break; + case PART_DRAW_BB: + if(cd) { + cd[0]=cd[3]=cd[6]=cd[9]=ma_r; + cd[1]=cd[4]=cd[7]=cd[10]=ma_g; + cd[2]=cd[5]=cd[8]=cd[11]=ma_b; + cd+=12; + } + if(part->draw&PART_DRAW_BB_LOCK && part->bb_align==PART_BB_VIEW){ + VECCOPY(xvec,bb_ob->obmat[0]); + Normalize(xvec); + VECCOPY(yvec,bb_ob->obmat[1]); + Normalize(yvec); + VECCOPY(zvec,bb_ob->obmat[2]); + Normalize(zvec); + } + else if(part->bb_align==PART_BB_VEL){ + float temp[3]; + VECCOPY(temp,state.vel); + Normalize(temp); + VECSUB(zvec,bb_ob->obmat[3],state.co); + if(part->draw&PART_DRAW_BB_LOCK){ + float fac=-Inpf(zvec,temp); + VECADDFAC(zvec,zvec,temp,fac); + } + Normalize(zvec); + Crossf(xvec,temp,zvec); + Normalize(xvec); + Crossf(yvec,zvec,xvec); + } + else{ + VECSUB(zvec,bb_ob->obmat[3],state.co); + if(part->draw&PART_DRAW_BB_LOCK) + zvec[part->bb_align]=0.0f; + Normalize(zvec); + + if(part->bb_align<PART_BB_VIEW) + Crossf(xvec,onevec,zvec); + else + Crossf(xvec,bb_ob->obmat[1],zvec); + Normalize(xvec); + Crossf(yvec,zvec,xvec); + } + + VECCOPY(vec,xvec); + VECCOPY(vec2,yvec); + + VecMulf(xvec,cos(part->bb_tilt*(1.0f-part->bb_rand_tilt*r_tilt)*(float)M_PI)); + VecMulf(vec2,sin(part->bb_tilt*(1.0f-part->bb_rand_tilt*r_tilt)*(float)M_PI)); + VECADD(xvec,xvec,vec2); + + VecMulf(yvec,cos(part->bb_tilt*(1.0f-part->bb_rand_tilt*r_tilt)*(float)M_PI)); + VecMulf(vec,-sin(part->bb_tilt*(1.0f-part->bb_rand_tilt*r_tilt)*(float)M_PI)); + VECADD(yvec,yvec,vec); + + VecMulf(xvec,pa_size); + VecMulf(yvec,pa_size); + + VECADDFAC(bb_center,state.co,xvec,part->bb_offset[0]); + VECADDFAC(bb_center,bb_center,yvec,part->bb_offset[1]); + + VECADD(vd,bb_center,xvec); + VECADD(vd,vd,yvec); vd+=3; + + VECSUB(vd,bb_center,xvec); + VECADD(vd,vd,yvec); vd+=3; + + VECSUB(vd,bb_center,xvec); + VECSUB(vd,vd,yvec); vd+=3; + + VECADD(vd,bb_center,xvec); + VECSUB(vd,vd,yvec); vd+=3; + + VECCOPY(nd, zvec); nd+=3; + VECCOPY(nd, zvec); nd+=3; + VECCOPY(nd, zvec); nd+=3; + VECCOPY(nd, zvec); nd+=3; + break; + } + + if(vedata){ + VECCOPY(ved,state.co); + ved+=3; + VECCOPY(vel,state.vel); + VecMulf(vel,timestep); + VECADD(ved,state.co,vel); + ved+=3; + } + + if(part->draw & PART_DRAW_SIZE){ + setlinestyle(3); + drawcircball(GL_LINE_LOOP, state.co, pa_size, imat); + setlinestyle(0); + } + + totpoint++; + } + if(next_pa) + continue; + if(part->draw&PART_DRAW_NUM && !(G.f & G_RENDER_SHADOW)){ + /* in path drawing state.co is the end point */ + glRasterPos3f(state.co[0], state.co[1], state.co[2]); + sprintf(val," %i",a); + BMF_DrawString(G.font, val); + } + } + } +/* 6. */ + + glGetIntegerv(GL_POLYGON_MODE, polygonmode); + glDisableClientState(GL_NORMAL_ARRAY); + + if(draw_as != PART_DRAW_CIRC){ + if(draw_as==PART_DRAW_PATH){ + ParticleCacheKey **cache, *path; + float *cd2=0,*cdata2=0; + + glEnableClientState(GL_VERTEX_ARRAY); + + if(dt > OB_WIRE) { + glEnableClientState(GL_NORMAL_ARRAY); + + if(part->draw&PART_DRAW_MAT_COL) + glEnableClientState(GL_COLOR_ARRAY); + + glEnable(GL_LIGHTING); + glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); + glEnable(GL_COLOR_MATERIAL); + } + else { + glDisableClientState(GL_NORMAL_ARRAY); + + glDisable(GL_COLOR_MATERIAL); + glDisable(GL_LIGHTING); + UI_ThemeColor(TH_WIRE); + } + + if(totchild && (part->draw&PART_DRAW_PARENT)==0) + totpart=0; + + cache=psys->pathcache; + for(a=0, pa=psys->particles; a<totpart; a++, pa++){ + path=cache[a]; + glVertexPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), path->co); + + if(dt > OB_WIRE) { + glNormalPointer(GL_FLOAT, sizeof(ParticleCacheKey), path->vel); + if(part->draw&PART_DRAW_MAT_COL) + glColorPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), path->col); + } + + glDrawArrays(GL_LINE_STRIP, 0, path->steps + 1); + } + + cache=psys->childcache; + for(a=0; a<totchild; a++){ + path=cache[a]; + glVertexPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), path->co); + + if(dt > OB_WIRE) { + glNormalPointer(GL_FLOAT, sizeof(ParticleCacheKey), path->vel); + if(part->draw&PART_DRAW_MAT_COL) + glColorPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), path->col); + } + + glDrawArrays(GL_LINE_STRIP, 0, path->steps + 1); + } + + if(dt > OB_WIRE) { + if(part->draw&PART_DRAW_MAT_COL) + glDisable(GL_COLOR_ARRAY); + glDisable(GL_COLOR_MATERIAL); + } + + if(cdata2) + MEM_freeN(cdata2); + cd2=cdata2=0; + + glLineWidth(1.0f); + + /* draw particle edit mode key points*/ + } + + if(draw_as!=PART_DRAW_PATH){ + glDisableClientState(GL_COLOR_ARRAY); + + if(vdata){ + glEnableClientState(GL_VERTEX_ARRAY); + glVertexPointer(3, GL_FLOAT, 0, vdata); + } + else + glDisableClientState(GL_VERTEX_ARRAY); + + if(ndata && dt>OB_WIRE){ + glEnableClientState(GL_NORMAL_ARRAY); + glNormalPointer(GL_FLOAT, 0, ndata); + glEnable(GL_LIGHTING); + } + else{ + glDisableClientState(GL_NORMAL_ARRAY); + glDisable(GL_LIGHTING); + } + + if(cdata){ + glEnableClientState(GL_COLOR_ARRAY); + glColorPointer(3, GL_FLOAT, 0, cdata); + } + + switch(draw_as){ + case PART_DRAW_AXIS: + case PART_DRAW_CROSS: + glDrawArrays(GL_LINES, 0, 6*totpoint); + break; + case PART_DRAW_LINE: + glDrawArrays(GL_LINES, 0, 2*totpoint); + break; + case PART_DRAW_BB: + if(dt<=OB_WIRE) + glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); + + glDrawArrays(GL_QUADS, 0, 4*totpoint); + break; + default: + glDrawArrays(GL_POINTS, 0, totpoint); + break; + } + } + + } + if(vedata){ + glDisableClientState(GL_COLOR_ARRAY); + cpack(0xC0C0C0); + + glEnableClientState(GL_VERTEX_ARRAY); + glVertexPointer(3, GL_FLOAT, 0, vedata); + + glDrawArrays(GL_LINES, 0, 2*totpoint); + } + + glPolygonMode(GL_FRONT, polygonmode[0]); + glPolygonMode(GL_BACK, polygonmode[1]); + } + +/* 7. */ + + glDisable(GL_LIGHTING); + glDisableClientState(GL_COLOR_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); + + if(states) + MEM_freeN(states); + if(vdata) + MEM_freeN(vdata); + if(vedata) + MEM_freeN(vedata); + if(cdata) + MEM_freeN(cdata); + if(ndata) + MEM_freeN(ndata); + + psys->flag &= ~PSYS_DRAWING; + + if(psys->lattice){ + end_latt_deform(); + psys->lattice=0; + } + + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + wmMultMatrix(CTX_wm_window(C), ob->obmat); // bring back local matrix for dtx +} + +static void draw_particle_edit(const bContext *C, Scene *scene, View3D *v3d, Object *ob, ParticleSystem *psys, int dt) +{ + ParticleEdit *edit = psys->edit; + ParticleData *pa; + ParticleCacheKey **path; + ParticleEditKey *key; + ParticleEditSettings *pset = NULL; // XXX PE_settings(); + int i, k, totpart = psys->totpart, totchild=0, timed = pset->draw_timed; + char nosel[4], sel[4]; + float sel_col[3]; + float nosel_col[3]; + char val[32]; + + /* create path and child path cache if it doesn't exist already */ + if(psys->pathcache==0){ +// XXX PE_hide_keys_time(psys,CFRA); + psys_cache_paths(ob,psys,CFRA,0); + } + if(psys->pathcache==0) + return; + + if(pset->flag & PE_SHOW_CHILD && psys->part->draw_as == PART_DRAW_PATH) { + if(psys->childcache==0) + psys_cache_child_paths(ob, psys, CFRA, 0); + } + else if(!(pset->flag & PE_SHOW_CHILD) && psys->childcache) + free_child_path_cache(psys); + + /* opengl setup */ + if((v3d->flag & V3D_ZBUF_SELECT)==0) + glDisable(GL_DEPTH_TEST); + + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + + /* get selection theme colors */ + UI_GetThemeColor3ubv(TH_VERTEX_SELECT, sel); + UI_GetThemeColor3ubv(TH_VERTEX, nosel); + sel_col[0]=(float)sel[0]/255.0f; + sel_col[1]=(float)sel[1]/255.0f; + sel_col[2]=(float)sel[2]/255.0f; + nosel_col[0]=(float)nosel[0]/255.0f; + nosel_col[1]=(float)nosel[1]/255.0f; + nosel_col[2]=(float)nosel[2]/255.0f; + + if(psys->childcache) + totchild = psys->totchildcache; + + /* draw paths */ + if(timed) + glEnable(GL_BLEND); + + glEnableClientState(GL_VERTEX_ARRAY); + + if(dt > OB_WIRE) { + /* solid shaded with lighting */ + glEnableClientState(GL_NORMAL_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + glEnable(GL_COLOR_MATERIAL); + glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); + } + else { + /* flat wire color */ + glDisableClientState(GL_NORMAL_ARRAY); + glDisable(GL_LIGHTING); + UI_ThemeColor(TH_WIRE); + } + + /* only draw child paths with lighting */ + if(dt > OB_WIRE) + glEnable(GL_LIGHTING); + + if(psys->part->draw_as == PART_DRAW_PATH) { + for(i=0, path=psys->childcache; i<totchild; i++,path++){ + glVertexPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), (*path)->co); + if(dt > OB_WIRE) { + glNormalPointer(GL_FLOAT, sizeof(ParticleCacheKey), (*path)->vel); + glColorPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), (*path)->col); + } + + glDrawArrays(GL_LINE_STRIP, 0, (int)(*path)->steps + 1); + } + } + + if(dt > OB_WIRE) + glDisable(GL_LIGHTING); + + if(pset->brushtype == PE_BRUSH_WEIGHT) { + glLineWidth(2.0f); + glEnableClientState(GL_COLOR_ARRAY); + glDisable(GL_LIGHTING); + } + + /* draw parents last without lighting */ + for(i=0, pa=psys->particles, path = psys->pathcache; i<totpart; i++, pa++, path++){ + glVertexPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), (*path)->co); + if(dt > OB_WIRE) + glNormalPointer(GL_FLOAT, sizeof(ParticleCacheKey), (*path)->vel); + if(dt > OB_WIRE || pset->brushtype == PE_BRUSH_WEIGHT) + glColorPointer(3, GL_FLOAT, sizeof(ParticleCacheKey), (*path)->col); + + glDrawArrays(GL_LINE_STRIP, 0, (int)(*path)->steps + 1); + } + + /* draw edit vertices */ + if(scene->selectmode!=SCE_SELECT_PATH){ + glDisableClientState(GL_NORMAL_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + glDisable(GL_LIGHTING); + glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE)); + + if(scene->selectmode==SCE_SELECT_POINT){ + float *cd=0,*cdata=0; + cd=cdata=MEM_callocN(edit->totkeys*(timed?4:3)*sizeof(float), "particle edit color data"); + + for(i=0, pa=psys->particles; i<totpart; i++, pa++){ + for(k=0, key=edit->keys[i]; k<pa->totkey; k++, key++){ + if(key->flag&PEK_SELECT){ + VECCOPY(cd,sel_col); + } + else{ + VECCOPY(cd,nosel_col); + } + if(timed) + *(cd+3) = (key->flag&PEK_HIDE)?0.0f:1.0f; + cd += (timed?4:3); + } + } + cd=cdata; + for(i=0, pa=psys->particles; i<totpart; i++, pa++){ + if((pa->flag & PARS_HIDE)==0){ + glVertexPointer(3, GL_FLOAT, sizeof(ParticleEditKey), edit->keys[i]->world_co); + glColorPointer((timed?4:3), GL_FLOAT, (timed?4:3)*sizeof(float), cd); + glDrawArrays(GL_POINTS, 0, pa->totkey); + } + cd += (timed?4:3) * pa->totkey; + + if((pset->flag&PE_SHOW_TIME) && (pa->flag&PARS_HIDE)==0 && !(G.f & G_RENDER_SHADOW)){ + for(k=0, key=edit->keys[i]+k; k<pa->totkey; k++, key++){ + if(key->flag & PEK_HIDE) continue; + + glRasterPos3fv(key->world_co); + sprintf(val," %.1f",*key->time); + BMF_DrawString(G.font, val); + } + } + } + if(cdata) + MEM_freeN(cdata); + cd=cdata=0; + } + else if(scene->selectmode == SCE_SELECT_END){ + for(i=0, pa=psys->particles; i<totpart; i++, pa++){ + if((pa->flag & PARS_HIDE)==0){ + key = edit->keys[i] + pa->totkey - 1; + if(key->flag & PEK_SELECT) + glColor3fv(sel_col); + else + glColor3fv(nosel_col); + /* has to be like this.. otherwise selection won't work, have try glArrayElement later..*/ + glBegin(GL_POINTS); + glVertex3fv(key->world_co); + glEnd(); + + if((pset->flag & PE_SHOW_TIME) && !(G.f & G_RENDER_SHADOW)){ + glRasterPos3fv(key->world_co); + sprintf(val," %.1f",*key->time); + BMF_DrawString(G.font, val); + } + } + } + } + } + + glDisable(GL_BLEND); + glDisable(GL_LIGHTING); + glDisable(GL_COLOR_MATERIAL); + glDisableClientState(GL_COLOR_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); + glEnable(GL_DEPTH_TEST); + glLineWidth(1.0f); + + wmMultMatrix(CTX_wm_window(C), ob->obmat); // bring back local matrix for dtx + glPointSize(1.0); +} + +unsigned int nurbcol[8]= { + 0, 0x9090, 0x409030, 0x603080, 0, 0x40fff0, 0x40c033, 0xA090F0 }; + +static void tekenhandlesN(Nurb *nu, short sel) +{ + BezTriple *bezt; + float *fp; + unsigned int *col; + int a; + + if(nu->hide || (G.f & G_HIDDENHANDLES)) return; + + glBegin(GL_LINES); + + if( (nu->type & 7)==1) { + if(sel) col= nurbcol+4; + else col= nurbcol; + + bezt= nu->bezt; + a= nu->pntsu; + while(a--) { + if(bezt->hide==0) { + if( (bezt->f2 & SELECT)==sel) { + fp= bezt->vec[0]; + + cpack(col[bezt->h1]); + glVertex3fv(fp); + glVertex3fv(fp+3); + + cpack(col[bezt->h2]); + glVertex3fv(fp+3); + glVertex3fv(fp+6); + } + else if( (bezt->f1 & SELECT)==sel) { + fp= bezt->vec[0]; + + cpack(col[bezt->h1]); + glVertex3fv(fp); + glVertex3fv(fp+3); + } + else if( (bezt->f3 & SELECT)==sel) { + fp= bezt->vec[1]; + + cpack(col[bezt->h2]); + glVertex3fv(fp); + glVertex3fv(fp+3); + } + } + bezt++; + } + } + glEnd(); +} + +static void tekenvertsN(Nurb *nu, short sel) +{ + BezTriple *bezt; + BPoint *bp; + float size; + int a; + + if(nu->hide) return; + + if(sel) UI_ThemeColor(TH_VERTEX_SELECT); + else UI_ThemeColor(TH_VERTEX); + + size= UI_GetThemeValuef(TH_VERTEX_SIZE); + glPointSize(size); + + bglBegin(GL_POINTS); + + if((nu->type & 7)==1) { + + bezt= nu->bezt; + a= nu->pntsu; + while(a--) { + if(bezt->hide==0) { + if (G.f & G_HIDDENHANDLES) { + if((bezt->f2 & SELECT)==sel) bglVertex3fv(bezt->vec[1]); + } else { + if((bezt->f1 & SELECT)==sel) bglVertex3fv(bezt->vec[0]); + if((bezt->f2 & SELECT)==sel) bglVertex3fv(bezt->vec[1]); + if((bezt->f3 & SELECT)==sel) bglVertex3fv(bezt->vec[2]); + } + } + bezt++; + } + } + else { + bp= nu->bp; + a= nu->pntsu*nu->pntsv; + while(a--) { + if(bp->hide==0) { + if((bp->f1 & SELECT)==sel) bglVertex3fv(bp->vec); + } + bp++; + } + } + + bglEnd(); + glPointSize(1.0); +} + +static void draw_editnurb(Object *ob, Nurb *nurb, int sel) +{ + Nurb *nu; + BPoint *bp, *bp1; + int a, b, ofs; + + nu= nurb; + while(nu) { + if(nu->hide==0) { + switch(nu->type & 7) { + case CU_POLY: + cpack(nurbcol[3]); + bp= nu->bp; + for(b=0; b<nu->pntsv; b++) { + if(nu->flagu & 1) glBegin(GL_LINE_LOOP); + else glBegin(GL_LINE_STRIP); + + for(a=0; a<nu->pntsu; a++, bp++) { + glVertex3fv(bp->vec); + } + + glEnd(); + } + break; + case CU_NURBS: + + bp= nu->bp; + for(b=0; b<nu->pntsv; b++) { + bp1= bp; + bp++; + for(a=nu->pntsu-1; a>0; a--, bp++) { + if(bp->hide==0 && bp1->hide==0) { + if(sel) { + if( (bp->f1 & SELECT) && ( bp1->f1 & SELECT ) ) { + cpack(nurbcol[5]); + + glBegin(GL_LINE_STRIP); + glVertex3fv(bp->vec); + glVertex3fv(bp1->vec); + glEnd(); + } + } + else { + if( (bp->f1 & SELECT) && ( bp1->f1 & SELECT) ); + else { + cpack(nurbcol[1]); + + glBegin(GL_LINE_STRIP); + glVertex3fv(bp->vec); + glVertex3fv(bp1->vec); + glEnd(); + } + } + } + bp1= bp; + } + } + if(nu->pntsv > 1) { /* surface */ + + ofs= nu->pntsu; + for(b=0; b<nu->pntsu; b++) { + bp1= nu->bp+b; + bp= bp1+ofs; + for(a=nu->pntsv-1; a>0; a--, bp+=ofs) { + if(bp->hide==0 && bp1->hide==0) { + if(sel) { + if( (bp->f1 & SELECT) && ( bp1->f1 & SELECT) ) { + cpack(nurbcol[7]); + + glBegin(GL_LINE_STRIP); + glVertex3fv(bp->vec); + glVertex3fv(bp1->vec); + glEnd(); + } + } + else { + if( (bp->f1 & SELECT) && ( bp1->f1 & SELECT) ); + else { + cpack(nurbcol[3]); + + glBegin(GL_LINE_STRIP); + glVertex3fv(bp->vec); + glVertex3fv(bp1->vec); + glEnd(); + } + } + } + bp1= bp; + } + } + + } + break; + } + } + nu= nu->next; + } +} + +static void drawnurb(Scene *scene, View3D *v3d, Base *base, Nurb *nurb, int dt) +{ + Object *ob= base->object; + Curve *cu = ob->data; + Nurb *nu; + BevList *bl; + +// XXX retopo_matrix_update(v3d); + + /* DispList */ + UI_ThemeColor(TH_WIRE); + drawDispList(scene, v3d, base, dt); + + if(v3d->zbuf) glDisable(GL_DEPTH_TEST); + + /* first non-selected handles */ + for(nu=nurb; nu; nu=nu->next) { + if((nu->type & 7)==CU_BEZIER) { + tekenhandlesN(nu, 0); + } + } + draw_editnurb(ob, nurb, 0); + draw_editnurb(ob, nurb, 1); + /* selected handles */ + for(nu=nurb; nu; nu=nu->next) { + if((nu->type & 7)==1) tekenhandlesN(nu, 1); + tekenvertsN(nu, 0); + } + + if(v3d->zbuf) glEnable(GL_DEPTH_TEST); + + /* direction vectors for 3d curve paths + when at its lowest, dont render normals */ + if(cu->flag & CU_3D && scene->editbutsize > 0.0015) { + UI_ThemeColor(TH_WIRE); + for (bl=cu->bev.first,nu=nurb; nu && bl; bl=bl->next,nu=nu->next) { + BevPoint *bevp= (BevPoint *)(bl+1); + int nr= bl->nr; + int skip= nu->resolu/16; + + while (nr-->0) { /* accounts for empty bevel lists */ + float fac= bevp->radius * scene->editbutsize; + float ox,oy,oz; // Offset perpendicular to the curve + float dx,dy,dz; // Delta along the curve + + ox = fac*bevp->mat[0][0]; + oy = fac*bevp->mat[0][1]; + oz = fac*bevp->mat[0][2]; + + dx = fac*bevp->mat[2][0]; + dy = fac*bevp->mat[2][1]; + dz = fac*bevp->mat[2][2]; + + glBegin(GL_LINE_STRIP); + glVertex3f(bevp->x - ox - dx, bevp->y - oy - dy, bevp->z - oz - dz); + glVertex3f(bevp->x, bevp->y, bevp->z); + glVertex3f(bevp->x + ox - dx, bevp->y + oy - dy, bevp->z + oz - dz); + glEnd(); + + bevp += skip+1; + nr -= skip; + } + } + } + + if(v3d->zbuf) glDisable(GL_DEPTH_TEST); + + for(nu=nurb; nu; nu=nu->next) { + tekenvertsN(nu, 1); + } + + if(v3d->zbuf) glEnable(GL_DEPTH_TEST); +} + +/* draw a sphere for use as an empty drawtype */ +static void draw_empty_sphere (float size) +{ + float cent=0; + GLUquadricObj *qobj = gluNewQuadric(); + gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); + + glPushMatrix(); + glTranslatef(cent, cent, cent); + glScalef(size, size, size); + gluSphere(qobj, 1.0, 8, 5); + + glPopMatrix(); + + gluDeleteQuadric(qobj); +} + +/* draw a cone for use as an empty drawtype */ +static void draw_empty_cone (float size) +{ + float cent=0; + float radius; + GLUquadricObj *qobj = gluNewQuadric(); + gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); + + + glPushMatrix(); + + radius = size; + glTranslatef(cent,cent, cent); + glScalef(radius, 2.0*size, radius); + glRotatef(-90., 1.0, 0.0, 0.0); + gluCylinder(qobj, 1.0, 0.0, 1.0, 8, 1); + + glPopMatrix(); + + gluDeleteQuadric(qobj); +} + +/* draw points on curve speed handles */ +static void curve_draw_speed(Scene *scene, Object *ob) +{ + Curve *cu= ob->data; + IpoCurve *icu; + BezTriple *bezt; + float loc[4], dir[3]; + int a; + + if(cu->ipo==NULL) + return; + + icu= cu->ipo->curve.first; + if(icu==NULL || icu->totvert<2) + return; + + glPointSize( UI_GetThemeValuef(TH_VERTEX_SIZE) ); + bglBegin(GL_POINTS); + + for(a=0, bezt= icu->bezt; a<icu->totvert; a++, bezt++) { + if( where_on_path(ob, bezt->vec[1][1], loc, dir)) { + UI_ThemeColor((bezt->f2 & SELECT) && ob==OBACT?TH_VERTEX_SELECT:TH_VERTEX); + bglVertex3fv(loc); + } + } + + glPointSize(1.0); + bglEnd(); +} + + +static void tekentextcurs(void) +{ + cpack(0); + + set_inverted_drawing(1); + glBegin(GL_QUADS); + glVertex2fv(G.textcurs[0]); + glVertex2fv(G.textcurs[1]); + glVertex2fv(G.textcurs[2]); + glVertex2fv(G.textcurs[3]); + glEnd(); + set_inverted_drawing(0); +} + +static void drawspiral(float *cent, float rad, float tmat[][4], int start) +{ + float vec[3], vx[3], vy[3]; + int a, tot=32; + char inverse=0; + + if (start < 0) { + inverse = 1; + start *= -1; + } + + VECCOPY(vx, tmat[0]); + VECCOPY(vy, tmat[1]); + VecMulf(vx, rad); + VecMulf(vy, rad); + + VECCOPY(vec, cent); + + if (inverse==0) { + for(a=0; a<tot; a++) { + if (a+start>31) + start=-a + 1; + glBegin(GL_LINES); + glVertex3fv(vec); + vec[0]= cent[0] + *(sinval+a+start) * (vx[0] * (float)a/(float)tot) + *(cosval+a+start) * (vy[0] * (float)a/(float)tot); + vec[1]= cent[1] + *(sinval+a+start) * (vx[1] * (float)a/(float)tot) + *(cosval+a+start) * (vy[1] * (float)a/(float)tot); + vec[2]= cent[2] + *(sinval+a+start) * (vx[2] * (float)a/(float)tot) + *(cosval+a+start) * (vy[2] * (float)a/(float)tot); + glVertex3fv(vec); + glEnd(); + } + } + else { + a=0; + vec[0]= cent[0] + *(sinval+a+start) * (vx[0] * (float)(-a+31)/(float)tot) + *(cosval+a+start) * (vy[0] * (float)(-a+31)/(float)tot); + vec[1]= cent[1] + *(sinval+a+start) * (vx[1] * (float)(-a+31)/(float)tot) + *(cosval+a+start) * (vy[1] * (float)(-a+31)/(float)tot); + vec[2]= cent[2] + *(sinval+a+start) * (vx[2] * (float)(-a+31)/(float)tot) + *(cosval+a+start) * (vy[2] * (float)(-a+31)/(float)tot); + for(a=0; a<tot; a++) { + if (a+start>31) + start=-a + 1; + glBegin(GL_LINES); + glVertex3fv(vec); + vec[0]= cent[0] + *(sinval+a+start) * (vx[0] * (float)(-a+31)/(float)tot) + *(cosval+a+start) * (vy[0] * (float)(-a+31)/(float)tot); + vec[1]= cent[1] + *(sinval+a+start) * (vx[1] * (float)(-a+31)/(float)tot) + *(cosval+a+start) * (vy[1] * (float)(-a+31)/(float)tot); + vec[2]= cent[2] + *(sinval+a+start) * (vx[2] * (float)(-a+31)/(float)tot) + *(cosval+a+start) * (vy[2] * (float)(-a+31)/(float)tot); + glVertex3fv(vec); + glEnd(); + } + } +} + +/* draws a circle on x-z plane given the scaling of the circle, assuming that + * all required matrices have been set (used for drawing empties) + */ +static void drawcircle_size(float size) +{ + float x, y; + short degrees; + + glBegin(GL_LINE_LOOP); + + /* coordinates are: cos(degrees*11.25)=x, sin(degrees*11.25)=y, 0.0f=z */ + for (degrees=0; degrees<32; degrees++) { + x= *(cosval + degrees); + y= *(sinval + degrees); + + glVertex3f(x*size, 0.0f, y*size); + } + + glEnd(); + +} + +/* needs fixing if non-identity matrice used */ +static void drawtube(float *vec, float radius, float height, float tmat[][4]) +{ + float cur[3]; + drawcircball(GL_LINE_LOOP, vec, radius, tmat); + + VecCopyf(cur,vec); + cur[2]+=height; + + drawcircball(GL_LINE_LOOP, cur, radius, tmat); + + glBegin(GL_LINES); + glVertex3f(vec[0]+radius,vec[1],vec[2]); + glVertex3f(cur[0]+radius,cur[1],cur[2]); + glVertex3f(vec[0]-radius,vec[1],vec[2]); + glVertex3f(cur[0]-radius,cur[1],cur[2]); + glVertex3f(vec[0],vec[1]+radius,vec[2]); + glVertex3f(cur[0],cur[1]+radius,cur[2]); + glVertex3f(vec[0],vec[1]-radius,vec[2]); + glVertex3f(cur[0],cur[1]-radius,cur[2]); + glEnd(); +} +/* needs fixing if non-identity matrice used */ +static void drawcone(float *vec, float radius, float height, float tmat[][4]) +{ + float cur[3]; + + VecCopyf(cur,vec); + cur[2]+=height; + + drawcircball(GL_LINE_LOOP, cur, radius, tmat); + + glBegin(GL_LINES); + glVertex3f(vec[0],vec[1],vec[2]); + glVertex3f(cur[0]+radius,cur[1],cur[2]); + glVertex3f(vec[0],vec[1],vec[2]); + glVertex3f(cur[0]-radius,cur[1],cur[2]); + glVertex3f(vec[0],vec[1],vec[2]); + glVertex3f(cur[0],cur[1]+radius,cur[2]); + glVertex3f(vec[0],vec[1],vec[2]); + glVertex3f(cur[0],cur[1]-radius,cur[2]); + glEnd(); +} +/* return 1 if nothing was drawn */ +static int drawmball(const bContext *C, Scene *scene, View3D *v3d, Base *base, int dt) +{ + Object *ob= base->object; + MetaBall *mb; + MetaElem *ml; + float imat[4][4], tmat[4][4]; + int code= 1; + + mb= ob->data; + + if(ob==G.obedit) { + UI_ThemeColor(TH_WIRE); + if((G.f & G_PICKSEL)==0 ) drawDispList(scene, v3d, base, dt); + ml= editelems.first; + } + else { + if((base->flag & OB_FROMDUPLI)==0) + drawDispList(scene, v3d, base, dt); + ml= mb->elems.first; + } + + if(ml==NULL) return 1; + + /* in case solid draw, reset wire colors */ + if(ob!=G.obedit && (ob->flag & SELECT)) { + if(ob==OBACT) UI_ThemeColor(TH_ACTIVE); + else UI_ThemeColor(TH_SELECT); + } + else UI_ThemeColor(TH_WIRE); + + wmGetMatrix(CTX_wm_window(C), tmat); + Mat4Invert(imat, tmat); + Normalize(imat[0]); + Normalize(imat[1]); + + while(ml) { + + /* draw radius */ + if(ob==G.obedit) { + if((ml->flag & SELECT) && (ml->flag & MB_SCALE_RAD)) cpack(0xA0A0F0); + else cpack(0x3030A0); + + if(G.f & G_PICKSEL) { + ml->selcol1= code; + glLoadName(code++); + } + } + drawcircball(GL_LINE_LOOP, &(ml->x), ml->rad, imat); + + /* draw stiffness */ + if(ob==G.obedit) { + if((ml->flag & SELECT) && !(ml->flag & MB_SCALE_RAD)) cpack(0xA0F0A0); + else cpack(0x30A030); + + if(G.f & G_PICKSEL) { + ml->selcol2= code; + glLoadName(code++); + } + drawcircball(GL_LINE_LOOP, &(ml->x), ml->rad*atan(ml->s)/M_PI_2, imat); + } + + ml= ml->next; + } + return 0; +} + +static void draw_forcefield(const bContext *C, Scene *scene, Object *ob) +{ + PartDeflect *pd= ob->pd; + float imat[4][4], tmat[4][4]; + float vec[3]= {0.0, 0.0, 0.0}; + int curcol; + float size; + + if(G.f & G_RENDER_SHADOW) + return; + + if(ob!=G.obedit && (ob->flag & SELECT)) { + if(ob==OBACT) curcol= TH_ACTIVE; + else curcol= TH_SELECT; + } + else curcol= TH_WIRE; + + /* scale size of circle etc with the empty drawsize */ + if (ob->type == OB_EMPTY) size = ob->empty_drawsize; + else size = 1.0; + + /* calculus here, is reused in PFIELD_FORCE */ + wmGetMatrix(CTX_wm_window(C), tmat); + Mat4Invert(imat, tmat); +// Normalize(imat[0]); // we don't do this because field doesnt scale either... apart from wind! +// Normalize(imat[1]); + + if (pd->forcefield == PFIELD_WIND) { + float force_val; + + Mat4One(tmat); + UI_ThemeColorBlend(curcol, TH_BACK, 0.5); + + if (has_ipo_code(ob->ipo, OB_PD_FSTR)) + force_val = IPO_GetFloatValue(ob->ipo, OB_PD_FSTR, scene->r.cfra); + else + force_val = pd->f_strength; + force_val*= 0.1; + drawcircball(GL_LINE_LOOP, vec, size, tmat); + vec[2]= 0.5*force_val; + drawcircball(GL_LINE_LOOP, vec, size, tmat); + vec[2]= 1.0*force_val; + drawcircball(GL_LINE_LOOP, vec, size, tmat); + vec[2]= 1.5*force_val; + drawcircball(GL_LINE_LOOP, vec, size, tmat); + vec[2] = 0; /* reset vec for max dist circle */ + + } + else if (pd->forcefield == PFIELD_FORCE) { + float ffall_val; + + if (has_ipo_code(ob->ipo, OB_PD_FFALL)) + ffall_val = IPO_GetFloatValue(ob->ipo, OB_PD_FFALL, scene->r.cfra); + else + ffall_val = pd->f_power; + + UI_ThemeColorBlend(curcol, TH_BACK, 0.5); + drawcircball(GL_LINE_LOOP, vec, size, imat); + UI_ThemeColorBlend(curcol, TH_BACK, 0.9 - 0.4 / pow(1.5, (double)ffall_val)); + drawcircball(GL_LINE_LOOP, vec, size*1.5, imat); + UI_ThemeColorBlend(curcol, TH_BACK, 0.9 - 0.4 / pow(2.0, (double)ffall_val)); + drawcircball(GL_LINE_LOOP, vec, size*2.0, imat); + } + else if (pd->forcefield == PFIELD_VORTEX) { + float ffall_val, force_val; + + Mat4One(tmat); + if (has_ipo_code(ob->ipo, OB_PD_FFALL)) + ffall_val = IPO_GetFloatValue(ob->ipo, OB_PD_FFALL, scene->r.cfra); + else + ffall_val = pd->f_power; + + if (has_ipo_code(ob->ipo, OB_PD_FSTR)) + force_val = IPO_GetFloatValue(ob->ipo, OB_PD_FSTR, scene->r.cfra); + else + force_val = pd->f_strength; + + UI_ThemeColorBlend(curcol, TH_BACK, 0.7); + if (force_val < 0) { + drawspiral(vec, size*1.0, tmat, 1); + drawspiral(vec, size*1.0, tmat, 16); + } + else { + drawspiral(vec, size*1.0, tmat, -1); + drawspiral(vec, size*1.0, tmat, -16); + } + } + else if (pd->forcefield == PFIELD_GUIDE && ob->type==OB_CURVE) { + Curve *cu= ob->data; + if((cu->flag & CU_PATH) && cu->path && cu->path->data) { + float mindist, guidevec1[4], guidevec2[3]; + + if (has_ipo_code(ob->ipo, OB_PD_FSTR)) + mindist = IPO_GetFloatValue(ob->ipo, OB_PD_FSTR, scene->r.cfra); + else + mindist = pd->f_strength; + + /*path end*/ + setlinestyle(3); + where_on_path(ob, 1.0f, guidevec1, guidevec2); + UI_ThemeColorBlend(curcol, TH_BACK, 0.5); + drawcircball(GL_LINE_LOOP, guidevec1, mindist, imat); + + /*path beginning*/ + setlinestyle(0); + where_on_path(ob, 0.0f, guidevec1, guidevec2); + UI_ThemeColorBlend(curcol, TH_BACK, 0.5); + drawcircball(GL_LINE_LOOP, guidevec1, mindist, imat); + + VECCOPY(vec, guidevec1); /* max center */ + } + } + + setlinestyle(3); + UI_ThemeColorBlend(curcol, TH_BACK, 0.5); + + if(pd->falloff==PFIELD_FALL_SPHERE){ + /* as last, guide curve alters it */ + if(pd->flag & PFIELD_USEMAX) + drawcircball(GL_LINE_LOOP, vec, pd->maxdist, imat); + + if(pd->flag & PFIELD_USEMIN) + drawcircball(GL_LINE_LOOP, vec, pd->mindist, imat); + } + else if(pd->falloff==PFIELD_FALL_TUBE){ + float radius,distance; + + Mat4One(tmat); + + vec[0]=vec[1]=0.0f; + radius=(pd->flag&PFIELD_USEMAXR)?pd->maxrad:1.0f; + distance=(pd->flag&PFIELD_USEMAX)?pd->maxdist:0.0f; + vec[2]=distance; + distance=(pd->flag&PFIELD_POSZ)?-distance:-2.0f*distance; + + if(pd->flag & (PFIELD_USEMAX|PFIELD_USEMAXR)) + drawtube(vec,radius,distance,tmat); + + radius=(pd->flag&PFIELD_USEMINR)?pd->minrad:1.0f; + distance=(pd->flag&PFIELD_USEMIN)?pd->mindist:0.0f; + vec[2]=distance; + distance=(pd->flag&PFIELD_POSZ)?-distance:-2.0f*distance; + + if(pd->flag & (PFIELD_USEMIN|PFIELD_USEMINR)) + drawtube(vec,radius,distance,tmat); + } + else if(pd->falloff==PFIELD_FALL_CONE){ + float radius,distance; + + Mat4One(tmat); + + radius=(pd->flag&PFIELD_USEMAXR)?pd->maxrad:1.0f; + radius*=(float)M_PI/180.0f; + distance=(pd->flag&PFIELD_USEMAX)?pd->maxdist:0.0f; + + if(pd->flag & (PFIELD_USEMAX|PFIELD_USEMAXR)){ + drawcone(vec,distance*sin(radius),distance*cos(radius),tmat); + if((pd->flag & PFIELD_POSZ)==0) + drawcone(vec,distance*sin(radius),-distance*cos(radius),tmat); + } + + radius=(pd->flag&PFIELD_USEMINR)?pd->minrad:1.0f; + radius*=(float)M_PI/180.0f; + distance=(pd->flag&PFIELD_USEMIN)?pd->mindist:0.0f; + + if(pd->flag & (PFIELD_USEMIN|PFIELD_USEMINR)){ + drawcone(vec,distance*sin(radius),distance*cos(radius),tmat); + if((pd->flag & PFIELD_POSZ)==0) + drawcone(vec,distance*sin(radius),-distance*cos(radius),tmat); + } + } + setlinestyle(0); +} + +static void draw_box(float vec[8][3]) +{ + glBegin(GL_LINE_STRIP); + glVertex3fv(vec[0]); glVertex3fv(vec[1]);glVertex3fv(vec[2]); glVertex3fv(vec[3]); + glVertex3fv(vec[0]); glVertex3fv(vec[4]);glVertex3fv(vec[5]); glVertex3fv(vec[6]); + glVertex3fv(vec[7]); glVertex3fv(vec[4]); + glEnd(); + + glBegin(GL_LINES); + glVertex3fv(vec[1]); glVertex3fv(vec[5]); + glVertex3fv(vec[2]); glVertex3fv(vec[6]); + glVertex3fv(vec[3]); glVertex3fv(vec[7]); + glEnd(); +} + +/* uses boundbox, function used by Ketsji */ +void get_local_bounds(Object *ob, float *center, float *size) +{ + BoundBox *bb= object_get_boundbox(ob); + + if(bb==NULL) { + center[0]= center[1]= center[2]= 0.0; + VECCOPY(size, ob->size); + } + else { + size[0]= 0.5*fabs(bb->vec[0][0] - bb->vec[4][0]); + size[1]= 0.5*fabs(bb->vec[0][1] - bb->vec[2][1]); + size[2]= 0.5*fabs(bb->vec[0][2] - bb->vec[1][2]); + + center[0]= (bb->vec[0][0] + bb->vec[4][0])/2.0; + center[1]= (bb->vec[0][1] + bb->vec[2][1])/2.0; + center[2]= (bb->vec[0][2] + bb->vec[1][2])/2.0; + } +} + + + +static void draw_bb_quadric(BoundBox *bb, short type) +{ + float size[3], cent[3]; + GLUquadricObj *qobj = gluNewQuadric(); + + gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); + + size[0]= 0.5*fabs(bb->vec[0][0] - bb->vec[4][0]); + size[1]= 0.5*fabs(bb->vec[0][1] - bb->vec[2][1]); + size[2]= 0.5*fabs(bb->vec[0][2] - bb->vec[1][2]); + + cent[0]= (bb->vec[0][0] + bb->vec[4][0])/2.0; + cent[1]= (bb->vec[0][1] + bb->vec[2][1])/2.0; + cent[2]= (bb->vec[0][2] + bb->vec[1][2])/2.0; + + glPushMatrix(); + if(type==OB_BOUND_SPHERE) { + glTranslatef(cent[0], cent[1], cent[2]); + glScalef(size[0], size[1], size[2]); + gluSphere(qobj, 1.0, 8, 5); + } + else if(type==OB_BOUND_CYLINDER) { + float radius = size[0] > size[1] ? size[0] : size[1]; + glTranslatef(cent[0], cent[1], cent[2]-size[2]); + glScalef(radius, radius, 2.0*size[2]); + gluCylinder(qobj, 1.0, 1.0, 1.0, 8, 1); + } + else if(type==OB_BOUND_CONE) { + float radius = size[0] > size[1] ? size[0] : size[1]; + glTranslatef(cent[0], cent[2]-size[2], cent[1]); + glScalef(radius, 2.0*size[2], radius); + glRotatef(-90., 1.0, 0.0, 0.0); + gluCylinder(qobj, 1.0, 0.0, 1.0, 8, 1); + } + glPopMatrix(); + + gluDeleteQuadric(qobj); +} + +static void draw_bounding_volume(Object *ob) +{ + BoundBox *bb=0; + + if(ob->type==OB_MESH) { + bb= mesh_get_bb(ob); + } + else if ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT) { + bb= ( (Curve *)ob->data )->bb; + } + else if(ob->type==OB_MBALL) { + bb= ob->bb; + if(bb==0) { + makeDispListMBall(ob); + bb= ob->bb; + } + } + else { + drawcube(); + return; + } + + if(bb==0) return; + + if(ob->boundtype==OB_BOUND_BOX) draw_box(bb->vec); + else draw_bb_quadric(bb, ob->boundtype); + +} + +static void drawtexspace(Object *ob) +{ + float vec[8][3], loc[3], size[3]; + + if(ob->type==OB_MESH) { + mesh_get_texspace(ob->data, loc, NULL, size); + } + else if ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT) { + Curve *cu= ob->data; + VECCOPY(size, cu->size); + VECCOPY(loc, cu->loc); + } + else if(ob->type==OB_MBALL) { + MetaBall *mb= ob->data; + VECCOPY(size, mb->size); + VECCOPY(loc, mb->loc); + } + else return; + + vec[0][0]=vec[1][0]=vec[2][0]=vec[3][0]= loc[0]-size[0]; + vec[4][0]=vec[5][0]=vec[6][0]=vec[7][0]= loc[0]+size[0]; + + vec[0][1]=vec[1][1]=vec[4][1]=vec[5][1]= loc[1]-size[1]; + vec[2][1]=vec[3][1]=vec[6][1]=vec[7][1]= loc[1]+size[1]; + + vec[0][2]=vec[3][2]=vec[4][2]=vec[7][2]= loc[2]-size[2]; + vec[1][2]=vec[2][2]=vec[5][2]=vec[6][2]= loc[2]+size[2]; + + setlinestyle(2); + + draw_box(vec); + + setlinestyle(0); +} + +/* draws wire outline */ +static void drawSolidSelect(View3D *v3d, Base *base) +{ + Object *ob= base->object; + + glLineWidth(2.0); + glDepthMask(0); + + if(ELEM3(ob->type, OB_FONT,OB_CURVE, OB_SURF)) { + Curve *cu = ob->data; + if (displist_has_faces(&cu->disp) && boundbox_clip(v3d, ob->obmat, cu->bb)) { + draw_index_wire= 0; + drawDispListwire(&cu->disp); + draw_index_wire= 1; + } + } else if (ob->type==OB_MBALL) { + if((base->flag & OB_FROMDUPLI)==0) + drawDispListwire(&ob->disp); + } + else if(ob->type==OB_ARMATURE) { + if(!(ob->flag & OB_POSEMODE)) + draw_armature(base, OB_WIRE, 0); + } + + glLineWidth(1.0); + glDepthMask(1); +} + +static void drawWireExtra(Scene *scene, View3D *v3d, Object *ob) +{ + if(ob!=G.obedit && (ob->flag & SELECT)) { + if(ob==OBACT) { + if(ob->flag & OB_FROMGROUP) UI_ThemeColor(TH_GROUP_ACTIVE); + else UI_ThemeColor(TH_ACTIVE); + } + else if(ob->flag & OB_FROMGROUP) + UI_ThemeColorShade(TH_GROUP_ACTIVE, -16); + else + UI_ThemeColor(TH_SELECT); + } + else { + if(ob->flag & OB_FROMGROUP) + UI_ThemeColor(TH_GROUP); + else { + if(ob->dtx & OB_DRAWWIRE) { + glColor3ub(80,80,80); + } else { + UI_ThemeColor(TH_WIRE); + } + } + } + + bglPolygonOffset(1.0); + glDepthMask(0); // disable write in zbuffer, selected edge wires show better + + if (ELEM3(ob->type, OB_FONT, OB_CURVE, OB_SURF)) { + Curve *cu = ob->data; + if (boundbox_clip(v3d, ob->obmat, cu->bb)) { + if (ob->type==OB_CURVE) + draw_index_wire= 0; + drawDispListwire(&cu->disp); + if (ob->type==OB_CURVE) + draw_index_wire= 1; + } + } else if (ob->type==OB_MBALL) { + drawDispListwire(&ob->disp); + } + + glDepthMask(1); + bglPolygonOffset(0.0); +} + +/* should be called in view space */ +static void draw_hooks(Object *ob) +{ + ModifierData *md; + float vec[3]; + + for (md=ob->modifiers.first; md; md=md->next) { + if (md->type==eModifierType_Hook) { + HookModifierData *hmd = (HookModifierData*) md; + + VecMat4MulVecfl(vec, ob->obmat, hmd->cent); + + if(hmd->object) { + setlinestyle(3); + glBegin(GL_LINES); + glVertex3fv(hmd->object->obmat[3]); + glVertex3fv(vec); + glEnd(); + setlinestyle(0); + } + + glPointSize(3.0); + bglBegin(GL_POINTS); + bglVertex3fv(vec); + bglEnd(); + glPointSize(1.0); + } + } +} + +//<rcruiz> +void drawRBpivot(bRigidBodyJointConstraint *data) +{ + float radsPerDeg = 6.283185307179586232f / 360.f; + int axis; + float v1[3]= {data->pivX, data->pivY, data->pivZ}; + float eu[3]= {radsPerDeg*data->axX, radsPerDeg*data->axY, radsPerDeg*data->axZ}; + float mat[4][4]; + + if(G.f & G_RENDER_SHADOW) + return; + + EulToMat4(eu,mat); + glLineWidth (4.0f); + setlinestyle(2); + for (axis=0; axis<3; axis++) { + float dir[3] = {0,0,0}; + float v[3]= {data->pivX, data->pivY, data->pivZ}; + + dir[axis] = 1.f; + glBegin(GL_LINES); + Mat4MulVecfl(mat,dir); + v[0] += dir[0]; + v[1] += dir[1]; + v[2] += dir[2]; + glVertex3fv(v1); + glVertex3fv(v); + glEnd(); + glRasterPos3fv(v); + if (axis==0) + BMF_DrawString(G.font, "px"); + else if (axis==1) + BMF_DrawString(G.font, "py"); + else + BMF_DrawString(G.font, "pz"); + } + glLineWidth (1.0f); + setlinestyle(0); +} + +/* flag can be DRAW_PICKING and/or DRAW_CONSTCOLOR, DRAW_SCENESET */ +void draw_object(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag) +{ + static int warning_recursive= 0; + Object *ob; + Curve *cu; + float cfraont; + float vec1[3], vec2[3]; + unsigned int col=0; + int sel, drawtype, colindex= 0, ipoflag; + int i, selstart, selend, empty_object=0; + short dt, dtx, zbufoff= 0; + + /* only once set now, will be removed too, should become a global standard */ + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + ob= base->object; + + if (ob!=G.obedit) { + if (ob->restrictflag & OB_RESTRICT_VIEW) + return; + } + + /* xray delay? */ + if((flag & DRAW_PICKING)==0 && (base->flag & OB_FROMDUPLI)==0) { + /* don't do xray in particle mode, need the z-buffer */ + if(!(G.f & G_PARTICLEEDIT)) { + /* xray and transp are set when it is drawing the 2nd/3rd pass */ + if(!v3d->xray && !v3d->transp && (ob->dtx & OB_DRAWXRAY)) { + add_view3d_after(v3d, base, V3D_XRAY, flag); + return; + } + } + } + + /* draw keys? */ + if(base==(scene->basact) || (base->flag & (SELECT+BA_WAS_SEL))) { + if(flag==0 && warning_recursive==0 && ob!=G.obedit) { + if(ob->ipo && ob->ipo->showkey && (ob->ipoflag & OB_DRAWKEY)) { + ListBase elems; + CfraElem *ce; + float temp[7][3]; + + warning_recursive= 1; + + elems.first= elems.last= 0; + // warning: no longer checks for certain ob-keys only... (so does this need to use the proper ipokeys then?) + make_cfra_list(ob->ipo, &elems); + + cfraont= (scene->r.cfra); + drawtype= v3d->drawtype; + if(drawtype>OB_WIRE) v3d->drawtype= OB_WIRE; + sel= base->flag; + memcpy(temp, &ob->loc, 7*3*sizeof(float)); + + ipoflag= ob->ipoflag; + ob->ipoflag &= ~OB_OFFS_OB; + + set_no_parent_ipo(1); + disable_speed_curve(1); + + if ((ob->ipoflag & OB_DRAWKEYSEL)==0) { + ce= elems.first; + while(ce) { + if(!ce->sel) { + (scene->r.cfra)= ce->cfra/scene->r.framelen; + + base->flag= 0; + + where_is_object_time(ob, (scene->r.cfra)); + draw_object(C, scene, ar, v3d, base, 0); + } + ce= ce->next; + } + } + + ce= elems.first; + while(ce) { + if(ce->sel) { + (scene->r.cfra)= ce->cfra/scene->r.framelen; + + base->flag= SELECT; + + where_is_object_time(ob, (scene->r.cfra)); + draw_object(C, scene, ar, v3d, base, 0); + } + ce= ce->next; + } + + set_no_parent_ipo(0); + disable_speed_curve(0); + + base->flag= sel; + ob->ipoflag= ipoflag; + + /* restore icu->curval */ + (scene->r.cfra)= cfraont; + + memcpy(&ob->loc, temp, 7*3*sizeof(float)); + where_is_object(ob); + v3d->drawtype= drawtype; + + BLI_freelistN(&elems); + + warning_recursive= 0; + } + } + } + + /* patch? children objects with a timeoffs change the parents. How to solve! */ + /* if( ((int)ob->ctime) != F_(scene->r.cfra)) where_is_object(ob); */ + + wmMultMatrix(CTX_wm_window(C), ob->obmat); + + /* which wire color */ + if((flag & DRAW_CONSTCOLOR) == 0) { + project_short(ar, v3d, ob->obmat[3], &base->sx); + + if((G.moving & G_TRANSFORM_OBJ) && (base->flag & (SELECT+BA_WAS_SEL))) UI_ThemeColor(TH_TRANSFORM); + else { + + if(ob->type==OB_LAMP) UI_ThemeColor(TH_LAMP); + else UI_ThemeColor(TH_WIRE); + + if((scene->basact)==base) { + if(base->flag & (SELECT+BA_WAS_SEL)) UI_ThemeColor(TH_ACTIVE); + } + else { + if(base->flag & (SELECT+BA_WAS_SEL)) UI_ThemeColor(TH_SELECT); + } + + // no theme yet + if(ob->id.lib) { + if(base->flag & (SELECT+BA_WAS_SEL)) colindex = 4; + else colindex = 3; + } + else if(warning_recursive==1) { + if(base->flag & (SELECT+BA_WAS_SEL)) { + if(scene->basact==base) colindex = 8; + else colindex= 7; + } + else colindex = 6; + } + else if(ob->flag & OB_FROMGROUP) { + if(base->flag & (SELECT+BA_WAS_SEL)) { + if(scene->basact==base) UI_ThemeColor(TH_GROUP_ACTIVE); + else UI_ThemeColorShade(TH_GROUP_ACTIVE, -16); + } + else UI_ThemeColor(TH_GROUP); + colindex= 0; + } + + } + + if(colindex) { + col= colortab[colindex]; + cpack(col); + } + } + + /* maximum drawtype */ + dt= MIN2(v3d->drawtype, ob->dt); + if(v3d->zbuf==0 && dt>OB_WIRE) dt= OB_WIRE; + dtx= 0; + + /* faceselect exception: also draw solid when dt==wire, except in editmode */ + if(ob==OBACT && (G.f & (G_VERTEXPAINT+G_TEXTUREPAINT+G_WEIGHTPAINT))) { + if(ob->type==OB_MESH) { + + if(ob==G.obedit); + else { + if(dt<OB_SOLID) + zbufoff= 1; + + dt= OB_SHADED; + glEnable(GL_DEPTH_TEST); + } + } + else { + if(dt<OB_SOLID) { + dt= OB_SOLID; + glEnable(GL_DEPTH_TEST); + zbufoff= 1; + } + } + } + + /* draw-extra supported for boundbox drawmode too */ + if(dt>=OB_BOUNDBOX ) { + + dtx= ob->dtx; + if(G.obedit==ob) { + // the only 2 extra drawtypes alowed in editmode + dtx= dtx & (OB_DRAWWIRE|OB_TEXSPACE); + } + + if(G.f & G_DRAW_EXT) { + if(ob->type==OB_EMPTY || ob->type==OB_CAMERA || ob->type==OB_LAMP) dt= OB_WIRE; + } + } + + /* draw outline for selected solid objects, mesh does itself */ + if((v3d->flag & V3D_SELECT_OUTLINE) && ob->type!=OB_MESH) { + if(dt>OB_WIRE && dt<OB_TEXTURE && ob!=G.obedit && (flag && DRAW_SCENESET)==0) { + if (!(ob->dtx&OB_DRAWWIRE) && (ob->flag&SELECT) && !(flag&DRAW_PICKING)) { + drawSolidSelect(v3d, base); + } + } + } + + switch( ob->type) { + case OB_MESH: + if (!(base->flag&OB_RADIO)) { + empty_object= draw_mesh_object(scene, v3d, base, dt, flag); + if(flag!=DRAW_CONSTCOLOR) dtx &= ~OB_DRAWWIRE; // mesh draws wire itself + } + + break; + case OB_FONT: + cu= ob->data; + if (cu->disp.first==NULL) makeDispListCurveTypes(ob, 0); + if(ob==G.obedit) { + tekentextcurs(); + + if (cu->flag & CU_FAST) { + cpack(0xFFFFFF); + set_inverted_drawing(1); + drawDispList(scene, v3d, base, OB_WIRE); + set_inverted_drawing(0); + } else { + drawDispList(scene, v3d, base, dt); + } + + if (cu->linewidth != 0.0) { + cpack(0xff44ff); + UI_ThemeColor(TH_WIRE); + VECCOPY(vec1, ob->orig); + VECCOPY(vec2, ob->orig); + vec1[0] += cu->linewidth; + vec2[0] += cu->linewidth; + vec1[1] += cu->linedist * cu->fsize; + vec2[1] -= cu->lines * cu->linedist * cu->fsize; + setlinestyle(3); + glBegin(GL_LINE_STRIP); + glVertex2fv(vec1); + glVertex2fv(vec2); + glEnd(); + setlinestyle(0); + } + + setlinestyle(3); + for (i=0; i<cu->totbox; i++) { + if (cu->tb[i].w != 0.0) { + if (i == (cu->actbox-1)) + UI_ThemeColor(TH_ACTIVE); + else + UI_ThemeColor(TH_WIRE); + vec1[0] = cu->tb[i].x; + vec1[1] = cu->tb[i].y + cu->fsize; + vec1[2] = 0.001; + glBegin(GL_LINE_STRIP); + glVertex3fv(vec1); + vec1[0] += cu->tb[i].w; + glVertex3fv(vec1); + vec1[1] -= cu->tb[i].h; + glVertex3fv(vec1); + vec1[0] -= cu->tb[i].w; + glVertex3fv(vec1); + vec1[1] += cu->tb[i].h; + glVertex3fv(vec1); + glEnd(); + } + } + setlinestyle(0); + + + if (getselection(&selstart, &selend) && selboxes) { + float selboxw; + + cpack(0xffffff); + set_inverted_drawing(1); + for (i=0; i<(selend-selstart+1); i++) { + SelBox *sb = &(selboxes[i]); + + if (i<(selend-selstart)) { + if (selboxes[i+1].y == sb->y) + selboxw= selboxes[i+1].x - sb->x; + else + selboxw= sb->w; + } + else { + selboxw= sb->w; + } + glBegin(GL_QUADS); + glVertex3f(sb->x, sb->y, 0.001); + glVertex3f(sb->x+selboxw, sb->y, 0.001); + glVertex3f(sb->x+selboxw, sb->y+sb->h, 0.001); + glVertex3f(sb->x, sb->y+sb->h, 0.001); + glEnd(); + } + set_inverted_drawing(0); + } + } + else if(dt==OB_BOUNDBOX) + draw_bounding_volume(ob); + else if(boundbox_clip(v3d, ob->obmat, cu->bb)) + empty_object= drawDispList(scene, v3d, base, dt); + + break; + case OB_CURVE: + case OB_SURF: + cu= ob->data; + /* still needed for curves hidden in other layers. depgraph doesnt handle that yet */ + if (cu->disp.first==NULL) makeDispListCurveTypes(ob, 0); + + if(ob==G.obedit) { + drawnurb(scene, v3d, base, editNurb.first, dt); + } + else if(dt==OB_BOUNDBOX) + draw_bounding_volume(ob); + else if(boundbox_clip(v3d, ob->obmat, cu->bb)) { + empty_object= drawDispList(scene, v3d, base, dt); + + if(cu->path) + curve_draw_speed(scene, ob); + } + break; + case OB_MBALL: + if(ob==G.obedit) + drawmball(C, scene, v3d, base, dt); + else if(dt==OB_BOUNDBOX) + draw_bounding_volume(ob); + else + empty_object= drawmball(C, scene, v3d, base, dt); + break; + case OB_EMPTY: + drawaxes(ob->empty_drawsize, flag, ob->empty_drawtype); + break; + case OB_LAMP: + drawlamp(C, scene, v3d, ob); + if(dtx || (base->flag & SELECT)) wmMultMatrix(CTX_wm_window(C), ob->obmat); + break; + case OB_CAMERA: + drawcamera(C, scene, v3d, ob, flag); + break; + case OB_LATTICE: + drawlattice(v3d, ob); + break; + case OB_ARMATURE: + if(dt>OB_WIRE) GPU_enable_material(0, NULL); // we use default material + empty_object= draw_armature(base, dt, flag); + if(dt>OB_WIRE) GPU_disable_material(); + break; + default: + drawaxes(1.0, flag, OB_ARROWS); + } + if(ob->pd && ob->pd->forcefield) draw_forcefield(C, scene, ob); + + /* code for new particle system */ + if( (warning_recursive==0) && + (ob->particlesystem.first) && + (flag & DRAW_PICKING)==0 && + (ob!=G.obedit) + ) { + ParticleSystem *psys; + if(col || (ob->flag & SELECT)) cpack(0xFFFFFF); /* for visibility, also while wpaint */ + glDepthMask(GL_FALSE); + + for(psys=ob->particlesystem.first; psys; psys=psys->next) + draw_new_particle_system(C, v3d, base, psys, dt); + + if(G.f & G_PARTICLEEDIT && ob==OBACT) { + psys= NULL; // XXX PE_get_current(ob); + if(psys && !G.obedit && psys_in_edit_mode(psys)) + draw_particle_edit(C, scene, v3d, ob, psys, dt); + } + glDepthMask(GL_TRUE); + if(col) cpack(col); + } + + { + bConstraint *con; + for(con=ob->constraints.first; con; con= con->next) + { + if(con->type==CONSTRAINT_TYPE_RIGIDBODYJOINT) + { + bRigidBodyJointConstraint *data = (bRigidBodyJointConstraint*)con->data; + if(data->flag&CONSTRAINT_DRAW_PIVOT) + drawRBpivot(data); + } + } + } + + /* draw extra: after normal draw because of makeDispList */ + if(dtx && !(G.f & (G_RENDER_OGL|G_RENDER_SHADOW))) { + if(dtx & OB_AXIS) { + drawaxes(1.0f, flag, OB_ARROWS); + } + if(dtx & OB_BOUNDBOX) draw_bounding_volume(ob); + if(dtx & OB_TEXSPACE) drawtexspace(ob); + if(dtx & OB_DRAWNAME) { + /* patch for several 3d cards (IBM mostly) that crash on glSelect with text drawing */ + /* but, we also dont draw names for sets or duplicators */ + if(flag == 0) { + if(v3d->zbuf) glDisable(GL_DEPTH_TEST); + glRasterPos3f(0.0, 0.0, 0.0); + + BMF_DrawString(G.font, " "); + BMF_DrawString(G.font, ob->id.name+2); + if(v3d->zbuf) glEnable(GL_DEPTH_TEST); + } + } + /*if(dtx & OB_DRAWIMAGE) drawDispListwire(&ob->disp);*/ + if((dtx & OB_DRAWWIRE) && dt>=OB_SOLID) drawWireExtra(scene, v3d, ob); + } + + if(dt<OB_SHADED) { + if((ob->gameflag & OB_DYNAMIC) || + ((ob->gameflag & OB_BOUNDS) && (ob->boundtype == OB_BOUND_SPHERE))) { + float tmat[4][4], imat[4][4], vec[3]; + + vec[0]= vec[1]= vec[2]= 0.0; + wmGetMatrix(CTX_wm_window(C), tmat); + Mat4Invert(imat, tmat); + + setlinestyle(2); + drawcircball(GL_LINE_LOOP, vec, ob->inertia, imat); + setlinestyle(0); + } + } + + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + + if(zbufoff) glDisable(GL_DEPTH_TEST); + + if(warning_recursive) return; + if(base->flag & (OB_FROMDUPLI|OB_RADIO)) return; + if(G.f & G_RENDER_SHADOW) return; + + /* object centers, need to be drawn in viewmat space for speed, but OK for picking select */ + if(ob!=OBACT || (G.f & (G_VERTEXPAINT|G_TEXTUREPAINT|G_WEIGHTPAINT))==0) { + int do_draw_center= -1; /* defines below are zero or positive... */ + + if((scene->basact)==base) + do_draw_center= ACTIVE; + else if(base->flag & SELECT) + do_draw_center= SELECT; + else if(empty_object || (v3d->flag & V3D_DRAW_CENTERS)) + do_draw_center= DESELECT; + + if(do_draw_center != -1) { + if(flag & DRAW_PICKING) { + /* draw a single point for opengl selection */ + glBegin(GL_POINTS); + glVertex3fv(ob->obmat[3]); + glEnd(); + } + else if((flag & DRAW_CONSTCOLOR)==0) { + /* we don't draw centers for duplicators and sets */ + drawcentercircle(v3d, ob->obmat[3], do_draw_center, ob->id.lib || ob->id.us>1); + } + } + } + + /* not for sets, duplicators or picking */ + if(flag==0 && (!(v3d->flag & V3D_HIDE_HELPLINES))) { + ListBase *list; + + /* draw hook center and offset line */ + if(ob!=G.obedit) draw_hooks(ob); + + /* help lines and so */ + if(ob!=G.obedit && ob->parent && (ob->parent->lay & v3d->lay)) { + setlinestyle(3); + glBegin(GL_LINES); + glVertex3fv(ob->obmat[3]); + glVertex3fv(ob->orig); + glEnd(); + setlinestyle(0); + } + + /* Drawing the constraint lines */ + list = &ob->constraints; + if (list) { + bConstraint *curcon; + bConstraintOb *cob; + char col[4], col2[4]; + + UI_GetThemeColor3ubv(TH_GRID, col); + make_axis_color(col, col2, 'z'); + glColor3ubv((GLubyte *)col2); + + cob= constraints_make_evalob(ob, NULL, CONSTRAINT_OBTYPE_OBJECT); + + for (curcon = list->first; curcon; curcon=curcon->next) { + bConstraintTypeInfo *cti= constraint_get_typeinfo(curcon); + ListBase targets = {NULL, NULL}; + bConstraintTarget *ct; + + if ((curcon->flag & CONSTRAINT_EXPAND) && (cti) && (cti->get_constraint_targets)) { + cti->get_constraint_targets(curcon, &targets); + + for (ct= targets.first; ct; ct= ct->next) { + /* calculate target's matrix */ + if (cti->get_target_matrix) + cti->get_target_matrix(curcon, cob, ct, bsystem_time(ob, (float)(scene->r.cfra), give_timeoffset(ob))); + else + Mat4One(ct->matrix); + + setlinestyle(3); + glBegin(GL_LINES); + glVertex3fv(ct->matrix[3]); + glVertex3fv(ob->obmat[3]); + glEnd(); + setlinestyle(0); + } + + if (cti->flush_constraint_targets) + cti->flush_constraint_targets(curcon, &targets, 1); + } + } + + constraints_clear_evalob(cob); + } + } + + free_old_images(); +} + +void draw_object_ext(const bContext *C, ARegion *ar, View3D *v3d, Scene *scene, Base *base) +{ + + if(v3d==NULL || base==NULL) return; + + if(v3d->drawtype > OB_WIRE) { + v3d->zbuf= 1; + glEnable(GL_DEPTH_TEST); + } + + G.f |= G_DRAW_EXT; + + glDrawBuffer(GL_FRONT); +// XXX persp(PERSP_VIEW); + + if(v3d->flag & V3D_CLIPPING) + view3d_set_clipping(v3d); + + draw_object(C, scene, ar, v3d, base, 0); + + if(v3d->flag & V3D_CLIPPING) + view3d_clr_clipping(); + + G.f &= ~G_DRAW_EXT; + + bglFlush(); /* reveil frontbuffer drawing */ + glDrawBuffer(GL_BACK); + + if(v3d->zbuf) { + v3d->zbuf= 0; + glDisable(GL_DEPTH_TEST); + } +// XXX ar->win_swap= WIN_FRONT_OK; +} + +/* ***************** BACKBUF SEL (BBS) ********* */ + +static void bbs_mesh_verts__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s) +{ + int offset = (intptr_t) userData; + EditVert *eve = EM_get_vert_for_index(index); + + if (eve->h==0) { + WM_set_framebuffer_index_color(offset+index); + bglVertex3fv(co); + } +} +static int bbs_mesh_verts(DerivedMesh *dm, int offset) +{ + glPointSize( UI_GetThemeValuef(TH_VERTEX_SIZE) ); + bglBegin(GL_POINTS); + dm->foreachMappedVert(dm, bbs_mesh_verts__mapFunc, (void*)(intptr_t) offset); + bglEnd(); + glPointSize(1.0); + + return offset + G.totvert; +} + +static int bbs_mesh_wire__setDrawOptions(void *userData, int index) +{ + int offset = (intptr_t) userData; + EditEdge *eed = EM_get_edge_for_index(index); + + if (eed->h==0) { + WM_set_framebuffer_index_color(offset+index); + return 1; + } else { + return 0; + } +} +static int bbs_mesh_wire(DerivedMesh *dm, int offset) +{ + dm->drawMappedEdges(dm, bbs_mesh_wire__setDrawOptions, (void*)(intptr_t) offset); + + return offset + G.totedge; +} + +static int bbs_mesh_solid__setSolidDrawOptions(void *userData, int index, int *drawSmooth_r) +{ + if (EM_get_face_for_index(index)->h==0) { + if (userData) { + WM_set_framebuffer_index_color(index+1); + } + return 1; + } else { + return 0; + } +} + +static void bbs_mesh_solid__drawCenter(void *userData, int index, float *cent, float *no) +{ + EditFace *efa = EM_get_face_for_index(index); + + if (efa->h==0 && efa->fgonf!=EM_FGON) { + WM_set_framebuffer_index_color(index+1); + + bglVertex3fv(cent); + } +} + +/* two options, facecolors or black */ +static int bbs_mesh_solid_EM(Scene *scene, View3D *v3d, DerivedMesh *dm, int facecol) +{ + cpack(0); + + if (facecol) { + dm->drawMappedFaces(dm, bbs_mesh_solid__setSolidDrawOptions, (void*)(intptr_t) 1, 0); + + if( CHECK_OB_DRAWFACEDOT(scene, v3d, G.obedit->dt) ) { + glPointSize(UI_GetThemeValuef(TH_FACEDOT_SIZE)); + + bglBegin(GL_POINTS); + dm->foreachMappedFaceCenter(dm, bbs_mesh_solid__drawCenter, NULL); + bglEnd(); + } + + return 1+G.totface; + } else { + dm->drawMappedFaces(dm, bbs_mesh_solid__setSolidDrawOptions, (void*) 0, 0); + return 1; + } +} + +static int bbs_mesh_solid__setDrawOpts(void *userData, int index, int *drawSmooth_r) +{ + Mesh *me = userData; + + if (!(me->mface[index].flag&ME_HIDE)) { + WM_set_framebuffer_index_color(index+1); + return 1; + } else { + return 0; + } +} + +/* TODO remove this - since face select mode now only works with painting */ +static void bbs_mesh_solid(Object *ob) +{ + DerivedMesh *dm = mesh_get_derived_final(ob, get_viewedit_datamask()); + Mesh *me = (Mesh*)ob->data; + + glColor3ub(0, 0, 0); + dm->drawMappedFaces(dm, bbs_mesh_solid__setDrawOpts, me, 0); + + dm->release(dm); +} + +void draw_object_backbufsel(const bContext *C, Scene *scene, View3D *v3d, Object *ob) +{ + + wmMultMatrix(CTX_wm_window(C), ob->obmat); + + glClearDepth(1.0); glClear(GL_DEPTH_BUFFER_BIT); + glEnable(GL_DEPTH_TEST); + + switch( ob->type) { + case OB_MESH: + if(ob==G.obedit) { + DerivedMesh *dm = editmesh_get_derived_cage(CD_MASK_BAREMESH); + + EM_init_index_arrays(1, 1, 1); + + em_solidoffs= bbs_mesh_solid_EM(scene, v3d, dm, scene->selectmode & SCE_SELECT_FACE); + + bglPolygonOffset(1.0); + + // we draw edges always, for loop (select) tools + em_wireoffs= bbs_mesh_wire(dm, em_solidoffs); + + // we draw verts if vert select mode or if in transform (for snap). + if(scene->selectmode & SCE_SELECT_VERTEX || G.moving & G_TRANSFORM_EDIT) + em_vertoffs= bbs_mesh_verts(dm, em_wireoffs); + else em_vertoffs= em_wireoffs; + + bglPolygonOffset(0.0); + + dm->release(dm); + + EM_free_index_arrays(); + } + else bbs_mesh_solid(ob); + + break; + case OB_CURVE: + case OB_SURF: + break; + } + + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); +} + + +/* ************* draw object instances for bones, for example ****************** */ +/* assumes all matrices/etc set OK */ + +/* helper function for drawing object instances - meshes */ +static void draw_object_mesh_instance(Scene *scene, View3D *v3d, Object *ob, int dt, int outline) +{ + DerivedMesh *dm=NULL, *edm=NULL; + int glsl; + + if(G.obedit && ob->data==G.obedit->data) + edm= editmesh_get_derived_base(); + else + dm = mesh_get_derived_final(ob, CD_MASK_BAREMESH); + + if(dt<=OB_WIRE) { + if(dm) + dm->drawEdges(dm, 1); + else if(edm) + edm->drawEdges(edm, 1); + } + else { + if(outline) + draw_mesh_object_outline(v3d, ob, dm?dm:edm); + + if(dm) { + glsl = draw_glsl_material(scene, ob, v3d, dt); + GPU_set_object_materials(scene, ob, glsl, NULL); + } + else { + glEnable(GL_COLOR_MATERIAL); + UI_ThemeColor(TH_BONE_SOLID); + glDisable(GL_COLOR_MATERIAL); + } + + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0); + glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); + glEnable(GL_LIGHTING); + + if(dm) { + dm->drawFacesSolid(dm, GPU_enable_material); + GPU_disable_material(); + } + else if(edm) + edm->drawMappedFaces(edm, NULL, NULL, 0); + + glDisable(GL_LIGHTING); + } + + if(edm) edm->release(edm); + if(dm) dm->release(dm); +} + +void draw_object_instance(Scene *scene, View3D *v3d, Object *ob, int dt, int outline) +{ + if (ob == NULL) + return; + + switch (ob->type) { + case OB_MESH: + draw_object_mesh_instance(scene, v3d, ob, dt, outline); + break; + case OB_EMPTY: + drawaxes(ob->empty_drawsize, 0, ob->empty_drawtype); + break; + } +} diff --git a/source/blender/editors/space_view3d/view3d_draw.c b/source/blender/editors/space_view3d/view3d_draw.c index 712a69be77b..d03681d6a59 100644 --- a/source/blender/editors/space_view3d/view3d_draw.c +++ b/source/blender/editors/space_view3d/view3d_draw.c @@ -33,6 +33,7 @@ #include "DNA_action_types.h" #include "DNA_armature_types.h" #include "DNA_camera_types.h" +#include "DNA_group_types.h" #include "DNA_key_types.h" #include "DNA_object_types.h" #include "DNA_space_types.h" @@ -72,12 +73,16 @@ #include "ED_screen.h" #include "ED_util.h" +#include "ED_types.h" #include "UI_interface.h" #include "UI_interface_icons.h" #include "UI_resources.h" #include "UI_view2d.h" +#include "GPU_draw.h" +#include "GPU_material.h" + #include "view3d_intern.h" // own include @@ -1145,6 +1150,178 @@ static void draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d) // XXX areawinset(ar->win); // restore viewport / scissor } +/* ****************** View3d afterdraw *************** */ + +typedef struct View3DAfter { + struct View3DAfter *next, *prev; + struct Base *base; + int type, flag; +} View3DAfter; + +/* temp storage of Objects that need to be drawn as last */ +void add_view3d_after(View3D *v3d, Base *base, int type, int flag) +{ + View3DAfter *v3da= MEM_callocN(sizeof(View3DAfter), "View 3d after"); + + BLI_addtail(&v3d->afterdraw, v3da); + v3da->base= base; + v3da->type= type; + v3da->flag= flag; +} + +/* clears zbuffer and draws it over */ +static void view3d_draw_xray(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, int clear) +{ + View3DAfter *v3da, *next; + int doit= 0; + + for(v3da= v3d->afterdraw.first; v3da; v3da= v3da->next) + if(v3da->type==V3D_XRAY) doit= 1; + + if(doit) { + if(clear && v3d->zbuf) glClear(GL_DEPTH_BUFFER_BIT); + v3d->xray= TRUE; + + for(v3da= v3d->afterdraw.first; v3da; v3da= next) { + next= v3da->next; + if(v3da->type==V3D_XRAY) { + draw_object(C, scene, ar, v3d, v3da->base, v3da->flag); + BLI_remlink(&v3d->afterdraw, v3da); + MEM_freeN(v3da); + } + } + v3d->xray= FALSE; + } +} + +/* disables write in zbuffer and draws it over */ +static void view3d_draw_transp(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d) +{ + View3DAfter *v3da, *next; + + glDepthMask(0); + v3d->transp= TRUE; + + for(v3da= v3d->afterdraw.first; v3da; v3da= next) { + next= v3da->next; + if(v3da->type==V3D_TRANSP) { + draw_object(C, scene, ar, v3d, v3da->base, v3da->flag); + BLI_remlink(&v3d->afterdraw, v3da); + MEM_freeN(v3da); + } + } + v3d->transp= FALSE; + + glDepthMask(1); + +} + +/* *********************** */ + +/* + In most cases call draw_dupli_objects, + draw_dupli_objects_color was added because when drawing set dupli's + we need to force the color + */ +static void draw_dupli_objects_color(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, Base *base, int color) +{ + ListBase *lb; + DupliObject *dob; + Base tbase; + BoundBox *bb= NULL; + GLuint displist=0; + short transflag, use_displist= -1; /* -1 is initialize */ + char dt, dtx; + + if (base->object->restrictflag & OB_RESTRICT_VIEW) return; + + tbase.flag= OB_FROMDUPLI|base->flag; + lb= object_duplilist(scene, base->object); + + for(dob= lb->first; dob; dob= dob->next) { + if(dob->no_draw); + else { + tbase.object= dob->ob; + + /* extra service: draw the duplicator in drawtype of parent */ + /* MIN2 for the drawtype to allow bounding box objects in groups for lods */ + dt= tbase.object->dt; tbase.object->dt= MIN2(tbase.object->dt, base->object->dt); + dtx= tbase.object->dtx; tbase.object->dtx= base->object->dtx; + + /* negative scale flag has to propagate */ + transflag= tbase.object->transflag; + if(base->object->transflag & OB_NEG_SCALE) + tbase.object->transflag ^= OB_NEG_SCALE; + + UI_ThemeColorBlend(color, TH_BACK, 0.5); + + /* generate displist, test for new object */ + if(use_displist==1 && dob->prev && dob->prev->ob!=dob->ob) { + use_displist= -1; + glDeleteLists(displist, 1); + } + /* generate displist */ + if(use_displist == -1) { + + /* lamp drawing messes with matrices, could be handled smarter... but this works */ + if(dob->ob->type==OB_LAMP || dob->type==OB_DUPLIGROUP) + use_displist= 0; + else { + /* disable boundbox check for list creation */ + object_boundbox_flag(dob->ob, OB_BB_DISABLED, 1); + /* need this for next part of code */ + bb= object_get_boundbox(dob->ob); + + Mat4One(dob->ob->obmat); /* obmat gets restored */ + + displist= glGenLists(1); + glNewList(displist, GL_COMPILE); + draw_object(C, scene, ar, v3d, &tbase, DRAW_CONSTCOLOR); + glEndList(); + + use_displist= 1; + object_boundbox_flag(dob->ob, OB_BB_DISABLED, 0); + } + } + if(use_displist) { + wmMultMatrix(CTX_wm_window(C), dob->mat); + if(boundbox_clip(v3d, dob->mat, bb)) + glCallList(displist); + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); + } + else { + Mat4CpyMat4(dob->ob->obmat, dob->mat); + draw_object(C, scene, ar, v3d, &tbase, DRAW_CONSTCOLOR); + } + + tbase.object->dt= dt; + tbase.object->dtx= dtx; + tbase.object->transflag= transflag; + } + } + + /* Transp afterdraw disabled, afterdraw only stores base pointers, and duplis can be same obj */ + + free_object_duplilist(lb); /* does restore */ + + if(use_displist) + glDeleteLists(displist, 1); +} + +static void draw_dupli_objects(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, Base *base) +{ + /* define the color here so draw_dupli_objects_color can be called + * from the set loop */ + + int color= (base->flag & SELECT)?TH_SELECT:TH_WIRE; + /* debug */ + if(base->object->dup_group && base->object->dup_group->id.us<1) + color= TH_REDALERT; + + draw_dupli_objects_color(C, scene, ar, v3d, base, color); +} + + void view3d_update_depths(ARegion *ar, View3D *v3d) { /* Create storage for, and, if necessary, copy depth buffer */ @@ -1174,7 +1351,7 @@ void view3d_update_depths(ARegion *ar, View3D *v3d) } /* Enable sculpting in wireframe mode by drawing sculpt object only to the depth buffer */ -static void draw_sculpt_depths(Scene *scene, View3D *v3d) +static void draw_sculpt_depths(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d) { Object *ob = OBACT; @@ -1193,7 +1370,7 @@ static void draw_sculpt_depths(Scene *scene, View3D *v3d) glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glEnable(GL_DEPTH_TEST); -// XXX draw_object(BASACT, 0); + draw_object(C, scene, ar, v3d, BASACT, 0); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); if(!depth_on) glDisable(GL_DEPTH_TEST); @@ -1204,6 +1381,185 @@ static void draw_sculpt_depths(Scene *scene, View3D *v3d) } } +void draw_depth(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, int (* func)(void *)) +{ + Base *base; + Scene *sce; + short zbuf, flag; + float glalphaclip; + /* temp set drawtype to solid */ + + /* Setting these temporarily is not nice */ + zbuf = v3d->zbuf; + flag = v3d->flag; + glalphaclip = U.glalphaclip; + + U.glalphaclip = 0.5; /* not that nice but means we wont zoom into billboards */ + v3d->flag &= ~V3D_SELECT_OUTLINE; + + setwinmatrixview3d(CTX_wm_window(C), v3d, ar->winx, ar->winy, NULL); /* 0= no pick rect */ + setviewmatrixview3d(v3d); /* note: calls where_is_object for camera... */ + + Mat4MulMat4(v3d->persmat, v3d->viewmat, v3d->winmat); + Mat4Invert(v3d->persinv, v3d->persmat); + Mat4Invert(v3d->viewinv, v3d->viewmat); + + glClear(GL_DEPTH_BUFFER_BIT); + + wmLoadMatrix(CTX_wm_window(C), v3d->viewmat); +// persp(PERSP_STORE); // store correct view for persp(PERSP_VIEW) calls + + if(v3d->flag & V3D_CLIPPING) { + view3d_set_clipping(v3d); + } + + v3d->zbuf= TRUE; + glEnable(GL_DEPTH_TEST); + + /* draw set first */ + if(scene->set) { + for(SETLOOPER(scene->set, base)) { + if(v3d->lay & base->lay) { + if (func == NULL || func(base)) { + draw_object(C, scene, ar, v3d, base, 0); + if(base->object->transflag & OB_DUPLI) { + draw_dupli_objects_color(C, scene, ar, v3d, base, TH_WIRE); + } + } + } + } + } + + for(base= scene->base.first; base; base= base->next) { + if(v3d->lay & base->lay) { + if (func == NULL || func(base)) { + /* dupli drawing */ + if(base->object->transflag & OB_DUPLI) { + draw_dupli_objects(C, scene, ar, v3d, base); + } + draw_object(C, scene, ar, v3d, base, 0); + } + } + } + + /* this isnt that nice, draw xray objects as if they are normal */ + if (v3d->afterdraw.first) { + View3DAfter *v3da, *next; + int num = 0; + v3d->xray= TRUE; + + glDepthFunc(GL_ALWAYS); /* always write into the depth bufer, overwriting front z values */ + for(v3da= v3d->afterdraw.first; v3da; v3da= next) { + next= v3da->next; + if(v3da->type==V3D_XRAY) { + draw_object(C, scene, ar, v3d, v3da->base, 0); + num++; + } + /* dont remove this time */ + } + v3d->xray= FALSE; + + glDepthFunc(GL_LEQUAL); /* Now write the depth buffer normally */ + for(v3da= v3d->afterdraw.first; v3da; v3da= next) { + next= v3da->next; + if(v3da->type==V3D_XRAY) { + v3d->xray= TRUE; v3d->transp= FALSE; + } else if (v3da->type==V3D_TRANSP) { + v3d->xray= FALSE; v3d->transp= TRUE; + } + + draw_object(C, scene, ar, v3d, v3da->base, 0); /* Draw Xray or Transp objects normally */ + BLI_remlink(&v3d->afterdraw, v3da); + MEM_freeN(v3da); + } + v3d->xray= FALSE; + v3d->transp= FALSE; + } + + v3d->zbuf = zbuf; + U.glalphaclip = glalphaclip; + v3d->flag = flag; +} + +typedef struct View3DShadow { + struct View3DShadow *next, *prev; + GPULamp *lamp; +} View3DShadow; + +static void gpu_render_lamp_update(Scene *scene, View3D *v3d, Object *ob, Object *par, float obmat[][4], ListBase *shadows) +{ + GPULamp *lamp; + View3DShadow *shadow; + + lamp = GPU_lamp_from_blender(scene, ob, par); + + if(lamp) { + GPU_lamp_update(lamp, ob->lay, obmat); + + if((ob->lay & v3d->lay) && GPU_lamp_has_shadow_buffer(lamp)) { + shadow= MEM_callocN(sizeof(View3DShadow), "View3DShadow"); + shadow->lamp = lamp; + BLI_addtail(shadows, shadow); + } + } +} + +static void gpu_update_lamps_shadows(Scene *scene, View3D *v3d) +{ + ListBase shadows; + View3DShadow *shadow; + Scene *sce; + Base *base; + Object *ob; + + shadows.first= shadows.last= NULL; + + /* update lamp transform and gather shadow lamps */ + for(SETLOOPER(scene, base)) { + ob= base->object; + + if(ob->type == OB_LAMP) + gpu_render_lamp_update(scene, v3d, ob, NULL, ob->obmat, &shadows); + + if (ob->transflag & OB_DUPLI) { + DupliObject *dob; + ListBase *lb = object_duplilist(scene, ob); + + for(dob=lb->first; dob; dob=dob->next) + if(dob->ob->type==OB_LAMP) + gpu_render_lamp_update(scene, v3d, dob->ob, ob, dob->mat, &shadows); + + free_object_duplilist(lb); + } + } + + /* render shadows after updating all lamps, nested object_duplilist + * don't work correct since it's replacing object matrices */ + for(shadow=shadows.first; shadow; shadow=shadow->next) { + /* this needs to be done better .. */ + float viewmat[4][4], winmat[4][4]; + int drawtype, lay, winsize, flag2; + + drawtype= v3d->drawtype; + lay= v3d->lay; + flag2= v3d->flag2 & V3D_SOLID_TEX; + + v3d->drawtype = OB_SOLID; + v3d->lay &= GPU_lamp_shadow_layer(shadow->lamp); + v3d->flag2 &= ~V3D_SOLID_TEX; + + GPU_lamp_shadow_buffer_bind(shadow->lamp, viewmat, &winsize, winmat); +// XXX drawview3d_render(v3d, viewmat, winsize, winsize, winmat, 1); + GPU_lamp_shadow_buffer_unbind(shadow->lamp); + + v3d->drawtype= drawtype; + v3d->lay= lay; + v3d->flag2 |= flag2; + } + + BLI_freelistN(&shadows); +} + void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d) { @@ -1228,8 +1584,8 @@ void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d) } /* shadow buffers, before we setup matrices */ -// if(draw_glsl_material(NULL, v3d->drawtype)) -// gpu_update_lamps_shadows(scene, v3d); + if(draw_glsl_material(scene, NULL, v3d, v3d->drawtype)) + gpu_update_lamps_shadows(scene, v3d); setwinmatrixview3d(CTX_wm_window(C), v3d, ar->winx, ar->winy, NULL); /* 0= no pick rect */ setviewmatrixview3d(v3d); /* note: calls where_is_object for camera... */ @@ -1319,10 +1675,10 @@ void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d) if(v3d->lay & base->lay) { UI_ThemeColorBlend(TH_WIRE, TH_BACK, 0.6f); -// XXX draw_object(base, DRAW_CONSTCOLOR|DRAW_SCENESET); + draw_object(C, scene, ar, v3d, base, DRAW_CONSTCOLOR|DRAW_SCENESET); if(base->object->transflag & OB_DUPLI) { -// XXX draw_dupli_objects_color(v3d, base, TH_WIRE); + draw_dupli_objects_color(C, scene, ar, v3d, base, TH_WIRE); } } } @@ -1336,10 +1692,11 @@ void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d) /* dupli drawing */ if(base->object->transflag & OB_DUPLI) { -// XXX draw_dupli_objects(v3d, base); + draw_dupli_objects(C, scene, ar, v3d, base); } if((base->flag & SELECT)==0) { -// XXX if(base->object!=G.obedit) draw_object(base, 0); + if(base->object!=G.obedit) + draw_object(C, scene, ar, v3d, base, 0); } } } @@ -1352,14 +1709,14 @@ void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d) /* draw selected and editmode */ for(base= scene->base.first; base; base= base->next) { if(v3d->lay & base->lay) { -// if (base->object==G.obedit || ( base->flag & SELECT) ) -// XXX draw_object(base, 0); + if (base->object==G.obedit || ( base->flag & SELECT) ) + draw_object(C, scene, ar, v3d, base, 0); } } if(!retopo && sculptparticle && !(obact && (obact->dtx & OB_DRAWXRAY))) { if(G.f & G_SCULPTMODE) - draw_sculpt_depths(scene, v3d); + draw_sculpt_depths(C, scene, ar, v3d); view3d_update_depths(ar, v3d); } @@ -1375,12 +1732,12 @@ void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d) // if(scene->radio) RAD_drawall(v3d->drawtype>=OB_SOLID); /* Transp and X-ray afterdraw stuff */ -// view3d_draw_transp(v3d); -// view3d_draw_xray(v3d, 1); // clears zbuffer if it is used! + view3d_draw_transp(C, scene, ar, v3d); + view3d_draw_xray(C, scene, ar, v3d, 1); // clears zbuffer if it is used! if(!retopo && sculptparticle && (obact && (OBACT->dtx & OB_DRAWXRAY))) { if(G.f & G_SCULPTMODE) - draw_sculpt_depths(scene, v3d); + draw_sculpt_depths(C, scene, ar, v3d); view3d_update_depths(ar, v3d); } diff --git a/source/blender/editors/space_view3d/view3d_edit.c b/source/blender/editors/space_view3d/view3d_edit.c new file mode 100644 index 00000000000..5ac774afadb --- /dev/null +++ b/source/blender/editors/space_view3d/view3d_edit.c @@ -0,0 +1,1086 @@ +/** + * $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 ***** + */ + +#include <string.h> +#include <stdio.h> +#include <math.h> +#include <float.h> + +#include "DNA_action_types.h" +#include "DNA_camera_types.h" +#include "DNA_lamp_types.h" +#include "DNA_object_types.h" +#include "DNA_space_types.h" +#include "DNA_scene_types.h" +#include "DNA_screen_types.h" +#include "DNA_userdef_types.h" +#include "DNA_view3d_types.h" +#include "DNA_world_types.h" + +#include "MEM_guardedalloc.h" + +#include "BLI_blenlib.h" +#include "BLI_arithb.h" +#include "BLI_rand.h" + +#include "BKE_action.h" +#include "BKE_context.h" +#include "BKE_object.h" +#include "BKE_global.h" +#include "BKE_scene.h" +#include "BKE_screen.h" +#include "BKE_utildefines.h" + +#include "RE_pipeline.h" // make_stars + +#include "BIF_gl.h" +#include "BIF_retopo.h" + +#include "WM_api.h" + +#include "ED_screen.h" + +#include "UI_interface.h" +#include "UI_resources.h" +#include "UI_view2d.h" + +#include "PIL_time.h" /* smoothview */ + +#include "view3d_intern.h" // own include + +/* ********************** view3d_edit: view manipulations ********************* */ + +#define TRACKBALLSIZE (1.1) + +/* the central math in this function was copied from trackball.cpp, sample code from the + Developers Toolbox series by SGI. */ + +/* trackball: better one than a full spherical solution */ + +void calctrackballvecfirst(rcti *area, short *mval, float *vec) +{ + float x, y, radius, d, z, t; + + radius= TRACKBALLSIZE; + + /* normalize x and y */ + x= (area->xmax + area->xmin)/2 -mval[0]; + x/= (float)((area->xmax - area->xmin)/2); + y= (area->ymax + area->ymin)/2 -mval[1]; + y/= (float)((area->ymax - area->ymin)/2); + + d = sqrt(x*x + y*y); + if (d < radius*M_SQRT1_2) /* Inside sphere */ + z = sqrt(radius*radius - d*d); + else + { /* On hyperbola */ + t = radius / M_SQRT2; + z = t*t / d; + } + + vec[0]= x; + vec[1]= y; + vec[2]= -z; /* yah yah! */ + + if( fabs(vec[2])>fabs(vec[1]) && fabs(vec[2])>fabs(vec[0]) ) { + vec[0]= 0.0; + vec[1]= 0.0; + if(vec[2]>0.0) vec[2]= 1.0; else vec[2]= -1.0; + } + else if( fabs(vec[1])>fabs(vec[0]) && fabs(vec[1])>fabs(vec[2]) ) { + vec[0]= 0.0; + vec[2]= 0.0; + if(vec[1]>0.0) vec[1]= 1.0; else vec[1]= -1.0; + } + else { + vec[1]= 0.0; + vec[2]= 0.0; + if(vec[0]>0.0) vec[0]= 1.0; else vec[0]= -1.0; + } +} + +void calctrackballvec(rcti *area, short *mval, float *vec) +{ + float x, y, radius, d, z, t; + + radius= TRACKBALLSIZE; + + /* x en y normalizeren */ + x= (area->xmax + area->xmin)/2 -mval[0]; + x/= (float)((area->xmax - area->xmin)/4); + y= (area->ymax + area->ymin)/2 -mval[1]; + y/= (float)((area->ymax - area->ymin)/2); + + d = sqrt(x*x + y*y); + if (d < radius*M_SQRT1_2) /* Inside sphere */ + z = sqrt(radius*radius - d*d); + else + { /* On hyperbola */ + t = radius / M_SQRT2; + z = t*t / d; + } + + vec[0]= x; + vec[1]= y; + vec[2]= -z; /* yah yah! */ + +} + + +// ndof scaling will be moved to user setting. +// In the mean time this is just a place holder. + +// Note: scaling in the plugin and ghostwinlay.c +// should be removed. With driver default setting, +// each axis returns approx. +-200 max deflection. + +// The values I selected are based on the older +// polling i/f. With event i/f, the sensistivity +// can be increased for improved response from +// small deflections of the device input. + + +// lukep notes : i disagree on the range. +// the normal 3Dconnection driver give +/-400 +// on defaut range in other applications +// and up to +/- 1000 if set to maximum +// because i remove the scaling by delta, +// which was a bad idea as it depend of the system +// speed and os, i changed the scaling values, but +// those are still not ok + + +float ndof_axis_scale[6] = { + +0.01, // Tx + +0.01, // Tz + +0.01, // Ty + +0.0015, // Rx + +0.0015, // Rz + +0.0015 // Ry +}; + +void filterNDOFvalues(float *sbval) +{ + int i=0; + float max = 0.0; + + for (i =0; i<6;i++) + if (fabs(sbval[i]) > max) + max = fabs(sbval[i]); + for (i =0; i<6;i++) + if (fabs(sbval[i]) != max ) + sbval[i]=0.0; +} + +// statics for controlling v3d->dist corrections. +// viewmoveNDOF zeros and adjusts v3d->ofs. +// viewmove restores based on dz_flag state. + +int dz_flag = 0; +float m_dist; + +void viewmoveNDOFfly(ARegion *ar, View3D *v3d, int mode) +{ + int i; + float phi; + float dval[7]; + // static fval[6] for low pass filter; device input vector is dval[6] + static float fval[6]; + float tvec[3],rvec[3]; + float q1[4]; + float mat[3][3]; + float upvec[3]; + + + /*---------------------------------------------------- + * sometimes this routine is called from headerbuttons + * viewmove needs to refresh the screen + */ +// XXX areawinset(ar->win); + + + // fetch the current state of the ndof device +// XXX getndof(dval); + + if (v3d->ndoffilter) + filterNDOFvalues(fval); + + // Scale input values + +// if(dval[6] == 0) return; // guard against divide by zero + + for(i=0;i<6;i++) { + + // user scaling + dval[i] = dval[i] * ndof_axis_scale[i]; + } + + + // low pass filter with zero crossing reset + + for(i=0;i<6;i++) { + if((dval[i] * fval[i]) >= 0) + dval[i] = (fval[i] * 15 + dval[i]) / 16; + else + fval[i] = 0; + } + + + // force perspective mode. This is a hack and is + // incomplete. It doesn't actually effect the view + // until the first draw and doesn't update the menu + // to reflect persp mode. + + v3d->persp = V3D_PERSP; + + + // Correct the distance jump if v3d->dist != 0 + + // This is due to a side effect of the original + // mouse view rotation code. The rotation point is + // set a distance in front of the viewport to + // make rotating with the mouse look better. + // The distance effect is written at a low level + // in the view management instead of the mouse + // view function. This means that all other view + // movement devices must subtract this from their + // view transformations. + + if(v3d->dist != 0.0) { + dz_flag = 1; + m_dist = v3d->dist; + upvec[0] = upvec[1] = 0; + upvec[2] = v3d->dist; + Mat3CpyMat4(mat, v3d->viewinv); + Mat3MulVecfl(mat, upvec); + VecSubf(v3d->ofs, v3d->ofs, upvec); + v3d->dist = 0.0; + } + + + // Apply rotation + // Rotations feel relatively faster than translations only in fly mode, so + // we have no choice but to fix that here (not in the plugins) + rvec[0] = -0.5 * dval[3]; + rvec[1] = -0.5 * dval[4]; + rvec[2] = -0.5 * dval[5]; + + // rotate device x and y by view z + + Mat3CpyMat4(mat, v3d->viewinv); + mat[2][2] = 0.0f; + Mat3MulVecfl(mat, rvec); + + // rotate the view + + phi = Normalize(rvec); + if(phi != 0) { + VecRotToQuat(rvec,phi,q1); + QuatMul(v3d->viewquat, v3d->viewquat, q1); + } + + + // Apply translation + + tvec[0] = dval[0]; + tvec[1] = dval[1]; + tvec[2] = -dval[2]; + + // the next three lines rotate the x and y translation coordinates + // by the current z axis angle + + Mat3CpyMat4(mat, v3d->viewinv); + mat[2][2] = 0.0f; + Mat3MulVecfl(mat, tvec); + + // translate the view + + VecSubf(v3d->ofs, v3d->ofs, tvec); + + + /*---------------------------------------------------- + * refresh the screen XXX + */ + + // update render preview window + +// XXX BIF_view3d_previewrender_signal(ar, PR_DBASE|PR_DISPRECT); +} + +/* Zooms in on a border drawn by the user */ +static int view_autodist(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, short *mval, float mouse_worldloc[3] ) //, float *autodist ) +{ + rcti rect; + /* ZBuffer depth vars */ + bglMats mats; + float depth, depth_close= MAXFLOAT; + int had_depth = 0; + double cent[2], p[3]; + int xs, ys; + +// XXX getmouseco_areawin(mval); + +// XXX persp(PERSP_VIEW); + + rect.xmax = mval[0] + 4; + rect.ymax = mval[1] + 4; + + rect.xmin = mval[0] - 4; + rect.ymin = mval[1] - 4; + + /* Get Z Depths, needed for perspective, nice for ortho */ + bgl_get_mats(&mats); + draw_depth(C, scene, ar, v3d, NULL); + + /* force updating */ + if (v3d->depths) { + had_depth = 1; + v3d->depths->damaged = 1; + } + + view3d_update_depths(ar, v3d); + + /* Constrain rect to depth bounds */ + if (rect.xmin < 0) rect.xmin = 0; + if (rect.ymin < 0) rect.ymin = 0; + if (rect.xmax >= v3d->depths->w) rect.xmax = v3d->depths->w-1; + if (rect.ymax >= v3d->depths->h) rect.ymax = v3d->depths->h-1; + + /* Find the closest Z pixel */ + for (xs=rect.xmin; xs < rect.xmax; xs++) { + for (ys=rect.ymin; ys < rect.ymax; ys++) { + depth= v3d->depths->depths[ys*v3d->depths->w+xs]; + if(depth < v3d->depths->depth_range[1] && depth > v3d->depths->depth_range[0]) { + if (depth_close > depth) { + depth_close = depth; + } + } + } + } + + if (depth_close==MAXFLOAT) + return 0; + + if (had_depth==0) { + MEM_freeN(v3d->depths->depths); + v3d->depths->depths = NULL; + } + v3d->depths->damaged = 1; + + cent[0] = (double)mval[0]; + cent[1] = (double)mval[1]; + + if (!gluUnProject(cent[0], cent[1], depth_close, mats.modelview, mats.projection, (GLint *)mats.viewport, &p[0], &p[1], &p[2])) + return 0; + + mouse_worldloc[0] = (float)p[0]; + mouse_worldloc[1] = (float)p[1]; + mouse_worldloc[2] = (float)p[2]; + return 1; +} + +static void view_zoom_mouseloc(ARegion *ar, View3D *v3d, float dfac, short *mouseloc) +{ + if(U.uiflag & USER_ZOOM_TO_MOUSEPOS) { + short vb[2]; + float dvec[3]; + float tvec[3]; + float tpos[3]; + float new_dist; + + /* find the current window width and height */ + vb[0] = ar->winx; + vb[1] = ar->winy; + + tpos[0] = -v3d->ofs[0]; + tpos[1] = -v3d->ofs[1]; + tpos[2] = -v3d->ofs[2]; + + /* Project cursor position into 3D space */ + initgrabz(v3d, tpos[0], tpos[1], tpos[2]); + window_to_3d(ar, v3d, dvec, mouseloc[0]-vb[0]/2, mouseloc[1]-vb[1]/2); + + /* Calculate view target position for dolly */ + tvec[0] = -(tpos[0] + dvec[0]); + tvec[1] = -(tpos[1] + dvec[1]); + tvec[2] = -(tpos[2] + dvec[2]); + + /* Offset to target position and dolly */ + new_dist = v3d->dist * dfac; + + VECCOPY(v3d->ofs, tvec); + v3d->dist = new_dist; + + /* Calculate final offset */ + dvec[0] = tvec[0] + dvec[0] * dfac; + dvec[1] = tvec[1] + dvec[1] * dfac; + dvec[2] = tvec[2] + dvec[2] * dfac; + + VECCOPY(v3d->ofs, dvec); + } else { + v3d->dist *= dfac; + } +} + + +#define COS45 0.70710678118654746 +#define SIN45 COS45 + +void viewmove(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, int mode) +{ + static float lastofs[3] = {0,0,0}; + Object *ob = OBACT; + float firstvec[3], newvec[3], dvec[3]; + float reverse, oldquat[4], q1[4], si, phi, dist0; + float ofs[3], obofs[3]= {0.0f, 0.0f, 0.0f}; + int firsttime=1; + short mvalball[2], mval[2], mvalo[2], mval_area[2], mvali[2]; + short use_sel = 0; + short preview3d_event= 1; + + // locals for dist correction + float mat[3][3]; + float upvec[3]; + + /* 3D window may not be defined */ + if( !v3d ) { + fprintf( stderr, "v3d == NULL in viewmove()\n" ); + return; + } + + // dist correction from other movement devices + if((dz_flag)||v3d->dist==0) { + dz_flag = 0; + v3d->dist = m_dist; + upvec[0] = upvec[1] = 0; + upvec[2] = v3d->dist; + Mat3CpyMat4(mat, v3d->viewinv); + Mat3MulVecfl(mat, upvec); + VecAddf(v3d->ofs, v3d->ofs, upvec); + } + + /* sometimes this routine is called from headerbuttons */ + +// XXX areawinset(ar->win); + + QUATCOPY(oldquat, v3d->viewquat); + +// XXX getmouseco_areawin(mval_area); /* for zoom to mouse loc */ +// XXX getmouseco_sc(mvali); /* work with screen coordinates because of trackball function */ + mvalball[0]= mvalo[0] = mvali[0]; /* needed for turntable to work */ + mvalball[1]= mvalo[1] = mvali[1]; + dist0= v3d->dist; + + calctrackballvec(&ar->winrct, mvalo, firstvec); + + /* cumultime(0); */ + + if(!G.obedit && (G.f & G_SCULPTMODE) && ob && v3d->pivot_last) { + use_sel= 1; + VecCopyf(ofs, v3d->ofs); + +// XXX VecCopyf(obofs, sculpt_data()->pivot); + Mat4MulVecfl(ob->obmat, obofs); + obofs[0]= -obofs[0]; + obofs[1]= -obofs[1]; + obofs[2]= -obofs[2]; + } + else if (U.uiflag & USER_ORBIT_SELECTION) { + use_sel = 1; + + VECCOPY(ofs, v3d->ofs); + + /* If there's no selection, lastofs is unmodified and last value since static */ +// XXX calculateTransformCenter(V3D_CENTROID, lastofs); + + VECCOPY(obofs, lastofs); + VecMulf(obofs, -1.0f); + } + else if (U.uiflag & USER_ORBIT_ZBUF) { + if ((use_sel= view_autodist(C, scene, ar, v3d, mval, obofs))) { + if (v3d->persp==V3D_PERSP) { + float my_origin[3]; /* original v3d->ofs */ + float my_pivot[3]; /* view */ + + VECCOPY(my_origin, v3d->ofs); + VecMulf(my_origin, -1.0f); /* ofs is flipped */ + + /* Set the dist value to be the distance from this 3d point */ + /* this means youll always be able to zoom into it and panning wont go bad when dist was zero */ + + /* remove dist value */ + upvec[0] = upvec[1] = 0; + upvec[2] = v3d->dist; + Mat3CpyMat4(mat, v3d->viewinv); + Mat3MulVecfl(mat, upvec); + VecSubf(my_pivot, v3d->ofs, upvec); + VecMulf(my_pivot, -1.0f); /* ofs is flipped */ + + /* find a new ofs value that is allong the view axis (rather then the mouse location) */ + lambda_cp_line_ex(obofs, my_pivot, my_origin, dvec); + dist0 = v3d->dist = VecLenf(my_pivot, dvec); + + VecMulf(dvec, -1.0f); + VECCOPY(v3d->ofs, dvec); + } + VecMulf(obofs, -1.0f); + VECCOPY(ofs, v3d->ofs); + } else { + ofs[0] = ofs[1] = ofs[2] = 0.0f; + } + } + else + ofs[0] = ofs[1] = ofs[2] = 0.0f; + + initgrabz(v3d, -v3d->ofs[0], -v3d->ofs[1], -v3d->ofs[2]); + + reverse= 1.0f; + if (v3d->persmat[2][1] < 0.0f) + reverse= -1.0f; + + while(TRUE) { +// XXX getmouseco_sc(mval); + + if( (mode==2 && U.viewzoom==USER_ZOOM_CONT) || /* continues zoom always update */ + mval[0]!=mvalo[0] || mval[1]!=mvalo[1]) { /* mouse moved, so update */ + + if(firsttime) { + + firsttime= 0; + /* are we translating, rotating or zooming? */ + if(mode==0) { +// XXX if(v3d->view!=0) scrarea_queue_headredraw(ar); /*for button */ + } + if(v3d->persp==V3D_CAMOB && mode!=1 && v3d->camera) { + v3d->persp= V3D_PERSP; +// XXX scrarea_do_windraw(ar); +// XXX scrarea_queue_headredraw(ar); + } + } + + if(mode==0) { /* view rotate */ + v3d->view= 0; /* need to reset everytime because of view snapping */ + + if (U.uiflag & USER_AUTOPERSP) v3d->persp= V3D_PERSP; + + if (U.flag & USER_TRACKBALL) mvalball[0]= mval[0]; + mvalball[1]= mval[1]; + + calctrackballvec(&ar->winrct, mvalball, newvec); + + VecSubf(dvec, newvec, firstvec); + + si= sqrt(dvec[0]*dvec[0]+ dvec[1]*dvec[1]+ dvec[2]*dvec[2]); + si/= (2.0*TRACKBALLSIZE); + + if (U.flag & USER_TRACKBALL) { + Crossf(q1+1, firstvec, newvec); + + Normalize(q1+1); + + /* Allow for rotation beyond the interval + * [-pi, pi] */ + while (si > 1.0) + si -= 2.0; + + /* This relation is used instead of + * phi = asin(si) so that the angle + * of rotation is linearly proportional + * to the distance that the mouse is + * dragged. */ + phi = si * M_PI / 2.0; + + si= sin(phi); + q1[0]= cos(phi); + q1[1]*= si; + q1[2]*= si; + q1[3]*= si; + QuatMul(v3d->viewquat, q1, oldquat); + + if (use_sel) { + /* compute the post multiplication quat, to rotate the offset correctly */ + QUATCOPY(q1, oldquat); + QuatConj(q1); + QuatMul(q1, q1, v3d->viewquat); + + QuatConj(q1); /* conj == inv for unit quat */ + VECCOPY(v3d->ofs, ofs); + VecSubf(v3d->ofs, v3d->ofs, obofs); + QuatMulVecf(q1, v3d->ofs); + VecAddf(v3d->ofs, v3d->ofs, obofs); + } + } else { + /* New turntable view code by John Aughey */ + + float m[3][3]; + float m_inv[3][3]; + float xvec[3] = {1,0,0}; + /* Sensitivity will control how fast the viewport rotates. 0.0035 was + obtained experimentally by looking at viewport rotation sensitivities + on other modeling programs. */ + /* Perhaps this should be a configurable user parameter. */ + const float sensitivity = 0.0035; + + /* Get the 3x3 matrix and its inverse from the quaternion */ + QuatToMat3(v3d->viewquat, m); + Mat3Inv(m_inv,m); + + /* Determine the direction of the x vector (for rotating up and down) */ + /* This can likely be compuated directly from the quaternion. */ + Mat3MulVecfl(m_inv,xvec); + + /* Perform the up/down rotation */ + phi = sensitivity * -(mval[1] - mvalo[1]); + si = sin(phi); + q1[0] = cos(phi); + q1[1] = si * xvec[0]; + q1[2] = si * xvec[1]; + q1[3] = si * xvec[2]; + QuatMul(v3d->viewquat, v3d->viewquat, q1); + + if (use_sel) { + QuatConj(q1); /* conj == inv for unit quat */ + VecSubf(v3d->ofs, v3d->ofs, obofs); + QuatMulVecf(q1, v3d->ofs); + VecAddf(v3d->ofs, v3d->ofs, obofs); + } + + /* Perform the orbital rotation */ + phi = sensitivity * reverse * (mval[0] - mvalo[0]); + q1[0] = cos(phi); + q1[1] = q1[2] = 0.0; + q1[3] = sin(phi); + QuatMul(v3d->viewquat, v3d->viewquat, q1); + + if (use_sel) { + QuatConj(q1); + VecSubf(v3d->ofs, v3d->ofs, obofs); + QuatMulVecf(q1, v3d->ofs); + VecAddf(v3d->ofs, v3d->ofs, obofs); + } + } + + /* check for view snap */ + if (G.qual==LR_CTRLKEY){ + int i; + float viewmat[3][3]; + + static const float thres = 0.93f; //cos(20 deg); + + static float snapquats[39][6] = { + /*{q0, q1, q3, q4, view, oposite_direction}*/ + {COS45, -SIN45, 0.0, 0.0, 1, 0}, //front + {0.0, 0.0, -SIN45, -SIN45, 1, 1}, //back + {1.0, 0.0, 0.0, 0.0, 7, 0}, //top + {0.0, -1.0, 0.0, 0.0, 7, 1}, //bottom + {0.5, -0.5, -0.5, -0.5, 3, 0}, //left + {0.5, -0.5, 0.5, 0.5, 3, 1}, //right + + /* some more 45 deg snaps */ + {0.65328145027160645, -0.65328145027160645, 0.27059805393218994, 0.27059805393218994, 0, 0}, + {0.92387950420379639, 0.0, 0.0, 0.38268342614173889, 0, 0}, + {0.0, -0.92387950420379639, 0.38268342614173889, 0.0, 0, 0}, + {0.35355335474014282, -0.85355335474014282, 0.35355338454246521, 0.14644660055637360, 0, 0}, + {0.85355335474014282, -0.35355335474014282, 0.14644660055637360, 0.35355338454246521, 0, 0}, + {0.49999994039535522, -0.49999994039535522, 0.49999997019767761, 0.49999997019767761, 0, 0}, + {0.27059802412986755, -0.65328145027160645, 0.65328145027160645, 0.27059802412986755, 0, 0}, + {0.65328145027160645, -0.27059802412986755, 0.27059802412986755, 0.65328145027160645, 0, 0}, + {0.27059799432754517, -0.27059799432754517, 0.65328139066696167, 0.65328139066696167, 0, 0}, + {0.38268336653709412, 0.0, 0.0, 0.92387944459915161, 0, 0}, + {0.0, -0.38268336653709412, 0.92387944459915161, 0.0, 0, 0}, + {0.14644658565521240, -0.35355335474014282, 0.85355335474014282, 0.35355335474014282, 0, 0}, + {0.35355335474014282, -0.14644658565521240, 0.35355335474014282, 0.85355335474014282, 0, 0}, + {0.0, 0.0, 0.92387944459915161, 0.38268336653709412, 0, 0}, + {-0.0, 0.0, 0.38268336653709412, 0.92387944459915161, 0, 0}, + {-0.27059802412986755, 0.27059802412986755, 0.65328133106231689, 0.65328133106231689, 0, 0}, + {-0.38268339633941650, 0.0, 0.0, 0.92387938499450684, 0, 0}, + {0.0, 0.38268339633941650, 0.92387938499450684, 0.0, 0, 0}, + {-0.14644658565521240, 0.35355338454246521, 0.85355329513549805, 0.35355332493782043, 0, 0}, + {-0.35355338454246521, 0.14644658565521240, 0.35355332493782043, 0.85355329513549805, 0, 0}, + {-0.49999991059303284, 0.49999991059303284, 0.49999985098838806, 0.49999985098838806, 0, 0}, + {-0.27059799432754517, 0.65328145027160645, 0.65328139066696167, 0.27059799432754517, 0, 0}, + {-0.65328145027160645, 0.27059799432754517, 0.27059799432754517, 0.65328139066696167, 0, 0}, + {-0.65328133106231689, 0.65328133106231689, 0.27059793472290039, 0.27059793472290039, 0, 0}, + {-0.92387932538986206, 0.0, 0.0, 0.38268333673477173, 0, 0}, + {0.0, 0.92387932538986206, 0.38268333673477173, 0.0, 0, 0}, + {-0.35355329513549805, 0.85355329513549805, 0.35355329513549805, 0.14644657075405121, 0, 0}, + {-0.85355329513549805, 0.35355329513549805, 0.14644657075405121, 0.35355329513549805, 0, 0}, + {-0.38268330693244934, 0.92387938499450684, 0.0, 0.0, 0, 0}, + {-0.92387938499450684, 0.38268330693244934, 0.0, 0.0, 0, 0}, + {-COS45, 0.0, 0.0, SIN45, 0, 0}, + {COS45, 0.0, 0.0, SIN45, 0, 0}, + {0.0, 0.0, 0.0, 1.0, 0, 0} + }; + + QuatToMat3(v3d->viewquat, viewmat); + + for (i = 0 ; i < 39; i++){ + float snapmat[3][3]; + float view = (int)snapquats[i][4]; + float oposite_dir = (int)snapquats[i][5]; + + QuatToMat3(snapquats[i], snapmat); + + if ((Inpf(snapmat[0], viewmat[0]) > thres) && + (Inpf(snapmat[1], viewmat[1]) > thres) && + (Inpf(snapmat[2], viewmat[2]) > thres)){ + + QUATCOPY(v3d->viewquat, snapquats[i]); + + v3d->view = view; + if (view){ + if (oposite_dir){ + v3d->flag2 |= V3D_OPP_DIRECTION_NAME; + }else{ + v3d->flag2 &= ~V3D_OPP_DIRECTION_NAME; + } + } + + break; + } + } + } + } + else if(mode==1) { /* translate */ + if(v3d->persp==V3D_CAMOB) { + float max= (float)MAX2(ar->winx, ar->winy); + + v3d->camdx += (mvalo[0]-mval[0])/(max); + v3d->camdy += (mvalo[1]-mval[1])/(max); + CLAMP(v3d->camdx, -1.0f, 1.0f); + CLAMP(v3d->camdy, -1.0f, 1.0f); + preview3d_event= 0; + } + else { + window_to_3d(ar, v3d, dvec, mval[0]-mvalo[0], mval[1]-mvalo[1]); + VecAddf(v3d->ofs, v3d->ofs, dvec); + } + } + else if(mode==2) { + float zfac=1.0; + + /* use initial value (do not use mvalo (that is used to detect mouse moviments)) */ + mvalo[0] = mvali[0]; + mvalo[1] = mvali[1]; + + if(U.viewzoom==USER_ZOOM_CONT) { + // oldstyle zoom + zfac = 1.0+(float)(mvalo[0]-mval[0]+mvalo[1]-mval[1])/1000.0; + } + else if(U.viewzoom==USER_ZOOM_SCALE) { + int ctr[2], len1, len2; + // method which zooms based on how far you move the mouse + + ctr[0] = (ar->winrct.xmax + ar->winrct.xmin)/2; + ctr[1] = (ar->winrct.ymax + ar->winrct.ymin)/2; + + len1 = (int)sqrt((ctr[0] - mval[0])*(ctr[0] - mval[0]) + (ctr[1] - mval[1])*(ctr[1] - mval[1])) + 5; + len2 = (int)sqrt((ctr[0] - mvalo[0])*(ctr[0] - mvalo[0]) + (ctr[1] - mvalo[1])*(ctr[1] - mvalo[1])) + 5; + + zfac = dist0 * ((float)len2/len1) / v3d->dist; + } + else { /* USER_ZOOM_DOLLY */ + float len1 = (ar->winrct.ymax - mval[1]) + 5; + float len2 = (ar->winrct.ymax - mvalo[1]) + 5; + zfac = dist0 * (2.0*((len2/len1)-1.0) + 1.0) / v3d->dist; + } + + if(zfac != 1.0 && zfac*v3d->dist > 0.001*v3d->grid && + zfac*v3d->dist < 10.0*v3d->far) + view_zoom_mouseloc(ar, v3d, zfac, mval_area); + + + if ((U.uiflag & USER_ORBIT_ZBUF) && (U.viewzoom==USER_ZOOM_CONT) && (v3d->persp==V3D_PERSP)) { + /* Secret apricot feature, translate the view when in continues mode */ + upvec[0] = upvec[1] = 0; + upvec[2] = (dist0 - v3d->dist) * v3d->grid; + v3d->dist = dist0; + Mat3CpyMat4(mat, v3d->viewinv); + Mat3MulVecfl(mat, upvec); + VecAddf(v3d->ofs, v3d->ofs, upvec); + } else { + /* these limits are in toets.c too */ + if(v3d->dist<0.001*v3d->grid) v3d->dist= 0.001*v3d->grid; + if(v3d->dist>10.0*v3d->far) v3d->dist=10.0*v3d->far; + } + + if(v3d->persp==V3D_ORTHO || v3d->persp==V3D_CAMOB) preview3d_event= 0; + } + + + + mvalo[0]= mval[0]; + mvalo[1]= mval[1]; + +// XXX if(G.f & G_PLAYANIM) inner_play_anim_loop(0, 0); + + /* If in retopo paint mode, update lines */ + if(retopo_mesh_paint_check() && v3d->retopo_view_data) { + v3d->retopo_view_data->queue_matrix_update= 1; + retopo_paint_view_update(v3d); + } + +// XXX scrarea_do_windraw(ar); +// XXX screen_swapbuffers(); + } + else { +// short val; +// unsigned short event; + /* we need to empty the queue... when you do this very long it overflows */ +// XX while(qtest()) event= extern_qread(&val); + +// XXX BIF_wait_for_statechange(); + } + + /* this in the end, otherwise get_mbut does not work on a PC... */ +// XXX if( !(get_mbut() & (L_MOUSE|M_MOUSE))) break; + } + + if(v3d->depths) v3d->depths->damaged= 1; +// XXX retopo_queue_updates(v3d); +// XXX allqueue(REDRAWVIEW3D, 0); + +// XXX if(preview3d_event) +// BIF_view3d_previewrender_signal(ar, PR_DBASE|PR_DISPRECT); +// else +// BIF_view3d_previewrender_signal(ar, PR_PROJECTED); + +} + + +void viewmoveNDOF(Scene *scene, View3D *v3d, int mode) +{ + float fval[7]; + float dvec[3]; + float sbadjust = 1.0f; + float len; + short use_sel = 0; + Object *ob = OBACT; + float m[3][3]; + float m_inv[3][3]; + float xvec[3] = {1,0,0}; + float yvec[3] = {0,-1,0}; + float zvec[3] = {0,0,1}; + float phi, si; + float q1[4]; + float obofs[3]; + float reverse; + //float diff[4]; + float d, curareaX, curareaY; + float mat[3][3]; + float upvec[3]; + + /* Sensitivity will control how fast the view rotates. The value was + * obtained experimentally by tweaking until the author didn't get dizzy watching. + * Perhaps this should be a configurable user parameter. + */ + float psens = 0.005f * (float) U.ndof_pan; /* pan sensitivity */ + float rsens = 0.005f * (float) U.ndof_rotate; /* rotate sensitivity */ + float zsens = 0.3f; /* zoom sensitivity */ + + const float minZoom = -30.0f; + const float maxZoom = 300.0f; + + //reset view type + v3d->view = 0; +//printf("passing here \n"); +// + if (G.obedit==NULL && ob && !(ob->flag & OB_POSEMODE)) { + use_sel = 1; + } + + if((dz_flag)||v3d->dist==0) { + dz_flag = 0; + v3d->dist = m_dist; + upvec[0] = upvec[1] = 0; + upvec[2] = v3d->dist; + Mat3CpyMat4(mat, v3d->viewinv); + Mat3MulVecfl(mat, upvec); + VecAddf(v3d->ofs, v3d->ofs, upvec); + } + + /*---------------------------------------------------- + * sometimes this routine is called from headerbuttons + * viewmove needs to refresh the screen + */ +// XXX areawinset(curarea->win); + + /*---------------------------------------------------- + * record how much time has passed. clamp at 10 Hz + * pretend the previous frame occured at the clamped time + */ +// now = PIL_check_seconds_timer(); + // frametime = (now - prevTime); + // if (frametime > 0.1f){ /* if more than 1/10s */ + // frametime = 1.0f/60.0; /* clamp at 1/60s so no jumps when starting to move */ +// } +// prevTime = now; + // sbadjust *= 60 * frametime; /* normalize ndof device adjustments to 100Hz for framerate independence */ + + /* fetch the current state of the ndof device & enforce dominant mode if selected */ +// XXX getndof(fval); + if (v3d->ndoffilter) + filterNDOFvalues(fval); + + + // put scaling back here, was previously in ghostwinlay + fval[0] = fval[0] * (1.0f/600.0f); + fval[1] = fval[1] * (1.0f/600.0f); + fval[2] = fval[2] * (1.0f/1100.0f); + fval[3] = fval[3] * 0.00005f; + fval[4] =-fval[4] * 0.00005f; + fval[5] = fval[5] * 0.00005f; + fval[6] = fval[6] / 1000000.0f; + + // scale more if not in perspective mode + if (v3d->persp == V3D_ORTHO) { + fval[0] = fval[0] * 0.05f; + fval[1] = fval[1] * 0.05f; + fval[2] = fval[2] * 0.05f; + fval[3] = fval[3] * 0.9f; + fval[4] = fval[4] * 0.9f; + fval[5] = fval[5] * 0.9f; + zsens *= 8; + } + + + /* set object offset */ + if (ob) { + obofs[0] = -ob->obmat[3][0]; + obofs[1] = -ob->obmat[3][1]; + obofs[2] = -ob->obmat[3][2]; + } + else { + VECCOPY(obofs, v3d->ofs); + } + + /* calc an adjustment based on distance from camera + disabled per patch 14402 */ + d = 1.0f; + +/* if (ob) { + VecSubf(diff, obofs, v3d->ofs); + d = VecLength(diff); + } +*/ + + reverse = (v3d->persmat[2][1] < 0.0f) ? -1.0f : 1.0f; + + /*---------------------------------------------------- + * ndof device pan + */ + psens *= 1.0f + d; + curareaX = sbadjust * psens * fval[0]; + curareaY = sbadjust * psens * fval[1]; + dvec[0] = curareaX * v3d->persinv[0][0] + curareaY * v3d->persinv[1][0]; + dvec[1] = curareaX * v3d->persinv[0][1] + curareaY * v3d->persinv[1][1]; + dvec[2] = curareaX * v3d->persinv[0][2] + curareaY * v3d->persinv[1][2]; + VecAddf(v3d->ofs, v3d->ofs, dvec); + + /*---------------------------------------------------- + * ndof device dolly + */ + len = zsens * sbadjust * fval[2]; + + if (v3d->persp==V3D_CAMOB) { + if(v3d->persp==V3D_CAMOB) { /* This is stupid, please fix - TODO */ + v3d->camzoom+= 10.0f * -len; + } + if (v3d->camzoom < minZoom) v3d->camzoom = minZoom; + else if (v3d->camzoom > maxZoom) v3d->camzoom = maxZoom; + } + else if ((v3d->dist> 0.001*v3d->grid) && (v3d->dist<10.0*v3d->far)) { + v3d->dist*=(1.0 + len); + } + + + /*---------------------------------------------------- + * ndof device turntable + * derived from the turntable code in viewmove + */ + + /* Get the 3x3 matrix and its inverse from the quaternion */ + QuatToMat3(v3d->viewquat, m); + Mat3Inv(m_inv,m); + + /* Determine the direction of the x vector (for rotating up and down) */ + /* This can likely be compuated directly from the quaternion. */ + Mat3MulVecfl(m_inv,xvec); + Mat3MulVecfl(m_inv,yvec); + Mat3MulVecfl(m_inv,zvec); + + /* Perform the up/down rotation */ + phi = sbadjust * rsens * /*0.5f * */ fval[3]; /* spin vertically half as fast as horizontally */ + si = sin(phi); + q1[0] = cos(phi); + q1[1] = si * xvec[0]; + q1[2] = si * xvec[1]; + q1[3] = si * xvec[2]; + QuatMul(v3d->viewquat, v3d->viewquat, q1); + + if (use_sel) { + QuatConj(q1); /* conj == inv for unit quat */ + VecSubf(v3d->ofs, v3d->ofs, obofs); + QuatMulVecf(q1, v3d->ofs); + VecAddf(v3d->ofs, v3d->ofs, obofs); + } + + /* Perform the orbital rotation */ + /* Perform the orbital rotation + If the seen Up axis is parallel to the zoom axis, rotation should be + achieved with a pure Roll motion (no Spin) on the device. When you start + to tilt, moving from Top to Side view, Spinning will increasingly become + more relevant while the Roll component will decrease. When a full + Side view is reached, rotations around the world's Up axis are achieved + with a pure Spin-only motion. In other words the control of the spinning + around the world's Up axis should move from the device's Spin axis to the + device's Roll axis depending on the orientation of the world's Up axis + relative to the screen. */ + //phi = sbadjust * rsens * reverse * fval[4]; /* spin the knob, y axis */ + phi = sbadjust * rsens * (yvec[2] * fval[4] + zvec[2] * fval[5]); + q1[0] = cos(phi); + q1[1] = q1[2] = 0.0; + q1[3] = sin(phi); + QuatMul(v3d->viewquat, v3d->viewquat, q1); + + if (use_sel) { + QuatConj(q1); + VecSubf(v3d->ofs, v3d->ofs, obofs); + QuatMulVecf(q1, v3d->ofs); + VecAddf(v3d->ofs, v3d->ofs, obofs); + } + + /*---------------------------------------------------- + * refresh the screen + */ +// XXX scrarea_do_windraw(curarea); +} + + + + diff --git a/source/blender/editors/space_view3d/view3d_header.c b/source/blender/editors/space_view3d/view3d_header.c index aa950b87238..0f4ecd2ef7b 100644 --- a/source/blender/editors/space_view3d/view3d_header.c +++ b/source/blender/editors/space_view3d/view3d_header.c @@ -29,6 +29,7 @@ #include <string.h> #include <stdio.h> +#include "DNA_object_types.h" #include "DNA_space_types.h" #include "DNA_scene_types.h" #include "DNA_screen_types.h" diff --git a/source/blender/editors/space_view3d/view3d_intern.h b/source/blender/editors/space_view3d/view3d_intern.h index d0e49373562..331b5553869 100644 --- a/source/blender/editors/space_view3d/view3d_intern.h +++ b/source/blender/editors/space_view3d/view3d_intern.h @@ -30,6 +30,11 @@ /* internal exports only */ +struct wmWindow; +struct BoundBox; +struct Object; +struct DerivedMesh; + typedef struct ViewDepths { unsigned short w, h; float *depths; @@ -43,34 +48,75 @@ typedef struct ViewDepths { #define DRAW_CONSTCOLOR 2 #define DRAW_SCENESET 4 +#define V3D_XRAY 1 +#define V3D_TRANSP 2 + /* project short */ #define IS_CLIPPED 12000 /* view3d_header.c */ void view3d_header_buttons(const bContext *C, ARegion *ar); +/* drawobject.c */ +void draw_object(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag); +int draw_glsl_material(Scene *scene, Object *ob, View3D *v3d, int dt); + +/* drawmesh.c */ +void draw_mesh_textured(Scene *scene, View3D *v3d, Object *ob, struct DerivedMesh *dm, int faceselect); + /* view3d_draw.c */ void drawview3dspace(const bContext *C, ARegion *ar, View3D *v3d); +void draw_depth(const bContext *C, Scene *scene, ARegion *ar, View3D *v3d, int (* func)(void *)); int view3d_test_clipping(View3D *v3d, float *vec); +void view3d_clr_clipping(void); +void view3d_set_clipping(View3D *v3d); +void add_view3d_after(View3D *v3d, Base *base, int type, int flag); +void make_axis_color(char *col, char *col2, char axis); + void circf(float x, float y, float rad); void circ(float x, float y, float rad); void view3d_update_depths(ARegion *ar, View3D *v3d); /* view3d_view.c */ float *give_cursor(Scene *scene, View3D *v3d); +void viewline(ARegion *ar, View3D *v3d, short mval[2], float ray_start[3], float ray_end[3]); +void viewray(ARegion *ar, View3D *v3d, short mval[2], float ray_start[3], float ray_normal[3]); + void initgrabz(View3D *v3d, float x, float y, float z); void window_to_3d(ARegion *ar, View3D *v3d, float *vec, short mx, short my); +int boundbox_clip(View3D *v3d, float obmat[][4], struct BoundBox *bb); + +void view3d_project_short_clip(ARegion *ar, View3D *v3d, float *vec, short *adr, float projmat[4][4], float wmat[4][4]); +void view3d_project_short_noclip(ARegion *ar, float *vec, short *adr, float mat[4][4]); void view3d_project_float(ARegion *a, float *vec, float *adr, float mat[4][4]); +void view3d_get_object_project_mat(View3D *v3d, struct Object *ob, float pmat[4][4], float vmat[4][4]); +void view3d_project_float(ARegion *ar, float *vec, float *adr, float mat[4][4]); + void project_short(ARegion *ar, View3D *v3d, float *vec, short *adr); void project_int(ARegion *ar, View3D *v3d, float *vec, int *adr); void project_int_noclip(ARegion *ar, View3D *v3d, float *vec, int *adr); void project_short_noclip(ARegion *ar, View3D *v3d, float *vec, short *adr); void project_float(ARegion *ar, View3D *v3d, float *vec, float *adr); void project_float_noclip(ARegion *ar, View3D *v3d, float *vec, float *adr); + int get_view3d_viewplane(View3D *v3d, int winxi, int winyi, rctf *viewplane, float *clipsta, float *clipend, float *pixsize); +void view_settings_from_ob(Object *ob, float *ofs, float *quat, float *dist, float *lens); +void obmat_to_viewmat(View3D *v3d, Object *ob, short smooth); + +short view3d_opengl_select(bContext *C, Scene *scene, ARegion *ar, View3D *v3d, unsigned int *buffer, unsigned int bufsize, rcti *input); +void initlocalview(Scene *scene, ARegion *ar, View3D *v3d); +void restore_localviewdata(View3D *vd); +void endlocalview(Scene *scene, ScrArea *sa); + +void centerview(ARegion *ar, View3D *v3d); +void view3d_home(View3D *v3d, ARegion *ar, int center); + +void view3d_align_axis_to_vector(View3D *v3d, int axisidx, float vec[3]); +void smooth_view(View3D *v3d, float *ofs, float *quat, float *dist, float *lens); +void smooth_view_to_camera(View3D *v3d); -void setwinmatrixview3d(wmWindow *win, View3D *v3d, int winx, int winy, rctf *rect); /* rect: for picking */ +void setwinmatrixview3d(struct wmWindow *win, View3D *v3d, int winx, int winy, rctf *rect); /* rect: for picking */ void setviewmatrixview3d(View3D *v3d); #endif /* ED_VIEW3D_INTERN_H */ diff --git a/source/blender/editors/space_view3d/view3d_view.c b/source/blender/editors/space_view3d/view3d_view.c index 26566ec7b8a..a7d8360157d 100644 --- a/source/blender/editors/space_view3d/view3d_view.c +++ b/source/blender/editors/space_view3d/view3d_view.c @@ -32,6 +32,7 @@ #include <float.h> #include "DNA_action_types.h" +#include "DNA_armature_types.h" #include "DNA_camera_types.h" #include "DNA_lamp_types.h" #include "DNA_object_types.h" @@ -48,10 +49,12 @@ #include "BLI_arithb.h" #include "BLI_rand.h" +#include "BKE_anim.h" #include "BKE_action.h" #include "BKE_context.h" #include "BKE_object.h" #include "BKE_global.h" +#include "BKE_main.h" #include "BKE_scene.h" #include "BKE_screen.h" #include "BKE_utildefines.h" @@ -72,6 +75,7 @@ #include "view3d_intern.h" // own include +#define BL_NEAR_CLIP 0.001 float *give_cursor(Scene *scene, View3D *v3d) { @@ -79,6 +83,49 @@ float *give_cursor(Scene *scene, View3D *v3d) else return scene->cursor; } +/* create intersection coordinates in view Z direction at mouse coordinates */ +void viewline(ARegion *ar, View3D *v3d, short mval[2], float ray_start[3], float ray_end[3]) +{ + float vec[4]; + + if(v3d->persp != V3D_ORTHO){ + vec[0]= 2.0f * mval[0] / ar->winx - 1; + vec[1]= 2.0f * mval[1] / ar->winy - 1; + vec[2]= -1.0f; + vec[3]= 1.0f; + + Mat4MulVec4fl(v3d->persinv, vec); + VecMulf(vec, 1.0f / vec[3]); + + VECCOPY(ray_start, v3d->viewinv[3]); + VECSUB(vec, vec, ray_start); + Normalize(vec); + + VECADDFAC(ray_start, v3d->viewinv[3], vec, v3d->near); + VECADDFAC(ray_end, v3d->viewinv[3], vec, v3d->far); + } + else { + vec[0] = 2.0f * mval[0] / ar->winx - 1; + vec[1] = 2.0f * mval[1] / ar->winy - 1; + vec[2] = 0.0f; + vec[3] = 1.0f; + + Mat4MulVec4fl(v3d->persinv, vec); + + VECADDFAC(ray_start, vec, v3d->viewinv[2], 1000.0f); + VECADDFAC(ray_end, vec, v3d->viewinv[2], -1000.0f); + } +} + +/* create intersection ray in view Z direction at mouse coordinates */ +void viewray(ARegion *ar, View3D *v3d, short mval[2], float ray_start[3], float ray_normal[3]) +{ + float ray_end[3]; + + viewline(ar, v3d, mval, ray_start, ray_end); + VecSubf(ray_normal, ray_end, ray_start); + Normalize(ray_normal); +} void initgrabz(View3D *v3d, float x, float y, float z) @@ -110,6 +157,75 @@ void window_to_3d(ARegion *ar, View3D *v3d, float *vec, short mx, short my) vec[2]= (v3d->persinv[0][2]*dx + v3d->persinv[1][2]*dy); } +void view3d_get_object_project_mat(View3D *v3d, Object *ob, float pmat[4][4], float vmat[4][4]) +{ + Mat4MulMat4(vmat, ob->obmat, v3d->viewmat); + Mat4MulMat4(pmat, vmat, v3d->winmat); + Mat4CpyMat4(vmat, ob->obmat); +} + +/* projectmat brings it to window coords, wmat to rotated world space */ +void view3d_project_short_clip(ARegion *ar, View3D *v3d, float *vec, short *adr, float projmat[4][4], float wmat[4][4]) +{ + float fx, fy, vec4[4]; + + adr[0]= IS_CLIPPED; + + /* clipplanes in eye space */ + if(v3d->flag & V3D_CLIPPING) { + VECCOPY(vec4, vec); + Mat4MulVecfl(wmat, vec4); + if(view3d_test_clipping(v3d, vec4)) + return; + } + + VECCOPY(vec4, vec); + vec4[3]= 1.0; + + Mat4MulVec4fl(projmat, vec4); + + /* clipplanes in window space */ + if( vec4[3]>BL_NEAR_CLIP ) { /* 0.001 is the NEAR clipping cutoff for picking */ + fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]); + + if( fx>0 && fx<ar->winx) { + + fy= (ar->winy/2)*(1 + vec4[1]/vec4[3]); + + if(fy>0.0 && fy< (float)ar->winy) { + adr[0]= (short)floor(fx); + adr[1]= (short)floor(fy); + } + } + } +} + +void view3d_project_short_noclip(ARegion *ar, float *vec, short *adr, float mat[4][4]) +{ + float fx, fy, vec4[4]; + + adr[0]= IS_CLIPPED; + + VECCOPY(vec4, vec); + vec4[3]= 1.0; + + Mat4MulVec4fl(mat, vec4); + + if( vec4[3]>BL_NEAR_CLIP ) { /* 0.001 is the NEAR clipping cutoff for picking */ + fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]); + + if( fx>-32700 && fx<32700) { + + fy= (ar->winy/2)*(1 + vec4[1]/vec4[3]); + + if(fy>-32700.0 && fy<32700.0) { + adr[0]= (short)floor(fx); + adr[1]= (short)floor(fy); + } + } + } +} + void view3d_project_float(ARegion *ar, float *vec, float *adr, float mat[4][4]) { float vec4[4]; @@ -128,8 +244,40 @@ void view3d_project_float(ARegion *ar, float *vec, float *adr, float mat[4][4]) } } - -#define BL_NEAR_CLIP 0.001 +int boundbox_clip(View3D *v3d, float obmat[][4], BoundBox *bb) +{ + /* return 1: draw */ + + float mat[4][4]; + float vec[4], min, max; + int a, flag= -1, fl; + + if(bb==NULL) return 1; + if(bb->flag & OB_BB_DISABLED) return 1; + + Mat4MulMat4(mat, obmat, v3d->persmat); + + for(a=0; a<8; a++) { + VECCOPY(vec, bb->vec[a]); + vec[3]= 1.0; + Mat4MulVec4fl(mat, vec); + max= vec[3]; + min= -vec[3]; + + fl= 0; + if(vec[0] < min) fl+= 1; + if(vec[0] > max) fl+= 2; + if(vec[1] < min) fl+= 4; + if(vec[1] > max) fl+= 8; + if(vec[2] < min) fl+= 16; + if(vec[2] > max) fl+= 32; + + flag &= fl; + if(flag==0) return 1; + } + + return 0; +} void project_short(ARegion *ar, View3D *v3d, float *vec, short *adr) /* clips */ { @@ -427,125 +575,9 @@ void setwinmatrixview3d(wmWindow *win, View3D *v3d, int winx, int winy, rctf *re } -/* SMOOTHVIEW */ -void smooth_view(View3D *v3d, float *ofs, float *quat, float *dist, float *lens) -{ - /* View Animation enabled */ - if (U.smooth_viewtx) { - int i; - char changed = 0; - float step = 0.0, step_inv; - float orig_dist; - float orig_lens; - float orig_quat[4]; - float orig_ofs[3]; - - double time_allowed, time_current, time_start; - - /* if there is no difference, return */ - changed = 0; /* zero means no difference */ - if (dist) { - if ((*dist) != v3d->dist) - changed = 1; - } - - if (lens) { - if ((*lens) != v3d->lens) - changed = 1; - } - - if (!changed && ofs) { - if ((ofs[0]!=v3d->ofs[0]) || - (ofs[1]!=v3d->ofs[1]) || - (ofs[2]!=v3d->ofs[2]) ) - changed = 1; - } - - if (!changed && quat ) { - if ((quat[0]!=v3d->viewquat[0]) || - (quat[1]!=v3d->viewquat[1]) || - (quat[2]!=v3d->viewquat[2]) || - (quat[3]!=v3d->viewquat[3]) ) - changed = 1; - } - - /* The new view is different from the old one - * so animate the view */ - if (changed) { - - /* store original values */ - VECCOPY(orig_ofs, v3d->ofs); - QUATCOPY(orig_quat, v3d->viewquat); - orig_dist = v3d->dist; - orig_lens = v3d->lens; - - time_allowed= (float)U.smooth_viewtx / 1000.0; - time_current = time_start = PIL_check_seconds_timer(); - - /* if this is view rotation only - * we can decrease the time allowed by - * the angle between quats - * this means small rotations wont lag */ - if (quat && !ofs && !dist) { - float vec1[3], vec2[3]; - VECCOPY(vec1, quat); - VECCOPY(vec2, v3d->viewquat); - Normalize(vec1); - Normalize(vec2); - /* scale the time allowed by the rotation */ - time_allowed *= NormalizedVecAngle2(vec1, vec2)/(M_PI/2); - } - - while (time_start + time_allowed > time_current) { - - step = (float)((time_current-time_start) / time_allowed); - - /* ease in/out */ - if (step < 0.5) step = (float)pow(step*2, 2)/2; - else step = (float)1-(pow(2*(1-step),2)/2); - - step_inv = 1-step; - - if (ofs) - for (i=0; i<3; i++) - v3d->ofs[i] = ofs[i]*step + orig_ofs[i]*step_inv; - - - if (quat) - QuatInterpol(v3d->viewquat, orig_quat, quat, step); - - if (dist) - v3d->dist = ((*dist)*step) + (orig_dist*step_inv); - - if (lens) - v3d->lens = ((*lens)*step) + (orig_lens*step_inv); - - /*redraw the view*/ -// scrarea_do_windraw(ar); -// screen_swapbuffers(); - - time_current= PIL_check_seconds_timer(); - } - } - } - - /* set these values even if animation is enabled because flaot - * error will make then not quite accurate */ - if (ofs) - VECCOPY(v3d->ofs, ofs); - if (quat) - QUATCOPY(v3d->viewquat, quat); - if (dist) - v3d->dist = *dist; - if (lens) - v3d->lens = *lens; - -} - - /* Gets the lens and clipping values from a camera of lamp type object */ -void object_view_settings(Object *ob, float *lens, float *clipsta, float *clipend) +static void object_view_settings(Object *ob, float *lens, float *clipsta, float *clipend) { if (!ob) return; @@ -712,3 +744,674 @@ void setcameratoview3d(View3D *v3d) /*}*/ v3d->viewquat[0]= -v3d->viewquat[0]; } + + +/* IGLuint-> GLuint*/ +/* Warning: be sure to account for a negative return value +* This is an error, "Too many objects in select buffer" +* and no action should be taken (can crash blender) if this happens +*/ +short view3d_opengl_select(bContext *C, Scene *scene, ARegion *ar, View3D *v3d, unsigned int *buffer, unsigned int bufsize, rcti *input) +{ + rctf rect; + short code, hits; + + G.f |= G_PICKSEL; + + /* case not a border select */ + if(input->xmin==input->xmax) { + rect.xmin= input->xmin-12; // seems to be default value for bones only now + rect.xmax= input->xmin+12; + rect.ymin= input->ymin-12; + rect.ymax= input->xmin+12; + } + else { + rect.xmin= input->xmin; + rect.xmax= input->xmax; + rect.ymin= input->ymin; + rect.ymax= input->ymax; + } + + /* get rid of overlay button matrix XXX ?*/ + setwinmatrixview3d(CTX_wm_window(C), v3d, ar->winx, ar->winy, &rect); + Mat4MulMat4(v3d->persmat, v3d->viewmat, v3d->winmat); + + if(v3d->drawtype > OB_WIRE) { + v3d->zbuf= TRUE; + glEnable(GL_DEPTH_TEST); + } + + if(v3d->flag & V3D_CLIPPING) + view3d_set_clipping(v3d); + + glSelectBuffer( bufsize, (GLuint *)buffer); + glRenderMode(GL_SELECT); + glInitNames(); /* these two calls whatfor? It doesnt work otherwise */ + glPushName(-1); + code= 1; + + if(G.obedit && G.obedit->type==OB_MBALL) { + draw_object(C, scene, ar, v3d, BASACT, DRAW_PICKING|DRAW_CONSTCOLOR); + } + else if ((G.obedit && G.obedit->type==OB_ARMATURE)) { + draw_object(C, scene, ar, v3d, BASACT, DRAW_PICKING|DRAW_CONSTCOLOR); + } + else { + Base *base; + + v3d->xray= TRUE; // otherwise it postpones drawing + for(base= scene->base.first; base; base= base->next) { + if(base->lay & v3d->lay) { + + if (base->object->restrictflag & OB_RESTRICT_SELECT) + base->selcol= 0; + else { + base->selcol= code; + glLoadName(code); + draw_object(C, scene, ar, v3d, base, DRAW_PICKING|DRAW_CONSTCOLOR); + + /* we draw group-duplicators for selection too */ + if((base->object->transflag & OB_DUPLI) && base->object->dup_group) { + ListBase *lb; + DupliObject *dob; + Base tbase; + + tbase.flag= OB_FROMDUPLI; + lb= object_duplilist(scene, base->object); + + for(dob= lb->first; dob; dob= dob->next) { + tbase.object= dob->ob; + Mat4CpyMat4(dob->ob->obmat, dob->mat); + + draw_object(C, scene, ar, v3d, &tbase, DRAW_PICKING|DRAW_CONSTCOLOR); + + Mat4CpyMat4(dob->ob->obmat, dob->omat); + } + free_object_duplilist(lb); + } + code++; + } + } + } + v3d->xray= FALSE; // restore + } + + glPopName(); /* see above (pushname) */ + hits= glRenderMode(GL_RENDER); + + G.f &= ~G_PICKSEL; + setwinmatrixview3d(CTX_wm_window(C), v3d, ar->winx, ar->winy, NULL); + Mat4MulMat4(v3d->persmat, v3d->viewmat, v3d->winmat); + + if(v3d->drawtype > OB_WIRE) { + v3d->zbuf= 0; + glDisable(GL_DEPTH_TEST); + } +// XXX persp(PERSP_WIN); + + if(v3d->flag & V3D_CLIPPING) + view3d_clr_clipping(); + + if(hits<0) printf("Too many objects in select buffer\n"); // XXX make error message + + return hits; +} + +// XXX solve: localview on region level? no.... layers are area, so all regions in area have to be set +static unsigned int free_localbit(void) +{ + unsigned int lay; + ScrArea *sa; + bScreen *sc; + + lay= 0; + + /* sometimes we loose a localview: when an area is closed */ + /* check all areas: which localviews are in use? */ + for(sc= G.main->screen.first; sc; sc= sc->id.next) { + for(sa= sc->areabase.first; sa; sa= sa->next) { + SpaceLink *sl= sa->spacedata.first; + for(; sl; sl= sl->next) { + if(sl->spacetype==SPACE_VIEW3D) { + View3D *v3d= (View3D*) sl; + lay |= v3d->lay; + } + } + } + } + + if( (lay & 0x01000000)==0) return 0x01000000; + if( (lay & 0x02000000)==0) return 0x02000000; + if( (lay & 0x04000000)==0) return 0x04000000; + if( (lay & 0x08000000)==0) return 0x08000000; + if( (lay & 0x10000000)==0) return 0x10000000; + if( (lay & 0x20000000)==0) return 0x20000000; + if( (lay & 0x40000000)==0) return 0x40000000; + if( (lay & 0x80000000)==0) return 0x80000000; + + return 0; +} + + +void initlocalview(Scene *scene, ARegion *ar, View3D *v3d) +{ + Base *base; + float size = 0.0, min[3], max[3], afm[3]; + unsigned int locallay; + int ok=0; + + if(v3d->localvd) return; + + INIT_MINMAX(min, max); + + locallay= free_localbit(); + + if(locallay==0) { + printf("Sorry, no more than 8 localviews\n"); // XXX error + ok= 0; + } + else { + if(G.obedit) { + minmax_object(G.obedit, min, max); + + ok= 1; + + BASACT->lay |= locallay; + G.obedit->lay= BASACT->lay; + } + else { + base= FIRSTBASE; + while(base) { + if TESTBASE(base) { + minmax_object(base->object, min, max); + base->lay |= locallay; + base->object->lay= base->lay; + ok= 1; + } + base= base->next; + } + } + + afm[0]= (max[0]-min[0]); + afm[1]= (max[1]-min[1]); + afm[2]= (max[2]-min[2]); + size= 0.7*MAX3(afm[0], afm[1], afm[2]); + if(size<=0.01) size= 0.01; + } + + if(ok) { + v3d->localvd= MEM_mallocN(sizeof(View3D), "localview"); + memcpy(v3d->localvd, v3d, sizeof(View3D)); + + v3d->ofs[0]= -(min[0]+max[0])/2.0; + v3d->ofs[1]= -(min[1]+max[1])/2.0; + v3d->ofs[2]= -(min[2]+max[2])/2.0; + + v3d->dist= size; + + // correction for window aspect ratio + if(ar->winy>2 && ar->winx>2) { + size= (float)ar->winx/(float)ar->winy; + if(size<1.0) size= 1.0/size; + v3d->dist*= size; + } + + if (v3d->persp==V3D_CAMOB) v3d->persp= V3D_PERSP; + if (v3d->near> 0.1) v3d->near= 0.1; + + v3d->cursor[0]= -v3d->ofs[0]; + v3d->cursor[1]= -v3d->ofs[1]; + v3d->cursor[2]= -v3d->ofs[2]; + + v3d->lay= locallay; + +// XXX countall(); +// XXX scrarea_queue_winredraw(curarea); + } + else { + /* clear flags */ + base= FIRSTBASE; + while(base) { + if( base->lay & locallay ) { + base->lay-= locallay; + if(base->lay==0) base->lay= v3d->layact; + if(base->object != G.obedit) base->flag |= SELECT; + base->object->lay= base->lay; + } + base= base->next; + } +// XXX scrarea_queue_headredraw(curarea); + + v3d->localview= 0; + } +// XXX BIF_view3d_previewrender_signal(curarea, PR_DBASE|PR_DISPRECT); +} + +void centerview(ARegion *ar, View3D *v3d) /* like a localview without local! */ +{ + Object *ob= OBACT; + float size, min[3], max[3], afm[3]; + int ok=0; + + /* SMOOTHVIEW */ + float new_ofs[3]; + float new_dist; + + INIT_MINMAX(min, max); + + if (G.f & G_WEIGHTPAINT) { + /* hardcoded exception, we look for the one selected armature */ + /* this is weak code this way, we should make a generic active/selection callback interface once... */ + Base *base; + for(base=FIRSTBASE; base; base= base->next) { + if(TESTBASELIB(base)) { + if(base->object->type==OB_ARMATURE) + if(base->object->flag & OB_POSEMODE) + break; + } + } + if(base) + ob= base->object; + } + + + if(G.obedit) { +// XXX ok = minmax_verts(min, max); /* only selected */ + } + else if(ob && (ob->flag & OB_POSEMODE)) { + if(ob->pose) { + bArmature *arm= ob->data; + bPoseChannel *pchan; + float vec[3]; + + for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) { + if(pchan->bone->flag & BONE_SELECTED) { + if(pchan->bone->layer & arm->layer) { + ok= 1; + VECCOPY(vec, pchan->pose_head); + Mat4MulVecfl(ob->obmat, vec); + DO_MINMAX(vec, min, max); + VECCOPY(vec, pchan->pose_tail); + Mat4MulVecfl(ob->obmat, vec); + DO_MINMAX(vec, min, max); + } + } + } + } + } + else if (FACESEL_PAINT_TEST) { +// XXX ok= minmax_tface(min, max); + } + else if (G.f & G_PARTICLEEDIT) { +// XXX ok= PE_minmax(min, max); + } + else { + Base *base= FIRSTBASE; + while(base) { + if TESTBASE(base) { + minmax_object(base->object, min, max); + /* account for duplis */ + minmax_object_duplis(base->object, min, max); + + ok= 1; + } + base= base->next; + } + } + + if(ok==0) return; + + afm[0]= (max[0]-min[0]); + afm[1]= (max[1]-min[1]); + afm[2]= (max[2]-min[2]); + size= 0.7f*MAX3(afm[0], afm[1], afm[2]); + + if(size <= v3d->near*1.5f) size= v3d->near*1.5f; + + new_ofs[0]= -(min[0]+max[0])/2.0f; + new_ofs[1]= -(min[1]+max[1])/2.0f; + new_ofs[2]= -(min[2]+max[2])/2.0f; + + new_dist = size; + + /* correction for window aspect ratio */ + if(ar->winy>2 && ar->winx>2) { + size= (float)ar->winx/(float)ar->winy; + if(size<1.0f) size= 1.0f/size; + new_dist*= size; + } + + v3d->cursor[0]= -new_ofs[0]; + v3d->cursor[1]= -new_ofs[1]; + v3d->cursor[2]= -new_ofs[2]; + + if (v3d->persp==V3D_CAMOB && v3d->camera) { + float orig_lens= v3d->lens; + + v3d->persp=V3D_PERSP; + v3d->dist= 0.0f; + view_settings_from_ob(v3d->camera, v3d->ofs, NULL, NULL, &v3d->lens); + smooth_view(v3d, new_ofs, NULL, &new_dist, &orig_lens); + } else { + if(v3d->persp==V3D_CAMOB) + v3d->persp= V3D_PERSP; + + smooth_view(v3d, new_ofs, NULL, &new_dist, NULL); + } +// XXX scrarea_queue_winredraw(curarea); +// XXX BIF_view3d_previewrender_signal(curarea, PR_DBASE|PR_DISPRECT); + +} + + +void restore_localviewdata(View3D *vd) +{ + if(vd->localvd==0) return; + + VECCOPY(vd->ofs, vd->localvd->ofs); + vd->dist= vd->localvd->dist; + vd->persp= vd->localvd->persp; + vd->view= vd->localvd->view; + vd->near= vd->localvd->near; + vd->far= vd->localvd->far; + vd->lay= vd->localvd->lay; + vd->layact= vd->localvd->layact; + vd->drawtype= vd->localvd->drawtype; + vd->camera= vd->localvd->camera; + QUATCOPY(vd->viewquat, vd->localvd->viewquat); + +} + +void endlocalview(Scene *scene, ScrArea *sa) +{ + View3D *v3d; + struct Base *base; + unsigned int locallay; + + if(sa->spacetype!=SPACE_VIEW3D) return; + v3d= sa->spacedata.first; + + if(v3d->localvd) { + + locallay= v3d->lay & 0xFF000000; + + restore_localviewdata(v3d); + + MEM_freeN(v3d->localvd); + v3d->localvd= 0; + v3d->localview= 0; + + /* for when in other window the layers have changed */ + if(v3d->scenelock) v3d->lay= scene->lay; + + base= FIRSTBASE; + while(base) { + if( base->lay & locallay ) { + base->lay-= locallay; + if(base->lay==0) base->lay= v3d->layact; + if(base->object != G.obedit) { + base->flag |= SELECT; + base->object->flag |= SELECT; + } + base->object->lay= base->lay; + } + base= base->next; + } + +// XXX countall(); +// XXX allqueue(REDRAWVIEW3D, 0); /* because of select */ +// XXX allqueue(REDRAWOOPS, 0); /* because of select */ +// XXX BIF_view3d_previewrender_signal(curarea, PR_DBASE|PR_DISPRECT); + } +} + +void view3d_home(View3D *v3d, ARegion *ar, int center) +{ + Base *base; + float size, min[3], max[3], afm[3]; + int ok= 1, onedone=0; + + if(center) { + min[0]= min[1]= min[2]= 0.0f; + max[0]= max[1]= max[2]= 0.0f; + } + else { + INIT_MINMAX(min, max); + } + + for(base= FIRSTBASE; base; base= base->next) { + if(base->lay & v3d->lay) { + onedone= 1; + minmax_object(base->object, min, max); + } + } + if(!onedone) return; + + afm[0]= (max[0]-min[0]); + afm[1]= (max[1]-min[1]); + afm[2]= (max[2]-min[2]); + size= 0.7f*MAX3(afm[0], afm[1], afm[2]); + if(size==0.0) ok= 0; + + if(ok) { + float new_dist; + float new_ofs[3]; + + new_dist = size; + new_ofs[0]= -(min[0]+max[0])/2.0f; + new_ofs[1]= -(min[1]+max[1])/2.0f; + new_ofs[2]= -(min[2]+max[2])/2.0f; + + // correction for window aspect ratio + if(ar->winy>2 && ar->winx>2) { + size= (float)ar->winx/(float)ar->winy; + if(size<1.0) size= 1.0f/size; + new_dist*= size; + } + + if (v3d->persp==V3D_CAMOB && v3d->camera) { + /* switch out of camera view */ + float orig_lens= v3d->lens; + + v3d->persp= V3D_PERSP; + v3d->dist= 0.0; + view_settings_from_ob(v3d->camera, v3d->ofs, NULL, NULL, &v3d->lens); + smooth_view(v3d, new_ofs, NULL, &new_dist, &orig_lens); + + } else { + if(v3d->persp==V3D_CAMOB) v3d->persp= V3D_PERSP; + smooth_view(v3d, new_ofs, NULL, &new_dist, NULL); + } +// XXX scrarea_queue_winredraw(curarea); + } +// XXX BIF_view3d_previewrender_signal(curarea, PR_DBASE|PR_DISPRECT); + +} + +void view3d_align_axis_to_vector(View3D *v3d, int axisidx, float vec[3]) +{ + float alignaxis[3] = {0.0, 0.0, 0.0}; + float norm[3], axis[3], angle, new_quat[4]; + + if(axisidx > 0) alignaxis[axisidx-1]= 1.0; + else alignaxis[-axisidx-1]= -1.0; + + VECCOPY(norm, vec); + Normalize(norm); + + angle= (float)acos(Inpf(alignaxis, norm)); + Crossf(axis, alignaxis, norm); + VecRotToQuat(axis, -angle, new_quat); + + v3d->view= 0; + + if (v3d->persp==V3D_CAMOB && v3d->camera) { + /* switch out of camera view */ + float orig_ofs[3]; + float orig_dist= v3d->dist; + float orig_lens= v3d->lens; + + VECCOPY(orig_ofs, v3d->ofs); + v3d->persp= V3D_PERSP; + v3d->dist= 0.0; + view_settings_from_ob(v3d->camera, v3d->ofs, NULL, NULL, &v3d->lens); + smooth_view(v3d, orig_ofs, new_quat, &orig_dist, &orig_lens); + } else { + if (v3d->persp==V3D_CAMOB) v3d->persp= V3D_PERSP; /* switch out of camera mode */ + smooth_view(v3d, NULL, new_quat, NULL, NULL); + } +} + + + +/* SMOOTHVIEW */ +void smooth_view(View3D *v3d, float *ofs, float *quat, float *dist, float *lens) +{ + /* View Animation enabled */ + if (U.smooth_viewtx) { + int i; + char changed = 0; + float step = 0.0, step_inv; + float orig_dist; + float orig_lens; + float orig_quat[4]; + float orig_ofs[3]; + + double time_allowed, time_current, time_start; + + /* if there is no difference, return */ + changed = 0; /* zero means no difference */ + if (dist) { + if ((*dist) != v3d->dist) + changed = 1; + } + + if (lens) { + if ((*lens) != v3d->lens) + changed = 1; + } + + if (!changed && ofs) { + if ((ofs[0]!=v3d->ofs[0]) || + (ofs[1]!=v3d->ofs[1]) || + (ofs[2]!=v3d->ofs[2]) ) + changed = 1; + } + + if (!changed && quat ) { + if ((quat[0]!=v3d->viewquat[0]) || + (quat[1]!=v3d->viewquat[1]) || + (quat[2]!=v3d->viewquat[2]) || + (quat[3]!=v3d->viewquat[3]) ) + changed = 1; + } + + /* The new view is different from the old one + * so animate the view */ + if (changed) { + + /* store original values */ + VECCOPY(orig_ofs, v3d->ofs); + QUATCOPY(orig_quat, v3d->viewquat); + orig_dist = v3d->dist; + orig_lens = v3d->lens; + + time_allowed= (float)U.smooth_viewtx / 1000.0; + time_current = time_start = PIL_check_seconds_timer(); + + /* if this is view rotation only + * we can decrease the time allowed by + * the angle between quats + * this means small rotations wont lag */ + if (quat && !ofs && !dist) { + float vec1[3], vec2[3]; + VECCOPY(vec1, quat); + VECCOPY(vec2, v3d->viewquat); + Normalize(vec1); + Normalize(vec2); + /* scale the time allowed by the rotation */ + time_allowed *= NormalizedVecAngle2(vec1, vec2)/(M_PI/2); + } + + while (time_start + time_allowed > time_current) { + + step = (float)((time_current-time_start) / time_allowed); + + /* ease in/out */ + if (step < 0.5) step = (float)pow(step*2, 2)/2; + else step = (float)1-(pow(2*(1-step),2)/2); + + step_inv = 1-step; + + if (ofs) + for (i=0; i<3; i++) + v3d->ofs[i] = ofs[i]*step + orig_ofs[i]*step_inv; + + + if (quat) + QuatInterpol(v3d->viewquat, orig_quat, quat, step); + + if (dist) + v3d->dist = ((*dist)*step) + (orig_dist*step_inv); + + if (lens) + v3d->lens = ((*lens)*step) + (orig_lens*step_inv); + + /*redraw the view*/ + // scrarea_do_windraw(ar); + // screen_swapbuffers(); + + time_current= PIL_check_seconds_timer(); + } + } + } + + /* set these values even if animation is enabled because flaot + * error will make then not quite accurate */ + if (ofs) + VECCOPY(v3d->ofs, ofs); + if (quat) + QUATCOPY(v3d->viewquat, quat); + if (dist) + v3d->dist = *dist; + if (lens) + v3d->lens = *lens; + +} + +/* For use with smooth view +* +* the current view is unchanged, blend between the current view and the +* camera view +* */ +void smooth_view_to_camera(View3D *v3d) +{ + if (!U.smooth_viewtx || !v3d->camera || v3d->persp != V3D_CAMOB) { + return; + } else { + Object *ob = v3d->camera; + + float orig_ofs[3]; + float orig_dist=v3d->dist; + float orig_lens=v3d->lens; + float new_dist=0.0; + float new_lens=35.0; + float new_quat[4]; + float new_ofs[3]; + + VECCOPY(orig_ofs, v3d->ofs); + + view_settings_from_ob(ob, new_ofs, new_quat, NULL, &new_lens); + + v3d->persp= V3D_PERSP; + smooth_view(v3d, new_ofs, new_quat, &new_dist, &new_lens); + VECCOPY(v3d->ofs, orig_ofs); + v3d->lens= orig_lens; + v3d->dist = orig_dist; /* restore the dist */ + + v3d->camera = ob; + v3d->persp= V3D_CAMOB; + } +} + + diff --git a/source/blender/windowmanager/SConscript b/source/blender/windowmanager/SConscript index 7e591ad34f6..2d078988b9f 100644 --- a/source/blender/windowmanager/SConscript +++ b/source/blender/windowmanager/SConscript @@ -9,7 +9,7 @@ sources = env.Glob('intern/*.c') incs = '. ../editors/include ../python ../makesdna ../blenlib ../blenkernel' incs += ' ../nodes ../imbuf ../blenloader ../render/extern/include' incs += ' ../ftfont ../radiosity/extern/include ../../kernel/gen_system' -incs += ' ../makesrna' +incs += ' ../makesrna ../gpu' incs += ' #/intern/guardedalloc #/intern/memutil #/intern/ghost #/intern/bmfont' incs += ' #/intern/elbeem #/extern/glew/include' diff --git a/source/blender/windowmanager/WM_api.h b/source/blender/windowmanager/WM_api.h index 3c8628c5fbb..222982fb05f 100644 --- a/source/blender/windowmanager/WM_api.h +++ b/source/blender/windowmanager/WM_api.h @@ -138,6 +138,8 @@ void wmFrustum (wmWindow *win, float x1, float x2, float y1, float y2, float void wmOrtho (wmWindow *win, float x1, float x2, float y1, float y2, float n, float f); void wmOrtho2 (wmWindow *win, float x1, float x2, float y1, float y2); + /* utilities */ +void WM_set_framebuffer_index_color(int index); #endif /* WM_API_H */ diff --git a/source/blender/windowmanager/intern/Makefile b/source/blender/windowmanager/intern/Makefile index 00412f00445..5ca68bef0a2 100644 --- a/source/blender/windowmanager/intern/Makefile +++ b/source/blender/windowmanager/intern/Makefile @@ -57,6 +57,7 @@ CPPFLAGS += -I../../blenkernel CPPFLAGS += -I../../nodes CPPFLAGS += -I../../imbuf CPPFLAGS += -I../../blenloader +CPPFLAGS += -I../../gpu CPPFLAGS += -I../../render/extern/include CPPFLAGS += -I../../ftfont CPPFLAGS += -I../../radiosity/extern/include diff --git a/source/blender/windowmanager/intern/wm_init_exit.c b/source/blender/windowmanager/intern/wm_init_exit.c index ae84ac26979..d8448be30ab 100644 --- a/source/blender/windowmanager/intern/wm_init_exit.c +++ b/source/blender/windowmanager/intern/wm_init_exit.c @@ -69,8 +69,6 @@ #include "SYS_System.h" -#include "UI_interface.h" - #include "RNA_define.h" #include "WM_api.h" @@ -84,6 +82,12 @@ #include "ED_screen.h" +#include "UI_interface.h" + +#include "GPU_extensions.h" +#include "GPU_draw.h" + + static void initbuttons(void) { UI_init(); @@ -135,7 +139,9 @@ void WM_init(bContext *C) // XXX UI_filelist_init_icons(); -// init_gl_stuff(); /* drawview.c, after homefile */ + GPU_state_init(); + GPU_extensions_init(); + read_Blog(); BLI_strncpy(G.lib, G.sce, FILE_MAX); } diff --git a/source/blender/windowmanager/intern/wm_subwindow.c b/source/blender/windowmanager/intern/wm_subwindow.c index 56574829b53..7477cb35a6d 100644 --- a/source/blender/windowmanager/intern/wm_subwindow.c +++ b/source/blender/windowmanager/intern/wm_subwindow.c @@ -445,7 +445,7 @@ static unsigned int index_to_framebuffer(int index) #endif -void set_framebuffer_index_color(int index) +void WM_set_framebuffer_index_color(int index) { cpack(index_to_framebuffer(index)); } |