/// <inheritdoc />
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
var intervalPosFactor = ((double)100 / EffectEndTime.TotalMilliseconds) * (StartTime.TotalMilliseconds + frame * 50);
var yOffsetAdjust = CalculateYOffset(intervalPosFactor);
var xOffsetAdjust = CalculateXOffset(intervalPosFactor);
if (_fp != null)
{
int yoffset = (int)(((double)(BufferHt + _fp.Height) / 2) + yOffsetAdjust - 1);
int xoffset = (int)(xOffsetAdjust + ((double)BufferWi - _fp.Width) / 2);
for (int x = 0; x < _fp.Width; x++)
{
for (int y = 0; y < _fp.Height; y++)
{
var fpColor = _fp.GetPixel(x, y);
if (Level < 100)
{
var hsv = HSV.FromRGB(fpColor);
hsv.V = hsv.V * ((double)Level / 100);
fpColor = hsv.ToRGB();
}
frameBuffer.SetPixel(x + xoffset, yoffset - y, fpColor);
}
}
}
}
/// <inheritdoc />
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
var intervalPos = GetEffectTimeIntervalPosition(frame);
var intervalPosFactor = intervalPos * 100;
double level = LevelCurve.GetValue(intervalPosFactor) / 100;
if (_fp != null)
{
int yoffset = (BufferHt + _fp.Height) / 2;
int xoffset = (_fp.Width - BufferWi) / 2;
for (int x = 0; x < _fp.Width; x++)
{
for (int y = 0; y < _fp.Height; y++)
{
var fpColor = _fp.GetPixel(x, y);
var hsv = HSV.FromRGB(fpColor);
hsv.V = hsv.V * level;
frameBuffer.SetPixel(x - xoffset, yoffset - y, hsv);
}
}
}
}
private void CalculatePixel(int x, int y, ref int bufferHt, FastPixel.FastPixel bitmap, IPixelFrameBuffer frameBuffer)
{
Color color = bitmap.GetPixel(x, bufferHt - y - 1);
if (!EmptyColor.Equals(color))
{
frameBuffer.SetPixel(x, y, color);
}
}
private void buttonImport_Click(object sender, EventArgs e)
{
OpenFileDialog fileDlg = new OpenFileDialog();
fileDlg.Filter = "Image Files (*.bmp, *.jpg, *.png)|*.bmp;*.jpg;*.png|All Files(*.*)|*.*";
DialogResult result = fileDlg.ShowDialog();
if (result == DialogResult.OK)
{
LipSyncMapItem mapItem;
Color pixelColor;
Bitmap rawBitmap = new Bitmap(fileDlg.FileName);
FastPixel.FastPixel scaledImage =
new FastPixel.FastPixel(new Bitmap(rawBitmap, CalcNumDataGridCols, CalcNumDataGridRows));
int cols = CalcNumDataGridCols;
int rows = CalcNumDataGridRows;
scaledImage.Lock();
for (int row = 0; row < rows; row++)
{
DataRow dr = currentDataTable.Rows[row];
for (int col = 0; col < cols; col++)
{
mapItem = FindRenderMapItem(row, col);
if (mapItem != null)
{
pixelColor = scaledImage.GetPixel(col, row);
dr[col] = pixelColor;
mapItem.PhonemeList[CurrentPhonemeString] = (pixelColor != Color.Black);
}
else
{
dr[col] = Color.Gray;
}
}
}
scaledImage.Unlock(false);
BuildDialogFromMap(_newMapping);
updatedataGridView1();
Refresh();
}
}
private void CalculateLocationPixel(int x, int y, ref int bufferHt, FastPixel.FastPixel bitmap, IPixelFrameBuffer frameBuffer)
{
int yCoord = y;
int xCoord = x;
//Flip me over so and offset my coordinates I can act like the string version
y = Math.Abs((BufferHtOffset - y) + (bufferHt - 1 + BufferHtOffset));
y = y - BufferHtOffset;
x = x - BufferWiOffset;
Color color = bitmap.GetPixel(x, bufferHt - y - 1);
if (!EmptyColor.Equals(color))
{
frameBuffer.SetPixel(xCoord, yCoord, color);
}
else
{
//Set me to my base color or transparent
frameBuffer.SetPixel(xCoord, yCoord, UseBaseColor ? BaseColor : Color.Transparent);
}
}
private void CalculatePixel(int x, int y, ref int bufferHt, FastPixel.FastPixel bitmap, IPixelFrameBuffer frameBuffer)
{
int yCoord = y;
int xCoord = x;
if (TargetPositioning == TargetPositioningType.Locations)
{
//Flip me over so and offset my coordinates I can act like the string version
y = Math.Abs((BufferHtOffset - y) + (bufferHt - 1 + BufferHtOffset));
y = y - BufferHtOffset;
x = x - BufferWiOffset;
}
Color color = bitmap.GetPixel(x, bufferHt - y - 1);
if (!_emptyColor.Equals(color))
{
frameBuffer.SetPixel(xCoord, yCoord, color);
}
else if (TargetPositioning == TargetPositioningType.Locations)
{
frameBuffer.SetPixel(xCoord, yCoord, Color.Transparent);
}
}
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
if (_image == null)
{
Logging.Error("Image object is null");
return;
}
var dir = 360 - Direction;
double level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
int speedFactor = 4;
int state = MovementRate * frame;
if (Type != EffectType.RenderPictureTiles && Type != EffectType.RenderPictureNone)
{
_position = ((GetEffectTimeIntervalPosition(frame) * Speed) % 1);
}
else if (frame == 0)
{
_position = ((GetEffectTimeIntervalPosition(frame + 1) * Speed) % 1);
}
CalculateImageNumberByPosition((GetEffectTimeIntervalPosition(frame)*GifSpeed)%1);
_image.SelectActiveFrame(_dimension, (int) _currentGifImageNum);
_scaledImage = ScaleToGrid
? ScalePictureImage(_image, BufferWi, BufferHt)
: ScaleImage(_image, (double) ScalePercent/100);
if (ColorEffect == ColorEffect.GreyScale)
{
_scaledImage = (Bitmap) ConvertToGrayScale(_scaledImage);
}
_fp = new FastPixel.FastPixel(_scaledImage);
if (_fp != null)
{
int imageWidth = _fp.Width;
int imageHeight = _fp.Height;
double deltaX = 0;
double deltaY = 0;
double angleOffset;
if (dir > 45 && dir <= 90)
angleOffset = -(dir - 90);
else if (dir > 90 && dir <= 135)
angleOffset = dir - 90;
else if (dir > 135 && dir <= 180)
angleOffset = -(dir - 180);
else if (dir > 180 && dir <= 225)
angleOffset = dir - 180;
else if (dir > 225 && dir <= 270)
angleOffset = -(dir - 270);
else if (dir > 270 && dir <= 315)
angleOffset = dir - 270;
else if (dir > 315 && dir <= 360)
angleOffset = -(dir - 360);
else
angleOffset = dir;
double imageSpeed = _position*(imageWidth/(Math.Cos((Math.PI/180)*angleOffset)));
//Moving left and right
if (dir > 0 && dir <= 90)
{
deltaX = ((double) dir/90)*(imageSpeed);
}
else if (dir > 90 && dir <= 180)
{
deltaX = ((double) Math.Abs(dir - 180)/90)*(imageSpeed);
}
else if (dir > 180 && dir <= 270)
{
deltaX = -1*(((double) Math.Abs(dir - 180)/90)*(imageSpeed));
}
else if (dir > 270 && dir <= 360)
{
deltaX = -1*(((double) Math.Abs(dir - 360)/90)*(imageSpeed));
}
//Moving up and down
if (dir >= 0 && dir <= 90)
{
deltaY = (((double) Math.Abs(dir - 90)/90))*(imageSpeed);
}
else if (dir > 90 && dir <= 180)
{
deltaY = -1*(((double) Math.Abs(dir - 90)/90)*(imageSpeed));
}
else if (dir > 180 && dir <= 270)
{
deltaY = -1*(((double) Math.Abs(dir - 270)/90)*(imageSpeed));
}
else if (dir > 270 && dir <= 360)
{
deltaY = ((double) Math.Abs(270 - dir)/90)*(imageSpeed);
}
_movementX += deltaX;
_movementY += deltaY;
_fp.Lock();
Color fpColor = new Color();
int yoffset = (BufferHt + imageHeight)/2;
int xoffset = (imageWidth - BufferWi)/2;
int xOffsetAdj = XOffset*BufferWi/100;
int yOffsetAdj = YOffset*BufferHt/100;
int imageHt = imageHeight;
int imageWi = imageWidth;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = -(BufferHt) + (int) ((BufferHt + 5)*_position*2);
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset >= -1)
{
yoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureWiggle:
if (_position >= 0.5)
{
xoffset += (int) (BufferWi*((1.0 - _position)*2.0 - 0.5));
}
else
{
xoffset += (int) (BufferWi*(_position*2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Vertical)
{
yoffset = (imageHt - BufferWi)/2; //adjust offsets for other axis
}
else
{
yoffset = (imageWi - BufferHt)/2; //adjust offsets for other axis
}
if (Orientation == StringOrientation.Vertical)
{
xoffset = -(BufferHt) + (int) ((BufferHt + 5)*_position*2);
}
else
{
xoffset = -(BufferWi) + (int) ((BufferWi + 5)*_position*2);
}
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset >= -1)
{
xoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureTiles:
imageHt = BufferHt;
imageWi = BufferWi;
break;
}
for (int x = 0; x < imageWi; x++)
{
for (int y = 0; y < imageHt; y++)
{
if (Type != EffectType.RenderPictureTiles) // change this so only when tiles are disabled
{
fpColor = _fp.GetPixel(x, y);
}
var hsv = HSV.FromRGB(fpColor);
double tempV = hsv.V*level*((double) (IncreaseBrightness)/10);
if (tempV > 1)
tempV = 1;
hsv.V = tempV;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
if (fpColor != Color.Transparent)
{
//Peek a boo
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, BufferHt + yoffset - y + yOffsetAdj, hsv);
}
break;
case EffectType.RenderPictureWiggle:
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x + xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo90:
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(BufferWi + xoffset - y + xOffsetAdj, x - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo180:
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, y - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo270:
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(y - xoffset + xOffsetAdj, BufferHt + yoffset - x + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureLeft:
// left
int leftX = x + (BufferWi - (int) (_position*(imageWi + BufferWi)));
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(leftX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureRight:
// right
int rightX = x + -imageWi + (int) (_position*(imageWi + BufferWi));
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(rightX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUp:
// up
int upY = (int) ((imageHt + BufferHt)*_position) - y;
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpleft:
int upLeftY = (int) ((imageHt + BufferHt)*_position) - y;
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(
Convert.ToInt32(x + BufferWi - (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor) + xOffsetAdj,
upLeftY + yOffsetAdj, hsv);
break; // up-left
case EffectType.RenderPictureDownleft:
int downLeftY = BufferHt + imageHt - (int) ((imageHt + BufferHt)*_position) - y;
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(
Convert.ToInt32(x + BufferWi - (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor) + xOffsetAdj,
downLeftY + yOffsetAdj, hsv);
break; // down-left
case EffectType.RenderPictureUpright:
int upRightY = (int) ((imageHt + BufferHt)*_position) - y;
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(
Convert.ToInt32(x + (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor - imageWi) + xOffsetAdj,
upRightY + yOffsetAdj, hsv);
break; // up-right
case EffectType.RenderPictureDownright:
int downRightY = BufferHt + imageHt - (int) ((imageHt + BufferHt)*_position) - y;
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(
Convert.ToInt32(x + (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor - imageWi) + xOffsetAdj,
downRightY + yOffsetAdj, hsv);
break; // down-right
case EffectType.RenderPictureDown:
// down
int downY = (BufferHt + imageHt - 1) - (int) ((imageHt + BufferHt)*_position) - y;
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureNone:
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureTiles:
int colorX = x + Convert.ToInt32(_movementX) - (XOffset*BufferWi/100);
int colorY = y + Convert.ToInt32(_movementY) + (YOffset*BufferHt/100);
if (colorX >= 0)
{
colorX = colorX%imageWidth;
}
else if (colorX < 0)
{
colorX = Convert.ToInt32(colorX%imageWidth) + imageWidth - 1;
}
if (colorY >= 0)
{
colorY = Convert.ToInt32((colorY%imageHeight));
}
else if (colorY < 0)
{
colorY = Convert.ToInt32(colorY%imageHeight) + imageHeight - 1;
}
if (colorX <= _fp.Width && colorY <= _fp.Height)
{
fpColor = _fp.GetPixel(colorX, colorY);
hsv = HSV.FromRGB(fpColor);
hsv = CustomColor(hsv, frame, level, fpColor);
frameBuffer.SetPixel(x, BufferHt - y - 1, hsv);
}
break;
}
}
}
_fp.Unlock(false);
_fp.Dispose();
_scaledImage.Dispose();
}
}
public void RenderMovie(int dir, string dataFilePath, int movieSpeed)
{
const int speedfactor = 4;
if (_moviePicturesFileList == null || State == 0) {
LoadMoviePictureFileList(dataFilePath);
}
// If we don't have any pictures, do nothing!
if (_moviePicturesFileList == null || !_moviePicturesFileList.Any())
return;
int pictureCount = _moviePicturesFileList.Count;
if (movieSpeed > 0) {
currentMovieImageNum += ((movieSpeed*.01) + 1);
}
else if (movieSpeed < 0) {
currentMovieImageNum += (100 + movieSpeed)*.01;
}
else {
currentMovieImageNum++;
}
int currentImage = Convert.ToInt32(currentMovieImageNum);
if (currentImage >= pictureCount || currentImage < 0)
currentMovieImageNum = currentImage= 0;
var currentMovieImage = new FastPixel.FastPixel(new Bitmap(Image.FromFile(_moviePicturesFileList[currentImage])));
int imgwidth = currentMovieImage.Width;
int imght = currentMovieImage.Height;
int yoffset = (BufferHt + imght)/2;
int xoffset = (imgwidth - BufferWi)/2;
int limit = (dir < 2) ? imgwidth + BufferWi : imght + BufferHt;
int movement = Convert.ToInt32((State%(limit*speedfactor))/speedfactor);
// copy image to buffer
currentMovieImage.Lock();
Color fpColor = new Color();
for (int x = 0; x < imgwidth; x++) {
for (int y = 0; y < imght; y++) {
fpColor = currentMovieImage.GetPixel(x, y);
if (fpColor != Color.Transparent && fpColor != Color.Black) {
switch (dir) {
case 1:
// left
SetPixel(x + BufferWi - movement, yoffset - y, fpColor);
break;
case 2:
// right
SetPixel(x + movement - imgwidth, yoffset - y, fpColor);
break;
case 3:
// up
SetPixel(x - xoffset, movement - y, fpColor);
break;
case 4:
// down
SetPixel(x - xoffset, BufferHt + imght - y - movement, fpColor);
break;
default:
// no movement - centered
SetPixel(x - xoffset, yoffset - y, fpColor);
break;
}
}
}
}
currentMovieImage.Unlock(false);
currentMovieImage.Dispose();
}
public override void Layout()
{
ElementNode node = null;
if (PixelCount > 0) {
node = _pixels[0].Node;
_pixels.Clear();
}
else if (initiallyAssignedNode != null) {
if (initiallyAssignedNode.IsLeaf) {
node = initiallyAssignedNode;
}
}
Point boundsTopLeft = new Point();
boundsTopLeft.X = Math.Min(_topLeft.X, Math.Min(Math.Min(_topRight.X, _bottomRight.X), _bottomLeft.X));
boundsTopLeft.Y = Math.Min(_topLeft.Y, Math.Min(Math.Min(_topRight.Y, _bottomRight.Y), _bottomLeft.Y));
Point bottomRight = new Point();
bottomRight.X = Math.Max(_topLeft.X, Math.Max(Math.Max(_topRight.X, _bottomRight.X), _bottomLeft.X));
bottomRight.Y = Math.Max(_topLeft.Y, Math.Max(Math.Max(_topRight.Y, _bottomRight.Y), _bottomLeft.Y));
Rectangle rect = new Rectangle(boundsTopLeft,
new Size(bottomRight.X - boundsTopLeft.X, bottomRight.Y - boundsTopLeft.Y));
Point tL = new Point(_topLeft.X - boundsTopLeft.X, _topLeft.Y - boundsTopLeft.Y);
Point tR = new Point(_topRight.X - boundsTopLeft.X, _topRight.Y - boundsTopLeft.Y);
Point bL = new Point(_bottomLeft.X - boundsTopLeft.X, _bottomLeft.Y - boundsTopLeft.Y);
Point bR = new Point(_bottomRight.X - boundsTopLeft.X, _bottomRight.Y - boundsTopLeft.Y);
Point[] points = {tL, tR, bR, bL};
if (rect.Width > 0 && rect.Height > 0) {
using (var b = new Bitmap(rect.Width, rect.Height)) {
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.FillPolygon(Brushes.White, points);
using (FastPixel.FastPixel fp = new FastPixel.FastPixel(b)) {
fp.Lock();
int xCount = 1;
int spacingY = _pixelSpacing;
for (int y = 0; y < rect.Height; y++) {
if (spacingY%_pixelSpacing == 0) {
int xDiv;
if (xCount%2 == 0)
xDiv = _pixelSpacing;
else
xDiv = _pixelSpacing/2;
for (int x = 0; x < rect.Width; x++) {
if ((x + xDiv)%_pixelSpacing == 0) {
Color newColor = fp.GetPixel(x, y);
if (newColor.A != 0) {
PreviewPixel pixel = new PreviewPixel(x + boundsTopLeft.X, y + boundsTopLeft.Y, 0, PixelSize);
pixel.Node = node;
_pixels.Add(pixel);
}
}
}
xCount += 1;
}
spacingY += 1;
}
fp.Unlock(false);
}
}
}
}
private void buttonImport_Click(object sender, EventArgs e)
{
OpenFileDialog fileDlg = new OpenFileDialog();
fileDlg.Filter = "Image Files (*.bmp, *.jpg, *.png)|*.bmp;*.jpg;*.png|All Files(*.*)|*.*";
DialogResult result = fileDlg.ShowDialog();
if (result == DialogResult.OK)
{
LipSyncMapItem mapItem;
Color pixelColor;
Bitmap rawBitmap = new Bitmap(fileDlg.FileName);
FastPixel.FastPixel scaledImage =
new FastPixel.FastPixel(new Bitmap(rawBitmap, CalcNumDataGridCols, CalcNumDataGridRows));
int cols = CalcNumDataGridCols;
int rows = CalcNumDataGridRows;
scaledImage.Lock();
for (int row = 0; row < rows; row++)
{
DataRow dr = currentDataTable.Rows[row];
for (int col = 0; col < cols; col++)
{
mapItem = FindRenderMapItem(row, col);
if (mapItem != null)
{
pixelColor = scaledImage.GetPixel(col, row);
dr[col] = pixelColor;
mapItem.PhonemeList[CurrentPhonemeString] = (pixelColor != Color.Black);
}
else
{
dr[col] = Color.Gray;
}
}
}
scaledImage.Unlock(false);
BuildDialogFromMap(_newMapping);
updatedataGridView1();
Refresh();
}
}
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
double position = (GetEffectTimeIntervalPosition(frame) * Speed) % 1;
double level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
// If we don't have any pictures, do nothing!
if (_moviePicturesFileList == null || !_moviePicturesFileList.Any())
{
return;
}
int pictureCount = _moviePicturesFileList.Count;
if (PlayBackSpeed > 0)
{
_currentMovieImageNum += ((PlayBackSpeed * .01) + 1);
}
else if (PlayBackSpeed < 0)
{
_currentMovieImageNum += (100 + PlayBackSpeed) * .01;
}
else
{
_currentMovieImageNum++;
}
int currentImage = Convert.ToInt32(_currentMovieImageNum);
if (currentImage >= pictureCount || currentImage < 0)
{
_currentMovieImageNum = currentImage = 0;
}
// copy image to buffer
Bitmap resizeImage = new Bitmap(Image.FromFile(_moviePicturesFileList[currentImage]));
FastPixel.FastPixel currentMovieImage = new FastPixel.FastPixel(new Bitmap(resizeImage));
int imgwidth = currentMovieImage.Width;
int imght = currentMovieImage.Height;
int yoffset = (BufferHt + imght) / 2;
int xoffset = (imgwidth - BufferWi) / 2;
int xOffsetAdj = XOffset * BufferWi / 100;
int yOffsetAdj = YOffset * BufferHt / 100;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = -(BufferHt) + (int)((BufferHt + 5) * position * 2);
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset >= -1)
{
yoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureWiggle:
if (position >= 0.5)
{
xoffset += (int)(BufferWi * ((1.0 - position) * 2.0 - 0.5));
}
else
{
xoffset += (int)(BufferWi * (position * 2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Vertical)
{
yoffset = (imght - BufferWi) / 2; //adjust offsets for other axis
xoffset = -(BufferHt) + (int)((BufferHt + 5) * position * 2);
}
else
{
yoffset = (imgwidth - BufferHt) / 2; //adjust offsets for other axis
xoffset = -(BufferWi) + (int)((BufferWi + 5) * position * 2);
}
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset >= -1)
{
xoffset = -1; //pause in middle
}
break;
}
currentMovieImage.Lock();
Color fpColor = new Color();
for (int x = 0; x < imgwidth; x++)
{
for (int y = 0; y < imght; y++)
{
fpColor = currentMovieImage.GetPixel(x, y);
if (fpColor != Color.Transparent && fpColor != Color.Black)
{
var hsv = HSV.FromRGB(fpColor);
double tempV = hsv.V * level * ((double)(IncreaseBrightness) / 10);
if (tempV > 1)
{
tempV = 1;
}
hsv.V = tempV;
int leftX, rightX, upY, downY;
switch (_data.EffectType)
{
case EffectType.RenderPictureLeft:
// left
leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
frameBuffer.SetPixel(leftX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureRight:
// right
rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUp:
// up
upY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDown:
// down
downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpleft:
// up-left
leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
upY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(leftX + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDownleft:
// down-left
leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(leftX + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpright:
// up-right
upY = (int)((imght + BufferHt) * position) - y;
rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDownright:
// down-right
downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo0:
// Peek a boo 0
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, BufferHt + yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureWiggle:
// Wiggle
frameBuffer.SetPixel(x + xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo90:
// Peekaboo90
frameBuffer.SetPixel(BufferWi + xoffset - y + xOffsetAdj, x - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo180:
// Peekaboo180
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, y - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo270:
// Peekaboo270
frameBuffer.SetPixel(y - xoffset + xOffsetAdj, BufferHt + yoffset - x + yOffsetAdj, hsv);
break;
default:
// no movement - centered
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
}
}
}
}
currentMovieImage.Unlock(false);
currentMovieImage.Dispose();
resizeImage.Dispose();
}
private void CalculatePixel(int x, int y, IPixelFrameBuffer frameBuffer, int frame, double level, double adjustedBrightness, ref int bufferHt, ref int bufferWi, bool locations = false, int bufferHtOffset = 0, int bufferWiOffset = 0)
{
int yCoord = y;
int xCoord = x;
int locationY = 0;
int locationX = 0;
Color fpColor = Color.Empty;
if (locations)
{
//Flip me over and offset my coordinates so I can act like the string version
y = Math.Abs((bufferHtOffset - y) + (bufferHt - 1 + bufferHtOffset));
y = y - bufferHtOffset;
x = x - bufferWiOffset;
}
else
{
fpColor = GetIntensity(level, _fp.GetPixel(x, y), adjustedBrightness);
}
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = bufferHt + _yoffset - y + _yOffsetAdj;
locationX = x + _xoffset - _xOffsetAdj;
break;
}
frameBuffer.SetPixel(xCoord - _xoffset + _xOffsetAdj, bufferHt + _yoffset - yCoord + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureWiggle:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = _yoffset - y + _yOffsetAdj;
locationX = x - _xoffset - _xOffsetAdj - bufferWi + _imageWi;
break;
}
frameBuffer.SetPixel(xCoord + _xoffset + _xOffsetAdj + bufferWi - _imageWi, _yoffset - yCoord + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPicturePeekaboo90:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = _xoffset + bufferWi - x - _xOffsetAdj;
locationX = bufferHt - y - _yOffsetAdj - _yoffset;
break;
}
frameBuffer.SetPixel(bufferWi + _xoffset - yCoord + _xOffsetAdj, bufferHt - xCoord - _yoffset + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPicturePeekaboo180:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = y - _yOffsetAdj + bufferHt - _imageHt + _yoffset;
locationX = (bufferWi - x) + _xoffset + _xOffsetAdj;
break;
}
if (Orientation == StringOrientation.Horizontal)
{
frameBuffer.SetPixel((_imageWi - xCoord) - _xoffset + _xOffsetAdj - bufferWi + bufferWi, yCoord - _yoffset + _yOffsetAdj, fpColor);
}
else
{
frameBuffer.SetPixel((bufferWi - xCoord) - _xoffset + _xOffsetAdj - _imageWi + bufferWi, yCoord - _yoffset + _yOffsetAdj, fpColor);
}
return;
case EffectType.RenderPicturePeekaboo270:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = _xoffset + x - _xOffsetAdj;
locationX = y - _yOffsetAdj - _yoffset;
break;
}
frameBuffer.SetPixel(yCoord - _xoffset + _xOffsetAdj, bufferHt + _yoffset - (bufferHt - xCoord) + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureLeft:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = _yoffset - y + _yOffsetAdj;
locationX = ((x - bufferWi) + (int)(_position * (_imageWi + bufferWi))) + _xOffsetAdj;
break;
}
int leftX = xCoord + (bufferWi - (int)(_position * (_imageWi + bufferWi)));
frameBuffer.SetPixel(leftX + _xOffsetAdj, _yoffset - y + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureRight:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = _yoffset - y + _yOffsetAdj;
locationX = ((x + _imageWi) - (int)(_position * (_imageWi + bufferWi))) + _xOffsetAdj;
break;
}
int rightX = xCoord + -_imageWi + (int)(_position * (_imageWi + bufferWi));
frameBuffer.SetPixel(rightX + _xOffsetAdj, _yoffset - yCoord + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureUp:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = ((int)((_imageHt + bufferHt) * _position) - y) + _yOffsetAdj;
locationX = x + _xoffset - _xOffsetAdj;
break;
}
int upY = (int)((_imageHt + bufferHt) * _position) - y;
frameBuffer.SetPixel(xCoord - _xoffset + _xOffsetAdj, upY + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureDown:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = ((bufferHt + _imageHt - 1) - (int)((_imageHt + bufferHt) * _position) - y) + _yOffsetAdj;
locationX = x + _xoffset - _xOffsetAdj;
break;
}
int downY = (bufferHt + _imageHt - 1) - (int)((_imageHt + bufferHt) * _position) - yCoord;
frameBuffer.SetPixel(x - _xoffset + _xOffsetAdj, downY + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureUpleft:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = ((int)((_imageHt + bufferHt) * _position) - y) + _yOffsetAdj;
locationX = (x - bufferWi + (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor) + _xOffsetAdj;
break;
}
int upLeftY = (int)((_imageHt + bufferHt) * _position) - yCoord;
frameBuffer.SetPixel(
Convert.ToInt32(xCoord + bufferWi - (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor) + _xOffsetAdj,
upLeftY + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureDownleft:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = ((bufferHt + _imageHt - 1) - (int)((_imageHt + bufferHt) * _position) - y) + _yOffsetAdj;
locationX = (x - bufferWi + (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor) + _xOffsetAdj;
break;
}
int downLeftY = bufferHt + _imageHt - (int)((_imageHt + bufferHt) * _position) - yCoord;
frameBuffer.SetPixel(
Convert.ToInt32(xCoord + bufferWi - (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor) + _xOffsetAdj,
downLeftY + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureUpright:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = ((int)((_imageHt + bufferHt) * _position) - y) + _yOffsetAdj;
locationX = (x + _imageWi - (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor) + _xOffsetAdj;
break;
}
int upRightY = (int)((_imageHt + bufferHt) * _position) - yCoord;
frameBuffer.SetPixel(
Convert.ToInt32(xCoord + (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor - _imageWi) + _xOffsetAdj,
upRightY + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureDownright:
if (TargetPositioning == TargetPositioningType.Locations)
{
locationY = ((bufferHt + _imageHt - 1) - (int)((_imageHt + bufferHt) * _position) - y) + _yOffsetAdj;
locationX = (x + _imageWi - (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor) + _xOffsetAdj;
break;
}
int downRightY = bufferHt + _imageHt - (int)((_imageHt + bufferHt) * _position) - yCoord;
frameBuffer.SetPixel(
Convert.ToInt32(xCoord + (MovementRate * frame % ((_imageWi + bufferWi) * SpeedFactor)) / SpeedFactor - _imageWi) + _xOffsetAdj,
downRightY + _yOffsetAdj, fpColor);
return;
case EffectType.RenderPictureNone:
if (locations)
{
locationY = _yoffset - y + _yOffsetAdj;
locationX = x + _xoffset - _xOffsetAdj;
break;
}
frameBuffer.SetPixel(xCoord - _xoffset + _xOffsetAdj, _yoffset - yCoord + _yOffsetAdj, fpColor);
return;
}
//will only get to here if Location and/or Tiles is selected.
if (locationX < _fp.Width && locationY < _fp.Height && locationX >= 0 && locationY >= 0)
{
fpColor = GetIntensity(level, _fp.GetPixel(locationX, locationY), adjustedBrightness);
frameBuffer.SetPixel(xCoord, yCoord, fpColor);
}
}
public void RenderPictures(int dir, string newPictureName, int gifSpeed, bool scaleToGrid, int scalePct)
{
if (String.IsNullOrEmpty(newPictureName))
{
return;
}
const int speedfactor = 4;
var effectType = (EffectType)dir;
if (newPictureName != _pictureName)
{
try
{
//This crazyness is to allow the file handle to be released on the file we are using. Otherwise it is locked
//And if you try to use the same image when you switch to picture tiles, it will have an
//file locked error
using (var fs = new FileStream(Path.Combine(NutcrackerDescriptor.ModulePath, newPictureName), FileMode.Open, FileAccess.Read))
{
var ms = new MemoryStream();
fs.CopyTo(ms);
ms.Position = 0;
if (_pictureImage != null)
{
_pictureImage.Dispose();
}
_pictureImage = Image.FromStream(ms);
}
_pictureName = newPictureName;
}
catch (Exception e)
{
Logging.Error("Error loading pictue file for nutcracker pictures", e);
}
}
var dimension = new FrameDimension(_pictureImage.FrameDimensionsList[0]);
// Number of frames
int frameCount = _pictureImage.GetFrameCount(dimension);
if (frameCount > 1)
{
if (gifSpeed > 0)
{
_currentGifImageNum += ((gifSpeed * .05));
}
else
{
_currentGifImageNum++;
}
if (Convert.ToInt32(_currentGifImageNum) >= frameCount)
{
_currentGifImageNum = 0;
}
_pictureImage.SelectActiveFrame(dimension, Convert.ToInt32(_currentGifImageNum));
}
Image image = scaleToGrid ? ScaleImage(_pictureImage, BufferWi, BufferHt) : ScaleImage(_pictureImage, _pictureImage.Width * scalePct / 10, _pictureImage.Height * scalePct / 10);
_fp = new FastPixel.FastPixel(new Bitmap(image));
if (_fp != null)
{
int imgwidth = _fp.Width;
int imght = _fp.Height;
int yoffset = (BufferHt + imght) / 2;
int xoffset = (imgwidth - BufferWi) / 2;
//int limit = (dir < 2) ? imgwidth + BufferWi : imght + BufferHt;
//int movement = Convert.ToInt32((State % (limit * speedfactor)) / speedfactor);
switch (effectType)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = Convert.ToInt32(State / speedfactor - BufferHt); // * speedfactor; //draw_at = (state < BufferHt)? state
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset > 0)
{
yoffset = 0; //pause in middle
}
break;
case EffectType.RenderPictureWiggle: //wiggle left-right -DJ
xoffset = Convert.ToInt32(State % (BufferWi / 4 * speedfactor));
if (xoffset > BufferWi / 8 * speedfactor)
{
xoffset = BufferWi / 4 * speedfactor - xoffset; //reverse direction
}
xoffset -= BufferWi / 4; //* speedfactor; //center it on mid value
xoffset += (imgwidth - BufferWi) / 2; //add in original xoffset from above
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
yoffset = (imght - BufferWi) / 2; //adjust offsets for other axis
xoffset = Convert.ToInt32(State / speedfactor - BufferHt); // * speedfactor; //draw_at = (state < BufferHt)? state
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset > 0)
{
xoffset = 0; //pause in middle
}
break;
default:
break;
}
// copy image to buffer
_fp.Lock();
for (int x = 0; x < imgwidth; x++)
{
for (int y = 0; y < imght; y++)
{
//if (!image.IsTransparent(x,y))
Color fpColor = _fp.GetPixel(x, y);
if (fpColor != Color.Transparent)
{
switch (effectType)
{
case EffectType.RenderPictureLeft:
// left
SetPixel(Convert.ToInt32(x + BufferWi - (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor), yoffset - y, fpColor);
break;
case EffectType.RenderPictureRight:
// right
SetPixel(Convert.ToInt32(x + (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth), yoffset - y, fpColor);
break;
case EffectType.RenderPictureUp:
// up
SetPixel(x - xoffset, Convert.ToInt32((State % ((imght + BufferHt) * speedfactor)) / speedfactor - y), fpColor);
break;
case EffectType.RenderPictureDown:
// down
SetPixel(x - xoffset, Convert.ToInt32(BufferHt + imght - y - (State % ((imght + BufferHt) * speedfactor)) / speedfactor), fpColor);
break;
case EffectType.RenderPictureUpleft:
SetPixel(Convert.ToInt32(x + BufferWi - (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor), Convert.ToInt32((State % ((imght + BufferHt) * speedfactor)) / speedfactor - y), fpColor);
break; // up-left
case EffectType.RenderPictureDownleft:
SetPixel(Convert.ToInt32(x + BufferWi - (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor), Convert.ToInt32(BufferHt + imght - y - (State % ((imght + BufferHt) * speedfactor)) / speedfactor), fpColor);
break; // down-left
case EffectType.RenderPictureUpright:
SetPixel(Convert.ToInt32(x + (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth), Convert.ToInt32((State % ((imght + BufferHt) * speedfactor)) / speedfactor - y), fpColor);
break; // up-right
case EffectType.RenderPictureDownright:
SetPixel(Convert.ToInt32(x + (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth), Convert.ToInt32(BufferHt + imght - y - (State % ((imght + BufferHt) * speedfactor)) / speedfactor), fpColor);
break; // down-right
case EffectType.RenderPicturePeekaboo0:
//Peek a boo
SetPixel(x - xoffset, BufferHt + yoffset - y, fpColor);
break;
case EffectType.RenderPictureWiggle:
SetPixel(x + xoffset, yoffset - y, fpColor);
break;
case EffectType.RenderPicturePeekaboo90:
SetPixel(BufferWi + xoffset - y, x - yoffset, fpColor);
break;
case EffectType.RenderPicturePeekaboo180:
SetPixel(x - xoffset, y - yoffset, fpColor);
break;
case EffectType.RenderPicturePeekaboo270:
SetPixel(y - xoffset, BufferHt + yoffset - x, fpColor);
break;
default:
// no movement - centered
SetPixel(x - xoffset, yoffset - y, fpColor);
break;
}
}
}
}
_fp.Unlock(false);
}
if (image != null)
{
image.Dispose();
}
}
protected override void RenderEffect(int frame, ref PixelFrameBuffer frameBuffer)
{
if (_image == null) return;
const int speedfactor = 4;
double position = (GetEffectTimeIntervalPosition(frame) * Speed) % 1;
double level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
CalculateImageNumberByPosition(position);
_image.SelectActiveFrame(_dimension,(int) _currentGifImageNum);
_scaledImage = ScaleToGrid ? ScaleImage(_image, BufferWi, BufferHt) : ScaleImage(_image, _image.Width * ScalePercent / 100, _image.Height * ScalePercent / 100);
_fp = new FastPixel.FastPixel(_scaledImage);
int imgwidth = _fp.Width;
int imght = _fp.Height;
int yoffset = (BufferHt + imght) / 2;
int xoffset = (imgwidth - BufferWi) / 2;
int state = Speed * frame;
int xOffsetAdj = XOffset*BufferWi/100;
int yOffsetAdj = YOffset*BufferHt/100;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = -(BufferHt) + (int)((BufferHt+5)*position*2);
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset >= -1)
{
yoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureWiggle:
if (position >= 0.5)
{
xoffset += (int)(BufferWi * ((1.0 - position) * 2.0 - 0.5));
}
else
{
xoffset += (int)(BufferWi * (position * 2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Vertical)
{
yoffset = (imght - BufferWi)/2; //adjust offsets for other axis
}
else
{
yoffset = (imgwidth - BufferHt) / 2; //adjust offsets for other axis
}
if (Orientation == StringOrientation.Vertical)
{
xoffset = -(BufferHt) + (int) ((BufferHt + 5)*position*2);
}
else
{
xoffset = -(BufferWi) + (int)((BufferWi + 5) * position * 2);
}
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset >= -1)
{
xoffset = -1; //pause in middle
}
break;
}
_fp.Lock();
for (int x = 0; x < imgwidth; x++)
{
for (int y = 0; y < imght; y++)
{
//if (!image.IsTransparent(x,y))
Color color = _fp.GetPixel(x, y);
if (color != Color.Transparent)
{
var hsv = HSV.FromRGB(color);
hsv.V = hsv.V * level;
switch (Type)
{
case EffectType.RenderPictureLeft:
// left
int leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
frameBuffer.SetPixel(leftX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureRight:
// right
int rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUp:
// up
int upY = (int)((imght + BufferHt) *position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDown:
// down
int downY = (BufferHt + imght-1) - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, downY+yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpleft:
int upLeftY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + BufferWi - (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor) + xOffsetAdj, upLeftY+yOffsetAdj, hsv);
break; // up-left
case EffectType.RenderPictureDownleft:
int downLeftY = BufferHt + imght - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + BufferWi - (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor) + xOffsetAdj, downLeftY+yOffsetAdj, hsv);
break; // down-left
case EffectType.RenderPictureUpright:
int upRightY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth)+xOffsetAdj, upRightY+yOffsetAdj, hsv);
break; // up-right
case EffectType.RenderPictureDownright:
int downRightY = BufferHt + imght - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth) + xOffsetAdj, downRightY+yOffsetAdj, hsv);
break; // down-right
case EffectType.RenderPicturePeekaboo0:
//Peek a boo
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, BufferHt + yoffset - y+yOffsetAdj, hsv);
break;
case EffectType.RenderPictureWiggle:
frameBuffer.SetPixel(x + xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo90:
frameBuffer.SetPixel(BufferWi + xoffset - y + xOffsetAdj, x - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo180:
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, y - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo270:
frameBuffer.SetPixel(y - xoffset + xOffsetAdj, BufferHt + yoffset - x + yOffsetAdj, hsv);
break;
default:
// no movement - centered
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
}
}
}
}
_fp.Unlock(false);
_fp.Dispose();
_scaledImage.Dispose();
}
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
double position = (GetEffectTimeIntervalPosition(frame) * Speed) % 1;
double level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
// If we don't have any pictures, do nothing!
if (_moviePicturesFileList == null || !_moviePicturesFileList.Any())
return;
int pictureCount = _moviePicturesFileList.Count;
if (PlayBackSpeed > 0)
{
_currentMovieImageNum += ((PlayBackSpeed * .01) + 1);
}
else if (PlayBackSpeed < 0)
{
_currentMovieImageNum += (100 + PlayBackSpeed) * .01;
}
else
{
_currentMovieImageNum ++;
}
int currentImage = Convert.ToInt32(_currentMovieImageNum);
if (currentImage >= pictureCount || currentImage < 0)
_currentMovieImageNum = currentImage = 0;
// copy image to buffer
Bitmap resizeImage = new Bitmap(Image.FromFile(_moviePicturesFileList[currentImage]));
FastPixel.FastPixel currentMovieImage = new FastPixel.FastPixel(new Bitmap(resizeImage));
int imgwidth = currentMovieImage.Width;
int imght = currentMovieImage.Height;
int yoffset = (BufferHt + imght) / 2;
int xoffset = (imgwidth - BufferWi) / 2;
int xOffsetAdj = XOffset * BufferWi / 100;
int yOffsetAdj = YOffset * BufferHt / 100;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = -(BufferHt) + (int)((BufferHt + 5) * position * 2);
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset >= -1)
{
yoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureWiggle:
if (position >= 0.5)
{
xoffset += (int)(BufferWi * ((1.0 - position) * 2.0 - 0.5));
}
else
{
xoffset += (int)(BufferWi * (position * 2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Vertical)
{
yoffset = (imght - BufferWi) / 2; //adjust offsets for other axis
xoffset = -(BufferHt) + (int)((BufferHt + 5) * position * 2);
}
else
{
yoffset = (imgwidth - BufferHt) / 2; //adjust offsets for other axis
xoffset = -(BufferWi) + (int)((BufferWi + 5) * position * 2);
}
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset >= -1)
{
xoffset = -1; //pause in middle
}
break;
}
currentMovieImage.Lock();
Color fpColor = new Color();
for (int x = 0; x < imgwidth; x++)
{
for (int y = 0; y < imght; y++)
{
fpColor = currentMovieImage.GetPixel(x, y);
if (fpColor != Color.Transparent && fpColor != Color.Black)
{
var hsv = HSV.FromRGB(fpColor);
double tempV = hsv.V * level * ((double)(IncreaseBrightness)/10);
if (tempV > 1)
tempV = 1;
hsv.V = tempV;
int leftX, rightX, upY, downY;
switch (_data.EffectType)
{
case EffectType.RenderPictureLeft:
// left
leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
frameBuffer.SetPixel(leftX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureRight:
// right
rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUp:
// up
upY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDown:
// down
downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpleft:
// up-left
leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
upY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(leftX + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDownleft:
// down-left
leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(leftX + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpright:
// up-right
upY = (int)((imght + BufferHt) * position) - y;
rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDownright:
// down-right
downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo0:
// Peek a boo 0
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, BufferHt + yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureWiggle:
// Wiggle
frameBuffer.SetPixel(x + xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo90:
// Peekaboo90
frameBuffer.SetPixel(BufferWi + xoffset - y + xOffsetAdj, x - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo180:
// Peekaboo180
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, y - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo270:
// Peekaboo270
frameBuffer.SetPixel(y - xoffset + xOffsetAdj, BufferHt + yoffset - x + yOffsetAdj, hsv);
break;
default:
// no movement - centered
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
}
}
}
}
currentMovieImage.Unlock(false);
currentMovieImage.Dispose();
resizeImage.Dispose();
}
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
if (_image != null)
{
var dir = 360 - Direction;
var intervalPos = GetEffectTimeIntervalPosition(frame);
var intervalPosFactor = intervalPos * 100;
double level = LevelCurve.GetValue(intervalPosFactor) / 100;
double adjustedBrightness = (double)(CalculateIncreaseBrightness(intervalPosFactor)) / 10;
int speedFactor = 4;
int state = MovementRate * frame;
if (Type != EffectType.RenderPictureTiles && Type != EffectType.RenderPictureNone)
{
_position = ((GetEffectTimeIntervalPosition(frame) * Speed) % 1);
}
else if (frame == 0)
{
_position = ((GetEffectTimeIntervalPosition(frame + 1) * Speed) % 1);
}
CalculateImageNumberByPosition((GetEffectTimeIntervalPosition(frame) * GifSpeed) % 1);
_image.SelectActiveFrame(_dimension, (int)_currentGifImageNum);
_scaledImage = ScaleToGrid
? ScalePictureImage(_image, BufferWi, BufferHt)
: ScaleImage(_image, (double)ScalePercent / 100);
if (ColorEffect == ColorEffect.GreyScale)
{
_scaledImage = (Bitmap)ConvertToGrayScale(_scaledImage);
}
_fp = new FastPixel.FastPixel(_scaledImage);
if (_fp != null)
{
int imageWidth = _fp.Width;
int imageHeight = _fp.Height;
double deltaX = 0;
double deltaY = 0;
double angleOffset;
if (dir > 45 && dir <= 90)
{
angleOffset = -(dir - 90);
}
else if (dir > 90 && dir <= 135)
{
angleOffset = dir - 90;
}
else if (dir > 135 && dir <= 180)
{
angleOffset = -(dir - 180);
}
else if (dir > 180 && dir <= 225)
{
angleOffset = dir - 180;
}
else if (dir > 225 && dir <= 270)
{
angleOffset = -(dir - 270);
}
else if (dir > 270 && dir <= 315)
{
angleOffset = dir - 270;
}
else if (dir > 315 && dir <= 360)
{
angleOffset = -(dir - 360);
}
else
{
angleOffset = dir;
}
double imageSpeed = _position * (imageWidth / (Math.Cos((Math.PI / 180) * angleOffset)));
//Moving left and right
if (dir > 0 && dir <= 90)
{
deltaX = ((double)dir / 90) * (imageSpeed);
}
else if (dir > 90 && dir <= 180)
{
deltaX = ((double)Math.Abs(dir - 180) / 90) * (imageSpeed);
}
else if (dir > 180 && dir <= 270)
{
deltaX = -1 * (((double)Math.Abs(dir - 180) / 90) * (imageSpeed));
}
else if (dir > 270 && dir <= 360)
{
deltaX = -1 * (((double)Math.Abs(dir - 360) / 90) * (imageSpeed));
}
//Moving up and down
if (dir >= 0 && dir <= 90)
{
deltaY = (((double)Math.Abs(dir - 90) / 90)) * (imageSpeed);
}
else if (dir > 90 && dir <= 180)
{
deltaY = -1 * (((double)Math.Abs(dir - 90) / 90) * (imageSpeed));
}
else if (dir > 180 && dir <= 270)
{
deltaY = -1 * (((double)Math.Abs(dir - 270) / 90) * (imageSpeed));
}
else if (dir > 270 && dir <= 360)
{
deltaY = ((double)Math.Abs(270 - dir) / 90) * (imageSpeed);
}
_movementX += deltaX;
_movementY += deltaY;
_fp.Lock();
Color fpColor = new Color();
int yoffset = (BufferHt + imageHeight) / 2;
int xoffset = (imageWidth - BufferWi) / 2;
int xOffsetAdj = CalculateXOffset(intervalPosFactor) * BufferWi / 100;
int yOffsetAdj = CalculateYOffset(intervalPosFactor) * BufferHt / 100;
int imageHt = imageHeight;
int imageWi = imageWidth;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = -(BufferHt) + (int)((BufferHt + 5) * _position * 2);
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset >= -1)
{
yoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureWiggle:
if (_position >= 0.5)
{
xoffset += (int)(BufferWi * ((1.0 - _position) * 2.0 - 0.5));
}
else
{
xoffset += (int)(BufferWi * (_position * 2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Vertical)
{
yoffset = (imageHt - BufferWi) / 2; //adjust offsets for other axis
}
else
{
yoffset = (imageWi - BufferHt) / 2; //adjust offsets for other axis
}
if (Orientation == StringOrientation.Vertical)
{
xoffset = -(BufferHt) + (int)((BufferHt + 5) * _position * 2);
}
else
{
xoffset = -(BufferWi) + (int)((BufferWi + 5) * _position * 2);
}
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset >= -1)
{
xoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureTiles:
imageHt = BufferHt;
imageWi = BufferWi;
break;
}
for (int x = 0; x < imageWi; x++)
{
for (int y = 0; y < imageHt; y++)
{
if (Type != EffectType.RenderPictureTiles) // change this so only when tiles are disabled
{
fpColor = _fp.GetPixel(x, y);
}
var hsv = HSV.FromRGB(fpColor);
double tempV = hsv.V * level * adjustedBrightness;
if (tempV > 1)
{
tempV = 1;
}
hsv.V = tempV;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
if (fpColor != Color.Transparent)
{
//Peek a boo
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, BufferHt + yoffset - y + yOffsetAdj, hsv);
}
break;
case EffectType.RenderPictureWiggle:
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(x + xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo90:
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(BufferWi + xoffset - y + xOffsetAdj, BufferHt - x - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo180:
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
if (StringOrientation == StringOrientation.Vertical)
{
frameBuffer.SetPixel((BufferWi - x) - xoffset + xOffsetAdj, y - yoffset + yOffsetAdj, hsv);
}
else
{
frameBuffer.SetPixel((BufferWi - x) - xoffset + xOffsetAdj - (BufferWi / 2), y - yoffset + yOffsetAdj, hsv);
}
break;
case EffectType.RenderPicturePeekaboo270:
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(y - xoffset + xOffsetAdj, BufferHt + yoffset - (BufferHt - x) + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureLeft:
// left
int leftX = x + (BufferWi - (int)(_position * (imageWi + BufferWi)));
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(leftX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureRight:
// right
int rightX = x + -imageWi + (int)(_position * (imageWi + BufferWi));
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(rightX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUp:
// up
int upY = (int)((imageHt + BufferHt) * _position) - y;
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpleft:
int upLeftY = (int)((imageHt + BufferHt) * _position) - y;
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(
Convert.ToInt32(x + BufferWi - (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor) + xOffsetAdj,
upLeftY + yOffsetAdj, hsv);
break; // up-left
case EffectType.RenderPictureDownleft:
int downLeftY = BufferHt + imageHt - (int)((imageHt + BufferHt) * _position) - y;
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(
Convert.ToInt32(x + BufferWi - (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor) + xOffsetAdj,
downLeftY + yOffsetAdj, hsv);
break; // down-left
case EffectType.RenderPictureUpright:
int upRightY = (int)((imageHt + BufferHt) * _position) - y;
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(
Convert.ToInt32(x + (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor - imageWi) + xOffsetAdj,
upRightY + yOffsetAdj, hsv);
break; // up-right
case EffectType.RenderPictureDownright:
int downRightY = BufferHt + imageHt - (int)((imageHt + BufferHt) * _position) - y;
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(
Convert.ToInt32(x + (state % ((imageWi + BufferWi) * speedFactor)) / speedFactor - imageWi) + xOffsetAdj,
downRightY + yOffsetAdj, hsv);
break; // down-right
case EffectType.RenderPictureDown:
// down
int downY = (BufferHt + imageHt - 1) - (int)((imageHt + BufferHt) * _position) - y;
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureNone:
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureTiles:
int colorX = x + Convert.ToInt32(_movementX) - (xOffsetAdj * BufferWi / 100);
int colorY = y + Convert.ToInt32(_movementY) + (yOffsetAdj * BufferHt / 100);
if (colorX >= 0)
{
colorX = colorX % imageWidth;
}
else if (colorX < 0)
{
colorX = Convert.ToInt32(colorX % imageWidth) + imageWidth - 1;
}
if (colorY >= 0)
{
colorY = Convert.ToInt32((colorY % imageHeight));
}
else if (colorY < 0)
{
colorY = Convert.ToInt32(colorY % imageHeight) + imageHeight - 1;
}
if (colorX <= _fp.Width && colorY <= _fp.Height)
{
fpColor = _fp.GetPixel(colorX, colorY);
hsv = HSV.FromRGB(fpColor);
hsv = CustomColor(hsv, frame, level, fpColor, adjustedBrightness);
frameBuffer.SetPixel(x, BufferHt - y - 1, hsv);
}
break;
}
}
}
_fp.Unlock(false);
_fp.Dispose();
_scaledImage.Dispose();
}
}
}
public void RenderPictures(int dir, string newPictureName, int gifSpeed, bool scaleToGrid, int scalePct)
{
if (String.IsNullOrEmpty(newPictureName)) return;
const int speedfactor = 4;
var effectType = (EffectType)dir;
if (newPictureName != _pictureName)
{
try
{
//This crazyness is to allow the file handle to be released on the file we are using. Otherwise it is locked
//And if you try to use the same image when you switch to picture tiles, it will have an
//file locked error
using (var fs = new FileStream(Path.Combine(NutcrackerDescriptor.ModulePath, newPictureName), FileMode.Open, FileAccess.Read))
{
var ms = new MemoryStream();
fs.CopyTo(ms);
ms.Position = 0;
if(_pictureImage!=null) _pictureImage.Dispose();
_pictureImage = Image.FromStream(ms);
}
_pictureName = newPictureName;
}
catch (Exception e)
{
Logging.Error("Error loading pictue file for nutcracker pictures", e);
}
}
var dimension = new FrameDimension(_pictureImage.FrameDimensionsList[0]);
// Number of frames
int frameCount = _pictureImage.GetFrameCount(dimension);
if (frameCount > 1)
{
if (gifSpeed > 0)
{
_currentGifImageNum += ((gifSpeed * .05));
}
else
{
_currentGifImageNum++;
}
if (Convert.ToInt32(_currentGifImageNum) >= frameCount)
{
_currentGifImageNum = 0;
}
_pictureImage.SelectActiveFrame(dimension, Convert.ToInt32(_currentGifImageNum));
}
Image image = scaleToGrid ? ScaleImage(_pictureImage, BufferWi, BufferHt) : ScaleImage(_pictureImage, _pictureImage.Width * scalePct / 10, _pictureImage.Height * scalePct / 10);
_fp = new FastPixel.FastPixel(new Bitmap(image));
if (_fp != null)
{
int imgwidth = _fp.Width;
int imght = _fp.Height;
int yoffset = (BufferHt + imght) / 2;
int xoffset = (imgwidth - BufferWi) / 2;
//int limit = (dir < 2) ? imgwidth + BufferWi : imght + BufferHt;
//int movement = Convert.ToInt32((State % (limit * speedfactor)) / speedfactor);
switch (effectType)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = Convert.ToInt32(State/speedfactor - BufferHt); // * speedfactor; //draw_at = (state < BufferHt)? state
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}else if (yoffset > 0) {
yoffset = 0; //pause in middle
}
break;
case EffectType.RenderPictureWiggle: //wiggle left-right -DJ
xoffset = Convert.ToInt32(State % (BufferWi / 4 * speedfactor));
if (xoffset > BufferWi / 8 * speedfactor) {
xoffset = BufferWi / 4 * speedfactor - xoffset; //reverse direction
}
xoffset -= BufferWi / 4; //* speedfactor; //center it on mid value
xoffset += (imgwidth - BufferWi) / 2; //add in original xoffset from above
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
yoffset = (imght - BufferWi) / 2; //adjust offsets for other axis
xoffset = Convert.ToInt32(State / speedfactor - BufferHt); // * speedfactor; //draw_at = (state < BufferHt)? state
if (xoffset > 10) {
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset > 0){
xoffset = 0; //pause in middle
}
break;
default:
break;
}
// copy image to buffer
_fp.Lock();
for (int x = 0; x < imgwidth; x++)
{
for (int y = 0; y < imght; y++)
{
//if (!image.IsTransparent(x,y))
Color fpColor = _fp.GetPixel(x, y);
if (fpColor != Color.Transparent)
{
switch (effectType)
{
case EffectType.RenderPictureLeft:
// left
SetPixel( Convert.ToInt32(x + BufferWi - (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor), yoffset - y, fpColor);
break;
case EffectType.RenderPictureRight:
// right
SetPixel(Convert.ToInt32(x + (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth), yoffset - y, fpColor);
break;
case EffectType.RenderPictureUp:
// up
SetPixel(x - xoffset, Convert.ToInt32((State % ((imght + BufferHt) * speedfactor)) / speedfactor - y), fpColor);
break;
case EffectType.RenderPictureDown:
// down
SetPixel(x - xoffset, Convert.ToInt32(BufferHt + imght - y - (State % ((imght + BufferHt) * speedfactor)) / speedfactor), fpColor);
break;
case EffectType.RenderPictureUpleft:
SetPixel(Convert.ToInt32(x + BufferWi - (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor), Convert.ToInt32((State % ((imght + BufferHt) * speedfactor)) / speedfactor - y), fpColor);
break; // up-left
case EffectType.RenderPictureDownleft:
SetPixel( Convert.ToInt32(x + BufferWi - (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor), Convert.ToInt32(BufferHt + imght - y - (State % ((imght + BufferHt) * speedfactor)) / speedfactor), fpColor);
break; // down-left
case EffectType.RenderPictureUpright:
SetPixel(Convert.ToInt32(x + (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth), Convert.ToInt32((State % ((imght + BufferHt) * speedfactor)) / speedfactor - y), fpColor);
break; // up-right
case EffectType.RenderPictureDownright:
SetPixel(Convert.ToInt32(x + (State % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth), Convert.ToInt32(BufferHt + imght - y - (State % ((imght + BufferHt) * speedfactor)) / speedfactor), fpColor);
break; // down-right
case EffectType.RenderPicturePeekaboo0:
//Peek a boo
SetPixel(x - xoffset, BufferHt + yoffset - y, fpColor);
break;
case EffectType.RenderPictureWiggle:
SetPixel(x + xoffset, yoffset - y, fpColor);
break;
case EffectType.RenderPicturePeekaboo90:
SetPixel(BufferWi + xoffset - y, x - yoffset, fpColor);
break;
case EffectType.RenderPicturePeekaboo180:
SetPixel(x - xoffset, y - yoffset, fpColor);
break;
case EffectType.RenderPicturePeekaboo270:
SetPixel(y - xoffset, BufferHt + yoffset - x, fpColor);
break;
default:
// no movement - centered
SetPixel(x - xoffset, yoffset - y, fpColor);
break;
}
}
}
}
_fp.Unlock(false);
}
if (image != null)
image.Dispose();
}
public override void Layout()
{
ElementNode node = null;
if (PixelCount > 0)
{
node = _pixels[0].Node;
_pixels.Clear();
}
else if (initiallyAssignedNode != null)
{
if (initiallyAssignedNode.IsLeaf)
{
node = initiallyAssignedNode;
}
}
Point boundsTopLeft = new Point();
boundsTopLeft.X = Math.Min(_topLeft.X, Math.Min(Math.Min(_topRight.X, _bottomRight.X), _bottomLeft.X));
boundsTopLeft.Y = Math.Min(_topLeft.Y, Math.Min(Math.Min(_topRight.Y, _bottomRight.Y), _bottomLeft.Y));
Point bottomRight = new Point();
bottomRight.X = Math.Max(_topLeft.X, Math.Max(Math.Max(_topRight.X, _bottomRight.X), _bottomLeft.X));
bottomRight.Y = Math.Max(_topLeft.Y, Math.Max(Math.Max(_topRight.Y, _bottomRight.Y), _bottomLeft.Y));
Rectangle rect = new Rectangle(boundsTopLeft,
new Size(bottomRight.X - boundsTopLeft.X, bottomRight.Y - boundsTopLeft.Y));
Point tL = new Point(_topLeft.X - boundsTopLeft.X, _topLeft.Y - boundsTopLeft.Y);
Point tR = new Point(_topRight.X - boundsTopLeft.X, _topRight.Y - boundsTopLeft.Y);
Point bL = new Point(_bottomLeft.X - boundsTopLeft.X, _bottomLeft.Y - boundsTopLeft.Y);
Point bR = new Point(_bottomRight.X - boundsTopLeft.X, _bottomRight.Y - boundsTopLeft.Y);
Point[] points = { tL, tR, bR, bL };
if (rect.Width > 0 && rect.Height > 0)
{
using (var b = new Bitmap(rect.Width, rect.Height)) {
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.FillPolygon(Brushes.White, points);
using (FastPixel.FastPixel fp = new FastPixel.FastPixel(b)) {
fp.Lock();
int xCount = 1;
int spacingY = _pixelSpacing;
for (int y = 0; y < rect.Height; y++)
{
if (spacingY % _pixelSpacing == 0)
{
int xDiv;
if (xCount % 2 == 0)
{
xDiv = _pixelSpacing;
}
else
{
xDiv = _pixelSpacing / 2;
}
for (int x = 0; x < rect.Width; x++)
{
if ((x + xDiv) % _pixelSpacing == 0)
{
Color newColor = fp.GetPixel(x, y);
if (newColor.A != 0)
{
PreviewPixel pixel = new PreviewPixel(x + boundsTopLeft.X, y + boundsTopLeft.Y, 0, PixelSize);
pixel.Node = node;
_pixels.Add(pixel);
}
}
}
xCount += 1;
}
spacingY += 1;
}
fp.Unlock(false);
}
}
}
}
protected override void RenderEffect(int frame, ref PixelFrameBuffer frameBuffer)
{
if (_image == null)
{
return;
}
const int speedfactor = 4;
double position = (GetEffectTimeIntervalPosition(frame) * Speed) % 1;
double level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
CalculateImageNumberByPosition(position);
_image.SelectActiveFrame(_dimension, (int)_currentGifImageNum);
_scaledImage = ScaleToGrid ? ScaleImage(_image, BufferWi, BufferHt) : ScaleImage(_image, _image.Width * ScalePercent / 100, _image.Height * ScalePercent / 100);
_fp = new FastPixel.FastPixel(_scaledImage);
int imgwidth = _fp.Width;
int imght = _fp.Height;
int yoffset = (BufferHt + imght) / 2;
int xoffset = (imgwidth - BufferWi) / 2;
int state = Speed * frame;
int xOffsetAdj = XOffset * BufferWi / 100;
int yOffsetAdj = YOffset * BufferHt / 100;
switch (Type)
{
case EffectType.RenderPicturePeekaboo0:
case EffectType.RenderPicturePeekaboo180:
//Peek a boo
yoffset = -(BufferHt) + (int)((BufferHt + 5) * position * 2);
if (yoffset > 10)
{
yoffset = -yoffset + 10; //reverse direction
}
else if (yoffset >= -1)
{
yoffset = -1; //pause in middle
}
break;
case EffectType.RenderPictureWiggle:
if (position >= 0.5)
{
xoffset += (int)(BufferWi * ((1.0 - position) * 2.0 - 0.5));
}
else
{
xoffset += (int)(BufferWi * (position * 2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Vertical)
{
yoffset = (imght - BufferWi) / 2; //adjust offsets for other axis
}
else
{
yoffset = (imgwidth - BufferHt) / 2; //adjust offsets for other axis
}
if (Orientation == StringOrientation.Vertical)
{
xoffset = -(BufferHt) + (int)((BufferHt + 5) * position * 2);
}
else
{
xoffset = -(BufferWi) + (int)((BufferWi + 5) * position * 2);
}
if (xoffset > 10)
{
xoffset = -xoffset + 10; //reverse direction
}
else if (xoffset >= -1)
{
xoffset = -1; //pause in middle
}
break;
}
_fp.Lock();
for (int x = 0; x < imgwidth; x++)
{
for (int y = 0; y < imght; y++)
{
//if (!image.IsTransparent(x,y))
Color color = _fp.GetPixel(x, y);
if (color != Color.Transparent)
{
var hsv = HSV.FromRGB(color);
hsv.V = hsv.V * level;
switch (Type)
{
case EffectType.RenderPictureLeft:
// left
int leftX = x + (BufferWi - (int)(position * (imgwidth + BufferWi)));
frameBuffer.SetPixel(leftX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureRight:
// right
int rightX = x + -imgwidth + (int)(position * (imgwidth + BufferWi));
frameBuffer.SetPixel(rightX + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUp:
// up
int upY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, upY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureDown:
// down
int downY = (BufferHt + imght - 1) - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, downY + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureUpleft:
int upLeftY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + BufferWi - (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor) + xOffsetAdj, upLeftY + yOffsetAdj, hsv);
break; // up-left
case EffectType.RenderPictureDownleft:
int downLeftY = BufferHt + imght - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + BufferWi - (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor) + xOffsetAdj, downLeftY + yOffsetAdj, hsv);
break; // down-left
case EffectType.RenderPictureUpright:
int upRightY = (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth) + xOffsetAdj, upRightY + yOffsetAdj, hsv);
break; // up-right
case EffectType.RenderPictureDownright:
int downRightY = BufferHt + imght - (int)((imght + BufferHt) * position) - y;
frameBuffer.SetPixel(Convert.ToInt32(x + (state % ((imgwidth + BufferWi) * speedfactor)) / speedfactor - imgwidth) + xOffsetAdj, downRightY + yOffsetAdj, hsv);
break; // down-right
case EffectType.RenderPicturePeekaboo0:
//Peek a boo
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, BufferHt + yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPictureWiggle:
frameBuffer.SetPixel(x + xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo90:
frameBuffer.SetPixel(BufferWi + xoffset - y + xOffsetAdj, x - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo180:
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, y - yoffset + yOffsetAdj, hsv);
break;
case EffectType.RenderPicturePeekaboo270:
frameBuffer.SetPixel(y - xoffset + xOffsetAdj, BufferHt + yoffset - x + yOffsetAdj, hsv);
break;
default:
// no movement - centered
frameBuffer.SetPixel(x - xoffset + xOffsetAdj, yoffset - y + yOffsetAdj, hsv);
break;
}
}
}
}
_fp.Unlock(false);
_fp.Dispose();
_scaledImage.Dispose();
}