windows/YeorinLab.cpp

// YEORIN-X v4 / D3D11 source-owned presentation laboratory.
// Not a game overlay. No hooks, capture, network, admin privileges or input injection.
// Windows source is provided; the release environment cannot compile/run this backend.
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include <shellapi.h>
#include <d3d11.h>
#include <dxgi1_3.h>
#include <d3dcompiler.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <deque>
#include <string>
#include <stdexcept>
#include <algorithm>
#include <memory>
#include "lease.hpp"
#include "distance.hpp"

namespace {
template<class T> void drop(T*&p){if(p){p->Release();p=nullptr;}}
void check(HRESULT h,const char*what){if(FAILED(h)){char msg[256];std::snprintf(msg,sizeof(msg),"%s (HRESULT 0x%08lx)",what,(unsigned long)h);throw std::runtime_error(msg);}}
double now(){static LARGE_INTEGER f=[](){LARGE_INTEGER x;QueryPerformanceFrequency(&x);return x;}();LARGE_INTEGER n;QueryPerformanceCounter(&n);return double(n.QuadPart)/f.QuadPart;}
struct Row{unsigned long long frame,source;int mode,armed;double inputTime,start,submit,presentReturn,completionObserved,gpuMs,alpha,bound,shiftX,shiftY;};
const char* SHADER=R"HLSL(
cbuffer P:register(b0){float2 size;float2 sourceOffset;float2 delta;float rho;float alpha;float time;float marker;float pad0;float pad1;};
Texture2D image:register(t0);SamplerState samp:register(s0);
struct V{float4 pos:SV_Position;};
V vs(uint id:SV_VertexID){V o;float2 p=float2((id<<1)&2,id&2);o.pos=float4(p*float2(2,-2)+float2(-1,1),0,1);return o;}
float4 scene(V v):SV_Target {
 float2 p=v.pos.xy-.5+sourceOffset;
 float2 cell=floor(p/48.0);float ch=fmod(abs(cell.x+cell.y),2);
 float3 col=lerp(float3(.07,.11,.16),float3(.24,.34,.43),ch);
 float2 q=abs(frac((p+24)/96)-.5);float circle=length(q)-.24;
 col+=(1-smoothstep(0,.025,abs(circle)))*.5;
 col+=float3(.12,.06,.01)*sin(p.x*.015+p.y*.012);
 // A marker changes only on a source update. It is NOT made newer by camera warp.
 if(v.pos.x<80&&v.pos.y<80)col=marker>.5?1:0;
 return float4(col,1);
}
float4 warp(V v):SV_Target {
 float2 p=v.pos.xy-.5;
 float d=max(0,min(min(p.x,size.x-1-p.x),min(p.y,size.y-1-p.y)));
 float2 step=delta*min(1.0,rho*d/max(length(delta),1e-12))*alpha;
 return image.SampleLevel(samp,(p+step+.5)/size,0);
}
)HLSL";
struct Params{float width,height,sourceX,sourceY,deltaX,deltaY,rho,alpha,time,marker,pad0,pad1;};
struct Timing{ID3D11Query *disjoint=nullptr,*begin=nullptr,*end=nullptr;size_t row=0;unsigned epoch=0;bool pending=false;};
class App {
public:
 HWND win=nullptr;bool quit=false,armed=false,resized=false,hiddenLock=false;int width=1280,height=720,mode=0;double duration=60,sourceHz=60,refreshHz=60;
 double inputX=0,inputY=0,inputTime=0,sourceX=0,sourceY=0,sourceMarker=0;bool marker=false;
 ID3D11Device *dev=nullptr;ID3D11DeviceContext *ctx=nullptr;IDXGISwapChain2 *swap=nullptr;HANDLE ready=nullptr;
 ID3D11Texture2D *source=nullptr,*back=nullptr;ID3D11RenderTargetView *sourceRT=nullptr,*backRT=nullptr;ID3D11ShaderResourceView *sourceSR=nullptr;
 ID3D11VertexShader *vs=nullptr;ID3D11PixelShader *scene=nullptr,*warp=nullptr;ID3D11Buffer *cb=nullptr;ID3D11SamplerState *sampler=nullptr;
 std::vector<Row> rows;std::vector<Timing> times;std::deque<double> gpuHistory;
 std::unique_ptr<yeorin4::RectangleSpectrum> spectrum;unsigned timingEpoch=0;
 std::string out="yeorin_windows_diagnostic.csv";double startTime=0,lastSource=-1;unsigned long long sourceId=0;
 ~App(){capture(false);if(ctx)ctx->ClearState();for(auto&t:times){drop(t.disjoint);drop(t.begin);drop(t.end);}drop(sourceSR);drop(sourceRT);drop(backRT);drop(source);drop(back);drop(vs);drop(scene);drop(warp);drop(cb);drop(sampler);if(ready)CloseHandle(ready);drop(swap);drop(ctx);drop(dev);}
 void capture(bool state){
  if(state==armed)return;armed=state;
  if(armed){RECT r;GetClientRect(win,&r);POINT a={r.left,r.top},b={r.right,r.bottom};ClientToScreen(win,&a);ClientToScreen(win,&b);r={a.x,a.y,b.x,b.y};ClipCursor(&r);ShowCursor(FALSE);}
  else{ClipCursor(nullptr);ShowCursor(TRUE);}
 }
 void input(HRAWINPUT handle){
  UINT n=0;if(GetRawInputData(handle,RID_INPUT,nullptr,&n,sizeof(RAWINPUTHEADER))!=0||n>1024*1024)return;
  std::vector<unsigned char>b(n);if(GetRawInputData(handle,RID_INPUT,b.data(),&n,sizeof(RAWINPUTHEADER))!=n)return;
  if(n<sizeof(RAWINPUT))return;auto*r=reinterpret_cast<RAWINPUT*>(b.data());
  if(r->header.dwType==RIM_TYPEMOUSE&&armed&&!(r->data.mouse.usFlags&MOUSE_MOVE_ABSOLUTE)){
   inputX+=r->data.mouse.lLastX*.5;inputY+=r->data.mouse.lLastY*.5;inputTime=now();
   if(r->data.mouse.usButtonFlags&RI_MOUSE_LEFT_BUTTON_DOWN)marker=!marker;
  }
 }
 void shaders(){
  auto compile=[&](const char*entry,const char*target){ID3DBlob *b=nullptr,*err=nullptr;HRESULT h=D3DCompile(SHADER,std::strlen(SHADER),"YEORIN_LAB",nullptr,nullptr,entry,target,D3DCOMPILE_ENABLE_STRICTNESS,0,&b,&err);if(FAILED(h)){std::string s=err?std::string((char*)err->GetBufferPointer(),err->GetBufferSize()):"shader failure";drop(err);drop(b);throw std::runtime_error(s);}drop(err);return b;};
  ID3DBlob*b=compile("vs","vs_5_0");check(dev->CreateVertexShader(b->GetBufferPointer(),b->GetBufferSize(),nullptr,&vs),"vertex shader");drop(b);
  b=compile("scene","ps_5_0");check(dev->CreatePixelShader(b->GetBufferPointer(),b->GetBufferSize(),nullptr,&scene),"scene shader");drop(b);
  b=compile("warp","ps_5_0");check(dev->CreatePixelShader(b->GetBufferPointer(),b->GetBufferSize(),nullptr,&warp),"warp shader");drop(b);
  D3D11_BUFFER_DESC bd={};bd.ByteWidth=sizeof(Params);bd.Usage=D3D11_USAGE_DEFAULT;bd.BindFlags=D3D11_BIND_CONSTANT_BUFFER;check(dev->CreateBuffer(&bd,nullptr,&cb),"constant buffer");
  D3D11_SAMPLER_DESC s={};s.Filter=D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT;s.AddressU=s.AddressV=s.AddressW=D3D11_TEXTURE_ADDRESS_CLAMP;s.MaxLOD=D3D11_FLOAT32_MAX;check(dev->CreateSamplerState(&s,&sampler),"sampler");
 }
 void textures(){
  if(ctx){ID3D11ShaderResourceView*nil=nullptr;ctx->PSSetShaderResources(0,1,&nil);ctx->OMSetRenderTargets(0,nullptr,nullptr);}
  drop(sourceSR);drop(sourceRT);drop(backRT);drop(source);drop(back);
  check(swap->ResizeBuffers(2,width,height,DXGI_FORMAT_R8G8B8A8_UNORM,DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT),"ResizeBuffers");
  check(swap->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&back),"back buffer");check(dev->CreateRenderTargetView(back,nullptr,&backRT),"back RTV");
  D3D11_TEXTURE2D_DESC d={};d.Width=width;d.Height=height;d.MipLevels=1;d.ArraySize=1;d.Format=DXGI_FORMAT_R8G8B8A8_UNORM;d.SampleDesc.Count=1;d.Usage=D3D11_USAGE_DEFAULT;d.BindFlags=D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE;
  check(dev->CreateTexture2D(&d,nullptr,&source),"source texture");check(dev->CreateRenderTargetView(source,nullptr,&sourceRT),"source RTV");check(dev->CreateShaderResourceView(source,nullptr,&sourceSR),"source SRV");lastSource=-1;++timingEpoch;spectrum=std::make_unique<yeorin4::RectangleSpectrum>(width,height);
 }
 void init(){
  D3D_FEATURE_LEVEL level;check(D3D11CreateDevice(nullptr,D3D_DRIVER_TYPE_HARDWARE,nullptr,0,nullptr,0,D3D11_SDK_VERSION,&dev,&level,&ctx),"D3D11CreateDevice (hardware required)");
  if(level<D3D_FEATURE_LEVEL_11_0)throw std::runtime_error("Feature level 11.0 required");
  IDXGIDevice*gd=nullptr;IDXGIAdapter*adapter=nullptr;IDXGIFactory2*factory=nullptr;
  check(dev->QueryInterface(__uuidof(IDXGIDevice),(void**)&gd),"DXGI device");check(gd->GetAdapter(&adapter),"adapter");check(adapter->GetParent(__uuidof(IDXGIFactory2),(void**)&factory),"factory");
  DXGI_SWAP_CHAIN_DESC1 d={};d.Width=width;d.Height=height;d.Format=DXGI_FORMAT_R8G8B8A8_UNORM;d.SampleDesc.Count=1;d.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;d.BufferCount=2;d.Scaling=DXGI_SCALING_STRETCH;d.SwapEffect=DXGI_SWAP_EFFECT_FLIP_DISCARD;d.AlphaMode=DXGI_ALPHA_MODE_IGNORE;d.Flags=DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT;
  IDXGISwapChain1*s1=nullptr;check(factory->CreateSwapChainForHwnd(dev,win,&d,nullptr,nullptr,&s1),"waitable flip chain");check(s1->QueryInterface(__uuidof(IDXGISwapChain2),(void**)&swap),"swapchain2");drop(s1);factory->MakeWindowAssociation(win,DXGI_MWA_NO_ALT_ENTER);drop(factory);drop(adapter);drop(gd);
  check(swap->SetMaximumFrameLatency(1),"maximum frame latency");ready=swap->GetFrameLatencyWaitableObject();if(!ready)throw std::runtime_error("No waitable swapchain handle");
  shaders();textures();times.resize(128);
  for(auto&t:times){D3D11_QUERY_DESC q={};q.Query=D3D11_QUERY_TIMESTAMP_DISJOINT;check(dev->CreateQuery(&q,&t.disjoint),"disjoint query");q.Query=D3D11_QUERY_TIMESTAMP;check(dev->CreateQuery(&q,&t.begin),"timestamp query");check(dev->CreateQuery(&q,&t.end),"timestamp query");}
  RAWINPUTDEVICE r={0x01,0x02,0,win};if(!RegisterRawInputDevices(&r,1,sizeof(r)))throw std::runtime_error("Raw Input registration failed");
  DEVMODE dm={};dm.dmSize=sizeof(dm);if(EnumDisplaySettings(nullptr,ENUM_CURRENT_SETTINGS,&dm)&&dm.dmDisplayFrequency>1)refreshHz=dm.dmDisplayFrequency;
  rows.reserve(100000);startTime=now();
 }
 void poll(){
  for(auto&t:times)if(t.pending){D3D11_QUERY_DATA_TIMESTAMP_DISJOINT d;UINT64 a=0,b=0;
   if(ctx->GetData(t.disjoint,&d,sizeof(d),D3D11_ASYNC_GETDATA_DONOTFLUSH)!=S_OK)continue;
   if(ctx->GetData(t.begin,&a,sizeof(a),D3D11_ASYNC_GETDATA_DONOTFLUSH)!=S_OK||ctx->GetData(t.end,&b,sizeof(b),D3D11_ASYNC_GETDATA_DONOTFLUSH)!=S_OK)continue;
   if(t.row<rows.size()){rows[t.row].completionObserved=now();if(!d.Disjoint&&d.Frequency&&b>=a){double ms=1000.*double(b-a)/d.Frequency;rows[t.row].gpuMs=ms;if(t.epoch==timingEpoch){gpuHistory.push_back(ms/1000);if(gpuHistory.size()>256)gpuHistory.pop_front();}}}
   t.pending=false;
  }
 }
 double budget(){if(gpuHistory.size()<32)return -1;std::vector<double>s(gpuHistory.begin(),gpuHistory.end());std::sort(s.begin(),s.end());return s[std::min(s.size()-1,size_t(std::ceil(s.size()*.99)-1))]+.00025;}
 void draw(ID3D11RenderTargetView*target,ID3D11PixelShader*ps,const Params&p){
  ctx->UpdateSubresource(cb,0,nullptr,&p,0,0);ctx->OMSetRenderTargets(1,&target,nullptr);D3D11_VIEWPORT vp={0,0,(float)width,(float)height,0,1};ctx->RSSetViewports(1,&vp);
  ctx->IASetInputLayout(nullptr);ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);ctx->VSSetShader(vs,nullptr,0);ctx->PSSetShader(ps,nullptr,0);ctx->PSSetConstantBuffers(0,1,&cb);ctx->PSSetSamplers(0,1,&sampler);ctx->Draw(3,0);
 }
 void frame(){
  poll();if(resized){capture(false);textures();resized=false;gpuHistory.clear();}
  double t=now();if(t-startTime>=duration||rows.size()>=100000){quit=true;return;}
  size_t slot=rows.size()%times.size();auto&tm=times[slot];bool measure=!tm.pending;
  if(measure){ctx->Begin(tm.disjoint);ctx->End(tm.begin);}
  Params p={};p.width=(float)width;p.height=(float)height;p.rho=.12f;p.time=float(t-startTime);
  ID3D11ShaderResourceView*nil=nullptr;ctx->PSSetShaderResources(0,1,&nil);
  if(lastSource<0||t-lastSource>=1/sourceHz){lastSource=t;++sourceId;if(!hiddenLock){sourceX=inputX;sourceY=inputY;}sourceMarker=marker?1:0;p.sourceX=float(sourceX);p.sourceY=float(sourceY);p.marker=float(sourceMarker);draw(sourceRT,scene,p);}
  // Raw input is already pumped after swap-chain readiness. This is arrival time,
  // not a HID hardware timestamp. Input never feeds synthetic OS events.
  double dx=inputX-sourceX,dy=inputY-sourceY,M=std::hypot(dx,dy);
  p.deltaX=float(dx);p.deltaY=float(dy);
  auto mo=spectrum->at(M,.12);
  double a=0,b=0;
  if(mode==3){a=M>0?std::min(1.,12/std::max(mo.maximum,1e-12)):0;}
  else if(mode==2&&armed&&budget()>0&&budget()<1/refreshHz){
   yeorin4::Lease l;l.source=sourceId;l.published=t;l.expires=t+1/refreshHz;l.a=M*mo.mean-std::sqrt(mo.energy);l.energy=mo.energy;l.maximum=mo.maximum;l.residual=M+1;
   yeorin4::Query q;q.source=sourceId;q.now=now();q.pixelCap=12;
   // Zero native offset is justified ONLY because this application owns the
   // exact source copied in its own baseline. This is not an external-game claim.
   auto d=yeorin4::revalidate(l,q);a=d.alpha;b=d.lower;
  }
  p.alpha=float(a);
  Row row={};row.frame=rows.size();row.source=sourceId;row.mode=mode;row.armed=armed?1:0;row.inputTime=inputTime;row.start=t;row.alpha=a;row.bound=b;row.shiftX=dx;row.shiftY=dy;row.completionObserved=-1;row.gpuMs=-1;
  if(mode==0){ctx->OMSetRenderTargets(0,nullptr,nullptr);ctx->CopyResource(back,source);}
  else {ctx->PSSetShaderResources(0,1,&sourceSR);draw(backRT,warp,p);ctx->PSSetShaderResources(0,1,&nil);}
  if(measure){ctx->End(tm.end);ctx->End(tm.disjoint);tm.row=rows.size();tm.epoch=timingEpoch;tm.pending=true;}
  row.submit=now();HRESULT hr=swap->Present(1,0);row.presentReturn=now();rows.push_back(row);
  if(hr==DXGI_STATUS_OCCLUDED){capture(false);Sleep(25);}else check(hr,"Present");
  if(rows.size()%60==0){char title[300];std::snprintf(title,sizeof(title),"YEORIN-X v4 timing lab | F1 native / F2 identity / F3 robust / F4 naive | F8 mouse | mode %d | alpha %.2f | GPU frame span %.3f ms",mode+1,a,gpuHistory.empty()?0:1000*gpuHistory.back());SetWindowTextA(win,title);}
 }
 void save(){
  if(ctx){ctx->Flush();double until=now()+.5;while(now()<until){poll();bool pending=false;for(auto&t:times)pending|=t.pending;if(!pending)break;Sleep(1);}}
  FILE*f=std::fopen(out.c_str(),"wb");if(!f)return;
  std::fprintf(f,"frame,source_id,mode,armed,input_arrival_s,frame_start_s,submit_s,present_return_s,gpu_completion_observed_s,gpu_frame_span_ms,alpha,conditional_bound_px2,shift_x,shift_y\n");
  for(auto&r:rows)std::fprintf(f,"%llu,%llu,%d,%d,%.9f,%.9f,%.9f,%.9f,%.9f,%.6f,%.9f,%.9f,%.6f,%.6f\n",r.frame,r.source,r.mode,r.armed,r.inputTime,r.start,r.submit,r.presentReturn,r.completionObserved,r.gpuMs,r.alpha,r.bound,r.shiftX,r.shiftY);
  std::fclose(f);
 }
};
App* app=nullptr;
LRESULT CALLBACK proc(HWND h,UINT m,WPARAM w,LPARAM l){
 if(app){
  if(m==WM_INPUT){app->input((HRAWINPUT)l);return DefWindowProc(h,m,w,l);}
  if(m==WM_ACTIVATE&&LOWORD(w)==WA_INACTIVE)app->capture(false);
  if(m==WM_SIZE&&w!=SIZE_MINIMIZED){int x=LOWORD(l),y=HIWORD(l);if(x>=64&&y>=64&&x<=4096&&y<=4096){app->width=x;app->height=y;app->resized=true;}}
  if(m==WM_KEYDOWN){
   if(w==VK_ESCAPE){if(app->armed)app->capture(false);else app->quit=true;return 0;}
   if(w>=VK_F1&&w<=VK_F4){app->mode=int(w-VK_F1);return 0;}
   if(w==VK_F8){app->capture(!app->armed);return 0;}
  }
  if(m==WM_CLOSE){app->quit=true;return 0;}
 }
 return DefWindowProc(h,m,w,l);
}
}
int WINAPI wWinMain(HINSTANCE inst,HINSTANCE,PWSTR,int){
 App a;app=&a;
 try{
  SetProcessDPIAware();int argc=0;LPWSTR*argv=CommandLineToArgvW(GetCommandLineW(),&argc);
  for(int i=1;i<argc;++i){if(!wcscmp(argv[i],L"--seconds")&&i+1<argc)a.duration=_wtof(argv[++i]);else if(!wcscmp(argv[i],L"--source-hz")&&i+1<argc)a.sourceHz=_wtof(argv[++i]);}
  LocalFree(argv);if(!std::isfinite(a.duration)||!std::isfinite(a.sourceHz)||a.duration<=0||a.duration>600||a.sourceHz<1||a.sourceHz>360)throw std::runtime_error("seconds must be 1..600; source-hz 1..360");
  WNDCLASSW wc={};wc.hInstance=inst;wc.lpfnWndProc=proc;wc.lpszClassName=L"Yeorin4Lab";wc.hCursor=LoadCursor(nullptr,IDC_ARROW);if(!RegisterClassW(&wc))throw std::runtime_error("RegisterClass failed");
  RECT r={0,0,a.width,a.height};AdjustWindowRect(&r,WS_OVERLAPPEDWINDOW,FALSE);a.win=CreateWindowW(wc.lpszClassName,L"YEORIN-X v4 | Source-owned timing laboratory, not a game overlay",WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,r.right-r.left,r.bottom-r.top,nullptr,nullptr,inst,nullptr);
  if(!a.win)throw std::runtime_error("CreateWindow failed");a.init();a.resized=false;ShowWindow(a.win,SW_SHOW);
  while(!a.quit){DWORD wait=MsgWaitForMultipleObjectsEx(1,&a.ready,100,QS_ALLINPUT,MWMO_INPUTAVAILABLE);MSG msg;
   while(PeekMessage(&msg,nullptr,0,0,PM_REMOVE)){if(msg.message==WM_QUIT)a.quit=true;TranslateMessage(&msg);DispatchMessage(&msg);}
   if(wait==WAIT_FAILED)throw std::runtime_error("Swap-chain wait failed");
   if(now()-a.startTime>=a.duration)a.quit=true;
   if(!a.quit&&wait==WAIT_OBJECT_0&&!IsIconic(a.win))a.frame();
  }
  a.capture(false);a.save();DestroyWindow(a.win);app=nullptr;return 0;
 }catch(const std::exception&e){a.capture(false);a.save();MessageBoxA(nullptr,e.what(),"YEORIN-X lab error",MB_ICONERROR);app=nullptr;return 1;}
}