- integrated Yacobys landscape. First commit.

git-svn-id: https://openmw.svn.sourceforge.net/svnroot/openmw/trunk@112 ea6a568a-9f4f-0410-981a-c910a81bb256

terrain/cpp_quadsegment.cpp

@@ -0,0 +1,145 @@
+/* Represents a segment of a quad. It can also represent a large segment
+ *
+ * this is needed for experimenting with splitting the lowest
+ * quad level into small segments for better culling.  Due to the
+ * intented design of using optomized meshes, this should not work on
+ * optomized meshes, as there is no easy way to segment the data
+ *
+ * This uses floating point numbers to define the areas of the
+ * quads. There may be issues due to accuracy if we go to small but it
+ * should be caught in debug mode
+ */
+#define QSDEBUG
+
+class QuadSegment
+{
+public:
+  /**
+   * @param qd the parent quad data
+   * @param size the proportion of the total size that the segment is. Must be greater than 0, but less than or equal to 1
+   * @param x,y the start positions of the segment
+   */
+  QuadSegment(QuadData* qd, float size = 1, float x = 0, float y = 0)
+    : mQuadData(qd),
+      mSegmentSize(size),
+      mX(x),
+      mY(y)
+  {
+    assert(qd);
+    assert(size>0&&size<=1);
+    assert(mY>=0&&mY<=1);
+    assert(mX>=0&&mY<=1);
+
+#ifdef QSDEBUG
+    {
+      //check sizes
+      const float qw = mQuadData->getVertexWidth()-1;
+      const float fsw = qw*size;
+      const int isw = (int)fsw;
+      assert(fsw==isw);
+    }
+#endif
+
+    //precalc offsets, as getVertex/getNormal get called a lot (1000s of times)
+    computeOffsets();
+  }
+
+  /**
+   * Gets how many vertexes wide this quad segment is. Should always be 2^n+1
+   * @return the vertex width of this quad segment
+   */
+  int getVertexWidth()
+  {
+    return (mQuadData->getVertexWidth()-1)*mSegmentSize+1;
+  }
+
+  /**
+   * @brief gets a vertex assuming that x = 0, y = 0 addresses the start of the quad
+   */
+  float getVertex(int x, int y)
+  {
+#ifdef QSDEBUG
+    {
+      const int vw = getVertexWidth();
+      assert(x<vw);
+    }
+#endif
+    return mQuadData->getVertex((mYOffset + y)*mQuadData->getVertexWidth()+(mXOffset+x));
+  }
+
+  float getNormal(int x, int y, int z)
+  {
+    assert(z>=0&&z<3);
+    return mQuadData->getNormal(((mYOffset + y)*mQuadData->getVertexWidth()+(mXOffset+x))*3+z);
+  }
+
+  /**
+   * @brief lazy function for getting a material
+   */
+  Ogre::MaterialPtr getMaterial()
+  {
+    if ( mMaterial.isNull() )
+      createMaterial();
+    assert(!mMaterial.isNull());
+    return mMaterial;
+  }
+
+  void createMaterial()
+  {
+    assert(mSegmentSize>0);
+    if ( mSegmentSize == 1 ) //we can use the top level material
+      mMaterial = mQuadData->getMaterial();
+    else //generate a material spesificly for this
+      mMaterial = mQuadData->getMaterialGenerator()->
+        getMaterialSegment(mQuadData,this);
+    assert(!mMaterial.isNull());
+  }
+
+  inline bool hasParentTexture() const{
+    return mQuadData->hasParentTexture();
+  }
+  inline const std::string& getParentTexture() const{
+    return mQuadData->getParentTexture();
+  }
+  inline int getVertexSeperation(){
+    return mQuadData->getVertexSeperation();
+  }
+
+  inline float getSegmentSize(){
+    return mSegmentSize;
+  }
+  inline float getStartX(){
+    return mX;
+  }
+  inline float getStartY(){
+    return mY;
+  }
+
+private:
+  int computeOffset(float x)
+  {
+#ifdef QSDEBUG
+    {
+      //check it is a valid position
+      const int start = (mQuadData->getVertexWidth()-1)*x;
+      const int vw = getVertexWidth()-1;
+      assert(vw>0);
+      assert((start%vw)==0);
+    }
+#endif
+    return float((mQuadData->getVertexWidth()-1))*x;
+  }
+
+  void computeOffsets()
+  {
+    mXOffset = computeOffset(mX);
+    mYOffset = computeOffset(mY);
+  }
+
+  QuadData* mQuadData;
+  float mSegmentSize;
+  float mX, mY;
+  Ogre::MaterialPtr mMaterial;
+
+  int mXOffset, mYOffset;
+};