shrikeframe.cpp

shrike is a utility application that acts as a testbed for shaders written in Sh

  if (!m_shader) return;
  showProgram(m_shader->vertex(), wxT("Vertex") );
}

void ShrikeFrame::showFsh(wxCommandEvent& event)
{
  if (!m_shader) return;
  showProgram(m_shader->fragment(), wxT("Fragment") );
}

void ShrikeFrame::showVshIr(wxCommandEvent& event)
{
  if (!m_shader) return;
  showIR(m_shader->vertex(), wxT("Vertex") );
}

void ShrikeFrame::showFshIr(wxCommandEvent& event)
{
  if (!m_shader) return;
  showIR(m_shader->fragment(), wxT("Fragment") );
}

void ShrikeFrame::showVshInterface(wxCommandEvent& event)
{
  if (!m_shader) return;
  showInterface(m_shader->vertex(), wxT("Vertex") );
}

void ShrikeFrame::showFshInterface(wxCommandEvent& event)
{
  if (!m_shader) return;
  showInterface(m_shader->fragment(), wxT("Fragment") );
}

void ShrikeFrame::reinit(wxCommandEvent& event)
{
  if (!m_shader) return;
  try {
    m_shader->init();
  } catch (const ShException& e) {
    std::cerr << e.message() << std::endl;
    return;
  }
  setShader(m_shader);
}

void ShrikeFrame::resetView(wxCommandEvent& event)
{
  m_canvas->resetView();
}

void ShrikeFrame::setBackground(wxCommandEvent& event)
{
  wxColourDialog dialog(this);

  if (dialog.ShowModal() != wxID_OK) return;

  wxColour c = dialog.GetColourData().GetColour();
  m_canvas->setBackground(c.Red(), c.Green(), c.Blue());
}

void ShrikeFrame::showProgram(ShProgram program,
                              const wxString& name)
{
  if (!program.node()) return;
  if (!program.node()->code()) return;

  wxString title = name + wxT(" Shader Code");
  wxFrame* frame = new wxFrame(0, -1, title.c_str());


  wxTextCtrl* control = new wxTextCtrl(frame, -1, wxT(""),
                                       wxDefaultPosition,
                                       wxDefaultSize,
                                       wxTE_MULTILINE | wxTE_READONLY);

#ifndef NO_TEXT_WINDOW_STREAM
  std::ostream stream(control);
  program.node()->code()->print(stream);
#else
  std::ostringstream s;
  program.node()->code()->print(s);
  control->AppendText(wxString(s.str().c_str(), *wxConvCurrent));
#endif

  frame->Show();
}

void ShrikeFrame::showInterface(ShProgram program,
                                const wxString& name)
{
  if (!program.node()) return;
  if (!program.node()->code()) return;

  wxString title = name + wxT(" Shader Interface");
  wxFrame* frame = new wxFrame(0, -1, title.c_str());

  wxTextCtrl* control = new wxTextCtrl(frame, -1, wxT(""),
                                       wxDefaultPosition,
                                       wxDefaultSize,
                                       wxTE_MULTILINE | wxTE_READONLY);
  
  control->AppendText(wxConvLibc.cMB2WX(program.describe_interface().c_str()));

  frame->Show();
}

void ShrikeFrame::showIR(ShProgram program,
                         const wxString& name)
{
  if (!program.node()) return;

  wxString title = name + wxT(" Shader Code");
  wxFrame* frame = new wxFrame(0, -1, title.c_str());


  wxTextCtrl* control = new wxTextCtrl(frame, -1, wxT(""),
                                       wxDefaultPosition,
                                       wxDefaultSize,
                                       wxTE_MULTILINE | wxTE_READONLY);

#ifndef NO_TEXT_WINDOW_STREAM
  std::ostream stream(control);
  program.node()->ctrlGraph->print(stream, 0);
#else
  std::ostringstream s;
  program.node()->ctrlGraph->print(s, 0);
  control->AppendText(wxString(s.str().c_str(), *wxConvCurrent));
#endif

  frame->Show();
}

void ShrikeFrame::fullscreen(wxCommandEvent& event)
{
  setFullscreen(event.IsChecked());
}

void ShrikeFrame::optimize(wxCommandEvent& event)
{
  if (event.IsChecked()) {
    ShContext::current()->optimization(2);
  } else {
    ShContext::current()->optimization(0);
  }
}

