Шейдеры

Romann · 26 Марта 2016

SkyLoader писал(а):
Вопрос по скиннингу. У нас есть несколько типов скиннинга.

А какое имеет отношение скиннинг к шейдерам?

Изменено 26 Марта 2016 пользователем Romann

Graff46 · 28 Марта 2016

На данный момент доступны ли шейдеры из OGSE с отражением при "намокании" поверхности?

Romann · 3 Апреля 2016

Graff46 писал(а):
доступны ли шейдеры из OGSE

Скачай ОГСЕ и возьми, только одни шейдеры не пойдут, нужно рендер брать, а может и весь движок. Загляни сюда.

Anonim · 21 Апреля 2016

@KD87, шейдер террейна же deffer_impl_bump и deffer_impl_flat? Просто игра как будто не реагируют на мои изменения, хочу сделать намокание с отражением неба через s_sky0, s_sky1. вроде как всё сделал но сталкеру вообще пофиг что я там наделал, пытался даже нарошно вызвать вылет.

KD87 · 26 Апреля 2016

SkyLoader писал(а):
Самое интересное, что вроде бы кол-во байтов у вершины должно быть больше с увеличением кол-ва данных (индексов костей и интерполяторов), но как во втором скиннинге, так и в третьем и четвертом размер один - 28 байтов.

Ну, коммент не имеет отношения к кол-ву байт. Приведенные структуры очевидно разного размера. А плотная компоновка структур влияет на скорость - есть определенный оптимальный размер кол-ва данных на вершину. Как раз в районе 28-32 байт, если мне память не изменяет.

Romann писал(а):
А какое имеет отношение скиннинг к шейдерам?

А как ты считаешь осуществляется скиннинг?

Graff46 писал(а):
шейдеры из OGSE с отражением

Доступны, только придется пользоваться и нашим движком.

Anonim писал(а):
шейдер террейна же deffer_impl_bump и deffer_impl_flat

Да. Изменения в этих шейдерах требуют перезапуска игры. К тому же, не факт, что s_sky0, s_sky1 доступны в этом шейдере. Скорее нет.

Ага, проверил - текстуры с вышеозначенными именами доступны только в шейдере скайбокса (sky2).

Изменено 26 Апреля 2016 пользователем KD87

Anonim · 27 Апреля 2016

@KD87, На момент написания сообщения перепутал их с текстурами s_env0, s_env1.

С ними та же история? Хотя в теории должны быть доступны.

KD87 · 27 Апреля 2016

Ты еще раз чего-то перепутал, таких текстур нет.

Anonim · 28 Апреля 2016

Как нет то? В шейдере воды используются

Uniform samplerCube s_env0, 1

KD87 · 28 Апреля 2016

Anonim писал(а):
Как нет то?

А приведи код соответствующего шейдера. У меня под рукой нет особо ресурсов никаких, так будет проще разобраться. Ты на каком движке пытаешься это сделать?

Anonim · 29 Апреля 2016

Скриптовый шейдер

local tex_env0                = "$user$sky0"    // текущий куб
local tex_env1                = "$user$sky1"        // следующий куб

  shader:sampler        ("s_env0")       :texture  (tex_env0)   : clamp()
  shader:sampler        ("s_env1")       :texture  (tex_env1)   : clamp()

Шейдер

uniform        samplerCUBE                s_env0;
uniform        samplerCUBE                s_env1;

        half3        env0               = texCUBE          (s_env0, vreflect);
        half3        env1               = texCUBE          (s_env1, vreflect);
        half3         env               = lerp                (env0,env1,L_ambient.w);

Знаю что ввёл в заблуждение , нужно было сразу про юзер скай говорить, но как то из головы вылетело, упёрся в название семплера.

Anonim · 29 Апреля 2016

KD87 писал(а):
Ты на каком движке пытаешься это сделать?

Дефолтный ТЧ с правками.

KD87 · 1 Мая 2016

Anonim писал(а):
Скриптовый шейдер

Хм. А как ты представляешь себе комбинацию скриптового шейдера и deffer_impl? Это движковый шейдер, а ты его перегружаешь. Надо очень тщательно писать шейдер и дать ему правильное имя. Как сделано у тебя?

varan · 1 Мая 2016

@KD87, можете подсказать по моей проблеме?

Вытащил себе локацию бар из ОГСЕ, только геометрию, без АИ-сетки. Скопировал себе ваши шейдеры. при загрузке вылетает

Если не копировать папку shaders, а только файл shaders.xr все работает, но картинка в баре вот такая

все очень сильно затемнено. Ставил на оригинал 1.004.

Сам ОГСЕ спокойно работает на максимальных настройках. В чем может быть причина? Без вашего движка не будет работать?

Изменено 1 Мая 2016 пользователем varan

Хемуль36рус · 2 Мая 2016

Вопрос такой, вот скрин с обычными шейдерами без лучей

в дали туманчик типа, все выглядит нормально.

Вот то же самое, та же погода и тот же час, но шейдеры с лучиками, в дали не прозрачная серость, может можно как-то настроить её прозрачность, как на первом скрине?

Изменено 2 Мая 2016 пользователем Хемуль36рус

Romann · 2 Мая 2016

varan писал(а):
Без вашего движка не будет работать?

Естественно, если тянешь шейдеры, то рендер нужен, а там и весь движок.

Anonim · 2 Мая 2016

@KD87,я привёл пример шейдера воды.

У меня пока никак не сделано, террейн просто не реагирует на изменения, я пока просто затемнил геометрию и увеличил глосс, осталось только небо заставить отражаться. Добавить эти семплеры не проблема, но ведь террейн вообще в танке насколько я понял. Ладно, сам попробую разобраться.

KD87 · 6 Мая 2016

Anonim писал(а):
У меня пока никак не сделан

