• Вход / Регистрация
    Логин:
    Пароль:
Страница 12 из 14«121011121314»
Модератор форума: Chalenger911 
Форум GtaMania.ru » Комп. игры / Железо / Интернет » Игры » Watch Dogs (Everything is connected. Connection is power)
Watch Dogs
offline
 Jaxer
Дата: Суббота, 2013-03-02, 16:55 | Сообщение # 1
Редактор
Сообщений: 1937




Разработчик: Ubisoft Montreal
Издатель: Ubisoft Entertainment
Жанр: Action (Shooter) / 3D / 3rd Person / Stealth
Официальный сайт: Watch Dogs
Дата выхода: 27 мая 2014 г.

Описание:

[spoiler="Сюжет"]
Сюжетная линия Watch Dogs построена на базе концепции информационной войны - данные стали взаимосвязаны, а в мире увеличивается использование технологий. Действие игры разворачивается в альтернативной версии реальности города Чикаго (штат Иллинойс), который является одним из многих городов использующих суперкомпьютер «ctOS». Система контролирует практически каждую часть города, а также содержит информацию обо всех его жителях и мероприятиях, которые могут быть использованы для различных целей. Во вселенной игры, авария в энергосистеме в США и Канаде была вызвана хакерами для побуждения развития ctOS. Главный персонаж игры — Эйден Пирс — высококвалифицированный хакер, очерченный как человек, использующий «как кулаки, так и интеллект». В демоверсии геймплея на выставке E3 было показано как Эйден использует способности отключения связи, телефонов и управления светофорами, тем самым облегчая задачу убить медиа-магната Джозефа Демарко, неправомерно оправданного по обвинению в убийстве.
[/spoiler]
[spoiler="Игровой процесс"]
Главные элементы геймплея Watch Dogs включают в себя взлом и наблюдение. Протагонист игры Эйден Пирс (озвученный Ноамом Дженкинсом) может использовать любое устройство, связанное с центральной операционной системой города (ctOS) как оружие против него. Во время показа демоверсии геймплея, Эйден, чтобы попасть на платную художественную выставку, в качестве отвлечения внимания вызывает помехи в сигналах мобильных телефонов, а также прослушивает телефонные разговоры для получения информации о своей цели, и воздействует на светофоры, вызывая автомобильную аварию для перехвата цели. Также игрок может получить доступ к информации из ctOS на неигровых персонажей, с которыми он сталкивается, включая информацию о демографии, здоровье, а также вероятности насилия.
[/spoiler]
[spoiler="Системные требования"]
Минимальные:
  • ОС: Windows Vista SP2 64bit, Windows 7 SP1 64bit, Windows 8 64bit;
  • Процессор: Intel Core 2 Quad Q8400 @ 2.66Ghz или AMD Phenom II X4 940 @ 3.0Ghz;
  • ОЗУ: 6 ГБ;
  • Видеокарта: Видеокарта с 1 ГБ видеопамяти, поддержкой DirectX 11 и Shader Model 5.0 (посмотрите список поддерживаемых видеокарт ниже);
  • Звук: Совместимая с DirectX 9 звуковая карта.
Рекомендуемые:
  • Процессор: Core i7 3770 @ 3.5Ghz или AMD FX-8350 @ 4.0Ghz;
  • ОЗУ: 8 GB;
  • Видеокарта: Видеокарта с 2 ГБ видеопамяти, поддержкой DirectX 11 и Shader Model 5.0 или лучше;
  • Звук: Звуковая карта с поддержкой Surround 5.1;
Поддерживаемые видеокарты:
  • nVidia GeForce GTX460 или лучше, GT500, GT600, GT700 серии;
  • AMD Radeon HD5850 или лучше, HD6000, HD7000, R7 и R9 серии; Intel® Iris™ Pro HD 5200
[/spoiler]


[spoiler="Скриншоты"]





[/spoiler]
[spoiler="Превью Stopgame"][/spoiler]
[spoiler="Трейлеры"]




[/spoiler]
[spoiler="Специальные издания"]Special Edition

Dedsec Edition

Uplay Exclusive Edition

Vigilante Edition
[/spoiler]

Купить Watch Dogs в Uplay





Сообщение отредактировал Jaxer - Воскресенье, 2014-06-01, 23:05
 
offline
 dax1
Дата: Среда, 2014-06-11, 22:59 | Сообщение # 166
Гангстер
Сообщений: 112
Orangebrains, а что за файл?


Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
offline
 Orangebrains
Дата: Среда, 2014-06-11, 23:00 | Сообщение # 167
Гангстер
Сообщений: 615
dax1, так он и написал, ага.
Ща комменты посмотрю, мб там чо есть. Но файл он нигде не упоминал.
не, в комментах только восхваление Энхансера 3.0.
 
offline
 dax1
Дата: Среда, 2014-06-11, 23:10 | Сообщение # 168
Гангстер
Сообщений: 112
болтология это всё, я уже давно недра расковырял, и даже патчик сделал для тех кто с ультра текстурами шпилит, в самим конфигах и близко ни чего подобного не видел, ну моб где то в шейдерах это но сомневаюсь, щас проверю.

Добавлено (2014-06-11, 23:07)
---------------------------------------------
Цитата Orangebrains ()
в комментах только восхваление Энхансера 3.0.

кстати не слышно там когда он его родит уже, а то прям в муках рождается то 2.5 то 3.0 то глядишь и до 3.5 дойдёт дело но попробовать так и не даст :D

Добавлено (2014-06-11, 23:10)
---------------------------------------------
есть там один такой файл, но его имени к сожалению нету, значит и замодить его не возможно пока что, вот его содежимое
[spoiler="Скрытый текст"]
Код
#define AMBIENT

