liangchengyou / wow_english

  /****************************************************************************
   Copyright (C) 2013 Henry van Merode. All rights reserved.
   Copyright (c) 2015-2016 Chukong Technologies Inc.
   Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
   
   http://www.cocos2d-x.org
   
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
   in the Software without restriction, including without limitation the rights
   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   copies of the Software, and to permit persons to whom the Software is
   furnished to do so, subject to the following conditions:
   
   The above copyright notice and this permission notice shall be included in
   all copies or substantial portions of the Software.
   
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
   ****************************************************************************/
  
  #pragma once
  
  #include <vector>
  #include "renderer/CCRenderState.h"
  #include "renderer/CCMeshCommand.h"
  #include "renderer/CCCallbackCommand.h"
  #include "renderer/backend/Buffer.h"
  #include "base/CCRef.h"
  #include "math/CCMath.h"
  
  
  NS_CC_BEGIN
  
  class MeshCommand;
  class GLProgramState;
  class IndexBuffer;
  class VertexBuffer;
  class Texture2D;
  class ParticleSystem3D;
  class Renderer;
  
  class PUBillboardChain
  {
  
  public:
  
      /** Contains the data of an element of the BillboardChain.
      */
      class Element
      {
  
      public:
  
          Element();
  
          Element(const Vec3& position,
              float width,
              float texCoord,
              const Vec4& colour,
              const Quaternion& orientation);
  
          Vec3 position;
          float width;
          /// U or V texture coord depending on options
          float texCoord;
          Vec4 color;
  
          //Only used when mFaceCamera == false
          Quaternion orientation;
      };
      typedef std::vector<Element> ElementList;
  
      /** Constructor
      @param name The name to give this object
      @param maxElements The maximum number of elements per chain
      @param numberOfChains The number of separate chain segments contained in this object
      @param useTextureCoords If true, use texture coordinates from the chain elements
      @param useVertexColours If true, use vertex colours from the chain elements
      @param dynamic If true, buffers are created with the intention of being updated
      */
      PUBillboardChain(const std::string& name, const std::string& texFile = "", size_t maxElements = 20, size_t numberOfChains = 1,
          bool useTextureCoords = true, bool useColours = true, bool dynamic = true);
      /// destructor
      virtual ~PUBillboardChain();
  
      /** Set the maximum number of chain elements per chain 
      */
      virtual void setMaxChainElements(size_t maxElements);
      /** Get the maximum number of chain elements per chain 
      */
      virtual size_t getMaxChainElements() const { return _maxElementsPerChain; }
      /** Set the number of chain segments (this class can render multiple chains
          at once using the same material). 
      */
      virtual void setNumberOfChains(size_t numChains);
      /** Get the number of chain segments (this class can render multiple chains
      at once using the same material). 
      */
      virtual size_t getNumberOfChains() const { return _chainCount; }
  
      /** Sets whether texture coordinate information should be included in the
          final buffers generated.
      @note You must use either texture coordinates or vertex colour since the
          vertices have no normals and without one of these there is no source of
          colour for the vertices.
      */
      virtual void setUseTextureCoords(bool use);
      /** Gets whether texture coordinate information should be included in the
          final buffers generated.
      */
      virtual bool getUseTextureCoords() const { return _useTexCoords; }
  
      /** The direction in which texture coordinates from elements of the
          chain are used.
      */
      enum TexCoordDirection
      {
          /// Tex coord in elements is treated as the 'u' texture coordinate
          TCD_U,
          /// Tex coord in elements is treated as the 'v' texture coordinate
          TCD_V
      };
      /** Sets the direction in which texture coords specified on each element
          are deemed to run along the length of the chain.
      @param dir The direction, default is TCD_U.
      */
      virtual void setTextureCoordDirection(TexCoordDirection dir);
      /** Gets the direction in which texture coords specified on each element
          are deemed to run.
      */
      virtual TexCoordDirection getTextureCoordDirection() { return _texCoordDir; }
  
      /** Set the range of the texture coordinates generated across the width of
          the chain elements.
      @param start Start coordinate, default 0.0
      @param end End coordinate, default 1.0
      */
      virtual void setOtherTextureCoordRange(float start, float end);
      /** Get the range of the texture coordinates generated across the width of
          the chain elements.
      */
      virtual const float* getOtherTextureCoordRange() const { return _otherTexCoordRange; }
  
      /** Sets whether vertex colour information should be included in the
          final buffers generated.
      @note You must use either texture coordinates or vertex colour since the
          vertices have no normals and without one of these there is no source of
          colour for the vertices.
      */
      virtual void setUseVertexColours(bool use);
      /** Gets whether vertex colour information should be included in the
          final buffers generated.
      */
      virtual bool getUseVertexColours() const { return _useVertexColour; }
  
      /** Sets whether or not the buffers created for this object are suitable
          for dynamic alteration.
      */
      virtual void setDynamic(bool dyn);
  
      /** Gets whether or not the buffers created for this object are suitable
          for dynamic alteration.
      */
      virtual bool getDynamic() const { return _dynamic; }
          
      /** Add an element to the 'head' of a chain.
      @remarks
          If this causes the number of elements to exceed the maximum elements
          per chain, the last element in the chain (the 'tail') will be removed
          to allow the additional element to be added.
      @param chainIndex The index of the chain
      @param billboardChainElement The details to add
      */
      virtual void addChainElement(size_t chainIndex, 
          const Element& billboardChainElement);
      /** Remove an element from the 'tail' of a chain.
      @param chainIndex The index of the chain
      */
      virtual void removeChainElement(size_t chainIndex);
      /** Update the details of an existing chain element.
      @param chainIndex The index of the chain
      @param elementIndex The element index within the chain, measured from 
          the 'head' of the chain
      @param billboardChainElement The details to set
      */
      virtual void updateChainElement(size_t chainIndex, size_t elementIndex, 
          const Element& billboardChainElement);
      /** Get the detail of a chain element.
      @param chainIndex The index of the chain
      @param elementIndex The element index within the chain, measured from
          the 'head' of the chain
      */
      virtual const Element& getChainElement(size_t chainIndex, size_t elementIndex) const;
  
      /** Returns the number of chain elements. */
      virtual size_t getNumChainElements(size_t chainIndex) const;
  
      /** Remove all elements of a given chain (but leave the chain intact). */
      virtual void clearChain(size_t chainIndex);
      /** Remove all elements from all chains (but leave the chains themselves intact). */
      virtual void clearAllChains();
  
      /** Sets whether the billboard should always be facing the camera or a custom direction
          set by each point element.
      @remarks
          Billboards facing the camera are useful for smoke trails, light beams, etc by
          simulating a cylinder. However, because of this property, wide trails can cause
          several artefacts unless the head is properly covered.
          Therefore, non-camera-facing billboards are much more convenient for leaving big
          trails of movement from thin objects, for example a sword swing as seen in many
          fighting games.
      @param faceCamera True to be always facing the camera (Default value: True)
      @param normalVector Only used when faceCamera == false. Must be a non-zero vector.
      This vector is the "point of reference" for each point orientation. For example,
      if normalVector is Vector3::UNIT_Z, and the point's orientation is an identity
      matrix, the segment corresponding to that point will be facing towards UNIT_Z
      This vector is internally normalized.
      */
      void setFaceCamera( bool faceCamera, const Vec3& normalVector=Vec3::UNIT_X );
  
      void setDepthTest(bool isDepthTest);
      void setDepthWrite(bool isDepthWrite);
      void setBlendFunc(const BlendFunc& blendFunc);
  
      void render(Renderer* renderer, const Mat4& transform, ParticleSystem3D* particleSystem);
  
      // Overridden members follow
      //void _updateRenderQueue(RenderQueue*);
      //void getRenderOperation(RenderOperation&);
      //virtual bool preRender(SceneManager* sm, RenderSystem* rsys);
      //void getWorldTransforms(Matrix4*) const;
      /// @copydoc MovableObject::visitRenderables
  
  protected:
  
      /// Setup the STL collections
      virtual void setupChainContainers();
      /// Setup vertex declaration
      virtual void setupVertexDeclaration();
      // Setup buffers
      virtual void setupBuffers();
      /// Update the contents of the vertex buffer
      virtual void updateVertexBuffer(const Mat4& camMat);
      /// Update the contents of the index buffer
      virtual void updateIndexBuffer();
  
      void init(const std::string& texFile);
  
  private:
  
      void onBeforeDraw();
  
      void onAfterDraw();
  
  protected:
  
      /// Maximum length of each chain
      size_t _maxElementsPerChain;
      /// Number of chains
      size_t _chainCount;
      /// Use texture coords?
      bool _useTexCoords;
      /// Use vertex colour?
      bool _useVertexColour;
      /// Dynamic use?
      bool _dynamic;
      /// Is the vertex declaration dirty?
      bool _vertexDeclDirty;
      /// Do the buffers need recreating?
      bool _buffersNeedRecreating;
      /// Do the bounds need redefining?
      mutable bool _boundsDirty;
      /// Is the index buffer dirty?
      bool _indexContentDirty;
      /// Is the vertex buffer dirty?
      bool _vertexContentDirty;
      /// Texture coord direction
      TexCoordDirection _texCoordDir;
      /// Other texture coord range
      float _otherTexCoordRange[2];
      /// When true, the billboards always face the camera
      bool _faceCamera;
      /// Used when mFaceCamera == false; determines the billboard's "normal". i.e.
      /// when the orientation is identity, the billboard is perpendicular to this
      /// vector
      Vec3 _normalBase;
  
  
      /// The list holding the chain elements
      ElementList _chainElementList;
  
      /** Simple struct defining a chain segment by referencing a subset of
          the preallocated buffer (which will be mMaxElementsPerChain * mChainCount
          long), by it's chain index, and a head and tail value which describe
          the current chain. The buffer subset wraps at mMaxElementsPerChain
          so that head and tail can move freely. head and tail are inclusive,
          when the chain is empty head and tail are filled with high-values.
      */
      struct ChainSegment
      {
          /// The start of this chains subset of the buffer
          size_t start;
          /// The 'head' of the chain, relative to start
          size_t head;
          /// The 'tail' of the chain, relative to start
          size_t tail;
      };
      typedef std::vector<ChainSegment> ChainSegmentList;
      ChainSegmentList _chainSegmentList;
  
      /// Chain segment has no elements
      static const size_t SEGMENT_EMPTY;
  
  
      struct VertexInfo
      {
          Vec3 position;
          Vec2 uv;
          Vec4 color;
      };
      MeshCommand             _meshCommand;
      RenderState::StateBlock _stateBlock;
      Texture2D*              _texture        = nullptr;
      backend::ProgramState*  _programState   = nullptr;
      backend::Buffer*        _indexBuffer    = nullptr; //index buffer
      backend::Buffer*        _vertexBuffer   = nullptr; //vertex buffer
  
      std::vector<VertexInfo> _vertices;
      std::vector<uint16_t>   _indices;
  
      std::string             _texFile;
  
      backend::UniformLocation    _locColor;
      backend::UniformLocation    _locTexture;
      backend::UniformLocation    _locPMatrix;
  
      //renderer state cache variables
      bool                        _rendererDepthTestEnabled   = true;
      backend::CompareFunction    _rendererDepthCmpFunc       = backend::CompareFunction::LESS;
      backend::CullMode           _rendererCullMode           = backend::CullMode::BACK;
      backend::Winding            _rendererWinding            = backend::Winding::COUNTER_CLOCK_WISE;
      bool                        _rendererDepthWrite         = false;
  };
  
  NS_CC_END