public void UnloadAsset()
{
//TODO: unset from any linked objects
Media.ShaderList.Remove(this);
Agk.DeleteShader(this.ResourceNumber);
}
public static ImageAsset MakeColorImage(uint rSizeX, uint rSizeY, uint rColor1, uint rColor2, uint rColor3, uint rColor4, int rFill)
{
string tName = rSizeX.ToString() + "," + rSizeY.ToString() + "," + rColor1.ToString() + "," + rColor2.ToString() + "," + rColor3.ToString() + "," + rColor4.ToString() + "," + rFill.ToString();
var tImg = Media.GetImageAsset(tName, 1.0f, 1.0f);
if (tImg != null)
{
return(tImg);
}
Agk.Swap();
Agk.DrawBox(0, 0, rSizeX, rSizeY, rColor1, rColor2, rColor3, rColor4, rFill);
Agk.Render();
var tNum = Agk.GetImage(0, 0, rSizeX, rSizeY);
Agk.ClearScreen();
Agk.Swap();
App.Log("Media.cs", 2, "media", " > made image from color");
tImg = new ImageAsset()
{
ResourceNumber = tNum,
File = tName,
ScaleX = 1.0f,
ScaleY = 1.0f
};
Media.ImageList.Add(tImg);
return(tImg);
}
public CharacterEntity2d(string rFileBase, int rWidth, int rHeight)
{
Properties.IsObject = false;
Properties.Filebase = rFileBase;
ImageAsset tSheet = Media.GetImageAsset(rFileBase + ".png", 1.0f, 1.0f);
Agk.Swap();
var spSheet = Agk.CreateSprite(tSheet.ResourceNumber);
Agk.SetSpritePosition(spSheet, 0.0f, 0.0f);
Agk.Render();
bool isFirst = true;
for (int row = 0; row < (Agk.GetImageHeight(tSheet.ResourceNumber) / rHeight); row++)
{
for (int col = 0; col < (Agk.GetImageWidth(tSheet.ResourceNumber) / rWidth); col++)
{
var tImg = Agk.GetImage(col * rWidth, row * rHeight, rWidth, rHeight);
if (isFirst)
{
Properties.ResourceNumber = Agk.CreateSprite(tImg);
isFirst = false;
}
Agk.AddSpriteAnimationFrame(Properties.ResourceNumber, tImg);
}
}
Agk.DeleteSprite(spSheet);
Agk.ClearScreen();
Agk.Swap();
CharacterHandler2d.CharacterList.Add(this);
}
public CharacterEntity3d(string rFileBase)
{
var tObj = Media.LoadObjectAsset(rFileBase + ".dae", false, true, Guid.NewGuid().ToString());
Agk.SetObjectScalePermanent(tObj.ResourceNumber, 30.0f, 30.0f, 30.0f);
Agk.RotateObjectGlobalY(tObj.ResourceNumber, 180.0f);
Agk.FixObjectPivot(tObj.ResourceNumber);
var fx = Media.GetShaderAsset("media/shaders/SurfaceDiffSpecBone.vs", "media/shaders/SurfaceDiffSpec.ps", true);
Agk.SetShaderConstantByName(fx.ResourceNumber, "u_normalSize", 1.0f, 0, 0, 0);
Agk.SetShaderConstantByName(fx.ResourceNumber, "u_specularPower", 10.0f, 0, 0, 0);
Agk.SetObjectShader(tObj.ResourceNumber, fx.ResourceNumber);
var tImg = Media.GetImageAsset(rFileBase + "_d.png", 1.0f, 1.0f);
Agk.SetObjectImage(tObj.ResourceNumber, tImg.ResourceNumber, 0);
tImg = Media.GetImageAsset(rFileBase + "_n.png", 1.0f, 1.0f);
Agk.SetObjectImage(tObj.ResourceNumber, tImg.ResourceNumber, 1);
tImg = Media.GetImageAsset(rFileBase + "_s.png", 1.0f, 1.0f);
Agk.SetObjectImage(tObj.ResourceNumber, tImg.ResourceNumber, 2);
Properties.ResourceNumber = tObj.ResourceNumber;
Properties.IsObject = true;
Properties.Filebase = rFileBase;
Properties.Shader = fx;
Properties.Height = Agk.GetObjectSizeMaxY(Properties.ResourceNumber) - Agk.GetObjectSizeMinY(Properties.ResourceNumber);
CharacterHandler3d.CharacterList.Add(this);
}
public void SphereCast(AGKVector3 rFrom, AGKVector3 rTo, float rRadius, bool rSlide)
{
Agk.SetVector3(FromVectorNumber, rFrom.X, rFrom.Y, rFrom.Z);
Agk.SetVector3(ToVectorNumber, rTo.X, rTo.Y, rTo.Z);
Agk.SphereCast3DPhysics(ResourceNumber, (int)FromVectorNumber, (int)ToVectorNumber, rRadius);
HitObjectNumber = (uint)Agk.Get3DPhysicsRayCastObjectHit(ResourceNumber, Agk.Get3DPhysicsRayCastFraction(ResourceNumber));
if (HitObjectNumber > 0)
{
Agk.Get3DPhysicsRayCastContactPosition(ResourceNumber, Agk.Get3DPhysicsRayCastFraction(ResourceNumber), (int)HitVectorNumber);
HitPosition.X = Agk.GetVector3X(HitVectorNumber);
HitPosition.Y = Agk.GetVector3Y(HitVectorNumber);
HitPosition.Z = Agk.GetVector3Z(HitVectorNumber);
if (!rSlide)
{
return;
}
Agk.Get3DPhysicsRayCastNormalVector(ResourceNumber, (int)HitVectorNumber);
if (Math.Abs(HitNormalVector.Y) > 0.999)
{
SlideVector = new AGKVector3(HitNormalVector.Y, 0.0f, 0.0f);
}
else
{
SlideVector = new AGKVector3(-HitNormalVector.Z, 0.0f, HitNormalVector.X).Normalize();
}
HitPosition *= SlideVector;
}
}
public static void OnMouseMove(object sender, MouseEventArgs e)
{
if (suppress)
{
suppress = false;
return;
}
Mouse.MoveX = e.X - Mouse.PosX;
Mouse.MoveY = e.Y - Mouse.PosY;
Mouse.PosX = e.X;
Mouse.PosY = e.Y;
if (!Mouse.IsVisible)
{
suppress = true;
Mouse.PosX = App.Config.Screen.CenterX;
Mouse.PosY = App.Config.Screen.CenterY;
Agk.SetRawMousePosition(App.Config.Screen.CenterX, App.Config.Screen.CenterY);
}
var st = Scheduler.Scheduled.FirstOrDefault(s => s.Name == "Hardware.ResetMouseMove");
if (st != null)
{
Scheduler.Scheduled.Remove(st);
st.Timer.Dispose();
}
Scheduler.SetInterval(Hardware.ResetMouseMove, "", 1, 0, (int)App.Timing.Delta, "");
}
public static ImageAsset GetImageAsset(string rFilename, float rScaleX, float rScaleY)
{
App.Log("Media.cs", 2, "media", "Requested image: " + rFilename + " " + rScaleX.ToString() + " " + rScaleY.ToString());
foreach (var i in Media.ImageList)
{
if (i.File == rFilename)
{
if (i.ScaleX == rScaleX && i.ScaleY == rScaleY)
{
if (Agk.GetImageExists(i.ResourceNumber) == 1)
{
App.Log("Media.cs", 2, "media", " > found image on " + i.ResourceNumber.ToString());
return(i);
}
else
{
App.Log("Media.cs", 2, "media", " > found image on " + i.ResourceNumber.ToString() + "but is not valid: reload it");
if (System.IO.File.Exists(rFilename))
{
i.ResourceNumber = Agk.LoadImageResized(rFilename, rScaleX, rScaleY, 0);
return(i);
}
}
}
}
}
if (System.IO.File.Exists(rFilename))
{
App.Log("Media.cs", 2, "media", " > image not loaded: load it");
var tImg = Agk.LoadImageResized(rFilename, rScaleX, rScaleY, 0);
Agk.SetImageWrapU(tImg, 1);
Agk.SetImageWrapV(tImg, 1);
var i = new ImageAsset()
{
ResourceNumber = tImg,
File = rFilename,
ScaleX = rScaleX,
ScaleY = rScaleY
};
Media.ImageList.Add(i);
return(i);
}
else
{
if (rFilename.Contains("media"))
{
//if filename does not include the media folder, we are looking for a generated sprite color image, just return null and keep running
//if filename does include media folder, the file is not found and we got problems.
App.Log("Media.cs", 5, "error", "ERROR: File not found: " + rFilename + " on Media.GetImageAsset");
App.StopRunning(true);
}
}
return(null);
}
public static ShaderAsset GetShaderAsset(string rVsFile, string rPsFile, bool rCanInstance)
{
App.Log("Media.cs", 2, "media", "Requested shader: " + rVsFile + " " + rPsFile);
if (rCanInstance)
{
foreach (var i in Media.ShaderList)
{
if (i.VS == rVsFile && i.PS == rPsFile)
{
if (Agk.IsShaderExists(i.ResourceNumber))
{
App.Log("Media.cs", 2, "media", " > found shader on " + i.ResourceNumber.ToString());
return(i);
}
else
{
App.Log("Media.cs", 2, "media", " > found shader on " + i.ResourceNumber.ToString() + "but is not valid: reload it");
if (System.IO.File.Exists(rVsFile) && System.IO.File.Exists(rPsFile))
{
i.ResourceNumber = Agk.LoadShader(rVsFile, rPsFile);
return(i);
}
}
}
}
}
if (System.IO.File.Exists(rVsFile) && System.IO.File.Exists(rPsFile))
{
App.Log("Media.cs", 2, "media", " > image not loaded: load it");
var tShd = Agk.LoadShader(rVsFile, rPsFile);
var i = new ShaderAsset()
{
ResourceNumber = tShd,
VS = rVsFile,
PS = rPsFile
};
Media.ShaderList.Add(i);
return(i);
}
else
{
if (rVsFile.Contains("media") || rPsFile.Contains("media"))
{
//if filename does not include the media folder, we are looking for a generated shader from string, just return null and keep running
//if filename does include media folder, the file is not found and we got problems.
System.Windows.Forms.MessageBox.Show("File not found: " + rVsFile + " " + rPsFile);
App.Log("Media.cs", 5, "error", "ERROR: File not found: " + rVsFile + ", " + rPsFile + " on Media.GetShaderAsset");
App.StopRunning(true);
}
}
System.Windows.Forms.MessageBox.Show("File not found: " + rVsFile + " " + rPsFile);
App.StopRunning(true);
return(null);
}
public static void UnloadAllImageAssets()
{
foreach (var i in Media.ImageList)
{
Agk.DeleteImage(i.ResourceNumber);
}
Media.ImageList.Clear();
}
public void Dispose()
{
Agk.Delete3DPhysicsRay(ResourceNumber);
Agk.DeleteVector3(FromVectorNumber);
Agk.DeleteVector3(ToVectorNumber);
Agk.DeleteVector3(HitVectorNumber);
this.Dispose();
}
public static void SetMouseVisible(bool rVisible)
{
if ((rVisible && !Mouse.IsVisible) || (!rVisible && Mouse.IsVisible))
{
Agk.SetRawMouseVisible(rVisible);
Mouse.IsVisible = rVisible;
}
}
static void Core_OnActivated(object sender, EventArgs e)
{
m_Window.TopMost = m_bMaximized;
m_Window.Update();
Agk.Resumed();
Agk.WindowMoved();
}
public static bool InitAGK()
{
if (m_Window.Handle != null)
{
Agk.InitGL(m_Window.Handle);
}
return(true);
}
public static bool InitAGK(Form window)
{
if (window.Handle != null)
{
Agk.InitGL(window.Handle);
}
return(true);
}
public static void UnloadAllShaderAssets()
{
foreach (var i in Media.ShaderList)
{
//TODO: remove from objects?
Agk.DeleteShader(i.ResourceNumber);
}
Media.ShaderList.Clear();
}
public static uint ParseColor(string rValue)
{
string valR;
string valG;
string valB;
if (rValue[0] == '#')
{
if (rValue.Length == 4)
{
//short form hex #000
valR = rValue[1].ToString();
valG = rValue[2].ToString();
valB = rValue[3].ToString();
return(Agk.MakeColor(
byte.Parse(valR + valR, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
byte.Parse(valG + valG, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
byte.Parse(valB + valB, NumberStyles.HexNumber, CultureInfo.InvariantCulture)
));
}
else if (rValue.Length == 7)
{
//rgb hex #000000
valR = rValue.Substring(1, 2);
valG = rValue.Substring(3, 2);
valB = rValue.Substring(5, 2);
return(Agk.MakeColor(
byte.Parse(valR, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
byte.Parse(valG, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
byte.Parse(valB, NumberStyles.HexNumber, CultureInfo.InvariantCulture)
));
}
else
{
//argb hex #00000000
valR = rValue.Substring(3, 2);
valG = rValue.Substring(5, 2);
valB = rValue.Substring(7, 2);
return(Agk.MakeColor(
byte.Parse(valR, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
byte.Parse(valG, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
byte.Parse(valB, NumberStyles.HexNumber, CultureInfo.InvariantCulture)
));
}
}
else if (rValue[0] == 'r')
{
rValue = rValue.Substring(4, rValue.Length - 4);
var c = rValue.Split(',');
{
return(Agk.MakeColor(Convert.ToUInt32(c[0]), Convert.ToUInt32(c[1]), Convert.ToUInt32(c[2])));
}
}
return(0);
}
public void ApplyToAgk()
{
Agk.SetCameraFOV(1, FOV);
Agk.SetCameraPosition(1, Position.X, Position.Y, Position.Z);
Agk.SetCameraRange(1, Near, Far);
Agk.SetCameraRotation(1, Rotation.X, Rotation.Y, Rotation.Z);
if (Target != null)
{
Agk.SetCameraLookAt(1, (Target.Properties.Position.X + Offset.X), (Target.Properties.Position.Y + Offset.Y), (Target.Properties.Position.Z + Offset.Z), Rotation.Z);
}
}
public static bool LoopAGK()
{
Application.DoEvents();
if (Agk.IsCapturingImage() > 0)
{
System.Threading.Thread.Sleep(10);
}
return(App.Status.IsRunning);
}
static void Core_OnDeactivate(object sender, EventArgs e)
{
Agk.MouseLeftButton(0, 0);
Agk.MouseRightButton(0, 0);
Agk.MouseMiddleButton(0, 0);
m_Window.TopMost = m_bMaximized;
m_Window.Update();
Agk.Paused();
Agk.WindowMoved();
}
public void UnloadAsset()
{
//TODO: unload textures/shaders?
Media.ObjectList.Remove(this);
if (this.HasBones)
{
Agk.DeleteObjectWithChildren(this.ResourceNumber);
}
else
{
Agk.DeleteObject(this.ResourceNumber);
}
}
public void RayCast(AGKVector3 rFrom, AGKVector3 rTo)
{
Agk.SetVector3(FromVectorNumber, rFrom.X, rFrom.Y, rFrom.Z);
Agk.SetVector3(ToVectorNumber, rTo.X, rTo.Y, rTo.Z);
Agk.RayCast3DPhysics(ResourceNumber, (int)FromVectorNumber, (int)ToVectorNumber, 1);
HitObjectNumber = (uint)Agk.Get3DPhysicsRayCastObjectHit(ResourceNumber, Agk.Get3DPhysicsRayCastFraction(ResourceNumber));
if (HitObjectNumber > 0)
{
Agk.Get3DPhysicsRayCastContactPosition(ResourceNumber, Agk.Get3DPhysicsRayCastFraction(ResourceNumber), (int)HitVectorNumber);
HitPosition.X = Agk.GetVector3X(HitVectorNumber);
HitPosition.Y = Agk.GetVector3Y(HitVectorNumber);
HitPosition.Z = Agk.GetVector3Z(HitVectorNumber);
}
}
public void UpdateFromAgk()
{
FOV = Agk.GetCameraFOV(1);
Position.X = Agk.GetCameraX(1);
Position.Y = Agk.GetCameraY(1);
Position.Z = Agk.GetCameraZ(1);
Rotation.X = Agk.GetCameraAngleX(1);
Rotation.Y = Agk.GetCameraAngleY(1);
Rotation.Z = Agk.GetCameraAngleZ(1);
//TODO: reverse calc orbit/target values if bound
//ProjectionMatrix = AGKMatrix4.Perspective(0.25f * (float)Math.PI, AspectRatio, 1.0f, 1000.0f);
ProjectionMatrix = AGKMatrix4.Perspective(FOV, App.Config.Screen.AspectRatio, Near, Far);
}
public static void UnloadAllObjectAssets()
{
foreach (var i in Media.ObjectList)
{
//TODO: unload/unlink textures/shaders?
if (i.HasBones)
{
Agk.DeleteObjectWithChildren(i.ResourceNumber);
}
else
{
Agk.DeleteObject(i.ResourceNumber);
}
}
Media.ObjectList.Clear();
}
public static void UpdateBoundObjects(object rArgs)
{
foreach (var objBinding in Media.ObjectBindings)
{
if (Data.GetBit((int)ObjectBinding.ModeBit.Location, objBinding.Mode) == 1)
{
Agk.SetObjectPosition
(
objBinding.Object.ResourceNumber,
Agk.GetObjectWorldX(objBinding.Parent.ResourceNumber),
Agk.GetObjectWorldY(objBinding.Parent.ResourceNumber),
Agk.GetObjectWorldZ(objBinding.Parent.ResourceNumber)
);
}
if (Data.GetBit((int)ObjectBinding.ModeBit.Rotation, objBinding.Mode) == 1)
{
Agk.SetObjectRotation
(
objBinding.Object.ResourceNumber,
Agk.GetObjectWorldAngleX(objBinding.Parent.ResourceNumber),
Agk.GetObjectWorldAngleY(objBinding.Parent.ResourceNumber),
Agk.GetObjectWorldAngleZ(objBinding.Parent.ResourceNumber)
);
}
if (Data.GetBit((int)ObjectBinding.ModeBit.Scale, objBinding.Mode) == 1)
{
}
if (Data.GetBit((int)ObjectBinding.ModeBit.Collision, objBinding.Mode) == 1)
{
}
if (Data.GetBit((int)ObjectBinding.ModeBit.Frame, objBinding.Mode) == 1)
{
Agk.SetObjectAnimationFrame
(
objBinding.Object.ResourceNumber,
"",
Agk.GetObjectAnimationTime(objBinding.Parent.ResourceNumber),
0.0f
);
}
if (Data.GetBit((int)ObjectBinding.ModeBit.Light, objBinding.Mode) == 1)
{
}
}
}
public static void UpdateTiming()
{
uint oldTime = App.Timing.Timer;
App.Timing.Timer = Agk.GetMilliseconds();
App.Timing.Delta = App.Timing.Timer - oldTime;
int oldPause = App.Timing.PauseState;
if (App.Timing.PauseHold == 0)
{
App.Timing.PauseState = 0;
}
else
{
App.Timing.PauseState = 1;
if (oldPause == 0)
{
App.Timing.PauseMark = App.Timing.Timer;
}
else
{
App.Timing.PauseElapsed = (uint)Agk.Abs(App.Timing.Timer - App.Timing.PauseMark);
}
}
if (App.Timing.PauseState == 2)
{
//pause ended and elapsed time has been applied, clear down
App.Timing.PauseState = 0;
App.Timing.PauseMark = 0;
App.Timing.PauseElapsed = 0;
}
if (App.Timing.PauseState == 0 && oldPause == 1)
{
//pause ended, resume all updates but keep the elapsed time available for paused updates to adjust against elapsed times.
App.Timing.PauseState = 2;
Hardware.Mouse.MoveX = 0.0f;
Hardware.Mouse.MoveY = 0.0f;
Hardware.Mouse.MoveZ = 0.0f;
}
}
public static void UpdateEntities(object rArgs)
{
foreach (var e in WorldEntityList)
{
e.Update();
}
//TEMP - For SurfaceDiffuseClipLit - TODO we dont want to apply this every loop, only when lighting changes, also handle multiple lights
var dirLight = World3d.Celestials.First().LightProperties;
foreach (var s in Media.ShaderList)
{
if (s.ReceiveDirectionalLight)
{
Agk.SetShaderConstantByName(s.ResourceNumber, "u_lightDirection", dirLight.Direction.X, dirLight.Direction.Y, dirLight.Direction.Z, 0);
Agk.SetShaderConstantByName(s.ResourceNumber, "u_lightDiffuse", dirLight.Diffuse.R, dirLight.Diffuse.G, dirLight.Diffuse.B, 0);
Agk.SetShaderConstantByName(s.ResourceNumber, "u_lightAmbient", dirLight.Ambient.R, dirLight.Ambient.G, dirLight.Ambient.B, 0);
}
}
}
public World3d()
{
Dispatcher.Add(World3d.UpdateEntities);
App.UpdateList.Add(new UpdateHandler("World3d.UpdateEntities", "", false));
Agk.SetSunActive(0);
Agk.SetAmbientColor(0, 0, 0);
//Agk.SetClearColor(52, 125, 217);
//TEMP most init will happen during a scene load, stick them here until things get built out more
Celestials.Add(new CelestialBody("sun")
{
LightProperties = new AGKCore.Lighting.Basic.DirectionalLight()
{
Ambient = new AGKVector4(0.2f, 0.2f, 0.2f, 0),
Diffuse = new AGKVector4(0.5f, 0.5f, 0.5f, 0),
Specular = new AGKVector4(0.5f, 0.5f, 0.5f, 0),
Direction = new AGKVector3(1, 1, -0.3f)
}
});
}
static void Core_OnSizeChanged(object sender, EventArgs e)
{
m_bMaximized = m_Window.WindowState == FormWindowState.Maximized;
m_Window.TopMost = m_bMaximized;
m_Window.Update();
Agk.UpdateDeviceSize();
Agk.WindowMoved();
App.Config.Screen.Width = m_Window.Width;
App.Config.Screen.Height = m_Window.Height;
App.Config.Screen.AspectRatio = App.Config.Screen.Width / App.Config.Screen.Height;
App.Config.Screen.CenterX = (int)Math.Floor(App.Config.Screen.Width * 0.5);
App.Config.Screen.CenterY = (int)Math.Floor(App.Config.Screen.Height * 0.5);
if (App.Config.Screen.Width > 1280)
{
App.Config.Screen.Layout = 1;
}
else
{
App.Config.Screen.Layout = 2;
}
}
public bool Update()
{
string animName = "";
float totalTime = 0;
if (Owner.Properties.IsObject)
{
//Agk.SetObjectAnimationSpeed((uint)Owner.Properties.ResourceNumber, )
animName = Agk.GetObjectAnimationName((uint)Owner.Properties.ResourceNumber, 1);
totalTime = Agk.GetObjectAnimationDuration((uint)Owner.Properties.ResourceNumber, animName);
}
int firstFrame = Animation.Keys[Animation.CurrentKey][0];
int lastFrame = Animation.Keys[Animation.CurrentKey][1];
int totalFrame = (int)Math.Floor(totalTime * Animation.Framerate);
CurrentFrame = CurrentFrame + (Animation.Framerate * Speed * (App.Timing.Delta * 0.001f)); //convert to seconds
if (CurrentFrame < firstFrame)
{
CurrentFrame = firstFrame;
}
if (CurrentFrame >= lastFrame)
{
if (IsLoop)
{
//handle frame, looping
CurrentFrame = firstFrame;
if (Owner.Properties.IsObject)
{
//float animTime = (CurrentFrame * totalTime) / lastFrame;
float animTime = (CurrentFrame * totalTime) / totalFrame;
Agk.SetObjectAnimationFrame((uint)Owner.Properties.ResourceNumber, animName, animTime, 0.0f);
}
else
{
Agk.SetSpriteFrame((uint)Owner.Properties.ResourceNumber, (int)CurrentFrame);
}
//handle variant
if (Animation.Keys.Count > 1)
{
if (App.Timing.Timer - _VariantMark >= _VariantDelay)
{
Animation.CurrentKey = (int)Agk.Random(0, (uint)(Animation.Keys.Count - 1));
_VariantDelay = Animation.VariantDelayMin + (int)Agk.Random(0, (uint)Animation.VariantDelayMax);
_VariantMark = (int)App.Timing.Timer;
}
}
//handle callback
bool isLoopDone = false;
if (!String.IsNullOrEmpty(Callback))
{
isLoopDone = (bool)Dispatcher.Invoke(Callback, CallbackArgs);
if (isLoopDone)
{
return(true);
}
}
return(false);
}
else
{
//handle frame, played once, end it
CurrentFrame = lastFrame;
if (Owner.Properties.IsObject)
{
//float animTime = (CurrentFrame * Agk.GetObjectAnimationDuration((uint)Owner.Properties.ResourceNumber, animName)) / Animation.Keys[Animation.CurrentKey][1];
float animTime = (CurrentFrame * totalTime) / totalFrame;
Agk.SetObjectAnimationFrame((uint)Owner.Properties.ResourceNumber, animName, animTime, 0.0f);
}
else
{
Agk.SetSpriteFrame((uint)Owner.Properties.ResourceNumber, (int)CurrentFrame);
}
//handle callback
if (!String.IsNullOrEmpty(Callback))
{
Dispatcher.Invoke(Callback, CallbackArgs);
}
return(true);
}
}
else
{
//handle frame, sequence hasnt completed, continue
if (Owner.Properties.IsObject)
{
//float animTime = (CurrentFrame * Agk.GetObjectAnimationDuration((uint)Owner.Properties.ResourceNumber, animName)) / Animation.Keys[Animation.CurrentKey][1];
float animTime = (CurrentFrame * totalTime) / totalFrame;
Agk.SetObjectAnimationFrame((uint)Owner.Properties.ResourceNumber, animName, animTime, 0.0f);
}
else
{
Agk.SetSpriteFrame((uint)Owner.Properties.ResourceNumber, (int)CurrentFrame);
}
//handle callback
bool isLoopDone = false;
if (!String.IsNullOrEmpty(Callback))
{
isLoopDone = (bool)Dispatcher.Invoke(Callback, CallbackArgs);
if (isLoopDone)
{
return(true);
}
}
return(false);
}
}
public static void GetGameplayInput(object rArgs)
{
App.Log("controls3d", LogLevel.Notice, "main", "> Begin GetGameplayInput");
//reset forced
UserInterface.Status.MouseModeForced = "";
UserInterface.Status.KeyModeForced = "";
//exit early if user does not have control
/*
* if(App.Status.LoadState < 3)
* {
* return;
* }
*/
if (CharacterHandler3d.MyCharacter == null)
{
return;
}
if (!CharacterHandler3d.MyCharacter.Status.IsLiving)
{
return;
}
if (UserInterface.Status.KeyMode != "gameplay" || CharacterHandler3d.MyCharacter.Status.MotionState == CharacterEntity3d.MotionStates.Forced)
{
return;
}
if (ActiveCamera.ControlMode != Camera3d.CameraMode.Anchored)
{
return;
}
bool animWait = false;
if (CharacterHandler3d.MyCharacter.AnimationQ.Count > 0)
{
animWait = CharacterHandler3d.MyCharacter.AnimationQ.First().Animation.Wait;
}
//grab old state
CharacterHandler3d.MyCharacter.OldStatus = JsonConvert.DeserializeObject <CharacterEntity3d.CharacterStatus>(JsonConvert.SerializeObject(CharacterHandler3d.MyCharacter.Status));
//reset states that need to be held by user
if (CharacterHandler3d.MyCharacter.Status.StanceState == CharacterEntity3d.StanceStates.Sneaking)
{
CharacterHandler3d.MyCharacter.Status.StanceState = CharacterEntity3d.StanceStates.Basic;
}
if (CharacterHandler3d.MyCharacter.Status.ActionState == CharacterEntity3d.ActionStates.Moving)
{
CharacterHandler3d.MyCharacter.Status.ActionState = CharacterEntity3d.ActionStates.Idle;
}
if (CharacterHandler3d.MyCharacter.Status.MotionState != CharacterEntity3d.MotionStates.Forced)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Stationary;
}
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
//get mouse input
if (UserInterface.Status.MouseMode == "gameplay")
{
}
//get keyboard input
if (UserInterface.Status.KeyMode == "gameplay" && !animWait)
{
if (CharacterHandler3d.MyCharacter.Status.MotionState != CharacterEntity3d.MotionStates.Forced)
{
//toggle strafelock
if (Hardware.IsKeyDown(MovementKey.StrafeToggle) && UserInterface.Status.InputReady)
{
UserInterface.Status.InputMark = App.Timing.Timer;
CharacterHandler3d.MyCharacter.Status.IsStrafeLocked = !CharacterHandler3d.MyCharacter.Status.IsStrafeLocked;
}
//toggle runlock
if (Hardware.IsKeyDown(MovementKey.RunToggle) && UserInterface.Status.InputReady)
{
UserInterface.Status.InputMark = App.Timing.Timer;
CharacterHandler3d.MyCharacter.Status.IsRunLocked = !CharacterHandler3d.MyCharacter.Status.IsRunLocked;
}
//apply run if locked
if (CharacterHandler3d.MyCharacter.Status.IsRunLocked &&
CharacterHandler3d.MyCharacter.OldStatus.StanceState == CharacterEntity3d.StanceStates.Basic
)
{
if (CharacterHandler3d.MyCharacter.OldStatus.ActionState == CharacterEntity3d.ActionStates.Moving &&
CharacterHandler3d.MyCharacter.OldStatus.MotionState < CharacterEntity3d.MotionStates.Sprinting
)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Running;
}
}
//sneak
if (Hardware.IsKeyDown(MovementKey.SpeedSlow))
{
CharacterHandler3d.MyCharacter.Status.StanceState = CharacterEntity3d.StanceStates.Sneaking;
}
//sprint
if (Hardware.IsKeyDown(MovementKey.SpeedBoost))
{
if (CharacterHandler3d.MyCharacter.Status.StanceState == CharacterEntity3d.StanceStates.Basic &&
CharacterHandler3d.MyCharacter.OldStatus.ActionState == CharacterEntity3d.ActionStates.Moving &&
CharacterHandler3d.MyCharacter.Status.MotionState != CharacterEntity3d.MotionStates.Forced
)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Sprinting;
}
}
//jump
if (Hardware.IsKeyDown(MovementKey.Upward) && UserInterface.Status.InputReady)
{
//don't allow a jump if sneaking or already in a jump
if (CharacterHandler3d.MyCharacter.Status.StanceState == CharacterEntity3d.StanceStates.Basic &&
CharacterHandler3d.MyCharacter.Status.ActionState < CharacterEntity3d.ActionStates.Jumping
)
{
UserInterface.Status.InputMark = App.Timing.Timer;
CharacterHandler3d.MyCharacter.Status.ActionState = CharacterEntity3d.ActionStates.Jumping;
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Forced;
}
}
float camY = MathUtil.Wrap(Agk.GetCameraAngleY(1) + 180.0f, 0.0f, 360.0f);
//forward
if (Hardware.IsKeyDown(MovementKey.Forward))
{
CharacterHandler3d.MyCharacter.Status.ActionState = CharacterEntity3d.ActionStates.Moving;
if (CharacterHandler3d.MyCharacter.Status.MotionState == CharacterEntity3d.MotionStates.Stationary)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Walking;
}
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
}
//backward
if (Hardware.IsKeyDown(MovementKey.Backward))
{
CharacterHandler3d.MyCharacter.Status.ActionState = CharacterEntity3d.ActionStates.Moving;
if (CharacterHandler3d.MyCharacter.Status.MotionState == CharacterEntity3d.MotionStates.Stationary)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Walking;
}
if (CharacterHandler3d.MyCharacter.Status.IsStrafeLocked)
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = camY;
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Backward;
}
else
{
CharacterHandler3d.MyCharacter.Properties.Facing = camY;
CharacterHandler3d.MyCharacter.Properties.Heading = camY;
}
}
//left
if (Hardware.IsKeyDown(MovementKey.Left))
{
CharacterHandler3d.MyCharacter.Status.ActionState = CharacterEntity3d.ActionStates.Moving;
if (CharacterHandler3d.MyCharacter.Status.MotionState == CharacterEntity3d.MotionStates.Stationary)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Walking;
}
if (CharacterHandler3d.MyCharacter.Status.IsStrafeLocked)
{
if (Hardware.IsKeyDown(MovementKey.Forward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 180.0f - 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
else if (Hardware.IsKeyDown(MovementKey.Backward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Backward;
}
else
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 90.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Left;
}
}
else
{
if (Hardware.IsKeyDown(MovementKey.Forward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f - 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 180.0f - 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
else if (Hardware.IsKeyDown(MovementKey.Backward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
else
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 90.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 90.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
}
}
//right
if (Hardware.IsKeyDown(MovementKey.Right))
{
CharacterHandler3d.MyCharacter.Status.ActionState = CharacterEntity3d.ActionStates.Moving;
if (CharacterHandler3d.MyCharacter.Status.MotionState == CharacterEntity3d.MotionStates.Stationary)
{
CharacterHandler3d.MyCharacter.Status.MotionState = CharacterEntity3d.MotionStates.Walking;
}
if (CharacterHandler3d.MyCharacter.Status.IsStrafeLocked)
{
if (Hardware.IsKeyDown(MovementKey.Forward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 180.0f + 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
else if (Hardware.IsKeyDown(MovementKey.Backward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY - 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Backward;
}
else
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY - 90.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Right;
}
}
else
{
if (Hardware.IsKeyDown(MovementKey.Forward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY + 180.0f + 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY + 180.0f + 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
else if (Hardware.IsKeyDown(MovementKey.Backward))
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY - 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY - 45.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
else
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.Wrap(camY - 90.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Properties.Heading = MathUtil.Wrap(camY - 90.0f, 0.0f, 360.0f);
CharacterHandler3d.MyCharacter.Status.DirectionState = CharacterEntity3d.DirectionStates.Standard;
}
}
}
}
}
//mouse steers character if moving and not strafe locked
if (UserInterface.Status.MouseMode == "gameplay")
{
if (CharacterHandler3d.MyCharacter.Status.ActionState == CharacterEntity3d.ActionStates.Moving &&
!CharacterHandler3d.MyCharacter.Status.IsStrafeLocked
)
{
CharacterHandler3d.MyCharacter.Properties.Facing = MathUtil.CurveAngle(CharacterHandler3d.MyCharacter.Properties.Facing + Hardware.Mouse.MoveX, CharacterHandler3d.MyCharacter.Properties.Facing, ActiveCamera.Precision);
}
}
//sprint camera effect
if (CharacterHandler3d.MyCharacter.Status.MotionState == CharacterEntity3d.MotionStates.Sprinting)
{
ActiveCamera.FOV = MathUtil.CurveValue(65.0f, ActiveCamera.FOV, Agk.ScreenFPS() * CharacterHandler3d.Config.SprintAcceleration);
}
else if (ActiveCamera.FOV != Camera3dHandler.DefaultFOV)
{
ActiveCamera.FOV = MathUtil.CurveValue(Camera3dHandler.DefaultFOV, ActiveCamera.FOV, Agk.ScreenFPS() * CharacterHandler3d.Config.SprintAcceleration);
}
//TEMP:
if (Hardware.IsKeyDown((int)Keys.Y))
{
Controls3d.ActiveCamera.Offset.Y += 0.1f;
}
if (Hardware.IsKeyDown((int)Keys.H))
{
Controls3d.ActiveCamera.Offset.Y -= 0.1f;
}
//TEMP: toggle active
if (Hardware.IsKeyDown((int)Keys.C) && UserInterface.Status.InputReady)
{
UserInterface.Status.InputMark = App.Timing.Timer;
Controls3d.SetActiveCamera(Camera3dHandler.CameraList.FirstOrDefault(c => c.Name != Controls3d.ActiveCamera.Name));
}
//ENDTEMP
App.Log("Controls3d", LogLevel.Notice, "main", "> End GetGameplayInput");
}