#include "../Profile.inc.fx"
#include "../Debug2.inc.fx"
#include "../CustomSemantics.inc.fx"
#include "../DepthShadow.inc.fx"
#include "../ParaboloidReflection.inc.fx"
#include "../Ambient.inc.fx"
#include "../Fog.inc.fx"
#include "../Shadow.inc.fx"

// ----------------------------------------------------------------------------

#define WATER_LEVEL WaterParams.x
#define TIME WaterParams.w

#define E3_TUNING 0
#define E3_TUNING_SUBSURFACE 0

#define GUARD_BAND 50.f
#define MAP_SIZE_GUARD_BAND float2(4096.f/2.f-GUARD_BAND,5120.f/2.f-GUARD_BAND)

// ----------------------------------------------------------------------------
// Vector map
// ----------------------------------------------------------------------------

#ifdef VECTORMAP

#include "WaterBackground.inc.fx"
#include "../parameters/SplinesAndDecals.fx"

struct SMeshVertex
{
float4 position : POSITION;
};

struct SVertexToPixel
{
float4 Position  : POSITION0;
float2 UV;
};

struct VectorMapOutput
{
float4 m_wave : SV_Target0;
float4 m_color : SV_Target1;
};

SVertexToPixel MainVS( in SMeshVertex input)
{
SVertexToPixel Output = (SVertexToPixel)0;
Output.Position = float4( input.position.xy * 2 - 1, 1.0f, 1.0f );
Output.UV = input.position.xy;
Output.UV.y = 1-Output.UV.y;
return Output;
}

VectorMapOutput MainPS( in SVertexToPixel input )
{
VectorMapOutput output = (VectorMapOutput)0;

float2 uv = input.UV.xy;
float4 worldPos = mul(float4(uv,0.f,1.f),GridMatrix);

float4 parameters = tex2D(ParametersMapTexture,uv);

float waveIntensity = parameters.y;

worldPos = float4(worldPos.xy / worldPos.w + WaterParams.yz,WATER_LEVEL,1.f);
output.m_wave.xyz = GetOceanWaveAtPosition(worldPos.xyz,0,0.f, waveIntensity);
output.m_wave.z += parameters.x;
output.m_wave.w = parameters.w;

output.m_color = float4(0,0,0,1);

return output;
}

technique t0
{
pass p0
{
SrcBlend = One;
DestBlend = Zero;

AlphaTestEnable = false;
ZEnable = false;
ZWriteEnable = false;
CullMode = None;
WireFrame = false;
}
}

#endif

// ----------------------------------------------------------------------------
// Normal map
// ----------------------------------------------------------------------------

#ifdef NORMALMAP

#include "../parameters/WaterNormalMapRendering.fx"

struct SMeshVertex
{
float4 position : POSITION;
};

struct SVertexToPixel
{
float4 Position  : POSITION0;
float2 UV;
};

SVertexToPixel MainVS( in SMeshVertex input)
{
SVertexToPixel Output = (SVertexToPixel)0;
Output.Position = float4( input.position.xy * 2 - 1, 1.0f, 1.0f );
Output.UV = input.position.xy;
Output.UV.y = 1-Output.UV.y;
return Output;
}

struct NormalMapOutput
{
float4 m_normal : SV_Target0;
};

float3 GetWaterPosition(float2 _UV)
{
float4 worldPos = mul(float4(_UV.x,_UV.y,0.f,1.f),GridMatrix);
worldPos.xyz = worldPos.xyz / worldPos.w;
float2 uv = _UV;
float4 tex = tex2D(WaveTexturePoint,float2(uv.x,uv.y));
return float3(worldPos.xyz + tex.xyz);
}

NormalMapOutput MainPS( in SVertexToPixel input )
{
NormalMapOutput output = (NormalMapOutput)0;

float2 uv = input.UV.xy;
float3 pos = GetWaterPosition( uv );
float scale = 2.f;

float3 APos = GetWaterPosition( uv + scale * float2(-WaterParams.x,0.f) );
float3 BPos = GetWaterPosition( uv + scale * float2(0.f,-WaterParams.y) );
float3 CPos = GetWaterPosition( uv + scale * float2(+WaterParams.x,0.f) );
float3 DPos = GetWaterPosition( uv + scale * float2(0.f,+WaterParams.y) );

float3 AP = APos - pos.xyz;
float3 BP = BPos - pos.xyz;
float3 CP = CPos - pos.xyz;
float3 DP = DPos - pos.xyz;

float3 normal = cross(AP,BP) + cross(BP,CP) + cross(CP,DP) + cross(DP,AP);
output.m_normal.xyz = normalize(normal) * 0.5f + 0.5f;

return output;
}

technique t0
{
pass p0
{
SrcBlend = One;
DestBlend = Zero;

AlphaTestEnable = false;
ZEnable = false;
ZWriteEnable = false;
CullMode = None;
WireFrame = false;
}
}

#endif

// ----------------------------------------------------------------------------
// Splines
// ----------------------------------------------------------------------------

#ifdef SPLINE

#include "../parameters/WaterSplineRendering.fx"
#include "../parameters/WaterSplineSettings.fx"
#include "../parameters/RoadHeight.fx"

#ifdef ARCHIMEDES_HEIGHTMAP
#include "..\FloatingBodyState.inc.fx"
StructuredBuffer<SBodyState> BodyStateRead;
#define QUATERNION
#endif

#define flowSpeed FlowParams.x
#define flowTextureSize FlowParams.y
#define flowDisplacementScale FlowParams.z
#define tangentFlowSpeed FlowParams1.w

#define WATER_TIME WaterParams.w

struct SMeshVertex
{
float2 UV : CS_DiffuseUV;
float4 P0 : CS_InstancePosition0;
float4 P1 : CS_InstancePosition1;
float4 P2 : CS_InstancePosition2;
float4 P3 : CS_InstancePosition3;
};

