public void CreateAlphaBackground()
{
if (Background != null)
{
Color c;
c = Color.FromArgb(255 - BackgroundAlpha, 0, 0, 0);
//_backgroundAlphaImage = new Bitmap(Background.Width, Background.Height, PixelFormat.Format32bppPArgb);
_backgroundAlphaImage = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(_backgroundAlphaImage);
using (SolidBrush brush = new SolidBrush(c))
{
gfx.FillRectangle(Brushes.Black, 0, 0, _backgroundAlphaImage.Width, _backgroundAlphaImage.Height);
gfx.DrawImage(Background, 0, 0, Background.Width, Background.Height);
gfx.FillRectangle(brush, 0, 0, Background.Width, Background.Height);
}
gfx.Dispose();
}
else
{
_backgroundAlphaImage = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(_backgroundAlphaImage);
gfx.Clear(Color.Black);
gfx.Dispose();
}
_fastPixel = new FastPixel.FastPixel(_backgroundAlphaImage.Width, _backgroundAlphaImage.Height);
}
protected override void RenderEffect(int frame, IPixelFrameBuffer frameBuffer)
{
var bufferHt = BufferHt;
var bufferWi = BufferWi;
using (var bitmap = new Bitmap(bufferWi, bufferHt))
{
InitialRender(frame, bitmap, bufferHt, bufferWi);
if (_text.Count == 0 && !UseBaseColor)
{
return;
}
_level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
FastPixel.FastPixel fp = new FastPixel.FastPixel(bitmap);
fp.Lock();
// copy to frameBuffer
for (int x = 0; x < bufferWi; x++)
{
for (int y = 0; y < bufferHt; y++)
{
CalculatePixel(x, y, ref bufferHt, fp, frameBuffer);
}
}
fp.Unlock(false);
fp.Dispose();
}
}
public override void DrawSelectPoints(FastPixel.FastPixel fp)
{
if (_dragPoints != null)
{
foreach (PreviewDoublePoint point in _dragPoints)
{
if (point?.PointType == PreviewPoint.PointTypes.Size)
{
int x = Convert.ToInt32(point.X - (double)SelectPointSize / 2);
int y = Convert.ToInt32(point.Y - (double)SelectPointSize / 2);
fp.DrawRectangle(
new Rectangle(x, y, SelectPointSize, SelectPointSize),
Color.White);
}
else
{
if (point?.PointType == PreviewPoint.PointTypes.Rotate)
{
int x = Convert.ToInt32(point.X - (double)SelectPointSize / 2);
int y = Convert.ToInt32(point.Y - (double)SelectPointSize / 2);
fp.DrawCircle(
new Rectangle(x, y, SelectPointSize, SelectPointSize),
Color.White);
}
}
}
}
}
public void Draw(FastPixel.FastPixel fp, bool forceDraw)
{
if (forceDraw)
{
Draw(fp, color);
}
}
protected override void RenderEffectByLocation(int numFrames, PixelLocationFrameBuffer frameBuffer)
{
var nodes = frameBuffer.ElementLocations.OrderBy(x => x.X).ThenBy(x => x.Y).GroupBy(x => x.X);
var bufferHt = BufferHt;
var bufferWi = BufferWi;
for (int frame = 0; frame < numFrames; frame++)
{
frameBuffer.CurrentFrame = frame;
_level = LevelCurve.GetValue(GetEffectTimeIntervalPosition(frame) * 100) / 100;
using (var bitmap = new Bitmap(bufferWi, bufferHt))
{
InitialRender(frame, bitmap, bufferHt, bufferWi);
FastPixel.FastPixel fp = new FastPixel.FastPixel(bitmap);
fp.Lock();
foreach (IGrouping <int, ElementLocation> elementLocations in nodes)
{
foreach (var elementLocation in elementLocations)
{
CalculatePixel(elementLocation.X, elementLocation.Y, ref bufferHt, fp, frameBuffer);
}
}
fp.Unlock(false);
fp.Dispose();
}
}
}
public override void Draw(FastPixel.FastPixel fp, bool editMode, List <ElementNode> highlightedElements, bool selected,
bool forceDraw)
{
//if (_strings != null) {
// _stringsInDegrees = (double) _stringCount*((double) _degrees/360);
// for (int i = 0; i < _stringsInDegrees; i++) {
// foreach (PreviewPixel pixel in _strings[i]._pixels) {
// //Console.WriteLine(pixel.X + ":" + pixel.Y);
// DrawPixel(pixel, fp, editMode, highlightedElements, selected, forceDraw);
// //if (highlightedElements.Contains(pixel.Node))
// // pixel.Draw(fp, PreviewTools.HighlightedElementColor);
// //else
// // pixel.Draw(fp, Color.White);
// }
// }
//}
//base.Draw(fp, editMode, highlightedElements, selected, forceDraw);
// DB: Added 8/4/2013
if (_strings != null)
{
//_stringsInDegrees = (double)_stringCount * ((double)_degrees / 360);
for (int i = 0; i < StringCount; i++)
{
foreach (PreviewPixel pixel in _strings[i]._pixels)
{
DrawPixel(pixel, fp, editMode, highlightedElements, selected, forceDraw);
}
}
}
base.Draw(fp, editMode, highlightedElements, selected, forceDraw);
}
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);
}
}
public override void Draw(FastPixel.FastPixel fp, bool editMode, List <ElementNode> highlightedElements, bool selected,
bool forceDraw)
{
foreach (PreviewBaseShape shape in Strings)
{
shape.Draw(fp, editMode, highlightedElements, selected, forceDraw);
}
DrawSelectPoints(fp);
}
/// <inheritdoc />
protected override void SetupRender()
{
var scaledImage = ScaleToGrid
? Picture.Picture.ScalePictureImage(Image, BufferWi, BufferHt)
: Picture.Picture.ScaleImage(Image, (double)ScalePercent / 100);
_fp = new FastPixel.FastPixel(scaledImage);
_fp.Lock();
}
public virtual void Draw(FastPixel.FastPixel fp, bool editMode, HashSet <Guid> highlightedElements, bool selected,
bool forceDraw)
{
foreach (PreviewPixel pixel in Pixels)
{
DrawPixel(pixel, fp, editMode, highlightedElements, selected, forceDraw);
}
DrawSelectPoints(fp);
}
public virtual void Draw(FastPixel.FastPixel fp, bool editMode, List <ElementNode> highlightedElements, bool selected,
bool forceDraw)
{
//Pixels.AsParallel().ForAll(pixel => {
foreach (PreviewPixel pixel in Pixels)
{
DrawPixel(pixel, fp, editMode, highlightedElements, selected, forceDraw);
}
//});
DrawSelectPoints(fp);
}
public override void Draw(FastPixel.FastPixel fp, bool editMode, List <ElementNode> highlightedElements, bool selected,
bool forceDraw)
{
foreach (PreviewPixel pixel in Pixels)
{
//if (highlightedElements != null && highlightedElements.Contains(pixel.Node))
// pixel.Draw(fp, Color.HotPink);
//else
// pixel.Draw(fp, Color.White);
DrawPixel(pixel, fp, editMode, highlightedElements, selected, forceDraw);
}
}
protected override void CleanUpRender()
{
_fp?.Dispose();
_fp = null;
if (_reader != null)
{
_reader.Close();
_reader.Dispose();
_reader = null;
}
_processVideo = true;
}
public void Draw(FastPixel.FastPixel fp, bool forceDraw)
{
if (forceDraw)
{
Draw(fp, color);
}
else if (Node != null)
{
if (PreviewPixel.IntentNodeToColor.TryGetValue(Node, out color))
{
Draw(fp, color);
}
}
}
public override void Draw(FastPixel.FastPixel fp, bool editMode, HashSet <Guid> highlightedElements, bool selected,
bool forceDraw)
{
if (_strings != null)
{
for (int i = 0; i < StringCount; i++)
{
foreach (PreviewPixel pixel in _strings[i]._pixels)
{
DrawPixel(pixel, fp, editMode, highlightedElements, selected, forceDraw);
}
}
}
base.Draw(fp, editMode, highlightedElements, selected, forceDraw);
}
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();
}
}
public void DrawSelectPoints(FastPixel.FastPixel fp)
{
if (_selectPoints != null)
{
foreach (PreviewPoint point in _selectPoints)
{
if (point != null)
{
if (point.PointType == PreviewPoint.PointTypes.Size)
{
fp.DrawRectangle(
new Rectangle(point.X - (SelectPointSize / 2), point.Y - (SelectPointSize / 2), SelectPointSize, SelectPointSize),
Color.White);
}
}
}
}
}
public virtual void DrawPixel(PreviewPixel pixel, FastPixel.FastPixel fp, bool editMode, HashSet <Guid> highlightedElements,
bool selected, bool forceDraw)
{
int origPixelSize = pixel.PixelSize;
if (forceDraw)
{
pixel.Draw(fp, forceDraw);
}
else
{
Color pixelColor = Color.White;
if (StringType == StringTypes.Pixel && IsPixelOne(pixel))
{
pixelColor = Color.Yellow;
pixel.PixelSize = PixelSize + 2;
}
else
{
if (selected)
{
pixelColor = PreviewTools.SelectedItemColor;
}
else
{
if (pixel.NodeId != Guid.Empty)
{
if (highlightedElements.Contains(pixel.NodeId))
{
pixelColor = Color.HotPink;
}
else
{
pixelColor = Color.Turquoise;
}
}
}
}
pixel.Draw(fp, pixelColor);
//Restore the size if we changed it.
pixel.PixelSize = origPixelSize;
}
}
public virtual void DrawPixel(PreviewPixel pixel, FastPixel.FastPixel fp, bool editMode, List <ElementNode> highlightedElements,
bool selected, bool forceDraw)
{
if (forceDraw)
{
pixel.Draw(fp, forceDraw);
}
else
{
Color pixelColor = Color.White;
if (
(_pixels.Count > 0) &&
(pixel == _pixels[0] || (_strings != null && _strings.Count > 0 && _strings[0].Pixels != null && _strings[0].Pixels.Count > 0 && _strings[0].Pixels[0] == pixel))
)
{
pixelColor = Color.Yellow;
pixel.PixelSize = PixelSize + 2;
}
else
{
if (selected)
{
pixelColor = PreviewTools.SelectedItemColor;
}
else if (highlightedElements != null && highlightedElements.Contains(pixel.Node))
{
pixelColor = Color.HotPink;
}
else
{
if (pixel.Node != null)
{
pixelColor = Color.Turquoise;
}
else
{
pixelColor = Color.White;
}
}
}
pixel.Draw(fp, pixelColor);
}
}
public void Draw(FastPixel.FastPixel fp, IIntentStates states, double zoomLevel)
{
if (_isDiscreteColored)
{
int col = 1;
int zoomedX = (int)(Bounds.X * zoomLevel);
Rectangle drawRect = new Rectangle(zoomedX, (int)(Bounds.Y * zoomLevel), Bounds.Width, Bounds.Height);
// Get states for each color
List <Color> colors = _discreteHandler.GetAlphaAffectedColor(states);
foreach (Color c in colors)
{
if (c != Color.Transparent && c.A > byte.MinValue)
{
fp.DrawCircle(drawRect, c);
if (col % 2 == 0)
{
drawRect.Y += PixelSize;
drawRect.X = zoomedX;
}
else
{
drawRect.X = zoomedX + PixelSize;
}
col++;
}
}
}
else
{
var state = states.FirstOrDefault();
if (state != null)
{
Color intentColor = _fullColorHandler.GetFullColor(state);
if (intentColor.A > 0)
{
Rectangle drawRect = zoomLevel != 1?new Rectangle((int)(Bounds.X * zoomLevel), (int)(Bounds.Y * zoomLevel), Bounds.Width, Bounds.Height):Bounds;
fp.DrawCircle(drawRect, intentColor);
}
}
}
}
public void CreateAlphaBackground()
{
if (Width <= 0 || Height <= 0)
{
return;
}
int newWidth = Convert.ToInt32(_background.Width * ZoomLevel);
int newHeight = Convert.ToInt32(_background.Height * ZoomLevel);
if (newWidth <= 0 || newHeight <= 0)
{
return;
}
if (Background != null)
{
Color c = Color.FromArgb(255 - BackgroundAlpha, 0, 0, 0);
//_backgroundAlphaImage = new Bitmap(Background.Width, Background.Height, PixelFormat.Format32bppPArgb);
_backgroundAlphaImage = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(_backgroundAlphaImage);
using (SolidBrush brush = new SolidBrush(c))
{
gfx.FillRectangle(Brushes.Black, 0, 0, Width, Height);
gfx.DrawImage(Background, 0, 0, newWidth, newHeight);
gfx.FillRectangle(brush, 0, 0, Width, Height);
}
gfx.Dispose();
}
else
{
_backgroundAlphaImage = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(_backgroundAlphaImage);
gfx.Clear(Color.Black);
gfx.Dispose();
}
_fastPixel = new FastPixel.FastPixel(_backgroundAlphaImage.Width, _backgroundAlphaImage.Height);
BeginUpdate();
EndUpdate();
Invalidate();
}
public virtual void DrawSelectPoints(FastPixel.FastPixel fp)
{
if (_selectPoints != null)
{
foreach (PreviewPoint point in _selectPoints)
{
if (point != null)
{
if (point.PointType == PreviewPoint.PointTypes.Size)
{
int x = Convert.ToInt32((point.X) * ZoomLevel) - (SelectPointSize / 2);
int y = Convert.ToInt32(point.Y * ZoomLevel) - (SelectPointSize / 2);
fp.DrawRectangle(
new Rectangle(x, y, SelectPointSize, SelectPointSize),
Color.White);
}
}
}
}
}
public virtual void DrawPixel(PreviewPixel pixel, FastPixel.FastPixel fp, bool editMode, List <ElementNode> highlightedElements,
bool selected, bool forceDraw)
{
if (forceDraw)
{
pixel.Draw(fp, forceDraw);
}
else if (selected)
{
pixel.Draw(fp, PreviewTools.SelectedItemColor);
}
else if (highlightedElements != null && highlightedElements.Contains(pixel.Node))
{
pixel.Draw(fp, Color.HotPink);
}
else
{
pixel.Draw(fp, Color.White);
}
}
public void Draw(FastPixel.FastPixel fp, IIntentStates states)
{
if (_isDiscreteColored)
{
int col = 1;
Rectangle drawRect = new Rectangle(drawArea.X, drawArea.Y, drawArea.Width, drawArea.Height);
// Get states for each color
List <Color> colors = _discreteHandler.GetAlphaAffectedColor(states);
foreach (Color c in colors)
{
if (c != Color.Transparent && c.A > byte.MinValue)
{
fp.DrawCircle(drawRect, c);
if (col % 2 == 0)
{
drawRect.Y += PixelSize;
drawRect.X = drawArea.X;
}
else
{
drawRect.X = drawArea.X + PixelSize;
}
col++;
}
}
}
else
{
var state = states.FirstOrDefault();
if (state != null)
{
Color intentColor = _fullColorHandler.GetFullColor(state);
if (intentColor.A > 0)
{
fp.DrawCircle(drawArea, intentColor);
}
}
}
}
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);
}
}
public void Draw(FastPixel.FastPixel fp, IIntentStates states)
{
if (_isDiscreteColored)
{
int col = 1;
Rectangle drawRect = new Rectangle(drawArea.X, drawArea.Y, drawArea.Width, drawArea.Height);
// Get states for each color
IEnumerable <Color> colors = IntentHelpers.GetAlphaAffectedDiscreteColorsForIntents(states);
foreach (Color c in colors)
{
if (c != Color.Transparent && c.A > byte.MinValue)
{
fp.DrawCircle(drawRect, c);
if (col % 2 == 0)
{
drawRect.Y += PixelSize;
drawRect.X = drawArea.X;
}
else
{
drawRect.X = drawArea.X + PixelSize;
}
col++;
}
}
}
else
{
Color intentColor = IntentHelpers.GetAlphaRGBMaxColorForIntents(states);
if (intentColor != Color.Transparent && intentColor.A > 0)
{
fp.DrawCircle(drawArea, intentColor);
}
}
}
protected override void CleanUpRender()
{
_fp?.Dispose();
_fp = null;
_pictures = null;
}
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();
}
//#region "Update in a BeginInvoke"
//public void ProcessUpdate(ElementIntentStates elementStates)
//{
// renderTimer.Reset();
// renderTimer.Start();
// if (!_paused)
// {
// FastPixel fp = new FastPixel(new Bitmap(_alphaBackground));
// fp.Lock();
// Color c;
// foreach (var channelIntentState in elementStates)
// {
// var elementId = channelIntentState.Key;
// Element element = VixenSystem.Elements.GetElement(elementId);
// if (element == null) continue;
// ElementNode node = VixenSystem.Elements.GetElementNodeForElement(element);
// if (node == null) continue;
// foreach (IIntentState<LightingValue> intentState in channelIntentState.Value)
// {
// c = intentState.GetValue().GetAlphaChannelIntensityAffectedColor();
// if (_background != null)
// {
// List<PreviewPixel> pixels;
// if (NodeToPixel.TryGetValue(node, out pixels))
// {
// foreach (PreviewPixel pixel in pixels)
// {
// pixel.Draw(fp, c);
// }
// }
// }
// }
// }
// fp.Unlock(true);
// // First, draw our background image opaque
// bufferedGraphics.Graphics.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
// bufferedGraphics.Graphics.DrawImage(fp.Bitmap, 0, 0, fp.Width, fp.Height);
// if (!this.Disposing && bufferedGraphics != null)
// bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
// fp = null;
// }
// renderTimer.Stop();
// lastRenderUpdateTime = renderTimer.ElapsedMilliseconds;
//}
//#endregion
public void ProcessUpdateParallel(/*Vixen.Preview.PreviewElementIntentStates elementStates*/)
{
renderTimer.Reset();
renderTimer.Start();
CancellationTokenSource tokenSource = new CancellationTokenSource();
if (!_paused)
{
Bitmap clone = (Bitmap)_alphaBackground.Clone();
//BitmapData odata = _alphaBackground.LockBits(new Rectangle(0, 0, _alphaBackground.Width, _alphaBackground.Height), ImageLockMode.ReadWrite, _alphaBackground.PixelFormat);
//BitmapData cdata = clone.LockBits(new Rectangle(0, 0, clone.Width, clone.Height), ImageLockMode.ReadWrite, clone.PixelFormat);
//Assert.AreNotEqual(odata.Scan0, cdata.Scan0);
//using (FastPixel fp = new FastPixel(new Bitmap(_alphaBackground)))
using (FastPixel.FastPixel fp = new FastPixel.FastPixel(clone))
{
try
{
fp.Lock();
Vixen.Preview.PreviewElementIntentStates elementStates =
new Vixen.Preview.PreviewElementIntentStates(VixenSystem.Elements.ToDictionary(x => x, x => x.State));
elementStates.AsParallel().WithCancellation(tokenSource.Token).ForAll(channelIntentState =>
{
//var elementId = channelIntentState.Key;
//Element element = VixenSystem.Elements.GetElement(elementId);
Element element = channelIntentState.Key;
if (element != null)
{
ElementNode node = VixenSystem.Elements.GetElementNodeForElement(element);
if (node != null)
{
List<PreviewPixel> pixels;
if (NodeToPixel.TryGetValue(node, out pixels))
{
foreach (PreviewPixel pixel in pixels)
{
pixel.Draw(fp, channelIntentState.Value);
}
}
//foreach (IIntentState<LightingValue> intentState in channelIntentState.Value)
//{
// Color c = ((IIntentState<LightingValue>)intentState).GetValue().GetAlphaChannelIntensityAffectedColor();
// if (_background != null)
// {
// List<PreviewPixel> pixels;
// if (NodeToPixel.TryGetValue(node, out pixels))
// {
// foreach (PreviewPixel pixel in pixels)
// {
// pixel.Draw(fp, c);
// }
// }
// }
//}
}
}
});
//Console.WriteLine("2: " + renderTimer.ElapsedMilliseconds);renderTimer.Reset();
fp.Unlock(true);
RenderBufferedGraphics(fp);
}
catch (Exception)
{
tokenSource.Cancel();
//Console.WriteLine(e.Message);
}
}
}
renderTimer.Stop();
lastRenderUpdateTime = renderTimer.ElapsedMilliseconds;
}
public void CreateAlphaBackground()
{
if (Background != null)
{
Color c;
c = Color.FromArgb(255 - BackgroundAlpha, 0, 0, 0);
//_backgroundAlphaImage = new Bitmap(Background.Width, Background.Height, PixelFormat.Format32bppPArgb);
_backgroundAlphaImage = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(_backgroundAlphaImage);
using (SolidBrush brush = new SolidBrush(c))
{
gfx.FillRectangle(Brushes.Black, 0, 0, _backgroundAlphaImage.Width, _backgroundAlphaImage.Height);
gfx.DrawImage(Background, 0, 0, Background.Width, Background.Height);
gfx.FillRectangle(brush, 0, 0, Background.Width, Background.Height);
}
gfx.Dispose();
}
else
{
_backgroundAlphaImage = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(_backgroundAlphaImage);
gfx.Clear(Color.Black);
gfx.Dispose();
}
_fastPixel = new FastPixel.FastPixel(_backgroundAlphaImage.Width, _backgroundAlphaImage.Height);
}
/// <summary>
/// This is used in edit mode only!!
/// Need to make it go away so we only have one render engine
/// </summary>
public void RenderInForeground()
{
renderTimer.Reset();
renderTimer.Start();
AllocateGraphicsBuffer();
if (_background != null) {
FastPixel.FastPixel fp = new FastPixel.FastPixel(new Bitmap(_alphaBackground));
fp.Lock();
foreach (DisplayItem displayItem in DisplayItems) {
if (_editMode) {
displayItem.Draw(fp, true, HighlightedElements, SelectedDisplayItems.Contains(displayItem), false);
}
else {
displayItem.Draw(fp, false, null, false, true);
}
}
fp.Unlock(true);
if (ShowInfo && _editMode)
{
foreach (DisplayItem displayItem in DisplayItems)
{
Graphics g = Graphics.FromImage(fp.Bitmap);
displayItem.DrawInfo(g);
}
}
// Finally, are we drawing a banded rectangle?
if (_mouseCaptured && _selectedDisplayItem == null) {
Graphics g = Graphics.FromImage(fp.Bitmap);
g.DrawRectangle(Pens.White, _bandRect);
}
// First, draw our background image opaque
bufferedGraphics.Graphics.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
// Now, draw our "pixel" image using alpha blending
bufferedGraphics.Graphics.DrawImage(fp.Bitmap, 0, 0, fp.Width, fp.Height);
}
bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
renderTimer.Stop();
lastRenderUpdateTime = renderTimer.ElapsedMilliseconds;
}
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 void LoadPictures(string DataFilePath)
{
moviePictures = new List<FastPixel.FastPixel>();
if (Data.Movie_DataPath.Length > 0) {
var imageFolder = System.IO.Path.Combine(NutcrackerDescriptor.ModulePath, DataFilePath);
List<string> sortedFiles = Directory.GetFiles(imageFolder).OrderBy(f => f).ToList();
foreach (string file in sortedFiles) {
Image image = Image.FromFile(file);
FastPixel.FastPixel imageFp = new FastPixel.FastPixel(new Bitmap(image));
moviePictures.Add(imageFp);
}
}
}
//#region "Update in a BeginInvoke"
//public void ProcessUpdate(ElementIntentStates elementStates)
//{
// renderTimer.Reset();
// renderTimer.Start();
// if (!_paused)
// {
// FastPixel fp = new FastPixel(new Bitmap(_alphaBackground));
// fp.Lock();
// Color c;
// foreach (var channelIntentState in elementStates)
// {
// var elementId = channelIntentState.Key;
// Element element = VixenSystem.Elements.GetElement(elementId);
// if (element == null) continue;
// ElementNode node = VixenSystem.Elements.GetElementNodeForElement(element);
// if (node == null) continue;
// foreach (IIntentState<LightingValue> intentState in channelIntentState.Value)
// {
// c = intentState.GetValue().GetAlphaChannelIntensityAffectedColor();
// if (_background != null)
// {
// List<PreviewPixel> pixels;
// if (NodeToPixel.TryGetValue(node, out pixels))
// {
// foreach (PreviewPixel pixel in pixels)
// {
// pixel.Draw(fp, c);
// }
// }
// }
// }
// }
// fp.Unlock(true);
// // First, draw our background image opaque
// bufferedGraphics.Graphics.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
// bufferedGraphics.Graphics.DrawImage(fp.Bitmap, 0, 0, fp.Width, fp.Height);
// if (!this.Disposing && bufferedGraphics != null)
// bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
// fp = null;
// }
// renderTimer.Stop();
// lastRenderUpdateTime = renderTimer.ElapsedMilliseconds;
//}
//#endregion
public void ProcessUpdateParallel( /*Vixen.Preview.PreviewElementIntentStates elementStates*/)
{
renderTimer.Reset();
renderTimer.Start();
CancellationTokenSource tokenSource = new CancellationTokenSource();
if (!_paused)
{
Bitmap clone = (Bitmap) _alphaBackground.Clone();
using (FastPixel.FastPixel fp = new FastPixel.FastPixel(clone))
{
try
{
fp.Lock();
Vixen.Preview.PreviewElementIntentStates elementStates =
new Vixen.Preview.PreviewElementIntentStates(VixenSystem.Elements.ToDictionary(x => x, x => x.State));
elementStates.AsParallel().WithCancellation(tokenSource.Token).ForAll(channelIntentState =>
{
Element element = channelIntentState.Key;
if (element != null)
{
ElementNode node = VixenSystem.Elements.GetElementNodeForElement(element);
if (node != null)
{
List<PreviewPixel> pixels;
if (NodeToPixel.TryGetValue(node, out pixels))
{
foreach (PreviewPixel pixel in pixels)
{
pixel.Draw(fp, channelIntentState.Value);
}
}
}
}
});
fp.Unlock(true);
RenderBufferedGraphics(fp);
}
catch (Exception)
{
tokenSource.Cancel();
}
}
}
renderTimer.Stop();
lastRenderUpdateTime = renderTimer.ElapsedMilliseconds;
}
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 RenderPictureTile(int dir, double scale, bool useColor, bool useAlpha, int ColorReplacementSensitivity,
string NewPictureName)
{
const int speedfactor = 4;
Image image = null;
try {
if (NewPictureName == null || NewPictureName.Length == 0)
return;
if (State == 0) {
lastState = 0;
movementX = 0.0;
movementY = 0.0;
lastScale = -1;
}
if (NewPictureName != PictureTilePictureName || scale != lastScale) {
if (IsNutcrackerResource(NewPictureName))
{
using (var fs = typeof(Nutcracker).Assembly.GetManifestResourceStream(NewPictureName))
image = Image.FromStream(fs);
}
else if (File.Exists(NewPictureName))
{
using (var fs = new FileStream(NewPictureName, FileMode.Open, FileAccess.Read))
{
image = Image.FromStream(fs);
}
}
else
{
return;
}
if (scale != 0.0) {
image = ScaleImage(image, scale/100);
}
if (useColor) {
image = ConvertToGrayScale(image);
}
_fp = new FastPixel.FastPixel(new Bitmap(image));
PictureTilePictureName = NewPictureName;
lastScale = scale;
}
if (_fp != null) {
int imageWidth = _fp.Width;
int imageHeight = _fp.Height;
double deltaX = 0;
double deltaY = 0;
if (dir > 0 && dir < 90) {
deltaX = (double) dir/90;
}
else if (dir > 90 && dir < 180) {
deltaX = (double) Math.Abs(dir - 180)/90;
}
else if (dir > 180 && dir < 270) {
deltaX = -1*((double) Math.Abs(dir - 180)/90);
}
else if (dir > 270 && dir < 360) {
deltaX = -1*((double) Math.Abs(dir - 360)/90);
}
if (dir >= 0 && dir < 90) {
deltaY = (double) Math.Abs(dir - 90)/90;
}
else if (dir > 90 && dir <= 180) {
deltaY = -1*((double) Math.Abs(dir - 90)/90);
}
else if (dir > 180 && dir < 270) {
deltaY = -1*((double) Math.Abs(dir - 270)/90);
}
else if (dir > 270 && dir <= 360) {
deltaY = (double) Math.Abs(270 - dir)/90;
}
movementX += (double) ((double) (State - lastState)/(double) speedfactor)*deltaX;
movementY += (double) ((double) (State - lastState)/(double) speedfactor)*deltaY;
lastState = (int) State;
_fp.Lock();
Color fpColor = new Color();
int colorX = 0;
int colorY = 0;
for (int x = 0; x < BufferWi; x++) {
for (int y = 0; y < BufferHt; y++) {
colorX = x + Convert.ToInt32(movementX);
colorY = y + Convert.ToInt32(movementY);
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);
if (fpColor != Color.Transparent) {
// Are we re-assigning the colors for this
if (useColor) {
// For now, we're always going to use alpha. Maybe later, we'll
// Convert black and white to a single color
//if (useAlpha)
//{
Color newColor = Palette.GetColor(0);
// TODO
// How high can GetBrightness go? Is it 0-100?
// How about alpha? Is it 0-255?
int a = Convert.ToInt32(fpColor.GetBrightness()*255);
fpColor = Color.FromArgb(a, newColor.R, newColor.G, newColor.B);
//}
//else
//{
// fpColor = Palette.GetColor(0);
//}
}
else {
//fpColor = Color.FromArgb(255, fpColor);
}
// Tree is up-side down, so draw the bitmp up-side down so it is right-side up.
SetPixel(x, BufferHt - y - 1, fpColor);
}
}
}
}
_fp.Unlock(false);
}
} finally {
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);
}
}
}
}
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 InitialRender(int frame, double intervalPosFactor)
{
if (_fp != null || _pictures.Count > 0)
{
var dir = 360 - Direction;
if (Type != EffectType.RenderPictureTiles && Type != EffectType.RenderPictureNone)
{
_position = ((GetEffectTimeIntervalPosition(frame) * Speed) % 1);
}
else if (frame == 0)
{
_position = ((GetEffectTimeIntervalPosition(frame + 1) * Speed) % 1);
}
if (_pictures.Count > 0)
{
for (int i = 0; i < _pictures.Count; i++)
{
if (frame >= _pictures[i].frame)
{
_fp = new FastPixel.FastPixel(_pictures[i].bitmap);
_pictures.RemoveAt(i);
break;
}
}
}
_imageWidth = _fp.Width;
_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;
_yoffset = ((BufferHt + _imageHeight) / 2) - 1; //subtract 1 because we are zero based and inverting the y
_xoffset = (_imageWidth - BufferWi) / 2;
_xOffsetAdj = CalculateXOffset(intervalPosFactor) * BufferWi / 100;
_yOffsetAdj = CalculateYOffset(intervalPosFactor) * BufferHt / 100;
_imageHt = _imageHeight;
_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)(_imageWi * ((1.0 - _position) * 2.0 - 0.5));
}
else
{
_xoffset += (int)(_imageWi * (_position * 2.0 - 0.5));
}
break;
case EffectType.RenderPicturePeekaboo90: //peekaboo 90
case EffectType.RenderPicturePeekaboo270: //peekaboo 270
if (Orientation == StringOrientation.Horizontal || TargetPositioning == TargetPositioningType.Locations)
{
_yoffset = (BufferHt - _imageWi) / 2; //adjust offsets for other axis
_xoffset = -(BufferWi) + (int)((BufferWi + 5) * _position * 2);
}
else
{
_yoffset = (BufferWi) / 2; //adjust offsets for other axis
_xoffset = -(BufferHt) + (int)((BufferHt + 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;
}
}
}
/// <summary>
/// This is used in edit mode only!!
/// Need to make it go away so we only have one render engine
/// </summary>
public void RenderInForeground()
{
renderTimer.Reset();
renderTimer.Start();
AllocateGraphicsBuffer(false);
if (Background != null)
{
FastPixel.FastPixel fp = new FastPixel.FastPixel(new Bitmap(_alphaBackground));
fp.Lock();
foreach (DisplayItem displayItem in DisplayItems)
{
if (_editMode)
{
displayItem.Draw(fp, true, HighlightedElements, SelectedDisplayItems.Contains(displayItem), false);
}
else
{
displayItem.Draw(fp, false, null, false, true);
}
}
fp.Unlock(true);
if (ShowInfo && _editMode)
{
foreach (DisplayItem displayItem in DisplayItems)
{
Graphics g = Graphics.FromImage(fp.Bitmap);
displayItem.DrawInfo(g);
}
}
// Finally, are we drawing a banded rectangle?
if (_mouseCaptured && _selectedDisplayItem == null)
{
Graphics g = Graphics.FromImage(fp.Bitmap);
g.DrawRectangle(Pens.White, _bandRect);
}
bufferedGraphics.Graphics.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
// Now, draw our "pixel" image using alpha blending
if (vScroll.Visible && hScroll.Visible)
{
int drawWidth = Width - vScroll.Width + hScroll.Value;
int drawHeight = Height - hScroll.Height + vScroll.Value;
int drawX = -hScroll.Value;
int drawY = -vScroll.Value;
Rectangle dest = new Rectangle(0, 0, drawWidth, drawHeight);
Rectangle src = new Rectangle(hScroll.Value, vScroll.Value, drawWidth, drawHeight);
bufferedGraphics.Graphics.DrawImage(fp.Bitmap, dest, src, GraphicsUnit.Pixel);
}
else
{
Rectangle dest = new Rectangle(0, 0, Width, Height);
Rectangle src = new Rectangle(0, 0, Width, Height);
bufferedGraphics.Graphics.DrawImage(fp.Bitmap, dest, src, GraphicsUnit.Pixel);
}
}
bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
renderTimer.Stop();
lastRenderUpdateTime = renderTimer.ElapsedMilliseconds;
}
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);
}
}
}
}
//
// TODO: Load animated GIF images
//
public void RenderPictures(int dir, string NewPictureName, int GifSpeed)
{
const int speedfactor = 4;
Image image = null;
if (NewPictureName != PictureName) {
image = Image.FromFile(NewPictureName);
fp = new FastPixel.FastPixel(new Bitmap(image));
//Console.WriteLine("Loaded picture: " + NewPictureName);
// imageCount = wxImage::GetImageCount(NewPictureName);
// imageIndex = 0;
// if (!image.LoadFile(NewPictureName,wxBITMAP_TYPE_ANY,0))
// {
// //wxMessageBox("Error loading image file: "+NewPictureName);
// image.Clear();
// }
PictureName = NewPictureName;
// if (!image.IsOk())
// return;
//}
//if(imageCount>1)
//{
// // The 10 could be animation speed. I did notice that state is jumping numbers
// // so state%someNumber == 0 may not hit every time. There could be a better way.
// if(state%(21-GifSpeed)==0) // change 1-20 in Gimspeed to be 20 to 1. This makes right hand slider fastest
// {
// if(imageIndex == imageCount-1)
// {
// imageIndex = 0;
// }
// else
// {
// imageIndex++;
// }
// if (!image.LoadFile(PictureName,wxBITMAP_TYPE_ANY,imageIndex))
// {
// //wxMessageBox("Error loading image file: "+NewPictureName);
// image.Clear();
// }
// if (!image.IsOk())
// return;
// }
}
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);
// copy image to buffer
fp.Lock();
Color fpColor = new Color();
for (int x = 0; x < imgwidth; x++) {
for (int y = 0; y < imght; y++) {
//if (!image.IsTransparent(x,y))
fpColor = fp.GetPixel(x, y);
if (fpColor != Color.Transparent) {
switch (dir) {
case 0:
// left
SetPixel(x + BufferWi - movement, yoffset - y-1, fpColor);
break;
case 1:
// right
SetPixel(x + movement - imgwidth, yoffset - y, fpColor);
break;
case 2:
// up
SetPixel(x - xoffset, movement - y, fpColor);
break;
case 3:
// down
SetPixel(x - xoffset, BufferHt + imght - y - movement, fpColor);
break;
default:
// no movement - centered
SetPixel(x - xoffset, yoffset - y, fpColor);
break;
}
}
}
}
fp.Unlock(false);
}
if (image != null)
image.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();
}
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();
}
