绘制地形出错，出现一层层的块片状东西

限之极

我绘制了一张地形，用的是去随便找的一个raw文件，但是用phong模型渲染出来后，地形的有些地方就好象是断层了一样，一片片的，又好象是有重绘一样，不知道是怎么会事，在绘制地形的时候，如果用PHONG模型，那么shader中要用高光吗，

请问这个问题有谁见过吗，很急，谢谢了！~


以下是我的截图和shader的代码，请大家指正，谢谢了

//================================
//Global   variebles;
//===============================
float4x4                           matWorld;
float4x4                           matWorldViewProj;

float3                             LightPos;
float3                             EyePos;

float3                             LightAttenuation  =  float3(1, 1, 1);
float4                             LightColor        =  float4(1, 1, 1, 1);

texture                            TexMap1;
texture                            TexMap2;



struct  VS_OUTPUT
{
    float4      Pos         :  POSITION;
    float3      Normal      :  TEXCOORD0;
    float2      Tex1        :  TEXCOORD1;
    float2      Tex2        :  TEXCOORD2;
    float4      LightDir    :  TEXCOORD3;
    float3      EyeDir      :  TEXCOORD4;
};

VS_OUTPUT    main_vs(float3  inPos       :  POSITION,
                     float3  inNormal    :  NORMAL,
                     float2  inTex1      :  TEXCOORD0,
                     float2  inTex2      :  TEXCOORD1
                     )
{
    VS_OUTPUT      vsOut      =    (VS_OUTPUT)0;
   
    vsOut.Pos                 =     mul(float4(inPos, 1), matWorldViewProj);
    vsOut.Normal              =     normalize(mul(float4(inNormal, 1), matWorld));
    vsOut.Tex1                =     inTex1;
    vsOut.Tex2                =     inTex2;
    vsOut.LightDir.xyz        =     LightPos  -  mul(float4(inPos, 1), matWorld);
   
    float    Dist             =     length(vsOut.LightDir.xyz);
    vsOut.LightDir.xyz       /=     Dist;

    vsOut.LightDir.w          =     saturate(1 / (LightAttenuation.x + LightAttenuation.y * Dist + LightAttenuation.z * Dist * Dist));


    vsOut.EyeDir              =     mul(float4(inPos, 1), matWorld)  -  EyePos;
   
    return      vsOut;
}
////////////////////////////////////
//our pixel shader
////////////////////////////////////

//==texture  filter
sampler  TexSampler1  =  sampler_state
{
    Texture        =  <TexMap1>;
    MipFilter      =  LINEAR;
    MinFilter      =  LINEAR;
    MagFilter      =  LINEAR;
};

sampler  TexSampler2  =  sampler_state
{
    Texture        =  <TexMap2>;
    MipFilter      =  LINEAR;
    MinFilter      =  LINEAR;
    MagFilter      =  LINEAR;
};




float4      main_ps(float3  inNormal       :  TEXCOORD0,
                    float2  inTex1         :  TEXCOORD1,
                    float2  inTex2         :  TEXCOORD2,
                    float4  inLightDir     :  TEXCOORD3,
                    float3  inEyeDir       :  TEXCOORD4
                    )  : COLOR
{
    float4           TexColor1    =    tex2D(TexSampler1, inTex1);
    float4           TexColor2    =    tex2D(TexSampler2, inTex2);



    //=============
    //Ambient
    float4           Color        =    float4(1, 1, 0.5, 1);

    //================
    //Diffuse

    float            Diff         =  saturate(dot(inNormal, inLightDir.xyz));
    Color      +=    LightColor * Diff * inLightDir.w;
    //=================
    //Specular
    Diff                   =  pow(saturate(dot(inLightDir.xyz, inEyeDir)), 4);
    Color      +=    LightColor * Diff * inLightDir.w;

    Color       =    Color * TexColor1 * TexColor2 * 0.8f;

    return  Color;
}

technique Phong
{
    pass p0
    {
        VertexShader = compile vs_2_0 main_vs();
        PixelShader = compile ps_2_0 main_ps();
    }  
}

限之极

有人遇见过吗 ，谢谢

clayman

check if you closed z buffer

限之极

没有啊，程序中就没有涉及到z buffer啊    会不会是顶点计算错误什么的 下面是 计算顶点和索引的代码，我看了好几遍，也应该没有错啊

