← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
1
1
/**
2
 
 * $Id: RAS_OpenGLRasterizer.cpp,v 1.5 2004/04/11 02:50:02 kester Exp $
 
2
 * $Id: RAS_OpenGLRasterizer.cpp,v 1.16 2005/01/16 06:02:06 kester Exp $
3
3
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4
4
 *
5
5
 * This program is free software; you can redistribute it and/or
28
28
 *
29
29
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
30
30
 */
 
31
 
 
32
#include <math.h>
 
33
 
31
34
#include "RAS_OpenGLRasterizer.h"
32
35
 
33
36
#ifdef HAVE_CONFIG_H
39
42
#endif // WIN32
40
43
#ifdef __APPLE__
41
44
#include <OpenGL/gl.h>
 
45
#include <OpenGL/glu.h>
42
46
#else
43
47
#include <GL/gl.h>
 
48
#include <GL/glu.h>
44
49
#endif
45
50
 
46
51
#include "RAS_Rect.h"
48
53
#include "MT_CmMatrix4x4.h"
49
54
#include "RAS_IRenderTools.h" // rendering text
50
55
 
 
56
#include "RAS_GLExtensionManager.h"
 
57
 
 
58
/**
 
59
 *  32x32 bit masks for vinterlace stereo mode
 
60
 */
 
61
static GLuint left_eye_vinterlace_mask[32];
 
62
static GLuint right_eye_vinterlace_mask[32];
 
63
 
 
64
/**
 
65
 *  32x32 bit masks for hinterlace stereo mode.
 
66
 *  Left eye = &hinterlace_mask[0]
 
67
 *  Right eye = &hinterlace_mask[1]
 
68
 */
 
69
static GLuint hinterlace_mask[33];
51
70
 
52
71
RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas)
53
72
        :RAS_IRasterizer(canvas),
54
73
        m_2DCanvas(canvas),
55
74
        m_fogenabled(false),
 
75
        m_time(0.0),
 
76
        m_stereomode(RAS_STEREO_NOSTEREO),
 
77
        m_curreye(RAS_STEREO_LEFTEYE),
 
78
        m_eyeseparation(0.0),
 
79
        m_seteyesep(false),
 
80
        m_focallength(0.0),
 
81
        m_setfocallength(false),
56
82
        m_noOfScanlines(32),
57
83
        m_materialCachingInfo(0)
58
84
{
59
85
        m_viewmatrix.Identity();
60
 
        m_stereomode = RAS_STEREO_NOSTEREO;
 
86
        
 
87
        for (int i = 0; i < 32; i++)
 
88
        {
 
89
                left_eye_vinterlace_mask[i] = 0x55555555;
 
90
                right_eye_vinterlace_mask[i] = 0xAAAAAAAA;
 
91
                hinterlace_mask[i] = (i&1)*0xFFFFFFFF;
 
92
        }
 
93
        hinterlace_mask[32] = 0;
61
94
}
62
95
 
63
96
 
126
159
        }
127
160
        
128
161
        glPolygonStipple(patc);
 
162
        
 
163
        glFrontFace(GL_CCW);
 
164
        glCullFace(GL_BACK);
 
165
        glEnable(GL_CULL_FACE);
129
166
}
130
167
 
131
168
 
140
177
        m_blueback = 0.4375;
141
178
        m_alphaback = 0.0;
142
179
        
143
 
        // enable both vertexcolor AND lighting color
144
 
        glEnable(GL_COLOR_MATERIAL);
145
 
        
146
180
        glClearColor(m_redback,m_greenback,m_blueback,m_alphaback);
 
181
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
147
182
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
148
183
 
149
184
        glShadeModel(GL_SMOOTH);
241
276
 
242
277
 
243
278
 
244
 
void RAS_OpenGLRasterizer::SetMaterial(const RAS_IPolyMaterial& mat)
 
279
bool RAS_OpenGLRasterizer::SetMaterial(const RAS_IPolyMaterial& mat)
245
280
{
246
 
        if (mat.GetCachingInfo() != m_materialCachingInfo)
247
 
        {
248
 
                mat.Activate(this, m_materialCachingInfo);
249
 
        }
 
281
        return mat.Activate(this, m_materialCachingInfo);
250
282
}
251
283
 
252
284
 
257
289
        glEnable(GL_CULL_FACE);
