public bool RenderGauge()
{
try
{
if (device != null && !DX_reinit)
{
Single brushAngle = (Int32)(m_BaseArcStart + (m_value - m_MinValue) * m_BaseArcSweep /
(m_MaxValue - m_MinValue)) % 360;
Double needleAngle = brushAngle * Math.PI / 180;
verts1[0].X = (float)(Center.X + m_NeedleRadius / 4 * Math.Cos(needleAngle));
verts1[0].Y = (float)(Center.Y + m_NeedleRadius / 4 * Math.Sin(needleAngle));
verts1[1].X = (float)(Center.X + m_NeedleRadius * Math.Cos(needleAngle));
verts1[1].Y = (float)(Center.Y + m_NeedleRadius * Math.Sin(needleAngle));
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black.ToArgb(), 0.0f, 0);
sprite.Begin(SpriteFlags.AlphaBlend);
if (BackgroundTexture != null)
{
sprite.Draw(BackgroundTexture, texture_size, (Color4)Color.White);
}
sprite.End();
//Begin the scene
device.BeginScene();
device.SetRenderState(RenderState.AlphaBlendEnable, true);
device.SetRenderState(RenderState.SourceBlend, SlimDX.Direct3D9.Blend.SourceAlpha);
device.SetRenderState(RenderState.DestinationBlend, SlimDX.Direct3D9.Blend.DestinationAlpha);
line.Draw(verts1, Color.Red);
device.EndScene();
device.Present();
return(true);
}
if (DX_reinit)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
Debug.Write(ex.ToString());
if (DX_reinit)
{
return(true);
}
else
{
return(false);
}
}
}
protected virtual void OnResetDevice()
{
Fps.OnResetDevice();
Matrix projection = Matrix.PerspectiveFovLH(FieldOfView, AspectRatio, NearPlane, FarPlane);
Device.SetTransform(TransformState.Projection, projection);
Device.SetTransform(TransformState.View, Freelook.View);
Device.SetRenderState(RenderState.Ambient, Ambient);
MeshFactory.OnResetDevice();
}
protected virtual void OnResetDevice()
{
Info.OnResetDevice();
Matrix projection = Matrix.PerspectiveFovLH(FieldOfView, AspectRatio, NearPlane, FarPlane);
Device.SetTransform(TransformState.Projection, projection);
UpdateView();
Device.SetRenderState(RenderState.Ambient, Ambient);
Device.SetLight(0, light);
Device.EnableLight(0, true);
_meshFactory.OnResetDevice();
}
public bool DirectX_Init(string background_image)
{
PresentParameters presentParms = new PresentParameters();
presentParms.Windowed = true;
presentParms.SwapEffect = SwapEffect.Discard;
presentParms.Multisample = MultisampleType.None;
presentParms.EnableAutoDepthStencil = true;
presentParms.AutoDepthStencilFormat = Format.D16;
presentParms.PresentFlags = PresentFlags.DiscardDepthStencil;
presentParms.PresentationInterval = PresentInterval.Default;
presentParms.BackBufferFormat = Format.X8R8G8B8;
presentParms.BackBufferHeight = gauge_target.Height;
presentParms.BackBufferWidth = gauge_target.Width;
presentParms.Windowed = true;
presentParms.BackBufferCount = 1;
switch (directx_render_type)
{
case RenderType.HARDWARE:
try
{
DX9device = new Device(new Direct3D(), 0, DeviceType.Hardware,
gauge_target.Handle, CreateFlags.HardwareVertexProcessing |
CreateFlags.FpuPreserve | CreateFlags.Multithreaded,
presentParms);
}
catch (Direct3D9Exception ex)
{
MessageBox.Show("Problem u inicijalizaciji DirectX-a greska 1\n" + ex.ToString());
}
break;
case RenderType.SOFTWARE:
{
try
{
DX9device = new Device(new Direct3D(), 0,
DeviceType.Hardware,
gauge_target.Handle, CreateFlags.SoftwareVertexProcessing |
CreateFlags.FpuPreserve | CreateFlags.Multithreaded, presentParms);
}
catch (Direct3D9Exception exe)
{
MessageBox.Show("Problem u inicijalizaciji DirectX-a greska 2\n" + exe.ToString());
return false;
}
}
break;
}
var vertexElems = new[] {
new VertexElement(0, 0, DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.PositionTransformed, 0),
new VertexElement(0, 16, DeclarationType.Color, DeclarationMethod.Default, DeclarationUsage.Color, 0),
VertexElement.VertexDeclarationEnd
};
var vertexDecl = new VertexDeclaration(DX9device, vertexElems);
DX9device.VertexDeclaration = vertexDecl;
if (File.Exists(background_image))
{
BackgroundTexture = Texture.FromFile(DX9device, background_image, this.Width, this.Height,
1, Usage.None, Format.Unknown, Pool.Default, SlimDX.Direct3D9.Filter.Default, SlimDX.Direct3D9.Filter.Default, 0);
}
texture_size.Width = gauge_target.Width;
texture_size.Height = gauge_target.Height;
sprite = new Sprite(DX9device);
if (render_event == null)
render_event = new AutoResetEvent(true);
line = new Line(DX9device);
line.Antialias = true;
line.Width = 3;
line.GLLines = true;
DX9device.SetRenderState(RenderState.AntialiasedLineEnable, true);
return true;
}
public bool DirectX_Init(string background_image)
{
if (!booting && !DX_reinit)
{
try
{
DX_reinit = true;
PresentParameters presentParms = new PresentParameters();
presentParms.Windowed = true;
presentParms.SwapEffect = SwapEffect.Discard;
presentParms.Multisample = MultisampleType.None;
presentParms.EnableAutoDepthStencil = true;
presentParms.AutoDepthStencilFormat = Format.D24X8;
presentParms.PresentFlags = PresentFlags.DiscardDepthStencil;
presentParms.PresentationInterval = PresentInterval.Default;
presentParms.BackBufferFormat = Format.X8R8G8B8;
presentParms.BackBufferHeight = gauge_target.Height;
presentParms.BackBufferWidth = gauge_target.Width;
presentParms.Windowed = true;
presentParms.BackBufferCount = 1;
switch (directx_render_type)
{
case RenderType.HARDWARE:
{
try
{
device = new Device(new Direct3D(), 0, DeviceType.Hardware,
gauge_target.Handle, CreateFlags.HardwareVertexProcessing |
CreateFlags.FpuPreserve | CreateFlags.Multithreaded,
presentParms);
}
catch (Direct3D9Exception ex)
{
if (debug && !console.ConsoleClosing)
{
console.Invoke(new DebugCallbackFunction(console.DebugCallback),
"DirectX hardware init error(AGauge)!\n" + ex.ToString());
}
}
}
break;
case RenderType.SOFTWARE:
{
try
{
device = new Device(new Direct3D(), 0, DeviceType.Hardware,
gauge_target.Handle, CreateFlags.SoftwareVertexProcessing |
CreateFlags.FpuPreserve | CreateFlags.Multithreaded, presentParms);
}
catch (Direct3D9Exception exe)
{
if (debug && !console.ConsoleClosing)
{
console.Invoke(new DebugCallbackFunction(console.DebugCallback),
"DirectX software init error(AGauge)!\n" + exe.ToString());
}
return(false);
}
}
break;
}
var vertexElems = new[] {
new VertexElement(0, 0, DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.PositionTransformed, 0),
new VertexElement(0, 16, DeclarationType.Color, DeclarationMethod.Default, DeclarationUsage.Color, 0),
VertexElement.VertexDeclarationEnd
};
var vertexDecl = new VertexDeclaration(device, vertexElems);
device.VertexDeclaration = vertexDecl;
if (background_image != null && File.Exists(background_image))
{
BackgroundTexture = Texture.FromFile(device, background_image, gauge_target.Width, gauge_target.Height,
1, Usage.None, Format.Unknown, Pool.Managed, SlimDX.Direct3D9.Filter.Default, SlimDX.Direct3D9.Filter.Default, 0);
}
texture_size.Width = gauge_target.Width;
texture_size.Height = gauge_target.Height;
sprite = new Sprite(device);
verts1 = new Vector2[2];
line = new Line(device);
line.Antialias = true;
line.Width = 3;
line.GLLines = true;
device.SetRenderState(RenderState.AntialiasedLineEnable, true);
DX_reinit = false;
return(true);
}
catch (Exception ex)
{
Debug.Write(ex.ToString());
DX_reinit = false;
if (debug && !console.ConsoleClosing)
{
console.Invoke(new DebugCallbackFunction(console.DebugCallback),
"Init AGauge error!\n" + ex.ToString());
}
return(false);
}
}
return(true);
}
/// <summary>
/// Sets the render states and draws the selected objects to scene.
/// </summary>
/// <param name="direct3DDevice">The direct 3D device pointer.</param>
/// <returns><see cref="int"/></returns>
public int EndSceneHook(IntPtr direct3DDevice)
{
// Do the first scan.
if (!_opened)
{
_memory.OpenSF4Process();
_memory.RunScan();
_interface.WriteConsole("Street Fighter 4 Process hooked.");
_opened = true;
}
if (_device == null)
{
_device = Device.FromPointer(direct3DDevice);
_interface.WriteConsole(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\uiBackground.png");
_background = Texture.FromFile(
_device,
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\Resources\Images\uiBackground.png");
_interface.WriteConsole("Device created.");
// Attempting to scale the font.
_fontSize = _device.Viewport.Height / 48;
_interface.WriteConsole(string.Format("Font size set to {0}", _fontSize));
_font = new Font(_device, new System.Drawing.Font("Consolas", _fontSize));
}
// The game calls endscene twice a frame. We only need to draw once.
// We should just return as normal the other time.
if (_endsceneSkip)
{
_endsceneSkip = false;
return(_device.EndScene().Code);
}
_endsceneSkip = true;
//// _device.SetRenderState(RenderState.Lighting, false);
//// _device.SetRenderState(RenderState.SpecularEnable, false);
_device.SetRenderState(RenderState.CullMode, Cull.None);
_device.SetRenderState(RenderState.AlphaBlendEnable, true);
_device.SetRenderState(RenderState.VertexBlend, VertexBlend.Disable);
_device.SetRenderState(RenderState.SourceBlend, Blend.SourceAlpha);
_device.SetRenderState(RenderState.DestinationBlend, Blend.InverseSourceAlpha);
_device.SetRenderState(RenderState.BlendOperationAlpha, BlendOperation.Minimum);
_device.SetRenderState(RenderState.FillMode, FillMode.Solid);
_device.SetRenderState(RenderState.ColorWriteEnable, 0xF);
_device.SetRenderState(RenderState.MultisampleAntialias, false);
// Setting up the camera
Vector3 eye = new Vector3 {
X = _memory.GetCamX(), Y = _memory.GetCamY(), Z = _memory.GetCamZ()
};
Vector3 target = new Vector3 {
X = _memory.GetCamXp(), Y = _memory.GetCamYp(), Z = _memory.GetCamZp()
};
float zoom = _memory.GetCamZoom();
_device.SetRenderState(RenderState.Lighting, false); // We don't need light for this...
_device.SetTransform(TransformState.View, Matrix.LookAtLH(eye, target, new Vector3(0, 1, 0)));
// Fix this shit later!
_device.SetTransform(
TransformState.Projection,
Matrix.PerspectiveLH(0.1f * 16 / 9 * zoom + 0.008f, 0.1f * zoom + 0.008f, 0.1F, 100.0F));
_playerOneBoxes = _memory.ReadMemoryByteArrayWithBase(0x00688E6C, new int[] { 0x8, 0x2190 }, 25248);
_playerTwoBoxes = _memory.ReadMemoryByteArrayWithBase(0x00688E6C, new int[] { 0xC, 0x2190 }, 25248);
// Draw everything...
if (_interface.DrawBasic1)
{
DrawHurtBoxes(_playerOneBoxes, _device);
}
if (_interface.DrawBasic2)
{
DrawHurtBoxes(_playerTwoBoxes, _device);
}
if (_interface.DrawPhysics1)
{
DrawPhysicsBoxes(_playerOneBoxes, _device);
}
if (_interface.DrawPhysics2)
{
DrawPhysicsBoxes(_playerTwoBoxes, _device);
}
if (_interface.DrawGrab1)
{
DrawThrowVulnerableBoxes(_playerOneBoxes, _device);
}
if (_interface.DrawGrab2)
{
DrawThrowVulnerableBoxes(_playerTwoBoxes, _device);
}
if (_interface.DrawHit1)
{
DrawHitbox(1, _device);
}
if (_interface.DrawHit2)
{
DrawHitbox(2, _device);
}
if (_interface.DrawGrab1)
{
DrawGrabBox(1, _device);
}
if (_interface.DrawGrab2)
{
DrawGrabBox(2, _device);
}
if (_interface.DrawProjectile1)
{
DrawProjectileBox(1, _device);
}
if (_interface.DrawProjectile2)
{
DrawProjectileBox(2, _device);
}
if (_interface.DrawProx1)
{
DrawProxBox(1, _device);
}
if (_interface.DrawProx2)
{
DrawProxBox(2, _device);
}
if (_interface.DrawInfo)
{
DrawInfo(_device);
}
_interface.FrameNumber = _memory.GetFrameCount();
// This does not use the sprite we use for all the other text...
_font.DrawString(null, "Frame Trapped Lab Active", 20, 20, _textColor);
return(_device.EndScene().Code);
}
int DrawIndexedPrimitivesHook(IntPtr devicePtr, SlimDX.Direct3D9.PrimitiveType primitiveType,
int baseVertexIndex, int minimumVertexIndex,
int numVertices, int startIndex, int primCount)
{
using (SlimDX.Direct3D9.Device device = SlimDX.Direct3D9.Device.FromPointer(devicePtr))
{
Primitive prim = new Primitive(primCount, numVertices);
int hRet = 0;
try
{
if (Interface.CaptureFrame)
{
RipModel(device, primitiveType, baseVertexIndex, startIndex, primCount);
}
//if new primitive being rendered, add it to our list
if (!prims.Contains(prim))
{
prims.Add(prim);
}
Primitive selectedPrim = prims.GetSelectedPrimitive();
if (selectedPrim != null)
{
if (selectedPrim.Equals(prim))
{
if (RedTexture == null)
{
RedTexture = SlimDX.Direct3D9.Texture.FromMemory(device, red);
}
if (Interface.chamed == true)
{
selectedPrim.Chamed = true;
Interface.Togglecham();
}
device.SetRenderState(SlimDX.Direct3D9.RenderState.FillMode, SlimDX.Direct3D9.FillMode.Solid);
device.SetTexture(0, RedTexture);
if (selectedPrim.Chamed)
{
//device.Clear(ClearFlags.ZBuffer, Color.Red, 1.0f, 0);
device.SetRenderState(SlimDX.Direct3D9.RenderState.ZEnable, false);
hRet = device.DrawIndexedPrimitives(primitiveType, baseVertexIndex, minimumVertexIndex,
numVertices, startIndex, primCount).Code;
device.SetRenderState(SlimDX.Direct3D9.RenderState.ZEnable, true);
}
if (Interface.rip)
{
if (!Interface.CaptureFrame)
{
RipModel(device, primitiveType, baseVertexIndex, startIndex, primCount);
Interface.ToggleRip();
}
}
hRet = device.DrawIndexedPrimitives(primitiveType, baseVertexIndex, minimumVertexIndex,
numVertices, startIndex, primCount).Code;
}
}
//if not to display, don't render
if (prims.IndexOf(prim) != -1)
{
if (prims[prims.IndexOf(prim)].Displayed == false)
{
return(0);
}
}
}
catch (Exception e)
{
Interface.ReportException(e);
return(hRet);
}
if (hRet == 0)
{
if (prims[prims.IndexOf(prim)].Chamed == false)
{
hRet = device.DrawIndexedPrimitives(primitiveType, baseVertexIndex, minimumVertexIndex,
numVertices, startIndex, primCount).Code;
}
else
{
PixelShader previous = device.PixelShader;
if (chamPixelShader == null)
{
chamPixelShader = new PixelShader(device, ShaderBytecode.Compile("float4 PShader(float4 position : SV_POSITION) : SV_Target\n" +
"{\nreturn float4(1.0f, 1.0f, 0.0f, 1.0f);\n}", "PShader", "ps_3_0", ShaderFlags.None));
}
device.PixelShader = chamPixelShader;
hRet = device.DrawIndexedPrimitives(primitiveType, baseVertexIndex, minimumVertexIndex,
numVertices, startIndex, primCount).Code;
device.SetRenderState(SlimDX.Direct3D9.RenderState.ZEnable, false);
hRet = device.DrawIndexedPrimitives(primitiveType, baseVertexIndex, minimumVertexIndex,
numVertices, startIndex, primCount).Code;
device.SetRenderState(RenderState.ZEnable, true);
device.PixelShader = previous;
}
}
return(hRet);
}
}
public bool DirectX_Init(string background_image)
{
if (!booting && !DX_reinit)
{
try
{
DX_reinit = true;
PresentParameters presentParms = new PresentParameters();
presentParms.Windowed = true;
presentParms.SwapEffect = SwapEffect.Discard;
presentParms.Multisample = MultisampleType.None;
presentParms.EnableAutoDepthStencil = true;
presentParms.AutoDepthStencilFormat = Format.D24X8;
presentParms.PresentFlags = PresentFlags.DiscardDepthStencil;
presentParms.PresentationInterval = PresentInterval.Default;
presentParms.BackBufferFormat = Format.X8R8G8B8;
presentParms.BackBufferHeight = gauge_target.Height;
presentParms.BackBufferWidth = gauge_target.Width;
presentParms.Windowed = true;
presentParms.BackBufferCount = 1;
switch (directx_render_type)
{
case RenderType.HARDWARE:
{
try
{
device = new Device(new Direct3D(), 0, DeviceType.Hardware,
gauge_target.Handle, CreateFlags.HardwareVertexProcessing |
CreateFlags.FpuPreserve | CreateFlags.Multithreaded,
presentParms);
}
catch (Direct3D9Exception ex)
{
if (debug && !console.ConsoleClosing)
console.Invoke(new DebugCallbackFunction(console.DebugCallback),
"DirectX hardware init error(AGauge)!\n" + ex.ToString());
}
}
break;
case RenderType.SOFTWARE:
{
try
{
device = new Device(new Direct3D(), 0, DeviceType.Hardware,
gauge_target.Handle, CreateFlags.SoftwareVertexProcessing |
CreateFlags.FpuPreserve | CreateFlags.Multithreaded, presentParms);
}
catch (Direct3D9Exception exe)
{
if (debug && !console.ConsoleClosing)
console.Invoke(new DebugCallbackFunction(console.DebugCallback),
"DirectX software init error(AGauge)!\n" + exe.ToString());
return false;
}
}
break;
}
var vertexElems = new[] {
new VertexElement(0, 0, DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.PositionTransformed, 0),
new VertexElement(0, 16, DeclarationType.Color, DeclarationMethod.Default, DeclarationUsage.Color, 0),
VertexElement.VertexDeclarationEnd
};
var vertexDecl = new VertexDeclaration(device, vertexElems);
device.VertexDeclaration = vertexDecl;
if (background_image != null && File.Exists(background_image))
{
BackgroundTexture = Texture.FromFile(device, background_image, gauge_target.Width, gauge_target.Height,
1, Usage.None, Format.Unknown, Pool.Managed, SlimDX.Direct3D9.Filter.Default, SlimDX.Direct3D9.Filter.Default, 0);
}
texture_size.Width = gauge_target.Width;
texture_size.Height = gauge_target.Height;
sprite = new Sprite(device);
verts1 = new Vector2[2];
line = new Line(device);
line.Antialias = true;
line.Width = 3;
line.GLLines = true;
device.SetRenderState(RenderState.AntialiasedLineEnable, true);
DX_reinit = false;
return true;
}
catch (Exception ex)
{
Debug.Write(ex.ToString());
DX_reinit = false;
if (debug && !console.ConsoleClosing)
console.Invoke(new DebugCallbackFunction(console.DebugCallback),
"Init AGauge error!\n" + ex.ToString());
return false;
}
}
return true;
}
