dlls/wined3d/baseshader.c - wine - Git at Google

 /*
  * shaders implementation
  *
  * Copyright 2002-2003 Jason Edmeades
  * Copyright 2002-2003 Raphael Junqueira
  * Copyright 2005 Oliver Stieber
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 #include "config.h"
 #include <string.h>
 #include <stdio.h>
 #include "wined3d_private.h"

 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);

 #define GLNAME_REQUIRE_GLSL  ((const char *)1)

 inline static BOOL shader_is_version_token(DWORD token) {
     return 0xFFFF0000 == (token & 0xFFFF0000) ||
            0xFFFE0000 == (token & 0xFFFF0000);
 }

 inline static BOOL shader_is_comment_token(DWORD token) {
     return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
 }

 int shader_addline(
     SHADER_BUFFER* buffer,
     const char *format, ...) {

     char* base = buffer->buffer + buffer->bsize;
     int rc;

     va_list args;
     va_start(args, format);
     rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
     va_end(args);

     if (rc < 0 ||                                   /* C89 */
         rc > SHADER_PGMSIZE - 1 - buffer->bsize) {  /* C99 */

         ERR("The buffer allocated for the shader program string "
             "is too small at %d bytes.\n", SHADER_PGMSIZE);
         buffer->bsize = SHADER_PGMSIZE - 1;
         return -1;
     }

     buffer->bsize += rc;
     buffer->lineNo++;
     TRACE("GL HW (%u, %u) : %s", buffer->lineNo, buffer->bsize, base);
     return 0;
 }

 const SHADER_OPCODE* shader_get_opcode(
     IWineD3DBaseShader *iface, const DWORD code) {

     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface;

     DWORD i = 0;
     DWORD version = This->baseShader.version;
     DWORD hex_version = This->baseShader.hex_version;
     const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;

     /** TODO: use dichotomic search */
     while (NULL != shader_ins[i].name) {
         if (((code & D3DSI_OPCODE_MASK) == shader_ins[i].opcode) &&
             (((hex_version >= shader_ins[i].min_version) && (hex_version <= shader_ins[i].max_version)) ||
             ((shader_ins[i].min_version == 0) && (shader_ins[i].max_version == 0)))) {
             return &shader_ins[i];
         }
         ++i;
     }
     FIXME("Unsupported opcode %lx(%ld) masked %lx version %ld\n",
        code, code, code & D3DSI_OPCODE_MASK, version);
     return NULL;
 }

 /* Note: For vertex shaders,
  * texUsed = addrUsed, and
  * D3DSPR_TEXTURE = D3DSPR_ADDR.
  *
  * Also note that this does not count the loop register
  * as an address register. */

 void shader_get_registers_used(
     IWineD3DBaseShader *iface,
     CONST DWORD* pToken) {

     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
     DWORD* tempsUsed = &This->baseShader.temps_used;
     DWORD* texUsed = &This->baseShader.textures_used;

     if (pToken == NULL)
         return;

     *tempsUsed = 0;
     *texUsed = 0;

     while (D3DVS_END() != *pToken) {
         CONST SHADER_OPCODE* curOpcode;

         /* Skip version */
         if (shader_is_version_token(*pToken)) {
              ++pToken;
              continue;

         /* Skip comments */
         } else if (shader_is_comment_token(*pToken)) {
              DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
              ++pToken;
              pToken += comment_len;
              continue;
         }

         /* Fetch opcode */
         curOpcode = shader_get_opcode(iface, *pToken);
         ++pToken;

         /* Unhandled opcode, and its parameters */
         if (NULL == curOpcode) {
            while (*pToken & 0x80000000)
                ++pToken;
            continue;

         /* Skip declarations (for now) */
         } else if (D3DSIO_DCL == curOpcode->opcode) {
             pToken += curOpcode->num_params;
             continue;

         /* Skip definitions (for now) */
         } else if (D3DSIO_DEF == curOpcode->opcode) {
             pToken += curOpcode->num_params;
             continue;

         /* Set texture registers, and temporary registers */
         } else {
             int i;

             for (i = 0; i < curOpcode->num_params; ++i) {
                 DWORD regtype = (((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
                 DWORD reg = (*pToken) & D3DSP_REGNUM_MASK;
                 if (D3DSPR_TEXTURE == regtype)
                     *texUsed |= (1 << reg);
                 if (D3DSPR_TEMP == regtype)
                     *tempsUsed |= (1 << reg);
                 ++pToken;
              }
         }
     }
 }

 void shader_program_dump_decl_usage(
     DWORD decl,
     DWORD param) {

     DWORD regtype = shader_get_regtype(param);
     TRACE("dcl_");

     if (regtype == D3DSPR_SAMPLER) {
         DWORD ttype = decl & D3DSP_TEXTURETYPE_MASK;

         switch (ttype) {
             case D3DSTT_2D: TRACE("2d"); break;
             case D3DSTT_CUBE: TRACE("cube"); break;
             case D3DSTT_VOLUME: TRACE("volume"); break;
             default: TRACE("unknown_ttype(%08lx)", ttype);
        }

     } else {

         DWORD usage = decl & D3DSP_DCL_USAGE_MASK;
         DWORD idx = (decl & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;

         switch(usage) {
         case D3DDECLUSAGE_POSITION:
             TRACE("%s%ld", "position", idx);
             break;
         case D3DDECLUSAGE_BLENDINDICES:
             TRACE("%s", "blend");
             break;
         case D3DDECLUSAGE_BLENDWEIGHT:
             TRACE("%s", "weight");
             break;
         case D3DDECLUSAGE_NORMAL:
             TRACE("%s%ld", "normal", idx);
             break;
         case D3DDECLUSAGE_PSIZE:
             TRACE("%s", "psize");
             break;
         case D3DDECLUSAGE_COLOR:
             if(idx == 0)  {
                 TRACE("%s", "color");
             } else {
                 TRACE("%s%ld", "specular", (idx - 1));
             }
             break;
         case D3DDECLUSAGE_TEXCOORD:
             TRACE("%s%ld", "texture", idx);
             break;
         case D3DDECLUSAGE_TANGENT:
             TRACE("%s", "tangent");
             break;
         case D3DDECLUSAGE_BINORMAL:
             TRACE("%s", "binormal");
             break;
         case D3DDECLUSAGE_TESSFACTOR:
             TRACE("%s", "tessfactor");
             break;
         case D3DDECLUSAGE_POSITIONT:
             TRACE("%s%ld", "positionT", idx);
             break;
         case D3DDECLUSAGE_FOG:
             TRACE("%s", "fog");
             break;
         case D3DDECLUSAGE_DEPTH:
             TRACE("%s", "depth");
             break;
         case D3DDECLUSAGE_SAMPLE:
             TRACE("%s", "sample");
             break;
         default:
             FIXME("unknown_semantics(%08lx)", usage);
         }
     }
 }

 /** Generate the variable & register declarations for the ARB_vertex_program
     output target */
 void generate_arb_declarations(IWineD3DBaseShader *iface, SHADER_BUFFER* buffer) {

     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
     DWORD i;

     for(i = 0; i < This->baseShader.limits.temporary; i++) {
         if (This->baseShader.temps_used & (1 << i))
             shader_addline(buffer, "TEMP R%lu;\n", i);
     }

     for (i = 0; i < This->baseShader.limits.address; i++) {
         if (This->baseShader.textures_used & (1 << i))
             shader_addline(buffer, "ADDRESS A%ld;\n", i);
     }

     for(i = 0; i < This->baseShader.limits.texture; i++) {
         if (This->baseShader.textures_used & (1 << i))
             shader_addline(buffer,"TEMP T%lu;\n", i);
     }

     /* Texture coordinate registers must be pre-loaded */
     for (i = 0; i < This->baseShader.limits.texture; i++) {
     if (This->baseShader.textures_used & (1 << i))
         shader_addline(buffer, "MOV T%lu, fragment.texcoord[%lu];\n", i, i);
     }
 }

 /** Generate the variable & register declarations for the GLSL
     output target */
 void generate_glsl_declarations(IWineD3DBaseShader *iface, SHADER_BUFFER* buffer) {

     FIXME("GLSL not fully implemented yet.\n");

 }

 /** Shared code in order to generate the bulk of the shader string.
     Use the shader_header_fct & shader_footer_fct to add strings
     that are specific to pixel or vertex functions
     NOTE: A description of how to parse tokens can be found at:
           http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
 void generate_base_shader(
     IWineD3DBaseShader *iface,
     SHADER_BUFFER* buffer,
     CONST DWORD* pFunction) {

     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
     const DWORD *pToken = pFunction;
     const SHADER_OPCODE *curOpcode = NULL;
     DWORD i;

     /* Initialize current parsing state */
     This->baseShader.parse_state.current_row = 0;

     /* First pass: figure out which temporary and texture registers are used */
     shader_get_registers_used(iface, pToken);
     TRACE("Texture/Address registers used: %#lx, Temp registers used %#lx\n",
           This->baseShader.textures_used, This->baseShader.temps_used);

     /* TODO: check register usage against GL/Directx limits, and fail if they're exceeded
         nUseAddressRegister < = GL_MAX_PROGRAM_ADDRESS_REGISTERS_AR
         nUseTempRegister    <=  GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
     */

     /* Pre-declare registers */
     if (USING_GLSL)
         generate_glsl_declarations(iface, buffer);
     else
         generate_arb_declarations(iface, buffer);

     /* Second pass, process opcodes */
     if (NULL != pToken) {
         while (D3DPS_END() != *pToken) {

             /* Skip version token */
             if (shader_is_version_token(*pToken)) {
                 ++pToken;
                 continue;
             }

             /* Skip comment tokens */
             if (shader_is_comment_token(*pToken)) {
                 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
                 ++pToken;
                 TRACE("#%s\n", (char*)pToken);
                 pToken += comment_len;
                 continue;
             }

             /* Read opcode */
             curOpcode = shader_get_opcode(iface, *pToken);
             ++pToken;

             /* Unknown opcode and its parameters */
             if (NULL == curOpcode) {
                 while (*pToken & 0x80000000) { /* TODO: Think of a sensible name for 0x80000000 */
                     FIXME("unrecognized opcode: %08lx\n", *pToken);
                     ++pToken;
                 }

             /* Using GLSL & no generator function exists */
             } else if (USING_GLSL && curOpcode->hw_glsl_fct == NULL) {

                 FIXME("Token %s is not yet implemented with GLSL\n", curOpcode->name);
                 pToken += curOpcode->num_params;

             /* Unhandled opcode in ARB */
             } else if ( !USING_GLSL && GLNAME_REQUIRE_GLSL == curOpcode->glname) {

                 FIXME("Token %s requires greater functionality than "
                     "Vertex or Fragment_Program_ARB supports\n", curOpcode->name);
                 pToken += curOpcode->num_params;

             /* If a generator function is set for current shader target, use it */
             } else if ((!USING_GLSL && curOpcode->hw_fct != NULL) ||
                        (USING_GLSL && curOpcode->hw_glsl_fct != NULL)) {

                 SHADER_OPCODE_ARG hw_arg;

                 hw_arg.shader = iface;
                 hw_arg.opcode = curOpcode;
                 hw_arg.buffer = buffer;
                 if (curOpcode->num_params > 0) {
                     hw_arg.dst = *pToken;

                     /* FIXME: this does not account for relative address tokens */
                     for (i = 1; i < curOpcode->num_params; i++)
                        hw_arg.src[i-1] = *(pToken + i);
                 }

                 /* Call appropriate function for output target */
                 if (USING_GLSL)
                     curOpcode->hw_glsl_fct(&hw_arg);
                 else
                     curOpcode->hw_fct(&hw_arg);

                 pToken += curOpcode->num_params;

             } else {

                 TRACE("Found opcode D3D:%s GL:%s, PARAMS:%d, \n",
                 curOpcode->name, curOpcode->glname, curOpcode->num_params);

                 /* Unless we encounter a no-op command, this opcode is unrecognized */
                 if (curOpcode->opcode != D3DSIO_NOP) {
                     FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
                     pToken += curOpcode->num_params;
                 }
             }
         }
         /* TODO: What about result.depth? */

     }
 }


 void shader_dump_ins_modifiers(const DWORD output) {

     DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
     DWORD mmask = output & D3DSP_DSTMOD_MASK;

     switch (shift) {
         case 0: break;
         case 13: TRACE("_d8"); break;
         case 14: TRACE("_d4"); break;
         case 15: TRACE("_d2"); break;
         case 1: TRACE("_x2"); break;
         case 2: TRACE("_x4"); break;
         case 3: TRACE("_x8"); break;
         default: TRACE("_unhandled_shift(%ld)", shift); break;
     }

     switch(mmask) {
         case D3DSPDM_NONE: break;
         case D3DSPDM_SATURATE: TRACE("_sat"); break;
         case D3DSPDM_PARTIALPRECISION: TRACE("_pp"); break;
         case D3DSPDM_MSAMPCENTROID: TRACE("_centroid"); break;
         default: TRACE("_unhandled_modifier(%#lx)", mmask); break;
     }
 }

 /* TODO: Move other shared code here */
	/*
	* shaders implementation
	*
	* Copyright 2002-2003 Jason Edmeades
	* Copyright 2002-2003 Raphael Junqueira
	* Copyright 2005 Oliver Stieber
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include "config.h"
	#include <string.h>
	#include <stdio.h>
	#include "wined3d_private.h"

	WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);

	#define GLNAME_REQUIRE_GLSL ((const char *)1)

	inline static BOOL shader_is_version_token(DWORD token) {
	return 0xFFFF0000 == (token & 0xFFFF0000) \|\|
	0xFFFE0000 == (token & 0xFFFF0000);
	}

	inline static BOOL shader_is_comment_token(DWORD token) {
	return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
	}

	int shader_addline(
	SHADER_BUFFER* buffer,
	const char *format, ...) {

	char* base = buffer->buffer + buffer->bsize;
	int rc;

	va_list args;
	va_start(args, format);
	rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
	va_end(args);

	if (rc < 0 \|\| /* C89 */
	rc > SHADER_PGMSIZE - 1 - buffer->bsize) { /* C99 */

	ERR("The buffer allocated for the shader program string "
	"is too small at %d bytes.\n", SHADER_PGMSIZE);
	buffer->bsize = SHADER_PGMSIZE - 1;
	return -1;
	}

	buffer->bsize += rc;
	buffer->lineNo++;
	TRACE("GL HW (%u, %u) : %s", buffer->lineNo, buffer->bsize, base);
	return 0;
	}

	const SHADER_OPCODE* shader_get_opcode(
	IWineD3DBaseShader *iface, const DWORD code) {

	IWineD3DBaseShaderImpl This = (IWineD3DBaseShaderImpl) iface;

	DWORD i = 0;
	DWORD version = This->baseShader.version;
	DWORD hex_version = This->baseShader.hex_version;
	const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;

	/** TODO: use dichotomic search */
	while (NULL != shader_ins[i].name) {
	if (((code & D3DSI_OPCODE_MASK) == shader_ins[i].opcode) &&
	(((hex_version >= shader_ins[i].min_version) && (hex_version <= shader_ins[i].max_version)) \|\|
	((shader_ins[i].min_version == 0) && (shader_ins[i].max_version == 0)))) {
	return &shader_ins[i];
	}
	++i;
	}
	FIXME("Unsupported opcode %lx(%ld) masked %lx version %ld\n",
	code, code, code & D3DSI_OPCODE_MASK, version);
	return NULL;
	}

	/* Note: For vertex shaders,
	* texUsed = addrUsed, and
	* D3DSPR_TEXTURE = D3DSPR_ADDR.
	*
	* Also note that this does not count the loop register
	* as an address register. */

	void shader_get_registers_used(
	IWineD3DBaseShader *iface,
	CONST DWORD* pToken) {

	IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
	DWORD* tempsUsed = &This->baseShader.temps_used;
	DWORD* texUsed = &This->baseShader.textures_used;

	if (pToken == NULL)
	return;

	*tempsUsed = 0;
	*texUsed = 0;

	while (D3DVS_END() != *pToken) {
	CONST SHADER_OPCODE* curOpcode;

	/* Skip version */
	if (shader_is_version_token(*pToken)) {
	++pToken;
	continue;

	/* Skip comments */
	} else if (shader_is_comment_token(*pToken)) {
	DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
	++pToken;
	pToken += comment_len;
	continue;
	}

	/* Fetch opcode */
	curOpcode = shader_get_opcode(iface, *pToken);
	++pToken;

	/* Unhandled opcode, and its parameters */
	if (NULL == curOpcode) {
	while (*pToken & 0x80000000)
	++pToken;
	continue;

	/* Skip declarations (for now) */
	} else if (D3DSIO_DCL == curOpcode->opcode) {
	pToken += curOpcode->num_params;
	continue;

	/* Skip definitions (for now) */
	} else if (D3DSIO_DEF == curOpcode->opcode) {
	pToken += curOpcode->num_params;
	continue;

	/* Set texture registers, and temporary registers */
	} else {
	int i;

	for (i = 0; i < curOpcode->num_params; ++i) {
	DWORD regtype = (((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
	DWORD reg = (*pToken) & D3DSP_REGNUM_MASK;
	if (D3DSPR_TEXTURE == regtype)
	*texUsed \|= (1 << reg);
	if (D3DSPR_TEMP == regtype)
	*tempsUsed \|= (1 << reg);
	++pToken;
	}
	}
	}
	}

	void shader_program_dump_decl_usage(
	DWORD decl,
	DWORD param) {

	DWORD regtype = shader_get_regtype(param);
	TRACE("dcl_");

	if (regtype == D3DSPR_SAMPLER) {
	DWORD ttype = decl & D3DSP_TEXTURETYPE_MASK;

	switch (ttype) {
	case D3DSTT_2D: TRACE("2d"); break;
	case D3DSTT_CUBE: TRACE("cube"); break;
	case D3DSTT_VOLUME: TRACE("volume"); break;
	default: TRACE("unknown_ttype(%08lx)", ttype);
	}

	} else {

	DWORD usage = decl & D3DSP_DCL_USAGE_MASK;
	DWORD idx = (decl & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;

	switch(usage) {
	case D3DDECLUSAGE_POSITION:
	TRACE("%s%ld", "position", idx);
	break;
	case D3DDECLUSAGE_BLENDINDICES:
	TRACE("%s", "blend");
	break;
	case D3DDECLUSAGE_BLENDWEIGHT:
	TRACE("%s", "weight");
	break;
	case D3DDECLUSAGE_NORMAL:
	TRACE("%s%ld", "normal", idx);
	break;
	case D3DDECLUSAGE_PSIZE:
	TRACE("%s", "psize");
	break;
	case D3DDECLUSAGE_COLOR:
	if(idx == 0) {
	TRACE("%s", "color");
	} else {
	TRACE("%s%ld", "specular", (idx - 1));
	}
	break;
	case D3DDECLUSAGE_TEXCOORD:
	TRACE("%s%ld", "texture", idx);
	break;
	case D3DDECLUSAGE_TANGENT:
	TRACE("%s", "tangent");
	break;
	case D3DDECLUSAGE_BINORMAL:
	TRACE("%s", "binormal");
	break;
	case D3DDECLUSAGE_TESSFACTOR:
	TRACE("%s", "tessfactor");
	break;
	case D3DDECLUSAGE_POSITIONT:
	TRACE("%s%ld", "positionT", idx);
	break;
	case D3DDECLUSAGE_FOG:
	TRACE("%s", "fog");
	break;
	case D3DDECLUSAGE_DEPTH:
	TRACE("%s", "depth");
	break;
	case D3DDECLUSAGE_SAMPLE:
	TRACE("%s", "sample");
	break;
	default:
	FIXME("unknown_semantics(%08lx)", usage);
	}
	}
	}

	/** Generate the variable & register declarations for the ARB_vertex_program
	output target */
	void generate_arb_declarations(IWineD3DBaseShader iface, SHADER_BUFFER buffer) {

	IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
	DWORD i;

	for(i = 0; i < This->baseShader.limits.temporary; i++) {
	if (This->baseShader.temps_used & (1 << i))
	shader_addline(buffer, "TEMP R%lu;\n", i);
	}

	for (i = 0; i < This->baseShader.limits.address; i++) {
	if (This->baseShader.textures_used & (1 << i))
	shader_addline(buffer, "ADDRESS A%ld;\n", i);
	}

	for(i = 0; i < This->baseShader.limits.texture; i++) {
	if (This->baseShader.textures_used & (1 << i))
	shader_addline(buffer,"TEMP T%lu;\n", i);
	}

	/* Texture coordinate registers must be pre-loaded */
	for (i = 0; i < This->baseShader.limits.texture; i++) {
	if (This->baseShader.textures_used & (1 << i))
	shader_addline(buffer, "MOV T%lu, fragment.texcoord[%lu];\n", i, i);
	}
	}

	/** Generate the variable & register declarations for the GLSL
	output target */
	void generate_glsl_declarations(IWineD3DBaseShader iface, SHADER_BUFFER buffer) {

	FIXME("GLSL not fully implemented yet.\n");

	}

	/** Shared code in order to generate the bulk of the shader string.
	Use the shader_header_fct & shader_footer_fct to add strings
	that are specific to pixel or vertex functions
	NOTE: A description of how to parse tokens can be found at:
	http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
	void generate_base_shader(
	IWineD3DBaseShader *iface,
	SHADER_BUFFER* buffer,
	CONST DWORD* pFunction) {

	IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
	const DWORD *pToken = pFunction;
	const SHADER_OPCODE *curOpcode = NULL;
	DWORD i;

	/* Initialize current parsing state */
	This->baseShader.parse_state.current_row = 0;

	/* First pass: figure out which temporary and texture registers are used */
	shader_get_registers_used(iface, pToken);
	TRACE("Texture/Address registers used: %#lx, Temp registers used %#lx\n",
	This->baseShader.textures_used, This->baseShader.temps_used);

	/* TODO: check register usage against GL/Directx limits, and fail if they're exceeded
	nUseAddressRegister < = GL_MAX_PROGRAM_ADDRESS_REGISTERS_AR
	nUseTempRegister <= GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
	*/

	/* Pre-declare registers */
	if (USING_GLSL)
	generate_glsl_declarations(iface, buffer);
	else
	generate_arb_declarations(iface, buffer);

	/* Second pass, process opcodes */
	if (NULL != pToken) {
	while (D3DPS_END() != *pToken) {

	/* Skip version token */
	if (shader_is_version_token(*pToken)) {
	++pToken;
	continue;
	}

	/* Skip comment tokens */
	if (shader_is_comment_token(*pToken)) {
	DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
	++pToken;
	TRACE("#%s\n", (char*)pToken);
	pToken += comment_len;
	continue;
	}

	/* Read opcode */
	curOpcode = shader_get_opcode(iface, *pToken);
	++pToken;

	/* Unknown opcode and its parameters */
	if (NULL == curOpcode) {
	while (pToken & 0x80000000) { / TODO: Think of a sensible name for 0x80000000 */
	FIXME("unrecognized opcode: %08lx\n", *pToken);
	++pToken;
	}

	/* Using GLSL & no generator function exists */
	} else if (USING_GLSL && curOpcode->hw_glsl_fct == NULL) {

	FIXME("Token %s is not yet implemented with GLSL\n", curOpcode->name);
	pToken += curOpcode->num_params;

	/* Unhandled opcode in ARB */
	} else if ( !USING_GLSL && GLNAME_REQUIRE_GLSL == curOpcode->glname) {

	FIXME("Token %s requires greater functionality than "
	"Vertex or Fragment_Program_ARB supports\n", curOpcode->name);
	pToken += curOpcode->num_params;

	/* If a generator function is set for current shader target, use it */
	} else if ((!USING_GLSL && curOpcode->hw_fct != NULL) \|\|
	(USING_GLSL && curOpcode->hw_glsl_fct != NULL)) {

	SHADER_OPCODE_ARG hw_arg;

	hw_arg.shader = iface;
	hw_arg.opcode = curOpcode;
	hw_arg.buffer = buffer;
	if (curOpcode->num_params > 0) {
	hw_arg.dst = *pToken;

	/* FIXME: this does not account for relative address tokens */
	for (i = 1; i < curOpcode->num_params; i++)
	hw_arg.src[i-1] = *(pToken + i);
	}

	/* Call appropriate function for output target */
	if (USING_GLSL)
	curOpcode->hw_glsl_fct(&hw_arg);
	else
	curOpcode->hw_fct(&hw_arg);

	pToken += curOpcode->num_params;

	} else {

	TRACE("Found opcode D3D:%s GL:%s, PARAMS:%d, \n",
	curOpcode->name, curOpcode->glname, curOpcode->num_params);

	/* Unless we encounter a no-op command, this opcode is unrecognized */
	if (curOpcode->opcode != D3DSIO_NOP) {
	FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
	pToken += curOpcode->num_params;
	}
	}
	}
	/* TODO: What about result.depth? */

	}
	}


	void shader_dump_ins_modifiers(const DWORD output) {

	DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
	DWORD mmask = output & D3DSP_DSTMOD_MASK;

	switch (shift) {
	case 0: break;
	case 13: TRACE("_d8"); break;
	case 14: TRACE("_d4"); break;
	case 15: TRACE("_d2"); break;
	case 1: TRACE("_x2"); break;
	case 2: TRACE("_x4"); break;
	case 3: TRACE("_x8"); break;
	default: TRACE("_unhandled_shift(%ld)", shift); break;
	}

	switch(mmask) {
	case D3DSPDM_NONE: break;
	case D3DSPDM_SATURATE: TRACE("_sat"); break;
	case D3DSPDM_PARTIALPRECISION: TRACE("_pp"); break;
	case D3DSPDM_MSAMPCENTROID: TRACE("_centroid"); break;
	default: TRACE("_unhandled_modifier(%#lx)", mmask); break;
	}
	}

	/* TODO: Move other shared code here */