d3d1x: add new Direct3D 10/11 COM state tracker for Gallium

This is a new implementation of the Direct3D 11 COM API for Gallium.

Direct3D 10 and 10.1 implementations are also provided, which are
automatically generated with s/D3D11/D3D10/g plus a bunch of #ifs.

While this is an initial version, most of the code is there (limited
to what Gallium can express), and tri, gears and texturing demos
are working.

The primary goal is to realize Gallium's promise of multiple API
support, and provide an API that can be easily implemented with just
a very thin wrapper over Gallium, instead of the enormous amount of
complex code needed for OpenGL.

The secondary goal is to run Windows Direct3D 10/11 games on Linux
using Wine.
Wine dlls are currently not provided, but adding them should be
quite easy.

Fglrx and nvidia drivers can also be supported by writing a Gallium
driver that talks to them using OpenGL, which is a relatively easy
task.
Thanks to the great design of Direct3D 10/11 and closeness to Gallium,
this approach should not result in detectable overhead, and is the
most maintainable way to do it, providing a path to switch to the
open Gallium drivers once they are on par with the proprietary ones.

Currently Wine has a very limited Direct3D 10 implementation, and
completely lacks a Direct3D 11 implementation.

Note that Direct3D 10/11 are completely different from Direct3D 9
and earlier, and thus warrant a fully separate implementation.

The third goal is to provide a superior alternative to OpenGL for
graphics programming on non-Windows systems, particularly Linux
and other free and open systems.

Thanks to a very clean and well-though design done from scratch,
the Direct3D 10/11 APIs are vastly better than OpenGL and can be
supported with orders of magnitude less code and development time,
as you can see by comparing the lines of code of this commit and
those in the existing Mesa OpenGL implementation.

This would have been true for the Longs Peak proposal as well, but
unfortunately it was abandoned by Khronos, leaving the OpenGL
ecosystem without a graphics API with a modern design.

A binding of Direct3D 10/11 to EGL would solve this issue in the
most economical way possible, and this would be great to provide
in Mesa, since DXGI, the API used to bind Direct3D 10/11 to Windows,
is a bit suboptimal, especially on non-Windows platforms.

Finally, a mature Direct3D 10/11 implementation is intrinsically going
to be faster and more reliable than an OpenGL implementation, thanks
to the dramatically smaller API and the segregation of all nontrivial
work to object creation that the application must perform ahead of
time.

Currently, this commit contains:
- Independently created headers for Direct3D 10, 10.1, 11 and DXGI 1.1,
  partially based on the existing Wine headers for D3D10 and DXGI 1.0
- A parser for Direct3D 10/11 DXBC and TokenizedProgramFormat (TPF)
- A shader translator from TokenizedProgramFormat to TGSI
- Implementation of the Direct3D 11 core interfaces
- Automatically generated implementation of Direct3D 10 and 10.1
- Implementation of DXGI using the "native" framework of the EGL st
- Demos, usable either on Windows or on this implementation
  - d3d11tri, a clone of tri
  - d3d11tex, a (multi)texturing demo
  - d3d11gears, an improved version of glxgears
  - d3d11spikysphere, a D3D11 tessellation demo (currently Windows-only)
- A downloader for the Microsoft HLSL compiler, needed to recompile
  the shaders (compiled shader bytecode is also included)

To compile this, configure at least with these options:
--with-state-trackers=egl,d3d1x --with-egl-platforms=x11
plus some gallium drivers (such as softpipe with --enable-gallium-swrast)

The Wine headers (usually from a wine-dev or wine-devel package) must
be installed.
Only x86-32 has been tested.

You may need to run "make" in the subdirectories of src/gallium/winsys/sw
and you may need to manually run "sudo make install" in
src/gallium/targets/egl

To test it, run the demos in the "progs" directory.
Windows binaries are included to find out how demos should work, and to
test Wine integration when it will be done.

Enjoy, and let me know if you manage to compile and run this, or
which issues you are facing if not.

Using softpipe is recommended for now, and your mileage with hardware
drivers may vary.
However, getting this to work on hardware drivers is also obviously very
important.

Note that currently llvmpipe is buggy and causes all 3 gears to be
drawn with the same color.
Use export GALLIUM_DRIVER=softpipe to avoid this.

Thanks to all the Gallium contributors and especially the VMware
team, whose work made it possible to implement Direct3D 10/11 much
more easily than it would have been otherwise.

6 files changed, 1202 insertions, 0 deletions

diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/Makefile b/src/gallium/state_trackers/d3d1x/gd3d1x/Makefile
new file mode 100644
index 0000000000..924b2f17c5
--- /dev/null
+++ b/src/gallium/state_trackers/d3d1x/gd3d1x/Makefile
@@ -0,0 +1,6 @@
+LIBNAME=gd3d1x
+CPP_SOURCES=$(wildcard *.cpp)
+LIBRARY_INCLUDES=-Iinclude -I../gd3dapi -I../d3dapi -I../w32api -I../d3d1xstutil/include -I../d3d1xshader/include -I../../../include -I../../../auxiliary -I../../../state_trackers/egl/common
+PROGS=tools/dxbc2tgsi
+LIBS=libgd3d1x.a ../d3d1xshader/libd3d1xshader.a ../../../auxiliary/libgallium.a -ldl
+include ../Makefile.inc
diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h b/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h
new file mode 100644
index 0000000000..6756b2112d
--- /dev/null
+++ b/src/gallium/state_trackers/d3d1x/gd3d1x/d3d1x_private.h
@@ -0,0 +1,101 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef D3D1X_PRIVATE_H_
+#define D3D1X_PRIVATE_H_
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <float.h>
+
+#include "dxbc.h"
+#include "tpf.h"
+#include "tpf_to_tgsi.h"
+
+#include "d3d1xstutil.h"
+
+#include <d3d11.h>
+#include <d3d11shader.h>
+
+
+#include <specstrings.h>
+
+extern "C"
+{
+#include <pipe/p_defines.h>
+#include <pipe/p_screen.h>
+#include <pipe/p_context.h>
+#include <util/u_inlines.h>
+#include <util/u_format.h>
+#include <util/u_caps.h>
+#include <util/u_debug.h>
+#include <os/os_thread.h>
+}
+
+#include "galliumdxgi.h"
+#include "galliumd3d10_1.h"
+#include "galliumd3d11.h"
+
+#ifdef CHECK
+#define invalid(x) unlikely(x)
+#else
+#define invalid(x) (0)
+#endif
+
+#define D3D10_STAGE_VS 0
+#define D3D10_STAGE_PS 1
+#define D3D10_STAGE_GS 2
+#define D3D10_STAGES 3
+
+#define D3D11_STAGE_VS 0
+#define D3D11_STAGE_PS 1
+#define D3D11_STAGE_GS 2
+#define D3D11_STAGE_HS 3
+#define D3D11_STAGE_DS 4
+#define D3D11_STAGE_CS 5
+#define D3D11_STAGES 6
+
+#define D3D11_BLEND_COUNT 20
+extern unsigned d3d11_to_pipe_blend[D3D11_BLEND_COUNT];
+
+#define D3D11_USAGE_COUNT 4
+extern unsigned d3d11_to_pipe_usage[D3D11_USAGE_COUNT];
+
+#define D3D11_STENCIL_OP_COUNT 9
+extern unsigned d3d11_to_pipe_stencil_op[D3D11_STENCIL_OP_COUNT];
+
+#define D3D11_TEXTURE_ADDRESS_COUNT 6
+extern unsigned d3d11_to_pipe_wrap[D3D11_TEXTURE_ADDRESS_COUNT];
+
+#define D3D11_QUERY_COUNT 16
+extern unsigned d3d11_to_pipe_query[D3D11_QUERY_COUNT];
+extern unsigned d3d11_query_size[D3D11_QUERY_COUNT];
+
+#define D3D_PRIMITIVE_TOPOLOGY_COUNT 65
+extern unsigned d3d_to_pipe_prim[D3D_PRIMITIVE_TOPOLOGY_COUNT];
+
+#endif /* D3D1X_H_ */
diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/d3d_enums.cpp b/src/gallium/state_trackers/d3d1x/gd3d1x/d3d_enums.cpp
new file mode 100644
index 0000000000..7932e438c9
--- /dev/null
+++ b/src/gallium/state_trackers/d3d1x/gd3d1x/d3d_enums.cpp
@@ -0,0 +1,147 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "d3d1x_private.h"
+
+unsigned d3d11_to_pipe_blend[D3D11_BLEND_COUNT] =
+{
+	PIPE_BLENDFACTOR_ONE, /* absent in D3D11, but apparently accepted */
+	PIPE_BLENDFACTOR_ZERO,
+	PIPE_BLENDFACTOR_ONE,
+	PIPE_BLENDFACTOR_SRC_COLOR,
+	PIPE_BLENDFACTOR_INV_SRC_COLOR,
+	PIPE_BLENDFACTOR_SRC_ALPHA,
+	PIPE_BLENDFACTOR_INV_SRC_ALPHA,
+	PIPE_BLENDFACTOR_DST_ALPHA,
+	PIPE_BLENDFACTOR_INV_DST_ALPHA,
+	PIPE_BLENDFACTOR_DST_COLOR,
+	PIPE_BLENDFACTOR_INV_DST_COLOR,
+	PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE,
+	0, /* absent in D3D11 */
+	0,  /* absent in D3D11 */
+	PIPE_BLENDFACTOR_CONST_COLOR,
+	PIPE_BLENDFACTOR_INV_CONST_COLOR,
+	PIPE_BLENDFACTOR_SRC1_COLOR,
+	PIPE_BLENDFACTOR_INV_SRC1_COLOR,
+	PIPE_BLENDFACTOR_SRC1_ALPHA,
+	PIPE_BLENDFACTOR_INV_SRC1_ALPHA
+};
+
+unsigned d3d11_to_pipe_usage[D3D11_USAGE_COUNT] =
+{
+	PIPE_USAGE_DEFAULT,
+	PIPE_USAGE_IMMUTABLE,
+	PIPE_USAGE_DYNAMIC,
+	PIPE_USAGE_STAGING
+};
+
+unsigned d3d11_to_pipe_stencil_op[D3D11_STENCIL_OP_COUNT] =
+{
+	PIPE_STENCIL_OP_KEEP,
+	PIPE_STENCIL_OP_KEEP,
+	PIPE_STENCIL_OP_ZERO,
+	PIPE_STENCIL_OP_REPLACE,
+	PIPE_STENCIL_OP_INCR,
+	PIPE_STENCIL_OP_DECR,
+	PIPE_STENCIL_OP_INVERT,
+	PIPE_STENCIL_OP_INCR_WRAP,
+	PIPE_STENCIL_OP_DECR_WRAP,
+};
+
+unsigned d3d11_to_pipe_wrap[D3D11_TEXTURE_ADDRESS_COUNT] =
+{
+	PIPE_TEX_WRAP_REPEAT,
+	PIPE_TEX_WRAP_REPEAT,
+	PIPE_TEX_WRAP_MIRROR_REPEAT,
+	PIPE_TEX_WRAP_CLAMP_TO_EDGE,
+	PIPE_TEX_WRAP_CLAMP_TO_BORDER,
+	PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE,
+};
+
+unsigned d3d11_to_pipe_query[D3D11_QUERY_COUNT] =
+{
+	PIPE_QUERY_GPU_FINISHED,
+	PIPE_QUERY_OCCLUSION_COUNTER,
+	PIPE_QUERY_TIME_ELAPSED,
+	PIPE_QUERY_TIMESTAMP_DISJOINT,
+	0, /* D3D11_QUERY_PIPELINE_STATISTICS */
+	PIPE_QUERY_OCCLUSION_COUNTER,
+	PIPE_QUERY_SO_STATISTICS,
+	0, /* D3D11_QUERY_SO_OVERFLOW_PREDICATE */
+	/* per-stream SO queries */
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+};
+
+unsigned d3d11_query_size[D3D11_QUERY_COUNT] =
+{
+		sizeof(BOOL),
+		sizeof(UINT64),
+		sizeof(UINT64),
+		sizeof(UINT64),
+		0,
+		sizeof(BOOL),
+		sizeof(D3D11_QUERY_DATA_SO_STATISTICS),
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+};
+
+unsigned d3d_to_pipe_prim[D3D_PRIMITIVE_TOPOLOGY_COUNT] =
+{
+	0,
+	PIPE_PRIM_POINTS,
+	PIPE_PRIM_LINES,
+	PIPE_PRIM_LINE_STRIP,
+	PIPE_PRIM_TRIANGLES,
+	PIPE_PRIM_TRIANGLE_STRIP,
+	PIPE_PRIM_LINES_ADJACENCY,
+	PIPE_PRIM_LINE_STRIP_ADJACENCY,
+	PIPE_PRIM_TRIANGLES_ADJACENCY,
+	PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY,
+	/* gap */
+	0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0,
+	/* patches */
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+};
diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp b/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp
new file mode 100644
index 0000000000..2e5062f2ca
--- /dev/null
+++ b/src/gallium/state_trackers/d3d1x/gd3d1x/tools/dxbc2tgsi.cpp
@@ -0,0 +1,82 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "dxbc.h"
+#include "tpf.h"
+#include "../tpf_to_tgsi.h"
+#include "tgsi/tgsi_dump.h"
+#include <iostream>
+#include <fstream>
+
+void usage()
+{
+	std::cerr << "Gallium Direct3D10/11 Shader to TGSI converter\n";
+	std::cerr << "This program is free software, released under a MIT-like license\n";
+	std::cerr << "Not affiliated with or endorsed by Microsoft in any way\n";
+	std::cerr << "Latest version available from http://cgit.freedesktop.org/mesa/mesa/\n";
+	std::cerr << "\n";
+	std::cerr << "Usage: dxbc2tgsi FILE\n";
+	std::cerr << std::endl;
+}
+
+int main(int argc, char** argv)
+{
+	if(argc < 2)
+	{
+		usage();
+		return 1;
+	}
+
+	std::vector<char> data;
+	std::ifstream in(argv[1]);
+	char c;
+	in >> std::noskipws;
+	while(in >> c)
+		data.push_back(c);
+	in.close();
+
+	dxbc_container* dxbc = dxbc_parse(&data[0], data.size());
+	if(dxbc)
+	{
+		std::cout << *dxbc;
+		dxbc_chunk_header* tpf_chunk = dxbc_find_shader_bytecode(&data[0], data.size());
+		if(tpf_chunk)
+		{
+			tpf_program* tpf = tpf_parse(tpf_chunk + 1, bswap_le32(tpf_chunk->size));
+			if(tpf)
+			{
+				const struct tgsi_token* tokens = (const struct tgsi_token*)tpf_to_tgsi(*tpf);
+				if(tokens)
+				{
+					std::cout << *tpf;
+					std::cout << "\n# TGSI program: " << std::endl;
+					tgsi_dump(tokens, 0);
+				}
+			}
+		}
+		delete dxbc;
+	}
+}
diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.cpp b/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.cpp
new file mode 100644
index 0000000000..676c939aa0
--- /dev/null
+++ b/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.cpp
@@ -0,0 +1,832 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "tpf.h"
+#include "tgsi/tgsi_ureg.h"
+#include <vector>
+
+#if 1
+#define check(x) assert(x)
+#define fail(x) assert(0 && (x))
+#else
+#define check(x) do {if(!(x)) throw(#x);} while(0)
+#define fail(x) throw(x)
+#endif
+
+static unsigned tpf_to_pipe_interpolation[] =
+{
+	TGSI_INTERPOLATE_PERSPECTIVE, /* UNDEFINED */
+	TGSI_INTERPOLATE_CONSTANT,
+	TGSI_INTERPOLATE_PERSPECTIVE, /* LINEAR */
+	TGSI_INTERPOLATE_PERSPECTIVE, /* LINEAR_CENTROID */
+	TGSI_INTERPOLATE_LINEAR, /* LINEAR_NOPERSPECTIVE */
+	TGSI_INTERPOLATE_LINEAR, /* LINEAR_NOPERSPECTIVE_CENTROID */
+
+	// Added in D3D10.1
+	TGSI_INTERPOLATE_PERSPECTIVE, /* LINEAR_SAMPLE */
+	TGSI_INTERPOLATE_LINEAR, /* LINEAR_NOPERSPECTIVE_SAMPLE */
+};
+
+static int tpf_to_pipe_sv[] =
+{
+	-1,
+	TGSI_SEMANTIC_POSITION,
+	-1, /*TGSI_SEMANTIC_CLIP_DISTANCE */
+	-1, /*TGSI_SEMANTIC_CULL_DISTANCE */
+	-1, /*TGSI_SEMANTIC_RENDER_TARGET_ARRAY_INDEX */
+	-1, /*TGSI_SEMANTIC_VIEWPORT_ARRAY_INDEX */
+	-1, /*TGSI_SEMANTIC_VERTEXID,*/
+	TGSI_SEMANTIC_PRIMID,
+	TGSI_SEMANTIC_INSTANCEID,
+	TGSI_SEMANTIC_FACE,
+	-1, /*TGSI_SEMANTIC_SAMPLE_INDEX*/
+};
+
+struct tpf_to_tgsi_converter
+{
+	struct ureg_program* ureg;
+	std::vector<struct ureg_dst> temps;
+	std::vector<struct ureg_dst> outputs;
+	std::vector<struct ureg_src> inputs;
+	std::vector<struct ureg_src> samplers;
+	std::vector<std::pair<unsigned, unsigned> > targets; // first is normal, second shadow/comparison
+	std::vector<unsigned> sampler_modes; // 0 = normal, 1 = shadow/comparison
+	std::vector<std::pair<unsigned, unsigned> > loops;
+	tpf_insn* insn;
+	struct tpf_program& program;
+	std::vector<unsigned> tpf_to_tgsi_insn_num;
+	std::vector<std::pair<unsigned, unsigned> > label_to_tpf_insn_num;
+	bool in_sub;
+	bool avoid_txf;
+	bool avoid_int;
+
+	tpf_to_tgsi_converter(struct tpf_program& program)
+	: program(program)
+	{
+		avoid_txf = true;
+		avoid_int = false;
+	}
+
+	struct ureg_dst _reg(tpf_op& op)
+	{
+		switch(op.file)
+		{
+		case TPF_FILE_NULL:
+		{
+			struct ureg_dst d;
+			memset(&d, 0, sizeof(d));
+			d.File = TGSI_FILE_NULL;
+			return d;
+		}
+		case TPF_FILE_TEMP:
+			check(op.has_simple_index());
+			check(op.indices[0].disp < temps.size());
+			return temps[op.indices[0].disp];
+		case TPF_FILE_OUTPUT:
+			check(op.has_simple_index());
+			check(op.indices[0].disp < outputs.size());
+			return outputs[op.indices[0].disp];
+		default:
+			check(0);
+			return ureg_dst_undef();
+		}
+	}
+
+	struct ureg_dst _dst(unsigned i = 0)
+	{
+		check(i < insn->num_ops);
+		tpf_op& op = *insn->ops[i];
+		check(op.mode == TPF_OPERAND_MODE_MASK || op.mode == TPF_OPERAND_MODE_SCALAR);
+		struct ureg_dst d = ureg_writemask(_reg(op), op.mask);
+		if(insn->insn.sat)
+			d = ureg_saturate(d);
+		return d;
+	}
+
+	struct ureg_src _src(unsigned i)
+	{
+		check(i < insn->num_ops);
+		tpf_op& op = *insn->ops[i];
+		struct ureg_src s;
+		switch(op.file)
+		{
+		case TPF_FILE_IMMEDIATE32:
+			s = ureg_imm4f(ureg, op.imm_values[0].f32, op.imm_values[1].f32, op.imm_values[2].f32, op.imm_values[3].f32);
+			break;
+		case TPF_FILE_INPUT:
+			check(op.has_simple_index());
+			check(op.indices[0].disp < inputs.size());
+			s = inputs[op.indices[0].disp];
+			break;
+		case TPF_FILE_CONSTANT_BUFFER:
+			// TODO: indirect addressing
+			check(op.num_indices == 2);
+			check(op.is_index_simple(0));
+			check(op.is_index_simple(1));
+			s = ureg_src_register(TGSI_FILE_CONSTANT, (unsigned)op.indices[1].disp);
+			s.Dimension = 1;
+			s.DimensionIndex = op.indices[0].disp;
+			break;
+		default:
+			s = ureg_src(_reg(op));
+			break;
+		}
+		if(op.mode == TPF_OPERAND_MODE_SWIZZLE || op.mode == TPF_OPERAND_MODE_SCALAR)
+			s = ureg_swizzle(s, op.swizzle[0], op.swizzle[1], op.swizzle[2], op.swizzle[3]);
+		else
+		{
+			/* immediates are masked to show needed values */
+			check(op.file == TPF_FILE_IMMEDIATE32 || op.file == TPF_FILE_IMMEDIATE64);
+		}
+		if(op.abs)
+			s = ureg_abs(s);
+		if(op.neg)
+			s = ureg_negate(s);
+		return s;
+	};
+
+	int _idx(tpf_file file, unsigned i = 0)
+	{
+		check(i < insn->num_ops);
+		tpf_op& op = *insn->ops[i];
+		check(op.file == file);
+		check(op.has_simple_index());
+		return (int)op.indices[0].disp;
+	}
+
+	int _texslot(bool have_sampler = true)
+	{
+		std::map<std::pair<int, int>, int>::iterator i;
+		i = program.resource_sampler_to_slot.find(std::make_pair(_idx(TPF_FILE_RESOURCE, 2), have_sampler ? _idx(TPF_FILE_SAMPLER, 3) : -1));
+		check(i != program.resource_sampler_to_slot.end());
+		return i->second;
+	}
+
+	unsigned tex_target(unsigned texslot)
+	{
+		unsigned mode = sampler_modes[program.slot_to_sampler[texslot]];
+		unsigned target;
+		if(mode)
+			target = targets[program.slot_to_resource[texslot]].second;
+		else
+			target = targets[program.slot_to_resource[texslot]].first;
+		check(target);
+		return target;
+	}
+
+	std::vector<struct ureg_dst> insn_tmps;
+
+	struct ureg_dst _tmp()
+	{
+		struct ureg_dst t = ureg_DECL_temporary(ureg);
+		insn_tmps.push_back(t);
+		return t;
+	}
+
+	struct ureg_dst _tmp(struct ureg_dst d)
+	{
+		if(d.File == TGSI_FILE_TEMPORARY)
+			return d;
+		else
+			return ureg_writemask(_tmp(), d.WriteMask);
+	}
+
+#define OP1_(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1)); break
+#define OP2_(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1), _src(2)); break
+#define OP3_(d, g) case TPF_OPCODE_##d: ureg_##g(ureg, _dst(), _src(1), _src(2), _src(3)); break
+#define OP1(n) OP1_(n, n)
+#define OP2(n) OP2_(n, n)
+#define OP3(n) OP3_(n, n)
+#define OP_CF(d, g)  case TPF_OPCODE_##d: ureg_##g(ureg, &label); label_to_tpf_insn_num.push_back(std::make_pair(label, program.cf_insn_linked[insn_num])); break;
+
+	void translate_insns(unsigned begin, unsigned end)
+	{
+		for(unsigned insn_num = begin; insn_num < end; ++insn_num)
+		{
+			tpf_to_tgsi_insn_num[insn_num] = ureg_get_instruction_number(ureg);
+			unsigned label;
+			insn = program.insns[insn_num];
+			bool ok;
+			ok = true;
+			switch(insn->opcode)
+			{
+			// trivial instructions
+			case TPF_OPCODE_NOP:
+				break;
+			OP1(MOV);
+
+			// float
+			OP2(ADD);
+			OP2(MUL);
+			OP3(MAD);
+			OP2(DIV);
+			OP1(FRC);
+			OP1(RCP);
+			OP2(MIN);
+			OP2(MAX);
+			OP2_(LT, SLT);
+			OP2_(GE, SGE);
+			OP2_(EQ, SEQ);
+			OP2_(NE, SNE);
+
+			// bitwise
+			OP1(NOT);
+			OP2(AND);
+			OP2(OR);
+			OP2(XOR);
+
+			// special mathematical
+			OP2(DP2);
+			OP2(DP3);
+			OP2(DP4);
+			OP1(RSQ);
+			OP1_(LOG, LG2);
+			OP1_(EXP, EX2);
+
+			// rounding
+			OP1_(ROUND_NE, ROUND);
+			OP1_(ROUND_Z, TRUNC);
+			OP1_(ROUND_PI, CEIL);
+			OP1_(ROUND_NI, FLR);
+
+			// cross-thread
+			OP1_(DERIV_RTX, DDX);
+			OP1_(DERIV_RTX_COARSE, DDX);
+			OP1_(DERIV_RTX_FINE, DDX);
+			OP1_(DERIV_RTY, DDY);
+			OP1_(DERIV_RTY_COARSE, DDY);
+			OP1_(DERIV_RTY_FINE, DDY);
+			case TPF_OPCODE_EMIT:
+				ureg_EMIT(ureg);
+				break;
+			case TPF_OPCODE_CUT:
+				ureg_ENDPRIM(ureg);
+				break;
+			case TPF_OPCODE_EMITTHENCUT:
+				ureg_EMIT(ureg);
+				ureg_ENDPRIM(ureg);
+				break;
+
+			// non-trivial instructions
+			case TPF_OPCODE_MOVC:
+				/* CMP checks for < 0, but MOVC checks for != 0
+				 * but fortunately, x != 0 is equivalent to -abs(x) < 0
+				 * XXX: can test_nz apply to this?!
+				 */
+				ureg_CMP(ureg, _dst(), ureg_negate(ureg_abs(_src(1))), _src(2), _src(3));
+				break;
+			case TPF_OPCODE_SQRT:
+			{
+				struct ureg_dst d = _dst();
+				struct ureg_dst t = _tmp(d);
+				ureg_RSQ(ureg, t, _src(1));
+				ureg_RCP(ureg, d, ureg_src(t));
+				break;
+			}
+			case TPF_OPCODE_SINCOS:
+			{
+				struct ureg_dst s = _dst(0);
+				struct ureg_dst c = _dst(1);
+				struct ureg_src v = _src(2);
+				if(s.File != TGSI_FILE_NULL)
+					ureg_SIN(ureg, s, v);
+				if(c.File != TGSI_FILE_NULL)
+					ureg_COS(ureg, c, v);
+				break;
+			}
+
+			// control flow
+			case TPF_OPCODE_DISCARD:
+				ureg_KIL(ureg, _src(0));
+				break;
+			OP_CF(LOOP, BGNLOOP);
+			OP_CF(ENDLOOP, ENDLOOP);
+			case TPF_OPCODE_BREAK:
+				ureg_BRK(ureg);
+				break;
+			case TPF_OPCODE_BREAKC:
+				// XXX: can test_nz apply to this?!
+				ureg_BREAKC(ureg, _src(0));
+				break;
+			case TPF_OPCODE_CONTINUE:
+				ureg_CONT(ureg);
+				break;
+			case TPF_OPCODE_CONTINUEC:
+				// XXX: can test_nz apply to this?!
+				ureg_IF(ureg, _src(0), &label);
+				ureg_CONT(ureg);
+				ureg_fixup_label(ureg, label, ureg_get_instruction_number(ureg));
+				ureg_ENDIF(ureg);
+				break;
+			case TPF_OPCODE_SWITCH:
+				ureg_SWITCH(ureg, _src(0));
+				break;
+			case TPF_OPCODE_CASE:
+				ureg_CASE(ureg, _src(0));
+				break;
+			case TPF_OPCODE_DEFAULT:
+				ureg_DEFAULT(ureg);
+				break;
+			case TPF_OPCODE_ENDSWITCH:
+				ureg_ENDSWITCH(ureg);
+				break;
+			case TPF_OPCODE_CALL:
+				ureg_CAL(ureg, &label);
+				label_to_tpf_insn_num.push_back(std::make_pair(label, program.label_to_insn_num[_idx(TPF_FILE_LABEL)]));
+				break;
+			case TPF_OPCODE_LABEL:
+				if(in_sub)
+					ureg_ENDSUB(ureg);
+				else
+					ureg_END(ureg);
+				ureg_BGNSUB(ureg);
+				in_sub = true;
+				break;
+			case TPF_OPCODE_RET:
+				if(in_sub || insn_num != (program.insns.size() - 1))
+					ureg_RET(ureg);
+				break;
+			case TPF_OPCODE_RETC:
+				ureg_IF(ureg, _src(0), &label);
+				if(insn->insn.test_nz)
+					ureg_RET(ureg);
+				ureg_fixup_label(ureg, label, ureg_get_instruction_number(ureg));
+				if(!insn->insn.test_nz)
+				{
+					ureg_ELSE(ureg, &label);
+					ureg_RET(ureg);
+					ureg_fixup_label(ureg, label, ureg_get_instruction_number(ureg));
+				}
+				ureg_ENDIF(ureg);
+				break;
+			OP_CF(ELSE, ELSE);
+			case TPF_OPCODE_ENDIF:
+				ureg_ENDIF(ureg);
+				break;
+			case TPF_OPCODE_IF:
+				if(insn->insn.test_nz)
+				{
+					ureg_IF(ureg, _src(0), &label);
+					label_to_tpf_insn_num.push_back(std::make_pair(label, program.cf_insn_linked[insn_num]));
+				}
+				else
+				{
+					unsigned linked = program.cf_insn_linked[insn_num];
+					if(program.insns[linked]->opcode == TPF_OPCODE_ENDIF)
+					{
+						ureg_IF(ureg, _src(0), &label);
+						ureg_fixup_label(ureg, label, ureg_get_instruction_number(ureg));
+						ureg_ELSE(ureg, &label);
+						label_to_tpf_insn_num.push_back(std::make_pair(label, linked));
+					}
+					else
+					{
+						/* we have to swap the branches in this case (fun!)
+						 * TODO: maybe just emit a SEQ 0?
+						 * */
+						unsigned endif = program.cf_insn_linked[linked];
+
+						ureg_IF(ureg, _src(0), &label);
+						label_to_tpf_insn_num.push_back(std::make_pair(label, linked));
+
+						translate_insns(linked + 1, endif);
+
+						tpf_to_tgsi_insn_num[linked] = ureg_get_instruction_number(ureg);
+						ureg_ELSE(ureg, &label);
+						label_to_tpf_insn_num.push_back(std::make_pair(label, endif));
+
+						translate_insns(insn_num + 1, linked);
+
+						insn_num = endif - 1;
+						goto next;
+					}
+				}
+				break;
+			case TPF_OPCODE_RESINFO:
+			{
+				std::map<int, int>::iterator i;
+				i = program.resource_to_slot.find(_idx(TPF_FILE_RESOURCE, 2));
+				check(i != program.resource_to_slot.end());
+				unsigned texslot = i->second;
+
+				// no driver actually provides this, unfortunately
+				ureg_TXQ(ureg, _dst(), tex_target(texslot), _src(1), samplers[texslot]);
+				break;
+			};
+			// TODO: sample offset, sample index
+			case TPF_OPCODE_LD: // dst, coord_int, res; mipmap level in last coord_int arg (ouch)
+			case TPF_OPCODE_LD_MS:
+			{
+				unsigned texslot = _texslot(false);
+				unsigned dim;
+				switch(targets[texslot].first)
+				{
+				case TGSI_TEXTURE_1D:
+					dim = 1;
+					break;
+				case TGSI_TEXTURE_2D:
+				case TGSI_TEXTURE_RECT:
+					dim = 2;
+					break;
+				case TGSI_TEXTURE_3D:
+					dim = 3;
+					break;
+				default:
+					check(0);
+				}
+				struct ureg_dst tmp = _tmp();
+				if(avoid_txf)
+				{
+					struct ureg_src texcoord;
+					if(!avoid_int)
+					{
+						ureg_I2F(ureg, tmp, _src(1));
+						texcoord = ureg_src(tmp);
+					}
+					else
+						texcoord = _src(1);
+
+					ureg_TXL(ureg, _dst(), tex_target(texslot), ureg_swizzle(texcoord, 0, 1, 2, dim), samplers[texslot]);
+				}
+				else
+					ureg_TXF(ureg, _dst(), tex_target(texslot), ureg_swizzle(_src(1), 0, 1, 2, dim), samplers[texslot]);
+				break;
+			}
+			case TPF_OPCODE_SAMPLE: // dst, coord, res, samp
+			{
+				unsigned texslot = _texslot();
+				ureg_TEX(ureg, _dst(), tex_target(texslot), _src(1), samplers[texslot]);
+				break;
+			}
+			case TPF_OPCODE_SAMPLE_B: // dst, coord, res, samp, bias.x
+			{
+				unsigned texslot = _texslot();
+				struct ureg_dst tmp = _tmp();
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_XYZ), _src(1));
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), ureg_swizzle(_src(4), 0, 0, 0, 0));
+				ureg_TXB(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]);
+				break;
+			}
+			case TPF_OPCODE_SAMPLE_C: // dst, coord, res, samp, comp.x
+			{
+				unsigned texslot = _texslot();
+				struct ureg_dst tmp = _tmp();
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_XY), _src(1));
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Z), ureg_swizzle(_src(4), 0, 0, 0, 0));
+				ureg_TEX(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]);
+				break;
+			}
+			case TPF_OPCODE_SAMPLE_C_LZ: // dst, coord, res, samp, comp.x
+			{
+				unsigned texslot = _texslot();
+				struct ureg_dst tmp = _tmp();
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_XY), _src(1));
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Z), ureg_swizzle(_src(4), 0, 0, 0, 0));
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), ureg_imm1f(ureg, 0.0));
+				ureg_TXL(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]);
+				break;
+			}
+			case TPF_OPCODE_SAMPLE_D: // dst, coord, res, samp, ddx, ddy
+			{
+				unsigned texslot = _texslot();
+				ureg_TXD(ureg, _dst(), tex_target(texslot), _src(1), samplers[texslot], _src(4), _src(5));
+				break;
+			}
+			case TPF_OPCODE_SAMPLE_L: // dst, coord, res, samp, bias.x
+			{
+				unsigned texslot = _texslot();
+				struct ureg_dst tmp = _tmp();
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_XYZ), _src(1));
+				ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), ureg_swizzle(_src(4), 0, 0, 0, 0));
+				ureg_TXL(ureg, _dst(), tex_target(texslot), ureg_src(tmp), samplers[texslot]);
+				break;
+			}
+			default:
+				ok = false;
+				break;
+			}
+
+			if(!ok && !avoid_int)
+			{
+				ok = true;
+				switch(insn->opcode)
+				{
+				// integer
+				OP1_(ITOF, I2F);
+				OP1_(FTOI, F2I);
+				OP2_(IADD, UADD);
+				OP1(INEG);
+				OP2_(IMUL, UMUL);
+				OP3_(IMAD, UMAD);
+				OP2_(ISHL, SHL);
+				OP2_(ISHR, ISHR);
+				OP2(IMIN);
+				OP2(IMAX);
+				OP2_(ILT, ISLT);
+				OP2_(IGE, ISGE);
+				OP2_(IEQ, USEQ);
+				OP2_(INE, USNE);
+
+				// unsigned
+				OP1_(UTOF, U2F);
+				OP1_(FTOU, F2U);
+				OP2(UMUL);
+				OP3(UMAD);
+				OP2(UMIN);
+				OP2(UMAX);
+				OP2_(ULT, USLT);
+				OP2_(UGE, USGE);
+				OP2(USHR);
+
+				case TPF_OPCODE_UDIV:
+				{
+					struct ureg_dst q = _dst(0);
+					struct ureg_dst r = _dst(1);
+					struct ureg_src a = _src(2);
+					struct ureg_src b = _src(3);
+					if(q.File != TGSI_FILE_NULL)
+						ureg_UDIV(ureg, q, a, b);
+					if(r.File != TGSI_FILE_NULL)
+						ureg_UMOD(ureg, r, a, b);
+					break;
+				}
+				default:
+					ok = false;
+				}
+			}
+
+			if(!ok && avoid_int)
+			{
+				ok = true;
+				switch(insn->opcode)
+				{
+				case TPF_OPCODE_ITOF:
+				case TPF_OPCODE_UTOF:
+					break;
+				OP1_(FTOI, TRUNC);
+				OP1_(FTOU, FLR);
+				// integer
+				OP2_(IADD, ADD);
+				OP2_(IMUL, MUL);
+				OP3_(IMAD, MAD);
+				OP2_(MIN, MIN);
+				OP2_(MAX, MAX);
+				OP2_(ILT, SLT);
+				OP2_(IGE, SGE);
+				OP2_(IEQ, SEQ);
+				OP2_(INE, SNE);
+
+				// unsigned
+				OP2_(UMUL, MUL);
+				OP3_(UMAD, MAD);
+				OP2_(UMIN, MIN);
+				OP2_(UMAX, MAX);
+				OP2_(ULT, SLT);
+				OP2_(UGE, SGE);
+
+				case TPF_OPCODE_INEG:
+					ureg_MOV(ureg, _dst(), ureg_negate(_src(1)));
+					break;
+				case TPF_OPCODE_ISHL:
+				{
+					struct ureg_dst d = _dst();
+					struct ureg_dst t = _tmp(d);
+					ureg_EX2(ureg, t, _src(2));
+					ureg_MUL(ureg, d, ureg_src(t), _src(1));
+					break;
+				}
+				case TPF_OPCODE_ISHR:
+				case TPF_OPCODE_USHR:
+				{
+					struct ureg_dst d = _dst();
+					struct ureg_dst t = _tmp(d);
+					ureg_EX2(ureg, t, ureg_negate(_src(2)));
+					ureg_MUL(ureg, t, ureg_src(t), _src(1));
+					ureg_FLR(ureg, d, ureg_src(t));
+					break;
+				}
+				case TPF_OPCODE_UDIV:
+				{
+					struct ureg_dst q = _dst(0);
+					struct ureg_dst r = _dst(1);
+					struct ureg_src a = _src(2);
+					struct ureg_src b = _src(3);
+					struct ureg_dst f = _tmp();
+					ureg_DIV(ureg, f, a, b);
+					if(q.File != TGSI_FILE_NULL)
+						ureg_FLR(ureg, q, ureg_src(f));
+					if(r.File != TGSI_FILE_NULL)
+					{
+						ureg_FRC(ureg, f, ureg_src(f));
+						ureg_MUL(ureg, r, ureg_src(f), b);
+					}
+					break;
+				}
+				default:
+					ok = false;
+				}
+			}
+
+			check(ok);
+
+			if(!insn_tmps.empty())
+			{
+				for(unsigned i = 0; i < insn_tmps.size(); ++i)
+					ureg_release_temporary(ureg, insn_tmps[i]);
+				insn_tmps.clear();
+			}
+next:;
+		}
+	}
+
+	void* do_translate()
+	{
+		unsigned processor;
+		switch(program.version.type)
+		{
+		case 0:
+			processor = TGSI_PROCESSOR_FRAGMENT;
+			break;
+		case 1:
+			processor = TGSI_PROCESSOR_VERTEX;
+			break;
+		case 2:
+			processor = TGSI_PROCESSOR_GEOMETRY;
+			break;
+		default:
+			fail("Tessellation and compute shaders not yet supported");
+			return 0;
+		}
+
+		if(!tpf_link_cf_insns(program))
+			fail("Malformed control flow");
+		if(!tpf_find_labels(program))
+			fail("Failed to locate labels");
+		if(!tpf_allocate_resource_sampler_pairs(program))
+			fail("Unsupported (indirect?) accesses to resources and/or samplers");
+
+		ureg = ureg_create(processor);
+
+		in_sub = false;
+
+		for(unsigned i = 0; i < program.slot_to_resource.size(); ++i)
+			samplers.push_back(ureg_DECL_sampler(ureg, i));
+
+		tpf_to_tgsi_insn_num.resize(program.insns.size());
+		for(unsigned insn_num = 0; insn_num < program.dcls.size(); ++insn_num)
+		{
+			tpf_dcl& dcl = *program.dcls[insn_num];
+			int idx = -1;
+			if(dcl.op.get() && dcl.op->has_simple_index())
+				idx = dcl.op->indices[0].disp;
+			switch(dcl.opcode)
+			{
+			case TPF_OPCODE_DCL_GLOBAL_FLAGS:
+				break;
+			case TPF_OPCODE_DCL_TEMPS:
+				for(unsigned i = 0; i < dcl.num; ++i)
+					temps.push_back(ureg_DECL_temporary(ureg));
+				break;
+			case TPF_OPCODE_DCL_INPUT:
+				check(idx >= 0);
+				if(inputs.size() <= (unsigned)idx)
+					inputs.resize(idx + 1);
+				if(processor == TGSI_PROCESSOR_VERTEX)
+					inputs[idx] = ureg_DECL_vs_input(ureg, idx);
+				else
+					check(0);
+				break;
+			case TPF_OPCODE_DCL_INPUT_PS:
+				check(idx >= 0);
+				if(inputs.size() <= (unsigned)idx)
+					inputs.resize(idx + 1);
+				inputs[idx] = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_GENERIC, idx, tpf_to_pipe_interpolation[dcl.dcl_input_ps.interpolation]);
+				break;
+			case TPF_OPCODE_DCL_OUTPUT:
+				check(idx >= 0);
+				if(outputs.size() <= (unsigned)idx)
+					outputs.resize(idx + 1);
+				if(processor == TGSI_PROCESSOR_FRAGMENT)
+					outputs[idx] = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, idx);
+				else
+					outputs[idx] = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, idx);
+				break;
+			case TPF_OPCODE_DCL_INPUT_SIV:
+			case TPF_OPCODE_DCL_INPUT_SGV:
+			case TPF_OPCODE_DCL_INPUT_PS_SIV:
+			case TPF_OPCODE_DCL_INPUT_PS_SGV:
+				check(idx >= 0);
+				if(inputs.size() <= (unsigned)idx)
+					inputs.resize(idx + 1);
+				// TODO: is this correct?
+				inputs[idx] = ureg_DECL_system_value(ureg, idx, tpf_to_pipe_sv[dcl.sv], 0);
+				break;
+			case TPF_OPCODE_DCL_OUTPUT_SIV:
+			case TPF_OPCODE_DCL_OUTPUT_SGV:
+				check(idx >= 0);
+				if(outputs.size() <= (unsigned)idx)
+					outputs.resize(idx + 1);
+				check(tpf_to_pipe_sv[dcl.sv] >= 0);
+				outputs[idx] = ureg_DECL_output(ureg, tpf_to_pipe_sv[dcl.sv], 0);
+				break;
+			case TPF_OPCODE_DCL_RESOURCE:
+				check(idx >= 0);
+				if(targets.size() <= (unsigned)idx)
+					targets.resize(idx + 1);
+				switch(dcl.dcl_resource.target)
+				{
+				case TPF_TARGET_TEXTURE1D:
+					targets[idx].first = TGSI_TEXTURE_1D;
+					targets[idx].second = TGSI_TEXTURE_SHADOW1D;
+					break;
+				case TPF_TARGET_TEXTURE2D:
+					targets[idx].first = TGSI_TEXTURE_2D;
+					targets[idx].second = TGSI_TEXTURE_SHADOW2D;
+					break;
+				case TPF_TARGET_TEXTURE3D:
+					targets[idx].first = TGSI_TEXTURE_3D;
+					targets[idx].second = 0;
+					break;
+				case TPF_TARGET_TEXTURECUBE:
+					targets[idx].first = TGSI_TEXTURE_CUBE;
+					targets[idx].second = 0;
+					break;
+				default:
+					check(0);
+				}
+				break;
+			case TPF_OPCODE_DCL_SAMPLER:
+				check(idx >= 0);
+				if(sampler_modes.size() <= (unsigned)idx)
+					sampler_modes.resize(idx + 1);
+				check(!dcl.dcl_sampler.mono);
+				sampler_modes[idx] = dcl.dcl_sampler.shadow;
+				break;
+			case TPF_OPCODE_DCL_CONSTANT_BUFFER:
+				check(dcl.op->num_indices == 2);
+				check(dcl.op->is_index_simple(0));
+				check(dcl.op->is_index_simple(1));
+				idx = dcl.op->indices[0].disp;
+				ureg_DECL_constant2D(ureg, 0, (unsigned)dcl.op->indices[1].disp - 1, idx);
+				break;
+			default:
+				check(0);
+			}
+		}
+
+		translate_insns(0, program.insns.size());
+		tpf_to_tgsi_insn_num.push_back(ureg_get_instruction_number(ureg));
+		if(in_sub)
+			ureg_ENDSUB(ureg);
+		else
+			ureg_END(ureg);
+
+		for(unsigned i = 0; i < label_to_tpf_insn_num.size(); ++i)
+			ureg_fixup_label(ureg, label_to_tpf_insn_num[i].first, tpf_to_tgsi_insn_num[label_to_tpf_insn_num[i].second]);
+
+		const struct tgsi_token * tokens = ureg_get_tokens(ureg, 0);
+		ureg_destroy(ureg);
+		return (void*)tokens;
+	}
+
+	void* translate()
+	{
+		try
+		{
+			return do_translate();
+		}
+		catch(const char*)
+		{
+			return 0;
+		}
+	}
+};
+
+void* tpf_to_tgsi(struct tpf_program& program)
+{
+	tpf_to_tgsi_converter conv(program);
+	return conv.translate();
+}
diff --git a/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.h b/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.h
new file mode 100644
index 0000000000..68a30d2d2e
--- /dev/null
+++ b/src/gallium/state_trackers/d3d1x/gd3d1x/tpf_to_tgsi.h
@@ -0,0 +1,34 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef TPF_TO_TGSI_H_
+#define TPF_TO_TGSI_H_
+
+#include "tpf.h"
+
+void* tpf_to_tgsi(struct tpf_program& program);
+
+#endif /* TPF_TO_TGSI_H_ */