fteqw/plugins/hl2/mat_vmt.c

#include "../plugin.h"
#include "shader.h"
static plugfsfuncs_t *fsfuncs;

typedef struct shaderparsestate_s parsestate_t;

typedef struct
{
	char **savefile;
	char *sourcefile;
	char type[MAX_QPATH];
	char normalmap[MAX_QPATH];
	struct
	{
		char name[MAX_QPATH];
	} tex[5];
	char envmap[MAX_QPATH];
	char envmapmask[MAX_QPATH];
	char envfrombase;
	char halflambert;

	float alphatestref;
	char *blendfunc;
	qboolean alphatest;
	qboolean culldisable;
	qboolean ignorez;
	char *replaceblock;
} vmtstate_t;


static void VARGS Q_strlcatfz (char *dest, size_t *offset, size_t size, const char *fmt, ...) LIKEPRINTF(4);
static void VARGS Q_strlcatfz (char *dest, size_t *offset, size_t size, const char *fmt, ...)
{
	va_list		argptr;

	dest += *offset;
	size -= *offset;

	va_start (argptr, fmt);
	Q_vsnprintfz(dest, size, fmt, argptr);
	va_end (argptr);
	*offset += strlen(dest);
}
static void Q_StrCat(char **ptr, const char *append)
{
	size_t oldlen = *ptr?strlen(*ptr):0;
	size_t newlen = strlen(append);
	char *newptr = plugfuncs->Malloc(oldlen+newlen+1);
	memcpy(newptr, *ptr, oldlen);
	memcpy(newptr+oldlen, append, newlen);
	newptr[oldlen+newlen] = 0;
	plugfuncs->Free(*ptr);
	*ptr = newptr;
}

//case comparisons are specific to ascii only, so this should be 'safe' for utf-8 strings too.
int Q_strncasecmp (const char *s1, const char *s2, int n)
{
	int		c1, c2;

	while (1)
	{
		c1 = *s1++;
		c2 = *s2++;

		if (!n--)
			return 0;		// strings are equal until end point

		if (c1 != c2)
		{
			if (c1 >= 'a' && c1 <= 'z')
				c1 -= ('a' - 'A');
			if (c2 >= 'a' && c2 <= 'z')
				c2 -= ('a' - 'A');
			if (c1 != c2)
			{	// strings not equal
				if (c1 > c2)
					return 1;		// strings not equal
				return -1;
			}
		}
		if (!c1)
			return 0;		// strings are equal
//		s1++;
//		s2++;
	}

	return -1;
}
int Q_strcasecmp (const char *s1, const char *s2)
{
	return Q_strncasecmp (s1, s2, 0x7fffffff);
}