struct SVertexToPixel
{
float4 Position   : POSITION0;
float3 Morph   : POSITION1;
float2 WorldPosition    : POSITION2;
float3 UV;

};

void GetBezierPosition( in float3 P0 , in float3 P1 , in float3 P2 , in float3 P3 ,in float t , out float3 position , out float3 derivate)
{
float a1 = 1-t;
float a2 = a1*a1;
float a3 = a2*a1;
float t2 = t*t;
float t3 = t2*t;

position = P0 * a3 + 3*P1*t*a2 + 3*P2*t2*a1 + P3*t3;

derivate = 3 *( (P1 - P0) * a2 +
(P2 - P1) * 2*t*a1 +
(P3 - P2) * t2 );
}

SVertexToPixel MainVS( in SMeshVertex input)
{
SVertexToPixel output = (SVertexToPixel)0;

float3 position,derivate;

GetBezierPosition( input.P0.xyz , input.P1.xyz , input.P2.xyz , input.P3.xyz , input.UV.y , position , derivate );

float width = lerp( input.P0.w , input.P1.w , input.UV.y );

position += normalize( cross(derivate,float3(0,0,1)) ) * input.UV.x * width;

float l = lerp( input.P2.w , input.P3.w , input.UV.y);

output.UV = float3( l , input.UV.x * width, (1-abs(input.UV.x)) * width);

output.Morph.z = position.z - WATER_LEVEL;

output.WorldPosition = position.xy;

#if (defined(USE_WATER_GRID_PROJECTION) || defined(ARCHIMEDES_HEIGHTMAP))

position.z = 0; // To render in the water vector map Z must be setted to ZERO

#ifdef ARCHIMEDES_HEIGHTMAP
output.Position = mul( float4(position.xyz,1) , BodyStateRead[0].HullWorldViewProj );
#else
output.Position = mul( float4(position.xyz,1) ,GridMatrix);
#endif

#else
#ifdef WATERMASK

float2 WorldOffset = Offsets.xy;
float2 TargetOffset = Offsets.zw;

float2 posXY = (position.xy + WorldOffset) - TargetOffset;

// scale to 0...1
posXY *= TargetSize.xy;

output.Morph.z += WATER_LEVEL;

// add offset to fix with vertices (which are at pixel corners and NOT at pixel centers)
// this was needed from trial and error
posXY.x += TargetSize.x * 1.0;
posXY.y -= TargetSize.y * 0.5;

output.Position.xy = (posXY * 2) - 1; // Convert to projected space
output.Position.z = (1.0f - (position.z / 256.0f));
output.Position.w = 1;

#else
output.Position = mul( float4(position.xyz - CameraPosition.xyz ,1) ,ViewRotProjectionMatrix);
#endif
#endif

return output;
}

float3 GetWaterHeight(in SVertexToPixel input)
{
float3 result = input.Morph;

float scale = flowTextureSize;

float2 speed = float2(flowSpeed, tangentFlowSpeed);

float2 uv = (input.UV.xy - WATER_TIME*speed) / scale;

uv = input.WorldPosition.xy / scale - WATER_TIME*speed/scale;

float4 tex = tex2D(FlowTexture,uv);

result += (tex.xyz-0.5) * float3(-0.1,0.1,flowDisplacementScale) * scale;

return result;
}

#define SPLINE_SMOOTH_LENGTH (FlowParams1.x)

float ComputeSplineBlendFactor(in SVertexToPixel input)
{
float blend = saturate(input.UV.z / SPLINE_SMOOTH_LENGTH);

blend *= saturate(input.UV.x/SPLINE_SMOOTH_LENGTH);
blend *= saturate((SpineLength-input.UV.x)/SPLINE_SMOOTH_LENGTH);

blend = 1-saturate(3*blend);
blend = 1- blend*blend ;

return blend;

}

#ifdef ARCHIMEDES_HEIGHTMAP

float4 MainPS( in SVertexToPixel input ) : SV_Target0
{
float4 result = 1;

float blend = ComputeSplineBlendFactor(input);

result.x = GetWaterHeight(input).z;
result.y = FlowParams.w;
return result;
}

technique t0
{
pass p0
{
SrcBlend = SrcAlpha;
DestBlend = InvSrcAlpha;
AlphaBlendEnable = True;
AlphaTestEnable = false;
ZEnable = false;
ZWriteEnable = false;
CullMode = None;
WireFrame = false;
}
}

#endif

#ifdef USE_WATER_GRID_PROJECTION

struct VectorMapOutput
{
float4 m_params : SV_Target0;
float4 m_color : SV_Target1;
};

VectorMapOutput MainPS( in SVertexToPixel input )
{
VectorMapOutput output = (VectorMapOutput)0;

float height = GetWaterHeight(input).z;

// x = m_flowSpeed
// y = m_flowTextureSize
// z = m_flowDisplacementScale
// w = m_waveIntensity

float blend = ComputeSplineBlendFactor(input);

output.m_params = float4(height,FlowParams.w,FlowParams1.z,blend);
output.m_color = float4(WaterColor.rgb,blend);

return output;
}

technique t0
{
pass p0
{
SrcBlend = SrcAlpha;
DestBlend = InvSrcAlpha;
AlphaBlendEnable = True;
AlphaTestEnable = false;
ZEnable = true;  /// false
ZWriteEnable = true; // false
CullMode = None;
WireFrame = false;
}
}

#endif

#ifdef WATERMASK

struct SPixelOutput
{
float4 height : SV_Target0;
float4 influence : SV_Target1;
float4 waterMask : SV_Target2;
};

