HiShader

标签：style   blog   http   color   os   io   ar   for   2014   

• HiShader.material

• vertex_program MyVertexShader glsl
  {
      source HiShader.vsh
      default_params
      {
          param_named_auto MVP worldviewproj_matrix
      }
  }
              
  fragment_program MyFragmentShader glsl
  {
      source HiShader.fsh
      default_params
      {
          param_named_auto Resolution viewport_size
          param_named_auto Time time
      }
  }
  
  material MyMaterial
  {
      technique
      {
          pass
          {
              vertex_program_ref MyVertexShader
              {    
              }
              fragment_program_ref MyFragmentShader
              {
              }
          }
      }
  }

   

• HiShader.vsh

• uniform mat4 MVP;
  void main()
  {
      gl_Position = MVP * gl_Vertex;
  }

   

• HiShader.fsh

• // by @301z
  
  uniform float Time;
  uniform vec4      Resolution;           // viewport resolution (in pixels)
  
  float rand(vec2 n) { 
      return fract(sin(dot(n, vec2(12.9898, 4.1414))) * 43758.5453);
  }
  
  float noise(vec2 n) {
      const vec2 d = vec2(0.0, 1.0);
      vec2 b = floor(n), f = smoothstep(vec2(0.0), vec2(1.0), fract(n));
      return mix(mix(rand(b), rand(b + d.yx), f.x), mix(rand(b + d.xy), rand(b + d.yy), f.x), f.y);
  }
  
  float fbm(vec2 n) {
      float total = 0.0, amplitude = 1.0;
      for (int i = 0; i < 7; i++) {
          total += noise(n) * amplitude;
          n += n;
          amplitude *= 0.5;
      }
      return total;
  }
  
  void main() {
      const vec3 c1 = vec3(0.1, 0.0, 0.0);
      const vec3 c2 = vec3(0.7, 0.0, 0.0);
      const vec3 c3 = vec3(0.2, 0.0, 0.0);
      const vec3 c4 = vec3(1.0, 0.9, 0.0);
      const vec3 c5 = vec3(0.1);
      const vec3 c6 = vec3(0.9);
      vec2 p = gl_FragCoord.xy * 8.0 / Resolution.xx;
      float q = fbm(p - Time * 0.1);
      vec2 r = vec2(fbm(p + q + Time * 0.7 - p.x - p.y), fbm(p + q - Time * 0.4));
      vec3 c = mix(c1, c2, fbm(p + r)) + mix(c3, c4, r.x) - mix(c5, c6, r.y);
      gl_FragColor = vec4(c * cos(1.57 * gl_FragCoord.y / Resolution.y), 1.0);
  }

   

• Graphics.h

• /***************************************************
      ©2014 Pf_D. All rights reserved.
  ***************************************************/
  #pragma once
  #include "OGRE\Ogre.h"
  #include "OIS\OIS.h"
       
  enum CameraStyle
  {
      CS_FREELOOK,
      CS_ORBIT,
      CS_MANUAL
  };
       
  class cCameraManager
  {
  private:
      Ogre::Camera *mCamera;
      CameraStyle mStyle;
      Ogre::SceneNode *mTarget;
      bool mOrbiting;
      bool mZooming;
      Ogre::Real mTopSpeed;
      Ogre::Vector3 mVelocity;
      bool mGoingForward;
      bool mGoingBack;
      bool mGoingLeft;
      bool mGoingRight;
      bool mGoingUp;
      bool mGoingDown;
      bool mFastMove;
       
  public:
      cCameraManager(Ogre::Camera *cam);
       
      void setCamera(Ogre::Camera *cam);
      Ogre::Camera *getCamera();
       
      void manualStop();
       
      void setStyle(CameraStyle style);
      CameraStyle getStyle();
       
      void setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist);
       
      void setTarget(Ogre::SceneNode *target);
      Ogre::SceneNode *getTarget();
       
      void setTopSpeed(Ogre::Real topSpeed);
      Ogre::Real getTopSpeed();
       
      bool frameRenderingQueued(const Ogre::FrameEvent& evt);
       
      // Processes key press for free-look style movement.
      void injectKeyDown(const OIS::KeyEvent &evt);
      void injectKeyUp(const OIS::KeyEvent &evt);
       
      // Processes mouse movement differently for each style.
      void injectMouseMove(const OIS::MouseEvent &evt);
       
      // Processes mouse presses. Only applies for orbit style.
      // Left button is for orbiting, and right button is for zooming.
      void injectMouseDown(const OIS::MouseEvent &evt, OIS::MouseButtonID id);
      void injectMouseUp(const OIS::MouseEvent &evt, OIS::MouseButtonID id);
  };
  

   