static qboolean VMT_ReadVMT(const char *materialname, vmtstate_t *st);	//this is made more complicated on account of includes allowing recursion
static char *VMT_ParseBlock(const char *fname, vmtstate_t *st, char *line)
{	//assumes the open { was already parsed, but will parse the close.
	char *replace = NULL;
	com_tokentype_t ttype;
	char key[MAX_OSPATH];
	char value[MAX_OSPATH];
	char *qmark;
	qboolean cond;
	for(;line;)
	{
		line = cmdfuncs->ParseToken(line, key, sizeof(key), &ttype);
		if (ttype == TTP_RAWTOKEN && !strcmp(key, "}"))
			break;	//end-of-block
		line = cmdfuncs->ParseToken(line, value, sizeof(value), &ttype);
		if (ttype == TTP_RAWTOKEN && !strcmp(value, "{"))
		{	//sub block. we don't go into details here.
			if (!Q_strcasecmp(key, "replace"))
				replace = line;
			else
				Con_DPrintf("%s: Unknown block \"%s\"\n", fname, key);
			line = VMT_ParseBlock(fname, NULL, line);
			continue;
		}

		while ((qmark = strchr(key, '?')))
		{
			*qmark++ = 0;
			if (!Q_strcasecmp(key, "srgb"))
				cond = false;//!!(vid.flags & VID_SRGBAWARE);
			else
			{
				Con_DPrintf("%s: Unknown vmt conditional \"%s\"\n", fname, key);
				cond = false;
			}
			if (!cond)
			{
				*key = 0;
				break;
			}
			else
				memmove(key, qmark, strlen(qmark)+1);
		}

		if (!*key || !st)
			;
		else if (!Q_strcasecmp(key, "include"))
		{
			if (!VMT_ReadVMT(value, st))
				return NULL;
		}
		else if (!Q_strcasecmp(key, "$basetexture") || !Q_strcasecmp(key, "$hdrbasetexture"))	//fixme: hdr version should probably override the other. order matters.
			Q_strlcpy(st->tex[0].name, value, sizeof(st->tex[0].name));
		else if (!Q_strcasecmp(key, "$hdrcompressedtexture"))	//named texture is R8G8B8E8 and needs to be decompressed manually... should probably just use e5bgr9 but we don't have a way to transcode it here.
			;
		else if (!Q_strcasecmp(key, "$basetexturetransform"))
			;
		else if (!Q_strcasecmp(key, "$bumpmap")) // same as normalmap ~eukara
		{
			Q_strlcpy(st->normalmap, value, sizeof(st->normalmap));
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		}
		else if (!Q_strcasecmp(key, "$ssbump"))
			;
		else if (!Q_strcasecmp(key, "$ssbumpmathfix"))
			;
		else if (!Q_strcasecmp(key, "$basetexture2") || !strcmp(key, "$texture2"))
			Q_strlcpy(st->tex[1].name, value, sizeof(st->tex[1].name));
		else if (!Q_strcasecmp(key, "$basetexturetransform2"))
			;
		else if (!Q_strcasecmp(key, "$surfaceprop"))
			;

		else if (!Q_strcasecmp(key, "$ignorez"))
			st->ignorez = !!atoi(value);
		else if (!Q_strcasecmp(key, "$nocull") && (!strcmp(value, "1")||!strcmp(value, "0")))
			st->culldisable = atoi(value);
		else if (!Q_strcasecmp(key, "$alphatest") && (!strcmp(value, "1")||!strcmp(value, "0")))
			st->alphatest = atoi(value);
		else if (!Q_strcasecmp(key, "$alphatestreference"))
			st->alphatestref = atof(value);
		else if (!Q_strcasecmp(key, "$alphafunc"))
		{
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		}
		else if (!Q_strcasecmp(key, "$alpha"))
		{
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		}
		else if (!Q_strcasecmp(key, "$translucent"))
		{
			if (atoi(value))
				st->blendfunc = "src_alpha one_minus_src_alpha\n";
		}
		else if (!Q_strcasecmp(key, "$additive"))
		{
			if (atoi(value))
				st->blendfunc = "src_one one_minus_src_alpha\n";
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		}
		else if (!Q_strcasecmp(key, "$halflambert"))
			st->halflambert = 1;
		else if (!Q_strcasecmp(key, "$color"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$vertexcolor"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$vertexalpha"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$decal"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$decalscale"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$decalsize"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$envmap"))
			Q_strlcpy(st->envmap, value, sizeof(st->envmap));
		else if (!Q_strcasecmp(key, "$envmapmask"))
			Q_strlcpy(st->envmapmask, value, sizeof(st->envmapmask));
		else if (!Q_strcasecmp(key, "$envmapcontrast"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$envmaptint"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$envmapsaturation"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$basealphaenvmapmask"))
			st->envfrombase=1;
		else if (!Q_strcasecmp(key, "$normalmapalphaenvmapmask"))
			st->envfrombase=0;
		else if (!Q_strcasecmp(key, "$crackmaterial"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$selfillum"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$selfillummask"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$selfillumtint"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$nofog"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$nomip"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$nodecal"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$detail"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$detailscale"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$detailtint"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$detailblendfactor"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$detailblendmode"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);

		else if (!Q_strcasecmp(key, "$surfaceprop2"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$AllowAlphaToCoverage"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$blendmodulatetexture"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);

		//water/reflection stuff
		else if (!Q_strcasecmp(key, "$refracttinttexture"))
			Q_strlcpy(st->tex[0].name, value, sizeof(st->tex[0].name));
		else if (!Q_strcasecmp(key, "$refracttexture"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$refractamount"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$refracttint"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$reflecttexture"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$reflectamount"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$reflecttint"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$fresnelpower"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$minreflectivity"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$maxreflectivity"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$normalmap"))
		{
			Q_strlcpy(st->normalmap, value, sizeof(st->normalmap));
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		}
		else if (!Q_strcasecmp(key, "$bumpframe"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$fogenable"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$fogcolor"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$fogstart"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$fogend"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$abovewater"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$underwateroverlay"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$reflectentities"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$scale"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$bottommaterial"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$scroll1"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);
		else if (!Q_strcasecmp(key, "$scroll2"))
			Con_DPrintf("%s: %s \"%s\"\n", fname, key, value);

		else if (*key == '%')
			;	//editor lines
		else
			Con_DPrintf("%s: Unknown field \"%s\"\n", fname, key);
	}
	if (replace)
		VMT_ParseBlock(fname, st, replace);
	return line;
}
static void Shader_GenerateFromVMT(parsestate_t *ps, vmtstate_t *st, const char *shortname, void (*LoadMaterialString)(parsestate_t *ps, const char *script))
{
	size_t offset = 0;
	char script[8192];
	char *progargs = "";

	if (!*st->tex[0].name)	//fill in a default...
		Q_strlcpy(st->tex[0].name, shortname, sizeof(st->tex[0].name));

	if (st->alphatest)
		progargs = "#MASK=0.5#MASKLT";	//alphamask has to be handled by glsl (when glsl is used)

	Q_strlcatfz(script, &offset, sizeof(script), "\n");
	if (!Q_strcasecmp(st->type, "WorldVertexTransition"))
	{	//attempt to do terrain blending
		Q_strlcpy(st->type, "vmt/transition#TWOWAY", sizeof(st->type));
		Q_strlcatfz(script, &offset, sizeof(script),	"\tprogram \"%s%s\"\n", st->type, progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tuppermap \"%s%s.vtf\"\n", strcmp(st->tex[1].name, "materials/")?"materials/":"", st->tex[1].name);
	}
	else if (!Q_strcasecmp(st->type, "Decal"))
	{
		Q_strlcpy(st->type, "vmt/vertexlit", sizeof(st->type));
		Q_strlcatfz(script, &offset, sizeof(script),	"\tprogram \"%s%s\"\n", st->type, progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tpolygonOffset 1\n");
	}
	else if (!Q_strcasecmp(st->type, "DecalModulate"))
	{
		Q_strlcatfz(script, &offset, sizeof(script),
			"\t{\n"
				"\t\tprogram \"vmt/vertexlit%s\"\n"
				"\t\tblendFunc gl_dst_color gl_one_minus_src_alpha\n"
			"\t}\n", progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tpolygonOffset 1\n");
	}
	else if (!Q_strcasecmp(st->type, "Water"))
	{
		Q_strlcatfz(script, &offset, sizeof(script),
			"\t{\n"
				"\t\tprogram \"vmt/water%s\"\n"
				"\t\tmap $refraction\n"
				"\t\tmap $reflection\n"
			"\t}\n", progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tnormalmap \"%s%s.vtf\"\n", strcmp(st->normalmap, "materials/")?"materials/":"", st->normalmap);
	}
	else if (!Q_strcasecmp(st->type, "Refract"))
	{
		Q_strlcatfz(script, &offset, sizeof(script),
			"\t{\n"
				"\t\tprogram \"vmt/refract%s\"\n"
				"\t\tmap $refraction\n"
			"\t}\n", progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tnormalmap \"%s%s.vtf\"\n", strcmp(st->normalmap, "materials/")?"materials/":"", st->normalmap);
	}
	else if (!Q_strcasecmp(st->type, "VertexlitGeneric"))
	{
		if (*st->envmap && st->envfrombase)
		{
			if (st->halflambert)
				Q_strlcpy(st->type, "vmt/vertexlit#ENVFROMBASE#HALFLAMBERT", sizeof(st->type));
			else
				Q_strlcpy(st->type, "vmt/vertexlit#ENVFROMBASE", sizeof(st->type));
		}
		else
		{
			if (st->halflambert)
				Q_strlcpy(st->type, "vmt/vertexlit#HALFLAMBERT", sizeof(st->type));
			else
				Q_strlcpy(st->type, "vmt/vertexlit", sizeof(st->type));
		}

		Q_strlcatfz(script, &offset, sizeof(script),	"\tprogram \"%s%s\"\n", st->type, progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);

		if (*st->normalmap)
			Q_strlcatfz(script, &offset, sizeof(script),	"\tnormalmap \"%s%s.vtf\"\n", strcmp(st->normalmap, "materials/")?"materials/":"", st->normalmap);
	}
	else if (!Q_strcasecmp(st->type, "LightmappedGeneric"))
	{
		/* reflectmask from diffuse map alpha */
		if (*st->envmap && st->envfrombase)
			Q_strlcpy(st->type, "vmt/lightmapped#ENVFROMBASE", sizeof(st->type));
		else if (*st->envmap && *st->envmapmask) /* dedicated reflectmask */
			Q_strlcpy(st->type, "vmt/lightmapped#ENVFROMMASK", sizeof(st->type));
		else /* take from normalmap */
			Q_strlcpy(st->type, "vmt/lightmapped", sizeof(st->type));

		Q_strlcatfz(script, &offset, sizeof(script),	"\tprogram \"%s%s\"\n", st->type, progargs);
		Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);

		if (*st->normalmap)
			Q_strlcatfz(script, &offset, sizeof(script),	"\tnormalmap \"%s%s.vtf\"\n", strcmp(st->normalmap, "materials/")?"materials/":"", st->normalmap);
	}
	else
	{
		/* render-target camera/monitor - eukara*/
		if (!Q_strcasecmp(st->tex[0].name, "_rt_Camera"))
			Q_strlcatfz(script, &offset, sizeof(script),
			"\t{\n"
				"\t\tmap $rt:base\n"
			"\t}\n"/*, progargs*/);
		else
		{
			/* the default should just be unlit, let's not make any assumptions - eukara*/
			Q_strlcpy(st->type, "vmt/unlit", sizeof(st->type));
			Q_strlcatfz(script, &offset, sizeof(script),	"\tprogram \"%s%s\"\n", st->type, progargs);
			Q_strlcatfz(script, &offset, sizeof(script),	"\tdiffusemap \"%s%s.vtf\"\n", strcmp(st->tex[0].name, "materials/")?"materials/":"", st->tex[0].name);
		}
	}

	if (*st->envmapmask)
		Q_strlcatfz(script, &offset, sizeof(script),	"\treflectmask \"%s%s.vtf\"\n", strcmp(st->envmapmask, "materials/")?"materials/":"", st->envmapmask);
	if (*st->envmap && strcmp(st->envmap, "env_cubemap"))
		Q_strlcatfz(script, &offset, sizeof(script),	"\treflectcube \"%s%s.vtf\"\n", strcmp(st->envmap, "materials/")?"materials/":"", st->envmap);
	if (st->alphatest)
		Q_strlcatfz(script, &offset, sizeof(script), "\talphatest ge128\n");
	if (st->culldisable)
		Q_strlcatfz(script, &offset, sizeof(script), "\tcull disable\n");
	if (st->ignorez)
		Q_strlcatfz(script, &offset, sizeof(script), "\tnodepth\n");
	if (st->blendfunc)
		Q_strlcatfz(script, &offset, sizeof(script), "\tprogblendfunc %s\n", st->blendfunc);

	Q_strlcatfz(script, &offset, sizeof(script), "}\n");

	LoadMaterialString(ps, script);

	if (st->sourcefile)
	{	//cat the original file on there...
		if (st->savefile)
		{
			char *winsucks;	//strip any '\r' chars in there that like to show as ugly glyphs.
			for (winsucks = st->sourcefile; *winsucks; winsucks++)
				if (*winsucks=='\r')
					*winsucks = ' ';

			Q_StrCat(st->savefile, "\n/*\n");
			Q_StrCat(st->savefile, st->sourcefile);
			Q_StrCat(st->savefile, "*/");
		}
		plugfuncs->Free(st->sourcefile);
	}
}
static qboolean VMT_ReadVMT(const char *fname, vmtstate_t *st)
{
	char *line, *file = NULL;
	com_tokentype_t ttype;
	char token[MAX_QPATH];
	char *prefix="", *postfix="";

	//don't dupe the mandatory materials/ prefix
	if (strncmp(fname, "materials/", 10))
		prefix = "materials/";
	if (strcmp(fsfuncs->GetExtension(fname, NULL), ".vmt"))
		postfix = ".vmt";
	Q_snprintfz(token, sizeof(token), "%s%s%s", prefix, fname, postfix);

	file = fsfuncs->LoadFile(token, NULL);
	if (file)
	{
		if (st->savefile)
		{
			if (st->sourcefile)
			{
				Q_StrCat(&st->sourcefile, fname);
				Q_StrCat(&st->sourcefile, ":\n");
				Q_StrCat(&st->sourcefile, file);
			}
			else
				Q_StrCat(&st->sourcefile, file);
		}

		line = file;
		line = cmdfuncs->ParseToken(line, st->type, sizeof(st->type), &ttype);
		line = cmdfuncs->ParseToken(line, token, sizeof(token), &ttype);
		if (!strcmp(token, "{"))
		{
			line = VMT_ParseBlock(fname, st, line);
		}

		plugfuncs->Free(file);
		return !!line;
	}
	return false;
}
static qboolean Shader_LoadVMT(parsestate_t *ps, const char *filename, void (*LoadMaterialString)(parsestate_t *ps, const char *script))
{
	vmtstate_t st;
	memset(&st, 0, sizeof(st));
	st.savefile = NULL;//ps->saveshaderbody;
	if (!VMT_ReadVMT(filename, &st))
	{
		if (st.sourcefile)
			plugfuncs->Free(st.sourcefile);
		return false;
	}

	Shader_GenerateFromVMT(ps, &st, filename, LoadMaterialString);
	return true;
}

static struct sbuiltin_s vmtprograms[] =
{
//we don't know what renderer the engine will need...
#ifdef FTEPLUGIN
	#ifndef GLQUAKE
		#define GLQUAKE
	#endif
	#ifndef VKQUAKE
		#define VKQUAKE
	#endif
	#ifndef D3DQUAKE
		#define D3DQUAKE
	#endif
#endif
#include "mat_vmt_progs.h"
	{QR_NONE}
};
static plugmaterialloaderfuncs_t vmtfuncs =
{
	"HL2 VMT",
	Shader_LoadVMT,

	vmtprograms,
};

qboolean VMT_Init(void)
{
	fsfuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*fsfuncs));
	if (!fsfuncs)
		return false;
	return plugfuncs->ExportInterface(plugmaterialloaderfuncs_name, &vmtfuncs, sizeof(vmtfuncs));
}