use a second uv-set on your models

#include <acknex.h>
#include <default.c>



void ent_loadseconduvset(ENTITY* entity1, ENTITY* entity2);
void ent_exportmesh(ENTITY* entity, STRING* filename);
void ent_importmesh(ENTITY* entity, STRING* filename);



ENTITY* skycube =
{
	type = "skycube+6.tga";
	flags2 = SKY | CUBE | VISIBLE;
	material = mat_sky;
}



void applylightmaps();
ENTITY* tempentity;



//----------------------------------------------------------------------------- mtl_lightmap

BMAP* bmap_lightmap = "landscape_lm.dds";

MATERIAL* mtl_lightmap =
{
	skin1 = bmap_lightmap;
	
	effect=
	"
	texture mtlSkin1;
	texture entSkin1;

	technique t0
	{
		pass p0
		{
			Texture[0]=<mtlSkin1>;
			Texture[1]=<entSkin1>;
			
			// mix light map with dynamic lighting 
			TexCoordIndex[0] = 1;
			ColorArg1[0] = Texture;
			ColorOp[0] = AddSigned;
			ColorArg2[0] = Diffuse;
			
			// apply lighting to texture
			TexCoordIndex[1] = 0;
			ColorArg1[1] = Texture;
			ColorOp[1] = Modulate2x;
			ColorArg2[1] = Current;
		}
	}
	";
}



//----------------------------------------------------------------------------- main
void main()
{
	video_mode = 8;
	
	vec_set(mat_sky.emissive_blue, vector(20,20,20)); // make sky a bit brighter
	
	wait(3);
	level_load("");
	wait(1);
	
	vec_set(sky_color, vector(250, 175, 75));
	
	vec_set(sun_angle, vector(-30, 35, 0));
	sun_light = 10;
	
	vec_set(camera.x, vector(300, 0, 200));
	camera.pan = 180;	
	
	
	
	STRING* meshfilename = "landscape_lm.mesh";
	
	
	/*
	//-------------------- example 1
	
	you = ent_create("landscape.mdl", nullvector, 0); // load model with texture uv-set
	you.material = mtl_lightmap; // assign light map material
	
	tempentity = ent_create("landscape_lm.mdl", nullvector, 0); // load model with light map uv-set
	ent_loadseconduvset(you, tempentity); // generate and assign a new mesh with both uv-sets
	ent_remove(tempentity); // tempentity isn't needed anymore
	
	ent_exportmesh(you, meshfilename); // save mesh with both uv-sets for reuse
	*/
	
	
	//-------------------- example 2
	
	// for very huge models ent_importmesh() probably is faster than ent_loadseconduvset().
	// usually ent_loadseconduvset() should be fast enough though.
	
	if(you) {ent_remove(you);}
	
	you = ent_create("landscape.mdl", nullvector, 0); // load model with texture uv-set
	you.material = mtl_lightmap; // assign light map material
	ent_importmesh(you, meshfilename); // load and assign the previously saved mesh
	
	
	/*
	//-------------------- example 3
	
	// applylightmaps() cycles through all entities in the level and applies a light map
	// if the two "_lm" files exist for the entity.
	
	if(you) {ent_remove(you);}
	
	ent_create("landscape.mdl", nullvector, 0);
	applylightmaps();
	*/
	
	
	while(!key_any) {wait(1);}
	def_moveset(); // default camera movement
}



//----------------------------------------------------------------------------- example 3

var file_exists(STRING* filename)
{
	var filehandle;
	filehandle = file_open_read(filename);
	if(filehandle)
	{
		file_close(filehandle);
		return(1);
	}
	else
	{
		return(0);	
	}
}

STRING* tempstring1 = "#100";
STRING* tempstring2 = "#100";
MATERIAL* tempmaterial;

void applylightmaps()
{
	you = ent_next(0);
	while(you != 0)
	{
		str_for_entfile(tempstring1, you);
		str_trunc(tempstring1, 4);
		str_cpy(tempstring2, tempstring1);
		str_cat(tempstring1, "_lm.mdl");
		str_cat(tempstring2, "_lm.dds");
		
		if(file_exists(tempstring1) && file_exists(tempstring2))
		{		
			you.material = mtl_create(); // they should be removed again when changing the level
			tempmaterial = you.material;
			tempmaterial.effect = mtl_lightmap.effect;
			tempmaterial.skin1 = bmap_create(tempstring2); // they should be removed again when changing the level
			
			tempentity = ent_create(tempstring1, nullvector, 0);
			ent_loadseconduvset(you, tempentity);
			ent_remove(tempentity);
		}
		
		you = ent_next(you);
	}
}

material mtl_normalmapping
{
//	flags = tangent; // don't set the tangent flag here if you use a replaced mesh!
	effect = "normalmapping.fx";
}

[...]

you = ent_create("model.mdl", nullvector, 0); // load model with texture uv-set
you.material = mtl_normalmapping;
mtl_normalmapping.tangent = on; // set the tangent flag only for one frame
wait(1);
mtl_normalmapping.tangent = off;
	
// load the second uv-set after disabling the tangent flag
// the tangents still are in the mesh
	
