Quest3D - Русскоязычное сообщество

float4 __light0_Light_point_1_color
<
	string UIName = "Light0 Color";
	string UIWidget = "Color";
> = float4(1.000000, 1.000000, 1.000000, 1.000000);
float __light0_Light_point_1_intensity
<
	string UIName = "Light0 Intensity";
	float UIMin = 0.000000;
	float UIMax = 10.000000;
	float UIStep = 0.01;
	string UIWidget = "slider";
> = 1.319800;
float __light0_Light_point_1_distance_falloff_exponent
<
	string UIName = "Light0 Distance Falloff Exponent";
	float UIMin = 0.000000;
	float UIMax = 4.000000;
	float UIStep = 0.01;
	string UIWidget = "slider";
> = 1.000000;
float __light0_Light_point_1_distance_falloff_start
<
	string UIName = "Light0 Distance Falloff Start";
	float UIMin = 0.000000;
	float UIMax = 10.000000;
	float UIStep = 0.01;
	string UIWidget = "slider";
> = 0.000000;
float __light0_Light_point_1_distance_falloff_limit
<
	string UIName = "Light0 Distance Falloff Limit";
	float UIMin = 0.000000;
	float UIMax = 1000.000000;
	float UIStep = 0.01;
	string UIWidget = "slider";
> = 1000.000000;
float __light0_Light_point_1_distance_scale
<
	string UIName = "Light0 Distance Scale";
	float UIMin = 0.001000;
	float UIMax = 100.000000;
	float UIStep = 0.01;
	string UIWidget = "slider";
> = 1.000000;
float3 __light0_position : Position 
<
	string Object = "PointLight0";
	string Space = "World";
	string UIName = "Light0 Light_position";
> = float3(0.000000, 0.000000, 0.000000);

float3 light_pos[8]	: LIGHTPOS; 
 
float4 light_color[8]	: LIGHTCOLOR;

float4 albedo;

if (IN.vertexColor.r>0.02f)
{
albedo=tex2D(семплер кирпичной текстуры, IN.texCoord);
}
else
{
albedo=tex2D(семплер камушки текстуры, IN.texCoord);
}

if (IN.vertexColor.b>0.02f)
{
albedo=tex2D(семплер травка текстуры, IN.texCoord);
}

// DIFFUSE LIGHT+ATTENUATION+TEXTURE
/////////////////////////////////////////////////////////////////////////
///// Объявление Переменных /////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Матрицы
float4x4 WorldVP : WorldViewProjection;		// Произведение мировой, видовой и проекционной матриц
float4x4 World   : World;					// Матрица мирового преобразования
float4x4 WorldIT : WorldInverseTranspose;	// Инвертированная - транспонированная мир матрица
 
// Макрос для замены в коде MAX_LIGHTS на 8
#define MAX_LIGHTS 8
 
// Источник света
float3 lightpos[MAX_LIGHTS] : LIGHTPOS;		// Подключение позиции источника света
float3 lightcol[MAX_LIGHTS] : LIGHTCOLOR;	// Подключение цвета источника
float light_atten[MAX_LIGHTS]: LIGHTATT1;	// Затухание источника

// Одиночный слайдер для значения типа Value
float valueName	:CHANNELVALUE0 <		// CHANNELVALUE0 - номер канала
    string UIName = "Slider Value";		// Имя в редакторе
    string UIWidget = "slider";			// Тип
    float UIMin = 0.0;				    // Минимальное значение
    float UIMax = 10.0;		            // Максимальное значение
	float UIStep = 0.01;		
> = 2.2;
 
float3 DiffuseColor : CHANNELVECTOR0 <
    string UIName =  "Diffuse Color";  	// Имя в редакторе
    string UIWidget = "Color";   		// Тип виждета
> = {1,1,1};							// Дефолтовое значение