258
290
        glEnable(GL_DEPTH_TEST);
259
291
        glClearDepth(1.0); 
 
292
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
260
293
        glClearColor(m_redback, m_greenback, m_blueback, m_alphaback);
261
294
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
262
295
        glDepthMask (GL_TRUE);
263
296
        glDepthFunc(GL_LEQUAL);
264
297
        glBlendFunc(GL_ONE, GL_ZERO);
265
 
 
 
298
        
 
299
        glDisable(GL_POLYGON_STIPPLE);
 
300
        
266
301
        glDisable(GL_LIGHTING);
 
302
        if (bgl::QueryExtension(bgl::_GL_EXT_separate_specular_color) || bgl::QueryVersion(1, 2))
 
303
                glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
267
304
        
268
305
        EndFrame();
269
306
}
270
307
 
271
 
 
 
308
bool RAS_OpenGLRasterizer::InterlacedStereo() const
 
309
{
 
310
        return m_stereomode == RAS_STEREO_VINTERLACE || m_stereomode == RAS_STEREO_INTERLACED;
 
311
}
272
312
 
273
313
bool RAS_OpenGLRasterizer::BeginFrame(int drawingmode, double time)
274
314
{
275
315
        m_time = time;
276
316
        m_drawingmode = drawingmode;
277
317
        
278
 
        m_2DCanvas->ClearColor(m_redback,m_greenback,m_blueback,m_alphaback);
279
 
        m_2DCanvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER);
 
318
        if (!InterlacedStereo() || m_curreye == RAS_STEREO_LEFTEYE)
 
319
        {
 
320
                m_2DCanvas->ClearColor(m_redback,m_greenback,m_blueback,m_alphaback);
 
321
                m_2DCanvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER);
 
322
        }
280
323
 
281
324
        // Blender camera routine destroys the settings
282
325
        if (m_drawingmode < KX_SOLID)
337
380
 
338
381
 
339
382
 
340
 
void RAS_OpenGLRasterizer::SetDepthMask(int depthmask)
 
383
void RAS_OpenGLRasterizer::SetDepthMask(DepthMask depthmask)
341
384
{
342
 
        switch (depthmask)
343
 
        {
344
 
        case KX_DEPTHMASK_ENABLED:
345
 
                {
346
 
                        glDepthMask(GL_TRUE);
347
 
                        //glDisable ( GL_ALPHA_TEST );
348
 
                        break;
349
 
                };
350
 
        case KX_DEPTHMASK_DISABLED:
351
 
                {
352
 
                        glDepthMask(GL_FALSE);
353
 
                        //glAlphaFunc ( GL_GREATER, 0.0 ) ;
354
 
                        //glEnable ( GL_ALPHA_TEST ) ;
355
 
                        break;
356
 
                };
357
 
        default:
358
 
                {
359
 
                //printf("someone made a mistake, RAS_OpenGLRasterizer::SetDepthMask(int depthmask)\n");
360
 
                exit(0);
361
 
                }
362
 
        }
 
385
        glDepthMask(depthmask == KX_DEPTHMASK_DISABLED ? GL_FALSE : GL_TRUE);
363
386
}
364
387
 
365
388
 
378
401
 
379
402
void RAS_OpenGLRasterizer::EndFrame()
380
403
{
 
404
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
381
405
        m_2DCanvas->EndFrame();
382
406
}       
383
407
 
384
 
 
385
408
void RAS_OpenGLRasterizer::SetRenderArea()
386
409
{
387
410
        // only above/below stereo method needs viewport adjustment
388
 
        if(m_stereomode == RAS_STEREO_ABOVEBELOW)
389
 
        {
390
 
                switch(m_curreye)
391
 
                {
392
 
                        case RAS_STEREO_LEFTEYE:
393
 
                                // upper half of window
394
 
                                m_2DCanvas->GetDisplayArea().SetLeft(0);
395
 
                                m_2DCanvas->GetDisplayArea().SetBottom(m_2DCanvas->GetHeight() -
396
 
                                        int(m_2DCanvas->GetHeight() - m_noOfScanlines) / 2);
397
 
 
398
 
                                m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
399
 
                                m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight()));
400
 
                                break;
401
 
                        case RAS_STEREO_RIGHTEYE:
402
 
                                // lower half of window
403
 
                                m_2DCanvas->GetDisplayArea().SetLeft(0);
404
 
                                m_2DCanvas->GetDisplayArea().SetBottom(0);
405
 
                                m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
406
 
                                m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight() - m_noOfScanlines) / 2);