SPixelOutput MainPS( in SVertexToPixel input )
{
SPixelOutput output = (SPixelOutput)0;

output.waterMask = input.Morph.z;

return output;
}

technique t0
{
pass p0
{
SrcBlend = One;
DestBlend = Zero;
AlphaBlendEnable = false;
AlphaTestEnable = false;
ZEnable = false;
ZWriteEnable = false;
CullMode = None;
WireFrame = false;
}
}

#endif

#if !( defined(ARCHIMEDES_HEIGHTMAP) || defined(USE_WATER_GRID_PROJECTION) || defined(WATERMASK) )

float4 MainPS( in SVertexToPixel input ) : SV_Target0
{
return float4(1,0,0,1);
}

technique t0
{
pass p0
{
SrcBlend = One;
DestBlend = Zero;
AlphaBlendEnable = false;
AlphaTestEnable = false;
ZEnable = true;
ZWriteEnable = true;
CullMode = None;
WireFrame = false;
}
}

#endif

#endif

// ----------------------------------------------------------------------------
// Draw
// ----------------------------------------------------------------------------

#ifdef DRAW

#define AVOID_INTERPOLATOR_IMPRECISION_OFFSET 0.1f

#include "../parameters/WaterGridRendering.fx"
#include "../parameters/WaterGridLights.fx"

struct SMeshVertex
{
float2 position : CS_Position;
NUINT4 index : CS_Color;
};

struct SVertexToPixel
{
float4 Position  : POSITION0;
float4 ProjectedPosition;

float2 uv;

float3 wPointBeforeMorph;
float4 wPoint;

SFogVertexToPixel fog;

#ifdef FOURLIGHTS
float4 lightIndex03;
#endif
#ifdef EIGHTLIGHTS
float4 lightIndex47;
#endif

};

#define WATER_LEVEL WaterParams.x
#define WATER_TIME WaterParams.z
#define RAINY SizeParams.y
#define INV_TRANSPARENCY_DEPTH WaterParams1.x
//#define INV_TRANSPARENCY_DEPTH (1.f / 1.5f)

#define FOAM_UV_SCALE WaterParams1.y

SVertexToPixel MainVS( in SMeshVertex input)
{
SVertexToPixel Output = (SVertexToPixel)0;

// Compute the world position
float2 uv = input.position.xy ;
float4 worldPos = mul(float4(uv,0.f,1.f),GridMatrix);
worldPos = float4(worldPos.xy / worldPos.w + WaterParams.yz,WATER_LEVEL,1.f);

// Add the displacement map

float4 vectorMap = tex2Dlod(VectorMapTexture,float4(uv,0,0));

Output.uv = uv;

Output.wPointBeforeMorph = worldPos.xyz;

worldPos.xyz += vectorMap.xyz;

Output.wPoint.xyz = worldPos.xyz;
Output.wPoint.w = length(vectorMap.xy) + smoothstep(6,8,vectorMap.z)*10;

// Apply the view proj matrix
Output.Position = mul( float4(worldPos.xyz-CameraPosition.xyz,1) ,ViewRotProjectionMatrix);
Output.ProjectedPosition = Output.Position;
// JitterPosition(Output.Position);

// Force the clipping of the triangle the vertex is masked ( out a water spline )
float2 p2 = abs(worldPos.xy);
if ((p2.x < MAP_SIZE_GUARD_BAND.x) && (p2.y<MAP_SIZE_GUARD_BAND.y))
{
if (vectorMap.w == 0)
{
Output.Position.w = -10000;
}
}

ComputeFogVertexToPixel( Output.fog, worldPos.xyz );

#ifdef FOURLIGHTS
Output.lightIndex03 = TileLightsIndex03[input.index.r] + AVOID_INTERPOLATOR_IMPRECISION_OFFSET;
#endif
#ifdef EIGHTLIGHTS
Output.lightIndex47 = TileLightsIndex47[input.index.r] + AVOID_INTERPOLATOR_IMPRECISION_OFFSET;
#endif

return Output;
}

float3 GetDetailNormalMap( float3 position )
{
float scale = 0.5;

float time = TIME * 0.1;
float2 uv0 = ( position.xy + time ) * scale / 1.5;
float2 uv1 = ( position.xy - time ) * scale / 30;

float3 n0 = tex2D(DetailNormalMapTexture, uv0 ).xyz * 2 - 1;
float3 n1 = tex2D(DetailNormalMapTexture, uv1 ).xyz * 2 - 1;

float3 ripples = tex2D(RippleNormalMapTexture,position.xy * 0.25).xyz;
ripples.z = 1.f - sqrt( dot( ripples.xy, ripples.xy ) );
float3 normal = n0*0.5+n1;

normal += ripples*6;

return normalize(normal);
}

float SchlickFresnel(float cosAngle,float F)
{
return F + (1.0 - F) * pow(1.0 - cosAngle,5.0);
}

float4 SchlickFresnel4(float4 cosAngle,float F)
{
return F + (1.0 - F) * pow(1.0 - cosAngle,5.0);
}

float3 FresnelSchlickWithRoughness(float3 SpecularColor,float cosAngle,float Gloss)
{
return SpecularColor + (max((float3)Gloss, SpecularColor) - SpecularColor) * pow(1 - cosAngle, 5);
}

float EnergyConservationSpecular( float dotproduct_saturated, float power )
{
return pow( dotproduct_saturated , power ) * ( ( 0.0397436f * power ) + 0.0856832f );
}

float4 EnergyConservationSpecular4( float4 dotproduct_saturated, float power )
{
return pow( dotproduct_saturated , power ) * ( ( 0.0397436f * power ) + 0.0856832f );
}

float SpecularReflection( float dotproduct_saturated, float power )
{
return pow( dotproduct_saturated , power );
}

