음.. 결국 이전에 소스 갈아 엎기 전의 부분까지 완성했습니다..
이제 남은건, 스카이박스 좀 씌워주고
오브젝트정도 띄우고, 에니메이션 돌려주고...
뭐 그 정도만 하면...

.... 어라... 짐 맵툴을 만드는건지 게임을 만드는건지.. 분간이 안가는군요.. orz
저작자 표시 비영리 변경 금지
신고
블로그 이미지

프로그래머 지향자 RosaGigantea

바쁜 일상 생활중의 기억 장소

최근, 게임회사에 들어가기 위해 여러 작업을 하고 있습니다만...
제가 해온건 거의 Network 관련이라 (이쪽이 은근히 재미 있습니다..) Network 관련 프로그램을 짜거나 했었는데..

막상 이력서 쓸려고 보니, 게임회사에서 한눈에 볼 수 있는 작품이 없더군요...
(Network 경우 DB 셋팅이니, 서버, 클라이언트 소스 동시에 검토 하니... 의외로 잘 안먹히는 느낌입니다..)

역시 시대는 3D... 3D로 최소한의 능력을 보여주자 해서 (라기 보단 뭔가 네트워크랑 2D(MFC)로 작품내니 무시당하는 느낌이....)이전에 만들었던 맵툴 소스를 열어서 디버깅 했습니다만...

그땐, 셀러논 시스템이었고, 지금은 AMD 시스템... 윈도우도 비스타 -> 7...
그리고 CG 컴파일러 문제....  여튼 지금 보니 프로그램이 엄청 꼬여있더군요...

그래서 기분을 가볍게 하고, 처음부터 갈아 엎어서 만들고 있는 도중....

맵툴의 맵 시스템은, 친구에게 받아서 대략 구조 검토하고 개조한 뒤, 위에 좀 괜찮은 효과를 씌울까 하다가
역시 믿을 만한건 화면 효과라.... 이전의 수면효과를 CG (NVidia 의)를 해볼려 하다가..
기초 부터 하는게 좋을꺼 같아 HLSL 로 하기로 했습니다.

그런데.. 이거 의외로 소스가 없더군요.(특히 우리나라..)
이거 받은 친구에게 물어봤는데.. 수면 쉐이더가 그렇게 고급기술은 아니라고 들었습니다만...

어떻게 구현하는지 소스 좀 구경하려고 하니 죄다 스샷 찍어놓고, "나 이거 했어요" 느낌이더군요.....

음.......
결국, 이전에 오우거 엔진 공부할때 네이버 오우거 카페의 주바리님의 바다 쉐이더 분석을 가지고 공부 한적이 있어서, 그걸 이용하기로 했습니다.
하지만, 오우거 엔진의 경우 CG를 사용하기에 HLSL코드가 아니라 살짝 요령을 가지고 바꿔 봤습니다.

제 글은 그냥 HLSL소스를 필요로 하는.... (제가 봤을때 이건 대학생 레벨 정도 일꺼 같은..)
분들꼐 많은 도움이 되시길 바라면서...
제 글에 이해가 잘 안가시는 분은
http://starlike.cafe24.com/moniwiki/wiki.php/OgreOceanDemoAnalysis?action=show
이쪽의 주바리님이 분석한걸 봐주시기 바랍니다.


처음 소스 입니다.
파란 화면 평면을 띄어 봅시다..

float4x4 WorldViewProj;
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
struct v2f {
    float4 Position  : POSITION;  // in clip space
};
v2f main_vs( a2v IN)
{
    v2f OUT;
    float4 P = IN.Position;
   
    OUT.Position = mul(P, WorldViewProj);
   
    return OUT;
}
/******************************************************************************/
float4 main_fs(v2f IN) : COLOR
{
    return float4(0, 0, 1, 1);
}


이건 삼각형 2개로 이루워진... 말 그래도 그냥 평면입니다.


파랗게 변했군요..
픽셀 출력이 float(0,0,1,1) 이니까 어쩔 수 없겠지만요 ...
주바리님 소스에 의하면 버텍스 쉐이더의 mul 부분의 연산 순서가 바껴있는데요..
이건 CG와 HLSL의 컴파일 차이인지... 음...

