PS1 texturing bubbling ?

const float4x4 matWorldViewProj;
const float4x4 matWorld; 
texture entSkin1; 

// Color map sampler
sampler ColorMapSampler = sampler_state 
{ 
   Texture = <entSkin1>; 

}; 
    
// Vertex Shader: 
void DiffuseVS( 
   in float4 InPos: POSITION, 
   in float3 InNormal: NORMAL, 
   in float2 InTex: TEXCOORD0, 
   out float4 OutPos: POSITION, 
   out float2 OutTex: TEXCOORD0, 
   out float3 OutNormal: TEXCOORD1) 
{ 
   OutPos = mul(InPos, matWorldViewProj); 
   OutPos /= OutPos.w;
   OutNormal = normalize(mul(InNormal, matWorld));
   OutTex = InTex; 
} 
    
// Pixel Shader: 
float4 DiffusePS( 
   in float2 InTex: TEXCOORD0, 
   in float3 InNormal: TEXCOORD1): COLOR 
{ 
   return tex2D(ColorMapSampler, InTex); 
} 
 
// Technique: 
technique AffineTechnique 
{ 
   pass P0 
   { 
      VertexShader = compile vs_2_0 DiffuseVS(); 
      PixelShader  = compile ps_2_0 DiffusePS(); 
   } 
} 

#define TRANSFORM_TEX(tex,name) (tex.xy * name##_ST.xy + name##_ST.zw)

float distance = length(mul(UNITY_MATRIX_MV,v.vertex));

//Affine Texture Mapping
float4 affinePos = vertex;//vertex;				
o.uv_MainTex = TRANSFORM_TEX(v.texcoord, _MainTex);
o.uv_MainTex *= distance + (vertex.w*(UNITY_LIGHTMODEL_AMBIENT.a * 8)) / distance / 2;
o.normal = distance + (vertex.w*(UNITY_LIGHTMODEL_AMBIENT.a * 8)) / distance / 2;

const float4x4 matWorldViewProj;
const float4x4 matWorld; 
texture entSkin1; 

// Color map sampler
sampler ColorMapSampler = sampler_state 
{ 
	Texture = <entSkin1>; 
}; 

// Vertex Shader: 
void DiffuseVS( 
in float4 InPos: POSITION, 
in float3 InNormal: NORMAL, 
in float2 InTex: TEXCOORD0, 
out float4 OutPos: POSITION, 
out float2 OutTex: TEXCOORD0, 
out float3 OutNormal: TEXCOORD1) 
{
	float distance = length(mul(InPos, matWorldViewProj));
	OutPos = mul(InPos, matWorldViewProj); 
	OutPos *= distance + (OutPos.w * (0.1)) / distance / 2;
	//OutNormal = distance + (OutPos.w * (0.1)) / distance / 2;
	OutNormal = normalize(mul(InNormal, matWorld));
	OutTex = InTex; 
} 

// Pixel Shader: 
float4 DiffusePS( 
in float2 InTex: TEXCOORD0, 
in float3 InNormal: TEXCOORD1): COLOR 
{ 
	return tex2D(ColorMapSampler, InTex); 
} 

// Technique: 
technique AffineTechnique 
{ 
	pass P0 
	{ 
		VertexShader = compile vs_2_0 DiffuseVS(); 
		PixelShader  = compile ps_2_0 DiffusePS(); 
	} 
}

#include <transform>
#include <fog>
#include <pos>
#include <normal>
#include <light>
#include <color>

#define DXLIGHTING
#define DXFOG

struct vertexOut
{
	float4 Pos : POSITION;
	float Fog : FOG;
	float4 Color : COLOR0;
	float2 Tex : TEXCOORD0;
	float2 LM : TEXCOORD1;
};

vertexOut solid_VS (
in float4 inPos : POSITION, 
in float3 inNormal : NORMAL,
in float2 inTex : TEXCOORD0,
in float2 inLM : TEXCOORD1
)
{
	vertexOut Out;
	Out.Pos = DoTransform(inPos);
	Out.Pos *= inPos.w / length(mul(inPos, matWorldViewProj));
	Out.Tex = inTex;
	Out.LM = inLM;
	Out.Fog = DoFog(inPos);
	float3 P = DoPos(inPos);
	float3 N = DoNormal(inNormal);

	float3 Color = 0; 
	for (int i = 0; i < 8; i++)  // add 8 dynamic lights
	{
		Color += DoLight(P, N, i);
	}

	Out.Color = 0.5 * DoAmbient() + 0.5 * float4(Color, 1) * vecDiffuse;

	return Out;		
}

technique solid
{
	pass one
	{		
		CullMode = None;
		ZWriteEnable = True;
		AlphaBlendEnable = False;
		AlphaTestEnable = False;
		
		VertexShader = compile vs_2_0 solid_VS();
	}
}