Anonim писал(а):
террейн просто не реагирует на изменения

Ну так все-таки как-то же делал. Чтобы сказать, что не так, надо знать, как сделано.

varan писал(а):
Без вашего движка не будет работать?

Естественно. Половина шейдеров точно работать не будет.

varan писал(а):
при загрузке вылетает

Конечно, в ОГСЕ движок пропатчен на использование "чистого" SM 3.0, а не того огрызка, что по умолчанию в сталкере. Соответственно, многие инструкции в наших шейдерах работать не будут.

@Хемуль36рус, если лучи сделаны не постпроцессом, надо смотреть шейдер, где рисуются лоды, и там учитывать лучи, по-другому как-то блендить. А если постпроцессом, то сам шейдер лучей и смотри, опять же с блендингом что-то делать надо.

Expropriator · 6 Мая 2016

Есть сборка шейдеров 1603. В чём разница, визуально, от 1602? Еще такой вопрос: почему шейдеры не пакуются в db архив. Это единственное, что у меня не попадает в состав db.

DoK74rus · 14 Мая 2016

Всем привет, подскажите пожалуйста какую строку в файле bloom.ps отредактировать что бы блум не засвечивал изображение на 2-4 рендерах?

Такое получается сделать только если на dx10-11 рендере включить r2_ls_bloom_fast, а на остальных рендерах при этом жуткое мыло. Платформа ЗП

Изменено 14 Мая 2016 пользователем DoK74rus

Anonim · 16 Мая 2016

@KD87, Таки дела, перенёс детальный бамп и стип параллакс из ЧН, код:

sload.h

Показать

#ifndef SLOAD_H
#define SLOAD_H

#include "common.h"

//////////////////////////////////////////////////////////////////////////////////////////
// Bumped surface loader                //
//////////////////////////////////////////////////////////////////////////////////////////
struct        surface_bumped
{
        half4         	base;
        half3         	normal;
        half         	gloss;
        half         	height;
};

#ifdef         DBG_TMAPPING
half4   tbase                 (float2 tc)        {
        float2                 tile                 = max(ddx(tc),ddy(tc));
        return                 (1-max(tile.x,tile.y));        //*tex2D        (s_base,         tc);
}
#else
half4   tbase                 (float2 tc)        {
        return                 tex2D                (s_base,         tc);
}
#endif

#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)

static const float fParallaxStartFade = 8.0f;
static const float fParallaxStopFade = 12.0f;

void UpdateTC( inout p_bumped I)
{
	if (I.position.z < fParallaxStopFade)
	{
		const float maxSamples = 25;
		const float minSamples = 5;
		const float fParallaxOffset = -0.013;

//	Calculate number of steps
		float nNumSteps = lerp( maxSamples, minSamples, normalize(I.eye).z );

float	fStepSize			= 1.0 / nNumSteps;
		float2	vDelta				= normalize(I.eye).xy * fParallaxOffset*1.2;
		float2	vTexOffsetPerStep	= fStepSize * vDelta;

//	Prepare start data for cycle
		float2	vTexCurrentOffset	= I.tcdh;
		float	fCurrHeight			= 0.0;
		float	fCurrentBound		= 1.0;
/*
		for( int i=0; i<nNumSteps; ++i )
		{
			if (fCurrHeight < fCurrentBound)
			{	
				vTexCurrentOffset += vTexOffsetPerStep;		
				fCurrHeight = s_bumpX.SampleLevel( smp_base, vTexCurrentOffset.xy, 0 ).a; 
				fCurrentBound -= fStepSize;
			}
		}
*/

//[unroll(25)]	//	Doesn't work with [loop]
		for( ;fCurrHeight < fCurrentBound; fCurrentBound -= fStepSize )
		{
			vTexCurrentOffset += vTexOffsetPerStep;		
			fCurrHeight = tex2Dlod( s_bumpX, float4(vTexCurrentOffset.xy,0,0) ).a; 
		}

//	Reconstruct previouse step's data
		vTexCurrentOffset -= vTexOffsetPerStep;
		float fPrevHeight = tex2D( s_bumpX, float3(vTexCurrentOffset.xy,0) ).a;

//	Smooth tc position between current and previouse step
		float	fDelta2 = ((fCurrentBound + fStepSize) - fPrevHeight);
		float	fDelta1 = (fCurrentBound - fCurrHeight);
		float	fParallaxAmount = (fCurrentBound * fDelta2 - (fCurrentBound + fStepSize) * fDelta1 ) / ( fDelta2 - fDelta1 );
		float	fParallaxFade 	= smoothstep(fParallaxStopFade, fParallaxStartFade, I.position.z);
		float2	vParallaxOffset = vDelta * ((1- fParallaxAmount )*fParallaxFade);
		float2	vTexCoord = I.tcdh + vParallaxOffset;
	
		//	Output the result
		I.tcdh = vTexCoord;

#if defined(USE_TDETAIL) && defined(USE_STEEPPARALLAX)
		I.tcdbump = vTexCoord * dt_params;
#endif
	}

}

#elif	defined(USE_PARALLAX) || defined(USE_STEEPPARALLAX)

void UpdateTC( inout p_bumped I)
{
	half	height	= tex2D( s_bumpX, I.tcdh).w;	//
			//height  /= 2;
			//height  *= 0.8;
			height	= height*(parallax.x) + (parallax.y);	//
	float2	new_tc  = I.tcdh + height * normalize(I.eye);	//

//	Output the result
	I.tcdh.xy = new_tc;
}

#else	//	USE_PARALLAX

void UpdateTC( inout p_bumped I)
{
	;
}

#endif	//	USE_PARALLAX

