← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/gameengine/Converter/BL_BlenderDataConversion.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2007-05-17 11:47:59 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070517114759-yp4ybrnhp2u7pk66
Tags: 2.44-1
* New upstream release.
* Drop debian/patches/01_64bits_stupidity, not needed anymore: as of this
  version blender is 64 bits safe again. Adjust README.Debian accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Converter/BL_BlenderDataConversion.cpp
1
1
/**
2
 
 * $Id: BL_BlenderDataConversion.cpp,v 1.58 2007/02/05 08:07:55 snailrose Exp $
 
2
 * $Id: BL_BlenderDataConversion.cpp,v 1.61 2007/04/29 13:39:46 campbellbarton Exp $
3
3
 *
4
4
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5
5
 *
190
190
        {
191
191
                unsigned int integer;
192
192
                unsigned char cp[4];
193
 
        } out_colour, in_colour;
194
 
        
195
 
        in_colour.integer = icol;
196
 
        out_colour.cp[0] = in_colour.cp[3]; // red
197
 
        out_colour.cp[1] = in_colour.cp[2]; // green
198
 
        out_colour.cp[2] = in_colour.cp[1]; // blue
199
 
        out_colour.cp[3] = in_colour.cp[0]; // alpha
200
 
        
201
 
        return out_colour.integer;
 
193
        } out_color, in_color;
 
194
        
 
195
        in_color.integer = icol;
 
196
        out_color.cp[0] = in_color.cp[3]; // red
 
197
        out_color.cp[1] = in_color.cp[2]; // green
 
198
        out_color.cp[2] = in_color.cp[1]; // blue
 
199
        out_color.cp[3] = in_color.cp[0]; // alpha
 
200
        
 
201
        return out_color.integer;
202
202
}
203
203
 
204
204
/* Now the real converting starts... */
210
210
                MCol col;
211
211
                unsigned int integer;
212
212
                unsigned char cp[4];
213
 
        } out_colour, in_colour;
 
213
        } out_color, in_color;
214
214
 
215
 
        in_colour.col = col;
216
 
        out_colour.cp[0] = in_colour.cp[3]; // red
217
 
        out_colour.cp[1] = in_colour.cp[2]; // green
218
 
        out_colour.cp[2] = in_colour.cp[1]; // blue
219
 
        out_colour.cp[3] = in_colour.cp[0]; // alpha
 
215
        in_color.col = col;
 
216
        out_color.cp[0] = in_color.cp[3]; // red
 
217
        out_color.cp[1] = in_color.cp[2]; // green
 
218
        out_color.cp[2] = in_color.cp[1]; // blue
 
219
        out_color.cp[3] = in_color.cp[0]; // alpha
220
220
        
221
 
        return out_colour.integer;
 
221
        return out_color.integer;
222
222
}
223
223
 
224
224
static void SetDefaultFaceType(Scene* scene)
247
247
        unsigned int &c2, 
248
248
        unsigned int &c3)
249
249
{
250
 
        unsigned int colour = 0xFFFFFFFFL;
 
250
        unsigned int color = 0xFFFFFFFFL;
251
251
        switch(type)
252
252
        {
253
253
                case 0: // vertex colors
260
260
                                        c3 = KX_Mcol2uint_new(mmcol[3]);
261
261
                        }else // backup white
262
262
                        {
263
 
                                c0 = KX_rgbaint2uint_new(colour);
264
 
                                c1 = KX_rgbaint2uint_new(colour);
265
 
                                c2 = KX_rgbaint2uint_new(colour);       
 
263
                                c0 = KX_rgbaint2uint_new(color);
 
264
                                c1 = KX_rgbaint2uint_new(color);
 
265
                                c2 = KX_rgbaint2uint_new(color);        
266
266
                                if (mface->v4)
267
 
                                        c3 = KX_rgbaint2uint_new( colour );
 
267
                                        c3 = KX_rgbaint2uint_new( color );
268
268
                        }
269
269
                } break;
270
270
                