technique fallback { pass one { } }

Out.Pos *= inPos.w / length(mul(inPos, matWorldViewProj));

		#ifdef DXFOG
			float DoFog(float4 Pos)
			{
				float3 P = mul(Pos,matWorldView).xyz; // convert vector to view space to get it's depth (.z)
				return saturate((vecFog.y-P.z) * vecFog.z); // apply the linear fog formula
			}
			#else // distance based fog
			float DoFog(float4 Pos)
			{
				float3 P = mul(Pos,matWorld).xyz;
				return 1 - (distance(P,vecViewPos.xyz)-vecFog.x) * vecFog.z;
			}
		#endif

//Vertex snapping
float4 snapToPixel = mul(UNITY_MATRIX_MVP,v.vertex);
float4 vertex = snapToPixel;
vertex.xyz = snapToPixel.xyz / snapToPixel.w;
vertex.x = floor(160 * vertex.x) / 160;
vertex.y = floor(120 * vertex.y) / 120;
vertex.xyz *= snapToPixel.w;
o.pos = vertex;

#include <pos>
#include <normal>
#include <lights>

float4x4 matWorldViewProj;
float4 vecViewPos;

float4 vecLightDir[8];

float4 vecFog;
float4 vecFogColor;
float4 vecSkill1;

Texture entSkin1;
Texture entSkin2;

sampler ColorSampler = sampler_state
{
	Texture = <entSkin1>;
	Mipfilter = None;
	Minfilter = None;
	Magfilter = None;
};

sampler ShadowSampler = sampler_state
{
	Texture = <entSkin2>;
	Mipfilter = Linear;
	Minfilter = Linear;
	Magfilter = Linear;
};

struct vertexOut
{
	float4 Pos : POSITION;
	float4 Color : COLOR0;
	float3 Normal : NORMAL;
	float4 Tex : TEXCOORD0;
	float4 WorldPos : TEXCOORD1;
};

vertexOut VS (
in float4 inPos : POSITION,
in float3 inNormal : NORMAL,
in float2 inTex1 : TEXCOORD0,
in float2 inTex2 : TEXCOORD1
)
{
	inPos.w = 1.0f;	
	vertexOut Out;
	
	// vertex snapping
	float4 snapToPixel = mul(inPos, matWorldViewProj);
	float4 vertex = snapToPixel;
	vertex.xyz = snapToPixel.xyz / snapToPixel.w;
	vertex.x = floor((vecSkill1.y + 40) * vertex.x) / (vecSkill1.y + 40); // default 160
	vertex.y = floor(vecSkill1.y * vertex.y) / vecSkill1.y; // default 120
	vertex.xyz *= snapToPixel.w;
	Out.Pos = vertex;
	
	// affine texture mapping
	Out.Pos *= inPos.w / length(mul(inPos, matWorldViewProj));
	
	Out.Normal = normalize (mul(inNormal, (float3x3)matWorld));
	Out.Tex.xy = inTex1.xy;
	Out.Tex.zw = inTex2.xy;
	Out.WorldPos = mul(inPos, matWorld);
	Out.Color = 0;
	
	float3 P = DoPos(inPos);
	float3 N = DoNormal(inNormal);
	
	for(int i = 0; i < 8; i++)
	{
		if(vecLightDir[i].w > 0 && vecLightDir[i].w <= 1000) // spotlight ?
		{
			
		}
		else // pointlight ?
		{
			Out.Color += DoLight(P,N,i);
		}
	}
	
	// cut out polygons
	float distance = length(mul(inPos, matWorldViewProj));
	
	if(vecSkill1.z == 0){ vecSkill1.z = 512; }
	
	if (distance > vecSkill1.z)
	{
		Out.Pos.w = 0;
	}
	
	return Out;
}

float4 PS(vertexOut In) : COLOR0
{
	float4 textureColor = tex2D(ColorSampler, In.Tex.xy);
	float4 color = tex2D(ShadowSampler, In.Tex.zw);
	float fDepth = distance(vecViewPos.xyz, In.WorldPos.xyz);
	
	color += In.Color; // add dynamic lights
	
	color.rgb = saturate(color.rgb);
	color.rgb = pow(color.rgb, vecSkill1.x);
	color.rgb *= textureColor.rgb;
	
	float Fog = saturate((fDepth - vecFog.x) * vecFog.z);
	color.rgb = lerp(color.rgb, vecFogColor, Fog);
	
	color.a = 1;
	
	return color;
}

technique mtl_shaded
{
	pass one
	{
		ZWriteEnable = True;
		AlphaBlendEnable = False;
		AlphaTestEnable = False;
		
		VertexShader = compile vs_3_0 VS();
		PixelShader = compile ps_3_0 PS();
	}
}