다음 차례 입니다.

float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float4 eyePosition;
float time;
float2 textureScale = float2(25, 25);
texture texture0;
texture texture1;
 
sampler2D texSampler : TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
     
    float2 bumpCoord0 : TEXCOORD3;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
void main_vs(in a2v IN, out v2f OUT)
{
    float4 P = IN.Position;
   
    OUT.Position = mul(P, WorldViewProj);
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale;
}
/******************************************************************************/
uniform sampler2D NormalMap;
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
 
    float3 N = normalize(t0.xyz);
    float3x3 m; // tangent to world matrix
    m[0] = float3(1, 0, 0);
    m[1] = float3(0, 0, 1);
    m[2] = float3(0, 1, 0);
   
    N = normalize( mul( N, m ) );
   
    float amplitude = saturate(dot(N, float3(0, 1, 0)));
   
    OUT.color = float4(0, 0, amplitude, 1);
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}


텍스쳐를 씌었습니다.... 멀리 떨어져서 그냥 다 검은색으로 보이네요.

평면에 웨이브를 줘 보겠습니다.
float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float4 eyePosition;
float time;
float2 textureScale = float2(25, 26);
float waveFreq = 0.028;
float waveAmp = 1.8;

texture texture0;
texture texture1;
 
/******************************************************************************/
sampler2D texSampler : TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};
/******************************************************************************/
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
     
    float2 bumpCoord0 : TEXCOORD3;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
/******************************************************************************/
void main_vs(in a2v IN, out v2f OUT)
{
    #define NWAVES 2
    Wave wave[NWAVES] = {
        { 1.0, 1.0, 0.5, float2(-1, 0) },
        { 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
    };
    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;
    wave[1].freq = waveFreq * 3.0;
    wave[1].amp = waveAmp * 0.33;
    float4 P = IN.Position;
   
    int i = 0;
    float angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
    P.y += wave[i].amp * sin( angle );
    OUT.Position = mul(P, WorldViewProj);
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale;
}
/******************************************************************************/
uniform sampler2D NormalMap;
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
 
    float3 N = normalize(t0.xyz);
    float3x3 m; // tangent to world matrix
    m[0] = float3(1, 0, 0);
    m[1] = float3(0, 0, 1);
    m[2] = float3(0, 1, 0);
   
    N = normalize( mul( N, m ) );
   
    float amplitude = saturate(dot(N, float3(0, 1, 0)));
   
    OUT.color = float4(0, 0, amplitude, 1);
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}




음.. 이렇게 확대해 봐도 잘 모르겠습니다..
뭔가 미묘하게 움직이는게 보이기는 하는데요
너무 어두워서... >_<


위의 소스를 좀더 개량해 봅니다.
float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float4 eyePosition;
float time;
float2 textureScale = float2(25, 26);
float waveFreq = 0.028;
float waveAmp = 1.8;
texture texture0;
texture texture1;
 
/******************************************************************************/
sampler2D texSampler : TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};
/******************************************************************************/
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
     
    float2 bumpCoord0 : TEXCOORD3;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
/******************************************************************************/
void main_vs(in a2v IN, out v2f OUT)
{
    #define NWAVES 2
    Wave wave[NWAVES] = {
        { 1.0, 1.0, 0.5, float2(-1, 0) },
        { 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
    };
    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;
    wave[1].freq = waveFreq * 3.0;
    wave[1].amp = waveAmp * 0.33;
    float4 P = IN.Position;
   
    float angle;
    for(int i = 0; i<NWAVES; ++i)
    {
        angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
        P.y += wave[i].amp * sin( angle );
    }
    OUT.Position = mul(P, WorldViewProj);
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale;
}
/******************************************************************************/
uniform sampler2D NormalMap;
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
 
    float3 N = normalize(t0.xyz);
    float3x3 m; // tangent to world matrix
    m[0] = float3(1, 0, 0);
    m[1] = float3(0, 0, 1);
    m[2] = float3(0, 1, 0);
   
    N = normalize( mul( N, m ) );
   
    float amplitude = saturate(dot(N, float3(0, 1, 0)));
   
    OUT.color = float4(0, 0, amplitude, 1);
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}


