From 5806cae23f753a7301457128c17bdfdbe84a48b6 Mon Sep 17 00:00:00 2001 From: Brandon-T Date: Fri, 24 Jan 2014 06:31:30 -0500 Subject: [PATCH] Added Texture Rendering Allows Smart or Browsers to draw graphics. --- DXI/DXI.depend | 9 +- DXI/DXI.layout | 12 +- DXI/main.cpp | 2 +- d3d9/Graphics.cpp | 70 + d3d9/Graphics.hpp | 29 + d3d9/Hooks/Direct3DDevice9Proxy.cpp | 652 +++++++++ d3d9/Hooks/Direct3DDevice9Proxy.hpp | 139 ++ d3d9/Hooks/Hooks.cpp | 63 + d3d9/Hooks/Hooks.hpp | 29 + d3d9/Images.cpp | 218 +++ d3d9/Images.hpp | 84 ++ d3d9/SMARTPlugin.hpp | 53 + d3d9/SharedMemory.cpp | 238 ++++ d3d9/SharedMemory.hpp | 77 ++ d3d9/SmartJNI.cpp | 220 +++ d3d9/d3d9.cbp | 83 ++ d3d9/d3d9.depend | 244 ++++ d3d9/d3d9.layout | 84 ++ d3d9/jni.h | 1959 +++++++++++++++++++++++++++ d3d9/jni_md.h | 37 + d3d9/main.cpp | 8 +- 21 files changed, 4299 insertions(+), 11 deletions(-) create mode 100644 d3d9/Graphics.cpp create mode 100644 d3d9/Graphics.hpp create mode 100644 d3d9/Hooks/Direct3DDevice9Proxy.cpp create mode 100644 d3d9/Hooks/Direct3DDevice9Proxy.hpp create mode 100644 d3d9/Hooks/Hooks.cpp create mode 100644 d3d9/Hooks/Hooks.hpp create mode 100644 d3d9/Images.cpp create mode 100644 d3d9/Images.hpp create mode 100644 d3d9/SMARTPlugin.hpp create mode 100644 d3d9/SharedMemory.cpp create mode 100644 d3d9/SharedMemory.hpp create mode 100644 d3d9/SmartJNI.cpp create mode 100644 d3d9/d3d9.cbp create mode 100644 d3d9/d3d9.depend create mode 100644 d3d9/d3d9.layout create mode 100644 d3d9/jni.h create mode 100644 d3d9/jni_md.h diff --git a/DXI/DXI.depend b/DXI/DXI.depend index 8a29e6f..05a8bd1 100644 --- a/DXI/DXI.depend +++ b/DXI/DXI.depend @@ -1,8 +1,8 @@ # depslib dependency file v1.0 -1387667367 source:c:\users\brandon\desktop\dxi\sharedmemory.cpp +1388751552 source:c:\users\brandon\desktop\dxi\sharedmemory.cpp "SharedMemory.hpp" -1387667354 c:\users\brandon\desktop\dxi\sharedmemory.hpp +1388751552 c:\users\brandon\desktop\dxi\sharedmemory.hpp @@ -13,3 +13,8 @@ +1388753939 source:c:\users\brandon\desktop\dxi\main.cpp + + + "SharedMemory.hpp" + diff --git a/DXI/DXI.layout b/DXI/DXI.layout index b7a5a70..2da953d 100644 --- a/DXI/DXI.layout +++ b/DXI/DXI.layout @@ -1,19 +1,19 @@ - + - + - + - + - + - + diff --git a/DXI/main.cpp b/DXI/main.cpp index 168c94c..6e3024e 100644 --- a/DXI/main.cpp +++ b/DXI/main.cpp @@ -80,7 +80,7 @@ bool UnMapSharedMemory() extern "C" bool __declspec(dllexport) DXISetup(int ProcessID) { - return (CreateSharedMemory(ProcessID) || OpenSharedMemory(ProcessID)); + return OpenSharedMemory(ProcessID); } extern "C" void* __declspec(dllexport) DXIImagePointer() diff --git a/d3d9/Graphics.cpp b/d3d9/Graphics.cpp new file mode 100644 index 0000000..44be056 --- /dev/null +++ b/d3d9/Graphics.cpp @@ -0,0 +1,70 @@ +#include "Graphics.hpp" + +HRESULT Graphics::Capture(IDirect3DDevice9* Device, const char* FilePath, int Width, int Height, D3DFORMAT Format) +{ + IDirect3DSurface9* RenderTarget = nullptr; + IDirect3DSurface9* DestTarget = nullptr; + HRESULT result = Device->GetRenderTarget(0, &RenderTarget); + + if (result == S_OK) + { + if (Width == 0 || Height == 0 || Format == D3DFMT_UNKNOWN) + { + D3DSURFACE_DESC descriptor = {}; + RenderTarget->GetDesc(&descriptor); + Width = descriptor.Width; + Height = descriptor.Height; + Format = descriptor.Format; + } + + result = Device->CreateOffscreenPlainSurface(Width, Height, Format, D3DPOOL_SYSTEMMEM, &DestTarget, nullptr); + result = Device->GetRenderTargetData(RenderTarget, DestTarget); + result = D3DXSaveSurfaceToFile(FilePath, D3DXIFF_PNG, DestTarget, nullptr, nullptr); + } + + SafeRelease(RenderTarget); + SafeRelease(DestTarget); + return result; +} + +HRESULT Graphics::Capture2(IDirect3DDevice9* Device, const char* FilePath) +{ + IDirect3DSurface9* RenderTarget = nullptr; + HRESULT result = Device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &RenderTarget); + result = D3DXSaveSurfaceToFile(FilePath, D3DXIFF_PNG, RenderTarget, nullptr, nullptr); + SafeRelease(RenderTarget); + return result; +} + +HRESULT Graphics::Capture3(IDirect3DDevice9* Device, std::uint8_t* &Buffer, int Width, int Height, D3DFORMAT Format) +{ + IDirect3DSurface9* RenderTarget = nullptr; + IDirect3DSurface9* DestTarget = nullptr; + HRESULT result = Device->GetRenderTarget(0, &RenderTarget); + + if (result == S_OK) + { + if (Width == 0 || Height == 0 || Format == D3DFMT_UNKNOWN) + { + D3DSURFACE_DESC descriptor = {}; + RenderTarget->GetDesc(&descriptor); + Width = descriptor.Width; + Height = descriptor.Height; + Format = descriptor.Format; + } + + result = Device->CreateOffscreenPlainSurface(Width, Height, Format, D3DPOOL_SYSTEMMEM, &DestTarget, nullptr); + result = Device->GetRenderTargetData(RenderTarget, DestTarget); + + D3DLOCKED_RECT rect; + DestTarget->LockRect(&rect, 0, D3DLOCK_READONLY); + + //std::unique_ptr mem(new std::uint8_t[Width * Height * 4]); + //memcpy(mem.get(), rect.pBits, Width * Height * 4); + Buffer = reinterpret_cast(rect.pBits); + } + + SafeRelease(RenderTarget); + SafeRelease(DestTarget); + return result; +} diff --git a/d3d9/Graphics.hpp b/d3d9/Graphics.hpp new file mode 100644 index 0000000..2215046 --- /dev/null +++ b/d3d9/Graphics.hpp @@ -0,0 +1,29 @@ +#ifndef GRAPHICS_HPP_INCLUDED +#define GRAPHICS_HPP_INCLUDED + +#include +#include +#include +#include +#include "Images.hpp" + + +template +void SafeRelease(T* &Ptr) +{ + if (Ptr) + { + Ptr->Release(); + Ptr = nullptr; + } +} + +class Graphics +{ + public: + HRESULT Capture(IDirect3DDevice9* Device, const char* FilePath, int Width = 0, int Height = 0, D3DFORMAT Format = D3DFMT_UNKNOWN); + HRESULT Capture2(IDirect3DDevice9* Device, const char* FilePath); + HRESULT Capture3(IDirect3DDevice9* Device, std::uint8_t* &Buffer, int Width = 0, int Height = 0, D3DFORMAT Format = D3DFMT_UNKNOWN); +}; + +#endif // GRAPHICS_HPP_INCLUDED diff --git a/d3d9/Hooks/Direct3DDevice9Proxy.cpp b/d3d9/Hooks/Direct3DDevice9Proxy.cpp new file mode 100644 index 0000000..1bd4023 --- /dev/null +++ b/d3d9/Hooks/Direct3DDevice9Proxy.cpp @@ -0,0 +1,652 @@ +#include "Direct3DDevice9Proxy.hpp" + +Direct3DDevice9Proxy::Direct3DDevice9Proxy(IDirect3DDevice9* pOriginal) +{ + ptr_Direct3DDevice9 = pOriginal; +} + +Direct3DDevice9Proxy::~Direct3DDevice9Proxy() {} + +HRESULT Direct3DDevice9Proxy::QueryInterface(REFIID riid, void** ppvObj) +{ + HRESULT hRes = ptr_Direct3DDevice9->QueryInterface(riid, ppvObj); + *ppvObj = hRes == S_OK ? this : nullptr; + return hRes; +} + +ULONG Direct3DDevice9Proxy::AddRef() +{ + return ptr_Direct3DDevice9->AddRef(); +} + +ULONG Direct3DDevice9Proxy::Release() +{ + ULONG ReferenceCount = ptr_Direct3DDevice9->Release(); + if (ReferenceCount == 0) + { + delete this; + } + return ReferenceCount; +} + +HRESULT Direct3DDevice9Proxy::TestCooperativeLevel() +{ + return ptr_Direct3DDevice9->TestCooperativeLevel(); +} + +UINT Direct3DDevice9Proxy::GetAvailableTextureMem() +{ + return ptr_Direct3DDevice9->GetAvailableTextureMem(); +} + +HRESULT Direct3DDevice9Proxy::EvictManagedResources() +{ + return ptr_Direct3DDevice9->EvictManagedResources(); +} + +HRESULT Direct3DDevice9Proxy::GetDirect3D(IDirect3D9** ppD3D9) +{ + return ptr_Direct3DDevice9->GetDirect3D(ppD3D9); +} + +HRESULT Direct3DDevice9Proxy::GetDeviceCaps(D3DCAPS9* pCaps) +{ + return ptr_Direct3DDevice9->GetDeviceCaps(pCaps); +} + +HRESULT Direct3DDevice9Proxy::GetDisplayMode(UINT iSwapChain, D3DDISPLAYMODE* pMode) +{ + return ptr_Direct3DDevice9->GetDisplayMode(iSwapChain, pMode); +} + +HRESULT Direct3DDevice9Proxy::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) +{ + return ptr_Direct3DDevice9->GetCreationParameters(pParameters); +} + +HRESULT Direct3DDevice9Proxy::SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) +{ + return ptr_Direct3DDevice9->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap); +} + +void Direct3DDevice9Proxy::SetCursorPosition(int X, int Y, DWORD Flags) +{ + return ptr_Direct3DDevice9->SetCursorPosition(X, Y, Flags); +} + +BOOL Direct3DDevice9Proxy::ShowCursor(BOOL bShow) +{ + return ptr_Direct3DDevice9->ShowCursor(bShow); +} + +HRESULT Direct3DDevice9Proxy::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain) +{ + return ptr_Direct3DDevice9->CreateAdditionalSwapChain(pPresentationParameters, pSwapChain); +} + +HRESULT Direct3DDevice9Proxy::GetSwapChain(UINT iSwapChain, IDirect3DSwapChain9** pSwapChain) +{ + return ptr_Direct3DDevice9->GetSwapChain(iSwapChain, pSwapChain); +} + +UINT Direct3DDevice9Proxy::GetNumberOfSwapChains() +{ + return ptr_Direct3DDevice9->GetNumberOfSwapChains(); +} + +HRESULT Direct3DDevice9Proxy::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) +{ + return ptr_Direct3DDevice9->Reset(pPresentationParameters); +} + +HRESULT Direct3DDevice9Proxy::Present(CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion) +{ + return ptr_Direct3DDevice9->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion); +} + +HRESULT Direct3DDevice9Proxy::GetBackBuffer(UINT iSwapChain, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) +{ + return ptr_Direct3DDevice9->GetBackBuffer(iSwapChain, iBackBuffer, Type, ppBackBuffer); +} + +HRESULT Direct3DDevice9Proxy::GetRasterStatus(UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) +{ + return ptr_Direct3DDevice9->GetRasterStatus(iSwapChain, pRasterStatus); +} + +HRESULT Direct3DDevice9Proxy::SetDialogBoxMode(BOOL bEnableDialogs) +{ + return ptr_Direct3DDevice9->SetDialogBoxMode(bEnableDialogs); +} + +void Direct3DDevice9Proxy::SetGammaRamp(UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp) +{ + return ptr_Direct3DDevice9->SetGammaRamp(iSwapChain, Flags, pRamp); +} + +void Direct3DDevice9Proxy::GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp) +{ + return ptr_Direct3DDevice9->GetGammaRamp(iSwapChain, pRamp); +} + +HRESULT Direct3DDevice9Proxy::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::CreateVertexBuffer(UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateRenderTarget(Width, Height, Format, MultiSample, MultisampleQuality, Lockable, ppSurface, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Discard, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateDepthStencilSurface(Width, Height, Format, MultiSample, MultisampleQuality, Discard, ppSurface, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::UpdateSurface(IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestinationSurface, CONST POINT* pDestPoint) +{ + return ptr_Direct3DDevice9->UpdateSurface(pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint); +} + +HRESULT Direct3DDevice9Proxy::UpdateTexture(IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture) +{ + return ptr_Direct3DDevice9->UpdateTexture(pSourceTexture, pDestinationTexture); +} + +HRESULT Direct3DDevice9Proxy::GetRenderTargetData(IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface) +{ + return ptr_Direct3DDevice9->GetRenderTargetData(pRenderTarget, pDestSurface); +} + +HRESULT Direct3DDevice9Proxy::GetFrontBufferData(UINT iSwapChain, IDirect3DSurface9* pDestSurface) +{ + return ptr_Direct3DDevice9->GetFrontBufferData(iSwapChain, pDestSurface); +} + +HRESULT Direct3DDevice9Proxy::StretchRect(IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestSurface, CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter) +{ + return ptr_Direct3DDevice9->StretchRect(pSourceSurface, pSourceRect, pDestSurface, pDestRect, Filter); +} + +HRESULT Direct3DDevice9Proxy::ColorFill(IDirect3DSurface9* pSurface, CONST RECT* pRect, D3DCOLOR color) +{ + return ptr_Direct3DDevice9->ColorFill(pSurface, pRect, color); +} + +HRESULT Direct3DDevice9Proxy::CreateOffscreenPlainSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) +{ + return ptr_Direct3DDevice9->CreateOffscreenPlainSurface(Width, Height, Format, Pool, ppSurface, pSharedHandle); +} + +HRESULT Direct3DDevice9Proxy::SetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) +{ + return ptr_Direct3DDevice9->SetRenderTarget(RenderTargetIndex, pRenderTarget); +} + +HRESULT Direct3DDevice9Proxy::GetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9** ppRenderTarget) +{ + return ptr_Direct3DDevice9->GetRenderTarget(RenderTargetIndex, ppRenderTarget); +} + +HRESULT Direct3DDevice9Proxy::SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil) +{ + return ptr_Direct3DDevice9->SetDepthStencilSurface(pNewZStencil); +} + +HRESULT Direct3DDevice9Proxy::GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface) +{ + return ptr_Direct3DDevice9->GetDepthStencilSurface(ppZStencilSurface); +} + +HRESULT Direct3DDevice9Proxy::BeginScene() +{ + return ptr_Direct3DDevice9->BeginScene(); +} + +HRESULT Direct3DDevice9Proxy::EndScene() +{ + HDC hdc = nullptr; + if (SmartGlobal && SmartGlobal->version) + { + dxReadPixels(ptr_Direct3DDevice9, SmartGlobal->img, hdc, SmartGlobal->width, SmartGlobal->height); + if (!IsIconic(WindowFromDC(hdc))) + { + + if (SmartDebugEnabled) + { + BltSmartBuffer(ptr_Direct3DDevice9); + } + + int X = 0, Y = 0; + SmartGlobal->getMousePos(X, Y); + if (X != -1 && Y != -1) + { + //SetRenderState(D3DRS_POINTSIZE,...). //Not cross-hardware compatible.. + //ptr_Direct3DDevice9->DrawPrimitive(D3DPT_POINTLIST, 0, 6); + //DrawCircle(ptr_Direct3DDevice9, X, Y, 2); //Weird behaviour + } + } + } + + /**Removed because Direct-X can be captured from Targets without plugins**/ + /*else + { + if (!SharedImageData || !SharedImageData->GetDataPointer()) + { + CreateSharedMemory(getpid()) || OpenSharedMemory(getpid()); + } + + int Width = 0, Height = 0; + void* ImgPtr = SharedImageData->GetDataPointer(); + dxReadPixels(ptr_Direct3DDevice9, ImgPtr, hdc, Width, Height); + + if (!IsIconic(WindowFromDC(hdc))) + { + void* DbgPtr = reinterpret_cast(SharedImageData->GetDataPointer()) + SharedImageSize; + BltMappedBuffer(DbgPtr, Width, Height); + } + }*/ + + return ptr_Direct3DDevice9->EndScene(); +} + +HRESULT Direct3DDevice9Proxy::Clear(DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) +{ + return ptr_Direct3DDevice9->Clear(Count, pRects, Flags, Color, Z, Stencil); +} + +HRESULT Direct3DDevice9Proxy::SetTransform(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) +{ + return ptr_Direct3DDevice9->SetTransform(State, pMatrix); +} + +HRESULT Direct3DDevice9Proxy::GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) +{ + return ptr_Direct3DDevice9->GetTransform(State, pMatrix); +} + +HRESULT Direct3DDevice9Proxy::MultiplyTransform(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) +{ + return ptr_Direct3DDevice9->MultiplyTransform(State, pMatrix); +} + +HRESULT Direct3DDevice9Proxy::SetViewport(CONST D3DVIEWPORT9* pViewport) +{ + return ptr_Direct3DDevice9->SetViewport(pViewport); +} + +HRESULT Direct3DDevice9Proxy::GetViewport(D3DVIEWPORT9* pViewport) +{ + return ptr_Direct3DDevice9->GetViewport(pViewport); +} + +HRESULT Direct3DDevice9Proxy::SetMaterial(CONST D3DMATERIAL9* pMaterial) +{ + return ptr_Direct3DDevice9->SetMaterial(pMaterial); +} + +HRESULT Direct3DDevice9Proxy::GetMaterial(D3DMATERIAL9* pMaterial) +{ + return ptr_Direct3DDevice9->GetMaterial(pMaterial); +} + +HRESULT Direct3DDevice9Proxy::SetLight(DWORD Index, CONST D3DLIGHT9* pLight) +{ + return ptr_Direct3DDevice9->SetLight(Index, pLight); +} + +HRESULT Direct3DDevice9Proxy::GetLight(DWORD Index, D3DLIGHT9* pLight) +{ + return ptr_Direct3DDevice9->GetLight(Index, pLight); +} + +HRESULT Direct3DDevice9Proxy::LightEnable(DWORD Index, BOOL Enable) +{ + return ptr_Direct3DDevice9->LightEnable(Index, Enable); +} + +HRESULT Direct3DDevice9Proxy::GetLightEnable(DWORD Index, BOOL* pEnable) +{ + return ptr_Direct3DDevice9->GetLightEnable(Index, pEnable); +} + +HRESULT Direct3DDevice9Proxy::SetClipPlane(DWORD Index, CONST float* pPlane) +{ + return ptr_Direct3DDevice9->SetClipPlane(Index, pPlane); +} + +HRESULT Direct3DDevice9Proxy::GetClipPlane(DWORD Index, float* pPlane) +{ + return ptr_Direct3DDevice9->GetClipPlane(Index, pPlane); +} + +HRESULT Direct3DDevice9Proxy::SetRenderState(D3DRENDERSTATETYPE State, DWORD Value) +{ + return ptr_Direct3DDevice9->SetRenderState(State, Value); +} + +HRESULT Direct3DDevice9Proxy::GetRenderState(D3DRENDERSTATETYPE State, DWORD* pValue) +{ + return ptr_Direct3DDevice9->GetRenderState(State, pValue); +} + +HRESULT Direct3DDevice9Proxy::CreateStateBlock(D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppSB) +{ + return ptr_Direct3DDevice9->CreateStateBlock(Type, ppSB); +} + +HRESULT Direct3DDevice9Proxy::BeginStateBlock() +{ + return ptr_Direct3DDevice9->BeginStateBlock(); +} + +HRESULT Direct3DDevice9Proxy::EndStateBlock(IDirect3DStateBlock9** ppSB) +{ + return ptr_Direct3DDevice9->EndStateBlock(ppSB); +} + +HRESULT Direct3DDevice9Proxy::SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus) +{ + return ptr_Direct3DDevice9->SetClipStatus(pClipStatus); +} + +HRESULT Direct3DDevice9Proxy::GetClipStatus(D3DCLIPSTATUS9* pClipStatus) +{ + return ptr_Direct3DDevice9->GetClipStatus(pClipStatus); +} + +HRESULT Direct3DDevice9Proxy::GetTexture(DWORD Stage, IDirect3DBaseTexture9** ppTexture) +{ + return ptr_Direct3DDevice9->GetTexture(Stage, ppTexture); +} + +HRESULT Direct3DDevice9Proxy::SetTexture(DWORD Stage, IDirect3DBaseTexture9* pTexture) +{ + return ptr_Direct3DDevice9->SetTexture(Stage, pTexture); +} + +HRESULT Direct3DDevice9Proxy::GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) +{ + return ptr_Direct3DDevice9->GetTextureStageState(Stage, Type, pValue); +} + +HRESULT Direct3DDevice9Proxy::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) +{ + return ptr_Direct3DDevice9->SetTextureStageState(Stage, Type, Value); +} + +HRESULT Direct3DDevice9Proxy::GetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue) +{ + return ptr_Direct3DDevice9->GetSamplerState(Sampler, Type, pValue); +} + +HRESULT Direct3DDevice9Proxy::SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) +{ + return ptr_Direct3DDevice9->SetSamplerState(Sampler, Type, Value); +} + +HRESULT Direct3DDevice9Proxy::ValidateDevice(DWORD* pNumPasses) +{ + return ptr_Direct3DDevice9->ValidateDevice(pNumPasses); +} + +HRESULT Direct3DDevice9Proxy::SetPaletteEntries(UINT PaletteNumber, CONST PALETTEENTRY* pEntries) +{ + return ptr_Direct3DDevice9->SetPaletteEntries(PaletteNumber, pEntries); +} + +HRESULT Direct3DDevice9Proxy::GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY* pEntries) +{ + return ptr_Direct3DDevice9->GetPaletteEntries(PaletteNumber, pEntries); +} + +HRESULT Direct3DDevice9Proxy::SetCurrentTexturePalette(UINT PaletteNumber) +{ + return ptr_Direct3DDevice9->SetCurrentTexturePalette(PaletteNumber); +} + +HRESULT Direct3DDevice9Proxy::GetCurrentTexturePalette(UINT *PaletteNumber) +{ + return ptr_Direct3DDevice9->GetCurrentTexturePalette(PaletteNumber); +} + +HRESULT Direct3DDevice9Proxy::SetScissorRect(CONST RECT* pRect) +{ + return ptr_Direct3DDevice9->SetScissorRect(pRect); +} + +HRESULT Direct3DDevice9Proxy::GetScissorRect(RECT* pRect) +{ + return ptr_Direct3DDevice9->GetScissorRect(pRect); +} + +HRESULT Direct3DDevice9Proxy::SetSoftwareVertexProcessing(BOOL bSoftware) +{ + return ptr_Direct3DDevice9->SetSoftwareVertexProcessing(bSoftware); +} + +BOOL Direct3DDevice9Proxy::GetSoftwareVertexProcessing() +{ + return ptr_Direct3DDevice9->GetSoftwareVertexProcessing(); +} + +HRESULT Direct3DDevice9Proxy::SetNPatchMode(float nSegments) +{ + return ptr_Direct3DDevice9->SetNPatchMode(nSegments); +} + +float Direct3DDevice9Proxy::GetNPatchMode() +{ + return ptr_Direct3DDevice9->GetNPatchMode(); +} + +HRESULT Direct3DDevice9Proxy::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) +{ + return ptr_Direct3DDevice9->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount); +} + +HRESULT Direct3DDevice9Proxy::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount) +{ + return ptr_Direct3DDevice9->DrawIndexedPrimitive(PrimitiveType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount); +} + +HRESULT Direct3DDevice9Proxy::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) +{ + return ptr_Direct3DDevice9->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride); +} + +HRESULT Direct3DDevice9Proxy::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) +{ + return ptr_Direct3DDevice9->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); +} + +HRESULT Direct3DDevice9Proxy::ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags) +{ + return ptr_Direct3DDevice9->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags); +} + +HRESULT Direct3DDevice9Proxy::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl) +{ + return ptr_Direct3DDevice9->CreateVertexDeclaration(pVertexElements, ppDecl); +} + +HRESULT Direct3DDevice9Proxy::SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl) +{ + return ptr_Direct3DDevice9->SetVertexDeclaration(pDecl); +} + +HRESULT Direct3DDevice9Proxy::GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl) +{ + return ptr_Direct3DDevice9->GetVertexDeclaration(ppDecl); +} + +HRESULT Direct3DDevice9Proxy::SetFVF(DWORD FVF) +{ + return ptr_Direct3DDevice9->SetFVF(FVF); +} + +HRESULT Direct3DDevice9Proxy::GetFVF(DWORD* pFVF) +{ + return ptr_Direct3DDevice9->GetFVF(pFVF); +} + +HRESULT Direct3DDevice9Proxy::CreateVertexShader(CONST DWORD* pFunction, IDirect3DVertexShader9** ppShader) +{ + return ptr_Direct3DDevice9->CreateVertexShader(pFunction, ppShader); +} + +HRESULT Direct3DDevice9Proxy::SetVertexShader(IDirect3DVertexShader9* pShader) +{ + return ptr_Direct3DDevice9->SetVertexShader(pShader); +} + +HRESULT Direct3DDevice9Proxy::GetVertexShader(IDirect3DVertexShader9** ppShader) +{ + return ptr_Direct3DDevice9->GetVertexShader(ppShader); +} + +HRESULT Direct3DDevice9Proxy::SetVertexShaderConstantF(UINT StartRegister, CONST float* pconstantData, UINT Vector4fCount) +{ + return ptr_Direct3DDevice9->SetVertexShaderConstantF(StartRegister, pconstantData, Vector4fCount); +} + +HRESULT Direct3DDevice9Proxy::GetVertexShaderConstantF(UINT StartRegister, float* pconstantData, UINT Vector4fCount) +{ + return ptr_Direct3DDevice9->GetVertexShaderConstantF(StartRegister, pconstantData, Vector4fCount); +} + +HRESULT Direct3DDevice9Proxy::SetVertexShaderConstantI(UINT StartRegister, CONST int* pconstantData, UINT Vector4iCount) +{ + return ptr_Direct3DDevice9->SetVertexShaderConstantI(StartRegister, pconstantData, Vector4iCount); +} + +HRESULT Direct3DDevice9Proxy::GetVertexShaderConstantI(UINT StartRegister, int* pconstantData, UINT Vector4iCount) +{ + return ptr_Direct3DDevice9->GetVertexShaderConstantI(StartRegister, pconstantData, Vector4iCount); +} + +HRESULT Direct3DDevice9Proxy::SetVertexShaderConstantB(UINT StartRegister, CONST BOOL* pconstantData, UINT BoolCount) +{ + return ptr_Direct3DDevice9->SetVertexShaderConstantB(StartRegister, pconstantData, BoolCount); +} + +HRESULT Direct3DDevice9Proxy::GetVertexShaderConstantB(UINT StartRegister, BOOL* pconstantData, UINT BoolCount) +{ + return ptr_Direct3DDevice9->GetVertexShaderConstantB(StartRegister, pconstantData, BoolCount); +} + +HRESULT Direct3DDevice9Proxy::SetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride) +{ + return ptr_Direct3DDevice9->SetStreamSource(StreamNumber, pStreamData, OffsetInBytes, Stride); +} + +HRESULT Direct3DDevice9Proxy::GetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer9** ppStreamData, UINT* OffsetInBytes, UINT* pStride) +{ + return ptr_Direct3DDevice9->GetStreamSource(StreamNumber, ppStreamData, OffsetInBytes, pStride); +} + +HRESULT Direct3DDevice9Proxy::SetStreamSourceFreq(UINT StreamNumber, UINT Divider) +{ + return ptr_Direct3DDevice9->SetStreamSourceFreq(StreamNumber, Divider); +} + +HRESULT Direct3DDevice9Proxy::GetStreamSourceFreq(UINT StreamNumber, UINT* Divider) +{ + return ptr_Direct3DDevice9->GetStreamSourceFreq(StreamNumber, Divider); +} + +HRESULT Direct3DDevice9Proxy::SetIndices(IDirect3DIndexBuffer9* pIndexData) +{ + return ptr_Direct3DDevice9->SetIndices(pIndexData); +} + +HRESULT Direct3DDevice9Proxy::GetIndices(IDirect3DIndexBuffer9** ppIndexData) +{ + return ptr_Direct3DDevice9->GetIndices(ppIndexData); +} + +HRESULT Direct3DDevice9Proxy::CreatePixelShader(CONST DWORD* pFunction, IDirect3DPixelShader9** ppShader) +{ + return ptr_Direct3DDevice9->CreatePixelShader(pFunction, ppShader); +} + +HRESULT Direct3DDevice9Proxy::SetPixelShader(IDirect3DPixelShader9* pShader) +{ + return ptr_Direct3DDevice9->SetPixelShader(pShader); +} + +HRESULT Direct3DDevice9Proxy::GetPixelShader(IDirect3DPixelShader9** ppShader) +{ + return ptr_Direct3DDevice9->GetPixelShader(ppShader); +} + +HRESULT Direct3DDevice9Proxy::SetPixelShaderConstantF(UINT StartRegister, CONST float* pconstantData, UINT Vector4fCount) +{ + return ptr_Direct3DDevice9->SetPixelShaderConstantF(StartRegister, pconstantData, Vector4fCount); +} + +HRESULT Direct3DDevice9Proxy::GetPixelShaderConstantF(UINT StartRegister, float* pconstantData, UINT Vector4fCount) +{ + return ptr_Direct3DDevice9->GetPixelShaderConstantF(StartRegister, pconstantData, Vector4fCount); +} + +HRESULT Direct3DDevice9Proxy::SetPixelShaderConstantI(UINT StartRegister, CONST int* pconstantData, UINT Vector4iCount) +{ + return ptr_Direct3DDevice9->SetPixelShaderConstantI(StartRegister, pconstantData, Vector4iCount); +} + +HRESULT Direct3DDevice9Proxy::GetPixelShaderConstantI(UINT StartRegister, int* pconstantData, UINT Vector4iCount) +{ + return ptr_Direct3DDevice9->GetPixelShaderConstantI(StartRegister, pconstantData, Vector4iCount); +} + +HRESULT Direct3DDevice9Proxy::SetPixelShaderConstantB(UINT StartRegister, CONST BOOL* pconstantData, UINT BoolCount) +{ + return ptr_Direct3DDevice9->SetPixelShaderConstantB(StartRegister, pconstantData, BoolCount); +} + +HRESULT Direct3DDevice9Proxy::GetPixelShaderConstantB(UINT StartRegister, BOOL* pconstantData, UINT BoolCount) +{ + return ptr_Direct3DDevice9->GetPixelShaderConstantB(StartRegister, pconstantData, BoolCount); +} + +HRESULT Direct3DDevice9Proxy::DrawRectPatch(UINT Handle, CONST float* pNumSegs, CONST D3DRECTPATCH_INFO* pRectPatchInfo) +{ + return ptr_Direct3DDevice9->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo); +} + +HRESULT Direct3DDevice9Proxy::DrawTriPatch(UINT Handle, CONST float* pNumSegs, CONST D3DTRIPATCH_INFO* pTriPatchInfo) +{ + return ptr_Direct3DDevice9->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo); +} + +HRESULT Direct3DDevice9Proxy::DeletePatch(UINT Handle) +{ + return ptr_Direct3DDevice9->DeletePatch(Handle); +} + +HRESULT Direct3DDevice9Proxy::CreateQuery(D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery) +{ + return ptr_Direct3DDevice9->CreateQuery(Type, ppQuery); +} diff --git a/d3d9/Hooks/Direct3DDevice9Proxy.hpp b/d3d9/Hooks/Direct3DDevice9Proxy.hpp new file mode 100644 index 0000000..8e424ac --- /dev/null +++ b/d3d9/Hooks/Direct3DDevice9Proxy.hpp @@ -0,0 +1,139 @@ +#ifndef DIRECT3DDEVICE9PROXY_HPP_INCLUDED +#define DIRECT3DDEVICE9PROXY_HPP_INCLUDED + +#include +#include "../Graphics.hpp" +#include "../SMARTPlugin.hpp" + +class Direct3DDevice9Proxy : public IDirect3DDevice9 +{ + private: + IDirect3DDevice9* ptr_Direct3DDevice9; + IDirect3D9* Direct3D9; + + public: + Direct3DDevice9Proxy(IDirect3DDevice9* pOriginal); + virtual ~Direct3DDevice9Proxy(); + + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj); + ULONG __stdcall AddRef(); + ULONG __stdcall Release(); + HRESULT __stdcall TestCooperativeLevel(); + UINT __stdcall GetAvailableTextureMem(); + HRESULT __stdcall EvictManagedResources(); + HRESULT __stdcall GetDirect3D(IDirect3D9** ppD3D9); + HRESULT __stdcall GetDeviceCaps(D3DCAPS9* pCaps); + HRESULT __stdcall GetDisplayMode(UINT iSwapChain, D3DDISPLAYMODE* pMode); + HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters); + HRESULT __stdcall SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap); + void __stdcall SetCursorPosition(int X, int Y, DWORD Flags); + BOOL __stdcall ShowCursor(BOOL bShow); + HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain) ; + HRESULT __stdcall GetSwapChain(UINT iSwapChain, IDirect3DSwapChain9** pSwapChain); + UINT __stdcall GetNumberOfSwapChains(); + HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters); + HRESULT __stdcall Present(CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion); + HRESULT __stdcall GetBackBuffer(UINT iSwapChain, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer); + HRESULT __stdcall GetRasterStatus(UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus); + HRESULT __stdcall SetDialogBoxMode(BOOL bEnableDialogs); + void __stdcall SetGammaRamp(UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp); + void __stdcall GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp); + HRESULT __stdcall CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle); + HRESULT __stdcall CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle); + HRESULT __stdcall CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle); + HRESULT __stdcall CreateVertexBuffer(UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle); + HRESULT __stdcall CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle); + HRESULT __stdcall CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle); + HRESULT __stdcall CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Discard, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle); + HRESULT __stdcall UpdateSurface(IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestinationSurface, CONST POINT* pDestPoint); + HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture); + HRESULT __stdcall GetRenderTargetData(IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface); + HRESULT __stdcall GetFrontBufferData(UINT iSwapChain, IDirect3DSurface9* pDestSurface); + HRESULT __stdcall StretchRect(IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestSurface, CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter); + HRESULT __stdcall ColorFill(IDirect3DSurface9* pSurface, CONST RECT* pRect, D3DCOLOR color); + HRESULT __stdcall CreateOffscreenPlainSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle); + HRESULT __stdcall SetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget); + HRESULT __stdcall GetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9** ppRenderTarget); + HRESULT __stdcall SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil); + HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface); + HRESULT __stdcall BeginScene(); + HRESULT __stdcall EndScene(); + HRESULT __stdcall Clear(DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil); + HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix); + HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix); + HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix); + HRESULT __stdcall SetViewport(CONST D3DVIEWPORT9* pViewport); + HRESULT __stdcall GetViewport(D3DVIEWPORT9* pViewport); + HRESULT __stdcall SetMaterial(CONST D3DMATERIAL9* pMaterial); + HRESULT __stdcall GetMaterial(D3DMATERIAL9* pMaterial); + HRESULT __stdcall SetLight(DWORD Index, CONST D3DLIGHT9* pLight); + HRESULT __stdcall GetLight(DWORD Index, D3DLIGHT9* pLight); + HRESULT __stdcall LightEnable(DWORD Index, BOOL Enable); + HRESULT __stdcall GetLightEnable(DWORD Index, BOOL* pEnable); + HRESULT __stdcall SetClipPlane(DWORD Index, CONST float* pPlane); + HRESULT __stdcall GetClipPlane(DWORD Index, float* pPlane); + HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State, DWORD Value); + HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State, DWORD* pValue); + HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppSB); + HRESULT __stdcall BeginStateBlock(); + HRESULT __stdcall EndStateBlock(IDirect3DStateBlock9** ppSB); + HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus); + HRESULT __stdcall GetClipStatus(D3DCLIPSTATUS9* pClipStatus); + HRESULT __stdcall GetTexture(DWORD Stage, IDirect3DBaseTexture9** ppTexture); + HRESULT __stdcall SetTexture(DWORD Stage, IDirect3DBaseTexture9* pTexture); + HRESULT __stdcall GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue); + HRESULT __stdcall SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value); + HRESULT __stdcall GetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue); + HRESULT __stdcall SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value); + HRESULT __stdcall ValidateDevice(DWORD* pNumPasses); + HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber, CONST PALETTEENTRY* pEntries); + HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY* pEntries); + HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber); + HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber); + HRESULT __stdcall SetScissorRect(CONST RECT* pRect); + HRESULT __stdcall GetScissorRect(RECT* pRect); + HRESULT __stdcall SetSoftwareVertexProcessing(BOOL bSoftware); + BOOL __stdcall GetSoftwareVertexProcessing(); + HRESULT __stdcall SetNPatchMode(float nSegments); + float __stdcall GetNPatchMode(); + HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount); + HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount); + HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride); + HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride); + HRESULT __stdcall ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags); + HRESULT __stdcall CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl); + HRESULT __stdcall SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl); + HRESULT __stdcall GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl); + HRESULT __stdcall SetFVF(DWORD FVF); + HRESULT __stdcall GetFVF(DWORD* pFVF); + HRESULT __stdcall CreateVertexShader(CONST DWORD* pFunction, IDirect3DVertexShader9** ppShader); + HRESULT __stdcall SetVertexShader(IDirect3DVertexShader9* pShader); + HRESULT __stdcall GetVertexShader(IDirect3DVertexShader9** ppShader); + HRESULT __stdcall SetVertexShaderConstantF(UINT StartRegister, CONST float* pconstantData, UINT Vector4fCount); + HRESULT __stdcall GetVertexShaderConstantF(UINT StartRegister, float* pconstantData, UINT Vector4fCount); + HRESULT __stdcall SetVertexShaderConstantI(UINT StartRegister, CONST int* pconstantData, UINT Vector4iCount); + HRESULT __stdcall GetVertexShaderConstantI(UINT StartRegister, int* pconstantData, UINT Vector4iCount); + HRESULT __stdcall SetVertexShaderConstantB(UINT StartRegister, CONST BOOL* pconstantData, UINT BoolCount); + HRESULT __stdcall GetVertexShaderConstantB(UINT StartRegister, BOOL* pconstantData, UINT BoolCount); + HRESULT __stdcall SetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride); + HRESULT __stdcall GetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer9** ppStreamData, UINT* OffsetInBytes, UINT* pStride); + HRESULT __stdcall SetStreamSourceFreq(UINT StreamNumber, UINT Divider); + HRESULT __stdcall GetStreamSourceFreq(UINT StreamNumber, UINT* Divider); + HRESULT __stdcall SetIndices(IDirect3DIndexBuffer9* pIndexData); + HRESULT __stdcall GetIndices(IDirect3DIndexBuffer9** ppIndexData); + HRESULT __stdcall CreatePixelShader(CONST DWORD* pFunction, IDirect3DPixelShader9** ppShader); + HRESULT __stdcall SetPixelShader(IDirect3DPixelShader9* pShader); + HRESULT __stdcall GetPixelShader(IDirect3DPixelShader9** ppShader); + HRESULT __stdcall SetPixelShaderConstantF(UINT StartRegister, CONST float* pconstantData, UINT Vector4fCount); + HRESULT __stdcall GetPixelShaderConstantF(UINT StartRegister, float* pconstantData, UINT Vector4fCount); + HRESULT __stdcall SetPixelShaderConstantI(UINT StartRegister, CONST int* pconstantData, UINT Vector4iCount); + HRESULT __stdcall GetPixelShaderConstantI(UINT StartRegister, int* pconstantData, UINT Vector4iCount); + HRESULT __stdcall SetPixelShaderConstantB(UINT StartRegister, CONST BOOL* pconstantData, UINT BoolCount); + HRESULT __stdcall GetPixelShaderConstantB(UINT StartRegister, BOOL* pconstantData, UINT BoolCount); + HRESULT __stdcall DrawRectPatch(UINT Handle, CONST float* pNumSegs, CONST D3DRECTPATCH_INFO* pRectPatchInfo); + HRESULT __stdcall DrawTriPatch(UINT Handle, CONST float* pNumSegs, CONST D3DTRIPATCH_INFO* pTriPatchInfo); + HRESULT __stdcall DeletePatch(UINT Handle); + HRESULT __stdcall CreateQuery(D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery); +}; + +#endif // DIRECT3DDEVICE9PROXY_HPP_INCLUDED diff --git a/d3d9/Hooks/Hooks.cpp b/d3d9/Hooks/Hooks.cpp new file mode 100644 index 0000000..5fd16a4 --- /dev/null +++ b/d3d9/Hooks/Hooks.cpp @@ -0,0 +1,63 @@ +#include "Hooks.hpp" + +std::unique_ptr SharedImageData; +const char* SharedImageName = "Local\\DXIImage_"; + +std::string GetProcessID() +{ + return "_" + std::to_string(getpid()); +} + +void GetDesktopResolution(int &width, int &height) +{ + #if defined _WIN32 || defined _WIN64 + RECT desktop = {0}; + const HWND hDesktop = GetDesktopWindow(); + GetWindowRect(hDesktop, &desktop); + width = desktop.right; + height = desktop.bottom; + #endif +} + +bool InitializeAll() +{ + return ((CreateSharedMemory(getpid()) || OpenSharedMemory(getpid())) && Initialize()); +} + +bool CreateSharedMemory(int ProcessID) +{ + int Width = 0, Height = 0; + GetDesktopResolution(Width, Height); + MessageBox(NULL, ("Mapped: " + std::string(SharedImageName) + std::to_string(ProcessID)).c_str(), "Map-ID", 0); + SharedImageData.reset(new SharedMemory(SharedImageName + std::to_string(ProcessID))); + return SharedImageData->MapMemory(Width || Height == 0 ? TotalImageSize : Width * Height * 4 * 2); +} + +bool OpenSharedMemory(int ProcessID) +{ + int Width = 0, Height = 0; + GetDesktopResolution(Width, Height); + MessageBox(NULL, ("Opened: " + std::string(SharedImageName) + std::to_string(ProcessID)).c_str(), "Map-ID", 0); + SharedImageData.reset(new SharedMemory(SharedImageName + std::to_string(ProcessID))); + return SharedImageData->OpenMemoryMap(Width || Height == 0 ? SharedImageSize : Width * Height * 4 * 2); +} + +bool UnMapSharedMemory() +{ + SharedImageData.reset(nullptr); + return true; +} + +void FlipImageBytes(void* In, void* &Out, int width, int height, unsigned int Bpp) +{ + unsigned long Chunk = (Bpp > 24 ? width * 4 : width * 3 + width % 4); + unsigned char* Destination = static_cast(Out); + unsigned char* Source = static_cast(In) + Chunk * (height - 1); + + while(Source != In) + { + std::memcpy(Destination, Source, Chunk); + Destination += Chunk; + Source -= Chunk; + } +} diff --git a/d3d9/Hooks/Hooks.hpp b/d3d9/Hooks/Hooks.hpp new file mode 100644 index 0000000..b6e219b --- /dev/null +++ b/d3d9/Hooks/Hooks.hpp @@ -0,0 +1,29 @@ +#ifndef HOOKS_HPP_INCLUDED +#define HOOKS_HPP_INCLUDED + +#include +#include +#include +#include "Exports.hpp" +#include "../SharedMemory.hpp" +#include "../SMARTPlugin.hpp" + +#define SharedImageSize 8294400 //Highest Resolution Support: 1920 x 1080 x sizeof(RGBA) +#define TotalImageSize (SharedImageSize * 2) //Image + DebugImage + +extern const char* SharedImageName; +extern std::unique_ptr SharedImageData; + +extern void GetDesktopResolution(int &width, int &height); + +extern bool InitializeAll(); + +extern bool CreateSharedMemory(int ProcessId); + +extern bool OpenSharedMemory(int ProcessId); + +extern bool UnMapSharedMemory(); + +extern void FlipImageBytes(void* In, void* &Out, int width, int height, unsigned int Bpp); + +#endif // HOOKS_HPP_INCLUDED diff --git a/d3d9/Images.cpp b/d3d9/Images.cpp new file mode 100644 index 0000000..ec67254 --- /dev/null +++ b/d3d9/Images.cpp @@ -0,0 +1,218 @@ +#include "Images.hpp" + +namespace CG +{ + Image::~Image() + { + if (!PointerInit) + delete[] this->Pixels; + #if defined _WIN32 || defined _WIN64 + DeleteObject(hBmp); + #endif + } + + Image::Image(const char* FilePath) : Pixels(nullptr), width(0), height(0), BitsPerPixel(0) + { + std::fstream hFile(FilePath, std::ios::in | std::ios::binary); + if (!hFile.is_open()) throw std::invalid_argument("Error: File Not Found."); + + hFile.seekg(0, std::ios::end); + int Length = hFile.tellg(); + hFile.seekg(0, std::ios::beg); + std::vector FileInfo(Length); + hFile.read(reinterpret_cast(FileInfo.data()), 54); + + if(FileInfo[0] != 'B' && FileInfo[1] != 'M') + { + hFile.close(); + throw std::invalid_argument("Error: Invalid File Format. Bitmap Required."); + } + + if (FileInfo[28] != 24 && FileInfo[28] != 32) + { + hFile.close(); + throw std::invalid_argument("Error: Invalid File Format. 24 or 32 bit Image Required."); + } + + BitsPerPixel = FileInfo[28]; + width = FileInfo[18] + (FileInfo[19] << 8); + height = FileInfo[22] + (FileInfo[23] << 8); + std::uint32_t PixelsOffset = FileInfo[10] + (FileInfo[11] << 8); + std::uint32_t size = ((width * BitsPerPixel + 31) / 32) * 4 * height; + std::vector Data(size); + + hFile.seekg (PixelsOffset, std::ios::beg); + hFile.read(reinterpret_cast(Data.data()), size); + hFile.close(); + + this->Pixels = new RGBA[width * height]; + this->ProcessPixels(Data.data(), this->Pixels); + } + + Image::Image(int Width, int Height) : Pixels(new RGBA[Width * Height]), width(Width), height(Height), BitsPerPixel(32) + { + std::memset(this->Pixels, 0, Width * Height); + } + + Image::Image(RGBA* Ptr, int Width, int Height) : Pixels(Ptr), width(Width), height(Height), BitsPerPixel(32) + { + PointerInit = true; + } + + #if defined _WIN32 || defined _WIN64 + Image::Image(HDC DC, int X, int Y, int Width, int Height) : Pixels(nullptr), width(Width), height(Height), BitsPerPixel(32) + { + BITMAP Bmp = {0}; + HBITMAP hBmp = reinterpret_cast(GetCurrentObject(DC, OBJ_BITMAP)); + + if (GetObject(hBmp, sizeof(BITMAP), &Bmp) == 0) + throw std::runtime_error("BITMAP DC NOT FOUND."); + + RECT area = {X, Y, X + Width, Y + Height}; + HWND Window = WindowFromDC(DC); + GetClientRect(Window, &area); + + HDC MemDC = GetDC(nullptr); + HDC SDC = CreateCompatibleDC(MemDC); + HBITMAP hSBmp = CreateCompatibleBitmap(MemDC, width, height); + DeleteObject(SelectObject(SDC, hSBmp)); + + BitBlt(SDC, 0, 0, width, height, DC, X, Y, SRCCOPY); + std::vector Data(((width * BitsPerPixel + 31) / 32) * 4 * height); + + BITMAPINFO Info = {sizeof(BITMAPINFOHEADER), width, height, 1, BitsPerPixel, BI_RGB, Data.size(), 0, 0, 0, 0}; + GetDIBits(SDC, hSBmp, 0, height, Data.data(), &Info, DIB_RGB_COLORS); + + DeleteDC(SDC); + DeleteObject(hSBmp); + ReleaseDC(nullptr, MemDC); + this->ProcessPixels(Data.data(), this->Pixels); + } + + Image::Image(HWND Window, int X, int Y, int Width, int Height) + { + HDC DC = GetDC(Window); + BITMAP Bmp = {0}; + HBITMAP hBmp = reinterpret_cast(GetCurrentObject(DC, OBJ_BITMAP)); + + if (GetObject(hBmp, sizeof(BITMAP), &Bmp) == 0) + throw std::runtime_error("BITMAP DC NOT FOUND."); + + RECT area = {X, Y, X + Width, Y + Height}; + GetClientRect(Window, &area); + + HDC MemDC = GetDC(nullptr); + HDC SDC = CreateCompatibleDC(MemDC); + HBITMAP hSBmp = CreateCompatibleBitmap(MemDC, width, height); + DeleteObject(SelectObject(SDC, hSBmp)); + + BitBlt(SDC, 0, 0, width, height, DC, X, Y, SRCCOPY); + std::vector Data(((width * BitsPerPixel + 31) / 32) * 4 * height); + + BITMAPINFO Info = {sizeof(BITMAPINFOHEADER), width, height, 1, BitsPerPixel, BI_RGB, Data.size(), 0, 0, 0, 0}; + GetDIBits(SDC, hSBmp, 0, height, Data.data(), &Info, DIB_RGB_COLORS); + + DeleteDC(SDC); + DeleteObject(hSBmp); + ReleaseDC(nullptr, MemDC); + ReleaseDC(Window, DC); + this->ProcessPixels(Data.data(), this->Pixels); + } + + void Image::Draw(HWND Hwnd, int X , int Y , int Width , int Height , int SourceX , int SourceY, DWORD RasterType) + { + HDC hDC = GetDC(Hwnd); + Draw(hDC, X, Y, Width, Height, SourceX, SourceY, RasterType); + ReleaseDC(Hwnd, hDC); + } + + void Image::Draw(HDC hDC, int X, int Y, int Width, int Height, int SourceX, int SourceY, DWORD RasterType) + { + BITMAP Bmp; + HDC MemDC = CreateCompatibleDC(hDC); + if (!hBmp) + { + std::vector Data(((width * BitsPerPixel + 31) / 32) * 4 * height); + BITMAPINFO Info = {sizeof(BITMAPINFOHEADER), width, height, 1, BitsPerPixel, BI_RGB, Data.size(), 0, 0, 0, 0}; + this->ProcessPixels(this->Pixels, Data.data()); + DeleteObject(hBmp); + hBmp = CreateDIBitmap(GetDC(nullptr), &Info.bmiHeader, CBM_INIT, Data.data(), &Info, DIB_RGB_COLORS); + } + + HGDIOBJ hbmOld = SelectObject(MemDC, hBmp); + GetObject(hBmp, sizeof(Bmp), &Bmp); + + BitBlt(hDC, X, Y, Width == 0 ? Bmp.bmWidth : Width, Height == 0 ? Bmp.bmHeight : Height, MemDC, SourceX, SourceY, RasterType); + + SelectObject(MemDC, hbmOld); + DeleteDC(MemDC); + } + #endif + + void Image::Save(const char* FilePath) + { + std::fstream hFile(FilePath, std::ios::out | std::ios::binary); + if (!hFile.is_open()) throw std::invalid_argument("Error: File not found."); + + std::uint32_t Trash = 0; + std::uint16_t Planes = 1; + std::uint32_t biSize = 40; + std::uint16_t Type = 0x4D42; + std::uint32_t compression = 0; + std::uint32_t PixelsOffsetBits = 54; + std::uint32_t size = ((width * BitsPerPixel + 31) / 32) * 4 * height; + std::uint32_t bfSize = 54 + size; + std::vector Data(size); + + this->ProcessPixels(this->Pixels, Data.data()); + + hFile.write(reinterpret_cast(&Type), sizeof(Type)); + hFile.write(reinterpret_cast(&bfSize), sizeof(bfSize)); + hFile.write(reinterpret_cast(&Trash), sizeof(std::uint32_t)); + hFile.write(reinterpret_cast(&PixelsOffsetBits), sizeof(PixelsOffsetBits)); + hFile.write(reinterpret_cast(&biSize), sizeof(biSize)); + hFile.write(reinterpret_cast(&width), sizeof(width)); + hFile.write(reinterpret_cast(&height), sizeof(height)); + hFile.write(reinterpret_cast(&Planes), sizeof(Planes)); + hFile.write(reinterpret_cast(&BitsPerPixel), sizeof(BitsPerPixel)); + hFile.write(reinterpret_cast(&compression), sizeof(compression)); + hFile.write(reinterpret_cast(&size), sizeof(size)); + hFile.write(reinterpret_cast(&Trash), sizeof(std::uint32_t) * 4); + hFile.write(reinterpret_cast(Data.data()), size); + hFile.close(); + } + + void Image::ProcessPixels(const std::uint8_t* In, RGBA* Out) + { + for (std::size_t I = 0; I < height; ++I) + { + for (std::size_t J = 0; J < width; ++J) + { + Out[(height - 1 - I) * width + J].B = *(In++); + Out[(height - 1 - I) * width + J].G = *(In++); + Out[(height - 1 - I) * width + J].R = *(In++); + Out[(height - 1 - I) * width + J].A = (BitsPerPixel > 24 ? * (In++) : 0xFF); + } + if(BitsPerPixel == 24) + In += (-width * 3) & 3; + } + } + + void Image::ProcessPixels(const RGBA* In, std::uint8_t* Out) + { + for (std::size_t I = 0; I < height; ++I) + { + for (std::size_t J = 0; J < width; ++J) + { + *(Out++) = In[(height - 1 - I) * width + J].B; + *(Out++) = In[(height - 1 - I) * width + J].G; + *(Out++) = In[(height - 1 - I) * width + J].R; + + if (BitsPerPixel > 24) + *(Out++) = In[(height - 1 - I) * width + J].A; + } + if(BitsPerPixel == 24) + Out += (-width * 3) & 3; + } + } +} diff --git a/d3d9/Images.hpp b/d3d9/Images.hpp new file mode 100644 index 0000000..d4d5b13 --- /dev/null +++ b/d3d9/Images.hpp @@ -0,0 +1,84 @@ +#ifndef IMAGES_HPP_INCLUDED +#define IMAGES_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +namespace CG +{ + typedef union RGBA + { + std::uint32_t Colour; + struct + { + std::uint8_t R, G, B, A; + }; + } *PRGB; + + class Image + { + private: + RGBA* Pixels; + std::uint32_t width, height; + std::uint16_t BitsPerPixel; + bool PointerInit = false; +#if defined _WIN32 || defined _WIN64 + HBITMAP hBmp = nullptr; +#endif + + protected: + void ProcessPixels(const std::uint8_t* In, RGBA* Out); + void ProcessPixels(const RGBA* In, std::uint8_t* Out); + + public: + explicit Image(const char* FilePath); + explicit Image(int Width, int Height); + explicit Image(RGBA* Ptr, int Width, int Height); + ~Image(); + +#if defined _WIN32 || defined _WIN64 + explicit Image(HDC DC, int X, int Y, int Width, int Height); + explicit Image(HWND Window, int X, int Y, int Width, int Height); + void Draw(HWND Hwnd, int X, int Y, int Width, int Height, int SourceX, int SourceY, DWORD RasterType); + void Draw(HDC hDC, int X, int Y, int Width, int Height, int SourceX, int SourceY, DWORD RasterType); +#endif + + void Save(const char* FilePath); + + inline std::uint16_t Bpp() + { + return BitsPerPixel; + } + + inline int Width() const + { + return width; + } + + inline int Height() const + { + return height; + } + + inline RGBA* GetPixels() + { + return Pixels; + } + + inline RGBA GetPixel(int X, int Y) const + { + return Pixels[Y * width + X]; + } + + inline void SetPixel(int X, int Y, std::uint32_t Color) + { + Pixels[Y * width + X].Colour = Color; + } + }; +} + +#endif // IMAGES_HPP_INCLUDED diff --git a/d3d9/SMARTPlugin.hpp b/d3d9/SMARTPlugin.hpp new file mode 100644 index 0000000..ada09b9 --- /dev/null +++ b/d3d9/SMARTPlugin.hpp @@ -0,0 +1,53 @@ +/** © 2013, Brandon T. All Rights Reserved. + * + * This file is part of the DXI Library. + * DXI is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * DXI is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with DXI. If not, see . + */ + +#ifndef _SMART_PLUGIN +#define _SMART_PLUGIN + +#include +#include +#include "Graphics.hpp" + +typedef void (*_SMARTGetMousePos)(int &x, int &y); +typedef void (*_SMARTSetCapture)(bool enabled); +typedef void (*_SMARTButtonPressed)(int id, bool state); + +typedef struct +{ + int version; + void *img, *dbg; + int width, height; + _SMARTGetMousePos getMousePos; + _SMARTSetCapture setCapture; +} SMARTInfo; + + + +typedef void (*_SMARTPluginInit)(SMARTInfo* ptr, bool* ReplaceButtons, int* ButtonCount, char*** ButtonText, int** ButtonIDs, _SMARTButtonPressed* ButtonCallback); + +extern ID3DXSprite* Sprite; +extern IDirect3DTexture9* Texture; +extern unsigned char* TexturePixels; +extern SMARTInfo* SmartGlobal; +extern bool SmartDebugEnabled; +extern bool SmartDirectXEnabled; +void BltSmartBuffer(IDirect3DDevice9* Device); +void FlipImageBytes(void* In, void* &Out, int width, int height, unsigned int Bpp = 32); +HRESULT dxReadPixels(IDirect3DDevice9* Device, void* Buffer, HDC &DC, int &Width, int &Height, D3DFORMAT Format = D3DFMT_UNKNOWN); +void DrawCircle(IDirect3DDevice9* Device, float mx, float my, float r, D3DCOLOR color = D3DCOLOR_XRGB(255, 0, 0)); + +#endif diff --git a/d3d9/SharedMemory.cpp b/d3d9/SharedMemory.cpp new file mode 100644 index 0000000..54a3aac --- /dev/null +++ b/d3d9/SharedMemory.cpp @@ -0,0 +1,238 @@ +/** © 2013, Brandon T. All Rights Reserved. + * + * This file is part of the DXI Library. + * DXI is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * DXI is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with DXI. If not, see . + */ + +#include "SharedMemory.hpp" + +SharedMemory::SharedMemory(std::string MapName) : hFileMap(nullptr), pData(nullptr), MapName(MapName), Size(0), Debug(false), Events() {} +SharedMemory::SharedMemory(std::string MapName, std::size_t Size) : hFileMap(nullptr), pData(nullptr), MapName(MapName), Size(Size), Debug(false), Events() {} +SharedMemory::~SharedMemory() +{ + ReleaseMemory(); + DeleteAllEvents(); +} + +void* SharedMemory::GetDataPointer() +{ + void* Ptr = pData; + return Ptr; +} + +bool SharedMemory::OpenMemoryMap(std::size_t Size) +{ + this->Size = Size; + + #if defined _WIN32 || defined _WIN64 + if ((hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, false, MapName.c_str())) == nullptr) + { + if (Debug) std::cout << _T("\nCould Not Open Shared Memory Map.\n"); + return false; + } + + if ((pData = MapViewOfFile(hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, Size)) == nullptr) + { + if (Debug) std::cout << _T("\nCould Not Map View Of File.\n"); + CloseHandle(hFileMap); + return false; + } + + #else + + if ((hFileMap = open(MapName.c_str(), O_RDWR | O_CREAT, 438)) == -1) + { + if (Debug) std::cout << _T("\nCould Not Open Shared Memory Map.\n"); + return false; + } + + if ((pData = mmap(nullptr, Size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, hFileMap, 0)) == MAP_FAILED) + { + if (Debug) std::cout << _T("\nCould Not Map View Of File.\n"); + close(hFileMap); + return false; + } + #endif + + if (Debug) std::cout << _T("\nInter-Process Communication Successful.\n"); + return true; +} + +bool SharedMemory::MapMemory(std::size_t Size) +{ + this->Size = Size; + + #if defined _WIN32 || defined _WIN64 + if ((hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, Size, MapName.c_str())) == nullptr) + { + if (Debug) std::cout << _T("\nCould Not Create Shared Memory Map.\n"); + return false; + } + + if ((pData = MapViewOfFile(hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, Size)) == nullptr) + { + if (Debug) std::cout << _T("\nCould Not Map View Of File.\n"); + CloseHandle(hFileMap); + return false; + } + + #else + + if ((hFileMap = open(MapName.c_str(), O_RDWR | O_CREAT, 438)) == -1) + { + if (Debug) std::cout << _T("\nCould Not Create Shared Memory Map.\n"); + return false; + } + + if ((pData = mmap(nullptr, Size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, hFileMap, 0)) == MAP_FAILED) + { + if (Debug) std::cout << _T("\nCould Not Map View Of File.\n"); + close(hFileMap); + return false; + } + #endif + + if (Debug) std::cout << _T("\nMapped Shared Memory Successfully.\n"); + return true; +} + +bool SharedMemory::ReleaseMemory() +{ + bool Result = false; + #if defined _WIN32 || defined _WIN64 + if (pData) + { + Result = UnmapViewOfFile(pData); + pData = nullptr; + if (Result && Debug) + { + std::cout << _T("\nMemory Un-Mapped Successfully.\n"); + } + } + + if (hFileMap) + { + if (CloseHandle(hFileMap)) + { + hFileMap = nullptr; + Result = Result && true; + if (Debug) std::cout << _T("\nMemory Map Closed Successfully.\n"); + } + } + + #else + + if (pData) + { + Result = munmap(pData, Size); + if (!Result && Debug) + { + std::cout << _T("\nMemory Un-Mapped Successfully.\n"); + } + pData = nullptr; + return true; + } + + if (hFileMap) + { + if (!close(hFileMap)) + { + hFileMap = nullptr; + if (Debug) std::cout << _T("\nMemory Map Closed Successfully.\n"); + } + } + #endif + return Result; +} + +bool SharedMemory::CreateNewEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, bool bManualReset, bool bInitialState, std::string EventName) +{ + std::map::iterator it = Events.find(EventName); + if (it != Events.end()) + { + if (Debug) + { + std::cout << _T("\nCreateNewEvent Error: An Event With That Key Already Exists!\n"); + } + return false; + } + + Events.insert(std::pair(EventName, CreateEvent(lpEventAttributes, bManualReset, bInitialState, EventName.c_str()))); + it = Events.end(); + return ((--it)->second != nullptr); +} + +std::uint32_t SharedMemory::OpenSingleEvent(std::string EventName, bool InheritHandle, bool SaveHandle, std::uint32_t dwDesiredAccess, std::uint32_t dwMilliseconds) +{ + void* hEvent = OpenEvent(dwDesiredAccess, InheritHandle, EventName.c_str()); + if (hEvent) + { + if (SaveHandle) + { + std::map::iterator it = Events.find(EventName); + if (it != Events.end()) + { + CloseHandle(it->second); + it->second = hEvent; + } + else + Events.insert(std::pair(EventName, hEvent)); + } + std::uint32_t Result = WaitForSingleObject(hEvent, dwMilliseconds); + if (!SaveHandle) CloseHandle(hEvent); + return Result; + } + CloseHandle(hEvent); + return WAIT_FAILED; +} + +bool SharedMemory::SetEventSignal(std::string EventName, bool Signaled) +{ + std::map::iterator it = Events.find(EventName); + if (it == Events.end()) + { + if (Debug) + { + std::cout << _T("\nSetEventSignal Error: No Event With That Key Exists!\n"); + } + return false; + } + if (Signaled) return SetEvent(it->second); + return ResetEvent(it->second); +} + +bool SharedMemory::DeleteSingleEvent(std::string EventName) +{ + std::map::iterator it = Events.find(EventName); + if (it == Events.end()) return true; + bool Result = CloseHandle(it->second); + Events.erase(it); + return Result; +} + +bool SharedMemory::DeleteAllEvents() +{ + bool Result = false; + for (std::map::iterator it = Events.begin(); it != Events.end(); ++it) + { + Result = Result && CloseHandle(it->second); + } + Events.clear(); + return Result; +} + +void SharedMemory::SetDebug(bool On) +{ + Debug = On; +} diff --git a/d3d9/SharedMemory.hpp b/d3d9/SharedMemory.hpp new file mode 100644 index 0000000..e0ef3be --- /dev/null +++ b/d3d9/SharedMemory.hpp @@ -0,0 +1,77 @@ +/** © 2013, Brandon T. All Rights Reserved. + * + * This file is part of the DXI Library. + * DXI is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * DXI is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with DXI. If not, see . + */ + +#ifndef SHAREDMEMORY_HPP_INCLUDED +#define SHAREDMEMORY_HPP_INCLUDED + +#if defined _WIN32 || defined _WIN64 + #include +#else + #include + #include + #include + #include + #include +#endif + +#include +#include +#include + +class SharedMemory +{ + private: + void* FromFile; + void* hFileMap; + void* pData; + std::string MapName; + std::size_t Size; + bool Debug; + std::map Events; + + public: + SharedMemory(std::string MapName); + SharedMemory(std::string MapName, std::size_t Size); + ~SharedMemory(); + + SharedMemory(const SharedMemory& Shm) = delete; + SharedMemory(SharedMemory && Shm) = delete; + SharedMemory& operator = (const SharedMemory& Shm) = delete; + SharedMemory& operator = (SharedMemory && Shm) = delete; + + void* GetDataPointer(); + + bool OpenMemoryMap(std::size_t Size); + + bool MapMemory(std::size_t Size); + + bool ReleaseMemory(); + + bool CreateNewEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, bool bManualReset, bool bInitialState, std::string EventName); + + std::uint32_t OpenSingleEvent(std::string EventName, bool InheritHandle, bool SaveHandle = false, std::uint32_t dwDesiredAccess = EVENT_ALL_ACCESS, std::uint32_t dwMilliseconds = INFINITE); + + bool SetEventSignal(std::string EventName, bool Signaled); + + bool DeleteSingleEvent(std::string EventName); + + bool DeleteAllEvents(); + + void SetDebug(bool On); +}; + +#endif // SHAREDMEMORY_HPP_INCLUDED diff --git a/d3d9/SmartJNI.cpp b/d3d9/SmartJNI.cpp new file mode 100644 index 0000000..74f461c --- /dev/null +++ b/d3d9/SmartJNI.cpp @@ -0,0 +1,220 @@ +/** © 2013, Brandon T. All Rights Reserved. + * + * This file is part of the DXI Library. + * DXI is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * DXI is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with DXI. If not, see . + */ + +#include "SmartPlugin.hpp" +#include + +ID3DXSprite* Sprite = nullptr; +IDirect3DTexture9* Texture = nullptr; +unsigned char* TexturePixels = nullptr; +SMARTInfo* SmartGlobal = nullptr; +bool SmartDebugEnabled = false; +bool SmartDirectXEnabled = true; + +void SMARTButtonPressed(int ID, bool State) +{ + switch(ID) + { + case 100: + if (State) + { + SmartGlobal->setCapture(false); + SmartDirectXEnabled = true; + } + else + { + SmartGlobal->setCapture(true); + SmartDirectXEnabled = false; + } + break; + + case 101: + SmartDebugEnabled = State ? false : true; + break; + + } +} + +extern "C" void SMARTPluginInit(SMARTInfo* ptr, bool* ReplaceButtons, int* ButtonCount, char** * ButtonText, int** ButtonIDs, _SMARTButtonPressed* ButtonCallback) +{ + SmartGlobal = ptr; + if (ptr) + { + *ReplaceButtons = true; + char** ButtonTexts = new char* [2]; + ButtonTexts[0] = const_cast("Disable Direct-X_Enable Direct-X"); + ButtonTexts[1] = const_cast("Enable Debug_Disable Debug"); + + int* IDs = new int[2]; + IDs[0] = 100; + IDs[1] = 101; + + *ButtonCount = 2; + *ButtonText = ButtonTexts; + *ButtonIDs = IDs; + *ButtonCallback = &SMARTButtonPressed; + } +} + +void LoadTexture(IDirect3DDevice9* Device, unsigned char* buffer, int width, int height, IDirect3DTexture9*& Texture, ID3DXSprite*& Sprite) +{ + Device->CreateTexture(width, height, 1, 0, /*D3DFMT_X8R8G8B8*/D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &Texture, 0); + D3DXCreateSprite(Device, &Sprite); + + D3DLOCKED_RECT rect; + Texture->LockRect(0, &rect, nullptr, D3DLOCK_DISCARD); + TexturePixels = static_cast(rect.pBits); + Texture->UnlockRect(0); + + memcpy(TexturePixels, &buffer[0], width * height * 4); +} + +void LoadTexture(IDirect3DDevice9* Device, const char* FilePath, IDirect3DTexture9*& Texture, ID3DXSprite*& Sprite) +{ + D3DXCreateTextureFromFileEx(Device, FilePath, + D3DX_DEFAULT_NONPOW2, //width + D3DX_DEFAULT_NONPOW2, //height + 1, //mip map levels + 0, //usage + D3DFMT_FROM_FILE, //D3DFMT_X8B8G8R8, //format + D3DPOOL_MANAGED,//D3DPOOL_DEFAULT,//D3DPOOL_MANAGED, //pool + D3DX_DEFAULT, + D3DX_DEFAULT, + 0xFF000000, //alpha is FF + nullptr, //D3DXIMAGE_INFO* + nullptr, + &Texture); + D3DXCreateSprite(Device, &Sprite); +} + +void DrawTextureSprite(IDirect3DDevice9* Device, IDirect3DTexture9* Texture, ID3DXSprite* Sprite) +{ + if (Sprite && Texture) + { + /*D3DXMATRIX world = {0}, rotation = {0}, scale = {0}, translation = {0}; + D3DXMatrixIdentity(&world); + + D3DXMatrixScaling(&scale, 1.0f, 1.0f, 1.0f); + D3DXMatrixRotationYawPitchRoll(&rotation, 0.0f, 0.0f, 0.0f); + D3DXMatrixTranslation(&translation, 0.0f, 0.0f, 0.0f); + world = rotation * scale * translation; + + Sprite->SetTransform(&world);*/ + + /*Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); + Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); + Device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);*/ + + //Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + //Device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD); + + D3DXVECTOR3 Position = D3DXVECTOR3(0, 0, 0); + Sprite->Begin(D3DXSPRITE_ALPHABLEND); + Sprite->Draw(Texture, nullptr, nullptr, &Position, D3DCOLOR_RGBA(0xFF, 0xFF, 0xFF, 0xFF)); //0xFFFFFFFF - white.. + Sprite->End(); + } +} + +void BltSmartBuffer(IDirect3DDevice9* Device) +{ + if (SmartGlobal != nullptr) + { + std::uint8_t* Ptr = reinterpret_cast(SmartGlobal->dbg); + for (int I = 0; I < SmartGlobal->height; ++I) + { + for (int J = 0; J < SmartGlobal->width; ++J) + { + std::uint8_t B = *(Ptr++); + std::uint8_t G = *(Ptr++); + std::uint8_t R = *(Ptr++); + *(Ptr++) = (B == 0 && G == 0 && R == 0) ? 0 : 0xFF; + } + } + + if (!Texture) + { + LoadTexture(Device, static_cast(SmartGlobal->dbg), SmartGlobal->width, SmartGlobal->height, Texture, Sprite); + } + else + { + memcpy(TexturePixels, SmartGlobal->dbg, SmartGlobal->width * SmartGlobal->height * 4); + } + + DrawTextureSprite(Device, Texture, Sprite); + SafeRelease(Texture); + SafeRelease(Sprite); + } +} + +HRESULT dxReadPixels(IDirect3DDevice9* Device, void* Buffer, HDC& DC, int& Width, int& Height, D3DFORMAT Format) +{ + IDirect3DSurface9* RenderTarget = nullptr; + IDirect3DSurface9* DestTarget = nullptr; + HRESULT result = Device->GetRenderTarget(0, &RenderTarget); + + if (result == S_OK) + { + if (Width == 0 || Height == 0 || Format == D3DFMT_UNKNOWN) + { + D3DSURFACE_DESC descriptor = {}; + RenderTarget->GetDesc(&descriptor); + Width = descriptor.Width; + Height = descriptor.Height; + Format = descriptor.Format; + } + + RenderTarget->GetDC(&DC); + result = Device->CreateOffscreenPlainSurface(Width, Height, Format, D3DPOOL_SYSTEMMEM, &DestTarget, nullptr); + result = Device->GetRenderTargetData(RenderTarget, DestTarget); + + D3DLOCKED_RECT rect; + DestTarget->LockRect(&rect, 0, D3DLOCK_READONLY); + memcpy(Buffer, rect.pBits, Width * Height * 4); + DestTarget->UnlockRect(); + } + + SafeRelease(RenderTarget); + SafeRelease(DestTarget); + return result; +} + +struct VERTEX_2D_DIF +{ + float x, y, z, rhw; + D3DCOLOR color; + static const DWORD FVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE; +}; + +void DrawCircle(IDirect3DDevice9* Device, float mx, float my, float r, D3DCOLOR color) +{ + static const int CIRCLE_RESOLUTION = 50; + + VERTEX_2D_DIF verts[CIRCLE_RESOLUTION + 1]; + + for (int i = 0; i < CIRCLE_RESOLUTION + 1; ++i) + { + verts[i].x = mx + r * cos(D3DX_PI * (i / (CIRCLE_RESOLUTION / 2.0f))); + verts[i].y = my + r * sin(D3DX_PI * (i / (CIRCLE_RESOLUTION / 2.0f))); + verts[i].z = 0; + verts[i].rhw = 1; + verts[i].color = color; + } + + Device->SetFVF(VERTEX_2D_DIF::FVF); + Device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, CIRCLE_RESOLUTION-1, &verts, sizeof(VERTEX_2D_DIF)); +} diff --git a/d3d9/d3d9.cbp b/d3d9/d3d9.cbp new file mode 100644 index 0000000..a868d43 --- /dev/null +++ b/d3d9/d3d9.cbp @@ -0,0 +1,83 @@ + + + + + + diff --git a/d3d9/d3d9.depend b/d3d9/d3d9.depend new file mode 100644 index 0000000..620e2ae --- /dev/null +++ b/d3d9/d3d9.depend @@ -0,0 +1,244 @@ +# depslib dependency file v1.0 +1382646564 source:c:\users\brandon\desktop\glx\d3d9\main.cpp + "Hooks/Exports.hpp" + +1387416012 c:\users\brandon\desktop\glx\d3d9\hooks\exports.hpp + + + "Library.hpp" + "IDirect3D9Proxy.hpp" + +1382650830 c:\users\brandon\desktop\glx\d3d9\hooks\library.hpp + + + + + +1387393415 c:\users\brandon\desktop\glx\d3d9\hooks\idirect3d9proxy.hpp + + "Direct3DDevice9Proxy.hpp" + +1387433169 c:\users\brandon\desktop\glx\d3d9\hooks\direct3ddevice9proxy.hpp + + +1387505582 source:c:\users\brandon\desktop\glx\d3d9\hooks\direct3ddevice9proxy.cpp + "Direct3DDevice9Proxy.hpp" + "../Graphics.hpp" + "../BaseForm.hpp" + + + +1387415998 source:c:\users\brandon\desktop\glx\d3d9\hooks\exports.cpp + "Exports.hpp" + +1387400262 source:c:\users\brandon\desktop\glx\d3d9\hooks\idirect3d9proxy.cpp + "IDirect3D9Proxy.hpp" + +1382646543 source:c:\users\brandon\desktop\glx\d3d9\hooks\library.cpp + "Library.hpp" + +1387505446 source:c:\users\brandon\desktop\glx\d3d9\images.cpp + "Images.hpp" + +1387505562 c:\users\brandon\desktop\glx\d3d9\images.hpp + + + + + + + +1387502790 source:c:\users\brandon\desktop\glx\d3d9\graphics.cpp + "Graphics.hpp" + +1387502775 c:\users\brandon\desktop\glx\d3d9\graphics.hpp + + + + + "Images.hpp" + +1387504871 c:\users\brandon\desktop\glx\d3d9\baseform.hpp + + + +1388751552 source:c:\users\brandon\desktop\d3d9\hooks\exports.cpp + "Exports.hpp" + +1388751552 c:\users\brandon\desktop\d3d9\hooks\exports.hpp + + + "Library.hpp" + "IDirect3D9Proxy.hpp" + +1388751552 c:\users\brandon\desktop\d3d9\hooks\library.hpp + + + + + +1388751552 c:\users\brandon\desktop\d3d9\hooks\idirect3d9proxy.hpp + + "Direct3DDevice9Proxy.hpp" + +1388751552 c:\users\brandon\desktop\d3d9\hooks\direct3ddevice9proxy.hpp + + +1388751552 source:c:\users\brandon\desktop\d3d9\hooks\idirect3d9proxy.cpp + "IDirect3D9Proxy.hpp" + +1388751552 source:c:\users\brandon\desktop\d3d9\hooks\library.cpp + "Library.hpp" + +1387505446 source:c:\users\brandon\desktop\d3d9\images.cpp + "Images.hpp" + +1388751551 c:\users\brandon\desktop\d3d9\images.hpp + + + + + + + +1388753442 source:c:\users\brandon\desktop\d3d9\main.cpp + "Hooks/Exports.hpp" + +1388751551 source:c:\users\brandon\desktop\d3d9\graphics.cpp + "Graphics.hpp" + +1388751551 c:\users\brandon\desktop\d3d9\graphics.hpp + + + + + "Images.hpp" + +1388753479 source:c:\users\brandon\desktop\d3d9\hooks\direct3ddevice9proxy.cpp + "Direct3DDevice9Proxy.hpp" + "../Graphics.hpp" + "../SMARTPlugin.hpp" + "Hooks.hpp" + + +1388751551 source:c:\users\brandon\desktop\d3d9\sharedmemory.cpp + "SharedMemory.hpp" + +1388751551 c:\users\brandon\desktop\d3d9\sharedmemory.hpp + + + + + + + + + + +1388751551 source:c:\users\brandon\desktop\d3d9\smartjni.cpp + "SmartPlugin.hpp" + + +1388751551 c:\users\brandon\desktop\d3d9\smartplugin.hpp + + + +1388753879 source:c:\users\brandon\desktop\d3d9\hooks\hooks.cpp + "Hooks.hpp" + +1388751552 c:\users\brandon\desktop\d3d9\hooks\hooks.hpp + + + + "Exports.hpp" + "../SharedMemory.hpp" + "../SMARTPlugin.hpp" + +1390040825 source:c:\users\school\desktop\direct-x\d3d9\graphics.cpp + "Graphics.hpp" + +1390040825 c:\users\school\desktop\direct-x\d3d9\graphics.hpp + + + + + "Images.hpp" + +1390040825 c:\users\school\desktop\direct-x\d3d9\images.hpp + + + + + + + +1390554438 source:c:\users\school\desktop\direct-x\d3d9\hooks\direct3ddevice9proxy.cpp + "Direct3DDevice9Proxy.hpp" + +1390524285 c:\users\school\desktop\direct-x\d3d9\hooks\direct3ddevice9proxy.hpp + + "../Graphics.hpp" + "../SMARTPlugin.hpp" + +1390561458 c:\users\school\desktop\direct-x\d3d9\smartplugin.hpp + + + "Graphics.hpp" + +1390524628 c:\users\school\desktop\direct-x\d3d9\hooks\hooks.hpp + + + + "Exports.hpp" + "../SharedMemory.hpp" + "../SMARTPlugin.hpp" + +1390524508 c:\users\school\desktop\direct-x\d3d9\hooks\exports.hpp + + + "Library.hpp" + "IDirect3D9Proxy.hpp" + +1390040826 c:\users\school\desktop\direct-x\d3d9\hooks\library.hpp + + + + + +1390040826 c:\users\school\desktop\direct-x\d3d9\hooks\idirect3d9proxy.hpp + + "Direct3DDevice9Proxy.hpp" + +1390040825 c:\users\school\desktop\direct-x\d3d9\sharedmemory.hpp + + + + + + + + + + +1390040826 source:c:\users\school\desktop\direct-x\d3d9\hooks\exports.cpp + "Exports.hpp" + +1390040826 source:c:\users\school\desktop\direct-x\d3d9\hooks\hooks.cpp + "Hooks.hpp" + +1390040826 source:c:\users\school\desktop\direct-x\d3d9\hooks\idirect3d9proxy.cpp + "IDirect3D9Proxy.hpp" + +1390040826 source:c:\users\school\desktop\direct-x\d3d9\hooks\library.cpp + "Library.hpp" + +1390040825 source:c:\users\school\desktop\direct-x\d3d9\sharedmemory.cpp + "SharedMemory.hpp" + +1390561464 source:c:\users\school\desktop\direct-x\d3d9\smartjni.cpp + "SmartPlugin.hpp" + + +1390554680 source:c:\users\school\desktop\direct-x\d3d9\main.cpp + "Hooks/Exports.hpp" + diff --git a/d3d9/d3d9.layout b/d3d9/d3d9.layout new file mode 100644 index 0000000..e40fdfe --- /dev/null +++ b/d3d9/d3d9.layout @@ -0,0 +1,84 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d3d9/jni.h b/d3d9/jni.h new file mode 100644 index 0000000..ab9a693 --- /dev/null +++ b/d3d9/jni.h @@ -0,0 +1,1959 @@ +/* + * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. + * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ + +/* + * We used part of Netscape's Java Runtime Interface (JRI) as the starting + * point of our design and implementation. + */ + +/****************************************************************************** + * Java Runtime Interface + * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved. + *****************************************************************************/ + +#ifndef _JAVASOFT_JNI_H_ +#define _JAVASOFT_JNI_H_ + +#include +#include + +/* jni_md.h contains the machine-dependent typedefs for jbyte, jint + and jlong */ + +#include "jni_md.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * JNI Types + */ + +#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H + +typedef unsigned char jboolean; +typedef unsigned short jchar; +typedef short jshort; +typedef float jfloat; +typedef double jdouble; + +typedef jint jsize; + +#ifdef __cplusplus + +class _jobject {}; +class _jclass : public _jobject {}; +class _jthrowable : public _jobject {}; +class _jstring : public _jobject {}; +class _jarray : public _jobject {}; +class _jbooleanArray : public _jarray {}; +class _jbyteArray : public _jarray {}; +class _jcharArray : public _jarray {}; +class _jshortArray : public _jarray {}; +class _jintArray : public _jarray {}; +class _jlongArray : public _jarray {}; +class _jfloatArray : public _jarray {}; +class _jdoubleArray : public _jarray {}; +class _jobjectArray : public _jarray {}; + +typedef _jobject *jobject; +typedef _jclass *jclass; +typedef _jthrowable *jthrowable; +typedef _jstring *jstring; +typedef _jarray *jarray; +typedef _jbooleanArray *jbooleanArray; +typedef _jbyteArray *jbyteArray; +typedef _jcharArray *jcharArray; +typedef _jshortArray *jshortArray; +typedef _jintArray *jintArray; +typedef _jlongArray *jlongArray; +typedef _jfloatArray *jfloatArray; +typedef _jdoubleArray *jdoubleArray; +typedef _jobjectArray *jobjectArray; + +#else + +struct _jobject; + +typedef struct _jobject *jobject; +typedef jobject jclass; +typedef jobject jthrowable; +typedef jobject jstring; +typedef jobject jarray; +typedef jarray jbooleanArray; +typedef jarray jbyteArray; +typedef jarray jcharArray; +typedef jarray jshortArray; +typedef jarray jintArray; +typedef jarray jlongArray; +typedef jarray jfloatArray; +typedef jarray jdoubleArray; +typedef jarray jobjectArray; + +#endif + +typedef jobject jweak; + +typedef union jvalue { + jboolean z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong j; + jfloat f; + jdouble d; + jobject l; +} jvalue; + +struct _jfieldID; +typedef struct _jfieldID *jfieldID; + +struct _jmethodID; +typedef struct _jmethodID *jmethodID; + +/* Return values from jobjectRefType */ +typedef enum _jobjectType { + JNIInvalidRefType = 0, + JNILocalRefType = 1, + JNIGlobalRefType = 2, + JNIWeakGlobalRefType = 3 +} jobjectRefType; + + +#endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */ + +/* + * jboolean constants + */ + +#define JNI_FALSE 0 +#define JNI_TRUE 1 + +/* + * possible return values for JNI functions. + */ + +#define JNI_OK 0 /* success */ +#define JNI_ERR (-1) /* unknown error */ +#define JNI_EDETACHED (-2) /* thread detached from the VM */ +#define JNI_EVERSION (-3) /* JNI version error */ +#define JNI_ENOMEM (-4) /* not enough memory */ +#define JNI_EEXIST (-5) /* VM already created */ +#define JNI_EINVAL (-6) /* invalid arguments */ + +/* + * used in ReleaseScalarArrayElements + */ + +#define JNI_COMMIT 1 +#define JNI_ABORT 2 + +/* + * used in RegisterNatives to describe native method name, signature, + * and function pointer. + */ + +typedef struct { + char *name; + char *signature; + void *fnPtr; +} JNINativeMethod; + +/* + * JNI Native Method Interface. + */ + +struct JNINativeInterface_; + +struct JNIEnv_; + +#ifdef __cplusplus +typedef JNIEnv_ JNIEnv; +#else +typedef const struct JNINativeInterface_ *JNIEnv; +#endif + +/* + * JNI Invocation Interface. + */ + +struct JNIInvokeInterface_; + +struct JavaVM_; + +#ifdef __cplusplus +typedef JavaVM_ JavaVM; +#else +typedef const struct JNIInvokeInterface_ *JavaVM; +#endif + +struct JNINativeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + void *reserved3; + jint (JNICALL *GetVersion)(JNIEnv *env); + + jclass (JNICALL *DefineClass) + (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, + jsize len); + jclass (JNICALL *FindClass) + (JNIEnv *env, const char *name); + + jmethodID (JNICALL *FromReflectedMethod) + (JNIEnv *env, jobject method); + jfieldID (JNICALL *FromReflectedField) + (JNIEnv *env, jobject field); + + jobject (JNICALL *ToReflectedMethod) + (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic); + + jclass (JNICALL *GetSuperclass) + (JNIEnv *env, jclass sub); + jboolean (JNICALL *IsAssignableFrom) + (JNIEnv *env, jclass sub, jclass sup); + + jobject (JNICALL *ToReflectedField) + (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic); + + jint (JNICALL *Throw) + (JNIEnv *env, jthrowable obj); + jint (JNICALL *ThrowNew) + (JNIEnv *env, jclass clazz, const char *msg); + jthrowable (JNICALL *ExceptionOccurred) + (JNIEnv *env); + void (JNICALL *ExceptionDescribe) + (JNIEnv *env); + void (JNICALL *ExceptionClear) + (JNIEnv *env); + void (JNICALL *FatalError) + (JNIEnv *env, const char *msg); + + jint (JNICALL *PushLocalFrame) + (JNIEnv *env, jint capacity); + jobject (JNICALL *PopLocalFrame) + (JNIEnv *env, jobject result); + + jobject (JNICALL *NewGlobalRef) + (JNIEnv *env, jobject lobj); + void (JNICALL *DeleteGlobalRef) + (JNIEnv *env, jobject gref); + void (JNICALL *DeleteLocalRef) + (JNIEnv *env, jobject obj); + jboolean (JNICALL *IsSameObject) + (JNIEnv *env, jobject obj1, jobject obj2); + jobject (JNICALL *NewLocalRef) + (JNIEnv *env, jobject ref); + jint (JNICALL *EnsureLocalCapacity) + (JNIEnv *env, jint capacity); + + jobject (JNICALL *AllocObject) + (JNIEnv *env, jclass clazz); + jobject (JNICALL *NewObject) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *NewObjectV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *NewObjectA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jclass (JNICALL *GetObjectClass) + (JNIEnv *env, jobject obj); + jboolean (JNICALL *IsInstanceOf) + (JNIEnv *env, jobject obj, jclass clazz); + + jmethodID (JNICALL *GetMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallObjectMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jobject (JNICALL *CallObjectMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jobject (JNICALL *CallObjectMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); + + jboolean (JNICALL *CallBooleanMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jboolean (JNICALL *CallBooleanMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jboolean (JNICALL *CallBooleanMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); + + jbyte (JNICALL *CallByteMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jbyte (JNICALL *CallByteMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jbyte (JNICALL *CallByteMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + jchar (JNICALL *CallCharMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jchar (JNICALL *CallCharMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jchar (JNICALL *CallCharMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + jshort (JNICALL *CallShortMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jshort (JNICALL *CallShortMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jshort (JNICALL *CallShortMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + jint (JNICALL *CallIntMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jint (JNICALL *CallIntMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jint (JNICALL *CallIntMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + jlong (JNICALL *CallLongMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jlong (JNICALL *CallLongMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jlong (JNICALL *CallLongMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + jfloat (JNICALL *CallFloatMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jfloat (JNICALL *CallFloatMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jfloat (JNICALL *CallFloatMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + jdouble (JNICALL *CallDoubleMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jdouble (JNICALL *CallDoubleMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jdouble (JNICALL *CallDoubleMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); + + void (JNICALL *CallVoidMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + void (JNICALL *CallVoidMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + void (JNICALL *CallVoidMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); + + jobject (JNICALL *CallNonvirtualObjectMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallNonvirtualObjectMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jobject (JNICALL *CallNonvirtualObjectMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue * args); + + jboolean (JNICALL *CallNonvirtualBooleanMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallNonvirtualBooleanMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jboolean (JNICALL *CallNonvirtualBooleanMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue * args); + + jbyte (JNICALL *CallNonvirtualByteMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallNonvirtualByteMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jbyte (JNICALL *CallNonvirtualByteMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jchar (JNICALL *CallNonvirtualCharMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallNonvirtualCharMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jchar (JNICALL *CallNonvirtualCharMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jshort (JNICALL *CallNonvirtualShortMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallNonvirtualShortMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jshort (JNICALL *CallNonvirtualShortMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jint (JNICALL *CallNonvirtualIntMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallNonvirtualIntMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jint (JNICALL *CallNonvirtualIntMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jlong (JNICALL *CallNonvirtualLongMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallNonvirtualLongMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jlong (JNICALL *CallNonvirtualLongMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jfloat (JNICALL *CallNonvirtualFloatMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallNonvirtualFloatMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jfloat (JNICALL *CallNonvirtualFloatMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jdouble (JNICALL *CallNonvirtualDoubleMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallNonvirtualDoubleMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jdouble (JNICALL *CallNonvirtualDoubleMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + void (JNICALL *CallNonvirtualVoidMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + void (JNICALL *CallNonvirtualVoidMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + void (JNICALL *CallNonvirtualVoidMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue * args); + + jfieldID (JNICALL *GetFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *GetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jboolean (JNICALL *GetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jbyte (JNICALL *GetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jchar (JNICALL *GetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jshort (JNICALL *GetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jint (JNICALL *GetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jlong (JNICALL *GetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jfloat (JNICALL *GetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jdouble (JNICALL *GetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + + void (JNICALL *SetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val); + void (JNICALL *SetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val); + void (JNICALL *SetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val); + void (JNICALL *SetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val); + void (JNICALL *SetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val); + void (JNICALL *SetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jint val); + void (JNICALL *SetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val); + void (JNICALL *SetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val); + void (JNICALL *SetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val); + + jmethodID (JNICALL *GetStaticMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallStaticObjectMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallStaticObjectMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *CallStaticObjectMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jboolean (JNICALL *CallStaticBooleanMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallStaticBooleanMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jboolean (JNICALL *CallStaticBooleanMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jbyte (JNICALL *CallStaticByteMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallStaticByteMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jbyte (JNICALL *CallStaticByteMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jchar (JNICALL *CallStaticCharMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallStaticCharMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jchar (JNICALL *CallStaticCharMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jshort (JNICALL *CallStaticShortMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallStaticShortMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jshort (JNICALL *CallStaticShortMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jint (JNICALL *CallStaticIntMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallStaticIntMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jint (JNICALL *CallStaticIntMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jlong (JNICALL *CallStaticLongMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallStaticLongMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jlong (JNICALL *CallStaticLongMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jfloat (JNICALL *CallStaticFloatMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallStaticFloatMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jfloat (JNICALL *CallStaticFloatMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jdouble (JNICALL *CallStaticDoubleMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallStaticDoubleMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jdouble (JNICALL *CallStaticDoubleMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + void (JNICALL *CallStaticVoidMethod) + (JNIEnv *env, jclass cls, jmethodID methodID, ...); + void (JNICALL *CallStaticVoidMethodV) + (JNIEnv *env, jclass cls, jmethodID methodID, va_list args); + void (JNICALL *CallStaticVoidMethodA) + (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args); + + jfieldID (JNICALL *GetStaticFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + jobject (JNICALL *GetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jboolean (JNICALL *GetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jbyte (JNICALL *GetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jchar (JNICALL *GetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jshort (JNICALL *GetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jint (JNICALL *GetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jlong (JNICALL *GetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jfloat (JNICALL *GetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jdouble (JNICALL *GetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + + void (JNICALL *SetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value); + void (JNICALL *SetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value); + void (JNICALL *SetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value); + void (JNICALL *SetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value); + void (JNICALL *SetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value); + void (JNICALL *SetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value); + void (JNICALL *SetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value); + void (JNICALL *SetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value); + void (JNICALL *SetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value); + + jstring (JNICALL *NewString) + (JNIEnv *env, const jchar *unicode, jsize len); + jsize (JNICALL *GetStringLength) + (JNIEnv *env, jstring str); + const jchar *(JNICALL *GetStringChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringChars) + (JNIEnv *env, jstring str, const jchar *chars); + + jstring (JNICALL *NewStringUTF) + (JNIEnv *env, const char *utf); + jsize (JNICALL *GetStringUTFLength) + (JNIEnv *env, jstring str); + const char* (JNICALL *GetStringUTFChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringUTFChars) + (JNIEnv *env, jstring str, const char* chars); + + + jsize (JNICALL *GetArrayLength) + (JNIEnv *env, jarray array); + + jobjectArray (JNICALL *NewObjectArray) + (JNIEnv *env, jsize len, jclass clazz, jobject init); + jobject (JNICALL *GetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index); + void (JNICALL *SetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index, jobject val); + + jbooleanArray (JNICALL *NewBooleanArray) + (JNIEnv *env, jsize len); + jbyteArray (JNICALL *NewByteArray) + (JNIEnv *env, jsize len); + jcharArray (JNICALL *NewCharArray) + (JNIEnv *env, jsize len); + jshortArray (JNICALL *NewShortArray) + (JNIEnv *env, jsize len); + jintArray (JNICALL *NewIntArray) + (JNIEnv *env, jsize len); + jlongArray (JNICALL *NewLongArray) + (JNIEnv *env, jsize len); + jfloatArray (JNICALL *NewFloatArray) + (JNIEnv *env, jsize len); + jdoubleArray (JNICALL *NewDoubleArray) + (JNIEnv *env, jsize len); + + jboolean * (JNICALL *GetBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *isCopy); + jbyte * (JNICALL *GetByteArrayElements) + (JNIEnv *env, jbyteArray array, jboolean *isCopy); + jchar * (JNICALL *GetCharArrayElements) + (JNIEnv *env, jcharArray array, jboolean *isCopy); + jshort * (JNICALL *GetShortArrayElements) + (JNIEnv *env, jshortArray array, jboolean *isCopy); + jint * (JNICALL *GetIntArrayElements) + (JNIEnv *env, jintArray array, jboolean *isCopy); + jlong * (JNICALL *GetLongArrayElements) + (JNIEnv *env, jlongArray array, jboolean *isCopy); + jfloat * (JNICALL *GetFloatArrayElements) + (JNIEnv *env, jfloatArray array, jboolean *isCopy); + jdouble * (JNICALL *GetDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jboolean *isCopy); + + void (JNICALL *ReleaseBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode); + void (JNICALL *ReleaseByteArrayElements) + (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode); + void (JNICALL *ReleaseCharArrayElements) + (JNIEnv *env, jcharArray array, jchar *elems, jint mode); + void (JNICALL *ReleaseShortArrayElements) + (JNIEnv *env, jshortArray array, jshort *elems, jint mode); + void (JNICALL *ReleaseIntArrayElements) + (JNIEnv *env, jintArray array, jint *elems, jint mode); + void (JNICALL *ReleaseLongArrayElements) + (JNIEnv *env, jlongArray array, jlong *elems, jint mode); + void (JNICALL *ReleaseFloatArrayElements) + (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode); + void (JNICALL *ReleaseDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode); + + void (JNICALL *GetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); + void (JNICALL *GetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); + void (JNICALL *GetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); + void (JNICALL *GetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); + void (JNICALL *GetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); + void (JNICALL *GetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); + void (JNICALL *GetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); + void (JNICALL *GetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); + + void (JNICALL *SetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf); + void (JNICALL *SetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf); + void (JNICALL *SetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf); + void (JNICALL *SetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf); + void (JNICALL *SetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf); + void (JNICALL *SetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf); + void (JNICALL *SetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf); + void (JNICALL *SetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf); + + jint (JNICALL *RegisterNatives) + (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, + jint nMethods); + jint (JNICALL *UnregisterNatives) + (JNIEnv *env, jclass clazz); + + jint (JNICALL *MonitorEnter) + (JNIEnv *env, jobject obj); + jint (JNICALL *MonitorExit) + (JNIEnv *env, jobject obj); + + jint (JNICALL *GetJavaVM) + (JNIEnv *env, JavaVM **vm); + + void (JNICALL *GetStringRegion) + (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf); + void (JNICALL *GetStringUTFRegion) + (JNIEnv *env, jstring str, jsize start, jsize len, char *buf); + + void * (JNICALL *GetPrimitiveArrayCritical) + (JNIEnv *env, jarray array, jboolean *isCopy); + void (JNICALL *ReleasePrimitiveArrayCritical) + (JNIEnv *env, jarray array, void *carray, jint mode); + + const jchar * (JNICALL *GetStringCritical) + (JNIEnv *env, jstring string, jboolean *isCopy); + void (JNICALL *ReleaseStringCritical) + (JNIEnv *env, jstring string, const jchar *cstring); + + jweak (JNICALL *NewWeakGlobalRef) + (JNIEnv *env, jobject obj); + void (JNICALL *DeleteWeakGlobalRef) + (JNIEnv *env, jweak ref); + + jboolean (JNICALL *ExceptionCheck) + (JNIEnv *env); + + jobject (JNICALL *NewDirectByteBuffer) + (JNIEnv* env, void* address, jlong capacity); + void* (JNICALL *GetDirectBufferAddress) + (JNIEnv* env, jobject buf); + jlong (JNICALL *GetDirectBufferCapacity) + (JNIEnv* env, jobject buf); + + /* New JNI 1.6 Features */ + + jobjectRefType (JNICALL *GetObjectRefType) + (JNIEnv* env, jobject obj); +}; + +/* + * We use inlined functions for C++ so that programmers can write: + * + * env->FindClass("java/lang/String") + * + * in C++ rather than: + * + * (*env)->FindClass(env, "java/lang/String") + * + * in C. + */ + +struct JNIEnv_ { + const struct JNINativeInterface_ *functions; +#ifdef __cplusplus + + jint GetVersion() { + return functions->GetVersion(this); + } + jclass DefineClass(const char *name, jobject loader, const jbyte *buf, + jsize len) { + return functions->DefineClass(this, name, loader, buf, len); + } + jclass FindClass(const char *name) { + return functions->FindClass(this, name); + } + jmethodID FromReflectedMethod(jobject method) { + return functions->FromReflectedMethod(this,method); + } + jfieldID FromReflectedField(jobject field) { + return functions->FromReflectedField(this,field); + } + + jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) { + return functions->ToReflectedMethod(this, cls, methodID, isStatic); + } + + jclass GetSuperclass(jclass sub) { + return functions->GetSuperclass(this, sub); + } + jboolean IsAssignableFrom(jclass sub, jclass sup) { + return functions->IsAssignableFrom(this, sub, sup); + } + + jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) { + return functions->ToReflectedField(this,cls,fieldID,isStatic); + } + + jint Throw(jthrowable obj) { + return functions->Throw(this, obj); + } + jint ThrowNew(jclass clazz, const char *msg) { + return functions->ThrowNew(this, clazz, msg); + } + jthrowable ExceptionOccurred() { + return functions->ExceptionOccurred(this); + } + void ExceptionDescribe() { + functions->ExceptionDescribe(this); + } + void ExceptionClear() { + functions->ExceptionClear(this); + } + void FatalError(const char *msg) { + functions->FatalError(this, msg); + } + + jint PushLocalFrame(jint capacity) { + return functions->PushLocalFrame(this,capacity); + } + jobject PopLocalFrame(jobject result) { + return functions->PopLocalFrame(this,result); + } + + jobject NewGlobalRef(jobject lobj) { + return functions->NewGlobalRef(this,lobj); + } + void DeleteGlobalRef(jobject gref) { + functions->DeleteGlobalRef(this,gref); + } + void DeleteLocalRef(jobject obj) { + functions->DeleteLocalRef(this, obj); + } + + jboolean IsSameObject(jobject obj1, jobject obj2) { + return functions->IsSameObject(this,obj1,obj2); + } + + jobject NewLocalRef(jobject ref) { + return functions->NewLocalRef(this,ref); + } + jint EnsureLocalCapacity(jint capacity) { + return functions->EnsureLocalCapacity(this,capacity); + } + + jobject AllocObject(jclass clazz) { + return functions->AllocObject(this,clazz); + } + jobject NewObject(jclass clazz, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args, methodID); + result = functions->NewObjectV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject NewObjectV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->NewObjectV(this,clazz,methodID,args); + } + jobject NewObjectA(jclass clazz, jmethodID methodID, + const jvalue *args) { + return functions->NewObjectA(this,clazz,methodID,args); + } + + jclass GetObjectClass(jobject obj) { + return functions->GetObjectClass(this,obj); + } + jboolean IsInstanceOf(jobject obj, jclass clazz) { + return functions->IsInstanceOf(this,obj,clazz); + } + + jmethodID GetMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetMethodID(this,clazz,name,sig); + } + + jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallObjectMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jobject CallObjectMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallObjectMethodV(this,obj,methodID,args); + } + jobject CallObjectMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallObjectMethodA(this,obj,methodID,args); + } + + jboolean CallBooleanMethod(jobject obj, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallBooleanMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallBooleanMethodV(this,obj,methodID,args); + } + jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallBooleanMethodA(this,obj,methodID, args); + } + + jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallByteMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jbyte CallByteMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallByteMethodV(this,obj,methodID,args); + } + jbyte CallByteMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallByteMethodA(this,obj,methodID,args); + } + + jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallCharMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jchar CallCharMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallCharMethodV(this,obj,methodID,args); + } + jchar CallCharMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallCharMethodA(this,obj,methodID,args); + } + + jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallShortMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jshort CallShortMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallShortMethodV(this,obj,methodID,args); + } + jshort CallShortMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallShortMethodA(this,obj,methodID,args); + } + + jint CallIntMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallIntMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jint CallIntMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallIntMethodV(this,obj,methodID,args); + } + jint CallIntMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallIntMethodA(this,obj,methodID,args); + } + + jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallLongMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jlong CallLongMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallLongMethodV(this,obj,methodID,args); + } + jlong CallLongMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallLongMethodA(this,obj,methodID,args); + } + + jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallFloatMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jfloat CallFloatMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallFloatMethodV(this,obj,methodID,args); + } + jfloat CallFloatMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallFloatMethodA(this,obj,methodID,args); + } + + jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallDoubleMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallDoubleMethodV(this,obj,methodID,args); + } + jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallDoubleMethodA(this,obj,methodID,args); + } + + void CallVoidMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallVoidMethodV(this,obj,methodID,args); + va_end(args); + } + void CallVoidMethodV(jobject obj, jmethodID methodID, + va_list args) { + functions->CallVoidMethodV(this,obj,methodID,args); + } + void CallVoidMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + functions->CallVoidMethodA(this,obj,methodID,args); + } + + jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + } + jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualObjectMethodA(this,obj,clazz, + methodID,args); + } + + jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + } + jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, + methodID, args); + } + + jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + } + jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualByteMethodA(this,obj,clazz, + methodID,args); + } + + jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + } + jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualCharMethodA(this,obj,clazz, + methodID,args); + } + + jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + } + jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualShortMethodA(this,obj,clazz, + methodID,args); + } + + jint CallNonvirtualIntMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + } + jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualIntMethodA(this,obj,clazz, + methodID,args); + } + + jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + } + jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualLongMethodA(this,obj,clazz, + methodID,args); + } + + jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + } + jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, + jmethodID methodID, + const jvalue * args) { + return functions->CallNonvirtualFloatMethodA(this,obj,clazz, + methodID,args); + } + + jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + } + jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, + jmethodID methodID, + const jvalue * args) { + return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, + methodID,args); + } + + void CallNonvirtualVoidMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + va_end(args); + } + void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + } + void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, + jmethodID methodID, + const jvalue * args) { + functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); + } + + jfieldID GetFieldID(jclass clazz, const char *name, + const char *sig) { + return functions->GetFieldID(this,clazz,name,sig); + } + + jobject GetObjectField(jobject obj, jfieldID fieldID) { + return functions->GetObjectField(this,obj,fieldID); + } + jboolean GetBooleanField(jobject obj, jfieldID fieldID) { + return functions->GetBooleanField(this,obj,fieldID); + } + jbyte GetByteField(jobject obj, jfieldID fieldID) { + return functions->GetByteField(this,obj,fieldID); + } + jchar GetCharField(jobject obj, jfieldID fieldID) { + return functions->GetCharField(this,obj,fieldID); + } + jshort GetShortField(jobject obj, jfieldID fieldID) { + return functions->GetShortField(this,obj,fieldID); + } + jint GetIntField(jobject obj, jfieldID fieldID) { + return functions->GetIntField(this,obj,fieldID); + } + jlong GetLongField(jobject obj, jfieldID fieldID) { + return functions->GetLongField(this,obj,fieldID); + } + jfloat GetFloatField(jobject obj, jfieldID fieldID) { + return functions->GetFloatField(this,obj,fieldID); + } + jdouble GetDoubleField(jobject obj, jfieldID fieldID) { + return functions->GetDoubleField(this,obj,fieldID); + } + + void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { + functions->SetObjectField(this,obj,fieldID,val); + } + void SetBooleanField(jobject obj, jfieldID fieldID, + jboolean val) { + functions->SetBooleanField(this,obj,fieldID,val); + } + void SetByteField(jobject obj, jfieldID fieldID, + jbyte val) { + functions->SetByteField(this,obj,fieldID,val); + } + void SetCharField(jobject obj, jfieldID fieldID, + jchar val) { + functions->SetCharField(this,obj,fieldID,val); + } + void SetShortField(jobject obj, jfieldID fieldID, + jshort val) { + functions->SetShortField(this,obj,fieldID,val); + } + void SetIntField(jobject obj, jfieldID fieldID, + jint val) { + functions->SetIntField(this,obj,fieldID,val); + } + void SetLongField(jobject obj, jfieldID fieldID, + jlong val) { + functions->SetLongField(this,obj,fieldID,val); + } + void SetFloatField(jobject obj, jfieldID fieldID, + jfloat val) { + functions->SetFloatField(this,obj,fieldID,val); + } + void SetDoubleField(jobject obj, jfieldID fieldID, + jdouble val) { + functions->SetDoubleField(this,obj,fieldID,val); + } + + jmethodID GetStaticMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticMethodID(this,clazz,name,sig); + } + + jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, + ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->CallStaticObjectMethodV(this,clazz,methodID,args); + } + jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, + const jvalue *args) { + return functions->CallStaticObjectMethodA(this,clazz,methodID,args); + } + + jboolean CallStaticBooleanMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jboolean CallStaticBooleanMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + } + jboolean CallStaticBooleanMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); + } + + jbyte CallStaticByteMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallStaticByteMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jbyte CallStaticByteMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticByteMethodV(this,clazz,methodID,args); + } + jbyte CallStaticByteMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticByteMethodA(this,clazz,methodID,args); + } + + jchar CallStaticCharMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallStaticCharMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jchar CallStaticCharMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticCharMethodV(this,clazz,methodID,args); + } + jchar CallStaticCharMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticCharMethodA(this,clazz,methodID,args); + } + + jshort CallStaticShortMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallStaticShortMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jshort CallStaticShortMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticShortMethodV(this,clazz,methodID,args); + } + jshort CallStaticShortMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticShortMethodA(this,clazz,methodID,args); + } + + jint CallStaticIntMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallStaticIntMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jint CallStaticIntMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticIntMethodV(this,clazz,methodID,args); + } + jint CallStaticIntMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticIntMethodA(this,clazz,methodID,args); + } + + jlong CallStaticLongMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallStaticLongMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jlong CallStaticLongMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticLongMethodV(this,clazz,methodID,args); + } + jlong CallStaticLongMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticLongMethodA(this,clazz,methodID,args); + } + + jfloat CallStaticFloatMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jfloat CallStaticFloatMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticFloatMethodV(this,clazz,methodID,args); + } + jfloat CallStaticFloatMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticFloatMethodA(this,clazz,methodID,args); + } + + jdouble CallStaticDoubleMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jdouble CallStaticDoubleMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + } + jdouble CallStaticDoubleMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); + } + + void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallStaticVoidMethodV(this,cls,methodID,args); + va_end(args); + } + void CallStaticVoidMethodV(jclass cls, jmethodID methodID, + va_list args) { + functions->CallStaticVoidMethodV(this,cls,methodID,args); + } + void CallStaticVoidMethodA(jclass cls, jmethodID methodID, + const jvalue * args) { + functions->CallStaticVoidMethodA(this,cls,methodID,args); + } + + jfieldID GetStaticFieldID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticFieldID(this,clazz,name,sig); + } + jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticObjectField(this,clazz,fieldID); + } + jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticBooleanField(this,clazz,fieldID); + } + jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticByteField(this,clazz,fieldID); + } + jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticCharField(this,clazz,fieldID); + } + jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticShortField(this,clazz,fieldID); + } + jint GetStaticIntField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticIntField(this,clazz,fieldID); + } + jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticLongField(this,clazz,fieldID); + } + jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticFloatField(this,clazz,fieldID); + } + jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticDoubleField(this,clazz,fieldID); + } + + void SetStaticObjectField(jclass clazz, jfieldID fieldID, + jobject value) { + functions->SetStaticObjectField(this,clazz,fieldID,value); + } + void SetStaticBooleanField(jclass clazz, jfieldID fieldID, + jboolean value) { + functions->SetStaticBooleanField(this,clazz,fieldID,value); + } + void SetStaticByteField(jclass clazz, jfieldID fieldID, + jbyte value) { + functions->SetStaticByteField(this,clazz,fieldID,value); + } + void SetStaticCharField(jclass clazz, jfieldID fieldID, + jchar value) { + functions->SetStaticCharField(this,clazz,fieldID,value); + } + void SetStaticShortField(jclass clazz, jfieldID fieldID, + jshort value) { + functions->SetStaticShortField(this,clazz,fieldID,value); + } + void SetStaticIntField(jclass clazz, jfieldID fieldID, + jint value) { + functions->SetStaticIntField(this,clazz,fieldID,value); + } + void SetStaticLongField(jclass clazz, jfieldID fieldID, + jlong value) { + functions->SetStaticLongField(this,clazz,fieldID,value); + } + void SetStaticFloatField(jclass clazz, jfieldID fieldID, + jfloat value) { + functions->SetStaticFloatField(this,clazz,fieldID,value); + } + void SetStaticDoubleField(jclass clazz, jfieldID fieldID, + jdouble value) { + functions->SetStaticDoubleField(this,clazz,fieldID,value); + } + + jstring NewString(const jchar *unicode, jsize len) { + return functions->NewString(this,unicode,len); + } + jsize GetStringLength(jstring str) { + return functions->GetStringLength(this,str); + } + const jchar *GetStringChars(jstring str, jboolean *isCopy) { + return functions->GetStringChars(this,str,isCopy); + } + void ReleaseStringChars(jstring str, const jchar *chars) { + functions->ReleaseStringChars(this,str,chars); + } + + jstring NewStringUTF(const char *utf) { + return functions->NewStringUTF(this,utf); + } + jsize GetStringUTFLength(jstring str) { + return functions->GetStringUTFLength(this,str); + } + const char* GetStringUTFChars(jstring str, jboolean *isCopy) { + return functions->GetStringUTFChars(this,str,isCopy); + } + void ReleaseStringUTFChars(jstring str, const char* chars) { + functions->ReleaseStringUTFChars(this,str,chars); + } + + jsize GetArrayLength(jarray array) { + return functions->GetArrayLength(this,array); + } + + jobjectArray NewObjectArray(jsize len, jclass clazz, + jobject init) { + return functions->NewObjectArray(this,len,clazz,init); + } + jobject GetObjectArrayElement(jobjectArray array, jsize index) { + return functions->GetObjectArrayElement(this,array,index); + } + void SetObjectArrayElement(jobjectArray array, jsize index, + jobject val) { + functions->SetObjectArrayElement(this,array,index,val); + } + + jbooleanArray NewBooleanArray(jsize len) { + return functions->NewBooleanArray(this,len); + } + jbyteArray NewByteArray(jsize len) { + return functions->NewByteArray(this,len); + } + jcharArray NewCharArray(jsize len) { + return functions->NewCharArray(this,len); + } + jshortArray NewShortArray(jsize len) { + return functions->NewShortArray(this,len); + } + jintArray NewIntArray(jsize len) { + return functions->NewIntArray(this,len); + } + jlongArray NewLongArray(jsize len) { + return functions->NewLongArray(this,len); + } + jfloatArray NewFloatArray(jsize len) { + return functions->NewFloatArray(this,len); + } + jdoubleArray NewDoubleArray(jsize len) { + return functions->NewDoubleArray(this,len); + } + + jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { + return functions->GetBooleanArrayElements(this,array,isCopy); + } + jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) { + return functions->GetByteArrayElements(this,array,isCopy); + } + jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) { + return functions->GetCharArrayElements(this,array,isCopy); + } + jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) { + return functions->GetShortArrayElements(this,array,isCopy); + } + jint * GetIntArrayElements(jintArray array, jboolean *isCopy) { + return functions->GetIntArrayElements(this,array,isCopy); + } + jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) { + return functions->GetLongArrayElements(this,array,isCopy); + } + jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { + return functions->GetFloatArrayElements(this,array,isCopy); + } + jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { + return functions->GetDoubleArrayElements(this,array,isCopy); + } + + void ReleaseBooleanArrayElements(jbooleanArray array, + jboolean *elems, + jint mode) { + functions->ReleaseBooleanArrayElements(this,array,elems,mode); + } + void ReleaseByteArrayElements(jbyteArray array, + jbyte *elems, + jint mode) { + functions->ReleaseByteArrayElements(this,array,elems,mode); + } + void ReleaseCharArrayElements(jcharArray array, + jchar *elems, + jint mode) { + functions->ReleaseCharArrayElements(this,array,elems,mode); + } + void ReleaseShortArrayElements(jshortArray array, + jshort *elems, + jint mode) { + functions->ReleaseShortArrayElements(this,array,elems,mode); + } + void ReleaseIntArrayElements(jintArray array, + jint *elems, + jint mode) { + functions->ReleaseIntArrayElements(this,array,elems,mode); + } + void ReleaseLongArrayElements(jlongArray array, + jlong *elems, + jint mode) { + functions->ReleaseLongArrayElements(this,array,elems,mode); + } + void ReleaseFloatArrayElements(jfloatArray array, + jfloat *elems, + jint mode) { + functions->ReleaseFloatArrayElements(this,array,elems,mode); + } + void ReleaseDoubleArrayElements(jdoubleArray array, + jdouble *elems, + jint mode) { + functions->ReleaseDoubleArrayElements(this,array,elems,mode); + } + + void GetBooleanArrayRegion(jbooleanArray array, + jsize start, jsize len, jboolean *buf) { + functions->GetBooleanArrayRegion(this,array,start,len,buf); + } + void GetByteArrayRegion(jbyteArray array, + jsize start, jsize len, jbyte *buf) { + functions->GetByteArrayRegion(this,array,start,len,buf); + } + void GetCharArrayRegion(jcharArray array, + jsize start, jsize len, jchar *buf) { + functions->GetCharArrayRegion(this,array,start,len,buf); + } + void GetShortArrayRegion(jshortArray array, + jsize start, jsize len, jshort *buf) { + functions->GetShortArrayRegion(this,array,start,len,buf); + } + void GetIntArrayRegion(jintArray array, + jsize start, jsize len, jint *buf) { + functions->GetIntArrayRegion(this,array,start,len,buf); + } + void GetLongArrayRegion(jlongArray array, + jsize start, jsize len, jlong *buf) { + functions->GetLongArrayRegion(this,array,start,len,buf); + } + void GetFloatArrayRegion(jfloatArray array, + jsize start, jsize len, jfloat *buf) { + functions->GetFloatArrayRegion(this,array,start,len,buf); + } + void GetDoubleArrayRegion(jdoubleArray array, + jsize start, jsize len, jdouble *buf) { + functions->GetDoubleArrayRegion(this,array,start,len,buf); + } + + void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, + const jboolean *buf) { + functions->SetBooleanArrayRegion(this,array,start,len,buf); + } + void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, + const jbyte *buf) { + functions->SetByteArrayRegion(this,array,start,len,buf); + } + void SetCharArrayRegion(jcharArray array, jsize start, jsize len, + const jchar *buf) { + functions->SetCharArrayRegion(this,array,start,len,buf); + } + void SetShortArrayRegion(jshortArray array, jsize start, jsize len, + const jshort *buf) { + functions->SetShortArrayRegion(this,array,start,len,buf); + } + void SetIntArrayRegion(jintArray array, jsize start, jsize len, + const jint *buf) { + functions->SetIntArrayRegion(this,array,start,len,buf); + } + void SetLongArrayRegion(jlongArray array, jsize start, jsize len, + const jlong *buf) { + functions->SetLongArrayRegion(this,array,start,len,buf); + } + void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, + const jfloat *buf) { + functions->SetFloatArrayRegion(this,array,start,len,buf); + } + void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, + const jdouble *buf) { + functions->SetDoubleArrayRegion(this,array,start,len,buf); + } + + jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, + jint nMethods) { + return functions->RegisterNatives(this,clazz,methods,nMethods); + } + jint UnregisterNatives(jclass clazz) { + return functions->UnregisterNatives(this,clazz); + } + + jint MonitorEnter(jobject obj) { + return functions->MonitorEnter(this,obj); + } + jint MonitorExit(jobject obj) { + return functions->MonitorExit(this,obj); + } + + jint GetJavaVM(JavaVM **vm) { + return functions->GetJavaVM(this,vm); + } + + void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) { + functions->GetStringRegion(this,str,start,len,buf); + } + void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) { + functions->GetStringUTFRegion(this,str,start,len,buf); + } + + void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { + return functions->GetPrimitiveArrayCritical(this,array,isCopy); + } + void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { + functions->ReleasePrimitiveArrayCritical(this,array,carray,mode); + } + + const jchar * GetStringCritical(jstring string, jboolean *isCopy) { + return functions->GetStringCritical(this,string,isCopy); + } + void ReleaseStringCritical(jstring string, const jchar *cstring) { + functions->ReleaseStringCritical(this,string,cstring); + } + + jweak NewWeakGlobalRef(jobject obj) { + return functions->NewWeakGlobalRef(this,obj); + } + void DeleteWeakGlobalRef(jweak ref) { + functions->DeleteWeakGlobalRef(this,ref); + } + + jboolean ExceptionCheck() { + return functions->ExceptionCheck(this); + } + + jobject NewDirectByteBuffer(void* address, jlong capacity) { + return functions->NewDirectByteBuffer(this, address, capacity); + } + void* GetDirectBufferAddress(jobject buf) { + return functions->GetDirectBufferAddress(this, buf); + } + jlong GetDirectBufferCapacity(jobject buf) { + return functions->GetDirectBufferCapacity(this, buf); + } + jobjectRefType GetObjectRefType(jobject obj) { + return functions->GetObjectRefType(this, obj); + } + +#endif /* __cplusplus */ +}; + +typedef struct JavaVMOption { + char *optionString; + void *extraInfo; +} JavaVMOption; + +typedef struct JavaVMInitArgs { + jint version; + + jint nOptions; + JavaVMOption *options; + jboolean ignoreUnrecognized; +} JavaVMInitArgs; + +typedef struct JavaVMAttachArgs { + jint version; + + char *name; + jobject group; +} JavaVMAttachArgs; + +/* These will be VM-specific. */ + +#define JDK1_2 +#define JDK1_4 + +/* End VM-specific. */ + +struct JNIInvokeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + jint (JNICALL *DestroyJavaVM)(JavaVM *vm); + + jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args); + + jint (JNICALL *DetachCurrentThread)(JavaVM *vm); + + jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version); + + jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args); +}; + +struct JavaVM_ { + const struct JNIInvokeInterface_ *functions; +#ifdef __cplusplus + + jint DestroyJavaVM() { + return functions->DestroyJavaVM(this); + } + jint AttachCurrentThread(void **penv, void *args) { + return functions->AttachCurrentThread(this, penv, args); + } + jint DetachCurrentThread() { + return functions->DetachCurrentThread(this); + } + + jint GetEnv(void **penv, jint version) { + return functions->GetEnv(this, penv, version); + } + jint AttachCurrentThreadAsDaemon(void **penv, void *args) { + return functions->AttachCurrentThreadAsDaemon(this, penv, args); + } +#endif +}; + +#ifdef _JNI_IMPLEMENTATION_ +#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT +#else +#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT +#endif +_JNI_IMPORT_OR_EXPORT_ jint JNICALL +JNI_GetDefaultJavaVMInitArgs(void *args); + +_JNI_IMPORT_OR_EXPORT_ jint JNICALL +JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args); + +_JNI_IMPORT_OR_EXPORT_ jint JNICALL +JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); + +/* Defined by native libraries. */ +JNIEXPORT jint JNICALL +JNI_OnLoad(JavaVM *vm, void *reserved); + +JNIEXPORT void JNICALL +JNI_OnUnload(JavaVM *vm, void *reserved); + +#define JNI_VERSION_1_1 0x00010001 +#define JNI_VERSION_1_2 0x00010002 +#define JNI_VERSION_1_4 0x00010004 +#define JNI_VERSION_1_6 0x00010006 + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* !_JAVASOFT_JNI_H_ */ diff --git a/d3d9/jni_md.h b/d3d9/jni_md.h new file mode 100644 index 0000000..3808001 --- /dev/null +++ b/d3d9/jni_md.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved. + * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ + +#ifndef _JAVASOFT_JNI_MD_H_ +#define _JAVASOFT_JNI_MD_H_ + +#define JNIEXPORT __declspec(dllexport) +#define JNIIMPORT __declspec(dllimport) +#define JNICALL __stdcall + +typedef long jint; +typedef __int64 jlong; +typedef signed char jbyte; + +#endif /* !_JAVASOFT_JNI_MD_H_ */ diff --git a/d3d9/main.cpp b/d3d9/main.cpp index 9894b5b..c707bcf 100644 --- a/d3d9/main.cpp +++ b/d3d9/main.cpp @@ -5,10 +5,14 @@ extern "C" bool __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lp switch (fdwReason) { case DLL_PROCESS_ATTACH: - DisableThreadLibraryCalls(hinstDLL); - return Initialize(); + { + DisableThreadLibraryCalls(hinstDLL); + return Initialize(); + } case DLL_PROCESS_DETACH: + SafeRelease(Sprite); + SafeRelease(Texture); DeInitialize(); break;