Çözüldü OSF files gölge sorunu hk

#include "StdAfx.h"
#include "../EterLib/StateManager.h"
#include "../EterLib/Camera.h"

#include "MapOutdoor.h"

static int recreate = false;

void CMapOutdoor::SetShadowTextureSize(WORD size)
{
    if (m_wShadowMapSize != size)
    {
        recreate = true;
        Tracenf("ShadowTextureSize changed %d -> %d", m_wShadowMapSize, size);
    }

    m_wShadowMapSize = size;
}

void CMapOutdoor::CreateCharacterShadowTexture()
{
    extern bool GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW;

    if (GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW)
        return;

    ReleaseCharacterShadowTexture();

    if (IsLowTextureMemory())
        SetShadowTextureSize(128);

    m_ShadowMapViewport.X = 1;
    m_ShadowMapViewport.Y = 1;
    m_ShadowMapViewport.Width = m_wShadowMapSize - 2;
    m_ShadowMapViewport.Height = m_wShadowMapSize - 2;
    m_ShadowMapViewport.MinZ = 0.0f;
    m_ShadowMapViewport.MaxZ = 1.0f;

    if (FAILED(ms_lpd3dDevice->CreateTexture(m_wShadowMapSize, m_wShadowMapSize, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &m_lpCharacterShadowMapTexture)))
    {
        TraceError("CMapOutdoor Unable to create Character Shadow render target texture\n");
        return;
    }

    if (FAILED(m_lpCharacterShadowMapTexture->GetSurfaceLevel(0, &m_lpCharacterShadowMapRenderTargetSurface)))
    {
        TraceError("CMapOutdoor Unable to GetSurfaceLevel Character Shadow render target texture\n");
        return;
    }

    if (FAILED(ms_lpd3dDevice->CreateDepthStencilSurface(m_wShadowMapSize, m_wShadowMapSize, D3DFMT_D16, D3DMULTISAMPLE_NONE, &m_lpCharacterShadowMapDepthSurface)))
    {
        TraceError("CMapOutdoor Unable to create Character Shadow depth Surface\n");
        return;
    }
}

void CMapOutdoor::ReleaseCharacterShadowTexture()
{
    SAFE_RELEASE(m_lpCharacterShadowMapRenderTargetSurface);
    SAFE_RELEASE(m_lpCharacterShadowMapDepthSurface);
    SAFE_RELEASE(m_lpCharacterShadowMapTexture);
}

DWORD dwLightEnable = FALSE;

bool CMapOutdoor::BeginRenderCharacterShadowToTexture()
{
    D3DXMATRIX matLightView, matLightProj;

    CCamera* pCurrentCamera = CCameraManager::Instance().GetCurrentCamera();

    if (!pCurrentCamera)
        return false;

    if (recreate)
    {
        CreateCharacterShadowTexture();
        recreate = false;
    }

    D3DXVECTOR3 v3Target = pCurrentCamera->GetTarget();

    D3DXVECTOR3 v3Eye(v3Target.x - 1.732f * 1250.0f,
        v3Target.y - 1250.0f,
        v3Target.z + 2.0f * 1.732f * 1250.0f);

    const auto vv = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
    D3DXMatrixLookAtRH(&matLightView,
        &v3Eye,
        &v3Target,
        &vv);

    D3DXMatrixOrthoRH(&matLightProj, 2550.0f * SHADOW_DISTANCE_MULTIPLIER, 2550.0f * SHADOW_DISTANCE_MULTIPLIER, 1.0f, 15000.0f);

    STATEMANAGER.SaveTransform(D3DTS_VIEW, &matLightView);
    STATEMANAGER.SaveTransform(D3DTS_PROJECTION, &matLightProj);

    dwLightEnable = STATEMANAGER.GetRenderState(D3DRS_LIGHTING);
    STATEMANAGER.SetRenderState(D3DRS_LIGHTING, FALSE);

    STATEMANAGER.SaveRenderState(D3DRS_TEXTUREFACTOR, 0xFF808080);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR);
    STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
    STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);

    bool bSuccess = true;

    // Backup Device Context
    if (FAILED(ms_lpd3dDevice->GetRenderTarget(&m_lpBackupRenderTargetSurface)))
    {
        TraceError("CMapOutdoor::BeginRenderCharacterShadowToTexture : Unable to Save Window Render Target\n");
        bSuccess = false;
    }

    if (FAILED(ms_lpd3dDevice->GetDepthStencilSurface(&m_lpBackupDepthSurface)))
    {
        TraceError("CMapOutdoor::BeginRenderCharacterShadowToTexture : Unable to Save Window Depth Surface\n");
        bSuccess = false;
    }

    if (FAILED(ms_lpd3dDevice->SetRenderTarget(m_lpCharacterShadowMapRenderTargetSurface, m_lpCharacterShadowMapDepthSurface)))
    {
        TraceError("CMapOutdoor::BeginRenderCharacterShadowToTexture : Unable to Set Shadow Map Render Target\n");
        bSuccess = false;
    }

    if (FAILED(ms_lpd3dDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0xFF, 0xFF, 0xFF), 1.0f, 0)))
    {
        TraceError("CMapOutdoor::BeginRenderCharacterShadowToTexture : Unable to Clear Render Target");
        bSuccess = false;
    }

    if (FAILED(ms_lpd3dDevice->GetViewport(&m_BackupViewport)))
    {
        TraceError("CMapOutdoor::BeginRenderCharacterShadowToTexture : Unable to Save Window Viewport\n");
        bSuccess = false;
    }

    if (FAILED(ms_lpd3dDevice->SetViewport(&m_ShadowMapViewport)))
    {
        TraceError("CMapOutdoor::BeginRenderCharacterShadowToTexture : Unable to Set Shadow Map viewport\n");
        bSuccess = false;
    }

    return bSuccess;
}

