MeshEntity.h

Go to the documentation of this file.

/*
 * Copyright 2012 Joel Baxter
 *
 * This file is part of MeshTex.
 *
 * MeshTex is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * MeshTex is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with MeshTex.  If not, see <http://www.gnu.org/licenses/>.
 */

#if !defined(INCLUDED_MESHENTITY_H)
#define INCLUDED_MESHENTITY_H

#include "AllocatedMatrix.h"

#include "scenelib.h"
#include "ipatch.h"
#include "generic/callback.h"

class MeshEntity
{
public: // public types

   enum TextureAxisSelection
   {
      S_TEX_AXIS_ONLY,  
      T_TEX_AXIS_ONLY,  
      ALL_TEX_AXES      
   };

   enum SliceType
   {
      ROW_SLICE_TYPE = 0,  
      COL_SLICE_TYPE = 1,  
      NUM_SLICE_TYPES = 2  
   };

   typedef Callback1<const char *, void> MessageCallback;

   typedef Callback2<float, float, void> TexInfoCallback;

   typedef struct {
      float oldValue;     
      float rowDistance;  
      float colDistance;  
      float rowNumber;    
      float colNumber;    
      float constant;     
   } GeneralFunctionFactors;

   typedef struct {
      bool maxSlice;  
      int index;      
   } SliceDesignation;

   typedef struct {
      SliceDesignation designation;  
      bool totalLengthOnly;          
   } RefSliceDescriptor;

   template<typename ObjectClass, void (ObjectClass::*member)(float, float)>
   class TexInfoCallbackMethod :
      public BindFirstOpaque2<Member2<ObjectClass, float, float, void, member> >
   {
   public:
      TexInfoCallbackMethod(ObjectClass& object) :
         BindFirstOpaque2<Member2<ObjectClass, float, float, void, member> >(object) {}
   };

public: // public methods


   MeshEntity(scene::Node& mesh,
              const MessageCallback& infoReportCallback,
              const MessageCallback& warningReportCallback,
              const MessageCallback& errorReportCallback);
   ~MeshEntity();


   bool IsValid() const;
   void GetInfo(const int *refRow,
                const int *refCol,
                const TexInfoCallback *rowTexInfoCallback,
                const TexInfoCallback *colTexInfoCallback);


   void MinAlign(TextureAxisSelection axes);
   void MaxAlign(TextureAxisSelection axes);
   void MinMaxAlignAutoScale(TextureAxisSelection axes);
   void MinMaxAlignStretch(TextureAxisSelection axes);
   void MinMaxAlignShrink(TextureAxisSelection axes);


   void SetScale(SliceType sliceType,
                 const SliceDesignation *alignSlice,
                 const RefSliceDescriptor *refSlice,
                 bool naturalScale,
                 float naturalScaleOrTiles);
   void GeneralFunction(const GeneralFunctionFactors *sFactors,
                        const GeneralFunctionFactors *tFactors,
                        const SliceDesignation *alignRow,
                        const SliceDesignation *alignCol,
                        const RefSliceDescriptor *refRow,
                        const RefSliceDescriptor *refCol,
                        bool surfaceValues);

private: // private methods


   MeshEntity(const MeshEntity&);
   const MeshEntity& operator=(const MeshEntity&);

private: // private types

   enum TextureAxis
   {
      S_TEX_AXIS = 0,   
      T_TEX_AXIS = 1,   
      NUM_TEX_AXES = 2  
   };

   enum PositionAxis
   {
      X_POS_AXIS = 0,   
      Y_POS_AXIS = 1,   
      Z_POS_AXIS = 2,   
      NUM_POS_AXES = 3  
   };

   enum ScaleOperation
   {
      STRETCH_SCALE_OP,  
      SHRINK_SCALE_OP    
   };

   typedef struct {
      SliceType sliceType; 
      float position;      
      int edgeSlice[NUM_SLICE_TYPES];  
   } SlicePatchContext;

   typedef struct {
      float scale;  
      float tiles;  
      float min;    
      float max;    
   } SliceTexInfo;

   typedef struct {
      unsigned index;        
      bool totalLengthOnly;  
   } RefSliceDescriptorInt;

   typedef bool(MeshEntity::*InternalImpl)(TextureAxis axis);

private: // private template methods

   template<typename Element>
   inline static Element& MatrixElement(Matrix<Element>& matrix,
                                        SliceType sliceType,
                                        int slice,
                                        int index) {
      return (sliceType == ROW_SLICE_TYPE ? matrix(slice, index) : 
                                            matrix(index, slice));
   }

private: // private methods


