mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-04-07 13:55:33 +08:00
5269 lines
178 KiB
C++
5269 lines
178 KiB
C++
// Patterns.h : header file
|
||
|
||
#pragma once
|
||
|
||
// effects types
|
||
const int c_nEffectsSimple = 0;
|
||
const int c_nEffectsAdvanced = 1;
|
||
const int c_nEffectsAll = 2;
|
||
|
||
// additional constants
|
||
const int c_nPatternNone = 0;
|
||
const int c_nPatternSolid = 1;
|
||
const int c_nPatternDots = 2;
|
||
const int c_nPatternDotsDense = 3;
|
||
const int c_nPatternGrid = 4;
|
||
const int c_nPatternGridRotated = 5;
|
||
const int c_nPatternLineVertical = 6;
|
||
const int c_nPatternLineHorizontal = 7;
|
||
const int c_nPatternLineDiagonal = 8;
|
||
const int c_nPatternLineDiagonalRotated = 9;
|
||
const int c_nPatternChess = 10;
|
||
const int c_nPatternDashes = 11;
|
||
const int c_nPatternSpiner = 12;
|
||
const int c_nPatternThatches = 13;
|
||
const int c_nPatternHeart = 17;
|
||
const int c_nPatternCross = 18;
|
||
|
||
const int c_nPatternDots2 = 32;
|
||
const int c_nPatternDotsDense2 = 33;
|
||
const int c_nPatternGrid2 = 34;
|
||
const int c_nPatternGridRotated2 = 35;
|
||
const int c_nPatternLineVertical2 = 36;
|
||
const int c_nPatternLineHorizontal2 = 37;
|
||
const int c_nPatternLineDiagonal2 = 38;
|
||
const int c_nPatternLineDiagonalRotated2 = 39;
|
||
const int c_nPatternChess2 = 40;
|
||
const int c_nPatternDashes2 = 41;
|
||
const int c_nPatternSpiner2 = 42;
|
||
const int c_nPatternThatches2 = 43;
|
||
const int c_nPatternHeart2 = 47;
|
||
const int c_nPatternCross2 = 48;
|
||
|
||
const int c_nPatternDots3 = 62;
|
||
const int c_nPatternDotsDense3 = 63;
|
||
const int c_nPatternGrid3 = 64;
|
||
const int c_nPatternGridRotated3 = 65;
|
||
const int c_nPatternLineVertical3 = 66;
|
||
const int c_nPatternLineHorizontal3 = 67;
|
||
const int c_nPatternLineDiagonal3 = 68;
|
||
const int c_nPatternLineDiagonalRotated3 = 69;
|
||
const int c_nPatternChess3 = 70;
|
||
const int c_nPatternDashes3 = 71;
|
||
const int c_nPatternSpiner3 = 72;
|
||
const int c_nPatternThatches3 = 73;
|
||
const int c_nPatternHeart3 = 77;
|
||
const int c_nPatternCross3 = 78;
|
||
|
||
const int c_nFadeZoomIn = 14;
|
||
const int c_nFadeZoomOut = 15;
|
||
const int c_nFadeZoomBoth = 16;
|
||
|
||
const int c_nMosaicSpiralIn = 1;
|
||
const int c_nMosaicSpiralOut = 2;
|
||
const int c_nMosaicStrips = 3;
|
||
const int c_nMosaicDissolve = 4;
|
||
const int c_nMosaicClockwise = 5;
|
||
const int c_nMosaicCounterClockwise = 6;
|
||
const int c_nMosaicRandom = 7;
|
||
const int c_nMosaicLeftTopToRightBottom = 8;
|
||
const int c_nMosaicRightTopToLeftBottom = 9;
|
||
const int c_nMosaicRightBottomToLeftTop = 10;
|
||
const int c_nMosaicLeftBottomToRightTop = 11;
|
||
const int c_nMosaicWallLeftToRight = 12;
|
||
const int c_nMosaicWallRightToLeft = 13;
|
||
const int c_nMosaicWallTopToBottom = 14;
|
||
const int c_nMosaicWallBottomToTop = 15;
|
||
const int c_nMosaicChessLeftToRight = 16;
|
||
const int c_nMosaicChessRightToLeft = 17;
|
||
const int c_nMosaicChessTopToBottom = 18;
|
||
const int c_nMosaicChessBottomToTop = 19;
|
||
|
||
const int c_nRotateSingleIn = 1;
|
||
const int c_nRotateTwiceIn = 2;
|
||
const int c_nRotateSingleOut = 3;
|
||
const int c_nRotateTwiceOut = 4;
|
||
const int c_nRotateHalfIn = 5;
|
||
const int c_nRotateHalfOut = 6;
|
||
const int c_nRotateTransparentSingleIn = 7;
|
||
const int c_nRotateTransparentTwiceIn = 8;
|
||
const int c_nRotateTransparentSingleOut = 9;
|
||
const int c_nRotateTransparentTwiceOut = 10;
|
||
const int c_nRotateTransparentHalfIn = 11;
|
||
const int c_nRotateTransparentHalfOut = 12;
|
||
|
||
|
||
const int c_nDoorVerticalIn = 3; //1;
|
||
const int c_nDoorVerticalOut = 4; //2;
|
||
const int c_nDoorHorizontalIn = 1; //3;
|
||
const int c_nDoorHorizontalOut = 2; //4;
|
||
const int c_nDoorDiagonal = 5;
|
||
const int c_nDoorDiagonalRotated = 6;
|
||
|
||
const int c_nStripsVertical = 1;
|
||
const int c_nStripsHorizontal = 2;
|
||
|
||
const int c_nSideLeftToRight = 1;
|
||
const int c_nSideRightToLeft = 2;
|
||
const int c_nSideTopToBottom = 3;
|
||
const int c_nSideBottomToTop = 4;
|
||
const int c_nSideLeftTopToRightBottom = 5;
|
||
const int c_nSideLeftBottomToRightTop = 6;
|
||
const int c_nSideRightBottomToLeftTop = 7;
|
||
const int c_nSideRightTopToLeftBottom = 8;
|
||
|
||
const int c_nCenterBoxIn = 1;
|
||
const int c_nCenterBoxOut = 2;
|
||
const int c_nCenterDiamondIn = 3;
|
||
const int c_nCenterDiamondOut = 4;
|
||
const int c_nCenterCircleIn = 5;
|
||
const int c_nCenterCircleOut = 6;
|
||
const int c_nCenterCrossIn = 7;
|
||
const int c_nCenterCrossOut = 8;
|
||
|
||
const int c_nStretchLeftToRightIn = 1;
|
||
const int c_nStretchLeftToRightOut = 2;
|
||
const int c_nStretchRightToLeftIn = 3;
|
||
const int c_nStretchRightToLeftOut = 4;
|
||
const int c_nStretchBottomToTopIn = 5;
|
||
const int c_nStretchBottomToTopOut = 6;
|
||
const int c_nStretchTopToBottomIn = 7;
|
||
const int c_nStretchTopToBottomOut = 8;
|
||
|
||
//const int c_nCircleCornerLeftTop = 1;
|
||
//const int c_nCircleCornerLeftBottom = 2;
|
||
//const int c_nCircleCornerRightTop = 3;
|
||
//const int c_nCircleCornerRightBottom = 4;
|
||
const int c_nCircleCornerLeftTopClockwise = 5;
|
||
const int c_nCircleCornerLeftBottomClockwise = 6;
|
||
const int c_nCircleCornerRightTopClockwise = 7;
|
||
const int c_nCircleCornerRightBottomClockwise = 8;
|
||
|
||
const int c_nBottomToTopClockwise = 1;
|
||
const int c_nBottomToTopCounterClockwise = 2;
|
||
const int c_nBottomToTopOpposite = 3;
|
||
const int c_nTopToBottomClockwise = 4;
|
||
const int c_nTopToBottomCounterClockwise = 5;
|
||
const int c_nTopToBottomOpposite = 6;
|
||
const int c_nLeftToRightClockwise = 7;
|
||
const int c_nLeftToRightCounterClockwise = 8;
|
||
const int c_nLeftToRightOpposite = 9;
|
||
const int c_nRightToLeftClockwise = 10;
|
||
const int c_nRightToLeftCounterClockwise = 11;
|
||
const int c_nRightToLeftOpposite = 12;
|
||
const int c_n2AngleClockwise = 13;
|
||
const int c_n2AngleCounterClockwise = 14;
|
||
const int c_n3AngleClockwise = 15;
|
||
const int c_n3AngleCounterClockwise = 16;
|
||
const int c_n4AngleClockwise = 17;
|
||
const int c_n4AngleCounterClockwise = 18;
|
||
const int c_n6AngleClockwise = 19;
|
||
const int c_n6AngleCounterClockwise = 20;
|
||
const int c_n8AngleClockwise = 21;
|
||
const int c_n8AngleCounterClockwise = 22;
|
||
const int c_n12AngleClockwise = 23;
|
||
const int c_n12AngleCounterClockwise = 24;
|
||
|
||
const int c_nSwingLeftIn = 1;
|
||
const int c_nSwingLeftOut = 2;
|
||
const int c_nSwingRightIn = 3;
|
||
const int c_nSwingRightOut = 4;
|
||
const int c_nSwingBottomIn = 7; //5;
|
||
const int c_nSwingBottomOut = 8; //6;
|
||
const int c_nSwingTopIn = 5; //7;
|
||
const int c_nSwingTopOut = 6; //8;
|
||
|
||
const int c_nShatterHigh = 1;
|
||
const int c_nShatterLow = 2;
|
||
|
||
const int c_nFlipVerticalIn = 5; //1;
|
||
const int c_nFlipVerticalOut = 6; //2;
|
||
const int c_nFlipVerticalInBackward = 7; //3;
|
||
const int c_nFlipVerticalOutBackward = 8; //4;
|
||
const int c_nFlipHorizontalIn = 1; //5;
|
||
const int c_nFlipHorizontalOut = 2; //6;
|
||
const int c_nFlipHorizontalInBackward = 3; //7;
|
||
const int c_nFlipHorizontalOutBackward = 4; //8;
|
||
|
||
const int c_nTwirlClockwise = 1;
|
||
const int c_nTwirlClockwiseZoomOut = 2;
|
||
const int c_nTwirlClockwiseZoomIn = 3;
|
||
const int c_nTwirlCounterClockwise = 4;
|
||
const int c_nTwirlCounterClockwiseZoomOut = 5;
|
||
const int c_nTwirlCounterClockwiseZoomIn = 6;
|
||
const int c_nTwirlDrain = 7;
|
||
const int c_nTwirlReverseDrain = 8;
|
||
|
||
const int c_nSpiralTopLeft = 1;
|
||
const int c_nSpiralTopRight = 2;
|
||
const int c_nSpiralBottomLeft = 3;
|
||
const int c_nSpiralBottomRight = 4;
|
||
const int c_nSpiralCenterIn = 5;
|
||
const int c_nSpiralReverseCenterIn = 6;
|
||
const int c_nSpiralCenterOut = 7;
|
||
const int c_nSpiralReverseCenterOut = 8;
|
||
|
||
|
||
const int c_nTwirlStepCount = 5;
|
||
const double c_dTwirlStepBeginFrame[5] = {0.0,0.3,0.5,0.7,1.0};
|
||
|
||
const int c_nSphereIn = 1;
|
||
const int c_nSphereOut = 1;
|
||
|
||
const int c_nSphereStepCount = 5;
|
||
const double c_dSphereStepBeginFrame[5] = {0.0,0.3,0.5,0.7,1.0};
|
||
|
||
const int c_nTwistLeftToRight = 1;
|
||
const int c_nTwistRightToLeft = 2;
|
||
const int c_nTwistTopToBottom = 3;
|
||
const int c_nTwistBottomToTop = 4;
|
||
const int c_nTwistLeftTopToRightBottom = 5;
|
||
const int c_nTwistLeftBottomToRightTop = 6;
|
||
const int c_nTwistRightTopToLeftBottom = 7;
|
||
const int c_nTwistRightBottomToLeftTop = 8;
|
||
|
||
const int c_nRippleOut = 1;
|
||
const int c_nRippleIn = 2;
|
||
const int c_nRippleStepCount = 4;
|
||
const double c_dRippleStepBeginFrame[5] = {0.0,0.2,0.8,1.0};
|
||
|
||
const int c_nWaveHorizontal = 1;
|
||
const int c_nWaveVertical = 2;
|
||
|
||
const int c_nWaveStepCount = 4;
|
||
const double c_dWaveStepBeginFrame[5] = {0.0,0.2,0.8,1.0};
|
||
|
||
const int c_nBurning = 1;
|
||
const int c_nBurningFade = 2;
|
||
const int c_nBurningFire = 3;
|
||
|
||
const int c_nGaussianBlurStepCount = 5;
|
||
const double c_dGaussianBlurStepBeginFrame[5] = {0.0,0.3,0.5,0.7,1.0};
|
||
|
||
const int c_nNoiseColored = 1;
|
||
const int c_nNoiseGrayscale = 2;
|
||
const int c_nFlashLight = 3;
|
||
const int c_nFlashDark = 4;
|
||
const int c_nNoiseStepCount = 5;
|
||
const double c_dNoiseStepBeginFrame[5] = {0.0,0.4,0.5,0.6,1.0};
|
||
|
||
|
||
const int c_nTetris = 1;
|
||
const int c_nTetrisCollapse = 2;
|
||
|
||
const int c_nShotChangeGHorizontalRToL = 1;
|
||
const int c_nShotChangeGHorizontalLToR = 2;
|
||
const int c_nShotChangeGVerticalUToB = 3;
|
||
const int c_nShotChangeGVerticalBToU = 4;
|
||
const int c_nShotChangeBHorizontalRToL = 5;
|
||
const int c_nShotChangeBHorizontalLToR = 6;
|
||
const int c_nShotChangeBVerticalUToB = 7;
|
||
const int c_nShotChangeBVerticalBToU = 8;
|
||
const int c_nShotChangeGHorizontalRToLNoZ = 9;
|
||
const int c_nShotChangeGHorizontalLToRNoZ = 10;
|
||
const int c_nShotChangeGVerticalUToBNoZ = 11;
|
||
const int c_nShotChangeGVerticalBToUNoZ = 12;
|
||
const int c_nShotChangeBHorizontalRToLNoZ = 13;
|
||
const int c_nShotChangeBHorizontalLToRNoZ = 14;
|
||
const int c_nShotChangeBVerticalUToBNoZ = 15;
|
||
const int c_nShotChangeBVerticalBToUNoZ = 16;
|
||
|
||
const int c_nBlackWhiteLines = 1;
|
||
const int c_nBlackWhiteLinesInverse = 2;
|
||
|
||
//mask
|
||
const int c_nBowTileHorizontal = 1;
|
||
const int c_nBowTileVertical = 2;
|
||
const int c_nDiagonalBoxOut = 3;
|
||
const int c_nDiagonalCrossOut = 4;
|
||
const int c_nDiagonalDownRight = 5;
|
||
const int c_nDiagonalDownLeft = 6;
|
||
const int c_nDiagonalUpRight = 7;
|
||
const int c_nDiagonalUpLeft = 8;
|
||
const int c_nFunIn = 9;
|
||
const int c_nFunOut = 10;
|
||
const int c_nFunUp = 11;
|
||
const int c_nFilledVDown = 12;
|
||
const int c_nFilledVLeft = 13;
|
||
const int c_nFilledVRight = 14;
|
||
const int c_nFilledVUp = 15;
|
||
const int c_nInsertDownLeft = 16;
|
||
const int c_nInsertDownRight = 17;
|
||
const int c_nInsertUpLeft = 18;
|
||
const int c_nInsertUpRight = 19;
|
||
const int c_nRevealDown = 20;
|
||
const int c_nRevealRight = 21;
|
||
const int c_nRevealLeft = 22;
|
||
const int c_nRevealUp = 23;
|
||
const int c_nSplitHorizontal = 24;
|
||
const int c_nSplitVertical = 25;
|
||
const int c_nSweepIn = 26;
|
||
const int c_nSweepOut = 27;
|
||
const int c_nSweepUp = 28;
|
||
const int c_nZigZagHorizontal = 29;
|
||
const int c_nZigZagVertical = 30;
|
||
const int c_nBarsHorizontal = 31;
|
||
const int c_nBarsVertical = 32;
|
||
const int c_nBowTileSmoothHorizontal = 33;
|
||
const int c_nBowTileSmoothVertical = 34;
|
||
const int c_nDiagonalSmoothBoxOut = 35;
|
||
const int c_nDiagonalSmoothCrossOut = 36;
|
||
const int c_nDiagonalSmoothDownRight = 37;
|
||
const int c_nDiagonalSmoothDownLeft = 38;
|
||
const int c_nDiagonalSmoothUpRight = 39;
|
||
const int c_nDiagonalSmoothUpLeft = 40;
|
||
const int c_nFunSmoothIn = 41;
|
||
const int c_nFunSmoothOut = 42;
|
||
const int c_nFunSmoothUp = 43;
|
||
const int c_nFilledVSmoothDown = 44;
|
||
const int c_nFilledVSmoothLeft = 45;
|
||
const int c_nFilledVSmoothRight = 46;
|
||
const int c_nFilledVSmoothUp = 47;
|
||
const int c_nInsertSmoothDownLeft = 48;
|
||
const int c_nInsertSmoothDownRight = 49;
|
||
const int c_nInsertSmoothUpLeft = 50;
|
||
const int c_nInsertSmoothUpRight = 51;
|
||
const int c_nSplitSmoothHorizontal = 52;
|
||
const int c_nSplitSmoothVertical = 53;
|
||
const int c_nSweepSmoothIn = 54;
|
||
const int c_nSweepSmoothOut = 55;
|
||
const int c_nSweepSmoothUp = 56;
|
||
const int c_nZigZagSmoothHorizontal = 57;
|
||
const int c_nZigZagSmoothVertical = 58;
|
||
const int c_nWipeSmoothCircle = 59;
|
||
const int c_nWipeSmoothCircles = 60;
|
||
const int c_nWipeSmoothDiamond = 61;
|
||
const int c_nWipeSmoothDiamonds = 62;
|
||
const int c_nWipeSmoothWideStar = 63;
|
||
const int c_nWipeSmoothWideStars = 64;
|
||
const int c_nWipeSmoothWideFlower = 65;
|
||
const int c_nWipeSmoothWideFlowers = 66;
|
||
const int c_nWipeSmoothWideKeyHole = 67;
|
||
const int c_nWipeSmoothWideKeyHoles = 68;
|
||
const int c_nWipeSmoothNarrowStar = 69;
|
||
const int c_nWipeSmoothNarrowStars = 70;
|
||
const int c_nWipeSmoothNarrowKeyHole = 71;
|
||
const int c_nWipeSmoothNarrowKeyHoles = 72;
|
||
const int c_nWipeSmoothNarrowFlower = 73;
|
||
const int c_nWipeSmoothNarrowFlowers = 74;
|
||
const int c_nCircleCornerLeftTop = 81;
|
||
const int c_nCircleCornerLeftBottom = 82;
|
||
const int c_nCircleCornerRightTop = 83;
|
||
const int c_nCircleCornerRightBottom = 84;
|
||
const int c_nCircleCornerSmoothLeftTop = 85;
|
||
const int c_nCircleCornerSmoothLeftBottom = 86;
|
||
const int c_nCircleCornerSmoothRightTop = 87;
|
||
const int c_nCircleCornerSmoothRightBottom = 88;
|
||
const int c_nWipeSmoothCircleIn = 89;
|
||
const int c_nWipeCircles = 90;
|
||
const int c_nWipeSmoothBoxIn = 91;
|
||
const int c_nWipeSmoothBoxOut = 92;
|
||
const int c_nWipeSmoothDiamondIn = 93;
|
||
const int c_nWipeDiamonds = 94;
|
||
|
||
const int c_nPixelate = 1;
|
||
const int c_nRollRight = 2;
|
||
const int c_nRollLeft = 3;
|
||
const int c_nSlideUp = 4;
|
||
const int c_nSlideDown = 5;
|
||
const int c_nSlideRight = 6;
|
||
const int c_nSlideLeft = 7;
|
||
const int c_nSlideCenterUp = 8;
|
||
const int c_nSlideCenterDown = 9;
|
||
const int c_nSlideCenterRight = 10;
|
||
const int c_nSlideCenterLeft = 11;
|
||
const int c_nShrinkInVertical = 12;
|
||
const int c_nShrinkInHorizontal = 13;
|
||
const int c_nEye = 14;
|
||
const int c_nHeart = 15;
|
||
const int c_nWave = 16;
|
||
const int c_nSmoothEye = 17;
|
||
const int c_nSmoothHeart = 18;
|
||
const int c_nSmoothWave = 19;
|
||
|
||
//shatter
|
||
const int c_nWhirlWind = 5;
|
||
|
||
const int c_nPageTurnLeftTop = 5;
|
||
const int c_nPageTurnLeftBottom = 6;
|
||
const int c_nPageTurnRightBottom = 7;
|
||
const int c_nPageTurnRightTop = 8;
|
||
const int c_nPageTurnLeftTop3d = 9;
|
||
const int c_nPageTurnLeftBottom3d = 10;
|
||
const int c_nPageTurnRightBottom3d = 11;
|
||
const int c_nPageTurnRightTop3d = 12;
|
||
|
||
const int c_nPageTurnLeftTopWhiteBack3d = 20;
|
||
const int c_nPageTurnLeftBottomWhiteBack3d = 21;
|
||
const int c_nPageTurnRightBottomWhiteBack3d = 22;
|
||
const int c_nPageTurnRightTopWhiteBack3d = 23;
|
||
|
||
const int c_nPageTurnAlbumLeftTop = 24;
|
||
const int c_nPageTurnAlbumRightTop = 25;
|
||
const int c_nPageTurnAlbumRightBottom = 26;
|
||
const int c_nPageTurnAlbumLeftBottom = 27;
|
||
|
||
const int c_nPageTurnAlbumLeftTopCorners1 = 28;
|
||
const int c_nPageTurnAlbumRightTopCorners1 = 29;
|
||
const int c_nPageTurnAlbumRightBottomCorners1= 30;
|
||
const int c_nPageTurnAlbumLeftBottomCorners1 = 31;
|
||
|
||
const int c_nPageTurnAlbumLeftTopCorners2 = 32;
|
||
const int c_nPageTurnAlbumRightTopCorners2 = 33;
|
||
const int c_nPageTurnAlbumRightBottomCorners2= 34;
|
||
const int c_nPageTurnAlbumLeftBottomCorners2 = 35;
|
||
|
||
const int c_nPageTurnAlbumLeftTopCorners3 = 36;
|
||
const int c_nPageTurnAlbumRightTopCorners3 = 37;
|
||
const int c_nPageTurnAlbumRightBottomCorners3= 38;
|
||
const int c_nPageTurnAlbumLeftBottomCorners3 = 39;
|
||
|
||
const int c_nPageTurnAlbumLeftTopCorners4 = 40;
|
||
const int c_nPageTurnAlbumRightTopCorners4 = 41;
|
||
const int c_nPageTurnAlbumRightBottomCorners4= 42;
|
||
const int c_nPageTurnAlbumLeftBottomCorners4 = 43;
|
||
|
||
|
||
const int c_nPinwheelCurvedSN5A = 1;
|
||
const int c_nPinwheelCurvedSN7A = 2;
|
||
const int c_nPinwheelCurvedSN12A = 3;
|
||
const int c_nPinwheelCurvedSW5A = 4;
|
||
const int c_nPinwheelCurvedSW7A = 5;
|
||
const int c_nPinwheelCurvedSW12A = 6;
|
||
const int c_nPinwheelCurvedLN5A = 7;
|
||
const int c_nPinwheelCurvedLN7A = 8;
|
||
const int c_nPinwheelCurvedLN12A = 9;
|
||
const int c_nPinwheelPropeller4 = 10;
|
||
const int c_nPinwheelPropeller7 = 11;
|
||
const int c_nPinwheelPropeller12 = 12;
|
||
|
||
const int c_nPinwheelCurvedSN5ASmooth = 13;
|
||
const int c_nPinwheelCurvedSN7ASmooth = 14;
|
||
const int c_nPinwheelCurvedSN12ASmooth = 15;
|
||
const int c_nPinwheelCurvedSW5ASmooth = 16;
|
||
const int c_nPinwheelCurvedSW7ASmooth = 17;
|
||
const int c_nPinwheelCurvedSW12ASmooth = 18;
|
||
const int c_nPinwheelCurvedLN5ASmooth = 19;
|
||
const int c_nPinwheelCurvedLN7ASmooth = 20;
|
||
const int c_nPinwheelCurvedLN12ASmooth = 21;
|
||
const int c_nPinwheelPropeller4Smooth = 22;
|
||
const int c_nPinwheelPropeller7Smooth = 23;
|
||
const int c_nPinwheelPropeller12Smooth = 24;
|
||
|
||
const int c_nPuzzle4x4 = 1;
|
||
const int c_nPuzzle7x7 = 2;
|
||
const int c_nPuzzle10x10 = 3;
|
||
const int c_nPuzzle4x4Collapse = 4;
|
||
const int c_nPuzzle7x7Collapse = 5;
|
||
const int c_nPuzzle10x10Collapse = 6;
|
||
const int c_nTile4x4Cons = 7;
|
||
const int c_nTile4x4Rand = 8;
|
||
const int c_nTile7x7Cons = 9;
|
||
const int c_nTile7x7Rand = 10;
|
||
const int c_nTile10x10Cons = 11;
|
||
const int c_nTile10x10Rand = 12;
|
||
const int c_nTile4x4ConsCollapse = 13;
|
||
const int c_nTile4x4RandCollapse = 14;
|
||
const int c_nTile7x7ConsCollapse = 15;
|
||
const int c_nTile7x7RandCollapse = 16;
|
||
const int c_nTile10x10ConsCollapse = 17;
|
||
const int c_nTile10x10RandCollapse = 18;
|
||
|
||
|
||
const int c_nSmallHexagons = 1;
|
||
const int c_nLargeHexagons = 2;
|
||
const int c_nSmallHexagonsCollapse = 3;
|
||
const int c_nLargeHexagonsCollapse = 4;
|
||
const int c_nSmallRhombuses = 5;
|
||
const int c_nLargeRhombuses = 6;
|
||
const int c_nSmallRhombusesCollapse = 7;
|
||
const int c_nLargeRhombusesCollapse = 8;
|
||
const int c_nSmallBricks = 9;
|
||
const int c_nLargeBricks = 10;
|
||
const int c_nSmallBricks2 = 11;
|
||
const int c_nLargeBricks2 = 12;
|
||
const int c_nSmallBricks3 = 13;
|
||
const int c_nLargeBricks3 = 14;
|
||
const int c_nSmallBricksCollapse = 15;
|
||
const int c_nLargeBricksCollapse = 16;
|
||
const int c_nSmallTriangles = 17;
|
||
const int c_nLargeTriangles = 18;
|
||
const int c_nSmallTriangles2 = 19;
|
||
const int c_nLargeTriangles2 = 20;
|
||
const int c_nSmallTriangles3 = 21;
|
||
const int c_nLargeTriangles3 = 22;
|
||
const int c_nSmallTrianglesCollapse = 23;
|
||
const int c_nLargeTrianglesCollapse = 24;
|
||
const int c_nSmallInclinedBricks = 25;
|
||
const int c_nLargeInclinedBricks = 26;
|
||
const int c_nSmallInclinedBricks2 = 27;
|
||
const int c_nLargeInclinedBricks2 = 28;
|
||
const int c_nSmallInclinedBricksCollapse = 29;
|
||
const int c_nLargeInclinedBricksCollapse = 30;
|
||
|
||
const int c_nGraduateSideLeftToRight = 1;
|
||
const int c_nGraduateSideRightToLeft = 2;
|
||
const int c_nGraduateSideTopToBottom = 3;
|
||
const int c_nGraduateSideBottomToTop = 4;
|
||
const int c_nGraduateCornerLeftTop = 5;
|
||
const int c_nGraduateCornerLeftBottom = 6;
|
||
const int c_nGraduateCornerRightBottom = 7;
|
||
const int c_nGraduateCornerRightTop = 8;
|
||
|
||
const int c_nGraduateClockBottomClockwise = 1;
|
||
const int c_nGraduateClockBottomReverse = 2;
|
||
const int c_nGraduateClockBottomOpposite = 3;
|
||
const int c_nGraduateClockTopClockwise = 4;
|
||
const int c_nGraduateClockTopReverse = 5;
|
||
const int c_nGraduateClockTopOpposite = 6;
|
||
const int c_nGraduateClockLeftClockwise = 7;
|
||
const int c_nGraduateClockLeftReverse = 8;
|
||
const int c_nGraduateClockLeftOpposite = 9;
|
||
const int c_nGraduateClockRightClockwise = 10;
|
||
const int c_nGraduateClockRightReverse = 11;
|
||
const int c_nGraduateClockRightOpposite = 12;
|
||
const int c_nGraduateClock2AnglesClockwise = 13;
|
||
const int c_nGraduateClock2AnglesReverse = 14;
|
||
const int c_nGraduateClock3AnglesClockwise = 15;
|
||
const int c_nGraduateClock3AnglesReverse = 16;
|
||
const int c_nGraduateSideLeftToRightSmooth = 17;
|
||
const int c_nGraduateSideRightToLeftSmooth = 18;
|
||
const int c_nGraduateSideTopToBottomSmooth = 19;
|
||
const int c_nGraduateSideBottomToTopSmooth = 20;
|
||
const int c_nGraduateCornerLeftTopSmooth = 21;
|
||
const int c_nGraduateCornerLeftBottomSmooth = 22;
|
||
const int c_nGraduateCornerRightBottomSmooth = 23;
|
||
const int c_nGraduateCornerRightTopSmooth = 24;
|
||
const int c_nGraduateClockBottomClockwiseSmooth = 25;
|
||
const int c_nGraduateClockBottomReverseSmooth = 26;
|
||
const int c_nGraduateClockBottomOppositeSmooth = 27;
|
||
const int c_nGraduateClockTopClockwiseSmooth = 28;
|
||
const int c_nGraduateClockTopReverseSmooth = 29;
|
||
const int c_nGraduateClockTopOppositeSmooth = 30;
|
||
const int c_nGraduateClockLeftClockwiseSmooth = 31;
|
||
const int c_nGraduateClockLeftReverseSmooth = 32;
|
||
const int c_nGraduateClockLeftOppositeSmooth = 33;
|
||
const int c_nGraduateClockRightClockwiseSmooth = 34;
|
||
const int c_nGraduateClockRightReverseSmooth = 35;
|
||
const int c_nGraduateClockRightOppositeSmooth = 36;
|
||
const int c_nGraduateClock2AnglesClockwiseSmooth = 37;
|
||
const int c_nGraduateClock2AnglesReverseSmooth = 38;
|
||
const int c_nGraduateClock3AnglesClockwiseSmooth = 39;
|
||
const int c_nGraduateClock3AnglesReverseSmooth = 40;
|
||
|
||
|
||
// dots
|
||
const BYTE c_byPatternDots[8][8] =
|
||
{
|
||
{1,0,0,0,1,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0}
|
||
};
|
||
|
||
// dots dense
|
||
const BYTE c_byPatternDotsDense[8][8] =
|
||
{
|
||
{1,0,1,0,1,0,1,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{1,0,1,0,1,0,1,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{1,0,1,0,1,0,1,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{1,0,1,0,1,0,1,0},
|
||
{0,0,0,0,0,0,0,0}
|
||
};
|
||
|
||
// grid
|
||
const BYTE c_byPatternGrid[8][8] =
|
||
{
|
||
{1,1,1,1,1,1,1,1},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,1,1,1,1,1,1,1},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0}
|
||
};
|
||
|
||
// grid rotated
|
||
const BYTE c_byPatternGridRotated[8][8] =
|
||
{
|
||
{1,0,0,0,0,0,0,1},
|
||
{0,1,0,0,0,0,1,0},
|
||
{0,0,1,0,0,1,0,0},
|
||
{0,0,0,1,1,0,0,0},
|
||
{0,0,0,1,1,0,0,0},
|
||
{0,0,1,0,0,1,0,0},
|
||
{0,1,0,0,0,0,1,0},
|
||
{1,0,0,0,0,0,0,1}
|
||
};
|
||
|
||
// line vertical
|
||
const BYTE c_byPatternLineVertical[8][8] =
|
||
{
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0},
|
||
{1,0,0,0,1,0,0,0}
|
||
};
|
||
|
||
// line horizontal
|
||
const BYTE c_byPatternLineHorizontal[8][8] =
|
||
{
|
||
{1,1,1,1,1,1,1,1},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{1,1,1,1,1,1,1,1},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0}
|
||
};
|
||
|
||
// line diagonal
|
||
const BYTE c_byPatternLineDiagonal[8][8] =
|
||
{
|
||
{0,0,0,1,0,0,0,0},
|
||
{0,0,1,0,0,0,0,0},
|
||
{0,1,0,0,0,0,0,0},
|
||
{1,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,1},
|
||
{0,0,0,0,0,0,1,0},
|
||
{0,0,0,0,0,1,0,0},
|
||
{0,0,0,0,1,0,0,0}
|
||
};
|
||
|
||
// line diagonal rotated
|
||
const BYTE c_byPatternLineDiagonalRotated[8][8] =
|
||
{
|
||
{0,0,0,0,1,0,0,0},
|
||
{0,0,0,0,0,1,0,0},
|
||
{0,0,0,0,0,0,1,0},
|
||
{0,0,0,0,0,0,0,1},
|
||
{1,0,0,0,0,0,0,0},
|
||
{0,1,0,0,0,0,0,0},
|
||
{0,0,1,0,0,0,0,0},
|
||
{0,0,0,1,0,0,0,0}
|
||
};
|
||
|
||
// chess board
|
||
const BYTE c_byPatternChessBoard[8][8] =
|
||
{
|
||
{1,1,1,1,0,0,0,0},
|
||
{1,1,1,1,0,0,0,0},
|
||
{1,1,1,1,0,0,0,0},
|
||
{1,1,1,1,0,0,0,0},
|
||
{0,0,0,0,1,1,1,1},
|
||
{0,0,0,0,1,1,1,1},
|
||
{0,0,0,0,1,1,1,1},
|
||
{0,0,0,0,1,1,1,1}
|
||
};
|
||
|
||
// dashes
|
||
const BYTE c_byPatternDashes[8][8] =
|
||
{
|
||
{1,0,0,0,0,0,0,0},
|
||
{0,1,0,0,0,0,0,0},
|
||
{0,0,1,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,1,0},
|
||
{0,0,0,0,0,1,0,0},
|
||
{0,0,0,0,1,0,0,0},
|
||
{0,0,0,0,0,0,0,0}
|
||
};
|
||
|
||
// spiner
|
||
const BYTE c_byPatternSpiner[8][8] =
|
||
{
|
||
{0,0,0,1,0,1,0,0},
|
||
{0,0,0,0,1,1,0,0},
|
||
{1,1,0,0,1,0,0,0},
|
||
{0,1,1,1,1,0,0,1},
|
||
{1,0,0,1,1,1,1,0},
|
||
{0,0,0,1,0,0,1,1},
|
||
{0,0,1,1,0,0,0,0},
|
||
{0,0,1,0,1,0,0,0}
|
||
};
|
||
|
||
// heart
|
||
const BYTE c_byPatternHeart[8][8] =
|
||
{
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,1,0,0,0,0},
|
||
{0,0,1,1,1,0,0,0},
|
||
{0,1,1,1,1,1,0,0},
|
||
{1,1,1,1,1,1,1,0},
|
||
{1,1,1,1,1,1,1,0},
|
||
{0,1,1,0,1,1,0,0},
|
||
{0,0,0,0,0,0,0,0}
|
||
};
|
||
|
||
// Cross
|
||
const BYTE c_byPatternCross[8][8] =
|
||
{
|
||
{1,0,0,0,1,0,0,1},
|
||
{0,1,0,1,0,0,1,0},
|
||
{0,0,1,0,1,1,0,0},
|
||
{0,1,0,1,0,1,0,1},
|
||
{1,0,1,0,1,0,1,0},
|
||
{0,0,1,1,0,1,0,0},
|
||
{0,1,0,0,1,0,1,0},
|
||
{1,0,0,1,0,0,0,1}
|
||
};
|
||
|
||
// thatches
|
||
const BYTE c_byPatternThatches[8][8] =
|
||
{
|
||
{1,1,1,1,1,0,0,0},
|
||
{0,1,1,1,0,1,0,0},
|
||
{0,0,1,0,0,0,1,0},
|
||
{0,1,0,0,0,1,1,1},
|
||
{1,0,0,0,1,1,1,1},
|
||
{0,0,0,1,0,1,1,1},
|
||
{0,0,1,0,0,0,1,0},
|
||
{0,1,1,1,0,0,0,1}
|
||
};
|
||
|
||
// empty
|
||
const BYTE c_byPatternEmpty[8][8] =
|
||
{
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0},
|
||
{0,0,0,0,0,0,0,0}
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////
|
||
// Mosaic patterns
|
||
|
||
// spiral in
|
||
const BYTE c_byMosaicSpiralIn[8][8] =
|
||
{
|
||
{ 0, 1, 2, 3, 4, 5, 6, 7},
|
||
{27,28,29,30,31,32,33, 8},
|
||
{26,47,48,49,50,51,34, 9},
|
||
{25,45,59,60,61,52,35,10},
|
||
{24,45,58,63,62,53,36,11},
|
||
{23,44,57,56,55,54,37,12},
|
||
{22,43,42,41,40,39,38,13},
|
||
{21,20,19,18,17,16,15,14}
|
||
};
|
||
|
||
// spiral out
|
||
const BYTE c_byMosaicSpiralOut[8][8] =
|
||
{
|
||
{42,43,44,45,46,47,48,49},
|
||
{41,20,21,22,23,24,25,50},
|
||
{40,19, 6, 7, 8, 9,26,51},
|
||
{39,18, 5, 0, 1,10,27,52},
|
||
{38,17, 4, 3, 2,11,28,53},
|
||
{37,16,15,14,13,12,29,54},
|
||
{36,35,34,33,32,31,30,55},
|
||
{63,62,61,60,59,58,57,56}
|
||
};
|
||
|
||
// strips
|
||
const BYTE c_byMosaicStrips[8][8] =
|
||
{
|
||
{ 7,15,23,31,39,47,55,63},
|
||
{63,55,47,39,31,23,15, 7},
|
||
{ 7,15,23,31,39,47,55,63},
|
||
{63,55,47,39,31,23,15, 7},
|
||
{ 7,15,23,31,39,47,55,63},
|
||
{63,55,47,39,31,23,15, 7},
|
||
{ 7,15,23,31,39,47,55,63},
|
||
{63,55,47,39,31,23,15, 7}
|
||
};
|
||
|
||
// dissolve
|
||
const BYTE c_byMosaicDissolve[8][8] =
|
||
{
|
||
{35,55,19,59,35,55,19,59},
|
||
{47,23,63,31,47,23,63,31},
|
||
{27,51,39,11,27,51,39,11},
|
||
{43,15, 7, 3,43,15, 7, 3},
|
||
{35,55,19,59,35,55,19,59},
|
||
{47,23,63,31,47,23,63,31},
|
||
{27,51,39,11,27,51,39,11},
|
||
{43,15, 7, 3,43,15, 7, 3}
|
||
};
|
||
|
||
// random
|
||
const BYTE c_byMosaicRandom[8][8] =
|
||
{
|
||
{ 0,54,48,13,61, 5,51,45},
|
||
{24,29, 4,33,44,25, 9,20},
|
||
{43,63,37,55,17,30,40,56},
|
||
{21,14,23,10,27,12, 2,32},
|
||
{38,53,34,47, 1,62,46, 8},
|
||
{59, 7,57,22,39,18,36,41},
|
||
{15,42,16,60,11,50,31,19},
|
||
{49,28, 3,35,58,26, 6,52}
|
||
};
|
||
|
||
// diagonal left-bottom
|
||
const BYTE c_byMosaicDiagonalLeftBottom[8][8] =
|
||
{
|
||
{ 0, 4, 8,13,17,21,26,30},
|
||
{ 4, 8,13,17,21,26,30,34},
|
||
{ 8,13,17,21,26,30,34,39},
|
||
{13,17,21,26,30,34,39,43},
|
||
{17,21,26,30,34,39,43,48},
|
||
{21,26,30,34,39,43,48,52},
|
||
{26,30,34,39,43,48,52,57},
|
||
{30,34,39,43,48,52,57,63}
|
||
};
|
||
|
||
// diagonal left-top
|
||
const BYTE c_byMosaicDiagonalLeftTop[8][8] =
|
||
{
|
||
{31,35,39,44,49,53,58,63},
|
||
{27,31,35,39,44,49,53,58},
|
||
{21,27,31,35,39,44,49,53},
|
||
{17,21,27,31,35,39,44,49},
|
||
{13,17,21,27,31,35,39,44},
|
||
{ 9,13,17,21,27,31,35,39},
|
||
{ 4, 9,13,17,21,27,31,35},
|
||
{ 0, 4, 9,13,17,21,27,31}
|
||
};
|
||
|
||
// diagonal right-bottom
|
||
const BYTE c_byMosaicDiagonalRightBottom[8][8] =
|
||
{
|
||
{31,27,21,17,13, 9, 4, 0},
|
||
{35,31,27,21,17,13, 9, 4},
|
||
{39,35,31,27,21,17,13, 9},
|
||
{44,39,35,31,27,21,17,13},
|
||
{49,44,39,35,31,27,21,17},
|
||
{53,49,44,39,35,31,27,21},
|
||
{59,53,49,44,39,35,31,27},
|
||
{63,59,53,49,44,39,35,31}
|
||
};
|
||
|
||
// diagonal right-top
|
||
const BYTE c_byMosaicDiagonalRightTop[8][8] =
|
||
{
|
||
{63,59,53,49,44,39,35,31},
|
||
{59,53,49,44,39,35,31,27},
|
||
{53,49,44,39,35,31,27,21},
|
||
{49,44,39,35,31,27,21,17},
|
||
{44,39,35,31,27,21,17,13},
|
||
{39,35,31,27,21,17,13, 9},
|
||
{35,31,27,21,17,13, 9, 4},
|
||
{31,27,21,17,13, 9, 4, 0}
|
||
};
|
||
|
||
// wall left
|
||
const BYTE c_byMosaicWallLeft[8][8] =
|
||
{
|
||
{ 0,15,16,31,32,47,48,63},
|
||
{ 1,14,17,30,33,46,49,62},
|
||
{ 2,13,18,29,34,45,50,61},
|
||
{ 3,12,19,28,35,44,51,60},
|
||
{ 4,11,20,27,36,43,52,59},
|
||
{ 5,10,21,26,37,42,53,58},
|
||
{ 6, 9,22,25,38,41,54,57},
|
||
{ 7, 8,23,24,39,40,55,56}
|
||
};
|
||
|
||
// wall right
|
||
const BYTE c_byMosaicWallRight[8][8] =
|
||
{
|
||
{63,48,47,32,31,16,15, 0},
|
||
{62,49,46,33,30,17,14, 1},
|
||
{61,50,45,34,29,18,13, 2},
|
||
{60,51,44,35,28,19,12, 3},
|
||
{59,52,43,36,27,20,11, 4},
|
||
{58,53,42,37,26,21,10, 5},
|
||
{57,54,41,38,25,22, 9, 6},
|
||
{56,55,40,39,24,23, 8, 7}
|
||
};
|
||
|
||
// wall bottom
|
||
const BYTE c_byMosaicWallBottom[8][8] =
|
||
{
|
||
{ 0, 1, 2, 3, 4, 5, 6, 7},
|
||
{15,14,13,12,11,10, 9, 8},
|
||
{16,17,18,19,20,21,22,23},
|
||
{31,30,29,28,27,26,25,24},
|
||
{32,33,34,35,36,37,38,39},
|
||
{47,46,45,44,43,42,41,40},
|
||
{48,49,50,51,52,53,54,55},
|
||
{63,62,61,60,59,58,57,56}
|
||
};
|
||
|
||
// wall top
|
||
const BYTE c_byMosaicWallTop[8][8] =
|
||
{
|
||
{63,62,61,60,59,58,57,56},
|
||
{48,49,50,51,52,53,54,55},
|
||
{47,46,45,44,43,42,41,40},
|
||
{32,33,34,35,36,37,38,39},
|
||
{31,30,29,28,27,26,25,24},
|
||
{16,17,18,19,20,21,22,23},
|
||
{15,14,13,12,11,10, 9, 8},
|
||
{ 0, 1, 2, 3, 4, 5, 6, 7}
|
||
};
|
||
|
||
// chess left
|
||
const BYTE c_byMosaicChessLeft[8][8] =
|
||
{
|
||
{ 0,36, 8,44,16,52,24,60},
|
||
{32, 4,40,12,48,20,56,28},
|
||
{ 1,37, 9,45,17,53,25,61},
|
||
{33, 5,41,13,49,21,57,29},
|
||
{ 2,38,10,46,18,54,26,62},
|
||
{34, 6,42,14,50,22,59,30},
|
||
{ 3,39,11,47,19,55,27,63},
|
||
{35, 7,43,15,51,23,59,31}
|
||
};
|
||
|
||
// chess right
|
||
const BYTE c_byMosaicChessRight[8][8] =
|
||
{
|
||
{60,24,52,16,44, 8,36, 0},
|
||
{28,56,20,48,12,40, 4,32},
|
||
{61,25,53,17,45, 9,37, 1},
|
||
{29,57,21,49,13,41, 5,33},
|
||
{62,26,54,18,46,10,38, 2},
|
||
{30,59,22,50,14,42, 6,34},
|
||
{63,27,55,19,47,11,39, 3},
|
||
{31,59,23,51,15,43, 7,35}
|
||
};
|
||
|
||
// chess top
|
||
const BYTE c_byMosaicChessTop[8][8] =
|
||
{
|
||
{60,28,61,29,62,30,63,31},
|
||
{24,56,25,57,26,58,27,59},
|
||
{52,20,53,21,54,22,55,23},
|
||
{16,48,17,49,18,50,19,51},
|
||
{44,12,45,13,46,14,47,15},
|
||
{ 8,40, 9,41,10,42,11,43},
|
||
{36, 4,37, 5,38, 6,39, 7},
|
||
{ 0,32, 1,33, 2,34, 3,35}
|
||
};
|
||
|
||
// chess bottom
|
||
const BYTE c_byMosaicChessBottom[8][8] =
|
||
{
|
||
{ 0,32, 1,33, 2,34, 3,35},
|
||
{36, 4,37, 5,38, 6,39, 7},
|
||
{ 8,40, 9,41,10,42,11,43},
|
||
{44,12,45,13,46,14,47,15},
|
||
{16,48,17,49,18,50,19,51},
|
||
{52,20,53,21,54,22,55,23},
|
||
{24,56,25,57,26,58,27,59},
|
||
{60,28,61,29,62,30,63,31}
|
||
};
|
||
|
||
// counterclockwise
|
||
const BYTE c_byMosaicCounterClockwise[8][8] =
|
||
{
|
||
{60,61,63, 3, 5, 6, 9,12},
|
||
{57,59,62, 2, 4, 8,11,13},
|
||
{55,56,58, 1, 7,10,15,16},
|
||
{54,53,52, 0,14,17,18,19},
|
||
{51,50,48,34,24,22,20,21},
|
||
{49,46,43,37,31,27,25,23},
|
||
{47,44,41,38,35,32,28,26},
|
||
{45,42,40,39,36,33,30,29}
|
||
};
|
||
|
||
// clockwise
|
||
const BYTE c_byMosaicClockwise[8][8] =
|
||
{
|
||
{ 9, 6, 5, 3,64,63,60,58},
|
||
{10, 8, 4, 2,62,59,57,55},
|
||
{13,12, 7, 1,61,56,54,53},
|
||
{15,14,11, 0,48,49,50,51},
|
||
{16,17,19,26,36,45,46,47},
|
||
{18,20,22,29,34,39,42,44},
|
||
{21,23,27,30,32,37,40,43},
|
||
{24,25,28,31,33,35,38,41}
|
||
};
|
||
|
||
/*
|
||
const BYTE c_byMosaicDissolve[8][8] =
|
||
{
|
||
{ , , , , , , , },
|
||
{ , , , , , , , },
|
||
{ , , , , , , , },
|
||
{ , , , , , , , },
|
||
{ , , , , , , , },
|
||
{ , , , , , , , },
|
||
{ , , , , , , , },
|
||
{ , , , , , , , }
|
||
};
|
||
*/
|
||
|
||
class Category
|
||
{
|
||
public:
|
||
|
||
CString Name;
|
||
CSimpleArray<int> Effects;
|
||
|
||
Category()
|
||
{ }
|
||
Category(const CString& _name)
|
||
{ Name = _name; }
|
||
Category& operator= (const Category& x)
|
||
{
|
||
Name = x.Name;
|
||
|
||
Effects.RemoveAll();
|
||
|
||
for (int index = 0; index < x.Effects.GetSize(); ++index)
|
||
Effects.Add(x.Effects[index]);
|
||
|
||
return *this;
|
||
}
|
||
};
|
||
|
||
class Effect
|
||
{
|
||
public:
|
||
|
||
int ID;
|
||
CString Name;
|
||
CString Name2;
|
||
int TileX;
|
||
int TileY;
|
||
int Type;
|
||
|
||
Effect()
|
||
{ Name = Name2 = ""; ID = -1; TileX = TileY = -1; Type = c_nEffectsAll; }
|
||
Effect(const CString& _name, int _id)
|
||
{ Name = _name; ID = _id; Type = c_nEffectsAll; }
|
||
Effect(const CString& _name, const CString& _name2, int _id)
|
||
{ Name = _name; Name2 = _name2; ID = _id; Type = c_nEffectsAll; }
|
||
Effect& operator= (const Effect& x)
|
||
{ Name = x.Name; Name2 = x.Name2; ID = x.ID; TileX = x.TileX; TileY = x.TileY; Type = x.Type; return *this; }
|
||
};
|
||
|
||
class Graduate
|
||
{
|
||
int Size;
|
||
int* Graduation;
|
||
|
||
public:
|
||
|
||
Graduate()
|
||
{ Size = 0; Graduation = 0; }
|
||
~Graduate()
|
||
{ Clear(); }
|
||
BOOL Clear()
|
||
{
|
||
if (Graduation)
|
||
delete[] Graduation;
|
||
|
||
Graduation = 0;
|
||
Size = 0;
|
||
|
||
return TRUE;
|
||
}
|
||
BOOL Create(int _size)
|
||
{
|
||
if (_size < 1)
|
||
return Clear();
|
||
if (_size == Size)
|
||
return TRUE;
|
||
|
||
Size = _size;
|
||
Graduation = new int[Size];
|
||
|
||
if (!Graduation)
|
||
{
|
||
Clear();
|
||
return FALSE;
|
||
}
|
||
|
||
for (int index = 0; index < Size; ++index)
|
||
Graduation[index] = index;
|
||
|
||
//srand(GetTickCount());
|
||
srand( 1 );
|
||
|
||
for (int index = 0; index < Size; ++index)
|
||
{
|
||
int swap_index = rand() % Size;
|
||
|
||
int swap_value = Graduation[swap_index];
|
||
Graduation[swap_index] = Graduation[index];
|
||
Graduation[index] = swap_value;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
double GetLevel(int _index, double Frame)
|
||
{
|
||
if (_index < 0 || _index >= Size)
|
||
return 0;
|
||
if (Frame <= 0)
|
||
return 0;
|
||
if (Frame >= 1)
|
||
return 1;
|
||
|
||
double level = Size*Frame;
|
||
|
||
if (level <= Graduation[_index])
|
||
return 0;
|
||
if (level >= Graduation[_index] + 1)
|
||
return 1;
|
||
return level - Graduation[_index];
|
||
}
|
||
};
|
||
|
||
|
||
class CTetrisFigure
|
||
{
|
||
public:
|
||
CTetrisFigure()
|
||
{
|
||
m_nFigHeight = 0;
|
||
m_nFigWidth = 0;
|
||
m_nPicHeight = 0;
|
||
m_nPicWidth = 0;
|
||
m_nType = 0;
|
||
m_pBGRASource = NULL;
|
||
m_nXCoorSource = 0;
|
||
m_nYCoorSource = 0;
|
||
}
|
||
CTetrisFigure(int nFigWidth, int nFigHeight, int nType, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
|
||
{
|
||
m_nFigHeight = nFigHeight;
|
||
m_nFigWidth = nFigWidth;
|
||
m_nType = nType;
|
||
m_nPicHeight = nPicHeight;
|
||
m_nPicWidth = nPicWidth;
|
||
m_pBGRASource = pBGRASource;
|
||
m_nXCoorSource = nXCoorSource;
|
||
m_nYCoorSource = nYCoorSource;
|
||
}
|
||
~CTetrisFigure()
|
||
{
|
||
}
|
||
|
||
private:
|
||
|
||
void DrawAlphaBlendingLine(BYTE* pBGRAResult, BYTE* pBGRASource, int nColor, int nNumLine, double dEffect)
|
||
{
|
||
BYTE *pResult = pBGRAResult;
|
||
BYTE *pSource = pBGRASource;
|
||
int nAlpha = 7;
|
||
for(int k = 0; k < nNumLine; k++)
|
||
{
|
||
nAlpha *= 2;
|
||
}
|
||
if(1 == dEffect)
|
||
{
|
||
*pResult = (nColor*nAlpha + *pSource *(255-nAlpha))/255; pResult++; pSource ++;
|
||
*pResult = (nColor*nAlpha + *pSource *(255-nAlpha))/255; pResult++; pSource ++;
|
||
*pResult = (nColor*nAlpha + *pSource *(255-nAlpha))/255; pResult++; pSource ++;
|
||
}
|
||
else
|
||
{
|
||
*pResult = dEffect*(nColor*nAlpha + *pSource *(255-nAlpha))/255 + *pSource*(1-dEffect); pResult++; pSource ++;
|
||
*pResult = dEffect*(nColor*nAlpha + *pSource *(255-nAlpha))/255 + *pSource*(1-dEffect); pResult++; pSource ++;
|
||
*pResult = dEffect*(nColor*nAlpha + *pSource *(255-nAlpha))/255 + *pSource*(1-dEffect); pResult++; pSource ++;
|
||
}
|
||
pResult++; pSource++;
|
||
}
|
||
|
||
public:
|
||
|
||
void SetValue(int nFigWidth, int nFigHeight, int nType, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
|
||
{
|
||
m_nFigHeight = nFigHeight;
|
||
m_nFigWidth = nFigWidth;
|
||
m_nType = nType;
|
||
m_nPicHeight = nPicHeight;
|
||
m_nPicWidth = nPicWidth;
|
||
m_pBGRASource = pBGRASource;
|
||
m_nXCoorSource = nXCoorSource;
|
||
m_nYCoorSource = nYCoorSource;
|
||
}
|
||
|
||
BOOL Cpy(BYTE* pBGRAResult, int nXCoorResult, int nYCoorResult, int nWidth, int nHeight, double dEffect)
|
||
{
|
||
if(!pBGRAResult || nWidth != m_nPicWidth || nHeight != m_nPicHeight)
|
||
return FALSE;
|
||
|
||
BYTE* pSource = m_pBGRASource;
|
||
BYTE* pResultBuffer = new BYTE[ 4 * nWidth * ( 2 * nHeight)];
|
||
BYTE* pResultBufferCurent = pResultBuffer;
|
||
pResultBufferCurent += 4 * nWidth * nHeight;
|
||
BYTE* pResultBufferMiddle = pResultBufferCurent;
|
||
BYTE* pResult = pBGRAResult;
|
||
|
||
IppiSize roiSize = { nWidth, nHeight};
|
||
|
||
ippiCopy_8u_C4R( pResult, 4 * nWidth, pResultBufferMiddle, 4 * nWidth, roiSize);
|
||
|
||
pSource += m_nYCoorSource * nWidth * 4;
|
||
pResultBufferCurent += nYCoorResult * nWidth * 4;
|
||
|
||
if (1 == m_nType)
|
||
{
|
||
for(int nYIndex = nYCoorResult; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += m_nXCoorSource*4;
|
||
pResultBufferCurent += nXCoorResult*4;
|
||
int nXIndex = nXCoorResult;
|
||
for(; nXIndex < min(nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( nYCoorResult + 5 >= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= min(nWidth, nXCoorResult + m_nFigWidth) - (min(nHeight, nYCoorResult + m_nFigHeight) - nYIndex)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy(pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
}
|
||
else if(2 == m_nType)
|
||
{
|
||
int nYIndex = nYCoorResult;
|
||
|
||
for(; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight/2); nYIndex++)
|
||
{
|
||
pSource += m_nXCoorSource * 4;
|
||
pResultBufferCurent += nXCoorResult * 4;
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( nYCoorResult + 5 >= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min(nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( min( nHeight, nYCoorResult + m_nFigHeight / 2) - 5 <= nYIndex &&
|
||
( ( nXIndex <= nXCoorResult + m_nFigWidth / 3 - ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex) && nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex)) ||
|
||
( nXIndex >= nXCoorResult + 2 * m_nFigWidth / 3 + ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex))) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight/2) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( nXIndex - nXCoorResult)) &&
|
||
0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy(pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 3);
|
||
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 3);
|
||
int nXIndex = nXCoorResult + m_nFigWidth / 3;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3); nXIndex++)
|
||
{
|
||
if
|
||
( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - 5 <= nXIndex
|
||
&& ( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex)
|
||
&& nYIndex <= min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - (min(nWidth, nXCoorResult + 2*m_nFigWidth/3)- 5), dEffect);
|
||
}
|
||
else if
|
||
( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex
|
||
&& ( nXIndex >= nXCoorResult + m_nFigWidth / 3 + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex)
|
||
&& nXIndex <= min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
|
||
}
|
||
else if
|
||
( nXCoorResult + m_nFigWidth / 3 + 5 >= nXIndex
|
||
&& ( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( nXIndex - ( nXCoorResult + m_nFigWidth / 3))
|
||
&& nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - ( nXCoorResult + m_nFigWidth / 3)))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth/3 + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
}
|
||
else if(3 == m_nType)
|
||
{
|
||
int nYIndex = nYCoorResult;
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 3); nYIndex++)
|
||
{
|
||
pSource += m_nXCoorSource * 4;
|
||
pResultBufferCurent += nXCoorResult * 4;
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 2); nXIndex++)
|
||
{
|
||
if ( nYCoorResult + 5 >= nYIndex
|
||
&& ( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth / 2) - ( nYIndex - nYCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if
|
||
( min(nWidth, nXCoorResult + m_nFigWidth / 2) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - 5), dEffect);
|
||
}
|
||
else if
|
||
( nXCoorResult + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 3) - ( nXIndex - nXCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min(nHeight, nYCoorResult + 2 * m_nFigHeight / 3); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
int nXIndex = nXCoorResult;
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if ( nYCoorResult + m_nFigHeight / 3 + 5 >= nYIndex &&
|
||
( nXIndex <= nXCoorResult + m_nFigWidth - ( nYIndex - nYCoorResult - m_nFigHeight / 3) && nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( nYIndex - nYCoorResult - m_nFigHeight / 3))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 3 + 5 - nYIndex, dEffect);
|
||
}
|
||
else if
|
||
( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + m_nFigHeight / 3 + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 0, nXIndex - (min(nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if
|
||
( ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - 5 <= nYIndex) &&
|
||
( nXIndex <= nXCoorResult + m_nFigWidth - ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex) && nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + 2*m_nFigHeight/3) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex && 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 2); nXIndex++)
|
||
{
|
||
if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= nXCoorResult + m_nFigWidth / 2 - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
|
||
}
|
||
else if( min(nWidth, nXCoorResult + m_nFigWidth / 2) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + 2 * m_nFigHeight / 3 + ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex) && nYIndex <= nYCoorResult + m_nFigHeight - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth/2) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
else if(4 == m_nType)
|
||
{
|
||
int nYIndex = nYCoorResult;
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 3); nYIndex++)
|
||
{
|
||
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 2);
|
||
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 2);
|
||
|
||
int nXIndex = nXCoorResult + m_nFigWidth / 2;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if ( nYCoorResult + 5 >= nYIndex &&
|
||
( nXIndex >= nXCoorResult + m_nFigWidth/2 + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if
|
||
( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if
|
||
( nXCoorResult + m_nFigWidth / 2 + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult - m_nFigWidth / 2) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 3) - ( nXIndex - nXCoorResult - m_nFigWidth / 2))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth/2 + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min(nHeight, nYCoorResult + 2 * m_nFigHeight / 3); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( nYCoorResult + m_nFigHeight / 3 + 5 >= nYIndex &&
|
||
( nXIndex <= nXCoorResult + m_nFigWidth / 2 - ( nYIndex - nYCoorResult - m_nFigHeight / 3) && nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult - m_nFigHeight / 3))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 3 + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex && 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - (min(nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - 5 <= nYIndex) &&
|
||
( nXIndex <= nXCoorResult + m_nFigWidth / 2 - ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex) && nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + m_nFigHeight / 3 + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - ( nXIndex - nXCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 2);
|
||
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 2);
|
||
int nXIndex = nXCoorResult + m_nFigWidth / 2;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
|
||
( nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= nXCoorResult + m_nFigWidth - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( nYCoorResult + m_nFigHeight - 5), dEffect);
|
||
}
|
||
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
nYIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex)
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + m_nFigWidth / 2 + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + 2 * m_nFigHeight / 3 + ( nXIndex - nXCoorResult - m_nFigWidth / 2) && nYIndex <= nYCoorResult + m_nFigHeight - ( nXIndex - nXCoorResult - m_nFigWidth / 2))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth/2 + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
}
|
||
else if(5 == m_nType)
|
||
{
|
||
int nYIndex = nYCoorResult;
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 2); nYIndex++)
|
||
{
|
||
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 3);
|
||
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 3);
|
||
int nXIndex = nXCoorResult + m_nFigWidth / 3;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3); nXIndex++)
|
||
{
|
||
if( nYCoorResult + 5 >= nYIndex &&
|
||
( nXIndex >= nXCoorResult + m_nFigWidth / 3 + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - ( nYIndex - nYCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min(nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + m_nFigWidth / 3 + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult - m_nFigWidth / 3) && nYIndex <= min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - ( nXIndex - nXCoorResult - m_nFigWidth / 3))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth / 3 + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( nYCoorResult + m_nFigHeight / 2 + 5 >= nYIndex &&
|
||
( ( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult - m_nFigHeight / 2) && nXIndex <= nXCoorResult + m_nFigWidth / 3 - ( nYIndex - nYCoorResult - m_nFigHeight / 2))
|
||
|| nXIndex >= nXCoorResult + 2 * m_nFigWidth / 3 + ( nYIndex - nYCoorResult - m_nFigHeight / 2) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult - m_nFigHeight / 2))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 2 + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
|
||
( nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
else if(6 == m_nType)
|
||
{
|
||
int nYIndex = nYCoorResult;
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 3); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
int nXIndex = nXCoorResult;
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( nYCoorResult + 5 >= nYIndex &&
|
||
(nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 3) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( min( nHeight, nYCoorResult + m_nFigHeight / 3) - 5 <= nYIndex &&
|
||
( nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( min( nHeight, nYCoorResult + m_nFigHeight / 3) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nHeight, nYCoorResult + m_nFigHeight / 3) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight / 3) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult)
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 2); nXIndex++)
|
||
{
|
||
if( min( nWidth, nXCoorResult + m_nFigWidth / 2) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + m_nFigHeight / 3 + ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - 5), dEffect);
|
||
}
|
||
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth / 2) - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
else if(7 == m_nType)
|
||
{
|
||
int nYIndex = nYCoorResult;
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 2); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
|
||
int nXIndex = nXCoorResult;
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 3); nXIndex++)
|
||
{
|
||
if( nYCoorResult + 5 >= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth / 3) - ( nYIndex - nYCoorResult))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( min( nWidth, nXCoorResult + m_nFigWidth / 3) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth / 3) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( min( nWidth, nXCoorResult + m_nFigWidth / 3) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth / 3) - 5), dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult)
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
|
||
}
|
||
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
|
||
{
|
||
pSource += 4 * m_nXCoorSource;
|
||
pResultBufferCurent += 4 * nXCoorResult;
|
||
int nXIndex = nXCoorResult;
|
||
|
||
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
|
||
{
|
||
if( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
|
||
( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
|
||
}
|
||
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
|
||
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
|
||
}
|
||
else if( nYCoorResult + m_nFigHeight / 2 + 5 >= nYIndex &&
|
||
( nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - ( nYCoorResult + m_nFigHeight / 2)) && nXIndex >= nXCoorResult + m_nFigWidth / 3 + ( nYIndex - ( nYCoorResult + m_nFigHeight / 2)))
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 2 + 5 - nYIndex, dEffect);
|
||
}
|
||
else if( nXCoorResult + 5 >= nXIndex &&
|
||
nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)
|
||
&& 0 != dEffect)
|
||
{
|
||
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
|
||
}
|
||
else
|
||
{
|
||
memcpy( pResultBufferCurent, pSource, 3);
|
||
}
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
for(; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
pResultBufferCurent += 4;
|
||
pSource += 4;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
ippiCopy_8u_C4R(pResultBufferMiddle, 4 * nWidth, pResult, 4 * nWidth, roiSize);
|
||
|
||
delete pResultBuffer;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
|
||
public:
|
||
|
||
int m_nFigHeight;
|
||
int m_nFigWidth;
|
||
|
||
int m_nPicHeight;
|
||
int m_nPicWidth;
|
||
|
||
int m_nType;
|
||
|
||
BYTE* m_pBGRASource;
|
||
|
||
int m_nXCoorSource;
|
||
int m_nYCoorSource;
|
||
|
||
};
|
||
|
||
|
||
class Utility
|
||
{
|
||
protected:
|
||
|
||
BOOL DrawFilmsPerf(BYTE* pBGRA, int nWidth, int nHeight, int nBlendColor, int nBkColor, float dX, float dY, float dWidth, float dHeight, float dRadius)
|
||
{
|
||
BYTE* pBuffer = pBGRA;
|
||
pBuffer += 4 * nWidth * (nHeight - 1);
|
||
|
||
Gdiplus::Bitmap oImage( nWidth, nHeight, -4*nWidth, PixelFormat32bppARGB, pBuffer );
|
||
if( Gdiplus::Ok == oImage.GetLastStatus() )
|
||
{
|
||
Gdiplus::Graphics oRender( &oImage );
|
||
|
||
oRender.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
|
||
oRender.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
|
||
oRender.SetInterpolationMode(Gdiplus::InterpolationModeBilinear);
|
||
|
||
Gdiplus::GraphicsPath oPath;
|
||
|
||
oPath.AddLine(dX + dRadius, dY, dX + dWidth - (dRadius * 2), dY);
|
||
oPath.AddArc(dX + dWidth - (dRadius * 2), dY, dRadius * 2, dRadius * 2, 270, 90);
|
||
oPath.AddLine(dX + dWidth, dY + dRadius, dX + dWidth, dY + dHeight - (dRadius * 2));
|
||
oPath.AddArc(dX + dWidth - (dRadius * 2), dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2,0,90);
|
||
oPath.AddLine(dX + dWidth - (dRadius * 2), dY + dHeight, dX + dRadius, dY + dHeight);
|
||
oPath.AddArc(dX, dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2, 90, 90);
|
||
oPath.AddLine(dX, dY + dHeight - (dRadius * 2), dX, dY + dRadius);
|
||
oPath.AddArc(dX, dY, dRadius * 2, dRadius * 2, 180, 90);
|
||
oPath.CloseFigure();
|
||
|
||
Gdiplus::PathGradientBrush *oBrush = new Gdiplus::PathGradientBrush(&oPath);
|
||
oBrush->SetCenterPoint(Gdiplus::PointF(dX + dWidth / 2, dY + dHeight / 2));
|
||
oBrush->SetCenterColor(Color(nBkColor, nBkColor, nBkColor));
|
||
Color *oColor = new Color( nBkColor, nBkColor, nBkColor);
|
||
int nColorCount = 1;
|
||
oBrush->SetSurroundColors(oColor, &nColorCount);
|
||
|
||
oRender.FillPath(oBrush, &oPath);
|
||
|
||
Gdiplus::Pen *oPen = new Gdiplus::Pen(Color( nBlendColor, nBlendColor, nBlendColor), 1);
|
||
oRender.DrawArc( oPen, dX + dWidth - (dRadius * 2), dY, dRadius * 2, dRadius * 2, 315, 45);
|
||
oRender.DrawLine( oPen, dX + dWidth, dY + dRadius - 1, dX + dWidth, dY + dHeight - dRadius + 1);
|
||
oRender.DrawArc( oPen, dX + dWidth - (dRadius * 2), dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2,0,90);
|
||
oRender.DrawLine( oPen, dX + dWidth - dRadius + 1, dY + dHeight, dX + dRadius - 1, dY + dHeight);
|
||
oRender.DrawArc( oPen, dX, dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2, 90, 45);
|
||
|
||
delete oColor;
|
||
delete oPen;
|
||
delete oBrush;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL DrawFilmsBorder(BYTE* pBGRA, int nWidth, int nHeight, int nFilmColorMid, int nFilmColorBorder, float dBorderWidth, float dBorderHeight, BOOL bVertical)
|
||
{
|
||
BYTE* pBuffer = pBGRA;
|
||
pBuffer += 4 * nWidth * (nHeight - 1);
|
||
|
||
Gdiplus::Bitmap oImage( nWidth, nHeight, -4*nWidth, PixelFormat32bppARGB, pBuffer );
|
||
if( Gdiplus::Ok == oImage.GetLastStatus() )
|
||
{
|
||
Gdiplus::Graphics oRender( &oImage );
|
||
|
||
oRender.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
|
||
oRender.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
|
||
oRender.SetInterpolationMode(Gdiplus::InterpolationModeBilinear);
|
||
|
||
Gdiplus::Color clMid(nFilmColorMid, nFilmColorMid, nFilmColorMid);
|
||
Gdiplus::Color clBorder(nFilmColorBorder, nFilmColorBorder, nFilmColorBorder);
|
||
|
||
if ( bVertical )
|
||
{
|
||
Gdiplus::SolidBrush *oSolidBrush = new Gdiplus::SolidBrush(clMid);
|
||
oRender.FillRectangle(oSolidBrush, -1.0, -1.0, float(nWidth + 1.0), float(nHeight + 1.0));
|
||
|
||
Gdiplus::LinearGradientBrush* oGradBrush1 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( -1.0, -1.0), Gdiplus::PointF( dBorderWidth + 1, -1.0), clBorder, clMid);
|
||
oRender.FillRectangle(oGradBrush1, -1.0, -1.0, dBorderWidth + 1, float(nHeight) + 1);
|
||
|
||
Gdiplus::LinearGradientBrush* oGradBrush2 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( nWidth + 1, -1.0), Gdiplus::PointF( nWidth - dBorderWidth -2.0, -1.0), clBorder, clMid);
|
||
oRender.FillRectangle(oGradBrush2, nWidth - dBorderWidth - 1, -1.0, dBorderWidth + 1, float(nHeight) + 1);
|
||
|
||
delete oGradBrush1;
|
||
delete oGradBrush2;
|
||
delete oSolidBrush;
|
||
}
|
||
else
|
||
{
|
||
Gdiplus::SolidBrush *oSolidBrush = new Gdiplus::SolidBrush(clMid);
|
||
oRender.FillRectangle(oSolidBrush, -1.0, -1.0, float(nWidth + 1.0), float(nHeight + 1.0));
|
||
|
||
Gdiplus::LinearGradientBrush* oGradBrush1 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( -1.0, -1.0), Gdiplus::PointF( -1.0, dBorderHeight + 1), clBorder, clMid);
|
||
oRender.FillRectangle(oGradBrush1, -1.0, -1.0, float(nWidth) + 2.0, dBorderHeight + 1);
|
||
|
||
Gdiplus::LinearGradientBrush* oGradBrush2 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( -1.0, float(nHeight) + 1.0), Gdiplus::PointF( -1.0, nHeight - dBorderHeight - 1.0), clBorder, clMid);
|
||
oRender.FillRectangle(oGradBrush2, float(-1.0), float(nHeight - dBorderHeight - 1.0), float(nWidth + 2.0), float(dBorderHeight + 2.0));
|
||
|
||
delete oGradBrush1;
|
||
delete oGradBrush2;
|
||
delete oSolidBrush;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
public:
|
||
|
||
Utility()
|
||
{
|
||
g_fSin = 0;
|
||
g_fCos = 0;
|
||
|
||
g_sBurningPalette = 0;
|
||
g_pBurningMask = 0;
|
||
|
||
g_nBurningMaskWidth = -1;
|
||
g_nBurningMaskHeight = -1;
|
||
|
||
g_nRand = -1;
|
||
|
||
InitSinCos();
|
||
InitBurningPalette();
|
||
|
||
g_pShotSource1 = 0;
|
||
g_pShotSource2 = 0;
|
||
g_nShotType = -1;
|
||
|
||
//g_pMask = 0;
|
||
//g_nMaskType = -1;
|
||
//g_nMaskWidth = -1;
|
||
//g_nMaskHeight = -1;
|
||
|
||
g_ppWipeRandomStrips = 0;
|
||
g_nWipeStripsCount = -1;
|
||
|
||
}
|
||
|
||
~Utility()
|
||
{
|
||
if (g_fSin)
|
||
delete[] g_fSin;
|
||
if (g_fCos)
|
||
delete[] g_fCos;
|
||
if (g_sBurningPalette)
|
||
delete[] g_sBurningPalette;
|
||
if (g_pBurningMask)
|
||
delete[] g_pBurningMask;
|
||
if (g_pShotSource1)
|
||
delete[] g_pShotSource1;
|
||
if (g_pShotSource2)
|
||
delete[] g_pShotSource2;
|
||
for(int nIndex = 0; nIndex < g_nWipeStripsCount; nIndex++ )
|
||
{
|
||
if(g_ppWipeRandomStrips[nIndex])
|
||
delete[] g_ppWipeRandomStrips[nIndex];
|
||
}
|
||
if (g_ppWipeRandomStrips)
|
||
delete[] g_ppWipeRandomStrips;
|
||
}
|
||
void InitSinCos()
|
||
{
|
||
if (!g_fSin)
|
||
g_fSin = new float[720];
|
||
if (!g_fCos)
|
||
g_fCos = new float[720];
|
||
|
||
for (int i = 0; i < 720; i++)
|
||
{
|
||
g_fCos[i] = (float)cos(M_PI*i/360);
|
||
g_fSin[i] = (float)sin(M_PI*i/360);
|
||
}
|
||
|
||
g_fSin[0] = 0.000001f;
|
||
g_fSin[360] = 0.000001f;
|
||
}
|
||
void InitBurningPalette()
|
||
{
|
||
if (!g_sBurningPalette)
|
||
g_sBurningPalette = new Ipp32s[768];
|
||
|
||
int r,g,b;
|
||
r = 256+256+255;
|
||
g = 256+255;
|
||
b = 255;
|
||
for(int i = 255; i > 239; i--)
|
||
{
|
||
g_sBurningPalette[i] = 255;
|
||
g_sBurningPalette[i+256] = 255;
|
||
g_sBurningPalette[i+512] = 255;
|
||
}
|
||
for(int i = 239; i > 15; i--)
|
||
{
|
||
g_sBurningPalette[i] = (r > 255) ? 255 : r;
|
||
g_sBurningPalette[i+256] = (g > 255) ? 255 : g;
|
||
g_sBurningPalette[i+512] = (b > 255) ? 255 : b;
|
||
r = (r > 3) ? (r - 4) : 0;
|
||
g = (g > 3) ? (g - 4) : 0;
|
||
b = (b > 3) ? (b - 4) : 0;
|
||
}
|
||
for(int i = 15; i >= 0; i--)
|
||
{
|
||
g_sBurningPalette[i] = 0;
|
||
g_sBurningPalette[i+256] = 0;
|
||
g_sBurningPalette[i+512] = 0;
|
||
}
|
||
}
|
||
void GenerateBurningMask(int nWidth, int nHeight)
|
||
{
|
||
if ((nWidth == g_nBurningMaskWidth) && (nHeight == g_nBurningMaskHeight) && (g_pBurningMask))
|
||
return;
|
||
|
||
if (g_pBurningMask)
|
||
delete []g_pBurningMask;
|
||
|
||
if (0 == nWidth*nHeight)
|
||
return;
|
||
|
||
srand(GetTickCount());
|
||
g_nBurningMaskWidth = nWidth;
|
||
g_nBurningMaskHeight = nHeight;
|
||
g_pBurningMask = new BYTE[nWidth*nHeight];
|
||
Ipp16s *pBuffer = new Ipp16s[nWidth*nHeight];
|
||
IppiSize roiSize = {nWidth,nHeight};
|
||
memset(g_pBurningMask,0,nWidth*nHeight);
|
||
memset(pBuffer,0,nWidth*nHeight*sizeof(Ipp16s));
|
||
|
||
float fH = 512.0f;
|
||
float fR = (float)nWidth;
|
||
int k = 0;
|
||
for (k=2;k<5;k++)
|
||
{
|
||
fH /= 2;
|
||
fR /= 3;
|
||
int nSign = 1;
|
||
if (0==rand()%2)
|
||
nSign = -1;
|
||
for(int p=0;p<20*k;p++)
|
||
{
|
||
int nCenterX = rand()%nWidth;
|
||
int nCenterY = rand()%nHeight;
|
||
for (int i=0;i<nWidth;i++)
|
||
{
|
||
for (int j=0;j<nHeight;j++)
|
||
{
|
||
float fTemp = (float)sqrt((double)(i-nCenterX)*(i-nCenterX)+(j-nCenterY)*(j-nCenterY));
|
||
if (fTemp<fR)
|
||
{
|
||
pBuffer[i + j*g_nBurningMaskWidth] += fH*nSign*(1.0-fTemp/fR)*(1.0-fTemp/fR);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fH = 2;
|
||
fR /= 3;
|
||
int nSign = 1;
|
||
if (0==rand()%2)
|
||
nSign = -1;
|
||
for(int p=0;p<20*k;p++)
|
||
{
|
||
int nCenterX = rand()%nWidth;
|
||
int nCenterY = rand()%nHeight;
|
||
for (int i=0;i<nWidth;i++)
|
||
{
|
||
for (int j=0;j<nHeight;j++)
|
||
{
|
||
float fTemp = (float)sqrt((double)(i-nCenterX)*(i-nCenterX)+(j-nCenterY)*(j-nCenterY));
|
||
if (fTemp<fR)
|
||
{
|
||
pBuffer[i + j*g_nBurningMaskWidth] += fH*nSign*(1.0-fTemp/fR)*(1.0-fTemp/fR);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Ipp16s nMin, nMax;
|
||
ippiMin_16s_C1R(pBuffer, 2*nWidth, roiSize, &nMin);
|
||
ippiMax_16s_C1R(pBuffer, 2*nWidth, roiSize, &nMax);
|
||
nMax = max(nMax,nMin+1);
|
||
for (int i=0;i<nWidth;i++)
|
||
{
|
||
for (int j=0;j<nHeight;j++)
|
||
{
|
||
pBuffer[i + j*g_nBurningMaskWidth] -= nMin;
|
||
g_pBurningMask[i + j*g_nBurningMaskWidth] = 255.0f/(float)(nMax-nMin)*(pBuffer[i + j*g_nBurningMaskWidth]);
|
||
}
|
||
}
|
||
|
||
delete []pBuffer;
|
||
}
|
||
void GenerateRand(int nRandMax)
|
||
{
|
||
if (-1 != g_nRand)
|
||
return;
|
||
g_nRand = 0;
|
||
::srand(::GetTickCount());
|
||
g_nRand = rand()% ( nRandMax + 1 );
|
||
}
|
||
BOOL RunTetris(CTetrisFigure *pList, int nFiguresCount, float dFrame, BYTE *pBGRAResult, int nWidth, int nHeight, int nStep, int *pnBottomLineFigures)
|
||
{
|
||
if(!pList)
|
||
return FALSE;
|
||
BYTE* pr = pBGRAResult;
|
||
int nSt = nStep;
|
||
if(dFrame < 1./nFiguresCount)
|
||
pList->Cpy(pr, pList->m_nXCoorSource, nHeight - *pnBottomLineFigures + pList->m_nYCoorSource, nWidth, nHeight, 1);
|
||
else
|
||
{
|
||
nSt++;
|
||
if(nSt == nFiguresCount - 1)
|
||
for(int i = 0; i < nFiguresCount - 1; i++)
|
||
(pList+i)->Cpy(pr, (pList+i)->m_nXCoorSource, (pList+i)->m_nYCoorSource, nWidth, nHeight, 1 - (dFrame - (nFiguresCount - 1.)/nFiguresCount)*nFiguresCount);
|
||
else
|
||
{
|
||
(pList+nSt - 1)->Cpy(pr, (pList+nSt - 1)->m_nXCoorSource, (pList+nSt - 1)->m_nYCoorSource, nWidth, nHeight, 1);
|
||
if(dFrame < (nSt + 1.)/nFiguresCount)
|
||
(pList+nSt)->Cpy(pr, (pList+nSt)->m_nXCoorSource, nHeight - *(pnBottomLineFigures + nSt) + (pList+nSt)->m_nYCoorSource, nWidth, nHeight, 1);
|
||
else
|
||
if(!RunTetris(pList, nFiguresCount, dFrame, pr, nWidth, nHeight, nSt, pnBottomLineFigures))
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
BOOL CollapseTetris(CTetrisFigure *pList, int nFiguresCount, float dFrame, BYTE *pBGRAResult, int nWidth, int nHeight, int nStep, int *pnBottomLineFigures)
|
||
{
|
||
if(!pList)
|
||
return FALSE;
|
||
BYTE* pr = pBGRAResult;
|
||
int nSt = nStep;
|
||
if(dFrame < 1./nFiguresCount)
|
||
for(int i = 0; i < nFiguresCount - 1; i++)
|
||
(pList + i)->Cpy(pr, (pList + i)->m_nXCoorSource, (pList + i)->m_nYCoorSource, nWidth, nHeight, dFrame*nFiguresCount);
|
||
else
|
||
{
|
||
nSt++;
|
||
if(nSt > nFiguresCount)
|
||
return TRUE;
|
||
else if(dFrame < (nSt + 1.)/nFiguresCount)
|
||
{
|
||
(pList + nSt - 1)->Cpy(pr, (pList + nSt - 1)->m_nXCoorSource, (pList + nSt - 1)->m_nYCoorSource*(1-(dFrame*nFiguresCount - nSt)) + (-(pList + nSt - 1)->m_nFigHeight)*(dFrame*nFiguresCount - nSt), nWidth, nHeight, 1);
|
||
for(int i = nSt; i < nFiguresCount - 1; i++)
|
||
(pList+i)->Cpy(pr, (pList+i)->m_nXCoorSource, (pList+i)->m_nYCoorSource, nWidth, nHeight, 1);
|
||
}
|
||
else
|
||
{
|
||
if(!CollapseTetris(pList, nFiguresCount, dFrame, pr, nWidth, nHeight, nSt, pnBottomLineFigures))
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void GenerateShot(int nWidth, int nHeight, int nType, double dPercent, BYTE nBkColor, BYTE nFilmColorMid, BYTE nFilmColorBorder, BYTE nBlendColor)
|
||
{
|
||
//if(g_pShotSource1 && g_pShotSource2 && nType == g_nShotType)
|
||
// return;
|
||
|
||
if(g_pShotSource1)
|
||
delete[] g_pShotSource1;
|
||
if(g_pShotSource2)
|
||
delete[] g_pShotSource2;
|
||
|
||
BOOL bInverse;
|
||
BOOL bRapprochement;
|
||
int nDirection;
|
||
|
||
if (c_nShotChangeGHorizontalRToL == nType || c_nShotChangeBHorizontalRToL == nType)
|
||
{
|
||
bInverse = TRUE;
|
||
bRapprochement = TRUE;
|
||
nDirection = 0;
|
||
}
|
||
else if(c_nShotChangeGHorizontalLToR == nType || c_nShotChangeBHorizontalLToR == nType )
|
||
{
|
||
bInverse = FALSE;
|
||
bRapprochement = TRUE;
|
||
nDirection = 0;
|
||
}
|
||
else if(c_nShotChangeGVerticalUToB == nType || c_nShotChangeBVerticalUToB == nType )
|
||
{
|
||
bInverse = FALSE;
|
||
bRapprochement = TRUE;
|
||
nDirection = 1;
|
||
}
|
||
else if(c_nShotChangeGVerticalBToU == nType || c_nShotChangeBVerticalBToU == nType )
|
||
{
|
||
bInverse = TRUE;
|
||
bRapprochement = TRUE;
|
||
nDirection = 1;
|
||
}
|
||
else if(c_nShotChangeGHorizontalRToLNoZ == nType || c_nShotChangeBHorizontalRToLNoZ == nType )
|
||
{
|
||
bInverse = TRUE;
|
||
bRapprochement = FALSE;
|
||
nDirection = 0;
|
||
}
|
||
else if(c_nShotChangeGHorizontalLToRNoZ == nType || c_nShotChangeBHorizontalLToRNoZ == nType )
|
||
{
|
||
bInverse = FALSE;
|
||
bRapprochement = FALSE;
|
||
nDirection = 0;
|
||
}
|
||
else if(c_nShotChangeGVerticalUToBNoZ == nType || c_nShotChangeBVerticalUToBNoZ == nType )
|
||
{
|
||
bInverse = FALSE;
|
||
bRapprochement = FALSE;
|
||
nDirection = 1;
|
||
}
|
||
else if(c_nShotChangeGVerticalBToUNoZ == nType || c_nShotChangeBVerticalBToUNoZ == nType )
|
||
{
|
||
bInverse = TRUE;
|
||
bRapprochement = FALSE;
|
||
nDirection = 1;
|
||
}
|
||
|
||
g_pShotSource1 = new BYTE[nWidth*nHeight*4];
|
||
g_pShotSource2 = new BYTE[nWidth*nHeight*4];
|
||
|
||
g_nShotType = nType;
|
||
|
||
//BOOL bVertical = (1 == nDirection? TRUE : FALSE);
|
||
|
||
//if( 1 == nDirection )
|
||
//{
|
||
// double dUnit = nWidth / 35.;
|
||
// const double dWidthPerf = 2.8 * dUnit;
|
||
// const double dHeightPerf = 1.98 * dUnit;
|
||
// const double dRadiusPerf = 0.5 * dUnit;
|
||
// const double dStepPerf = (4.75 * dUnit < 10? 10 : 4.75 * dUnit);
|
||
// const double dBorderWidth = 1.01 * dUnit;
|
||
// const double dMidLineWidth = 0.4 * dUnit;
|
||
// const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
|
||
//
|
||
// double dStartY1 = 0;
|
||
// double dStartY2 = 0;
|
||
|
||
// double dAdditional = nHeight;
|
||
// if ( bRapprochement )
|
||
// dAdditional += -nHeight * dPercent / 2;
|
||
|
||
// if ( !bInverse )
|
||
// dStartY2 = dAdditional;
|
||
// else
|
||
// dStartY1 = dAdditional;
|
||
|
||
// const double dFullBorderWidth = dBorderWidth + dWidthPerf + dMidLineWidth;
|
||
|
||
// DrawFilmsBorder(g_pShotSource1, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, dFullBorderWidth, 0.1 * dFullBorderWidth, bVertical);
|
||
// DrawFilmsBorder(g_pShotSource2, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, dFullBorderWidth, 0.1 * dFullBorderWidth, bVertical);
|
||
|
||
// for ( double dCurY = - 2 * nHeight - dStartY1; dCurY < nHeight + dStepPerf; dCurY += dStepPerf)
|
||
// {
|
||
// DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, dBorderWidth, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
|
||
// DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, nWidth - dBorderWidth - dWidthPerf, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
|
||
// }
|
||
// for ( double dCurY = - 2 * nHeight - dStartY2; dCurY < nHeight + dStepPerf; dCurY += dStepPerf)
|
||
// {
|
||
// DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, dBorderWidth, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
|
||
// DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, nWidth - dBorderWidth - dWidthPerf, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
|
||
// }
|
||
//
|
||
//}
|
||
//else
|
||
//{
|
||
// double dUnit = nHeight / 35.;
|
||
// const double dWidthPerf = 2.8 * dUnit;
|
||
// const double dHeightPerf = 1.98 * dUnit;
|
||
// const double dRadiusPerf = 0.5 * dUnit;
|
||
// const double dStepPerf = (4.75 * dUnit < 10? 10 : 4.75 * dUnit);
|
||
// const double dBorderWidth = 1.01 * dUnit;
|
||
// const double dMidLineWidth = 0.4 * dUnit;
|
||
// const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
|
||
|
||
// double dStartX1 = 0;
|
||
// double dStartX2 = 0;
|
||
|
||
// double dAdditional = nWidth;
|
||
// if ( bRapprochement )
|
||
// dAdditional += -nWidth * dPercent / 2;
|
||
|
||
// if ( !bInverse )
|
||
// dStartX2 = dAdditional;
|
||
// else
|
||
// dStartX1 = dAdditional;
|
||
|
||
// const double dFullBorderWidth = dBorderWidth + dWidthPerf + dMidLineWidth;
|
||
|
||
// DrawFilmsBorder(g_pShotSource1, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, 0.1 * dFullBorderWidth, dFullBorderWidth, bVertical);
|
||
// DrawFilmsBorder(g_pShotSource2, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, 0.1 * dFullBorderWidth, dFullBorderWidth, bVertical);
|
||
|
||
// for ( double dCurX = - 2*nWidth - dStartX1; dCurX < nWidth + dStepPerf; dCurX += dStepPerf)
|
||
// {
|
||
// DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, dCurX, dBorderWidth, dHeightPerf, dWidthPerf, dRadiusPerf);
|
||
// DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, dCurX, nHeight - dBorderWidth - dWidthPerf, dHeightPerf, dWidthPerf, dRadiusPerf);
|
||
// }
|
||
// for ( double dCurX = - 2*nWidth - dStartX2; dCurX < nWidth + dStepPerf; dCurX += dStepPerf)
|
||
// {
|
||
// DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, dCurX, dBorderWidth, dHeightPerf, dWidthPerf, dRadiusPerf);
|
||
// DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, dCurX, nHeight - dBorderWidth - dWidthPerf, dHeightPerf, dWidthPerf, dRadiusPerf);
|
||
// }
|
||
//}
|
||
//return;
|
||
if( 1 == nDirection)
|
||
{
|
||
|
||
const double dUnit = nWidth / 35.;
|
||
const double dWidthPerf = 2.8 * dUnit;
|
||
const double dHeightPerf = 1.98 * dUnit;
|
||
const double dRadiusPerf = 0.5 * dUnit;
|
||
const double dStepPerf = 4.75 * dUnit;
|
||
const double dBorderWidth = 1.01 * dUnit;
|
||
const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
|
||
|
||
BYTE *pBuffer = g_pShotSource1;
|
||
|
||
for (int nIndex = 0; nIndex < 2; nIndex++ )
|
||
{
|
||
if ( 0 == nIndex )
|
||
pBuffer = g_pShotSource1;
|
||
else
|
||
pBuffer = g_pShotSource2;
|
||
|
||
for(int nYIndex = 0; nYIndex < nHeight; nYIndex++)
|
||
{
|
||
int nAdditional = nHeight;
|
||
if ( bRapprochement )
|
||
{
|
||
nAdditional += - nHeight * dPercent / 2;
|
||
}
|
||
int nYIndexS1 = nYIndex;
|
||
int nYIndexS2 = nYIndex + nAdditional;
|
||
if(!bInverse)
|
||
{
|
||
nYIndexS1 += nAdditional;
|
||
nYIndexS2 -= nAdditional;
|
||
}
|
||
int nIndexS;
|
||
if ( 0 == nIndex )
|
||
nIndexS = nYIndexS1;
|
||
else
|
||
nIndexS = nYIndexS2;
|
||
|
||
for(int nXIndex = 0; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
const int nYStepCount = nIndexS % int(dStepPerf); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD> = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
|
||
const int nFirstFocus = dBorderWidth + dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
const int nSecondFocus = dBorderWidth + dWidthPerf - dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
const int nFullBorderWidth = dBorderWidth + dWidthPerf; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>)
|
||
const double dSqrRadiusPerf = dRadiusPerf * dRadiusPerf;
|
||
const double dSqrDecRadiusPerf = (dRadiusPerf - 1) * (dRadiusPerf - 1);
|
||
const double dSqrIncRadiusPerf = (dRadiusPerf + 1) * (dRadiusPerf + 1);
|
||
|
||
|
||
if( nXIndex <= dBorderWidth || nXIndex > nWidth - dBorderWidth ||
|
||
((( nXIndex > dBorderWidth && nXIndex <= nFullBorderWidth) || ( nXIndex >= nWidth - nFullBorderWidth && nXIndex < nWidth - dBorderWidth)) && nYStepCount > int(dHeightPerf) ) ||
|
||
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>*/ /*<2A><><EFBFBD><EFBFBD><EFBFBD>*/
|
||
(nXIndex <= nFirstFocus && (nYStepCount) <= dRadiusFactor && (nXIndex - nFirstFocus) * (nXIndex - nFirstFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nXIndex <= nFirstFocus && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - nFirstFocus) * (nXIndex - nFirstFocus) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nXIndex >= nSecondFocus && nXIndex <= nFullBorderWidth && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - nSecondFocus) * (nXIndex - nSecondFocus) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nXIndex >= nSecondFocus && nXIndex <= nFullBorderWidth && (nYStepCount) <= dRadiusFactor && (nXIndex - nSecondFocus) * (nXIndex - nSecondFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
|
||
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
|
||
(nXIndex <= nWidth - nSecondFocus && nXIndex >= nWidth - nFullBorderWidth && (nYStepCount) <= dRadiusFactor && (nXIndex - (nWidth - nSecondFocus)) * (nXIndex - (nWidth - nSecondFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nXIndex <= nWidth - nSecondFocus && nXIndex >= nWidth - nFullBorderWidth && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - (nWidth - nSecondFocus)) * (nXIndex - (nWidth - nSecondFocus)) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nXIndex >= nWidth - nFirstFocus && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - (nWidth - nFirstFocus)) * (nXIndex - (nWidth - nFirstFocus)) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nXIndex >= nWidth - nFirstFocus && (nYStepCount) <= dRadiusFactor && (nXIndex - (nWidth - nFirstFocus)) * (nXIndex - (nWidth - nFirstFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf))
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
if(nXIndex <= nFullBorderWidth)
|
||
{
|
||
*pBuffer = nFilmColorBorder * (1 - double(nXIndex) / double (nFullBorderWidth) ) + nFilmColorMid * (double(nXIndex) / double (nFullBorderWidth));
|
||
}
|
||
else
|
||
{
|
||
*pBuffer = nFilmColorBorder * double(nXIndex - (nWidth - nFullBorderWidth))/double(nFullBorderWidth) + nFilmColorMid * (1 - double(nXIndex - (nWidth - nFullBorderWidth))/double(nFullBorderWidth));
|
||
}
|
||
pBuffer++;
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
else if( nXIndex > nFullBorderWidth && nXIndex < nWidth - nFullBorderWidth)
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
*pBuffer = nFilmColorMid;
|
||
pBuffer++;
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
else
|
||
{
|
||
const double dLeftFirstSqrRad = ( nXIndex - nFirstFocus) * ( nXIndex - nFirstFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
|
||
const double dLeftSecondSqrRad = ( nXIndex - nSecondFocus) * ( nXIndex - nSecondFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
|
||
const double dRightFirstSqrRad = ( nXIndex - ( nWidth - nSecondFocus)) * ( nXIndex - ( nWidth - nSecondFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
|
||
const double dRightSecondSqrRad = ( nXIndex - ( nWidth - nFirstFocus)) * ( nXIndex - ( nWidth - nFirstFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
|
||
|
||
if //<2F><><EFBFBD><EFBFBD><EFBFBD>
|
||
( nXIndex >= dBorderWidth &&
|
||
(( nYStepCount == 0 && nXIndex <= nSecondFocus && nXIndex >= nFirstFocus)
|
||
||
|
||
( dLeftFirstSqrRad > dSqrDecRadiusPerf && dLeftFirstSqrRad < dSqrIncRadiusPerf
|
||
&& nXIndex <= nFirstFocus && nYStepCount <= dRadiusFactor)
|
||
||
|
||
( dLeftSecondSqrRad > dSqrDecRadiusPerf && dLeftSecondSqrRad < dSqrIncRadiusPerf
|
||
&& nXIndex >= nSecondFocus && nXIndex <= nFullBorderWidth && nYStepCount <= dRadiusFactor)
|
||
||
|
||
(nXIndex > nFullBorderWidth - 1 && nXIndex < nFullBorderWidth + 1 )) ||
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
nXIndex <= nWidth - dBorderWidth &&
|
||
(( nYStepCount == 0 && nXIndex >= nWidth - nSecondFocus && nXIndex <= nWidth - nFirstFocus )
|
||
||
|
||
( dRightFirstSqrRad > dSqrDecRadiusPerf && dRightFirstSqrRad < dSqrIncRadiusPerf
|
||
&& nXIndex >= nWidth - nFullBorderWidth && nXIndex <= nWidth - nSecondFocus && nYStepCount <= dRadiusFactor)
|
||
||
|
||
( dRightSecondSqrRad > dSqrDecRadiusPerf && dRightSecondSqrRad < dSqrIncRadiusPerf
|
||
&& nXIndex >= nWidth - nFirstFocus && nYStepCount <= dRadiusFactor)
|
||
||
|
||
(nXIndex > nWidth - dBorderWidth - 1 && nXIndex < nWidth - dBorderWidth + 1 ))
|
||
)
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
*pBuffer = nBlendColor;
|
||
*pBuffer++;
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
else
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
*pBuffer = nBkColor;
|
||
*pBuffer++;
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
const double dUnit = nHeight / 35.;
|
||
const double dWidthPerf = 2.8 * dUnit;
|
||
const double dHeightPerf = 1.98 * dUnit;
|
||
const double dRadiusPerf = 0.5 * dUnit;
|
||
const double dStepPerf = 4.75 * dUnit;
|
||
const double dBorderWidth = 1. * dUnit;
|
||
const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
|
||
|
||
BYTE *pBuffer = g_pShotSource1;
|
||
|
||
for (int nIndex = 0; nIndex < 2; nIndex++ )
|
||
{
|
||
if ( 0 == nIndex )
|
||
pBuffer = g_pShotSource1;
|
||
else
|
||
pBuffer = g_pShotSource2;
|
||
|
||
for(int nYIndex = 0; nYIndex < nHeight; nYIndex++)
|
||
{
|
||
for(int nXIndex = 0; nXIndex < nWidth; nXIndex++)
|
||
{
|
||
int nAdditional = nWidth;
|
||
if ( bRapprochement )
|
||
{
|
||
nAdditional -= nWidth * dPercent / 2;
|
||
}
|
||
int nXIndexS2 = nXIndex;
|
||
int nXIndexS1 = nXIndex + nAdditional;
|
||
if(!bInverse)
|
||
{
|
||
nXIndexS2 += nAdditional;
|
||
nXIndexS1 -= nAdditional;
|
||
}
|
||
int nIndexS = 0;
|
||
if ( 0 == nIndex)
|
||
nIndexS = nXIndexS1;
|
||
else
|
||
nIndexS = nXIndexS2;
|
||
|
||
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
const int nXStepCount = nIndexS % int(dStepPerf); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD> = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
|
||
const int nFirstFocus = dBorderWidth + dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
const int nSecondFocus = dBorderWidth + dWidthPerf - dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
const int nFullBorderWidth = dBorderWidth + dWidthPerf; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>)
|
||
const double dSqrRadiusPerf = dRadiusPerf * dRadiusPerf;
|
||
const double dSqrDecRadiusPerf = (dRadiusPerf - 1) * (dRadiusPerf - 1);
|
||
const double dSqrIncRadiusPerf = (dRadiusPerf + 1) * (dRadiusPerf + 1);
|
||
|
||
|
||
if( nYIndex <= dBorderWidth || nYIndex >= nHeight - dBorderWidth ||
|
||
((( nYIndex > dBorderWidth && nYIndex <= nFullBorderWidth) || ( nYIndex >= nHeight - nFullBorderWidth && nYIndex < nHeight - dBorderWidth)) && nXStepCount > int(dHeightPerf) ) ||
|
||
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>*/ /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
|
||
(nYIndex <= nFirstFocus && nXStepCount <= dRadiusFactor && (nYIndex - nFirstFocus) * (nYIndex - nFirstFocus) + (nXStepCount - dRadiusFactor) * (nXStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nYIndex <= nFirstFocus && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - nFirstFocus) * (nYIndex - nFirstFocus) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nYIndex >= nSecondFocus && nYIndex <= dBorderWidth + dWidthPerf && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - nSecondFocus) * (nYIndex - nSecondFocus) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nYIndex >= nSecondFocus && nYIndex <= dBorderWidth + dWidthPerf && nXStepCount <= dRadiusFactor && (nYIndex - nSecondFocus) * (nYIndex - nSecondFocus) + (nXStepCount - dRadiusFactor) * (nXStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
|
||
/*<2A><><EFBFBD><EFBFBD><EFBFBD>*/
|
||
(nYIndex <= nHeight - nSecondFocus && nYIndex >= nHeight - dBorderWidth - dWidthPerf && nXStepCount <= dRadiusFactor && (nYIndex - (nHeight - nSecondFocus)) * (nYIndex - (nHeight - nSecondFocus)) + (nXStepCount - dRadiusFactor) * (nXStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nYIndex <= nHeight - nSecondFocus && nYIndex >= nHeight - dBorderWidth - dWidthPerf && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - (nHeight - nSecondFocus)) * (nYIndex - (nHeight - nSecondFocus)) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
|
||
(nYIndex >= nHeight - nFirstFocus && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - (nHeight - nFirstFocus)) * (nYIndex - (nHeight - nFirstFocus)) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf ) ||
|
||
(nYIndex >= nHeight - nFirstFocus && nXStepCount <= dRadiusFactor && (nYIndex - (nHeight - nFirstFocus)) * (nYIndex - (nHeight - nFirstFocus)) + (nXStepCount - dRadiusFactor) * (nXStepCount- dRadiusFactor) > dSqrRadiusPerf))
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
if( nYIndex <= nFullBorderWidth)
|
||
{
|
||
*pBuffer = nFilmColorBorder * (1 - nYIndex / (dBorderWidth + dWidthPerf)) + nFilmColorMid * (nYIndex / (dBorderWidth + dWidthPerf));
|
||
//double dKoef = double(nYIndex) / double(nFullBorderWidth);
|
||
//*pBuffer = nFilmColorBorder * (1 - dKoef ) + nFilmColorMid * dKoef;
|
||
}
|
||
else
|
||
{
|
||
*pBuffer = nFilmColorBorder * (nYIndex - (nHeight - (dBorderWidth + dWidthPerf))) / (dBorderWidth + dWidthPerf) + nFilmColorMid * (1 - (nYIndex - (nHeight - (dBorderWidth + dWidthPerf)))/ (dBorderWidth + dWidthPerf));
|
||
//double dKoef = double(nYIndex - (nHeight - nFullBorderWidth)) / double(nFullBorderWidth);
|
||
//*pBuffer = nFilmColorBorder * dKoef + nFilmColorMid * (1 - dKoef);
|
||
}
|
||
pBuffer++;
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
else if(nYIndex > nFullBorderWidth && nYIndex < nHeight - nFullBorderWidth)
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
*pBuffer = nFilmColorMid;
|
||
pBuffer++;
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
else
|
||
{
|
||
const double dTopFirstSqrRad = ( nYIndex - nFirstFocus) * ( nYIndex - nFirstFocus) + (nXStepCount - dHeightPerf + dRadiusFactor ) * ( nXStepCount - dHeightPerf + dRadiusFactor);
|
||
const double dTopSecondSqrRad = ( nYIndex - nFirstFocus) * ( nYIndex - nFirstFocus) + (nXStepCount - dRadiusFactor) * ( nXStepCount - dRadiusFactor);
|
||
const double dBottomFirstSqrRad = ( nYIndex - ( nHeight - nSecondFocus)) * ( nYIndex - ( nHeight - nSecondFocus)) + (nXStepCount - dHeightPerf + dRadiusFactor) * ( nXStepCount - dHeightPerf + dRadiusFactor);
|
||
const double dBottomSecondSqrRad = ( nYIndex - ( nHeight - nSecondFocus)) * ( nYIndex - ( nHeight - nSecondFocus)) + (nXStepCount - dRadiusFactor) * ( nXStepCount - dRadiusFactor);
|
||
|
||
if(
|
||
nYIndex >= dBorderWidth &&nYIndex <= nHeight - dBorderWidth &&
|
||
((( nXStepCount > dHeightPerf - 1 && nXStepCount < dHeightPerf + 1 && nYIndex > nFirstFocus - 10/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/)
|
||
||
|
||
( dTopFirstSqrRad > dSqrDecRadiusPerf && dTopFirstSqrRad < dSqrIncRadiusPerf
|
||
&& nYIndex < nFirstFocus && nXStepCount >= dHeightPerf - dRadiusFactor)
|
||
||
|
||
( dTopSecondSqrRad > dSqrDecRadiusPerf && dTopSecondSqrRad < dSqrIncRadiusPerf
|
||
&& nYIndex < nFirstFocus && nXStepCount <= dRadiusFactor)
|
||
||
|
||
(nYIndex < dBorderWidth + 1 && nYIndex > dBorderWidth - 1) )
|
||
||
|
||
(( nXStepCount > dHeightPerf - 1 && nXStepCount < dHeightPerf + 1 && nYIndex >= nHeight - nSecondFocus )
|
||
||
|
||
( dBottomFirstSqrRad > dSqrDecRadiusPerf && dBottomFirstSqrRad < dSqrIncRadiusPerf
|
||
&& nYIndex >= nHeight - nFullBorderWidth && nYIndex <= nHeight - nSecondFocus && nXStepCount >= dHeightPerf - dRadiusFactor) ||
|
||
( dBottomSecondSqrRad > dSqrDecRadiusPerf && dBottomSecondSqrRad < dSqrIncRadiusPerf
|
||
&& nYIndex >= nHeight - nFullBorderWidth && nYIndex <= nHeight - nSecondFocus && nXStepCount <= dRadiusFactor)
|
||
||
|
||
(nYIndex < nHeight - nFullBorderWidth + 1 && nYIndex > nHeight - nFullBorderWidth - 1 ) )))
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
*pBuffer = nBlendColor;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for(int i = 0; i < 3; i++)
|
||
{
|
||
*pBuffer = nBkColor;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
*pBuffer = 255;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
void GenerateWipeStrips(int nCount)
|
||
{
|
||
if ( g_ppWipeRandomStrips && g_nWipeStripsCount == nCount )
|
||
return;
|
||
|
||
if ( g_ppWipeRandomStrips )
|
||
{
|
||
for(int nIndex = 0; nIndex < g_nWipeStripsCount; nIndex++ )
|
||
{
|
||
if(g_ppWipeRandomStrips[nIndex])
|
||
delete[] g_ppWipeRandomStrips[nIndex];
|
||
}
|
||
|
||
if (g_ppWipeRandomStrips)
|
||
delete[] g_ppWipeRandomStrips;
|
||
}
|
||
g_nWipeStripsCount = nCount;
|
||
|
||
::srand(::GetTickCount());
|
||
g_ppWipeRandomStrips = new int*[nCount];
|
||
|
||
for( int nIndex = 0; nIndex < nCount; nIndex++ )
|
||
{
|
||
g_ppWipeRandomStrips[nIndex] = new int[256];
|
||
}
|
||
for(int nCountIndex = 0; nCountIndex < nCount; nCountIndex++ )
|
||
{
|
||
for(int nTime = 0; nTime < 256; nTime++)
|
||
{
|
||
g_ppWipeRandomStrips[nCountIndex][nTime] = rand() % 100;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
public:
|
||
|
||
float* g_fCos;
|
||
float* g_fSin;
|
||
|
||
int g_nBurningMaskWidth;
|
||
int g_nBurningMaskHeight;
|
||
|
||
Ipp32s* g_sBurningPalette;
|
||
Ipp8u* g_pBurningMask;
|
||
int g_nRand;
|
||
|
||
BYTE* g_pShotSource1;
|
||
BYTE* g_pShotSource2;
|
||
int g_nShotType;
|
||
|
||
int** g_ppWipeRandomStrips;
|
||
int g_nWipeStripsCount;
|
||
};
|
||
|
||
class MaskPinwheelCurved
|
||
{
|
||
public:
|
||
|
||
MaskPinwheelCurved()
|
||
{
|
||
g_nMaskWidth = -1;
|
||
g_nMaskHeight = -1;
|
||
g_nMaskType = -1;
|
||
|
||
g_pMask = 0;
|
||
}
|
||
~MaskPinwheelCurved()
|
||
{
|
||
if ( g_pMask )
|
||
delete []g_pMask;
|
||
}
|
||
|
||
void GenerateMask(int nWidth, int nHeight, int nType)
|
||
{
|
||
if ((nWidth == g_nMaskWidth) && (nHeight == g_nMaskHeight) && (g_pMask) && (nType == g_nMaskType))
|
||
return ;
|
||
|
||
if (g_pMask)
|
||
delete []g_pMask;
|
||
|
||
int nSize = nWidth * nHeight;
|
||
if( !nSize )
|
||
return;
|
||
|
||
g_nMaskType = nType;
|
||
g_nMaskWidth = nWidth;
|
||
g_nMaskHeight = nHeight;
|
||
|
||
g_pMask = new BYTE[nSize];
|
||
if( !g_pMask )
|
||
return;
|
||
|
||
|
||
ZeroMemory( g_pMask, nSize );
|
||
|
||
if ( c_nPinwheelCurvedSN5A <= nType && c_nPinwheelPropeller12Smooth >= nType )
|
||
PinwheelCurved();
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
protected:
|
||
|
||
void PinwheelCurved()
|
||
{
|
||
double dParts = 1;
|
||
double dAmplitFactor = 0.1;
|
||
double dPhaseFactor = 2.0;
|
||
|
||
switch( g_nMaskType )
|
||
{
|
||
case c_nPinwheelCurvedSN5A: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
|
||
case c_nPinwheelCurvedSN7A: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
|
||
case c_nPinwheelCurvedSN12A: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
|
||
case c_nPinwheelCurvedSW5A: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedSW7A: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedSW12A: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedLN5A: dParts = 5; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedLN7A: dParts = 7; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedLN12A: dParts = 12; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelPropeller4: dParts = 4; dAmplitFactor = 0.4; dPhaseFactor = 3.0; break;
|
||
case c_nPinwheelPropeller7: dParts = 7; dAmplitFactor = 0.4; dPhaseFactor = 3.0; break;
|
||
case c_nPinwheelPropeller12: dParts = 12; dAmplitFactor = 0.4; dPhaseFactor = 3.0; break;
|
||
|
||
case c_nPinwheelCurvedSN5ASmooth: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
|
||
case c_nPinwheelCurvedSN7ASmooth: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
|
||
case c_nPinwheelCurvedSN12ASmooth: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
|
||
case c_nPinwheelCurvedSW5ASmooth: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedSW7ASmooth: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedSW12ASmooth: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedLN5ASmooth: dParts = 5; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedLN7ASmooth: dParts = 7; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelCurvedLN12ASmooth: dParts = 12; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
|
||
case c_nPinwheelPropeller4Smooth: dParts = 4; dAmplitFactor = 0.4; dPhaseFactor = 3.0; break;
|
||
case c_nPinwheelPropeller7Smooth: dParts = 7; dAmplitFactor = 0.4; dPhaseFactor = 3.0; break;
|
||
case c_nPinwheelPropeller12Smooth: dParts = 12; dAmplitFactor = 0.4; dPhaseFactor = 3.0; break;
|
||
}
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int nSizeTable = int(g_nMaskWidth + g_nMaskHeight);
|
||
double* pTable = new double[(nSizeTable + 1)];
|
||
if( !pTable )
|
||
{
|
||
memset( g_pMask, 255, g_nMaskWidth * g_nMaskHeight );
|
||
return;
|
||
}
|
||
|
||
double dMaxRadius = (g_nMaskWidth * g_nMaskWidth + g_nMaskHeight * g_nMaskHeight) / 4.0;
|
||
double dFactor = dMaxRadius / nSizeTable;
|
||
|
||
double dAmplit = sqrt(dMaxRadius) * dAmplitFactor; // * 4;
|
||
if ( ( g_nMaskType >= c_nPinwheelPropeller4 && g_nMaskType <= c_nPinwheelPropeller12 ) ||
|
||
( g_nMaskType >= c_nPinwheelPropeller4Smooth && g_nMaskType <= c_nPinwheelPropeller12Smooth ))
|
||
dAmplit = dMaxRadius * dAmplitFactor;
|
||
double dPhase = IPP_2PI / g_nMaskWidth * dPhaseFactor;
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
pTable[0] = 0;
|
||
for( int i = 1; i <= nSizeTable; i++ )
|
||
{
|
||
double dr = sqrt(i * dFactor);
|
||
pTable[i] = sin( dr * dPhase ) * dAmplit / dr;
|
||
}
|
||
|
||
// <20><><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int nSizeHelp = max(g_nMaskWidth, g_nMaskHeight);
|
||
double* pHelp = new double[nSizeHelp * 2];
|
||
if( !pHelp )
|
||
{
|
||
delete [] pTable;
|
||
memset( g_pMask, 255, g_nMaskWidth * g_nMaskHeight );
|
||
return;
|
||
}
|
||
|
||
int nMinSize = nSizeHelp / 2;
|
||
int nMaxSize = nSizeHelp - nMinSize;
|
||
|
||
dFactor = nSizeTable / dMaxRadius;
|
||
|
||
double* pItem = pHelp;
|
||
for( int i = -nMinSize; i < nMaxSize; ++i, pItem += 2 )
|
||
{
|
||
pItem[0] = i;
|
||
pItem[1] = i * i * dFactor;
|
||
}
|
||
|
||
Ipp8u* pBuffer = g_pMask;
|
||
int nWidth = g_nMaskWidth;
|
||
int nHeight = g_nMaskHeight;
|
||
|
||
double* pItemY = pHelp + (nMinSize - nHeight / 2) * 2;
|
||
double* pItemX = pHelp + (nMinSize - nWidth / 2) * 2;
|
||
|
||
dParts *= 255 / IPP_2PI;
|
||
|
||
for( int nY = nHeight; nY > 0; --nY, pItemY += 2, pItemX -= nWidth * 2 )
|
||
{
|
||
for ( int nX = nWidth; nX > 0; --nX, pItemX += 2 )
|
||
{
|
||
double dot = pItemY[1] + pItemX[1];
|
||
|
||
int index = int(dot);
|
||
double dr = pTable[index];
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if( index < nSizeTable )
|
||
{
|
||
dot -= index;
|
||
dr += (pTable[index + 1] - dr) * dot;
|
||
}
|
||
|
||
double dPos = pItemX[0] - dr * pItemY[0];
|
||
double dRow = pItemY[0] + dr * pItemX[0];
|
||
|
||
double dAngle = atan2( dRow, dPos );
|
||
|
||
*pBuffer++ = int( dAngle * dParts /*+ 128*/);
|
||
}
|
||
}
|
||
|
||
//int nHalfWidth = -g_nMaskWidth / 2;
|
||
//int nHalfHeight = -g_nMaskHeight / 2;
|
||
//int nMaxWidth = g_nMaskWidth + nHalfWidth;
|
||
//int nMaxHeight = g_nMaskHeight + nHalfHeight;
|
||
|
||
//for ( int nY = nHalfHeight; nY < nMaxHeight; ++nY )
|
||
//{
|
||
// for ( int nX = nHalfWidth; nX < nMaxWidth; ++nX )
|
||
// {
|
||
// double dot = (nX * nX + nY * nY) * dFactor;
|
||
//
|
||
// int index = int(dot);
|
||
// double dr = pTable[index];
|
||
|
||
// // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
// if( index < nSizeTable )
|
||
// {
|
||
// dot -= index;
|
||
// dr += (pTable[index + 1] - dr) * dot;
|
||
// }
|
||
|
||
// double dPos = nX - dr * nY;
|
||
// double dRow = nY + dr * nX;
|
||
//
|
||
// double dAngle = atan2( dRow, dPos );
|
||
|
||
// *pBuffer++ = int( dAngle * dParts + 128);
|
||
// }
|
||
//}
|
||
|
||
delete [] pHelp;
|
||
delete [] pTable;
|
||
}
|
||
|
||
public:
|
||
|
||
int g_nMaskWidth;
|
||
int g_nMaskHeight;
|
||
|
||
Ipp8u* g_pMask;
|
||
int g_nMaskType;
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
class MaskGraduate
|
||
{
|
||
|
||
public:
|
||
|
||
MaskGraduate()
|
||
{
|
||
g_nMaskWidth = -1;
|
||
g_nMaskHeight = -1;
|
||
g_nMaskType = -1;
|
||
g_nTilesX = -1;
|
||
g_nTilesY = -1;
|
||
|
||
g_pMask = 0;
|
||
|
||
g_nSize = 0;
|
||
g_pGraduation = NULL;
|
||
}
|
||
|
||
~MaskGraduate()
|
||
{
|
||
if ( g_pMask )
|
||
delete []g_pMask;
|
||
|
||
if ( g_pGraduation )
|
||
delete []g_pGraduation;
|
||
}
|
||
|
||
void GenerateMask(int nWidth, int nHeight, int nType, BOOL bWipeSide)
|
||
{
|
||
if ((nWidth == g_nMaskWidth) && (nHeight == g_nMaskHeight) && (g_pMask) && (nType == g_nMaskType))
|
||
return ;
|
||
|
||
if (g_pMask)
|
||
delete []g_pMask;
|
||
|
||
int nSize = nWidth * nHeight;
|
||
if( !nSize )
|
||
return;
|
||
|
||
g_nMaskType = nType;
|
||
g_nMaskWidth = nWidth;
|
||
g_nMaskHeight = nHeight;
|
||
|
||
if ( c_nGraduateSideLeftToRight <= nType && c_nGraduateCornerRightTop >= nType && bWipeSide)
|
||
{
|
||
g_nTilesX = 5;
|
||
g_nTilesY = 5;
|
||
}
|
||
else if ( c_nGraduateClockBottomClockwise <= nType && c_nGraduateClock3AnglesReverse >= nType && !bWipeSide)
|
||
{
|
||
g_nTilesX = 2;
|
||
g_nTilesY = 2;
|
||
}
|
||
g_nTileWidth = nWidth / g_nTilesX + 2;
|
||
g_nTileHeight = nHeight / g_nTilesY + 2;
|
||
|
||
g_pMask = new BYTE[nSize];
|
||
if( !g_pMask )
|
||
return;
|
||
|
||
ZeroMemory( g_pMask, nSize );
|
||
RandomShuffle(g_nTilesX * g_nTilesY);
|
||
|
||
if ( c_nGraduateSideLeftToRight <= nType && c_nGraduateCornerRightTop >= nType && bWipeSide)
|
||
WipeSide();
|
||
else if ( c_nGraduateClockBottomClockwise <= nType && c_nGraduateClock3AnglesReverse >= nType && !bWipeSide)
|
||
Clock();
|
||
return;
|
||
}
|
||
|
||
|
||
protected:
|
||
|
||
void WipeSide()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nCurTileX = nXIndex / g_nTileWidth;
|
||
int nCurTileY = nYIndex / g_nTileHeight;
|
||
|
||
int nCTX = nCurTileX;
|
||
int nCTY = nCurTileY;
|
||
|
||
nCurTileX = g_pGraduation[nCTX + nCTY * g_nTilesX] / g_nTilesX;
|
||
nCurTileY = g_pGraduation[nCTX + nCTY * g_nTilesX] % g_nTilesX;
|
||
double dMaxValue = 255 * (nCurTileX + nCurTileY * g_nTilesX + 1) / (g_nTilesX * g_nTilesY);
|
||
double dMinValue = 255 * (nCurTileX + nCurTileY * g_nTilesX) / (g_nTilesX * g_nTilesY);
|
||
double dCur = 1;
|
||
if( c_nGraduateSideLeftToRight == g_nMaskType )
|
||
dCur = double(nXIndex % g_nTileWidth) / g_nTileWidth;
|
||
else if ( c_nGraduateSideRightToLeft == g_nMaskType )
|
||
dCur = 1 - double(nXIndex % g_nTileWidth) / g_nTileWidth;
|
||
else if ( c_nGraduateSideTopToBottom == g_nMaskType )
|
||
dCur = 1 - double(nYIndex % g_nTileHeight) / g_nTileHeight;
|
||
else if ( c_nGraduateSideBottomToTop == g_nMaskType )
|
||
dCur = double(nYIndex % g_nTileHeight) / g_nTileHeight;
|
||
else if ( c_nGraduateCornerLeftTop == g_nMaskType )
|
||
dCur = max(double(nXIndex % g_nTileWidth) / g_nTileWidth, 1 - double(nYIndex % g_nTileHeight) / g_nTileHeight);
|
||
else if ( c_nGraduateCornerLeftBottom == g_nMaskType )
|
||
dCur = max(double(nXIndex % g_nTileWidth) / g_nTileWidth, double(nYIndex % g_nTileHeight) / g_nTileHeight);
|
||
else if ( c_nGraduateCornerRightTop == g_nMaskType )
|
||
dCur = max(1 - double(nXIndex % g_nTileWidth) / g_nTileWidth, 1 - double(nYIndex % g_nTileHeight) / g_nTileHeight);
|
||
else if ( c_nGraduateCornerRightBottom == g_nMaskType )
|
||
dCur = max(1 - double(nXIndex % g_nTileWidth) / g_nTileWidth, double(nYIndex % g_nTileHeight) / g_nTileHeight);
|
||
*pBuffer = dMaxValue * dCur + ( 1 - dCur) * dMinValue;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
void Clock()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
int nAnglesCount = 1;
|
||
int nStartAngle = 0;
|
||
if ( c_nGraduateClockLeftOpposite == g_nMaskType || c_nGraduateClockLeftClockwise == g_nMaskType || c_nGraduateClockLeftReverse == g_nMaskType )
|
||
{
|
||
nStartAngle = 180;
|
||
}
|
||
else if ( c_nGraduateClockTopOpposite == g_nMaskType || c_nGraduateClockTopClockwise == g_nMaskType || c_nGraduateClockTopReverse == g_nMaskType )
|
||
{
|
||
nStartAngle = 270;
|
||
}
|
||
else if ( c_nGraduateClockBottomOpposite == g_nMaskType || c_nGraduateClockBottomClockwise == g_nMaskType || c_nGraduateClockBottomReverse == g_nMaskType )
|
||
{
|
||
nStartAngle = 90;
|
||
}
|
||
|
||
if ( c_nGraduateClock2AnglesClockwise == g_nMaskType || c_nGraduateClock2AnglesReverse == g_nMaskType )
|
||
{
|
||
nAnglesCount = 2;
|
||
nStartAngle = 270;
|
||
}
|
||
else if ( c_nGraduateClock3AnglesClockwise == g_nMaskType || c_nGraduateClock3AnglesReverse == g_nMaskType )
|
||
{
|
||
nStartAngle = 270;
|
||
nAnglesCount = 3;
|
||
}
|
||
BOOL bReverse = FALSE;
|
||
|
||
double dRadianFactor = 1 / IPP_PI180;
|
||
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nCurTileX = nXIndex / g_nTileWidth;
|
||
int nCurTileY = nYIndex / g_nTileHeight;
|
||
|
||
int nCTX = nCurTileX;
|
||
int nCTY = nCurTileY;
|
||
|
||
nCurTileX = g_pGraduation[nCTX + nCTY * g_nTilesX] / g_nTilesX;
|
||
nCurTileY = g_pGraduation[nCTX + nCTY * g_nTilesX] % g_nTilesX;
|
||
double dMaxValue = 255 * (nCurTileX + nCurTileY * g_nTilesX + 1) / (g_nTilesX * g_nTilesY);
|
||
double dMinValue = 255 * (nCurTileX + nCurTileY * g_nTilesX) / (g_nTilesX * g_nTilesY);
|
||
double dCur = 1;
|
||
double dX = nXIndex - (nCTX + 0.5) * g_nTileWidth;
|
||
double dY = nYIndex - (nCTY + 0.5) * g_nTileHeight;
|
||
|
||
double dRadius = sqrt(dX * dX + dY * dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = (dRadius ? acos( dX / dRadius) * dSecY : 0) * dRadianFactor;
|
||
dAngle = (dAngle < 0 ? dAngle + 360 : dAngle );
|
||
dAngle = int(dAngle + nStartAngle) % 360;
|
||
|
||
dAngle = int(dAngle * nAnglesCount) % 360;
|
||
|
||
if( c_nGraduateClockRightOpposite == g_nMaskType || c_nGraduateClockLeftOpposite == g_nMaskType ||
|
||
c_nGraduateClockTopOpposite == g_nMaskType || c_nGraduateClockBottomOpposite == g_nMaskType)
|
||
{
|
||
if ( 180 >= dAngle )
|
||
dCur = dAngle / 180;
|
||
else
|
||
dCur = (360 - dAngle) / 180;
|
||
}
|
||
else if( c_nGraduateClockRightClockwise == g_nMaskType || c_nGraduateClockLeftClockwise == g_nMaskType ||
|
||
c_nGraduateClockTopClockwise == g_nMaskType || c_nGraduateClockBottomClockwise == g_nMaskType ||
|
||
c_nGraduateClock2AnglesClockwise == g_nMaskType || c_nGraduateClock3AnglesClockwise == g_nMaskType )
|
||
{
|
||
dCur = 1 - dAngle / 360;
|
||
}
|
||
else if( c_nGraduateClockRightReverse == g_nMaskType || c_nGraduateClockLeftReverse == g_nMaskType ||
|
||
c_nGraduateClockTopReverse == g_nMaskType || c_nGraduateClockBottomReverse == g_nMaskType ||
|
||
c_nGraduateClock2AnglesReverse == g_nMaskType || c_nGraduateClock3AnglesReverse == g_nMaskType )
|
||
{
|
||
dCur = dAngle / 360;
|
||
}
|
||
*pBuffer = dMaxValue * dCur + ( 1 - dCur) * dMinValue;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
BOOL RandomShuffle(int nSize)
|
||
{
|
||
|
||
if (nSize < 1)
|
||
return FALSE;
|
||
if (nSize == g_nSize)
|
||
return TRUE;
|
||
|
||
g_nSize = nSize;
|
||
g_pGraduation = new int[g_nSize];
|
||
|
||
if (NULL == g_pGraduation)
|
||
return FALSE;
|
||
|
||
for (int index = 0; index < g_nSize; ++index)
|
||
g_pGraduation[index] = index;
|
||
|
||
//srand(GetTickCount());
|
||
srand( 1 );
|
||
|
||
for (int index = 0; index < g_nSize; ++index)
|
||
{
|
||
int nSwapIndex = rand() % g_nSize;
|
||
int nSwapValue = g_pGraduation[nSwapIndex];
|
||
|
||
g_pGraduation[nSwapIndex] = g_pGraduation[index];
|
||
g_pGraduation[index] = nSwapValue;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
public:
|
||
|
||
Ipp8u* g_pMask;
|
||
|
||
protected:
|
||
|
||
int g_nMaskWidth;
|
||
int g_nMaskHeight;
|
||
|
||
int g_nSize;
|
||
int* g_pGraduation;
|
||
int g_nMaskType;
|
||
int g_nTilesX;
|
||
int g_nTilesY;
|
||
int g_nTileWidth;
|
||
int g_nTileHeight;
|
||
|
||
|
||
};
|
||
|
||
|
||
class Mask
|
||
{
|
||
public:
|
||
|
||
Mask()
|
||
{
|
||
g_nMaskWidth = -1;
|
||
g_nMaskHeight = -1;
|
||
g_nMaskType = -1;
|
||
|
||
g_pMask = 0;
|
||
}
|
||
~Mask()
|
||
{
|
||
if ( g_pMask )
|
||
delete []g_pMask;
|
||
}
|
||
|
||
void GenerateMask(int nWidth, int nHeight, int nType)
|
||
{
|
||
if ((nWidth == g_nMaskWidth) && (nHeight == g_nMaskHeight) && (g_pMask) && (nType == g_nMaskType))
|
||
return ;
|
||
|
||
if (g_pMask)
|
||
delete []g_pMask;
|
||
|
||
int nSize = nWidth * nHeight;
|
||
if( !nSize )
|
||
return;
|
||
|
||
g_nMaskType = nType;
|
||
g_nMaskWidth = nWidth;
|
||
g_nMaskHeight = nHeight;
|
||
|
||
g_pMask = new BYTE[nSize];
|
||
if( !g_pMask )
|
||
return;
|
||
|
||
|
||
ZeroMemory( g_pMask, nSize );
|
||
|
||
if ( c_nBowTileHorizontal == nType || c_nBowTileSmoothHorizontal == nType ||
|
||
c_nBowTileVertical == nType || c_nBowTileSmoothVertical == nType)
|
||
BowTile();
|
||
else
|
||
if ( c_nDiagonalBoxOut == nType || c_nDiagonalSmoothBoxOut == nType)
|
||
DiagonalBoxOut();
|
||
else
|
||
if ( c_nDiagonalCrossOut == nType || c_nDiagonalSmoothCrossOut == nType)
|
||
DiagonalCrossOut();
|
||
else
|
||
if ( c_nDiagonalDownRight == nType || c_nDiagonalSmoothDownRight == nType ||
|
||
c_nDiagonalDownLeft == nType || c_nDiagonalSmoothDownLeft == nType ||
|
||
c_nDiagonalUpRight == nType || c_nDiagonalSmoothUpRight == nType ||
|
||
c_nDiagonalUpLeft == nType || c_nDiagonalSmoothUpLeft == nType)
|
||
Diagonal();
|
||
else
|
||
if ( c_nFunIn == nType || c_nFunSmoothIn == nType)
|
||
FunIn();
|
||
else
|
||
if ( c_nFunOut == nType || c_nFunSmoothOut == nType)
|
||
FunOut();
|
||
else
|
||
if ( c_nFunUp == nType || c_nFunSmoothUp == nType)
|
||
FunUp();
|
||
else
|
||
if ( c_nFilledVDown == nType || c_nFilledVSmoothDown == nType ||
|
||
c_nFilledVRight == nType || c_nFilledVSmoothRight == nType ||
|
||
c_nFilledVLeft == nType || c_nFilledVSmoothLeft == nType ||
|
||
c_nFilledVUp == nType || c_nFilledVSmoothUp == nType )
|
||
FilledV();
|
||
|
||
else
|
||
if ( c_nInsertDownLeft == nType || c_nInsertSmoothDownLeft == nType ||
|
||
c_nInsertDownRight == nType || c_nInsertSmoothDownRight == nType ||
|
||
c_nInsertUpLeft == nType || c_nInsertSmoothUpLeft == nType ||
|
||
c_nInsertUpRight == nType || c_nInsertSmoothUpRight == nType )
|
||
Insert();
|
||
else
|
||
if ( c_nRevealUp == nType || c_nRevealDown == nType ||
|
||
c_nRevealLeft == nType || c_nRevealRight == nType)
|
||
Reveal();
|
||
else
|
||
if ( c_nSplitHorizontal == nType || c_nSplitSmoothHorizontal == nType ||
|
||
c_nSplitVertical == nType || c_nSplitSmoothVertical == nType )
|
||
Split();
|
||
else
|
||
if ( c_nSweepIn == nType || c_nSweepSmoothIn == nType )
|
||
SweepIn();
|
||
else
|
||
if ( c_nSweepOut == nType || c_nSweepSmoothOut == nType )
|
||
SweepOut();
|
||
else
|
||
if ( c_nSweepUp == nType || c_nSweepSmoothUp == nType )
|
||
SweepUp();
|
||
else
|
||
if ( c_nZigZagHorizontal == nType || c_nZigZagVertical == nType
|
||
|| c_nZigZagSmoothHorizontal == nType || c_nZigZagSmoothVertical == nType)
|
||
ZigZag();
|
||
else if ( c_nWipeSmoothDiamond == nType || c_nWipeSmoothDiamondIn == nType )
|
||
Diamond();
|
||
else if ( c_nWipeSmoothDiamonds == nType || c_nWipeDiamonds == nType )
|
||
Diamonds();
|
||
else if ( c_nWipeSmoothCircle == nType || c_nWipeSmoothCircleIn == nType )
|
||
Circle();
|
||
else if ( c_nWipeSmoothCircles == nType || c_nWipeCircles == nType )
|
||
Circles();
|
||
else if ( c_nWipeSmoothWideStar == nType || c_nWipeSmoothNarrowStar == nType ||
|
||
c_nWipeSmoothWideFlower == nType || c_nWipeSmoothNarrowFlower == nType)
|
||
StarFlower();
|
||
else if ( c_nWipeSmoothWideStars == nType || c_nWipeSmoothNarrowStars == nType ||
|
||
c_nWipeSmoothWideFlowers == nType || c_nWipeSmoothNarrowFlowers == nType)
|
||
StarsFlowers();
|
||
else if ( c_nWipeSmoothWideKeyHole == nType || c_nWipeSmoothNarrowKeyHole == nType)
|
||
KeyHole();
|
||
else if ( c_nWipeSmoothWideKeyHoles == nType || c_nWipeSmoothNarrowKeyHoles == nType)
|
||
KeyHoles();
|
||
else if ( c_nCircleCornerLeftBottom == nType || c_nCircleCornerSmoothLeftBottom == nType ||
|
||
c_nCircleCornerLeftTop == nType || c_nCircleCornerSmoothLeftTop == nType ||
|
||
c_nCircleCornerRightBottom == nType || c_nCircleCornerSmoothRightBottom == nType ||
|
||
c_nCircleCornerRightTop == nType || c_nCircleCornerSmoothRightTop == nType )
|
||
CircleCorner();
|
||
|
||
else if( c_nBarsHorizontal == nType)
|
||
BarsHorizontal();
|
||
else if( c_nBarsVertical == nType)
|
||
BarsVertical();
|
||
else if( c_nWipeSmoothBoxIn == nType || c_nWipeSmoothBoxOut == nType)
|
||
Box();
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
protected:
|
||
|
||
void BowTile()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if( c_nBowTileHorizontal == nType || c_nBowTileSmoothHorizontal == nType)
|
||
{
|
||
*pBuffer = 128 - abs( nXIndex - g_nMaskWidth / 2 ) * 255. / g_nMaskWidth + abs( nYIndex - g_nMaskHeight / 2 ) * 256 / g_nMaskHeight;
|
||
}
|
||
else
|
||
{
|
||
*pBuffer = 128 + abs( nXIndex - g_nMaskWidth / 2 ) * 255. / g_nMaskWidth - abs( nYIndex - g_nMaskHeight / 2 ) * 255 / g_nMaskHeight;
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void DiagonalBoxOut()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nValue = abs( nXIndex - g_nMaskWidth / 2 ) * 511. / g_nMaskWidth + abs( nYIndex - g_nMaskHeight / 2 ) * 511. / g_nMaskHeight;
|
||
*pBuffer = (nValue > 255? nValue : 255 - nValue);
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void DiagonalCrossOut()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
*pBuffer = abs( abs( nXIndex - g_nMaskWidth / 2 ) * 511. / g_nMaskWidth - abs( nYIndex - g_nMaskHeight / 2 ) * 511 / g_nMaskHeight );
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Diagonal()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if( c_nDiagonalDownRight == nType || c_nDiagonalSmoothDownRight == nType)
|
||
*pBuffer = ( nXIndex + g_nMaskHeight - nYIndex ) * 255. / ( g_nMaskHeight + g_nMaskWidth );
|
||
else if( c_nDiagonalDownLeft == nType || c_nDiagonalSmoothDownLeft == nType)
|
||
*pBuffer = ( g_nMaskWidth - nXIndex + g_nMaskHeight - nYIndex ) * 255. / ( g_nMaskHeight + g_nMaskWidth );
|
||
else if( c_nDiagonalUpRight == nType || c_nDiagonalSmoothUpRight == nType)
|
||
*pBuffer = ( nXIndex + nYIndex ) * 255. / ( g_nMaskHeight + g_nMaskWidth );
|
||
else if( c_nDiagonalUpLeft == nType || c_nDiagonalSmoothUpLeft == nType)
|
||
*pBuffer = ( g_nMaskWidth - nXIndex + nYIndex ) * 255. / ( g_nMaskHeight + g_nMaskWidth );
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void FunIn()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if(nYIndex > g_nMaskHeight / 2)
|
||
{
|
||
double dY = nXIndex - g_nMaskWidth / 2;
|
||
double dX = nYIndex - 3 * g_nMaskHeight / 4;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = abs((dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265);
|
||
*pBuffer = int(255 * ( dAngle)/180 );
|
||
}
|
||
else
|
||
{
|
||
double dY = nXIndex - g_nMaskWidth / 2;
|
||
double dX = nYIndex - g_nMaskHeight / 4;
|
||
double dRadius = _hypot(dX, dY);
|
||
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = 180 - abs((dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265);
|
||
*pBuffer = int(255 * ( dAngle)/180 );
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void FunOut()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
double dY = nYIndex - g_nMaskHeight / 2;
|
||
if(nXIndex > g_nMaskWidth / 2)
|
||
{
|
||
double dX = nXIndex - 3 * g_nMaskWidth / 4;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = -(dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265 + 180;
|
||
*pBuffer = int(255 * ( dAngle)/360 );
|
||
|
||
}
|
||
else
|
||
{
|
||
double dX = nXIndex - g_nMaskWidth / 4;
|
||
double dRadius = _hypot(dX, dY);
|
||
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = (dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
dAngle += (dAngle < 0 ? 360 : 0);
|
||
*pBuffer = int(255 * ( dAngle)/360 );
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void FunUp()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
double dX = nYIndex - g_nMaskHeight;
|
||
double dY = nXIndex - g_nMaskWidth / 2;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = 180 - abs((dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265);
|
||
*pBuffer = int(255 * ( dAngle)/90 );
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void FilledV()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if( c_nFilledVDown == nType || c_nFilledVSmoothDown == nType )
|
||
{
|
||
*pBuffer = abs( nXIndex - g_nMaskWidth / 2 ) * 128. / ( g_nMaskWidth / 2) + ( g_nMaskHeight - nYIndex) * 128./ g_nMaskHeight;
|
||
}
|
||
else if( c_nFilledVRight == nType || c_nFilledVSmoothRight == nType )
|
||
{
|
||
*pBuffer = ( nXIndex) * 128. / g_nMaskWidth + abs( nYIndex - g_nMaskHeight / 2 ) * 128./ ( g_nMaskHeight / 2 );
|
||
}
|
||
else if( c_nFilledVLeft == nType || c_nFilledVSmoothLeft == nType )
|
||
{
|
||
*pBuffer = ( g_nMaskWidth - nXIndex) * 128. / g_nMaskWidth + abs( nYIndex - g_nMaskHeight / 2 ) * 128./ ( g_nMaskHeight / 2 );
|
||
}
|
||
else if( c_nFilledVUp == nType || c_nFilledVSmoothUp == nType )
|
||
{
|
||
*pBuffer = abs( nXIndex - g_nMaskWidth / 2 ) * 128. / ( g_nMaskWidth / 2) + ( nYIndex) * 128./ g_nMaskHeight;
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void Insert()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if( c_nInsertDownLeft == nType || c_nInsertSmoothDownLeft == nType )
|
||
{
|
||
*pBuffer = max( (g_nMaskWidth - nXIndex) * 255. / g_nMaskWidth, (g_nMaskHeight - nYIndex) * 255. / g_nMaskHeight);
|
||
}
|
||
else if( c_nInsertDownRight == nType || c_nInsertSmoothDownRight == nType )
|
||
{
|
||
*pBuffer = max( (nXIndex) * 255. / g_nMaskWidth, (g_nMaskHeight - nYIndex) * 255. / g_nMaskHeight);
|
||
}
|
||
else if( c_nInsertUpLeft == nType || c_nInsertSmoothUpLeft == nType )
|
||
{
|
||
*pBuffer = max( (g_nMaskWidth - nXIndex) * 255. / g_nMaskWidth, nYIndex * 255. / g_nMaskHeight);
|
||
}
|
||
else if( c_nInsertUpRight == nType || c_nInsertSmoothUpRight == nType )
|
||
{
|
||
*pBuffer = max( nXIndex * 255. / g_nMaskWidth, nYIndex * 255. / g_nMaskHeight);
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Reveal()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if( c_nRevealUp == nType)
|
||
{
|
||
*pBuffer = nYIndex * 255. / g_nMaskHeight;
|
||
}
|
||
else if( c_nRevealDown == nType)
|
||
{
|
||
*pBuffer = ( g_nMaskHeight - nYIndex ) * 255. / g_nMaskHeight;
|
||
}
|
||
else if( c_nRevealLeft == nType)
|
||
{
|
||
*pBuffer = ( g_nMaskWidth - nXIndex ) * 255. / g_nMaskWidth;
|
||
}
|
||
else if( c_nRevealRight == nType)
|
||
{
|
||
*pBuffer = nXIndex * 255. / g_nMaskWidth;
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void Split()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if( c_nSplitHorizontal == nType || c_nSplitSmoothHorizontal == nType )
|
||
{
|
||
*pBuffer = abs( nYIndex - g_nMaskHeight / 2) * 511. / g_nMaskWidth;
|
||
}
|
||
else if( c_nSplitVertical == nType || c_nSplitSmoothVertical == nType )
|
||
{
|
||
*pBuffer = abs( nXIndex - g_nMaskWidth / 2) * 511. / g_nMaskWidth;
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void SweepIn()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if ( nYIndex > int( g_nMaskHeight * nXIndex / ( 2. * g_nMaskWidth ) + g_nMaskHeight / 4. ))
|
||
{
|
||
double dY = nXIndex;
|
||
double dX = nYIndex - g_nMaskHeight / 4;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = (dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
*pBuffer = int(255 * ( dAngle)/(90 - atan( g_nMaskHeight / (2. * g_nMaskWidth ) ) * 180 / 3.14159265));
|
||
}
|
||
else if ( nYIndex < int( g_nMaskHeight * nXIndex / ( 2. * g_nMaskWidth ) + g_nMaskHeight / 4. ))
|
||
{
|
||
double dY = nXIndex - g_nMaskWidth;
|
||
double dX = nYIndex - 3 * g_nMaskHeight / 4;
|
||
double dRadius = _hypot(dX, dY);
|
||
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = 180 + (dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
*pBuffer = int(255 * ( dAngle)/( 90 - atan( g_nMaskHeight / (2. * g_nMaskWidth ) ) * 180 / 3.14159265));
|
||
}
|
||
else
|
||
{
|
||
*pBuffer = 255;
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void SweepOut()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if(nXIndex > g_nMaskWidth / 2)
|
||
{
|
||
double dX = nYIndex - g_nMaskHeight / 2;
|
||
double dY = nXIndex - g_nMaskWidth;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = -(dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
*pBuffer = int(255 * dAngle / 180);
|
||
}
|
||
else
|
||
{
|
||
double dY = nXIndex;
|
||
double dX = nYIndex - g_nMaskHeight / 2;
|
||
double dRadius = _hypot(dX, dY);
|
||
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = (dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
*pBuffer = int(255 * dAngle / 180);
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void SweepUp()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
if(nXIndex > g_nMaskWidth / 2)
|
||
{
|
||
double dY = nYIndex;
|
||
double dX = nXIndex - g_nMaskWidth;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = 180 - (dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
*pBuffer = int(255 * dAngle / 90);
|
||
}
|
||
else
|
||
{
|
||
double dY = nYIndex;
|
||
double dX = nXIndex;
|
||
double dRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
double dAngle = (dRadius ? acos( dX / dRadius) * dSecY : 0) * 180 / 3.14159265;
|
||
*pBuffer = int(255 * dAngle / 90);
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void ZigZag()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int g_nMaskHeightBuf = g_nMaskHeight;
|
||
int g_nMaskWidthBuf = g_nMaskWidth;
|
||
int nXIndexBuf = nXIndex;
|
||
int nYIndexBuf = nYIndex;
|
||
|
||
if( c_nZigZagVertical == nType || c_nZigZagSmoothVertical == nType)
|
||
{
|
||
int nBuf = g_nMaskHeightBuf;
|
||
g_nMaskHeightBuf = g_nMaskWidthBuf;
|
||
g_nMaskWidthBuf = nBuf;
|
||
nBuf = nXIndexBuf;
|
||
nXIndexBuf = nYIndexBuf;
|
||
nYIndexBuf = nBuf;
|
||
}
|
||
//::srand( ::GetTickCount() );
|
||
//GenerateRand(15);
|
||
//const int nZigZagCount = g_nRand + 1;
|
||
const int nZigZagCount = 4;
|
||
const double dZigZagWidth = g_nMaskWidthBuf / ( nZigZagCount * 2 + 1 );
|
||
const double dZigZagHeight = g_nMaskHeightBuf / 5;
|
||
const double dTimeUnit = 255. / ( g_nMaskHeightBuf / 2 + dZigZagHeight / 2 );
|
||
|
||
int nCurValue = 0;
|
||
|
||
if( nXIndexBuf % int( 2 * dZigZagWidth ) < dZigZagWidth )
|
||
{
|
||
if(nYIndexBuf > - (nXIndexBuf % int( 2 * dZigZagWidth )) * ( dZigZagHeight / dZigZagWidth ) + g_nMaskHeightBuf / 2 + dZigZagHeight / 2)
|
||
{
|
||
nCurValue += int(( nYIndexBuf - ( g_nMaskHeightBuf / 2 - dZigZagHeight / 2 )) * dTimeUnit);
|
||
nCurValue -= int( ( dZigZagWidth - nXIndexBuf % int( 2 * dZigZagWidth ) ) * ( dZigZagHeight * dTimeUnit ) / dZigZagWidth );
|
||
*pBuffer = nCurValue;
|
||
}
|
||
else
|
||
{
|
||
nCurValue += int(-( nYIndexBuf - ( g_nMaskHeightBuf / 2 - dZigZagHeight / 2 )) * dTimeUnit);
|
||
nCurValue += int( ( dZigZagWidth - nXIndexBuf % int( 2 * dZigZagWidth ) ) * ( dZigZagHeight * dTimeUnit ) / dZigZagWidth );
|
||
}
|
||
*pBuffer = nCurValue;
|
||
|
||
}
|
||
else
|
||
{
|
||
if(nYIndexBuf > (nXIndexBuf % int( 2 * dZigZagWidth ) - dZigZagWidth) * ( dZigZagHeight / dZigZagWidth ) + g_nMaskHeightBuf / 2 - dZigZagHeight / 2)
|
||
{
|
||
nCurValue += int(( nYIndexBuf - ( g_nMaskHeightBuf / 2 + dZigZagHeight / 2 )) * dTimeUnit);
|
||
nCurValue += int( ( 2 * dZigZagWidth - nXIndexBuf % int( 2 * dZigZagWidth ) ) * ( dZigZagHeight * dTimeUnit ) / dZigZagWidth );
|
||
*pBuffer = nCurValue;
|
||
}
|
||
else
|
||
{
|
||
nCurValue += int(-( nYIndexBuf - ( g_nMaskHeightBuf / 2 + dZigZagHeight / 2 )) * dTimeUnit);
|
||
nCurValue -= int( ( 2 * dZigZagWidth - nXIndexBuf % int( 2 * dZigZagWidth ) ) * ( dZigZagHeight * dTimeUnit ) / dZigZagWidth );
|
||
}
|
||
*pBuffer = nCurValue;
|
||
|
||
}
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Diamond()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
int nIn = 1;
|
||
if ( c_nWipeSmoothDiamondIn == g_nMaskType )
|
||
nIn = 0;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nValue = abs( nXIndex - g_nMaskWidth / 2 ) * 255. / g_nMaskWidth + abs( nYIndex - g_nMaskHeight / 2 ) * 256 / g_nMaskHeight;
|
||
*pBuffer = 255 * (1 - nIn) + (-1 + 2 * nIn) * nValue;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void Diamonds()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
const int nHorDiamonds = 5;
|
||
const int nVerDiamonds = 5;
|
||
int nPartWidth = g_nMaskWidth / nHorDiamonds;
|
||
int nPartHeight = g_nMaskHeight / nVerDiamonds;
|
||
|
||
int nHorIndex = nXIndex / nPartWidth;
|
||
int nVerIndex = nYIndex / nPartHeight;
|
||
*pBuffer = abs( nXIndex - (nHorIndex + 0.5) * (nPartWidth) ) * 255. / nPartWidth + abs( nYIndex - (nVerIndex + 0.5) * (nPartHeight) ) * 256 / nPartHeight;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
void Circle()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
int nIn = 1;
|
||
if ( c_nWipeSmoothCircleIn == g_nMaskType )
|
||
nIn = 0;
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nValue = sqrt(double(( nXIndex - g_nMaskWidth / 2 ) * ( nXIndex - g_nMaskWidth / 2 ) + ( nYIndex - g_nMaskHeight / 2 ) * ( nYIndex - g_nMaskHeight / 2 ))) * 255. * 2/ sqrt( double(g_nMaskHeight * g_nMaskHeight + g_nMaskWidth* g_nMaskWidth));
|
||
*pBuffer = 255 * (1 - nIn) + (-1 + 2 * nIn) * nValue;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Circles()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
const int nHorCircles = 5;
|
||
const int nVerCircles = 5;
|
||
int nPartWidth = g_nMaskWidth / nHorCircles;
|
||
int nPartHeight = g_nMaskHeight / nVerCircles;
|
||
|
||
int nHorIndex = nXIndex / nPartWidth;
|
||
int nVerIndex = nYIndex / nPartHeight;
|
||
*pBuffer = sqrt(double(( nXIndex - (nHorIndex + 0.5) * nPartWidth ) * ( nXIndex - (nHorIndex + 0.5) * nPartWidth ) + ( nYIndex - (nVerIndex + 0.5) * nPartHeight ) * ( nYIndex - (nVerIndex + 0.5) * nPartHeight ))) * 255. * 2/ sqrt( double(nPartHeight * nPartHeight + nPartWidth * nPartWidth));
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void StarFlower()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
const int nStarsPoints = 5;
|
||
const int nCountSectors = nStarsPoints * 2;
|
||
const int nSector = 360 / nCountSectors;
|
||
double dRad = 3.14159265 / 180;
|
||
double dFactor = sin(dRad * ( 90 - nSector)) / sin(dRad * ( 90 - 2 * nSector)); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
double dY = nYIndex - g_nMaskHeight / 2;
|
||
double dX = nXIndex - g_nMaskWidth / 2;
|
||
double dCurRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
int nAngle = (dCurRadius ? acos( dX / dCurRadius) * dSecY : 0) /dRad;
|
||
nAngle = ( nAngle < 0? 360 + nAngle : nAngle);
|
||
|
||
nAngle -= 90;
|
||
nAngle = ( nAngle < 0? 360 + nAngle : nAngle);
|
||
|
||
int nCurSector = nAngle / nSector;
|
||
int nCurAngle = nAngle % nSector;
|
||
|
||
double dSmallRadius; // <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if ( nCurSector % 2 )
|
||
{
|
||
if(c_nWipeSmoothWideFlower == nType || c_nWipeSmoothNarrowFlower == nType)
|
||
dSmallRadius = dCurRadius * nSector / (nSector + nCurAngle * (dFactor - 1));
|
||
else
|
||
{
|
||
double dValue = 1 / tan(asin( ( dFactor * sin( dRad * (nSector - nCurAngle)) + sin(dRad * nCurAngle ) )/sqrt( dFactor * dFactor + 1 - 2 * dFactor * cos(dRad * nSector)) ));
|
||
dSmallRadius = dCurRadius / (sin(dRad * nCurAngle) * dValue + cos(dRad * nCurAngle));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(c_nWipeSmoothWideFlower == nType || c_nWipeSmoothNarrowFlower == nType)
|
||
dSmallRadius = dCurRadius * nSector / (dFactor * nSector + nCurAngle * (1 - dFactor));
|
||
else
|
||
{
|
||
double dValue = 1 / tan(asin( ( dFactor * sin( dRad * (nCurAngle)) + sin(dRad * (nSector - nCurAngle) ) )/sqrt( dFactor * dFactor + 1 - 2 * dFactor * cos(dRad * nSector)) ));
|
||
dSmallRadius = dCurRadius / (sin(dRad * (nSector - nCurAngle)) * dValue + cos(dRad * (nSector - nCurAngle)));
|
||
}
|
||
}
|
||
double dCurTime = 255. * dSmallRadius * 2 / sqrt( double (g_nMaskHeight * g_nMaskHeight + g_nMaskWidth * g_nMaskWidth));
|
||
|
||
*pBuffer = int(dCurTime) % 255;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void StarsFlowers()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
const int nHorStars = 5;
|
||
const int nVerStars = 5;
|
||
int nPartWidth = g_nMaskWidth / nHorStars;
|
||
int nPartHeight = g_nMaskHeight / nVerStars;
|
||
|
||
int nHorIndex = nXIndex / nPartWidth;
|
||
int nVerIndex = nYIndex / nPartHeight;
|
||
|
||
const int nStarsPoints = 5;
|
||
const int nCountSectors = nStarsPoints * 2;
|
||
const int nSector = 360 / nCountSectors;
|
||
double dRad = 3.14159265 / 180;
|
||
double dFactor = sin(dRad * ( 90 - nSector)) / sin(dRad * ( 90 - 2 * nSector)); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
double dValue = 300;
|
||
|
||
for(int nIndex = 0; nIndex < 2; nIndex++ )
|
||
{
|
||
double dY = nYIndex - (nVerIndex + 0.5) * nPartHeight;
|
||
double dX = nXIndex - (nHorIndex + 0.5) * nPartWidth;
|
||
double dCurRadius = _hypot(dX, dY);
|
||
double dSecY = (dY >= 0 ? 1.0 : -1.0);
|
||
int nAngle = (dCurRadius ? acos( dX / dCurRadius) * dSecY : 0) /dRad;
|
||
nAngle = ( nAngle < 0? 360 + nAngle : nAngle);
|
||
|
||
nAngle -= 90;
|
||
nAngle = ( nAngle < 0? 360 + nAngle : nAngle);
|
||
|
||
int nCurSector = nAngle / nSector;
|
||
int nCurAngle = nAngle % nSector;
|
||
|
||
double dSmallRadius; // <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if ( nCurSector % 2 )
|
||
{
|
||
if (c_nWipeSmoothWideFlowers == nType || c_nWipeSmoothNarrowFlowers == nType)
|
||
dSmallRadius = dCurRadius * nSector / (nSector + nCurAngle * (dFactor - 1));
|
||
else
|
||
{
|
||
double dValue = 1 / tan(asin( ( dFactor * sin( dRad * (nSector - nCurAngle)) + sin(dRad * nCurAngle ) )/sqrt( dFactor * dFactor + 1 - 2 * dFactor * cos(dRad * nSector)) ));
|
||
dSmallRadius = dCurRadius / (sin(dRad * nCurAngle) * dValue + cos(dRad * nCurAngle));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (c_nWipeSmoothWideFlowers == nType || c_nWipeSmoothNarrowFlowers == nType)
|
||
dSmallRadius = dCurRadius * nSector / (dFactor * nSector + nCurAngle * (1 - dFactor));
|
||
else
|
||
{
|
||
double dValue = 1 / tan(asin( ( dFactor * sin( dRad * (nCurAngle)) + sin(dRad * (nSector - nCurAngle) ) )/sqrt( dFactor * dFactor + 1 - 2 * dFactor * cos(dRad * nSector)) ));
|
||
dSmallRadius = dCurRadius / (sin(dRad * (nSector - nCurAngle)) * dValue + cos(dRad * (nSector - nCurAngle)));
|
||
}
|
||
}
|
||
double dCurTime = 255. * dSmallRadius * 2 / sqrt( double (nPartHeight * nPartHeight + nPartWidth * nPartWidth));
|
||
|
||
dValue = (dCurTime < dValue? dCurTime : dValue);
|
||
|
||
if (nIndex == 0)
|
||
{
|
||
if ( nYIndex % nPartHeight > nPartHeight / 2)
|
||
nVerIndex++;
|
||
else
|
||
nVerIndex--;
|
||
if ( nVerIndex < 0 || nVerIndex >= nVerStars )
|
||
nIndex = 2;
|
||
}
|
||
}
|
||
*pBuffer = int(dValue) % 255;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void KeyHoles()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
const int nHorHoles = 5;
|
||
const int nVerHoles = 5;
|
||
int nPartWidth = g_nMaskWidth / nHorHoles;
|
||
int nPartHeight = g_nMaskHeight / nVerHoles;
|
||
|
||
int nHorIndex = nXIndex / nPartWidth;
|
||
int nVerIndex = nYIndex / nPartHeight;
|
||
|
||
double dResValue = 300;
|
||
|
||
for(int nIndex =0; nIndex < 2; nIndex++)
|
||
{
|
||
int nX = nXIndex - nHorIndex * nPartWidth;
|
||
int nY = nYIndex - nVerIndex * nPartHeight;
|
||
int nValue;
|
||
int nValue1;
|
||
double dUnit = 255. * 8. / (nPartWidth * 3. );
|
||
if ( nY - 2. * nPartHeight / 3. <= - abs(8. * ( nX - nPartWidth / 2. ) / 3.))
|
||
{
|
||
nValue = (2. * nPartHeight / 3. - nY) * dUnit / 6.;
|
||
}
|
||
else
|
||
{
|
||
int nX1 = nX - nPartWidth / 2.;
|
||
int nY1 = nY - 2. * nPartHeight / 3.;
|
||
int nCurY = nY1 + 12. * abs(nX1) / 3.;
|
||
nValue = nCurY * dUnit / 3.;
|
||
}
|
||
nValue1 = sqrt(double(( nX - nPartWidth / 2. ) * ( nX - nPartWidth / 2. ) + ( nY - 2 * nPartHeight / 3. ) * ( nY - 2. * nPartHeight / 3. ))) * dUnit / 2.;
|
||
if ( nValue1 < nValue || 2. * nPartHeight / 3. < nY)
|
||
nValue = nValue1;
|
||
|
||
double dValue = sqrt( nValue / 255.) * 255;
|
||
|
||
dResValue = (dValue < dResValue? dValue : dResValue);
|
||
|
||
if (nIndex == 0)
|
||
{
|
||
if ( nYIndex % nPartHeight > nPartHeight / 2)
|
||
nVerIndex++;
|
||
else
|
||
nVerIndex--;
|
||
if ( nVerIndex < 0 || nVerIndex >= nVerHoles )
|
||
nIndex = 2;
|
||
}
|
||
|
||
}
|
||
*pBuffer = dResValue ;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void KeyHole()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nValue;
|
||
int nValue1;
|
||
double dUnit = 255. * 8 / (g_nMaskWidth * 3 );
|
||
if ( nYIndex - 2 * g_nMaskHeight / 3 <= - abs(8. * ( nXIndex - g_nMaskWidth / 2 ) / 3.))
|
||
{
|
||
nValue = (2 * g_nMaskHeight / 3 - nYIndex) * dUnit / 6;
|
||
}
|
||
else
|
||
{
|
||
int nX = nXIndex - g_nMaskWidth / 2;
|
||
int nY = nYIndex - 2 * g_nMaskHeight / 3;
|
||
int nCurY = nY + 12 * abs(nX) / 3;
|
||
nValue = nCurY * dUnit / 3;
|
||
}
|
||
nValue1 = sqrt(double(( nXIndex - g_nMaskWidth / 2 ) * ( nXIndex - g_nMaskWidth / 2 ) + ( nYIndex - 2 * g_nMaskHeight / 3 ) * ( nYIndex - 2 * g_nMaskHeight / 3 ))) * dUnit / 2;
|
||
if ( nValue1 < nValue || 2 * g_nMaskHeight / 3 < nYIndex)
|
||
nValue = nValue1;
|
||
|
||
double dValue = sqrt(nValue / 255.);
|
||
*pBuffer = dValue * 255;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CircleCorner()
|
||
{
|
||
int nType = g_nMaskType;
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
for ( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
double dMax = sqrt(double( g_nMaskWidth * g_nMaskWidth + g_nMaskHeight * g_nMaskHeight ));
|
||
if( c_nCircleCornerLeftBottom == nType || c_nCircleCornerSmoothLeftBottom == nType )
|
||
*pBuffer = 255. * sqrt (double( nXIndex * nXIndex + nYIndex * nYIndex )) / dMax ;
|
||
else if( c_nCircleCornerLeftTop == nType || c_nCircleCornerSmoothLeftTop == nType )
|
||
*pBuffer = 255. * sqrt (double( nXIndex * nXIndex + (nYIndex - g_nMaskHeight) * (nYIndex - g_nMaskHeight) )) / dMax;
|
||
else if( c_nCircleCornerRightBottom == nType || c_nCircleCornerSmoothRightBottom == nType )
|
||
*pBuffer = 255. * sqrt (double( (nXIndex - g_nMaskWidth) * (nXIndex - g_nMaskWidth) + nYIndex * nYIndex )) / dMax;
|
||
else if( c_nCircleCornerRightTop == nType || c_nCircleCornerSmoothRightTop == nType )
|
||
*pBuffer = 255. * sqrt (double( (nXIndex - g_nMaskWidth) * (nXIndex - g_nMaskWidth) + (nYIndex - g_nMaskHeight) * (nYIndex - g_nMaskHeight)) ) / dMax;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void BarsHorizontal()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
::srand( ::GetTickCount() );
|
||
int* nRow = new int[g_nMaskHeight];
|
||
for (int nIndex = 0; nIndex < g_nMaskHeight; nIndex++ )
|
||
{
|
||
nRow[nIndex] = rand()%255;
|
||
}
|
||
for( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
*pBuffer = nRow[nYIndex];
|
||
pBuffer++;
|
||
}
|
||
}
|
||
delete nRow;
|
||
}
|
||
|
||
void BarsVertical()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
::srand( ::GetTickCount() );
|
||
int* nCol = new int[g_nMaskWidth];
|
||
for (int nIndex = 0; nIndex < g_nMaskWidth; nIndex++ )
|
||
{
|
||
nCol[nIndex] = rand()%255;
|
||
}
|
||
for( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
*pBuffer = nCol[nXIndex];
|
||
pBuffer++;
|
||
}
|
||
}
|
||
delete nCol;
|
||
}
|
||
|
||
|
||
void Box()
|
||
{
|
||
Ipp8u* pBuffer = g_pMask;
|
||
|
||
int nIn = 1;
|
||
if ( c_nWipeSmoothBoxIn == g_nMaskType )
|
||
nIn = 0;
|
||
|
||
double dXFactor = 511. / g_nMaskWidth ;
|
||
double dYFactor = 511. / g_nMaskHeight;
|
||
|
||
for( int nYIndex = 0; nYIndex < g_nMaskHeight; nYIndex++ )
|
||
{
|
||
for( int nXIndex = 0; nXIndex < g_nMaskWidth; nXIndex++ )
|
||
{
|
||
int nValue = max( dXFactor * abs(double(nXIndex - g_nMaskWidth / 2)), dYFactor * abs(double(nYIndex - g_nMaskHeight / 2)));
|
||
*pBuffer = 255 * (1 - nIn) + (-1 + 2 * nIn) * nValue;
|
||
pBuffer++;
|
||
}
|
||
}
|
||
}
|
||
|
||
public:
|
||
|
||
int g_nMaskWidth;
|
||
int g_nMaskHeight;
|
||
|
||
Ipp8u* g_pMask;
|
||
int g_nMaskType;
|
||
|
||
};
|
||
|
||
class PuzzleFigure
|
||
{
|
||
public:
|
||
|
||
PuzzleFigure()
|
||
{
|
||
m_nFigHeight = 0;
|
||
m_nFigWidth = 0;
|
||
|
||
m_nPicHeight = 0;
|
||
m_nPicWidth = 0;
|
||
|
||
m_nLeftFactor = 0;
|
||
m_nRightFactor = 0;
|
||
m_nTopFactor = 0;
|
||
m_nBottomFactor = 0;
|
||
|
||
m_nXCoorSource = 0;
|
||
m_nYCoorSource = 0;
|
||
}
|
||
PuzzleFigure(int nFigWidth, int nFigHeight, int nTopFactor, int nRightFactor, int nBottomFactor, int nLeftFactor, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
|
||
{
|
||
m_nFigHeight = nFigHeight;
|
||
m_nFigWidth = nFigWidth;
|
||
|
||
m_nLeftFactor = nLeftFactor;
|
||
m_nRightFactor = nRightFactor;
|
||
m_nTopFactor = nTopFactor;
|
||
m_nBottomFactor = nBottomFactor;
|
||
|
||
m_nPicHeight = nPicHeight;
|
||
m_nPicWidth = nPicWidth;
|
||
|
||
m_pBGRASource = pBGRASource;
|
||
|
||
m_nXCoorSource = nXCoorSource;
|
||
m_nYCoorSource = nYCoorSource;
|
||
}
|
||
~PuzzleFigure()
|
||
{
|
||
}
|
||
|
||
private:
|
||
|
||
void DrawAlphaBlendingLine(BYTE* pBGRAResult, BYTE* pBGRASource, int nColor, int nNumLine, double dEffect)
|
||
{
|
||
BYTE *pResult = pBGRAResult;
|
||
BYTE *pSource = pBGRASource;
|
||
int nAlpha = 7;
|
||
for(int k = 0; k < nNumLine; k++)
|
||
{
|
||
nAlpha *= 2;
|
||
}
|
||
if(1 == dEffect)
|
||
{
|
||
*pResult = (nColor*nAlpha + *pSource *(255-nAlpha))/255; pResult++; pSource ++;
|
||
*pResult = (nColor*nAlpha + *pSource *(255-nAlpha))/255; pResult++; pSource ++;
|
||
*pResult = (nColor*nAlpha + *pSource *(255-nAlpha))/255; pResult++; pSource ++;
|
||
}
|
||
else
|
||
{
|
||
*pResult = dEffect*(nColor*nAlpha + *pSource *(255-nAlpha))/255 + *pSource*(1-dEffect); pResult++; pSource ++;
|
||
*pResult = dEffect*(nColor*nAlpha + *pSource *(255-nAlpha))/255 + *pSource*(1-dEffect); pResult++; pSource ++;
|
||
*pResult = dEffect*(nColor*nAlpha + *pSource *(255-nAlpha))/255 + *pSource*(1-dEffect); pResult++; pSource ++;
|
||
|
||
}
|
||
*pResult = 255;
|
||
pResult++; pSource++;
|
||
}
|
||
|
||
|
||
public:
|
||
|
||
void SetValue(int nFigWidth, int nFigHeight, int nTopFactor, int nRightFactor, int nBottomFactor, int nLeftFactor, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
|
||
{
|
||
m_nFigHeight = nFigHeight;
|
||
m_nFigWidth = nFigWidth;
|
||
|
||
m_nLeftFactor = nLeftFactor;
|
||
m_nRightFactor = nRightFactor;
|
||
m_nTopFactor = nTopFactor;
|
||
m_nBottomFactor = nBottomFactor;
|
||
|
||
m_nPicHeight = nPicHeight;
|
||
m_nPicWidth = nPicWidth;
|
||
|
||
m_pBGRASource = pBGRASource;
|
||
|
||
m_nXCoorSource = nXCoorSource;
|
||
m_nYCoorSource = nYCoorSource;
|
||
|
||
}
|
||
|
||
BOOL Draw(Gdiplus::Graphics *oMainRender, Gdiplus::TextureBrush *oBrush, double dXCoorResult, double dYCoorResult, int nWidth, int nHeight, double dEffect)
|
||
{
|
||
if(!oMainRender || !oBrush || nWidth != m_nPicWidth || nHeight != m_nPicHeight )
|
||
return FALSE;
|
||
|
||
int nSize = 4 * nHeight * nWidth;
|
||
|
||
|
||
double dDiagonal = min(m_nFigHeight, m_nFigWidth);
|
||
|
||
double dUnit = 1 / (72.0) * dDiagonal;
|
||
double dCircleWidth = 26 * dUnit; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20>.<2E>. 2 * <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - (<28><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
|
||
double dRadius = 15 * dUnit; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
double dSqrRadius = dRadius * dRadius;
|
||
double dDiff = dCircleWidth - dRadius;
|
||
|
||
double dInStep = 37 * dUnit;
|
||
|
||
double dStep = 11 * dUnit;
|
||
double dSrez = sqrt(dSqrRadius - dStep * dStep);
|
||
double dAngle = acos(11 * dUnit / dRadius) * 180 / IPP_PI;
|
||
|
||
double dXSur = m_nXCoorSource;
|
||
double dYSur = m_nYCoorSource;
|
||
|
||
double dFullHeight = m_nFigHeight + 2 * dCircleWidth; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
double dFullWidth = m_nFigWidth + 2 * dCircleWidth; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
double dXResult = dXCoorResult - dCircleWidth;
|
||
double dYResult = dYCoorResult - dCircleWidth;
|
||
|
||
|
||
Gdiplus::GraphicsPath oPathAddEllipse;
|
||
if ( 1 == m_nLeftFactor )
|
||
oPathAddEllipse.AddEllipse( float(dXSur - dCircleWidth), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); // left
|
||
if ( 1 == m_nRightFactor )
|
||
oPathAddEllipse.AddEllipse( float(dXSur + dCircleWidth + m_nFigWidth - 2 * dRadius), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); //right
|
||
if ( 1 == m_nBottomFactor )
|
||
oPathAddEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur + m_nFigHeight + dCircleWidth), float(2 * dRadius), float(2 * dRadius)); //bottom
|
||
if ( 1 == m_nTopFactor )
|
||
oPathAddEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur - dCircleWidth + 2 * dRadius), float(2 * dRadius), float(2 * dRadius)); //top
|
||
oPathAddEllipse.CloseFigure();
|
||
|
||
Gdiplus::GraphicsPath oPathExclEllipse;
|
||
if ( -1 == m_nLeftFactor )
|
||
oPathExclEllipse.AddEllipse( float(dXSur - dCircleWidth + 2 * dDiff), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); // left
|
||
if ( -1 == m_nRightFactor )
|
||
oPathExclEllipse.AddEllipse( float(dXSur + dCircleWidth + m_nFigWidth - 2 * dRadius - 2 * dDiff), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); //right
|
||
if ( -1 == m_nBottomFactor )
|
||
oPathExclEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur + m_nFigHeight + dCircleWidth - 2 * dDiff),float(2 * dRadius), float(2 * dRadius)); //bottom
|
||
if ( -1 == m_nTopFactor )
|
||
oPathExclEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur - dCircleWidth + 2 * dRadius + 2 * dDiff), float(2 * dRadius), float(2 * dRadius)); //top
|
||
oPathExclEllipse.CloseFigure();
|
||
|
||
Gdiplus::Region oRegion(&oPathAddEllipse);
|
||
|
||
oRegion.Union(Gdiplus::RectF(dXSur, nHeight - (dYSur + m_nFigHeight), m_nFigWidth, m_nFigHeight));
|
||
oRegion.Exclude(&oPathExclEllipse);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
oBrush->TranslateTransform(-float(m_nXCoorSource - dXCoorResult), float(m_nYCoorSource - dYCoorResult), MatrixOrderAppend);
|
||
oRegion.Translate(-float(m_nXCoorSource - dXCoorResult), float(m_nYCoorSource - dYCoorResult));
|
||
|
||
oMainRender->FillRegion(oBrush, &oRegion);
|
||
|
||
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for (int nIndex = 0; nIndex < 2; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
//if (nIndex == 1)
|
||
//{
|
||
// nAlphaBlack = 224 * dEffect;
|
||
// nAlphaWhite = 224 * dEffect;
|
||
//}
|
||
Gdiplus::Pen oPen( Color( nAlphaBlack, 0, 0, 0) , 1);
|
||
if ( 0 == m_nRightFactor )
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
|
||
else
|
||
{
|
||
if ( 1 == m_nRightFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth - 2 * dRadius + nIndex), nHeight - float(dYResult + dFullHeight / 2 + dRadius - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), 180 + dAngle, 360 - 2 * dAngle);
|
||
else if ( -1 == m_nRightFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth - 2 * dRadius - nIndex - 2 * dStep), nHeight - float(dYResult + dFullHeight / 2 + dRadius + nIndex), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight / 2 + dSrez +nIndex));
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight / 2 - dSrez - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
|
||
}
|
||
|
||
if ( 0 == m_nTopFactor )
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
|
||
else
|
||
{
|
||
if ( 1 == m_nTopFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius + nIndex), nHeight - float(dYResult + 2 * dRadius - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), 270 + dAngle, 360 - 2 * dAngle);
|
||
else if ( -1 == m_nTopFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius - nIndex), nHeight - float(dYResult + 2 * dRadius + nIndex + 2 * dStep), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), 90 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dFullWidth / 2 + dSrez + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth / 2 - dSrez - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
|
||
}
|
||
|
||
nAlphaWhite /= 2;
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
|
||
if ( 0 == m_nLeftFactor )
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
|
||
else
|
||
{
|
||
if ( 1 == m_nLeftFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + nIndex), nHeight - float(dYResult + dFullHeight / 2 + dRadius - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), dAngle, 360 - 2 * dAngle);
|
||
else if ( -1 == m_nLeftFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult - nIndex + 2 * dStep), nHeight - float(dYResult + dFullHeight / 2 + dRadius + nIndex), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), 180 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight / 2 - dSrez - nIndex));
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight / 2 + dSrez + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
|
||
}
|
||
|
||
if ( 0 == m_nBottomFactor )
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
|
||
else
|
||
{
|
||
if ( 1 == m_nBottomFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius + nIndex), nHeight - float(dYResult + dFullHeight - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), 90 + dAngle, 360 - 2 * dAngle);
|
||
else if ( -1 == m_nBottomFactor)
|
||
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius - nIndex), nHeight - float(dYResult + dFullHeight + nIndex - 2 * dStep), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), 270 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth / 2 + dSrez + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
|
||
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth / 2 - dSrez - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
|
||
}
|
||
|
||
|
||
}
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
oRegion.Translate(float(m_nXCoorSource - dXCoorResult), - float(m_nYCoorSource - dYCoorResult));
|
||
oBrush->TranslateTransform(float(m_nXCoorSource - dXCoorResult), - float(m_nYCoorSource - dYCoorResult), MatrixOrderAppend);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
public:
|
||
|
||
int m_nFigHeight;
|
||
int m_nFigWidth;
|
||
int m_nPicHeight;
|
||
int m_nPicWidth;
|
||
|
||
int m_nLeftFactor; // -1, 0, +1
|
||
int m_nRightFactor; // -1 : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int m_nTopFactor; // 0 : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int m_nBottomFactor; // +1 : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
BYTE* m_pBGRASource;
|
||
int m_nXCoorSource; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int m_nYCoorSource; //
|
||
|
||
|
||
};
|
||
|
||
|
||
class PuzzleUtility
|
||
{
|
||
public:
|
||
|
||
PuzzleUtility()
|
||
{
|
||
g_pShuffle = 0;
|
||
g_nShuffleCount = -1;
|
||
|
||
g_pCorners = 0;
|
||
g_nCornersCount = -1;
|
||
|
||
g_pHorizontalFactor = 0;
|
||
g_pVerticalFactor = 0;
|
||
g_nRow = -1;
|
||
g_nCol = -1;
|
||
g_nTypeShuffle = -1;
|
||
g_nTypeCorners = -1;
|
||
g_nTypeGenerate = -1;
|
||
}
|
||
~PuzzleUtility()
|
||
{
|
||
if ( g_pShuffle )
|
||
delete []g_pShuffle;
|
||
|
||
if ( g_pCorners )
|
||
delete []g_pCorners;
|
||
|
||
if ( g_pHorizontalFactor )
|
||
delete []g_pHorizontalFactor;
|
||
if ( g_pVerticalFactor )
|
||
delete []g_pVerticalFactor;
|
||
}
|
||
|
||
|
||
void GenerateRandomShuffle(int nXCount, int nYCount, int nShuffle, int nPuzzleType)
|
||
{
|
||
int nCount = nXCount * nYCount;
|
||
if ( g_pShuffle && nCount == g_nShuffleCount && nPuzzleType == g_nTypeShuffle)
|
||
return;
|
||
|
||
if ( g_pShuffle )
|
||
delete []g_pShuffle;
|
||
|
||
g_nTypeShuffle = nPuzzleType;
|
||
g_nShuffleCount = nCount;
|
||
g_pShuffle = new int[nCount];
|
||
|
||
for(int nIndex = 0; nIndex < nCount; nIndex++)
|
||
g_pShuffle[nIndex] = nIndex;
|
||
|
||
if ( 0 == nShuffle )
|
||
return;
|
||
else if ( 1 == nShuffle )
|
||
{
|
||
::srand(::GetTickCount());
|
||
std::random_shuffle(g_pShuffle, g_pShuffle + nCount);
|
||
return;
|
||
}
|
||
else if ( 2 == nShuffle )
|
||
{
|
||
for (int nIndex = 0; nIndex < nCount; nIndex++ )
|
||
{
|
||
g_pShuffle[nIndex] = nCount - 1 - nIndex;
|
||
}
|
||
return;
|
||
}
|
||
else if ( 3 == nShuffle )
|
||
{
|
||
int nYLevel = 0;
|
||
for (int nYIndex = 0; nYIndex < nYCount; nYIndex++, nYLevel = (nYLevel + 1) % 2 )
|
||
{
|
||
for (int nXIndex = 0; nXIndex < nXCount; nXIndex++ )
|
||
{
|
||
int nIndex = nYIndex * nXCount + nXIndex;
|
||
if ( 0 == nYLevel )
|
||
g_pShuffle[nIndex] = nCount - 1 - nIndex;
|
||
else
|
||
g_pShuffle[nIndex] = nCount - 1 - (nYIndex * nXCount + nXCount - 1 - nXIndex);
|
||
}
|
||
}
|
||
}
|
||
else if ( 4 == nShuffle )
|
||
{
|
||
for (int nYIndex = 0; nYIndex < nYCount; nYIndex++ )
|
||
{
|
||
for (int nXIndex = 0; nXIndex < nXCount; nXIndex++ )
|
||
{
|
||
int nIndex = nYIndex * nXCount + nXIndex;
|
||
if ( nXIndex % 2 == 0 )
|
||
{
|
||
int nCurX = nXIndex / 2;
|
||
g_pShuffle[nIndex] = nCount - 1 - nYIndex * nXCount - nCurX;
|
||
}
|
||
else
|
||
{
|
||
int nCurX = (nXIndex + 1) / 2;
|
||
g_pShuffle[nIndex] = nCount - 1 - (nYIndex * nXCount + nXCount - 1 - nCurX);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
|
||
}
|
||
void GenerateCorners(int nWidth, int nHeight, int nCount, int nType, int nPuzzleType)
|
||
{
|
||
if ( g_pCorners && nCount == g_nCornersCount && nPuzzleType == g_nTypeCorners && nHeight == g_nPicHeight && nWidth == g_nPicWidth )
|
||
return;
|
||
|
||
if ( g_pCorners )
|
||
delete []g_pCorners;
|
||
|
||
g_nPicWidth = nWidth;
|
||
g_nPicHeight = nHeight;
|
||
|
||
g_nTypeCorners = nPuzzleType;
|
||
g_nCornersCount = nCount;
|
||
|
||
g_pCorners = new int[nCount];
|
||
if ( (0 <= nType && nType <= 3) || 5 == nType || 6 == nType || 7 == nType)
|
||
{
|
||
::srand(::GetTickCount());
|
||
for ( int nIndex = 0; nIndex < nCount; nIndex++)
|
||
g_pCorners[nIndex] = nType;
|
||
}
|
||
else if ( 4 == nType )
|
||
{
|
||
::srand(::GetTickCount());
|
||
for ( int nIndex = 0; nIndex < nCount; nIndex++)
|
||
g_pCorners[nIndex] = rand() % 4;
|
||
}
|
||
return;
|
||
|
||
}
|
||
void GeneratePuzzle(int nRow, int nCol, int nPuzzleType)
|
||
{
|
||
if ( g_pHorizontalFactor && g_pVerticalFactor && nRow == g_nRow && nCol == g_nCol && nPuzzleType == g_nTypeGenerate)
|
||
return;
|
||
|
||
if ( g_pHorizontalFactor )
|
||
delete []g_pHorizontalFactor;
|
||
if ( g_pVerticalFactor )
|
||
delete []g_pVerticalFactor;
|
||
|
||
int nSize = nCol * nRow * 2;
|
||
|
||
g_nTypeGenerate = nPuzzleType;
|
||
g_nRow = nRow;
|
||
g_nCol = nCol;
|
||
|
||
g_pHorizontalFactor = new int[nSize];
|
||
g_pVerticalFactor = new int[nSize];
|
||
|
||
::srand(GetTickCount());
|
||
for ( int nYIndex = 0, nIndex = 0; nYIndex < nRow; nYIndex++ )
|
||
{
|
||
for ( int nXIndex = 0; nXIndex < nCol; nXIndex++, nIndex += 2 )
|
||
{
|
||
if ( 1 == nRow )
|
||
{
|
||
g_pHorizontalFactor[nIndex + 0] = 0;
|
||
g_pHorizontalFactor[nIndex + 1] = 0;
|
||
continue;
|
||
}
|
||
if ( 0 == nYIndex )
|
||
{
|
||
g_pHorizontalFactor[nIndex + 0] = 0;
|
||
g_pHorizontalFactor[nIndex + 1] = -1 + 2 * (rand() % 2);
|
||
}
|
||
else if ( nRow - 1 == nYIndex )
|
||
{
|
||
g_pHorizontalFactor[nIndex + 1] = 0;
|
||
g_pHorizontalFactor[nIndex + 0] = - g_pHorizontalFactor[nIndex - nCol * 2 + 1];
|
||
}
|
||
else
|
||
{
|
||
g_pHorizontalFactor[nIndex + 1] = -1 + 2 * (rand() % 2);
|
||
g_pHorizontalFactor[nIndex + 0] = - g_pHorizontalFactor[nIndex - nCol * 2 + 1];
|
||
}
|
||
|
||
if ( 1 == nCol )
|
||
{
|
||
g_pVerticalFactor[nIndex + 0] = 0;
|
||
g_pVerticalFactor[nIndex + 1] = 0;
|
||
continue;
|
||
}
|
||
if ( 0 == nXIndex )
|
||
{
|
||
g_pVerticalFactor[nIndex + 0] = 0;
|
||
g_pVerticalFactor[nIndex + 1] = -1 + 2 * (rand() % 2);
|
||
}
|
||
else if ( nCol - 1 == nXIndex )
|
||
{
|
||
g_pVerticalFactor[nIndex + 1] = 0;
|
||
g_pVerticalFactor[nIndex + 0] = - g_pVerticalFactor[nIndex - 1];
|
||
}
|
||
else
|
||
{
|
||
g_pVerticalFactor[nIndex + 1] = -1 + 2 * (rand() % 2);
|
||
g_pVerticalFactor[nIndex + 0] = - g_pVerticalFactor[nIndex - 1];
|
||
}
|
||
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
int GetStartX(int nFigWidth, int nFigHeight, int nXResult, int nYResult, int nIndex, int nCurX)
|
||
{
|
||
int nXStart = 0;
|
||
|
||
switch(nIndex)
|
||
{
|
||
case 0: nXStart = - nFigWidth; break;
|
||
case 1: nXStart = g_nPicWidth + nFigWidth; break;
|
||
case 2: nXStart = g_nPicWidth + nFigWidth; break;
|
||
case 3: nXStart = - nFigWidth; break;
|
||
case 5: nXStart = nXResult; break;
|
||
case 6: nXStart = nXResult; break;
|
||
case 7:
|
||
{
|
||
if (nCurX % 2)
|
||
nXStart = -nFigWidth;
|
||
else
|
||
nXStart = g_nPicWidth + nFigWidth;
|
||
}
|
||
}
|
||
|
||
return nXStart;
|
||
}
|
||
|
||
int GetStartY(int nFigWidth, int nFigHeight, int nXResult, int nYResult, int nIndex)
|
||
{
|
||
int nYStart = 0;
|
||
|
||
switch(nIndex)
|
||
{
|
||
case 0: nYStart = - nFigHeight; break;
|
||
case 1: nYStart = - nFigHeight; break;
|
||
case 2: nYStart = g_nPicHeight + nFigHeight; break;
|
||
case 3: nYStart = g_nPicHeight + nFigHeight; break;
|
||
case 5: nYStart = - nFigHeight; break;
|
||
case 6: nYStart = g_nPicHeight + nFigHeight; break;
|
||
case 7: nYStart = - nFigHeight; break;
|
||
}
|
||
|
||
return nYStart;
|
||
}
|
||
public:
|
||
|
||
//<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
|
||
int *g_pShuffle;
|
||
int g_nShuffleCount;
|
||
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int *g_pCorners;
|
||
int g_nCornersCount;
|
||
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
int *g_pHorizontalFactor;
|
||
int *g_pVerticalFactor;
|
||
int g_nRow;
|
||
int g_nCol;
|
||
int g_nTypeShuffle;
|
||
int g_nTypeCorners;
|
||
int g_nTypeGenerate;
|
||
|
||
protected:
|
||
|
||
int g_nPicWidth;
|
||
int g_nPicHeight;
|
||
|
||
|
||
};
|
||
class Figure
|
||
{
|
||
public:
|
||
|
||
Figure()
|
||
{
|
||
m_dBigRadius = -1;
|
||
|
||
m_nPicHeight = -1;
|
||
m_nPicWidth = -1;
|
||
|
||
m_pBGRASource = 0;
|
||
|
||
m_dXCoorSource = -1;
|
||
m_dYCoorSource = -1;
|
||
m_arrPoints = 0;
|
||
|
||
m_nFigureType = -1;
|
||
m_nPointsCount = -1;
|
||
}
|
||
~Figure()
|
||
{
|
||
if ( m_arrPoints )
|
||
delete[] m_arrPoints;
|
||
}
|
||
|
||
public:
|
||
|
||
void SetValue(int nFigureType, double dSide, BYTE* pBGRASource, int nPicWidth, int nPicHeight, double dXCoorSource, double dYCoorSource)
|
||
{
|
||
|
||
m_nPicHeight = nPicHeight;
|
||
m_nPicWidth = nPicWidth;
|
||
|
||
m_pBGRASource = pBGRASource;
|
||
|
||
m_dXCoorSource = dXCoorSource;
|
||
m_dYCoorSource = dYCoorSource;
|
||
|
||
m_arrPoints = 0;
|
||
m_nPointsCount = -1;
|
||
|
||
m_nFigureType = nFigureType;
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if ( 6 == m_nFigureType )
|
||
{
|
||
m_dBigRadius = dSide;
|
||
m_dShiftX = m_dBigRadius / 2;
|
||
m_dShiftY = sqrt(3.0) * m_dBigRadius / 2;
|
||
}
|
||
else if ( 30 == m_nFigureType || 31 == m_nFigureType)
|
||
{
|
||
m_dBigRadius = sqrt(3.0) * dSide / 3; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
m_dShiftY = m_dBigRadius / 2; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
m_dShiftX = dSide / 2;
|
||
}
|
||
else if ( 41 == m_nFigureType )
|
||
{
|
||
m_dBigRadius = dSide / sqrt(2.0);
|
||
}
|
||
else if ( 42 == m_nFigureType )
|
||
{
|
||
m_dShiftX = dSide / 2;
|
||
m_dShiftY = dSide * ( 12.0 / 25.0 ) / 2;
|
||
}
|
||
else if ( 43 == m_nFigureType )
|
||
{
|
||
m_dShiftX = dSide / 2;
|
||
m_dShiftY = dSide * ( 12.0 / 25.0 ) / 2;
|
||
}
|
||
}
|
||
|
||
BOOL Draw(Gdiplus::Graphics *oMainRender, Gdiplus::TextureBrush *oBrush, double dXCoorResult, double dYCoorResult, int nWidth, int nHeight, double dEffect)
|
||
{
|
||
if(!oMainRender || !oBrush || nWidth != m_nPicWidth || nHeight != m_nPicHeight)
|
||
return FALSE;
|
||
|
||
int nSize = 4 * nHeight * nWidth;
|
||
|
||
CreatePolygon(m_nFigureType, m_dXCoorSource, m_dYCoorSource);
|
||
|
||
Gdiplus::GraphicsPath oPath;
|
||
oPath.AddPolygon(m_arrPoints, m_nPointsCount);
|
||
oPath.CloseFigure();
|
||
|
||
Gdiplus::Region oRegion(&oPath);
|
||
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
oBrush->TranslateTransform(-float(m_dXCoorSource - dXCoorResult), -float(m_dYCoorSource - dYCoorResult), MatrixOrderAppend);
|
||
oRegion.Translate(-float(m_dXCoorSource - dXCoorResult), -float(m_dYCoorSource - dYCoorResult));
|
||
|
||
oMainRender->FillRegion(oBrush, &oRegion);
|
||
|
||
if (6 == m_nFigureType)
|
||
DrawHexagonBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
|
||
else if ( 30 == m_nFigureType || 31 == m_nFigureType )
|
||
DrawTriangleBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
|
||
else if ( 41 == m_nFigureType )
|
||
DrawRhombusBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
|
||
else if ( 42 == m_nFigureType )
|
||
DrawBrickBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
|
||
else if ( 43 == m_nFigureType )
|
||
DrawInclinedBrickBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
oRegion.Translate(float(m_dXCoorSource - dXCoorResult), float(m_dYCoorSource - dYCoorResult));
|
||
oBrush->TranslateTransform(float(m_dXCoorSource - dXCoorResult), float(m_dYCoorSource - dYCoorResult), MatrixOrderAppend);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
protected:
|
||
|
||
BOOL CreatePolygon(int nNumber, double dX, double dY)
|
||
{
|
||
if (m_arrPoints)
|
||
delete []m_arrPoints;
|
||
if (6 == nNumber)
|
||
{
|
||
m_nPointsCount = 6;
|
||
m_arrPoints = new Gdiplus::PointF[6];
|
||
int nRadius = m_dBigRadius;
|
||
double dXShift = m_dShiftX;
|
||
double dYShift = m_dShiftY;
|
||
|
||
m_arrPoints[0].X = dX - dXShift;
|
||
m_arrPoints[0].Y = dY + dYShift;
|
||
m_arrPoints[1].X = dX + dXShift;
|
||
m_arrPoints[1].Y = dY + dYShift;
|
||
m_arrPoints[2].X = dX + nRadius;
|
||
m_arrPoints[2].Y = dY;
|
||
m_arrPoints[3].X = dX + dXShift;
|
||
m_arrPoints[3].Y = dY - dYShift;
|
||
|
||
m_arrPoints[4].X = dX - dXShift;
|
||
m_arrPoints[4].Y = dY - dYShift;
|
||
m_arrPoints[5].X = dX - nRadius;
|
||
m_arrPoints[5].Y = dY;
|
||
|
||
}
|
||
|
||
else if ( 30 == nNumber )
|
||
{
|
||
m_nPointsCount = 3;
|
||
m_arrPoints = new Gdiplus::PointF[3];
|
||
m_arrPoints[0].X = dX - m_dShiftX;
|
||
m_arrPoints[0].Y = dY + m_dShiftY;
|
||
|
||
m_arrPoints[1].X = dX;
|
||
m_arrPoints[1].Y = dY - m_dBigRadius;
|
||
|
||
m_arrPoints[2].X = dX + m_dShiftX;
|
||
m_arrPoints[2].Y = dY + m_dShiftY;
|
||
}
|
||
else if ( 31 == nNumber )
|
||
{
|
||
m_nPointsCount = 3;
|
||
m_arrPoints = new Gdiplus::PointF[3];
|
||
m_arrPoints[0].X = dX;
|
||
m_arrPoints[0].Y = dY + m_dBigRadius;
|
||
|
||
m_arrPoints[1].X = dX - m_dShiftX;
|
||
m_arrPoints[1].Y = dY - m_dShiftY;
|
||
|
||
m_arrPoints[2].X = dX + m_dShiftX;
|
||
m_arrPoints[2].Y = dY - m_dShiftY;
|
||
}
|
||
else if ( 41 == m_nFigureType )
|
||
{
|
||
m_nPointsCount = 4;
|
||
m_arrPoints = new Gdiplus::PointF[4];
|
||
|
||
m_arrPoints[0].X = dX - m_dBigRadius;
|
||
m_arrPoints[0].Y = dY;
|
||
|
||
m_arrPoints[1].X = dX;
|
||
m_arrPoints[1].Y = dY + m_dBigRadius;
|
||
|
||
m_arrPoints[2].X = dX + m_dBigRadius;
|
||
m_arrPoints[2].Y = dY;
|
||
|
||
m_arrPoints[3].X = dX;
|
||
m_arrPoints[3].Y = dY - m_dBigRadius;
|
||
}
|
||
else if ( 42 == m_nFigureType )
|
||
{
|
||
m_nPointsCount = 4;
|
||
m_arrPoints = new Gdiplus::PointF[4];
|
||
|
||
m_arrPoints[0].X = dX - m_dShiftX;
|
||
m_arrPoints[0].Y = dY - m_dShiftY;
|
||
|
||
m_arrPoints[1].X = dX + m_dShiftX;
|
||
m_arrPoints[1].Y = dY - m_dShiftY;
|
||
|
||
m_arrPoints[2].X = dX + m_dShiftX;
|
||
m_arrPoints[2].Y = dY + m_dShiftY;
|
||
|
||
m_arrPoints[3].X = dX - m_dShiftX;
|
||
m_arrPoints[3].Y = dY + m_dShiftY;
|
||
}
|
||
else if ( 43 == m_nFigureType )
|
||
{
|
||
m_nPointsCount = 4;
|
||
m_arrPoints = new Gdiplus::PointF[4];
|
||
|
||
double dCos = cos(-IPP_PI4);
|
||
double dSin = sin(-IPP_PI4);
|
||
|
||
m_arrPoints[3].X = - m_dShiftX * dCos - (- m_dShiftY) * dSin + dX;
|
||
m_arrPoints[3].Y = - m_dShiftX * dSin + (- m_dShiftY) * dCos + dY;
|
||
|
||
m_arrPoints[2].X = m_dShiftX * dCos - (- m_dShiftY) * dSin + dX;
|
||
m_arrPoints[2].Y = m_dShiftX * dSin + (- m_dShiftY) * dCos + dY;
|
||
|
||
m_arrPoints[1].X = m_dShiftX * dCos - ( m_dShiftY) * dSin + dX;
|
||
m_arrPoints[1].Y = m_dShiftX * dSin + ( m_dShiftY) * dCos + dY;
|
||
|
||
m_arrPoints[0].X = - m_dShiftX * dCos - ( m_dShiftY) * dSin + dX;
|
||
m_arrPoints[0].Y = - m_dShiftX * dSin + ( m_dShiftY) * dCos + dY;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
BOOL DrawHexagonBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
|
||
{
|
||
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
|
||
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for ( int nIndex = 0; nIndex < 3; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
if (nIndex == 1)
|
||
{
|
||
nAlphaBlack = 224 * dEffect;
|
||
nAlphaWhite = 224 * dEffect;
|
||
}
|
||
nAlphaWhite /= 2;
|
||
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
|
||
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[4]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[4], m_arrPoints[5]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[5], m_arrPoints[0]);
|
||
|
||
m_arrPoints[0].X++;
|
||
m_arrPoints[0].Y--;
|
||
|
||
m_arrPoints[1].X--;
|
||
m_arrPoints[1].Y--;
|
||
|
||
m_arrPoints[2].X--;
|
||
|
||
m_arrPoints[3].X--;
|
||
m_arrPoints[3].Y++;
|
||
|
||
m_arrPoints[4].X++;
|
||
m_arrPoints[4].Y++;
|
||
|
||
m_arrPoints[5].X++;
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
BOOL DrawTriangleBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
|
||
{
|
||
if (30 == m_nFigureType )
|
||
{
|
||
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
|
||
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for ( int nIndex = 0; nIndex < 3; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
if (nIndex == 1 || nIndex == 2)
|
||
{
|
||
nAlphaBlack = 224 * dEffect;
|
||
nAlphaWhite = 224 * dEffect;
|
||
}
|
||
nAlphaWhite /= 2;
|
||
if(nIndex == 0)
|
||
{
|
||
nAlphaWhite = 128;
|
||
nAlphaBlack = 128;
|
||
}
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
|
||
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[0]);
|
||
|
||
m_arrPoints[0].X ++;
|
||
m_arrPoints[0].Y -= float(0.4);
|
||
|
||
m_arrPoints[1].Y++;
|
||
|
||
m_arrPoints[2].X --;
|
||
m_arrPoints[2].Y -= float(0.4);
|
||
|
||
|
||
}
|
||
}
|
||
else if ( 31 == m_nFigureType)
|
||
{
|
||
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
|
||
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for ( int nIndex = 0; nIndex < 3; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
if (nIndex == 1 || nIndex == 2)
|
||
{
|
||
nAlphaBlack = 224 * dEffect;
|
||
nAlphaWhite = 224 * dEffect;
|
||
}
|
||
nAlphaWhite /= 2;
|
||
if(nIndex == 0)
|
||
{
|
||
nAlphaWhite = 128;
|
||
nAlphaBlack = 128;
|
||
}
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
|
||
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[0]);
|
||
|
||
m_arrPoints[0].Y--;
|
||
|
||
m_arrPoints[1].X ++;
|
||
m_arrPoints[1].Y += float(0.4);
|
||
|
||
m_arrPoints[2].X --;
|
||
m_arrPoints[2].Y += float(0.4);
|
||
|
||
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL DrawRhombusBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
|
||
{
|
||
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
|
||
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for ( int nIndex = 0; nIndex < 3; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
if (nIndex == 1)
|
||
{
|
||
nAlphaBlack = 224 * dEffect;
|
||
nAlphaWhite = 224 * dEffect;
|
||
}
|
||
nAlphaWhite /= 2;
|
||
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
|
||
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[0]);
|
||
|
||
m_arrPoints[0].X++;
|
||
m_arrPoints[1].Y--;
|
||
m_arrPoints[2].X--;
|
||
m_arrPoints[3].Y++;
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL DrawBrickBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
|
||
{
|
||
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
|
||
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for ( int nIndex = 0; nIndex < 3; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
if (nIndex == 1)
|
||
{
|
||
nAlphaBlack = 224 * dEffect;
|
||
nAlphaWhite = 224 * dEffect;
|
||
}
|
||
nAlphaWhite /= 2;
|
||
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
|
||
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[0]);
|
||
|
||
m_arrPoints[0].X++;
|
||
m_arrPoints[0].Y++;
|
||
|
||
m_arrPoints[1].X--;
|
||
m_arrPoints[1].Y++;
|
||
|
||
m_arrPoints[2].X--;
|
||
m_arrPoints[2].Y--;
|
||
|
||
m_arrPoints[3].X++;
|
||
m_arrPoints[3].Y--;
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
BOOL DrawInclinedBrickBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
|
||
{
|
||
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
|
||
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
|
||
|
||
int nAlphaBlack = 448 * dEffect;
|
||
int nAlphaWhite = 448 * dEffect;
|
||
|
||
for ( int nIndex = 0; nIndex < 3; nIndex++ )
|
||
{
|
||
nAlphaBlack /= 2;
|
||
if (nIndex == 1)
|
||
{
|
||
nAlphaBlack = 224 * dEffect;
|
||
nAlphaWhite = 224 * dEffect;
|
||
}
|
||
nAlphaWhite /= 2;
|
||
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
|
||
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
|
||
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
|
||
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[0]);
|
||
|
||
m_arrPoints[1].X--;
|
||
m_arrPoints[2].Y++;
|
||
m_arrPoints[3].X++;
|
||
m_arrPoints[0].Y--;
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
public:
|
||
double m_dBigRadius;
|
||
|
||
int m_nPicHeight;
|
||
int m_nPicWidth;
|
||
|
||
BYTE* m_pBGRASource;
|
||
|
||
double m_dXCoorSource;
|
||
double m_dYCoorSource;
|
||
|
||
int m_nFigureType;
|
||
// 30, 31 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
|
||
// 6 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
// 41 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 45 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
// 42 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 25:12)
|
||
// 43 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> 45 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
protected:
|
||
|
||
double m_dShiftY; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
double m_dShiftX; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
Gdiplus::PointF* m_arrPoints;
|
||
int m_nPointsCount;
|
||
|
||
};
|
||
|
||
|
||
|