• Graphics.cpp

• /***************************************************
      ©2014 Pf_D. All rights reserved.
  ***************************************************/
  #include "Graphics.h"
       
  cCameraManager::cCameraManager(Ogre::Camera *cam)
      :mCamera(0),
      mStyle(CameraStyle::CS_FREELOOK),
      mTarget(0),
      mOrbiting(false),
      mZooming(false),
      mTopSpeed(150),
      mVelocity(Ogre::Vector3::ZERO),
      mGoingForward(false),
      mGoingBack(false),
      mGoingLeft(false),
      mGoingRight(false),
      mGoingUp(false),
      mGoingDown(false),
      mFastMove(false)
  {
      setCamera(cam);
      setStyle(CS_FREELOOK);
  }
       
  void cCameraManager::setCamera(Ogre::Camera *cam)
  {
      mCamera = cam;
  }
       
  Ogre::Camera *cCameraManager::getCamera()
  {
      return mCamera;
  }
       
  void cCameraManager::setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist)
  {
      mCamera->setPosition(mTarget->_getDerivedPosition());
      mCamera->setOrientation(mTarget->_getDerivedOrientation());
      mCamera->yaw(yaw);
      mCamera->pitch(pitch);
      mCamera->moveRelative(Ogre::Vector3(0, 0, dist));
  }
       
  void cCameraManager::setTarget(Ogre::SceneNode *target)
  {
      if(target != mTarget)
      {
          mTarget = target;
          if(target)
          {
              setYawPitchDist(Ogre::Degree(0), Ogre::Degree(15), 150);
              mCamera->setAutoTracking(true, mTarget);
          }
          else
              mCamera->setAutoTracking(false);
      }
  }
           
  Ogre::SceneNode *cCameraManager::getTarget()
  {
      return mTarget;
  }
       
  void cCameraManager::manualStop()
  {
      if(mStyle == CS_FREELOOK)
      {
          mVelocity = Ogre::Vector3::ZERO;
          mGoingForward = false;
          mGoingBack = false;
          mGoingLeft = false;
          mGoingRight = false;
          mGoingUp = false;
          mGoingDown = false;
      }
  }
       
  void cCameraManager::setStyle(CameraStyle style)
  {
      if(mStyle != CS_ORBIT && style == CS_ORBIT)
      {
          setTarget(mTarget ? mTarget : mCamera->getSceneManager()->getRootSceneNode());
          mCamera->setFixedYawAxis(true);
          manualStop();
          setYawPitchDist(Ogre::Degree(0), Ogre::Degree(15), 150);
      }
      else if(mStyle != CS_FREELOOK && style == CS_FREELOOK)
      {
          mCamera->setAutoTracking(false);
          mCamera->setFixedYawAxis(true);
      }
      else if(mStyle != CS_MANUAL && style == CS_MANUAL)
      {
          mCamera->setAutoTracking(false);
          manualStop();
      }
      mStyle = style;
  }
       
  CameraStyle cCameraManager::getStyle()
  {
      return mStyle;
  }
       
  void cCameraManager::setTopSpeed(Ogre::Real topSpeed)
  {
      mTopSpeed = topSpeed;
  }
       
  Ogre::Real cCameraManager::getTopSpeed()
  {
      return mTopSpeed;
  }
       
  bool cCameraManager::frameRenderingQueued(const Ogre::FrameEvent& evt)
  {
      if (mStyle == CS_FREELOOK)
      {
          // build our acceleration vector based on keyboard input composite
          Ogre::Vector3 accel = Ogre::Vector3::ZERO;
          if (mGoingForward) accel += mCamera->getDirection();
          if (mGoingBack) accel -= mCamera->getDirection();
          if (mGoingRight) accel += mCamera->getRight();
          if (mGoingLeft) accel -= mCamera->getRight();
          if (mGoingUp) accel += mCamera->getUp();
          if (mGoingDown) accel -= mCamera->getUp();
       
          // if accelerating, try to reach top speed in a certain time
          Ogre::Real topSpeed = mFastMove ? mTopSpeed * 20 : mTopSpeed;
          if (accel.squaredLength() != 0)
          {
              accel.normalise();
              mVelocity += accel * topSpeed * evt.timeSinceLastFrame * 10;
          }
          // if not accelerating, try to stop in a certain time
          else mVelocity -= mVelocity * evt.timeSinceLastFrame * 10;
       
          Ogre::Real tooSmall = std::numeric_limits<Ogre::Real>::epsilon();
       
          // keep camera velocity below top speed and above epsilon
          if (mVelocity.squaredLength() > topSpeed * topSpeed)
          {
              mVelocity.normalise();
              mVelocity *= topSpeed;
          }
          else if (mVelocity.squaredLength() < tooSmall * tooSmall)
              mVelocity = Ogre::Vector3::ZERO;
       
          if (mVelocity != Ogre::Vector3::ZERO) mCamera->move(mVelocity * evt.timeSinceLastFrame);
      }
       
      return true;
  }
       
  void cCameraManager::injectKeyDown(const OIS::KeyEvent &evt)
  {
      if(mStyle != CS_FREELOOK)
          return;
      if (evt.key == OIS::KC_W || evt.key == OIS::KC_UP) mGoingForward = true;
      else if (evt.key == OIS::KC_S || evt.key == OIS::KC_DOWN) mGoingBack = true;
      else if (evt.key == OIS::KC_A || evt.key == OIS::KC_LEFT) mGoingLeft = true;
      else if (evt.key == OIS::KC_D || evt.key == OIS::KC_RIGHT) mGoingRight = true;
      else if (evt.key == OIS::KC_PGUP) mGoingUp = true;
      else if (evt.key == OIS::KC_PGDOWN) mGoingDown = true;
      else if (evt.key == OIS::KC_LSHIFT) mFastMove = true;
  }
       
  void cCameraManager::injectKeyUp(const OIS::KeyEvent &evt)
  {
      if(mStyle != CS_FREELOOK)
          return;
      if (evt.key == OIS::KC_W || evt.key == OIS::KC_UP) mGoingForward = false;
      else if (evt.key == OIS::KC_S || evt.key == OIS::KC_DOWN) mGoingBack = false;
      else if (evt.key == OIS::KC_A || evt.key == OIS::KC_LEFT) mGoingLeft = false;
      else if (evt.key == OIS::KC_D || evt.key == OIS::KC_RIGHT) mGoingRight = false;
      else if (evt.key == OIS::KC_PGUP) mGoingUp = false;
      else if (evt.key == OIS::KC_PGDOWN) mGoingDown = false;
      else if (evt.key == OIS::KC_LSHIFT) mFastMove = false;
  }
       
  void cCameraManager::injectMouseMove(const OIS::MouseEvent &evt)
  {
      if (mStyle == CS_ORBIT)
      {
          Ogre::Real dist = (mCamera->getPosition() - mTarget->_getDerivedPosition()).length();
       
          if (mOrbiting)   // yaw around the target, and pitch locally
          {
              mCamera->setPosition(mTarget->_getDerivedPosition());
       
              mCamera->yaw(Ogre::Degree(-evt.state.X.rel * 0.25f));
              mCamera->pitch(Ogre::Degree(-evt.state.Y.rel * 0.25f));
       
              mCamera->moveRelative(Ogre::Vector3(0, 0, dist));
       
              // don‘t let the camera go over the top or around the bottom of the target
          }
          else if (mZooming)  // move the camera toward or away from the target
          {
              // the further the camera is, the faster it moves
              mCamera->moveRelative(Ogre::Vector3(0, 0, evt.state.Y.rel * 0.004f * dist));
          }
          else if (evt.state.Z.rel != 0)  // move the camera toward or away from the target
          {
              // the further the camera is, the faster it moves
              mCamera->moveRelative(Ogre::Vector3(0, 0, -evt.state.Z.rel * 0.0008f * dist));
          }
      }
      else if (mStyle == CS_FREELOOK)
      {
          mCamera->yaw(Ogre::Degree(-evt.state.X.rel * 0.15f));
          mCamera->pitch(Ogre::Degree(-evt.state.Y.rel * 0.15f));
      }
  }
       
  void cCameraManager::injectMouseDown(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
  {
      if (mStyle == CS_ORBIT)
      {
          if (id == OIS::MB_Left) mOrbiting = true;
          else if (id == OIS::MB_Right) mZooming = true;
      }
  }
       
  void cCameraManager::injectMouseUp(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
  {
      if (mStyle == CS_ORBIT)
      {
          if (id == OIS::MB_Left) mOrbiting = false;
          else if (id == OIS::MB_Right) mZooming = false;
      }
  }
  

   

• System.h

• /***************************************************
      ©2014 Pf_D. All rights reserved.
  ***************************************************/
  #pragma once
  #include "Graphics.h"
  #include "OGRE\Ogre.h"
  #include "OIS\OIS.h"
  #include "MyGUI.h"
  #include "MyGUI_OgrePlatform.h"
     
  class cApplication : public Ogre::FrameListener, public OIS::KeyListener, public OIS::MouseListener
  {
  protected:
      MyGUI::Gui          *mGUI;
      MyGUI::OgrePlatform *mPlatform;
        
      Ogre::Root          *mRoot;
      Ogre::RenderWindow  *mWindow;
      Ogre::SceneManager  *mSceneMgr;
      Ogre::Camera        *mCamera;
     
      cCameraManager      *mCameraMgr;
      OIS::InputManager   *mInputMgr;
      OIS::Keyboard       *mKeyboard;
      OIS::Mouse          *mMouse;
      bool mDragLook;
    
  public:
      cApplication()
          :mDragLook(false)
      {
      }
   
      virtual bool frameStarted(const Ogre::FrameEvent &evt);
      virtual bool frameRenderingQueued(const Ogre::FrameEvent &evt);
      virtual bool frameEnded(const Ogre::FrameEvent &evt);
       
      virtual bool keyPressed(const OIS::KeyEvent &arg);
      virtual bool keyReleased(const OIS::KeyEvent &arg);
        
      virtual bool mouseMoved(const OIS::MouseEvent &arg);
      virtual bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
      virtual bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
     
      virtual void setupResources();
      virtual void createInput();
      virtual void chooseSceneMgr();
      virtual void setupView();
      virtual void loadResources();
      virtual void createScene() {}
       
      bool setup();
      void go();
     
      void setDragLook(bool enabled);
  };
  

   

• System.cpp

• /***************************************************
      ©2014 Pf_D. All rights reserved.
  ***************************************************/
  #include "System.h"
     
  bool cApplication::frameStarted(const Ogre::FrameEvent &evt)
  {
      mKeyboard->capture();
      mMouse->capture();
      return true;
  }
       
  bool cApplication::frameRenderingQueued(const Ogre::FrameEvent &evt)
  {
      mCameraMgr->frameRenderingQueued(evt);
      return true;
  }
       
  bool cApplication::frameEnded(const Ogre::FrameEvent &evt)
  {
      return true;
  }
      
  bool cApplication::keyPressed(const OIS::KeyEvent &arg)
  {
      if(arg.key == OIS::KC_ESCAPE)
          exit(0);
      MyGUI::InputManager::getInstance().injectKeyPress(
          MyGUI::KeyCode::Enum(arg.key), arg.text);
      mCameraMgr->injectKeyDown(arg);
      // ...
      return true;
  }
       
  bool cApplication::keyReleased(const OIS::KeyEvent &arg)
  {
      MyGUI::InputManager::getInstance().injectKeyRelease(MyGUI::KeyCode::Enum(arg.key));
      mCameraMgr->injectKeyUp(arg);
      // ...
      return true;
  }
       
  bool cApplication::mouseMoved( const OIS::MouseEvent &arg )
  {
      bool ret = MyGUI::InputManager::getInstance().injectMouseMove(
          arg.state.X.abs, arg.state.Y.abs, arg.state.Z.abs);
      if(!ret)
          mCameraMgr->injectMouseMove(arg);
      // ...
      return true;
  }
       
  bool cApplication::mousePressed( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
  {
      bool ret = MyGUI::InputManager::getInstance().injectMousePress(
          arg.state.X.abs, arg.state.Y.abs, MyGUI::MouseButton::Enum(id));
      if(!ret)
          mCameraMgr->injectMouseDown(arg, id);
      if(mDragLook && id == OIS::MB_Left) 
      {
          mCameraMgr->setStyle(CS_FREELOOK);
          MyGUI::Gui::getInstance().hidePointer();
      }
      // ...
      return true;
  }
       
  bool cApplication::mouseReleased( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
  {
      bool ret = MyGUI::InputManager::getInstance().injectMouseRelease(
          arg.state.X.abs, arg.state.Y.abs, MyGUI::MouseButton::Enum(id));
      if(!ret)
          mCameraMgr->injectMouseUp(arg, id);
      if(mDragLook && id == OIS::MB_Left) 
      {
          mCameraMgr->setStyle(CS_MANUAL);
          MyGUI::Gui::getInstance().showPointer();
      }
      // ...
      return true;
  }
      
  void cApplication::setupResources()
  {
      Ogre::ConfigFile cf;
  #if OGRE_DEBUG_MODE
      cf.load("resources_d.cfg");
  #else
      cf.load("resources.cfg");
  #endif
      Ogre::ConfigFile::SectionIterator secIter = cf.getSectionIterator();
      Ogre::String secName, typeName, archName;
      while(secIter.hasMoreElements())
      {
          secName = secIter.peekNextKey();
          Ogre::ConfigFile::SettingsMultiMap *settings = secIter.getNext();
          Ogre::ConfigFile::SettingsMultiMap::iterator i;
          for(i=settings->begin(); i!=settings->end(); i++)
          {
              typeName = i->first;
              archName = i->second;
              Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
                  archName, typeName, secName);
          }
      }
  }
      
  void cApplication::createInput()
  {
      OIS::ParamList parameters;
      unsigned int windowHandle = 0;
      std::ostringstream windowHandleString;
      mWindow->getCustomAttribute("WINDOW", &windowHandle);
      windowHandleString << windowHandle;
      parameters.insert(std::make_pair("WINDOW", windowHandleString.str()));
      parameters.insert(std::make_pair("w32_mouse", std::string("DISCL_FOREGROUND")));
      parameters.insert(std::make_pair("w32_mouse", std::string("DISCL_NONEXCLUSIVE")));
      mInputMgr = OIS::InputManager::createInputSystem(parameters);
      mKeyboard = static_cast<OIS::Keyboard*>(mInputMgr->createInputObject(OIS::OISKeyboard, true));
      mKeyboard->setEventCallback(this);
      mMouse = static_cast<OIS::Mouse*>(mInputMgr->createInputObject(OIS::OISMouse, true));
      const OIS::MouseState &mouseState = mMouse->getMouseState();
      mouseState.width = mWindow->getWidth();
      mouseState.height = mWindow->getHeight();
      mMouse->setEventCallback(this);
  }
     
  void cApplication::chooseSceneMgr()
  {
      mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);
  }
      
  void cApplication::setupView()
  {
      // Create camera
      mCamera = mSceneMgr->createCamera("Camera");
      mCamera->setPosition(Ogre::Vector3(0, 0, 50));
      mCamera->lookAt(Ogre::Vector3(0, 0, -300));
      mCamera->setNearClipDistance(5);
      mCameraMgr = new cCameraManager(mCamera);
      // Create viewports
      Ogre::Viewport *vp = mWindow->addViewport(mCamera);
      vp->setBackgroundColour(Ogre::ColourValue(0, 0, 0));
      mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth())/Ogre::Real(vp->getActualHeight()));
  }
      
  void cApplication::loadResources()
  {
      Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
  }
      
  bool cApplication::setup()
  {
  #ifndef OGRE_STATIC_LIB
  #if OGRE_DEBUG_MODE
      mRoot = OGRE_NEW Ogre::Root("plugins_d.cfg");
  #else
      mRoot = OGRE_NEW Ogre::Root("plugins.cfg");
  #endif
  #endif
      setupResources();
      if(!mRoot->showConfigDialog())
          return false;
      mWindow = mRoot->initialise(true);
      createInput();
      ShowCursor(false);
      chooseSceneMgr();
      setupView();
      loadResources();
      createScene();
      mRoot->addFrameListener(this);
      return true;
  }
       
  void cApplication::go()
  {
      if(!setup())
          return;
      mRoot->startRendering();
  }
     
  void cApplication::setDragLook(bool enabled)
  {
      if(enabled)
      {
          mCameraMgr->setStyle(CS_MANUAL);
          mDragLook = true;
      }
      else
      {
          mCameraMgr->setStyle(CS_FREELOOK);
          mDragLook = false;
      }
  }
  

   

