Transparent vertex points as little as pixels in Direct3D9

#include <Windows.h>
#include <tchar.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <mmsystem.h> //for timeGetTime to rotate it around
#include <stdio.h>

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#pragma comment(lib, "winmm.lib")

typedef struct {
	D3DXVECTOR3 vPos;
    D3DCOLOR colDiffuse;
	D3DXVECTOR2 vUV;
} PicVertex;

typedef struct {
	D3DXVECTOR3 vPos;
    D3DCOLOR colDiffuse;
	D3DXVECTOR2 vUV;
} PointVertex;

typedef struct {
	D3DXVECTOR3 vPos;
    D3DCOLOR colDiffuse;
} PixelVertex;

#define D3DFVF_PICVERTEX (D3DFVF_DIFFUSE | D3DFVF_XYZ | D3DFVF_TEX1)
#define D3DFVF_PIXELVERTEX (D3DFVF_DIFFUSE | D3DFVF_XYZ)
#define D3DFVF_POINTVERTEX (D3DFVF_DIFFUSE | D3DFVF_XYZ | D3DFVF_TEX1)

#define ADD_POINT_UV(x, y, z, size, col, u, v) { D3DXVECTOR3(x + (u - 0.5f) * size, y + (v - 0.5f) * size, z), col, D3DXVECTOR2(u, v) }
#define ADD_POINT(x, y, z, size, col) \
	ADD_POINT_UV(x, y, z, size, col, 0.0f, 1.0f),\
	ADD_POINT_UV(x, y, z, size, col, 0.0f, 0.0f),\
	ADD_POINT_UV(x, y, z, size, col, 1.0f, 1.0f),\
	ADD_POINT_UV(x, y, z, size, col, 1.0f, 1.0f),\
	ADD_POINT_UV(x, y, z, size, col, 0.0f, 0.0f),\
	ADD_POINT_UV(x, y, z, size, col, 1.0f, 0.0f),
#define ADD_PIXEL(x, y, z, col) { D3DXVECTOR3(x, y, z), col },

LPDIRECT3D9 g_pD3D = NULL; //Our DirectX handle
LPDIRECT3DDEVICE9 g_pd3dDevice = NULL; //Our DirectX device
LPDIRECT3DVERTEXBUFFER9 g_pQuadVB = NULL; //The vertex buffer for the quad 4 verts per quad
LPDIRECT3DVERTEXBUFFER9 g_pPixelVB = NULL; //The vertex buffer for the single pixel points, 1 vert per pixel
LPDIRECT3DVERTEXBUFFER9 g_pPointVB = NULL; //The vertex buffer for our multi-pixel points, 4 verts per quad
LPD3DXEFFECT g_pEffect = NULL; //The shader file
D3DXHANDLE g_pPointEffect = NULL; //The effect for rendering the point
D3DXHANDLE g_pFFEffect = NULL; //The effect for rendering everything else (this is a NULL effect, which is the default Fixed Function pipeline in DX9)
LPDIRECT3DVERTEXDECLARATION9 g_pVertexDeclaration = NULL; //The input data specification for our custom shader
LPDIRECT3DTEXTURE9 g_pTexture = NULL; //The texture to be rendered onto the quad

//The quad, same as yours
PicVertex aQuad[] =  {
	//The quad that you will texture. I have not textured it, but I'm sure you can figure that out
	{ D3DXVECTOR3(-1.0f,  1.0f, 0.0f), D3DCOLOR_ARGB(255, 255, 255, 255), D3DXVECTOR2(0.0f, 0.0f) },
	{ D3DXVECTOR3(-1.0f, -1.0f, 0.0f), D3DCOLOR_ARGB(255, 255, 255, 255), D3DXVECTOR2(0.0f, 1.0f) },
	{ D3DXVECTOR3( 1.0f,  1.0f, 0.0f), D3DCOLOR_ARGB(255, 255, 255, 255), D3DXVECTOR2(1.0f, 0.0f) },
	{ D3DXVECTOR3( 1.0f, -1.0f, 0.0f), D3DCOLOR_ARGB(255, 255, 255, 255), D3DXVECTOR2(1.0f, 1.0f) }
};