//////////
//Подключил текстуры из Квеста
//2D текстуру
texture gColorTexture : COLORMAP0 <
    string ResourceName = "default_color.dds";
    string UIName =  "Diffuse Texture";
    string ResourceType = "2D";
>;

sampler2D Texture1 = sampler_state {
    Texture = <gColorTexture>;

    MinFilter = Linear;
    MipFilter = Linear;
    MagFilter = Linear;

    AddressU = Wrap;
    AddressV = Wrap;
};  
 
/////////////////////////////////////////////////////////////////////////
///// Структуры /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Входящие данные

struct a2v
{
    float4 position		: POSITION;	 // Позиция объекта
	float3 normal    	: NORMAL;	 // Нормаль к поверхности
	float2 texCoor      : TEXCOORD0; // Текстурные координаты

};
 
// Исходящие данные
struct v2f
{
    float4 HPosition   	: POSITION;		// Позиция объекта
	float3 wnormal    	: TEXCOORD2;	// Направление нормали в мировом пространстве
	float3 LightVector0	: TEXCOORD1;	// Вектор света
    float3 LightVector1	: TEXCOORD3;
	float2 texCoor      : TEXCOORD0;	// Текстурные координаты
};
 
/////////////////////////////////////////////////////////////////////////
///// Шейдеры ///////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
 
// Вершинный шейдер
v2f VS(a2v IN)
{
    v2f OUT = (v2f)0;	// Обнуление выходной структуры
	OUT.wnormal = mul(IN.normal,WorldIT);			// Получение нормали в мировой системе координат
	float3 worldSpacePos = mul(IN.position,World);	// Получаем позицию вершины в мировом пространстве
	OUT.LightVector0 = (lightpos[0]-worldSpacePos) * light_atten[0]*0.03; // Вносим радиус затухания в вектор света 
    OUT.LightVector1 = (lightpos[1]-worldSpacePos) * light_atten[1]*0.03;
	OUT.HPosition = mul(IN.position,WorldVP); 
    OUT.texCoor = IN.texCoor;  // Передаем в пиксельный шейдер
    return OUT;
}
 
// Пиксельный шейдер
float4 PS(v2f IN) : COLOR
{
	float3 N = normalize(IN.wnormal);
    float3 L = normalize(IN.LightVector0);
    float3 L1 = normalize(IN.LightVector1);
	float diffuse = dot(N,L);
	float diffuse1 = dot(N,L1);
	float atten = saturate(1.0 - dot(IN.LightVector0, IN.LightVector0)); // Затухание
    float4 tex = tex2D(Texture1, IN.texCoor.xy);
	float3 resultA = lightcol[0]*diffuse*DiffuseColor*atten*tex;
	float3 resultB = lightcol[1]*diffuse1*DiffuseColor*atten*tex;
	float3 result = resultA + resultB;
	return float4(result,1);
}
 
/////////////////////////////////////////////////////////////////////////
///// Техника ///////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
 
technique Main
 {
    pass p0
 {
        VertexShader = compile vs_2_0 VS();
        PixelShader = compile ps_2_0 PS();
ZWriteEnable = true;
 }
}

// Пиксельный шейдер
float4 PS(v2f IN) : COLOR
{
	float3 N = normalize(IN.wnormal);

//Считаем для первого ИС
	float3 L1 = normalize(IN.LightVector0);
	float diffuseL1 = dot(N,L1);
	float attenL1 = saturate(1.0 - dot(IN.LightVector0, IN.LightVector0)); // Затухание для первого ИС
	float3 lColorL1 = lightcol[0]*diffuseL1*attenL1;

//Считаем для второго ИС
	float3 L2 = normalize(IN.LightVector1);
	float diffuseL2 = dot(N,L2); 
	float attenL2 = saturate(1.0 - dot(IN.LightVector1, IN.LightVector1)); // Затухание для второго ИС
	float3 lColorL2 = lightcol[1]*diffuseL2*attenL2;


    float4 tex = tex2D(Texture1, IN.texCoor.xy);

	
	float3 result = (lColorL1+lColorL2)*DiffuseColor*tex;
	return float4(result,1);
}

	float atten = saturate(1.0 - dot(IN.LightVector0, IN.LightVector0)); // Затухание
    float4 tex = tex2D(Texture1, IN.texCoor.xy);
	float3 resultA = lightcol[0]*diffuse*DiffuseColor*atten*tex;
	float3 resultB = lightcol[1]*diffuse1*DiffuseColor*atten*tex;

  [branch] if (yes>1)  