void CMapOutdoor::EndRenderCharacterShadowToTexture()
{
    ms_lpd3dDevice->SetViewport(&m_BackupViewport);

    ms_lpd3dDevice->SetRenderTarget(m_lpBackupRenderTargetSurface, m_lpBackupDepthSurface);

    SAFE_RELEASE(m_lpBackupRenderTargetSurface);
    SAFE_RELEASE(m_lpBackupDepthSurface);

    STATEMANAGER.RestoreTransform(D3DTS_VIEW);
    STATEMANAGER.RestoreTransform(D3DTS_PROJECTION);

    // Restore Device Context
    STATEMANAGER.SetRenderState(D3DRS_LIGHTING, dwLightEnable);
    STATEMANAGER.RestoreRenderState(D3DRS_TEXTUREFACTOR);
}

CSpeedTreeForestDirectX8::Instance().UpdateCompundMatrix(v3Eye, matLightView, matLightProj);

#define WRAPPER_USE_GPU_LEAF_PLACEMENT // bunu kapatıp

#define WRAPPER_USE_CPU_LEAF_PLACEMENT // bunu açtığım zaman sorun kalkıyor yağrak yoğunluğu azalıyor

kod ekleme ile define değiştirme arasındaki fark nedir tam olarak

void CSpeedTreeForestDirectX9::UpdateCompundMatrix(const D3DXVECTOR3 & c_rEyeVec, const D3DXMATRIX & c_rmatView, const D3DXMATRIX & c_rmatProj)
{
    // setup composite matrix for shader
    D3DXMATRIX matBlend;
    D3DXMatrixIdentity(&matBlend);

    D3DXMATRIX matBlendShader;
    D3DXMatrixMultiply(&matBlendShader, &c_rmatView, &c_rmatProj);

    float afDirection[3];
    afDirection[0] = matBlendShader.m[0][2];
    afDirection[1] = matBlendShader.m[1][2];
    afDirection[2] = matBlendShader.m[2][2];
    CSpeedTreeRT::SetCamera(c_rEyeVec, afDirection);

    D3DXMatrixTranspose(&matBlendShader, &matBlendShader);
    STATEMANAGER.SetVertexShaderConstant(c_nVertexShader_CompoundMatrix, &matBlendShader, 4);
}

void CSpeedTreeForestDirectX9::UpdateCompundMatrix(const D3DXVECTOR3 & c_rEyeVec, const D3DXMATRIX & c_rmatView, const D3DXMATRIX & c_rmatProj)
{
    ...

    float afDirection[3];
    afDirection[0] = c_rmatView.m[2][0];
    afDirection[1] = c_rmatView.m[2][1];
    afDirection[2] = c_rmatView.m[2][2];
    
    CSpeedTreeRT::SetCamera(c_rEyeVec, afDirection);

    ...