음... 뭔가 더 미묘하게 움직이는 느낌이 드는군요.. ㅋㅋ

float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float4 eyePosition;
float time;
float2 textureScale = float2(25, 26);
float waveFreq = 0.028;
float waveAmp = 1.8;
float BumpScale = 1;
texture texture0;
texture texture1;
 
/******************************************************************************/
sampler2D texSampler : TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};
/******************************************************************************/
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
   
// tangent to obj space transform
    float3 rotMatrix1 : TEXCOORD0; // first row of the 3x3 transform
    float3 rotMatrix2 : TEXCOORD1; // second row of the 3x3 transform
    float3 rotMatrix3 : TEXCOORD2; // third row of the 3x3 transform
    float2 bumpCoord0 : TEXCOORD3;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
/******************************************************************************/
void main_vs(in a2v IN, out v2f OUT)
{
    #define NWAVES 2
    Wave wave[NWAVES] = {
        { 1.0, 1.0, 0.5, float2(-1, 0) },
        { 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
    };
    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;
    wave[1].freq = waveFreq * 3.0;
    wave[1].amp = waveAmp * 0.33;
    float4 P = IN.Position;
   
     // sum waves
    float ddx = 0.0, ddy = 0.0;
    float deriv;
    float angle;
   
    for(int i = 0; i<NWAVES; ++i)
    {
        angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
        P.y += wave[i].amp * sin( angle );
        deriv = wave[i].freq * wave[i].amp * cos(angle);
        ddx -= deriv * wave[i].dir.x;
        ddy -= deriv * wave[i].dir.y;
    }
   
    // compute the 3x3 tranform from tangent space to object space
    // first rows are the tangent and binormal scaled by the bump scale
    OUT.rotMatrix1.xyz = BumpScale * normalize(float3(1, ddy, 0)); // Binormal
    OUT.rotMatrix2.xyz = BumpScale * normalize(float3(0, ddx, 1)); // Tangent
    OUT.rotMatrix3.xyz = normalize(float3(ddx, 1, ddy)); // Normal
    OUT.Position = mul(P, WorldViewProj);
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale;
}
/******************************************************************************/
uniform sampler2D NormalMap;
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
 
    float3 N = normalize(t0.xyz);
    float3x3 m; // tangent to world matrix
    m[0] = float3(1, 0, 0);
    m[1] = float3(0, 0, 1);
    m[2] = float3(0, 1, 0);
   
    N = normalize( mul( N, m ) );
   
    float amplitude = saturate(dot(N, float3(0, 1, 0)));
   
    OUT.color = float4(0, 0, amplitude, 1);
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}


노멀 맵핑을 교정한 소스의 결과 입니다.....
이렇게 봐도... 음.... 역시 그냥 검은 평면에 뭔가 파란 점이 떠다니는 정도로 밖에 안보이네요..


여기에 주변광을 넣을 준비 하는 소스입니다.
float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float time;
float2 textureScale = float2(25, 26);
float waveFreq = 0.028;
float waveAmp = 1.8;
float BumpScale = 1;
float4 eyePosition;
float4 deepColor = float4(0, 0.3, 0.5, 1.0);
float4 shallowColor = float4(0, 1, 1, 1.0);
float waterAmount = 0.3;
texture texture0;
texture texture1;
 
/******************************************************************************/
sampler2D NormalMap: TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};
/******************************************************************************/
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
   
// tangent to obj space transform
    float3 rotMatrix1 : TEXCOORD0; // first row of the 3x3 transform
    float3 rotMatrix2 : TEXCOORD1; // second row of the 3x3 transform
    float3 rotMatrix3 : TEXCOORD2; // third row of the 3x3 transform
    float2 bumpCoord0 : TEXCOORD3;
    float2 bumpCoord1 : TEXCOORD4;
    float2 bumpCoord2 : TEXCOORD5;
 
   float3 eyeVector : TEXCOORD7;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