bool    CTerrain::ComputeVertex()
{
        HRESULT        hr  =  0;
        hr    =    m_pDevice->CreateVertexBuffer(
                m_numVertices * sizeof(TerrainVertex),
                D3DUSAGE_WRITEONLY,
                0,
                D3DPOOL_MANAGED,
                &m_pVertexBuf,
                0);

        if(FAILED(hr))
        {
                return  false;
        }

        int  startX  =  -m_width / 2;
        int  startZ  =  m_depth / 2;

        int  endX    =  m_width / 2;
        int  endZ    =  -m_depth / 2;

        //==compute  vertex  texture  coordinate
        float  uCoordIncementSize  =  1.0f / (float)m_numCellPerRow;
        float  vCoordIncementSize  =  1.0f / (float)m_numCellPerCol;

        TerrainVertex  *vb  =  0;
        m_pVertexBuf->Lock(0, 0, (void**)&vb, 0);

        int    i  =  0;
        for(int z = startZ; z > endZ; z -= m_cellSpacing)
        {
                int    j  =  0;
                for(int x = startX; x < endX; x += m_cellSpacing)
                {
                        int    index  =  i * m_numCellPerRow + j;

                        D3DXVECTOR3    normal  =  ComputeNormal(i, j);

                        vb[index]  =  TerrainVertex(
                                (float)x,
                                (float)m_heightMap[index],
                                (float)z,
                                normal,
                                uCoordIncementSize * j,
                                vCoordIncementSize * i,
                                0,
                                0);

                        j++;
                }
                i++;
        }

        m_pVertexBuf->Unlock();

        const D3DVERTEXELEMENT9 elements[] =
        {
                { 0, 0,  D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
                { 0, 16,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
                { 0, 28,  D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
                { 0, 36, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
                D3DDECL_END()
        };

        hr = m_pDevice->CreateVertexDeclaration(elements, &m_pVerDelc);

        if(FAILED(hr))
        {
                return false;
        }

        return   true;
}

bool    CTerrain::ComputeIndex()
{
        HRESULT    hr;
        hr  =  m_pDevice->CreateIndexBuffer(
                m_numTriangles * 3 * sizeof(WORD),
                D3DUSAGE_WRITEONLY,
                D3DFMT_INDEX16,
                D3DPOOL_MANAGED,
                &m_pIndexBuf,
                0);

        if(FAILED(hr))
        {
                return  false;
        }

        WORD  *ib  =  0;
        m_pIndexBuf->Lock(0, 0, (void**)&ib, 0);

        int    index  =  0;

        for(int i = 0; i < m_numCellPerCol; i++)
        {
                for(int j = 0; j < m_numCellPerRow; j++)
                {
                        ib[index]        =        i * m_numCellPerRow + j;
                        ib[index + 1]    =        i * m_numCellPerRow + j + 1;
                        ib[index + 2]    =  (i + 1) * m_numCellPerRow + j;

                        ib[index + 3]    =  (i + 1) * m_numCellPerRow + j;
                        ib[index + 4]    =        i * m_numCellPerRow + j + 1;
                        ib[index + 5]    =  (i + 1) * m_numCellPerRow + j + 1;

                        //next quad
                        index += 6;
                }
        }
   
        m_pIndexBuf->Unlock();

        return  true;
}

小小C

索引顺序

artint

没细看代码，只看了一下图。以前我也遇到过这种情况，后来发现是顶点有问题。是索引指向了一些超出了顶点范围的顶点。

限之极

哦，我看了好几次了顶点和索引了，其他的应该没有问题吧，尤其是我的shader

oz01

我以前也遇到过非常近似的问题
原因也在定点索引

限之极

这个是我的计算顶点和索引的代码
麻烦大家帮我看看 有没有什么不妥的  谢谢了
bool    CTerrain::ComputeVertex()
{
        HRESULT        hr  =  0;
        hr    =    m_pDevice->CreateVertexBuffer(
                m_numVertices * sizeof(TerrainVertex),
                D3DUSAGE_WRITEONLY,
                0,
                D3DPOOL_MANAGED,
                &m_pVertexBuf,
                0);

        if(FAILED(hr))
        {
                return  false;
        }

        int  startX  =  -m_width / 2;
        int  startZ  =  m_depth / 2;

        int  endX    =  m_width / 2;
        int  endZ    =  -m_depth / 2;

        //==compute  vertex  texture  coordinate
        float  uCoordIncementSize  =  1.0f / (float)m_numCellPerRow;
        float  vCoordIncementSize  =  1.0f / (float)m_numCellPerCol;

        TerrainVertex  *vb  =  0;
        m_pVertexBuf->Lock(0, 0, (void**)&vb, 0);

        int    i  =  0;
        for(int z = startZ; z > endZ; z -= m_cellSpacing)
        {
                int    j  =  0;
                for(int x = startX; x < endX; x += m_cellSpacing)
                {
                        int    index  =  i * m_numCellPerRow + j;

                        D3DXVECTOR3    normal  =  ComputeNormal(j, i);

                        vb[index]  =  TerrainVertex(
                                (float)x,
                                (float)m_heightMap[index],
                                (float)z,
                                normal,
                                uCoordIncementSize * j,
                                vCoordIncementSize * i,
                                0,
                                0);

                        j++;
                }
                i++;
        }

        m_pVertexBuf->Unlock();

        const D3DVERTEXELEMENT9 elements[] =
        {
                { 0, 0,  D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
                { 0, 16,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
                { 0, 28,  D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
                { 0, 36, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
                D3DDECL_END()
        };

        hr = m_pDevice->CreateVertexDeclaration(elements, &m_pVerDelc);

        if(FAILED(hr))
        {
                return false;
        }

        return   true;
}

bool    CTerrain::ComputeIndex()
{
        HRESULT    hr;
        hr  =  m_pDevice->CreateIndexBuffer(
                m_numTriangles * 3 * sizeof(WORD),
                D3DUSAGE_WRITEONLY,
                D3DFMT_INDEX16,
                D3DPOOL_MANAGED,
                &m_pIndexBuf,
                0);

        if(FAILED(hr))
        {
                return  false;
        }

        WORD  *ib  =  0;
        m_pIndexBuf->Lock(0, 0, (void**)&ib, 0);

        int    index  =  0;

        for(int i = 0; i < m_numCellPerRow; i++)
        {
                for(int j = 0; j < m_numCellPerCol; j++)
                {
                        ib[index]        =        i * m_numCellPerRow + j;
                        ib[index + 1]    =        i * m_numCellPerRow + j + 1;
                        ib[index + 2]    =  (i + 1) * m_numCellPerRow + j;

                        ib[index + 3]    =  (i + 1) * m_numCellPerRow + j;
                        ib[index + 4]    =        i * m_numCellPerRow + j + 1;
                        ib[index + 5]    =  (i + 1) * m_numCellPerRow + j + 1;

                        //next quad
                        index += 6;
                }
        }
   
        m_pIndexBuf->Unlock();

        return  true;
}

lj56456311

我以前也遇到过这样的情况~~不过因为我用的三角带渲染，不知道你是不是这问题，应该与shader无关的，就上顶点问题