PShaderTxt.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     7-15-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------


// PShaderTxt.cpp

#include "PShaderTxt.h"

#include <qlayout.h>
#include <qmessagebox.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <stateGlift.h>

using namespace std;
using namespace glift;

PShaderTxt::PShaderTxt(const QGLContext *ctx, QWidget *parent, const char *name, WFlags wf)
: QWidget(parent, name, wf), 
  _stype(NOT_LOADED), 
  _shader(0),
  _fpshader(0),
  _vpshader(0),
  _ctx(ctx),
  _errw(0)
{
    QHBoxLayout *topLayout = new QHBoxLayout( this, 2 );

    _mle = new QMultiLineEdit( this, "shader text editor" );
    topLayout->addWidget(_mle);
    _mle->setWordWrap( QMultiLineEdit::WidgetWidth );
    _mle->setText("");
    _errw = new ErrTxtWin("",0,"a text error window");
    _errw->resize(512,768);
    _errw->setCaption("Programmable Shader Error");
}

PShaderTxt::~PShaderTxt()
{

}

//////////////////////////////////////////////////////////////////////////
/// load Shader
//////////////////////////////////////////////////////////////////////////
QString PShaderTxt::getFileName()
{
   if(_shader.isNull())
      return QString("No Shader");

   switch(_stype) {
   case ARB_FP:
      if(_fpshader->getProgFile())
         return QString(_fpshader->getProgFile());
      else
      break;
   case ARB_VP:
      if(_fpshader->getProgFile())
         return QString(_fpshader->getProgFile());
      break;
   }

   return QString("Not Saved");
}


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// Public slots
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
/// load Shader
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::loadShader()
{
   /// for capturing errors
   int errpos = -1;
   string fperr;
   ostringstream oss;
   ostream *ossave;
   
   ///make the gl context current for loading
   /// might be dangerous
   const_cast<QGLContext*>(_ctx)->makeCurrent();

   ///do the right thing for each type
   switch(_stype)
   {
   case ARB_FP:
      /// save off old error stream
      ossave = _fpshader->getErrStream();
      /// capture init errors
      _fpshader->setErrStream(&oss);
      /// load the changed shader
      _fpshader->reload(_mle->text().ascii());
      /// return the default error stream
      _fpshader->setErrStream(ossave);
      /// handle any errors
      fperr = oss.str();
      /// launch error, if there is one
      _errw->maybeError(fperr.c_str());
      /// be nice and mark where it happened
      if( (errpos = getErrorPos(fperr)) > -1 )
      {
         _errw->markSelection(errpos);
      }

      break;
   case ARB_VP:
      /// save off old error stream
      ossave = _vpshader->getErrStream();
      /// capture init errors
      _vpshader->setErrStream(&oss);
      _vpshader->reload(_mle->text().ascii());
      _vpshader->setErrStream(ossave);
      fperr = oss.str();
      /// launch error, if there is one
      _errw->maybeError(fperr.c_str());
      if( (errpos = getErrorPos(fperr)) > -1 )
      {
         _errw->markSelection(errpos);
      }

      break;

   }
}

//////////////////////////////////////////////////////////////////////////
/// load shader, from glift shader
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::loadShader(glift::ProgShaderSP shader)
{
   if((_stype != NOT_LOADED) || (!_shader.isNull()))
   {
      cerr << "PShaderTxt::loadShader(), Shader already loaded!!!" << endl;
      return;
   }

   if(shader.isNull())
   {
      cerr << "PShaderTxt::loadShader(), Shader is null!!!" << endl;
      return;   
   }

   _shader = shader;
   if(castShader())
   {      
      cerr << "PShaderTxt::loadShader(), Shader type not supported" << endl;
      return;
   }

   /// set the text for editing
   switch(_stype){
   case ARB_FP:
      _mle->setText(QString(_fpshader->getProgText()));
      break;
   case ARB_VP:
      _mle->setText(QString(_vpshader->getProgText()));
      break;
   }

   loadShader();
}