float3 GetFakeReflectionColor()
{
float lerpFactor = abs((TimeOfDay * 2.0f) - 1.0f);
return lerp(AmbientSkyColor, AmbientGroundColor, lerpFactor);
}

float4 FetchReflectionWithBias(in float2 texCoords, in float mipBias = 0.0f, in bool skyOnly = false )
{
#ifdef NOREFLECTION
return float4(GetFakeReflectionColor(), 1.0f);
#endif
return SampleParaboloidReflection (ParaboloidReflectionTexture, texCoords, mipBias , skyOnly);
}

float3 SampleAmbient( float3 normal )
{
#ifdef NOREFLECTION
return GetFakeReflectionColor();
#endif
bool sampleParaboloidBottom = false;
float2 reflectTexCoords = ComputeParaboloidProjectionTexCoords(normal, sampleParaboloidBottom);
float4 reflectionSample = SampleParaboloidReflection(ParaboloidReflectionTexture, reflectTexCoords, 4);
return reflectionSample.rgb * 1;
}

float GetDeferredDistanceAttenuationFactor( float d2 , float4 attenuation )
{
float d1 = sqrt(d2)+1;
float base = 1.0f / (d1*d1);
return saturate( base * attenuation.z + attenuation.w );
}

void ComputeAmbient(
in float3 position,in float3 normal,
in float3 viewVector,in float specularPower,
inout float3 diffuseLightSum,
inout float3 subsurfaceScatteringSum,
inout float3 specularSum)
{
float3 ambientColor = float3(0.8,1,1)*WaterParams2.w;
diffuseLightSum += ambientColor;
subsurfaceScatteringSum += ambientColor;
}

void Compute4Lights(in uint4 lightIndex,
in float3 position,in float3 normal,
in float3 viewVector,in float specularPower,
inout float3 diffuseLightSum,
inout float3 subsurfaceScatteringSum,
inout float3 specularSum)
{
for (int i=0;i<4;++i)
{
int index = lightIndex[i];
if (index != 0)
{

float4 tileLightsDirection = TileDirection[index];
float4 tileLightsColor = TileLightsColor[index];
float4 light = TileLights[index];
float4 attenuation = TileLightAttenuations[index];

float3 L = (light.xyz - position);
float3 Ln = normalize( L );

float3 Hs = normalize(Ln + viewVector);

float NdotH = dot( normal , Hs );
float NdotHs = saturate(dot( normal , Hs ));
float VdotHs = saturate(dot( Hs , viewVector ));
float NdotL = saturate(dot( normal , L ));

float3 lightColor = tileLightsColor.rgb;

float cosAngle = dot(tileLightsDirection.xyz,-Ln);
float angleAttenation = saturate(cosAngle * tileLightsColor.w + tileLightsDirection.w);
float distanceAttenuation = 40*GetDeferredDistanceAttenuationFactor(dot(L,L),attenuation);

lightColor *= distanceAttenuation * angleAttenation;

float3 specular = lightColor * pow( abs(NdotH) , specularPower );

diffuseLightSum += lightColor;
subsurfaceScatteringSum += lightColor;
specularSum.rgb += specular;
}
}

/*
{

float4 tileLightsDirection0 = TileDirection[lightIndex.x];
float4 tileLightsColor0 = TileLightsColor[lightIndex.x];
float4 tileLights0 = TileLights[lightIndex.x];

float4 tileLightsDirection1 = TileDirection[lightIndex.y];
float4 tileLightsColor1 = TileLightsColor[lightIndex.y];
float4 tileLights1 = TileLights[lightIndex.y];

float4 tileLightsDirection2 = TileDirection[lightIndex.z];
float4 tileLightsColor2 = TileLightsColor[lightIndex.z];
float4 tileLights2 = TileLights[lightIndex.z];

float4 tileLightsDirection3 = TileDirection[lightIndex.w];
float4 tileLightsColor3 = TileLightsColor[lightIndex.w];
float4 tileLights3 = TileLights[lightIndex.w];

float3 L0 = (tileLights0.xyz - position);
float3 L0n = normalize( L0 );
float3 H0s = normalize(L0n + viewVector);

float3 L1 = (tileLights1.xyz - position);
float3 L1n = normalize( L1 );
float3 H1s = normalize(L1n + viewVector);

float3 L2 = (tileLights2.xyz - position);
float3 L2n = normalize( L2 );
float3 H2s = normalize(L2n + viewVector);

float3 L3 = (tileLights3.xyz - position);
float3 L3n = normalize( L3 );
float3 H3s = normalize(L3n + viewVector);

float4 L_sqrtLength = float4(dot(L0,L0),dot(L1,L1),dot(L2,L2),dot(L3,L3));
float4 NdotHs = saturate( float4( dot( normal , H0s ),dot( normal , H1s ),dot( normal , H2s ),dot( normal , H3s )) );
float4 cosAngle = float4( dot(tileLightsDirection0.xyz,-L0n ),
dot(tileLightsDirection1.xyz,-L1n ),
dot(tileLightsDirection2.xyz,-L2n ),
dot(tileLightsDirection3.xyz,-L3n ));

float4 a = float4(tileLightsColor0.w,tileLightsColor1.w,tileLightsColor2.w,tileLightsColor3.w);
float4 b = float4(tileLightsDirection0.w,tileLightsDirection1.w,tileLightsDirection2.w,tileLightsDirection3.w);
float4 c = float4(tileLights0.w,tileLights1.w,tileLights2.w,tileLights3.w);

float4 angleAttenation = saturate(cosAngle * a + b);

float4 distanceAttenuation = 1.f - saturate( L_sqrtLength * c );

float4 attenuation = angleAttenation * distanceAttenuation;

float3 lightColor0 = tileLightsColor0.rgb * attenuation.x;
float3 lightColor1 = tileLightsColor1.rgb * attenuation.y;
float3 lightColor2 = tileLightsColor2.rgb * attenuation.z;
float3 lightColor3 = tileLightsColor3.rgb * attenuation.w;

float4 spec = pow( NdotHs , specularPower ); // EnergyConservationSpecular4( NdotHs , specularPower ) * SchlickFresnel4(VdotHs,f0);

float3 specular = lightColor0 * spec.x +
lightColor1 * spec.y +
lightColor2 * spec.z +
lightColor3 * spec.w;

float3 diffuseLight = lightColor0 +
lightColor1 +
lightColor2 +
lightColor3;

specularSum.rgb += specular;
diffuseLightSum += diffuseLight;
subsurfaceScatteringSum += diffuseLight;
}*/
}

