|
Post by sbdjazz on Feb 18, 2017 12:35:40 GMT
Tindal Effect (rays of sun visible in dust or fog) or something similar to Tindal effect, is it possible?
|
|
|
Post by Red Moon Entertainment on Feb 18, 2017 12:57:23 GMT
I think here is something could help you. Not sure.
|
|
|
Post by Red Moon Entertainment on Feb 18, 2017 13:28:45 GMT
BTW, did you meant this? It's a skybox by Heiko Irrgang (CloudyLightRays) in a skyboxes set, made of six of'em. See the others skyboxes of the set here.
|
|
|
Post by GH Games on Feb 18, 2017 15:27:39 GMT
Yea on the link hplovecraft gave you the shader called "God Rays" will do what your looking for.
|
|
|
Post by sbdjazz on Feb 18, 2017 17:11:50 GMT
Got a give it a try Thanks all of you!!!
|
|
|
Post by sbdjazz on Feb 18, 2017 17:43:18 GMT
Is there a way I can use bloom as well as god rays? The default bloom script won't work. Is there a bloom post processing script that works on user setting.
|
|
|
Post by GH Games on Feb 18, 2017 17:47:35 GMT
I don't see why not. I wouldn't recommend it, however I assume your camchase already has "User" set to it. So all you need to do is add the bloom script. I guess.
|
|
|
Post by sbdjazz on Feb 18, 2017 17:50:13 GMT
I did, but it then stops showing any effect at all.
|
|
|
Post by GH Games on Feb 18, 2017 18:02:02 GMT
Hmm. This has happened to me before too. Try re-adding your camera from scratch.
|
|
|
Post by DedTed on Feb 18, 2017 18:07:49 GMT
I believe you can't use more one camera script in 3D Rad... Sad
|
|
|
Post by sbdjazz on Feb 18, 2017 18:08:22 GMT
I got an idea, making a new thread.
|
|
|
Post by Red Moon Entertainment on Feb 19, 2017 12:59:04 GMT
I'm not sure but, I think it's possible creating a unique script-shader which contains both bloom and godrays.
|
|
|
Post by DedTed on Feb 19, 2017 16:20:51 GMT
Wish if Shadmar was here...
|
|
|
Post by WhyNot on Feb 19, 2017 16:40:29 GMT
To use bloom and god rays at once...
Use this script
//////////////////////////////////////////////////////////////////////////////////////////////////////////// // Post-process shader: display deformation and color manipulation //////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////// // Post-process shader: display deformation and color manipulation ////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*HLSLSTART GR
float2 ViewportSize = {800, 600}; //***************************************************************************** //EDITIABLE VALUES //***************************************************************************** float2 screenLightPos =float2(0.5,0.5); float Weight = 0.05f; float Decay = 0.977f; #define SAMPLES 64
//-------------------------------------------------------------------------------------------- //Textures //-------------------------------------------------------------------------------------------- texture screenTexture;
sampler screenTextureSampler = sampler_state { Texture = <screenTexture>; MinFilter = POINT; MagFilter = POINT;
AddressU = Clamp; AddressV = Clamp; };
texture ProcessedTexture;
sampler2D ProcessedTargetSampler = sampler_state { Texture = <ProcessedTexture>; MinFilter = POINT; MagFilter = POINT;
AddressU = Clamp; AddressV = Clamp; };
//-------------------------------------------------------------------------------------------- //Struct's //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- //Pixel Shader //-------------------------------------------------------------------------------------------- float4 DefaultRender(in float2 textureUV : TEXCOORD0) : COLOR { // Set up illumination decay factor. half illuminationDecay = 0.7f;
// Store initial sample. half3 color = tex2D(screenTextureSampler, textureUV.xy);
// Calculate vector from pixel to light source in screen space. half2 deltaTexCoord = (textureUV - screenLightPos.xy);
// Divide by number of samples and scale by control factor. deltaTexCoord *= 1.0f / SAMPLES * 1; //change to change range
// Evaluate summation from Equation 3 NUM_SAMPLES iterations. for (int i = 0; i < SAMPLES; i++) { // Step sample location along ray. textureUV -= deltaTexCoord;
// Retrieve sample from depthmask half3 sample = tex2D(screenTextureSampler, textureUV );
// Output sample as original rendered/colored objects not just depthmask, comment out if only light is wanted if (sample.r+sample.g+sample.b < 2.0f) sample.rgb=0; //else sample=1.0f; //enable to output just white
// Apply sample attenuation scale/decay factors. sample *= illuminationDecay * Weight;
// Accumulate combined color. color += sample;
// Update exponential decay factor. illuminationDecay *= Decay; }
// Output final color return float4( color, 1.0f); }
//-------------------------------------------------------------------------------------------- //Technique //--------------------------------------------------------------------------------------------
technique PostProcessing { pass p0 { PixelShader = compile ps_3_0 DefaultRender(); } }
HLSLEND*/ //////////////////////////////////////////////////////////////////////////////////////////////////////////// // Stacked post-process shaders example: bloom effect ////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*HLSLSTART Bright Only
texture processedTexture; sampler processedTextureSampler = sampler_state { Texture = <processedTexture>; MinFilter = LINEAR; MagFilter = LINEAR; };
float Luminance = 0.08f; static const float fMiddleGray = 0.18f; static const float fWhiteCutoff = 0.8f;
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR { //Enhance bright pixels, hide darker pixels float3 ColorOut = tex2D(processedTextureSampler,textureUV); //read a pixel from the rendered scene (this shader receives it as a texture) ColorOut *= fMiddleGray / ( Luminance + 0.001f ); ColorOut *= ( 1.0f + ( ColorOut / ( fWhiteCutoff * fWhiteCutoff ) ) ); ColorOut -= 5.0f; ColorOut = max( ColorOut, 0.0f ); ColorOut /= ( 10.0f + ColorOut ); return float4( ColorOut, 1.0f ); }
technique PostProcessing { pass P0 { PixelShader = compile ps_2_0 DefaultRender(); } }
HLSLEND*/
//////////////////////////////
/*HLSLSTART Bloom H
texture processedTexture; sampler processedTextureSampler = sampler_state { Texture = <processedTexture>; MinFilter = LINEAR; MagFilter = LINEAR; };
#define NUM 13
float2 tKH[NUM];
static const float BlurWeights[NUM] = { 0.002216, 0.008764, 0.026995, 0.064759, 0.120985, 0.176033, 0.199471, 0.176033, 0.120985, 0.064759, 0.026995, 0.008764, 0.002216,
};
float BloomScale = 1.5f;
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR { float4 Color = 0;
for (int i = 0; i < NUM; i++)
{ Color += tex2D( processedTextureSampler, textureUV + tKH[i].xy ) * BlurWeights[i]; }
Color *= BloomScale; return float4(Color.rgb,1.0f); }
technique PostProcessing { pass P0 { PixelShader = compile ps_2_0 DefaultRender(); } }
HLSLEND*/
//////////////////////////////
/*HLSLSTART Bloom V
texture processedTexture; sampler processedTextureSampler = sampler_state { Texture = <processedTexture>; MinFilter = LINEAR; MagFilter = LINEAR; };
#define NUM 13
float2 tKV[NUM];
static const float BlurWeights[NUM] = { 0.002216, 0.008764, 0.026995, 0.064759, 0.120985, 0.176033, 0.199471, 0.176033, 0.120985, 0.064759, 0.026995, 0.008764, 0.002216, };
float BloomScale = 1.5f; float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR { float4 Color = 0; for (int i = 0; i < NUM; i++) { Color += tex2D( processedTextureSampler, textureUV + tKV[i].xy ) * BlurWeights[i]; }
Color *= BloomScale; return float4(Color.rgb,1.0f); }
technique PostProcessing { pass P0 { PixelShader = compile ps_2_0 DefaultRender(); } }
HLSLEND*/
//////////////////////////////
/*HLSLSTART Combine
texture screenTexture; //this is the original 3d scene, as rendered to the main render-target texture sampler screenTextureSampler = sampler_state { Texture = <screenTexture>; MinFilter = LINEAR; MagFilter = LINEAR; };
texture processedTexture; //this is the post-processed scene rendered by the previous pixel-shader sampler processedTextureSampler = sampler_state { Texture = <processedTexture>; MinFilter = LINEAR; MagFilter = LINEAR; };
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR { //Combine the original 3d scene with the post-processed scene float3 ColorOrig = tex2D( screenTextureSampler, textureUV ); ColorOrig += tex2D( processedTextureSampler, textureUV ); return float4( ColorOrig, 1.0f ); }
technique PostProcessing { pass P0 { PixelShader = compile ps_2_0 DefaultRender(); } }
HLSLEND*/
///////////////////////////////////////////////////////////////////////////////////////
//The following is our regular script code which sets and manipulates the shaders above
void Main() { if (iInitializing()) { //Assign the 4 post-process shaders above to the camera, in the order we want them to be processed iShaderStack(OBJ_0,"",1.0f); //clear (reset) the stack (list of shader to process) first! iShaderStack(OBJ_0,"Bright Only",0.125f); iShaderStack(OBJ_0,"Bloom H",-0.125f); //apply bloom H technique to the small buffer again iShaderStack(OBJ_0,"Bloom V",8.0f); //apply bloom V technique to the small buffer again, also expaning back the image to the original screen size iShaderStack(OBJ_0,"Combine",1.0f); iShaderStack(OBJ_0,"GR",1.00); //finally combine the buffer with the rendered scene, before it is sent to the screen }
//Send texel/pixel conversion tables (used by bloom 'Bloom H' and 'Bloom V' shaders) int i; float [] tK (2*13); float pixToTexX; float pixToTexY; pixToTexX = 1.0f/iDisplayWidth(); pixToTexY = 0.0f; tK[0]=(-6*pixToTexX);tK[1]=(-6*pixToTexY); tK[2]=(-5*pixToTexX);tK[3]=(-5*pixToTexY); tK[4]=(-4*pixToTexX);tK[5]=(-4*pixToTexY); tK[6]=(-3*pixToTexX);tK[7]=(-3*pixToTexY); tK[8]=(-2*pixToTexX);tK[9]=(-2*pixToTexY); tK[10]=(-1*pixToTexX);tK[11]=(-1*pixToTexY); tK[12]=(0*pixToTexX);tK[13]=(0*pixToTexY); tK[14]=(1*pixToTexX);tK[15]=(1*pixToTexY); tK[16]=(2*pixToTexX);tK[17]=(2*pixToTexY); tK[18]=(3*pixToTexX);tK[19]=(3*pixToTexY); tK[20]=(4*pixToTexX);tK[21]=(4*pixToTexY); tK[22]=(5*pixToTexX);tK[23]=(5*pixToTexY); tK[24]=(6*pixToTexX);tK[25]=(6*pixToTexY); for (i=0;i<12;i++) iShaderFloat2Set(OBJ_0,"",tK[i*2],tK[i*2+1]); //note how we omit shader variable name for the first 12 calls to iShaderFloat2Set(). Please see script functions reference for more information. iShaderFloat2Set(OBJ_0,"tKH",tK[24],tK[25]); pixToTexX = 0.0f; pixToTexY = 1.0f/iDisplayHeight(); tK[0]=(-6*pixToTexX);tK[1]=(-6*pixToTexY); tK[2]=(-5*pixToTexX);tK[3]=(-5*pixToTexY); tK[4]=(-4*pixToTexX);tK[5]=(-4*pixToTexY); tK[6]=(-3*pixToTexX);tK[7]=(-3*pixToTexY); tK[8]=(-2*pixToTexX);tK[9]=(-2*pixToTexY); tK[10]=(-1*pixToTexX);tK[11]=(-1*pixToTexY); tK[12]=(0*pixToTexX);tK[13]=(0*pixToTexY); tK[14]=(1*pixToTexX);tK[15]=(1*pixToTexY); tK[16]=(2*pixToTexX);tK[17]=(2*pixToTexY); tK[18]=(3*pixToTexX);tK[19]=(3*pixToTexY); tK[20]=(4*pixToTexX);tK[21]=(4*pixToTexY); tK[22]=(5*pixToTexX);tK[23]=(5*pixToTexY); tK[24]=(6*pixToTexX);tK[25]=(6*pixToTexY); for (i=0;i<12;i++) iShaderFloat2Set(OBJ_0,"",tK[i*2],tK[i*2+1]); iShaderFloat2Set(OBJ_0,"tKV",tK[24],tK[25]); }
OK all credits goes to Shadmar I just modified them...
|
|
|
Post by DedTed on Feb 19, 2017 17:31:12 GMT
Hehe. Nice! You're awesome
|
|
|
Post by NicusorN5 on Feb 19, 2017 18:41:25 GMT
Didn't know that I can use for ( int i = 0; 1 < limit ; 1++) in 3D Rad .
|
|
|
Post by sbdjazz on Feb 19, 2017 20:01:36 GMT
for(int i = 0; i < limit; i++)
{
Thanks_man();
}
|
|
|
Post by sbdjazz on Feb 19, 2017 21:18:58 GMT
Nope it didn't work. The GR effect gets higher priority for some reason and with it enabled bloom cannot be used. I think we are in the right direction. Some more modifications to the code might solve it.
|
|
|
Post by WhyNot on Feb 20, 2017 4:58:28 GMT
Yeah I haven't tested it properly... I'll maybe modify them...
|
|
|
Post by sbdjazz on Feb 20, 2017 5:53:55 GMT
OK, I just modified them. And it works now
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Post-process shader: display deformation and color manipulation
////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Post-process shader: display deformation and color manipulation
////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Stacked post-process shaders example: bloom effect
////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*HLSLSTART Bright Only
texture processedTexture;
sampler processedTextureSampler =
sampler_state
{
Texture = <processedTexture>;
MinFilter = LINEAR;
MagFilter = LINEAR;
};
float Luminance = 0.09f;
static const float fMiddleGray = 0.19f;
static const float fWhiteCutoff = 0.5f;
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR
{
//Enhance bright pixels, hide darker pixels
float3 ColorOut = tex2D(processedTextureSampler,textureUV); //read a pixel from the rendered scene (this shader receives it as a texture)
ColorOut *= fMiddleGray / ( Luminance + 0.001f );
ColorOut *= ( 1.0f + ( ColorOut / ( fWhiteCutoff * fWhiteCutoff ) ) );
ColorOut -= 5.0f;
ColorOut = max( ColorOut, 0.0f );
ColorOut /= ( 10.0f + ColorOut );
return float4( ColorOut, 1.0f );
}
technique PostProcessing
{
pass P0
{
PixelShader = compile ps_2_0 DefaultRender();
}
}
HLSLEND*/
//////////////////////////////
/*HLSLSTART Bloom H
texture processedTexture;
sampler processedTextureSampler =
sampler_state
{
Texture = <processedTexture>;
MinFilter = LINEAR;
MagFilter = LINEAR;
};
#define NUM 13
float2 tKH[NUM];
static const float BlurWeights[NUM] =
{
0.002216,
0.008764,
0.026995,
0.064759,
0.120985,
0.176033,
0.199471,
0.176033,
0.120985,
0.064759,
0.026995,
0.008764,
0.002216,
};
float BloomScale = 1.5f;
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR
{
float4 Color = 0;
for (int i = 0; i < NUM; i++)
{
Color += tex2D( processedTextureSampler, textureUV + tKH[i].xy ) * BlurWeights[i];
}
Color *= BloomScale;
return float4(Color.rgb,1.0f);
}
technique PostProcessing
{
pass P0
{
PixelShader = compile ps_2_0 DefaultRender();
}
}
HLSLEND*/
//////////////////////////////
/*HLSLSTART Bloom V
texture processedTexture;
sampler processedTextureSampler =
sampler_state
{
Texture = <processedTexture>;
MinFilter = LINEAR;
MagFilter = LINEAR;
};
#define NUM 13
float2 tKV[NUM];
static const float BlurWeights[NUM] =
{
0.002216,
0.008764,
0.026995,
0.064759,
0.120985,
0.176033,
0.199471,
0.176033,
0.120985,
0.064759,
0.026995,
0.008764,
0.002216,
};
float BloomScale = 1.5f;
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR
{
float4 Color = 0;
for (int i = 0; i < NUM; i++)
{
Color += tex2D( processedTextureSampler, textureUV + tKV[i].xy ) * BlurWeights[i];
}
Color *= BloomScale;
return float4(Color.rgb,1.0f);
}
technique PostProcessing
{
pass P0
{
PixelShader = compile ps_2_0 DefaultRender();
}
}
HLSLEND*/
//////////////////////////////
/*HLSLSTART Combine
texture screenTexture; //this is the original 3d scene, as rendered to the main render-target texture
sampler screenTextureSampler =
sampler_state
{
Texture = <screenTexture>;
MinFilter = LINEAR;
MagFilter = LINEAR;
};
texture processedTexture; //this is the post-processed scene rendered by the previous pixel-shader
sampler processedTextureSampler =
sampler_state
{
Texture = <processedTexture>;
MinFilter = LINEAR;
MagFilter = LINEAR;
};
float4 DefaultRender( in float2 textureUV : TEXCOORD0 ) : COLOR
{
//Combine the original 3d scene with the post-processed scene
float3 ColorOrig = tex2D( screenTextureSampler, textureUV );
ColorOrig += tex2D( processedTextureSampler, textureUV );
return float4( ColorOrig, 1.0f );
}
technique PostProcessing
{
pass P0
{
PixelShader = compile ps_2_0 DefaultRender();
}
}
HLSLEND*/
/*HLSLSTART GR
float2 ViewportSize = {800, 600};
//*****************************************************************************
//EDITIABLE VALUES
//*****************************************************************************
float2 screenLightPos =float2(0.5,0.5);
float Weight = 0.05f;
float Decay = 0.946f;
#define SAMPLES 64
//--------------------------------------------------------------------------------------------
//Textures
//--------------------------------------------------------------------------------------------
texture screenTexture;
sampler screenTextureSampler =
sampler_state
{
Texture = <screenTexture>;
MinFilter = POINT;
MagFilter = POINT;
AddressU = Clamp;
AddressV = Clamp;
};
texture processedTexture;
sampler2D ProcessedTextureSampler =
sampler_state
{
Texture = <processedTexture>;
MinFilter = POINT;
MagFilter = POINT;
AddressU = Clamp;
AddressV = Clamp;
};
//--------------------------------------------------------------------------------------------
//Struct's
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
//Pixel Shader
//--------------------------------------------------------------------------------------------
float4 DefaultRender(in float2 textureUV : TEXCOORD0) : COLOR
{
// Set up illumination decay factor.
float illuminationDecay = 0.7f;
// Store initial sample.
float3 color = tex2D(screenTextureSampler, textureUV.xy);
// Calculate vector from pixel to light source in screen space.
float2 deltaTexCoord = (textureUV - screenLightPos.xy);
// Divide by number of samples and scale by control factor.
deltaTexCoord *= 1.0f / SAMPLES * 1; //change to change range
// Evaluate summation from Equation 3 NUM_SAMPLES iterations.
for (int i = 0; i < SAMPLES; i++)
{
// Step sample location along ray.
textureUV -= deltaTexCoord;
// Retrieve sample from depthmask
float3 sample = tex2D(screenTextureSampler, textureUV );
// Output sample as original rendered/colored objects not just depthmask, comment out if only light is wanted
//if (sample.r+sample.g+sample.b < 2.0f) sample.rgb=0;
//else sample=1.0f; //enable to output just white
// Apply sample attenuation scale/decay factors.
sample *= illuminationDecay * Weight;
// Accumulate combined color.
color += sample;
// Update exponential decay factor.
illuminationDecay *= Decay;
}
color+= tex2D( ProcessedTextureSampler, textureUV );
// Output final color
return float4( color, 1.0f);
}
//--------------------------------------------------------------------------------------------
//Technique
//--------------------------------------------------------------------------------------------
technique PostProcessing
{
pass p0
{
PixelShader = compile ps_3_0 DefaultRender();
}
}
HLSLEND*/
///////////////////////////////////////////////////////////////////////////////////////
//The following is our regular script code which sets and manipulates the shaders above
void Main()
{
if (iInitializing())
{
//Assign the 4 post-process shaders above to the camera, in the order we want them to be processed
iShaderStack(OBJ_0,"",1.0f); //clear (reset) the stack (list of shader to process) first!
iShaderStack(OBJ_0,"Bright Only",0.125f);
iShaderStack(OBJ_0,"Bloom H",-0.125f); //apply bloom H technique to the small buffer again
iShaderStack(OBJ_0,"Bloom V",8.0f); //apply bloom V technique to the small buffer again, also expaning back the image to the original screen size
iShaderStack(OBJ_0,"GR",1.00); //finally combine the buffer with the rendered scene, before it is sent to the screen
}
//Send texel/pixel conversion tables (used by bloom 'Bloom H' and 'Bloom V' shaders)
int i;
float [] tK (2*13);
float pixToTexX;
float pixToTexY;
pixToTexX = 1.0f/iDisplayWidth();
pixToTexY = 0.0f;
tK[0]=(-6*pixToTexX);tK[1]=(-6*pixToTexY);
tK[2]=(-5*pixToTexX);tK[3]=(-5*pixToTexY);
tK[4]=(-4*pixToTexX);tK[5]=(-4*pixToTexY);
tK[6]=(-3*pixToTexX);tK[7]=(-3*pixToTexY);
tK[8]=(-2*pixToTexX);tK[9]=(-2*pixToTexY);
tK[10]=(-1*pixToTexX);tK[11]=(-1*pixToTexY);
tK[12]=(0*pixToTexX);tK[13]=(0*pixToTexY);
tK[14]=(1*pixToTexX);tK[15]=(1*pixToTexY);
tK[16]=(2*pixToTexX);tK[17]=(2*pixToTexY);
tK[18]=(3*pixToTexX);tK[19]=(3*pixToTexY);
tK[20]=(4*pixToTexX);tK[21]=(4*pixToTexY);
tK[22]=(5*pixToTexX);tK[23]=(5*pixToTexY);
tK[24]=(6*pixToTexX);tK[25]=(6*pixToTexY);
for (i=0;i<12;i++) iShaderFloat2Set(OBJ_0,"",tK[i*2],tK[i*2+1]); //note how we omit shader variable name for the first 12 calls to iShaderFloat2Set(). Please see script functions reference for more information.
iShaderFloat2Set(OBJ_0,"tKH",tK[24],tK[25]);
pixToTexX = 0.0f;
pixToTexY = 1.0f/iDisplayHeight();
tK[0]=(-6*pixToTexX);tK[1]=(-6*pixToTexY);
tK[2]=(-5*pixToTexX);tK[3]=(-5*pixToTexY);
tK[4]=(-4*pixToTexX);tK[5]=(-4*pixToTexY);
tK[6]=(-3*pixToTexX);tK[7]=(-3*pixToTexY);
tK[8]=(-2*pixToTexX);tK[9]=(-2*pixToTexY);
tK[10]=(-1*pixToTexX);tK[11]=(-1*pixToTexY);
tK[12]=(0*pixToTexX);tK[13]=(0*pixToTexY);
tK[14]=(1*pixToTexX);tK[15]=(1*pixToTexY);
tK[16]=(2*pixToTexX);tK[17]=(2*pixToTexY);
tK[18]=(3*pixToTexX);tK[19]=(3*pixToTexY);
tK[20]=(4*pixToTexX);tK[21]=(4*pixToTexY);
tK[22]=(5*pixToTexX);tK[23]=(5*pixToTexY);
tK[24]=(6*pixToTexX);tK[25]=(6*pixToTexY);
for (i=0;i<12;i++) iShaderFloat2Set(OBJ_0,"",tK[i*2],tK[i*2+1]);
iShaderFloat2Set(OBJ_0,"tKV",tK[24],tK[25]);
}
We need to find a curves shader to fine tune the contrast, or if you find a way.
|
|