/******************************************************************************/
void main_vs(in a2v IN, out v2f OUT)
{
    #define NWAVES 2
    Wave wave[NWAVES] = {
        { 1.0, 1.0, 0.5, float2(-1, 0) },
        { 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
    };
    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;
    wave[1].freq = waveFreq * 3.0;
    wave[1].amp = waveAmp * 0.33;
    float4 P = IN.Position;
   
     // sum waves
    float ddx = 0.0, ddy = 0.0;
    float deriv;
    float angle;
   
    for(int i = 0; i<NWAVES; ++i)
    {
        angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
        P.y += wave[i].amp * sin( angle );
        deriv = wave[i].freq * wave[i].amp * cos(angle);
        ddx -= deriv * wave[i].dir.x;
        ddy -= deriv * wave[i].dir.y;
    }
   
    // compute the 3x3 tranform from tangent space to object space
    // first rows are the tangent and binormal scaled by the bump scale
    OUT.rotMatrix1.xyz = BumpScale * normalize(float3(1, ddy, 0)); // Binormal
    OUT.rotMatrix2.xyz = BumpScale * normalize(float3(0, ddx, 1)); // Tangent
    OUT.rotMatrix3.xyz = normalize(float3(ddx, 1, ddy)); // Normal
    OUT.Position = mul(P, WorldViewProj);
   
    // calculate texture coordinates for normal map lookup
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale;
    OUT.bumpCoord1.xy = IN.TexCoord * textureScale * 2.0;
    OUT.bumpCoord2.xy = IN.TexCoord * textureScale * 4.0;
 
    OUT.eyeVector = P.xyz - eyePosition; // eye position in vertex space
}
/******************************************************************************/
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
    float4 t1 = tex2D(NormalMap, IN.bumpCoord1) * 2.0 - 1.0;
    float4 t2 = tex2D(NormalMap, IN.bumpCoord2) * 2.0 - 1.0;
    float3 N = t0.xyz + t1.xyz + t2.xyz;
   
    float3x3 m; // tangent to world matrix
    m[0] = IN.rotMatrix1;
    m[1] = IN.rotMatrix2;
    m[2] = IN.rotMatrix3;
   
    N = normalize( mul( m, N ) );
   
    float3 E = normalize(IN.eyeVector);
   
    float facing = 1.0 - max(dot(-E, N), 0);
    float4 waterColor = lerp(shallowColor, deepColor, facing) * waterAmount;
   
    OUT.color = waterColor;
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}


음... 역시 아직도 검은 평면.. orz
포기하지 않고 소스를 좀더 수정해 봅니다.

float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float time;
float2 textureScale = float2(25, 26);
float waveFreq = 0.028;
float waveAmp = 1.8;
float BumpScale = 1;
float2 bumpSpeed = float2(0.015, 0.005);
float4 eyePosition;
float4 deepColor = float4(0, 0.3, 0.5, 1.0);
float4 shallowColor = float4(0, 1, 1, 1.0);
float waterAmount = 0.3;
texture texture0;
texture texture1;
 
/******************************************************************************/
sampler2D NormalMap: TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};
/******************************************************************************/
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
   
// tangent to obj space transform
    float3 rotMatrix1 : TEXCOORD0; // first row of the 3x3 transform
    float3 rotMatrix2 : TEXCOORD1; // second row of the 3x3 transform
    float3 rotMatrix3 : TEXCOORD2; // third row of the 3x3 transform
    float2 bumpCoord0 : TEXCOORD3;
    float2 bumpCoord1 : TEXCOORD4;
    float2 bumpCoord2 : TEXCOORD5;
    float3 eyeVector : TEXCOORD7;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