407
 
                                break;
408
 
                }
409
 
        }
410
 
        else
411
 
        {
412
 
                // every available pixel
413
 
                m_2DCanvas->GetDisplayArea().SetLeft(0);
414
 
                m_2DCanvas->GetDisplayArea().SetBottom(0);
415
 
                m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
416
 
                m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight()));
 
411
        switch (m_stereomode)
 
412
        {
 
413
                case RAS_STEREO_ABOVEBELOW:
 
414
                        switch(m_curreye)
 
415
                        {
 
416
                                case RAS_STEREO_LEFTEYE:
 
417
                                        // upper half of window
 
418
                                        m_2DCanvas->GetDisplayArea().SetLeft(0);
 
419
                                        m_2DCanvas->GetDisplayArea().SetBottom(m_2DCanvas->GetHeight() -
 
420
                                                int(m_2DCanvas->GetHeight() - m_noOfScanlines) / 2);
 
421
        
 
422
                                        m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
 
423
                                        m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight()));
 
424
                                        break;
 
425
                                case RAS_STEREO_RIGHTEYE:
 
426
                                        // lower half of window
 
427
                                        m_2DCanvas->GetDisplayArea().SetLeft(0);
 
428
                                        m_2DCanvas->GetDisplayArea().SetBottom(0);
 
429
                                        m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
 
430
                                        m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight() - m_noOfScanlines) / 2);
 
431
                                        break;
 
432
                        }
 
433
                        break;
 
434
                case RAS_STEREO_SIDEBYSIDE:
 
435
                        switch (m_curreye)
 
436
                        {
 
437
                                case RAS_STEREO_LEFTEYE:
 
438
                                        // Left half of window
 
439
                                        m_2DCanvas->GetDisplayArea().SetLeft(0);
 
440
                                        m_2DCanvas->GetDisplayArea().SetBottom(0);
 
441
                                        m_2DCanvas->GetDisplayArea().SetRight(m_2DCanvas->GetWidth()/2);
 
442
                                        m_2DCanvas->GetDisplayArea().SetTop(m_2DCanvas->GetHeight());
 
443
                                        break;
 
444
                                case RAS_STEREO_RIGHTEYE:
 
445
                                        // Right half of window
 
446
                                        m_2DCanvas->GetDisplayArea().SetLeft(m_2DCanvas->GetWidth()/2);
 
447
                                        m_2DCanvas->GetDisplayArea().SetBottom(0);
 
448
                                        m_2DCanvas->GetDisplayArea().SetRight(m_2DCanvas->GetWidth());
 
449
                                        m_2DCanvas->GetDisplayArea().SetTop(m_2DCanvas->GetHeight());
 
450
                                        break;
 
451
                        }
 
452
                        break;
 
453
                default:
 
454
                        // every available pixel
 
455
                        m_2DCanvas->GetDisplayArea().SetLeft(0);
 
456
                        m_2DCanvas->GetDisplayArea().SetBottom(0);
 
457
                        m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
 
458
                        m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight()));
 
459
                        break;
417
460
        }
418
461
}
419
462
 
420
463
        
421
 
void RAS_OpenGLRasterizer::SetStereoMode(const int stereomode)
 
464
void RAS_OpenGLRasterizer::SetStereoMode(const StereoMode stereomode)
422
465
{
423
466
        m_stereomode = stereomode;
424
467
}
434
477
}
435
478
 
436
479
 
437
 
void RAS_OpenGLRasterizer::SetEye(int eye)
 