/*#ifdef         USE_PARALLAX
surface_bumped                sload_i         ( p_bumped I)        // + texld, mad, nrm(3), mad  = 1+1+3+1 = 6, 15+6=21, OK
{
        surface_bumped      S;
        half        height	=       tex2D      (s_bumpX, I.tcdh).w;                                //
                    height  =       height*parallax.x + parallax.y;                        //
        float2		new_tc  =       I.tcdh + height*normalize        (I.eye);                //
        half4       Nu      =       tex2D		(s_bump,         new_tc);                // IN:  normal.gloss
        half4       NuE     =       tex2D      	(s_bumpX,       new_tc);                // IN:         normal_error.height
        S.base              =       tbase                (new_tc);                                // IN:  rgb.a
        S.normal            = 		Nu.wzyx + (NuE.xyz - 1.0h);							 // (Nu.wzyx - .5h) + (E-.5)
        S.gloss             =       Nu.x*Nu.x	;                                        //        S.gloss             =        Nu.x*Nu.x;
        S.height            =       NuE.z       ;

#ifdef        USE_TDETAIL
        half4       detail  =		tex2D(s_detail,I.tcdbump)        	;
        S.base.rgb          =		S.base.rgb     * detail.rgb*2		;
        S.gloss             =  		S.gloss * detail.w * 2				;
#endif

return                S;
}
#else*/
surface_bumped                sload_i         ( p_bumped I)
{
        surface_bumped        S;
		
		UpdateTC(I);	//	All kinds of parallax are applied here.
		
          half4 Nu 			=		tex2D                (s_bump, I.tcdh);                        // IN:  normal.gloss
        half4 NuE           =		tex2D                (s_bumpX,I.tcdh);                        // IN:         normal_error.height
        S.base              =		tbase                (I.tcdh)		;                         // IN:  rgb.a
        S.normal            =		Nu.wzyx + (NuE.xyz - 1.0h)			;
        S.gloss             =		Nu.x*Nu.x							;                         //        S.gloss             =        Nu.x*Nu.x;
        S.height            = 		NuE.z;

/*#ifdef        USE_TDETAIL
        half4 detail		=        tex2D(s_detail,I.tcdbump)    ;
        S.base.rgb          =      	S.base.rgb*detail.rgb        	*2      ;
        S.gloss             =  		S.gloss * detail.w * 2			;
#endif*/
#ifdef        USE_TDETAIL
#ifdef        USE_TDETAIL_BUMP
	half4 NDetail		= tex2D( s_detailBump, I.tcdbump);
	half4 NDetailX		= tex2D( s_detailBumpX, I.tcdbump);
	S.gloss				= S.gloss * NDetail.x * 2;
	//S.normal			+= NDetail.wzy-.5;
	S.normal			+= NDetail.wzy + NDetailX.xyz - 1.0h; //	(Nu.wzyx - .5h) + (E-.5)

half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;

//	S.base.rgb			= float3(1,0,0);
#else        //	USE_TDETAIL_BUMP
	half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;
	S.gloss				= S.gloss * detail.w * 2;
#endif        //	USE_TDETAIL_BUMP
#endif
        return              S;
}
/*#endif*/

surface_bumped              sload                 ( p_bumped I)
{
        surface_bumped      S   = sload_i	(I);
		S.normal.z			*=	0.5;		//. make bump twice as contrast (fake, remove me if possible)
		
#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)
//		S.base.yz = float2(0,0);
#endif

return              S;
}

#endif

#ifndef SLOAD_H
#define SLOAD_H

#include "common.h"

//////////////////////////////////////////////////////////////////////////////////////////
// Bumped surface loader                //
//////////////////////////////////////////////////////////////////////////////////////////
struct        surface_bumped
{
        half4         	base;
        half3         	normal;
        half         	gloss;
        half         	height;
};

#ifdef         DBG_TMAPPING
half4   tbase                 (float2 tc)        {
        float2                 tile                 = max(ddx(tc),ddy(tc));
        return                 (1-max(tile.x,tile.y));        //*tex2D        (s_base,         tc);
}
#else
half4   tbase                 (float2 tc)        {
        return                 tex2D                (s_base,         tc);
}
#endif

#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)

static const float fParallaxStartFade = 8.0f;
static const float fParallaxStopFade = 12.0f;

void UpdateTC( inout p_bumped I)
{
	if (I.position.z < fParallaxStopFade)
	{
		const float maxSamples = 25;
		const float minSamples = 5;
		const float fParallaxOffset = -0.013;

		//	Calculate number of steps
		float nNumSteps = lerp( maxSamples, minSamples, normalize(I.eye).z );

		float	fStepSize			= 1.0 / nNumSteps;
		float2	vDelta				= normalize(I.eye).xy * fParallaxOffset*1.2;
		float2	vTexOffsetPerStep	= fStepSize * vDelta;

		//	Prepare start data for cycle
		float2	vTexCurrentOffset	= I.tcdh;
		float	fCurrHeight			= 0.0;
		float	fCurrentBound		= 1.0;
/*
		for( int i=0; i<nNumSteps; ++i )
		{
			if (fCurrHeight < fCurrentBound)
			{	
				vTexCurrentOffset += vTexOffsetPerStep;		
				fCurrHeight = s_bumpX.SampleLevel( smp_base, vTexCurrentOffset.xy, 0 ).a; 
				fCurrentBound -= fStepSize;
			}
		}
*/

		//[unroll(25)]	//	Doesn't work with [loop]
		for( ;fCurrHeight < fCurrentBound; fCurrentBound -= fStepSize )
		{
			vTexCurrentOffset += vTexOffsetPerStep;		
			fCurrHeight = tex2Dlod( s_bumpX, float4(vTexCurrentOffset.xy,0,0) ).a; 
		}

		//	Reconstruct previouse step's data
		vTexCurrentOffset -= vTexOffsetPerStep;
		float fPrevHeight = tex2D( s_bumpX, float3(vTexCurrentOffset.xy,0) ).a;

		//	Smooth tc position between current and previouse step
		float	fDelta2 = ((fCurrentBound + fStepSize) - fPrevHeight);
		float	fDelta1 = (fCurrentBound - fCurrHeight);
		float	fParallaxAmount = (fCurrentBound * fDelta2 - (fCurrentBound + fStepSize) * fDelta1 ) / ( fDelta2 - fDelta1 );
		float	fParallaxFade 	= smoothstep(fParallaxStopFade, fParallaxStartFade, I.position.z);
		float2	vParallaxOffset = vDelta * ((1- fParallaxAmount )*fParallaxFade);
		float2	vTexCoord = I.tcdh + vParallaxOffset;
	
		//	Output the result
		I.tcdh = vTexCoord;

#if defined(USE_TDETAIL) && defined(USE_STEEPPARALLAX)
		I.tcdbump = vTexCoord * dt_params;
#endif
	}

}

