← Back to branch summary

~ubuntu-branches/ubuntu/maverick/blender/maverick

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/DerivedMesh.c

  • Committer: Bazaar Package Importer
  • Author(s): Khashayar Naderehvandi, Khashayar Naderehvandi, Alessio Treglia
  • Date: 2009-01-22 16:53:59 UTC
  • mfrom: (14.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090122165359-v0996tn7fbit64ni
Tags: 2.48a+dfsg-1ubuntu1
https://launchpad.net/bugs/320045
[ Khashayar Naderehvandi ]
* Merge from debian experimental (LP: #320045), Ubuntu remaining changes:
  - Add patch correcting header file locations.
  - Add libvorbis-dev and libgsm1-dev to Build-Depends.
  - Use avcodec_decode_audio2() in source/blender/src/hddaudio.c

[ Alessio Treglia ]
* Add missing previous changelog entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenkernel/intern/DerivedMesh.c
1
1
/**
2
 
 * $Id: DerivedMesh.c 14669 2008-05-04 09:41:15Z campbellbarton $
 
2
 * $Id: DerivedMesh.c 16889 2008-10-02 22:55:25Z blendix $
3
3
 *
4
4
 * ***** BEGIN GPL LICENSE BLOCK *****
5
5
 *
33
33
#include <config.h>
34
34
#endif
35
35
 
36
 
#include <zlib.h>
37
 
 
38
36
#include "PIL_time.h"
39
37
 
40
38
#include "MEM_guardedalloc.h"
59
57
#include "BLI_edgehash.h"
60
58
#include "BLI_editVert.h"
61
59
#include "BLI_linklist.h"
 
60
#include "BLI_memarena.h"
62
61
 
63
62
#include "BKE_cdderivedmesh.h"
64
63
#include "BKE_customdata.h"
66
65
#include "BKE_deform.h"
67
66
#include "BKE_displist.h"
68
67
#include "BKE_effect.h"
 
68
#include "BKE_fluidsim.h"
69
69
#include "BKE_global.h"
70
70
#include "BKE_key.h"
71
71
#include "BKE_material.h"
78
78
#include "BKE_utildefines.h"
79
79
#include "BKE_particle.h"
80
80
 
 
81
#include "BLO_sys_types.h" // for intptr_t support
 
82
 
81
83
#ifdef WITH_VERSE
82
84
#include "BKE_verse.h"
83
85
#endif
85
87
#include "BIF_gl.h"
86
88
#include "BIF_glutil.h"
87
89
 
88
 
// headers for fluidsim bobj meshes
89
 
#include <stdlib.h>
90
 
#include "LBM_fluidsim.h"
91
 
#include "elbeem.h"
92
 
 
93
 
///////////////////////////////////
94
 
///////////////////////////////////
95
 
 
96
 
MVert *dm_getVertArray(DerivedMesh *dm)
 
90
#include "GPU_draw.h"
 
91
#include "GPU_extensions.h"
 
92
#include "GPU_material.h"
 
93
 
 
94
///////////////////////////////////
 
95
///////////////////////////////////
 
96
 
 
97
static MVert *dm_getVertArray(DerivedMesh *dm)
97
98
{
98
99
        MVert *mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
99
100
 
107
108
        return mvert;
108
109
}
109
110
 
110
 
MEdge *dm_getEdgeArray(DerivedMesh *dm)
 
111
static MEdge *dm_getEdgeArray(DerivedMesh *dm)
111
112
{
112
113
        MEdge *medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
113
114
 
121
122
        return medge;
122
123
}
123
124
 
124
 
MFace *dm_getFaceArray(DerivedMesh *dm)
 
125
static MFace *dm_getFaceArray(DerivedMesh *dm)
125
126
{
126
127
        MFace *mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
127
128
 
135
136
        return mface;
136
137
}
137
138
 
138
 
MVert *dm_dupVertArray(DerivedMesh *dm)
 
139
static MVert *dm_dupVertArray(DerivedMesh *dm)
139
140
{
140
141
        MVert *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumVerts(dm),
141
142
                                 "dm_dupVertArray tmp");
145
146
        return tmp;
146
147
}
147
148
 
148
 
MEdge *dm_dupEdgeArray(DerivedMesh *dm)
 
149
static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
149
150
{
150
151
        MEdge *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumEdges(dm),
151
152
                                 "dm_dupEdgeArray tmp");
155
156
        return tmp;
156
157
}
157
158
 
158
 
MFace *dm_dupFaceArray(DerivedMesh *dm)
 
159
static MFace *dm_dupFaceArray(DerivedMesh *dm)
159
160
{
160
161
        MFace *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumFaces(dm),
161
162
                                 "dm_dupFaceArray tmp");
186
187
void DM_init(DerivedMesh *dm,
187
188
             int numVerts, int numEdges, int numFaces)
188
189
{
189
 
        CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
190
 
        CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
191
 
        CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numFaces);
192
 
 
193
190
        dm->numVertData = numVerts;
194
191
        dm->numEdgeData = numEdges;
195
192
        dm->numFaceData = numFaces;
412
409
        CustomData_swap(&dm->faceData, index, corner_indices);
413
410
}
414
411
 
 
412
///
 
413
 
415
414
static DerivedMesh *getMeshDerivedMesh(Mesh *me, Object *ob, float (*vertCos)[3])
416
415
{
417
416
        DerivedMesh *dm = CDDM_from_mesh(me, ob);
418
 
        int i, dofluidsim;
419
 
 
420
 
        dofluidsim = ((ob->fluidsimFlag & OB_FLUIDSIM_ENABLE) &&
421
 
                      (ob->fluidsimSettings->type & OB_FLUIDSIM_DOMAIN)&&
422
 
                      (ob->fluidsimSettings->meshSurface) &&
423
 
                      (me->totvert == ((Mesh *)(ob->fluidsimSettings->meshSurface))->totvert));
424
 
 
425
 
        if (vertCos && !dofluidsim)
 
417
        
 
418
        if(!dm)
 
419
                return NULL;
 
420
        
 
421
        if (vertCos)
426
422
                CDDM_apply_vert_coords(dm, vertCos);
427
423
 
428
424
        CDDM_calc_normals(dm);
429
425
 
430
 
        /* apply fluidsim normals */    
431
 
        if (dofluidsim) {
432
 
                // use normals from readBobjgz
433
 
                // TODO? check for modifiers!?
434
 
                MVert *fsvert = ob->fluidsimSettings->meshSurfNormals;
435
 
                short (*normals)[3] = MEM_mallocN(sizeof(short)*3*me->totvert, "fluidsim nor");
436
 
 
437
 
                for (i=0; i<me->totvert; i++) {
438
 
                        VECCOPY(normals[i], fsvert[i].no);
439
 
                        //mv->no[0]= 30000; mv->no[1]= mv->no[2]= 0; // DEBUG fixed test normals
440
 
                }
441
 
 
442
 
                CDDM_apply_vert_normals(dm, normals);
443
 
 
444
 
                MEM_freeN(normals);
445
 
        }
446
 
 
447
426
        return dm;
448
427
}
449
428
 
482
461
                EditVert *eve;
483
462
 
484
463
                for (i=0,eve=emdm->em->verts.first; eve; eve= eve->next)
485
 
                        eve->tmp.l = (long) i++;
 
464
                        eve->tmp.l = (intptr_t) i++;
486
465
                for(i=0,eed= emdm->em->edges.first; eed; i++,eed= eed->next)
487
466
                        func(userData, i, emdm->vertexCos[(int) eed->v1->tmp.l], emdm->vertexCos[(int) eed->v2->tmp.l]);
488
467
        } else {
500
479
                EditVert *eve;
501
480
 
502
481
                for (i=0,eve=emdm->em->verts.first; eve; eve= eve->next)
503
 
                        eve->tmp.l = (long) i++;
 
482
                        eve->tmp.l = (intptr_t) i++;
504
483
 
505
484
                glBegin(GL_LINES);
506
485
                for(i=0,eed= emdm->em->edges.first; eed; i++,eed= eed->next) {
535
514
                EditVert *eve;
536
515
 
537
516
                for (i=0,eve=emdm->em->verts.first; eve; eve= eve->next)
538
 
                        eve->tmp.l = (long) i++;
 
517
                        eve->tmp.l = (intptr_t) i++;
539
518
 
540
519
                glBegin(GL_LINES);
541
520
                for (i=0,eed= emdm->em->edges.first; eed; i++,eed= eed->next) {
622
601
 
623
602
        if (emdm->vertexCos) {
624
603
                for (i=0,eve=emdm->em->verts.first; eve; eve= eve->next)
625
 
                        eve->tmp.l = (long) i++;
 
604
                        eve->tmp.l = (intptr_t) i++;
626
605
        }
627
606
 
628
607
        for(i=0,efa= emdm->em->faces.first; efa; i++,efa= efa->next) {
640
619
                EditVert *eve;
641
620
 
642
621
                for (i=0,eve=emdm->em->verts.first; eve; eve= eve->next)
643
 
                        eve->tmp.l = (long) i++;
 
622
                        eve->tmp.l = (intptr_t) i++;
644
623
 
645
624
                for (i=0,efa= emdm->em->faces.first; efa; i++,efa= efa->next) {
646
625
                        int drawSmooth = (efa->flag & ME_SMOOTH);
736
715
                EditVert *eve;
737
716
 
738
717
                for (i=0,eve=em->verts.first; eve; eve= eve->next)
739
 
                        eve->tmp.l = (long) i++;
 
718
                        eve->tmp.l = (intptr_t) i++;
740
719
 
741
720
                for (i=0,efa= em->faces.first; efa; i++,efa= efa->next) {
742
721
                        MTFace *tf= CustomData_em_get(&em->fdata, efa->data, CD_MTFACE);
895
874
        emDM_drawFacesTex_common(dm, NULL, setDrawOptions, userData);
896
875
}
897
876
 
 
877
static void emDM_drawMappedFacesGLSL(DerivedMesh *dm,
 
878
               int (*setMaterial)(int, void *attribs),
 
879
               int (*setDrawOptions)(void *userData, int index), void *userData) 
 
880
{
 
881
        EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
 
882
        EditMesh *em= emdm->em;
 
883
        float (*vertexCos)[3]= emdm->vertexCos;
 
884
        float (*vertexNos)[3]= emdm->vertexNos;
 
885
        EditVert *eve;
 
886
        EditFace *efa;
 
887
        DMVertexAttribs attribs;
 
888
        GPUVertexAttribs gattribs;
 
889
        MTFace *tf;
 
890
        int transp, new_transp, orig_transp, tfoffset;
 
891
        int i, b, matnr, new_matnr, dodraw, layer;
 
892
 
 
893
        dodraw = 0;
 
894
        matnr = -1;
 
895
 
 
896
        transp = GPU_get_material_blend_mode();
 
897
        orig_transp = transp;
 
898
        layer = CustomData_get_layer_index(&em->fdata, CD_MTFACE);
 
899
        tfoffset = (layer == -1)? -1: em->fdata.layers[layer].offset;
 
900
 
 
901
        memset(&attribs, 0, sizeof(attribs));
 
902
 
 
903
        /* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 
904
        glShadeModel(GL_SMOOTH);
 
905
 
 
906
        for (i=0,eve=em->verts.first; eve; eve= eve->next)
 
907
                eve->tmp.l = (long) i++;
 
908
 
 
909
#define PASSATTRIB(efa, eve, vert) {                                                                                    \
 
910
        if(attribs.totorco) {                                                                                                           \
 
911
                float *orco = attribs.orco.array[eve->tmp.l];                                                   \
 
912
                glVertexAttrib3fvARB(attribs.orco.glIndex, orco);                                               \
 
913
        }                                                                                                                                                       \
 
914
        for(b = 0; b < attribs.tottface; b++) {                                                                         \
 
915
                MTFace *_tf = (MTFace*)((char*)efa->data + attribs.tface[b].emOffset);  \
 
916
                glVertexAttrib2fvARB(attribs.tface[b].glIndex, _tf->uv[vert]);                  \
 
917
        }                                                                                                                                                       \
 
918
        for(b = 0; b < attribs.totmcol; b++) {                                                                          \
 
919
                MCol *cp = (MCol*)((char*)efa->data + attribs.mcol[b].emOffset);                \
 
920
                GLubyte col[4];                                                                                                                 \
 
921
                col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a;                             \
 
922
                glVertexAttrib4ubvARB(attribs.mcol[b].glIndex, col);                                    \
 
923
        }                                                                                                                                                       \
 
924
        if(attribs.tottang) {                                                                                                           \
 
925
                float *tang = attribs.tang.array[i*4 + vert];                                                   \
 
926
                glVertexAttrib3fvARB(attribs.tang.glIndex, tang);                                               \
 
927
        }                                                                                                                                                       \
 
928
}
 
929
 
 
930
        for (i=0,efa= em->faces.first; efa; i++,efa= efa->next) {
 
931
                int drawSmooth= (efa->flag & ME_SMOOTH);
 
932
 
 
933
                if(setDrawOptions && !setDrawOptions(userData, i))
 
934
                        continue;
 
935
 
 
936
                new_matnr = efa->mat_nr + 1;
 
937
                if(new_matnr != matnr) {
 
938
                        dodraw = setMaterial(matnr = new_matnr, &gattribs);
 
939
                        if(dodraw)
 
940
                                DM_vertex_attributes_from_gpu(dm, &gattribs, &attribs);
 
941
                }
 
942
 
 
943
                if(tfoffset != -1) {
 
944
                        tf = (MTFace*)((char*)efa->data)+tfoffset;
 
945
                        new_transp = tf->transp;
 
946
 
 
947
                        if(new_transp != transp) {
 
948
                                if(new_transp == GPU_BLEND_SOLID && orig_transp != GPU_BLEND_SOLID)
 
949
                                        GPU_set_material_blend_mode(orig_transp);
 
950
                                else
 
951
                                        GPU_set_material_blend_mode(new_transp);
 
952
                                transp = new_transp;
 
953
                        }
 
954
                }
 
955
 
 
956
                if(dodraw) {
 
957
                        glBegin(efa->v4?GL_QUADS:GL_TRIANGLES);
 
958
                        if (!drawSmooth) {
 
959
                                if(vertexCos) glNormal3fv(emdm->faceNos[i]);
 
960
                                else glNormal3fv(efa->n);
 
961
 
 
962
                                PASSATTRIB(efa, efa->v1, 0);
 
963
                                if(vertexCos) glVertex3fv(vertexCos[(int) efa->v1->tmp.l]);
 
964
                                else glVertex3fv(efa->v1->co);
 
965
 
 
966
                                PASSATTRIB(efa, efa->v2, 1);
 
967
                                if(vertexCos) glVertex3fv(vertexCos[(int) efa->v2->tmp.l]);
 
968
                                else glVertex3fv(efa->v2->co);
 
969
 
 
970
                                PASSATTRIB(efa, efa->v3, 2);
 
971
                                if(vertexCos) glVertex3fv(vertexCos[(int) efa->v3->tmp.l]);
 
972
                                else glVertex3fv(efa->v3->co);
 
973
 
 
974
                                if(efa->v4) {
 
975
                                        PASSATTRIB(efa, efa->v4, 3);
 
976
                                        if(vertexCos) glVertex3fv(vertexCos[(int) efa->v4->tmp.l]);
 
977
                                        else glVertex3fv(efa->v4->co);
 
978
                                }
 
979
                        } else {
 
980
                                PASSATTRIB(efa, efa->v1, 0);
 
981
                                if(vertexCos) {
 
982
                                        glNormal3fv(vertexNos[(int) efa->v1->tmp.l]);
 
983
                                        glVertex3fv(vertexCos[(int) efa->v1->tmp.l]);
 
984
                                }
 
985
                                else {
 
986
                                        glNormal3fv(efa->v1->no);
 
987
                                        glVertex3fv(efa->v1->co);
 
988
                                }
 
989
 
 
990
                                PASSATTRIB(efa, efa->v2, 1);
 
991
                                if(vertexCos) {
 
992
                                        glNormal3fv(vertexNos[(int) efa->v2->tmp.l]);
 
993
                                        glVertex3fv(vertexCos[(int) efa->v2->tmp.l]);
 
994
                                }
 
995
                                else {
 
996
                                        glNormal3fv(efa->v2->no);
 
997
                                        glVertex3fv(efa->v2->co);
 
998
                                }
 
999
 
 
1000
                                PASSATTRIB(efa, efa->v3, 2);
 
1001
                                if(vertexCos) {
 
1002
                                        glNormal3fv(vertexNos[(int) efa->v3->tmp.l]);
 
1003
                                        glVertex3fv(vertexCos[(int) efa->v3->tmp.l]);
 
1004
                                }
 
1005
                                else {
 
1006
                                        glNormal3fv(efa->v3->no);
 
1007
                                        glVertex3fv(efa->v3->co);
 
1008
                                }
 
1009
 
 
1010
                                if(efa->v4) {
 
1011
                                        PASSATTRIB(efa, efa->v4, 3);
 
1012
                                        if(vertexCos) {
 
1013
                                                glNormal3fv(vertexNos[(int) efa->v4->tmp.l]);
 
1014
                                                glVertex3fv(vertexCos[(int) efa->v4->tmp.l]);
 
1015
                                        }
 
1016
                                        else {
 
1017
                                                glNormal3fv(efa->v4->no);
 
1018
                                                glVertex3fv(efa->v4->co);
 
1019
                                        }
 
1020
                                }
 
1021
                        }
 
1022
                        glEnd();
 
1023
                }
 
1024
        }
 
1025
}
 
1026
 
 
1027
static void emDM_drawFacesGLSL(DerivedMesh *dm,
 
1028
               int (*setMaterial)(int, void *attribs))
 
1029
{
 
1030
        dm->drawMappedFacesGLSL(dm, setMaterial, NULL, NULL);
 
1031
}
 
1032
 
898
1033
static void emDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
899
1034
{
900
1035
        EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
934
1069
        return BLI_countlist(&emdm->em->faces);
935
1070
}
936
1071
 
937
 
void emDM_getVert(DerivedMesh *dm, int index, MVert *vert_r)
 
1072
static void emDM_getVert(DerivedMesh *dm, int index, MVert *vert_r)
938
1073
{
939
1074
        EditVert *ev = ((EditMeshDerivedMesh *)dm)->em->verts.first;
940
1075
        int i;
952
1087
        vert_r->bweight = (unsigned char) (ev->bweight*255.0f);
953
1088
}
954
1089
 
955
 
void emDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r)
 
1090
static void emDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r)
956
1091
{
957
1092
        EditMesh *em = ((EditMeshDerivedMesh *)dm)->em;
958
1093
        EditEdge *ee = em->edges.first;
987
1122
        }
988
1123
}
989
1124
 
990
 
void emDM_getFace(DerivedMesh *dm, int index, MFace *face_r)
 
1125
static void emDM_getFace(DerivedMesh *dm, int index, MFace *face_r)
991
1126
{
992
1127
        EditMesh *em = ((EditMeshDerivedMesh *)dm)->em;
993
1128
        EditFace *ef = em->faces.first;
1029
1164
        test_index_face(face_r, NULL, 0, ef->v4?4:3);
1030
1165
}
1031
1166
 
1032
 
void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
 
1167
static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
1033
1168
{
1034
1169
        EditVert *ev = ((EditMeshDerivedMesh *)dm)->em->verts.first;
1035
1170
 
1047
1182
        }
1048
1183
}
1049
1184
 
1050
 
void emDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r)
 
1185
static void emDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r)
1051
1186
{
1052
1187
        EditMesh *em = ((EditMeshDerivedMesh *)dm)->em;
1053
1188
        EditEdge *ee = em->edges.first;
1056
1191
 
1057
1192
        /* store vertex indices in tmp union */
1058
1193
        for(ev = em->verts.first, i = 0; ev; ev = ev->next, ++i)
1059
 
                ev->tmp.l = (long) i++;
 
1194
                ev->tmp.l = (intptr_t) i;
1060
1195
 
1061
1196
        for( ; ee; ee = ee->next, ++edge_r) {
1062
1197
                edge_r->crease = (unsigned char) (ee->crease*255.0f);
1075
1210
        }
1076
1211
}
1077
1212
 
1078
 
void emDM_copyFaceArray(DerivedMesh *dm, MFace *face_r)
 
1213
static void emDM_copyFaceArray(DerivedMesh *dm, MFace *face_r)
1079
1214
{
1080
1215
        EditMesh *em = ((EditMeshDerivedMesh *)dm)->em;
1081
1216
        EditFace *ef = em->faces.first;
1084
1219
 
1085
1220
        /* store vertexes indices in tmp union */
1086
1221
        for(ev = em->verts.first, i = 0; ev; ev = ev->next, ++i)
1087
 
                ev->tmp.l = (long) i;
 
1222
                ev->tmp.l = (intptr_t) i;
1088
1223
 
1089
1224
        for( ; ef; ef = ef->next, ++face_r) {
1090
1225
                face_r->mat_nr = ef->mat_nr;
1100
1235
        }
1101
1236
}
1102
1237
 
 
1238
static void *emDM_getFaceDataArray(DerivedMesh *dm, int type)
 
1239
{
 
1240
        EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
 
1241
        EditMesh *em= emdm->em;
 
1242
        EditFace *efa;
 
1243
        char *data, *emdata;
 
1244
        void *datalayer;
 
1245
        int index, offset, size;
 
1246
 
 
1247
        datalayer = DM_get_face_data_layer(dm, type);
 
1248
        if(datalayer)
 
1249
                return datalayer;
 
1250
 
 
1251
        /* layers are store per face for editmesh, we convert to a temporary
 
1252
         * data layer array in the derivedmesh when these are requested */
 
1253
        if(type == CD_MTFACE || type == CD_MCOL) {
 
1254
                index = CustomData_get_layer_index(&em->fdata, type);
 
1255
 
 
1256
                if(index != -1) {
 
1257
                        offset = em->fdata.layers[index].offset;
 
1258
                        size = CustomData_sizeof(type);
 
1259
 
 
1260
                        DM_add_face_layer(dm, type, CD_CALLOC, NULL);
 
1261
                        index = CustomData_get_layer_index(&dm->faceData, type);
 
1262
                        dm->faceData.layers[index].flag |= CD_FLAG_TEMPORARY;
 
1263
 
 
1264
                        data = datalayer = DM_get_face_data_layer(dm, type);
 
1265
                        for(efa=em->faces.first; efa; efa=efa->next, data+=size) {
 
1266
                                emdata = CustomData_em_get(&em->fdata, efa->data, type);
 
1267
                                memcpy(data, emdata, size);
 
1268
                        }
 
1269
                }
 
1270
        }
 
1271
 
 
1272
        return datalayer;
 
1273
}
 
1274
 
1103
1275
static void emDM_release(DerivedMesh *dm)
1104
1276
{
1105
1277
        EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
1135
1307
        emdm->dm.copyVertArray = emDM_copyVertArray;
1136
1308
        emdm->dm.copyEdgeArray = emDM_copyEdgeArray;
1137
1309
        emdm->dm.copyFaceArray = emDM_copyFaceArray;
 
1310
        emdm->dm.getFaceDataArray = emDM_getFaceDataArray;
1138
1311
 
1139
1312
        emdm->dm.foreachMappedVert = emDM_foreachMappedVert;
1140
1313
        emdm->dm.foreachMappedEdge = emDM_foreachMappedEdge;
1145
1318
        emdm->dm.drawMappedEdgesInterp = emDM_drawMappedEdgesInterp;
1146
1319
        emdm->dm.drawMappedFaces = emDM_drawMappedFaces;
1147
1320
        emdm->dm.drawMappedFacesTex = emDM_drawMappedFacesTex;
 
1321
        emdm->dm.drawMappedFacesGLSL = emDM_drawMappedFacesGLSL;
1148
1322
        emdm->dm.drawFacesTex = emDM_drawFacesTex;
 
1323
        emdm->dm.drawFacesGLSL = emDM_drawFacesGLSL;
1149
1324
        emdm->dm.drawUVEdges = emDM_drawUVEdges;
1150
1325
 
1151
1326
        emdm->dm.release = emDM_release;
1171
1346
                int i;
1172
1347
 
1173
1348
                for (i=0,eve=em->verts.first; eve; eve= eve->next)
1174
 
                        eve->tmp.l = (long) i++;
 
1349
                        eve->tmp.l = (intptr_t) i++;
1175
1350
 
1176
1351
                emdm->vertexNos = MEM_callocN(sizeof(*emdm->vertexNos)*i, "emdm_vno");
1177
1352
                emdm->faceNos = MEM_mallocN(sizeof(*emdm->faceNos)*totface, "emdm_vno");
1575
1750
}
1576
1751
 
1577
1752
/* draw all VerseFaces */
1578
 
static void vDM_drawFacesSolid(DerivedMesh *dm, int (*setMaterial)(int))
 
1753
static void vDM_drawFacesSolid(DerivedMesh *dm, int (*setMaterial)(int, void *attribs))
1579
1754
{
1580
1755
        VDerivedMesh *vdm = (VDerivedMesh*)dm;
1581
1756
        struct VerseFace *vface;
1675
1850
                int (*setDrawParams)(void *userData, int index),
1676
1851
                void *userData)
1677
1852
{
 
1853
        /* not supported yet */
 
1854
        vDM_drawFacesTex(dm, NULL);
1678
1855
}
1679
1856
 
1680
1857
/**/
1816
1993
        ScrArea *sa;
1817
1994
 
1818
1995
        /* check if we need tfaces & mcols due to face select or texture paint */
1819
 
        if(FACESEL_PAINT_TEST || G.f & G_TEXTUREPAINT) {
 
1996
        if(FACESEL_PAINT_TEST || G.f & G_TEXTUREPAINT)
1820
1997
                mask |= CD_MASK_MTFACE | CD_MASK_MCOL;
1821
 
        } else {
1822
 
                /* check if we need tfaces & mcols due to view mode */
1823
 
                for(sa = G.curscreen->areabase.first; sa; sa = sa->next) {
1824
 
                        if(sa->spacetype == SPACE_VIEW3D) {
1825
 
                                View3D *view = sa->spacedata.first;
1826
 
                                if(view->drawtype == OB_SHADED) {
1827
 
                                        /* this includes normals for mesh_create_shadedColors */
1828
 
                                        mask |= CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_NORMAL | CD_MASK_ORCO;
1829
 
                                }
1830
 
                                if((view->drawtype == OB_TEXTURE) || ((view->drawtype == OB_SOLID) && (view->flag2 & V3D_SOLID_TEX))) {
1831
 
                                        mask |= CD_MASK_MTFACE | CD_MASK_MCOL;
 
1998
 
 
1999
        /* check if we need tfaces & mcols due to view mode */
 
2000
        for(sa = G.curscreen->areabase.first; sa; sa = sa->next) {
 
2001
                if(sa->spacetype == SPACE_VIEW3D) {
 
2002
                        View3D *view = sa->spacedata.first;
 
2003
                        if(view->drawtype == OB_SHADED) {
 
2004
                                /* this includes normals for mesh_create_shadedColors */
 
2005
                                mask |= CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_NORMAL | CD_MASK_ORCO;
 
2006
                        }
 
2007
                        if((view->drawtype == OB_TEXTURE) || ((view->drawtype == OB_SOLID) && (view->flag2 & V3D_SOLID_TEX))) {
 
2008
                                mask |= CD_MASK_MTFACE | CD_MASK_MCOL;
 
2009
 
 
2010
                                if((G.fileflags & G_FILE_GAME_MAT) &&
 
2011
                                   (G.fileflags & G_FILE_GAME_MAT_GLSL)) {
 
2012
                                        mask |= CD_MASK_ORCO;
1832
2013
                                }
1833
2014
                        }
1834
2015
                }
1841
2022
        return mask;
1842
2023
}
1843
2024
 
1844
 
static DerivedMesh *create_orco_dm(Object *ob, Mesh *me)
 
2025
static float *get_editmesh_orco_verts(EditMesh *em)
 
2026
{
 
2027
        EditVert *eve;
 
2028
        float *orco;
 
2029
        int a, totvert;
 
2030
 
 
2031
        /* these may not really be the orco's, but it's only for preview.
 
2032
         * could be solver better once, but isn't simple */
 
2033
 
 
2034
        totvert= 0;
 
2035
        for(eve=em->verts.first; eve; eve=eve->next)
 
2036
                totvert++;
 
2037
        
 
2038
        orco = MEM_mallocN(sizeof(float)*3*totvert, "EditMesh Orco");
 
2039
 
 
2040
        for(a=0, eve=em->verts.first; eve; eve=eve->next, a+=3)
 
2041
                VECCOPY(orco+a, eve->co);
 
2042
        
 
2043
        return orco;
 
2044
}
 
2045
 
 
2046
static DerivedMesh *create_orco_dm(Object *ob, Mesh *me, EditMesh *em)
1845
2047
{
1846
2048
        DerivedMesh *dm;
1847
2049
        float (*orco)[3];
1848
2050
 
1849
 
        dm= CDDM_from_mesh(me, ob);
1850
 
        orco= (float(*)[3])get_mesh_orco_verts(ob);
 
2051
        if(em) {
 
2052
                dm= CDDM_from_editmesh(em, me);
 
2053
                orco= (float(*)[3])get_editmesh_orco_verts(em);
 
2054
        }
 
2055
        else {
 
2056
                dm= CDDM_from_mesh(me, ob);
 
2057
                orco= (float(*)[3])get_mesh_orco_verts(ob);
 
2058
        }
 
2059
 
1851
2060
        CDDM_apply_vert_coords(dm, orco);
1852
2061
        CDDM_calc_normals(dm);
1853
2062
        MEM_freeN(orco);
1855
2064
        return dm;
1856
2065
}
1857
2066
 
1858
 
static void add_orco_dm(Object *ob, DerivedMesh *dm, DerivedMesh *orcodm)
 
2067
static void add_orco_dm(Object *ob, EditMesh *em, DerivedMesh *dm, DerivedMesh *orcodm)
1859
2068
{
1860
2069
        float (*orco)[3], (*layerorco)[3];
1861
2070
        int totvert;
1870
2079
                else
1871
2080
                        dm->getVertCos(dm, orco);
1872
2081
        }
1873
 
        else
1874
 
                orco= (float(*)[3])get_mesh_orco_verts(ob);
 
2082
        else {
 
2083
                if(em) orco= (float(*)[3])get_editmesh_orco_verts(em);
 
2084
                else orco= (float(*)[3])get_mesh_orco_verts(ob);
 
2085
        }
1875
2086
 
1876
2087
        transform_mesh_orco_verts(ob->data, orco, totvert, 0);
1877
2088
 
1886
2097
static void mesh_calc_modifiers(Object *ob, float (*inputVertexCos)[3],
1887
2098
                                DerivedMesh **deform_r, DerivedMesh **final_r,
1888
2099
                                int useRenderParams, int useDeform,
1889
 
                                int needMapping, CustomDataMask dataMask)
 
2100
                                int needMapping, CustomDataMask dataMask, int index)
1890
2101
{
1891
2102
        Mesh *me = ob->data;
1892
2103
        ModifierData *firstmd, *md;
1895
2106
        float (*deformedVerts)[3] = NULL;
1896
2107
        DerivedMesh *dm, *orcodm, *finaldm;
1897
2108
        int numVerts = me->totvert;
1898
 
        int fluidsimMeshUsed = 0;
1899
2109
        int required_mode;
1900
2110
 
1901
2111
        md = firstmd = modifiers_getVirtualModifierList(ob);
1911
2121
        if(deform_r) *deform_r = NULL;
1912
2122
        *final_r = NULL;
1913
2123
 
1914
 
        /* replace original mesh by fluidsim surface mesh for fluidsim
1915
 
         * domain objects
1916
 
         */
1917
 
        if((G.obedit!=ob) && !needMapping) {
1918
 
                if((ob->fluidsimFlag & OB_FLUIDSIM_ENABLE)) {
1919
 
                        if(ob->fluidsimSettings->type & OB_FLUIDSIM_DOMAIN) {
1920
 
                                loadFluidsimMesh(ob,useRenderParams);
1921
 
                                fluidsimMeshUsed = 1;
1922
 
                                /* might have changed... */
1923
 
                                me = ob->data;
1924
 
                                numVerts = me->totvert;
1925
 
                        }
1926
 
                }
1927
 
        }
1928
 
 
1929
2124
        if(useRenderParams) required_mode = eModifierMode_Render;
1930
2125
        else required_mode = eModifierMode_Realtime;
1931
2126
 
1934
2129
                        deformedVerts = mesh_getVertexCos(me, &numVerts);
1935
2130
                
1936
2131
                /* Apply all leading deforming modifiers */
1937
 
                for(; md; md = md->next, curr = curr->next) {
 
2132
                for(;md; md = md->next, curr = curr->next) {
1938
2133
                        ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1939
2134
 
1940
2135
                        if((md->mode & required_mode) != required_mode) continue;
1948
2143
                        } else {
1949
2144
                                break;
1950
2145
                        }
 
2146
                        
 
2147
                        /* grab modifiers until index i */
 
2148
                        if((index >= 0) && (modifiers_indexInObject(ob, md) >= index))
 
2149
                                break;
1951
2150
                }
1952
2151
 
1953
2152
                /* Result of all leading deforming modifiers is cached for
1973
2172
#endif
1974
2173
                }
1975
2174
        } else {
1976
 
                if(!fluidsimMeshUsed) {
1977
 
                        /* default behaviour for meshes */
1978
 
                        if(inputVertexCos)
1979
 
                                deformedVerts = inputVertexCos;
1980
 
                        else
1981
 
                                deformedVerts = mesh_getRefKeyCos(me, &numVerts);
1982
 
                } else {
1983
 
                        /* the fluid sim mesh might have more vertices than the original 
1984
 
                         * one, so inputVertexCos shouldnt be used
1985
 
                         */
1986
 
                        deformedVerts = mesh_getVertexCos(me, &numVerts);
1987
 
                }
 
2175
                /* default behaviour for meshes */
 
2176
                if(inputVertexCos)
 
2177
                        deformedVerts = inputVertexCos;
 
2178
                else
 
2179
                        deformedVerts = mesh_getRefKeyCos(me, &numVerts);
1988
2180
        }
1989
2181
 
1990
2182
 
2001
2193
        if(me->vnode) dm = derivedmesh_from_versemesh(me->vnode, deformedVerts);
2002
2194
#endif
2003
2195
 
2004
 
        for(; md; md = md->next, curr = curr->next) {
 
2196
        for(;md; md = md->next, curr = curr->next) {
2005
2197
                ModifierTypeInfo *mti = modifierType_getInfo(md->type);
2006
2198
 
2007
2199
                if((md->mode & required_mode) != required_mode) continue;
2017
2209
                if(dm && mti->requiredDataMask) {
2018
2210
                        mask = mti->requiredDataMask(md);
2019
2211
                        if(mask & CD_MASK_ORCO)
2020
 
                                add_orco_dm(ob, dm, orcodm);
 
2212
                                add_orco_dm(ob, NULL, dm, orcodm);
2021
2213
                }
2022
2214
 
2023
2215
                /* How to apply modifier depends on (a) what we already have as
2070
2262
                        mask= (CustomDataMask)curr->link;
2071
2263
                        if(mask & CD_MASK_ORCO) {
2072
2264
                                if(!orcodm)
2073
 
                                        orcodm= create_orco_dm(ob, me);
 
2265
                                        orcodm= create_orco_dm(ob, me, NULL);
2074
2266
 
2075
2267
                                mask &= ~CD_MASK_ORCO;
2076
2268
                                DM_set_only_copy(orcodm, mask);
2107
2299
                                }
2108
2300
                        } 
2109
2301
                }
 
2302
                
 
2303
                /* grab modifiers until index i */
 
2304
                if((index >= 0) && (modifiers_indexInObject(ob, md) >= index))
 
2305
                        break;
2110
2306
        }
2111
2307
 
2112
2308
        for(md=firstmd; md; md=md->next)
2147
2343
 
2148
2344
        /* add an orco layer if needed */
2149
2345
        if(dataMask & CD_MASK_ORCO) {
2150
 
                add_orco_dm(ob, finaldm, orcodm);
 
2346
                add_orco_dm(ob, NULL, finaldm, orcodm);
2151
2347
 
2152
2348
                if(deform_r && *deform_r)
2153
 
                        add_orco_dm(ob, *deform_r, NULL);
 
2349
                        add_orco_dm(ob, NULL, *deform_r, NULL);
2154
2350
        }
2155
2351
 
2156
2352
        *final_r = finaldm;
2162
2358
                MEM_freeN(deformedVerts);
2163
2359
 
2164
2360
        BLI_linklist_free(datamasks, NULL);
2165
 
 
2166
 
        /* restore mesh in any case */
2167
 
        if(fluidsimMeshUsed) ob->data = ob->fluidsimSettings->orgMesh;
2168
2361
}
2169
2362
 
2170
2363
static float (*editmesh_getVertexCos(EditMesh *em, int *numVerts_r))[3]
2206
2399
        EditMesh *em = G.editMesh;
2207
2400
        ModifierData *md;
2208
2401
        float (*deformedVerts)[3] = NULL;
2209
 
        DerivedMesh *dm;
 
2402
        CustomDataMask mask;
 
2403
        DerivedMesh *dm, *orcodm = NULL;
2210
2404
        int i, numVerts = 0, cageIndex = modifiers_getCageIndex(ob, NULL);
2211
2405
        LinkNode *datamasks, *curr;
2212
2406
 
2231
2425
                if(!editmesh_modifier_is_enabled(md, dm))
2232
2426
                        continue;
2233
2427
 
 
2428
                /* add an orco layer if needed by this modifier */
 
2429
                if(dm && mti->requiredDataMask) {
 
2430
                        mask = mti->requiredDataMask(md);
 
2431
                        if(mask & CD_MASK_ORCO)
 
2432
                                add_orco_dm(ob, em, dm, orcodm);
 
2433
                }
 
2434
 
2234
2435
                /* How to apply modifier depends on (a) what we already have as
2235
2436
                 * a result of previous modifiers (could be a DerivedMesh or just
2236
2437
                 * deformed vertices) and (b) what type the modifier is.
2281
2482
                                }
2282
2483
                        }
2283
2484
 
 
2485
                        /* create an orco derivedmesh in parallel */
 
2486
                        mask= (CustomDataMask)curr->link;
 
2487
                        if(mask & CD_MASK_ORCO) {
 
2488
                                if(!orcodm)
 
2489
                                        orcodm= create_orco_dm(ob, ob->data, em);
 
2490
 
 
2491
                                mask &= ~CD_MASK_ORCO;
 
2492
                                DM_set_only_copy(orcodm, mask);
 
2493
                                ndm = mti->applyModifierEM(md, ob, em, orcodm);
 
2494
 
 
2495
                                if(ndm) {
 
2496
                                        /* if the modifier returned a new dm, release the old one */
 
2497
                                        if(orcodm && orcodm != ndm) orcodm->release(orcodm);
 
2498
                                        orcodm = ndm;
 
2499
                                }
 
2500
                        }
 
2501
 
2284
2502
                        /* set the DerivedMesh to only copy needed data */
2285
2503
                        DM_set_only_copy(dm, (CustomDataMask)curr->link);
2286
2504
 
2339
2557
                deformedVerts = NULL;
2340
2558
        }
2341
2559
 
 
2560
        /* add an orco layer if needed */
 
2561
        if(dataMask & CD_MASK_ORCO)
 
2562
                add_orco_dm(ob, em, *final_r, orcodm);
 
2563
 
 
2564
        if(orcodm)
 
2565
                orcodm->release(orcodm);
 
2566
 
2342
2567
        if(deformedVerts)
2343
2568
                MEM_freeN(deformedVerts);
2344
2569
}
2476
2701
                if( (G.f & G_WEIGHTPAINT) && ob==obact ) {
2477
2702
                        MCol *wpcol = (MCol*)calc_weightpaint_colors(ob);
2478
2703
                        int layernum = CustomData_number_of_layers(&me->fdata, CD_MCOL);
 
2704
                        int prevactive = CustomData_get_active_layer(&me->fdata, CD_MCOL);
 
2705
                        int prevrender = CustomData_get_render_layer(&me->fdata, CD_MCOL);
2479
2706
 
2480
2707
                        /* ugly hack here, we temporarily add a new active mcol layer with
2481
2708
                           weightpaint colors in it, that is then duplicated in CDDM_from_mesh */
2482
2709
                        CustomData_add_layer(&me->fdata, CD_MCOL, CD_ASSIGN, wpcol, me->totface);
2483
2710
                        CustomData_set_layer_active(&me->fdata, CD_MCOL, layernum);
 
2711
                        CustomData_set_layer_render(&me->fdata, CD_MCOL, layernum);
2484
2712
 
2485
2713
                        mesh_calc_modifiers(ob, NULL, &ob->derivedDeform,
2486
2714
                                            &ob->derivedFinal, 0, 1,
2487
 
                                            needMapping, dataMask);
 
2715
                                            needMapping, dataMask, -1);
2488
2716
 
2489
2717
                        CustomData_free_layer_active(&me->fdata, CD_MCOL, me->totface);
 
2718
                        CustomData_set_layer_active(&me->fdata, CD_MCOL, prevactive);
 
2719
                        CustomData_set_layer_render(&me->fdata, CD_MCOL, prevrender);
2490
2720
                } else {
2491
2721
                        mesh_calc_modifiers(ob, NULL, &ob->derivedDeform,
2492
2722
                                            &ob->derivedFinal, G.rendering, 1,
2493
 
                                            needMapping, dataMask);
 
2723
                                            needMapping, dataMask, -1);
2494
2724
                }
2495
2725
 
2496
2726
                INIT_MINMAX(min, max);
2633
2863
                        old->release(old);
2634
2864
 
2635
2865
                        if(dataMask & CD_MASK_ORCO)
2636
 
                                add_orco_dm(ob, *dm, NULL);
 
2866
                                add_orco_dm(ob, NULL, *dm, NULL);
2637
2867
 
2638
2868
                        /* Restore the original verts */
2639
2869
                        me->mr->newlvl= BLI_countlist(&me->mr->levels);
2661
2891
        int orig_lvl= 0;
2662
2892
        
2663
2893
        vert_copy= multires_render_pin(ob, me, &orig_lvl);
2664
 
        mesh_calc_modifiers(ob, NULL, NULL, &final, 1, 1, 0, dataMask);
 
2894
        mesh_calc_modifiers(ob, NULL, NULL, &final, 1, 1, 0, dataMask, -1);
 
2895
        multires_render_final(ob, me, &final, vert_copy, orig_lvl, dataMask);
 
2896
 
 
2897
        return final;
 
2898
}
 
2899
 
 
2900
DerivedMesh *mesh_create_derived_index_render(Object *ob, CustomDataMask dataMask, int index)
 
2901
{
 
2902
        DerivedMesh *final;
 
2903
        Mesh *me= get_mesh(ob);
 
2904
        float *vert_copy= NULL;
 
2905
        int orig_lvl= 0;
 
2906
        
 
2907
        vert_copy= multires_render_pin(ob, me, &orig_lvl);
 
2908
        mesh_calc_modifiers(ob, NULL, NULL, &final, 1, 1, 0, dataMask, index);
2665
2909
        multires_render_final(ob, me, &final, vert_copy, orig_lvl, dataMask);
2666
2910
 
2667
2911
        return final;
2671
2915
{
2672
2916
        DerivedMesh *final;
2673
2917
 
2674
 
        mesh_calc_modifiers(ob, NULL, NULL, &final, 0, 1, 0, dataMask);
 
2918
        mesh_calc_modifiers(ob, NULL, NULL, &final, 0, 1, 0, dataMask, -1);
2675
2919
 
2676
2920
        return final;
2677
2921
}
2681
2925
{
2682
2926
        DerivedMesh *final;
2683
2927
        
2684
 
        mesh_calc_modifiers(ob, vertCos, NULL, &final, 0, 0, 0, dataMask);
 
2928
        mesh_calc_modifiers(ob, vertCos, NULL, &final, 0, 0, 0, dataMask, -1);
2685
2929
 
2686
2930
        return final;
2687
2931
}
2696
2940
        int orig_lvl= 0;
2697
2941
 
2698
2942
        vert_copy= multires_render_pin(ob, me, &orig_lvl);
2699
 
        mesh_calc_modifiers(ob, vertCos, NULL, &final, 1, 0, 0, dataMask);
 
2943
        mesh_calc_modifiers(ob, vertCos, NULL, &final, 1, 0, 0, dataMask, -1);
2700
2944
        multires_render_final(ob, me, &final, vert_copy, orig_lvl, dataMask);
2701
2945
 
2702
2946
        return final;
2848
3092
        return numleft;
2849
3093
}
2850
3094
 
2851
 
/* ************************* fluidsim bobj file handling **************************** */
2852
 
 
2853
 
#ifndef DISABLE_ELBEEM
2854
 
 
2855
 
#ifdef WIN32
2856
 
#ifndef snprintf
2857
 
#define snprintf _snprintf
2858
 
#endif
2859
 
#endif
2860
 
 
2861
 
/* write .bobj.gz file for a mesh object */
2862
 
void writeBobjgz(char *filename, struct Object *ob, int useGlobalCoords, int append, float time) 
2863
 
{
2864
 
        char debugStrBuffer[256];
2865
 
        int wri,i,j,totvert,totface;
2866
 
        float wrf;
2867
 
        gzFile gzf;
2868
 
        DerivedMesh *dm;
2869
 
        float vec[3];
2870
 
        float rotmat[3][3];
2871
 
        MVert *mvert;
2872
 
        MFace *mface;
2873
 
        //if(append)return; // DEBUG
2874
 
 
2875
 
        if(!ob->data || (ob->type!=OB_MESH)) {
2876
 
                snprintf(debugStrBuffer,256,"Writing GZ_BOBJ Invalid object %s ...\n", ob->id.name); 
2877
 
                elbeemDebugOut(debugStrBuffer);
2878
 
                return;
2879
 
        }
2880
 
        if((ob->size[0]<0.0) || (ob->size[0]<0.0) || (ob->size[0]<0.0) ) {
2881
 
                snprintf(debugStrBuffer,256,"\nfluidSim::writeBobjgz:: Warning object %s has negative scaling - check triangle ordering...?\n\n", ob->id.name); 
2882
 
                elbeemDebugOut(debugStrBuffer);
2883
 
        }
2884
 
 
2885
 
        snprintf(debugStrBuffer,256,"Writing GZ_BOBJ '%s' ... ",filename); elbeemDebugOut(debugStrBuffer); 
2886
 
        if(append) gzf = gzopen(filename, "a+b9");
2887
 
        else       gzf = gzopen(filename, "wb9");
2888
 
        if (!gzf) {
2889
 
                snprintf(debugStrBuffer,256,"writeBobjgz::error - Unable to open file for writing '%s'\n", filename);
2890
 
                elbeemDebugOut(debugStrBuffer);
2891
 
                return;
2892
 
        }
2893
 
 
2894
 
        dm = mesh_create_derived_render(ob, CD_MASK_BAREMESH);
2895
 
        //dm = mesh_create_derived_no_deform(ob,NULL);
2896
 
 
2897
 
        mvert = dm->getVertArray(dm);
2898
 
        mface = dm->getFaceArray(dm);
2899
 
        totvert = dm->getNumVerts(dm);
2900
 
        totface = dm->getNumFaces(dm);
2901
 
 
2902
 
        // write time value for appended anim mesh
2903
 
        if(append) {
2904
 
                gzwrite(gzf, &time, sizeof(time));
2905
 
        }
2906
 
 
2907
 
        // continue with verts/norms
2908
 
        if(sizeof(wri)!=4) { snprintf(debugStrBuffer,256,"Writing GZ_BOBJ, Invalid int size %d...\n", wri); elbeemDebugOut(debugStrBuffer); return; } // paranoia check
2909
 
        wri = dm->getNumVerts(dm);
2910
 
        mvert = dm->getVertArray(dm);
2911
 
        gzwrite(gzf, &wri, sizeof(wri));
2912
 
        for(i=0; i<wri;i++) {
2913
 
                VECCOPY(vec, mvert[i].co);
2914
 
                if(useGlobalCoords) { Mat4MulVecfl(ob->obmat, vec); }
2915
 
                for(j=0; j<3; j++) {
2916
 
                        wrf = vec[j]; 
2917
 
                        gzwrite(gzf, &wrf, sizeof( wrf )); 
2918
 
                }
2919
 
        }
2920
 
 
2921
 
        // should be the same as Vertices.size
2922
 
        wri = totvert;
2923
 
        gzwrite(gzf, &wri, sizeof(wri));
2924
 
        EulToMat3(ob->rot, rotmat);
2925
 
        for(i=0; i<wri;i++) {
2926
 
                VECCOPY(vec, mvert[i].no);
2927
 
                Normalize(vec);
2928
 
                if(useGlobalCoords) { Mat3MulVecfl(rotmat, vec); }
2929
 
                for(j=0; j<3; j++) {
2930
 
                        wrf = vec[j];
2931
 
                        gzwrite(gzf, &wrf, sizeof( wrf )); 
2932
 
                }
2933
 
        }
2934
 
 
2935
 
        // append only writes verts&norms 
2936
 
        if(!append) {
2937
 
                //float side1[3],side2[3],norm1[3],norm2[3];
2938
 
                //float inpf;
2939
 
        
2940
 
                // compute no. of triangles 
2941
 
                wri = 0;
2942
 
                for(i=0; i<totface; i++) {
2943
 
                        wri++;
2944
 
                        if(mface[i].v4) { wri++; }
2945
 
                }
2946
 
                gzwrite(gzf, &wri, sizeof(wri));
2947
 
                for(i=0; i<totface; i++) {
2948
 
 
2949
 
                        int face[4];
2950
 
                        face[0] = mface[i].v1;
2951
 
                        face[1] = mface[i].v2;
2952
 
                        face[2] = mface[i].v3;
2953
 
                        face[3] = mface[i].v4;
2954
 
                        //snprintf(debugStrBuffer,256,"F %s %d = %d,%d,%d,%d \n",ob->id.name, i, face[0],face[1],face[2],face[3] ); elbeemDebugOut(debugStrBuffer);
2955
 
                        //VecSubf(side1, mvert[face[1]].co,mvert[face[0]].co);
2956
 
                        //VecSubf(side2, mvert[face[2]].co,mvert[face[0]].co);
2957
 
                        //Crossf(norm1,side1,side2);
2958
 
                        gzwrite(gzf, &(face[0]), sizeof( face[0] )); 
2959
 
                        gzwrite(gzf, &(face[1]), sizeof( face[1] )); 
2960
 
                        gzwrite(gzf, &(face[2]), sizeof( face[2] )); 
2961
 
                        if(face[3]) { 
2962
 
                                //VecSubf(side1, mvert[face[2]].co,mvert[face[0]].co);
2963
 
                                //VecSubf(side2, mvert[face[3]].co,mvert[face[0]].co);
2964
 
                                //Crossf(norm2,side1,side2);
2965
 
                                //inpf = Inpf(norm1,norm2);
2966
 
                                //if(inpf>0.) {
2967
 
                                gzwrite(gzf, &(face[0]), sizeof( face[0] )); 
2968
 
                                gzwrite(gzf, &(face[2]), sizeof( face[2] )); 
2969
 
                                gzwrite(gzf, &(face[3]), sizeof( face[3] )); 
2970
 
                                //} else {
2971
 
                                        //gzwrite(gzf, &(face[0]), sizeof( face[0] )); 
2972
 
                                        //gzwrite(gzf, &(face[3]), sizeof( face[3] )); 
2973
 
                                        //gzwrite(gzf, &(face[2]), sizeof( face[2] )); 
2974
 
                                //}
2975
 
                        } // quad
2976
 
                }
2977
 
        }
2978
 
 
2979
 
        snprintf(debugStrBuffer,256,"Done. #Vertices: %d, #Triangles: %d\n", totvert, totface ); 
2980
 
        elbeemDebugOut(debugStrBuffer);
2981
 
        
2982
 
        gzclose( gzf );
2983
 
        dm->release(dm);
2984
 
}
2985
 
 
2986
 
void initElbeemMesh(struct Object *ob, 
2987
 
                int *numVertices, float **vertices, 
2988
 
                int *numTriangles, int **triangles,
2989
 
                int useGlobalCoords) 
2990
 
{
2991
 
        DerivedMesh *dm = NULL;
2992
 
        MVert *mvert;
2993
 
        MFace *mface;
2994
 
        int countTris=0, i, totvert, totface;
2995
 
        float *verts;
2996
 
        int *tris;
2997
 
 
2998
 
        dm = mesh_create_derived_render(ob, CD_MASK_BAREMESH);
2999
 
        //dm = mesh_create_derived_no_deform(ob,NULL);
3000
 
 
3001
 
        mvert = dm->getVertArray(dm);
3002
 
        mface = dm->getFaceArray(dm);
3003
 
        totvert = dm->getNumVerts(dm);
3004
 
        totface = dm->getNumFaces(dm);
3005
 
 
3006
 
        *numVertices = totvert;
3007
 
        verts = MEM_callocN( totvert*3*sizeof(float), "elbeemmesh_vertices");
3008
 
        for(i=0; i<totvert; i++) {
3009
 
                VECCOPY( &verts[i*3], mvert[i].co);
3010
 
                if(useGlobalCoords) { Mat4MulVecfl(ob->obmat, &verts[i*3]); }
3011
 
        }
3012
 
        *vertices = verts;
3013
 
 
3014
 
        for(i=0; i<totface; i++) {
3015
 
                countTris++;
3016
 
                if(mface[i].v4) { countTris++; }
3017
 
        }
3018
 
        *numTriangles = countTris;
3019
 
        tris = MEM_callocN( countTris*3*sizeof(int), "elbeemmesh_triangles");
3020
 
        countTris = 0;
3021
 
        for(i=0; i<totface; i++) {
3022
 
                int face[4];
3023
 
                face[0] = mface[i].v1;
3024
 
                face[1] = mface[i].v2;
3025
 
                face[2] = mface[i].v3;
3026
 
                face[3] = mface[i].v4;
3027
 
 
3028
 
                tris[countTris*3+0] = face[0]; 
3029
 
                tris[countTris*3+1] = face[1]; 
3030
 
                tris[countTris*3+2] = face[2]; 
3031
 
                countTris++;
3032
 
                if(face[3]) { 
3033
 
                        tris[countTris*3+0] = face[0]; 
3034
 
                        tris[countTris*3+1] = face[2]; 
3035
 
                        tris[countTris*3+2] = face[3]; 
3036
 
                        countTris++;
3037
 
                }
3038
 
        }
3039
 
        *triangles = tris;
3040
 
 
3041
 
        dm->release(dm);
3042
 
}
3043
 
 
3044
 
/* read .bobj.gz file into a fluidsimDerivedMesh struct */
3045
 
Mesh* readBobjgz(char *filename, Mesh *orgmesh, float* bbstart, float *bbsize) //, fluidsimDerivedMesh *fsdm)
3046
 
{
3047
 
        int wri,i,j;
3048
 
        char debugStrBuffer[256];
3049
 
        float wrf;
3050
 
        Mesh *newmesh; 
3051
 
        const int debugBobjRead = 1;
3052
 
        // init data from old mesh (materials,flags)
3053
 
        MFace *origMFace = &((MFace*) orgmesh->mface)[0];
3054
 
        int mat_nr = -1;
3055
 
        int flag = -1;
3056
 
        MFace *fsface = NULL;
3057
 
        int gotBytes;
3058
 
        gzFile gzf;
3059
 
 
3060
 
        if(!orgmesh) return NULL;
3061
 
        if(!origMFace) return NULL;
3062
 
        mat_nr = origMFace->mat_nr;
3063
 
        flag = origMFace->flag;
3064
 
 
3065
 
        // similar to copy_mesh
3066
 
        newmesh = MEM_dupallocN(orgmesh);
3067
 
        newmesh->mat= orgmesh->mat;
3068
 
 
3069
 
        newmesh->mvert= NULL;
3070
 
        newmesh->medge= NULL;
3071
 
        newmesh->mface= NULL;
3072
 
        newmesh->mtface= NULL;
3073
 
 
3074
 
        newmesh->dvert = NULL;
3075
 
 
3076
 
        newmesh->mcol= NULL;
3077
 
        newmesh->msticky= NULL;
3078
 
        newmesh->texcomesh= NULL;
3079
 
        memset(&newmesh->vdata, 0, sizeof(newmesh->vdata));
3080
 
        memset(&newmesh->edata, 0, sizeof(newmesh->edata));
3081
 
        memset(&newmesh->fdata, 0, sizeof(newmesh->fdata));
3082
 
 
3083
 
        newmesh->key= NULL;
3084
 
        newmesh->totface = 0;
3085
 
        newmesh->totvert = 0;
3086
 
        newmesh->totedge = 0;
3087
 
        newmesh->medge = NULL;
3088
 
 
3089
 
 
3090
 
        snprintf(debugStrBuffer,256,"Reading '%s' GZ_BOBJ... ",filename); elbeemDebugOut(debugStrBuffer); 
3091
 
        gzf = gzopen(filename, "rb");
3092
 
        // gzf = fopen(filename, "rb");
3093
 
        // debug: fread(b,c,1,a) = gzread(a,b,c)
3094
 
        if (!gzf) {
3095
 
                //snprintf(debugStrBuffer,256,"readBobjgz::error - Unable to open file for reading '%s'\n", filename); // DEBUG
3096
 
                MEM_freeN(newmesh);
3097
 
                return NULL;
3098
 
        }
3099
 
 
3100
 
        //if(sizeof(wri)!=4) { snprintf(debugStrBuffer,256,"Reading GZ_BOBJ, Invalid int size %d...\n", wri); return NULL; } // paranoia check
3101
 
        gotBytes = gzread(gzf, &wri, sizeof(wri));
3102
 
        newmesh->totvert = wri;
3103
 
        newmesh->mvert = CustomData_add_layer(&newmesh->vdata, CD_MVERT, CD_CALLOC, NULL, newmesh->totvert);
3104
 
        if(debugBobjRead){ snprintf(debugStrBuffer,256,"#vertices %d ", newmesh->totvert); elbeemDebugOut(debugStrBuffer); } //DEBUG
3105
 
        for(i=0; i<newmesh->totvert;i++) {
3106
 
                //if(debugBobjRead) snprintf(debugStrBuffer,256,"V %d = ",i);
3107
 
                for(j=0; j<3; j++) {
3108
 
                        gotBytes = gzread(gzf, &wrf, sizeof( wrf )); 
3109
 
                        newmesh->mvert[i].co[j] = wrf;
3110
 
                        //if(debugBobjRead) snprintf(debugStrBuffer,256,"%25.20f ", wrf);
3111
 
                }
3112
 
                //if(debugBobjRead) snprintf(debugStrBuffer,256,"\n");
3113
 
        }
3114
 
 
3115
 
        // should be the same as Vertices.size
3116
 
        gotBytes = gzread(gzf, &wri, sizeof(wri));
3117
 
        if(wri != newmesh->totvert) {
3118
 
                // complain #vertices has to be equal to #normals, reset&abort
3119
 
                CustomData_free_layer_active(&newmesh->vdata, CD_MVERT, newmesh->totvert);
3120
 
                MEM_freeN(newmesh);
3121
 
                snprintf(debugStrBuffer,256,"Reading GZ_BOBJ, #normals=%d, #vertices=%d, aborting...\n", wri,newmesh->totvert );
3122
 
                return NULL;
3123
 
        }
3124
 
        for(i=0; i<newmesh->totvert;i++) {
3125
 
                for(j=0; j<3; j++) {
3126
 
                        gotBytes = gzread(gzf, &wrf, sizeof( wrf )); 
3127
 
                        newmesh->mvert[i].no[j] = (short)(wrf*32767.0f);
3128
 
                        //newmesh->mvert[i].no[j] = 0.5; // DEBUG tst
3129
 
                }
3130
 
        //fprintf(stderr,"  DEBDPCN nm%d, %d = %d,%d,%d \n",
3131
 
                        //(int)(newmesh->mvert), i, newmesh->mvert[i].no[0], newmesh->mvert[i].no[1], newmesh->mvert[i].no[2]);
3132
 
        }
3133
 
        //fprintf(stderr,"  DPCN 0 = %d,%d,%d \n", newmesh->mvert[0].no[0], newmesh->mvert[0].no[1], newmesh->mvert[0].no[2]);
3134
 
 
3135
 
        
3136
 
        /* compute no. of triangles */
3137
 
        gotBytes = gzread(gzf, &wri, sizeof(wri));
3138
 
        newmesh->totface = wri;
3139
 
        newmesh->mface = CustomData_add_layer(&newmesh->fdata, CD_MFACE, CD_CALLOC, NULL, newmesh->totface);
3140
 
        if(debugBobjRead){ snprintf(debugStrBuffer,256,"#faces %d ", newmesh->totface); elbeemDebugOut(debugStrBuffer); } //DEBUG
3141
 
        fsface = newmesh->mface;
3142
 
        for(i=0; i<newmesh->totface; i++) {
3143
 
                int face[4];
3144
 
 
3145
 
                gotBytes = gzread(gzf, &(face[0]), sizeof( face[0] )); 
3146
 
                gotBytes = gzread(gzf, &(face[1]), sizeof( face[1] )); 
3147
 
                gotBytes = gzread(gzf, &(face[2]), sizeof( face[2] )); 
3148
 
                face[3] = 0;
3149
 
 
3150
 
                fsface[i].v1 = face[0];
3151
 
                fsface[i].v2 = face[1];
3152
 
                fsface[i].v3 = face[2];
3153
 
                fsface[i].v4 = face[3];
3154
 
        }
3155
 
 
3156
 
        // correct triangles with v3==0 for blender, cycle verts
3157
 
        for(i=0; i<newmesh->totface; i++) {
3158
 
                if(!fsface[i].v3) {
3159
 
                        int temp = fsface[i].v1;
3160
 
                        fsface[i].v1 = fsface[i].v2;
3161
 
                        fsface[i].v2 = fsface[i].v3;
3162
 
                        fsface[i].v3 = temp;
3163
 
                }
3164
 
        }
3165
 
        
3166
 
        gzclose( gzf );
3167
 
        for(i=0;i<newmesh->totface;i++) { 
3168
 
                fsface[i].mat_nr = mat_nr;
3169
 
                fsface[i].flag = flag;
3170
 
                fsface[i].edcode = ME_V1V2 | ME_V2V3 | ME_V3V1;
3171
 
                //snprintf(debugStrBuffer,256,"%d : %d,%d,%d\n", i,fsface[i].mat_nr, fsface[i].flag, fsface[i].edcode );
3172
 
        }
3173
 
 
3174
 
        snprintf(debugStrBuffer,256," (%d,%d) done\n", newmesh->totvert,newmesh->totface); elbeemDebugOut(debugStrBuffer); //DEBUG
3175
 
        return newmesh;
3176
 
}
3177
 
 
3178
 
/* read zipped fluidsim velocities into the co's of the fluidsimsettings normals struct */
3179
 
void readVelgz(char *filename, Object *srcob)
3180
 
{
3181
 
        char debugStrBuffer[256];
3182
 
        int wri, i, j;
3183
 
        float wrf;
3184
 
        gzFile gzf;
3185
 
        MVert *vverts = srcob->fluidsimSettings->meshSurfNormals;
3186
 
        int len = strlen(filename);
3187
 
        Mesh *mesh = srcob->data;
3188
 
        // mesh and vverts have to be valid from loading...
3189
 
 
3190
 
        // clean up in any case
3191
 
        for(i=0; i<mesh->totvert;i++) { 
3192
 
                for(j=0; j<3; j++) {
3193
 
                        vverts[i].co[j] = 0.; 
3194
 
                } 
3195
 
        } 
3196
 
        if(srcob->fluidsimSettings->domainNovecgen>0) return;
3197
 
 
3198
 
        if(len<7) { 
3199
 
                //printf("readVelgz Eror: invalid filename '%s'\n",filename); // DEBUG
3200
 
                return; 
3201
 
        }
3202
 
 
3203
 
        // .bobj.gz , correct filename
3204
 
        // 87654321
3205
 
        filename[len-6] = 'v';
3206
 
        filename[len-5] = 'e';
3207
 
        filename[len-4] = 'l';
3208
 
 
3209
 
        snprintf(debugStrBuffer,256,"Reading '%s' GZ_VEL... ",filename); elbeemDebugOut(debugStrBuffer); 
3210
 
        gzf = gzopen(filename, "rb");
3211
 
        if (!gzf) { 
3212
 
                //printf("readVelgz Eror: unable to open file '%s'\n",filename); // DEBUG
3213
 
                return; 
3214
 
        }
3215
 
 
3216
 
        gzread(gzf, &wri, sizeof( wri ));
3217
 
        if(wri != mesh->totvert) {
3218
 
                //printf("readVelgz Eror: invalid no. of velocities %d vs. %d aborting.\n" ,wri ,mesh->totvert ); // DEBUG
3219
 
                return; 
3220
 
        }
3221
 
 
3222
 
        for(i=0; i<mesh->totvert;i++) {
3223
 
                for(j=0; j<3; j++) {
3224
 
                        gzread(gzf, &wrf, sizeof( wrf )); 
3225
 
                        vverts[i].co[j] = wrf;
3226
 
                }
3227
 
                //if(i<20) fprintf(stderr, "GZ_VELload %d = %f,%f,%f  \n",i,vverts[i].co[0],vverts[i].co[1],vverts[i].co[2]); // DEBUG
3228
 
        }
3229
 
 
3230
 
        gzclose(gzf);
3231
 
}
3232
 
 
3233
 
 
3234
 
/* ***************************** fluidsim derived mesh ***************************** */
3235
 
 
3236
 
/* check which file to load, and replace old mesh of the object with it */
3237
 
/* this replacement is undone at the end of mesh_calc_modifiers */
3238
 
void loadFluidsimMesh(Object *srcob, int useRenderParams)
3239
 
{
3240
 
        Mesh *mesh = NULL;
3241
 
        float *bbStart = NULL, *bbSize = NULL;
3242
 
        float lastBB[3];
3243
 
        int displaymode = 0;
3244
 
        int curFrame = G.scene->r.cfra - 1 /*G.scene->r.sfra*/; /* start with 0 at start frame */
3245
 
        char targetDir[FILE_MAXFILE+FILE_MAXDIR], targetFile[FILE_MAXFILE+FILE_MAXDIR];
3246
 
        char debugStrBuffer[256];
3247
 
        //snprintf(debugStrBuffer,256,"loadFluidsimMesh call (obid '%s', rp %d)\n", srcob->id.name, useRenderParams); // debug
3248
 
 
3249
 
        if((!srcob)||(!srcob->fluidsimSettings)) {
3250
 
                snprintf(debugStrBuffer,256,"DEBUG - Invalid loadFluidsimMesh call, rp %d, dm %d)\n", useRenderParams, displaymode); // debug
3251
 
                elbeemDebugOut(debugStrBuffer); // debug
3252
 
                return;
3253
 
        }
3254
 
        // make sure the original mesh data pointer is stored
3255
 
        if(!srcob->fluidsimSettings->orgMesh) {
3256
 
                srcob->fluidsimSettings->orgMesh = srcob->data;
3257
 
        }
3258
 
 
3259
 
        // free old mesh, if there is one (todo, check if it's still valid?)
3260
 
        if(srcob->fluidsimSettings->meshSurface) {
3261
 
                Mesh *freeFsMesh = srcob->fluidsimSettings->meshSurface;
3262
 
 
3263
 
                // similar to free_mesh(...) , but no things like unlink...
3264
 
                CustomData_free(&freeFsMesh->vdata, freeFsMesh->totvert);
3265
 
                CustomData_free(&freeFsMesh->edata, freeFsMesh->totedge);
3266
 
                CustomData_free(&freeFsMesh->fdata, freeFsMesh->totface);
3267
 
                MEM_freeN(freeFsMesh);
3268
 
                
3269
 
                if(srcob->data == srcob->fluidsimSettings->meshSurface)
3270
 
                 srcob->data = srcob->fluidsimSettings->orgMesh;
3271
 
                srcob->fluidsimSettings->meshSurface = NULL;
3272
 
 
3273
 
                if(srcob->fluidsimSettings->meshSurfNormals) MEM_freeN(srcob->fluidsimSettings->meshSurfNormals);
3274
 
                srcob->fluidsimSettings->meshSurfNormals = NULL;
3275
 
        } 
3276
 
 
3277
 
        // init bounding box
3278
 
        bbStart = srcob->fluidsimSettings->bbStart; 
3279
 
        bbSize = srcob->fluidsimSettings->bbSize;
3280
 
        lastBB[0] = bbSize[0];  // TEST
3281
 
        lastBB[1] = bbSize[1]; 
3282
 
        lastBB[2] = bbSize[2];
3283
 
        fluidsimGetAxisAlignedBB(srcob->fluidsimSettings->orgMesh, srcob->obmat, bbStart, bbSize, &srcob->fluidsimSettings->meshBB);
3284
 
        // check free fsmesh... TODO
3285
 
        
3286
 
        if(!useRenderParams) {
3287
 
                displaymode = srcob->fluidsimSettings->guiDisplayMode;
3288
 
        } else {
3289
 
                displaymode = srcob->fluidsimSettings->renderDisplayMode;
3290
 
        }
3291
 
        
3292
 
        snprintf(debugStrBuffer,256,"loadFluidsimMesh call (obid '%s', rp %d, dm %d), curFra=%d, sFra=%d #=%d \n", 
3293
 
                        srcob->id.name, useRenderParams, displaymode, G.scene->r.cfra, G.scene->r.sfra, curFrame ); // debug
3294
 
        elbeemDebugOut(debugStrBuffer); // debug
3295
 
 
3296
 
        strncpy(targetDir, srcob->fluidsimSettings->surfdataPath, FILE_MAXDIR);
3297
 
        // use preview or final mesh?
3298
 
        if(displaymode==1) {
3299
 
                // just display original object
3300
 
                srcob->data = srcob->fluidsimSettings->orgMesh;
3301
 
                return;
3302
 
        } else if(displaymode==2) {
3303
 
                strcat(targetDir,"fluidsurface_preview_####");
3304
 
        } else { // 3
3305
 
                strcat(targetDir,"fluidsurface_final_####");
3306
 
        }
3307
 
        BLI_convertstringcode(targetDir, G.sce);
3308
 
        BLI_convertstringframe(targetDir, curFrame); // fixed #frame-no 
3309
 
        
3310
 
        strcpy(targetFile,targetDir);
3311
 
        strcat(targetFile, ".bobj.gz");
3312
 
 
3313
 
        snprintf(debugStrBuffer,256,"loadFluidsimMesh call (obid '%s', rp %d, dm %d) '%s' \n", srcob->id.name, useRenderParams, displaymode, targetFile);  // debug
3314
 
        elbeemDebugOut(debugStrBuffer); // debug
3315
 
 
3316
 
        if(displaymode!=2) { // dont add bounding box for final
3317
 
                mesh = readBobjgz(targetFile, srcob->fluidsimSettings->orgMesh ,NULL,NULL);
3318
 
        } else {
3319
 
                mesh = readBobjgz(targetFile, srcob->fluidsimSettings->orgMesh, bbSize,bbSize );
3320
 
        }
3321
 
        if(!mesh) {
3322
 
                // switch, abort background rendering when fluidsim mesh is missing
3323
 
                const char *strEnvName2 = "BLENDER_ELBEEMBOBJABORT"; // from blendercall.cpp
3324
 
                if(G.background==1) {
3325
 
                        if(getenv(strEnvName2)) {
3326
 
                                int elevel = atoi(getenv(strEnvName2));
3327
 
                                if(elevel>0) {
3328
 
                                        printf("Env. var %s set, fluid sim mesh '%s' not found, aborting render...\n",strEnvName2, targetFile);
3329
 
                                        exit(1);
3330
 
                                }
3331
 
                        }
3332
 
                }
3333
 
                
3334
 
                // display org. object upon failure
3335
 
                srcob->data = srcob->fluidsimSettings->orgMesh;
3336
 
                return;
3337
 
        }
3338
 
 
3339
 
        if((mesh)&&(mesh->totvert>0)) {
3340
 
                make_edges(mesh, 0);    // 0 = make all edges draw
3341
 
        }
3342
 
        srcob->fluidsimSettings->meshSurface = mesh;
3343
 
        srcob->data = mesh;
3344
 
        srcob->fluidsimSettings->meshSurfNormals = MEM_dupallocN(mesh->mvert);
3345
 
 
3346
 
        // load vertex velocities, if they exist...
3347
 
        // TODO? use generate flag as loading flag as well?
3348
 
        // warning, needs original .bobj.gz mesh loading filename
3349
 
        if(displaymode==3) {
3350
 
                readVelgz(targetFile, srcob);
3351
 
        } else {
3352
 
                // no data for preview, only clear...
3353
 
                int i,j;
3354
 
                for(i=0; i<mesh->totvert;i++) { for(j=0; j<3; j++) { srcob->fluidsimSettings->meshSurfNormals[i].co[j] = 0.; }} 
3355
 
        }
3356
 
 
3357
 
        //fprintf(stderr,"LOADFLM DEBXHCH fs=%d 3:%d,%d,%d \n", (int)mesh, ((Mesh *)(srcob->fluidsimSettings->meshSurface))->mvert[3].no[0], ((Mesh *)(srcob->fluidsimSettings->meshSurface))->mvert[3].no[1], ((Mesh *)(srcob->fluidsimSettings->meshSurface))->mvert[3].no[2]);
3358
 
        return;
3359
 
}
3360
 
 
3361
 
/* helper function */
3362
 
/* init axis aligned BB for mesh object */
3363
 
void fluidsimGetAxisAlignedBB(struct Mesh *mesh, float obmat[][4],
3364
 
                 /*RET*/ float start[3], /*RET*/ float size[3], /*RET*/ struct Mesh **bbmesh )
3365
 
{
3366
 
        float bbsx=0.0, bbsy=0.0, bbsz=0.0;
3367
 
        float bbex=1.0, bbey=1.0, bbez=1.0;
3368
 
        int i;
3369
 
        float vec[3];
3370
 
 
3371
 
        VECCOPY(vec, mesh->mvert[0].co); 
3372
 
        Mat4MulVecfl(obmat, vec);
3373
 
        bbsx = vec[0]; bbsy = vec[1]; bbsz = vec[2];
3374
 
        bbex = vec[0]; bbey = vec[1]; bbez = vec[2];
3375
 
 
3376
 
        for(i=1; i<mesh->totvert;i++) {
3377
 
                VECCOPY(vec, mesh->mvert[i].co);
3378
 
                Mat4MulVecfl(obmat, vec);
3379
 
 
3380
 
                if(vec[0] < bbsx){ bbsx= vec[0]; }
3381
 
                if(vec[1] < bbsy){ bbsy= vec[1]; }
3382
 
                if(vec[2] < bbsz){ bbsz= vec[2]; }
3383
 
                if(vec[0] > bbex){ bbex= vec[0]; }
3384
 
                if(vec[1] > bbey){ bbey= vec[1]; }
3385
 
                if(vec[2] > bbez){ bbez= vec[2]; }
3386
 
        }
3387
 
 
3388
 
        // return values...
3389
 
        if(start) {
3390
 
                start[0] = bbsx;
3391
 
                start[1] = bbsy;
3392
 
                start[2] = bbsz;
3393
 
        } 
3394
 
        if(size) {
3395
 
                size[0] = bbex-bbsx;
3396
 
                size[1] = bbey-bbsy;
3397
 
                size[2] = bbez-bbsz;
3398
 
        }
3399
 
 
3400
 
        // init bounding box mesh?
3401
 
        if(bbmesh) {
3402
 
                int i,j;
3403
 
                Mesh *newmesh = NULL;
3404
 
                if(!(*bbmesh)) { newmesh = MEM_callocN(sizeof(Mesh), "fluidsimGetAxisAlignedBB_meshbb"); }
3405
 
                else {           newmesh = *bbmesh; }
3406
 
 
3407
 
                newmesh->totvert = 8;
3408
 
                if(!newmesh->mvert)
3409
 
                        newmesh->mvert = CustomData_add_layer(&newmesh->vdata, CD_MVERT, CD_CALLOC, NULL, newmesh->totvert);
3410
 
                for(i=0; i<8; i++) {
3411
 
                        for(j=0; j<3; j++) newmesh->mvert[i].co[j] = start[j]; 
3412
 
                }
3413
 
 
3414
 
                newmesh->totface = 6;
3415
 
                if(!newmesh->mface)
3416
 
                        newmesh->mface = CustomData_add_layer(&newmesh->fdata, CD_MFACE, CD_CALLOC, NULL, newmesh->totface);
3417
 
 
3418
 
                *bbmesh = newmesh;
3419
 
        }
3420
 
}
3421
 
 
3422
 
#else // DISABLE_ELBEEM
3423
 
 
3424
 
/* dummy for mesh_calc_modifiers */
3425
 
void loadFluidsimMesh(Object *srcob, int useRenderParams) {
3426
 
}
3427
 
 
3428
 
#endif // DISABLE_ELBEEM
 
3095
/* ******************* GLSL ******************** */
 
3096
 
 
3097
void DM_add_tangent_layer(DerivedMesh *dm)
 
3098
{
 
3099
        /* mesh vars */
 
3100
        MTFace *mtface, *tf;
 
3101
        MFace *mface, *mf;
 
3102
        MVert *mvert, *v1, *v2, *v3, *v4;
 
3103
        MemArena *arena= NULL;
 
3104
        VertexTangent **vtangents= NULL;
 
3105
        float (*orco)[3]= NULL, (*tangent)[3];
 
3106
        float *uv1, *uv2, *uv3, *uv4, *vtang;
 
3107
        float fno[3], tang[3], uv[4][2];
 
3108
        int i, j, len, mf_vi[4], totvert, totface;
 
3109
 
 
3110
        if(CustomData_get_layer_index(&dm->faceData, CD_TANGENT) != -1)
 
3111
                return;
 
3112
 
 
3113
        /* check we have all the needed layers */
 
3114
        totvert= dm->getNumVerts(dm);
 
3115
        totface= dm->getNumFaces(dm);
 
3116
 
 
3117
        mvert= dm->getVertArray(dm);
 
3118
        mface= dm->getFaceArray(dm);
 
3119
        mtface= dm->getFaceDataArray(dm, CD_MTFACE);
 
3120
 
 
3121
        if(!mtface) {
 
3122
                orco= dm->getVertDataArray(dm, CD_ORCO);
 
3123
                if(!orco)
 
3124
                        return;
 
3125
        }
 
3126
        
 
3127
        /* create tangent layer */
 
3128
        DM_add_face_layer(dm, CD_TANGENT, CD_CALLOC, NULL);
 
3129
        tangent= DM_get_face_data_layer(dm, CD_TANGENT);
 
3130
        
 
3131
        /* allocate some space */
 
3132
        arena= BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE);
 
3133
        BLI_memarena_use_calloc(arena);
 
3134
        vtangents= MEM_callocN(sizeof(VertexTangent*)*totvert, "VertexTangent");
 
3135
        
 
3136
        /* sum tangents at connected vertices */
 
3137
        for(i=0, tf=mtface, mf=mface; i < totface; mf++, tf++, i++) {
 
3138
                v1= &mvert[mf->v1];
 
3139
                v2= &mvert[mf->v2];
 
3140
                v3= &mvert[mf->v3];
 
3141
 
 
3142
                if (mf->v4) {
 
3143
                        v4= &mvert[mf->v4];
 
3144
                        CalcNormFloat4(v4->co, v3->co, v2->co, v1->co, fno);
 
3145
                }
 
3146
                else {
 
3147
                        v4= NULL;
 
3148
                        CalcNormFloat(v3->co, v2->co, v1->co, fno);
 
3149
                }
 
3150
                
 
3151
                if(mtface) {
 
3152
                        uv1= tf->uv[0];
 
3153
                        uv2= tf->uv[1];
 
3154
                        uv3= tf->uv[2];
 
3155
                        uv4= tf->uv[3];
 
3156
                }
 
3157
                else {
 
3158
                        uv1= uv[0]; uv2= uv[1]; uv3= uv[2]; uv4= uv[3];
 
3159
                        spheremap(orco[mf->v1][0], orco[mf->v1][1], orco[mf->v1][2], &uv[0][0], &uv[0][1]);
 
3160
                        spheremap(orco[mf->v2][0], orco[mf->v2][1], orco[mf->v2][2], &uv[1][0], &uv[1][1]);
 
3161
                        spheremap(orco[mf->v3][0], orco[mf->v3][1], orco[mf->v3][2], &uv[2][0], &uv[2][1]);
 
3162
                        if(v4)
 
3163
                                spheremap(orco[mf->v4][0], orco[mf->v4][1], orco[mf->v4][2], &uv[3][0], &uv[3][1]);
 
3164
                }
 
3165
                
 
3166
                tangent_from_uv(uv1, uv2, uv3, v1->co, v2->co, v3->co, fno, tang);
 
3167
                sum_or_add_vertex_tangent(arena, &vtangents[mf->v1], tang, uv1);
 
3168
                sum_or_add_vertex_tangent(arena, &vtangents[mf->v2], tang, uv2);
 
3169
                sum_or_add_vertex_tangent(arena, &vtangents[mf->v3], tang, uv3);
 
3170
                
 
3171
                if(mf->v4) {
 
3172
                        v4= &mvert[mf->v4];
 
3173
                        
 
3174
                        tangent_from_uv(uv1, uv3, uv4, v1->co, v3->co, v4->co, fno, tang);
 
3175
                        sum_or_add_vertex_tangent(arena, &vtangents[mf->v1], tang, uv1);
 
3176
                        sum_or_add_vertex_tangent(arena, &vtangents[mf->v3], tang, uv3);
 
3177
                        sum_or_add_vertex_tangent(arena, &vtangents[mf->v4], tang, uv4);
 
3178
                }
 
3179
        }
 
3180
        
 
3181
        /* write tangent to layer */
 
3182
        for(i=0, tf=mtface, mf=mface; i < totface; mf++, tf++, i++, tangent+=4) {
 
3183
                len= (mf->v4)? 4 : 3; 
 
3184
                
 
3185
                if(mtface) {
 
3186
                        uv1= tf->uv[0];
 
3187
                        uv2= tf->uv[1];
 
3188
                        uv3= tf->uv[2];
 
3189
                        uv4= tf->uv[3];
 
3190
                }
 
3191
                else {
 
3192
                        uv1= uv[0]; uv2= uv[1]; uv3= uv[2]; uv4= uv[3];
 
3193
                        spheremap(orco[mf->v1][0], orco[mf->v1][1], orco[mf->v1][2], &uv[0][0], &uv[0][1]);
 
3194
                        spheremap(orco[mf->v2][0], orco[mf->v2][1], orco[mf->v2][2], &uv[1][0], &uv[1][1]);
 
3195
                        spheremap(orco[mf->v3][0], orco[mf->v3][1], orco[mf->v3][2], &uv[2][0], &uv[2][1]);
 
3196
                        if(len==4)
 
3197
                                spheremap(orco[mf->v4][0], orco[mf->v4][1], orco[mf->v4][2], &uv[3][0], &uv[3][1]);
 
3198
                }
 
3199
                
 
3200
                mf_vi[0]= mf->v1;
 
3201
                mf_vi[1]= mf->v2;
 
3202
                mf_vi[2]= mf->v3;
 
3203
                mf_vi[3]= mf->v4;
 
3204
                
 
3205
                for(j=0; j<len; j++) {
 
3206
                        vtang= find_vertex_tangent(vtangents[mf_vi[j]], mtface ? tf->uv[j] : uv[j]);
 
3207
 
 
3208
                        VECCOPY(tangent[j], vtang);
 
3209
                        Normalize(tangent[j]);
 
3210
                }
 
3211
        }
 
3212
        
 
3213
        BLI_memarena_free(arena);
 
3214
        MEM_freeN(vtangents);
 
3215
}
 
3216
 
 
3217
void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs, DMVertexAttribs *attribs)
 