480
void RAS_OpenGLRasterizer::SetEye(StereoEye eye)
438
481
{
439
482
        m_curreye = eye;
440
 
        if(m_stereomode == RAS_STEREO_QUADBUFFERED) {
441
 
                if(m_curreye == RAS_STEREO_LEFTEYE)
442
 
                        glDrawBuffer(GL_BACK_LEFT);
443
 
                else
444
 
                        glDrawBuffer(GL_BACK_RIGHT);
 
483
        switch (m_stereomode)
 
484
        {
 
485
                case RAS_STEREO_QUADBUFFERED:
 
486
                        glDrawBuffer(m_curreye == RAS_STEREO_LEFTEYE ? GL_BACK_LEFT : GL_BACK_RIGHT);
 
487
                        break;
 
488
                case RAS_STEREO_ANAGLYPH:
 
489
                        if (m_curreye == RAS_STEREO_LEFTEYE)
 
490
                        {
 
491
                                glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
 
492
                        } else {
 
493
                                //glAccum(GL_LOAD, 1.0);
 
494
                                glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
 
495
                                ClearDepthBuffer();
 
496
                        }
 
497
                        break;
 
498
                case RAS_STEREO_VINTERLACE:
 
499
                {
 
500
                        glEnable(GL_POLYGON_STIPPLE);
 
501
                        glPolygonStipple((const GLubyte*) ((m_curreye == RAS_STEREO_LEFTEYE) ? left_eye_vinterlace_mask : right_eye_vinterlace_mask));
 
502
                        if (m_curreye == RAS_STEREO_RIGHTEYE)
 
503
                                ClearDepthBuffer();
 
504
                        break;
 
505
                }
 
506
                case RAS_STEREO_INTERLACED:
 
507
                {
 
508
                        glEnable(GL_POLYGON_STIPPLE);
 
509
                        glPolygonStipple((const GLubyte*) &hinterlace_mask[m_curreye == RAS_STEREO_LEFTEYE?0:1]);
 
510
                        if (m_curreye == RAS_STEREO_RIGHTEYE)
 
511
                                ClearDepthBuffer();
 
512
                        break;
 
513
                }
 
514
                default:
 
515
                        break;
445
516
        }
446
517
}
447
518
 
 
519
RAS_IRasterizer::StereoEye RAS_OpenGLRasterizer::GetEye()
 
520
{
 
521
        return m_curreye;
 
522
}
 
523
 
448
524
 
449
525
void RAS_OpenGLRasterizer::SetEyeSeparation(float eyeseparation)
450
526
{
451
527
        m_eyeseparation = eyeseparation;
 
528
        m_seteyesep = true;
452
529
}
453
530
 
 
531
float RAS_OpenGLRasterizer::GetEyeSeparation()
 
532
{
 
533
        return m_eyeseparation;
 
534
}
454
535
 
455
536
void RAS_OpenGLRasterizer::SetFocalLength(float focallength)
456
537
{
457
538
        m_focallength = focallength;
 
539
        m_setfocallength = true;
 
540
}
 
541
 
 
542
float RAS_OpenGLRasterizer::GetFocalLength()
 
543
{
 
544
        return m_focallength;
458
545
}
459
546
 
460
547
 
529
616
 
530
617
                                                glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
531
618
 
532
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
533
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
534
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
535
 
                                                vindex++;
536
 
                                                
537
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
538
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
539
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
540
 
                                                vindex++;
541
 
                                                
542
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
543
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
544
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
545
 
                                                vindex++;
546
 
                                                
547
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
619
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
620
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
621
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
622
                                                vindex++;
 
623
                                                
 
624
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
625
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
626
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
627
                                                vindex++;
 
628
                                                
 
629
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
630
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
631
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
632
                                                vindex++;
 
633
                                                
 
634
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
548
635
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
549
636
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
550
637
                                                vindex++;
558
645
                                                // However it depends on the way the colors are packed into 
559
646
                                                // the m_rgba field of RAS_TexVert
560
647
 
561
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
562
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
563
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
564
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
565
 
                                                vindex++;
566
 
                                                
567
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
568
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
569
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
570
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
571
 
                                                vindex++;
572
 
                                                
573
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
574
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
575
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
576
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
577
 
                                                vindex++;
578
 
                                                
579
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
580
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
648
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
649
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
650
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
651
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
652
                                                vindex++;
 
653
                                                
 
654
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
655
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
656
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
657
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
658
                                                vindex++;
 
659
                                                
 
660
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
661
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
662
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
663
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
664
                                                vindex++;
 
665
                                                
 
666
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
667
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
581
668
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
582
669
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
583
670
                                                vindex++;
597
684
 
598
685
                                                glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
599
686
 
600
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
601
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
602
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
603
 
                                                vindex++;
604
 
                                                
605
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
606
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
607
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
608
 
                                                vindex++;
609
 
                                                
610
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
687
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
688
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
689
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
690
                                                vindex++;
 
691
                                                
 
692
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
693
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
694
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
695
                                                vindex++;
 
696
                                                
 
697
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
611
698
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
612
699
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
613
700
                                                vindex++;
618
705
                                        for (unsigned int i=0;i<numindices;i+=3)
619
706
                                        {
620
707
 
621
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
622
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
623
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
624
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
625
 
                                                vindex++;
626
 
                                                
627
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
628
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
629
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
630
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
631
 
                                                vindex++;
632
 
                                                
633
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
634
 
                                                glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
708
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
709
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
710
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
711
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
712
                                                vindex++;
 
713
                                                
 
714
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
715
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
716
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
717
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
718
                                                vindex++;
 
719
                                                
 
720
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
721
                                                glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
635
722
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
636
723
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
637
724
                                                vindex++;
686
773
                numindices = indexarray.size();
687
774
                
688
775
                if (!numindices)
689
 
                        break;
 
776
                        continue;
690
777
                
691
778
                int vindex=0;
692
779
                switch (mode)
733
820
                                                glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
734
821
 
735
822
                                                if (!recalc)
736
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
737
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
738
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
739
 
                                                vindex++;
740
 
                                                
741
 
                                                if (!recalc)
742
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
743
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
744
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
745
 
                                                vindex++;
746
 
                                                
747
 
                                                if (!recalc)
748
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());                                             
749
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
750
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
751
 
                                                vindex++;
752
 
                                                
753
 
                                                if (!recalc)
754
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
823
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
824
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
825
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
826
                                                vindex++;
 
827
                                                
 
828
                                                if (!recalc)
 
829
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
830
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
831
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
832
                                                vindex++;
 
833
                                                
 
834
                                                if (!recalc)
 
835
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());                                             
 