//The points and pixels to draw. These are not quite the same as your points.
//I have turned down the alpha value to make the effect more noticable
PointVertex g_colPoints[] = {
	//All non-pixel sized points in here
	ADD_POINT(-0.5f, 0.005f, 0.0f, 0.05f,  D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f, 0.055f, 0.0f, 0.05f,  D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.55f, 0.0f, 0.05f,  D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.45f, 0.0f, 0.05f,  D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.40f, 0.0f, 0.025f, D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.35f, 0.0f, 0.05f,  D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.30f, 0.0f, 0.05f,  D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.25f, 0.0f, 0.012f, D3DCOLOR_ARGB(180, 255, 0,   0)  )
	ADD_POINT(-0.5f,  0.20f, 0.0f, 0.05f,  D3DCOLOR_ARGB(100, 128, 128, 128))
	ADD_POINT(-0.5f,  0.15f, 0.0f, 0.05f,  D3DCOLOR_ARGB(255, 128, 128, 128))
	ADD_POINT(-0.1f,  0.10f, 0.0f, 0.50f,  D3DCOLOR_ARGB(180, 0,   0,   0)  )
};

PixelVertex g_colPixels[] = {
	//All the single pixel points in here
	ADD_PIXEL(0.5f, 0.005f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f, 0.055f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.55f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.45f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.40f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.35f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.30f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.25f, 0.0f, D3DCOLOR_ARGB(220, 255, 0,   0)  )
	ADD_PIXEL(0.5f,  0.20f, 0.0f, D3DCOLOR_ARGB(100, 128, 128, 128))
	ADD_PIXEL(0.5f,  0.15f, 0.0f, D3DCOLOR_ARGB(255, 128, 128, 128))
	ADD_PIXEL(0.5f,  0.10f, 0.0f, D3DCOLOR_ARGB(220, 0,   0,   0)  )
};

bool InitD3D(HWND hWnd) {
	//Create the device, not much here
	if ((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL) {
		return false;
	}
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	d3dpp.Windowed = TRUE;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
	d3dpp.EnableAutoDepthStencil = TRUE;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	if (FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &g_pd3dDevice))) {
		return false;
	}
	g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); // Allows faces to be visible on both sides
	g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
	g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE); //We don't need the Z buffer. This allows us to render the pixels with the same Z as the quad and not have them artifact
	//The 3 lines to set up alpha blending
	g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
	//Compile and set up our shader. You can find more information on shaders by googling "Directx 9 shader"
	LPD3DXBUFFER pErrors;
	if (FAILED(D3DXCreateEffectFromFile(g_pd3dDevice, _T("Shader.fx"), NULL, NULL, 0, NULL, &g_pEffect, &pErrors))) {
		if (pErrors == NULL) {
			MessageBox(HWND_DESKTOP, _T("Shader.fx not found"), _T("Shader missing"), MB_OK | MB_ICONERROR);
		} else {
			MessageBoxA(HWND_DESKTOP, (LPSTR)pErrors->GetBufferPointer(), "Shader compile error", MB_OK | MB_ICONERROR);
			pErrors->Release();
		}
		//return false;
	} else {
		g_pPointEffect = g_pEffect->GetTechniqueByName("Point");
		g_pFFEffect = g_pEffect->GetTechniqueByName("FixedFunction");
		//The input data that we send to our custom shader. This is similar to the FVFs that are #defined above
		D3DVERTEXELEMENT9 decl[] = {
			{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
			{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
			{ 0, 16, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
			D3DDECL_END()
		};
		g_pd3dDevice->CreateVertexDeclaration(decl, &g_pVertexDeclaration);
	}
	return true;
}

void Cleanup() {
	//Nothing special here, just release everything
	if (g_pEffect != NULL) {
		g_pEffect->Release();
	}
	if (g_pQuadVB != NULL) {
		g_pQuadVB->Release();
	}
	if (g_pPixelVB != NULL) {
		g_pPixelVB->Release();
	}
	if (g_pPointVB != NULL) {
		g_pPointVB->Release();
	}
	if (g_pVertexDeclaration != NULL) {
		g_pVertexDeclaration->Release();
	}
	if (g_pTexture != NULL) {
		g_pTexture->Release();
	}
	if (g_pd3dDevice != NULL) {
		g_pd3dDevice->Release();
	}
	if (g_pD3D != NULL) {
		g_pD3D->Release();
	}
}

bool InitGeometry() {
    void *pVerts;
	//The quad, this is more or less what you already have
    if (FAILED(g_pd3dDevice->CreateVertexBuffer(sizeof(aQuad), 0, D3DFVF_PICVERTEX, D3DPOOL_DEFAULT, &g_pQuadVB, NULL))) {
        return false;
    }
    if (FAILED(g_pQuadVB->Lock(0, 0, &pVerts, 0))) {
        return false;
	}
	memcpy(pVerts, aQuad, sizeof(aQuad));
    g_pQuadVB->Unlock();
	if (FAILED(D3DXCreateTextureFromFile(g_pd3dDevice, "demo.bmp", &g_pTexture))) {
		MessageBox(HWND_DESKTOP, _T("Place an image named \'demo.bmp\' in the working directory to have a textured plane."), _T("No texture"), MB_OK | MB_ICONWARNING);
		//return false;
	}
	//single pixel points, pretty much the same as the quad you already had
    if (FAILED(g_pd3dDevice->CreateVertexBuffer(sizeof(g_colPixels), 0, D3DFVF_PIXELVERTEX, D3DPOOL_DEFAULT, &g_pPixelVB, NULL))) {
        return false;
    }
    if (FAILED(g_pPixelVB->Lock(0, 0, &pVerts, 0))) {
        return false;
	}
	memcpy(pVerts, g_colPixels, sizeof(g_colPixels));
    g_pPixelVB->Unlock();
	//any size point, pretty much the same as the quad you already had
    if (FAILED(g_pd3dDevice->CreateVertexBuffer(sizeof(g_colPoints), 0, D3DFVF_POINTVERTEX, D3DPOOL_DEFAULT, &g_pPointVB, NULL))) {
        return false;
    }
    if (FAILED(g_pPointVB->Lock(0, 0, &pVerts, 0))) {
        return false;
	}
	memcpy(pVerts, g_colPoints, sizeof(g_colPoints));
    g_pPointVB->Unlock();
    return true;
}

void SetupMatrices() {
	//You will probably have a function similar to this somewhere. This builds the matrices for World, View and Projection
	D3DXMATRIXA16 matWorld, matView, matProj, matTmp;
	D3DXMatrixRotationZ(&matWorld, timeGetTime() / 1000.0f);
	//D3DXMatrixRotationX(&matTmp, timeGetTime() / 10000.0f);
	//matWorld *= matTmp;
	g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);
	D3DXVECTOR3 vEyePt(0.0f, -3.0f, -4.0f);
	D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
	D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
	g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView);
	D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / 4, 1.0f, 1.0f, 100.0f);
	g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);
	//This passes the projection matrix onto the shader, you will need to add this to your code
	if (g_pEffect != NULL) {
		D3DXMATRIXA16 matWoldViewProj = matWorld * matView * matProj;
		g_pEffect->SetMatrix("matWorldViewProj", &matWoldViewProj);
	}
}