#elif	defined(USE_PARALLAX) || defined(USE_STEEPPARALLAX)

void UpdateTC( inout p_bumped I)
{
	half	height	= tex2D( s_bumpX, I.tcdh).w;	//
			//height  /= 2;
			//height  *= 0.8;
			height	= height*(parallax.x) + (parallax.y);	//
	float2	new_tc  = I.tcdh + height * normalize(I.eye);	//

	//	Output the result
	I.tcdh.xy = new_tc;
}

#else	//	USE_PARALLAX

void UpdateTC( inout p_bumped I)
{
	;
}

#endif	//	USE_PARALLAX

/*#ifdef         USE_PARALLAX
surface_bumped                sload_i         ( p_bumped I)        // + texld, mad, nrm(3), mad  = 1+1+3+1 = 6, 15+6=21, OK
{
        surface_bumped      S;
        half        height	=       tex2D      (s_bumpX, I.tcdh).w;                                //
                    height  =       height*parallax.x + parallax.y;                        //
        float2		new_tc  =       I.tcdh + height*normalize        (I.eye);                //
        half4       Nu      =       tex2D		(s_bump,         new_tc);                // IN:  normal.gloss
        half4       NuE     =       tex2D      	(s_bumpX,       new_tc);                // IN:         normal_error.height
        S.base              =       tbase                (new_tc);                                // IN:  rgb.a
        S.normal            = 		Nu.wzyx + (NuE.xyz - 1.0h);							 // (Nu.wzyx - .5h) + (E-.5)
        S.gloss             =       Nu.x*Nu.x	;                                        //        S.gloss             =        Nu.x*Nu.x;
        S.height            =       NuE.z       ;

#ifdef        USE_TDETAIL
        half4       detail  =		tex2D(s_detail,I.tcdbump)        	;
        S.base.rgb          =		S.base.rgb     * detail.rgb*2		;
        S.gloss             =  		S.gloss * detail.w * 2				;
#endif

        return                S;
}
#else*/
surface_bumped                sload_i         ( p_bumped I)
{
        surface_bumped        S;
		
		UpdateTC(I);	//	All kinds of parallax are applied here.
		
          half4 Nu 			=		tex2D                (s_bump, I.tcdh);                        // IN:  normal.gloss
        half4 NuE           =		tex2D                (s_bumpX,I.tcdh);                        // IN:         normal_error.height
        S.base              =		tbase                (I.tcdh)		;                         // IN:  rgb.a
        S.normal            =		Nu.wzyx + (NuE.xyz - 1.0h)			;
        S.gloss             =		Nu.x*Nu.x							;                         //        S.gloss             =        Nu.x*Nu.x;
        S.height            = 		NuE.z;

/*#ifdef        USE_TDETAIL
        half4 detail		=        tex2D(s_detail,I.tcdbump)    ;
        S.base.rgb          =      	S.base.rgb*detail.rgb        	*2      ;
        S.gloss             =  		S.gloss * detail.w * 2			;
#endif*/
#ifdef        USE_TDETAIL
#ifdef        USE_TDETAIL_BUMP
	half4 NDetail		= tex2D( s_detailBump, I.tcdbump);
	half4 NDetailX		= tex2D( s_detailBumpX, I.tcdbump);
	S.gloss				= S.gloss * NDetail.x * 2;
	//S.normal			+= NDetail.wzy-.5;
	S.normal			+= NDetail.wzy + NDetailX.xyz - 1.0h; //	(Nu.wzyx - .5h) + (E-.5)

	half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;

//	S.base.rgb			= float3(1,0,0);
#else        //	USE_TDETAIL_BUMP
	half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;
	S.gloss				= S.gloss * detail.w * 2;
#endif        //	USE_TDETAIL_BUMP
#endif
        return              S;
}
/*#endif*/

surface_bumped              sload                 ( p_bumped I)
{
        surface_bumped      S   = sload_i	(I);
		S.normal.z			*=	0.5;		//. make bump twice as contrast (fake, remove me if possible)
		
#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)
//		S.base.yz = float2(0,0);
#endif		

        return              S;
}

#endif

deffer_base_bump.vs

Показать

#include	"common.h"

