Source/Stereo.cpp

   1
   2 #include "Game.h"
   3 #include "Stereo.h"
   4
   5
   6 extern int kContextWidth;
   7 extern int kContextHeight;
   8
   9 bool CanInitStereo(StereoMode mode) {
  10         GLint stencilbits = 0;
  11
  12         switch(mode) {
  13                 case stereoNone:
  14                         return true;
  15                         break;
  16                 case stereoAnaglyph:
  17                         return true;
  18                         break;
  19                 case stereoHorizontalInterlaced:
  20                 case stereoVerticalInterlaced:
  21                         glGetIntegerv(GL_STENCIL_BITS, &stencilbits);
  22                         if ( stencilbits < 1 ) {
  23                                 fprintf(stderr, "Failed to get a stencil buffer, interlaced stereo not available.\n");
  24                                 return false;
  25                         } else {
  26                                 fprintf(stderr, "Stencil buffer has %i bits, good.\n", stencilbits);
  27                         }
  28                         return true;
  29                         break;
  30                 default:
  31                         return false;
  32         }
  33
  34 }
  35
  36 void InitStereo(StereoMode mode) {
  37         switch(mode) {
  38                 case stereoNone:
  39                         glDisable( GL_STENCIL_TEST);
  40                         return;
  41                 case stereoAnaglyph:
  42                         glDisable( GL_STENCIL_TEST);
  43                         return;
  44                 case stereoHorizontalInterlaced:
  45                 case stereoVerticalInterlaced:
  46
  47                         fprintf(stderr, "Screen width is %i, height is %i\n", kContextWidth, kContextHeight);
  48
  49                         // Setup stencil buffer
  50                         glEnable( GL_STENCIL_TEST);
  51                         glClearStencil(0);
  52                         glClear(  GL_STENCIL_BUFFER_BIT );
  53                         glStencilFunc(GL_ALWAYS, 0x1, 0x1);
  54                         glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
  55
  56                         // Setup viewport
  57                         glViewport(0,0, kContextWidth, kContextHeight);
  58                         glMatrixMode(GL_PROJECTION);
  59                         glPushMatrix();
  60                                 glLoadIdentity();
  61                                 glOrtho((GLdouble)0, (GLdouble)kContextWidth, (GLdouble)kContextHeight, 0, -1, 1);
  62                                 glMatrixMode(GL_MODELVIEW);
  63                                 glPushMatrix();
  64                                         glLoadIdentity();
  65
  66                                         glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
  67
  68                                         if ( mode == stereoHorizontalInterlaced ) {
  69                                                 for(int y=0;y<kContextHeight;y+=2) {
  70                                                         glBegin(GL_LINES);
  71                                                                 glVertex3f(0, y, 0);
  72                                                                 glVertex3f(kContextWidth, y, 0);
  73                                                         glEnd();
  74                                                 }
  75                                         } else {
  76                                                 for(int x=0;x<kContextWidth;x+=2) {
  77                                                         glBegin(GL_LINES);
  78                                                                 glVertex3f(x, 0, 0);
  79                                                                 glVertex3f(x, kContextHeight, 0);
  80                                                         glEnd();
  81                                                 }
  82                                         }
  83
  84                                         glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
  85
  86                                 glPopMatrix();
  87                                 glMatrixMode(GL_PROJECTION);
  88                         glPopMatrix();
  89
  90                         glStencilFunc(GL_NOTEQUAL, 0x01, 0x01);
  91                         glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  92         }
  93
  94 }
  95
  96 const char* StereoModeName(StereoMode mode) {
  97         switch(mode) {
  98                 case stereoNone:                 return "None"; break;
  99                 case stereoAnaglyph:             return "Anaglyph"; break;
 100                 case stereoHorizontalInterlaced: return "Horizontal interlacing"; break;
 101                 case stereoVerticalInterlaced:   return "Vertical interlacing"; break;
 102                 case stereoHorizontalSplit:      return "Horizontal split"; break;
 103                 case stereoVerticalSplit:        return "Vertical split"; break;
 104                 case stereoOpenGL:               return "OpenGL"; break;
 105                 default:                         return "(error)"; break;
 106         }
 107 }