开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
GdiPlusMatrix.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：9k
源码类别：

模拟服务器

开发平台：

C/C++

GdiPlusMatrix.h：源码内容
  1. /**************************************************************************
  2. * 
  3. * Copyright (c) 1998-2001, Microsoft Corp.  All Rights Reserved.
  4. *
  5. * Module Name:
  6. *
  7. *   GdiplusMatrix.h
  8. *
  9. * Abstract:
  10. *
  11. *   GDI+ Matrix class
  12. *
  13. **************************************************************************/
  15. class Matrix : public GdiplusBase
  16. {
  17. public:
  18.     friend class Graphics;
  19.     friend class GraphicsPath;
  20.     friend class TextureBrush;
  21.     friend class LinearGradientBrush;
  22.     friend class PathGradientBrush;
  23.     friend class Pen;
  24.     friend class Region;
  25.     
  26.     // Default constructor is set to identity matrix.
  28.     Matrix()
  29.     {
  30.         GpMatrix *matrix = NULL;
  32.         lastResult = DllExports::GdipCreateMatrix(&matrix);
  33.     
  34.         SetNativeMatrix(matrix);
  35.     }
  37.     Matrix(IN REAL m11, 
  38.            IN REAL m12,
  39.            IN REAL m21, 
  40.            IN REAL m22,
  41.            IN REAL dx, 
  42.            IN REAL dy)
  43.     {
  44.         GpMatrix *matrix = NULL;
  46.         lastResult = DllExports::GdipCreateMatrix2(m11, m12, m21, m22, 
  47.                                                       dx, dy, &matrix);
  48.     
  49.         SetNativeMatrix(matrix);
  50.     }
  51.     
  52.     Matrix(IN const RectF& rect, 
  53.            IN const PointF* dstplg)
  54.     {
  55.         GpMatrix *matrix = NULL;
  57.         lastResult = DllExports::GdipCreateMatrix3(&rect, 
  58.                                                    dstplg,
  59.                                                    &matrix);
  61.         SetNativeMatrix(matrix);
  62.     }
  64.     Matrix(IN const Rect& rect, 
  65.            IN const Point* dstplg)
  66.     {
  67.         GpMatrix *matrix = NULL;
  69.         lastResult = DllExports::GdipCreateMatrix3I(&rect, 
  70.                                                     dstplg,
  71.                                                     &matrix);
  73.         SetNativeMatrix(matrix);
  74.     }
  76.     ~Matrix()
  77.     {
  78.         DllExports::GdipDeleteMatrix(nativeMatrix);
  79.     }
  81.     Matrix *Clone() const
  82.     {
  83.         GpMatrix *cloneMatrix = NULL;
  85.         SetStatus(DllExports::GdipCloneMatrix(nativeMatrix,
  86.                                                   &cloneMatrix));
  88.         if (lastResult != Ok)
  89.             return NULL;
  91.         return new Matrix(cloneMatrix);
  92.     }
  94.     Status GetElements(OUT REAL *m) const 
  95.     {
  96.         return SetStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
  97.     }
  98.     
  99.     Status SetElements(IN REAL m11, 
  100.                        IN REAL m12, 
  101.                        IN REAL m21, 
  102.                        IN REAL m22, 
  103.                        IN REAL dx, 
  104.                        IN REAL dy)
  105.     {
  106.         return SetStatus(DllExports::GdipSetMatrixElements(nativeMatrix,
  107.                             m11, m12, m21, m22, dx, dy));
  108.     }
  110.     REAL OffsetX() const
  111.     {
  112.         REAL elements[6];
  114.         if (GetElements(&elements[0]) == Ok)
  115.             return elements[4];
  116.         else 
  117.             return 0.0f;
  118.     }
  120.     REAL OffsetY() const
  121.     {
  122.        REAL elements[6];
  124.        if (GetElements(&elements[0]) == Ok)
  125.            return elements[5];
  126.        else 
  127.            return 0.0f;
  128.     }
  130.     Status Reset()
  131.     {
  132.         // set identity matrix elements 
  133.         return SetStatus(DllExports::GdipSetMatrixElements(nativeMatrix,
  134.                                              1.0, 0.0, 0.0, 1.0, 0.0, 0.0));
  135.     }
  137.     Status Multiply(IN const Matrix *matrix, 
  138.                     IN MatrixOrder order = MatrixOrderPrepend)
  139.     {
  140.         return SetStatus(DllExports::GdipMultiplyMatrix(nativeMatrix, 
  141.                                           matrix->nativeMatrix,
  142.                                           order));
  143.     }
  145.     Status Translate(IN REAL offsetX, 
  146.                      IN REAL offsetY, 
  147.                      IN MatrixOrder order = MatrixOrderPrepend)
  148.     {
  149.         return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, offsetX,
  150.                                                          offsetY, order));
  151.     }
  153.     Status Scale(IN REAL scaleX, 
  154.                  IN REAL scaleY, 
  155.                  IN MatrixOrder order = MatrixOrderPrepend)
  156.     {
  157.         return SetStatus(DllExports::GdipScaleMatrix(nativeMatrix, scaleX, 
  158.                                                      scaleY, order));
  159.     }
  161.     Status Rotate(IN REAL angle, 
  162.                   IN MatrixOrder order = MatrixOrderPrepend)
  163.     {
  164.         return SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, 
  165.                                                       order));
  166.     }
  167.     
  168.     Status RotateAt(IN REAL angle, 
  169.                     IN const PointF& center, 
  170.                     IN MatrixOrder order = MatrixOrderPrepend)
  171.     {
  172.         if(order == MatrixOrderPrepend)
  173.         {
  174.             SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, center.X,
  175.                                                       center.Y, order));
  176.             SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, 
  177.                                                    order));
  178.             return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix,
  179.                                                              -center.X, 
  180.                                                              -center.Y, 
  181.                                                              order));
  182.         }
  183.         else
  184.         {
  185.             SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, 
  186.                                                       - center.X, 
  187.                                                       - center.Y, 
  188.                                                       order));
  189.             SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, 
  190.                                                    order));
  191.             return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, 
  192.                                                              center.X, 
  193.                                                              center.Y, 
  194.                                                              order));
  195.         }
  196.     }
  198.     Status Shear(IN REAL shearX, 
  199.                  IN REAL shearY,
  200.                  IN MatrixOrder order = MatrixOrderPrepend)
  201.     {
  202.         return SetStatus(DllExports::GdipShearMatrix(nativeMatrix, shearX, 
  203.                                                      shearY, order));
  204.     }
  206.     Status Invert()
  207.     {
  208.         return SetStatus(DllExports::GdipInvertMatrix(nativeMatrix));
  209.     }
  211.     // float version
  212.     Status TransformPoints(IN OUT PointF* pts, 
  213.                            IN INT count = 1) const
  214.     {
  215.         return SetStatus(DllExports::GdipTransformMatrixPoints(nativeMatrix, 
  216.                                                                pts, count));
  217.     }
  218.     
  219.     Status TransformPoints(IN OUT Point* pts, 
  220.                            IN INT count = 1) const
  221.     {
  222.         return SetStatus(DllExports::GdipTransformMatrixPointsI(nativeMatrix, 
  223.                                                                 pts, 
  224.                                                                 count));
  225.     }
  227.     Status TransformVectors(IN OUT PointF* pts, 
  228.                             IN INT count = 1) const
  229.     { 
  230.         return SetStatus(DllExports::GdipVectorTransformMatrixPoints(
  231.                                         nativeMatrix, pts, count));
  232.     }
  234.     Status TransformVectors(IN OUT Point* pts, 
  235.                             IN INT count = 1) const
  236.     { 
  237.        return SetStatus(DllExports::GdipVectorTransformMatrixPointsI(
  238.                                         nativeMatrix, 
  239.                                         pts, 
  240.                                         count));
  241.     }
  242.     
  243.     BOOL IsInvertible() const
  244.     {
  245.         BOOL result = FALSE;
  247.         SetStatus(DllExports::GdipIsMatrixInvertible(nativeMatrix, &result));
  248.     
  249.         return result;
  250.     }
  252.     BOOL IsIdentity() const
  253.     {
  254.        BOOL result = FALSE;
  256.        SetStatus(DllExports::GdipIsMatrixIdentity(nativeMatrix, &result));
  257.     
  258.        return result;
  259.     }
  261.     BOOL Equals(IN const Matrix *matrix) const
  262.     {
  263.        BOOL result = FALSE;
  265.        SetStatus(DllExports::GdipIsMatrixEqual(nativeMatrix,
  266.                                                matrix->nativeMatrix, 
  267.                                                &result));
  268.    
  269.        return result;
  270.     }
  271.     
  272.     Status GetLastStatus() const
  273.     {
  274.         Status lastStatus = lastResult;
  275.         lastResult = Ok;
  276.  
  277.         return lastStatus;
  278.     }
  280. private:
  281.     Matrix(const Matrix &);
  282.     Matrix& operator=(const Matrix &);
  284. protected:
  285.     Matrix(GpMatrix *nativeMatrix)
  286.     {
  287.         lastResult = Ok;
  288.         SetNativeMatrix(nativeMatrix);
  289.     }
  290.     
  291.     VOID SetNativeMatrix(GpMatrix *nativeMatrix)
  292.     {
  293.         this->nativeMatrix = nativeMatrix;
  294.     }
  296.     Status SetStatus(Status status) const
  297.     {
  298.         if (status != Ok)
  299.             return (lastResult = status);
  300.         else
  301.             return status;
  302.     }
  304. protected:
  305.     GpMatrix *nativeMatrix;
  306.     mutable Status lastResult;
  307. };