280
280
                                col_converter.cp[2] = (unsigned char) (mat->g*255.0);
281
281
                                col_converter.cp[1] = (unsigned char) (mat->b*255.0);
282
282
                                col_converter.cp[0] = (unsigned char) (mat->alpha*255.0);
283
 
                                colour = col_converter.integer;
 
283
                                color = col_converter.integer;
284
284
                        }
285
 
                        c0 = KX_rgbaint2uint_new(colour);
286
 
                        c1 = KX_rgbaint2uint_new(colour);
287
 
                        c2 = KX_rgbaint2uint_new(colour);       
 
285
                        c0 = KX_rgbaint2uint_new(color);
 
286
                        c1 = KX_rgbaint2uint_new(color);
 
287
                        c2 = KX_rgbaint2uint_new(color);        
288
288
                        if (mface->v4)
289
 
                                c3 = KX_rgbaint2uint_new(colour);
 
289
                                c3 = KX_rgbaint2uint_new(color);
290
290
                } break;
291
291
                
292
292
                default: // white
293
293
                {
294
 
                        c0 = KX_rgbaint2uint_new(colour);
295
 
                        c1 = KX_rgbaint2uint_new(colour);
296
 
                        c2 = KX_rgbaint2uint_new(colour);       
 
294
                        c0 = KX_rgbaint2uint_new(color);
 
295
                        c1 = KX_rgbaint2uint_new(color);
 
296
                        c2 = KX_rgbaint2uint_new(color);        
297
297
                        if (mface->v4)
298
 
                                c3 = KX_rgbaint2uint_new(colour);
 
298
                                c3 = KX_rgbaint2uint_new(color);
299
299
                } break;
300
300
        }