float3 WaterAbsorption(float depth)
{
float3 ka = float3(2,0.6,0.4)*1;
float3 depthAttenuation   = exp(ka*depth);
return saturate(depthAttenuation);
}

float4 MainPS( in SVertexToPixel Input)
{
float2 uv = Input.uv;

// ------------------------------------------------------------------------
// Detections
// ------------------------------------------------------------------------

float3 velocity = Input.wPoint.xyz - Input.wPointBeforeMorph.xyz;
float acceleration_z_detection = saturate( velocity.z*10);
float acceleration_xy_detection = saturate( length(velocity.xy)*1);

// ------------------------------------------------------------------------
// Normals
// ------------------------------------------------------------------------

float3 normalMap = tex2D(NormalMapTexture,uv).rgb * 2 - 1;
float3 normal = normalMap;
float3 tangent   = normalize(float3(normal.z,0.f,-normal.x));
float3 binormal   = normalize(float3(0.f,normal.z,-normal.y));
float3 detail_normal = GetDetailNormalMap( Input.wPointBeforeMorph );

float3 projectedPosition = Input.ProjectedPosition.xyz / Input.ProjectedPosition.w;

float2 screen_uv = projectedPosition.xy;

screen_uv.xy = screen_uv*0.5+0.5;
screen_uv.y = 1-screen_uv.y;

float world_depth = SampleDepthWS( DepthCopyTexture, screen_uv );

float vertex_world_depth = MakeDepthLinearWS( projectedPosition.z );

float zDiff = world_depth - vertex_world_depth;

normal = normalize( tangent * detail_normal.x + binormal * detail_normal.y + normal * detail_normal.z );

// ------------------------------------------------------------------------
// Sun light vector and water color
// ------------------------------------------------------------------------

float3 L = -SunDirection.xyz;
float3 V = normalize(CameraPosition.xyz - Input.wPoint.xyz);
float3 R = reflect(-V, normal);
R.z += 0.05;
float3 Re3 = reflect(-V, normalize( lerp(normal,float3(0,0,1),0.75 * E3_TUNING)));
float3 Hr = normalize(R + V);
float3 Hs = normalize(L + V);

// ------------------------------------------------------------------------
// Sunlight
// ------------------------------------------------------------------------

float3 sun_light = saturate(dot(L, normal) ) * SunColor.rgb ;

float shadow = 1;
float shadowAttenuated = 1;

#ifdef SUNSHADOW
SLongRangeShadowParams longRangeParams;
longRangeParams.enabled = true;
longRangeParams.positionWS = Input.wPoint.xyz;
longRangeParams.normalWS = 0; // Not needed for water

CSMTYPE CSMShadowCoords = ComputeCSMShadowCoords( Input.wPoint.xyz );
shadow = CalculateSunShadow( CSMShadowCoords, float2(0,0), LightShadowMapSize, FacettedShadowReceiveParams, longRangeParams );
shadowAttenuated = shadow * 0.7 + 0.3;
#endif

sun_light *= shadowAttenuated;

// ------------------------------------------------------------------------
// Fake Subsurface scattering
// ------------------------------------------------------------------------

float water_displacement = saturate( pow( Input.wPoint.w * 0.09 ,2) );

float3 subsurface_scattering_contribution = 0.5*float3(0.7,1,1) * (saturate( 0*water_displacement*0.5 + dot(normal.xy,normal.xy)));

float3 subsurface_scattering = SunColor.rgb * shadowAttenuated;

// ------------------------------------------------------------------------
// Water material
// ------------------------------------------------------------------------

float waterDepthAlphaBlend = saturate( zDiff * INV_TRANSPARENCY_DEPTH ) * 0.5 + 0.5;

float contourFoam = 1 - saturate( abs(0.05-zDiff) / .125);

float3 sampledWaterColor = tex2D(ColorMapTexture,uv).rgb * 0.02 * saturate(zDiff);

float3 WaterColor = sampledWaterColor + sampledWaterColor*subsurface_scattering*WaterAbsorption(-zDiff*3)*0.01 ;

float4 parameters = tex2D(ParametersMapTexture,uv);

float foamTime = TIME * 0.0025;

float4 foam = tex2Dbias(FoamTexture, float4(Input.wPointBeforeMorph.xy * FOAM_UV_SCALE * 2+ foamTime,0,-2));

float foam_level = parameters.z;
float foamBlend = saturate( (foam.a - (1-foam_level)) / (foam_level+0.001) );

WaterColor = lerp(WaterColor,foam.rgb,foamBlend*0.15);
WaterColor = lerp(WaterColor,foam.aaa,contourFoam*0.125);

//float Nd = 1.f / 1.33f;
//float f0 = pow((1-Nd)/(1+Nd),2);
float f0 = WaterParams2.x;
float reflectionIntensity = WaterParams2.y;
float specularPower = WaterParams2.z;

float3 color = 0;
float3 diffuseLightSum = 0;

// ------------------------------------------------------------------------
// Reflection
// ------------------------------------------------------------------------

float lightIntensity = saturate(length(diffuseLightSum));

float reflectionProjectionDistance = 400.f;
float3 correctedReflecton = normalize( (Input.wPoint.xyz + R * reflectionProjectionDistance) - CameraPosition.xyz);

bool sampleParaboloidBottom = false;
float2 reflectTexCoords = ComputeParaboloidProjectionTexCoords( R, sampleParaboloidBottom);
float4 reflection = FetchReflectionWithBias( reflectTexCoords, 0 , true);

#if (E3_TUNING == 1)
float2 reflectTexCoords2 = ComputeParaboloidProjectionTexCoords( Re3, sampleParaboloidBottom);
float4 reflection2 = FetchReflectionWithBias( reflectTexCoords2, 0);
float3 temp = reflection2.rgb * 1000;
reflection.rgb += reflection2.rgb * min(2,dot(temp,temp)) * (1-lightIntensity);
#endif

float SSR_mask = 1;
#ifdef USE_SSR
float2 duv = normal.xy * 0.1;// * Input.ProjectedPosition.w;
float4 SSReflection = tex2D(ScreenSpaceReflectionTexture,screen_uv + duv);
SSR_mask = 1-SSReflection.a;
reflection.rgb = lerp(reflection.rgb,SSReflection.rgb,SSReflection.a);
#endif

float4 specular_ambient = reflection;

#ifdef SUNSHADOW
diffuseLightSum += sun_light;

float VdotHs = saturate(dot( Hs , V ));
float NdotHs = saturate(dot( normal , Hs ));

color += sun_light * EnergyConservationSpecular( NdotHs , specularPower ) * SchlickFresnel(VdotHs,f0) * shadow * SSR_mask;
#endif

// ------------------------------------------------------------------------
// Specular reflection combining
// ------------------------------------------------------------------------

float NdotV = 1-saturate( dot(normal,V));
float VdotHr = saturate(dot( Hr , V ));
float NdotHr = saturate(dot( normal , Hr ));

float microfacettes_distribution = SpecularReflection(NdotV,5);
color += specular_ambient.rgb * microfacettes_distribution * SchlickFresnel(VdotHr,0.01) * reflectionIntensity;

ComputeAmbient( Input.wPoint.xyz,normal,
V,specularPower,
diffuseLightSum,
subsurface_scattering,
color);

#ifdef FOURLIGHTS
uint4 lightIndex03 = uint4(Input.lightIndex03);

Compute4Lights( lightIndex03,
Input.wPoint.xyz,normal,
V,specularPower,
diffuseLightSum,
subsurface_scattering,
color);
#endif

#ifdef EIGHTLIGHTS
uint4 lightIndex47 = uint4(Input.lightIndex47);

Compute4Lights( lightIndex47,
Input.wPoint.xyz,normal,
V,specularPower,
diffuseLightSum,
subsurface_scattering,
color);
#endif

color += diffuseLightSum * WaterColor;
#if E3_TUNING_SUBSURFACE
R = reflect(-V, normalize(float3(0,0,1)*40 + normal) );
reflectTexCoords = ComputeParaboloidProjectionTexCoords( R, sampleParaboloidBottom);
float4 ssReflection = FetchReflectionWithBias( reflectTexCoords, 6) );
subsurface_scattering += E3_TUNING * ssReflection.rgb*25 * (1-0.75*lightIntensity);
#endif
color += subsurface_scattering_contribution * subsurface_scattering * WaterColor * 3;// * shadowAttenuated;