void Render() {
	g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 255), 1.0f, 0);
	if (SUCCEEDED(g_pd3dDevice->BeginScene())) {
		SetupMatrices();
		//Render the image first. Because we are not using a depth buffer, whatever we render last will appear on top
		g_pd3dDevice->SetTexture(0, g_pTexture); //Set your texture
		g_pd3dDevice->SetStreamSource(0, g_pQuadVB, 0, sizeof(PicVertex));
		g_pd3dDevice->SetFVF(D3DFVF_PICVERTEX);
		g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
		//Now render the multi-pixel points on top of that
		g_pd3dDevice->SetStreamSource(0, g_pPointVB, 0, sizeof(PointVertex));
		if (g_pEffect == NULL) { //we dont have a shader, render using the fixed function pipeline
			g_pd3dDevice->SetTexture(0, NULL); //Set your texture
			g_pd3dDevice->SetFVF(D3DFVF_POINTVERTEX);
			g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, (sizeof(g_colPoints) / sizeof(g_colPoints[0])) / 3);
		} else {
			g_pd3dDevice->SetVertexDeclaration(g_pVertexDeclaration);
			g_pEffect->SetTechnique(g_pPointEffect);
			UINT nPasses; //Our effect only has 1 pass, P0, so the following for loop will only have 1 itteration
			g_pEffect->Begin(&nPasses, 0);
			for (UINT nPass = 0; nPass < nPasses; ++nPass) {
				g_pEffect->BeginPass(nPass);
				g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, (sizeof(g_colPoints) / sizeof(g_colPoints[0])) / 3);
				g_pEffect->EndPass();
			}
			g_pEffect->End();
			g_pEffect->SetTechnique(g_pFFEffect);
			g_pd3dDevice->SetVertexDeclaration(NULL);
		}
		//And finally the pixel on top of it
		g_pd3dDevice->SetFVF(D3DFVF_PIXELVERTEX);
		g_pd3dDevice->SetStreamSource(0, g_pPixelVB, 0, sizeof(PixelVertex));
		g_pd3dDevice->DrawPrimitive(D3DPT_POINTLIST, 0, sizeof(g_colPixels) / sizeof(PixelVertex));
		g_pd3dDevice->EndScene();
	}
	g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
}

LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	//Nothing special here
	switch (msg) {
		case WM_DESTROY:
			Cleanup();
			PostQuitMessage(0);
			return 0;
	}
	return DefWindowProc(hWnd, msg, wParam, lParam);
}

int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
	//Nothing special here
	WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0, 0, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, _T("DotsExample"), NULL };
	RegisterClassEx(&wc);
	HWND hWnd = CreateWindow(_T("DotsExample"), _T("Points Example - Andrew Brock"), WS_OVERLAPPEDWINDOW, 100, 100, 580, 580, NULL, NULL, wc.hInstance, NULL);
	if (InitD3D(hWnd)) {
        if (InitGeometry()) {
            ShowWindow(hWnd, SW_SHOWDEFAULT);
            UpdateWindow(hWnd);
            MSG msg;
            ZeroMemory(&msg, sizeof(msg));
            while (msg.message != WM_QUIT) {
                if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                } else {
                    Render();
				}
            }
        }
    }
    UnregisterClass(_T("DotsExample"), wc.hInstance);
    return 0;
}

float4x4 matWorldViewProj : WORLDVIEWPROJ; //World * View * Projection, passed in from SetupMatrices()

//What our vertex shader outputs, and the input of our pixel shader
struct VS_OUTPUT {
    float4 vPosition : POSITION;
    float4 vDiffuse : COLOR;
	float2 vTexCoord : TEXCOORD0;
};

//This is the vertex shader. It is called once for each vertex in our mesh (a quad).
//This neads to convert the mesh co-ordinate of the vertex into the screen co-ordinate.
//This is done by multiplying the position by the World x View x Projection matrices
//The output from this is then used to determine what pixels to draw, and is then fed into the Pixel Shader.
VS_OUTPUT VertexShaderPoint(float4 vPos : POSITION, float4 vDiffuse : COLOR, float2 vTexCoord : TEXCOORD0) {
	VS_OUTPUT output;
	output.vPosition = mul(vPos, matWorldViewProj); //Multiply by world, view and projection matrices and pass onto pixel shader
	output.vDiffuse = vDiffuse; //Pass this straight onto the pixel shader
	output.vTexCoord = vTexCoord; //Pass this straight onto the pixel shader
	return output;
}

//This is the pixel shader. It is called once for each pixel drawn to screen in our custom point
//The output of this function is the coulour and alpha of the pixel to render to the screen.
float4 PixelShaderPoint(VS_OUTPUT input) : COLOR {
	//Imagine we have a circle, centered around (0.5, 0.5), and ranges from 0-1 in each dimension
	float2 len = input.vTexCoord - 0.5;
	//Now now we have a unit circle. That is a circle centered at (0, 0) and has a constant radius of 1 unit.
	//If the distance from this pixel to the center (0, 0) is more than 1, then this pixel lies outside of the circle, and hence should not be drawn
	//Otherwise if it is less than or equal to 1 then this pixel is part of the circle that makes up the point.
	//The issue here is that the distance formula has a square root in it, which is slow. We can cheat and use distance squared, and take into acount the squared lenght when comparing.
	//However, 1*1=1, so in this particular case, there is no difference
	float dist = len.x * len.x + len.y * len.y; //This is the square of the length from the center
	clip(0.25 - dist); //if the distance from the center of the square is >1 then dont render this pixel
	return input.vDiffuse;
}

//This is the technique we use for rendering. It tells the graphics card what vertex and pixel shaders to use.
//We can also use it to set the render state to do things like enable/disable alpha blending, depth, ...
technique Point {
	pass P0 {
		VertexShader = compile vs_2_0 VertexShaderPoint();
		PixelShader = compile ps_2_0 PixelShaderPoint();
	}
}

//This technique disables the custom shaders and hence re-enables the Fixed Function Pipeline
technique FixedFunction {
	pass P0 {
		VertexShader = NULL;
		PixelShader = NULL;
	}
}