3218
{
 
3219
        CustomData *vdata, *fdata, *tfdata = NULL;
 
3220
        int a, b, layer;
 
3221
 
 
3222
        /* From the layers requested by the GLSL shader, figure out which ones are
 
3223
         * actually available for this derivedmesh, and retrieve the pointers */
 
3224
 
 
3225
        memset(attribs, 0, sizeof(DMVertexAttribs));
 
3226
 
 
3227
        vdata = &dm->vertData;
 
3228
        fdata = &dm->faceData;
 
3229
 
 
3230
        /* ugly hack, editmesh derivedmesh doesn't copy face data, this way we
 
3231
         * can use offsets instead */
 
3232
        if(dm->release == emDM_release)
 
3233
                tfdata = &((EditMeshDerivedMesh*)dm)->em->fdata;
 
3234
        else
 
3235
                tfdata = fdata;
 
3236
 
 
3237
        /* add a tangent layer if necessary */
 
3238
        for(b = 0; b < gattribs->totlayer; b++)
 
3239
                if(gattribs->layer[b].type == CD_TANGENT)
 
3240
                        if(CustomData_get_layer_index(fdata, CD_TANGENT) == -1)
 
3241
                                DM_add_tangent_layer(dm);
 
3242
 
 
3243
        for(b = 0; b < gattribs->totlayer; b++) {
 
3244
                if(gattribs->layer[b].type == CD_MTFACE) {
 
3245
                        /* uv coordinates */
 
3246
                        if(gattribs->layer[b].name[0])
 
3247
                                layer = CustomData_get_named_layer_index(tfdata, CD_MTFACE,
 
3248
                                        gattribs->layer[b].name);
 
3249
                        else
 
3250
                                layer = CustomData_get_active_layer_index(tfdata, CD_MTFACE);
 
3251
 
 
3252
                        if(layer != -1) {
 
3253
                                a = attribs->tottface++;
 
3254
 
 
3255
                                attribs->tface[a].array = tfdata->layers[layer].data;
 
3256
                                attribs->tface[a].emOffset = tfdata->layers[layer].offset;
 
3257
                                attribs->tface[a].glIndex = gattribs->layer[b].glindex;
 
3258
                        }
 
3259
                }
 
3260
                else if(gattribs->layer[b].type == CD_MCOL) {
 
3261
                        /* vertex colors */
 
3262
                        if(gattribs->layer[b].name[0])
 
3263
                                layer = CustomData_get_named_layer_index(tfdata, CD_MCOL,
 
3264
                                        gattribs->layer[b].name);
 
3265
                        else
 
3266
                                layer = CustomData_get_active_layer_index(tfdata, CD_MCOL);
 
3267
 
 
3268
                        if(layer != -1) {
 
3269
                                a = attribs->totmcol++;
 
3270
 
 
3271
                                attribs->mcol[a].array = tfdata->layers[layer].data;
 
3272
                                attribs->mcol[a].emOffset = tfdata->layers[layer].offset;
 
3273
                                attribs->mcol[a].glIndex = gattribs->layer[b].glindex;
 
3274
                        }
 
3275
                }
 
3276
                else if(gattribs->layer[b].type == CD_TANGENT) {
 
3277
                        /* tangents */
 
3278
                        layer = CustomData_get_layer_index(fdata, CD_TANGENT);
 
3279
 
 
3280
                        if(layer != -1) {
 
3281
                                attribs->tottang = 1;
 
3282
 
 
3283
                                attribs->tang.array = fdata->layers[layer].data;
 
3284
                                attribs->tang.emOffset = fdata->layers[layer].offset;
 
3285
                                attribs->tang.glIndex = gattribs->layer[b].glindex;
 
3286
                        }
 
3287
                }
 
3288
                else if(gattribs->layer[b].type == CD_ORCO) {
 
3289
                        /* original coordinates */
 
3290
                        layer = CustomData_get_layer_index(vdata, CD_ORCO);
 
3291
 
 
3292
                        if(layer != -1) {
 
3293
                                attribs->totorco = 1;
 
3294
 
 
3295
                                attribs->orco.array = vdata->layers[layer].data;
 
3296
                                attribs->orco.emOffset = vdata->layers[layer].offset;
 
3297
                                attribs->orco.glIndex = gattribs->layer[b].glindex;
 
3298
                        }
 
3299
                }
 
3300
        }
 
3301
}
3429
3302