float4 fog = ComputeFogWS( Input.wPoint.xyz );

float3 resultColor = color;

ApplyFogNoBloom( resultColor, fog );

// Fade out the horizon line to avoid flickering
const float horizonThresholdDown = 740.f/768.f;
const float horizonThresholdUP = 760.f/768.f;
waterDepthAlphaBlend *= 1 - saturate((uv.y - horizonThresholdDown) / (horizonThresholdUP - horizonThresholdDown));

return float4(resultColor,waterDepthAlphaBlend);
}

technique t0
{
pass p0
{
SrcBlend = SrcAlpha;
DestBlend = InvSrcAlpha;

AlphaBlendEnable = true;
AlphaTestEnable = false;
ZEnable = true;
ZWriteEnable = true;
CullMode = CCW;
WireFrame = false;
}
}

#endif

// ----------------------------------------------------------------------------
// Occlusion box
// ----------------------------------------------------------------------------

#ifdef OCCLUSIONBOX

#include "../parameters/GridOcclusion.fx"

struct SMeshVertex
{
float3 position : CS_Position;
};

struct SVertexToPixel
{
float4 Position  : POSITION0;
};

SVertexToPixel MainVS( in SMeshVertex input)
{
SVertexToPixel output = (SVertexToPixel)0;

float3 pos = input.position-CameraPosition.xyz;

output.Position = mul( float4(pos,1) ,ViewRotProjectionMatrix);

return output;
}

#define NULL_PIXEL_SHADER

float4 MainPS( in SVertexToPixel Input )
{
return 0;
}

technique t0
{
pass p0
{
ColorWriteEnable0 = None;
SrcBlend = One;
DestBlend = Zero;
AlphaBlendEnable = false;
AlphaTestEnable = false;
ZEnable = true ;
ZWriteEnable = false;
CullMode = None;
WireFrame = false;
}
}

#endif
[/spoiler]


Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
offline
 Orangebrains
Дата: Среда, 2014-06-11, 23:28 | Сообщение # 169
Гангстер
Сообщений: 615
dax1, ребята протестирую, мб и релизнет. Хз
 
offline
 dax1
