Jump to content

  • Log In with Google      Sign In   
  • Create Account

We need your help!

We need 7 developers from Canada and 17 more from Australia to help us complete a research survey.

Support our site by taking a quick sponsored survey and win a chance at a $50 Amazon gift card. Click here to get started!


Alundra

Member Since 19 Jul 2011
Offline Last Active Today, 05:25 AM

Topics I've Started

Why driver gives a gain of FPS ?

30 August 2015 - 03:41 PM

Hi,
The changelog of the driver always says it gives a gain of FPS on multiple games.
Why does it happen ?
Thanks

Mirror hierarchy in local space

21 August 2015 - 01:43 PM

Hi,

I'm searching a way to mirror an hierarchy stored in local space.

Each transformation is relative to its parent and is stored as translation, rotation using quaternion and scaling.

The goal is to mirror a skeleton but it's the same thing as mirror an hierarchy of node.

The goal is to transform the translation and rotation to have the mirror correctly.

The mirror table is generated to know what transformation has to be swapped.

What doesn't work is to invert sign of translation and quaternion like that :

translation.x = -translation.x;
quaternion.x = -quaternion.x;
quaternion.w = -quaternion.w;

The scaling has to stay intact because the hierarchy can be blended with another after the mirror process.

Thanks for the help


PI or not to PI ?

11 August 2015 - 01:51 PM

Hi,

We always removed PI in lighting equations, artist who set 1.0 in reality set PI.

Is it really needed to add PI in the lighting equation which cause the intensity of light to be PI times less than before ?

Here code without PI :

float3 Diffuse_Lambert( in float3 DiffuseColor )
{
  return DiffuseColor;
}

// [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"].
float D_GGX( in float Roughness, in float NoH )
{
  float m = Roughness * Roughness;
  float m2 = m * m;
  float d = ( NoH * m2 - NoH ) * NoH + 1.0f;
  return m2 / ( d * d );
}

Here code with PI :

float3 Diffuse_Lambert( in float3 DiffuseColor )
{
  return DiffuseColor * ( 1.0f / 3.14159f );
}

// [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"].
float D_GGX( in float Roughness, in float NoH )
{
  float m = Roughness * Roughness;
  float m2 = m * m;
  float d = ( NoH * m2 - NoH ) * NoH + 1.0f;
  return m2 / ( 3.14159f * d * d );
}

 

 

 


PhysX multiple scene or one ?

06 August 2015 - 10:01 AM

Hi,

A 3D or 2D world can contains multiple scene and can stream scene too.

Is it better to have one PhysX scene which handle all or multiple PhysX scene for each scene is better ?

Thanks


Schlick vis factor

06 August 2015 - 07:21 AM

Hi,

Here the current vis factor I'm using based on an old discussion about PBR :

// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"].
float SchlickFunc( in float v, in float m )
{
  float k = sqrt( ( 2.0f * m * m ) / 3.14159f );
  return v / ( v - ( k * v ) + k );
}

// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"].
float G_Schlick( in float Roughness, in float NoV, in float NoL )
{
  return SchlickFunc( NoL, Roughness ) * SchlickFunc( NoV, Roughness );
}

But I saw unreal uses :

// Tuned to match behavior of Vis_Smith
// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"]
float Vis_Schlick( float Roughness, float NoV, float NoL )
{
  float k = Square( Roughness ) * 0.5;
  float Vis_SchlickV = NoV * (1 - k) + k;
  float Vis_SchlickL = NoL * (1 - k) + k;
  return 0.25 / ( Vis_SchlickV * Vis_SchlickL );
}

Where comes from this calcule ? As you can see, the pi factor is not there, sqrt also.

Here the formula used by John Hable :

float G1V(float dotNV, float k)
{
  return 1.0f/(dotNV*(1.0f-k)+k);
}

// V
float alpha = roughness*roughness;
float k = alpha/2.0f;
vis = G1V(dotNL,k)*G1V(dotNV,k);

Again, not the same formula and again pi and sqrt not there.

What is the explanation of all these different formula ? The unreal one is the most mysterious to me.

Thanks

--

The other factors used are common :

float3 Diffuse_Lambert( float3 DiffuseColor )
{
  return DiffuseColor * (1 / PI);
}
// GGX / Trowbridge-Reitz
// [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"]
float D_GGX( float Roughness, float NoH )
{
  float m = Roughness * Roughness;
  float m2 = m * m;
  float d = ( NoH * m2 - NoH ) * NoH + 1; // 2 mad
  return m2 / ( PI*d*d ); // 4 mul, 1 rcp
}
// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"]
// [Lagarde 2012, "Spherical Gaussian approximation for Blinn-Phong, Phong and Fresnel"]
float3 F_Schlick( float3 SpecularColor, float VoH )
{
  // Anything less than 2% is physically impossible and is instead considered to be shadowing
  float Fc = pow( 1 - VoH, 5 ); // 1 sub, 3 mul
  return saturate( 50.0 * SpecularColor.g ) * Fc + (1 - Fc) * SpecularColor;
}

PARTNERS