[Решено] Перенос данных из одного буфера вершин в другой.

//--------------------------------------------------------------------------------------
// This shader computes standard transform and lighting
//--------------------------------------------------------------------------------------
VS_OUTPUT RenderSceneVS( float4 inPositionOS  : POSITION, 
                         float2 inTexCoord    : TEXCOORD0,
                         float2 vInViewWS    : TEXCOORD2,//////////////
                         float3 vInNormalOS   : NORMAL,
                         float3 vInBinormalOS : BINORMAL,
                         float3 vInTangentOS  : TANGENT )
{
    VS_OUTPUT Out;
        
    // Transform and output input position 
    Out.position = mul( inPositionOS, g_mWorldViewProjection );
       
    // Propagate texture coordinate through:
    Out.texCoord = inTexCoord * g_fBaseTextureRepeat;

    // Transform the normal, tangent and binormal vectors from object space to homogeneous projection space:
    float3 vNormalWS   = mul( vInNormalOS,   (float3x3) g_mWorld );
    float3 vTangentWS  = mul( vInTangentOS,  (float3x3) g_mWorld );
    float3 vBinormalWS = mul( vInBinormalOS, (float3x3) g_mWorld );
    
    // Propagate the world space vertex normal through:   
    Out.vNormalWS = vNormalWS;
    
    vNormalWS   = normalize( vNormalWS );
    vTangentWS  = normalize( vTangentWS );
    vBinormalWS = normalize( vBinormalWS );
    
    // Compute position in world space:
    float4 vPositionWS = mul( inPositionOS, g_mWorld );
                 
    // Compute and output the world view vector (unnormalized):
    float3 vViewWS = g_vEye - vPositionWS;
    Out.vViewWS = vViewWS;

    // Compute denormalized light vector in world space:
    float3 vLightWS = g_LightDir;
       
    // Normalize the light and view vectors and transform it to the tangent space:
    float3x3 mWorldToTangent = float3x3( vTangentWS, vBinormalWS, vNormalWS );
       
    // Propagate the view and the light vectors (in tangent space):
    Out.vLightTS = mul( vLightWS, (float3x3) g_mWorld );  //mul( vLightWS, mWorldToTangent )
    Out.vViewTS  = mul( (float3x3) g_mView, vViewWS );    //mul( mWorldToTangent, vViewWS );
       
    // Compute the ray direction for intersecting the height field profile with 
    // current view ray. See the above paper for derivation of this computation.
         
    // Compute initial parallax displacement direction:
    float2 vParallaxDirection = normalize(  Out.vViewTS.xy );
       
    // The length of this vector determines the furthest amount of displacement:
    float fLength         = length( Out.vViewTS );
    float fParallaxLength = sqrt( fLength * fLength - Out.vViewTS.z * Out.vViewTS.z ) / Out.vViewTS.z; 
       
    // Compute the actual reverse parallax displacement vector:
    Out.vParallaxOffsetTS = vParallaxDirection * fParallaxLength;
       
    // Need to scale the amount of displacement to account for different height ranges
    // in height maps. This is controlled by an artist-editable parameter:
    Out.vParallaxOffsetTS *= g_fHeightMapScale;

   return Out;
}

pd3dDevice->GetTransform(D3DTS_WORLD, &world);
pd3dDevice->GetTransform(D3DTS_VIEW, &view);
pd3dDevice->GetTransform(D3DTS_PROJECTION, &proj);

worldViewProjectionMatrix = world * view * proj;
D3DXMatrixInverse(&invWorldViewProjectionMatrix, 0, &worldViewProjectionMatrix);
g_pEffect->SetMatrix("g_mWorldViewProjection", &worldViewProjectionMatrix);
g_pEffect->SetMatrix("g_mInvWorldViewProjection", &invWorldViewProjectionMatrix);
g_pEffect->SetMatrix("g_mWorld", &world);
g_pEffect->SetMatrix("g_mView", &view);

g_cameraEye.x = -view._41;
g_cameraEye.y = -view._42;
g_cameraEye.z = -view._43;
D3DXMatrixTranspose(&view, &view);
D3DXVec3TransformNormal(&g_cameraEye, &g_cameraEye, &view);
g_cameraLookAt.x = view._31;
g_cameraLookAt.y = view._32;
g_cameraLookAt.z = view._33;

g_pEffect->SetValue("g_vEye", &g_cameraEye, sizeof(g_cameraEye));
g_pEffect->SetFloat("g_fHeightMapScale", 0.1f);

g_pEffect->SetValue("g_LightDir", &g_light.dir, sizeof(g_light.dir));//g_light.dir
g_pEffect->SetValue("g_LightDiffuse", g_light.diffuse, sizeof(g_light.diffuse));

g_pEffect->SetValue("g_materialAmbientColor", g_material.ambient, sizeof(g_material.ambient));
g_pEffect->SetValue("g_materialDiffuseColor", g_material.diffuse, sizeof(g_material.diffuse));
g_pEffect->SetValue("g_materialSpecularColor", g_material.specular, sizeof(g_material.specular));

g_pEffect->SetFloat("g_fSpecularExponent", 100.0f); //g_material.shininess
g_pEffect->SetFloat("g_fBaseTextureRepeat", 1.0f);
g_pEffect->SetInt("g_nLODThreshold", 3);
g_pEffect->SetInt("g_nMinSamples", 8);
g_pEffect->SetInt("g_nMaxSamples", 50);
g_pEffect->SetFloat("g_fShadowSoftening", 0.58f);

g_pEffect->SetBool("g_bVisualizeLOD", false);
g_pEffect->SetBool("g_bVisualizeMipLevel", false);
g_pEffect->SetBool("g_bDisplayShadows", true);
g_pEffect->SetBool("g_bAddSpecular", true);

//g_pEffect->SetValue("g_ambientColor", ambientColor, sizeof(ambientColor));
g_pEffect->SetTexture("g_diffuseTexture", pDiffuseTexture);
g_pEffect->SetTexture("g_normalTexture", pNormalTexture);


static UINT numPasses, i = 0;

g_pEffect->SetTechnique(hTechnique);

g_pEffect->Begin(&numPasses, 0);
for (i = 0; i < numPasses; i++)
{
  g_pEffect->BeginPass(i);
  //g_pEffect->CommitChanges();
  pd3dDevice->DrawIndexedPrimitive(Type, baseVertexIndex, minIndex, NumVertices, startIndex, primCount);
  g_pEffect->EndPass();
}
g_pEffect->End();