tempentity = ent_create("model_lm.mdl", nullvector, 0); // load model with light map uv-set
ent_loadseconduvset(you, tempentity); // generate and assign a new mesh with both uv-sets
ent_remove(tempentity); // tempentity isn't needed anymore

/***********************************************************************************************
/	Copyright 2006	by Taco Cohen. All rights reserved							
/***********************************************************************************************/

/***********************************************************************************************
/	Global Variables:
/***********************************************************************************************/
// Tweakables:
static const float AmbientIntensity	= 1.1f;					// The intensity of the ambient light.
static const float DiffuseIntensity = 1.0f;					// The intensity of the diffuse light.
static const float SpecularIntensity = 2.0f;				// The intensity of the specular light.
static const float SpecularPower = 14.5f;					// The specular power. Used as 'glossyness' factor.
static const float4 SunColor = {0.9f, 0.9f, 0.9f, 1.0f};	// Color vector of the sunlight.

// Application fed data:
const float4x4 matWorldViewProj;	// World*view*projection matrix.
const float4x4 matWorld;			// World matrix.
const float4 vecAmbient;			// Ambient color.
const float4 vecSunDir;				// The sun direction vector.
const float4 vecViewPos;			// View position.

texture entSkin1; 							// Color map.
sampler ColorMapSampler = sampler_state		// Color map sampler.
{
	Texture = <entSkin1>;
	AddressU  = Wrap;
	AddressV  = Wrap;
};

texture entSkin2; 							// Normal map.
sampler NormalMapSampler = sampler_state	// Normal map sampler.
{
	Texture = <entSkin2>;
	AddressU  = Wrap;
	AddressV  = Wrap;
};

texture mtlSkin1; 							// ##### light map
sampler LightMapSampler = sampler_state	// ##### light map sampler.
{
	Texture = <mtlSkin1>;
	AddressU  = Wrap;
	AddressV  = Wrap;
};


/***********************************************************************************************
/	Vertex Shader:
/***********************************************************************************************/
void NormalMapVS(	in float4 InPos		: POSITION,
					in float3 InNormal	: NORMAL,
					in float2 InTex		: TEXCOORD0,
					in float2 InTex2		: TEXCOORD1, // ##### second uv-set
					in float3 InTangent	: TEXCOORD2,
					
					out float4 OutPos	: POSITION,
					out float2 OutTex	: TEXCOORD0,
					out float2 OutTex2 : TEXCOORD3, // ##### second uv-set
					out float3 OutViewDir: TEXCOORD1,
					out float3 OutSunDir: TEXCOORD2)
{
	// Transform the vertex from object space to clip space:
	OutPos = mul(InPos, matWorldViewProj);
	
	// Pass the texture coordinate to the pixel shader:
	OutTex = InTex;
	
	// ##### output second uv-set
	OutTex2 = InTex2;
	
	// Compute 3x3 matrix to transform from world space to tangent space:
	half3x3 worldToTangentSpace;
	worldToTangentSpace[0] = mul(InTangent, matWorld);
	worldToTangentSpace[1] = mul(cross(InTangent, InNormal), matWorld);
	worldToTangentSpace[2] = mul(InNormal, matWorld);
	
	// Calculate the view direction vector in tangent space:
	OutViewDir = normalize(mul(worldToTangentSpace, vecViewPos - mul(InPos, matWorld)));
	
	// Calculate the light direction vector in tangent space:
	OutSunDir = normalize(mul(worldToTangentSpace, -vecSunDir));
}


/***********************************************************************************************
/	Pixel Shader:
/***********************************************************************************************/
float4 NormalMapPS(	in float2 InTex	: TEXCOORD0,
					in float3 InViewDir	: TEXCOORD1,
					in float3 InSunDir	: TEXCOORD2,
					in float2 InTex2 : TEXCOORD3) : COLOR // ##### second uv-set
{
	// Read the normal from the normal map and convert from [0..1] to [-1..1] range
	float3 BumpNormal = 2 * tex2D(NormalMapSampler, InTex) - 1;
	
	// Calculate the ambient term:
	float4 Ambient = AmbientIntensity * vecAmbient;
	
	// Calculate the diffuse term:
	float4 Diffuse = DiffuseIntensity * saturate(dot(InSunDir, BumpNormal));
	Diffuse *= SunColor;
	
	// Calculate the reflection vector:
	float3 R = normalize(2 * dot(BumpNormal, InSunDir) * BumpNormal - InSunDir);
	
	// Calculate the specular term:
	InViewDir = normalize(InViewDir);
	float Specular = pow(saturate(dot(R, InViewDir)), SpecularPower) * SpecularIntensity;
	
	// Fetch the pixel color from the color map:
	float4 Color = tex2D(ColorMapSampler, InTex);
	
	// ##### fetch the light map color from the light map:
	float4 Light = tex2D(LightMapSampler, InTex2);
	
	// Calculate final color:
	return (Ambient + Diffuse + Specular) * Color * (Light * 2); // #####
}

/***********************************************************************************************
/	Technique:
/***********************************************************************************************/
technique SpecularTechnique
{
	pass P0
	{
		VertexShader = compile vs_2_0 NormalMapVS();
		PixelShader  = compile ps_2_0 NormalMapPS();
	}
}