//////////////////////////////////////////////////////////////////////////
/// load Shader from file
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::loadShaderFromFile(const QString &fname)
{
   if((_stype != NOT_LOADED) || (!_shader.isNull()))
   {
      cerr << "PShaderTxt::loadShaderFromFile(), Shader already loaded!!!" << endl;
      return;
   }

   if(fname.isEmpty())
   {
      cerr << "PShaderTxt::loadShaderFromFile(), No file name given" << endl;
      return;
   }

   /// check the context to see if we can do anything
   if((!_ctx) || (!_ctx->isValid()))
   {
      cerr << "PShaderTxt::loadShaderFromFile(), Invalid gl context" << endl;
      return;
   }

   ///make the gl context current for loading
   const_cast<QGLContext*>(_ctx)->makeCurrent();

   /// capture error stream...
   ostringstream oss;
   /// generate shader using glift shader factory function
   _shader = glift::getProgShaderFromFile(fname, (ostream*)&oss);
   /// launch error if there is one
   _errw->launchError(oss.str().c_str());
   /// mark where it happened
   int errpos = -1;
   if( (errpos = getErrorPos(oss.str())) > -1 )
   {
      _errw->markSelection(errpos);
   }

   /// figure out what kind of shader it was
   if(castShader())
   {
      cerr << "PShaderTxt::loadShaderFromFile(), shader type not supported" << endl;   
   }

   /// set the text for editing
   switch(_stype){
   case ARB_FP:
      _mle->setText(QString(_fpshader->getProgText()));
      break;
   case ARB_VP:
      _mle->setText(QString(_vpshader->getProgText()));
      break;
   }
}

//////////////////////////////////////////////////////////////////////////
/// load Shader from text
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::loadShaderFromText(const QString &text)
{
   if((_stype != NOT_LOADED) || (!_shader.isNull()))
   {
      cerr << "PShaderTxt::loadShaderFromText(), Shader already loaded!!!" << endl;
      return;
   }
   
   if(text.isEmpty())
   {      
      cerr << "PShaderTxt::loadShaderFromText(), No Shader to load" << endl;
      return;
   }

   ///make the gl context current for loading
   const_cast<QGLContext*>(_ctx)->makeCurrent();

   /// capture error stream...
   ostringstream oss;
   /// generate shader using glift shader factory function
   _shader = glift::getProgShaderFromText(text, (ostream*)&oss);
   /// launch error if there is one
   _errw->launchError(oss.str().c_str());
   /// mark where it happened
   int errpos = -1;
   if( (errpos = getErrorPos(oss.str())) > -1 )
   {
      _errw->markSelection(errpos);
   }

   /// figure out what kind of shader it was
   if(castShader())
   {
      cerr << "PShaderTxt::loadShaderFromFile(), shader type not supported" << endl;   
   }

   /// setup the text editor
   _mle->setText(text);
}


//////////////////////////////////////////////////////////////////////////
/// save shader
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::saveShader(const QString &lastPath)
{
   QString s;
   ofstream of;
   
   if(_mle->isModified())
      loadShader();

   switch(_stype)
   {
   case ARB_FP:
      if(_fpshader.isNull())
      {
         cerr << "PShaderTxt::saveShader(), null fpshader" << endl;
         return;
      }
 
      /// nothing to save?
      if(!_fpshader->getProgText()) return;

      /// do we have a name?
      if(!_fpshader->getProgFile())
      {
         s = QFileDialog::getSaveFileName( lastPath, "Shaders (*.fp *.txt)");
         if(QString::null == s)
            return;
         _fpshader->setProgFile(s.ascii());
      }
      else /// use it's given name
      {
         s = _fpshader->getProgFile();
      }
      of.open(s.ascii(), ios::binary);
      if(of.bad())
      {
         _errw->launchError( "failed to open " + s + " for writing \n" );
         of.close();
         return;
      }

      of.write(_fpshader->getProgText(), strlen(_fpshader->getProgText()));
      
      if(of.bad())
      {
         _errw->launchError( "error writing " + s + "\n" );
         of.close();
         return;
      }

      of.close();
      _mle->setModified(false);
      return;

      break;
   case ARB_VP:
      if(_vpshader.isNull())
      {
         cerr << "PShaderTxt::saveShader(), null vpshader" << endl;
         return;
      }
      /// nothing to save?
      if(!_vpshader->getProgText()) return;

      /// do we have a name?
      if(!_vpshader->getProgFile())
      {
         s = QFileDialog::getSaveFileName( lastPath, "Shaders (*.vp *.txt)");
         if(QString::null == s)
            return;
         _vpshader->setProgFile(s.ascii());
      }
      else
      {
         s = _vpshader->getProgFile();
      }

      of.open(s.ascii(), ios::binary);
      if(of.bad())
      {
         _errw->launchError( "failed to open " + s + " for writing \n" );
         of.close();
         return;
      }

      of.write(_vpshader->getProgText(), strlen(_vpshader->getProgText()));
      
      if(of.bad())
      {
         _errw->launchError( "error writing " + s + "\n" );
         of.close();
         return;
      }

      of.close();
      _mle->setModified(false);
      return;
      break;
   }
}