/******************************************************************************/
void main_vs(in a2v IN, out v2f OUT)
{
    #define NWAVES 2
    Wave wave[NWAVES] = {
        { 1.0, 1.0, 0.5, float2(-1, 0) },
        { 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
    };
    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;
    wave[1].freq = waveFreq * 3.0;
    wave[1].amp = waveAmp * 0.33;
    float4 P = IN.Position;
   
     // sum waves
    float ddx = 0.0, ddy = 0.0;
    float deriv;
    float angle;
   
    for(int i = 0; i<NWAVES; ++i)
    {
        angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
        P.y += wave[i].amp * sin( angle );
        deriv = wave[i].freq * wave[i].amp * cos(angle);
        ddx -= deriv * wave[i].dir.x;
        ddy -= deriv * wave[i].dir.y;
    }
   
    // compute the 3x3 tranform from tangent space to object space
    // first rows are the tangent and binormal scaled by the bump scale
    OUT.rotMatrix1.xyz = BumpScale * normalize(float3(1, ddy, 0)); // Binormal
    OUT.rotMatrix2.xyz = BumpScale * normalize(float3(0, ddx, 1)); // Tangent
    OUT.rotMatrix3.xyz = normalize(float3(ddx, 1, ddy)); // Normal
    OUT.Position = mul(P, WorldViewProj);
   
    // calculate texture coordinates for normal map lookup
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale + time * bumpSpeed;
    OUT.bumpCoord1.xy = IN.TexCoord * textureScale * 2.0 + time * bumpSpeed * 4.0;
    OUT.bumpCoord2.xy = IN.TexCoord * textureScale * 4.0 + time * bumpSpeed * 8.0;
 
    OUT.eyeVector = P.xyz - eyePosition; // eye position in vertex space
}
/******************************************************************************/
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
    float4 t1 = tex2D(NormalMap, IN.bumpCoord1) * 2.0 - 1.0;
    float4 t2 = tex2D(NormalMap, IN.bumpCoord2) * 2.0 - 1.0;
    float3 N = t0.xyz + t1.xyz + t2.xyz;
   
    float3x3 m; // tangent to world matrix
    m[0] = IN.rotMatrix1;
    m[1] = IN.rotMatrix2;
    m[2] = IN.rotMatrix3;
   
    N = normalize( mul( N, m ) );
   
    float3 E = normalize(IN.eyeVector);
   
    float facing = 1.0 - max(dot(-E, N), 0);
    float4 waterColor = lerp(shallowColor, deepColor, facing) * waterAmount;
   
    OUT.color = waterColor;
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}




여기까지 하니까 이제 뭔가 보이기 시작하네요.
평면이 꿈툴거리는것도 뭔가 그럴듯 합니다.

이제 여기에 SkyCube, 하늘 Texture 를 씌여 줍니다.
오우거 소스의 이 소스는 원래 기반이 SkyCube 이므로 SkyCube 로 텍스쳐를 불러오는게
좀더 자연스러운 수면효과를 만들 수 있습니다.

float4x4 WorldViewProj : WORLDVIEWPROJ; //our world view projection matrix
float time;
float2 textureScale = float2(25, 26);
float waveFreq = 0.028;
float waveAmp = 1.8;
float BumpScale = 0.2;
float2 bumpSpeed = float2(0.015, 0.005);
float4 eyePosition;
float4 deepColor = float4(0, 0.3, 0.5, 1.0);
float4 shallowColor = float4(0, 1, 1, 1.0);
float waterAmount = 0.3;
float4 reflectionColor = float4(0.95, 1, 1, 1.0);
float reflectionAmount = 1.0;
float reflectionBlur = 0.0;
    
float fresnelPower = 5.0;
float fresnelBias = 0.328;
float hdrMultiplier = 0.471;

texture texture0;
texture texture1;
 
