more directx support

libs/directx/directx.cpp

@@ -18,7 +18,17 @@ typedef struct {
 	int init_flags;
 } dx_driver;
 
+typedef struct {
+	hl_type *t;
+	D3D11_BOX box;
+} dx_box_obj;
+
+
 typedef ID3D11Buffer dx_buffer;
+typedef ID3D11VertexShader dx_vshader;
+typedef ID3D11PixelShader dx_pshader;
+typedef ID3D11Buffer dx_buffer;
+typedef ID3D11InputLayout dx_layout;
 
 static dx_driver *driver = NULL;
 static IDXGIFactory *factory = NULL;
@@ -29,7 +39,7 @@ static IDXGIFactory *GetDXGI() {
 	return factory;
 }
 
-HL_PRIM dx_driver *HL_NAME(dx_create)( HWND window, int flags ) {
+HL_PRIM dx_driver *HL_NAME(create)( HWND window, int flags ) {
 	DWORD result;
 	static D3D_FEATURE_LEVEL levels[] = {
 		D3D_FEATURE_LEVEL_11_1,
@@ -73,11 +83,38 @@ HL_PRIM dx_driver *HL_NAME(dx_create)( HWND window, int flags ) {
 	if( d->device->CreateRenderTargetView(backBuffer, NULL, &d->renderTarget) != S_OK )
 		return NULL;
 	backBuffer->Release();
+
+	d->context->OMSetRenderTargets(1,&d->renderTarget,NULL);
+
+	ID3D11RasterizerState *rs;
+	D3D11_RASTERIZER_DESC rdesc;
+	rdesc.FillMode = D3D11_FILL_SOLID;
+	rdesc.CullMode = D3D11_CULL_NONE;
+	rdesc.FrontCounterClockwise = TRUE;
+	rdesc.DepthBias = 0;
+	rdesc.DepthBiasClamp = 0;
+	rdesc.SlopeScaledDepthBias = 0;
+	rdesc.DepthClipEnable = FALSE;
+	rdesc.ScissorEnable = FALSE;
+	rdesc.MultisampleEnable = FALSE;
+	rdesc.AntialiasedLineEnable = FALSE;
+	d->device->CreateRasterizerState(&rdesc,&rs);
+	d->context->RSSetState(rs);
+
+	D3D11_VIEWPORT view;
+	view.TopLeftX = 0;
+	view.TopLeftY = 0;
+	view.Width = (float)r.right;
+	view.Height = (float)r.bottom;
+	view.MinDepth = 0;
+	view.MaxDepth = 1;
+	d->context->RSSetViewports(1,&view);
+
 	driver = d;
 	return d;
 }
 
-HL_PRIM void HL_NAME(dx_clear_color)( double r, double g, double b, double a ) {
+HL_PRIM void HL_NAME(clear_color)( double r, double g, double b, double a ) {
 	float color[4];
 	color[0] = (float)r;
 	color[1] = (float)g;
@@ -86,19 +123,19 @@ HL_PRIM void HL_NAME(dx_clear_color)( double r, double g, double b, double a ) {
 	driver->context->ClearRenderTargetView(driver->renderTarget,color);
 }
 
-HL_PRIM void HL_NAME(dx_present)() {
+HL_PRIM void HL_NAME(present)() {
 	driver->swapchain->Present(0,0);
 }
 
-HL_PRIM int HL_NAME(dx_get_screen_width)() {
+HL_PRIM int HL_NAME(get_screen_width)() {
 	return GetSystemMetrics(SM_CXSCREEN);
 }
 
-HL_PRIM int HL_NAME(dx_get_screen_height)() {
+HL_PRIM int HL_NAME(get_screen_height)() {
 	return GetSystemMetrics(SM_CYSCREEN);
 }
 
-HL_PRIM const uchar *HL_NAME(dx_get_device_name)() {
+HL_PRIM const uchar *HL_NAME(get_device_name)() {
 	IDXGIAdapter *adapter;
 	DXGI_ADAPTER_DESC desc;
 	if( GetDXGI()->EnumAdapters(0,&adapter) != S_OK || adapter->GetDesc(&desc) != S_OK )
@@ -107,12 +144,12 @@ HL_PRIM const uchar *HL_NAME(dx_get_device_name)() {
 	return (uchar*)hl_copy_bytes((vbyte*)desc.Description,(ustrlen((uchar*)desc.Description)+1)*2);
 }
 
-HL_PRIM double HL_NAME(dx_get_supported_version)() {
+HL_PRIM double HL_NAME(get_supported_version)() {
 	if( driver == NULL ) return 0.;
 	return (driver->feature >> 12) + ((driver->feature & 0xFFF) / 2560.);
 }
 
-HL_PRIM dx_buffer *HL_NAME(dx_create_buffer)( int size, int usage, int bind, int access, int misc, int stride, vbyte *data ) {
+HL_PRIM dx_buffer *HL_NAME(create_buffer)( int size, int usage, int bind, int access, int misc, int stride, vbyte *data ) {
 	ID3D11Buffer *buffer;
 	D3D11_BUFFER_DESC desc;
 	D3D11_SUBRESOURCE_DATA res;
@@ -130,14 +167,29 @@ HL_PRIM dx_buffer *HL_NAME(dx_create_buffer)( int size, int usage, int bind, int
 	return buffer;
 }
 
-HL_PRIM void HL_NAME(dx_release_buffer)( dx_buffer *b ) {
+HL_PRIM void HL_NAME(update_subresource)( dx_buffer *b, int index, dx_box_obj *box, vbyte *data, int srcRowPitch, int srcDstPitch ) {
+	driver->context->UpdateSubresource(b, index, box ? &box->box : NULL, data, srcRowPitch, srcDstPitch);
+}
+
+HL_PRIM void *HL_NAME(buffer_map)( dx_buffer *b, int subRes, int type, bool waitGpu ) {
+	D3D11_MAPPED_SUBRESOURCE map;
+	if( driver->context->Map(b,subRes,(D3D11_MAP)type,waitGpu?0:D3D11_MAP_FLAG_DO_NOT_WAIT,&map) != S_OK ) 
+		return NULL;
+	return map.pData;
+}
+
+HL_PRIM void HL_NAME(buffer_unmap)( dx_buffer *b, int subRes ) {
+	driver->context->Unmap(b, subRes);
+}
+
+HL_PRIM void HL_NAME(release_buffer)( dx_buffer *b ) {
 	b->Release();
 }
 
-HL_PRIM vbyte *HL_NAME(dx_compile_shader)( vbyte *data, int dataSize, char *source, char *target, int flags, bool *error, int *size ) {
+HL_PRIM vbyte *HL_NAME(compile_shader)( vbyte *data, int dataSize, char *source, char *entry, char *target, int flags, bool *error, int *size ) {
 	ID3DBlob *code;
 	ID3DBlob *errorMessage;
-	if( D3DCompile(data,dataSize,source,NULL,NULL,NULL,target,flags,0,&code,&errorMessage) != S_OK ) {
+	if( D3DCompile(data,dataSize,source,NULL,NULL,entry,target,flags,0,&code,&errorMessage) != S_OK ) {
 		*error = true;
 		code = errorMessage;
 	}
@@ -145,15 +197,101 @@ HL_PRIM vbyte *HL_NAME(dx_compile_shader)( vbyte *data, int dataSize, char *sour
 	return hl_copy_bytes((vbyte*)code->GetBufferPointer(),*size);
 }
 
+HL_PRIM dx_vshader *HL_NAME(create_vertex_shader)( vbyte *code, int size ) {
+	dx_vshader *shader;
+	if( driver->device->CreateVertexShader(code, size, NULL, &shader) != S_OK )
+		return NULL;
+	return shader;
+}
+
+HL_PRIM dx_pshader *HL_NAME(create_pixel_shader)( vbyte *code, int size ) {
+	dx_pshader *shader;
+	if( driver->device->CreatePixelShader(code, size, NULL, &shader) != S_OK )
+		return NULL;
+	return shader;
+}
+
+HL_PRIM void HL_NAME(draw_indexed)( int count, int start, int baseVertex ) {
+	driver->context->DrawIndexed(count,start,baseVertex);
+}
+
+HL_PRIM void HL_NAME(vs_set_shader)( dx_vshader *s ) {
+	driver->context->VSSetShader(s,NULL,0);
+}
+
+HL_PRIM void HL_NAME(vs_set_constant_buffers)( int start, int count, varray *a ) {
+	driver->context->VSSetConstantBuffers(start,count,hl_aptr(a,dx_buffer*));
+}
+
+HL_PRIM void HL_NAME(ps_set_shader)( dx_pshader *s ) {
+	driver->context->PSSetShader(s,NULL,0);
+}
+
+HL_PRIM void HL_NAME(ps_set_constant_buffers)( int start, int count, varray *a ) {
+	driver->context->PSSetConstantBuffers(start,count,hl_aptr(a,dx_buffer*));
+}
+
+HL_PRIM void HL_NAME(ia_set_index_buffer)( dx_buffer *b, bool is32, int offset ) {
+	driver->context->IASetIndexBuffer(b,is32?DXGI_FORMAT_R32_UINT:DXGI_FORMAT_R16_UINT,offset);
+}
+
+HL_PRIM void HL_NAME(ia_set_vertex_buffers)( int start, int count, varray *a, vbyte *strides, vbyte *offsets ) {
+	driver->context->IASetVertexBuffers(start,count,hl_aptr(a,dx_buffer*),(UINT*)strides,(UINT*)offsets);
+}
+
+HL_PRIM void HL_NAME(ia_set_primitive_topology)( int topology ) {
+	driver->context->IASetPrimitiveTopology((D3D11_PRIMITIVE_TOPOLOGY)topology);
+}
+
+HL_PRIM void HL_NAME(ia_set_input_layout)( dx_layout *l ) {
+	driver->context->IASetInputLayout(l);
+}
+
+typedef struct {
+	hl_type *t;
+	D3D11_INPUT_ELEMENT_DESC desc;
+} input_element;
+
+HL_PRIM dx_layout *HL_NAME(create_input_layout)( varray *arr, vbyte *bytecode, int bytecodeLength ) {
+	ID3D11InputLayout *input;
+	D3D11_INPUT_ELEMENT_DESC desc[32];
+	int i;
+	if( arr->size > 32 ) return NULL;
+	for(i=0;i<arr->size;i++)
+		desc[i] = hl_aptr(arr,input_element*)[i]->desc;
+	if( driver->device->CreateInputLayout(desc,arr->size,bytecode,bytecodeLength,&input) != S_OK )
+		return NULL;
+	return input;
+}
+
 #define _DRIVER _ABSTRACT(dx_driver)
 #define _BUFFER _ABSTRACT(dx_buffer)
-DEFINE_PRIM(_DRIVER, dx_create, _ABSTRACT(dx_window) _I32);
-DEFINE_PRIM(_VOID, dx_clear_color, _F64 _F64 _F64 _F64);
-DEFINE_PRIM(_VOID, dx_present, _NO_ARG);
-DEFINE_PRIM(_I32, dx_get_screen_width, _NO_ARG);
-DEFINE_PRIM(_I32, dx_get_screen_height, _NO_ARG);
-DEFINE_PRIM(_BYTES, dx_get_device_name, _NO_ARG);
-DEFINE_PRIM(_F64, dx_get_supported_version, _NO_ARG);
-DEFINE_PRIM(_BUFFER, dx_create_buffer, _I32 _I32 _I32 _I32 _I32 _I32 _BYTES);
-DEFINE_PRIM(_VOID, dx_release_buffer, _BUFFER);
-DEFINE_PRIM(_BYTES, dx_compile_shader, _BYTES _I32 _BYTES _BYTES _I32 _REF(_BOOL) _REF(_I32));
+#define _SHADER _ABSTRACT(dx_shader)
+#define _LAYOUT _ABSTRACT(dx_layout)
+
+DEFINE_PRIM(_DRIVER, create, _ABSTRACT(dx_window) _I32);
+DEFINE_PRIM(_VOID, clear_color, _F64 _F64 _F64 _F64);
+DEFINE_PRIM(_VOID, present, _NO_ARG);
+DEFINE_PRIM(_I32, get_screen_width, _NO_ARG);
+DEFINE_PRIM(_I32, get_screen_height, _NO_ARG);
+DEFINE_PRIM(_BYTES, get_device_name, _NO_ARG);
+DEFINE_PRIM(_F64, get_supported_version, _NO_ARG);
+DEFINE_PRIM(_BUFFER, create_buffer, _I32 _I32 _I32 _I32 _I32 _I32 _BYTES);
+DEFINE_PRIM(_BYTES, buffer_map, _BUFFER _I32 _I32 _BOOL);
+DEFINE_PRIM(_VOID, buffer_unmap, _BUFFER _I32);
+DEFINE_PRIM(_VOID, release_buffer, _BUFFER);
+DEFINE_PRIM(_BYTES, compile_shader, _BYTES _I32 _BYTES _BYTES _BYTES _I32 _REF(_BOOL) _REF(_I32));
+DEFINE_PRIM(_SHADER, create_vertex_shader, _BYTES _I32);
+DEFINE_PRIM(_SHADER, create_pixel_shader, _BYTES _I32);
+DEFINE_PRIM(_VOID, draw_indexed, _I32 _I32 _I32);
+DEFINE_PRIM(_VOID, vs_set_shader, _SHADER);
+DEFINE_PRIM(_VOID, vs_set_constant_buffers, _I32 _I32 _ARR);
+DEFINE_PRIM(_VOID, ps_set_shader, _SHADER);
+DEFINE_PRIM(_VOID, ps_set_constant_buffers, _I32 _I32 _ARR);
+DEFINE_PRIM(_VOID, update_subresource, _BUFFER _I32 _OBJ(_I32 _I32 _I32 _I32 _I32 _I32) _BYTES _I32 _I32);
+DEFINE_PRIM(_VOID, ia_set_index_buffer, _BUFFER _BOOL _I32);
+DEFINE_PRIM(_VOID, ia_set_vertex_buffers, _I32 _I32 _ARR _BYTES _BYTES);
+DEFINE_PRIM(_VOID, ia_set_primitive_topology, _I32);
+DEFINE_PRIM(_VOID, ia_set_input_layout, _LAYOUT);
+DEFINE_PRIM(_LAYOUT, create_input_layout, _ARR _BYTES _I32);
+

libs/directx/dx/Buffer.hx

@@ -50,14 +50,49 @@ package dx;
 	@:op(a | b) static function or(a:BufferMisc, b:BufferMisc) : BufferMisc;
 }
 
+@:enum abstract MapType(Int) {
+	var Read = 1;
+	var Write = 2;
+	var ReadWrite = 3;
+	var WriteDiscard = 4;
+	var WriteNoOverwrite = 5;
+}
+
+class ResourceBox {
+	public var left : Int;
+	public var top : Int;
+	public var front : Int;
+	public var right : Int;
+	public var bottom : Int;
+	public var back : Int;
+	public function new() {
+	}
+	public function reset() {
+		left = top = front = right = bottom = back = 0;
+	}
+}
+
 abstract Buffer(hl.Abstract<"dx_buffer">) {
 
-	@:hlNative("directx","dx_create_buffer")
+	@:hlNative("directx","create_buffer")
 	public static function alloc( size : Int, usage : BufferUsage, bind : BufferBind, access : BufferAccess, misc : BufferMisc, stride : Int, data : hl.Bytes ) : Buffer {
 		return null;
 	}
 
-	@:hlNative("directx", "dx_release_buffer")
+	@:hlNative("directx", "buffer_map")
+	public function map( subResource : Int, type : MapType, waitGpu : Bool ) : hl.Bytes {
+		return null;
+	}
+
+	@:hlNative("directx", "update_subresource")
+	public function updateSubresource( subResource : Int, box : Null<ResourceBox>, data : hl.Bytes, srcRowPitch : Int, srcDepthPitch : Int ) : Void {
+	}
+
+	@:hlNative("directx", "buffer_unmap")
+	public function unmap( subResource : Int ) : Void {
+	}
+
+	@:hlNative("directx", "release_buffer")
 	public function release() {
 	}
 

libs/directx/dx/Driver.hx

@@ -1,27 +1,87 @@
 package dx;
 
-enum DriverInitFlag {
-	SingleThread;
-	DebugLayer;
-	SwitchToRef;
-	PreventInternalThreadingOptimizations;
-	Unused1;
-	BgraSupport;
-	Debuggable;
-	PreventAlteringLayerSettingsFromRegistry;
-	DisableGpuTimeout;
-	Unused2;
-	Unused3;
-	VideoSupport;
+typedef DriverInstance = hl.Abstract<"dx_driver">;
+
+typedef Shader = hl.Abstract<"dx_shader">;
+
+typedef Layout = hl.Abstract<"dx_layout">;
+
+@:enum abstract DriverInitFlags(Int) {
+	var None = 0;
+	var SingleThread = 1;
+	var DebugLayer = 2;
+	var SwitchToRef = 4;
+	var PreventInternalThreadingOptimizations = 8;
+	var BgraSupport = 32;
+	var Debuggable = 64;
+	var PreventAlteringLayerSettingsFromRegistry = 128;
+	var DisableGpuTimeout = 256;
+	var VideoSupport = 2048;
+	@:op(a | b) static function or(a:DriverInitFlags, b:DriverInitFlags) : DriverInitFlags;
 }
 
-typedef DriverInstance = hl.Abstract<"dx_driver">;
+@:enum abstract ShaderFlags(Int) {
+	var None = 0;
+	var Debug = 0x1;
+	var SkipValidation = 0x2;
+	var SkipOptimization = 0x4;
+	var PackMatrixRowMajor = 0x8;
+	var PackMatrixColumnMajor = 0x10;
+	var PartialPrecision = 0x20;
+	var ForceVSSoftwareNoOpt = 0x40;
+	var ForcePSSoftwareNoOpt = 0x80;
+	var NoPreshader = 0x100;
+	var AvoidFlowControl = 0x200;
+	var PreferFlowControl = 0x400;
+	var EnableStrictness = 0x800;
+	var EnableBackwardsCompatibility = 0x1000;
+	var IEEEStrictness = 0x2000;
+	var OptimizationLevel0 = 0x4000;
+	var OptimizationLevel1 = 0; // default
+	var OptimizationLevel2 = 0x4000 | 0x8000;
+	var OptimizationLevel3 = 0x8000;
+	var WarningsAreErrors = 0x40000;
+	var ResourcesMayAlias = 0x80000;
+	var EnableUnboundedDescriptorTables = 0x100000;
+	var AllResourcesBound = 0x200000;
+	@:op(a | b) static function or(a:ShaderFlags, b:ShaderFlags) : ShaderFlags;
+}
 
-@:hlNative("directx","dx_")
+@:enum abstract PrimitiveTopology(Int) {
+	var Undefined = 0;
+	var PointList = 1;
+	var LineList = 2;
+	var LineStrip = 3;
+	var TriangleList = 4;
+	var TriangleStrip = 5;
+	var LineListAdj = 10;
+	var TriangleListAdj = 12;
+	var TriangleStripAdj = 13;
+	static inline function controlPointPatchList(count:Int) : PrimitiveTopology return cast (count + 32);
+}
+
+@:enum abstract LayoutClassification(Int) {
+	var PerVertexData = 0;
+	var PerInstanceData = 0;
+}
+
+class LayoutElement {
+	public var semanticName : hl.Bytes;
+	public var semanticIndex : Int;
+	public var format : Format;
+	public var inputSlot : Int;
+	public var alignedByteOffset : Int;
+	public var inputSlotClass : LayoutClassification;
+	public var instanceDataStepRate : Int;
+	public function new() {
+	}
+}
+
+@:hlNative("directx")
 class Driver {
 
-	public static function create( win : Window, ?flags : haxe.EnumFlags<DriverInitFlag> ) {
-		return dxCreate(@:privateAccess win.win, flags == null ? 0 : flags.toInt());
+	public static function create( win : Window, flags : DriverInitFlags = None ) {
+		return dxCreate(@:privateAccess win.win, flags);
 	}
 
 	public static function clearColor( r : Float, g : Float, b : Float, a : Float ) {
@@ -46,9 +106,71 @@ class Driver {
 		return 0.;
 	}
 
-	@:hlNative("directx","dx_create")
-	static function dxCreate( win : hl.Abstract < "dx_window" > , flags : Int ) : DriverInstance { return null; }
-	@:hlNative("directx","dx_get_device_name")
+	public static function compileShader( data : String, source : String, entryPoint : String, target : String, flags : ShaderFlags ) : haxe.io.Bytes @:privateAccess {
+		var isError = false, size = 0;
+		var out = dxCompileShader(data.toUtf8(), data.length, source.toUtf8(), entryPoint.toUtf8(), target.toUtf8(), flags, isError, size);
+		if( isError )
+			throw String.fromUTF8(out);
+		return out.toBytes(size);
+	}
+
+	public static function createVertexShader( bytes : haxe.io.Bytes ) {
+		return dxCreateVertexShader(bytes, bytes.length);
+	}
+
+	public static function createPixelShader( bytes : haxe.io.Bytes ) {
+		return dxCreatePixelShader(bytes, bytes.length);
+	}
+
+	public static function drawIndexed( indexCount : Int, startIndex : Int, baseVertex : Int ) : Void {
+	}
+
+	public static function vsSetShader( shader : Shader ) : Void {
+	}
+
+	public static function vsSetConstantBuffers( start : Int, count : Int, buffers : hl.NativeArray<Buffer> ) : Void {
+	}
+
+	public static function psSetShader( shader : Shader ) : Void {
+	}
+
+	public static function psSetConstantBuffers( start : Int, count : Int, buffers : hl.NativeArray<Buffer> ) : Void {
+	}
+
+	public static function iaSetPrimitiveTopology( topology : PrimitiveTopology ) : Void {
+	}
+
+	public static function iaSetIndexBuffer( buffer : Buffer, is32Bits : Bool, offset : Int ) : Void {
+	}
+
+	public static function iaSetVertexBuffers( start : Int, count : Int, buffers : hl.NativeArray<Buffer>, strides : hl.BytesAccess<Int>, offsets : hl.BytesAccess<Int> ) : Void {
+	}
+
+	public static function iaSetInputLayout( layout : Layout ) : Void {
+	}
+
+	public static function createInputLayout( elements : hl.NativeArray<LayoutElement>, shaderBytes : hl.Bytes, shaderSize : Int ) : Layout {
+		return null;
+	}
+
+	@:hlNative("directx","create")
+	static function dxCreate( win : hl.Abstract<"dx_window">, flags : DriverInitFlags ) : DriverInstance { return null; }
+	@:hlNative("directx","get_device_name")
 	static function dxGetDeviceName() : hl.Bytes { return null; }
 
+	@:hlNative("directx","compile_shader")
+	static function dxCompileShader( data : hl.Bytes, size : Int, source : hl.Bytes, entry : hl.Bytes, target : hl.Bytes, flags : ShaderFlags, error : hl.Ref<Bool>, outSize : hl.Ref<Int> ) : hl.Bytes {
+		return null;
+	}
+
+	@:hlNative("directx","create_vertex_shader")
+	static function dxCreateVertexShader( data : hl.Bytes, size : Int ) : Shader {
+		return null;
+	}
+
+	@:hlNative("directx","create_pixel_shader")
+	static function dxCreatePixelShader( data : hl.Bytes, size : Int ) : Shader {
+		return null;
+	}
+
 }

libs/directx/dx/Format.hx

@@ -0,0 +1,123 @@
+package dx;
+
+@:enum abstract Format(Int) {
+	var UNKNOWN                     = 0;
+	var R32G32B32A32_TYPELESS       = 1;
+	var R32G32B32A32_FLOAT          = 2;
+	var R32G32B32A32_UINT           = 3;
+	var R32G32B32A32_SINT           = 4;
+	var R32G32B32_TYPELESS          = 5;
+	var R32G32B32_FLOAT             = 6;
+	var R32G32B32_UINT              = 7;
+	var R32G32B32_SINT              = 8;
+	var R16G16B16A16_TYPELESS       = 9;
+	var R16G16B16A16_FLOAT          = 10;
+	var R16G16B16A16_UNORM          = 11;
+	var R16G16B16A16_UINT           = 12;
+	var R16G16B16A16_SNORM          = 13;
+	var R16G16B16A16_SINT           = 14;
+	var R32G32_TYPELESS             = 15;
+	var R32G32_FLOAT                = 16;
+	var R32G32_UINT                 = 17;
+	var R32G32_SINT                 = 18;
+	var R32G8X24_TYPELESS           = 19;
+	var D32_FLOAT_S8X24_UINT        = 20;
+	var R32_FLOAT_X8X24_TYPELESS    = 21;
+	var X32_TYPELESS_G8X24_UINT     = 22;
+	var R10G10B10A2_TYPELESS        = 23;
+	var R10G10B10A2_UNORM           = 24;
+	var R10G10B10A2_UINT            = 25;
+	var R11G11B10_FLOAT             = 26;
+	var R8G8B8A8_TYPELESS           = 27;
+	var R8G8B8A8_UNORM              = 28;
+	var R8G8B8A8_UNORM_SRGB         = 29;
+	var R8G8B8A8_UINT               = 30;
+	var R8G8B8A8_SNORM              = 31;
+	var R8G8B8A8_SINT               = 32;
+	var R16G16_TYPELESS             = 33;
+	var R16G16_FLOAT                = 34;
+	var R16G16_UNORM                = 35;
+	var R16G16_UINT                 = 36;
+	var R16G16_SNORM                = 37;
+	var R16G16_SINT                 = 38;
+	var R32_TYPELESS                = 39;
+	var D32_FLOAT                   = 40;
+	var R32_FLOAT                   = 41;
+	var R32_UINT                    = 42;
+	var R32_SINT                    = 43;
+	var R24G8_TYPELESS              = 44;
+	var D24_UNORM_S8_UINT           = 45;
+	var R24_UNORM_X8_TYPELESS       = 46;
+	var X24_TYPELESS_G8_UINT        = 47;
+	var R8G8_TYPELESS               = 48;
+	var R8G8_UNORM                  = 49;
+	var R8G8_UINT                   = 50;
+	var R8G8_SNORM                  = 51;
+	var R8G8_SINT                   = 52;
+	var R16_TYPELESS                = 53;
+	var R16_FLOAT                   = 54;
+	var D16_UNORM                   = 55;
+	var R16_UNORM                   = 56;
+	var R16_UINT                    = 57;
+	var R16_SNORM                   = 58;
+	var R16_SINT                    = 59;
+	var R8_TYPELESS                 = 60;
+	var R8_UNORM                    = 61;
+	var R8_UINT                     = 62;
+	var R8_SNORM                    = 63;
+	var R8_SINT                     = 64;
+	var A8_UNORM                    = 65;
+	var R1_UNORM                    = 66;
+	var R9G9B9E5_SHAREDEXP          = 67;
+	var R8G8_B8G8_UNORM             = 68;
+	var G8R8_G8B8_UNORM             = 69;
+	var BC1_TYPELESS                = 70;
+	var BC1_UNORM                   = 71;
+	var BC1_UNORM_SRGB              = 72;
+	var BC2_TYPELESS                = 73;
+	var BC2_UNORM                   = 74;
+	var BC2_UNORM_SRGB              = 75;
+	var BC3_TYPELESS                = 76;
+	var BC3_UNORM                   = 77;
+	var BC3_UNORM_SRGB              = 78;
+	var BC4_TYPELESS                = 79;
+	var BC4_UNORM                   = 80;
+	var BC4_SNORM                   = 81;
+	var BC5_TYPELESS                = 82;
+	var BC5_UNORM                   = 83;
+	var BC5_SNORM                   = 84;
+	var B5G6R5_UNORM                = 85;
+	var B5G5R5A1_UNORM              = 86;
+	var B8G8R8A8_UNORM              = 87;
+	var B8G8R8X8_UNORM              = 88;
+	var R10G10B10_XR_BIAS_A2_UNORM  = 89;
+	var B8G8R8A8_TYPELESS           = 90;
+	var B8G8R8A8_UNORM_SRGB         = 91;
+	var B8G8R8X8_TYPELESS           = 92;
+	var B8G8R8X8_UNORM_SRGB         = 93;
+	var BC6H_TYPELESS               = 94;
+	var BC6H_UF16                   = 95;
+	var BC6H_SF16                   = 96;
+	var BC7_TYPELESS                = 97;
+	var BC7_UNORM                   = 98;
+	var BC7_UNORM_SRGB              = 99;
+	var AYUV                        = 100;
+	var Y410                        = 101;
+	var Y416                        = 102;
+	var NV12                        = 103;
+	var P010                        = 104;
+	var P016                        = 105;
+	var _420_OPAQUE                 = 106;
+	var YUY2                        = 107;
+	var Y210                        = 108;
+	var Y216                        = 109;
+	var NV11                        = 110;
+	var AI44                        = 111;
+	var IA44                        = 112;
+	var P8                          = 113;
+	var A8P8                        = 114;
+	var B4G4R4A4_UNORM              = 115;
+	var P208                        = 130;
+	var V208                        = 131;
+	var V408                        = 132;
+}

libs/directx/window.c

@@ -25,7 +25,7 @@ HL_PRIM dx_window *HL_NAME(win_create)( int width, int height ) {
 		wc.hIcon		 = LoadIcon(NULL, IDI_WINLOGO);
 		wc.hIconSm       = wc.hIcon;
 		wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
-		wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+		wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
 		wc.lpszMenuName  = NULL;
 		wc.lpszClassName = USTR("HL_WIN");
 		wc.cbSize        = sizeof(WNDCLASSEX);