public void Enable(EnableMode mode)
{
switch (mode)
{
case EnableMode.Blend:
GL.Enable(EnableCap.Blend);
//FIXME:???for sprite black bg problem
//TODO:removed, not safe
// GL.Disable(EnableCap.DepthTest); //FIXME:???
// __disableBlend = true;
break;
case EnableMode.DepthTest:
GL.Enable(EnableCap.DepthTest);
break;
case EnableMode.CullFace:
GL.Enable(EnableCap.CullFace);
break;
default:
Debug.Assert(false);
break;
}
}
public void SetForAllItemsEnableMode(EnableMode mode)
{
for (lastIndex = 0; lastIndex < EnableItems.Count; lastIndex++)
{
EnableItems[lastIndex].EnableMode = mode;
}
}
public static void SetEnableMode(this BaseClientManagmentControl source, EnableMode mode, params EnableItem[] items)
{
foreach (var enableItem in items)
{
enableItem.EnableMode = mode;
}
}
public Gene Mutate(MutationParams mutationParams)
{
if (!Utility.flipCoin(mutationParams.shouldMutate.probability))
{
return(this);
}
if (Utility.flipCoin(mutationParams.axis.probability))
{
this.axis = Utility.genAxis();
}
if (Utility.flipCoin(mutationParams.enableMode.probability))
{
this.enableMode = (EnableMode)Utility.genInt((int)EnableMode.NumEnableModes);
}
if (Utility.flipCoin(mutationParams.heartBeat.probability))
{
this.heartBeat = Utility.nudgeFloat(this.heartBeat, heartBeatRange, mutationParams.heartBeat.amount);
}
if (Utility.flipCoin(mutationParams.contractTime.probability))
{
this.contractTime = Utility.nudgeFloat(this.contractTime, contractTimeRange, mutationParams.contractTime.amount);
}
if (Utility.flipCoin(mutationParams.extensionDistance.probability))
{
this.extensionDistance = Utility.nudgeFloat(this.extensionDistance, extensionDistanceRange, mutationParams.extensionDistance.amount);
}
return(this);
}
public ButtonAttribute(string text = null, EnableMode mode = EnableMode.Always, string style = "Button", int order = 0)
{
Text = text;
Mode = mode;
Style = style;
Order = order;
}
/*override (Gdk.EventButton evnt)
* {
* var res = base.OnButtonPressEvent(evnt);
* if ((evnt.Button & (uint)Gdk.ModifierType.Button1Mask) != 0)
* {
* if ((evnt.Button & (uint)Gdk.ModifierType.ShiftMask) != 0)
* {
* // if is left click + shift
* EnableMode = EnableMode.ActiveWithLimit;
* }
* else
* {
* // if is left click
* EnableMode = EnableMode.Active;
* }
* }else if ((evnt.Button & (uint)Gdk.ModifierType.Button3Mask) != 0)
* {
* //right clicked
* EnableMode = EnableMode.Disabled;
* }
*
* QueueDraw();
*
* return res;
* }*/
void SetBgColor(EnableMode enableMode, Gdk.EventExpose evnt)
{
//this.ModifyBg(StateType.Normal, Colors[(int)EnableMode]);
Cairo.Context cr = Gdk.CairoHelper.Create(this.GdkWindow);
cr.Rectangle(0, 0, Allocation.Width, Allocation.Height);
Color c = new Color(0, 0, 0);
cr.SetSourceColor(c);
cr.Stroke();
cr.Rectangle(1, 1, Allocation.Width - 1, Allocation.Height - 1);
if (enableMode == EnableMode.Active)
{
c = Colors[1];
}
else if (enableMode == EnableMode.ActiveWithLimit)
{
c = Colors[2];
}
else if (enableMode == EnableMode.Disabled)
{
c = Colors[0];
}
cr.SetSourceColor(c);
cr.Fill();
cr.Target.Dispose();
cr.Dispose();
// set tooltip
HasTooltip = true;
TooltipText = enableMode.ToString();
}
public bool IsEnabled(EnableMode mode)
{
EnableCap mode_ = 0; //FIXME:
switch (mode)
{
case EnableMode.CullFace:
mode_ = EnableCap.CullFace;
break;
case EnableMode.DepthTest:
mode_ = EnableCap.DepthTest;
break;
case EnableMode.Blend:
mode_ = EnableCap.Blend;
break;
case EnableMode.ScissorTest:
mode_ = EnableCap.ScissorTest;
break;
case EnableMode.StencilTest:
mode_ = EnableCap.StencilTest;
break;
default:
Debug.Assert(false);
break;
}
return(GL.IsEnabled(mode_));
}
public void Present(GraphicsContext graphics, FrameBuffer deviceScreen)
{
EnableMode enableMode = graphics.GetEnableMode();
ImageRect viewport = graphics.GetViewport();
ColorMask colorMask = graphics.GetColorMask();
FrameBuffer frameBuffer = graphics.GetFrameBuffer();
ShaderProgram shaderProgram = graphics.GetShaderProgram();
VertexBuffer buffer = graphics.GetVertexBuffer(0);
Texture texture = graphics.GetTexture(0);
graphics.SetEnableMode(EnableMode.None);
graphics.SetViewport(deviceScreen.Rectangle);
graphics.SetColorMask(ColorMask.Rgba);
graphics.SetFrameBuffer(deviceScreen);
graphics.SetShaderProgram(this.shaderProgram);
graphics.SetVertexBuffer(0, this.vertexBuffer);
graphics.SetTexture(0, this.colorTexture);
graphics.DrawArrays(DrawMode.Triangles, 0, 18);
graphics.SetEnableMode(enableMode);
graphics.SetViewport(viewport);
graphics.SetColorMask(colorMask);
graphics.SetFrameBuffer(frameBuffer);
graphics.SetShaderProgram(shaderProgram);
graphics.SetVertexBuffer(0, buffer);
graphics.SetTexture(0, texture);
}
/// <summary>Obtains whether or not the specified graphics feature is enabled</summary>
/// <param name="mode">Graphics feature to enable or disable</param>
/// <returns>Specify true to enable</returns>
public bool IsEnabled(EnableMode mode)
{
if ((mode & ~(EnableMode.ScissorTest | EnableMode.CullFace | EnableMode.Blend | EnableMode.DepthTest | EnableMode.PolygonOffsetFill | EnableMode.StencilTest | EnableMode.Dither)) != EnableMode.None)
{
throw new ArgumentException();
}
return((mode & this.state.Enable) != EnableMode.None);
}
private void StartJobsIfNeeded()
{
if (!Active || DownloadManager.Instance.AddBatchCount > 0)
{
Debug.WriteLine("Leaving StartJobsIfNeeded");
return;
}
DateTime now = DateTime.Now;
EnableMode em = matrix[now.DayOfWeek, now.Hour];
if (parameters.WorkOnlyOnSpecifiedTimes && em == EnableMode.Disabled)
{
RestoreIfNecessary();
return;
}
if (em == EnableMode.ActiveWithLimit)
{
SpeedLimitExtension limit = (SpeedLimitExtension)AppManager.Instance.Application.GetExtensionByType(typeof(SpeedLimitExtension));
if (limit.Parameters.MaxRate != parameters.MaxRateOnTime)
{
//limit.Parameters.Enabled = true;
//limit.Parameters.MaxRate = parameters.MaxRateOnTime;
limit.SetMaxRateTemp(parameters.MaxRateOnTime);
needToRestore = true;
}
}
else
{
RestoreIfNecessary();
}
int maxJobs = parameters.MaxJobs;
using (DownloadManager.Instance.LockDownloadList(false))
{
int count = GetActiveJobsCount();
if (count < maxJobs)
{
for (int i = 0;
(count < maxJobs) && i < DownloadManager.Instance.Downloads.Count;
i++)
{
Downloader d = DownloadManager.Instance.Downloads[i];
if (d.State != DownloaderState.Ended && !d.IsWorking())
{
DownloadManager.Instance.Downloads[i].Start();
count++;
}
}
}
}
}
public static bool HasEnable(PropertyInfo property, EnableMode flags)
{
HiddenAttribute attr = property.GetCustomAttribute(typeof(HiddenAttribute)) as HiddenAttribute;
if (attr != null)
{
return attr.CompareFlags(flags);
}
return true;
}
public void SetForNewItemsEnableMode(EnableMode mode)
{
if (lastIndex < 0)
{
SetForAllItemsEnableMode(mode);
return;
}
for (; lastIndex < EnableItems.Count; lastIndex++)
{
EnableItems[lastIndex].EnableMode = mode;
}
}
/// <summary>Sets the logical OR of the flag that represents whether or not each graphics feature is enabled</summary>
/// <param name="mode">Logical OR of the flag that represents whether or not each graphics feature is enabled</param>
public void SetEnableMode(EnableMode mode)
{
if ((mode & ~(EnableMode.ScissorTest | EnableMode.CullFace | EnableMode.Blend | EnableMode.DepthTest | EnableMode.PolygonOffsetFill | EnableMode.StencilTest | EnableMode.Dither)) != EnableMode.None)
{
throw new ArgumentException();
}
if (this.state.Enable != mode)
{
this.state.Enable = mode;
GraphicsContext.notifyUpdate |= GraphicsUpdate.Enable;
}
}
public static bool HasEnable(Type modelType, string propertyName, EnableMode flags)
{
var property = modelType.GetProperty(propertyName);
if (property == null) return false;
HiddenAttribute attr = property.GetCustomAttribute(typeof(HiddenAttribute)) as HiddenAttribute;
if (attr != null)
{
return !attr.CompareFlags(flags);
}
return true;
}
public MuscleGene(int _originNode, int _connectedNode)
{
Assert.IsTrue(_originNode < _connectedNode, "Cannot connect a muscle from " + _originNode + " to " + _connectedNode + "!");
originNode = _originNode;
connectedNode = _connectedNode;
heartBeat = Utility.genFloat(heartBeatRange);
contractTime = Utility.genFloat(contractTimeRange);
contractedLength = 0.0f;
extensionDistance = Utility.genFloat(extensionDistanceRange);
jointType = (JointType)Utility.genInt((int)JointType.NumJoints);
axis = Utility.genAxis();
enableMode = EnableMode.Enabled;
}
/// <summary>Enables or disables the specified graphics feature</summary>
/// <param name="mode">Graphics feature to enable or disable</param>
/// <param name="status">Specify true to enable</param>
public void Enable(EnableMode mode, bool status)
{
EnableMode enableMode = this.state.Enable;
if ((mode & ~(EnableMode.ScissorTest | EnableMode.CullFace | EnableMode.Blend | EnableMode.DepthTest | EnableMode.PolygonOffsetFill | EnableMode.StencilTest | EnableMode.Dither)) != EnableMode.None)
{
throw new ArgumentException();
}
enableMode = (status ? (enableMode | mode) : (enableMode & ~mode));
if (this.state.Enable != enableMode)
{
this.state.Enable = enableMode;
GraphicsContext.notifyUpdate |= GraphicsUpdate.Enable;
}
}
//private bool __disableBlend = false;
public void Enable(EnableMode mode, bool status)
{
//Debug.Assert(false);
EnableCap mode_ = 0; //FIXME:
switch (mode)
{
case EnableMode.CullFace:
mode_ = EnableCap.CullFace;
break;
case EnableMode.DepthTest:
mode_ = EnableCap.DepthTest;
break;
case EnableMode.Blend:
mode_ = EnableCap.Blend;
//FIXME:??????for sprite black bg problem
//TODO:removed, not safe
// if (status == true)
// {
// GL.Disable(EnableCap.DepthTest); //FIXME:???
// __disableBlend = true;
// }
break;
case EnableMode.ScissorTest:
mode_ = EnableCap.ScissorTest;
break;
case EnableMode.StencilTest:
mode_ = EnableCap.StencilTest;
break;
default:
Debug.Assert(false);
break;
}
if (status)
{
GL.Enable(mode_);
}
else
{
GL.Disable(mode_);
}
}
protected override bool OnButtonPressEvent(EventButton evnt)
{
if (EnableMode == EnableMode.Active)
{
EnableMode = EnableMode.ActiveWithLimit;
}
else if (EnableMode == EnableMode.ActiveWithLimit)
{
EnableMode = EnableMode.Disabled;
}
else if (EnableMode == EnableMode.Disabled)
{
EnableMode = EnableMode.Active;
}
return(base.OnButtonPressEvent(evnt));
}
public Video(DisposableI parent, ApplicationI application, DepthStencilFormats depthStencilFormats, bool vSync)
: base(parent)
{
try
{
this.application = application;
FileTag = "Vita_";
currentPixelTextures = new Texture2D[4];
currentSamplerStates = new SamplerState[4];
PixelFormat format = PixelFormat.None;
switch (depthStencilFormats)
{
case DepthStencilFormats.None: format = PixelFormat.None; break;
case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break;
case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break;
case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break;
case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break;
default:
Debug.ThrowError("Video", "Unsuported DepthStencilFormat type");
break;
}
context = new GraphicsContext(0, 0, PixelFormat.Rgba, format, MultiSampleMode.None);
currentFrameBuffer = context.Screen;
BackBufferSize = new Size2(currentFrameBuffer.Width, currentFrameBuffer.Height);
((VitaApplication)application).Vita_SetFrameSize(currentFrameBuffer.Width, currentFrameBuffer.Height);
currentEnableMode = EnableMode.None;
context.Enable(currentEnableMode);
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public void Reset(FrameBuffer screen)
{
this.Enable = EnableMode.Dither;
this.Scissor = new ImageRect(0, 0, screen.Width, screen.Height);
this.Viewport = new ImageRect(0, 0, screen.Width, screen.Height);
this.DepthRange = new Vector2(0f, 1f);
this.ClearColor = new Vector4(0f, 0f, 0f, 0f);
this.ClearDepth = 1f;
this.ClearStencil = 0;
this.CullFace = new CullFace(CullFaceMode.Back, CullFaceDirection.Ccw);
this.BlendFuncRgb = new BlendFunc(BlendFuncMode.Add, BlendFuncFactor.One, BlendFuncFactor.Zero);
this.BlendFuncAlpha = this.BlendFuncRgb;
this.DepthFunc = new DepthFunc(DepthFuncMode.Less, true);
this.PolygonOffset = new PolygonOffset(0f, 0f);
this.StencilFuncFront = new StencilFunc(StencilFuncMode.Always, 0, 255, 255);
this.StencilOpFront = new StencilOp(StencilOpMode.Keep, StencilOpMode.Keep, StencilOpMode.Keep);
this.StencilFuncBack = this.StencilFuncFront;
this.StencilOpBack = this.StencilOpFront;
this.ColorMask = ColorMask.Rgba;
this.LineWidth = 1f;
}
public void LoadSchedule(string data)
{
if (data == null || (data = data.Trim()).Length == 0)
{
return;
}
string[] days = data.Split('|');
for (int i = 0; i < days.Length; i++)
{
string[] values = days[i].Split(','); //day,hour,status {0,1,2} -> index
if (values.Length == 3)
{
int day = int.Parse(values[0]);
int hour = int.Parse(values[1]);
EnableMode em = (EnableMode)int.Parse(values[2]);
this[(DayOfWeek)day, hour] = em;
}
}
}
public DayHourMatrix(string data)
{
if (data == null || (data = data.Trim()).Length == 0)
{
return;
}
string[] days = data.Split('|');
for (int i = 0; i < days.Length; i++)
{
string[] values = days[i].Split(',');
if (values.Length == 3)
{
int day = int.Parse(values[0]);
int hour = int.Parse(values[1]);
EnableMode em = (EnableMode)int.Parse(values[2]);
this[(DayOfWeek)day, hour] = em;
}
}
}
public static void EnableTarget(object target, EnableMode mode)
{
var go = GameObjectUtil.GetGameObjectFromSource(target);
if (go != null)
{
switch (mode)
{
case EnableMode.Disable:
go.SetActive(false);
break;
case EnableMode.Enable:
go.SetActive(true);
break;
case EnableMode.Toggle:
go.SetActive(!go.activeSelf);
break;
}
}
}
public Video(DisposableI parent, ApplicationI application, DepthStencilFormats depthStencilFormats, bool vSync)
: base(parent)
{
try
{
this.application = application;
FileTag = "Vita_";
currentPixelTextures = new Texture2D[4];
currentSamplerStates = new SamplerState[4];
PixelFormat format = PixelFormat.None;
switch (depthStencilFormats)
{
case DepthStencilFormats.None: format = PixelFormat.None; break;
case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break;
case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break;
case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break;
case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break;
default:
Debug.ThrowError("Video", "Unsuported DepthStencilFormat type");
break;
}
context = new GraphicsContext(0, 0, PixelFormat.Rgba, format, MultiSampleMode.None);
currentFrameBuffer = context.Screen;
BackBufferSize = new Size2(currentFrameBuffer.Width, currentFrameBuffer.Height);
((VitaApplication)application).Vita_SetFrameSize(currentFrameBuffer.Width, currentFrameBuffer.Height);
currentEnableMode = EnableMode.None;
context.Enable(currentEnableMode);
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public HiddenAttribute(EnableMode flags)
{
this.Flags = flags;
}
public MuscleGene Enable()
{
enableMode = EnableMode.Enabled;
return(this);
}
public bool CompareFlags(EnableMode flags)
{
return (Flags & flags) > 0;
}
/// <summary>Enables the specified graphics feature</summary>
/// <param name="mode">Graphics feature to enable or disable</param>
public void Enable(EnableMode mode)
{
this.Enable(mode, true);
}
/// <summary>Disables the specified graphics feature</summary>
/// <param name="mode">Graphics feature to enable or disable</param>
public void Disable(EnableMode mode)
{
this.Enable(mode, false);
}
public void Disable(EnableMode mode)
{
// Debug.Assert(false);
Enable(mode, false);
}
public MultiStateToggle(EnableMode enableMode) : this()
{
EnableMode = enableMode;
}
void EventTriggerEvaluator.IEvaluator.EnableTarget(object target, EnableMode mode)
{
SignalTriggered(target);
EventTriggerEvaluator.Default.EnableTarget(target, mode);
}
public MuscleGene Limp()
{
enableMode = EnableMode.Limp;
return(this);
}