/******************************************************************************/
sampler2D NormalMap: TEXUNIT0 = sampler_state
{
 Texture   = (texture0);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
sampler2D EnvironmentMap: TEXUNIT0 = sampler_state
{
 Texture   = (texture1);
    MIPFILTER = LINEAR;
    MAGFILTER = LINEAR;
    MINFILTER = LINEAR;
};
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};
/******************************************************************************/
//application to vertex structure
struct a2v {
    float4 Position : POSITION;   // in object space
    float2 TexCoord : TEXCOORD0;
};
//vertex to pixel shader structure
struct v2f {
    float4 Position  : POSITION;  // in clip space
   
// tangent to obj space transform
    float3 rotMatrix1 : TEXCOORD0; // first row of the 3x3 transform
    float3 rotMatrix2 : TEXCOORD1; // second row of the 3x3 transform
    float3 rotMatrix3 : TEXCOORD2; // third row of the 3x3 transform
    float2 bumpCoord0 : TEXCOORD3;
    float2 bumpCoord1 : TEXCOORD4;
    float2 bumpCoord2 : TEXCOORD5;
    float3 eyeVector : TEXCOORD7;
};
//pixel shader to screen
struct p2f
{
    float4 color    : COLOR0;
};
/******************************************************************************/
void main_vs(in a2v IN, out v2f OUT)
{
    #define NWAVES 2
    Wave wave[NWAVES] = {
        { 1.0, 1.0, 0.5, float2(-1, 0) },
        { 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
    };
    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;
    wave[1].freq = waveFreq * 3.0;
    wave[1].amp = waveAmp * 0.33;
    float4 P = IN.Position;
   
     // sum waves
    float ddx = 0.0, ddy = 0.0;
    float deriv;
    float angle;
   
    for(int i = 0; i<NWAVES; ++i)
    {
        angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
        P.y += wave[i].amp * sin( angle );
        deriv = wave[i].freq * wave[i].amp * cos(angle);
        ddx -= deriv * wave[i].dir.x;
        ddy -= deriv * wave[i].dir.y;
    }
   
    // compute the 3x3 tranform from tangent space to object space
    // first rows are the tangent and binormal scaled by the bump scale
    OUT.rotMatrix1.xyz = BumpScale * normalize(float3(1, ddy, 0)); // Binormal
    OUT.rotMatrix2.xyz = BumpScale * normalize(float3(0, ddx, 1)); // Tangent
    OUT.rotMatrix3.xyz = normalize(float3(ddx, 1, ddy)); // Normal
    OUT.Position = mul(P, WorldViewProj);
   
    // calculate texture coordinates for normal map lookup
    OUT.bumpCoord0.xy = IN.TexCoord * textureScale + time * bumpSpeed;
    OUT.bumpCoord1.xy = IN.TexCoord * textureScale * 2.0 + time * bumpSpeed * 4.0;
    OUT.bumpCoord2.xy = IN.TexCoord * textureScale * 4.0 + time * bumpSpeed * 8.0;
 
    OUT.eyeVector = P.xyz - eyePosition; // eye position in vertex space
}
/******************************************************************************/
void main_fs(in v2f IN, out p2f OUT)
{
    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
    float4 t1 = tex2D(NormalMap, IN.bumpCoord1) * 2.0 - 1.0;
    float4 t2 = tex2D(NormalMap, IN.bumpCoord2) * 2.0 - 1.0;
    float3 N = t0.xyz + t1.xyz + t2.xyz;
   
    float3x3 m; // tangent to world matrix
    m[0] = IN.rotMatrix1;
    m[1] = IN.rotMatrix2;
    m[2] = IN.rotMatrix3;
   
    N = normalize( mul( N, m ) );
   
    // reflection
    float3 E = normalize(IN.eyeVector);
    float4 R;
    R.xyz = reflect(E, N);
  
    // Ogre conversion for cube map lookup
    R.z = -R.z;
    R.w = reflectionBlur;
    float4 reflection = tex2Dbias(EnvironmentMap, R);
    // cheap hdr effect
    reflection.rgb *= (reflection.r + reflection.g + reflection.b) * hdrMultiplier;
    // fresnel
    float facing = 1.0 - max(dot(-E, N), 0);
    float fresnel = saturate(fresnelBias + pow(facing, fresnelPower));
    float4 waterColor = lerp(shallowColor, deepColor, facing) * waterAmount;
    reflection = lerp(waterColor,  reflection * reflectionColor, fresnel) * reflectionAmount;
 
    OUT.color = waterColor + reflection;
}
technique water
{
    pass p0
    {
        vertexshader = compile vs_1_1 main_vs();
        pixelshader = compile ps_2_0 main_fs();
    }
}



음.... 꽤 그럴듯한 효과가 나왔습니다.

이것만으론 뭐가 뭔지 역시 모르겠습니다 하실 분도 계실꺼 같아서
소스도 같이 올립니다.






저작자 표시 비영리 변경 금지
신고
블로그 이미지

프로그래머 지향자 RosaGigantea

바쁜 일상 생활중의 기억 장소


맵툴.. 오우거 엔진으로 변환

맵만 만들고 이 프로젝트는 포기
바로 온라인 서버 가지고 노는걸로 가기
2D 온라인겜으로 가는게 취업상 유리할듯..

vc 2008 작업
완료 된것 : 수면 효과 80%...
                눈 파티클
                간단한 지형 및 MFC 인터페이스



저작자 표시 비영리 변경 금지
신고
블로그 이미지

프로그래머 지향자 RosaGigantea

바쁜 일상 생활중의 기억 장소


맵툴 작업현황

그냥.. 비 효과를 포기했습니다.

음... 생각해 보니 갖고 있는 예제가... 무지개 생성 예제이고...
비도 DX10 이 아닌 이상 원하는 결과 갖기 힘들꺼 같고..

그냥 눈 파티클 생성해서 저 동그란 눈송이 그림만 나중에 바꿔서 좀 수정하면 비가 될꺼 같아서....

@_@

음... 그런겁니다.. orz
저작자 표시 비영리 변경 금지
신고
블로그 이미지

프로그래머 지향자 RosaGigantea

바쁜 일상 생활중의 기억 장소

현재 작업줄인 툴작업에서
당연히 되겠지라고 방치하다가 뒷통수 맞은 문제점 입니다.


음.. 그러니까.. 원래 안개 설정할때 CColorDlg 란 공용 컨트롤을 사용해서 DoModal 을 할려고 했지만.. 왠지 모르게 위 그림처럼 창이 안뜨더군요....

이것저것 찾아보다가..


풀화면에서 Dialog띠우기 팁 입니다. (DX9.0) 2005/05/25
http://www.doopal.net

안녕하세요 볼따구 입니다.


풀화면에서 가끔 Dialog를 뛰어야 하는 경우가 생깁니다.
9.0 이상 버젼에서는 DX차원에서 지원을 합니다.

하지만, 몇가지 제안이 있기 때문에 실제로 적용시키는걸 잘 모르는분들이 있어서
한번 올려봅니다. ;;;

D3D디바이스를 생성할때
D3DPRESENT_PARAMETERS 인자중에 몇가지를 셋팅을 해야 합니다.
[1] SwapEffect = D3DSWAPEFFECT_DISCARD;
[2] BackBufferFormat = D3DFMT_X8R8G8B8; 또는 D3DFMT_X1R5G5B5, D3DFMT_R5G6B5
[3] Flags        |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;

위에 옵션을 셋팅해서 디바이스를 생성한후에
D3DDevice->SetDialogBoxMode( TRUE );  이렇게 디바이스에 DialogBox를 사용한다고 해 놓으면
풀화면에서도 잘나오는걸 확인할수가 있을겁니다.

즐프~
(출처 : http://proline1.cafe24.com/zeroboard/view.php?id=data&no=49)

라고 SetDialogBoxMode를 true로 하라길래 수정 했지만 역시 변한게 없었습니다.

그러다가....
정말 우연히...
alt 키를 눌렀는데 떠지더군요.   orz

대략 창을 띄울때 DirectX 렌더링으로 순위가 뒤로 밀린건지...
잘 알 수는 없지만.. 원인을 알았으니 고치는건 쉽죠

CColorDialog dlg(CC_FULLOPEN);
PostMessage(WM_SYSKEYDOWN, VK_LMENU, 0);
dlg.DoModal();
 
DoModal 직전에 강제로 Alt 키를 눌러서 포커스가 메뉴로 가게 했습니다..
그러니..

제대로 나왔습니다.....

About 상자도 이렇게 처리하니 잘 뜨는군요.

// App command to run the dialog
void CMapTool_3DApp::OnAppAbout()
{
 CAboutDlg aboutDlg;
 PostMessage(NULL, WM_SYSKEYDOWN, VK_LMENU, 0);
 aboutDlg.DoModal();
}

그리고.. FileDlg 공용박스는... 왠지 저거 안해도 제대로 나오더군요..
MFC 버그인가....

하지만 일단 안전을 위해 PostMessage 를 해두는것도 나쁘진 않을꺼 같네요.
저작자 표시 비영리 변경 금지
신고
블로그 이미지

프로그래머 지향자 RosaGigantea

바쁜 일상 생활중의 기억 장소

티스토리 툴바