836
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
837
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
838
                                                vindex++;
 
839
                                                
 
840
                                                if (!recalc)
 
841
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
755
842
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
756
843
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
757
844
                                                vindex++;
777
864
                                                        mv1 = MT_Point3(vertexarray[(indexarray[vindex])].getLocalXYZ());
778
865
                                                        mv2 = MT_Point3(vertexarray[(indexarray[vindex+1])].getLocalXYZ());
779
866
                                                        mv3 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ());
780
 
                                                        mv4 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ());
 
867
                                                        mv4 = MT_Point3(vertexarray[(indexarray[vindex+3])].getLocalXYZ());
781
868
                                                        
782
869
                                                        fnor = (((mv2-mv1).cross(mv3-mv2))+((mv4-mv3).cross(mv1-mv4))).safe_normalized();
783
870
 
784
871
                                                        glNormal3f(fnor[0], fnor[1], fnor[2]);
785
872
                                                }
786
873
 
787
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
788
 
                                                if (!recalc)
789
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
790
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
791
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
792
 
                                                vindex++;
793
 
                                                
794
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
795
 
                                                if (!recalc)
796
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
797
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
798
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
799
 
                                                vindex++;
800
 
                                                
801
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
802
 
                                                if (!recalc)
803
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
804
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
805
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
806
 
                                                vindex++;
807
 
                                                
808
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
809
 
                                                if (!recalc)
810
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
874
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
875
                                                if (!recalc)
 
876
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
877
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
878
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
879
                                                vindex++;
 
880
                                                
 
881
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
882
                                                if (!recalc)
 
883
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
884
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
885
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
886
                                                vindex++;
 
887
                                                
 
888
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
889
                                                if (!recalc)
 
890
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
891
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
892
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
893
                                                vindex++;
 
894
                                                
 
895
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
896
                                                if (!recalc)
 
897
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
811
898
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
812
899
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
813
900
                                                vindex++;
844
931
                                                glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
845
932
 
846
933
                                                if (!recalc)
847
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
848
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
849
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
850
 
                                                vindex++;
851
 
                                                
852
 
                                                if (!recalc)
853
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
854
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
855
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
856
 
                                                vindex++;
857
 
                                                
858
 
                                                if (!recalc)
859
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
934
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
935
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
936
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
937
                                                vindex++;
 
938
                                                
 
939
                                                if (!recalc)
 
940
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
941
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
942
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
943
                                                vindex++;
 
944
                                                
 
945
                                                if (!recalc)
 
946
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
860
947
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
861
948
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
862
949
                                                vindex++;
884
971
                                                        glNormal3f(fnor[0], fnor[1], fnor[2]);
