756 lines
29 KiB
MQL5
756 lines
29 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| IVSurface3D.mq5 |
|
|
//| MMQ — Muhammad Minhas Qamar |
|
|
//| www.mql5.com/en/articles/23385 |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "MMQ — Muhammad Minhas Qamar"
|
|
#property link "https://www.mql5.com/en/articles/23385"
|
|
#property version "1.00"
|
|
#property indicator_chart_window
|
|
#property indicator_plots 0
|
|
#property indicator_buffers 0
|
|
|
|
#include <Canvas/Canvas3D.mqh>
|
|
#include <Canvas/DX/DXMesh.mqh>
|
|
#include <Canvas/DX/DXBox.mqh>
|
|
#include <IVSurface/IVSurfaceData.mqh>
|
|
#include <IVSurface/IVProviderNative.mqh>
|
|
|
|
enum ENUM_IV_SOURCE
|
|
{
|
|
IV_SOURCE_CSV = 0, // read a chain CSV from MQL5\Files
|
|
IV_SOURCE_NATIVE = 1 // enumerate the broker's MT5 option symbols
|
|
};
|
|
|
|
input ENUM_IV_SOURCE InpSource = IV_SOURCE_CSV;
|
|
input string InpCsvFile = "IVSurface\iv_chain_sample.csv";
|
|
input string InpUnderlying = ""; // native: base symbol, empty = current chart symbol
|
|
input double InpRiskFree = 0.045; // native: risk-free rate for IV inversion
|
|
input int InpRefreshSec = 0; // native: auto-refresh seconds (0 = manual R only)
|
|
input bool InpLightTheme = true; // light background (vs dark)
|
|
|
|
#define FRAME_MS 16
|
|
|
|
//--- geometry scale of the surface in world units
|
|
#define SURF_W 3.2f // strike axis span
|
|
#define SURF_D 3.2f // time axis span
|
|
#define SURF_H 1.6f // vol height span
|
|
|
|
//--- theme colours, resolved from InpLightTheme in ResolveTheme()
|
|
uint g_bgArgb; // 3D clear colour
|
|
color g_textColor; // overlay text
|
|
color g_panelColor; // overlay panel fill
|
|
color g_axisColor; // axis boxes / labels
|
|
|
|
//--- the 3D canvas, the surface mesh, the data, the camera
|
|
CCanvas3D g_canvas;
|
|
CDXMesh *g_mesh = NULL; // the solid shaded surface
|
|
CDXMesh *g_wire = NULL; // a line-list mesh overlaying the quote grid
|
|
CDXBox *g_rodX = NULL; // coloured spine along the strike edge
|
|
CDXBox *g_rodY = NULL; // coloured spine along the implied-vol edge
|
|
CDXBox *g_rodZ = NULL; // coloured spine along the time edge
|
|
CIVSurface g_surf;
|
|
string g_objName = "IVSurface3D_canvas";
|
|
|
|
//--- wireframe vertices (share the surface geometry) + edge index list
|
|
DXVertex g_wireVerts[];
|
|
uint g_wireIdx[];
|
|
|
|
DXVertex g_verts[];
|
|
uint g_idx[];
|
|
|
|
double g_camYaw = 0.7;
|
|
double g_camPitch = 0.5;
|
|
double g_camDist = 6.5;
|
|
bool g_dragging = false;
|
|
int g_dragX = 0, g_dragY = 0;
|
|
datetime g_lastRefresh = 0;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| MQL5 colour -> DXColor (normalized RGBA). |
|
|
//+------------------------------------------------------------------+
|
|
DXColor ToDXColor(const color clr, const float a = 1.0f)
|
|
{
|
|
DXColor c;
|
|
c.r = ((clr) & 0xFF) / 255.0f;
|
|
c.g = ((clr >> 8) & 0xFF) / 255.0f;
|
|
c.b = ((clr >> 16) & 0xFF) / 255.0f;
|
|
c.a = a;
|
|
return(c);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Map a normalized value t in [0,1] to a blue->green->red ramp, |
|
|
//| the classic "cool low vol, hot high vol" heat scale. |
|
|
//+------------------------------------------------------------------+
|
|
DXColor HeatColor(double t)
|
|
{
|
|
if(t < 0.0)
|
|
t = 0.0;
|
|
if(t > 1.0)
|
|
t = 1.0;
|
|
double r, g, b;
|
|
if(t < 0.5)
|
|
{
|
|
double u = t / 0.5;
|
|
r = 0.1;
|
|
g = 0.2 + 0.7 * u;
|
|
b = 0.9 - 0.5 * u;
|
|
}
|
|
else
|
|
{
|
|
double u = (t - 0.5) / 0.5;
|
|
r = 0.1 + 0.9 * u;
|
|
g = 0.9 - 0.7 * u;
|
|
b = 0.4 - 0.4 * u;
|
|
}
|
|
DXColor c;
|
|
c.r = (float)r;
|
|
c.g = (float)g;
|
|
c.b = (float)b;
|
|
c.a = 1.0f;
|
|
return(c);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Resolve the theme palette from the light/dark input. Kept in one |
|
|
//| place so the 3D clear colour and the 2D overlay stay consistent. |
|
|
//+------------------------------------------------------------------+
|
|
void ResolveTheme(void)
|
|
{
|
|
if(InpLightTheme)
|
|
{
|
|
g_bgArgb = ColorToARGB((color)0xEDEFF2);
|
|
g_textColor = (color)0x2A2E33;
|
|
g_panelColor = (color)0xFFFFFF;
|
|
g_axisColor = (color)0x606060;
|
|
}
|
|
else
|
|
{
|
|
g_bgArgb = ColorToARGB((color)0x0E1116);
|
|
g_textColor = (color)0xD8DEE6;
|
|
g_panelColor = (color)0x1A1E24;
|
|
g_axisColor = (color)0x9098A0;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Map a data point (strike, timeYears, iv) to its world position, |
|
|
//| using the same normalization the surface mesh uses so labels and |
|
|
//| gridlines line up exactly with the surface. |
|
|
//+------------------------------------------------------------------+
|
|
DXVector3 DataToWorld(const double strike, const double t, const double iv)
|
|
{
|
|
int nx = g_surf.NStrikes(), ny = g_surf.NTimes();
|
|
double kMin = g_surf.Strike(0), kMax = g_surf.Strike(nx - 1);
|
|
double tMin = g_surf.TimeYears(0), tMax = g_surf.TimeYears(ny - 1);
|
|
double vMin = g_surf.IVMin(), vMax = g_surf.IVMax();
|
|
double x = ((strike - kMin) / MathMax(kMax - kMin, 1e-9) - 0.5) * SURF_W;
|
|
double z = ((t - tMin) / MathMax(tMax - tMin, 1e-9) - 0.5) * SURF_D;
|
|
double y = ((iv - vMin) / MathMax(vMax - vMin, 1e-9) - 0.5) * SURF_H;
|
|
return(DXVector3((float)x, (float)y, (float)z));
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Project a world position to 2D screen pixels using the canvas's |
|
|
//| current view and projection matrices. Returns false when the |
|
|
//| point is behind the camera. This is the workhorse that lets us |
|
|
//| draw axis tick numbers and titles that track the surface as the |
|
|
//| camera orbits (CCanvas3D has no native 3D text). |
|
|
//+------------------------------------------------------------------+
|
|
bool WorldToScreen(const DXVector3 &world, int &sx, int &sy)
|
|
{
|
|
DXMatrix view, proj, vp;
|
|
g_canvas.ViewMatrixGet(view);
|
|
g_canvas.ProjectionMatrixGet(proj);
|
|
DXMatrixMultiply(vp, view, proj);
|
|
|
|
DXVector4 p = DXVector4(world.x, world.y, world.z, 1.0f), clip;
|
|
DXVec4Transform(clip, p, vp);
|
|
if(clip.w <= 1e-5)
|
|
return(false);
|
|
|
|
double ndcX = clip.x / clip.w;
|
|
double ndcY = clip.y / clip.w;
|
|
sx = (int)((ndcX * 0.5 + 0.5) * g_canvas.Width());
|
|
sy = (int)((1.0 - (ndcY * 0.5 + 0.5)) * g_canvas.Height());
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Build a line-list wireframe over the surface. Every strike |
|
|
//| gridline and every expiry gridline becomes a pair of vertices, |
|
|
//| so DirectX draws the quote lattice as thin lines on top of the |
|
|
//| solid surface (the classic vol-surface look). |
|
|
//+------------------------------------------------------------------+
|
|
void RebuildWireData(void)
|
|
{
|
|
int nx = g_surf.NStrikes(), ny = g_surf.NTimes();
|
|
int count = nx * ny;
|
|
ArrayResize(g_wireVerts, count);
|
|
|
|
//--- lift the wire a hair above the surface so it does not z-fight
|
|
DXColor line = ToDXColor(InpLightTheme ? (color)0x303438 : (color)0xC8CED6);
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
g_wireVerts[i] = g_verts[i];
|
|
g_wireVerts[i].position.y += 0.004f;
|
|
g_wireVerts[i].vcolor = line;
|
|
}
|
|
|
|
//--- horizontal edges (along strike) + vertical edges (along expiry)
|
|
int nEdges = ny * (nx - 1) + nx * (ny - 1);
|
|
ArrayResize(g_wireIdx, nEdges * 2);
|
|
int c = 0;
|
|
for(int j = 0; j < ny; j++)
|
|
for(int k = 0; k < nx - 1; k++)
|
|
{ g_wireIdx[c++] = j * nx + k; g_wireIdx[c++] = j * nx + k + 1; }
|
|
for(int k = 0; k < nx; k++)
|
|
for(int j = 0; j < ny - 1; j++)
|
|
{ g_wireIdx[c++] = j * nx + k; g_wireIdx[c++] = (j + 1) * nx + k; }
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Create the wireframe mesh from the current grid and register it |
|
|
//| with the canvas. |
|
|
//+------------------------------------------------------------------+
|
|
bool BuildWireframe(void)
|
|
{
|
|
RebuildWireData();
|
|
g_wire = new CDXMesh;
|
|
if(!g_wire.Create(g_canvas.DXDispatcher(), g_canvas.InputScene(),
|
|
g_wireVerts, g_wireIdx, DX_PRIMITIVE_TOPOLOGY_LINELIST))
|
|
return(false);
|
|
g_canvas.ObjectAdd(g_wire);
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Three thin coloured CDXBox rods running along the same three |
|
|
//| edges the tick labels annotate, so each axis has a colour spine: |
|
|
//| blue = strike, green = time, red = implied vol. They double as a |
|
|
//| colour key next to the numeric labels. |
|
|
//+------------------------------------------------------------------+
|
|
bool BuildAxisRods(void)
|
|
{
|
|
float t = 0.014f; // rod half-thickness
|
|
float ox = -SURF_W * 0.5f, oy = -SURF_H * 0.5f, oz = -SURF_D * 0.5f; // the labelled corner
|
|
CDXDispatcher *d = g_canvas.DXDispatcher();
|
|
CDXInput *s = g_canvas.InputScene();
|
|
|
|
g_rodX = new CDXBox;
|
|
g_rodY = new CDXBox;
|
|
g_rodZ = new CDXBox;
|
|
|
|
//--- strike spine: along X at (min time, min vol) edge
|
|
if(!g_rodX.Create(d, s, DXVector3(ox, oy - t, oz - t), DXVector3(ox + SURF_W, oy + t, oz + t)))
|
|
return(false);
|
|
//--- implied-vol spine: up Y at (min strike, min time) edge
|
|
if(!g_rodY.Create(d, s, DXVector3(ox - t, oy, oz - t), DXVector3(ox + t, oy + SURF_H, oz + t)))
|
|
return(false);
|
|
//--- time spine: along Z at (max strike, min vol) edge (matches the labels)
|
|
if(!g_rodZ.Create(d, s, DXVector3(ox + SURF_W - t, oy - t, oz), DXVector3(ox + SURF_W + t, oy + t, oz + SURF_D)))
|
|
return(false);
|
|
|
|
g_rodX.DiffuseColorSet(ToDXColor((color)0x1E6FBF)); // blue strike
|
|
g_rodY.DiffuseColorSet(ToDXColor((color)0xC23A5A)); // red vol
|
|
g_rodZ.DiffuseColorSet(ToDXColor((color)0x1FA36A)); // green time
|
|
g_rodX.EmissionColorSet(ToDXColor((color)0x1E6FBF, 0.4f)); // glow a little so they read on any angle
|
|
g_rodY.EmissionColorSet(ToDXColor((color)0xC23A5A, 0.4f));
|
|
g_rodZ.EmissionColorSet(ToDXColor((color)0x1FA36A, 0.4f));
|
|
g_canvas.ObjectAdd(g_rodX);
|
|
g_canvas.ObjectAdd(g_rodY);
|
|
g_canvas.ObjectAdd(g_rodZ);
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Load the chosen data source into g_surf. Returns false if no |
|
|
//| usable surface could be built. |
|
|
//+------------------------------------------------------------------+
|
|
bool LoadData(void)
|
|
{
|
|
OptionQuote quotes[];
|
|
bool ok = false;
|
|
if(InpSource == IV_SOURCE_CSV)
|
|
{
|
|
CIVProviderCSV csv;
|
|
ok = csv.Load(InpCsvFile, quotes);
|
|
}
|
|
else
|
|
{
|
|
string under = (InpUnderlying == "") ? _Symbol : InpUnderlying;
|
|
CIVProviderNative nat;
|
|
ok = nat.Load(under, InpRiskFree, quotes);
|
|
}
|
|
if(!ok)
|
|
{
|
|
Print("IVSurface3D: data load failed");
|
|
return(false);
|
|
}
|
|
if(!g_surf.Build(quotes))
|
|
{
|
|
Print("IVSurface3D: surface build failed (need >=2 strikes and >=2 expiries)");
|
|
return(false);
|
|
}
|
|
PrintFormat("IVSurface3D: %d x %d grid, IV %.1f%%..%.1f%%",
|
|
g_surf.NStrikes(), g_surf.NTimes(), g_surf.IVMin() * 100, g_surf.IVMax() * 100);
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Build the surface mesh vertices from the current grid. x maps to |
|
|
//| strike, z to time-to-expiry, y (height) and colour to IV, each |
|
|
//| normalized to the world-unit box so any chain fits the view. |
|
|
//+------------------------------------------------------------------+
|
|
void BuildMeshVertices(void)
|
|
{
|
|
int nx = g_surf.NStrikes(), ny = g_surf.NTimes();
|
|
int count = nx * ny;
|
|
if(ArraySize(g_verts) != count)
|
|
ArrayResize(g_verts, count);
|
|
|
|
double kMin = g_surf.Strike(0), kMax = g_surf.Strike(nx - 1);
|
|
double tMin = g_surf.TimeYears(0), tMax = g_surf.TimeYears(ny - 1);
|
|
double vMin = g_surf.IVMin(), vMax = g_surf.IVMax();
|
|
double kSpan = MathMax(kMax - kMin, 1e-9);
|
|
double tSpan = MathMax(tMax - tMin, 1e-9);
|
|
double vSpan = MathMax(vMax - vMin, 1e-9);
|
|
|
|
for(int j = 0; j < ny; j++)
|
|
for(int k = 0; k < nx; k++)
|
|
{
|
|
int i = j * nx + k;
|
|
double iv = g_surf.IV(j, k);
|
|
double vt = (iv - vMin) / vSpan;
|
|
double x = ((g_surf.Strike(k) - kMin) / kSpan - 0.5) * SURF_W;
|
|
double z = ((g_surf.TimeYears(j) - tMin) / tSpan - 0.5) * SURF_D;
|
|
double y = (vt - 0.5) * SURF_H;
|
|
g_verts[i].position = DXVector4((float)x, (float)y, (float)z, 1.0f);
|
|
g_verts[i].normal = DXVector4(0, 1, 0, 0);
|
|
g_verts[i].tcoord = DXVector2((float)k / (nx - 1), (float)j / (ny - 1));
|
|
g_verts[i].vcolor = HeatColor(vt);
|
|
}
|
|
RecomputeNormals();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Two triangles per grid cell; the index list is static for a |
|
|
//| given grid size, so we only rebuild it when the grid changes. |
|
|
//+------------------------------------------------------------------+
|
|
void BuildMeshIndices(void)
|
|
{
|
|
int nx = g_surf.NStrikes(), ny = g_surf.NTimes();
|
|
int cells = (nx - 1) * (ny - 1);
|
|
ArrayResize(g_idx, cells * 6);
|
|
int c = 0;
|
|
for(int j = 0; j < ny - 1; j++)
|
|
for(int k = 0; k < nx - 1; k++)
|
|
{
|
|
int i0 = j * nx + k, i1 = j * nx + k + 1, i2 = (j + 1) * nx + k, i3 = (j + 1) * nx + k + 1;
|
|
g_idx[c++] = i0;
|
|
g_idx[c++] = i2;
|
|
g_idx[c++] = i1;
|
|
g_idx[c++] = i1;
|
|
g_idx[c++] = i2;
|
|
g_idx[c++] = i3;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Smooth per-vertex normals accumulated from adjacent faces, so |
|
|
//| the lighting follows the ridges and valleys of the surface. |
|
|
//+------------------------------------------------------------------+
|
|
void RecomputeNormals(void)
|
|
{
|
|
int count = ArraySize(g_verts);
|
|
for(int i = 0; i < count; i++)
|
|
g_verts[i].normal = DXVector4(0, 0, 0, 0);
|
|
int tris = ArraySize(g_idx) / 3;
|
|
for(int t = 0; t < tris; t++)
|
|
{
|
|
uint ia = g_idx[t * 3 + 0], ib = g_idx[t * 3 + 1], ic = g_idx[t * 3 + 2];
|
|
DXVector3 a = DXVector3(g_verts[ia].position.x, g_verts[ia].position.y, g_verts[ia].position.z);
|
|
DXVector3 b = DXVector3(g_verts[ib].position.x, g_verts[ib].position.y, g_verts[ib].position.z);
|
|
DXVector3 cc = DXVector3(g_verts[ic].position.x, g_verts[ic].position.y, g_verts[ic].position.z);
|
|
DXVector3 ab, ac, fn;
|
|
DXVec3Subtract(ab, b, a);
|
|
DXVec3Subtract(ac, cc, a);
|
|
DXVec3Cross(fn, ab, ac);
|
|
g_verts[ia].normal.x += fn.x;
|
|
g_verts[ia].normal.y += fn.y;
|
|
g_verts[ia].normal.z += fn.z;
|
|
g_verts[ib].normal.x += fn.x;
|
|
g_verts[ib].normal.y += fn.y;
|
|
g_verts[ib].normal.z += fn.z;
|
|
g_verts[ic].normal.x += fn.x;
|
|
g_verts[ic].normal.y += fn.y;
|
|
g_verts[ic].normal.z += fn.z;
|
|
}
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
DXVector3 n = DXVector3(g_verts[i].normal.x, g_verts[i].normal.y, g_verts[i].normal.z);
|
|
DXVec3Normalize(n, n);
|
|
g_verts[i].normal = DXVector4(n.x, n.y, n.z, 0.0f);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Place the camera from yaw/pitch/distance. |
|
|
//+------------------------------------------------------------------+
|
|
void UpdateCamera(void)
|
|
{
|
|
double cp = MathCos(g_camPitch), sp = MathSin(g_camPitch);
|
|
double cy = MathCos(g_camYaw), sy = MathSin(g_camYaw);
|
|
DXVector3 eye;
|
|
eye.x = (float)(g_camDist * cp * sy);
|
|
eye.y = (float)(g_camDist * sp);
|
|
eye.z = (float)(g_camDist * cp * cy);
|
|
g_canvas.ViewPositionSet(eye);
|
|
g_canvas.ViewTargetSet(DXVector3(0.0f, 0.0f, 0.0f));
|
|
g_canvas.ViewUpDirectionSet(DXVector3(0.0f, 1.0f, 0.0f));
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| "Nice number" helper: round a raw step to 1/2/5 x 10^n so tick |
|
|
//| labels land on human-friendly values. |
|
|
//+------------------------------------------------------------------+
|
|
double NiceStep(const double range, const int target)
|
|
{
|
|
double raw = range / MathMax(target, 1);
|
|
double mag = MathPow(10, MathFloor(MathLog10(raw)));
|
|
double n = raw / mag;
|
|
double nice = (n < 1.5) ? 1 : (n < 3) ? 2 : (n < 7) ? 5 : 10;
|
|
return(nice * mag);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Draw numeric tick labels along the three axes and an axis title |
|
|
//| beside each, by projecting world positions to screen pixels. This|
|
|
//| gives the surface the labelled coordinate frame that turns it |
|
|
//| from a floating blob into a readable chart. |
|
|
//+------------------------------------------------------------------+
|
|
void DrawAxes3D(void)
|
|
{
|
|
int nx = g_surf.NStrikes(), ny = g_surf.NTimes();
|
|
double kMin = g_surf.Strike(0), kMax = g_surf.Strike(nx - 1);
|
|
double tMin = g_surf.TimeYears(0), tMax = g_surf.TimeYears(ny - 1);
|
|
double vMin = g_surf.IVMin(), vMax = g_surf.IVMax();
|
|
uint axisClr = ColorToARGB(g_axisColor);
|
|
uint titleClr = ColorToARGB(g_textColor);
|
|
int sx, sy;
|
|
|
|
double ex = g_camDist * MathCos(g_camPitch) * MathSin(g_camYaw);
|
|
double ez = g_camDist * MathCos(g_camPitch) * MathCos(g_camYaw);
|
|
bool strikeVisible = (ez < 0.0); // strike edge sits on the -Z face
|
|
bool timeVisible = (ex > 0.0); // time edge sits on the +X face
|
|
bool volVisible = (ex < 0.0 || ez < 0.0); // vertical spine at the (-X,-Z) corner
|
|
|
|
g_canvas.FontSet("Segoe UI", 12, FW_BOLD);
|
|
|
|
if(strikeVisible)
|
|
{
|
|
double kStep = NiceStep(kMax - kMin, 6);
|
|
for(double k = MathCeil(kMin / kStep) * kStep; k <= kMax + 1e-6; k += kStep)
|
|
{
|
|
DXVector3 w = DataToWorld(k, tMin, vMin);
|
|
if(WorldToScreen(w, sx, sy))
|
|
g_canvas.TextOut(sx, sy + 6, StringFormat("%.0f", k), axisClr, TA_CENTER);
|
|
}
|
|
}
|
|
if(timeVisible)
|
|
{
|
|
double tStep = NiceStep(tMax - tMin, 5);
|
|
for(double t = MathCeil(tMin / tStep) * tStep; t <= tMax + 1e-6; t += tStep)
|
|
{
|
|
DXVector3 w = DataToWorld(kMax, t, vMin);
|
|
if(WorldToScreen(w, sx, sy))
|
|
g_canvas.TextOut(sx + 8, sy, StringFormat("%.2fy", t), axisClr, TA_LEFT);
|
|
}
|
|
}
|
|
if(volVisible)
|
|
{
|
|
double vStep = NiceStep(vMax - vMin, 5);
|
|
for(double v = MathCeil(vMin / vStep) * vStep; v <= vMax + 1e-6; v += vStep)
|
|
{
|
|
DXVector3 w = DataToWorld(kMin, tMin, v);
|
|
if(WorldToScreen(w, sx, sy))
|
|
g_canvas.TextOut(sx - 8, sy - 7, StringFormat("%.0f%%", v * 100), axisClr, TA_RIGHT);
|
|
}
|
|
}
|
|
|
|
//--- axis titles at the midpoints, gated by the same visibility
|
|
g_canvas.FontSet("Segoe UI", 14, FW_BOLD);
|
|
DXVector3 wt;
|
|
if(strikeVisible)
|
|
{
|
|
wt = DataToWorld((kMin + kMax) * 0.5, tMin, vMin);
|
|
if(WorldToScreen(wt, sx, sy))
|
|
g_canvas.TextOut(sx, sy + 26, "Strike", titleClr, TA_CENTER);
|
|
}
|
|
if(timeVisible)
|
|
{
|
|
wt = DataToWorld(kMax, (tMin + tMax) * 0.5, vMin);
|
|
if(WorldToScreen(wt, sx, sy))
|
|
g_canvas.TextOut(sx + 40, sy + 8, "Time to Expiry", titleClr, TA_LEFT);
|
|
}
|
|
if(volVisible)
|
|
{
|
|
wt = DataToWorld(kMin, tMin, (vMin + vMax) * 0.5);
|
|
if(WorldToScreen(wt, sx, sy))
|
|
g_canvas.TextOut(sx - 44, sy - 8, "Implied Vol", titleClr, TA_RIGHT);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 2D overlay drawn on top of the finished 3D frame. Because |
|
|
//| CCanvas3D inherits the 2D CCanvas drawing calls, we can paint a |
|
|
//| title, an axis key, a colour legend for the implied-vol scale, |
|
|
//| and a spot / range readout straight onto the same bitmap after |
|
|
//| Render() but before Update() flushes it to the chart. |
|
|
//+------------------------------------------------------------------+
|
|
void DrawOverlay(void)
|
|
{
|
|
DrawAxes3D(); // projected axis ticks + titles, under the panels
|
|
int W = g_canvas.Width();
|
|
uint txt = ColorToARGB(g_textColor);
|
|
uint dim = ColorToARGB(g_textColor, 200);
|
|
|
|
//--- title card (top-left)
|
|
int px = 12, py = 12, pw = 330, ph = 70;
|
|
uint card = ColorToARGB(g_panelColor, 235); // near-opaque card
|
|
uint border = ColorToARGB(InpLightTheme ? (color)0xC4C8CE : (color)0x2E343C);
|
|
uint header = ColorToARGB(InpLightTheme ? (color)0x2A2E33 : (color)0x3A4048);
|
|
g_canvas.FillRectangle(px, py, px + pw, py + ph, card);
|
|
g_canvas.Rectangle(px, py, px + pw, py + ph, border); // crisp border
|
|
g_canvas.FillRectangle(px, py, px + pw, py + 34, header); // title bar
|
|
g_canvas.FontSet("Segoe UI", 18, FW_BOLD);
|
|
g_canvas.TextOut(px + 14, py + 7, "Implied Volatility Surface", ColorToARGB(clrWhite));
|
|
g_canvas.FontSet("Segoe UI", 14);
|
|
g_canvas.TextOut(px + 14, py + 44, StringFormat("spot %.2f IV %.1f%% - %.1f%%",
|
|
g_surf.Spot(), g_surf.IVMin() * 100.0, g_surf.IVMax() * 100.0), txt);
|
|
|
|
//--- vertical colour legend (right edge)
|
|
int lx = W - 52, lw = 22;
|
|
int barTop = 70, barBot = 300;
|
|
for(int y = barTop; y < barBot; y++)
|
|
{
|
|
double t = 1.0 - (double)(y - barTop) / (barBot - barTop); // top = high vol
|
|
DXColor c = HeatColor(t);
|
|
color mc = (color)(((int)(c.b * 255) << 16) | ((int)(c.g * 255) << 8) | (int)(c.r * 255));
|
|
g_canvas.LineHorizontal(lx, lx + lw, y, ColorToARGB(mc));
|
|
}
|
|
g_canvas.Rectangle(lx, barTop, lx + lw, barBot, ColorToARGB(InpLightTheme ? (color)0x808890 : (color)0x505860));
|
|
g_canvas.FontSet("Segoe UI", 13, FW_BOLD);
|
|
g_canvas.TextOut(lx + lw - 2, barTop - 20, StringFormat("%.0f%%", g_surf.IVMax() * 100.0), txt, TA_RIGHT);
|
|
g_canvas.TextOut(lx + lw - 2, barBot + 4, StringFormat("%.0f%%", g_surf.IVMin() * 100.0), txt, TA_RIGHT);
|
|
g_canvas.TextOut(lx + lw - 2, (barTop + barBot) / 2 - 8, "IV", txt, TA_RIGHT);
|
|
|
|
//--- controls hint (bottom-left)
|
|
g_canvas.FontSet("Segoe UI", 13);
|
|
g_canvas.TextOut(20, g_canvas.Height() - 26,
|
|
"drag: orbit wheel: zoom R: reload", dim);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Create the 3D canvas + bind a chart object, build the mesh from |
|
|
//| the loaded surface, and set camera / projection / lighting. |
|
|
//+------------------------------------------------------------------+
|
|
bool CreateScene(void)
|
|
{
|
|
int w = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
|
|
int h = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
|
|
if(w < 50 || h < 50)
|
|
return(false);
|
|
|
|
//--- create the 3D canvas (builds DX context + scene input) then bind an
|
|
//--- OBJ_BITMAP_LABEL to its resource so the frames are actually shown.
|
|
if(!g_canvas.Create(g_objName, w, h, COLOR_FORMAT_ARGB_NORMALIZE))
|
|
{ Print("IVSurface3D: 3D canvas Create failed - is DirectX 11 available?"); return(false); }
|
|
if(ObjectFind(0, g_objName) < 0)
|
|
ObjectCreate(0, g_objName, OBJ_BITMAP_LABEL, 0, 0, 0);
|
|
ObjectSetInteger(0, g_objName, OBJPROP_XDISTANCE, 0);
|
|
ObjectSetInteger(0, g_objName, OBJPROP_YDISTANCE, 0);
|
|
ObjectSetInteger(0, g_objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
|
ObjectSetInteger(0, g_objName, OBJPROP_BACK, false);
|
|
ObjectSetInteger(0, g_objName, OBJPROP_SELECTABLE, false);
|
|
ObjectSetInteger(0, g_objName, OBJPROP_HIDDEN, true);
|
|
ObjectSetString(0, g_objName, OBJPROP_BMPFILE, g_canvas.ResourceName());
|
|
|
|
g_canvas.ProjectionMatrixSet((float)(M_PI / 5.0), (float)w / h, 0.1f, 100.0f);
|
|
DXVector3 light = DXVector3(0.3f, -0.8f, 0.5f);
|
|
DXVec3Normalize(light, light);
|
|
g_canvas.LightDirectionSet(light);
|
|
g_canvas.LightColorSet(ToDXColor(clrWhite));
|
|
//--- brighter ambient on a light theme so shaded faces do not go muddy
|
|
g_canvas.AmbientColorSet(ToDXColor(InpLightTheme ? (color)0x8A8E94 : (color)0x505560));
|
|
UpdateCamera();
|
|
|
|
BuildMeshIndices();
|
|
BuildMeshVertices();
|
|
g_mesh = new CDXMesh;
|
|
if(!g_mesh.Create(g_canvas.DXDispatcher(), g_canvas.InputScene(), g_verts, g_idx))
|
|
{ Print("IVSurface3D: surface mesh Create failed"); return(false); }
|
|
g_mesh.SpecularColorSet(ToDXColor(clrWhite));
|
|
g_mesh.SpecularPowerSet(24.0f);
|
|
g_canvas.ObjectAdd(g_mesh);
|
|
|
|
if(!BuildWireframe())
|
|
Print("IVSurface3D: wireframe creation failed (surface still renders)");
|
|
if(!BuildAxisRods())
|
|
Print("IVSurface3D: axis rods creation failed (surface still renders)");
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization: load data, build the scene, start timer. |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit(void)
|
|
{
|
|
ResolveTheme();
|
|
if(!LoadData())
|
|
return(INIT_FAILED);
|
|
if(!CreateScene())
|
|
return(INIT_FAILED);
|
|
ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, true);
|
|
ChartSetInteger(0, CHART_MOUSE_SCROLL, false);
|
|
EventSetMillisecondTimer(FRAME_MS);
|
|
g_lastRefresh = TimeCurrent();
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization: tear down the scene in the right order. |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
EventKillTimer();
|
|
ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, false);
|
|
ChartSetInteger(0, CHART_MOUSE_SCROLL, true);
|
|
|
|
ObjectDelete(0, g_objName);
|
|
ChartRedraw(0);
|
|
g_canvas.Destroy();
|
|
|
|
g_mesh = NULL;
|
|
g_wire = NULL;
|
|
g_rodX = NULL;
|
|
g_rodY = NULL;
|
|
g_rodZ = NULL;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Custom indicator iteration function (unused, no plots/buffers). |
|
|
//+------------------------------------------------------------------+
|
|
int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
|
|
{
|
|
return(rates_total);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Rebuild the surface mesh from freshly loaded data (native source |
|
|
//| auto-refresh, or a manual R press). |
|
|
//+------------------------------------------------------------------+
|
|
void Reload(void)
|
|
{
|
|
if(!LoadData() || g_mesh == NULL)
|
|
return;
|
|
BuildMeshIndices();
|
|
BuildMeshVertices();
|
|
//--- grid dimensions may have changed, so rebuild both meshes in place
|
|
//--- (they stay registered with the canvas, so we do not ObjectAdd again)
|
|
g_mesh.Create(g_canvas.DXDispatcher(), g_canvas.InputScene(), g_verts, g_idx);
|
|
g_mesh.SpecularColorSet(ToDXColor(clrWhite));
|
|
g_mesh.SpecularPowerSet(24.0f);
|
|
|
|
if(g_wire != NULL)
|
|
{
|
|
RebuildWireData();
|
|
g_wire.Create(g_canvas.DXDispatcher(), g_canvas.InputScene(),
|
|
g_wireVerts, g_wireIdx, DX_PRIMITIVE_TOPOLOGY_LINELIST);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Timer tick: auto-refresh the native source, then render + flush |
|
|
//| a fresh frame with the 2D overlay drawn on top. |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer(void)
|
|
{
|
|
if(InpSource == IV_SOURCE_NATIVE && InpRefreshSec > 0 &&
|
|
TimeCurrent() - g_lastRefresh >= InpRefreshSec)
|
|
{ Reload(); g_lastRefresh = TimeCurrent(); }
|
|
|
|
g_canvas.Render(DX_CLEAR_COLOR | DX_CLEAR_DEPTH, g_bgArgb);
|
|
DrawOverlay(); // 2D title / legend / axis key on top of the 3D frame
|
|
g_canvas.Update(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Mouse drag orbits the camera, wheel zooms, R reloads the data, |
|
|
//| and a chart resize rebuilds the DX scene at the new pixel size. |
|
|
//+------------------------------------------------------------------+
|
|
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
|
|
{
|
|
if(id == CHARTEVENT_MOUSE_MOVE)
|
|
{
|
|
int mx = (int)lparam, my = (int)dparam;
|
|
bool leftDown = (((uint)sparam & 1) != 0);
|
|
if(leftDown && !g_dragging)
|
|
{
|
|
g_dragging = true;
|
|
g_dragX = mx;
|
|
g_dragY = my;
|
|
}
|
|
else
|
|
if(leftDown && g_dragging)
|
|
{
|
|
g_camYaw -= (mx - g_dragX) * 0.01;
|
|
g_camPitch += (my - g_dragY) * 0.01;
|
|
if(g_camPitch > 1.45)
|
|
g_camPitch = 1.45;
|
|
if(g_camPitch < -0.2)
|
|
g_camPitch = -0.2;
|
|
g_dragX = mx;
|
|
g_dragY = my;
|
|
UpdateCamera();
|
|
}
|
|
else
|
|
if(!leftDown)
|
|
g_dragging = false;
|
|
return;
|
|
}
|
|
if(id == CHARTEVENT_MOUSE_WHEEL)
|
|
{
|
|
g_camDist *= (dparam > 0) ? 0.92 : 1.08;
|
|
if(g_camDist < 2.5)
|
|
g_camDist = 2.5;
|
|
if(g_camDist > 18.0)
|
|
g_camDist = 18.0;
|
|
UpdateCamera();
|
|
return;
|
|
}
|
|
if(id == CHARTEVENT_KEYDOWN)
|
|
{
|
|
if((int)lparam == 'R')
|
|
Reload();
|
|
return;
|
|
}
|
|
if(id == CHARTEVENT_CHART_CHANGE)
|
|
{
|
|
int w = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
|
|
int h = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
|
|
if(w > 50 && h > 50 && (w != g_canvas.Width() || h != g_canvas.Height()))
|
|
{
|
|
g_canvas.Destroy(); // frees the meshes it owns
|
|
g_mesh = NULL;
|
|
g_wire = NULL;
|
|
g_rodX = NULL;
|
|
g_rodY = NULL;
|
|
g_rodZ = NULL;
|
|
CreateScene(); // re-new's them at the new size
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|