• Main.cpp

• /***************************************************
      ©2014 Pf_D. All rights reserved.
  ***************************************************/
  #include "System.h"
      
  class cMyApplication : public cApplication
  {
  public:
      void createScene()
      {
          // MyGUI
          mPlatform = new MyGUI::OgrePlatform();
          mPlatform->initialise(mWindow, mSceneMgr);
          mGUI = new MyGUI::Gui();
          mGUI->initialise();
  		mCameraMgr->setStyle(CS_MANUAL);
  		mSceneMgr->setAmbientLight(Ogre::ColourValue::White);
  		Ogre::ManualObject *manual = mSceneMgr->createManualObject("Quad");
  		manual->begin("MyMaterial", Ogre::RenderOperation::OT_TRIANGLE_LIST);
  
  		manual->position(320, -240, 0.0);
  		manual->position(-320, 240, 0.0);
  		manual->position(-320, -240, 0.0);
  		manual->position(320, 240, 0.0);
  
  		manual->index(0);
  		manual->index(1);
  		manual->index(2);
  
  		manual->index(0);
  		manual->index(3);
  		manual->index(1);
  
  		manual->end();
  
  		manual->convertToMesh("Quad");
  		Ogre::Entity * ent = mSceneMgr->createEntity("Quad");
  		Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
  		node->attachObject(ent);
      }
  };
      
  int main()
  {
      cMyApplication App;
      App.go();
      return 0;
  }
  

   

HiShader

标签：style   blog   http   color   os   io   ar   for   2014   

原文地址：http://www.cnblogs.com/mynamepfd/p/3942272.html