Дата: Четверг, 2014-06-12, 00:05 | Сообщение # 170
Гангстер
Сообщений: 112
проверил эти
#define E3_TUNING 1
#define E3_TUNING_SUBSURFACE 1
ни чего нового на глаз не увидел, а мб не так смотрел хз crazy

Добавлено (2014-06-12, 00:05)
---------------------------------------------
хз в каких местах искать изменения, на коже персов или ещё где, в общем не существенно на мой взгляд.



Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
offline
 Orangebrains
Дата: Четверг, 2014-06-12, 00:27 | Сообщение # 171
Гангстер
Сообщений: 615
dax1,
Цитата Orangebrains ()
it's mostly cranking up the paraboloid reflections and stuff
 
offline
 dax1
Дата: Четверг, 2014-06-12, 00:36 | Сообщение # 172
Гангстер
Сообщений: 112
вот http://yadi.sk/d/1NL_-Ac6Somgx перепакованные шейдеры + мой патчик облегчающий жизнь с ультра текстурами
в шейдере том прописал
#define E3_TUNING 1
#define E3_TUNING_SUBSURFACE 1


Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
offline
 Orangebrains
Дата: Четверг, 2014-06-12, 02:12 | Сообщение # 173
Гангстер
Сообщений: 615
dax1, спасибо.
Ультра-текстуры нужны, как пишут многие сайты и издания, только для 4К мониторов. На обычных разница не заметна. Так что в ультра-текстурах нужды нет. А без твоего фикса у меня с ними вообще вот что было (из-за того, что в видеокарте не 3, а 2 гб памяти):



P.S. фикс не помог. С ультра-текстурами лагает и фризится.
P.P.S. Изменений ноль. Вообще.
Только плащ мокрее стал, лол.



Сообщение отредактировал Orangebrains - Четверг, 2014-06-12, 16:56
 
offline
 Orangebrains
Дата: Четверг, 2014-06-12, 02:40 | Сообщение # 174
Гангстер
Сообщений: 615
Gulliver, dax1, с геймпадом и надо играть! Управление "клавиатура+мышь" до жути неудобное.

Цитата dax1 ()
dax1, Проверил, просадок меньше стало, и +2 фпс.

А я вообще не заметил изменений.
 
offline
 portal-2x2
Дата: Четверг, 2014-06-12, 03:43 | Сообщение # 175
Гангстер
Сообщений: 1253
Цитата Orangebrains ()
А я вообще не заметил изменений.

Особенно когда загрузился только, камерой вертишь и лагов меньше, это значит что на прорисовку уходит меньше времени, соответственно его файлик что то изменяет.


GA-Z87X-OC,32gb DDRIII 2.4ghz,I7 4770k,Corsair H100i,GTX 690,SSD 256gb, 2XWD Velociraptor 1tb, Corsair RM1000w, Corsair Obsidian 900D
46.174.54.213:55555 CSS
 
offline
 portal-2x2
Дата: Четверг, 2014-06-12, 03:44 | Сообщение # 176
Гангстер
Сообщений: 1253
Orangebrains, Перенеси просто посты туда, а тут потри)


GA-Z87X-OC,32gb DDRIII 2.4ghz,I7 4770k,Corsair H100i,GTX 690,SSD 256gb, 2XWD Velociraptor 1tb, Corsair RM1000w, Corsair Obsidian 900D
46.174.54.213:55555 CSS
 
offline
 dax1
Дата: Четверг, 2014-06-12, 09:01 | Сообщение # 177
Гангстер
Сообщений: 112
Цитата Orangebrains ()
с геймпадом и надо играть! Управление "клавиатура+мышь" до жути неудобное.

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

Добавлено (2014-06-12, 09:01)
---------------------------------------------
мне патч норм помог, уж я то знаю чего в нём скрутил ;) так же в нём разрешение параболоид текстуры увеличено с 1к до 2к, увеличено количество частиц, количество капелек дождя на земле, ну и ещё по мелочи, некоторые вещи подрезаны, но не палится, а уж разница меж высокими и ультра текстурами видна невооружённым взглядом, хз как ты её не видишь, ни каких 4к не нужно что усмотреть новые детали на текстурах.



Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
offline
 dax1
Дата: Четверг, 2014-06-12, 09:14 | Сообщение # 178
Гангстер
Сообщений: 112
и это, шейдеры перепакованные можно открывать блокнотом, будут ли они правильно работать если в них из блокнота вносить изменения не проверял.


Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
offline
 Orangebrains
Дата: Четверг, 2014-06-12, 16:55 | Сообщение # 179
Гангстер
Сообщений: 615
dax1, portal-2x2, как фризилось при повороте камеры на ультра-текстурах, так и фризится.
 
offline
 dax1
Дата: Четверг, 2014-06-12, 17:40 | Сообщение # 180
Гангстер
Сообщений: 112
Orangebrains, оперативку 2113 mhz поставь, мб не будет, ну или хз чё те посоветовать, разгони систему что ли.


Я счастлив по умолчанию! Пожалуйста, не лезьте в настройки.
 
Форум GtaMania.ru » Комп. игры / Железо / Интернет » Игры » Watch Dogs (Everything is connected. Connection is power)
Страница 12 из 14«121011121314»
Поиск:

Реклама:
GtaMania.ru - это открытый ресурс, позволяющий публиковать материалы любому пользователю сети интернет. Администрация не несет ответственности за опубликованные пользователями материалы. Любой материал может быть удален по просьбе автора, при предъявлении сканированных копий документов подтверждающих авторские права на конкретный материал.
При копировании материалов, гиперссылка на http://gtamania.ru/ ОБЯЗАТЕЛЬНА!
| Design by SandWicH | Copyright GtaMania.ru © 2008 - 2016
Rambler's Top100