p_bumped	main	( v_static I )
{
	float4	w_pos	= I.P				;
	float2 	tc		= unpack_tc_base	(I.tc,I.T.w,I.B.w);	// copy tc
	float 	hemi 	= I.Nh.w			;

// Eye-space pos/normal
	p_bumped 	O;
	float3	Pe	= mul		(m_WV,  w_pos		);
	O.hpos 		= mul		(m_WVP,	w_pos		);
	O.tcdh 		= float4	(tc.xyyy			);
	O.position	= float4	(Pe, hemi			);

#if defined(USE_R2_STATIC_SUN) && !defined(USE_LM_HEMI)
	O.tcdh.w	= I.color.w;					// (r,g,b,dir-occlusion)
#endif

// Calculate the 3x3 transform from tangent space to eye-space
	// TangentToEyeSpace = object2eye * tangent2object
	//		     = object2eye * transpose(object2tangent) (since the inverse of a rotation is its transpose)
	float3 	N 	= unpack_bx4(I.Nh);	// just scale (assume normal in the -.5f, .5f)
	float3 	T 	= unpack_bx4(I.T);	// 
	float3 	B 	= unpack_bx4(I.;	// 
	float3x3 xform	= mul	((float3x3)m_WV, float3x3(
						T.x,B.x,N.x,
						T.y,B.y,N.y,
						T.z,B.z,N.z
				));
	// The pixel shader operates on the bump-map in [0..1] range
	// Remap this range in the matrix, anyway we are pixel-shader limited 
	// ...... [ 2  0  0  0]
	// ...... [ 0  2  0  0]
	// ...... [ 0  0  2  0]
	// ...... [-1 -1 -1  1]
	// issue: strange, but it's slower 
	// issue: interpolators? dp4? VS limited? black magic?

// Feed this transform to pixel shader
	O.M1 			= xform[0]; 
	O.M2 			= xform[1]; 
	O.M3 			= xform[2];

/*#ifdef 	USE_PARALLAX
	O.eye 			= mul		(float3x3(T,B,N),-(w_pos - eye_position));
#endif*/
#if defined(USE_PARALLAX) || defined(USE_STEEPPARALLAX)
	O.eye 			= mul		(float3x3(T,B,N),-(w_pos - eye_position));
#endif

#ifdef 	USE_TDETAIL
	O.tcdbump		= O.tcdh * dt_params;		// dt tc
#endif

#ifdef	USE_LM_HEMI
	O.lmh 			= unpack_tc_lmap	(I.lmh);
#endif
	return	O;
}

FXVS;

#include	"common.h"

p_bumped	main	( v_static I )
{
	float4	w_pos	= I.P				;
	float2 	tc		= unpack_tc_base	(I.tc,I.T.w,I.B.w);	// copy tc
	float 	hemi 	= I.Nh.w			;

	// Eye-space pos/normal
	p_bumped 	O;
	float3	Pe	= mul		(m_WV,  w_pos		);
	O.hpos 		= mul		(m_WVP,	w_pos		);
	O.tcdh 		= float4	(tc.xyyy			);
	O.position	= float4	(Pe, hemi			);

#if defined(USE_R2_STATIC_SUN) && !defined(USE_LM_HEMI)
	O.tcdh.w	= I.color.w;					// (r,g,b,dir-occlusion)
#endif

	// Calculate the 3x3 transform from tangent space to eye-space
	// TangentToEyeSpace = object2eye * tangent2object
	//		     = object2eye * transpose(object2tangent) (since the inverse of a rotation is its transpose)
	float3 	N 	= unpack_bx4(I.Nh);	// just scale (assume normal in the -.5f, .5f)
	float3 	T 	= unpack_bx4(I.T);	// 
	float3 	B 	= unpack_bx4(I.;	// 
	float3x3 xform	= mul	((float3x3)m_WV, float3x3(
						T.x,B.x,N.x,
						T.y,B.y,N.y,
						T.z,B.z,N.z
				));
	// The pixel shader operates on the bump-map in [0..1] range
	// Remap this range in the matrix, anyway we are pixel-shader limited 
	// ...... [ 2  0  0  0]
	// ...... [ 0  2  0  0]
	// ...... [ 0  0  2  0]
	// ...... [-1 -1 -1  1]
	// issue: strange, but it's slower 
	// issue: interpolators? dp4? VS limited? black magic? 

	// Feed this transform to pixel shader
	O.M1 			= xform[0]; 
	O.M2 			= xform[1]; 
	O.M3 			= xform[2]; 

/*#ifdef 	USE_PARALLAX
	O.eye 			= mul		(float3x3(T,B,N),-(w_pos - eye_position));
#endif*/
#if defined(USE_PARALLAX) || defined(USE_STEEPPARALLAX)
	O.eye 			= mul		(float3x3(T,B,N),-(w_pos - eye_position));
#endif

#ifdef 	USE_TDETAIL
	O.tcdbump		= O.tcdh * dt_params;		// dt tc
#endif

#ifdef	USE_LM_HEMI
	O.lmh 			= unpack_tc_lmap	(I.lmh);
#endif
	return	O;
}

FXVS;

Для детального бампа пропатчил второй рендер соответсвующей правкой из расширений.

Так вот, в игре всё работает. Я для дебага добавил в common.h дефайны. Но ведь это не по людски, как я считаю. Нужно как в ЧН добавлять новые шейдеры с хвостами "db" и "steep", но так как в патче движка я далеко не ушёл, немогу это сделать. Можешь как-нибудь помочь?

В огсе длл

	// HQ
	if (bump && hq)		{
		if (C.bFlags & bDetailBump)
			strcat			(ps,"_db");
		if (C.bFlags & bParallax)
			strcat			(ps,"_steep");
		strcat			(vs,"-hq");
		strcat			(ps,"-hq");
	}

Короче перенёс на 7 патч, сам код:

Показать

#ifndef SLOAD_H
#define SLOAD_H

#include "common.h"

//////////////////////////////////////////////////////////////////////////////////////////
// Bumped surface loader                //
//////////////////////////////////////////////////////////////////////////////////////////
struct        surface_bumped
{
        half4         	base;
        half3         	normal;
        half         	gloss;
        half         	height;
};

#ifdef         DBG_TMAPPING
half4   tbase                 (float2 tc)        {
        float2                 tile                 = max(ddx(tc),ddy(tc));
        return                 (1-max(tile.x,tile.y));        //*tex2D        (s_base,         tc);
}
#else
half4   tbase                 (float2 tc)        {
        return                 tex2D                (s_base,         tc);
}
#endif

#if !defined(ALLOW_STEEP_PARALLAX)
	#define	POM_MAX_SAMPLES int(1)
	#define	POM_MIN_SAMPLES int(1)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (1)
#elif ALLOW_STEEP_PARALLAX==1
	#define	POM_MAX_SAMPLES int(15)
	#define	POM_MIN_SAMPLES int(3)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (3)
#elif ALLOW_STEEP_PARALLAX==2
	#define	POM_MAX_SAMPLES int(30)
	#define	POM_MIN_SAMPLES int(5)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (5)
#elif ALLOW_STEEP_PARALLAX==3
	#define	POM_MAX_SAMPLES int(40)
	#define	POM_MIN_SAMPLES int(10)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (7)
#elif ALLOW_STEEP_PARALLAX==4
	#define	POM_MAX_SAMPLES int(60)
	#define	POM_MIN_SAMPLES int(20)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (10)
#endif

#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)

static const float fParallaxStartFade = 8.0f;
static const float fParallaxStopFade = 12.0f;

void UpdateTC( inout p_bumped I)
{
	if (I.position.z < fParallaxStopFade)
	{
//		const float maxSamples = 25;
//		const float minSamples = 5;
		const float fParallaxOffset = -0.013;

//	Calculate number of steps
		float nNumSteps = lerp( POM_MAX_SAMPLES, POM_MIN_SAMPLES, normalize(I.eye).z );

float	fStepSize			= 1.0 / nNumSteps;
		float2	vDelta				= normalize(I.eye).xy * fParallaxOffset*1.2;
		float2	vTexOffsetPerStep	= fStepSize * vDelta;

//	Prepare start data for cycle
		float2	vTexCurrentOffset	= I.tcdh;
		float	fCurrHeight			= 0.0;
		float	fCurrentBound		= 1.0;
/*
		for( int i=0; i<nNumSteps; ++i )
		{
			if (fCurrHeight < fCurrentBound)
			{	
				vTexCurrentOffset += vTexOffsetPerStep;		
				fCurrHeight = s_bumpX.SampleLevel( smp_base, vTexCurrentOffset.xy, 0 ).a; 
				fCurrentBound -= fStepSize;
			}
		}
*/

//[unroll(25)]	//	Doesn't work with [loop]
		for( ;fCurrHeight < fCurrentBound; fCurrentBound -= fStepSize )
		{
			vTexCurrentOffset += vTexOffsetPerStep;		
			fCurrHeight = tex2Dlod( s_bumpX, float4(vTexCurrentOffset.xy,0,0) ).a; 
		}

//	Reconstruct previouse step's data
		vTexCurrentOffset -= vTexOffsetPerStep;
		float fPrevHeight = tex2D( s_bumpX, float3(vTexCurrentOffset.xy,0) ).a;

//	Smooth tc position between current and previouse step
		float	fDelta2 = ((fCurrentBound + fStepSize) - fPrevHeight);
		float	fDelta1 = (fCurrentBound - fCurrHeight);
		float	fParallaxAmount = (fCurrentBound * fDelta2 - (fCurrentBound + fStepSize) * fDelta1 ) / ( fDelta2 - fDelta1 );
		float	fParallaxFade 	= smoothstep(fParallaxStopFade, fParallaxStartFade, I.position.z);
		float2	vParallaxOffset = vDelta * ((1- fParallaxAmount )*fParallaxFade);
		float2	vTexCoord = I.tcdh + vParallaxOffset;
	
		//	Output the result
		I.tcdh = vTexCoord;

#if defined(USE_TDETAIL) && defined(USE_STEEPPARALLAX)
		I.tcdbump = vTexCoord * dt_params;
#endif
	}

}

#elif	defined(USE_PARALLAX) || defined(USE_STEEPPARALLAX)

void UpdateTC( inout p_bumped I)
{
	half	height	= tex2D( s_bumpX, I.tcdh).w;	//
			//height  /= 2;
			//height  *= 0.8;
			height	= height*(parallax.x) + (parallax.y);	//
	float2	new_tc  = I.tcdh + height * normalize(I.eye);	//

//	Output the result
	I.tcdh.xy = new_tc;
}

#else	//	USE_PARALLAX

void UpdateTC( inout p_bumped I)
{
	;
}

#endif	//	USE_PARALLAX

/*#ifdef         USE_PARALLAX
surface_bumped                sload_i         ( p_bumped I)        // + texld, mad, nrm(3), mad  = 1+1+3+1 = 6, 15+6=21, OK
{
        surface_bumped      S;
        half        height	=       tex2D      (s_bumpX, I.tcdh).w;                                //
                    height  =       height*parallax.x + parallax.y;                        //
        float2		new_tc  =       I.tcdh + height*normalize        (I.eye);                //
        half4       Nu      =       tex2D		(s_bump,         new_tc);                // IN:  normal.gloss
        half4       NuE     =       tex2D      	(s_bumpX,       new_tc);                // IN:         normal_error.height
        S.base              =       tbase                (new_tc);                                // IN:  rgb.a
        S.normal            = 		Nu.wzyx + (NuE.xyz - 1.0h);							 // (Nu.wzyx - .5h) + (E-.5)
        S.gloss             =       Nu.x*Nu.x	;                                        //        S.gloss             =        Nu.x*Nu.x;
        S.height            =       NuE.z       ;

#ifdef        USE_TDETAIL
        half4       detail  =		tex2D(s_detail,I.tcdbump)        	;
        S.base.rgb          =		S.base.rgb     * detail.rgb*2		;
        S.gloss             =  		S.gloss * detail.w * 2				;
#endif

return                S;
}
#else*/
uniform sampler2D s_detailBump;
uniform sampler2D s_detailBumpX;

surface_bumped                sload_i         ( p_bumped I)
{
        surface_bumped        S;
		
		UpdateTC(I);	//	All kinds of parallax are applied here.
		
          half4 Nu 			=		tex2D                (s_bump, I.tcdh);                        // IN:  normal.gloss
        half4 NuE           =		tex2D                (s_bumpX,I.tcdh);                        // IN:         normal_error.height
        S.base              =		tbase                (I.tcdh)		;                         // IN:  rgb.a
        S.normal            =		Nu.wzyx + (NuE.xyz - 1.0h)			;
        S.gloss             =		Nu.x*Nu.x							;                         //        S.gloss             =        Nu.x*Nu.x;
        S.height            = 		NuE.z;

/*#ifdef        USE_TDETAIL
        half4 detail		=        tex2D(s_detail,I.tcdbump)    ;
        S.base.rgb          =      	S.base.rgb*detail.rgb        	*2      ;
        S.gloss             =  		S.gloss * detail.w * 2			;
#endif*/
#ifdef        USE_TDETAIL
#ifdef        USE_TDETAIL_BUMP
	half4 NDetail		= tex2D( s_detailBump, I.tcdbump);
	half4 NDetailX		= tex2D( s_detailBumpX, I.tcdbump);
	S.gloss				= S.gloss * NDetail.x * 2;
	//S.normal			+= NDetail.wzy-.5;
	S.normal			+= NDetail.wzy + NDetailX.xyz - 1.0h; //	(Nu.wzyx - .5h) + (E-.5)

half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;

//	S.base.rgb			= float3(1,0,0);
#else        //	USE_TDETAIL_BUMP
	half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;
	S.gloss				= S.gloss * detail.w * 2;
#endif        //	USE_TDETAIL_BUMP
#endif
        return              S;
}
/*#endif*/

surface_bumped              sload                 ( p_bumped I)
{
        surface_bumped      S   = sload_i	(I);
		S.normal.z			*=	0.5;		//. make bump twice as contrast (fake, remove me if possible)
		
#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)
//		S.base.yz = float2(0,0);
#endif

return              S;
}

#endif

#ifndef SLOAD_H
#define SLOAD_H

#include "common.h"

//////////////////////////////////////////////////////////////////////////////////////////
// Bumped surface loader                //
//////////////////////////////////////////////////////////////////////////////////////////
struct        surface_bumped
{
        half4         	base;
        half3         	normal;
        half         	gloss;
        half         	height;
};

#ifdef         DBG_TMAPPING
half4   tbase                 (float2 tc)        {
        float2                 tile                 = max(ddx(tc),ddy(tc));
        return                 (1-max(tile.x,tile.y));        //*tex2D        (s_base,         tc);
}
#else
half4   tbase                 (float2 tc)        {
        return                 tex2D                (s_base,         tc);
}
#endif

#if !defined(ALLOW_STEEP_PARALLAX)
	#define	POM_MAX_SAMPLES int(1)
	#define	POM_MIN_SAMPLES int(1)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (1)
#elif ALLOW_STEEP_PARALLAX==1
	#define	POM_MAX_SAMPLES int(15)
	#define	POM_MIN_SAMPLES int(3)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (3)
#elif ALLOW_STEEP_PARALLAX==2
	#define	POM_MAX_SAMPLES int(30)
	#define	POM_MIN_SAMPLES int(5)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (5)
#elif ALLOW_STEEP_PARALLAX==3
	#define	POM_MAX_SAMPLES int(40)
	#define	POM_MIN_SAMPLES int(10)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (7)
#elif ALLOW_STEEP_PARALLAX==4
	#define	POM_MAX_SAMPLES int(60)
	#define	POM_MIN_SAMPLES int(20)
//	#define	POM_FINAL_INTERSECTION_LOOPS int (10)
#endif

#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)

static const float fParallaxStartFade = 8.0f;
static const float fParallaxStopFade = 12.0f;

void UpdateTC( inout p_bumped I)
{
	if (I.position.z < fParallaxStopFade)
	{
//		const float maxSamples = 25;
//		const float minSamples = 5;
		const float fParallaxOffset = -0.013;

		//	Calculate number of steps
		float nNumSteps = lerp( POM_MAX_SAMPLES, POM_MIN_SAMPLES, normalize(I.eye).z );

		float	fStepSize			= 1.0 / nNumSteps;
		float2	vDelta				= normalize(I.eye).xy * fParallaxOffset*1.2;
		float2	vTexOffsetPerStep	= fStepSize * vDelta;

		//	Prepare start data for cycle
		float2	vTexCurrentOffset	= I.tcdh;
		float	fCurrHeight			= 0.0;
		float	fCurrentBound		= 1.0;
/*
		for( int i=0; i<nNumSteps; ++i )
		{
			if (fCurrHeight < fCurrentBound)
			{	
				vTexCurrentOffset += vTexOffsetPerStep;		
				fCurrHeight = s_bumpX.SampleLevel( smp_base, vTexCurrentOffset.xy, 0 ).a; 
				fCurrentBound -= fStepSize;
			}
		}
*/

		//[unroll(25)]	//	Doesn't work with [loop]
		for( ;fCurrHeight < fCurrentBound; fCurrentBound -= fStepSize )
		{
			vTexCurrentOffset += vTexOffsetPerStep;		
			fCurrHeight = tex2Dlod( s_bumpX, float4(vTexCurrentOffset.xy,0,0) ).a; 
		}

		//	Reconstruct previouse step's data
		vTexCurrentOffset -= vTexOffsetPerStep;
		float fPrevHeight = tex2D( s_bumpX, float3(vTexCurrentOffset.xy,0) ).a;

		//	Smooth tc position between current and previouse step
		float	fDelta2 = ((fCurrentBound + fStepSize) - fPrevHeight);
		float	fDelta1 = (fCurrentBound - fCurrHeight);
		float	fParallaxAmount = (fCurrentBound * fDelta2 - (fCurrentBound + fStepSize) * fDelta1 ) / ( fDelta2 - fDelta1 );
		float	fParallaxFade 	= smoothstep(fParallaxStopFade, fParallaxStartFade, I.position.z);
		float2	vParallaxOffset = vDelta * ((1- fParallaxAmount )*fParallaxFade);
		float2	vTexCoord = I.tcdh + vParallaxOffset;
	
		//	Output the result
		I.tcdh = vTexCoord;

#if defined(USE_TDETAIL) && defined(USE_STEEPPARALLAX)
		I.tcdbump = vTexCoord * dt_params;
#endif
	}

}

#elif	defined(USE_PARALLAX) || defined(USE_STEEPPARALLAX)

void UpdateTC( inout p_bumped I)
{
	half	height	= tex2D( s_bumpX, I.tcdh).w;	//
			//height  /= 2;
			//height  *= 0.8;
			height	= height*(parallax.x) + (parallax.y);	//
	float2	new_tc  = I.tcdh + height * normalize(I.eye);	//

	//	Output the result
	I.tcdh.xy = new_tc;
}

#else	//	USE_PARALLAX

void UpdateTC( inout p_bumped I)
{
	;
}

#endif	//	USE_PARALLAX

/*#ifdef         USE_PARALLAX
surface_bumped                sload_i         ( p_bumped I)        // + texld, mad, nrm(3), mad  = 1+1+3+1 = 6, 15+6=21, OK
{
        surface_bumped      S;
        half        height	=       tex2D      (s_bumpX, I.tcdh).w;                                //
                    height  =       height*parallax.x + parallax.y;                        //
        float2		new_tc  =       I.tcdh + height*normalize        (I.eye);                //
        half4       Nu      =       tex2D		(s_bump,         new_tc);                // IN:  normal.gloss
        half4       NuE     =       tex2D      	(s_bumpX,       new_tc);                // IN:         normal_error.height
        S.base              =       tbase                (new_tc);                                // IN:  rgb.a
        S.normal            = 		Nu.wzyx + (NuE.xyz - 1.0h);							 // (Nu.wzyx - .5h) + (E-.5)
        S.gloss             =       Nu.x*Nu.x	;                                        //        S.gloss             =        Nu.x*Nu.x;
        S.height            =       NuE.z       ;

#ifdef        USE_TDETAIL
        half4       detail  =		tex2D(s_detail,I.tcdbump)        	;
        S.base.rgb          =		S.base.rgb     * detail.rgb*2		;
        S.gloss             =  		S.gloss * detail.w * 2				;
#endif

        return                S;
}
#else*/
uniform sampler2D s_detailBump;
uniform sampler2D s_detailBumpX;

surface_bumped                sload_i         ( p_bumped I)
{
        surface_bumped        S;
		
		UpdateTC(I);	//	All kinds of parallax are applied here.
		
          half4 Nu 			=		tex2D                (s_bump, I.tcdh);                        // IN:  normal.gloss
        half4 NuE           =		tex2D                (s_bumpX,I.tcdh);                        // IN:         normal_error.height
        S.base              =		tbase                (I.tcdh)		;                         // IN:  rgb.a
        S.normal            =		Nu.wzyx + (NuE.xyz - 1.0h)			;
        S.gloss             =		Nu.x*Nu.x							;                         //        S.gloss             =        Nu.x*Nu.x;
        S.height            = 		NuE.z;

/*#ifdef        USE_TDETAIL
        half4 detail		=        tex2D(s_detail,I.tcdbump)    ;
        S.base.rgb          =      	S.base.rgb*detail.rgb        	*2      ;
        S.gloss             =  		S.gloss * detail.w * 2			;
#endif*/
#ifdef        USE_TDETAIL
#ifdef        USE_TDETAIL_BUMP
	half4 NDetail		= tex2D( s_detailBump, I.tcdbump);
	half4 NDetailX		= tex2D( s_detailBumpX, I.tcdbump);
	S.gloss				= S.gloss * NDetail.x * 2;
	//S.normal			+= NDetail.wzy-.5;
	S.normal			+= NDetail.wzy + NDetailX.xyz - 1.0h; //	(Nu.wzyx - .5h) + (E-.5)

	half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;

//	S.base.rgb			= float3(1,0,0);
#else        //	USE_TDETAIL_BUMP
	half4 detail		= tex2D( s_detail, I.tcdbump);
	S.base.rgb			= S.base.rgb * detail.rgb * 2;
	S.gloss				= S.gloss * detail.w * 2;
#endif        //	USE_TDETAIL_BUMP
#endif
        return              S;
}
/*#endif*/

surface_bumped              sload                 ( p_bumped I)
{
        surface_bumped      S   = sload_i	(I);
		S.normal.z			*=	0.5;		//. make bump twice as contrast (fake, remove me if possible)
		
#if defined(ALLOW_STEEPPARALLAX) && defined(USE_STEEPPARALLAX)
//		S.base.yz = float2(0,0);
#endif		

        return              S;
}

#endif

Войти

Шейдеры

Рекомендуемые сообщения

Romann 623

Ссылка на комментарий

Graff46 599

Ссылка на комментарий

Romann 623

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

KD87 720

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

KD87 720

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

KD87 720

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

KD87 720

Ссылка на комментарий

varan 124

Ссылка на комментарий

Хемуль36рус 1 790

Ссылка на комментарий

Romann 623

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

KD87 720

Ссылка на комментарий

Expropriator 2 119

Ссылка на комментарий

DoK74rus 19

Ссылка на комментарий

Anonim 680

Ссылка на комментарий

Создайте аккаунт или авторизуйтесь, чтобы оставить комментарий

Создать аккаунт

Войти

Недавно просматривали 0 пользователей

AMK Склад