finalized directx base api export

libs/directx/directx.cpp

@@ -18,18 +18,14 @@ typedef struct {
 	int init_flags;
 } dx_driver;
 
-typedef struct {
+template <typename T> class dx_struct {
 	hl_type *t;
-	D3D11_BOX box;
-} dx_box_obj;
+public:
+	T value;
+};
 
-typedef ID3D11VertexShader dx_vshader;
-typedef ID3D11PixelShader dx_pshader;
-typedef ID3D11InputLayout dx_layout;
 typedef ID3D11Resource dx_resource;
-typedef ID3D11RenderTargetView dx_render_target;
-typedef ID3D11DepthStencilView dx_depth_stencil;
-typedef ID3D11RasterizerState dx_raster;
+typedef ID3D11DeviceChild dx_pointer;
 
 static dx_driver *driver = NULL;
 static IDXGIFactory *factory = NULL;
@@ -88,49 +84,39 @@ HL_PRIM dx_resource *HL_NAME(get_back_buffer)() {
 	return backBuffer;
 }
 
-typedef struct {
-	hl_type *t;
-	D3D11_RENDER_TARGET_VIEW_DESC desc;
-} crr_desc;
-
-HL_PRIM dx_render_target *HL_NAME(create_render_target_view)( dx_resource *r, crr_desc *desc ) {
+HL_PRIM dx_pointer *HL_NAME(create_render_target_view)( dx_resource *r, dx_struct<D3D11_RENDER_TARGET_VIEW_DESC> *desc ) {
 	ID3D11RenderTargetView *rt;
-	if( driver->device->CreateRenderTargetView(r, desc ? &desc->desc : NULL, &rt) != S_OK )
+	if( driver->device->CreateRenderTargetView(r, desc ? &desc->value : NULL, &rt) != S_OK )
 		return NULL;
 	return rt;
 }
 
-HL_PRIM void HL_NAME(om_set_render_targets)( int count, varray *arr, dx_depth_stencil *depth ) {
-	driver->context->OMSetRenderTargets(count,hl_aptr(arr,dx_render_target*),depth);
+HL_PRIM void HL_NAME(om_set_render_targets)( int count, varray *arr, dx_pointer *depth ) {
+	driver->context->OMSetRenderTargets(count,hl_aptr(arr,ID3D11RenderTargetView*),(ID3D11DepthStencilView*)depth);
 }
 
-typedef struct {
-	hl_type *t;
-	D3D11_RASTERIZER_DESC desc;
-} raster_desc;
-
-HL_PRIM dx_raster *HL_NAME(create_rasterizer_state)( raster_desc *desc ) {
+HL_PRIM dx_pointer *HL_NAME(create_rasterizer_state)( dx_struct<D3D11_RASTERIZER_DESC> *desc ) {
 	ID3D11RasterizerState *rs;
-	if( driver->device->CreateRasterizerState(&desc->desc,&rs) != S_OK )
+	if( driver->device->CreateRasterizerState(&desc->value,&rs) != S_OK )
 		return NULL;
 	return rs;
 }
 
-HL_PRIM void HL_NAME(rs_set_state)( dx_raster *rs ) {
-	driver->context->RSSetState(rs);
+HL_PRIM void HL_NAME(rs_set_state)( dx_pointer *rs ) {
+	driver->context->RSSetState((ID3D11RasterizerState*)rs);
 }
 
 HL_PRIM void HL_NAME(rs_set_viewports)( int count, vbyte *data ) {
 	driver->context->RSSetViewports(count,(D3D11_VIEWPORT*)data);
 }
 
-HL_PRIM void HL_NAME(clear_color)( dx_render_target *rt, double r, double g, double b, double a ) {
+HL_PRIM void HL_NAME(clear_color)( dx_pointer *rt, double r, double g, double b, double a ) {
 	float color[4];
 	color[0] = (float)r;
 	color[1] = (float)g;
 	color[2] = (float)b;
 	color[3] = (float)a;
-	driver->context->ClearRenderTargetView(rt,color);
+	driver->context->ClearRenderTargetView((ID3D11RenderTargetView*)rt,color);
 }
 
 HL_PRIM void HL_NAME(present)() {
@@ -177,8 +163,19 @@ HL_PRIM dx_resource *HL_NAME(create_buffer)( int size, int usage, int bind, int
 	return buffer;
 }
 
-HL_PRIM void HL_NAME(update_subresource)( dx_resource *r, int index, dx_box_obj *box, vbyte *data, int srcRowPitch, int srcDstPitch ) {
-	driver->context->UpdateSubresource(r, index, box ? &box->box : NULL, data, srcRowPitch, srcDstPitch);
+HL_PRIM dx_resource *HL_NAME(create_texture_2d)( dx_struct<D3D11_TEXTURE2D_DESC> *desc, vbyte *data ) {
+	ID3D11Texture2D *tex;
+	D3D11_SUBRESOURCE_DATA res;
+	res.pSysMem = data;
+	res.SysMemPitch = 0;
+	res.SysMemSlicePitch = 0;
+	if( driver->device->CreateTexture2D(&desc->value,data?&res:NULL,&tex) != S_OK )
+		return NULL;
+	return tex;
+}
+
+HL_PRIM void HL_NAME(update_subresource)( dx_resource *r, int index, dx_struct<D3D11_BOX> *box, vbyte *data, int srcRowPitch, int srcDstPitch ) {
+	driver->context->UpdateSubresource(r, index, box ? &box->value : NULL, data, srcRowPitch, srcDstPitch);
 }
 
 HL_PRIM void *HL_NAME(map)( dx_resource *r, int subRes, int type, bool waitGpu ) {
@@ -217,15 +214,15 @@ HL_PRIM vbyte *HL_NAME(disassemble_shader)( vbyte *data, int dataSize, int flags
 	return ret;
 }
 
-HL_PRIM dx_vshader *HL_NAME(create_vertex_shader)( vbyte *code, int size ) {
-	dx_vshader *shader;
+HL_PRIM dx_pointer *HL_NAME(create_vertex_shader)( vbyte *code, int size ) {
+	ID3D11VertexShader *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;
+HL_PRIM dx_pointer *HL_NAME(create_pixel_shader)( vbyte *code, int size ) {
+	ID3D11PixelShader *shader;
 	if( driver->device->CreatePixelShader(code, size, NULL, &shader) != S_OK )
 		return NULL;
 	return shader;
@@ -235,16 +232,16 @@ 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_shader)( dx_pointer *s ) {
+	driver->context->VSSetShader((ID3D11VertexShader*)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,ID3D11Buffer*));
 }
 
-HL_PRIM void HL_NAME(ps_set_shader)( dx_pshader *s ) {
-	driver->context->PSSetShader(s,NULL,0);
+HL_PRIM void HL_NAME(ps_set_shader)( dx_pointer *s ) {
+	driver->context->PSSetShader((ID3D11PixelShader*)s,NULL,0);
 }
 
 HL_PRIM void HL_NAME(ps_set_constant_buffers)( int start, int count, varray *a ) {
@@ -263,67 +260,86 @@ 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);
+HL_PRIM void HL_NAME(ia_set_input_layout)( dx_pointer *l ) {
+	driver->context->IASetInputLayout((ID3D11InputLayout*)l);
+}
+
+HL_PRIM void HL_NAME(release_pointer)( dx_pointer *p ) {
+	p->Release();
 }
 
-HL_PRIM void HL_NAME(release_shader)( ID3D11DeviceChild *v ) {
-	v->Release();
+HL_PRIM void HL_NAME(release_resource)( dx_resource *r ) {
+	r->Release();
 }
 
-HL_PRIM void HL_NAME(release_render_target)( dx_render_target *rt ) {
-	rt->Release();
+HL_PRIM dx_pointer *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,dx_struct<D3D11_INPUT_ELEMENT_DESC>*)[i]->value;
+	if( driver->device->CreateInputLayout(desc,arr->size,bytecode,bytecodeLength,&input) != S_OK )
+		return NULL;
+	return input;
 }
 
-HL_PRIM void HL_NAME(release_depth_stencil)( dx_depth_stencil *ds ) {
-	ds->Release();
+HL_PRIM dx_pointer *HL_NAME(create_depth_stencil_view)( dx_resource *tex, int format ) {
+	ID3D11DepthStencilView *view;
+	D3D11_DEPTH_STENCIL_VIEW_DESC  desc;
+	ZeroMemory(&desc, sizeof(desc));
+	desc.Format = (DXGI_FORMAT)format;
+	desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
+	if( driver->device->CreateDepthStencilView(tex,&desc,&view) != S_OK )
+		return NULL;
+	return view;
 }
 
-HL_PRIM void HL_NAME(release_raster)( dx_raster *r ) {
-	r->Release();
+HL_PRIM dx_pointer *HL_NAME(create_depth_stencil_state)( dx_struct<D3D11_DEPTH_STENCIL_DESC> *desc ) {
+	ID3D11DepthStencilState *state;
+	if( driver->device->CreateDepthStencilState(&desc->value,&state) != S_OK )
+		return NULL;
+	return state;
 }
 
-HL_PRIM void HL_NAME(release_resource)( dx_resource *r ) {
-	r->Release();
+HL_PRIM void HL_NAME(om_set_depth_stencil_state)( dx_pointer *s, int ref )  {
+	driver->context->OMSetDepthStencilState((ID3D11DepthStencilState*)s,ref);
 }
 
-HL_PRIM void HL_NAME(release_layout)( dx_layout *l ) {
-	l->Release();
+HL_PRIM void HL_NAME(clear_depth_stencil_view)( dx_pointer *view, vdynamic *depth, vdynamic *stencil ) {
+	driver->context->ClearDepthStencilView((ID3D11DepthStencilView*)view, (depth?D3D11_CLEAR_DEPTH:0) | (stencil?D3D11_CLEAR_STENCIL:0), depth ? (FLOAT)depth->v.d : 0.f, stencil ? stencil->v.i : 0); 
 }
 
-typedef struct {
-	hl_type *t;
-	D3D11_INPUT_ELEMENT_DESC desc;
-} input_element;
+HL_PRIM void HL_NAME(om_set_blend_state)( dx_pointer *state, vbyte *factors, int sampleMask ) {
+	driver->context->OMSetBlendState((ID3D11BlendState*)state,(FLOAT*)factors,sampleMask);
+}
 
-HL_PRIM dx_layout *HL_NAME(create_input_layout)( varray *arr, vbyte *bytecode, int bytecodeLength ) {
-	ID3D11InputLayout *input;
-	D3D11_INPUT_ELEMENT_DESC desc[32];
+HL_PRIM dx_pointer *HL_NAME(create_blend_state)( bool alphaToCoverage, bool independentBlend, varray *arr, int count ) {
+	ID3D11BlendState *s;
+	D3D11_BLEND_DESC desc;
 	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 )
+	ZeroMemory(&desc,sizeof(desc));
+	desc.AlphaToCoverageEnable = alphaToCoverage;
+	desc.IndependentBlendEnable = independentBlend;
+	for(i=0;i<count;i++)
+		desc.RenderTarget[i] = hl_aptr(arr,dx_struct<D3D11_RENDER_TARGET_BLEND_DESC>*)[i]->value;
+	if( driver->device->CreateBlendState(&desc,&s) != S_OK )
 		return NULL;
-	return input;
+	return s;
 }
 
 #define _DRIVER _ABSTRACT(dx_driver)
-#define _SHADER _ABSTRACT(dx_shader)
-#define _LAYOUT _ABSTRACT(dx_layout)
+#define _POINTER _ABSTRACT(dx_pointer)
 #define _RESOURCE _ABSTRACT(dx_resource)
-#define _RASTER _ABSTRACT(dx_raster)
-#define _RENDER_TARGET _ABSTRACT(dx_render_target)
-#define _DEPTH_STENCIL _ABSTRACT(dx_depth_stencil)
 
 DEFINE_PRIM(_DRIVER, create, _ABSTRACT(dx_window) _I32);
 DEFINE_PRIM(_RESOURCE, get_back_buffer, _NO_ARG);
-DEFINE_PRIM(_RENDER_TARGET, create_render_target_view, _RESOURCE _DYN);
-DEFINE_PRIM(_VOID, om_set_render_targets, _I32 _ARR _DEPTH_STENCIL);
-DEFINE_PRIM(_RASTER, create_rasterizer_state, _DYN);
-DEFINE_PRIM(_VOID, rs_set_state, _RASTER);
+DEFINE_PRIM(_POINTER, create_render_target_view, _RESOURCE _DYN);
+DEFINE_PRIM(_VOID, om_set_render_targets, _I32 _ARR _POINTER);
+DEFINE_PRIM(_POINTER, create_rasterizer_state, _DYN);
+DEFINE_PRIM(_VOID, rs_set_state, _POINTER);
 DEFINE_PRIM(_VOID, rs_set_viewports, _I32 _BYTES);
-DEFINE_PRIM(_VOID, clear_color, _RENDER_TARGET _F64 _F64 _F64 _F64);
+DEFINE_PRIM(_VOID, clear_color, _POINTER _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);
@@ -334,23 +350,25 @@ DEFINE_PRIM(_BYTES, map, _RESOURCE _I32 _I32 _BOOL);
 DEFINE_PRIM(_VOID, unmap, _RESOURCE _I32);
 DEFINE_PRIM(_BYTES, compile_shader, _BYTES _I32 _BYTES _BYTES _BYTES _I32 _REF(_BOOL) _REF(_I32));
 DEFINE_PRIM(_BYTES, disassemble_shader, _BYTES _I32 _I32 _BYTES _REF(_I32));
-DEFINE_PRIM(_SHADER, create_vertex_shader, _BYTES _I32);
-DEFINE_PRIM(_SHADER, create_pixel_shader, _BYTES _I32);
+DEFINE_PRIM(_POINTER, create_vertex_shader, _BYTES _I32);
+DEFINE_PRIM(_POINTER, 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_shader, _POINTER);
 DEFINE_PRIM(_VOID, vs_set_constant_buffers, _I32 _I32 _ARR);
-DEFINE_PRIM(_VOID, ps_set_shader, _SHADER);
+DEFINE_PRIM(_VOID, ps_set_shader, _POINTER);
 DEFINE_PRIM(_VOID, ps_set_constant_buffers, _I32 _I32 _ARR);
-DEFINE_PRIM(_VOID, update_subresource, _RESOURCE _I32 _OBJ(_I32 _I32 _I32 _I32 _I32 _I32) _BYTES _I32 _I32);
+DEFINE_PRIM(_VOID, update_subresource, _RESOURCE _I32 _DYN _BYTES _I32 _I32);
 DEFINE_PRIM(_VOID, ia_set_index_buffer, _RESOURCE _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);
-
-DEFINE_PRIM(_VOID, release_render_target, _RENDER_TARGET);
-DEFINE_PRIM(_VOID, release_depth_stencil, _DEPTH_STENCIL);
+DEFINE_PRIM(_VOID, ia_set_input_layout, _POINTER);
+DEFINE_PRIM(_POINTER, create_input_layout, _ARR _BYTES _I32);
+DEFINE_PRIM(_RESOURCE, create_texture_2d, _DYN _BYTES);
+DEFINE_PRIM(_POINTER, create_depth_stencil_view, _RESOURCE _I32);
+DEFINE_PRIM(_POINTER, create_depth_stencil_state, _DYN);
+DEFINE_PRIM(_VOID, om_set_depth_stencil_state, _POINTER);
+DEFINE_PRIM(_VOID, clear_depth_stencil_view, _POINTER _NULL(_F64) _NULL(_I32));
+DEFINE_PRIM(_POINTER, create_blend_state, _BOOL _BOOL _ARR _I32);
+DEFINE_PRIM(_VOID, om_set_blend_state, _POINTER _BYTES _I32);
+DEFINE_PRIM(_VOID, release_pointer, _POINTER);
 DEFINE_PRIM(_VOID, release_resource, _RESOURCE);
-DEFINE_PRIM(_VOID, release_raster, _RASTER);
-DEFINE_PRIM(_VOID, release_shader, _SHADER);
-DEFINE_PRIM(_VOID, release_layout, _LAYOUT);

libs/directx/dx/Driver.hx

@@ -2,31 +2,55 @@ package dx;
 
 typedef DriverInstance = hl.Abstract<"dx_driver">;
 
-abstract Shader(hl.Abstract<"dx_shader">) {
-	@:hlNative("directx", "release_shader") public function release() {
+typedef Pointer = hl.Abstract<"dx_pointer">;
+
+abstract Shader(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
 	}
 }
 
-abstract Layout(hl.Abstract<"dx_layout">) {
-	@:hlNative("directx", "release_layout") public function release() {
+abstract Layout(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
 	}
 }
 
-abstract RasterState(hl.Abstract<"dx_raster">) {
-	@:hlNative("directx", "release_raster") public function release() {
+abstract RasterState(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
 	}
 }
 
-abstract RenderTargetView(hl.Abstract<"dx_render_target">) {
-	@:hlNative("directx", "release_render_target") public function release() {
+abstract RenderTargetView(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
 	}
 }
 
-abstract DepthStencilView(hl.Abstract<"dx_depth_stencil">) {
-	@:hlNative("directx", "release_depth_stencil") public function release() {
+abstract DepthStencilView(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
 	}
 }
 
+abstract DepthStencilState(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
+	}
+}
+
+abstract BlendState(Pointer) {
+	public inline function release() {
+		Driver.releasePointer(this);
+	}
+}
+
+abstract DxBool(Int) {
+	@:to public inline function toBool() : Bool return cast this;
+	@:from static function fromBool( b : Bool ) : DxBool return cast b;
+}
+
 @:enum abstract DriverInitFlags(Int) {
 	var None = 0;
 	var SingleThread = 1;
@@ -41,6 +65,56 @@ abstract DepthStencilView(hl.Abstract<"dx_depth_stencil">) {
 	@:op(a | b) static function or(a:DriverInitFlags, b:DriverInitFlags) : DriverInitFlags;
 }
 
+@:enum abstract ResourceUsage(Int) {
+	var Default = 0;
+	var Immutable = 1;
+	var Dynamic = 2;
+	var Staging = 3;
+}
+
+@:enum abstract ResourceBind(Int) {
+	var VertexBuffer = 1;
+	var IndexBuffer = 2;
+	var ConstantBuffer = 4;
+	var ShaderResource = 8;
+	var StreamOuput = 16;
+	var RenderTarget = 32;
+	var DepthStencil = 64;
+	var UnorderedAccess = 128;
+	var Decoder = 512;
+	var VideoDecoder = 1024;
+	@:op(a | b) static function or(a:ResourceBind, b:ResourceBind) : ResourceBind;
+}
+
+@:enum abstract ResourceAccess(Int) {
+	var None = 0;
+	var CpuWrite = 0x10000;
+	var CpuRead = 0x20000;
+	@:op(a | b) static function or(a:ResourceAccess, b:ResourceAccess) : ResourceAccess;
+}
+
+@:enum abstract ResourceMisc(Int) {
+	var None = 0;
+	var GenerateMips = 1;
+	var Shared = 2;
+	var TextureCube = 4;
+	var DrawIndirectArgs = 0x10;
+	var BufferAllowRawView = 0x20;
+	var BufferStructured = 0x40;
+	var ResourceClamp = 0x80;
+	var SharedKeyedMutex = 0x100;
+	var GdiCompatible = 0x200;
+	var SharedNTHandle = 0x800;
+	var RestrictedContent = 0x1000;
+	var RestrictSharedResource = 0x2000;
+	var RestrictSharedResourceDriver = 0x4000;
+	var Guarded = 0x8000;
+	var TilePool = 0x20000;
+	var Tiled = 0x40000;
+	var HWProtected = 0x80000;
+	@:op(a | b) static function or(a:ResourceMisc, b:ResourceMisc) : ResourceMisc;
+}
+
 @:enum abstract ShaderFlags(Int) {
 	var None = 0;
 	var Debug = 0x1;
@@ -160,14 +234,114 @@ class RenderTargetDesc {
 class RasterizerStateDesc {
 	public var fillMode : FillMode;
 	public var cullMode : CullMode;
-	public var frontCounterClockwise : Bool;
+	public var frontCounterClockwise : DxBool;
 	public var depthBias : Int;
 	public var depthBiasClamp : hl.F32;
 	public var slopeScaledDepthBias : hl.F32;
-	public var depthClipEnable : Bool;
-	public var scissorEnable : Bool;
-	public var multisampleEnable : Bool;
-	public var antialiasedLineEnable : Bool;
+	public var depthClipEnable : DxBool;
+	public var scissorEnable : DxBool;
+	public var multisampleEnable : DxBool;
+	public var antialiasedLineEnable : DxBool;
+	public function new() {
+	}
+}
+
+class Texture2dDesc {
+	public var width : Int;
+	public var height : Int;
+	public var mipLevels : Int;
+	public var arraySize : Int;
+	public var format : Format;
+	public var sampleCount : Int;
+	public var sampleQuality : Int;
+	public var usage : ResourceUsage;
+	public var bind : ResourceBind;
+	public var access : ResourceAccess;
+	public var misc : ResourceMisc;
+	public function new() {
+	}
+}
+
+@:enum abstract ComparisonFunc(Int) {
+	var Never = 1;
+	var Less = 2;
+	var Equal = 3;
+	var LessEqual = 4;
+	var Greater = 5;
+	var NotEqual = 6;
+	var GreaterEqual = 7;
+	var Always = 8;
+}
+
+@:enum abstract StencilOp(Int) {
+	var Keep = 1;
+	var Zero = 2;
+	var Replace = 3;
+	var IncrSat = 4;
+	var DecrSat = 5;
+	var Invert = 6;
+	var Incr = 7;
+	var Desc = 8;
+}
+
+class DepthStencilStateDesc {
+	public var depthEnable : DxBool;
+	public var depthWrite : DxBool;
+	public var depthFunc : ComparisonFunc;
+	public var stencilEnable : DxBool;
+	public var stencilReadMask : hl.UI8;
+	public var stencilWriteMask : hl.UI8;
+	public var frontFaceFail : StencilOp;
+	public var frontFaceDepthFail : StencilOp;
+	public var frontFacePass : StencilOp;
+	public var frontFaceFunc : ComparisonFunc;
+	public var backFaceFail : StencilOp;
+	public var backFaceDepthFail : StencilOp;
+	public var backFacePass : StencilOp;
+	public var backFaceFunc : ComparisonFunc;
+	public function new() {
+	}
+}
+
+@:enum abstract Blend(Int) {
+	var Zero = 1; // (;_;)
+	var One = 2;
+	var SrcColor = 3;
+	var InvSrcColor = 4;
+	var SrcAlpha = 5;
+	var InvSrcAlpha = 6;
+	var DestAlpha = 7;
+	var InvDestAlpha = 8;
+	var DestColor = 9;
+	var InvDestColor = 10;
+	var SrcAlphaSat = 11;
+	var BlendFactor = 14;
+	var InvBlendFactor = 15;
+	var Src1Color = 16;
+	var InvSrc1Color = 17;
+	var Src1Alpha = 18;
+	var InvSrc1Alpha = 19;
+}
+
+@:enum abstract BlendOp(Int) {
+	var Add = 1;
+	var Subtract = 2;
+	var RevSubstract = 3;
+	var Min = 4;
+	var Max = 5;
+}
+
+class RenderTargetBlendDesc {
+
+	public var blendEnable : DxBool;
+	public var srcBlend : Blend;
+	public var descBlend : Blend;
+	public var blendOp : BlendOp;
+	public var srcBlendAlpha : Blend;
+	public var destBlendAlpha : Blend;
+	public var blendOpAlpha : BlendOp;
+	public var renderTargetWriteMask : hl.UI8;
+
 	public function new() {
 	}
 }
@@ -238,6 +412,9 @@ class Driver {
 		return @:privateAccess String.fromUTF8(out);
 	}
 
+	public static function releasePointer( p : Pointer ) {
+	}
+
 	public static function createVertexShader( bytes : haxe.io.Bytes ) {
 		return dxCreateVertexShader(bytes, bytes.length);
 	}
@@ -277,6 +454,40 @@ class Driver {
 		return null;
 	}
 
+	public static function createBuffer( size : Int, usage : ResourceUsage, bind : ResourceBind, access : ResourceAccess, misc : ResourceMisc, stride : Int, data : hl.Bytes ) : Resource {
+		return null;
+	}
+
+	public static function createTexture2d( desc : Texture2dDesc, ?data : hl.Bytes ) : Resource {
+		return dxCreateTexture2d(desc,data);
+	}
+
+	public static function createDepthStencilView( texture : Resource, format : Format ) : DepthStencilView {
+		return null;
+	}
+
+	public static function omSetDepthStencilState( state : DepthStencilState ) : Void {
+	}
+
+	public static function clearDepthStencilView( view : DepthStencilView, depth : Null<Float>, stencil : Null<Int> ) {
+	}
+
+	public static function createDepthStencilState( desc : DepthStencilStateDesc ) : DepthStencilState {
+		return dxCreateDepthStencilState(desc);
+	}
+
+	public static function createBlendState( alphaToCoverage : Bool, independentBlend : Bool, blendDesc : hl.NativeArray<RenderTargetBlendDesc>, count : Int ) : BlendState {
+		return null;
+	}
+
+	public static function omSetBlendState( state : BlendState, factors : hl.BytesAccess<hl.F32>, sampleMask : Int ) {
+	}
+
+	@:hlNative("directx", "create_depth_stencil_state")
+	static function dxCreateDepthStencilState( desc : Dynamic ) : DepthStencilState {
+		return null;
+	}
+
 	@:hlNative("directx", "create_rasterizer_state")
 	static function dxCreateRasterizerState( desc : Dynamic ) : RasterState {
 		return null;
@@ -313,4 +524,9 @@ class Driver {
 		return null;
 	}
 
+	@:hlNative("directx","create_texture_2d")
+	static function dxCreateTexture2d( desc : Dynamic, data : hl.Bytes ) : Resource {
+		return null;
+	}
+
 }

libs/directx/dx/Resource.hx

@@ -1,55 +1,5 @@
 package dx;
 
-@:enum abstract BufferUsage(Int) {
-	var Default = 0;
-	var Immutable = 1;
-	var Dynamic = 2;
-	var Staging = 3;
-}
-
-@:enum abstract BufferBind(Int) {
-	var VertexBuffer = 1;
-	var IndexBuffer = 2;
-	var ConstantBuffer = 4;
-	var ShaderResource = 8;
-	var StreamOuput = 16;
-	var RenderTarget = 32;
-	var DepthStencil = 64;
-	var UnorderedAccess = 128;
-	var Decoder = 512;
-	var VideoDecoder = 1024;
-	@:op(a | b) static function or(a:BufferBind, b:BufferBind) : BufferBind;
-}
-
-@:enum abstract BufferAccess(Int) {
-	var None = 0;
-	var CpuWrite = 0x10000;
-	var CpuRead = 0x20000;
-	@:op(a | b) static function or(a:BufferAccess, b:BufferAccess) : BufferAccess;
-}
-
-@:enum abstract BufferMisc(Int) {
-	var None = 0;
-	var GenerateMips = 1;
-	var Shared = 2;
-	var TextureCube = 4;
-	var DrawIndirectArgs = 0x10;
-	var BufferAllowRawView = 0x20;
-	var BufferStructured = 0x40;
-	var ResourceClamp = 0x80;
-	var SharedKeyedMutex = 0x100;
-	var GdiCompatible = 0x200;
-	var SharedNTHandle = 0x800;
-	var RestrictedContent = 0x1000;
-	var RestrictSharedResource = 0x2000;
-	var RestrictSharedResourceDriver = 0x4000;
-	var Guarded = 0x8000;
-	var TilePool = 0x20000;
-	var Tiled = 0x40000;
-	var HWProtected = 0x80000;
-	@:op(a | b) static function or(a:BufferMisc, b:BufferMisc) : BufferMisc;
-}
-
 @:enum abstract MapType(Int) {
 	var Read = 1;
 	var Write = 2;
@@ -74,20 +24,20 @@ class ResourceBox {
 
 abstract Resource(hl.Abstract<"dx_resource">) {
 
-	@:hlNative("directx","create_buffer")
-	public static function createBuffer( size : Int, usage : BufferUsage, bind : BufferBind, access : BufferAccess, misc : BufferMisc, stride : Int, data : hl.Bytes ) : Resource {
-		return null;
-	}
-
 	@:hlNative("directx", "map")
 	public function map( subResource : Int, type : MapType, waitGpu : Bool ) : hl.Bytes {
 		return null;
 	}
 
+	public inline function updateSubresource( subResource : Int, box : Null<ResourceBox>, data : hl.Bytes, srcRowPitch : Int, srcDepthPitch : Int ) : Void {
+		dxUpdateSubresource(subResource, box, data, srcRowPitch, srcDepthPitch);
+	}
+
 	@:hlNative("directx", "update_subresource")
-	public function updateSubresource( subResource : Int, box : Null<ResourceBox>, data : hl.Bytes, srcRowPitch : Int, srcDepthPitch : Int ) : Void {
+	function dxUpdateSubresource( subResource : Int, box : Dynamic, data : hl.Bytes, srcRowPitch : Int, srcDepthPitch : Int ) : Void {
 	}
 
+
 	@:hlNative("directx", "unmap")
 	public function unmap( subResource : Int ) : Void {
 	}