   void UpdatePosMinMax(PositionAxis axis);
   void UpdateTexMinMax(TextureAxis axis);


   void CreateUndoPoint();
   void CommitChanges();


   int InternalSliceDesignation(const SliceDesignation *sliceDesignation,
                                SliceType sliceType);
   RefSliceDescriptorInt *InternalRefSliceDescriptor(const RefSliceDescriptor *refSlice,
                                                     SliceType sliceType,
                                                     RefSliceDescriptorInt& refSliceInt);


   float GetSliceTexScale(SliceType sliceType,
                          int slice,
                          TextureAxis axis,
                          float tiles);
   bool GetSliceTexInfo(SliceType sliceType,
                        int slice,
                        TextureAxis axis,
                        SliceTexInfo& info);
   void ReportSliceTexInfo(SliceType sliceType,
                           int slice,
                           TextureAxis axis,
                           char *messageBuffer,
                           unsigned messageBufferSize,
                           const TexInfoCallback *texInfoCallback);


   void ProcessForAxes(InternalImpl internalImpl,
                       TextureAxisSelection axes);
   void Shift(TextureAxis axis,
              float shift);
   void Scale(TextureAxis axis,
              float scale);
   bool MinAlignInt(TextureAxis axis);
   bool MaxAlignInt(TextureAxis axis);
   bool MinMaxAlignAutoScaleInt(TextureAxis axis);
   bool MinMaxAlignScale(TextureAxis axis,
                         ScaleOperation op);
   bool MinMaxAlignStretchInt(TextureAxis axis);
   bool MinMaxAlignShrinkInt(TextureAxis axis);


   float SliceParametricSpeedComponent(PositionAxis axis,
                                       float t,
                                       const SlicePatchContext& context);
   float SliceParametricSpeed(float t,
                              const SlicePatchContext& context);
   float EstimateSegmentLength(float startPosition,
                               float endPosition,
                               const SlicePatchContext& context);
   float RefineSegmentLength(float startPosition,
                             float endPosition,
                             const SlicePatchContext &context,
                             float segmentLengthEstimate,
                             float maxError);


   void GenControlTexFromSurface(TextureAxis axis,
                                 const Matrix<float>& surfaceValues);
   void CopyControlTexFromValues(TextureAxis axis,
                                 const Matrix<float>& values);
   void GenSurfaceFromControlTex(TextureAxis axis,
                                 Matrix<float>& surfaceValues);
   void CopyValuesFromControlTex(TextureAxis axis,
                                 Matrix<float>& values);
   void GenScaledDistanceValues(SliceType sliceType,
                                int alignSlice,
                                const RefSliceDescriptorInt *refSlice,
                                bool rawScale,
                                float rawScaleOrTiles,
                                Matrix<float>& values);
   void GeneralFunctionInt(const GeneralFunctionFactors& factors,
                           TextureAxis axis,
                           int alignRow,
                           int alignCol,
                           bool surfaceValues,
                           const Matrix<float>& rowDistances,
                           const Matrix<float>& colDistances);

private: // private static member vars

   static TextureAxis _naturalAxis[NUM_SLICE_TYPES];
   static bool _radiantScaleInverted[NUM_SLICE_TYPES];
   static bool _radiantTilesInverted[NUM_SLICE_TYPES];
   static const char *_infoSliceFormatString[NUM_SLICE_TYPES];
   static const char *_infoSliceInfscaleFormatString[NUM_SLICE_TYPES];
   static const char *_warningSliceInfscaleFormatString[NUM_SLICE_TYPES];
   static const char *_errorBadSliceString[NUM_SLICE_TYPES];
   static const char *_errorSliceZeroscaleString[NUM_SLICE_TYPES];
   static const char *_errorSliceZerotilesString[NUM_SLICE_TYPES];

private: // private member vars

   scene::Node& _mesh;

   bool _valid;

   PatchControlMatrix _meshData;

   const MessageCallback _infoReportCallback;

   const MessageCallback _warningReportCallback;

   const MessageCallback _errorReportCallback;

   float _naturalTexUnits[NUM_TEX_AXES];

   unsigned _numSlices[NUM_SLICE_TYPES];

   bool _texMinMaxDirty[NUM_TEX_AXES];

   float _texMin[NUM_TEX_AXES];

   float _texMax[NUM_TEX_AXES];

   bool _texMinAligned[NUM_TEX_AXES];

   bool _texMaxAligned[NUM_TEX_AXES];

   float _posMin[NUM_POS_AXES];

   float _posMax[NUM_POS_AXES];
};

#endif // #if !defined(INCLUDED_MESHENTITY_H)