301
301
}
592
592
        if( validface ) {
593
593
 
594
594
                material->ras_mode |= !( 
595
 
                        (tface->flag & TF_HIDE) ||
 
595
                        (mface->flag & ME_HIDE) ||
596
596
                        (tface->mode & TF_INVISIBLE)
597
597
                        )?POLY_VIS:0;
598
598
 
954
954
                                                tile = tface->tile;
955
955
                                                mode = tface->mode;
956
956
                                                
957
 
                                                polyvisible = !((tface->flag & TF_HIDE)||(tface->mode & TF_INVISIBLE));
 
957
                                                polyvisible = !((mface->flag & ME_HIDE)||(tface->mode & TF_INVISIBLE));
958
958
                                                
959
959
                                                uv0 = MT_Point2(tface->uv[0]);
960
960
                                                uv1 = MT_Point2(tface->uv[1]);
974
974
 
975
975
                                        if (mmcol)
976
976
                                        {
977
 
                                                // Use vertex colours
 
977
                                                // Use vertex colors
978
978
                                                rgb0 = KX_Mcol2uint_new(mmcol[0]);
979
979
                                                rgb1 = KX_Mcol2uint_new(mmcol[1]);
980
980
                                                rgb2 = KX_Mcol2uint_new(mmcol[2]);
985
985
                                        else {
986
986
                                                // no vertex colors: take from material if we have one,
987
987
                                                // otherwise set to white
988
 
                                                unsigned int colour = 0xFFFFFFFFL;
 
988
                                                unsigned int color = 0xFFFFFFFFL;
989
989
 
990
990
                                                if (ma)
991
991
                                                {
1000
1000
                                                        col_converter.cp[1] = (unsigned char) (ma->b*255.0);
1001
1001
                                                        col_converter.cp[0] = (unsigned char) (ma->alpha*255.0);
1002
1002
                                                        
1003
 
                                                        colour = col_converter.integer;
 
1003
                                                        color = col_converter.integer;
1004
1004
                                                }
1005
1005
        
1006
 
                                                rgb0 = KX_rgbaint2uint_new(colour);
1007
 
                                                rgb1 = KX_rgbaint2uint_new(colour);
1008
 
                                                rgb2 = KX_rgbaint2uint_new(colour);     
 
1006
                                                rgb0 = KX_rgbaint2uint_new(color);
 
1007
                                                rgb1 = KX_rgbaint2uint_new(color);
 
1008
                                                rgb2 = KX_rgbaint2uint_new(color);      
1009
1009
                                                
1010
1010
                                                if (mface->v4)
1011
 
                                                        rgb3 = KX_rgbaint2uint_new(colour);
 
1011
                                                        rgb3 = KX_rgbaint2uint_new(color);
1012
1012
                                        }
1013
1013
                                        
1014
1014
                                        bool istriangle = (mface->v4==0);
1304
1304
        
1305
1305
}
1306
1306
 
1307
 
static void my_get_local_bounds(Object *ob, float *centre, float *size)
 
1307
static void my_get_local_bounds(Object *ob, float *center, float *size)
1308
1308
{
1309
1309
        BoundBox *bb= NULL;
1310
1310
        /* uses boundbox, function used by Ketsji */
1321
1321
                case OB_CURVE:
1322
1322
                case OB_SURF:
1323
1323
                case OB_FONT:
1324
 
                        centre[0]= centre[1]= centre[2]= 0.0;
 
1324
                        center[0]= center[1]= center[2]= 0.0;
1325
1325
                        size[0]  = size[1]=size[2]=0.0;
1326
1326
                        break;
1327
1327
                case OB_MBALL:
1331
1331
        
1332
1332
        if(bb==NULL) 
1333
1333
        {
1334
 
                centre[0]= centre[1]= centre[2]= 0.0;
 
1334
                center[0]= center[1]= center[2]= 0.0;
1335
1335
                size[0] = size[1]=size[2]=1.0;
1336
1336
        }
1337
1337
        else 
1340
1340
                size[1]= 0.5*fabs(bb->vec[0][1] - bb->vec[2][1]);
1341
1341
                size[2]= 0.5*fabs(bb->vec[0][2] - bb->vec[1][2]);
1342
1342
                                        
1343
 
                centre[0]= 0.5*(bb->vec[0][0] + bb->vec[4][0]);
1344
 
                centre[1]= 0.5*(bb->vec[0][1] + bb->vec[2][1]);
1345
 
                centre[2]= 0.5*(bb->vec[0][2] + bb->vec[1][2]);
 
1343
                center[0]= 0.5*(bb->vec[0][0] + bb->vec[4][0]);
 
1344
                center[1]= 0.5*(bb->vec[0][1] + bb->vec[2][1]);
 
1345
                center[2]= 0.5*(bb->vec[0][2] + bb->vec[1][2]);
1346
1346
        }
1347
1347
}
1348
1348
        
1609
1609
        {
1610
1610
                Mesh* mesh = static_cast<Mesh*>(ob->data);
1611
1611
                RAS_MeshObject* meshobj = converter->FindGameMesh(mesh, ob->lay);
1612
 
                float centre[3], extents[3];
1613
 
                float radius = my_boundbox_mesh((Mesh*) ob->data, centre, extents);
 
1612
                float center[3], extents[3];
 
1613
                float radius = my_boundbox_mesh((Mesh*) ob->data, center, extents);
1614
1614
                
1615
1615
                if (!meshobj) {
1616
1616
                        meshobj = BL_ConvertMesh(mesh,ob,rendertools,kxscene,converter);
1641
1641
                        ((BL_DeformableGameObject*)gameobj)->m_pDeformer = dcont;
1642
1642
                }
1643
1643
                
1644
 
                MT_Point3 min = MT_Point3(centre) - MT_Vector3(extents);
1645
 
                MT_Point3 max = MT_Point3(centre) + MT_Vector3(extents);
 
1644
                MT_Point3 min = MT_Point3(center) - MT_Vector3(extents);
 
1645
                MT_Point3 max = MT_Point3(center) + MT_Vector3(extents);
1646
1646
                SG_BBox bbox = SG_BBox(min, max);
1647
1647
                gameobj->GetSGNode()->SetBBox(bbox);
1648
1648
                gameobj->GetSGNode()->SetRadius(radius);