unexpected token [ 

float3 refColor;
float glossiness = useGlossinesTexture==1?tex2D(glossinessSampler,In.texCoord.xy).r:iGlossiness;
float anisotropy = useAnisotropyTexture==1?tex2D(anisoSampler,In.texCoord.xy).r:iAnisotropy;
float anisoDir = useAnisoDirTexture==1?tex2D(anisoDirSampler,In.texCoord.xy).r:iAnisoDir;
float metallness = useMetallnessTexture==1?tex2D(metallnessSampler,In.texCoord.xy).r:iMetallness;

if (glossines == 0)
{
    float3 refVec = -reflect(eyeVec,Nn);
    refColor = texCUBE(envSampler,refVec);

}
else
{
    refColor = cubeBlur(envSampler,Nn,Bn,Tn,glossiness,Anisotropy,anisoDir,eyeDir);

}
if (metallness<1)
{
    refColor *= fresnel(eyeVec,Nn,frIOR);
}

float3 difColor=0;
if (difCalcType==useDifCubeTexture)
{
    difColor +=texCUBE(difCubeSampler,Nn);
}
if (difCalcType==useEnvCube_Linear)
{
    difColor += createDifLightLinear(envCubeSampler,Nn);
}
if (difCalcType==useEnvCube_Cubic)
{
    difColor += createDifLightCubic(envCubeSampler,Nn);
}

aldedo       += tex2D (gAlbedoMap, pIn.texC );
normal       += tex2D (gNORMALMap, pIn.texC );
position    += tex2D (gPOSITIONMap, pIn.texC );
self      += tex2D (gSELFILLUMMap, pIn.texC );

for( int i = 0;i < 100; i++ )
    {
aldedo       += aldedo;
normal       += normal;
position    += position;
self        +=self;
    }

aldedo       += tex2D (gAlbedoMap, pIn.texC )*100;
normal       += tex2D (gNORMALMap, pIn.texC )*100;
position    += tex2D (gPOSITIONMap, pIn.texC )*100;
self      += tex2D (gSELFILLUMMap, pIn.texC )*100;

	
half2 passessUV = half(6,3);
float3 refColor=0;
for (int x = 0; x < passessUV.x; ++x)
{
	float pX = x-p_.x;
	if (pX<=0) {rTn = -rTn;}
	for (int y = 0; y < passessUV.y; ++y)
	{
		float pY = y-p_.y;
		if (pY<=0) {rBTn = -rBTn;}
		float3 tNn = normalize(lerp(normals,rTn,(abs(pX)+noise_.x)*glossinessUV.x));
		float3 btNn = normalize(lerp(tNn,rBTn,(abs(pY)+noise_.y)*glossinessUV.y));
		refColor += texCUBE(iSamplerCube, -reflect(iEyeVec,btNn) ).r;
	}
}
refColor /=passesQ;

refColor += btNn//texCUBE(iSamplerCube, -reflect(iEyeVec,btNn) ).r;

	float pX = p_.x;//x-p_.x;
	if (pX<=0) {rTn = -rTn;}
	for (int y = 0; y < passessUV.y; ++y)
	{
		float pY = p_.y;//y-p_.y;

if (yes>1)
{
for( int i = 0;i < 100; i++ )
{
	aldedo 		+= tex2D (gAlbedoMap, (pIn.texC ));
 	normal	 	+= tex2D (gNORMALMap, (pIn.texC) );
	position 	+= tex2D (gPOSITIONMap, (pIn.texC) );
	self		+= tex2D (gSELFILLUMMap, (pIn.texC) );
	
	}

}

if (yes>1)
{
for( int i = 0;i < 100; i++ )
{
   aldedo       += tex2D (gAlbedoMap, (pIn.texC+i+0.3 ));
    normal       += tex2D (gNORMALMap, (pIn.texC+i+0.3) );
   position    += tex2D (gPOSITIONMap, (pIn.texC+i+0.3) );
   self      += tex2D (gSELFILLUMMap, (pIn.texC+i+0.3) );
   
   }

}  

// BLEND DIFFUSE ALPHA
/////////////////////////////////////////////////////////////////////////
///// Объявление Переменных /////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Объявление матриц
float4x4 WorldVP : WorldViewProjection;		// Произведение мировой, видовой и проекционной матриц
float4x4 World   : World;					// Матрица мирового преобразования
float4x4 WorldIT : WorldInverseTranspose;	// Инвертированная - транспонированная мир матрица

// Переменные (Value)
float LayerOpac : CHANNELVALUE0 <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    string UIName =  "Layer Opacity";
> = 1;

/////////////////////////////////////////////////////////////////////////
///// Текстуры //////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

texture texmap : TEXTURE0;
sampler Texture1 = sampler_state 
{
	Texture = <texmap>;
    MinFilter = Linear;
    MipFilter = Linear;
    MagFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
    AddressW = Wrap;
};

texture texmap2 : TEXTURE1;
sampler Texture2 = sampler_state 
{
	Texture = <texmap2>;
    MinFilter = Linear;
    MipFilter = Linear;
    MagFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
    AddressW = Wrap;
};
/////////////////////////////////////////////////////////////////////////
///// Структуры /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

//Входящие данные
struct appdata 
{
    float4 position		: POSITION;			// Позиция объекта
	float3 Normal    	: NORMAL;			// Нормаль к поверхности
	float2 texcoord0	: TEXCOORD0;		// Текстурные координаты
};

//Исходящие данные
struct vertexOutput 
{
    float4 HPosition   	: POSITION;			// Позиция объекта
	float3 wNormal    	: TEXCOORD0;		// Направление нормали в мировом пространстве
	float2 texcoord0	: TEXCOORD3;		// Текстурные координаты
};

/////////////////////////////////////////////////////////////////////////
///// Шейдеры ///////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
//Вершинный шейдер
vertexOutput VS(appdata IN) 
{
    vertexOutput OUT;
	OUT.wNormal = normalize(mul(IN.Normal,WorldIT));
	float4 worldSpacePos = mul(IN.position,World);
    OUT.HPosition = mul(IN.position,WorldVP);
	OUT.texcoord0 = IN.texcoord0;
    return OUT;
}

// Функция смешивания
float4 blend(float4 texture0, float4 texture1, float layerOpacity)
{
    const float blendRange = 0.1;
 
    if (texture1.a < layerOpacity - blendRange)     
    {
         return texture1;
    }
    else if (texture1.a > layerOpacity + blendRange)
    {
        return texture0;
    }
    else
    {
        float f = (texture1.a - layerOpacity + blendRange) / (2 * blendRange);
        return lerp(texture1, texture0, f);
    }
}

//Пиксельный шейдер
float4 PS(vertexOutput IN) : COLOR
{
	float4 tex1 = tex2D(Texture1,IN.texcoord0.xy);
	float4 tex2 = tex2D(Texture2,IN.texcoord0.xy);
	float4 result = blend(tex1,tex2,LayerOpac);
	return result;
}

/////////////////////////////////////////////////////////////////////////
///// Техника ///////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
technique Main 
 {
    pass p0 
 {
        VertexShader = compile vs_2_0 VS();
        PixelShader = compile ps_2_0 PS();
		ZWriteEnable = true;
 }
}