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                         glDisable( GL_DEPTH_TEST);
  51                         glDisable(GL_CULL_FACE);
  52                         glDisable(GL_LIGHTING);
  53                         glDisable(GL_TEXTURE_2D);
  54
  55                         glEnable( GL_STENCIL_TEST);
  56                         glClearStencil(0);
  57                         glClear(  GL_STENCIL_BUFFER_BIT );
  58                         glStencilFunc(GL_ALWAYS, 0x1, 0x1);
  59                         glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
  60
  61                         // Setup viewport
  62                         glViewport(0,0, kContextWidth, kContextHeight);
  63                         glMatrixMode(GL_PROJECTION);
  64                         glPushMatrix();
  65                                 glLoadIdentity();
  66                                 glOrtho((GLdouble)0, (GLdouble)kContextWidth, (GLdouble)kContextHeight, 0, -1, 1);
  67                                 glMatrixMode(GL_MODELVIEW);
  68                                 glPushMatrix();
  69                                         glLoadIdentity();
  70                                         glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
  71                                         glDisable(GL_LINE_SMOOTH);
  72
  73                                         // Add 0.5 to the coordinates, because OpenGL considers a pixel should be
  74                                         // turned on when a line passes through the center of it.
  75                                         if ( mode == stereoHorizontalInterlaced ) {
  76                                                 for(int y=0;y<kContextHeight;y+=2) {
  77                                                         glBegin(GL_LINES);
  78                                                                 glVertex3f(0.5, y+0.5, 0);
  79                                                                 glVertex3f(kContextWidth+0.5, y+0.5, 0);
  80                                                         glEnd();
  81                                                 }
  82                                         } else {
  83                                                 for(int x=0;x<kContextWidth;x+=2) {
  84                                                         glBegin(GL_LINES);
  85                                                                 glVertex3f(x+0.5, 0.5, 0);
  86                                                                 glVertex3f(x+0.5, kContextHeight+0.5, 0);
  87                                                         glEnd();
  88                                                 }
  89                                         }
  90
  91                                         glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
  92
  93                                 glPopMatrix();
  94                                 glMatrixMode(GL_PROJECTION);
  95                         glPopMatrix();
  96
  97                         glStencilFunc(GL_NOTEQUAL, 0x01, 0x01);
  98                         glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  99                         glEnable( GL_DEPTH_TEST);
 100                         glEnable(GL_CULL_FACE);
 101                         glEnable(GL_LIGHTING);
 102                         glEnable(GL_TEXTURE_2D);
 103
 104         }
 105
 106 }
 107
 108 const char* StereoModeName(StereoMode mode) {
 109         switch(mode) {
 110                 case stereoNone:                 return "None"; break;
 111                 case stereoAnaglyph:             return "Anaglyph"; break;
 112                 case stereoHorizontalInterlaced: return "Horizontal interlacing"; break;
 113                 case stereoVerticalInterlaced:   return "Vertical interlacing"; break;
 114                 case stereoHorizontalSplit:      return "Horizontal split"; break;
 115                 case stereoVerticalSplit:        return "Vertical split"; break;
 116                 case stereoOpenGL:               return "OpenGL"; break;
 117                 default:                         return "(error)"; break;
 118         }
 119 }