WebSVN - AndroidProjects - Rev 1674 - /BauzoidTools/BauzoidNET/BurutaruEditor/file/elements/BackgroundElement.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.IO;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.Drawing;
using System.Drawing.Design;

using BauzoidNET.graphics.sprite;
using BauzoidNET.graphics;
using BauzoidNET.parser;
using BauzoidNET.math;

using BurutaruEditor.view;

namespace BurutaruEditor.file.elements
{
public class BackgroundElement : LevelElement
{
private string mTextureFile = null;

public static readonly Vector4 ANIM_LINE_COLOR = new Vector4(1, 0.5f, 0.5f, 0.7f);

[System.ComponentModel.Editor(typeof(Document.SpriteFileNameEditor), typeof(System.Drawing.Design.UITypeEditor))]
[Category("Basic Parameters")]
public string TextureFile
{
get
{
return mTextureFile;
}
set
{
LoadSprite(value);
}
}

private SpriteTransform mTransform = new SpriteTransform();
private Vector2 mScrollFactor = new Vector2(1, 1);

private SpriteTransform mAnimTransform = new SpriteTransform();

private SimpleSprite mSprite = null;
[Browsable(false)]
public SimpleSprite Sprite { get { return mSprite; } }

[TypeConverter(typeof(ExpandableObjectConverter))]
[Category("Basic Parameters")]
public SpriteTransform Transform
{
get { return mTransform; }
}

[TypeConverter(typeof(ExpandableObjectConverter))]
[Category("Basic Parameters")]
public Vector2 ScrollFactor
{
get { return mScrollFactor; }
}

private Vector4 mMultiplyColor = new Vector4(1, 1, 1, 1);
private Vector4 mLerpColor = new Vector4(0, 0, 0, 0);

[Category("Basic Parameters")]
[Editor(typeof(ColorEditor), typeof(UITypeEditor))] // specify editor for the property
public Color MultiplyColor
{
get
{
return Color.FromArgb(255, (int)(mMultiplyColor.x * 255), (int)(mMultiplyColor.y * 255), (int)(mMultiplyColor.z * 255));
}
set
{
mMultiplyColor.set((float)value.R / 255.0f, (float)value.G / 255.0f, (float)value.B / 255.0f, 1.0f);
}
}

private float mMultiplyFactor = 1.0f;
[Category("Basic Parameters")]
public float MultiplyFactor
{
get { return mMultiplyFactor; }
set { mMultiplyFactor = MathUtil.clamp(value, 0, 1); }
}

[Category("Basic Parameters")]
[Editor(typeof(ColorEditor), typeof(UITypeEditor))] // specify editor for the property
public Color LerpColor
{
get
{
return Color.FromArgb(255, (int)(mLerpColor.x * 255), (int)(mLerpColor.y * 255), (int)(mLerpColor.z * 255));
}
set
{
mLerpColor.set((float)value.R / 255.0f, (float)value.G / 255.0f, (float)value.B / 255.0f, 1.0f);
}
}

private float mLerpFactor = 0.0f;
[Category("Basic Parameters")]
public float LerpFactor
{
get { return mLerpFactor; }
set { mLerpFactor = MathUtil.clamp(value, 0, 1); }
}

[Category("Basic Parameters")]
public float Alpha { get; set; }

[Category("Animation")]
public bool Animated { get; set; }

[Category("Animation")]
public float AnimStartTime { get; set; }

[Category("Animation")]
public float AnimDuration { get; set; }

[Category("Animation")]
public float TargetX { get; set; }

[Category("Animation")]
public float TargetY { get; set; }

[Category("Animation")]
public float TargetWidth { get; set; }

[Category("Animation")]
public float TargetHeight { get; set; }

[Category("Animation")]
public float TargetAngle { get; set; }

//=================================================================================================================================

public BackgroundElement(Document doc, string name)
: base(doc, name)
{
Alpha = 1.0f;
Animated = false;
AnimStartTime = 0;
AnimDuration = 0;
TargetX = 0.0f;
TargetY = 0.0f;
TargetWidth = 0.0f;
TargetHeight = 0.0f;
TargetAngle = 0.0f;
}

public override void Init()
{
string s = Path.Combine(Application.StartupPath, @"..\\..\\..\\..\\..\\BauzoidApps\\BurutaruZ_v2\\burutaru-android\\assets");
string fullPath = Path.GetFullPath(s) + "\\" + mTextureFile;

mSprite = new SimpleSprite(MainForm.App.getGraphics(), fullPath);
mSprite.init();
}

public override void Exit()
{
if (mSprite != null)
{
mSprite.dispose();
mSprite = null;
}
}

public void LoadSprite(string filename)
{
Exit();

string path = Path.GetFullPath(Path.Combine(Application.StartupPath, @"..\\..\\..\\..\\..\\BauzoidApps\\BurutaruZ_v2\\burutaru-android\\assets\\"));
System.Uri uri1 = new Uri(path, UriKind.Absolute);
System.Uri uri2 = new Uri(filename, UriKind.Absolute);
mTextureFile = uri1.MakeRelativeUri(uri2).ToString();

Init();
}

public override void Render()
{
float t = Doc.View.CurrentTime;

mSprite.getSpriteTransform().set(mTransform);
mSprite.getSpriteTransform().x += Doc.View.CurrentPosition.x * mScrollFactor.x;
mSprite.getSpriteTransform().y += Doc.View.CurrentPosition.y * mScrollFactor.y;
mSprite.getSpriteInstance().color.setFrom(mMultiplyColor);
mSprite.getSpriteInstance().color.w = mMultiplyFactor;
mSprite.getSpriteInstance().fogColor.setFrom(mLerpColor);
mSprite.getSpriteInstance().fogColor.w = mLerpFactor;
if (Animated && (t >= AnimStartTime))
mSprite.getSpriteInstance().alpha = Alpha * 0.5f;
else
mSprite.getSpriteInstance().alpha = Alpha;
mSprite.render();

// render animation ghost
if (Animated)
{
if (t >= AnimStartTime)
{
t -= AnimStartTime;
t /= AnimDuration;
t = MathUtil.clamp(t, 0, 1);
float dx = (TargetX - mTransform.x) * t;
float dy = (TargetY - mTransform.y) * t;
float dw = (TargetWidth - mTransform.w) * t;
float dh = (TargetHeight - mTransform.h) * t;
float da = (TargetAngle - mTransform.angle) * t;
mSprite.getSpriteTransform().x += dx;
mSprite.getSpriteTransform().y += dy;
mSprite.getSpriteTransform().w += dw;
mSprite.getSpriteTransform().h += dh;
mSprite.getSpriteTransform().angle += da;
mSprite.getSpriteInstance().alpha = Alpha;
mSprite.render();

/*float x1 = mTransform.x + Doc.View.CurrentPosition.x * mScrollFactor.x;
float y1 = mTransform.y + Doc.View.CurrentPosition.y * mScrollFactor.y;
float x2 = TargetX + Doc.View.CurrentPosition.x * mScrollFactor.x;
float y2 = TargetY + Doc.View.CurrentPosition.y * mScrollFactor.y;
RenderUtil.drawArrow(MainForm.App.getGraphics(), x1, y1, x2, y2, ANIM_LINE_COLOR);*/
}
}
}

public void GetTransformed(out float x, out float y, out float w, out float h, out float angle)
{
float t = Doc.View.CurrentTime;

x = mTransform.x + Doc.View.CurrentPosition.x * mScrollFactor.x;
y = mTransform.y + Doc.View.CurrentPosition.y * mScrollFactor.y;
w = mTransform.w;
h = mTransform.h;
angle = mTransform.angle;

if (Animated)
{
if (t >= AnimStartTime)
{
t -= AnimStartTime;
t /= AnimDuration;
t = MathUtil.clamp(t, 0, 1);
float dx = (TargetX - mTransform.x) * t;
float dy = (TargetY - mTransform.y) * t;
float dw = (TargetWidth - mTransform.w) * t;
float dh = (TargetHeight - mTransform.h) * t;
float da = (TargetAngle - mTransform.angle) * t;

x += dx;
y += dy;
w += dw;
h += dh;
angle += da;
}
}
}

public SpriteTransform GetTransformed()
{
float sx, sy, sw, sh, sAngle;
GetTransformed(out sx, out sy, out sw, out sh, out sAngle);

SpriteTransform result = new SpriteTransform();
result.x = sx;
result.y = sy;
result.w = sw;
result.h = sh;
result.pivotX = mTransform.pivotX;
result.pivotY = mTransform.pivotY;
result.angle = sAngle;

return result;
}

public override void RenderSelected(int selectedPart, bool forHover = false)
{
/*if (selectedPart == PART_SPAWN_TRIGGER)
base.RenderSelected(selectedPart);

float posX = SpawnTrigger.x + SpawnPosition.x + Doc.View.CurrentPosition.x;
float posY = SpawnTrigger.y + SpawnPosition.y + Doc.View.CurrentPosition.y;

float halfSize = BLOB_ENEMY_SIZE / 2 + DocumentView.SELECTION_FRAME_OFFSET;

Doc.View.RenderSelectionFrame(posX - halfSize, posY - halsSize, posX + halfSize, posY + halfSize);*/

mSprite.getSpriteTransform().set(mTransform);
mSprite.getSpriteTransform().x += Doc.View.CurrentPosition.x * mScrollFactor.x;
mSprite.getSpriteTransform().y += Doc.View.CurrentPosition.y * mScrollFactor.y;
SpriteTransform t = mSprite.getSpriteTransform();

Vector2 min = t.getAABoxMin();
Vector2 max = t.getAABoxMax();

/*float posX = SpawnTrigger.x + SpawnPosition.x + Doc.View.CurrentPosition.x;
float posY = SpawnTrigger.y + SpawnPosition.y + Doc.View.CurrentPosition.y;

float halfSize = BLOB_ENEMY_SIZE / 2 + DocumentView.SELECTION_FRAME_OFFSET;*/

if (forHover)
Doc.View.RenderSelectionFrame(min.x, min.y, max.x, max.y, DocumentView.SELECTION_FRAME_HOVER_ALPHA);
else
Doc.View.RenderSelectionFrame(min.x, min.y, max.x, max.y);
}

public override bool IsInside(float x, float y, out int selectedPart)
{
selectedPart = -1;

mSprite.getSpriteTransform().set(mTransform);
mSprite.getSpriteTransform().x += Doc.View.CurrentPosition.x * mScrollFactor.x;
mSprite.getSpriteTransform().y += Doc.View.CurrentPosition.y * mScrollFactor.y;
SpriteTransform t = mSprite.getSpriteTransform();

if (t.isInside(x, y))
return true;

/*Vector2 min = t.getAABoxMin();
Vector2 max = t.getAABoxMax();

if ((x >= min.x) && (y >= min.y) && (x <= max.x) && (y <= max.y))
return true;*/

return false;
}

public override void MoveBy(float dx, float dy, int selectedPart)
{
mTransform.x += (dx / Doc.View.ZoomFactor);
mTransform.y += (dy / Doc.View.ZoomFactor);
}

public override string GetPropertiesType()
{
return "BackgroundElement";
}

public override void WriteData(TextWriter tw)
{
base.WriteData(tw);
writeSpriteTransform(tw, mTransform);
tw.WriteLine("\ttexture \"" + mTextureFile + "\";");
tw.WriteLine("\tscrollFactor " + mScrollFactor.x + ", " + mScrollFactor.y + ";");
tw.WriteLine("\tmultiplyColor " + mMultiplyColor.x + ", " + mMultiplyColor.y + ", " + mMultiplyColor.z + ", " + mMultiplyFactor + ";");
tw.WriteLine("\tlerpColor " + mLerpColor.x + ", " + mLerpColor.y + ", " + mLerpColor.z + ", " + mLerpFactor + ";");
tw.WriteLine("\talpha " + Alpha + ";");

tw.WriteLine("\tanimated " + (Animated ? "true" : "false") + ";");
tw.WriteLine("\tanimStartTime " + AnimStartTime + ";");
tw.WriteLine("\tanimDuration " + AnimDuration + ";");
tw.WriteLine("\ttargetX " + TargetX + ";");
tw.WriteLine("\ttargetY " + TargetY + ";");
tw.WriteLine("\ttargetWidth " + TargetWidth + ";");
tw.WriteLine("\ttargetHeight " + TargetHeight + ";");
tw.WriteLine("\ttargetAngle " + TargetAngle + ";");
}

public override void WriteData(Serializer s)
{
base.WriteData(s);

writeSpriteTransform(s, mTransform);
s.Write("texture"); s.Write(mTextureFile);
s.Write("scrollFactor"); s.Write(mScrollFactor);
s.Write("multiplyColor"); s.Write(mMultiplyColor);
s.Write("lerpColor"); s.Write(mLerpColor);
s.Write("alpha"); s.Write(Alpha);

s.Write("animated"); s.Write(Animated);
s.Write("animStartTime"); s.Write(AnimStartTime);
s.Write("animDuration"); s.Write(AnimDuration);
s.Write("targetX"); s.Write(TargetX);
s.Write("targetY"); s.Write(TargetY);
s.Write("targetWidth"); s.Write(TargetWidth);
s.Write("targetHeight"); s.Write(TargetHeight);
s.Write("targetAngle"); s.Write(TargetAngle);

}

public override bool ReadParameter(Tokenizer t, string id)
{
// texture
if (id.Equals("texture", StringComparison.OrdinalIgnoreCase))
{
mTextureFile = t.readString();
}
// scroll speed
else if (id.Equals("scrollFactor", StringComparison.OrdinalIgnoreCase))
{
mScrollFactor = ParseUtil.readVector2(t);
}
else if (id.Equals("multiplyColor", StringComparison.OrdinalIgnoreCase))
{
mMultiplyColor = ParseUtil.readVector4(t);
mMultiplyFactor = mMultiplyColor.w;
mMultiplyColor.w = 1.0f;
}
else if (id.Equals("lerpColor", StringComparison.OrdinalIgnoreCase))
{
mLerpColor = ParseUtil.readVector4(t);
mLerpFactor = mLerpColor.w;
mLerpColor.w = 1.0f;
}
else if (id.Equals("alpha", StringComparison.OrdinalIgnoreCase))
{
Alpha = t.readNumber();
}
else if (id.Equals("animated", StringComparison.OrdinalIgnoreCase))
{
Animated = (t.readIdentifier().Equals("true", StringComparison.OrdinalIgnoreCase));
}
else if (id.Equals("animStartTime", StringComparison.OrdinalIgnoreCase))
{
AnimStartTime = t.readNumber();
}
else if (id.Equals("animDuration", StringComparison.OrdinalIgnoreCase))
{
AnimDuration = t.readNumber();
}
else if (id.Equals("targetX", StringComparison.OrdinalIgnoreCase))
{
TargetX = t.readNumber();
}
else if (id.Equals("targetY", StringComparison.OrdinalIgnoreCase))
{
TargetY = t.readNumber();
}
else if (id.Equals("targetWidth", StringComparison.OrdinalIgnoreCase))
{
TargetWidth = t.readNumber();
}
else if (id.Equals("targetHeight", StringComparison.OrdinalIgnoreCase))
{
TargetHeight = t.readNumber();
}
else if (id.Equals("targetAngle", StringComparison.OrdinalIgnoreCase))
{
TargetAngle = t.readNumber();
}
// read other parameter types
else if (!parseSpriteTransform(t, id, mTransform))
{
// no other parameter type, so check super-class
return base.ReadParameter(t, id);
}

t.readToken(";");
return true;
}
}
}

Subversion Repositories AndroidProjects

(root)/BauzoidTools/BauzoidNET/BurutaruEditor/file/elements/BackgroundElement.cs - Rev 1674