void ShrikeFrame::setopts(wxCommandEvent& event)
{
  // Didn't wxT() those because, well, it's not like we're printing or writing this, is it?
  std::string name;
  switch (event.GetId()) {
  case SHRIKE_MENU_SHADER_OPTS_LIFTING:
    name = "uniform lifting";
    break;
  case SHRIKE_MENU_SHADER_OPTS_PROPAGATION:
    name = "propagation";
    break;
  case SHRIKE_MENU_SHADER_OPTS_DEADCODE:
    name = "deadcode";
    break;
  case SHRIKE_MENU_SHADER_OPTS_SUBST:
    name = "forward substitution";
    break;
  case SHRIKE_MENU_SHADER_OPTS_COPY:
    name = "copy propagation";
    break;
  case SHRIKE_MENU_SHADER_OPTS_STRAIGHT:
    name = "straightening";
    break;
  default:
    return;
  }
  if (event.IsChecked()) {
    ShContext::current()->enable_optimization(name);
  } else {
    ShContext::current()->disable_optimization(name);
  }
}

void ShrikeFrame::wireframe(wxCommandEvent& event)
{
  m_canvas->SetCurrent();
  
  if (event.IsChecked()) {
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  } else {
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  }

  m_canvas->Refresh(FALSE);
}

void ShrikeFrame::setFullscreen(bool fs)
{
  ShowFullScreen(fs);
  if (fs) {
    m_hsplitter->Unsplit(m_shaderList);
  } else {
    if (!m_hsplitter->IsSplit()) {
      m_hsplitter->SplitVertically(m_shaderList, m_right_window,
                                   150);
      m_shaderList->Show();
    }
  }
  m_viewMenu->Check(SHRIKE_MENU_VIEW_FULLSCREEN, fs);
  m_fullscreen = fs;
}

void ShrikeFrame::fps(wxCommandEvent& event)
{
  setFps(event.IsChecked());
}

void ShrikeFrame::setFps(bool fps)
{
  m_fps = fps;
  ShrikeCanvas::instance()->setShowFps(m_fps);
}

void ShrikeFrame::keyDown(wxKeyEvent& event)
{
  if (event.GetKeyCode() == WXK_ESCAPE) {
    if (m_fullscreen) {
      setFullscreen(false);
    }
  } else {
    event.Skip();
  }
}

ShrikeFrame* ShrikeFrame::instance()
{
  return m_instance;
}

void ShrikeFrame::screenshot(wxCommandEvent& event)
{
  wxFileDialog* dialog = new wxFileDialog(this, wxT("Save Screenshot"),
                                          wxT("."), wxT(""),
                                          wxT("PNG Files (*.png)|*.png"), wxSAVE);
  if (dialog->ShowModal() == wxID_OK) {
    m_canvas->screenshot(dialog->GetPath().c_str());
  }
}

wxTreeCtrl* ShrikeFrame::initShaderList(wxWindow* parent)
{
#ifndef WIN32
  wxTreeCtrl* tree = new wxTreeCtrl(parent, SHRIKE_TREECTRL_SHADERS,
                                    wxDefaultPosition, wxDefaultSize,
                                    wxTR_HAS_BUTTONS | wxTR_HIDE_ROOT | wxTR_NO_LINES);
#else
  wxTreeCtrl* tree = new wxTreeCtrl(parent, SHRIKE_TREECTRL_SHADERS,
                                    wxDefaultPosition, wxDefaultSize,
                                    wxTR_HAS_BUTTONS | wxTR_HIDE_ROOT | wxTR_LINES_AT_ROOT);
#endif

  wxTreeItemId root = tree->AddRoot( wxT("") );

  std::map<std::string, wxTreeItemId> nodes;
  
  for (Shader::iterator I = Shader::begin(); I != Shader::end(); ++I) {
    Shader* shader = *I;
    std::list<std::string> nodelist;
    std::string name = shader->name();
    while (1) {
      std::string::size_type i = name.find(": ");
      if (i == std::string::npos) {
        nodelist.push_back(name);
        break;
      } else {
        nodelist.push_back(name.substr(0, i));
        name = name.substr(i + 2);
      }
    }

    wxTreeItemId last = root;
    std::string fullname;
    for (std::list<std::string>::iterator N = nodelist.begin();
         N != nodelist.end(); ++N) {
      std::list<std::string>::iterator M = N;
      ++M;
      std::string name = *N;
      if (!fullname.empty()) fullname += ":";
      fullname += name;
      ShaderTreeData* data = 0;
      if (M == nodelist.end()) data = new ShaderTreeData(shader);
      if (nodes.find(fullname) == nodes.end()) {
        nodes[fullname] = tree->AppendItem(last, wxConvLibc.cMB2WX(name.c_str()), -1, -1,
                                           data);
      } else {
        if (data && tree->GetItemData(nodes[fullname]) == 0) {
          tree->SetItemData(nodes[fullname], data);
        }
      }
      last = nodes[fullname];
    }
  }

  tree->SortChildren(root);
  return tree;
}

ShrikeFrame* ShrikeFrame::m_instance = 0;