885
972
                                                }
886
973
 
887
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
888
 
                                                if (!recalc)
889
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
890
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
891
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
892
 
                                                vindex++;
893
 
                                                
894
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
895
 
                                                if (!recalc)
896
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
897
 
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
898
 
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
899
 
                                                vindex++;
900
 
                                                
901
 
                                                glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA()));
902
 
                                                if (!recalc)
903
 
                                                        glNormal3sv(vertexarray[(indexarray[vindex])].getNormal());
 
974
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
975
                                                if (!recalc)
 
976
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
977
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
978
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
979
                                                vindex++;
 
980
                                                
 
981
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
982
                                                if (!recalc)
 
983
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
 
984
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
 
985
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
 
986
                                                vindex++;
 
987
                                                
 
988
                                                glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
 
989
                                                if (!recalc)
 
990
                                                        glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
904
991
                                                glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
905
992
                                                glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
906
993
                                                vindex++;
991
1078
                                {
992
1079
                                        float v1[3],v2[3],v3[3],v4[3];
993
1080
                                        
994
 
                                        char *cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA());
995
1081
                                        v1[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
996
1082
                                        v1[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
997
1083
                                        v1[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
998
1084
                                        vindex++;
999
1085
                                        
1000
 
                                        cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA());
1001
1086
                                        v2[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
1002
1087
                                        v2[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
1003
1088
                                        v2[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
1004
1089
                                        vindex++;
1005
1090
                                        
1006
 
                                        cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA());
1007
1091
                                        v3[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
1008
1092
                                        v3[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
1009
1093
                                        v3[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
1010
1094
                                        vindex++;
1011
1095
                                        
1012
 
                                        cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA());
1013
1096
                                        v4[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
1014
1097
                                        v4[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
1015
1098
                                        v4[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
1067
1150
}
1068
1151
 
1069
1152
 
1070
 
void RAS_OpenGLRasterizer::SetProjectionMatrix(MT_Matrix4x4 & mat)
 
1153
void RAS_OpenGLRasterizer::SetProjectionMatrix(const MT_Matrix4x4 & mat)
1071
1154
{
1072
1155
        glMatrixMode(GL_PROJECTION);
1073
1156
        double matrix[16];
1084
1167
        float top,
1085
1168
        float frustnear,
1086
1169
        float frustfar,
1087
 
        bool perspective
 
1170
        bool
1088
1171
){
1089
1172
        MT_Matrix4x4 result;
1090
1173
        double mat[16];
1094
1177
        {
1095
1178
                        float near_div_focallength;
1096
1179
                        // next 2 params should be specified on command line and in Blender publisher
1097
 
                        m_focallength = 1.5 * right;  // derived from example
1098
 
                        m_eyeseparation = 0.18 * right;  // just a guess...
 
1180
                        if (!m_setfocallength)
 
1181
                                m_focallength = 1.5 * right;  // derived from example
 
1182
                        if (!m_seteyesep)
 
1183
                                m_eyeseparation = 0.18 * right;  // just a guess...
1099
1184
 
1100
1185
                        near_div_focallength = frustnear / m_focallength;
1101
1186
                        switch(m_curreye)
1125
1210
 
1126
1211
// next arguments probably contain redundant info, for later...
1127
1212
void RAS_OpenGLRasterizer::SetViewMatrix(const MT_Matrix4x4 &mat, const MT_Vector3& campos,
1128
 
                const MT_Point3 &camLoc, const MT_Quaternion &camOrientQuat)
 
1213
                const MT_Point3 &, const MT_Quaternion &camOrientQuat)
1129
1214
{
1130
1215
        MT_Matrix4x4 viewMat = mat;
1131
1216
 
1247
1332
        return m_time;
1248
1333
}
1249
1334
 
1250
 
 
 
1335
void RAS_OpenGLRasterizer::SetPolygonOffset(float mult, float add)
 
1336
{
 
1337
        glPolygonOffset(mult, add);
 
1338
        GLint mode = GL_POLYGON_OFFSET_FILL;
 
1339
        if (m_drawingmode < KX_SHADED)
 
1340
                mode = GL_POLYGON_OFFSET_LINE;
 
1341
        if (mult != 0.0f || add != 0.0f)
 
1342
                glEnable(mode);
 
1343
        else
 
1344
                glDisable(mode);
 
1345
}