//////////////////////////////////////////////////////////////////////////
/// save shader as
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::saveShaderAs(const QString &lastPath)
{
   QString s;
   ofstream of;

   s = QFileDialog::getSaveFileName( lastPath, "Shaders (*.fp *.vp *.txt)");
   if(QString::null == s)
      return;

   of.open(s.ascii(), ios::binary);
   if(of.bad())
   {
      _errw->launchError( "failed to open " + s + " for writing \n" );
      of.close();
      return;
   }

   if(_mle->isModified())
      loadShader();

   switch(_stype)
   {
   case ARB_FP:
      if(_fpshader.isNull()) return;
      _fpshader->setProgFile(s.ascii());
      of.write(_fpshader->getProgText(), strlen(_fpshader->getProgText()));
      break;
   case ARB_VP:
      if(_vpshader.isNull()) return;
      _vpshader->setProgFile(s.ascii());
      of.write(_vpshader->getProgText(), strlen(_vpshader->getProgText()));
      break;
   }

   if(of.bad())
   {
      _errw->launchError( "error writing " + s + "\n" );
   }

   of.close();

   _mle->setModified(false);
}

//////////////////////////////////////////////////////////////////////////
/// close shader
//////////////////////////////////////////////////////////////////////////
void PShaderTxt::closeShader(const QString &lastPath)
{
   if(_mle->isModified())
   {
      loadShader();

      if(!QMessageBox::information(this,"Save File?", 
         "This shader has not been saved, save now?",
         "Save","Cancel"))
      {
         saveShader(lastPath);
      }
   }
}

//////////////////////////////////////////////////////////////////////////
/// cast Shader
//////////////////////////////////////////////////////////////////////////
bool PShaderTxt::castShader()
{
   if(_shader.isNull())
   {
      cerr << "PShaderTxt::castShader(), Shader is null!!!" << endl;
      return true;   
   }

   /// fragment program ARB
   if(_fpshader = dynamic_cast<FragProgARB*>(_shader.getPtr()))
   {
      _stype = ARB_FP;
   }
   /// vertex program ARB
   else if(_vpshader = dynamic_cast<VertexProgARB*>(_shader.getPtr()))
   {
      _stype = ARB_VP;
   }
   /// catch all, don't know what to do??
   else
   {
      cerr << "PShaderTxt::castShader(), shader type unknown " << endl;
      return true;
   }

   return false;
}

//////////////////////////////////////////////////////////////////////////
/// get error position
//////////////////////////////////////////////////////////////////////////
const string ARB_ERR_CHAR("at character");

int PShaderTxt::getErrorPos(std::string s)
{
   if(s.empty()) return -1;

   /// arb style error position at a specific character
   if(s.find(ARB_ERR_CHAR) != -1)
   {
      string epos = s.substr(s.find(ARB_ERR_CHAR) + ARB_ERR_CHAR.size(), 8);
      istringstream iss(epos);
      int p;
      iss >> p;

      return s.find("!!ARB") + p;
   }

   return -1;
}

---

Send questions, comments, and bug reports to: